@sudobility/music_types 0.11.19 → 0.11.21

package/dist/services/regeneration/controller.js

@@ -0,0 +1,202 @@
+/**
+ * Regeneration workflow controller (spec §12): turns a score selection +
+ * instruction into a structured `RegenerateRegionRequest` (extracting
+ * preceding/selected/following context, expanding a partial-measure
+ * selection to full measures), and turns an accepted candidate back into a
+ * single undoable `ScoreCommand`.
+ */
+import { findTrack } from '../../domain/score/queries.js';
+import { selectionToRange } from '../../domain/selection/selection.js';
+import { extractFragment } from '../../domain/score/fragment.js';
+import { replaceRegionCommand } from '../../domain/commands/region-commands.js';
+/**
+ * One, always. Generation is a background job now: nobody is present to pick
+ * between alternatives when it lands, so a result that needed choosing would
+ * leave the project in limbo.
+ */
+const CANDIDATE_COUNT = 1;
+const CONTEXT_MEASURE_LIMIT = 2;
+/**
+ * The tick extent implied by `sel` *before* any measure-boundary
+ * alignment — duplicates the first half of `selectionToRange`'s logic
+ * (which always returns an already-aligned range) so this controller can
+ * detect whether alignment actually changed anything.
+ */
+function rawTickExtent(score, sel) {
+    let min = Infinity;
+    let max = -Infinity;
+    for (const eventId of sel.eventIds) {
+        const event = findEventTicks(score, eventId);
+        if (!event)
+            continue;
+        min = Math.min(min, event.start);
+        max = Math.max(max, event.end);
+    }
+    for (const measureId of sel.measureIds) {
+        const measure = findMeasureTicks(score, measureId);
+        if (!measure)
+            continue;
+        min = Math.min(min, measure.start);
+        max = Math.max(max, measure.end);
+    }
+    if (sel.range) {
+        min = Math.min(min, sel.range.startTick);
+        max = Math.max(max, sel.range.endTick);
+    }
+    if (!Number.isFinite(min) || !Number.isFinite(max))
+        return null;
+    return { start: min, end: max };
+}
+function findEventTicks(score, eventId) {
+    for (const track of score.tracks) {
+        for (const measure of track.measures) {
+            for (const voice of measure.voices) {
+                const event = voice.events.find(e => e.id === eventId);
+                if (event)
+                    return {
+                        start: event.startTick,
+                        end: event.startTick + event.durationTicks,
+                    };
+            }
+        }
+    }
+    return null;
+}
+function findMeasureTicks(score, measureId) {
+    for (const track of score.tracks) {
+        const measure = track.measures.find(m => m.id === measureId);
+        if (measure)
+            return {
+                start: measure.startTick,
+                end: measure.startTick + measure.durationTicks,
+            };
+    }
+    return null;
+}
+/** Up to `maxMeasures` measures immediately preceding `range.startTick`, unioned across `range`'s tracks (all tracks if `range.trackIds` is empty). */
+function precedingContextRange(score, range, maxMeasures) {
+    const trackIds = range.trackIds.length > 0 ? range.trackIds : score.tracks.map(t => t.id);
+    let earliestStart = range.startTick;
+    for (const trackId of trackIds) {
+        const track = findTrack(score, trackId);
+        if (!track)
+            continue;
+        const priorMeasures = track.measures
+            .filter(m => m.startTick < range.startTick)
+            .slice(-maxMeasures);
+        if (priorMeasures.length > 0) {
+            earliestStart = Math.min(earliestStart, priorMeasures[0].startTick);
+        }
+    }
+    return {
+        startTick: earliestStart,
+        endTick: range.startTick,
+        trackIds: range.trackIds,
+    };
+}
+/** Up to `maxMeasures` measures immediately following `range.endTick`, unioned across `range`'s tracks (all tracks if `range.trackIds` is empty). */
+function followingContextRange(score, range, maxMeasures) {
+    const trackIds = range.trackIds.length > 0 ? range.trackIds : score.tracks.map(t => t.id);
+    let latestEnd = range.endTick;
+    for (const trackId of trackIds) {
+        const track = findTrack(score, trackId);
+        if (!track)
+            continue;
+        const nextMeasures = track.measures
+            .filter(m => m.startTick >= range.endTick)
+            .slice(0, maxMeasures);
+        if (nextMeasures.length > 0) {
+            const last = nextMeasures[nextMeasures.length - 1];
+            latestEnd = Math.max(latestEnd, last.startTick + last.durationTicks);
+        }
+    }
+    return {
+        startTick: range.endTick,
+        endTick: latestEnd,
+        trackIds: range.trackIds,
+    };
+}
+/**
+ * Builds a `RegenerateRegionRequest` for `selection` on `score`: aligns the
+ * selection to full-measure boundaries (`selectionToRange` always does
+ * this; `expandedToFullMeasures` reports whether that changed anything),
+ * and extracts up to 2 measures of preceding/following context alongside
+ * the selected fragment itself (spec §12 steps 1-3).
+ *
+ * Throws if `selection` has no resolvable tick range (nothing selected).
+ */
+export function prepareRegenerationRequest(score, selection, instruction, options = {}) {
+    const alignedRange = selectionToRange(score, selection);
+    if (!alignedRange) {
+        throw new Error('prepareRegenerationRequest: selection has no resolvable tick range.');
+    }
+    const raw = rawTickExtent(score, selection);
+    const expandedToFullMeasures = raw !== null &&
+        (raw.start !== alignedRange.startTick || raw.end !== alignedRange.endTick);
+    // `selectionToRange` has already aligned, so the region below is aligned by
+    // construction — hence the explicit `true` rather than trusting the default.
+    return {
+        ...prepareRegenerationRequestForRange(score, alignedRange, instruction, {
+            ...options,
+            measureAligned: true,
+        }),
+        expandedToFullMeasures,
+    };
+}
+/**
+ * Builds a request for an explicit tick range, used **verbatim**.
+ *
+ * This is the entry point Replace Notes needs. `prepareRegenerationRequest`
+ * snaps its selection out to whole measures, which is exactly what "replace
+ * only these notes" forbids; the snapping policy lives there alone so it
+ * cannot be half-applied here.
+ *
+ * `expandedToFullMeasures` is always false: nothing was expanded, because
+ * nothing was derived — the caller said what it meant.
+ */
+export function prepareRegenerationRequestForRange(score, range, instruction, options = {}) {
+    const selectedFragment = extractFragment(score, range);
+    const precedingContext = extractFragment(score, precedingContextRange(score, range, CONTEXT_MEASURE_LIMIT));
+    const followingContext = extractFragment(score, followingContextRange(score, range, CONTEXT_MEASURE_LIMIT));
+    const constraints = {
+        // Omitted, not false, when the region does not sit on barlines: there is
+        // no measure count to preserve, and asserting one confuses the prompt.
+        ...((options.measureAligned ?? true)
+            ? { preserveMeasureCount: true }
+            : {}),
+        preserveTimeSignatures: true,
+        preserveTempoEvents: true,
+        ...options.constraints,
+    };
+    return {
+        scoreId: score.id,
+        instruction,
+        range,
+        precedingContext,
+        selectedFragment,
+        followingContext,
+        constraints,
+        candidateCount: CANDIDATE_COUNT,
+        ...(options.style ? { style: options.style } : {}),
+        ...(options.mood ? { mood: options.mood } : {}),
+        ...(options.complexity ? { complexity: options.complexity } : {}),
+        expandedToFullMeasures: false,
+    };
+}
+/**
+ * Turns an accepted regeneration `candidate` into the single undoable
+ * `ScoreCommand` that replaces the region with the candidate's fragment
+ * (spec §12 steps 10-13). `score` is used defensively, to confirm every
+ * track the candidate references still exists before building the command
+ * (a candidate produced against a since-edited score could reference a
+ * deleted track).
+ */
+export function applyCandidate(score, candidate) {
+    const { range } = candidate.fragment;
+    const missingTrackId = range.trackIds.find(id => findTrack(score, id) === null);
+    if (missingTrackId) {
+        throw new Error(`applyCandidate: candidate references track "${missingTrackId}", which is not present in the score.`);
+    }
+    return replaceRegionCommand(range, candidate.fragment);
+}
+//# sourceMappingURL=controller.js.map

package/dist/services/regeneration/controller.js.map

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

package/dist/test/fixtures.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Score fixtures for the codec suites.
+ *
+ * Copied from `music_lib`'s test tree when the codecs moved here, minus
+ * `testRenderTheme` — that one needs a `RenderTheme`, and nothing in this
+ * package renders anything.
+ */
+/**
+ * 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 '../index.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;
+//# 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;AAEH;;;;;;GAMG;AACH,OAAO,KAAK,EAMV,KAAK,EAGN,MAAM,aAAa,CAAC;AAsGrB,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"}

package/dist/test/fixtures.js

@@ -0,0 +1,420 @@
+/**
+ * Score fixtures for the codec suites.
+ *
+ * Copied from `music_lib`'s test tree when the codecs moved here, minus
+ * `testRenderTheme` — that one needs a `RenderTheme`, and nothing in this
+ * package renders anything.
+ */
+import { measureDurationTicks, ticksFor } from '../index.js';
+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,
+    };
+}
+//# sourceMappingURL=fixtures.js.map