@sudobility/music_player 0.1.0 → 0.1.2

package/dist/shared/pump-window.d.ts

@@ -0,0 +1,38 @@
+/**
+ * What the pump does with the notes it drained, as pure logic.
+ *
+ * Kept apart from the posting so the rule that matters can be tested without
+ * an audio device: a note whose moment has already passed by more than the
+ * grace window is skipped rather than fired late.
+ *
+ * That rule is the one deliberate exception to "no note is ever dropped", and
+ * it earns its place. Without it, a main-thread stall turns into a backlog
+ * that arrives in a single burst — every note that should have been spread
+ * over the stall landing at once. Late notes are worse than absent ones: the
+ * absent one is a gap, the burst is a garble across every part at once.
+ *
+ * A note only slightly late is still played, because the ear will not notice
+ * and dropping it would be gratuitous.
+ *
+ * **The React Native sample engine is now its only consumer.** The web engine
+ * hands a four-second horizon of self-releasing notes to the fluidsynth
+ * sequencer instead, so nothing there is ever dispatched late enough to need
+ * skipping — see `soundfont-engine.ts`'s `HORIZON_SECONDS`. RN has no sequencer
+ * to hand a horizon to and keeps this model.
+ */
+import type { PlaybackNote as ScheduledNote } from '@sudobility/music_types';
+export type Dispatch = {
+    note: ScheduledNote;
+    atSeconds: number;
+};
+export declare function planDispatch({ notes, secondsForTick, positionSeconds, graceSeconds, }: {
+    notes: readonly ScheduledNote[];
+    /** Tick to playback seconds — the engine's, since it owns the tempo map and speed. */
+    secondsForTick: (tick: number) => number;
+    positionSeconds: number;
+    graceSeconds: number;
+}): {
+    due: Dispatch[];
+    skipped: ScheduledNote[];
+};
+//# sourceMappingURL=pump-window.d.ts.map

package/dist/shared/pump-window.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pump-window.d.ts","sourceRoot":"","sources":["../../src/shared/pump-window.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,OAAO,KAAK,EAAE,YAAY,IAAI,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAE7E,MAAM,MAAM,QAAQ,GAAG;IAAE,IAAI,EAAE,aAAa,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CAAC;AAElE,wBAAgB,YAAY,CAAC,EAC3B,KAAK,EACL,cAAc,EACd,eAAe,EACf,YAAY,GACb,EAAE;IACD,KAAK,EAAE,SAAS,aAAa,EAAE,CAAC;IAChC,sFAAsF;IACtF,cAAc,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC;IACzC,eAAe,EAAE,MAAM,CAAC;IACxB,YAAY,EAAE,MAAM,CAAC;CACtB,GAAG;IAAE,GAAG,EAAE,QAAQ,EAAE,CAAC;IAAC,OAAO,EAAE,aAAa,EAAE,CAAA;CAAE,CAShD"}

package/dist/shared/pump-window.js

@@ -0,0 +1,13 @@
+export function planDispatch({ notes, secondsForTick, positionSeconds, graceSeconds, }) {
+    const due = [];
+    const skipped = [];
+    for (const note of notes) {
+        const atSeconds = secondsForTick(note.tick);
+        if (positionSeconds - atSeconds > graceSeconds)
+            skipped.push(note);
+        else
+            due.push({ note, atSeconds });
+    }
+    return { due, skipped };
+}
+//# sourceMappingURL=pump-window.js.map

package/dist/shared/pump-window.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pump-window.js","sourceRoot":"","sources":["../../src/shared/pump-window.ts"],"names":[],"mappings":"AA0BA,MAAM,UAAU,YAAY,CAAC,EAC3B,KAAK,EACL,cAAc,EACd,eAAe,EACf,YAAY,GAOb;IACC,MAAM,GAAG,GAAe,EAAE,CAAC;IAC3B,MAAM,OAAO,GAAoB,EAAE,CAAC;IACpC,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;QACzB,MAAM,SAAS,GAAG,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAC5C,IAAI,eAAe,GAAG,SAAS,GAAG,YAAY;YAAE,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;;YAC9D,GAAG,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE,CAAC,CAAC;IACrC,CAAC;IACD,OAAO,EAAE,GAAG,EAAE,OAAO,EAAE,CAAC;AAC1B,CAAC"}

package/dist/shared/render-events.d.ts

