tone 15.5.42 → 15.5.44

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/core/type/TransportTime.ts

@@ -1,5 +1,6 @@
 import { getContext } from "../Global.js";
 import { Seconds, Ticks } from "../type/Units.js";
+import { isDefined } from "../util/TypeCheck.js";
 import { TimeClass } from "./Time.js";
 import { TimeBaseUnit, TimeExpression, TimeValue } from "./TimeBase.js";
 
@@ -22,6 +23,21 @@ export class TransportTimeClass<
 		return this.context.transport.seconds as Type;
 	}
 
+	/**
+	 * Return the time in ticks.
+	 */
+	toTicks(): Ticks {
+		if (isDefined(this._val)) {
+			return super.toTicks();
+		}
+		// read the transport's actual current tick instead of re-deriving it
+		// from elapsed seconds at the current bpm, which ignores tempo changes.
+		// round up to the next tick since the current one may already be
+		// in the middle of being processed by the clock.
+		const transport = this.context.transport;
+		return Math.ceil(transport.getTicksAtTime(transport.now()));
+	}
+
 	protected _getExpressions(): TimeExpression<Type> {
 		const expressions = super._getExpressions();
 		// Override the quantize ("@") handler so that it returns Transport time

package/Tone/event/Part.test.ts

@@ -928,5 +928,59 @@ describe("Part", () => {
 			}).to.throw(Error);
 			part.dispose();
 		});
+
+		it("`toTicks()` with no argument matches the transport's actual current tick after a bpm change (#693)", async () => {
+			let actualTicks = 0;
+			let noArgTicks = 0;
+			await Offline(({ transport }) => {
+				transport.bpm.value = 120;
+				transport.start(0);
+				return atTime(0.5, () => {
+					transport.bpm.value = 40;
+					actualTicks = transport.getTicksAtTime(transport.now());
+					noArgTicks = transport.toTicks();
+				});
+			}, 0.6);
+			expect(noArgTicks).to.be.closeTo(actualTicks, 1);
+		});
+
+		it("does not delay a part's note when it is (re)started with no time arg while the transport is running", async () => {
+			let callTime: number | undefined;
+			await Offline(({ transport }) => {
+				const part = new Part(
+					(time) => {
+						callTime = time;
+					},
+					[0]
+				);
+				transport.bpm.value = 120;
+				transport.start(0);
+				return atTime(0.5, () => {
+					part.start();
+				});
+			}, 1);
+			expect(callTime).to.be.closeTo(0.5, 0.02);
+		});
+
+		it("does not leave an orphaned repeat after stopping a phase-shifted note before its first occurrence", async () => {
+			// a note's own repeat is phase-shifted from the part's start tick;
+			// stopping before a phase-shifted note's first occurrence used to miss
+			// that boundary, leaving an orphaned repeat that could later collide
+			// with a subsequent restart (#864)
+			const calls: number[] = [];
+			await Offline(({ transport }) => {
+				const part = new Part((time) => calls.push(time), [0, 0.5]);
+				part.loop = true;
+				part.loopEnd = 1;
+				transport.bpm.value = 120;
+				transport.start(0);
+				part.start(0);
+				// stop before the note at 0.5s into the loop ever gets to fire
+				part.stop(0.1);
+				// restart partway through the next cycle
+				part.start(200 / 384);
+			}, 2);
+			expect(calls.length).to.equal(4);
+		});
 	});
 });

package/Tone/event/ToneEvent.test.ts

@@ -1,7 +1,7 @@
 import { expect } from "chai";
 
 import { BasicTests } from "../../test/helper/Basic.js";
-import { Offline, whenBetween } from "../../test/helper/Offline.js";
+import { atTime, Offline, whenBetween } from "../../test/helper/Offline.js";
 import { Time } from "../core/type/Time.js";
 import { noOp } from "../core/util/Interface.js";
 import { ToneEvent } from "./ToneEvent.js";
@@ -362,6 +362,30 @@ describe("ToneEvent", () => {
 			}, 2);
 		});
 
+		it("keeps a still-playing segment running until its own scheduled stop, even when a later restart is already queued (#864)", async () => {
+			const callTimes: number[] = [];
+			await Offline(({ transport }) => {
+				const note = new ToneEvent({
+					loop: true,
+					loopEnd: 0.1,
+					callback(time): void {
+						callTimes.push(time);
+					},
+				});
+				note.start(0);
+				transport.start(0);
+				return atTime(0.3, () => {
+					// queue a stop/restart ahead of the still-playing segment
+					note.stop(transport.seconds + 0.5);
+					note.start(transport.seconds + 0.8);
+				});
+			}, 1.5);
+			// the live segment should keep firing up to its own stop (~0.8),
+			// not be cut short by the later start() call scheduled at the same time
+			const notesBetween = callTimes.filter((t) => t > 0.35 && t < 0.75);
+			expect(notesBetween.length).to.be.greaterThan(2);
+		});
+
 		it("loops the correct amount of times when the event is started in the transport's past", async () => {
 			let callCount = 0;
 			await Offline(({ transport }) => {

package/Tone/event/ToneEvent.ts

@@ -16,6 +16,7 @@ import {
 } from "../core/type/Units.js";
 import { defaultArg, optionsFromArguments } from "../core/util/Defaults.js";
 import { noOp } from "../core/util/Interface.js";
+import { clamp } from "../core/util/Math.js";
 import {
 	BasicPlaybackState,
 	StateTimeline,
@@ -185,11 +186,15 @@ export class ToneEvent<ValueType = any> extends ToneWithContext<
 					if (isNumber(this._loop)) {
 						duration = this._loop * this._getLoopDuration();
 					}
-					const nextEvent = this._state.getAfter(startTick);
+					// look up the next boundary in the same (unshifted) frame as
+					// event.time; startOffset can push startTick past it entirely,
+					// in which case this segment shouldn't schedule anything
+					const nextEvent = this._state.getAfter(event.time);
 					if (nextEvent !== null) {
-						duration = Math.min(
-							duration,
-							nextEvent.time - startTick
+						duration = clamp(
+							nextEvent.time - startTick,
+							0,
+							duration
 						);
 					}
 					if (duration !== Infinity) {

package/Tone/version.ts

@@ -1 +1 @@
-export const version: string = "15.5.42";
+export const version: string = "15.5.44";