tone 15.5.41 → 15.5.43

package/Tone/core/clock/Clock.test.ts

@@ -354,6 +354,65 @@ describe("Clock", () => {
 				clock.start(0, 4);
 			});
 		});
+
+		it("does not replay stale pre-restart ticks when the loop update has fallen behind a restart (#1419)", async () => {
+			const observedTicks: Array<number | undefined> = [];
+			await Offline(() => {
+				const clock = new Clock((_t, ticks) => {
+					observedTicks.push(ticks);
+				}, 200);
+				const boundLoop = (
+					clock as unknown as { _boundLoop: () => void }
+				)._boundLoop;
+				clock.start(0);
+				// Detach the clock's own loop from the context's "tick" event
+				// so _lastUpdate genuinely never catches up, simulating the
+				// tick loop's cadence (default updateInterval=0.05s) falling
+				// behind a rapid stop/start cycle, as described in #1419.
+				clock.context.off("tick", boundLoop);
+				return atTime(0.02, (time) => {
+					clock.stop(time);
+					clock.start(time, 40);
+					// Reattach the loop: without a fix, it would replay ticks
+					// from [_lastUpdate, time) using the pre-restart TickSource
+					// state instead of the new offset.
+					clock.context.on("tick", boundLoop);
+				});
+			}, 0.03);
+			expect(observedTicks).to.deep.equal([0, 1, 2, 3, 4, 40, 41]);
+		});
+
+		it("does not drop the pending stop event or pending ticks when stop and the following start happen at different times within the stale window (#1419)", async () => {
+			const observedTicks: Array<number | undefined> = [];
+			const stopEvents: number[] = [];
+			await Offline(() => {
+				const clock = new Clock((_t, ticks) => {
+					observedTicks.push(ticks);
+				}, 200);
+				const boundLoop = (
+					clock as unknown as { _boundLoop: () => void }
+				)._boundLoop;
+				clock.on("stop", (time) => {
+					stopEvents.push(time);
+				});
+				clock.start(0);
+				// Same staleness simulation as above, but this time stop() and
+				// the following start() are scheduled at two distinct times
+				// within the stale window, rather than the same instant.
+				clock.context.off("tick", boundLoop);
+				return atTime(0.025, () => {
+					clock.stop(0.015);
+					clock.start(0.02, 40);
+					clock.context.on("tick", boundLoop);
+				});
+			}, 0.03);
+			// the "stop" event scheduled at 0.015 must still fire
+			expect(stopEvents).to.deep.equal([0.015]);
+			// ticks 0, 1, 2 (at 200Hz: 0, 0.005, 0.01) are still pending
+			// in [_lastUpdate, 0.015) and must still fire, followed by
+			// the post-restart ticks from offset 40
+			expect(observedTicks).to.deep.equal([0, 1, 2, 40, 41]);
+		});
 	});
 
 	context("Events", () => {

package/Tone/core/clock/Clock.ts

@@ -133,6 +133,17 @@ export class Clock<TypeName extends "bpm" | "hertz" = "hertz">
 		const computedTime = this.toSeconds(time);
 		this.log("start", computedTime);
 		if (this._state.getValueAtTime(computedTime) !== "started") {
+			if (this._lastUpdate < computedTime && computedTime <= this.now()) {
+				// _lastUpdate has not yet caught up to this restart (e.g.
+				// rapid stop/start cycles outrunning the tick loop's
+				// cadence). Flush the state-transition events (e.g. a
+				// pending "stop") and tick callbacks still waiting in
+				// [_lastUpdate, computedTime) using the pre-restart
+				// TickSource state before it's reset below, so they aren't
+				// silently dropped, and so the next _loop() pass doesn't
+				// replay them using the post-restart state.
+				this._processRange(this._lastUpdate, computedTime);
+			}
 			this._state.setStateAtTime("started", computedTime);
 			this._tickSource.start(computedTime, offset);
 			if (computedTime < this._lastUpdate) {
@@ -267,9 +278,19 @@ export class Clock<TypeName extends "bpm" | "hertz" = "hertz">
 	private _loop(): void {
 		const startTime = this._lastUpdate;
 		const endTime = this.now();
-		this._lastUpdate = endTime;
 		this.log("loop", startTime, endTime);
+		this._processRange(startTime, endTime);
+	}
 
+	/**
+	 * Invoke the state-transition events (start/stop/pause) and tick
+	 * callbacks scheduled between startTime and endTime, and advance
+	 * _lastUpdate to endTime.
+	 * @param startTime The beginning of the range to process.
+	 * @param endTime The end of the range to process.
+	 */
+	private _processRange(startTime: number, endTime: number): void {
+		this._lastUpdate = endTime;
 		if (startTime !== endTime) {
 			// the state change events
 			this._state.forEachBetween(startTime, endTime, (e) => {

package/Tone/core/clock/Transport.test.ts

@@ -1001,6 +1001,38 @@ describe("Transport", () => {
 			expect(invocations).to.equal(3);
 		});
 
+		it("does not drop the transport's stop event when stop/start outrun the clock's tick loop (#1419)", async () => {
+			const stopEvents: number[] = [];
+			await Offline((context) => {
+				const transport = new TransportInstance({ context });
+				transport.on("stop", (time) => {
+					stopEvents.push(time);
+				});
+				const clock = (
+					transport as unknown as {
+						_clock: {
+							context: typeof context;
+							_boundLoop: () => void;
+						};
+					}
+				)._clock;
+				transport.start(0);
+				// Detach the clock's own loop from the context's "tick"
+				// event so its _lastUpdate genuinely falls behind,
+				// simulating the tick loop's cadence (default
+				// updateInterval=0.05s) outrunning a rapid
+				// Transport.stop()/Transport.start() cycle, as described
+				// in #1419.
+				clock.context.off("tick", clock._boundLoop);
+				return atTime(0.02, () => {
+					transport.stop(0.015);
+					transport.start(0.018);
+					clock.context.on("tick", clock._boundLoop);
+				});
+			}, 0.03);
+			expect(stopEvents).to.deep.equal([0.015]);
+		});
+
 		it("invokes start event with correct offset", async () => {
 			let wasCalled = false;
 			await Offline((context) => {

package/Tone/version.ts

@@ -1 +1 @@
-export const version: string = "15.5.41";
+export const version: string = "15.5.43";