@sudobility/music_player 0.1.0 → 0.1.2

package/dist/shared/bus.js

@@ -0,0 +1,83 @@
+import { getMusicPositionSource } from '@sudobility/music_types';
+export class PlaybackBus {
+    positionListeners = new Set();
+    soundingListeners = new Set();
+    transportListeners = new Set();
+    /** The last values published, so a subscriber joining mid-playback is not blind until the next event. */
+    lastSounding = [];
+    lastTransport = 'stopped';
+    onPosition(listener) {
+        this.positionListeners.add(listener);
+        return () => this.positionListeners.delete(listener);
+    }
+    onSounding(listener) {
+        this.soundingListeners.add(listener);
+        return () => this.soundingListeners.delete(listener);
+    }
+    onTransport(listener) {
+        this.transportListeners.add(listener);
+        return () => this.transportListeners.delete(listener);
+    }
+    /**
+     * Every caret move in the app arrives here — the engine's position reports,
+     * a seek, a click on the staff, an arrow key — which is what makes this the
+     * one place that has to tell `IMusicPosition` about it. Reporting from the
+     * controller's report handler instead would have covered playback only, and
+     * left the shared position stale the moment somebody moved the caret by
+     * hand.
+     *
+     * The anchor is stamped **here**, inside the engine's own callback, rather
+     * than wherever a React subscriber eventually runs: that is the difference
+     * between measuring from the audio clock and measuring from event-loop
+     * latency, and it is why the caret used to drift away from the highlights
+     * and the keyboard under load.
+     */
+    publishPosition(tick) {
+        getMusicPositionSource().report(tick);
+        for (const listener of this.positionListeners)
+            listener(tick);
+    }
+    /**
+     * The engine already emits only on change (`SoundingSet`), so this does not
+     * filter again — doing so would hide a deliberate re-publish after a seek.
+     */
+    publishSounding(notes) {
+        this.lastSounding = notes;
+        for (const listener of this.soundingListeners)
+            listener(notes);
+    }
+    publishTransport(state) {
+        this.lastTransport = state;
+        for (const listener of this.transportListeners)
+            listener(state);
+    }
+    /**
+     * Where playback last reported it was. Read once on subscribe; do not poll
+     * this.
+     *
+     * Delegated to the playhead rather than kept here. The bus used to store its
+     * own copy of the reported tick beside the one `IMusicPositionSource` holds,
+     * which made two objects each own the same fact — and they duly came apart:
+     * when the engine's throttle stopped reporting, the playhead went on
+     * projecting while this copy stayed where it was, so the caret glided the
+     * length of the score with the scroll and the readouts still at bar one.
+     * Reading through means the smoothed position and the reported one are two
+     * views of one state, which is what the interface promises.
+     */
+    get positionTick() {
+        return getMusicPositionSource().reportedTick;
+    }
+    get sounding() {
+        return this.lastSounding;
+    }
+    get transport() {
+        return this.lastTransport;
+    }
+    /** Drops every listener. For teardown; a live app never calls this. */
+    clear() {
+        this.positionListeners.clear();
+        this.soundingListeners.clear();
+        this.transportListeners.clear();
+    }
+}
+//# sourceMappingURL=bus.js.map

