tonus 0.1.8 → 0.6.1

package/dist/engines/score/cadence.js

@@ -125,6 +125,84 @@ function bestFigure(observed, figures) {
     }
     return best;
 }
+// ── The corpus catalogue (CADENTIAE) ────────────────────────────────────────
+// The mining keyed tails by their last <=4 notes; the classifier reads the same
+// span out of the (longer) formula window.
+const TAIL = 4;
+/**
+ * Octave-reduce a semitone offset to [-5..+6].
+ *
+ * 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().
+ */
+export function reduceArrival(semitones) {
+    let a = semitones % 12;
+    if (a > 6)
+        a -= 12;
+    if (a < -5)
+        a += 12;
+    return a;
+}
+/**
+ * THE cadence family key — one implementation, shared by every consumer.
+ *
+ * This once existed three times: here (keyed off the Phrase tree), in
+ * tonus-corpus `census/_shared.mjs` (keyed off flat tabula rows), and in the
+ * CADENTIAE miner (a character-for-character copy of the census one). They
+ * agreed — measured corpus-wide, 28,051 engine cadences against 27,985 census
+ * phrase ends with ZERO key disagreements — but agreement by luck across three
+ * copies is what "no second parser, no drift" forbids; hence this one shared
+ * function.
+ *
+ * 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.
+ *
+ * A ONE-NOTE PHRASE IS A CADENCE — it has a landing but no gesture, so it is
+ * emitted with an empty shape rather than skipped. (The census once dropped
+ * these — 68 corpus-wide, all real phrases carrying a real divisio, mostly
+ * "::" at the chant end — a hole this shared key closes.)
+ */
+export function cadenceKeys(rows, finalMidi) {
+    if (!rows.length)
+        return [];
+    const final = finalMidi ?? rows[rows.length - 1].midi;
+    const events = [];
+    for (let i = 0; i < rows.length; i++) {
+        const next = rows[i + 1];
+        if (next && next.phraseIndex === rows[i].phraseIndex)
+            continue; // not a phrase end
+        // The last <=TAIL rows of this phrase, ending at row i.
+        const seg = [];
+        for (let j = i; j >= 0 && seg.length < TAIL && rows[j].phraseIndex === rows[i].phraseIndex; j--) {
+            seg.unshift(rows[j]);
+        }
+        const shape = seg.slice(1).map((r, k) => r.midi - seg[k].midi);
+        const arrival = seg[seg.length - 1].midi - final;
+        events.push({
+            key: `${shape.join(",")} @${arrival}`,
+            shape,
+            arrival,
+            degree: reduceArrival(arrival),
+            isFinal: rows[i].divisio === "::" || !next,
+            phraseIndex: rows[i].phraseIndex,
+        });
+    }
+    return events;
+}
+/** The chant's closing note — the reference every arrival is measured from. */
+function chantFinalMidi(phrases) {
+    for (let pi = phrases.length - 1; pi >= 0; pi--) {
+        const w = phraseFinalWindow(phrases[pi]);
+        if (w.length > 0)
+            return w[w.length - 1].midi;
+    }
+    return undefined;
+}
 /**
  * Detect the cadence closing each phrase. One Cadence per phrase that carries a
  * divisio. With no mode, targets/approach are still classified but no figure is
@@ -132,6 +210,7 @@ function bestFigure(observed, figures) {
  */
 export function detectCadences(phrases, modeData) {
     const cadences = [];
+    const finalMidi = chantFinalMidi(phrases);
     for (let pi = 0; pi < phrases.length; pi++) {
         const phrase = phrases[pi];
         if (!phrase.divisio)
@@ -162,6 +241,15 @@ export function detectCadences(phrases, modeData) {
                 }
             }
         }