@@ -0,0 +1,25 @@
+import type { Score } from '@sudobility/music_types';
+import type { RenderPlan } from '@sudobility/music_types';
+export type { RenderEvent, RenderPlan, RenderTrack, } from '@sudobility/music_types';
+/**
+ * The plan an export should sound, matching live playback.
+ *
+ * **Mute and solo are respected**, because they are part of how the score
+ * currently sounds, and an export that ignored them would not match what you
+ * just heard. Solo wins: if anything is soloed, only soloed tracks sound.
+ *
+ * Every track appears in `tracks` regardless — silent, muted, soloed away —
+ * because the renderer sizes its mix headroom by how many channels exist, as
+ * playback does. Only a track's *notes* are dropped when it is silenced.
+ *
+ * `isPercussion` comes from the clef and not the MIDI channel, and the voice is
+ * left for the renderer to resolve from `midiProgram`/`instrumentName`: both
+ * are the signals live playback uses, and the export sounding different from
+ * the thing it is an export *of* is the bug being fixed here.
+ *
+ * That parity is now structural: the notes come from `flattenScoreNotes`, the
+ * same traversal `playbackPlan` uses. Walking the score separately is what let
+ * the two drift over ties.
+ */
+export declare function renderEvents(score: Score): RenderPlan;
+//# sourceMappingURL=render-events.d.ts.map

package/dist/shared/render-events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"render-events.d.ts","sourceRoot":"","sources":["../../src/shared/render-events.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,yBAAyB,CAAC;AAErD,OAAO,KAAK,EAEV,UAAU,EAEX,MAAM,yBAAyB,CAAC;AACjC,YAAY,EACV,WAAW,EACX,UAAU,EACV,WAAW,GACZ,MAAM,yBAAyB,CAAC;AAKjC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,KAAK,GAAG,UAAU,CAsDrD"}

package/dist/shared/render-events.js

@@ -0,0 +1,79 @@
+/**
+ * A score flattened into timed events, ready for an offline audio render.
+ *
+ * Deliberately score-in, events-out: the actual rendering needs Tone.js and an
+ * audio context, so it lives in music_io. Everything *musical* about an export
+ * — which tracks sound, when each note starts, how long the file has to be —
+ * is decided here, where it can be tested without a browser.
+ */
+import { TempoMap } from '@sudobility/music_types';
+import { fermataTempoMap } from '@sudobility/music_types';
+import { flattenScoreNotes } from '@sudobility/music_types';
+import { resolveVoice } from './plan.js';
+/** Release tail, so the last note is not cut off mid-decay. */
+const TAIL_SEC = 1;
+/**
+ * The plan an export should sound, matching live playback.
+ *
+ * **Mute and solo are respected**, because they are part of how the score
+ * currently sounds, and an export that ignored them would not match what you
+ * just heard. Solo wins: if anything is soloed, only soloed tracks sound.
+ *
+ * Every track appears in `tracks` regardless — silent, muted, soloed away —
+ * because the renderer sizes its mix headroom by how many channels exist, as
+ * playback does. Only a track's *notes* are dropped when it is silenced.
+ *
+ * `isPercussion` comes from the clef and not the MIDI channel, and the voice is
+ * left for the renderer to resolve from `midiProgram`/`instrumentName`: both
+ * are the signals live playback uses, and the export sounding different from
+ * the thing it is an export *of* is the bug being fixed here.
+ *
+ * That parity is now structural: the notes come from `flattenScoreNotes`, the
+ * same traversal `playbackPlan` uses. Walking the score separately is what let
+ * the two drift over ties.
+ */
+export function renderEvents(score) {
+    // The same derived map live playback uses, so an exported file holds its
+    // pauses for exactly as long as the transport just did.
+    const tempoMap = new TempoMap(fermataTempoMap(score), score.ppq);
+    const anySolo = score.tracks.some(t => t.solo);
+    const tracks = score.tracks.map(track => {
+        const isPercussion = track.clef === 'percussion';
+        // The renderer picks its sample pack from this, and a percussion track's
+        // midiProgram addresses a kit rather than an instrument.
+        const voice = resolveVoice(track.midiProgram, isPercussion, track.instrumentName);
+        return {
+            id: track.id,
+            midiProgram: track.midiProgram,
+            instrumentName: track.instrumentName,
+            isPercussion,
+            volume: track.volume,
+            pan: track.pan,
+            voiceProgram: voice.program,
+            voiceName: voice.name,
+        };
+    });
+    // The same traversal live playback uses, so ties are joined here too. They
+    // were not, and a tie re-articulated in the exported file while sustaining
+    // on screen — measured: one note of 960 ticks live, two of 0.5s offline.
+    const silenced = new Set(score.tracks.filter(t => (anySolo ? !t.solo : t.muted)).map(t => t.id));
+    const events = [];
+    for (const note of flattenScoreNotes(score)) {
+        if (silenced.has(note.trackId))
+            continue;
+        const startSec = tempoMap.ticksToSeconds(note.tick);
+        const endSec = tempoMap.ticksToSeconds(note.tick + note.durTicks);
+        events.push({
+            trackId: note.trackId,
+            midi: note.midi,
+            startSec,
+            // Never zero: a rounding error should not silence a note.
+            durationSec: Math.max(0.01, endSec - startSec),
+            velocity: note.velocity / 127,
+        });
+    }
+    events.sort((a, b) => a.startSec - b.startSec);
+    const lastEnd = events.reduce((max, e) => Math.max(max, e.startSec + e.durationSec), 0);
+    return { tracks, events, durationSec: lastEnd + TAIL_SEC };
+}
+//# sourceMappingURL=render-events.js.map

