@sudobility/music_player 0.1.0 → 0.1.2

package/dist/web/playback/click.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"click.js","sourceRoot":"","sources":["../../../src/web/playback/click.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,SAAS,GAAG,IAAI,CAAC;AACvB,MAAM,OAAO,GAAG,IAAI,CAAC;AACrB,MAAM,aAAa,GAAG,IAAI,CAAC;AAC3B,wEAAwE;AACxE,MAAM,UAAU,GAAG,IAAI,CAAC;AAUxB,MAAM,UAAU,aAAa,CAC3B,OAAyB,EACzB,WAAsB,EACtB,SAAiB,EACjB,MAAe;IAEf,MAAM,UAAU,GAAG,OAAO,CAAC,gBAAgB,EAAE,CAAC;IAC9C,MAAM,IAAI,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC;IAClC,UAAU,CAAC,SAAS,CAAC,KAAK,GAAG,MAAM,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,OAAO,CAAC;IAC1D,UAAU,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;IACzB,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC;IAE1B,6EAA6E;IAC7E,2BAA2B;IAC3B,MAAM,GAAG,GAAG,SAAS,GAAG,aAAa,CAAC;IACtC,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,UAAU,EAAE,SAAS,CAAC,CAAC;IAChD,IAAI,CAAC,IAAI,CAAC,4BAA4B,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAEpD,UAAU,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;IAC5B,UAAU,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IACrB,IAAI,QAAQ,GAAG,KAAK,CAAC;IACrB,UAAU,CAAC,OAAO,GAAG,GAAG,EAAE;QACxB,QAAQ,GAAG,IAAI,CAAC;QAChB,UAAU,CAAC,UAAU,EAAE,CAAC;QACxB,IAAI,CAAC,UAAU,EAAE,CAAC;IACpB,CAAC,CAAC;IAEF,OAAO;QACL,MAAM,EAAE,GAAG;QACX,MAAM,CAAC,IAAY;YACjB,oEAAoE;YACpE,yEAAyE;YACzE,kEAAkE;YAClE,IAAI,QAAQ,IAAI,IAAI,IAAI,GAAG;gBAAE,OAAO;YACpC,qEAAqE;YACrE,wDAAwD;YACxD,IAAI,CAAC,IAAI,CAAC,qBAAqB,CAAC,IAAI,CAAC,CAAC;YACtC,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC;YAClC,6DAA6D;YAC7D,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACxB,CAAC;KACF,CAAC;AACJ,CAAC"}

package/dist/web/playback/clock.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Playback position, owned here rather than by Tone's Transport.
+ *
+ * `now` is injected: the engine passes the AudioContext's `currentTime`, so
+ * position is measured on the very clock the audio is rendered against, and
+ * tests pass a variable they control instead of waiting for real time.
+ *
+ * Everything works by anchoring — a position and the moment it was true —
+ * rather than by accumulating deltas. Accumulation drifts, and drift in the
+ * playback clock is what silenced tracks in the engine this replaces.
+ */
+export declare class PlaybackClock {
+    private readonly now;
+    private running;
+    private anchorNow;
+    private anchorPosition;
+    private rate;
+    constructor(now: () => number);
+    /** Starts, or resumes from wherever it was paused. `fromSeconds` overrides that. */
+    start(fromSeconds?: number): void;
+    pause(): void;
+    stop(): void;
+    /** Jumps to `seconds`, keeping whatever running state the clock had. */
+    seek(seconds: number): void;
+    /**
+     * Scales elapsed time — the playback-speed control.
+     *
+     * Banks the current position first, so a speed change applies from here on
+     * rather than retroactively rescaling everything already played, which would
+     * jump the caret.
+     */
+    setRate(rate: number): void;
+    get positionSeconds(): number;
+    get isRunning(): boolean;
+}
+//# sourceMappingURL=clock.d.ts.map

package/dist/web/playback/clock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clock.d.ts","sourceRoot":"","sources":["../../../src/web/playback/clock.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,qBAAa,aAAa;IAMZ,OAAO,CAAC,QAAQ,CAAC,GAAG;IALhC,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,SAAS,CAAK;IACtB,OAAO,CAAC,cAAc,CAAK;IAC3B,OAAO,CAAC,IAAI,CAAK;gBAEY,GAAG,EAAE,MAAM,MAAM;IAE9C,oFAAoF;IACpF,KAAK,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI;IAMjC,KAAK,IAAI,IAAI;IAMb,IAAI,IAAI,IAAI;IAMZ,wEAAwE;IACxE,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAK3B;;;;;;OAMG;IACH,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAM3B,IAAI,eAAe,IAAI,MAAM,CAG5B;IAED,IAAI,SAAS,IAAI,OAAO,CAEvB;CACF"}