+        // The corpus classification, from THE shared key function — the engine does
+        // not compute this itself. `cadenceKeys` takes flat rows, so the window is
+        // projected into that shape; one phrase in, one event out.
+        const ev = cadenceKeys(window.map((w) => ({ phraseIndex: 0, midi: w.midi, divisio: null })), finalMidi)[0];
+        const shape = ev?.shape ?? [];
+        const arrival = ev?.arrival ?? 0;
+        // A 1-note phrase has a landing but no gesture: a real cadence with an
+        // empty shape, which is why `signature` is the key rather than null.
+        const signature = ev?.key ?? null;
         cadences.push({
             phraseIndex: pi,
             divisio,
@@ -172,6 +260,14 @@ export function detectCadences(phrases, modeData) {
             steps,
             confidence: Math.round(confidence * 100) / 100,
             notes: window.map((w) => [pi, w.syllableIndex, w.noteIndex]),
+            signature,
+            shape,
+            arrival,
+            // Left null here on purpose. Detection is a pure pass over the phrase
+            // tree; the corpus catalogue is generated data, and reaching for it from
+            // inside the detector would put a baked artifact in the detection path.
+            // buildScore joins it, where MODES is already joined.
+            finality: null,
         });
     }
     return cadences;

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

@@ -0,0 +1,21 @@
+import type { ChantTabulaRow } from "../tabula.js";
+export type AccidentalMode = "standard" | "heji" | "cents";
+export type CentsBaseline = "pythagorean" | "et";
+/** One note's intonation mark, for the emitter to place before/above the head. */
+export interface AccidentalMark {
+    /** "glyph" → a notehead-preceding accidental; "cents" → a label floating above the staff. */
+    kind: "glyph" | "cents";
+    /** Glyph codepoint (kind "glyph") — a standard or HEJI accidental. */
+    glyph?: string;
+    /** Text label (kind "cents") — e.g. "−3.9". */
+    label?: string;
+}
+export type AccidentalGlyphSet = "modern" | "medieval";
+/**
+ * Compute the intonation mark for each tabula row, or null where none applies.
+ * Repeat-suppression (standard mode) and per-phrase pitch-class suppression
+ * (cents mode) keep the staff from being carpeted.
+ * @throws Error when `heji` is asked of a non-just (meantone) tuning.
+ */
+export declare function computeAccidentals(rows: ChantTabulaRow[], mode: AccidentalMode, centsBaseline?: CentsBaseline, glyphSet?: AccidentalGlyphSet): (AccidentalMark | null)[];
+//# sourceMappingURL=accidentals.d.ts.map

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