package/dist/shared/bus.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bus.js","sourceRoot":"","sources":["../../src/shared/bus.ts"],"names":[],"mappings":"AA2BA,OAAO,EAAE,sBAAsB,EAAE,MAAM,yBAAyB,CAAC;AAEjE,MAAM,OAAO,WAAW;IACL,iBAAiB,GAAG,IAAI,GAAG,EAA0B,CAAC;IACtD,iBAAiB,GAAG,IAAI,GAAG,EAEzC,CAAC;IACa,kBAAkB,GAAG,IAAI,GAAG,EAE1C,CAAC;IAEJ,yGAAyG;IACjG,YAAY,GAA4B,EAAE,CAAC;IAC3C,aAAa,GAA2B,SAAS,CAAC;IAE1D,UAAU,CAAC,QAAgC;QACzC,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;QACrC,OAAO,GAAG,EAAE,CAAC,IAAI,CAAC,iBAAiB,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;IACvD,CAAC;IAED,UAAU,CAAC,QAAkD;QAC3D,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;QACrC,OAAO,GAAG,EAAE,CAAC,IAAI,CAAC,iBAAiB,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;IACvD,CAAC;IAED,WAAW,CAAC,QAAiD;QAC3D,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;QACtC,OAAO,GAAG,EAAE,CAAC,IAAI,CAAC,kBAAkB,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;IACxD,CAAC;IAED;;;;;;;;;;;;;OAaG;IACH,eAAe,CAAC,IAAY;QAC1B,sBAAsB,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;QACtC,KAAK,MAAM,QAAQ,IAAI,IAAI,CAAC,iBAAiB;YAAE,QAAQ,CAAC,IAAI,CAAC,CAAC;IAChE,CAAC;IAED;;;OAGG;IACH,eAAe,CAAC,KAA8B;QAC5C,IAAI,CAAC,YAAY,GAAG,KAAK,CAAC;QAC1B,KAAK,MAAM,QAAQ,IAAI,IAAI,CAAC,iBAAiB;YAAE,QAAQ,CAAC,KAAK,CAAC,CAAC;IACjE,CAAC;IAED,gBAAgB,CAAC,KAA6B;QAC5C,IAAI,CAAC,aAAa,GAAG,KAAK,CAAC;QAC3B,KAAK,MAAM,QAAQ,IAAI,IAAI,CAAC,kBAAkB;YAAE,QAAQ,CAAC,KAAK,CAAC,CAAC;IAClE,CAAC;IAED;;;;;;;;;;;;OAYG;IACH,IAAI,YAAY;QACd,OAAO,sBAAsB,EAAE,CAAC,YAAY,CAAC;IAC/C,CAAC;IAED,IAAI,QAAQ;QACV,OAAO,IAAI,CAAC,YAAY,CAAC;IAC3B,CAAC;IAED,IAAI,SAAS;QACX,OAAO,IAAI,CAAC,aAAa,CAAC;IAC5B,CAAC;IAED,uEAAuE;IACvE,KAAK;QACH,IAAI,CAAC,iBAAiB,CAAC,KAAK,EAAE,CAAC;QAC/B,IAAI,CAAC,iBAAiB,CAAC,KAAK,EAAE,CAAC;QAC/B,IAAI,CAAC,kBAAkB,CAAC,KAAK,EAAE,CAAC;IAClC,CAAC;CACF"}

package/dist/shared/midi.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Pure MIDI-number conversions used by the Tone.js adapter (Task 13). Kept
+ * dependency-free (no Tone.js import) so they're trivially unit-testable
+ * without mocking `tone`, per the Task 13 brief's guidance to keep every
+ * piece of logic that doesn't actually need Tone in small, separately
+ * testable functions.
+ */
+/** Converts a MIDI note number (60 = C4) to its frequency in Hertz. */
+export declare function midiToHertz(midi: number): number;
+/**
+ * Converts a domain `NoteEvent.velocity` (spec §4: integer 0-127) to Tone's
+ * normalized 0-1 velocity range, clamped defensively in case of an
+ * out-of-range value slipping through (validation should catch this
+ * earlier, but the audio layer shouldn't crash or produce out-of-range
+ * gain if it doesn't).
+ */
+export declare function normalizeVelocity(velocity: number): number;
+//# sourceMappingURL=midi.d.ts.map

package/dist/shared/midi.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"midi.d.ts","sourceRoot":"","sources":["../../src/shared/midi.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAMH,uEAAuE;AACvE,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEhD;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAE1D"}

package/dist/shared/midi.js

@@ -0,0 +1,25 @@
+/**
+ * Pure MIDI-number conversions used by the Tone.js adapter (Task 13). Kept
+ * dependency-free (no Tone.js import) so they're trivially unit-testable
+ * without mocking `tone`, per the Task 13 brief's guidance to keep every
+ * piece of logic that doesn't actually need Tone in small, separately
+ * testable functions.
+ */
+/** A4 = 69 = 440Hz, the standard MIDI tuning reference. */
+const A4_MIDI = 69;
+const A4_HERTZ = 440;
+/** Converts a MIDI note number (60 = C4) to its frequency in Hertz. */
+export function midiToHertz(midi) {
+    return A4_HERTZ * 2 ** ((midi - A4_MIDI) / 12);
+}
+/**
+ * Converts a domain `NoteEvent.velocity` (spec §4: integer 0-127) to Tone's
+ * normalized 0-1 velocity range, clamped defensively in case of an
+ * out-of-range value slipping through (validation should catch this
+ * earlier, but the audio layer shouldn't crash or produce out-of-range
+ * gain if it doesn't).
+ */
+export function normalizeVelocity(velocity) {
+    return Math.min(1, Math.max(0, velocity / 127));
+}
+//# sourceMappingURL=midi.js.map