package/dist/web/playback/clock.js

@@ -0,0 +1,64 @@
+/**
+ * Playback position, owned here rather than by Tone's Transport.
+ *
+ * `now` is injected: the engine passes the AudioContext's `currentTime`, so
+ * position is measured on the very clock the audio is rendered against, and
+ * tests pass a variable they control instead of waiting for real time.
+ *
+ * Everything works by anchoring — a position and the moment it was true —
+ * rather than by accumulating deltas. Accumulation drifts, and drift in the
+ * playback clock is what silenced tracks in the engine this replaces.
+ */
+export class PlaybackClock {
+    now;
+    running = false;
+    anchorNow = 0;
+    anchorPosition = 0;
+    rate = 1;
+    constructor(now) {
+        this.now = now;
+    }
+    /** Starts, or resumes from wherever it was paused. `fromSeconds` overrides that. */
+    start(fromSeconds) {
+        this.anchorPosition = fromSeconds ?? this.positionSeconds;
+        this.anchorNow = this.now();
+        this.running = true;
+    }
+    pause() {
+        if (!this.running)
+            return;
+        this.anchorPosition = this.positionSeconds;
+        this.running = false;
+    }
+    stop() {
+        this.running = false;
+        this.anchorPosition = 0;
+        this.anchorNow = this.now();
+    }
+    /** Jumps to `seconds`, keeping whatever running state the clock had. */
+    seek(seconds) {
+        this.anchorPosition = seconds;
+        this.anchorNow = this.now();
+    }
+    /**
+     * Scales elapsed time — the playback-speed control.
+     *
+     * Banks the current position first, so a speed change applies from here on
+     * rather than retroactively rescaling everything already played, which would
+     * jump the caret.
+     */
+    setRate(rate) {
+        this.anchorPosition = this.positionSeconds;
+        this.anchorNow = this.now();
+        this.rate = rate;
+    }
+    get positionSeconds() {
+        if (!this.running)
+            return this.anchorPosition;
+        return this.anchorPosition + (this.now() - this.anchorNow) * this.rate;
+    }
+    get isRunning() {
+        return this.running;
+    }
+}
+//# sourceMappingURL=clock.js.map

package/dist/web/playback/clock.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"clock.js","sourceRoot":"","sources":["../../../src/web/playback/clock.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,MAAM,OAAO,aAAa;IAMK;IALrB,OAAO,GAAG,KAAK,CAAC;IAChB,SAAS,GAAG,CAAC,CAAC;IACd,cAAc,GAAG,CAAC,CAAC;IACnB,IAAI,GAAG,CAAC,CAAC;IAEjB,YAA6B,GAAiB;QAAjB,QAAG,GAAH,GAAG,CAAc;IAAG,CAAC;IAElD,oFAAoF;IACpF,KAAK,CAAC,WAAoB;QACxB,IAAI,CAAC,cAAc,GAAG,WAAW,IAAI,IAAI,CAAC,eAAe,CAAC;QAC1D,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QAC5B,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;IACtB,CAAC;IAED,KAAK;QACH,IAAI,CAAC,IAAI,CAAC,OAAO;YAAE,OAAO;QAC1B,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC,eAAe,CAAC;QAC3C,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC;IACvB,CAAC;IAED,IAAI;QACF,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC;QACrB,IAAI,CAAC,cAAc,GAAG,CAAC,CAAC;QACxB,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;IAC9B,CAAC;IAED,wEAAwE;IACxE,IAAI,CAAC,OAAe;QAClB,IAAI,CAAC,cAAc,GAAG,OAAO,CAAC;QAC9B,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;IAC9B,CAAC;IAED;;;;;;OAMG;IACH,OAAO,CAAC,IAAY;QAClB,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC,eAAe,CAAC;QAC3C,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QAC5B,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;IACnB,CAAC;IAED,IAAI,eAAe;QACjB,IAAI,CAAC,IAAI,CAAC,OAAO;YAAE,OAAO,IAAI,CAAC,cAAc,CAAC;QAC9C,OAAO,IAAI,CAAC,cAAc,GAAG,CAAC,IAAI,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC,SAAS,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC;IACzE,CAAC;IAED,IAAI,SAAS;QACX,OAAO,IAAI,CAAC,OAAO,CAAC;IACtB,CAAC;CACF"}