@@ -0,0 +1,88 @@
+import { pythagoreanCentsByPc } from "../../temper/scale.js";
+// The Pythagorean chain's ET-cents deviation per pitch class, derived from the
+// SAME E♭–G♯ chain the engine tunes with (temper/scale.ts) so baseline and
+// engine can never disagree — a hardcoded copy once drifted and broke the
+// heji channel for every flatted chant under the default tuning.
+const PYTH_BASELINE = pythagoreanCentsByPc();
+const GLYPHS_BY_SET = {
+    modern: { [-1]: "E260", 0: "E261", 1: "E262" },
+    medieval: { [-1]: "E9E0", 0: "E9E1", 1: "E9E3" },
+};
+// 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
+const HEJI_COMMA_UP = "E2C7"; // one syntonic comma higher
+/** Deviation of a note from the Pythagorean chain, in cents. */
+function fromPythagorean(row) {
+    return row.offset - (PYTH_BASELINE[row.pc] ?? 0);
+}
+/**
+ * Compute the intonation mark for each tabula row, or null where none applies.
+ * Repeat-suppression (standard mode) and per-phrase pitch-class suppression
+ * (cents mode) keep the staff from being carpeted.
+ * @throws Error when `heji` is asked of a non-just (meantone) tuning.
+ */
+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)
+                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] };
+        });
+    }
+    if (mode === "heji") {
+        // A tuning is just-expressible when its departures from Pythagorean are
+        // whole syntonic commas (±21.5¢). An irrational tempering (meantone) leaves
+        // fractional deviations everywhere — heji cannot notate it. Detect that.
+        const devs = rows.map(fromPythagorean);
+        const SYNTONIC = 21.506;
+        const tempered = devs.some((d) => {
+            if (Math.abs(d) < 0.5)
+                return false; // on the pure-fifth chain
+            const commas = d / SYNTONIC;
+            return Math.abs(commas - Math.round(commas)) > 0.1; // not a whole comma
+        });
+        if (tempered) {
+            throw new Error("inscriptio: accidentals \"heji\" needs a just-expressible tuning; the " +
+                "current temperament tempers by fractional commas (e.g. meantone). Use " +
+                "accidentals: \"cents\" for tempered tunings.");
+        }
+        return rows.map((row) => {
+            const d = fromPythagorean(row);
+            if (Math.abs(d) < 0.5)
+                return null; // Pythagorean baseline — no arrow
+            const commas = Math.round(d / SYNTONIC);
+            if (commas === 0)
+                return null;
+            return { kind: "glyph", glyph: commas < 0 ? HEJI_COMMA_DOWN : HEJI_COMMA_UP };
+        });
+    }
+    // cents — signed deviation label, stated once per pitch class PER PHRASE.
+    // A deviating pitch is labelled at its first appearance in each phrase and
+    // rides silently through the phrase's repeats; the next phrase restates it
+    // (the reader's memory is the phrase, and chant has no measures to carry it).
+    const seen = new Set();
+    return rows.map((row) => {
+        const value = centsBaseline === "et" ? row.offset : fromPythagorean(row);
+        if (Math.abs(value) < 0.5)
+            return null; // effectively in tune
+        const key = `${row.phraseIndex}:${row.pc}`;
+        if (seen.has(key))
+            return null; // already labelled in this phrase
+        seen.add(key);
+        const sign = value < 0 ? "−" : "+"; // real minus sign
+        return { kind: "cents", label: `${sign}${Math.abs(value).toFixed(1)}` };
+    });
+}
+//# sourceMappingURL=accidentals.js.map

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