package/dist/shared/midi.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"midi.js","sourceRoot":"","sources":["../../src/shared/midi.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,2DAA2D;AAC3D,MAAM,OAAO,GAAG,EAAE,CAAC;AACnB,MAAM,QAAQ,GAAG,GAAG,CAAC;AAErB,uEAAuE;AACvE,MAAM,UAAU,WAAW,CAAC,IAAY;IACtC,OAAO,QAAQ,GAAG,CAAC,IAAI,CAAC,CAAC,IAAI,GAAG,OAAO,CAAC,GAAG,EAAE,CAAC,CAAC;AACjD,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,iBAAiB,CAAC,QAAgB;IAChD,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,QAAQ,GAAG,GAAG,CAAC,CAAC,CAAC;AAClD,CAAC"}

package/dist/shared/mix.d.ts

@@ -0,0 +1,75 @@
+/**
+ * The master-bus rules, shared by live playback and offline export on both
+ * platforms — `web/playback/synth-host.ts`, `web/audio/soundfont-render.ts`,
+ * `rn/playback/sample-engine.ts` and `rn/audio/offline-render.ts`.
+ *
+ * They live here rather than in each caller because an export that mixed
+ * differently from playback is exactly the bug this module exists to prevent:
+ * the file is supposed to be a recording of what was heard, and copies of these
+ * numbers would drift apart the first time one was tuned.
+ *
+ * Living here is not the same as being used, which is how the web export came
+ * to sum its channels raw while playback trimmed them — `sqrt(n)` louder than
+ * what was heard, into encoders that hard-clamp. All four callers are named
+ * above so the next one to be added is noticed by its absence.
+ */
+/**
+ * Ceiling for the safety limiter on the master bus, in dB below full scale.
+ *
+ * The headroom trim sizes the mix for how loud it is *on average*; this catches
+ * the peaks it cannot predict — the moments when parts happen to line up in
+ * phase, which sum far above the incoherent average. Just under full scale
+ * rather than at it, so the limiter, and not the sound card, decides the
+ * ceiling.
+ */
+export declare const LIMITER_CEILING_DB = -1;
+/**
+ * How far to pull the master down for `trackCount` channels summing into it.
+ *
+ * Every channel is scheduled at its own MIDI volume with nothing reconciling
+ * them, so the mix got louder with every track added. A nine-track arrangement
+ * summed to roughly two and a half times full scale and clipped through most of
+ * the piece; what that distortion buried first were the quiet, sustained
+ * voices, which is why tracks that were neither muted nor silent could not be
+ * heard at all.
+ *
+ * `1/sqrt(n)`, not `1/n`: separate instrument parts are not phase-correlated,
+ * so their powers add rather than their amplitudes. `1/n` is the law for copies
+ * of one signal and would leave a large arrangement far too quiet. A single
+ * track keeps unity — it has nothing to sum with.
+ */
+export declare function headroomTrimFor(trackCount: number): number;
+/**
+ * Holds a rendered buffer under `LIMITER_CEILING_DB`, in place.
+ *
+ * The offline counterpart of the `DynamicsCompressorNode` on the live master
+ * bus, and it exists for the same reason: the headroom trim sizes the mix for
+ * how loud it is *on average*, and the moments where parts happen to line up in
+ * phase sum far above that. Live those peaks meet a limiter; in an export they
+ * meet `encodeWav`/`encodeMp3`, which clamp — so without this the loudest
+ * instants of a file are hard-clipped rather than ducked.
+ *
+ * It is **not** a reimplementation of that node. `DynamicsCompressorNode` has a
+ * knee, a ratio and program-dependent behaviour the specification does not pin
+ * down closely enough to reproduce, and chasing it would be pretending to a
+ * precision that is not there. What is reproduced is the job: nothing leaves
+ * here above the ceiling, and it gets there by ducking rather than clipping.
+ *
+ * The gain is worked out **backwards**, which is the one thing an offline
+ * limiter can do that a live one cannot. Each sample's gain is the lower of
+ * what that sample needs and what the next sample allows plus one attack step,
+ * so the ramp down is *finished* when the peak lands instead of chasing it.
+ * That ordering is also what makes the ceiling exact rather than approximate: a
+ * forward one-pole never quite arrives, and clamping the residue turns the last
+ * fraction of a decibel back into the clipping this replaces.
+ *
+ * The forward pass is the release, and the reason a sustained loud passage does
+ * not pump: within one cycle the requirement relaxes at every zero crossing,
+ * and the bounded climb simply does not follow it.
+ *
+ * Costs one `Float32Array` the length of the render — 53MB for five minutes at
+ * 44.1kHz, freed on return, against a `samples` buffer of the same size that
+ * the caller is already holding.
+ */
+export declare function limitPeaks(samples: Float32Array, sampleRate: number): void;
+//# sourceMappingURL=mix.d.ts.map

package/dist/shared/mix.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mix.d.ts","sourceRoot":"","sources":["../../src/shared/mix.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH;;;;;;;;GAQG;AACH,eAAO,MAAM,kBAAkB,KAAK,CAAC;AAErC;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,eAAe,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAE1D;AAsBD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,GAAG,IAAI,CAyB1E"}

