@sudobility/music_drawing 0.0.1

package/dist/playhead.js

@@ -0,0 +1,89 @@
+import { measureAtXInSystem, systemAtY } from './layout.js';
+/** The score's shared measure grid (first track — every track shares it once `rebuildMeasureTicks` has run; same convention as `store/selectors.ts`). */
+function measureTimings(score) {
+    return score.tracks[0]?.measures ?? [];
+}
+/** Binary search over ascending `startTick`s for the measure containing `tick`; clamps below/above the score to the first/last measure. */
+function measureIndexForTick(timings, tick) {
+    if (tick < timings[0].startTick)
+        return 0;
+    let lo = 0;
+    let hi = timings.length - 1;
+    while (lo <= hi) {
+        const mid = (lo + hi) >> 1;
+        const m = timings[mid];
+        if (tick < m.startTick)
+            hi = mid - 1;
+        else if (tick >= m.startTick + m.durationTicks)
+            lo = mid + 1;
+        else
+            return mid;
+    }
+    return timings.length - 1;
+}
+/** Binary search over systems by their (ascending) measure-index ranges. */
+function systemForMeasureIndex(plan, measureIndex) {
+    const systems = plan.systems;
+    let lo = 0;
+    let hi = systems.length - 1;
+    while (lo <= hi) {
+        const mid = (lo + hi) >> 1;
+        const s = systems[mid];
+        if (measureIndex < s.measureIndices[0])
+            hi = mid - 1;
+        else if (measureIndex > s.measureIndices[s.measureIndices.length - 1])
+            lo = mid + 1;
+        else
+            return s;
+    }
+    return null;
+}
+/**
+ * Where the caret for `tick` sits on the canvas, or `null` when there is
+ * nothing to draw against (empty score / no layout). Ticks past the end of
+ * the score clamp to the final measure's right edge.
+ */
+export function caretPositionForTick(plan, score, tick) {
+    const timings = measureTimings(score);
+    if (timings.length === 0)
+        return null;
+    const measureIndex = measureIndexForTick(timings, tick);
+    const timing = timings[measureIndex];
+    const layout = plan.trackLayouts[0]?.measures[measureIndex];
+    const system = systemForMeasureIndex(plan, measureIndex);
+    if (!layout || !system)
+        return null;
+    const fraction = timing.durationTicks > 0
+        ? Math.min(1, Math.max(0, (tick - timing.startTick) / timing.durationTicks))
+        : 0;
+    return {
+        x: layout.box.x + fraction * layout.box.width,
+        yTop: system.yTop,
+        yBottom: system.yBottom,
+    };
+}
+/**
+ * The tick a canvas click at logical `(x, y)` should seek to, or `null`
+ * when the point is in dead space between/outside systems. Horizontal
+ * positions left/right of a system's measures clamp to that system's
+ * first/last measure, so clicking the clef area seeks to the system start.
+ */
+export function tickForPoint(plan, score, x, y) {
+    const timings = measureTimings(score);
+    if (timings.length === 0)
+        return null;
+    const system = systemAtY(plan, y);
+    if (!system)
+        return null;
+    const hit = measureAtXInSystem(plan, system, x);
+    if (!hit)
+        return null;
+    const timing = timings[hit.measureIndex];
+    if (!timing)
+        return null;
+    const fraction = hit.box.width > 0
+        ? Math.min(1, Math.max(0, (x - hit.box.x) / hit.box.width))
+        : 0;
+    return Math.round(timing.startTick + fraction * timing.durationTicks);
+}
+//# sourceMappingURL=playhead.js.map

package/dist/playhead.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"playhead.js","sourceRoot":"","sources":["../src/playhead.ts"],"names":[],"mappings":"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"}

package/dist/test/canvas-stub.d.ts