package/dist/web/playback/governor.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Adaptive quality — currently measuring, not acting.
+ *
+ * This used to step interpolation order down after ten consecutive pump frames
+ * more than 100ms late, on the reasoning that a starved pump meant a starved
+ * synth. `setInterpolation(0)` renders the same passage in 53% of the time, so
+ * the knob is real, and timbre is the right thing to shed first.
+ *
+ * The scheduling horizon killed the reasoning. The pump no longer delivers
+ * notes on time — it tops up a four-second buffer in the worklet, and the
+ * synth renders from that buffer on the audio thread. The main thread can now
+ * stall for a second with nothing audible happening at all, so lateness here
+ * says only that the main thread is busy. Degrading timbre for every listener
+ * because a notation redraw took 119ms is a cost with no benefit.
+ *
+ * So the count is kept and nothing acts on it. It is free, and it is the shape
+ * a real audio-thread load signal would take. `AudioWorkletNode` exposes no
+ * such signal today, and `AudioContext` offers only latency figures that do not
+ * move under voice pressure; when one exists, it plugs in here.
+ *
+ * Polyphony was to be the other rung. `js-synthesizer` has no runtime setter
+ * for it — `ISynthesizer` has `setInterpolation` and `setGain` and nothing else
+ * — so the ceiling is chosen once at init in `synth-host.ts` and fluidsynth's
+ * own overflow priority does the stealing above it.
+ */
+export type GovernorOptions = {
+    onChange?: (interpolationOrder: number) => void;
+};
+export declare class Governor {
+    private readonly options;
+    private lateFrames;
+    constructor(options?: GovernorOptions);
+    get interpolation(): number;
+    /** Consecutive frames measured late. Diagnostic; nothing acts on it. */
+    get stalledFrames(): number;
+    /**
+     * One pump frame's lateness, in seconds.
+     *
+     * Counted, never acted on — see this module's doc for why. `options.onChange`
+     * is therefore never invoked; it is kept so the caller's wiring survives
+     * whatever replaces this signal.
+     */
+    record(lateBySeconds: number): void;
+}
+//# sourceMappingURL=governor.d.ts.map

package/dist/web/playback/governor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"governor.d.ts","sourceRoot":"","sources":["../../../src/web/playback/governor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,MAAM,eAAe,GAAG;IAC5B,QAAQ,CAAC,EAAE,CAAC,kBAAkB,EAAE,MAAM,KAAK,IAAI,CAAC;CACjD,CAAC;AAOF,qBAAa,QAAQ;IAGP,OAAO,CAAC,QAAQ,CAAC,OAAO;IAFpC,OAAO,CAAC,UAAU,CAAK;gBAEM,OAAO,GAAE,eAAoB;IAE1D,IAAI,aAAa,IAAI,MAAM,CAE1B;IAED,wEAAwE;IACxE,IAAI,aAAa,IAAI,MAAM,CAE1B;IAED;;;;;;OAMG;IACH,MAAM,CAAC,aAAa,EAAE,MAAM,GAAG,IAAI;CAOpC"}

package/dist/web/playback/governor.js

@@ -0,0 +1,33 @@
+/** fluidsynth's interpolation orders, best first. */
+const LADDER = [7, 4, 1, 0];
+/** How late a pump frame must be to count against the budget. */
+const LATE_THRESHOLD_SECONDS = 0.1;
+export class Governor {
+    options;
+    lateFrames = 0;
+    constructor(options = {}) {
+        this.options = options;
+    }
+    get interpolation() {
+        return LADDER[0];
+    }
+    /** Consecutive frames measured late. Diagnostic; nothing acts on it. */
+    get stalledFrames() {
+        return this.lateFrames;
+    }
+    /**
+     * One pump frame's lateness, in seconds.
+     *
+     * Counted, never acted on — see this module's doc for why. `options.onChange`
+     * is therefore never invoked; it is kept so the caller's wiring survives
+     * whatever replaces this signal.
+     */
+    record(lateBySeconds) {
+        if (lateBySeconds > LATE_THRESHOLD_SECONDS) {
+            this.lateFrames += 1;
+            return;
+        }
+        this.lateFrames = 0;
+    }
+}
+//# sourceMappingURL=governor.js.map