package/dist/shared/mix.js

@@ -0,0 +1,115 @@
+/**
+ * The master-bus rules, shared by live playback and offline export on both
+ * platforms — `web/playback/synth-host.ts`, `web/audio/soundfont-render.ts`,
+ * `rn/playback/sample-engine.ts` and `rn/audio/offline-render.ts`.
+ *
+ * They live here rather than in each caller because an export that mixed
+ * differently from playback is exactly the bug this module exists to prevent:
+ * the file is supposed to be a recording of what was heard, and copies of these
+ * numbers would drift apart the first time one was tuned.
+ *
+ * Living here is not the same as being used, which is how the web export came
+ * to sum its channels raw while playback trimmed them — `sqrt(n)` louder than
+ * what was heard, into encoders that hard-clamp. All four callers are named
+ * above so the next one to be added is noticed by its absence.
+ */
+/**
+ * Ceiling for the safety limiter on the master bus, in dB below full scale.
+ *
+ * The headroom trim sizes the mix for how loud it is *on average*; this catches
+ * the peaks it cannot predict — the moments when parts happen to line up in
+ * phase, which sum far above the incoherent average. Just under full scale
+ * rather than at it, so the limiter, and not the sound card, decides the
+ * ceiling.
+ */
+export const LIMITER_CEILING_DB = -1;
+/**
+ * How far to pull the master down for `trackCount` channels summing into it.
+ *
+ * Every channel is scheduled at its own MIDI volume with nothing reconciling
+ * them, so the mix got louder with every track added. A nine-track arrangement
+ * summed to roughly two and a half times full scale and clipped through most of
+ * the piece; what that distortion buried first were the quiet, sustained
+ * voices, which is why tracks that were neither muted nor silent could not be
+ * heard at all.
+ *
+ * `1/sqrt(n)`, not `1/n`: separate instrument parts are not phase-correlated,
+ * so their powers add rather than their amplitudes. `1/n` is the law for copies
+ * of one signal and would leave a large arrangement far too quiet. A single
+ * track keeps unity — it has nothing to sum with.
+ */
+export function headroomTrimFor(trackCount) {
+    return trackCount > 1 ? 1 / Math.sqrt(trackCount) : 1;
+}
+/**
+ * Attack and release for the offline limiter, in seconds, quoted against
+ * `LIMITER_REFERENCE_DB` of reduction.
+ *
+ * The same numbers `SynthHost` gives its `DynamicsCompressorNode`, so a peak
+ * ducks for about as long either way. Expressed as a slew rate rather than a
+ * filter coefficient, which is what makes the ceiling exact — see `limitPeaks`.
+ */
+const LIMITER_ATTACK_SECONDS = 0.003;
+const LIMITER_RELEASE_SECONDS = 0.25;
+/**
+ * The depth the attack and release times describe.
+ *
+ * A slew rate needs a distance to be a time. Twelve decibels is deep enough to
+ * cover the peaks a phase-aligned tutti produces over the headroom trim, and a
+ * shallower reduction simply completes proportionally sooner.
+ */
+const LIMITER_REFERENCE_DB = 12;
+/**
+ * Holds a rendered buffer under `LIMITER_CEILING_DB`, in place.
+ *
+ * The offline counterpart of the `DynamicsCompressorNode` on the live master
+ * bus, and it exists for the same reason: the headroom trim sizes the mix for
+ * how loud it is *on average*, and the moments where parts happen to line up in
+ * phase sum far above that. Live those peaks meet a limiter; in an export they
+ * meet `encodeWav`/`encodeMp3`, which clamp — so without this the loudest
+ * instants of a file are hard-clipped rather than ducked.
+ *
+ * It is **not** a reimplementation of that node. `DynamicsCompressorNode` has a
+ * knee, a ratio and program-dependent behaviour the specification does not pin
+ * down closely enough to reproduce, and chasing it would be pretending to a
+ * precision that is not there. What is reproduced is the job: nothing leaves
+ * here above the ceiling, and it gets there by ducking rather than clipping.
+ *
+ * The gain is worked out **backwards**, which is the one thing an offline
+ * limiter can do that a live one cannot. Each sample's gain is the lower of
+ * what that sample needs and what the next sample allows plus one attack step,
+ * so the ramp down is *finished* when the peak lands instead of chasing it.
+ * That ordering is also what makes the ceiling exact rather than approximate: a
+ * forward one-pole never quite arrives, and clamping the residue turns the last
+ * fraction of a decibel back into the clipping this replaces.
+ *
+ * The forward pass is the release, and the reason a sustained loud passage does
+ * not pump: within one cycle the requirement relaxes at every zero crossing,
+ * and the bounded climb simply does not follow it.
+ *
+ * Costs one `Float32Array` the length of the render — 53MB for five minutes at
+ * 44.1kHz, freed on return, against a `samples` buffer of the same size that
+ * the caller is already holding.
+ */
+export function limitPeaks(samples, sampleRate) {
+    const attackSlope = LIMITER_REFERENCE_DB / Math.max(1, LIMITER_ATTACK_SECONDS * sampleRate);
+    const releaseSlope = LIMITER_REFERENCE_DB / Math.max(1, LIMITER_RELEASE_SECONDS * sampleRate);
+    // Gain in dB, never above zero: a limiter only ever turns things down.
+    const envelope = new Float32Array(samples.length);
+    let carried = 0;
+    for (let i = samples.length - 1; i >= 0; i -= 1) {
+        const magnitude = Math.abs(samples[i]);
+        const required = magnitude > 0
+            ? Math.min(0, LIMITER_CEILING_DB - 20 * Math.log10(magnitude))
+            : 0;
+        carried = Math.min(required, carried + attackSlope);
+        envelope[i] = carried;
+    }
+    let level = envelope[0] ?? 0;
+    for (let i = 0; i < samples.length; i += 1) {
+        level = Math.min(envelope[i], level + releaseSlope);
+        // Exactly 1 where nothing needed doing, so an untouched mix stays bit-identical.
+        samples[i] = level === 0 ? samples[i] : samples[i] * 10 ** (level / 20);
+    }
+}
+//# sourceMappingURL=mix.js.map

