tonus 0.7.0 → 0.9.0

package/CHANGELOG.md

@@ -2,7 +2,219 @@
 
 All notable changes to tonus. Newest first.
 
-## Unreleased
+## 0.9.0 — 2026-08-19
+
+The tracks stop promising a contract they never kept, and the geometry says
+where the ink is.
+
+### Added
+
+- **`Syllable.neumes` — the syllable's figures, each classified.** A syllable
+  is not a neume; it carries neumes. GABC marks the figures with `!`, `/` and
+  `//`, and the parser has always recorded them, but classification read the
+  whole syllable, so a melisma of three ordinary figures was named once and
+  that name was `compound`: 18,718 of the 27,643 compounds, 67.7% of them.
+  `neume` still reads the syllable as one figure and is unchanged; `neumes`
+  names them individually. Compound falls from 17.8% to **8.3%**, and the
+  torculus count more than doubles (4,521 → 10,607).
+
+  The salicus reports at syllable scope, and the exception is the point. Its
+  rule reads the oriscus on the next-to-last note of an ascent, and 41 of the
+  corpus's 255 salici are written across a figure boundary with the oriscus in
+  one figure and the summit in the next. Splitting first severed them and the
+  count fell to 251, narrowing Cardine's definition by refactoring rather than
+  by ruling. Held at 255, with 35 more recovered: figures that are a salicus in
+  their own right inside a syllable that is not one.
+
+- **Six neume names for figures that restate a pitch.** `classifyShape` had no
+  case for the unison beyond a two-note group, so every repercussive figure
+  fell to `compound`: 12,675 of them, 6.6% of the corpus. `NeumeShape` gains
+  `distropha`, `tristropha`, `tristropha flexa`, `pressus`, `pressus maior`,
+  and `scandicus subpunctis` (the mirror of `pes subpunctis`, which was the
+  only form named past three intervals). 4,154 groups that read `compound` now
+  carry a name, and `compound` falls from 17.8% to 15.9%.
+
+  The names rest on contour, which is what both emitters already read: quadrata
+  breathes strophae apart on the staff position alone, and moderna merges a
+  strophic run into one slur. `hasStrophicus` is untouched and still reports
+  the GABC marker, which is the narrower fact.
+
+  This does not reopen the salicus ruling. That one turns on an ornament the
+  printed edition may have resolved away, so reading it from the ictus would
+  invent what the source withheld; a restated pitch is a contour the source
+  states outright.
+
+  The praepunctis family is absent by choice. Measured over the corpus, the
+  long figures are genuine compound melismas (`[up,down,down,up]` 643,
+  `[up,down,down,down]` 524) rather than textbook praepunctis forms, and a name
+  matching nothing is worse than the gap.
+
+- **`NoteGeometry` reports the figure's ink extent**, as `inkLeft` and
+  `inkRight` beside the anchor. `x` is an ANCHOR, and what it anchors differs by
+  notation: quadrata's square glyphs start at it and run right, so `x` is the
+  figure's left edge and a mark drawn anchor-to-anchor sits left of the notes it
+  names and stops short of the last one; moderna centres its noteheads on it.
+  These are the numbers the in-house tracks have always consumed, now reported
+  rather than measured privately. A caller placing a playhead or an overlay no
+  longer has to read the drawn glyph back out of the SVG to find the middle of a
+  notehead.
+
+  Quadrata measures the edges from the glyph's bounding box as it places;
+  moderna derives them from the anchor, so they straddle it evenly.
+
+### Changed
+
+- **The rhythm model names a note by its own figure.** `applyCompoundBeats`
+  annotated every note of a melisma with the whole syllable's name, so the two
+  conventional overrides (salicus → arsic, doubly-dotted clivis → thetic) could
+  not see a clivis inside a syllable that read `compound`. Measured over the
+  corpus: 5 phrases of 26,803 change `rhythmicType`, and 75 notes of 400,948
+  change arsis/thesis (0.019%). Small because most newly-visible clivises carry
+  no double mora, so the thetic rule still does not fire on them.
+
+- **The docs no longer offer a downstream track contract.** `score.md` framed
+  the geometry as the interface analysis tracks build on, and said a custom
+  track downstream does the same. It could not: the tracks consume a private
+  surface (the tabula row, the lyric baseline, per-system right edges, the
+  scale factor, and band room only an emitter can reserve). The geometry is
+  documented for what it is and is used for: locating a note on the drawn page.
+  The three tracks stay in the library, and the tracks section is rewritten as
+  reference rather than prose.
+
+- **The metrics documentation stops dumping six interfaces in a row.** The
+  section ended in fifty-odd unbroken lines of TypeScript, its meaning carried
+  in trailing comments. The five composite fields are now grouped by the
+  question each answers, and the two that were enumerations wearing interfaces
+  are tables: `motus` with the semitone ranges its three names mean, and
+  `cadenceDistribution` with each divisio's GABC mark and analytic weight —
+  the bar-line hierarchy stated once, where `metrics.ts` already cites it.
+
+- **Corrected counts in the tracks documentation.** The cadence catalogue holds
+  110 families, not 122; the corpus carries about 26,800 cadences, not 20,500.
+  The `rara` share is stated both ways it can be read: about 43% of the
+  corpus's cadences, but about a third of the labels a page prints.
+
+- **A corpus measurement the library can answer for itself is checked against
+  the library.** A count written into prose is a copy, and a copy goes stale on
+  the next re-bake with nothing to catch it: the catalogue held 122 families for
+  as long as it took someone to notice it held 110, in three places at once.
+  `tests/comments.test.mjs` gains the class — the book table, the ledger totals,
+  the catalogue's size and population, the censused count, the calendar's size —
+  each failure naming the file, the stale figure and the live value. Illustrative
+  counts come out of the comments that carried them; calibration provenance
+  stays, because a figure recording what a constant was fitted against is the
+  evidence for that constant, not decoration.
+
+  Three figures were already wrong. `chant.md` gave `listings - count` as 580
+  extra rows "over the 683 chants printed in more than one book", but 683
+  multi-book chants produce 696 extra rows — two measures of different things in
+  one sentence, now stated as the rule they illustrate. `score.md` had a cadence
+  breakdown failing inclusion–exclusion, and read its 43% as the share that
+  joins the catalogue where it is the share that does not.
+
+### Fixed
+
+- **The staff was anchored an octave below the gamut.** `guido.ts` fixes Γ
+  (gamma ut) at midi 43 and runs two octaves up from it, so within tonus the
+  gamut is an absolute frame. The GABC parser anchored the staff an octave under
+  it: a c4 chant opened on E2 at 82.5 Hz, and most of the corpus read at or
+  below the floor of the medieval system. Measured over 400 chants, 346 sat
+  below Γ; none do now. *Ab occultis meis* spans midi 52–65, opening on E3 and
+  landing on Elami, Fefaut, Gesolreut.
+
+  Nothing caught it because the tabula was self-consistent — `spn`, `hz` and
+  `octave` all derive from `midi`, so they reported a wrong number faithfully.
+  It showed on the Guidonian hand, where a joint is a fixed place: orreliquum
+  had grown a per-chant octave lift to haul chants back onto the figure, itself
+  replacing an earlier manual control. Two compensations for one constant. A
+  downstream consumer carrying such a lift should now remove it.
+
+  **This moves output data**: every `midi`, `hz`, `spn` and `octave` in the
+  tabula shifts by twelve semitones. The census is unaffected — its pitch fields
+  are final-relative, and `blocks.bin` rebuilds bit-identical.
+
+- **`NoteGeometry.noteIndex` addressed the wrong note.** Both emitters filled
+  it from the row's `neumeIndex` (position within the neume FIGURE) where
+  `ChantTabulaRow.noteIndex` and `Cadence.notes[*][2]` mean position within the
+  SYLLABLE. The documented tuple join therefore misaddressed every syllable
+  carrying a second figure: 17 of 159 notes on *Puer natus est*. `noteIndex`
+  now carries the syllable position the tabula means, and `neumeIndex` is
+  reported alongside it, so the three address one note. A consumer joining by
+  array index (the safe join) is unaffected.
+
+- **A wrapped cadence closed twice.** A cadence figure crossing a system break
+  is re-inked in both, because the claim spans them, but it CLOSES once. Drawn
+  per system, the terminal node landed on the earlier fragment's last sample (a
+  landing mid-figure) and the label repeated: at width 680 that subject drew 7
+  nodes under quadrata and 8 under moderna for 6 confident cadences. The node
+  and label now draw only in the system holding the figure's last note.
+
+- **The tonarium's mode line admitted claims the rest of the renderer
+  refuses.** It gated modulations at confidence 0.4 where the documented floor,
+  the cadence path, and the ink doctrine all say nothing below 0.45 draws.
+
+- **A flat was drawn on the line of the note it was written before, not the
+  line of the note it alters.** Solesmes prints an accidental on the line of
+  the pitch it inflects, so a B-flat sign sits on the B line; where the sign is
+  printed and which degree it alters are separate facts, and both emitters took
+  both from the row carrying the sign. On *Felices sensus* (gregobase:1180) two
+  flats governing B-flats were drawn on the G and A lines, where the Liber
+  Usualis plate (p. 1637) has them on the B line. Corpus-wide, 3,505 of 4,358
+  explicit signs sat on a degree they do not alter. The mark now carries the
+  altered degree, and horizontal placement is untouched: the sign still reads
+  before the figure it governs.
+
+- **A written sign could be dropped.** Repeat-suppression compared the
+  sign-carrying row's pitch class against the row immediately before it, which
+  measured the wrong pitch (the sign's neighbour, not the degree it alters) and
+  applied a weaker rule than the books', which restate once another pitch has
+  intervened. *Felices sensus* wrote three flats and printed two: the third
+  followed another A, though it opens a new phrase and governs a new B-flat.
+  Suppression is now keyed on the altered degree and on nothing else, and it
+  holds back only a sign with no music between it and the last mark of that
+  degree. A sign whose alteration is never found within its lookahead prints
+  rather than borrowing the coordinate of the line it was written on: that line
+  is a different fact, and keying both into one map let a found degree and an
+  unfound sign's carrying line collide. All three of the fixture's flats print.
+
+- **A natural's line was found by the wrong test.** The lookahead for the
+  governed degree read `accidental !== 0`, which a natural never satisfies: it
+  restores a pitch rather than altering one. Naturals are now read against the
+  state they set, so a B-natural sign sits on the B line.
+
+## 0.8.0 — 2026-08-18
+
+### Changed
+
+- **`prosody` is renamed `metrics`, because that is what it measures.**
+
+- **CI runs the test suite** in place of the retired site deploy.
+
+## 0.7.0 — 2026-08-17
+
+The site leaves for its own repo, and the fonts are named rather than bundled.
+
+### Changed
+
+- **The site migrated to orreliquum.** The playground, its diagrams and the hand
+  figure now live in the site's own repo, which consumes tonus as a dependency;
+  this repo keeps the library and `docs/api`.
+
+- **Junicode is named, not bundled**, and the font note is stated as a recipe.
+  tonus ships no font files: the `fonts` option emits family references, and a
+  slot's `embed` carries the caller's own bytes.
+
+- **The glyph extractor is JavaScript**, and Bravura lives in the repo.
+
+- **The signs get their own documentation page**, and the removed exports leave
+  the table.
+
+### Fixed
+
+- **A correction to the Guidonian hand data.**
+
+- **0.6.1 — the tagged 0.6.0 never reached the registry.** A republish under a
+  new patch version, the registry having lagged the git tag.
 
 ## 0.6.0 — 2026-08-16
 

package/README.md

@@ -8,7 +8,7 @@ belong to which day and returns analysis and notation, and calculates the
 _music of the spheres_ proposed by Pythagoras, Boethius, and more as real
 intervals.
 
-**[Interactive demo →](https://jeffreypierce.github.io/tonus/)**
+**[Orreliquum — the library at work →](https://jeffreypierce.github.io/orreliquum/)**
 
 Everything is computed locally and deterministically: the same question always
 returns the same answer, from data that ships inside the package, with no network

package/dist/engines/chant/attest.js

@@ -8,14 +8,14 @@
 // ReferenceError whenever ordinary.js loaded first).
 //
 // ── A FILTER THAT LEFT AND CAME BACK ───────────────────────────────────────
-// This filter was once retired because its data had a genre-shaped hole: 31%
-// of the corpus undated, 93% of RESPONSORIES among them, so `before: 1098`
-// deleted the Hartker repertory from Epiphany Matins — wrong about the
-// liturgy on the exact question the library exists to answer. The rule was
-// never the problem; the coverage was. The corpus side closed it (crosswalk
-// gap-fill + matcher v2: composite respond+verse, the incipit-entry rule,
-// containment, genre disambiguation — all gold-gated): 85% of shipped records
-// now carry a dated witness and responsories are 92% DATED. What remains
+// This filter was once retired because its data had a genre-shaped hole: a
+// third of the corpus undated, and RESPONSORIES almost all of it, so
+// `before: 1098` deleted the Hartker repertory from Epiphany Matins — wrong
+// about the liturgy on the exact question the library exists to answer. The
+// rule was never the problem; the coverage was. The corpus side closed it
+// (crosswalk gap-fill + matcher v2: composite respond+verse, the incipit-entry
+// rule, containment, genre disambiguation — all gold-gated): the great majority
+// of shipped records now carry a dated witness, responsories included. What remains
 // undated is deliberate (psalter, formulas) or editorial territory (hymns,
 // modern propers) — not a genre bias. So the evidence law stands: an undated
 // chant is EXCLUDED under any cutoff. Silence is not evidence.

package/dist/engines/chant/hour.js

@@ -97,10 +97,10 @@ function primeForFeast(feast) {
  *
  * A monastic weekday in the temporale mostly has no proper antiphons — the
  * office-monastic table has the day but leaves antLaudes/antVespera/antMatutinum
- * empty (292 of its 409 entries), because those antiphons live in the psalter,
+ * empty in most of its entries, because those antiphons live in the psalter,
  * not in the propers. Without a fallback the hour silently returns a partial
- * ordo, which is why Lauds resolved on 106 of 360 days and essentially never in
- * the temporale.
+ * ordo, which is why Lauds resolved on well under a third of the year's days
+ * and essentially never in the temporale.
  *
  * ── WHY THE COMMUNE COMES BEFORE THE FERIAL CYCLE ───────────────────────────
  * A saint's day is not a feria. When the rubrics give a saint no proper

package/dist/engines/chant/intone.js

@@ -50,7 +50,13 @@ function buildHalf(syllables, tenor, cadenceNotes, prefixNotes) {
         }
         else {
             const note = noteAssignment[noteIdx++] ?? tenor;
-            tokens.push(`(${note})${syl}`);
+            // TEXT FIRST, then its notes — `syl(note)`, which is what GABC means and
+            // what every corpus chant encodes. Emitted the other way round, each
+            // whitespace-separated word opened with an empty-text syllable that took
+            // syllableIndex 0, so the word's real first syllable never scored
+            // wordStart and the renderer hyphenated between every pair: a whole verse
+            // set as a single word. The word-aware metrics read the same lie.
+            tokens.push(`${syl}(${note})`);
         }
     }
     return tokens.join("");

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

@@ -1,5 +1,5 @@
 import { type Imprint } from "../imprint.js";
-import { type Prosody } from "./prosody.js";
+import { type Metrics } from "./metrics.js";
 import { type Cadence } from "./cadence.js";
 import { type Modulation } from "./modulation.js";
 import { type ChantTabulaRow } from "./tabula.js";
@@ -28,7 +28,7 @@ export interface Score {
     phrases: IRPhrase[];
     errors: ParseError[];
     tabula: ChantTabulaRow[];
-    prosody: Prosody;
+    metrics: Metrics;
     /** Mode-specific cadence at each phrase-ending divisio. */
     cadences: Cadence[];
     /** Passages where the tonal centre leans away from the home mode. */
@@ -38,7 +38,7 @@ export interface Score {
 /**
  * Score builder (`tonus.notatio`). Parses a chant's GABC into a musical
  * IR — phrases, syllables, notes with tuned pitches, arsis/thesis
- * rhythm, prosody, imprint, and a tabula. Options: a temperamentum
+ * rhythm, metrics, imprint, and a tabula. Options: a temperamentum
  * (tuning), a pondus (articulation weight, style name or opts), and an
  * accentus (phrasing, style name or opts).
  * @throws Error on invalid Chant input or unparseable GABC.

package/dist/engines/score/api.js

@@ -6,7 +6,7 @@ import { buildIR } from "./ir.js";
 import { buildRatios } from "../temper/scale.js";
 import { computeMeta } from "./meta.js";
 import { computeImprint } from "../imprint.js";
-import { computeProsody } from "./prosody.js";
+import { computeMetrics } from "./metrics.js";
 import { detectCadences } from "./cadence.js";
 import { detectModulations } from "./modulation.js";
 import { computeTabula } from "./tabula.js";
@@ -33,7 +33,7 @@ function resolveAccentus(input) {
 /**
  * Score builder (`tonus.notatio`). Parses a chant's GABC into a musical
  * IR — phrases, syllables, notes with tuned pitches, arsis/thesis
- * rhythm, prosody, imprint, and a tabula. Options: a temperamentum
+ * rhythm, metrics, imprint, and a tabula. Options: a temperamentum
  * (tuning), a pondus (articulation weight, style name or opts), and an
  * accentus (phrasing, style name or opts).
  * @throws Error on invalid Chant input or unparseable GABC.
@@ -98,7 +98,7 @@ export function buildScore(chant, opts) {
         phrases: ir.phrases,
         errors: ir.errors,
         tabula,
-        prosody: computeProsody(ir.phrases),
+        metrics: computeMetrics(ir.phrases),
         cadences,
         modulations,
         imprint: computeImprint(ir.phrases, scale, {

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

@@ -59,10 +59,10 @@ export interface Cadence {
  *
  * NOT part of the family key — kept because the folded value is still worth
  * reporting (it is the scale DEGREE, mode-theoretically real). As a key the
- * fold made a fifth ABOVE the final share a family with a fourth BELOW:
- * measured over 27,985 phrase ends, 3,499 landed on @-5, of which 2,427 were
- * really +7 and 1,072 really -5. Two opposite gestures, one key. Arrival in
- * the key is therefore the SIGNED offset; see cadenceKeys().
+ * fold made a fifth ABOVE the final share a family with a fourth BELOW — two
+ * opposite gestures under one key. The measurement behind that ruling is
+ * stated once, in `data/cadentiae.ts`'s header, beside the table it governs.
+ * Arrival in the key is therefore the SIGNED offset; see cadenceKeys().
  */
 export declare function reduceArrival(semitones: number): number;
 /** One phrase-end event: the family key, and whether it closes the chant. */
@@ -91,6 +91,12 @@ export interface CadenceKeyEvent {
  * copies is what "no second parser, no drift" forbids; hence this one shared
  * function.
  *
+ * That 27,985 is the population of the run that PROVED the agreement, and it
+ * does not match `CADENTIAE_POPULATION.ends`: the table was rebaked afterwards
+ * against the sung corpus. Two measurements of different populations, not a
+ * contradiction — the figure here is fixed to its proof and does not track the
+ * table.
+ *
  * Takes the FLAT shape, because that is what the census and the miner have; the
  * engine's own detection flattens into it. A phrase end is a `phraseIndex`
  * transition or the last row.

package/dist/engines/score/cadence.js

@@ -134,10 +134,10 @@ const TAIL = 4;
  *
  * NOT part of the family key — kept because the folded value is still worth
  * reporting (it is the scale DEGREE, mode-theoretically real). As a key the
- * fold made a fifth ABOVE the final share a family with a fourth BELOW:
- * measured over 27,985 phrase ends, 3,499 landed on @-5, of which 2,427 were
- * really +7 and 1,072 really -5. Two opposite gestures, one key. Arrival in
- * the key is therefore the SIGNED offset; see cadenceKeys().
+ * fold made a fifth ABOVE the final share a family with a fourth BELOW — two
+ * opposite gestures under one key. The measurement behind that ruling is
+ * stated once, in `data/cadentiae.ts`'s header, beside the table it governs.
+ * Arrival in the key is therefore the SIGNED offset; see cadenceKeys().
  */
 export function reduceArrival(semitones) {
     let a = semitones % 12;
@@ -158,6 +158,12 @@ export function reduceArrival(semitones) {
  * copies is what "no second parser, no drift" forbids; hence this one shared
  * function.
  *
+ * That 27,985 is the population of the run that PROVED the agreement, and it
+ * does not match `CADENTIAE_POPULATION.ends`: the table was rebaked afterwards
+ * against the sung corpus. Two measurements of different populations, not a
+ * contradiction — the figure here is fixed to its proof and does not track the
+ * table.
+ *
  * Takes the FLAT shape, because that is what the census and the miner have; the
  * engine's own detection flattens into it. A phrase end is a `phraseIndex`
  * transition or the last row.

package/dist/engines/score/emitters/accidentals.d.ts

@@ -9,6 +9,15 @@ export interface AccidentalMark {
     glyph?: string;
     /** Text label (kind "cents") — e.g. "−3.9". */
     label?: string;
+    /** The DEGREE THE SIGN ALTERS (kind "glyph", standard mode), as the two
+     *  emitters address a line: `degree` is quadrata's staffPosition, `degreeSpn`
+     *  is moderna's written pitch. A flat is printed on the line of the pitch it
+     *  inflects — a B-flat sign sits on the B line — while its horizontal place
+     *  is before the figure where it takes effect. Those are two facts, and the
+     *  carrying row supplies only the second. Both absent when the sign alters
+     *  nothing found ahead. */
+    degree?: number;
+    degreeSpn?: string;
 }
 export type AccidentalGlyphSet = "modern" | "medieval";
 /**

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

@@ -8,6 +8,12 @@ const GLYPHS_BY_SET = {
     modern: { [-1]: "E260", 0: "E261", 1: "E262" },
     medieval: { [-1]: "E9E0", 0: "E9E1", 1: "E9E3" },
 };
+// How far ahead a written sign is read for the degree it alters. A flat is
+// written before the figure it governs, not always before the note: on
+// gregobase:1180 one sign precedes its B-flat by four notes within the
+// syllable. Bounded so a sign whose alteration never arrives does not reach
+// across the chant and borrow an unrelated note's line.
+const SCOPE = 12;
 // HEJI comma glyphs (Extended Helmholtz–Ellis, U+E2C0–). The syntonic-comma
 // arrows: one comma down / up. Higher-order commas are out of scope for 0.2.
 const HEJI_COMMA_DOWN = "E2C2"; // one syntonic comma lower
@@ -24,21 +30,78 @@ function fromPythagorean(row) {
  */
 export function computeAccidentals(rows, mode, centsBaseline = "pythagorean", glyphSet = "modern") {
     if (mode === "standard") {
-        // A glyph before any note whose pitch is explicitly inflected — but not on
-        // an immediately-repeated same pitch (restate only after another pitch).
-        let prevPc = null;
-        return rows.map((row) => {
-            const repeat = row.pc === prevPc;
-            prevPc = row.pc;
-            if (row.accidentalSource !== "explicit" || repeat)
+        // WHERE a sign is printed and WHICH DEGREE it alters are different facts,
+        // and the row carrying the sign supplies only the first. In
+        // `fe(jx)cit(ih)` the flat is written before the I while it governs the J:
+        // horizontally it precedes the figure (so the singer reads it in time),
+        // vertically it belongs to the pitch it inflects. Solesmes prints a flat
+        // on the LINE OF THE PITCH IT ALTERS — a B-flat sign sits on the B line
+        // [biblio: liber-usualis, Rules for Interpretation; the plate for
+        // gregobase:1180 at p. 1637 shows both of that chant's flats on the B
+        // line, over an A and a G]. Reading `row.accidental` here drew nothing at
+        // all in the `fe(jx)` case (the I is unaltered); reading the carrying
+        // row's staffPosition drew the flat on whatever line happened to precede
+        // — corpus-wide, 80% of signs sat on a degree they do not alter.
+        const alteredOf = (from) => {
+            // The sign governs the next note in its scope that CARRIES THE STATE it
+            // sets. A flat looks for the note it lowers; a natural looks for the note
+            // it restores, which is unaltered by definition (`accidental === 0`) and
+            // is marked "state" because the sign, not the clef, put it there.
+            // Reading only `accidental !== 0` found the flats and missed every
+            // natural's B.
+            //
+            // The scan opens AT the carrying row, which is the common case: a sign
+            // written directly before the note it alters is carried by that note.
+            // The two facts coincide there; where they part, the scan walks on.
+            const sign = rows[from].accidentalSign ?? rows[from].accidental;
+            for (let j = from; j < rows.length && j < from + SCOPE; j++) {
+                const r = rows[j];
+                if (sign === 0 ? r.accidentalSource === "state" : r.accidental === sign)
+                    return r;
+            }
+            return undefined;
+        };
+        // Restate a sign once another pitch has intervened since that DEGREE was
+        // last marked. Comparing the carrying row against the row before it was
+        // wrong twice over: it measured the wrong pitch (the sign's neighbour,
+        // not the degree it alters), and "the immediately-preceding row" is a
+        // weaker rule than the books', which restate after an intervening pitch.
+        // On gregobase:1180 the third flat was dropped because the note before it
+        // was another A — though it opens a new phrase and governs a new B-flat.
+        //
+        // SUPPRESSION IS KEYED ON THE ALTERED DEGREE, AND ON NOTHING ELSE. A sign
+        // whose alteration is never found has no degree to key on, and it is not
+        // keyed on the line it happens to be written on: that line is a different
+        // coordinate, and the two sharing one map made a found degree and an
+        // unfound sign's carrying line collide. Such a sign always prints —
+        // rare, and an unexplained sign on the page is the safer failure.
+        const lastMarked = new Map();
+        return rows.map((row, i) => {
+            if (row.accidentalSource !== "explicit")
                 return null;
-            // Draw the SIGN the source wrote, not this note's own alteration. In
-            // `fe(jx)cit(ih)` the flat is printed before the I while it governs J —
-            // where a sign is printed and which degree it alters are different facts.
-            // Reading `row.accidental` here drew nothing in that case, because the I
-            // is unaltered.
             const sign = row.accidentalSign ?? row.accidental;
-            return { kind: "glyph", glyph: GLYPHS_BY_SET[glyphSet][sign] };
+            const altered = alteredOf(i);
+            const degree = altered?.staffPosition;
+            const mark = {
+                kind: "glyph", glyph: GLYPHS_BY_SET[glyphSet][sign],
+                degree, degreeSpn: altered?.spn,
+            };
+            if (degree === undefined)
+                return mark;
+            const since = lastMarked.get(degree);
+            lastMarked.set(degree, i);
+            // What the books restate after is INTERVENING MUSIC, and the sign that
+            // says nothing new is the one with none: the two signs adjacent, the
+            // second merely re-marking a degree the first has just marked. Asking
+            // instead whether an intervening row LEFT the degree suppressed a real
+            // restatement whenever the music between the signs stayed on the altered
+            // degree — the commonest case there is, since that degree is what the
+            // signs are both about.
+            if (since !== undefined &&
+                rows.slice(since + 1, i).every((r) => r.accidentalSource === "explicit")) {
+                return null;
+            }
+            return mark;
         });
     }
     if (mode === "heji") {

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

@@ -24,7 +24,7 @@
 // draw.
 //
 // ─── HOW THIS MEETS THE PAGE ───────────────────────────────────────────────
-// The site (orreliquum-next) keeps a system of its own, stated at the top of
+// The site (orreliquum) keeps a system of its own, stated at the top of
 // its stylesheet. The two are separate and they AGREE BY SHARING NUMBERS,
 // not by one importing the other:
 //

package/dist/engines/score/emitters/breaking.d.ts

@@ -25,8 +25,8 @@ export interface BreakQuery {
      * Set when the caller has ALREADY consumed `next.lineBreak` itself. Quadrata
      * honours `z` in its own block (it must repeat the clef and place a custos
      * before the staff advances), so asking here too would break the same system
-     * twice — measured, one Graduale chant drew 9 custos for 9 systems where 8 is
-     * correct, the last system needing none.
+     * twice — measured, a Graduale chant drew one custos per system where the
+     * last system needs none.
      */
     forcedHandled?: boolean;
 }

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

@@ -52,8 +52,8 @@ export function decideBreak(q) {
     // be tested on its own: a single figure wider than a whole line (a 36-note
     // melisma at 420px) can never be rescued by breaking, but the line before it
     // should still end rather than run on. Folding this into the `need` test
-    // below let such a syllable extend a line that was already full — measured,
-    // one Graduale render overran by 56px.
+    // below let such a syllable extend a line that was already full, and a
+    // Graduale render overran its width.
     if (q.x > q.boundary)
         return { break: true, reason: "width" };
     return q.x + q.need > q.boundary

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

@@ -172,9 +172,9 @@ const HEAD_K = 0.825;
  *
  * This briefly mapped inclinatum to a half note, on the reasoning that the
  * ambitus figure uses that shape to mark a mode's tenor. That confused a
- * DIAGRAM's private vocabulary with the notation's: an inclinatum is 10.4% of
- * every note in the corpus, so a tenth of every transcribed chant came out
- * hollow, each one implying a length it does not have.
+ * DIAGRAM's private vocabulary with the notation's: an inclinatum is about a
+ * tenth of every note in the corpus, so that share of every transcribed chant
+ * came out hollow, each one implying a length it does not have.
  */
 function notehead(x, y, small, half, gm) {
     const s = gm.SCALE * (small ? 0.68 : 1.0) * HEAD_K;
@@ -428,8 +428,12 @@ export function toModerna(rows, chant, options = {}) {
             if (r.quilisma)
                 body.push(quilismaMark(mx, my, gm));
             const mk = markByRow.get(r);
-            if (mk?.kind === "glyph")
-                body.push(accidentalMark(mx, my, mk.glyph, gm));
+            if (mk?.kind === "glyph") {
+                // Vertically the sign belongs to the pitch it alters, not to the note
+                // it was written before; horizontally it stays at this note's column.
+                const ay = mk.degreeSpn ? writtenY(mk.degreeSpn, systemY, gm).y : my;
+                body.push(accidentalMark(mx, ay, mk.glyph, gm));
+            }
             else if (mk?.kind === "cents") {
                 // Cents labels float in a band above the staff (not glued to the
                 // head) — an analytic overlay, not an engraving mark.
@@ -601,10 +605,16 @@ export function toModerna(rows, chant, options = {}) {
         phraseIndex: pl.row.phraseIndex,
         syllableIndex: pl.row.syllableIndex,
         neumeGroup: pl.row.neumeGroup,
-        noteIndex: pl.row.neumeIndex,
+        noteIndex: pl.row.noteIndex,
+        neumeIndex: pl.row.neumeIndex,
         system: pl.system,
         x: Number(pl.x.toFixed(2)),
         y: Number(pl.y.toFixed(2)),
+        // Derived, not measured: moderna centres its noteheads on the anchor, so
+        // the ink straddles it evenly. The track mapping above derives them the
+        // same way, from the same number.
+        inkLeft: Number((pl.x - gm.NH_W / 2).toFixed(2)),
+        inkRight: Number((pl.x + gm.NH_W / 2).toFixed(2)),
         systemY: Number(pl.systemY.toFixed(2)),
     }));
     return { svg, geometry };

package/dist/engines/score/emitters/svg.d.ts

@@ -124,13 +124,29 @@ export declare function lyricMarkup(runs: LyricRun[] | undefined, plain: string,
 export interface NoteGeometry {
     phraseIndex: number;
     syllableIndex: number;
+    /** 0-based index of the neume figure within the syllable (GABC break markers). */
     neumeGroup: number;
+    /** 0-based position of this note within its SYLLABLE — the same index
+     *  `ChantTabulaRow.noteIndex` and `Cadence.notes[*][2]` carry, so the three
+     *  address one note. Both emitters used to fill this from `neumeIndex`, which
+     *  agrees only on syllables of a single figure: on *Puer natus est* the
+     *  documented tuple join misaddressed 17 of 159 notes. */
     noteIndex: number;
+    /** 0-based position of this note within its NEUME FIGURE. */
+    neumeIndex: number;
     /** Which system (staff line) the note landed in — 0 when nothing wraps. */
     system: number;
     /** Notehead anchor in svg user units. */
     x: number;
     y: number;
+    /** The figure's measured ink extent. `x` is the ANCHOR — quadrata's square
+     *  glyphs start there and run right, so a span drawn anchor-to-anchor sits
+     *  left of the notes it names and stops short of the last one. A mark that
+     *  spans notes reaches for these instead. Quadrata measures them from the
+     *  glyph's bbox as it places; moderna centres its heads on the anchor, so
+     *  they are derived and straddle it evenly. */
+    inkLeft: number;
+    inkRight: number;
     /** The system's top offset within the svg — 0 in the first system. */
     systemY: number;
 }