package/dist/web/playback/governor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"governor.js","sourceRoot":"","sources":["../../../src/web/playback/governor.ts"],"names":[],"mappings":"AA6BA,qDAAqD;AACrD,MAAM,MAAM,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;AAC5B,iEAAiE;AACjE,MAAM,sBAAsB,GAAG,GAAG,CAAC;AAEnC,MAAM,OAAO,QAAQ;IAGU;IAFrB,UAAU,GAAG,CAAC,CAAC;IAEvB,YAA6B,UAA2B,EAAE;QAA7B,YAAO,GAAP,OAAO,CAAsB;IAAG,CAAC;IAE9D,IAAI,aAAa;QACf,OAAO,MAAM,CAAC,CAAC,CAAC,CAAC;IACnB,CAAC;IAED,wEAAwE;IACxE,IAAI,aAAa;QACf,OAAO,IAAI,CAAC,UAAU,CAAC;IACzB,CAAC;IAED;;;;;;OAMG;IACH,MAAM,CAAC,aAAqB;QAC1B,IAAI,aAAa,GAAG,sBAAsB,EAAE,CAAC;YAC3C,IAAI,CAAC,UAAU,IAAI,CAAC,CAAC;YACrB,OAAO;QACT,CAAC;QACD,IAAI,CAAC,UAAU,GAAG,CAAC,CAAC;IACtB,CAAC;CACF"}

package/dist/web/playback/quiet-stub-notices.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Silences libfluidsynth's build-stub notices, and nothing else.
+ *
+ * The WASM build stubs out filesystem calls it does not need and reports each
+ * one at *error* level every time a soundfont is loaded:
+ *
+ *     fluidsynth: error: function fluid_stat is a stub, always returning -1
+ *     fluidsynth: error: function fluid_file_test is a stub, always returning true
+ *
+ * They are build notices, not failures — audio is verified working with them
+ * firing. They also cannot be suppressed through `js-synthesizer`'s
+ * `disableLogging`, which controls fluidsynth's *log callback*: these come out
+ * of the C code's stderr through emscripten's stdio instead, as the stack shows
+ * (`put_char → write → doWritev → _fd_write`).
+ *
+ * Two different hooks are needed, because the two paths load the module
+ * differently.
+ *
+ * On the **main thread** the build is injected as a classic script, so its
+ * `var Module = typeof Module != "undefined" ? Module : {}` sees a global we
+ * seeded first, and `Module.printErr` redirects the stream.
+ *
+ * In an **AudioWorklet** that does not work: `addModule` loads module scripts,
+ * so `var Module` is module-scoped and a global seed is invisible. The hook
+ * there is the other half of the same line — `Module["printErr"] ||
+ * console.error.bind(console)` binds whatever `console.error` *is at module
+ * init*. Replacing it in the worklet's own scope beforehand therefore catches
+ * the stream, and affects nothing outside that worklet.
+ *
+ * This matters more than tidiness: fluidsynth calls the stubs once per sample
+ * while loading, which measured at over a thousand console writes per font —
+ * each capturing a stack, during the load this engine is already slow at.
+ *
+ * Deliberately a pattern match rather than blanket suppression: anything that
+ * is not a stub notice is passed straight through to `console.error`, so a real
+ * fluidsynth failure still reaches the console.
+ */
+/** Matches only "function <name> is a stub, ..." — the emscripten build notices. */
+export declare const STUB_NOTICE_PATTERN: RegExp;
+export declare function isStubNotice(text: unknown): boolean;
+/**
+ * A module URL that filters the stub notices inside an AudioWorklet.
+ *
+ * Patches the worklet's own `console.error` rather than seeding `Module`, for
+ * the module-scoping reason above. Scoped to the worklet, so the page console
+ * is untouched.
+ *
+ * A blob rather than a hosted file: it is a few lines, and making an app host
+ * another asset just to quiet a log would be a poor trade. Returns `null` where
+ * blobs are unavailable, in which case the notices simply remain.
+ */
+export declare function createWorkletQuietModuleUrl(): string | null;
+/** Seeds the quiet `Module` on the main thread, before libfluidsynth is injected. */
+export declare function seedMainThreadQuietModule(): void;
+//# sourceMappingURL=quiet-stub-notices.d.ts.map

package/dist/web/playback/quiet-stub-notices.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"quiet-stub-notices.d.ts","sourceRoot":"","sources":["../../../src/web/playback/quiet-stub-notices.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AAEH,oFAAoF;AACpF,eAAO,MAAM,mBAAmB,QAA2B,CAAC;AAE5D,wBAAgB,YAAY,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO,CAEnD;AA0BD;;;;;;;;;;GAUG;AACH,wBAAgB,2BAA2B,IAAI,MAAM,GAAG,IAAI,CAG3D;AAED,qFAAqF;AACrF,wBAAgB,yBAAyB,IAAI,IAAI,CAQhD"}

package/dist/web/playback/quiet-stub-notices.js

