tone 15.5.53 → 15.5.55

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

@@ -1,7 +1,12 @@
 import { expect } from "chai";
 
 import { BasicTests } from "../../../test/helper/Basic.js";
-import { atTime, Offline, whenBetween } from "../../../test/helper/Offline.js";
+import {
+	atTime,
+	holdClock,
+	Offline,
+	whenBetween,
+} from "../../../test/helper/Offline.js";
 import { noOp } from "../util/Interface.js";
 import { Clock } from "./Clock.js";
 
@@ -361,23 +366,14 @@ describe("Clock", () => {
 				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);
-				});
+				return atTime(
+					0.02,
+					holdClock(clock, (time) => {
+						clock.stop(time);
+						clock.start(time, 40);
+					})
+				);
 			}, 0.03);
 			expect(observedTicks).to.deep.equal([0, 1, 2, 3, 4, 40, 41]);
 		});
@@ -389,22 +385,17 @@ describe("Clock", () => {
 				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);
-				});
+				return atTime(
+					0.025,
+					holdClock(clock, () => {
+						clock.stop(0.015);
+						clock.start(0.02, 40);
+					})
+				);
 			}, 0.03);
 			// the "stop" event scheduled at 0.015 must still fire
 			expect(stopEvents).to.deep.equal([0.015]);
@@ -419,22 +410,17 @@ describe("Clock", () => {
 			let restartTime = 0;
 			await Offline(() => {
 				const clock = new Clock(noOp, 200);
-				const boundLoop = (
-					clock as unknown as { _boundLoop: () => void }
-				)._boundLoop;
 				clock.on("stop", (time) => events.push(["stop", time]));
 				clock.on("start", (time) => events.push(["start", time]));
 				clock.start(0);
-				// Same staleness simulation as above. stop() and start() are
-				// scheduled at the same instant, as happens when both default
-				// to now() within one task: `transport.stop(); transport.start()`
-				clock.context.off("tick", boundLoop);
-				return atTime(0.02, (time) => {
-					restartTime = time;
-					clock.stop(time);
-					clock.start(time, 40);
-					clock.context.on("tick", boundLoop);
-				});
+				return atTime(
+					0.02,
+					holdClock(clock, (time) => {
+						restartTime = time;
+						clock.stop(time);
+						clock.start(time, 40);
+					})
+				);
 			}, 0.03);
 			expect(events).to.deep.equal([
 				["start", 0],

package/Tone/core/clock/Clock.ts

@@ -167,6 +167,12 @@ export class Clock<TypeName extends "bpm" | "hertz" = "hertz">
 	stop(time?: Time): this {
 		const computedTime = this.toSeconds(time);
 		this.log("stop", computedTime);
+		if (this._lastUpdate < computedTime && computedTime <= this.now()) {
+			// Deliver the ticks still pending before the stop against the
+			// events scheduled so far, so they aren't replayed against events
+			// scheduled for the next run between stop() and start().
+			this._processRange(this._lastUpdate, computedTime);
+		}
 		this._state.cancel(computedTime);
 		this._state.setStateAtTime("stopped", computedTime);
 		this._tickSource.stop(computedTime);

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

@@ -4,7 +4,12 @@ import "../context/Destination.js";
 import { expect } from "chai";
 
 import { warns } from "../../../test/helper/Basic.js";
-import { atTime, Offline, whenBetween } from "../../../test/helper/Offline.js";
+import {
+	atTime,
+	holdClock,
+	Offline,
+	whenBetween,
+} from "../../../test/helper/Offline.js";
 import { Synth } from "../../instrument/Synth.js";
 import { Signal } from "../../signal/Signal.js";
 import { Time } from "../type/Time.js";
@@ -1008,31 +1013,40 @@ describe("Transport", () => {
 				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);
-				});
+				return atTime(
+					0.02,
+					holdClock(transport, () => {
+						transport.stop(0.015);
+						transport.start(0.018);
+					})
+				);
 			}, 0.03);
 			expect(stopEvents).to.deep.equal([0.015]);
 		});
 