package/dist/shared/render-events.js.map

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

package/dist/shared/sounding-set.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Which notes are sounding at a given moment, by two monotonic cursors.
+ *
+ * Replaces deriving the set from a list of pending note-offs the pump walked
+ * every tick — a list that no longer exists, because releases happen in the
+ * worklet now. One cursor over notes by start, one over the same notes by end;
+ * both only ever move forward, so a step costs the number of notes that
+ * actually started or stopped rather than the size of the score.
+ *
+ * `advanceTo` returns `null` when nothing changed, which is the point. The
+ * engine used to hand its observer a freshly-allocated array twenty times a
+ * second whether or not a single note had begun or ended, waking every
+ * consumer downstream — notation colour, the piano keyboard's key lights — for
+ * nothing.
+ */
+import type { SoundingNote } from '@sudobility/music_types';
+import type { PlaybackNote as ScheduledNote } from '@sudobility/music_types';
+export declare class SoundingSet {
+    private byStart;
+    private byEnd;
+    private startCursor;
+    private endCursor;
+    /**
+     * Keyed by note id so an end can remove the right entry, valued by the
+     * resolved note so a consumer never has to search the score for the track and
+     * pitch the scheduler already knew.
+     */
+    private sounding;
+    /** Forces the next `advanceTo` to emit, so a reset is always observable. */
+    private dirty;
+    load(notes: readonly ScheduledNote[], secondsForTick: (tick: number) => number): void;
+    /**
+     * Drops everything sounding and moves both cursors to `positionSeconds`.
+     *
+     * A note spanning that moment is deliberately *not* restored: the engine
+     * silences the synth on every seek and stop, so nothing is audible there
+     * either. Highlighting a note that is not sounding would be a lie.
+     */
+    reset(positionSeconds: number): void;
+    /** The ids sounding at `positionSeconds`, or `null` if they are what they were. */
+    advanceTo(positionSeconds: number): SoundingNote[] | null;
+    /** How many notes are sounding. */
+    get size(): number;
+}
+//# sourceMappingURL=sounding-set.d.ts.map

package/dist/shared/sounding-set.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sounding-set.d.ts","sourceRoot":"","sources":["../../src/shared/sounding-set.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAC5D,OAAO,KAAK,EAAE,YAAY,IAAI,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAE7E,qBAAa,WAAW;IACtB,OAAO,CAAC,OAAO,CAA2D;IAC1E,OAAO,CAAC,KAAK,CAAqD;IAClE,OAAO,CAAC,WAAW,CAAK;IACxB,OAAO,CAAC,SAAS,CAAK;IACtB;;;;OAIG;IACH,OAAO,CAAC,QAAQ,CAAmC;IACnD,4EAA4E;IAC5E,OAAO,CAAC,KAAK,CAAQ;IAErB,IAAI,CACF,KAAK,EAAE,SAAS,aAAa,EAAE,EAC/B,cAAc,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,GACvC,IAAI;IAgBP;;;;;;OAMG;IACH,KAAK,CAAC,eAAe,EAAE,MAAM,GAAG,IAAI;IAWpC,mFAAmF;IACnF,SAAS,CAAC,eAAe,EAAE,MAAM,GAAG,YAAY,EAAE,GAAG,IAAI;IA2BzD,mCAAmC;IACnC,IAAI,IAAI,IAAI,MAAM,CAEjB;CACF"}