@@ -0,0 +1,93 @@
+/**
+ * Silences libfluidsynth's build-stub notices, and nothing else.
+ *
+ * The WASM build stubs out filesystem calls it does not need and reports each
+ * one at *error* level every time a soundfont is loaded:
+ *
+ *     fluidsynth: error: function fluid_stat is a stub, always returning -1
+ *     fluidsynth: error: function fluid_file_test is a stub, always returning true
+ *
+ * They are build notices, not failures — audio is verified working with them
+ * firing. They also cannot be suppressed through `js-synthesizer`'s
+ * `disableLogging`, which controls fluidsynth's *log callback*: these come out
+ * of the C code's stderr through emscripten's stdio instead, as the stack shows
+ * (`put_char → write → doWritev → _fd_write`).
+ *
+ * Two different hooks are needed, because the two paths load the module
+ * differently.
+ *
+ * On the **main thread** the build is injected as a classic script, so its
+ * `var Module = typeof Module != "undefined" ? Module : {}` sees a global we
+ * seeded first, and `Module.printErr` redirects the stream.
+ *
+ * In an **AudioWorklet** that does not work: `addModule` loads module scripts,
+ * so `var Module` is module-scoped and a global seed is invisible. The hook
+ * there is the other half of the same line — `Module["printErr"] ||
+ * console.error.bind(console)` binds whatever `console.error` *is at module
+ * init*. Replacing it in the worklet's own scope beforehand therefore catches
+ * the stream, and affects nothing outside that worklet.
+ *
+ * This matters more than tidiness: fluidsynth calls the stubs once per sample
+ * while loading, which measured at over a thousand console writes per font —
+ * each capturing a stack, during the load this engine is already slow at.
+ *
+ * Deliberately a pattern match rather than blanket suppression: anything that
+ * is not a stub notice is passed straight through to `console.error`, so a real
+ * fluidsynth failure still reaches the console.
+ */
+/** Matches only "function <name> is a stub, ..." — the emscripten build notices. */
+export const STUB_NOTICE_PATTERN = /function \w+ is a stub/;
+export function isStubNotice(text) {
+    return STUB_NOTICE_PATTERN.test(String(text));
+}
+/**
+ * The seed, as source, so it can run in a worklet where our modules cannot
+ * reach. Kept in sync with `isStubNotice` by construction: both use the same
+ * pattern, written once here.
+ */
+function seedSource() {
+    // Must run before libfluidsynth: emscripten binds console.error at init.
+    return `(function () {
+  var pattern = ${STUB_NOTICE_PATTERN.toString()};
+  var original = console.error.bind(console);
+  console.error = function () {
+    for (var i = 0; i < arguments.length; i++) {
+      if (typeof arguments[i] === 'string' && pattern.test(arguments[i])) return;
+    }
+    original.apply(null, arguments);
+  };
+  globalThis.Module = Object.assign({}, globalThis.Module, {
+    printErr: function (text) {
+      if (!pattern.test(String(text))) original(text);
+    },
+  });
+})();`;
+}
+/**
+ * A module URL that filters the stub notices inside an AudioWorklet.
+ *
+ * Patches the worklet's own `console.error` rather than seeding `Module`, for
+ * the module-scoping reason above. Scoped to the worklet, so the page console
+ * is untouched.
+ *
+ * A blob rather than a hosted file: it is a few lines, and making an app host
+ * another asset just to quiet a log would be a poor trade. Returns `null` where
+ * blobs are unavailable, in which case the notices simply remain.
+ */
+export function createWorkletQuietModuleUrl() {
+    if (typeof Blob === 'undefined' || typeof URL?.createObjectURL !== 'function')
+        return null;
+    return URL.createObjectURL(new Blob([seedSource()], { type: 'text/javascript' }));
+}
+/** Seeds the quiet `Module` on the main thread, before libfluidsynth is injected. */
+export function seedMainThreadQuietModule() {
+    const scope = globalThis;
+    scope.Module = {
+        ...scope.Module,
+        printErr: (text) => {
+            if (!isStubNotice(text))
+                console.error(text);
+        },
+    };
+}
+//# sourceMappingURL=quiet-stub-notices.js.map