@@ -0,0 +1,107 @@
+/** The one ink. Everything black is this black. */
+export declare const INK = "#111";
+/** The liturgical red. Reserved for the CLAIM lines: the mode's in the
+ * tonarium, and — ruled 2026-08-11, amending the 07-29 reservation — the
+ * word's accent in the prosodia. The precedent is the score's own text
+ * apparatus: the dropcap and annotations have always been rubricated, and
+ * in the books red is the word's colour. Nothing else wears it. */
+export declare const RUBRICA = "#9E2B25";
+/** Stratum opacities: one ink, graded. The melody strata (wave, spark) sit
+ * under their annotations; a claim re-inks at full strength. */
+export declare const STRATUM: {
+    readonly wave: 0.75;
+    readonly spark: 0.45;
+    readonly cadence: 1;
+    readonly letters: 0.62;
+    readonly label: 0.9;
+    readonly bracket: 0.3;
+    readonly rail: 0.24;
+    readonly margin: 0.38;
+    readonly block: 0.18;
+    readonly rule: 0.15;
+};
+/** Below this confidence nothing is drawn. Not faint — absent. */
+export declare const CONF_FLOOR = 0.45;
+/** THE nib — one pressure law: normalized velocity → stroke width. */
+export declare const nib: (vn: number) => number;
+/** The stroke ladder. A diagram picks a rung; it does not invent a width.
+ * Named for what the line DOES, so the choice is about meaning, not weight. */
+export declare const STROKE: {
+    readonly hair: 0.55;
+    readonly fine: 0.75;
+    readonly firm: 1.05;
+    readonly heavy: 1.5;
+};
+/** The type scale, and it is THE PAGE'S: a modular scale on 15px stepped by
+ *  the Pythagorean minor third, 32:27 — the same six `--micro` … `--display-size`
+ *  that ../../../../docs/styles.css declares. So a wheel's label and a table's
+ *  label at the same step are the same size.
+ *
+ *  It was 9/11/13.5/17/21/26, derived from what the diagrams happened to use.
+ *  That was honest when the page had no scale of its own; once the page took
+ *  one, the two agreed on `title` alone and every drawn label sat 1.5–2px under
+ *  the prose around it. ../../../../scripts/vendor-ink.mjs asserts the pairing
+ *  now, so this cannot drift again silently.
+ *
+ *  Nothing inside tonus reads STEP — the site's diagrams are its only consumer
+ *  — so moving it changes no emitted SVG for a package consumer. */
+export declare const STEP: {
+    readonly micro: 10.5;
+    readonly caption: 12.5;
+    readonly label: 15;
+    readonly body: 18;
+    readonly title: 21;
+    readonly display: 25;
+};
+/** The house faces. Junicode is the serif — the real face, not the Crimson Pro
+ * stand-in the early rounds carried; Plex Mono is the machine register. */
+export declare const HOUSE_SERIF = "Junicode, 'Crimson Pro', Georgia, serif";
+/** The machine register. IBM Plex Mono FIRST: the site loads and self-hosts
+ * that face, and with `ui-monospace` at the head of the stack every drawn
+ * label resolved to the system mono — SF Mono on macOS — beside page text in
+ * Plex. Two monospaces, same size, same column. */
+export declare const HOUSE_MONO = "'IBM Plex Mono', ui-monospace, Menlo, monospace";
+/** The fourth stack, and NOT a fourth face: neither text face carries the
+ *  planetary or musical signs (see fonts/README.md), so a figure that draws one
+ *  falls back to the system. Mirrors `--symbol` in ../../../../docs/styles.css
+ *  — the same sharing-by-numbers seam as HOUSE_SERIF and HOUSE_MONO, and it was duplicated
+ *  inline in mutatio.js as a local SIGN_FACE before this existed. */
+export declare const HOUSE_SYMBOL: string;
+/** The figures a FIGURE sets: Junicode's own, which are OLDSTYLE by default —
+ *  they sit on the baseline with ascenders and descenders as lowercase letters
+ *  do, so a number reads as part of a line of text rather than standing off it.
+ *
+ *  `features` is empty on purpose, and that is the finding worth keeping: in
+ *  Junicode `zero` IS the oldstyle glyph and `zero.lf` is the lining variant,
+ *  so `onum` maps lining BACK to the default and does nothing unless `lnum` is
+ *  already on. Setting it here looked correct and changed no pixel — measured
+ *  identical advances, 423.2 either way. Reach for `lnum`/`tnum` when a column
+ *  of digits must line up; that is the setting that does work.
+ *
+ *  Nothing in the library's own emitters uses this yet. It lives here because
+ *  this file is the ONE definition of the ink system and the site vendors it
+ *  (../../../../scripts/vendor-ink.mjs) — a second copy in the site would be
+ *  the drift this module exists to prevent. */
+export declare const FIGURES: {
+    readonly family: "Junicode, 'Crimson Pro', Georgia, serif";
+    readonly features: "";
+};
+/** A scaled measure, at most two places and no trailing zeros: 1.8, not 1.80. */
+export declare const sc: (v: number) => string;
+/** XML-escape a string for an SVG attribute or text node. */
+export declare const esc: (s: string) => string;
+export type Pt = [number, number];
+/** Sample one cubic Bézier segment (matches the generators' tessellation). */
+export declare function sampleCubic(p1: Pt, c1: Pt, c2: Pt, p2: Pt, steps: number): Pt[];
+/** Catmull–Rom through the points, sampled — the one curve idiom. */
+export declare function crSamples(pts: Pt[], steps: number): Pt[];
+/** Piecewise-linear velocity read along x between anchors; the pressure signal
+ * every pressure-bearing line shares. Null velocities read 0.3. */
+export declare function velocityAt(velpts: Pt[]): (x: number) => number;
+/** The subject's own velocity ceiling — pressure normalizes per subject, not
+ * to a corpus constant (the plates' frozen 0.62 was a session artifact). */
+export declare function velocityCeiling(velocities: readonly (number | null | undefined)[]): number;
+/** A ribbon polygon around sampled points: THE nib at `scale`, velocity as
+ * width — the one pressure stroke everything draws with. */
+export declare function ribbonPath(samples: Pt[], vat: (x: number) => number, vmax: number, scale: number): string;
+//# sourceMappingURL=atramentum.d.ts.map

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