package/dist/shared/sounding-set.js

@@ -0,0 +1,81 @@
+export class SoundingSet {
+    byStart = [];
+    byEnd = [];
+    startCursor = 0;
+    endCursor = 0;
+    /**
+     * Keyed by note id so an end can remove the right entry, valued by the
+     * resolved note so a consumer never has to search the score for the track and
+     * pitch the scheduler already knew.
+     */
+    sounding = new Map();
+    /** Forces the next `advanceTo` to emit, so a reset is always observable. */
+    dirty = true;
+    load(notes, secondsForTick) {
+        this.byStart = notes
+            .map(n => ({
+            note: { noteId: n.noteId, trackId: n.trackId, midi: n.midi },
+            startSeconds: secondsForTick(n.tick),
+        }))
+            .sort((a, b) => a.startSeconds - b.startSeconds);
+        this.byEnd = notes
+            .map(n => ({
+            noteId: n.noteId,
+            endSeconds: secondsForTick(n.tick + n.durTicks),
+        }))
+            .sort((a, b) => a.endSeconds - b.endSeconds);
+        this.reset(0);
+    }
+    /**
+     * Drops everything sounding and moves both cursors to `positionSeconds`.
+     *
+     * A note spanning that moment is deliberately *not* restored: the engine
+     * silences the synth on every seek and stop, so nothing is audible there
+     * either. Highlighting a note that is not sounding would be a lie.
+     */
+    reset(positionSeconds) {
+        this.sounding.clear();
+        this.startCursor = lowerBound(this.byStart, positionSeconds, e => e.startSeconds);
+        this.endCursor = lowerBound(this.byEnd, positionSeconds, e => e.endSeconds);
+        this.dirty = true;
+    }
+    /** The ids sounding at `positionSeconds`, or `null` if they are what they were. */
+    advanceTo(positionSeconds) {
+        let changed = this.dirty;
+        this.dirty = false;
+        while (this.startCursor < this.byStart.length &&
+            this.byStart[this.startCursor].startSeconds <= positionSeconds) {
+            const { note } = this.byStart[this.startCursor];
+            this.sounding.set(note.noteId, note);
+            this.startCursor += 1;
+            changed = true;
+        }
+        while (this.endCursor < this.byEnd.length &&
+            this.byEnd[this.endCursor].endSeconds <= positionSeconds) {
+            // Deleting an id that was never added — its start was skipped by a reset
+            // — is a no-op, which is what makes seeking into a held note safe.
+            if (this.sounding.delete(this.byEnd[this.endCursor].noteId))
+                changed = true;
+            this.endCursor += 1;
+        }
+        return changed ? [...this.sounding.values()] : null;
+    }
+    /** How many notes are sounding. */
+    get size() {
+        return this.sounding.size;
+    }
+}
+/** First index whose key is >= `value`. */
+function lowerBound(items, value, key) {
+    let lo = 0;
+    let hi = items.length;
+    while (lo < hi) {
+        const mid = (lo + hi) >> 1;
+        if (key(items[mid]) < value)
+            lo = mid + 1;
+        else
+            hi = mid;
+    }
+    return lo;
+}
+//# sourceMappingURL=sounding-set.js.map

package/dist/shared/sounding-set.js.map

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

package/dist/shared/test-plan.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Hand-built `PlaybackPlan`s for engine tests.
+ *
+ * The engines take a plan, not a score, so their tests build one directly
+ * rather than importing a score fixture and a converter from music_lib —
+ * which is what kept the platform layer depending on the domain. A plan is
+ * plain data, so this is also clearer: a test that needs two notes says so
+ * instead of asserting against whatever a fixture happens to contain.
+ *
+ * The default tempo is linear: 120 BPM at ppq 480 is 960 ticks per second, so
+ * `ticksToSeconds` is `tick / 960` and the arithmetic in assertions stays
+ * readable.
+ */
+import type { PlaybackNote, PlaybackPlan, PlaybackTrack, TempoConversion } from '@sudobility/music_types';
+export declare const TICKS_PER_SECOND = 960;
+export declare const LINEAR_TEMPO: TempoConversion;
+export declare function testTrack(over: Partial<PlaybackTrack> & {
+    id: string;
+}): PlaybackTrack;
+export declare function testNote(over: Partial<PlaybackNote> & {
+    trackId: string;
+}): PlaybackNote;
+export declare function testPlan(over?: Partial<PlaybackPlan>): PlaybackPlan;
+/** `count` pitched tracks numbered `t0..`, each on its own GM program. */
+export declare function planOfTracks(count: number, isPercussion?: boolean): PlaybackPlan;
+/**
+ * Two tracks over four bars of 4/4 — a quarter note per beat, alternating.
+ *
+ * The length is load-bearing at both ends. Long enough that the transport tests,
+ * which advance the clock by seconds and assert on scheduling several seconds
+ * ahead, still have music left to schedule; short enough that the sounding-note
+ * test, which steps ten seconds looking for the set to empty, sees it end. At
+ * 960 ticks per second this runs eight seconds.
+ */
+export declare function twoTrackPlan(): PlaybackPlan;
+//# sourceMappingURL=test-plan.d.ts.map

