From d3b6aefbc731e6218c8212c30f6e30bea6156b23 Mon Sep 17 00:00:00 2001
From: Jared Johnson <jared@jaredjohnson.dev>
Date: Sun, 28 Jun 2026 13:02:57 -0400
Subject: [PATCH 1/4] conditionally debounce based on the last render time and
 add a reset all button

---
 site/src/App.tsx | 56 ++++++++++++++++++++++++++++++++++++++++++------
 1 file changed, 49 insertions(+), 7 deletions(-)

diff --git a/site/src/App.tsx b/site/src/App.tsx
index 39cba2fee..1967f97fd 100644
--- a/site/src/App.tsx
+++ b/site/src/App.tsx
@@ -95,9 +95,23 @@ export default function App() {
 	const width =
 		config.layout?.type === 'standard' ? (config.layout.width ?? 900) : 900;
 	const notationFont = config.fonts?.notation?.family ?? 'Bravura';
-	const reset = (
-		key: 'noteSpacing' | 'softmaxFactor' | 'systemSpacing' | 'maxSystemFill',
-	) => setConfig(({ [key]: _, ...rest }) => rest);
+	const resetKeys = [
+		'noteSpacing',
+		'softmaxFactor',
+		'systemSpacing',
+		'maxSystemFill',
+	] as const;
+	const reset = (key: (typeof resetKeys)[number]) =>
+		setConfig(({ [key]: _, ...rest }) => rest);
+	const canReset = resetKeys.some((k) => config[k] !== undefined);
+	const resetAll = () =>
+		setConfig((c) => {
+			const next = { ...c };
+			for (const k of resetKeys) {
+				delete next[k];
+			}
+			return next;
+		});
 
 	// `config` stays live so the sliders/reset respond instantly; `renderConfig` lags
 	// behind it by the debounce so dragging a slider re-renders once it settles, not on
@@ -109,13 +123,20 @@ export default function App() {
 			skipConfigDebounce.current = false;
 			return;
 		}
+		// If the last render was fast, apply config changes immediately; only debounce
+		// once renders get slow enough to lag the sliders.
+		if (renderMs != null && renderMs <= 50) {
+			setRenderConfig(config);
+			setDebouncing(false);
+			return;
+		}
 		setDebouncing(true);
 		const t = setTimeout(() => {
 			setRenderConfig(config);
 			setDebouncing(false);
 		}, 500);
 		return () => clearTimeout(t);
-	}, [config]);
+	}, [config, renderMs]);
 
 	useEffect(() => {
 		const canvas = canvasRef.current;
@@ -216,6 +237,13 @@ export default function App() {
 			setDebouncing(false);
 			return;
 		}
+		// If the last render was fast, just render on every keystroke; only debounce
+		// once renders get slow enough to lag typing.
+		if (renderMs != null && renderMs <= 50) {
+			setDebouncing(false);
+			setInput(value);
+			return;
+		}
 		// Spinner shows while we wait out the typing, then render the settled text.
 		setDebouncing(true);
 		debounceRef.current = setTimeout(() => {
@@ -369,9 +397,23 @@ export default function App() {
 						</button>
 
 						<div className="flex flex-col gap-4 rounded-lg border border-zinc-200 bg-zinc-50 p-3">
-							<span className="text-xs font-semibold uppercase tracking-wide text-zinc-500">
-								Config
-							</span>
+							<div className="flex items-center justify-between">
+								<span className="text-xs font-semibold uppercase tracking-wide text-zinc-500">
+									Config
+								</span>
+								<button
+									type="button"
+									onClick={resetAll}
+									disabled={!canReset}
+									className="text-xs font-medium text-zinc-400 hover:text-zinc-600 disabled:cursor-default disabled:text-zinc-300 disabled:hover:text-zinc-300"
+								>
+									Reset all
+								</button>
+							</div>
+							<p className="text-xs text-zinc-400">
+								With only a single system, some controls (e.g. system spacing
+								and max system fill) won't have a visible effect.
+							</p>
 							<label
 								htmlFor="darkMode"
 								className="flex items-center gap-2 text-xs font-medium text-zinc-500"

From 85bff93a167a79ce6cfac64b974c57ccdd4bfb42 Mon Sep 17 00:00:00 2001
From: Jared Johnson <jared@jaredjohnson.dev>
Date: Sun, 28 Jun 2026 13:34:51 -0400
Subject: [PATCH 2/4] add fillFirstSystem config and add spatial primitives to
 detect collisions

---
 .agents/skills/test-musicxml/SKILL.md         |  11 +
 docs/collision-audit.md                       |  70 ++++++
 src/collision.test.ts                         |  84 +++++++
 src/collision.ts                              | 154 ++++++++++++
 src/config.ts                                 |   6 +
 src/draw.ts                                   | 237 +++++++++++++-----
 src/geometry.test.ts                          |  48 ++++
 src/geometry.ts                               |  84 +++++++
 src/layout.ts                                 |   1 +
 src/quadtree.test.ts                          |  62 +++++
 src/quadtree.ts                               | 141 +++++++++++
 .../__screenshots__/fill_first_system_off.png | Bin 0 -> 12449 bytes
 .../__screenshots__/harmony_grace.png         | Bin 5497 -> 5501 bytes
 tests/integration/render.test.ts              |  16 +-
 14 files changed, 851 insertions(+), 63 deletions(-)
 create mode 100644 docs/collision-audit.md
 create mode 100644 src/collision.test.ts
 create mode 100644 src/collision.ts
 create mode 100644 src/geometry.test.ts
 create mode 100644 src/geometry.ts
 create mode 100644 src/quadtree.test.ts
 create mode 100644 src/quadtree.ts
 create mode 100644 tests/integration/__screenshots__/fill_first_system_off.png

diff --git a/.agents/skills/test-musicxml/SKILL.md b/.agents/skills/test-musicxml/SKILL.md
index adebd0c4d..c5203693d 100644
--- a/.agents/skills/test-musicxml/SKILL.md
+++ b/.agents/skills/test-musicxml/SKILL.md
@@ -53,6 +53,17 @@ Use this skill when adding or updating a `vexml` MusicXML rendering test case, e
 5. Update the implementation in `src/` to fill the rendering gap.
    - Prefer a minimal, root-cause fix.
    - Keep changes consistent with the existing renderer and test patterns.
+   - **Collisions must go through the collision pipeline.** When a fix involves moving an
+     element so it clears another (an above-stave annotation over a notehead/tie, a chord
+     diagram next to another, two annotations stacking) — or detecting that content is clipped
+     ("no-man's land") — route it through `CollisionDetector` (`src/collision.ts`):
+     register the fixed thing as an obstacle (`add`/`addRect`), resolve the movable thing
+     (`liftClear` to lift above-stave text, `pushRightOf` to space diagrams), then draw at the
+     resolved position and register it. Do **not** add new bespoke magic-offset clearance
+     logic. Not everything is movable — noteheads, stems, and ties are obstacles, not nudge
+     targets. Fixed structural placement (page margins, part spacing, bracket offsets,
+     widget-internal geometry) is exempt — it is deterministic, not clash resolution. See
+     `docs/collision-audit.md` for what is and isn't in scope.
 
 6. Run the test command again:
 
diff --git a/docs/collision-audit.md b/docs/collision-audit.md
new file mode 100644
index 000000000..25e791c02
--- /dev/null
+++ b/docs/collision-audit.md
@@ -0,0 +1,70 @@
+# Nudge / collision audit
+
+> **Caveat — not a maintained list.** This is a point-in-time snapshot taken while the
+> collision pipeline (`src/geometry.ts`, `src/quadtree.ts`, `src/collision.ts`) was introduced.
+> Line numbers and entries **will drift** as the code changes — treat it as a map, not a
+> source of truth. Re-audit (`rg`-style sweep for offset/clearance code) if you need current
+> data. It exists so the historical "where did we nudge things?" knowledge isn't lost.
+
+The renderer (`src/draw.ts`) draws to a `<canvas>` in immediate mode. Historically, every
+time two elements could clash, a one-off fix nudged one of them with its own magic constant —
+a whack-a-mole. The pipeline replaces the recurring class of those with one mechanism. This
+doc records what existed, split by whether the pipeline absorbs it.
+
+## How the pipeline works (the one true path)
+
+Compute a movable element's natural `Rect` → ask the `CollisionDetector` to resolve it against
+everything already placed (`liftClear` for above-stave text, `pushRightOf` for diagrams) →
+draw at the resolved position → register the placed `Rect` so later elements avoid it. Fixed
+elements (noteheads, stems, ties) are registered as obstacles but never moved. The detector
+also reports out-of-bounds content (`escaping`) — the "no-man's land" where renders get
+clipped. A `QuadTree` (with an out-of-bounds overflow bucket) is the spatial index.
+
+**Rule for future work:** any new "move this so it clears that" (or "is this being clipped?")
+goes through `CollisionDetector`. Do not add new bespoke magic-offset clearance code.
+
+## A. Recurring runtime clash resolution — the whack-a-mole
+
+| Site | What moves | Clears | Status |
+|---|---|---|---|
+| `draw.ts::noteTop` | (obstacle calc) notehead ∪ stem tip ∪ above-articulation | — | feeds `noteRect` |
+| `draw.ts::drawHarmony` | chord symbol lifts | notehead, stem-down tie apex, other text | **migrated** → `liftClear` |
+| `draw.ts::drawWords` | words text lifts | notehead, tie, other text | **migrated** → `liftClear` |
+| `draw.ts` chord-diagram block | fret box pushes right | adjacent diagram across a barline | **migrated** → `pushRightOf` |
+| `draw.ts::drawTempo` | metronome mark lifts (`shiftY`) | high first note | **deferred** (scaled mark + reserved headroom; Phase 2) |
+| chord diagram vertical | fixed `CHORD_DIAGRAM_GAP`, does **not** clear notes | (latent clip bug) | **deferred** (Phase 3) |
+
+The migration was behavior-preserving: the full screenshot suite was byte-identical except a
+1–2px improvement on `harmony_grace` (the symbol now also clears the grace note's stem tip).
+The new capabilities the pipeline enables but no fixture yet exercises: a wide symbol clearing
+a *neighbouring* tall note under its text, and stacking multiple annotations in one column.
+
+## B. Out-of-bounds / clip hazards ("no-man's land") — covered by `escaping`
+
+| Site | Hazard |
+|---|---|
+| `draw.ts` `pageTop`/`pageBottom` growth | crop grown ad hoc so content isn't clipped |
+| `constants.ts::LEDGER_HEADROOM`, `draw.ts` `topSlack` | scratch slack; "bump if an extreme tessitura ever clips" |
+| `draw.ts` system-overflow two-pass (`topOverflow`) | reserves vertical space so stacked systems don't collide |
+
+`CollisionDetector.escaping(scratchViewport)` now flags vertical clips per system and warns
+(see `warnEscapes` in `draw.ts`). The existing `pageTop`/`pageBottom` crop logic is unchanged —
+`escaping` is the generic home for clip handling going forward, the two-pass overflow could
+fold into it later.
+
+## C. Fixed structural placement — left alone (NOT collisions)
+
+These are deterministic engraving placement, not runtime clash resolution. Routing them through
+the detector would add indirection for no benefit. Documented so future work doesn't "migrate"
+them by mistake:
+
+- Page margins (`PAGE_MARGIN_*`), `INTER/INTRA_PART_SPACING`, `BASE_VOICE_WIDTH`.
+- Lead-glyph width estimates (`LEAD_BARLINE/CLEF/KEY/TIME`) — generous reservations so notes
+  never collide with clef/key/time glyphs.
+- `LABEL_GAP` / part-label centering (`+1.5`), `BRACKET_X_SHIFT` (bracket sits just outside the
+  system line, `draw.ts` bracket blocks).
+- Tab note-area centering, tab grace alignment, `GRACE_SPACING` pre-reservation (`layout.ts`).
+- Chord-diagram-internal geometry (`barShiftX`, `bridgeWidth`, title/dot/barre positions in
+  `chord-diagram.ts`).
+- Tab fret / harmonic-bracket centering (`notes.ts` `boldFret`/harmonic layout).
+- Analytic slur control-point lift (`spanners.ts` `cpYFor`), wrapped tie/slur split.
diff --git a/src/collision.test.ts b/src/collision.test.ts
new file mode 100644
index 000000000..8d6ac4dc4
--- /dev/null
+++ b/src/collision.test.ts
@@ -0,0 +1,84 @@
+import { expect, test } from 'bun:test';
+import { CollisionDetector } from './collision';
+import { Rect } from './geometry';
+
+function detector(): CollisionDetector {
+	return new CollisionDetector(new Rect(-1000, -1000, 4000, 4000));
+}
+
+test('query reports the kind and minimum-translation of each hit', () => {
+	const d = detector();
+	d.addRect(new Rect(5, 0, 10, 10), 'note');
+	const hits = d.query(new Rect(0, 0, 10, 10));
+	expect(hits).toHaveLength(1);
+	expect(hits[0]?.other.kind).toBe('note');
+	// Overlap is 5 wide, 10 tall → separate along x, leftward (candidate is left of note).
+	expect(hits[0]?.mtv.axis).toBe('x');
+	expect(hits[0]?.mtv.dx).toBe(-5);
+});
+
+test('liftClear raises a rect to sit `gap` above the highest obstacle in its column', () => {
+	const d = detector();
+	d.addRect(new Rect(5, 90, 10, 30), 'note'); // top at y=90
+	d.addRect(new Rect(5, 70, 10, 5), 'tie'); // higher: top at y=70 (kind-agnostic)
+	const natural = new Rect(0, 85, 20, 15); // bottom at y=100, overlaps both
+	const placed = d.liftClear(natural, 8);
+	expect(placed.bottom).toBe(62); // 70 (highest top) - 8 gap
+	expect(placed.x).toBe(0); // x unchanged — text only lifts vertically
+});
+
+test('liftClear never lowers a rect that is already clear', () => {
+	const d = detector();
+	d.addRect(new Rect(5, 200, 10, 30), 'note'); // well below the annotation
+	const natural = new Rect(0, 85, 20, 15); // bottom at y=100
+	expect(d.liftClear(natural, 8)).toBe(natural); // returned unchanged
+});
+
+test('liftClear stacks successive annotations above one another', () => {
+	const d = detector();
+	d.addRect(new Rect(5, 90, 10, 30), 'note');
+	const a = d.liftClear(new Rect(0, 85, 20, 15), 8); // bottom 82
+	d.add({ rect: a, kind: 'annotation' });
+	const b = d.liftClear(new Rect(0, 85, 20, 15), 8); // must clear `a`, not the note
+	expect(b.bottom).toBe(a.y - 8); // a.y is a's top
+});
+
+test('liftClear with a kind filter ignores other kinds (text clears notes, not diagrams)', () => {
+	const d = detector();
+	d.addRect(new Rect(5, 90, 10, 30), 'note'); // top at y=90
+	d.addRect(new Rect(0, 70, 20, 5), 'diagram'); // higher, but a diagram
+	const natural = new Rect(0, 85, 20, 15); // bottom at y=100
+	// Clearing only note/tie/annotation: lifts to clear the note (90), not the diagram (70).
+	const placed = d.liftClear(natural, 8, ['note', 'tie', 'annotation']);
+	expect(placed.bottom).toBe(82); // 90 - 8, the diagram was ignored
+});
+
+test('pushRightOf reproduces the chord-diagram running-cursor (gap enforced even when close)', () => {
+	const d = detector();
+	d.addRect(new Rect(0, 0, 88, 84), 'diagram'); // right edge at x=88
+	// Overlapping neighbour → pushed to 88 + 6.
+	expect(d.pushRightOf(new Rect(50, 0, 88, 84), 'diagram', 6).x).toBe(94);
+	// Close but not overlapping (90 > 88) → gap still enforced to 94.
+	expect(d.pushRightOf(new Rect(90, 0, 88, 84), 'diagram', 6).x).toBe(94);
+	// Far enough away → left where it is.
+	expect(d.pushRightOf(new Rect(200, 0, 88, 84), 'diagram', 6).x).toBe(200);
+});
+
+test('pushRightOf ignores diagrams in a different vertical band', () => {
+	const d = detector();
+	d.addRect(new Rect(0, 0, 88, 84), 'diagram');
+	// Same x-range but a different stave (y far below) → no horizontal push.
+	expect(d.pushRightOf(new Rect(50, 500, 88, 84), 'diagram', 6).x).toBe(50);
+});
+
+test('escaping flags rects that cross the viewport edges', () => {
+	const d = detector();
+	d.addRect(new Rect(10, 10, 5, 5), 'note'); // inside
+	d.addRect(new Rect(10, -20, 5, 5), 'annotation'); // off the top
+	d.addRect(new Rect(95, 10, 20, 5), 'diagram'); // off the right
+	const escaped = d.escaping(new Rect(0, 0, 100, 100));
+	const byKind = new Map(escaped.map((e) => [e.item.kind, e.edges]));
+	expect(byKind.size).toBe(2);
+	expect(byKind.get('annotation')).toEqual(['top']);
+	expect(byKind.get('diagram')).toEqual(['right']);
+});
diff --git a/src/collision.ts b/src/collision.ts
new file mode 100644
index 000000000..50feebbb6
--- /dev/null
+++ b/src/collision.ts
@@ -0,0 +1,154 @@
+import { Rect } from './geometry';
+import { QuadTree } from './quadtree';
+
+/*
+ * Generic collision detection + nudge resolution for the renderer.
+ *
+ * The renderer draws in immediate mode, so the ONLY way to resolve a clash is to position a
+ * movable element before it's drawn. The flow per element is: compute its natural Rect, ask
+ * the detector to resolve it against everything already placed, draw at the resolved
+ * position, then register the placed Rect so later elements avoid it in turn.
+ *
+ * Not everything is movable. Register fixed things (noteheads, stems, ties) as obstacles;
+ * only nudge the things that can yield (chord symbols, words, chord diagrams). The detector
+ * reports the TYPE of each collision — the other element's `kind` plus the axis/direction of
+ * the minimum separation (`mtv`) — so a caller can pick the right fix. The constrained
+ * resolvers below (`liftClear`, `pushRightOf`) encode the per-kind policy directly: text
+ * only ever lifts up, diagrams only push right, so a raw minimum-translation can't shove a
+ * chord symbol sideways off the note it labels.
+ *
+ * ANY new "move this so it clears that" logic should go through here — do not add new bespoke
+ * magic-offset clearance code. See docs/collision-audit.md.
+ */
+
+export type CollisionKind = 'note' | 'tie' | 'annotation' | 'diagram';
+export type Collidable = { rect: Rect; kind: CollisionKind };
+export type Axis = 'x' | 'y';
+export type Edge = 'top' | 'bottom' | 'left' | 'right';
+
+/* One detected collision. `other.kind` + `mtv.axis` are "the type of collision". */
+export type Collision = {
+	other: Collidable;
+	overlap: Rect;
+	/* Signed minimum translation (along the smaller-overlap axis) to separate FROM `other`. */
+	mtv: { axis: Axis; dx: number; dy: number };
+};
+
+// Finite sentinel for half-open probe rects (avoids Infinity arithmetic producing NaN).
+const FAR = 1e6;
+
+export class CollisionDetector {
+	private readonly tree: QuadTree<Collidable>;
+
+	constructor(bounds: Rect, maxItems = 8, maxDepth = 8) {
+		this.tree = new QuadTree<Collidable>(bounds, maxItems, maxDepth);
+	}
+
+	add(c: Collidable): void {
+		this.tree.insert(c);
+	}
+
+	addRect(rect: Rect, kind: CollisionKind): void {
+		this.tree.insert({ rect, kind });
+	}
+
+	clear(): void {
+		this.tree.clear();
+	}
+
+	/* Every registered obstacle the candidate strictly overlaps, with kind + overlap + MTV. */
+	query(candidate: Rect): Collision[] {
+		const out: Collision[] = [];
+		for (const other of this.tree.query(candidate)) {
+			const overlap = candidate.intersection(other.rect);
+			if (!overlap) {
+				continue;
+			}
+			out.push({ other, overlap, mtv: mtvOf(candidate, other.rect, overlap) });
+		}
+		return out;
+	}
+
+	/*
+	 * Move `rect` straight UP until its bottom sits `gap` above the highest obstacle sharing
+	 * its x-column; never moves it down. One-shot: probe the whole column above the rect's
+	 * bottom and take the single highest obstacle top, so it converges immediately and can't
+	 * oscillate. This is the unified form of the old per-annotation "clear noteTop" lifts.
+	 *
+	 * `kinds`, when given, restricts which obstacle kinds count — e.g. above-stave text
+	 * clears notes/ties/other text but deliberately ignores diagrams (which draw on top).
+	 */
+	liftClear(rect: Rect, gap: number, kinds?: CollisionKind[]): Rect {
+		// A tall, thin probe down the rect's x-column, ending at the rect's bottom: catches
+		// every obstacle in the column whose top is at/above where the rect currently sits.
+		const probe = new Rect(rect.x, -FAR, rect.w, FAR + rect.bottom);
+		let topMost = Infinity;
+		for (const c of this.query(probe)) {
+			if (kinds && !kinds.includes(c.other.kind)) {
+				continue;
+			}
+			topMost = Math.min(topMost, c.other.rect.y);
+		}
+		if (topMost === Infinity) {
+			return rect;
+		}
+		const targetBottom = Math.min(rect.bottom, topMost - gap);
+		return rect.translate(0, targetBottom - rect.bottom);
+	}
+
+	/*
+	 * Push `rect` right until it sits `gap` past every already-placed obstacle of `kind` in
+	 * its y-band. Enforces the gap against a neighbor that's merely close (not yet
+	 * overlapping), reproducing the running-cursor spacing chord diagrams used.
+	 */
+	pushRightOf(rect: Rect, kind: CollisionKind, gap: number): Rect {
+		// Span everything from far left up to the rect's right edge, within its y-band.
+		const probe = new Rect(-FAR, rect.y, FAR + rect.right, rect.h);
+		let targetX = rect.x;
+		for (const c of this.query(probe)) {
+			if (c.other.kind === kind) {
+				targetX = Math.max(targetX, c.other.rect.right + gap);
+			}
+		}
+		return rect.translate(targetX - rect.x, 0);
+	}
+
+	/*
+	 * Registered items that escape `viewport` (the rendered/crop rectangle), with which edges
+	 * they cross — the "no-man's land" where content gets clipped. The caller decides whether
+	 * to grow the crop or lift the element. Independent of element-vs-element overlap.
+	 */
+	escaping(viewport: Rect): { item: Collidable; edges: Edge[] }[] {
+		const out: { item: Collidable; edges: Edge[] }[] = [];
+		for (const item of this.tree.all()) {
+			if (viewport.contains(item.rect)) {
+				continue;
+			}
+			const edges: Edge[] = [];
+			if (item.rect.y < viewport.y) {
+				edges.push('top');
+			}
+			if (item.rect.bottom > viewport.bottom) {
+				edges.push('bottom');
+			}
+			if (item.rect.x < viewport.x) {
+				edges.push('left');
+			}
+			if (item.rect.right > viewport.right) {
+				edges.push('right');
+			}
+			out.push({ item, edges });
+		}
+		return out;
+	}
+}
+
+/* Smallest push to separate `a` from `b`: along whichever axis they overlap least, away
+ * from `b`'s center. */
+function mtvOf(a: Rect, b: Rect, overlap: Rect): Collision['mtv'] {
+	const signX = a.x + a.w / 2 < b.x + b.w / 2 ? -1 : 1;
+	const signY = a.y + a.h / 2 < b.y + b.h / 2 ? -1 : 1;
+	return overlap.w <= overlap.h
+		? { axis: 'x', dx: signX * overlap.w, dy: 0 }
+		: { axis: 'y', dx: 0, dy: signY * overlap.h };
+}
diff --git a/src/config.ts b/src/config.ts
index 113668497..5172dacdd 100644
--- a/src/config.ts
+++ b/src/config.ts
@@ -45,6 +45,11 @@ export type Config = {
 	 * nearly-full last system snaps flush instead of leaving an awkward sliver of margin.
 	 * 0 always stretches, 1 never does. */
 	minLastSystemFill: number;
+	/** Whether the first system is justified to the reference width (default: true). When
+	 * false the first system stays ragged at its intrinsic width, like a short trailing
+	 * line — useful for incipits or single-line excerpts that shouldn't stretch to the page
+	 * edge. Other systems still justify per maxSystemFill/minLastSystemFill. */
+	fillFirstSystem: boolean;
 	/** Fraction (0–1) of the reference width a system may fill before the breaker bumps
 	 * the next measure to a new system (default: 0.9). Lower leaves more air; 1 packs each
 	 * system to the edge (the old greedy behavior). Only affects near-full systems — a line
@@ -72,6 +77,7 @@ export const DEFAULT_CONFIG: Config = {
 	measureNumbering: 'system',
 	showTabHammerPullText: false,
 	showTabSlideText: false,
+	fillFirstSystem: true,
 	minLastSystemFill: 0.75,
 	maxSystemFill: 0.9,
 };
diff --git a/src/draw.ts b/src/draw.ts
index c0ebfc32f..5a1474b31 100644
--- a/src/draw.ts
+++ b/src/draw.ts
@@ -24,6 +24,7 @@ import {
 	type Voice,
 } from 'vexflow';
 import { ChordDiagram, type ChordSpec } from './chord-diagram';
+import { CollisionDetector, type CollisionKind } from './collision';
 import type { Config } from './config';
 import {
 	BRACKET_X_SHIFT,
@@ -47,6 +48,7 @@ import {
 	WORDS_NOTE_CLEARANCE,
 	WORDS_Y_OFFSET,
 } from './constants';
+import { Rect } from './geometry';
 import type { MeasureNumbering, ScoreLayout } from './layout';
 import {
 	endBeatOf,
@@ -172,6 +174,9 @@ type PendingStave = {
 	tuplets: ReturnType<typeof buildTuplets>;
 	// Real notes only (no gap-filling ghosts), for the bottom-bound calc.
 	staveNotes: StaveNote[];
+	// StaveNotes whose lead carries a tie — they get a tie-apex collision obstacle once their
+	// stem direction is final (stem-down ties bow up over the noteheads). See tieApexRect.
+	tiedNotes: Set<StaveNote>;
 };
 
 /*
@@ -193,6 +198,7 @@ function buildNotes(
 	// ghosts instead of jamming its last note against the end barline.
 	const endBeat = Math.max(endBeatOf(voices), meterFloor);
 	const staveNotes: StaveNote[] = [];
+	const tiedNotes = new Set<StaveNote>();
 	const vexVoices = voices.map((voice) => {
 		const tickables = vexflowVoiceTickables(
 			voice.chords,
@@ -201,6 +207,9 @@ function buildNotes(
 			(lead, note) => {
 				byLead.set(lead, note);
 				staveNotes.push(note);
+				if (lead.ties.length > 0) {
+					tiedNotes.add(note);
+				}
 			},
 		);
 		return softVoice(tickables, softmaxFactor);
@@ -214,7 +223,15 @@ function buildNotes(
 	);
 	const tuplets = voices.flatMap((v) => buildTuplets(v.chords, byLead));
 
-	return { stave, isTab: false, vexVoices, beams, tuplets, staveNotes };
+	return {
+		stave,
+		isTab: false,
+		vexVoices,
+		beams,
+		tuplets,
+		staveNotes,
+		tiedNotes,
+	};
 }
 
 /*
@@ -245,6 +262,41 @@ function noteTop(note: StaveNote): number {
 	return top;
 }
 
+// Above-stave text (chord symbols, words) clears notes, ties, and other placed text, but NOT
+// chord diagrams — a diagram deliberately draws on top of any text it shares a spot with. All
+// nudge logic funnels through the CollisionDetector; see docs/collision-audit.md.
+const TEXT_CLEAR_KINDS: CollisionKind[] = ['note', 'tie', 'annotation'];
+
+/*
+ * The collision obstacle for a note: a box from its top (noteTop — notehead ∪ beam-extended
+ * stem tip ∪ above articulations) down to its bottom notehead, one notehead wide, centered on
+ * its laid-out x. Deliberately built from noteTop/getNoteHeadBounds, NOT note.getBoundingBox()
+ * (which unions attached modifiers and reports a bogus near-origin y for grace groups).
+ */
+function noteRect(note: StaveNote): Rect {
+	const top = noteTop(note);
+	const bottom = note.getNoteHeadBounds().yBottom;
+	const hw = getNoteheadHalfWidth();
+	return new Rect(note.getAbsoluteX() - hw, top, 2 * hw, bottom - top);
+}
+
+/*
+ * The collision obstacle for a stem-down note's tie: the band the tie ribbon bows up into,
+ * from its reconstructed apex (TIE_APEX_RISE above the top notehead) down to that notehead.
+ * The tie is a separate spanner drawn later, so there's no glyph to measure — this lets an
+ * annotation clear the arc the same way it clears a notehead.
+ */
+function tieApexRect(note: StaveNote): Rect {
+	const headTop = Math.min(...note.getYs());
+	const hw = getNoteheadHalfWidth();
+	return new Rect(
+		note.getAbsoluteX() - hw,
+		headTop - TIE_APEX_RISE,
+		2 * hw,
+		TIE_APEX_RISE,
+	);
+}
+
 /*
  * Format a system's staves together and draw their notes. A note's absolute x is its
  * (shared) tick-context x plus its own stave's note-start x, so two things must hold
@@ -258,6 +310,7 @@ function formatAndDrawSystem(
 	context: RenderContext,
 	pending: PendingStave[],
 	softmaxFactor: number,
+	detector: CollisionDetector,
 ): { top: number; bottom: number } {
 	if (pending.length === 0) {
 		return { top: Infinity, bottom: 0 };
@@ -341,6 +394,12 @@ function formatAndDrawSystem(
 			const box = note.getBoundingBox();
 			bottom = Math.max(bottom, box.getY() + box.getH());
 			top = Math.min(top, noteTop(note));
+			// Register each note as a collision obstacle now that its position is final, so the
+			// above-stave annotations drawn next can be nudged clear of it (and of high ties).
+			detector.add({ rect: noteRect(note), kind: 'note' });
+			if (p.tiedNotes.has(note) && note.getStemDirection() === Stem.DOWN) {
+				detector.add({ rect: tieApexRect(note), kind: 'tie' });
+			}
 		}
 	}
 	return { top, bottom };
@@ -403,53 +462,68 @@ const HARMONY_ACCIDENTAL_KERN = 2.5;
 const HARMONY_ACCIDENTAL_FONT_SIZE = HARMONY_FONT_SIZE - 3;
 
 /*
- * Draw a chord symbol (from a <harmony>) above its note's stave, left-anchored at
- * the note's x — the laid-out position of the note the harmony applies to. Returns
- * the y the text reaches up to so the caller can grow the page crop to keep a margin
- * above it (drawTempo relies on reserved layout headroom instead; harmony feeds the
- * crop directly so no extra top margin is needed). Drawn after the notes are
- * formatted so getAbsoluteX is real.
+ * The total kerned advance of a chord symbol as drawHarmony draws it: accidentals render a
+ * touch smaller and pull in by HARMONY_ACCIDENTAL_KERN on each side. Measured so the symbol's
+ * collision box matches the glyphs that get drawn.
+ */
+function harmonyWidth(
+	context: RenderContext,
+	text: string,
+	font: string,
+): number {
+	let width = 0;
+	for (const ch of text) {
+		const accidental = HARMONY_ACCIDENTALS.has(ch);
+		context.setFont(
+			font,
+			accidental ? HARMONY_ACCIDENTAL_FONT_SIZE : HARMONY_FONT_SIZE,
+		);
+		width +=
+			context.measureText(ch).width -
+			(accidental ? 2 * HARMONY_ACCIDENTAL_KERN : 0);
+	}
+	return width;
+}
+
+/*
+ * Draw a chord symbol (from a <harmony>) above its note's stave, left-anchored at the note's
+ * x — the laid-out position of the note the harmony applies to. The collision detector lifts
+ * it clear of any notehead, high tie, or already-placed annotation it would land on (all
+ * registered as obstacles); it sits at a fixed gap above the top staff line when nothing is in
+ * the way. Returns the y the text reaches up to so the caller can grow the page crop above it.
+ * Drawn after the notes are formatted so getAbsoluteX is real.
  */
 function drawHarmony(
 	context: RenderContext,
 	staveNote: StaveNote,
 	text: string,
 	font: string,
-	hasTie: boolean,
+	detector: CollisionDetector,
 ): number {
 	const stave = staveNote.getStave();
 	if (!stave) {
 		return Infinity;
 	}
-	// Sit a fixed gap above the top staff line, but lift higher when the note rises into
-	// that band (a high note or its ledger lines) so the symbol clears the notehead. Uses
-	// noteTop, not the bounding box: an attached grace-note group makes the box report a
-	// bogus near-origin y, which would fling the symbol to the top of the page and defeat
-	// the top crop (leaving a huge blank margin above the first system).
 	const baseY = stave.getYForLine(0) - HARMONY_Y_OFFSET;
-	let noteClearY = noteTop(staveNote) - HARMONY_NOTE_CLEARANCE;
-	// A stem-down note's tie bows up over the noteheads (vexflow bows a single note's, and
-	// a chord's upper, tie opposite the stem), peaking past what noteTop sees. The tie is a
-	// separate spanner drawn later — there's no glyph to measure here — so reconstruct its
-	// apex from the top notehead center (a constant rise, independent of tie length) and
-	// clear that too, otherwise the symbol lands on the arc. Gate on the apex itself rising
-	// above where the symbol would otherwise sit (baseY): only then does the tie actually
-	// pass through the text. A low note's tie — including a long tie whose far-right apex
-	// stays below the baseline — sits clear of the symbol, so leave it at baseY.
-	if (hasTie && staveNote.getStemDirection() === Stem.DOWN) {
-		const tieApexY = Math.min(...staveNote.getYs()) - TIE_APEX_RISE;
-		if (tieApexY < baseY) {
-			noteClearY = Math.min(noteClearY, tieApexY - HARMONY_NOTE_CLEARANCE);
-		}
-	}
-	const y = Math.min(baseY, noteClearY);
 	context.save();
-	context.setFont(font, HARMONY_FONT_SIZE);
 	context.setFillStyle('#000000');
+	const natural = new Rect(
+		staveNote.getAbsoluteX(),
+		baseY - HARMONY_FONT_SIZE,
+		harmonyWidth(context, text, font),
+		HARMONY_FONT_SIZE,
+	);
+	const placed = detector.liftClear(
+		natural,
+		HARMONY_NOTE_CLEARANCE,
+		TEXT_CLEAR_KINDS,
+	);
+	const y = placed.bottom;
 	// The ♯/♭/♮ glyphs carry wide side-bearings in the text font, so a single fillText
 	// of "B♭" reads as "B ♭". Draw char by char and pull the accidental in on both sides
 	// so it sits tight against its root letter.
-	let x = staveNote.getAbsoluteX();
+	context.setFont(font, HARMONY_FONT_SIZE);
+	let x = placed.x;
 	for (const ch of text) {
 		const accidental = HARMONY_ACCIDENTALS.has(ch);
 		if (accidental) {
@@ -464,17 +538,17 @@ function drawHarmony(
 		}
 	}
 	context.restore();
-	return y - HARMONY_FONT_SIZE;
+	// Register the placed symbol so a later annotation in this system stacks above it.
+	detector.add({ rect: placed, kind: 'annotation' });
+	return placed.y;
 }
 
 /*
  * Draw a words direction (e.g. "ritardando") above the stave in italics, left-anchored at
- * the first note's x — where the directive applies. Sits a fixed gap above the top staff
- * line, but lifts higher when the first note rises into that band (a high note or its ledger
- * lines) so the text clears the notehead. Returns the y the text reaches up to so the caller
- * can grow the page crop above it (like drawHarmony). Drawn after the notes are formatted so
- * getAbsoluteX is real. Uses noteTop, not the bounding box, to clear the note: an attached
- * grace-note group makes the box report a bogus near-origin y.
+ * the first note's x — where the directive applies. The collision detector lifts it clear of
+ * any notehead/tie/annotation it would land on; it sits at a fixed gap above the top staff
+ * line otherwise. Returns the y the text reaches up to so the caller can grow the page crop
+ * above it (like drawHarmony). Drawn after the notes are formatted so getAbsoluteX is real.
  */
 function drawWords(
 	context: RenderContext,
@@ -482,19 +556,28 @@ function drawWords(
 	text: string,
 	firstNote: StaveNote | undefined,
 	font: string,
+	detector: CollisionDetector,
 ): number {
 	const baseY = stave.getYForLine(0) - WORDS_Y_OFFSET;
-	const noteClearY = firstNote
-		? noteTop(firstNote) - WORDS_NOTE_CLEARANCE
-		: baseY;
-	const y = Math.min(baseY, noteClearY);
 	const x = firstNote ? firstNote.getAbsoluteX() : stave.getNoteStartX();
 	context.save();
 	context.setFont(font, WORDS_FONT_SIZE, 'normal', 'italic');
 	context.setFillStyle('#000000');
-	context.fillText(text, x, y);
+	const natural = new Rect(
+		x,
+		baseY - WORDS_FONT_SIZE,
+		context.measureText(text).width,
+		WORDS_FONT_SIZE,
+	);
+	const placed = detector.liftClear(
+		natural,
+		WORDS_NOTE_CLEARANCE,
+		TEXT_CLEAR_KINDS,
+	);
+	context.fillText(text, placed.x, placed.bottom);
 	context.restore();
-	return y - WORDS_FONT_SIZE;
+	detector.add({ rect: placed, kind: 'annotation' });
+	return placed.y;
 }
 
 /*
@@ -534,6 +617,7 @@ function buildTabNotes(
 		beams: [],
 		tuplets: [],
 		staveNotes: [],
+		tiedNotes: new Set(),
 	};
 }
 
@@ -776,10 +860,28 @@ export function drawScore(
 		let systemTopY = layout.top + topSlack;
 		let systemContentBottom = systemTopY;
 		let currentSystem = -1;
-		// The right edge (+ gap) of the last chord diagram drawn in the current system, so a
-		// diagram near a barline can be pushed clear of the one before it across the measure
-		// boundary. Reset when a new system starts (x coordinates restart at the left).
-		let prevDiagramRight = -Infinity;
+		// Per-system collision index of everything already drawn (notes, high ties, placed
+		// chord symbols/words/diagrams). The above-stave annotations query it to nudge clear of
+		// obstacles, and chord diagrams use it to space apart across a barline (replacing an old
+		// running-cursor). Reset at each system start (x/y restart) — see the system-change
+		// block. ALL nudge logic funnels through here; see docs/collision-audit.md.
+		const detector = new CollisionDetector(
+			new Rect(0, 0, width, scratchHeight),
+		);
+		// The drawable region of the scratch canvas. Anything escaping it is in "no-man's land"
+		// and gets clipped, so warn — the slack that prevents this (LEDGER_HEADROOM/topSlack)
+		// is then the knob to grow. Vertical edges only; horizontal page overflow is separate.
+		const scratchViewport = new Rect(0, 0, width, scratchHeight);
+		const warnEscapes = () => {
+			for (const { item, edges } of detector.escaping(scratchViewport)) {
+				if (edges.includes('top') || edges.includes('bottom')) {
+					console.warn(
+						`vexml: ${item.kind} clipped past the ${edges.join('/')} of the canvas ` +
+							"(content in no-man's land — bump LEDGER_HEADROOM / topSlack).",
+					);
+				}
+			}
+		};
 		// Per system: the stave-top y it was placed at, and the highest (smallest) y any of
 		// its content reached. Their difference is how far the system overflows above its
 		// top stave — reserved above it on a redraw so it can't clash with the system above.
@@ -819,7 +921,10 @@ export function drawScore(
 				currentSystem = systemIndex;
 				systemContentBottom = systemTopY;
 				systemTopByIndex.set(systemIndex, systemTopY);
-				prevDiagramRight = -Infinity;
+				// Leaving the previous system: flag anything that escaped the canvas, then reset
+				// the collision index so the new system (coordinates restart) starts clean.
+				warnEscapes();
+				detector.clear();
 			}
 			const systemY = systemTopY;
 			let staveRow = 0;
@@ -841,7 +946,6 @@ export function drawScore(
 			const harmonyTasks: Array<{
 				staveNote: StaveNote;
 				text: string;
-				hasTie: boolean;
 				frame: ChordSpec | null;
 			}> = [];
 			// Words directions (e.g. "ritardando"), each drawn above its part's top stave at
@@ -1034,7 +1138,6 @@ export function drawScore(
 						harmonyTasks.push({
 							staveNote,
 							text,
-							hasTie: lead.ties.length > 0,
 							frame,
 						});
 					}
@@ -1127,6 +1230,7 @@ export function drawScore(
 				context,
 				systemPending,
 				softmaxFactor,
+				detector,
 			);
 			pageBottom = Math.max(pageBottom, noteExtent.bottom);
 			systemContentBottom = Math.max(systemContentBottom, noteExtent.bottom);
@@ -1148,13 +1252,13 @@ export function drawScore(
 			for (const w of wordsTasks) {
 				pageTop = Math.min(
 					pageTop,
-					drawWords(context, w.stave, w.text, w.firstNote, labelFont),
+					drawWords(context, w.stave, w.text, w.firstNote, labelFont, detector),
 				);
 			}
-			// Diagrams sit at their lead note's x; two on notes either side of a barline can
-			// be close enough to overlap (especially at a narrow width). Push each box's left
-			// edge past the previous diagram's right edge + a gap (tracked across measures in
-			// prevDiagramRight) so crowded diagrams separate instead of stacking.
+			// Diagrams sit at their lead note's x; two on notes either side of a barline can be
+			// close enough to overlap (especially at a narrow width). The detector pushes each
+			// box clear of any already-placed diagram in its band (replacing the old running
+			// cursor) so crowded diagrams separate instead of stacking.
 			for (const h of harmonyTasks) {
 				// A <harmony> with a <frame> draws as a fret box (chord name as its title)
 				// above the stave; one without draws as the plain chord-symbol text.
@@ -1168,9 +1272,19 @@ export function drawScore(
 						...h.frame.chord.map(([, f]) => (typeof f === 'number' ? f : 0)),
 						...(h.frame.barres ?? []).map((b) => b.fret),
 					];
-					const x = Math.max(h.staveNote.getAbsoluteX(), prevDiagramRight);
-					prevDiagramRight = x + CHORD_DIAGRAM_WIDTH + CHORD_DIAGRAM_GAP;
-					const diagram = new ChordDiagram(x, top, {
+					const natural = new Rect(
+						h.staveNote.getAbsoluteX(),
+						top,
+						CHORD_DIAGRAM_WIDTH,
+						CHORD_DIAGRAM_HEIGHT,
+					);
+					const placed = detector.pushRightOf(
+						natural,
+						'diagram',
+						CHORD_DIAGRAM_GAP,
+					);
+					detector.add({ rect: placed, kind: 'diagram' });
+					const diagram = new ChordDiagram(placed.x, top, {
 						width: CHORD_DIAGRAM_WIDTH,
 						height: CHORD_DIAGRAM_HEIGHT,
 						numStrings: h.frame.chord.length,
@@ -1193,7 +1307,7 @@ export function drawScore(
 				} else {
 					pageTop = Math.min(
 						pageTop,
-						drawHarmony(context, h.staveNote, h.text, labelFont, h.hasTie),
+						drawHarmony(context, h.staveNote, h.text, labelFont, detector),
 					);
 				}
 			}
@@ -1237,6 +1351,9 @@ export function drawScore(
 					.draw();
 			}
 		}
+		// The last system's content is never followed by a system-change reset, so check it
+		// for clipped content here.
+		warnEscapes();
 
 		// Ties and slurs are resolved over the whole score now that every note is
 		// placed, so a span can cross a barline (its endpoints sit in different
diff --git a/src/geometry.test.ts b/src/geometry.test.ts
new file mode 100644
index 000000000..1b9f14ce7
--- /dev/null
+++ b/src/geometry.test.ts
@@ -0,0 +1,48 @@
+import { expect, test } from 'bun:test';
+import { Rect } from './geometry';
+
+test('right/bottom derive from x/y/w/h', () => {
+	const r = new Rect(10, 20, 30, 40);
+	expect(r.right).toBe(40);
+	expect(r.bottom).toBe(60);
+});
+
+test('intersects is strict — overlapping rects hit, edge-touching does not', () => {
+	const a = new Rect(0, 0, 10, 10);
+	expect(a.intersects(new Rect(5, 5, 10, 10))).toBe(true);
+	// Shares only the right edge (x=10): not an intersection.
+	expect(a.intersects(new Rect(10, 0, 10, 10))).toBe(false);
+	// Shares only the bottom edge (y=10): not an intersection.
+	expect(a.intersects(new Rect(0, 10, 10, 10))).toBe(false);
+	// Fully disjoint.
+	expect(a.intersects(new Rect(100, 100, 1, 1))).toBe(false);
+});
+
+test('intersection returns the overlap rect or null', () => {
+	const a = new Rect(0, 0, 10, 10);
+	const ov = a.intersection(new Rect(6, 4, 10, 10));
+	expect(ov).not.toBeNull();
+	expect([ov?.x, ov?.y, ov?.w, ov?.h]).toEqual([6, 4, 4, 6]);
+	expect(a.intersection(new Rect(10, 10, 5, 5))).toBeNull();
+});
+
+test('contains is inclusive of edges', () => {
+	const outer = new Rect(0, 0, 100, 100);
+	expect(outer.contains(new Rect(10, 10, 10, 10))).toBe(true);
+	expect(outer.contains(new Rect(0, 0, 100, 100))).toBe(true); // exact fit
+	expect(outer.contains(new Rect(95, 95, 10, 10))).toBe(false); // spills right/bottom
+	expect(outer.contains(new Rect(-1, 0, 10, 10))).toBe(false); // spills left
+});
+
+test('translate returns a shifted copy without mutating the original', () => {
+	const a = new Rect(1, 2, 3, 4);
+	const b = a.translate(10, -5);
+	expect([b.x, b.y, b.w, b.h]).toEqual([11, -3, 3, 4]);
+	expect([a.x, a.y]).toEqual([1, 2]); // unchanged
+});
+
+test('fromBoundingBox reads the vexflow accessors', () => {
+	const bb = { getX: () => 5, getY: () => 6, getW: () => 7, getH: () => 8 };
+	const r = Rect.fromBoundingBox(bb as never);
+	expect([r.x, r.y, r.w, r.h]).toEqual([5, 6, 7, 8]);
+});
diff --git a/src/geometry.ts b/src/geometry.ts
new file mode 100644
index 000000000..ea8dcc6fb
--- /dev/null
+++ b/src/geometry.ts
@@ -0,0 +1,84 @@
+import type { BoundingBox } from 'vexflow';
+
+/*
+ * An axis-aligned rectangle in canvas pixels. y grows downward (canvas convention), so
+ * `top` is the smaller y and `bottom` the larger. Immutable — `translate` returns a new
+ * Rect — because the collision pipeline resolves a position, *then* registers the placed
+ * rect (see collision.ts); nothing ever mutates a rect already in the index, so sharing
+ * is safe and there's no rebuild-on-move hazard.
+ */
+export class Rect {
+	constructor(
+		readonly x: number,
+		readonly y: number,
+		readonly w: number,
+		readonly h: number,
+	) {}
+
+	get right(): number {
+		return this.x + this.w;
+	}
+
+	get bottom(): number {
+		return this.y + this.h;
+	}
+
+	/*
+	 * True when the two rectangles overlap on a positive area. Strict (`<`, not `<=`): two
+	 * rects that merely share an edge do NOT intersect. This matters because a 0px overlap
+	 * would otherwise trigger a 0px "nudge" that still forces a re-layout and breaks the
+	 * byte-exact screenshot tests — and edge-touching elements read as clear anyway.
+	 */
+	intersects(o: Rect): boolean {
+		return (
+			this.x < o.right &&
+			o.x < this.right &&
+			this.y < o.bottom &&
+			o.y < this.bottom
+		);
+	}
+
+	/* The overlapping region of the two rectangles, or null when they don't intersect. */
+	intersection(o: Rect): Rect | null {
+		if (!this.intersects(o)) {
+			return null;
+		}
+		const x = Math.max(this.x, o.x);
+		const y = Math.max(this.y, o.y);
+		return new Rect(
+			x,
+			y,
+			Math.min(this.right, o.right) - x,
+			Math.min(this.bottom, o.bottom) - y,
+		);
+	}
+
+	/*
+	 * True when `o` lies entirely within this rectangle (inclusive edges). Used for the
+	 * bounds/clip check — a content rect not contained by the page rect escapes into
+	 * "no-man's land" and would be cut off.
+	 */
+	contains(o: Rect): boolean {
+		return (
+			o.x >= this.x &&
+			o.y >= this.y &&
+			o.right <= this.right &&
+			o.bottom <= this.bottom
+		);
+	}
+
+	/* A copy shifted by (dx, dy). */
+	translate(dx: number, dy: number): Rect {
+		return new Rect(this.x + dx, this.y + dy, this.w, this.h);
+	}
+
+	/*
+	 * Build a Rect from a vexflow BoundingBox. Safe for staves and modifiers, but NOT for a
+	 * raw note.getBoundingBox(): that unions in attached modifiers and a GraceNoteGroup's box
+	 * reports a bogus near-origin y. Build note obstacles from noteTop()/getNoteHeadBounds
+	 * instead (see draw.ts).
+	 */
+	static fromBoundingBox(bb: BoundingBox): Rect {
+		return new Rect(bb.getX(), bb.getY(), bb.getW(), bb.getH());
+	}
+}
diff --git a/src/layout.ts b/src/layout.ts
index 1c1c4dd1f..68cb556e8 100644
--- a/src/layout.ts
+++ b/src/layout.ts
@@ -345,6 +345,7 @@ export function computeLayout(parts: Part[], config: Config): ScoreLayout {
 			systemIndex === systems.length - 1 && systems.length > 1;
 		const justify =
 			layoutMode === 'standard' &&
+			(config.fillFirstSystem || systemIndex !== 0) &&
 			(!isLastOfMany || intrinsic >= cap * config.minLastSystemFill);
 		// Justified systems fill the page; ragged systems keep their intrinsic width —
 		// but every standard system is capped at the page width, so a measure too wide
diff --git a/src/quadtree.test.ts b/src/quadtree.test.ts
new file mode 100644
index 000000000..de432c36e
--- /dev/null
+++ b/src/quadtree.test.ts
@@ -0,0 +1,62 @@
+import { expect, test } from 'bun:test';
+import { Rect } from './geometry';
+import { QuadTree } from './quadtree';
+
+type Item = { id: number; rect: Rect };
+
+function randomRect(): Rect {
+	const x = Math.floor(Math.random() * 1000) - 100; // can stray outside [0,1000)
+	const y = Math.floor(Math.random() * 1000) - 100;
+	const w = 1 + Math.floor(Math.random() * 40);
+	const h = 1 + Math.floor(Math.random() * 40);
+	return new Rect(x, y, w, h);
+}
+
+test('query matches a brute-force oracle, including out-of-bounds items', () => {
+	const bounds = new Rect(0, 0, 1000, 1000);
+	for (let trial = 0; trial < 25; trial++) {
+		const tree = new QuadTree<Item>(bounds, 4, 6);
+		const items: Item[] = [];
+		for (let i = 0; i < 200; i++) {
+			const item = { id: i, rect: randomRect() };
+			items.push(item);
+			tree.insert(item);
+		}
+		for (let q = 0; q < 10; q++) {
+			const area = randomRect();
+			const got = new Set(tree.query(area).map((i) => i.id));
+			const want = new Set(
+				items.filter((i) => i.rect.intersects(area)).map((i) => i.id),
+			);
+			expect(got).toEqual(want);
+		}
+	}
+});
+
+test('items outside the root bounds land in the outside bucket and are still queryable', () => {
+	const tree = new QuadTree<Item>(new Rect(0, 0, 100, 100), 4, 4);
+	const inside = { id: 1, rect: new Rect(10, 10, 5, 5) };
+	const escaped = { id: 2, rect: new Rect(-50, -50, 20, 20) }; // wholly outside
+	const straddler = { id: 3, rect: new Rect(90, 90, 40, 40) }; // spills past the edge
+	tree.insert(inside);
+	tree.insert(escaped);
+	tree.insert(straddler);
+
+	const outsideIds = new Set(tree.outside().map((i) => i.id));
+	expect(outsideIds).toEqual(new Set([2, 3]));
+
+	// The escaped item is still found by a query that overlaps it.
+	const hits = new Set(tree.query(new Rect(-60, -60, 30, 30)).map((i) => i.id));
+	expect(hits).toEqual(new Set([2]));
+});
+
+test('clear resets the tree and the outside bucket', () => {
+	const tree = new QuadTree<Item>(new Rect(0, 0, 100, 100), 2, 4);
+	for (let i = 0; i < 20; i++) {
+		tree.insert({ id: i, rect: new Rect(i, i, 2, 2) });
+	}
+	tree.insert({ id: 99, rect: new Rect(-10, -10, 2, 2) });
+	tree.clear();
+	expect(tree.query(new Rect(0, 0, 100, 100))).toHaveLength(0);
+	expect(tree.outside()).toHaveLength(0);
+});
diff --git a/src/quadtree.ts b/src/quadtree.ts
new file mode 100644
index 000000000..d73bf75cc
--- /dev/null
+++ b/src/quadtree.ts
@@ -0,0 +1,141 @@
+import { Rect } from './geometry';
+
+/*
+ * A region quadtree of rect-bearing items, used by CollisionDetector as the broad-phase
+ * spatial index. Items live at the deepest node whose bounds fully contain them; a node
+ * splits into four quadrants once it holds more than `maxItems` (until `maxDepth`). An item
+ * straddling a split line stays at the parent.
+ *
+ * "No-man's land": a standard quadtree clamps to its root and silently drops anything
+ * outside. This one instead keeps such items in a separate `outside` bucket (only at the
+ * root) that `query` always consults — so content escaping the page bounds is still found,
+ * which is what powers the clip detection (CollisionDetector.escaping).
+ *
+ * Items are inserted only after their final position is resolved (notes are placed once;
+ * an annotation is nudged, then inserted), so a rect already in the tree is never moved —
+ * there is no rebuild-on-move path to get wrong.
+ */
+export class QuadTree<T extends { rect: Rect }> {
+	private items: T[] = [];
+	private children: QuadTree<T>[] | null = null;
+	private readonly outsideItems: T[] = [];
+
+	constructor(
+		private readonly bounds: Rect,
+		private readonly maxItems = 8,
+		private readonly maxDepth = 8,
+		private readonly depth = 0,
+	) {}
+
+	/* Insert an item. Items not fully inside the root bounds go to the outside bucket. */
+	insert(item: T): void {
+		if (this.bounds.contains(item.rect)) {
+			this.insertInto(item);
+		} else {
+			this.outsideItems.push(item);
+		}
+	}
+
+	private insertInto(item: T): void {
+		if (this.children) {
+			const child = this.children.find((c) => c.bounds.contains(item.rect));
+			if (child) {
+				child.insertInto(item);
+				return;
+			}
+			// Straddles a quadrant boundary — keep it at this node.
+			this.items.push(item);
+			return;
+		}
+		this.items.push(item);
+		if (this.items.length > this.maxItems && this.depth < this.maxDepth) {
+			this.split();
+		}
+	}
+
+	private split(): void {
+		const { x, y, w, h } = this.bounds;
+		const hw = w / 2;
+		const hh = h / 2;
+		const mk = (bx: number, by: number) =>
+			new QuadTree<T>(
+				new Rect(bx, by, hw, hh),
+				this.maxItems,
+				this.maxDepth,
+				this.depth + 1,
+			);
+		this.children = [
+			mk(x, y),
+			mk(x + hw, y),
+			mk(x, y + hh),
+			mk(x + hw, y + hh),
+		];
+		const pending = this.items;
+		this.items = [];
+		for (const item of pending) {
+			this.insertInto(item);
+		}
+	}
+
+	/*
+	 * Every stored item whose rect strictly intersects `area` — including outside-bucket
+	 * items. Broad phase: callers still do the exact overlap test they need.
+	 */
+	query(area: Rect): T[] {
+		const out: T[] = [];
+		this.queryTree(area, out);
+		for (const item of this.outsideItems) {
+			if (item.rect.intersects(area)) {
+				out.push(item);
+			}
+		}
+		return out;
+	}
+
+	private queryTree(area: Rect, out: T[]): void {
+		if (!this.bounds.intersects(area)) {
+			return;
+		}
+		for (const item of this.items) {
+			if (item.rect.intersects(area)) {
+				out.push(item);
+			}
+		}
+		if (this.children) {
+			for (const child of this.children) {
+				child.queryTree(area, out);
+			}
+		}
+	}
+
+	/* Items that fell outside the root bounds (the "no-man's land" overflow). */
+	outside(): T[] {
+		return [...this.outsideItems];
+	}
+
+	/* Every item in the tree, including the outside bucket. For whole-set scans like the
+	 * clip check (CollisionDetector.escaping), which must see items the query area misses. */
+	all(): T[] {
+		const out: T[] = [];
+		this.collect(out);
+		out.push(...this.outsideItems);
+		return out;
+	}
+
+	private collect(out: T[]): void {
+		for (const item of this.items) {
+			out.push(item);
+		}
+		if (this.children) {
+			for (const child of this.children) {
+				child.collect(out);
+			}
+		}
+	}
+
+	clear(): void {
+		this.items = [];
+		this.children = null;
+		this.outsideItems.length = 0;
+	}
+}
diff --git a/tests/integration/__screenshots__/fill_first_system_off.png b/tests/integration/__screenshots__/fill_first_system_off.png
new file mode 100644
index 0000000000000000000000000000000000000000..c46dc693b62f80207f0c98daddde6015b2ed0289
GIT binary patch
literal 12449
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

literal 0
HcmV?d00001

diff --git a/tests/integration/__screenshots__/harmony_grace.png b/tests/integration/__screenshots__/harmony_grace.png
index d649655b33c0a448c83e9652fd5458b03c2c85db..03d85a95be990ff79c3373c83aa457f2b06359db 100644
GIT binary patch
literal 5501
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

literal 5497
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

diff --git a/tests/integration/render.test.ts b/tests/integration/render.test.ts
index faa35ac97..14d98f444 100644
--- a/tests/integration/render.test.ts
+++ b/tests/integration/render.test.ts
@@ -570,9 +570,10 @@ const TEST_CASES = [
 	testCase('harmony.musicxml', 'harmony.png'),
 
 	// Treble stave, 4/4: a chord symbol over a note that carries a grace note. The grace
-	// note's group gives the main note a bogus near-origin bounding box; the harmony must
-	// position from the notehead (noteTop), not that box — otherwise it flies to the top of
-	// the page and defeats the top crop, leaving a huge blank margin above the system.
+	// note's group gives the main note a bogus near-origin bounding box; the collision
+	// pipeline builds obstacles from the notehead (noteTop), not that box — otherwise the
+	// symbol flies to the top of the page and defeats the top crop, leaving a huge blank
+	// margin above the system. The symbol also lifts a hair to clear the grace's stem tip.
 	// - M1: a "C" symbol over a B4 quarter preceded by a slashed D5 grace.
 	testCase('harmony_grace.musicxml', 'harmony_grace.png'),
 
@@ -722,6 +723,15 @@ const TEST_CASES = [
 		minLastSystemFill: 0,
 	}),
 
+	// The same sixteen C5 whole-note measures (wrapping 7/8/1 across three systems), but
+	// with fillFirstSystem false: the top seven-measure system stays ragged at its natural
+	// width (left-aligned, ending well short of the right page edge) instead of justifying
+	// to the page edge like in system_break.png. The middle full system still justifies and
+	// the lone last measure is ragged either way, so both are unchanged.
+	testCase('system_break.musicxml', 'fill_first_system_off.png', {
+		fillFirstSystem: false,
+	}),
+
 	// The same two systems (nine then seven C5 whole-note measures), with a measure number
 	// printed above the left edge of every measure (measureNumbering 'every'): "1"-"9"
 	// across the top system, "10"-"16" across the bottom.

From bf95c110c3754d715362a48c2086af0b936ccb51 Mon Sep 17 00:00:00 2001
From: Jared Johnson <jared@jaredjohnson.dev>
Date: Sun, 28 Jun 2026 13:36:31 -0400
Subject: [PATCH 3/4] log if compilation was successful

---
 cli/fix.ts | 1 +
 1 file changed, 1 insertion(+)

diff --git a/cli/fix.ts b/cli/fix.ts
index 9da3267c8..564791067 100644
--- a/cli/fix.ts
+++ b/cli/fix.ts
@@ -8,6 +8,7 @@ export async function fix({ check }: { check: boolean }) {
 		'.',
 	]);
 	await run('bunx', ['tsc', '--noEmit']);
+	console.log('Compilation successful.');
 	// Validate all .musicxml fixtures against the MusicXML XSD.
 	await run('./xmllint/validate.sh', []);
 }

From 443d3b05fd9f758e0f69508fb6e660bf91bc0467 Mon Sep 17 00:00:00 2001
From: Jared Johnson <jared@jaredjohnson.dev>
Date: Sun, 28 Jun 2026 13:49:47 -0400
Subject: [PATCH 4/4] rename fillFirstSystem to stretchSingleSystem and update
 semantics to only work for a lone system

---
 src/config.ts                                   |  14 ++++++++------
 src/layout.ts                                   |  10 +++++++---
 .../__screenshots__/fill_first_system_off.png   | Bin 12449 -> 0 bytes
 .../stretch_single_system_off.png               | Bin 0 -> 11677 bytes
 tests/integration/render.test.ts                |  14 +++++++-------
 5 files changed, 22 insertions(+), 16 deletions(-)
 delete mode 100644 tests/integration/__screenshots__/fill_first_system_off.png
 create mode 100644 tests/integration/__screenshots__/stretch_single_system_off.png

diff --git a/src/config.ts b/src/config.ts
index 5172dacdd..1075f9cc3 100644
--- a/src/config.ts
+++ b/src/config.ts
@@ -45,11 +45,13 @@ export type Config = {
 	 * nearly-full last system snaps flush instead of leaving an awkward sliver of margin.
 	 * 0 always stretches, 1 never does. */
 	minLastSystemFill: number;
-	/** Whether the first system is justified to the reference width (default: true). When
-	 * false the first system stays ragged at its intrinsic width, like a short trailing
-	 * line — useful for incipits or single-line excerpts that shouldn't stretch to the page
-	 * edge. Other systems still justify per maxSystemFill/minLastSystemFill. */
-	fillFirstSystem: boolean;
+	/** Whether a score that fits on a single system always stretches to the reference width
+	 * (default: true). When true a lone system is always justified to the page edge. When
+	 * false it is treated like a trailing line and obeys minLastSystemFill: it stays ragged
+	 * at its intrinsic width when its measures fill less than minLastSystemFill of the line,
+	 * and only stretches once they reach that fraction — useful so a short incipit or excerpt
+	 * isn't blown up across the whole page. No effect on multi-system scores. */
+	stretchSingleSystem: boolean;
 	/** Fraction (0–1) of the reference width a system may fill before the breaker bumps
 	 * the next measure to a new system (default: 0.9). Lower leaves more air; 1 packs each
 	 * system to the edge (the old greedy behavior). Only affects near-full systems — a line
@@ -77,7 +79,7 @@ export const DEFAULT_CONFIG: Config = {
 	measureNumbering: 'system',
 	showTabHammerPullText: false,
 	showTabSlideText: false,
-	fillFirstSystem: true,
+	stretchSingleSystem: true,
 	minLastSystemFill: 0.75,
 	maxSystemFill: 0.9,
 };
diff --git a/src/layout.ts b/src/layout.ts
index 68cb556e8..633d8032b 100644
--- a/src/layout.ts
+++ b/src/layout.ts
@@ -340,13 +340,17 @@ export function computeLayout(parts: Part[], config: Config): ScoreLayout {
 		// The last system of a multi-system score stays ragged unless its measures already
 		// fill most of the line: once their intrinsic width reaches minLastSystemFill
 		// of the reference width, justify it so a nearly-full trailing line snaps to the page
-		// edge instead of leaving a sliver of margin. Full systems and a lone line always justify.
+		// edge instead of leaving a sliver of margin. Full systems always justify. A lone
+		// single system also always justifies — unless stretchSingleSystem is off, which
+		// makes it obey the same minLastSystemFill rule as a trailing line, so a short
+		// excerpt keeps its natural width instead of being blown up across the page.
 		const isLastOfMany =
 			systemIndex === systems.length - 1 && systems.length > 1;
+		const isRaggableLone = systems.length === 1 && !config.stretchSingleSystem;
+		const obeysMinFill = isLastOfMany || isRaggableLone;
 		const justify =
 			layoutMode === 'standard' &&
-			(config.fillFirstSystem || systemIndex !== 0) &&
-			(!isLastOfMany || intrinsic >= cap * config.minLastSystemFill);
+			(!obeysMinFill || intrinsic >= cap * config.minLastSystemFill);
 		// Justified systems fill the page; ragged systems keep their intrinsic width —
 		// but every standard system is capped at the page width, so a measure too wide
 		// to fit (e.g. a large noteSpacing) shrinks to fit instead of spilling off the
diff --git a/tests/integration/__screenshots__/fill_first_system_off.png b/tests/integration/__screenshots__/fill_first_system_off.png
deleted file mode 100644
index c46dc693b62f80207f0c98daddde6015b2ed0289..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 12449
zcmeHucT`j9x_2B$9SdRwr5GJhRGK0X=~gfzAkqXWasYwQ3?&qSIHFh(P!Nzl0@8bj
zP;7v7flvYjl+a5c^qSmf<IK4;_sse3y5G9%e(SsI_{Xd<uy^);-{<)~zw-L@x~dY}
zHm+?b6p9Ud<<bolYGWJ<^@HS3KfouSe{3e8P`gmrOXoFRBF3rrUhE%;RA6pCZB<x*
zz4HFo`+MlO`E`}_H=jzatvDTa{OJ*IO(8|Wxb8hyb)G!nV&gooBUtUtf9cweZPrD$
z{6AmVq<-%C5BBUe2fpmS%PUYL5p%yT!-qNGt~Pi-O3Go5F}EB$<{CwJxFWyPVA9p4
zIQmXdP|$7^>S3bgk0{hHdk7m)KLuxQN1e-jXn;aJI6D3VYL}2PC+hy~tt1rcN9B%9
zsKYluh@epK|Mjc?FIT{6Kf#E&Hpg6BF}gRA2OB8<qIerAR>@yPM8pp_`0kgDCY8@m
z2nlr;Ihe!7wrc7aJAeD|NbcVJbKK!5Zh6+~3~?^SD9wO0|4cBwgXC<7{Fb_oae?d1
zpgJ3myt~V%C%fOieT!Xq8)CTpp51fT2Gltx@#Zb$V=7^}w$$R;mrFB4<x?NF!<U<;
zo%W{g7u4={Xp{@3wIrzdqfm#fd{2+7zCQKsA#FRSNNQr@6ZlNVX%B%l9a6sIpqS}&
zf3<S3&{J+TS;nRLXpey)o#qh19bDqWzic`5TFT*0d%A)DA-Uxa6aUL7)QiYF>b%3v
zZ)?%4#j4{14nqwpd6T6JJ>j;+CoGK!6f<};{hT}XuTPu&3~hBG@*y?MWiZq{pt2*&
zL<5T<wCS4f-@m_fwpkf@-UO_fnHl-DxMefHJb~Wrx-vhZrRodc)}(}%yZiMVEQYRy
zK6_%CQMtTj#NFs`X}1av$+}Fz&5+CA;2%-R*0xwIHb~>~PF^=g1!th*_iL;Oy&enH
z#haR%vrCP{vYI4Q|EGiX;RO~=KmUNbFC?CxxzZprd8vwX{7%$zwVLN1^t}Z-FRU$L
zbbdo#zvUU!{RoNt$0JLoNnN4TQKqA6n7C!ls}l}`bq6JInz$)nOwVy4A@`Mu0^0l{
zgJy+q`Rcj0oMu=m?ZF?V*^_G-7_<j{gt@6wC1IOHb=<K~GJjy0>5af^#~KpfROUVZ
zmJ_{Z?QY$bZ-a}AiRo)r7F7wbwI2TRMqOBnFy0X?e5+Y0OwwlgGoSyJV(4=VeLEA2
zmUtC+S^NGg&C~+B-lHM<0ng$*mS>9=`+Q>cvQ4V|7JBZ9dYF!qlQ<1szFB3I4r-O5
zP{tPe#u(SF7bEaA8l6g_S%jCFbuN^%))MEfsl^hdGVY603|dtcaroEsUY<*}Mv5qu
z`?N&5*$!T5$0z>x=Eo_S#vcbljLKlU$w?(8C06N0$CBl?a|m6@Ym}X-lX4g=VKG;X
zSj+9s6P-@8!%aV-?yHqmO5}9qS+y@Ne!0lbc1ZTD+(;$8Y=sVQrkK}XkLh(^{PsAI
z0L3!c7)@LrNgxi%^y-obHb0`y9p`GVqbDUqaiLR6jvSF@>UTmx#dJDAsU4DcKWo_w
z1@5((t$42O7Lm2ms|1i3x4VA44F1k|Xgla)XxNjgn-kNyxA7o6RJm$rtfDU$##Udp
zR>r0?7oILtJUEnU)0MxUlXJ2oE4Ic3d5rq-_9Tsj#Q9Hwg<IGUJ?9>ZCVK9PwJTv%
z!WCaT&a<H`$kw^%Rmc-!-Zet9b7YPBaE!vYD%#fe8a=1}&o4ziMwA&C*c$n$%c{OZ
z0|ReaMH&gJX{lxG@{6~d<FK%x7Olxzvc^1WhpLF(GmQ#p_G4BrO}w_S8)lng2LyD3
zS-L4dk<Q`*uqt9n*kkLJ^K)Y8=APiYjJ}Exef#RIY6h+YLH=^{H#Jk@Rl*5lX$78i
zhv-{bf4kfmC8t4KT3V{E_1KH=C>;pC6*CH$GWldTAFMh@fq+_+EWYp4Y)*=H+Ox*s
zkPrc?484#x-(_dlnTs#o#-}W0ZFbNd|9h#fKLzDNC>QQCdSPy?-JeHl+SELwoVlE+
z4fCpkSWT-$cHOYlO#&Mj<rquzaSLPsD48t{;N?|q#j~K^bfj)+YC1wUzAbj{aUF_~
za)?o5tN3F_;C?`-z5ig#BUe73m!X9XZDN!^#{M88EbNQZI)DDWyHerUB~_V;+*v_r
z^04PROKXdK$m%D}ryG#OL<^TkQ&#52LPkB4=@QQZ|FCf6ALaEvKBTU#EL33&YVvny
z^{&yK844Nh3?HNCUAOYBpW?JuGbC9IGz;JLbhSlcO=CI8XsJdgfHCPYc~94K>E2{%
z2o9EY<?~Cv&~|`J{?>GWP<e@c0^hs&`$lbb&-LC)0;s1H;!T!6k0eAh$8#Dz7f8Ln
zU8Qbw&-`x{*!pr^*=gm~OtkbfS#BgUXX>mPq=q6iS5{{l{r}>An|~tt%P$X?xXv^y
z^~I4KN1A;^ijR*R^Y;S`6iMcsEL*V+YTYMw?PS&7=83KXwaH3KX^jN8r1cdpD6>TR
z#=FrL|F9YxA5ypOJr?IYGd;~AYS;~>O1?6E^Cr)^Gwo93^y%s8gJ<sOdoB%VRnml*
z8LZ_D=<jQ<@(#(lePW4v!|FS-^PJsPkf0Xr2~btI^6fFYhsathU#t)Xu+r1l=P{zZ
zRSp@}xQPFI`6AWyPAO%w-F0;kQ+`m+%`v&F*lFyt4+l&Ft)kS-%)1kvdF--N=K#nx
z%@4T^zX5<5G&QG@J{IC>F}Rb0g5fgG^n9DHzRLNDu7z<*3-qZUuMEe&eV@*>@hSOP
z!;qTAY6t4Pd#K0rC$u$`Q)Hv8ckV+2T#T+}Nb;(q{6e?G#w|OqIVt&aX$@>T4$b-1
zpSVhEhf!{7bQU_KI#56<FV3jkGesvu6+O~jGy|Qcmus;bzsK`q!ymvL7f}7_poC_I
z6(K~_C<<4Vm0hzp7SnzAA{JY%#82&bbwUHiObOtGk_4c7)=Bml37gK@mr93TI&MHc
zP|q;NtSx;Z(Th`@#@dqTFi42=Inib_M;UcvnDV9i#7em8CDZo9@ZvG?-$0%4_1!P)
z0PDs^N;*i{$t&$XcB}WQZ%A-3vKQ)Yuuzhg&2fo$l1r+b7pK1AzxI^gTlgcmw_0@w
zi;Ajo=@`12<=kP}6-`A#Zvt@73i>>I7T`gy^yS7tIRmfJSxP>k5nr-8U8~L}bTjjC
ztNcvenW4JS8Rp6)ac#_~H_u8Zh;<r9#)Vd+4wc@*H<_8I*2qA3G$#7``ho;?kmcr6
zeEx)F9)Yg}+%LhkCY#j;JJGwP)-=l3ChTJMOP2=2*%emrHv5?@tS-%{DXh&-x(~@%
zwWs@{P(NK>dqjn)qq(x(Xz@ZaZ)041Cxf3Js3tFU``!KF$(6*n9NasA7SJkvN5Xk*
zyYhu=T7i??gIAC9Xp~z3GGo#A=_yRSNj{+bH!^AuY}>XiK+)6F6F2qsy%#ptuD6WA
zZ;LC@$uMkEpm%p=o7IM%F^?~n5;f^4au~{h7mbs{krVN>%8Hy4n8H5rSjwf|RC$kO
zeqRk$siP7dP?B-@Z;v?Rjk*DH7Y{TJ#<O#9a8zoPU`e^T;x*N21wCQ><1SGyZK=9&
zBW}Cra1%dXGU~o!y&^aH618Dmn;8o*D?mGQr|t?GEkm$&Ty4rd*>2=9*UDJr^Op^f
zf9>Y;Vd~pQ!ITj|B%|f#kiN!zyI#*KKi(w9?A)g&1}9zHeorV%S3U6BzYmdp=j+L1
zV%}vQE62JviRu@g@>qSWuxjk-$&9(|)8jr<Kg&Q`yh?$!)Hvdm#EXXh<j`u7Tj<`q
zh2H2vcTf%yksFF|08aNn8)}xYKy|LF0;U;P-k)MXBH&kTT9aFcn_^o;RSiF1KRO;C
z|2U&~G&xbarltlaj9($6y_}f`%d65HSI!|UU6zPB*my*3BkGHbcoK_v_<#&yT#dNg
z;v-siHp);1-3yEZN@W#UCA30WTpa%)7<xK=B?zM+=U7aZvzQd~Xahq-Pl{Q{+BbIM
zlVlpOLU^v;Hy0m^si{OtOE3pDodKn)#~P&x<BO$}9-=?1tjgRcY9?R!_u-15)AfsN
zQyceH)x^ZaKpXn<NZI$4xN0?s=w_SFjkXq03AdV64&i;w4FSe^F+jY<&1zn`>~w)q
zJ`{D&R#SO;W~N2JnKpi}R=D6&#FKE<?}PjAbMyjR>w=hfhh;)!zC}|E@WlFPg>toM
zd4C0_%QD6IqxahY+woc>rv2<f(2jy0H>&_gP7(c^K3Gg(xhBHk?q_mab>&aAs44I^
zj#r*Q#KHkF)6doOBP#j9PfQq_IQ35fvvKjns1^e;dWLHxO_tp<tG8WN<$%_-mzYvu
zD*=(fFtwSs_kQr;L6qD*!emb=beKW0;|XD5YB`YwvnC+2xj}j?6{zEU@mRW5Z<&Xt
za!qY58ZcR5^&30zhGcuBXBa;^;5Kf*vFdQ+AKp~r8TwZ!31Oo$_ko%qe0o}9qRSA#
zi|5M3@Zum2pS#u)%_PGF;WTp3LR3!Lvp~8;yS_tq&O$Gd1&IGM^W|Tx;Ga+&H;^#%
zV7tgoplv`gtneE)qEOMB*=FwR<;~KmGSgoUfQ(w$`V*;I9v6<W^FyJ2l^!J=yqI>S
zM?SbDa03dJ-9BaPJXjZM)s~tB6W#nSLThpw<w<yXo}0gW0X3VdujuOPBATq}UB*ly
z$QDjvy;q~h!d3Wv95tBp1?73xlxfgg)LcsqM0r?!mLMTy&#l?lZ*uy@60VCwST7gX
zii5=l$)c%r(VGf_&3vbbLGdhLkJjdJaZ7tZs-IA(<k%x0=_wgyZXXyRqvD(w(Ct|!
zRlohfHeAw1Y|G5d%=T^Dnw9cxsa(9h(q}=-j9Pro3@<rX@C*P*`yjS$ZYR&#Q{O)?
zI4uMv3^z}rA2g3R4FwVq5HM?X^5jXRzcE*pm1)}%nWlHKVSFdI<T!WlqGEH@X_HFW
zf9<0qwml_9g@rEg<gm;EFs~BRH}`1%teS;T;?dTWX!q%ANt;ffCP$^^!%3h&Tufoh
zfs7FQo(hyLw`PEnxURxhl60w$QH3_jy#2nf!l&15EX|Z(RMhU>{S62$m$Em7g_E+}
zXN-AUQX(5QyjEu}?*L2@<mUA=zJg$VoD;@<-a>{wRQ;Fx@xN&WT7{A~D*5pgt<87U
z*3_s<4ZH&FKqYk9K&OyN(xDWCd}|6YzM+Ol8S{pS3LnmL=s<N<q{8piz5ejwL!^xJ
zdW|`W<#fR)gSPqP3nS;^<DCNo1D9JDmd7&Kxg}F!{@NPhEB3<}t8Z*vcSYa|8K4gU
zg+Ou^=+u=lBbHl;h(Qca8uTzIrhqtZpCNDJlo$FE6e2G;CP49+omLqYRT5Thvf$i|
zwP*Mz1JS~cwWTSeLlub3?V=@!KhrkKKQ6yAo)cm~pn!_)geOC!A$~Nitx6~LCLTD6
zsUN_<9JFa_E4E_-*b+|C8Tbp8<ebrv5DOeV;;uUwMZk~|qa#7}1HAyKQci=k)o1+W
z%a=bsW^ZKXWRy%_UABL8-fOem)Vqym%p1l#^TwKDmC*Obvj8@-H3YyjXiKH!TDHVQ
z)J4i*TFZbI*%gn($9cfmoExV&)Q3p`&wC1<&~|u3tG-b4C@dFrvdU5FO<64-wLL?t
zHHIjZ{G%{UZEZzgY~V4K7+Q)a2nWLfG7NmQ$7~aDX;`8ckEC^T!gI(bHtmM@Yz8U+
zb5;#kIDqNufGF{4Vi_R#%3QmVe_|OZUf_hM9xV4MhMd6^M-(-+UZNgtE;h)yrK_@6
zK=rwT1k}{*`|Rv&a<VrVAUZcp%9(Q+qQ%28SCc32^{({rI(MsM=hkKvSTkoDWi_yK
z19wH=Hv6V;?jE)uR1C>U6hT~)=(TZknh6*=8ho%_A%<=vU3TS>j-XY!5I>1ar^Dty
z`ZmBXgX6kj1|ob1ieOwkUB~}u?f$;!+-T>?9$uxcS>cv4;H%(lyvRe06d*N=h31V>
zY}}HFJ_9*)EfNMZX)w%c9l>c~6cABX?(V~H9&ctp6cOcU;@s=uTpKJ5l=rh9{8$bY
zGmQqYo${O=1Y+Im)9dqyFO1>=7DC@vY8?Yewr<WH1b0<@&F(nED^*lf05eMzL+lio
z)lQ@26Y#jWY_HCQm%fke@0h%apxk`o28;3g5}Un~NkqQtyETGLiki-;_gm1{!o-uH
zEz|V!!X&J;SG`=oF9Cx^{?Ik;tyS>EC8pH@HENF|FdR3kk^dBTOLE*OsL^-6t|7g?
zdjoa8BIfD_xUUi<A5PJ-{s843Q0H|TpkW4x%pszpL_RFtqW^1I*J<Dc0@q&Or8>3e
z0pEgmVoi&(rfF!_S>~H-lGZ-lAHCUDn*2Q-L6SY$t6m*(!oZd+Y<@N5%-h<~<^e_O
z=y{mae|9`1uSH5bQL@djByb9~8bG`P*YrrD1GSNYLi#7S@p?ps0?Y82u&TaeInu{^
z@td*nQA15G2shc8Cphx}Mt(79&7^d6Y~Wu$%RhJ+1-+gtoFKXjOQDbwCF3$)z6R)f
z$)_Zi0gmpKWCL~e-T0qRhQjOk77tt-v5$9@(kSjuyd`JxI#ULq6XadIe}w1q2(-(%
zbNLFjkP1?Fu@LAl+>Rx`Z_98rYjr5JJ;I?uDrtUcC>s4w?sq?PWjNNqAsi#>!LM2j
z09!g7;}c*Do(YWxEF-3Km)d^B5i8|R7(Ll;-I003(sB69x8Pg0PtWcSs#{;}?~k{>
z32BGK&viteGQQx30g3>Ym&eMyim&5Xo3K2+t3cEt^5Ran+2P$p)|WRI1L?nP+|oBc
zJJJFLz0X-;b?V~^2m@G{%ZNnt@u3NVZ?fl~Jot_FNy(HxL}UYuX;9nJZi(vUCc>W@
zvqz5}0WtRY`pcH9SFgtC-O$#Sbf$NMU0C4@<YtnRlK`$BuM9!x`0*!00WiTRU_=eK
z9ATz0loXcL2Pge>m&J9&(r=Bv_EK{gDVq+;_~hi{uRiBd!<v?~3|R49ZqffkRZA2#
zd8~%$be^ARsj9pnm6LV7!CL5&oI`AFD7QgF_b@I->^U!4J6%82lR!>X*Aju<CagM-
z^OfBNT^mHc*}%R1<xJ&;{`{<6K}Gamz1Oe$4We4d!l(naAqkx@E7PYxe`CXRU%zo<
zx~W`6HB@Y%WTv63#MJ>97&^i5qwR8M(qEVnKs}cc>t+M$T~$(hW_Z}ki7#(H7L?7U
zkzFh;N7fd4(PpqZHZUBXp-^A>{%kMQ-=HDJAIzne455=Jug<G;V{E&hA3U?XFljW9
z5`Qgpdb(B=knXPi94BF6qALW)$-xmH9VX*!n{1%3Ut&K{gUBohLhuXE&omT*S)c<r
zVok{gUXVZ>g~<q}F-ky(XbeRo+RFUES@vSRw_5!K@CZxYuyOMxVy}{Lo+YC9;oD!A
zDffU)0?>K3$jzYg`t|EC#6iSqcqL()=O(%^QJ++N7e-qJrOVVDadFUOFkG)W37f#%
z#lqW7K(^9+cHou94KDzNt6bpB7%x|V$>QhFu(n;kZES2TTM?eCtgH;^dsa#&(SwU}
z^SHSrM@^{jqeOFCN2%|7tD@<h<<+@7Hx|eM<1NnLpI1gwnrWdIG?r1eJnFIvJ`onJ
zpLzTI^ii1j8T<m@@34-$mkHNvpZ<BH*A+fOj%<bgGmXDxC(jiwYOxa-8DINHCC1mS
z`NhJ&RXhWM9lsf5HfL3@cA6f9G16;&{f~BNeXzy3EheX=BRkwbDl<Mm*~{|gwteCU
zMu$J={{0nO7eBHqjQ5nTj8k#~-}nELPwuMv8zR)<V;+nMX*_$84@ORezQ<!~2Q+Ot
zjBGG^T6#f7wNyd$vr?tNWF#o8S>jG#%zpl@RmTWaDN#(!b-Ev%NzmJnzrYRL<G>qD
zh$JAi3YHE-WUji<=RshoDaZi6blH-GTYXLNze{O|J>p1rzkPtn00XnjpNulbAQqX+
z9cLIp_-Cbk&jh`991JLXh%v~{yTs!oTKM&WWlMaXEmiuvn1&aoiTiL}@!=4Li~s|U
zoJ+Q3Lk3`-@bTlrlpJ%Qk0ioGCm5g2&CS3j5thoRP*@vLYXmWkUK>_wH*hw9H$-Of
z1sDmR9&s8je%h-Be9dZUdO%Po-F;~wghpQJWv%tvm9G&T-5v7yJLgAQhAKFXtig?d
z`qs_)=TjFUHj$LHAQqKV|L%L3upsVj5K-LPe2P6$OBpmAjRuSe3O><K?Ocb-y!vl#
z55kr`(TvY^rK47~oM$~;bnl3SNC$2LLb2~)_ZTQ+aI@3x&x-*Pav;A#p6EIt-v)_f
zF^pGD48{6q-MH{+=)*K<73ftu*rnfvWje(JrhiMIZE8u0dv_sTOT?-v<}&yQ^K>fr
z`nQ>OL@E$H2fsGIRX)?J-X4bygi;4IxX#OVkbpQ}d;I`$1xiV*La=-hwvYUv3j#K&
z*U`~N(7E#2Ft&yl+upAe8W`ODn~JqyTIbbV$xe3$xAgnxWxmGM0Z1RIIW?Z8J%=q0
zdi5&KNJCw{3Ak#Zx}F}F(K>tQvcKcpk!jq!SXnnykn+11fC-of%rb<S_axSNX0RTp
z5fFh$39H~Z$myLVrsDVDpLx)HG1?i1YyE+0`S1l$B25fRH;jr;e6Y#Zy=7~AA!lvP
z@RUGk6z;3a(LLY+Ek4+^9qjnkwp(^b`CMIHH*Vf>KmtbwhYu+jZ0t{@6Ch_8mnO~S
zXF_KhWJKZOFiU+n4}ij{UzGoKGYaK&^<PH<{uix4s@_f#w4ED^xdv8TC;2mrImxQz
zlXIJ0L{b?LccbdUkEt+IIXO8KiXo$2S|G9(st(;757IHz1*Zjogmt+U57iHT&OQzf
zdUw$oq~?+bG7&Tc|1Z86A%B1`?hw#dP5}1$WBHUB{0v}wtQ4a)90&>>eS8Ik2T+EI
ze(*?uerl8So>CGt9ER%H0wfGFMSWe}P-^?7$L#1sr~h`z($ccoW8`g!=iim{%6+{E
zTbS4qpp{um(Jb9E_a#t3*{io#U&4*v`qxD(umBOCAg2|axCuz63}IKIO1LCrm41K2
zMnLP}`ULHNP|h|Tyl3xz1yj@mklgfH0gyI|JMP27tpYqog?EiXCj)F!lIk;8LdsXo
zKEF5;D4>Sqtlci)Pj%+o+-p(6I4RfyCt%InvF5XkrfUQ<;zV^0h+BNw$S!*d!v3?z
z(Xi-QRfk|u9+pwbCR(I=c7v6PtXAMWqzv5V196Cr3JYrJ)T)(Z-Uw#n;qCP?im<AG
z*U}xj=8;-(76D@Z^-~mzn4B&^x<w>i07|JNB>}8f3B)v<7y-00ePfHho|2Aa0lu?r
zk2S#VbAzV@U5;G+sB%9+Bd6%-(W6?bpyY;O3$JmlUxiPjz^Mmknh9Xq5SaNV69VLp
zg<<S^U{oT8z?Z@gbcmz&@)~7^yN(JdEMeWp!E#t%rLHaHfQ0%)bKi+K7g6`UZxmP&
z1XC=5UosNFCJmIosjVHX*Luoxb@3`wJ-GqCkCliQHd!1uSKvki`3vU)9~E&(L7Pm(
z$pFbmzOkk71L9ov(LkI8&>?^jDe4apzLn39L?`<0j0)tr6Y!;OLb~a@%)1v00aMR*
z#@mI?uT2sapkPxa(nG0`aeb-+g#+XL8*s&5I88IE2_Zk&#(QCiw83!!TX3>zw2SO=
z;x1EPXXCg@D|8Yhyuew{wS|c%CoCewGCDe1N*<o<sB-Y7h%14|SS;cvvQJM*=myl`
zrYCm@h&SnS0plPG+5=J=cs5N96WtsVkXy*I0LC>B!siq)%B7t~_ra|tDCdRG1)oNt
z__;i{<RwJ8C4)*9SY3qEAvbloAy@PQ$HWOj2(1)tFj1x9*<c}}h|DFIDYAx|3N!V+
z*A`LT?6~Q@$Fse-Q17tfQyX!=>04EoQK(1v@vN#CuC71F_z~k*BC;VzTeOC8(OgRN
zld&ydn~zuFZdX1jABK3Ps_{oOs6dZEow#P_K(y(h$sMm68OBe&33MeTLKsY7$dGSP
zp&lF>BBbD5&s$_>-qO~F5Z*(WA|!0Ug9-dmAEsifH@w)%)*eXu1~=&#c{r7OuH7(z
z>2vr1+g`%LWG`BPda_IL6OwmRVe^ev`#5Ryz&2t!r$D2>?S!U~hf^zq5*NL9VDkh|
zo&;|2;L9mvXD}f^3tU4>0S%1yn5Rs_E$}3Wi5PhB)YNURMCbW#oc)h!ImBicAjpPx
zaRg>G!iR5$3}fUnr@<>n0K$Xl_Ox4^t==xlg`gcrsAsiwitd2k$Hs#FP|$6!4ChOB
zaUDj^L>(y&4+$x7Ve~;=#w#M8IO3`Q-)PJYs9g`2J?A>?JZHiIloN`9Q5fc0sKcM2
z+HKpnLvgOW+sOXv)vHT+ajB`+fX2`=KHOa(jdRS^5>z80qPltg`mV;KaL6JX@{=Zk
z7drkMP!S;fe&7cWoPX45OCF@D@zK0+{wQesoyI6wFmvK3PSuFBSpmd-NIvoveyg57
zJy5GL0n$jv_4J3|)E@Yt#7~%Oe<Ap+cF`f}0ri_uOsn!|Q5rpi>qD$Nb4S8^SMLBY
zfGk8`2YfStLUUYYGh*zpMbZEUFkKi70FL4-8DWr__g4q<$pRAr5htA!4$(Kvq0p<v
zO$^}&Dg0DO)=bfPkb1(&uvj9Csa1vpGA~-bY7bw52sdYlnvw{ho0gLR65~68T_LQP
zUNofm{J?H!gs_F%mAOLV2A0+s_@&DUo-19wKnK@VBb;ZrF(K;yZTtF}kQ);&dlsq%
zqIpi;J~zAILB0_V2GjR^_}&td4+E|QrnH;w*tBUAmQO)JK?3^neOwc4hRYs|M9;bv
z0!)^C1-=ZtozPLeN)!stFtlePrd=Gq=0rl=W*Mi^SK=a&s?GWUXz`+Hl<wL0;7PkY
z!&pKVzy4^1>)T%xAn<_f-hUG97T$jUpkLXW9c}m&LSd9@x?#xa*@-TMz~W873m%~%
z5ga5y5JAljhTFyaFAO*F$ur@6n<`osPRlh9!#1w3=N}{5R0EQvL<blYXPNnsLqW(t
z!YLqXnz)Cc(ehEpz)5TUieBRa*cRmEf}^`6#-k)L@wn<cwCAERfCbo&kvopD=f3Tc
z=eWmOTY!(h72?4_u0Vrv{Ix%f%+hN-n^`I41cDMyV?<!=41;puP@yiIeX%K^20I2S
zb%TxH4joo_8b|;fDEQ>?4n%-7ax}o2a|g1Cayi^^#-|11GIEAdIb>v24h8?`eDwIp
z52&duXyr<n<twu-YE@@Q|6I>i%#iTSyy6zu*NYnakr}vv*!5~{$3)GK|Fw>51Xqi4
zVj?xCp?DsQe{e?NEtKN2o^L>XH4PK@zMTt=0p3c6evw#19+<zAh@E0r&db}YFYK2O
zd3N;j?8r=?kEo<wkL=H0aG>|D7*Z1OKQAmeTHoqn4gSk|O}(J@0Pgbid{%$t4j==i
z-s~hWC*aVf3h*6SuX}5A?Ff`=iCj^HBxGIiZ3bleZx?IOQ8&#pVY~tFThCXy#Kyt2
zND<&c5Y5e*g@<_wM;v~Yh97_!I_7XnL81KDUk`hj0=73X(!ADLrS}d}^>)XU*V0b7
zpqHiwlR$vJf9}rxG2kfD4pE~~_{xLe=n0-Ufh~^*D1jIr9}AgI+2M79&|gP~;{s(2
zUpxK@uu)22ue1W_Al1PFgz}ZKY7@f3(dkh{ZuRY3finfEhNa7Z57ux~B=Vu<6oJeA
zL<t-=3XB4QD3?Bj|3aa(lHY}2<v&DRWq?8xGAvnyLmXEX!Hocgb_x!Jz%YkCe-Ws-
zo1g)9Jnd;uqx;|)h`SBpVhJEWa73FN<L!Qq4H)~Ye;w%l|9Ax^6WxX3p9+W}|3=`y
sa1=k4#SToF^|vR5t8n#Z<m!zmi)#c0ro$O4_ymQ$ta>T^!tDqD2FOptUjP6A

diff --git a/tests/integration/__screenshots__/stretch_single_system_off.png b/tests/integration/__screenshots__/stretch_single_system_off.png
new file mode 100644
index 0000000000000000000000000000000000000000..120b9f4895f79c6dfbaeea12d7d1f58232a0bc0a
GIT binary patch
literal 11677
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
W^n04Et6u~^L6okkUCog<dHNr3Rl@xM

literal 0
HcmV?d00001

diff --git a/tests/integration/render.test.ts b/tests/integration/render.test.ts
index 14d98f444..3832eebe0 100644
--- a/tests/integration/render.test.ts
+++ b/tests/integration/render.test.ts
@@ -723,13 +723,13 @@ const TEST_CASES = [
 		minLastSystemFill: 0,
 	}),
 
-	// The same sixteen C5 whole-note measures (wrapping 7/8/1 across three systems), but
-	// with fillFirstSystem false: the top seven-measure system stays ragged at its natural
-	// width (left-aligned, ending well short of the right page edge) instead of justifying
-	// to the page edge like in system_break.png. The middle full system still justifies and
-	// the lone last measure is ragged either way, so both are unchanged.
-	testCase('system_break.musicxml', 'fill_first_system_off.png', {
-		fillFirstSystem: false,
+	// A score that fits on a single system, rendered with stretchSingleSystem false. The
+	// lone system's few measures fill well under minLastSystemFill of the page, so instead
+	// of stretching to the full page width (the default — see aloof_measure_1.png) it stays
+	// ragged at its natural width: the staff ends well short of the right page edge with
+	// empty margin beyond it.
+	testCase('aloof_measure_1.musicxml', 'stretch_single_system_off.png', {
+		stretchSingleSystem: false,
 	}),
 
 	// The same two systems (nine then seven C5 whole-note measures), with a measure number