@@ -0,0 +1,21 @@
+/**
+ * A recording stand-in for `CanvasRenderingContext2D`: every method call is
+ * appended to `ops`; every property write is accepted; `measureText`
+ * returns a deterministic width (8px/char) so VexFlow text layout math
+ * stays finite. Proxy-based so any method VexFlow's `CanvasContext` calls
+ * is recorded without this double having to enumerate the whole 2D API —
+ * new methods VexFlow starts calling never require test-double updates.
+ *
+ * Exported from the package root (like `testStoreContext`) so downstream
+ * suites — music_app's jsdom setup stubs `HTMLCanvasElement.getContext`
+ * with it — share one implementation.
+ */
+export type MockOp = {
+    method: string;
+    args: unknown[];
+};
+export type Mock2DContext = CanvasRenderingContext2D & {
+    ops: MockOp[];
+};
+export declare function createMock2DContext(width?: number, height?: number): Mock2DContext;
+//# sourceMappingURL=canvas-stub.d.ts.map

package/dist/test/canvas-stub.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"canvas-stub.d.ts","sourceRoot":"","sources":["../../src/test/canvas-stub.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,MAAM,MAAM,MAAM,GAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,OAAO,EAAE,CAAA;CAAE,CAAC;AACzD,MAAM,MAAM,aAAa,GAAG,wBAAwB,GAAG;IAAE,GAAG,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC;AAEzE,wBAAgB,mBAAmB,CAAC,KAAK,SAAM,EAAE,MAAM,SAAM,GAAG,aAAa,CAoC5E"}

package/dist/test/canvas-stub.js

@@ -0,0 +1,51 @@
+/**
+ * A recording stand-in for `CanvasRenderingContext2D`: every method call is
+ * appended to `ops`; every property write is accepted; `measureText`
+ * returns a deterministic width (8px/char) so VexFlow text layout math
+ * stays finite. Proxy-based so any method VexFlow's `CanvasContext` calls
+ * is recorded without this double having to enumerate the whole 2D API —
+ * new methods VexFlow starts calling never require test-double updates.
+ *
+ * Exported from the package root (like `testStoreContext`) so downstream
+ * suites — music_app's jsdom setup stubs `HTMLCanvasElement.getContext`
+ * with it — share one implementation.
+ */
+export function createMock2DContext(width = 800, height = 600) {
+    const ops = [];
+    const state = {
+        ops,
+        canvas: { width, height },
+        measureText: (text) => ({
+            width: String(text).length * 8,
+            actualBoundingBoxAscent: 8,
+            actualBoundingBoxDescent: 2,
+            fontBoundingBoxAscent: 8,
+            fontBoundingBoxDescent: 2,
+        }),
+        getTransform: () => ({ a: 1, b: 0, c: 0, d: 1, e: 0, f: 0 }),
+        createLinearGradient: () => ({ addColorStop: () => undefined }),
+        createRadialGradient: () => ({ addColorStop: () => undefined }),
+        getImageData: (_x, _y, w, h) => ({
+            width: w,
+            height: h,
+            data: new Uint8ClampedArray(w * h * 4),
+        }),
+    };
+    return new Proxy(state, {
+        get(target, prop) {
+            if (prop in target)
+                return target[prop];
+            const fn = (...args) => {
+                ops.push({ method: String(prop), args });
+                return undefined;
+            };
+            target[prop] = fn;
+            return fn;
+        },
+        set(target, prop, value) {
+            target[prop] = value;
+            return true;
+        },
+    });
+}
+//# sourceMappingURL=canvas-stub.js.map