package/dist/shared/mix.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mix.js","sourceRoot":"","sources":["../../src/shared/mix.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAAC,CAAC,CAAC;AAErC;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,eAAe,CAAC,UAAkB;IAChD,OAAO,UAAU,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AACxD,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,sBAAsB,GAAG,KAAK,CAAC;AACrC,MAAM,uBAAuB,GAAG,IAAI,CAAC;AAErC;;;;;;GAMG;AACH,MAAM,oBAAoB,GAAG,EAAE,CAAC;AAEhC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,MAAM,UAAU,UAAU,CAAC,OAAqB,EAAE,UAAkB;IAClE,MAAM,WAAW,GACf,oBAAoB,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,sBAAsB,GAAG,UAAU,CAAC,CAAC;IAC1E,MAAM,YAAY,GAChB,oBAAoB,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,uBAAuB,GAAG,UAAU,CAAC,CAAC;IAE3E,uEAAuE;IACvE,MAAM,QAAQ,GAAG,IAAI,YAAY,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;IAClD,IAAI,OAAO,GAAG,CAAC,CAAC;IAChB,KAAK,IAAI,CAAC,GAAG,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC;QAChD,MAAM,SAAS,GAAG,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAE,CAAC,CAAC;QACxC,MAAM,QAAQ,GACZ,SAAS,GAAG,CAAC;YACX,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,kBAAkB,GAAG,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;YAC9D,CAAC,CAAC,CAAC,CAAC;QACR,OAAO,GAAG,IAAI,CAAC,GAAG,CAAC,QAAQ,EAAE,OAAO,GAAG,WAAW,CAAC,CAAC;QACpD,QAAQ,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC;IACxB,CAAC;IAED,IAAI,KAAK,GAAG,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;IAC7B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC;QAC3C,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC,CAAE,EAAE,KAAK,GAAG,YAAY,CAAC,CAAC;QACrD,iFAAiF;QACjF,OAAO,CAAC,CAAC,CAAC,GAAG,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAE,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAE,GAAG,EAAE,IAAI,CAAC,KAAK,GAAG,EAAE,CAAC,CAAC;IAC5E,CAAC;AACH,CAAC"}

package/dist/shared/note-queue.d.ts