package/dist/web/playback/quiet-stub-notices.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"quiet-stub-notices.js","sourceRoot":"","sources":["../../../src/web/playback/quiet-stub-notices.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AAEH,oFAAoF;AACpF,MAAM,CAAC,MAAM,mBAAmB,GAAG,wBAAwB,CAAC;AAE5D,MAAM,UAAU,YAAY,CAAC,IAAa;IACxC,OAAO,mBAAmB,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC;AAChD,CAAC;AAED;;;;GAIG;AACH,SAAS,UAAU;IACjB,yEAAyE;IACzE,OAAO;kBACS,mBAAmB,CAAC,QAAQ,EAAE;;;;;;;;;;;;;MAa1C,CAAC;AACP,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,UAAU,2BAA2B;IACzC,IAAI,OAAO,IAAI,KAAK,WAAW,IAAI,OAAO,GAAG,EAAE,eAAe,KAAK,UAAU;QAAE,OAAO,IAAI,CAAC;IAC3F,OAAO,GAAG,CAAC,eAAe,CAAC,IAAI,IAAI,CAAC,CAAC,UAAU,EAAE,CAAC,EAAE,EAAE,IAAI,EAAE,iBAAiB,EAAE,CAAC,CAAC,CAAC;AACpF,CAAC;AAED,qFAAqF;AACrF,MAAM,UAAU,yBAAyB;IACvC,MAAM,KAAK,GAAG,UAA6D,CAAC;IAC5E,KAAK,CAAC,MAAM,GAAG;QACb,GAAG,KAAK,CAAC,MAAM;QACf,QAAQ,EAAE,CAAC,IAAa,EAAE,EAAE;YAC1B,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC;gBAAE,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;QAC/C,CAAC;KACF,CAAC;AACJ,CAAC"}

package/dist/web/playback/soundfont-engine.d.ts

