tonus 0.1.8 → 0.6.1

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