@@ -0,0 +1,43 @@
+/**
+ * The notes of a score, in time order, with a cursor.
+ *
+ * Replaces scheduling every note up front. The old engine handed the whole
+ * piece to Tone's Transport as individual events — some 11,500 of them for a
+ * three-minute arrangement — and every seek, edit or tempo change cancelled
+ * and rebuilt all of it. Here a seek is a binary search and a cursor move,
+ * whatever the length of the piece.
+ *
+ * Deliberately knows nothing about time in seconds: ticks are the score's own
+ * unit, and converting them depends on the tempo map and the playback-speed
+ * multiplier, both of which belong to the engine.
+ */
+import type { PlaybackNote as ScheduledNote } from '@sudobility/music_types';
+export declare class NoteQueue {
+    private notes;
+    private cursor;
+    load(notes: readonly ScheduledNote[]): void;
+    /**
+     * Moves the cursor to the first note at or after `tick`.
+     *
+     * Binary search rather than a scan: this runs on every seek, and a scan
+     * would make seeking cost more the further into the piece you go.
+     */
+    seekToTick(tick: number): void;
+    /**
+     * Every not-yet-returned note starting at or before `tick`, up to `maxCount`
+     * of them, advancing the cursor past what it returns.
+     *
+     * The cap bounds one pump tick's cost. On the web engine each note becomes a
+     * `postMessage` to the worklet sequencer, and a four-second horizon over a
+     * two-hundred-track score is thousands of them; whatever the cap leaves
+     * behind is picked up 50ms later, long before it is due.
+     *
+     * Unbounded by default, because the React Native sample engine drains its
+     * whole horizon in one go — it posts nothing across a thread boundary, so it
+     * has nothing to bound.
+     */
+    drainUntil(tick: number, maxCount?: number): ScheduledNote[];
+    /** True once every note has been drained — how the engine knows the piece is over. */
+    get exhausted(): boolean;
+}
+//# sourceMappingURL=note-queue.d.ts.map

package/dist/shared/note-queue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"note-queue.d.ts","sourceRoot":"","sources":["../../src/shared/note-queue.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,KAAK,EAAE,YAAY,IAAI,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAE7E,qBAAa,SAAS;IACpB,OAAO,CAAC,KAAK,CAAuB;IACpC,OAAO,CAAC,MAAM,CAAK;IAEnB,IAAI,CAAC,KAAK,EAAE,SAAS,aAAa,EAAE,GAAG,IAAI;IAK3C;;;;;OAKG;IACH,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAW9B;;;;;;;;;;;;OAYG;IACH,UAAU,CACR,IAAI,EAAE,MAAM,EACZ,QAAQ,SAA0B,GACjC,aAAa,EAAE;IAalB,sFAAsF;IACtF,IAAI,SAAS,IAAI,OAAO,CAEvB;CACF"}

package/dist/shared/note-queue.js

@@ -0,0 +1,54 @@
+export class NoteQueue {
+    notes = [];
+    cursor = 0;
+    load(notes) {
+        this.notes = [...notes].sort((a, b) => a.tick - b.tick);
+        this.cursor = 0;
+    }
+    /**
+     * Moves the cursor to the first note at or after `tick`.
+     *
+     * Binary search rather than a scan: this runs on every seek, and a scan
+     * would make seeking cost more the further into the piece you go.
+     */
+    seekToTick(tick) {
+        let lo = 0;
+        let hi = this.notes.length;
+        while (lo < hi) {
+            const mid = (lo + hi) >> 1;
+            if (this.notes[mid].tick < tick)
+                lo = mid + 1;
+            else
+                hi = mid;
+        }
+        this.cursor = lo;
+    }
+    /**
+     * Every not-yet-returned note starting at or before `tick`, up to `maxCount`
+     * of them, advancing the cursor past what it returns.
+     *
+     * The cap bounds one pump tick's cost. On the web engine each note becomes a
+     * `postMessage` to the worklet sequencer, and a four-second horizon over a
+     * two-hundred-track score is thousands of them; whatever the cap leaves
+     * behind is picked up 50ms later, long before it is due.
+     *
+     * Unbounded by default, because the React Native sample engine drains its
+     * whole horizon in one go — it posts nothing across a thread boundary, so it
+     * has nothing to bound.
+     */
+    drainUntil(tick, maxCount = Number.MAX_SAFE_INTEGER) {
+        const out = [];
+        while (out.length < maxCount &&
+            this.cursor < this.notes.length &&
+            this.notes[this.cursor].tick <= tick) {
+            out.push(this.notes[this.cursor]);
+            this.cursor += 1;
+        }
+        return out;
+    }
+    /** True once every note has been drained — how the engine knows the piece is over. */
+    get exhausted() {
+        return this.cursor >= this.notes.length;
+    }
+}
+//# sourceMappingURL=note-queue.js.map