package/dist/shared/test-plan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-plan.d.ts","sourceRoot":"","sources":["../../src/shared/test-plan.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,KAAK,EACV,YAAY,EACZ,YAAY,EACZ,aAAa,EACb,eAAe,EAChB,MAAM,yBAAyB,CAAC;AAEjC,eAAO,MAAM,gBAAgB,MAAM,CAAC;AAEpC,eAAO,MAAM,YAAY,EAAE,eAG1B,CAAC;AAEF,wBAAgB,SAAS,CACvB,IAAI,EAAE,OAAO,CAAC,aAAa,CAAC,GAAG;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE,GAC5C,aAAa,CAcf;AAED,wBAAgB,QAAQ,CACtB,IAAI,EAAE,OAAO,CAAC,YAAY,CAAC,GAAG;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,GAChD,YAAY,CAYd;AAED,wBAAgB,QAAQ,CAAC,IAAI,GAAE,OAAO,CAAC,YAAY,CAAM,GAAG,YAAY,CAevE;AAED,0EAA0E;AAC1E,wBAAgB,YAAY,CAC1B,KAAK,EAAE,MAAM,EACb,YAAY,UAAQ,GACnB,YAAY,CAMd;AAED;;;;;;;;GAQG;AACH,wBAAgB,YAAY,IAAI,YAAY,CAoB3C"}

package/dist/shared/test-plan.js

@@ -0,0 +1,83 @@
+export const TICKS_PER_SECOND = 960;
+export const LINEAR_TEMPO = {
+    ticksToSeconds: tick => tick / TICKS_PER_SECOND,
+    secondsToTicks: seconds => seconds * TICKS_PER_SECOND,
+};
+export function testTrack(over) {
+    const midiProgram = over.midiProgram ?? 0;
+    return {
+        midiProgram,
+        instrumentName: 'x',
+        isPercussion: false,
+        volume: 1,
+        pan: 0,
+        muted: false,
+        solo: false,
+        voiceProgram: midiProgram,
+        voiceName: 'x',
+        ...over,
+    };
+}
+export function testNote(over) {
+    return {
+        tick: 0,
+        durTicks: 480,
+        midi: 60,
+        // MIDI's 0-127, which is the unit `PlaybackNote` carries — `RenderPlan` is
+        // the one that uses 0..1. This read 0.8 for a while, which both engines
+        // treat as the quietest note there is.
+        velocity: 96,
+        noteId: `n-${over.tick ?? 0}-${over.trackId}`,
+        ...over,
+    };
+}
+export function testPlan(over = {}) {
+    const tracks = over.tracks ?? [testTrack({ id: 't0' })];
+    const notes = over.notes ?? [];
+    return {
+        tracks,
+        notes,
+        clicks: over.clicks ?? [],
+        tempo: over.tempo ?? LINEAR_TEMPO,
+        // Identity by default: an engine test is about scheduling, not repeats,
+        // and this is what a score with no repeats produces.
+        timeline: over.timeline ?? { segments: [], durationTicks: 0 },
+        durationTicks: over.durationTicks ??
+            notes.reduce((n, note) => Math.max(n, note.tick + note.durTicks), 0),
+    };
+}
+/** `count` pitched tracks numbered `t0..`, each on its own GM program. */
+export function planOfTracks(count, isPercussion = false) {
+    return testPlan({
+        tracks: Array.from({ length: count }, (_, i) => testTrack({ id: `t${i}`, midiProgram: i, isPercussion, voiceProgram: i })),
+    });
+}
+/**
+ * Two tracks over four bars of 4/4 — a quarter note per beat, alternating.
+ *
+ * The length is load-bearing at both ends. Long enough that the transport tests,
+ * which advance the clock by seconds and assert on scheduling several seconds
+ * ahead, still have music left to schedule; short enough that the sounding-note
+ * test, which steps ten seconds looking for the set to empty, sees it end. At
+ * 960 ticks per second this runs eight seconds.
+ */
+export function twoTrackPlan() {
+    const BEATS = 16;
+    const tracks = [
+        testTrack({ id: 't0', midiProgram: 0, voiceProgram: 0 }),
+        testTrack({ id: 't1', midiProgram: 1, voiceProgram: 1 }),
+    ];
+    const notes = Array.from({ length: BEATS }, (_, i) => testNote({
+        trackId: i % 2 === 0 ? 't0' : 't1',
+        tick: i * 480,
+        durTicks: 480,
+        midi: 60 + (i % 12),
+        noteId: `n${i}`,
+    }));
+    const clicks = Array.from({ length: BEATS }, (_, i) => ({
+        tick: i * 480,
+        accent: i % 4 === 0,
+    }));
+    return testPlan({ tracks, notes, clicks });
+}
+//# sourceMappingURL=test-plan.js.map