package/dist/test/canvas-stub.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"canvas-stub.js","sourceRoot":"","sources":["../../src/test/canvas-stub.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAKH,MAAM,UAAU,mBAAmB,CAAC,KAAK,GAAG,GAAG,EAAE,MAAM,GAAG,GAAG;IAC3D,MAAM,GAAG,GAAa,EAAE,CAAC;IACzB,MAAM,KAAK,GAAqC;QAC9C,GAAG;QACH,MAAM,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE;QACzB,WAAW,EAAE,CAAC,IAAY,EAAE,EAAE,CAAC,CAAC;YAC9B,KAAK,EAAE,MAAM,CAAC,IAAI,CAAC,CAAC,MAAM,GAAG,CAAC;YAC9B,uBAAuB,EAAE,CAAC;YAC1B,wBAAwB,EAAE,CAAC;YAC3B,qBAAqB,EAAE,CAAC;YACxB,sBAAsB,EAAE,CAAC;SAC1B,CAAC;QACF,YAAY,EAAE,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;QAC5D,oBAAoB,EAAE,GAAG,EAAE,CAAC,CAAC,EAAE,YAAY,EAAE,GAAG,EAAE,CAAC,SAAS,EAAE,CAAC;QAC/D,oBAAoB,EAAE,GAAG,EAAE,CAAC,CAAC,EAAE,YAAY,EAAE,GAAG,EAAE,CAAC,SAAS,EAAE,CAAC;QAC/D,YAAY,EAAE,CAAC,EAAU,EAAE,EAAU,EAAE,CAAS,EAAE,CAAS,EAAE,EAAE,CAAC,CAAC;YAC/D,KAAK,EAAE,CAAC;YACR,MAAM,EAAE,CAAC;YACT,IAAI,EAAE,IAAI,iBAAiB,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;SACvC,CAAC;KACH,CAAC;IACF,OAAO,IAAI,KAAK,CAAC,KAAK,EAAE;QACtB,GAAG,CAAC,MAAM,EAAE,IAAI;YACd,IAAI,IAAI,IAAI,MAAM;gBAAE,OAAO,MAAM,CAAC,IAAI,CAAC,CAAC;YACxC,MAAM,EAAE,GAAG,CAAC,GAAG,IAAe,EAAE,EAAE;gBAChC,GAAG,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC;gBACzC,OAAO,SAAS,CAAC;YACnB,CAAC,CAAC;YACF,MAAM,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC;YAClB,OAAO,EAAE,CAAC;QACZ,CAAC;QACD,GAAG,CAAC,MAAM,EAAE,IAAI,EAAE,KAAK;YACrB,MAAM,CAAC,IAAI,CAAC,GAAG,KAAK,CAAC;YACrB,OAAO,IAAI,CAAC;QACd,CAAC;KACF,CAA6B,CAAC;AACjC,CAAC"}

package/dist/test/fixtures.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Deterministic score fixtures shared across the test suite (Task 3 brief).
+ * No randomness: ids are generated by a simple per-call counter (not
+ * `createId`/`crypto.randomUUID`) and timestamps are a fixed constant, so
+ * every call with the same arguments produces a structurally identical
+ * `Score`.
+ */
+import type { Score } from '@sudobility/music_types';
+import type { RenderTheme } from '../types.js';
+/** An 8-measure C-major "Twinkle Twinkle Little Star" melody on a single piano track. */
+export declare function twinkleScore(): Score;
+/** A 4-measure two-track score: a treble melody and a supporting bass line. */
+export declare function twoTrackScore(): Score;
+/**
+ * Three tracks over 2 measures, deliberately plain.
+ *
+ * For tests about *which* tracks are involved — visibility, active-track
+ * resolution, per-track filtering — where two tracks cannot tell "the first
+ * one" apart from "the first visible one", and the music itself is beside the
+ * point.
+ */
+export declare function threeTrackScore(): Score;
+/**
+ * Two tracks with sharply different densities: a treble line of 16
+ * sixteenth notes per measure over a bass of one whole note per measure.
+ * Exercises cross-track timeline sync — the dense track needs a wider
+ * measure than `BASE_MEASURE_WIDTH` and must still share barlines and
+ * tick-aligned x positions with the sparse track.
+ */
+export declare function denseVsSparseScore(): Score;
+/** A 4-measure I-IV-V-I block-chord progression on a single piano track. */
+export declare function chordScore(): Score;
+/**
+ * Generates a score with `trackCount` tracks of `measureCount` measures
+ * each (4 quarter notes per measure, cycling through a C-major scale), for
+ * performance/stress tests. Deterministic and allocation-light.
+ */
+export declare function stressScore(trackCount: number, measureCount: number): Score;
+/**
+ * A `RenderTheme` for tests: every role gets a distinct, obviously-fake
+ * value so an assertion that the wrong role was used fails loudly instead of
+ * matching a lookalike hex. Shared here (rather than redeclared per suite)
+ * so adding a role to `RenderTheme` breaks in one place, and so consuming
+ * apps' jsdom suites can import the same object.
+ */
+export declare function testRenderTheme(): RenderTheme;
+//# sourceMappingURL=fixtures.d.ts.map