package/dist/shared/note-queue.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"note-queue.js","sourceRoot":"","sources":["../../src/shared/note-queue.ts"],"names":[],"mappings":"AAeA,MAAM,OAAO,SAAS;IACZ,KAAK,GAAoB,EAAE,CAAC;IAC5B,MAAM,GAAG,CAAC,CAAC;IAEnB,IAAI,CAAC,KAA+B;QAClC,IAAI,CAAC,KAAK,GAAG,CAAC,GAAG,KAAK,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC;QACxD,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC;IAClB,CAAC;IAED;;;;;OAKG;IACH,UAAU,CAAC,IAAY;QACrB,IAAI,EAAE,GAAG,CAAC,CAAC;QACX,IAAI,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC;QAC3B,OAAO,EAAE,GAAG,EAAE,EAAE,CAAC;YACf,MAAM,GAAG,GAAG,CAAC,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,CAAC;YAC3B,IAAI,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,GAAG,IAAI;gBAAE,EAAE,GAAG,GAAG,GAAG,CAAC,CAAC;;gBACzC,EAAE,GAAG,GAAG,CAAC;QAChB,CAAC;QACD,IAAI,CAAC,MAAM,GAAG,EAAE,CAAC;IACnB,CAAC;IAED;;;;;;;;;;;;OAYG;IACH,UAAU,CACR,IAAY,EACZ,QAAQ,GAAG,MAAM,CAAC,gBAAgB;QAElC,MAAM,GAAG,GAAoB,EAAE,CAAC;QAChC,OACE,GAAG,CAAC,MAAM,GAAG,QAAQ;YACrB,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM;YAC/B,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,IAAI,IAAI,IAAI,EACpC,CAAC;YACD,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;YAClC,IAAI,CAAC,MAAM,IAAI,CAAC,CAAC;QACnB,CAAC;QACD,OAAO,GAAG,CAAC;IACb,CAAC;IAED,sFAAsF;IACtF,IAAI,SAAS;QACX,OAAO,IAAI,CAAC,MAAM,IAAI,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC;IAC1C,CAAC;CACF"}

package/dist/shared/plan.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Everything live playback needs, decided here rather than in the engine.
+ *
+ * The live counterpart of `renderEvents`, and the reason music_io needs no
+ * musical code at all: ties are joined, pitches resolved, the measure grid's
+ * beats read off, the GM voice resolved and the tempo handed over as a
+ * conversion. The engine schedules and sounds; it decides nothing.
+ *
+ * This is `schedule.ts` from music_io, moved to where its imports already
+ * lived. The note traversal itself is `flattenScoreNotes`, shared with
+ * `renderEvents` so live and offline cannot drift over ties again.
+ */
+import type { PlaybackPlan, PlaybackTrack, Score } from '@sudobility/music_types';
+import type { AuditionVoice } from '../engine.js';
+/**
+ * The GM voice a program addresses.
+ *
+ * The one place the kit-versus-instrument distinction is resolved, shared by
+ * the plan and by auditioning. A percussion track's `midiProgram` is a *kit*
+ * address — `gmKitAt` maps any address to the kit whose region contains it, so
+ * a score that arrives at a program GM defines no kit at still plays — and the
+ * name must be the kit's, because `gmInstrument(40)` is Violin where kit 40 is
+ * Brush.
+ */
+export declare function resolveVoice(program: number, isPercussion: boolean, fallbackName?: string): AuditionVoice;
+/**
+ * The tracks alone.
+ *
+ * Separate from `playbackPlan` because a mix change while playing must not
+ * rebuild every note — `PlaybackEngine.applyMix` takes only this.
+ */
+export declare function playbackTracks(score: Score): PlaybackTrack[];
+export declare function playbackPlan(score: Score): PlaybackPlan;
+//# sourceMappingURL=plan.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"plan.d.ts","sourceRoot":"","sources":["../../src/shared/plan.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,OAAO,KAAK,EAEV,YAAY,EACZ,aAAa,EACb,KAAK,EACN,MAAM,yBAAyB,CAAC;AACjC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAalD;;;;;;;;;GASG;AACH,wBAAgB,YAAY,CAC1B,OAAO,EAAE,MAAM,EACf,YAAY,EAAE,OAAO,EACrB,YAAY,SAAK,GAChB,aAAa,CAUf;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,KAAK,GAAG,aAAa,EAAE,CAqB5D;AAqDD,wBAAgB,YAAY,CAAC,KAAK,EAAE,KAAK,GAAG,YAAY,CAgDvD"}

package/dist/shared/plan.js