package/dist/shared/test-plan.js.map

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

package/dist/singleton.d.ts

@@ -0,0 +1,23 @@
+/**
+ * The player singleton.
+ *
+ * Same shape as the rest of the family's services — initialise once at
+ * start-up, read it everywhere, reset it in tests.
+ *
+ * A singleton because there is one transport: one piece of music is playing,
+ * and two players would be two playheads, which is exactly the disagreement
+ * `MusicPosition` exists to prevent.
+ */
+import type { IMusicPlayer } from './types.js';
+export declare class MusicPlayerNotInitializedError extends Error {
+    constructor();
+}
+/**
+ * Idempotent, so a re-mounting composition root does not swap the transport out
+ * from under everything subscribed to it.
+ */
+export declare function initializeMusicPlayer(player: IMusicPlayer): IMusicPlayer;
+export declare function getMusicPlayer(): IMusicPlayer;
+/** Test-only: clears the singleton so suites cannot leak into each other. */
+export declare function resetMusicPlayer(): void;
+//# sourceMappingURL=singleton.d.ts.map

package/dist/singleton.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"singleton.d.ts","sourceRoot":"","sources":["../src/singleton.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAI/C,qBAAa,8BAA+B,SAAQ,KAAK;;CAOxD;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,YAAY,GAAG,YAAY,CAGxE;AAED,wBAAgB,cAAc,IAAI,YAAY,CAG7C;AAED,6EAA6E;AAC7E,wBAAgB,gBAAgB,IAAI,IAAI,CAEvC"}

package/dist/singleton.js

@@ -0,0 +1,26 @@
+let instance = null;
+export class MusicPlayerNotInitializedError extends Error {
+    constructor() {
+        super('The music player has not been initialized. Call initializeMusicPlayer() from your app composition root before using playback.');
+        this.name = 'MusicPlayerNotInitializedError';
+    }
+}
+/**
+ * Idempotent, so a re-mounting composition root does not swap the transport out
+ * from under everything subscribed to it.
+ */
+export function initializeMusicPlayer(player) {
+    if (!instance)
+        instance = player;
+    return instance;
+}
+export function getMusicPlayer() {
+    if (!instance)
+        throw new MusicPlayerNotInitializedError();
+    return instance;
+}
+/** Test-only: clears the singleton so suites cannot leak into each other. */
+export function resetMusicPlayer() {
+    instance = null;
+}
+//# sourceMappingURL=singleton.js.map

package/dist/singleton.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"singleton.js","sourceRoot":"","sources":["../src/singleton.ts"],"names":[],"mappings":"AAYA,IAAI,QAAQ,GAAwB,IAAI,CAAC;AAEzC,MAAM,OAAO,8BAA+B,SAAQ,KAAK;IACvD;QACE,KAAK,CACH,+HAA+H,CAChI,CAAC;QACF,IAAI,CAAC,IAAI,GAAG,gCAAgC,CAAC;IAC/C,CAAC;CACF;AAED;;;GAGG;AACH,MAAM,UAAU,qBAAqB,CAAC,MAAoB;IACxD,IAAI,CAAC,QAAQ;QAAE,QAAQ,GAAG,MAAM,CAAC;IACjC,OAAO,QAAQ,CAAC;AAClB,CAAC;AAED,MAAM,UAAU,cAAc;IAC5B,IAAI,CAAC,QAAQ;QAAE,MAAM,IAAI,8BAA8B,EAAE,CAAC;IAC1D,OAAO,QAAQ,CAAC;AAClB,CAAC;AAED,6EAA6E;AAC7E,MAAM,UAAU,gBAAgB;IAC9B,QAAQ,GAAG,IAAI,CAAC;AAClB,CAAC"}