@@ -0,0 +1,281 @@
+/**
+ * `PlaybackEngine` over a worklet-hosted soundfont synth.
+ *
+ * The shape is: a note queue with a cursor, a clock we own, and a pump that
+ * keeps a multi-second horizon of timed notes topped up in the worklet's
+ * sequencer. Timing therefore lives on the audio thread, and the pump's only
+ * job — refilling a buffer — is one that tolerates being late. Voice
+ * allocation and stealing belong to fluidsynth, which is the point: every
+ * note-loss bug in the engine this replaces came from our own voice management
+ * refusing a note.
+ *
+ * Everything time-related is injected (`now`, `startPump`, `createContext`,
+ * `loadFont`) so the transport can be tested without an audio device or real
+ * time. The alternative is an engine verifiable only by ear, which is how the
+ * last one accumulated four silent-failure bugs.
+ */
+import type { PlaybackPlan, PlaybackTrack, ScoreRange } from '@sudobility/music_types';
+import type { AuditionVoice, PlaybackEngine, PlaybackObserver } from '../../engine.js';
+import type { LoadProgress } from './soundfont-loader.js';
+/** The slice of `SynthHost` this engine drives, so tests can pass a stub. */
+export type SynthHostLike = {
+    init(context: BaseAudioContext, options: {
+        fluidsynthModuleUrl: string;
+        workletModuleUrl: string;
+        soundfont: ArrayBuffer;
+        instanceCount: number;
+    }): Promise<void>;
+    ensureInstances(count: number): Promise<void>;
+    setChannelPercussion(instance: number, channel: number, kit?: number): void;
+    programSelect(instance: number, channel: number, program: number): void;
+    noteOn(instance: number, channel: number, midi: number, velocity: number): void;
+    noteAt(instance: number, channel: number, midi: number, velocity: number, delaySeconds: number, durationSeconds: number): void;
+    noteOff(instance: number, channel: number, midi: number): void;
+    controlChange(instance: number, channel: number, control: number, value: number): void;
+    allSoundOff(): void;
+    setInterpolation(order: number): void;
+    setMasterVolume(volume: number): void;
+    setTrackCount(count: number): void;
+    dispose(): void;
+};
+export type SoundfontEngineDeps = {
+    host: SynthHostLike;
+    moduleUrls: {
+        fluidsynth: string;
+        worklet: string;
+    };
+    fontUrl: string;
+    loadFont?: (url: string, onProgress?: (progress: LoadProgress) => void) => Promise<ArrayBuffer>;
+    createContext?: () => AudioContext;
+    /** Defaults to the audio context's own clock, which is what the audio is rendered against. */
+    now?: () => number;
+    /** Starts the pump and returns a function that stops it. */
+    startPump?: (tick: () => void, intervalMs: number) => () => void;
+};
+export declare class SoundfontPlaybackEngine implements PlaybackEngine {
+    private readonly queue;
+    private readonly governor;
+    /** When the pump was last expected to run, for measuring how late it is. */
+    private nextPumpDueAt;
+    private readonly clock;
+    private readonly deps;
+    private context;
+    private plan;
+    /** Replaced on every `load`. The default is 120 BPM at ppq 480, as before. */
+    private tempo;
+    private tracks;
+    private observer;
+    private stopPump;
+    private readonly sounding;
+    /**
+     * When the last note of the loaded score finishes.
+     *
+     * The transport used to know the piece was over by the note queue being
+     * exhausted *and* no note-offs being outstanding. Releases now happen in the
+     * worklet, so there is nothing outstanding to count — this is what stops
+     * playback ending on the last note's attack instead of its release.
+     */
+    private lastNoteEndSeconds;
+    private loopRange;
+    private lastReportedAt;
+    private initialized;
+    /** In-flight bring-up, so concurrent callers share one attempt. */
+    private initializing;
+    private loadState;
+    /** Counted so a pump that fails every tick reports once, not sixty times a second. */
+    private tickFailures;
+    /**
+     * Where playback should begin once the pump actually runs.
+     *
+     * The clock is *not* started by `play()`. Starting it there loses the opening
+     * of the piece: the first pump tick can be seconds late while the main thread
+     * finishes worklet and soundfont setup, and by then the clock says the music
+     * is already seconds in — so every note before that point is past its grace
+     * window and gets skipped. Measured at 2.3s of lost opening on a real load.
+     * Anchoring on the first tick instead means the piece starts where it should,
+     * however busy the thread was.
+     */
+    private startAtSeconds;
+    private metronomeEnabled;
+    /** Click positions in ticks, with a cursor, mirroring how notes are drained. */
+    private clicks;
+    private clickCursor;
+    /**
+     * Clicks already placed on the audio graph, so the transport can take them
+     * back.
+     *
+     * They are scheduled a whole horizon ahead and do not go through the synth,
+     * so `allSoundOff` says nothing to them: pausing used to leave the room
+     * ticking for four seconds after the music stopped.
+     */
+    private pendingClicks;
+    /** Audition voices are held on their own channel so they never disturb a track. */
+    private auditionHeld;
+    /** How many synths the current score's channel assignment needs. */
+    private instanceCount;
+    private tempoMultiplier;
+    /**
+     * The channel auditions borrow — recomputed per score so it is one no track owns.
+     *
+     * It used to be channel 15 flat. That channel belongs to a track on any score
+     * with fifteen pitched parts, so tapping a key selected the audition's program
+     * on it and left that part playing the wrong instrument until the next edit
+     * reloaded the score.
+     */
+    private auditionChannel;
+    constructor(deps: SoundfontEngineDeps);
+    private now;
+    private secondsForTick;
+    /**
+     * Brings up the audio context and the synth, once.
+     *
+     * Resuming comes first, and the guard after it is the whole point. A browser
+     * starts an `AudioContext` **suspended** unless it was created during a user
+     * gesture, and a suspended context never runs its `AudioWorklet`. The synth's
+     * font load round-trips through that worklet, so attempting it on a suspended
+     * context does not fail — it simply never returns. That is what happened:
+     * `load` ran at load time, long before any click, and left a
+     * promise pending for good. Every later `play()` awaited the same promise,
+     * so the transport sat at "stopped" with nothing in the console to explain it.
+     *
+     * So when the context cannot be got running, this does the cheap part and
+     * returns. `play()` and `noteOn()` are user gestures and will get it running.
+     */
+    initialize(): Promise<void>;
+    private bringUp;
+    /** Only on change, so a progress stream does not become a store-update stream. */
+    private reportLoad;
+    /** Best effort: without a user gesture behind it this is allowed to fail. */
+    private resumeContext;
+    /** A stub context in a test has no `state`; only a real suspended one blocks. */
+    private contextCanRun;
+    load(plan: PlaybackPlan): Promise<void>;
+    /**
+     * A channel no track owns, searched from the top down because tracks fill
+     * from the bottom.
+     *
+     * Channel 9 is skipped: it is General MIDI's drum channel, so borrowing it
+     * would make every audition a drum hit. Percussion auditions get their drum
+     * type switched on instead, which is the same route a second drum track takes.
+     *
+     * Where a score owns every channel of every open instance there is nothing to
+     * borrow, and it falls back to sharing the last one — an audition that
+     * disturbs one track's program beats a keyboard that makes no sound.
+     */
+    private pickAuditionChannel;
+    /** Tells the host each track's program, percussion flag, pan and level. */
+    private applyPlanToHost;
+    /** Volume, mute and solo all resolve to one CC7 value per channel. */
+    private applyTrackLevels;
+    /**
+     * Starts the transport — reporting "playing" only once it is true.
+     *
+     * The first press of Play has to load a 23MB soundfont and hand it to
+     * fluidsynth, which takes seconds. This used to report "playing" up front so
+     * the button would not look dead through that wait, on the reasoning that it
+     * cost nothing in accuracy: the clock does not start until the pump's first
+     * tick, so no part of the piece is skipped however long the load takes.
+     *
+     * It cost something in accuracy elsewhere. The **caret** does not follow the
+     * engine's position while playing — it interpolates, dead-reckoning from the
+     * last 30Hz report with elapsed real time, because those reports arrive in
+     * clumps. During the load there are no reports at all, so the caret projected
+     * forward from a standing start and glided silently through several bars,
+     * then snapped back when the music finally began at the beginning. Two
+     * separately-sound optimisations that could not both be right.
+     *
+     * So the transport now says what is true, and `PlaybackLoadState` — which the
+     * bar renders as "Preparing instruments 45%" — says why the wait is happening.
+     * That indicator did not exist when the early report was written; it is what
+     * makes honesty affordable here.
+     *
+     * Only a cold engine waits. Once the synth is up this reports synchronously,
+     * which is every press after the first.
+     */
+    play(fromTick?: number): Promise<void>;
+    pause(): void;
+    stop(): void;
+    seek(tick: number): void;
+    /**
+     * Changes playback speed, rebuilding what is already queued.
+     *
+     * Every note in the sequencer carries a delay worked out at the speed that
+     * was in force when it was posted, and the horizon is four seconds deep — so
+     * on its own a speed change moved the caret at once and left the music at the
+     * old tempo for a whole horizon, then jumped. Re-seeking where we stand drops
+     * that backlog, and the next tick refills it at the new speed. The gap is one
+     * pump interval.
+     */
+    setTempoMultiplier(multiplier: number): void;
+    setLoop(range: ScoreRange | null): void;
+    setTrackMute(trackId: string, muted: boolean): void;
+    setTrackSolo(trackId: string, solo: boolean): void;
+    /**
+     * Re-reads the mix off `score` and pushes it, scheduling nothing.
+     *
+     * `setTrackMute`/`setTrackSolo` covered two of the four mix properties.
+     * Volume was read once, in `load`, and pan only in `applyPlanToHost` —
+     * so with the playback edit lock in place, where a mix change deliberately
+     * does *not* reload, moving a fader mid-playback moved the fader and left the
+     * sound where it was.
+     *
+     * A track the engine does not know is skipped rather than throwing: a mix
+     * change cannot add a track (that would be content), so an unknown id means
+     * the engine is holding an older plan and the next `load` settles it.
+     */
+    applyMix(tracks: readonly PlaybackTrack[]): void;
+    setMetronome(enabled: boolean): void;
+    setMasterVolume(volume: number): void;
+    noteOn(midi: number, voice: AuditionVoice): void;
+    noteOff(midi: number): void;
+    setObserver(observer: PlaybackObserver | null): void;
+    dispose(): void;
+    private startPump;
+    private endPump;
+    private tick;
+    private dispatchTick;
+    /**
+     * The far edge of what this tick may schedule, in ticks.
+     *
+     * Clamped to just inside a loop, because the wrap only happens on the pump
+     * tick *after* the end is reached: without this a note or click a few
+     * milliseconds past the loop end was already in the sequencer and sounded
+     * before the loop came round, on every pass. The end tick itself belongs to
+     * the next pass, where it is the loop's own first beat.
+     */
+    private horizonTick;
+    /**
+     * How late this frame ran against when it was due.
+     *
+     * Measured on the audio clock rather than wall time, because that is the
+     * clock the audio is rendered against and the one that matters if the thread
+     * is being starved.
+     */
+    private measureLateness;
+    /**
+     * Clicks due in this window, scheduled ahead at their exact moment.
+     *
+     * Unlike notes, these can be placed precisely: an oscillator started with
+     * `start(at)` sounds at that sample however busy the main thread is, so the
+     * click stays steady even when the pump runs late.
+     */
+    private pumpMetronome;
+    /** Takes back every click still queued — a stop, a seek, or the switch going off. */
+    private cancelPendingClicks;
+    /** Inverse of `secondsForTick`, for turning the lookahead window back into ticks. */
+    private tickForSeconds;
+    private get playbackSpeed();
+    private applyLoop;
+    /**
+     * Position and active notes, both at 30Hz.
+     *
+     * The engine this replaces called `onActiveNotes` on every note-on *and*
+     * note-off — some 11,500 store updates for a three-minute piece, on the same
+     * thread the scheduler runs on. Coalescing is what keeps that work off the
+     * pump's back.
+     */
+    private report;
+    /** Drops the sounding set and says so, for a seek, stop or teardown. */
+    private clearSounding;
+}
+//# sourceMappingURL=soundfont-engine.d.ts.map

package/dist/web/playback/soundfont-engine.d.ts.map

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