@@ -0,0 +1,239 @@
+// ---------------------------------------------------------------------------
+// engines/score/emitters/atramentum — the ink: one drawing grammar
+// ---------------------------------------------------------------------------
+// THE GOVERNING INK SYSTEM (ruled 2026-07-29), extracted here so everything
+// tonus draws shares one definition rather than agreeing by coincidence. The
+// analysis tracks were its first consumer; the documentation site's diagrams
+// are the second.
+//
+// - ONE INK. Every mark draws in the score's black; strata differ by OPACITY
+//   alone (STRATUM), never by hue. Rubrica is the only colour, and it is
+//   reserved for the claims: the mode line's in the tonarium, the accent's
+//   in the prosodia (ruled 2026-08-11, amending 07-29 — see RUBRICA below).
+// - ONE NIB. Every pressure-bearing line shares one width law (`nib`): a
+//   normalized velocity becomes stroke width. Two marks at different opacities
+//   are the same stroke, not two different pens.
+// - CONFIDENCE IS OPACITY, composing with the stratum: a weak claim fades, and
+//   below CONF_FLOOR it draws nothing at all. A thing tonus is unsure of does
+//   not get drawn faintly and hedged in a caption; it goes uninked.
+//
+// The design brief is "Dieter Rams designs a liturgical book" — functionalist
+// restraint, one canonical accent, nothing decorative that is not also
+// informative. STEP and STROKE exist so a diagram cannot quietly invent a
+// fifteenth type size or a seventh hairline: it picks a step or it does not
+// draw.
+//
+// ─── HOW THIS MEETS THE PAGE ───────────────────────────────────────────────
+// The documentation site keeps a system of its own, stated at the top of
+// ../../../../docs/styles.css. The two are separate and they AGREE BY SHARING
+// NUMBERS,
+// not by one importing the other:
+//
+//   STEP        mirrors the six CSS type steps  (--micro … --display-size)
+//   INK         mirrors --ink
+//   RUBRICA     mirrors --rubrica
+//   HOUSE_*     mirror --serif and --mono
+//
+// That seam is the thing to watch. A face or a step changed on one side and
+// not the other does not fail — it renders, quietly, in the wrong thing. It
+// has happened twice: HOUSE_MONO once listed ui-monospace first and drew
+// every figure label in the system mono beside page text in Plex; HOUSE_SANS
+// named a face no page loads, so the wheels' names and the tracks' letters
+// came out in system-ui. Both are why the rule below is worth keeping literal.
+//
+// ─── THE FACES HAVE JOBS ───────────────────────────────────────────────────
+// HOUSE_SERIF carries WORDS — a sign name, a month, a role, a gamut letter,
+// a chironomy letter. HOUSE_MONO carries MACHINE DATA — hz, cents, ratios,
+// ids. There is no third: if a label is a word, it is serif, wherever it is
+// drawn. A figure that wants a face outside these two is asking the wrong
+// question about its label.
+//
+// Colour reaches SVG the same way the score's does: a drawn figure names the
+// site's token with its own value as the fallback — `var(--paper-dim,
+// #F7F6F3)` — so the page can re-ink a figure it did not render, and the same
+// figure standing alone still knows what it looks like.
+//
+// This module is INTERNAL. It is not part of the public API — the site reaches
+// it through the vendored render subgraph, and outside consumers have no
+// reason to draw in tonus's hand.
+/** The one ink. Everything black is this black. */
+export const INK = "#111";
+/** The liturgical red. Reserved for the CLAIM lines: the mode's in the
+ * tonarium, and — ruled 2026-08-11, amending the 07-29 reservation — the
+ * word's accent in the prosodia. The precedent is the score's own text
+ * apparatus: the dropcap and annotations have always been rubricated, and
+ * in the books red is the word's colour. Nothing else wears it. */
+export const RUBRICA = "#9E2B25";
+/** Stratum opacities: one ink, graded. The melody strata (wave, spark) sit
+ * under their annotations; a claim re-inks at full strength. */
+export const STRATUM = {
+    wave: 0.75, // the chironomy line — the gesture itself
+    spark: 0.45, // the tonarium melody — context, not message
+    cadence: 1.0, // the claim: the melody's ending, full ink
+    letters: 0.62, // Pierik letters
+    label: 0.9, // signature labels
+    bracket: 0.3, // the label's end-ticked tie
+    rail: 0.24, // the maneriae rails
+    margin: 0.38, // the "cad" margin word
+    block: 0.18, // the prosodia's melisma blocks — a soft fill, not a line
+    rule: 0.15, // the prosodia's single rule — quieter than a rail
+};
+/** Below this confidence nothing is drawn. Not faint — absent. */
+export const CONF_FLOOR = 0.45;
+/** THE nib — one pressure law: normalized velocity → stroke width. */
+export const nib = (vn) => 0.5 + 1.5 * vn;
+/** The stroke ladder. A diagram picks a rung; it does not invent a width.
+ * Named for what the line DOES, so the choice is about meaning, not weight. */
+export const STROKE = {
+    hair: 0.55, // rails, grids, graticules — structure you read past
+    fine: 0.75, // the common diagram line
+    firm: 1.05, // a line making a claim (the mode line's weight)
+    heavy: 1.5, // an axis, a frame, a boundary
+};
+/** The type scale, and it is THE PAGE'S: a modular scale on 15px stepped by
+ *  the Pythagorean minor third, 32:27 — the same six `--micro` … `--display-size`
+ *  that ../../../../docs/styles.css declares. So a wheel's label and a table's
+ *  label at the same step are the same size.
+ *
+ *  It was 9/11/13.5/17/21/26, derived from what the diagrams happened to use.
+ *  That was honest when the page had no scale of its own; once the page took
+ *  one, the two agreed on `title` alone and every drawn label sat 1.5–2px under
+ *  the prose around it. ../../../../scripts/vendor-ink.mjs asserts the pairing
+ *  now, so this cannot drift again silently.
+ *
+ *  Nothing inside tonus reads STEP — the site's diagrams are its only consumer
+ *  — so moving it changes no emitted SVG for a package consumer. */
+export const STEP = {
+    micro: 10.5, // superscripts, tick labels
+    caption: 12.5, // the workhorse — most diagram labels
+    label: 15, // named things
+    body: 18, // running text
+    title: 21, // a panel's name
+    display: 25, // the rare headline
+};
+/** The house faces. Junicode is the serif — the real face, not the Crimson Pro
+ * stand-in the early rounds carried; Plex Mono is the machine register. */
+export const HOUSE_SERIF = "Junicode, 'Crimson Pro', Georgia, serif";
+/* HOUSE_SANS is GONE. The house has three faces and each has a
+ * job: Junicode carries content and Latin, Plex Mono carries machine data,
+ * Jacquard is the wordmark. The sans stack named a fourth that no page loads,
+ * so every label reaching for it resolved to system-ui — SF Pro on macOS —
+ * and the wheels' names and the tracks' letters were set in it. Both now
+ * label in HOUSE_SERIF. Nothing should reintroduce a sans without a face to
+ * back it. */
+/** The machine register. IBM Plex Mono FIRST: the site loads and self-hosts
+ * that face, and with `ui-monospace` at the head of the stack every drawn
+ * label resolved to the system mono — SF Mono on macOS — beside page text in
+ * Plex. Two monospaces, same size, same column. */
+export const HOUSE_MONO = "'IBM Plex Mono', ui-monospace, Menlo, monospace";
+/** The fourth stack, and NOT a fourth face: neither text face carries the
+ *  planetary or musical signs (see fonts/README.md), so a figure that draws one
+ *  falls back to the system. Mirrors `--symbol` in ../../../../docs/styles.css
+ *  — the same sharing-by-numbers seam as HOUSE_SERIF and HOUSE_MONO, and it was duplicated
+ *  inline in mutatio.js as a local SIGN_FACE before this existed. */
+export const HOUSE_SYMBOL = "'Apple Symbols', 'Segoe UI Symbol', "
+    + "'Noto Sans Symbols2', " + HOUSE_SERIF;
+/** The figures a FIGURE sets: Junicode's own, which are OLDSTYLE by default —
+ *  they sit on the baseline with ascenders and descenders as lowercase letters
+ *  do, so a number reads as part of a line of text rather than standing off it.
+ *
+ *  `features` is empty on purpose, and that is the finding worth keeping: in
+ *  Junicode `zero` IS the oldstyle glyph and `zero.lf` is the lining variant,
+ *  so `onum` maps lining BACK to the default and does nothing unless `lnum` is
+ *  already on. Setting it here looked correct and changed no pixel — measured
+ *  identical advances, 423.2 either way. Reach for `lnum`/`tnum` when a column
+ *  of digits must line up; that is the setting that does work.
+ *
+ *  Nothing in the library's own emitters uses this yet. It lives here because
+ *  this file is the ONE definition of the ink system and the site vendors it
+ *  (../../../../scripts/vendor-ink.mjs) — a second copy in the site would be
+ *  the drift this module exists to prevent. */
+export const FIGURES = {
+    family: HOUSE_SERIF,
+    features: "",
+};
+/** A scaled measure, at most two places and no trailing zeros: 1.8, not 1.80. */
+export const sc = (v) => Number(v.toFixed(2)).toString();
+/** XML-escape a string for an SVG attribute or text node. */
+export const esc = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;");
+/** Sample one cubic Bézier segment (matches the generators' tessellation). */
+export function sampleCubic(p1, c1, c2, p2, steps) {
+    const out = [];
+    for (let k = 0; k < steps; k++) {
+        const t = k / steps;
+        const mt = 1 - t;
+        out.push([
+            mt ** 3 * p1[0] + 3 * mt * mt * t * c1[0] + 3 * mt * t * t * c2[0] + t ** 3 * p2[0],
+            mt ** 3 * p1[1] + 3 * mt * mt * t * c1[1] + 3 * mt * t * t * c2[1] + t ** 3 * p2[1],
+        ]);
+    }
+    return out;
+}
+/** Catmull–Rom through the points, sampled — the one curve idiom. */
+export function crSamples(pts, steps) {
+    if (pts.length < 2)
+        return [...pts];
+    const P = [pts[0], ...pts, pts[pts.length - 1]];
+    const out = [];
+    for (let i = 1; i < P.length - 2; i++) {
+        const [p0, p1, p2, p3] = [P[i - 1], P[i], P[i + 1], P[i + 2]];
+        const c1 = [p1[0] + (p2[0] - p0[0]) / 6, p1[1] + (p2[1] - p0[1]) / 6];
+        const c2 = [p2[0] - (p3[0] - p1[0]) / 6, p2[1] - (p3[1] - p1[1]) / 6];
+        out.push(...sampleCubic(p1, c1, c2, p2, steps));
+    }
+    out.push(pts[pts.length - 1]);
+    return out;
+}
+/** Piecewise-linear velocity read along x between anchors; the pressure signal
+ * every pressure-bearing line shares. Null velocities read 0.3. */
+export function velocityAt(velpts) {
+    return (x) => {
+        if (velpts.length === 0)
+            return 0.3;
+        if (x <= velpts[0][0])
+            return velpts[0][1];
+        if (x >= velpts[velpts.length - 1][0])
+            return velpts[velpts.length - 1][1];
+        for (let i = 0; i + 1 < velpts.length; i++) {
+            const [x0, v0] = velpts[i];
+            const [x1, v1] = velpts[i + 1];
+            if (x0 <= x && x <= x1)
+                return v0 + (v1 - v0) * ((x - x0) / Math.max(x1 - x0, 1e-6));
+        }
+        return 0.3;
+    };
+}
+/** The subject's own velocity ceiling — pressure normalizes per subject, not
+ * to a corpus constant (the plates' frozen 0.62 was a session artifact). */
+export function velocityCeiling(velocities) {
+    let vmax = 0;
+    for (const v of velocities)
+        if (v != null && v > vmax)
+            vmax = v;
+    return vmax > 0 ? vmax : 0.62;
+}
+/** A ribbon polygon around sampled points: THE nib at `scale`, velocity as
+ * width — the one pressure stroke everything draws with. */
+export function ribbonPath(samples, vat, vmax, scale) {
+    const top = [];
+    const bot = [];
+    const N = samples.length;
+    for (let i = 0; i < N; i++) {
+        const [x, y] = samples[i];
+        const [x0, y0] = samples[Math.max(i - 1, 0)];
+        const [x1, y1] = samples[Math.min(i + 1, N - 1)];
+        const dx = x1 - x0;
+        const dy = y1 - y0;
+        const L = Math.hypot(dx, dy) || 1;
+        const nx = -dy / L;
+        const ny = dx / L;
+        const vn = Math.min(vat(x) / vmax, 1);
+        const w = nib(vn) * scale;
+        top.push([x + (nx * w) / 2, y + (ny * w) / 2]);
+        bot.push([x - (nx * w) / 2, y - (ny * w) / 2]);
+    }
+    return "M " + top.map((p) => `${p[0].toFixed(1)} ${p[1].toFixed(1)}`).join(" L ") +
+        " L " + bot.reverse().map((p) => `${p[0].toFixed(1)} ${p[1].toFixed(1)}`).join(" L ") + " Z";
+}
+//# sourceMappingURL=atramentum.js.map

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