@@ -0,0 +1,134 @@
+import { TempoMap } from '@sudobility/music_types';
+import { performanceTimeline, } from '@sudobility/music_types';
+import { fermataTempoMap } from '@sudobility/music_types';
+import { flattenScoreNotes } from '@sudobility/music_types';
+import { beatBoundaries } from '@sudobility/music_types';
+import { gmInstrument } from '@sudobility/music_types';
+import { gmKitAt } from '@sudobility/music_types';
+import { isPercussionTrack } from '@sudobility/music_types';
+/**
+ * The GM voice a program addresses.
+ *
+ * The one place the kit-versus-instrument distinction is resolved, shared by
+ * the plan and by auditioning. A percussion track's `midiProgram` is a *kit*
+ * address — `gmKitAt` maps any address to the kit whose region contains it, so
+ * a score that arrives at a program GM defines no kit at still plays — and the
+ * name must be the kit's, because `gmInstrument(40)` is Violin where kit 40 is
+ * Brush.
+ */
+export function resolveVoice(program, isPercussion, fallbackName = '') {
+    if (isPercussion) {
+        const kit = gmKitAt(program);
+        return { program: kit.program, name: kit.name, isPercussion: true };
+    }
+    return {
+        program,
+        name: gmInstrument(program)?.name ?? fallbackName,
+        isPercussion: false,
+    };
+}
+/**
+ * The tracks alone.
+ *
+ * Separate from `playbackPlan` because a mix change while playing must not
+ * rebuild every note — `PlaybackEngine.applyMix` takes only this.
+ */
+export function playbackTracks(score) {
+    return score.tracks.map(track => {
+        const percussion = isPercussionTrack(track);
+        const voice = resolveVoice(track.midiProgram, percussion, track.instrumentName);
+        return {
+            id: track.id,
+            midiProgram: track.midiProgram,
+            instrumentName: track.instrumentName,
+            isPercussion: percussion,
+            volume: track.volume,
+            pan: track.pan,
+            muted: track.muted,
+            solo: track.solo,
+            voiceProgram: voice.program,
+            voiceName: voice.name,
+        };
+    });
+}
+/**
+ * Every beat position across the measure grid, read off the first track —
+ * every track shares one grid once `rebuildMeasureTicks` has run.
+ */
+function metronomeClicks(score) {
+    const track = score.tracks[0];
+    if (!track)
+        return [];
+    const clicks = [];
+    for (const measure of track.measures) {
+        beatBoundaries(measure.timeSignature, score.ppq).forEach((offset, i) => {
+            clicks.push({ tick: measure.startTick + offset, accent: i === 0 });
+        });
+    }
+    return clicks;
+}
+/**
+ * Lays `events` out along the timeline, repeating what the repeats repeat.
+ *
+ * Each segment copies the written events inside its source range to its own
+ * place in performance time. A copy gets a distinct id — the caret lights a
+ * note by id, and the same written note sounding twice would otherwise light
+ * both times at once.
+ *
+ * The identity timeline copies everything exactly once at its own tick, so a
+ * score without repeats produces precisely what it did before.
+ */
+function expandAlongTimeline(events, timeline, withTick) {
+    if (timeline.segments.length === 0)
+        return events;
+    const expanded = [];
+    const passesBySource = new Map();
+    for (const segment of timeline.segments) {
+        const pass = (passesBySource.get(segment.sourceTick) ?? 0) + 1;
+        passesBySource.set(segment.sourceTick, pass);
+        const end = segment.sourceTick + segment.durationTicks;
+        for (const event of events) {
+            if (event.tick < segment.sourceTick || event.tick >= end)
+                continue;
+            const offset = event.tick - segment.sourceTick;
+            expanded.push(withTick(event, segment.performanceTick + offset, pass));
+        }
+    }
+    return expanded.sort((a, b) => a.tick - b.tick);
+}
+export function playbackPlan(score) {
+    const timeline = performanceTimeline(score);
+    /*
+      Notes are laid out in *performance* time, so a repeated bar genuinely
+      sounds twice. Everything that draws translates back through `timeline`
+      — see `sourceTickFor` — which is what keeps the score the canonical,
+      written thing rather than teaching the caret about repeats.
+    */
+    const notes = expandAlongTimeline(flattenScoreNotes(score), timeline, (note, tick, pass) => ({
+        ...note,
+        tick,
+        // Distinct per pass: the caret lights a note by id, and one written
+        // note sounding twice must not light both places at once.
+        noteId: pass === 1 ? note.noteId : `${note.noteId}#${pass}`,
+    }));
+    const clicks = expandAlongTimeline(metronomeClicks(score), timeline, (click, tick) => ({ ...click, tick }));
+    return {
+        tracks: playbackTracks(score),
+        notes,
+        clicks,
+        timeline,
+        /*
+          The tempo map with fermatas written into it as local slowings — see
+          `fermataTempoMap`. A pause is expressed as tempo rather than as longer
+          notes because the score tick has to stay the playback tick; the caret
+          builds its own map from the same function, so the two cannot disagree
+          about how long a hold lasts.
+    
+          `TempoMap` satisfies `TempoConversion` structurally, so nothing converts
+          twice.
+        */
+        tempo: new TempoMap(fermataTempoMap(score), score.ppq),
+        durationTicks: Math.max(timeline.durationTicks, notes.reduce((n, note) => Math.max(n, note.tick + note.durTicks), 0)),
+    };
+}
+//# sourceMappingURL=plan.js.map

package/dist/shared/plan.js.map

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