package/dist/test/fixtures.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fixtures.d.ts","sourceRoot":"","sources":["../../src/test/fixtures.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,KAAK,EAMV,KAAK,EAGN,MAAM,yBAAyB,CAAC;AAEjC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAqG/C,yFAAyF;AACzF,wBAAgB,YAAY,IAAI,KAAK,CA0DpC;AAED,+EAA+E;AAC/E,wBAAgB,aAAa,IAAI,KAAK,CAkFrC;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,IAAI,KAAK,CAiDvC;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,IAAI,KAAK,CAgF1C;AAED,4EAA4E;AAC5E,wBAAgB,UAAU,IAAI,KAAK,CAsClC;AAID;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,UAAU,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,KAAK,CA+D3E;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,IAAI,WAAW,CAY7C"}

package/dist/test/fixtures.js

@@ -0,0 +1,433 @@
+import { measureDurationTicks, ticksFor } from '@sudobility/music_types';
+const FIXED_TIMESTAMP = '2024-01-01T00:00:00.000Z';
+/** A per-call, per-prefix incrementing id generator (deterministic, cheap). */
+function makeIdFactory() {
+    const counters = new Map();
+    return {
+        next(prefix) {
+            const n = counters.get(prefix) ?? 0;
+            counters.set(prefix, n + 1);
+            return `${prefix}-${n}`;
+        },
+    };
+}
+/** Builds consecutive single-voice melody measures from a per-measure list of note specs. */
+function buildMelodyMeasures(measuresOfNotes, ppq, timeSignature, keySignature, trackId, ids) {
+    const measureTicks = measureDurationTicks(timeSignature, ppq);
+    return measuresOfNotes.map((notes, index) => {
+        const startTick = index * measureTicks;
+        const voiceId = ids.next('voice');
+        let cursor = startTick;
+        const events = notes.map(spec => {
+            const durationTicks = ticksFor(spec.duration, ppq);
+            const event = {
+                id: ids.next('note'),
+                pitch: spec.pitch,
+                startTick: cursor,
+                durationTicks,
+                velocity: 80,
+                voiceId,
+                trackId,
+            };
+            cursor += durationTicks;
+            return event;
+        });
+        return {
+            id: ids.next('measure'),
+            index,
+            startTick,
+            durationTicks: measureTicks,
+            timeSignature,
+            keySignature,
+            voices: [{ id: voiceId, name: 'Voice 1', events }],
+        };
+    });
+}
+/** Builds consecutive single-voice measures, each a block chord spanning the full measure. */
+function buildChordMeasures(chordsByMeasure, ppq, timeSignature, keySignature, trackId, ids) {
+    const measureTicks = measureDurationTicks(timeSignature, ppq);
+    return chordsByMeasure.map((pitches, index) => {
+        const startTick = index * measureTicks;
+        const voiceId = ids.next('voice');
+        const events = pitches.map(pitch => ({
+            id: ids.next('note'),
+            pitch,
+            startTick,
+            durationTicks: measureTicks,
+            velocity: 80,
+            voiceId,
+            trackId,
+        }));
+        return {
+            id: ids.next('measure'),
+            index,
+            startTick,
+            durationTicks: measureTicks,
+            timeSignature,
+            keySignature,
+            voices: [{ id: voiceId, name: 'Voice 1', events }],
+        };
+    });
+}
+const C_MAJOR = { fifths: 0, mode: 'major' };
+const FOUR_FOUR = { numerator: 4, denominator: 4 };
+function naturalPitch(step, octave) {
+    return { step, accidental: 0, octave };
+}
+/** An 8-measure C-major "Twinkle Twinkle Little Star" melody on a single piano track. */
+export function twinkleScore() {
+    const ids = makeIdFactory();
+    const ppq = 480;
+    const q = (step, octave = 4) => ({
+        pitch: naturalPitch(step, octave),
+        duration: 'quarter',
+    });
+    const h = (step, octave = 4) => ({
+        pitch: naturalPitch(step, octave),
+        duration: 'half',
+    });
+    const measures = [
+        [q('C'), q('C'), q('G'), q('G')],
+        [q('A'), q('A'), h('G')],
+        [q('F'), q('F'), q('E'), q('E')],
+        [q('D'), q('D'), h('C')],
+        [q('G'), q('G'), q('F'), q('F')],
+        [q('E'), q('E'), h('D')],
+        [q('G'), q('G'), q('F'), q('F')],
+        [q('E'), q('E'), h('D')],
+    ];
+    const trackId = ids.next('track');
+    const track = {
+        id: trackId,
+        name: 'Piano',
+        instrumentName: 'Piano',
+        midiProgram: 0,
+        midiChannel: 0,
+        clef: 'treble',
+        volume: 1,
+        pan: 0,
+        muted: false,
+        solo: false,
+        measures: buildMelodyMeasures(measures, ppq, FOUR_FOUR, C_MAJOR, trackId, ids),
+    };
+    return {
+        id: ids.next('score'),
+        version: 1,
+        ppq,
+        metadata: {
+            title: 'Twinkle Twinkle Little Star',
+            createdAt: FIXED_TIMESTAMP,
+            updatedAt: FIXED_TIMESTAMP,
+        },
+        tempoMap: [{ id: ids.next('tempo'), tick: 0, bpm: 120 }],
+        tracks: [track],
+    };
+}
+/** A 4-measure two-track score: a treble melody and a supporting bass line. */
+export function twoTrackScore() {
+    const ids = makeIdFactory();
+    const ppq = 480;
+    const q = (step, octave) => ({
+        pitch: naturalPitch(step, octave),
+        duration: 'quarter',
+    });
+    const w = (step, octave) => ({
+        pitch: naturalPitch(step, octave),
+        duration: 'whole',
+    });
+    const trebleMeasures = [
+        [q('C', 4), q('D', 4), q('E', 4), q('F', 4)],
+        [q('G', 4), q('F', 4), q('E', 4), q('D', 4)],
+        [q('C', 4), q('D', 4), q('E', 4), q('F', 4)],
+        [q('G', 4), q('F', 4), q('E', 4), q('D', 4)],
+    ];
+    const bassMeasures = [
+        [w('C', 2)],
+        [w('G', 2)],
+        [w('C', 2)],
+        [w('G', 2)],
+    ];
+    const trebleId = ids.next('track');
+    const bassId = ids.next('track');
+    const treble = {
+        id: trebleId,
+        name: 'Treble',
+        instrumentName: 'Piano',
+        midiProgram: 0,
+        midiChannel: 0,
+        clef: 'treble',
+        volume: 1,
+        pan: 0,
+        muted: false,
+        solo: false,
+        measures: buildMelodyMeasures(trebleMeasures, ppq, FOUR_FOUR, C_MAJOR, trebleId, ids),
+    };
+    const bass = {
+        id: bassId,
+        name: 'Bass',
+        instrumentName: 'Acoustic Bass',
+        midiProgram: 32,
+        midiChannel: 1,
+        clef: 'bass',
+        volume: 1,
+        pan: 0,
+        muted: false,
+        solo: false,
+        measures: buildMelodyMeasures(bassMeasures, ppq, FOUR_FOUR, C_MAJOR, bassId, ids),
+    };
+    return {
+        id: ids.next('score'),
+        version: 1,
+        ppq,
+        metadata: {
+            title: 'Two Track Demo',
+            createdAt: FIXED_TIMESTAMP,
+            updatedAt: FIXED_TIMESTAMP,
+        },
+        tempoMap: [{ id: ids.next('tempo'), tick: 0, bpm: 120 }],
+        tracks: [treble, bass],
+    };
+}
+/**
+ * Three tracks over 2 measures, deliberately plain.
+ *
+ * For tests about *which* tracks are involved — visibility, active-track
+ * resolution, per-track filtering — where two tracks cannot tell "the first
+ * one" apart from "the first visible one", and the music itself is beside the
+ * point.
+ */
+export function threeTrackScore() {
+    const ids = makeIdFactory();
+    const ppq = 480;
+    const q = (step, octave) => ({
+        pitch: naturalPitch(step, octave),
+        duration: 'quarter',
+    });
+    const measures = [
+        [q('C', 4), q('D', 4), q('E', 4), q('F', 4)],
+        [q('G', 4), q('F', 4), q('E', 4), q('D', 4)],
+    ];
+    const tracks = ['Alpha', 'Beta', 'Gamma'].map((name, index) => {
+        const trackId = ids.next('track');
+        return {
+            id: trackId,
+            name,
+            instrumentName: 'Piano',
+            midiProgram: 0,
+            midiChannel: index,
+            clef: 'treble',
+            volume: 1,
+            pan: 0,
+            muted: false,
+            solo: false,
+            measures: buildMelodyMeasures(measures, ppq, FOUR_FOUR, C_MAJOR, trackId, ids),
+        };
+    });
+    return {
+        id: ids.next('score'),
+        version: 1,
+        ppq,
+        metadata: {
+            title: 'Three Track Demo',
+            createdAt: FIXED_TIMESTAMP,
+            updatedAt: FIXED_TIMESTAMP,
+        },
+        tempoMap: [{ id: ids.next('tempo'), tick: 0, bpm: 120 }],
+        tracks,
+    };
+}
+/**
+ * Two tracks with sharply different densities: a treble line of 16
+ * sixteenth notes per measure over a bass of one whole note per measure.
+ * Exercises cross-track timeline sync — the dense track needs a wider
+ * measure than `BASE_MEASURE_WIDTH` and must still share barlines and
+ * tick-aligned x positions with the sparse track.
+ */
+export function denseVsSparseScore() {
+    const ids = makeIdFactory();
+    const ppq = 480;
+    const s = (step, octave) => ({
+        pitch: naturalPitch(step, octave),
+        duration: 'sixteenth',
+    });
+    const w = (step, octave) => ({
+        pitch: naturalPitch(step, octave),
+        duration: 'whole',
+    });
+    const runUp = ['C', 'D', 'E', 'F', 'G', 'A', 'B']
+        .flatMap(step => [s(step, 4), s(step, 4)])
+        .concat([s('C', 5), s('C', 5)]);
+    const denseMeasures = [runUp, runUp, runUp, runUp];
+    const sparseMeasures = [
+        [w('C', 2)],
+        [w('G', 2)],
+        [w('C', 2)],
+        [w('G', 2)],
+    ];
+    const denseId = ids.next('track');
+    const sparseId = ids.next('track');
+    const dense = {
+        id: denseId,
+        name: 'Dense',
+        instrumentName: 'Piano',
+        midiProgram: 0,
+        midiChannel: 0,
+        clef: 'treble',
+        volume: 1,
+        pan: 0,
+        muted: false,
+        solo: false,
+        measures: buildMelodyMeasures(denseMeasures, ppq, FOUR_FOUR, C_MAJOR, denseId, ids),
+    };
+    const sparse = {
+        id: sparseId,
+        name: 'Sparse',
+        instrumentName: 'Acoustic Bass',
+        midiProgram: 32,
+        midiChannel: 1,
+        clef: 'bass',
+        volume: 1,
+        pan: 0,
+        muted: false,
+        solo: false,
+        measures: buildMelodyMeasures(sparseMeasures, ppq, FOUR_FOUR, C_MAJOR, sparseId, ids),
+    };
+    return {
+        id: ids.next('score'),
+        version: 1,
+        ppq,
+        metadata: {
+            title: 'Dense vs Sparse',
+            createdAt: FIXED_TIMESTAMP,
+            updatedAt: FIXED_TIMESTAMP,
+        },
+        tempoMap: [{ id: ids.next('tempo'), tick: 0, bpm: 120 }],
+        tracks: [dense, sparse],
+    };
+}
+/** A 4-measure I-IV-V-I block-chord progression on a single piano track. */
+export function chordScore() {
+    const ids = makeIdFactory();
+    const ppq = 480;
+    const chords = [
+        [naturalPitch('C', 4), naturalPitch('E', 4), naturalPitch('G', 4)], // I
+        [naturalPitch('F', 4), naturalPitch('A', 4), naturalPitch('C', 5)], // IV
+        [naturalPitch('G', 4), naturalPitch('B', 4), naturalPitch('D', 5)], // V
+        [naturalPitch('C', 4), naturalPitch('E', 4), naturalPitch('G', 4)], // I
+    ];
+    const trackId = ids.next('track');
+    const track = {
+        id: trackId,
+        name: 'Piano',
+        instrumentName: 'Piano',
+        midiProgram: 0,
+        midiChannel: 0,
+        clef: 'treble',
+        volume: 1,
+        pan: 0,
+        muted: false,
+        solo: false,
+        measures: buildChordMeasures(chords, ppq, FOUR_FOUR, C_MAJOR, trackId, ids),
+    };
+    return {
+        id: ids.next('score'),
+        version: 1,
+        ppq,
+        metadata: {
+            title: 'Chord Progression Demo',
+            createdAt: FIXED_TIMESTAMP,
+            updatedAt: FIXED_TIMESTAMP,
+        },
+        tempoMap: [{ id: ids.next('tempo'), tick: 0, bpm: 90 }],
+        tracks: [track],
+    };
+}
+const STRESS_SCALE = ['C', 'D', 'E', 'F', 'G', 'A', 'B'];
+/**
+ * Generates a score with `trackCount` tracks of `measureCount` measures
+ * each (4 quarter notes per measure, cycling through a C-major scale), for
+ * performance/stress tests. Deterministic and allocation-light.
+ */
+export function stressScore(trackCount, measureCount) {
+    const ids = makeIdFactory();
+    const ppq = 480;
+    const measureTicks = measureDurationTicks(FOUR_FOUR, ppq);
+    const quarterTicks = ticksFor('quarter', ppq);
+    const tracks = [];
+    for (let t = 0; t < trackCount; t += 1) {
+        const trackId = ids.next('track');
+        const measures = [];
+        for (let m = 0; m < measureCount; m += 1) {
+            const startTick = m * measureTicks;
+            const voiceId = ids.next('voice');
+            const events = [];
+            for (let beat = 0; beat < 4; beat += 1) {
+                const step = STRESS_SCALE[(t + m + beat) % STRESS_SCALE.length];
+                events.push({
+                    id: ids.next('note'),
+                    pitch: naturalPitch(step, 4),
+                    startTick: startTick + beat * quarterTicks,
+                    durationTicks: quarterTicks,
+                    velocity: 80,
+                    voiceId,
+                    trackId,
+                });
+            }
+            measures.push({
+                id: ids.next('measure'),
+                index: m,
+                startTick,
+                durationTicks: measureTicks,
+                timeSignature: FOUR_FOUR,
+                keySignature: C_MAJOR,
+                voices: [{ id: voiceId, name: 'Voice 1', events }],
+            });
+        }
+        tracks.push({
+            id: trackId,
+            name: `Track ${t + 1}`,
+            instrumentName: 'Piano',
+            midiProgram: 0,
+            midiChannel: t % 16,
+            clef: 'treble',
+            volume: 1,
+            pan: 0,
+            muted: false,
+            solo: false,
+            measures,
+        });
+    }
+    return {
+        id: ids.next('score'),
+        version: 1,
+        ppq,
+        metadata: {
+            title: `Stress ${trackCount}x${measureCount}`,
+            createdAt: FIXED_TIMESTAMP,
+            updatedAt: FIXED_TIMESTAMP,
+        },
+        tempoMap: [{ id: ids.next('tempo'), tick: 0, bpm: 120 }],
+        tracks,
+    };
+}
+/**
+ * A `RenderTheme` for tests: every role gets a distinct, obviously-fake
+ * value so an assertion that the wrong role was used fails loudly instead of
+ * matching a lookalike hex. Shared here (rather than redeclared per suite)
+ * so adding a role to `RenderTheme` breaks in one place, and so consuming
+ * apps' jsdom suites can import the same object.
+ */
+export function testRenderTheme() {
+    return {
+        foreground: '#111111',
+        noteNormal: '#222222',
+        noteInactive: '#888888',
+        noteSelected: '#333333',
+        noteRegenerated: '#444444',
+        notePlaying: '#555555',
+        staveActive: '#666666',
+        staveInactive: '#777777',
+        caret: '#888888',
+    };
+}
+//# sourceMappingURL=fixtures.js.map