tonus 0.1.6 → 0.5.0

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

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

@@ -0,0 +1,80 @@
+// ---------------------------------------------------------------------------
+// engines/score/emitters/breaking — where a system ends, for both species
+// ---------------------------------------------------------------------------
+//
+// The two emitters break lines at different granularities — quadrata at a
+// divisio (and, since 2026-08-05, at a word), moderna between syllables — and
+// they draw different line-end marks (quadrata a custos, moderna none). Those
+// are real differences between the duae species, not accidents to unify.
+//
+// But the RULES governing a break are the same in both, and were written twice:
+//
+//   - `z` forces a break, outranking any width test        (the engraver's own)
+//   - `<nlba>` seals a seam and forbids one                 (the editor's own)
+//   - a seal yields when the sealed run cannot fit a line   (the page wins)
+//   - the usable width reserves the line-end mark           (never overrun it)
+//
+// Writing them twice is what shipped `<nlba>` working in quadrata and broken in
+// moderna on 2026-08-05: the fix went into the emitter I happened to patch
+// first, and only a sweep across both species caught it. This module is the
+// mechanism; each emitter keeps its own policy and its own drawing.
+//
+// Nothing here measures or draws. The caller supplies measurements — which is
+// what keeps tonus headless: the estimate lives in the emitter, the decision
+// lives here, and neither needs a DOM.
+const NO_BREAK = { break: false, reason: "none" };
+/**
+ * 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 function decideBreak(q) {
+    if (q.next.lineBreak && !q.forcedHandled)
+        return { break: true, reason: "forced" };
+    if (q.next.keepWithPrev) {
+        const run = q.sealedRun ?? q.need;
+        // A run that cannot fit a line of its own has nowhere better to go, so the
+        // seal yields rather than running off the canvas. Otherwise the seal holds:
+        // the break belongs before the group, and the caller finds it there.
+        const fitsAnyLine = q.lineStart + run <= q.boundary;
+        if (fitsAnyLine)
+            return NO_BREAK;
+    }
+    // Past the boundary already — break regardless of what comes next. This must
+    // 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.
+    if (q.x > q.boundary)
+        return { break: true, reason: "width" };
+    return q.x + q.need > q.boundary
+        ? { break: true, reason: "width" }
+        : NO_BREAK;
+}
+/**
+ * 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 function sealedRunWidth(rows, from, widthOf) {
+    let total = widthOf(from);
+    for (let i = from + 1; i < rows.length; i++) {
+        if (!rows[i].keepWithPrev)
+            break;
+        total += widthOf(i);
+    }
+    return total;
+}
+//# sourceMappingURL=breaking.js.map

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

@@ -0,0 +1,38 @@
+import type { SvgResult, SvgOpts } from "./svg.js";
+import type { ChantTabulaRow } from "../tabula.js";
+import type { Chant } from "../../chant/types.js";
+/** Every geometric constant, derived from the requested staff height. */
+export interface ModernaMetrics {
+    /** Staff space — the distance between two lines. */
+    MSP: number;
+    /** SMuFL glyph scale: 1 em = 4 staff spaces. */
+    SCALE: number;
+    /** Top staff line, system-local. */
+    MTOP: number;
+    /** noteheadBlack advance. */
+    NH_W: number;
+    /** Per-note advance inside a melisma. */
+    ADV: number;
+    /** Gap after each syllable. */
+    SYL_GAP: number;
+    /** Lyric baseline, system-local. */
+    LYRIC_Y: number;
+    /** The factor against the engraved metrics — 1 at the default. */
+    k: number;
+}
+/**
+ * Moderna's metrics for a requested staff height.
+ *
+ * Everything scales together, so the engraving's internal relationships —
+ * notehead to staff, slur to notehead, lyric to baseline — hold at any size;
+ * they were drawn as a set and stay one.
+ */
+export declare function metrics(staffHeight?: number): ModernaMetrics;
+type Row = ChantTabulaRow;
+/**
+ * Render the tabula as moderna. Multi-system when `width` is set; single system
+ * otherwise. Returns the shared { svg, geometry } contract.
+ */
+export declare function toModerna(rows: Row[], chant: Chant, options?: SvgOpts): SvgResult;
+export {};
+//# sourceMappingURL=moderna.d.ts.map