@@ -0,0 +1,62 @@
+import type { ChantTabulaRow } from "../tabula.js";
+/** What the caller knows at a candidate break point. */
+export interface BreakQuery {
+    /** The row that would OPEN the next system. */
+    next: ChantTabulaRow;
+    /** Cursor position, in svg user units. */
+    x: number;
+    /** Rightmost usable x — the line's width less padding and any line-end mark. */
+    boundary: number;
+    /**
+     * Width of what must fit before the next legal break point: a phrase for
+     * quadrata, a syllable for moderna. Measured by the caller, never estimated
+     * here.
+     */
+    need: number;
+    /**
+     * Width of the whole sealed run starting at `next`, when `next.keepWithPrev`
+     * is set — the caller measures to the end of the `<nlba>` group. Ignored
+     * otherwise.
+     */
+    sealedRun?: number;
+    /** Where a fresh system's cursor starts, for judging whether a run fits at all. */
+    lineStart: number;
+    /**
+     * 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.
+     */
+    forcedHandled?: boolean;
+}
+/** Why a system ended — carried so a caller can vary the line-end mark. */
+export type BreakReason = "forced" | "width" | "none";
+export interface BreakVerdict {
+    break: boolean;
+    reason: BreakReason;
+}
+/**
+ * Decide whether a system ends before `next`.
+ *
+ * The order is the precedence order, and it is the whole contract:
+ *
+ *   1. `z` — an instruction, not a preference. Nothing overrides it, including
+ *      a seal: an editor who wrote both meant both, and the break is the more
+ *      specific statement.
+ *   2. `<nlba>` — forbids a break, unless honouring it would push the sealed run
+ *      off the page. A seal is a preference about where a line ends; staying
+ *      inside the canvas is the stronger claim.
+ *   3. Width — the ordinary case.
+ */
+export declare function decideBreak(q: BreakQuery): BreakVerdict;
+/**
+ * Width of the sealed run beginning at `from`, by the caller's own measure.
+ *
+ * The head of a sealed group must be tested against the WHOLE group: admit the
+ * head alone and every seam after it is sealed, so the line can no longer break
+ * and the overflow is unrecoverable. Measured across the 35 Graduale chants that
+ * carry `<nlba>`, measuring one syllable instead of the run broke 37 seams.
+ */
+export declare function sealedRunWidth(rows: ChantTabulaRow[], from: number, widthOf: (index: number) => number): number;
+//# sourceMappingURL=breaking.d.ts.map