@sudobility/music_player 0.1.0 → 0.1.1

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,GAAG,CAAC,CAAC;IACjB,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,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC;QACzB,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,qFAAqF;IACrF,IAAI,YAAY;QACd,OAAO,IAAI,CAAC,YAAY,CAAC;IAC3B,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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"}

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"}