package/dist/types.d.ts

@@ -0,0 +1,84 @@
+import type { PlaybackBus } from './shared/bus.js';
+import type { PlaybackLoadState, PlaybackTrack, Score, ScoreRange, SoundingNote, TransportPlaybackState } from '@sudobility/music_types';
+export type Unsubscribe = () => void;
+/**
+ * The transport.
+ *
+ * Takes a `Score`, not a plan: this package owns `playbackPlan`, so making the
+ * caller build one first would be a two-step dance whose second step is here.
+ * The *engine* underneath still takes a `PlaybackPlan` and does no score maths,
+ * which is where music_io's "handed a plan, never a score" rule was always
+ * actually about.
+ *
+ * Deliberately has no caret, and no `togglePlay`, `seekToMeasure`,
+ * `previousMeasure`, `nextMeasure` or loop-from-selection. Those read and write
+ * the caret or the selection, both of which are editing state; a copy of either
+ * here is a second thing that can disagree with the first. See `MusicPosition`
+ * in music_types for what that cost last time. They live in music_lib's
+ * playback adapter and compose the primitives below.
+ */
+export interface IMusicPlayer {
+    /**
+     * Adopts a score.
+     *
+     * **While playing, this is a mix change and nothing else** — the note queue is
+     * kept. The edit lock is what makes that safe: while the transport runs, the
+     * only score change that can reach here is a mix change. A score arriving
+     * from outside that path (a generation result, an opened snapshot) must be
+     * preceded by `stop()`, or it will be heard as the old score.
+     */
+    /**
+     * Rejects on failure rather than swallowing. The host translates: the message
+     * a user sees is a localized string, and this package carries no copy.
+     */
+    load(score: Score, opts?: {
+        visibleTrackIds?: readonly string[];
+    }): Promise<void>;
+    play(): Promise<void>;
+    pause(): void;
+    stop(): void;
+    /** Seeks to a *written* tick; the first performance of it, if repeats make several. */
+    seek(scoreTick: number): void;
+    setLoop(range: ScoreRange | null): void;
+    setTempoMultiplier(multiplier: number): void;
+    setMetronome(enabled: boolean): void;
+    setMasterVolume(volume: number): void;
+    /** Live, without rebuilding the note queue: mixing is not editing. */
+    applyMix(tracks: readonly PlaybackTrack[]): void;
+    /** A track sounds only if it is visible *and* not muted. */
+    setVisibleTracks(visibleTrackIds: readonly string[]): void;
+    /**
+     * Sounds a pitch for as long as it is held — auditioning a key while editing.
+     *
+     * Touches no transport state on purpose: no caret move, no play/pause change,
+     * and no appearance in the active-note highlighting that follows the score.
+     *
+     * `isPercussion` must be passed for a percussion-clef track, or the tap sounds
+     * a pitched instrument while the same note plays back as a drum. The program
+     * is resolved to a voice here rather than by the caller, because a percussion
+     * program addresses a kit and only this package's tables know which.
+     */
+    noteOn(midi: number, program: number, isPercussion?: boolean): void;
+    noteOff(midi: number): void;
+    /**
+     * The three high-frequency channels, as one object.
+     *
+     * Exposed rather than wrapped so a host binds React to the same bus the
+     * engine publishes into — two would be two answers to "what is sounding".
+     * `positionTick` and `sounding` hang off it for a subscriber joining
+     * mid-playback, which is why they are held at all.
+     */
+    readonly bus: PlaybackBus;
+    onPosition(fn: (scoreTick: number) => void): Unsubscribe;
+    onSounding(fn: (notes: readonly SoundingNote[]) => void): Unsubscribe;
+    onTransport(fn: (state: TransportPlaybackState) => void): Unsubscribe;
+    /**
+     * Synth load progress. Not one of the bus's three high-frequency channels —
+     * it reports per percent and behaves like ordinary React state, so the host
+     * puts it in its store. It is here because the host has no other way to hear
+     * about it.
+     */
+    onLoadState(fn: (state: PlaybackLoadState) => void): Unsubscribe;
+    dispose(): void;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AACnD,OAAO,KAAK,EACV,iBAAiB,EACjB,aAAa,EACb,KAAK,EACL,UAAU,EACV,YAAY,EACZ,sBAAsB,EACvB,MAAM,yBAAyB,CAAC;AAEjC,MAAM,MAAM,WAAW,GAAG,MAAM,IAAI,CAAC;AAErC;;;;;;;;;;;;;;;GAeG;AACH,MAAM,WAAW,YAAY;IAC3B;;;;;;;;OAQG;IACH;;;OAGG;IACH,IAAI,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,CAAC,EAAE;QAAE,eAAe,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAElF,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACtB,KAAK,IAAI,IAAI,CAAC;IACd,IAAI,IAAI,IAAI,CAAC;IAEb,uFAAuF;IACvF,IAAI,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IAE9B,OAAO,CAAC,KAAK,EAAE,UAAU,GAAG,IAAI,GAAG,IAAI,CAAC;IACxC,kBAAkB,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7C,YAAY,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAAC;IACrC,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IAEtC,sEAAsE;IACtE,QAAQ,CAAC,MAAM,EAAE,SAAS,aAAa,EAAE,GAAG,IAAI,CAAC;IAEjD,4DAA4D;IAC5D,gBAAgB,CAAC,eAAe,EAAE,SAAS,MAAM,EAAE,GAAG,IAAI,CAAC;IAE3D;;;;;;;;;;OAUG;IACH,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;IACpE,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAE5B;;;;;;;OAOG;IACH,QAAQ,CAAC,GAAG,EAAE,WAAW,CAAC;IAE1B,UAAU,CAAC,EAAE,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI,GAAG,WAAW,CAAC;IACzD,UAAU,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,SAAS,YAAY,EAAE,KAAK,IAAI,GAAG,WAAW,CAAC;IACtE,WAAW,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,sBAAsB,KAAK,IAAI,GAAG,WAAW,CAAC;IACtE;;;;;OAKG;IACH,WAAW,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,iBAAiB,KAAK,IAAI,GAAG,WAAW,CAAC;IAEjE,OAAO,IAAI,IAAI,CAAC;CACjB"}

package/dist/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":""}

package/dist/web/audio/offline-synth.d.ts

@@ -0,0 +1,24 @@
+import type { SynthesizerLike } from './synth-types.js';
+export type LoadedOfflineSynth = {
+    synth: SynthesizerLike;
+    sfontId: number;
+    sampleRate: number;
+};
+export type OfflineSynthRequest = {
+    fluidsynthModuleUrl: string;
+    fontUrl: string;
+    loadFont: (url: string) => Promise<ArrayBuffer>;
+    sampleRate: number;
+    /**
+     * Builds the synth. Injected only by tests — the real path first loads
+     * libfluidsynth into the page through a script tag, which a unit test has no
+     * way to satisfy. Supplying this skips that bring-up, the same seam
+     * `SynthHost` exposes for the same reason.
+     */
+    createSynth?: () => SynthesizerLike;
+};
+/** The shared offline synth, building it on first use. */
+export declare function getOfflineSynth(request: OfflineSynthRequest): Promise<LoadedOfflineSynth>;
+/** Drops the shared synth. Exposed for tests and teardown, not used in normal flow. */
+export declare function releaseOfflineSynth(): void;
+//# sourceMappingURL=offline-synth.d.ts.map

package/dist/web/audio/offline-synth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"offline-synth.d.ts","sourceRoot":"","sources":["../../../src/web/audio/offline-synth.ts"],"names":[],"mappings":"AAoBA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAUxD,MAAM,MAAM,kBAAkB,GAAG;IAC/B,KAAK,EAAE,eAAe,CAAC;IACvB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AA6BF,MAAM,MAAM,mBAAmB,GAAG;IAChC,mBAAmB,EAAE,MAAM,CAAC;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,WAAW,CAAC,CAAC;IAChD,UAAU,EAAE,MAAM,CAAC;IACnB;;;;;OAKG;IACH,WAAW,CAAC,EAAE,MAAM,eAAe,CAAC;CACrC,CAAC;AAEF,0DAA0D;AAC1D,wBAAsB,eAAe,CAAC,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAgC/F;AAED,uFAAuF;AACvF,wBAAgB,mBAAmB,IAAI,IAAI,CAE1C"}