+		it("does not fire an event scheduled after stop() from the previous run (#1502)", async () => {
+			const invocations: number[] = [];
+			let restartTime = 0;
+			await Offline((context) => {
+				const transport = new TransportInstance({ context });
+				transport.start(0);
+				return atTime(
+					0.02,
+					holdClock(transport, (time) => {
+						transport.stop(time);
+						// For the next run, at a position the previous run passed
+						// between its last processed tick and the stop.
+						transport.schedule((t) => invocations.push(t), "5i");
+						restartTime = time + 0.005;
+						transport.start(restartTime);
+					})
+				);
+			}, 0.05);
+			expect(invocations).to.have.length(1);
+			expect(invocations[0]).to.be.at.least(restartTime);
+		});
+
 		it("invokes start event with correct offset", async () => {
 			let wasCalled = false;
 			await Offline((context) => {

package/Tone/event/Loop.test.ts

@@ -1,7 +1,12 @@
 import { expect } from "chai";
 
 import { BasicTests } from "../../test/helper/Basic.js";
-import { Offline, whenBetween } from "../../test/helper/Offline.js";
+import {
+	atTime,
+	holdClock,
+	Offline,
+	whenBetween,
+} from "../../test/helper/Offline.js";
 import { Time } from "../core/type/Time.js";
 import { noOp } from "../core/util/Interface.js";
 import { Loop } from "./Loop.js";
@@ -217,6 +222,29 @@ describe("Loop", () => {
 	});
 
 	context("Looping", () => {
+		it("starts a Loop created between stop() and start() with the new run (#1502)", async () => {
+			const beats: number[] = [];
+			let restartTime = 0;
+			await Offline((context) => {
+				const transport = context.transport;
+				transport.start(0);
+				return atTime(
+					0.02,
+					holdClock(transport, (time) => {
+						transport.stop(time);
+						new Loop({
+							context,
+							callback: (t) => beats.push(t),
+							interval: "4i",
+						}).start(0);
+						restartTime = time + 0.005;
+						transport.start(restartTime);
+					})
+				);
+			}, 0.05);
+			expect(beats[0]).to.be.at.least(restartTime);
+		});
+
 		it("loops", async () => {
 			let callCount = 0;
 			await Offline(({ transport }) => {

package/Tone/source/Source.test.ts

@@ -1,6 +1,6 @@
 import { expect } from "chai";
 
-import { atTime, Offline } from "../../test/helper/Offline.js";
+import { atTime, holdClock, Offline } from "../../test/helper/Offline.js";
 import { ToneAudioBuffer } from "../core/context/ToneAudioBuffer.js";
 import { getContext } from "../core/Global.js";
 import { Player } from "./buffer/Player.js";
@@ -334,24 +334,14 @@ describe("Source", () => {
 			const output = await Offline(({ transport }) => {
 				const source = new Player(rampBuffer).toDestination();
 				source.sync().start(0);
-				const clock = (
-					transport as unknown as {
-						_clock: {
-							context: typeof transport.context;
-							_boundLoop: () => void;
-						};
-					}
-				)._clock;
 				transport.start(0);
-				// hold the clock loop back so that stop/start land ahead of
-				// _lastUpdate, as they do in a realtime context where both
-				// default to now() = currentTime + lookAhead
-				clock.context.off("tick", clock._boundLoop);
-				return atTime(0.2, (time) => {
-					transport.stop(time);
-					transport.start(time, 0.5);
-					clock.context.on("tick", clock._boundLoop);
-				});
+				return atTime(
+					0.2,
+					holdClock(transport, (time) => {
+						transport.stop(time);
+						transport.start(time, 0.5);
+					})
+				);
 			}, 0.5);
 			// before the restart the ramp plays from 0
 			expect(output.getValueAtTime(0.1)).to.be.closeTo(0.1, 0.01);

package/Tone/version.ts

@@ -1 +1 @@
-export const version: string = "15.5.53";
+export const version: string = "15.5.55";