tone 15.5.49 → 15.5.51

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

@@ -616,6 +616,50 @@ describe("TickSource", () => {
 			}
 			source.dispose();
 		});
+
+		it("does not skip the boundary tick when started between ticks (#1500)", () => {
+			const block = 128 / 48000;
+			const source = new TickSource(384);
+			const start = 2 * block + 0.12;
+			source.start(start);
+			const fired: number[] = [];
+			const boundary = (2 + 70) * block + 0.1;
+			source.forEachTickBetween(start, boundary, (_, tick) =>
+				fired.push(tick)
+			);
+			source.forEachTickBetween(boundary, boundary + 0.05, (_, tick) =>
+				fired.push(tick)
+			);
+			expect(fired).to.include(
+				64,
+				"tick 64 at the window boundary was skipped"
+			);
+			source.dispose();
+		});
+
+		it("does not fire a tick twice when started more than half a tick past an integer tick (#1500)", () => {
+			const source = new TickSource(2);
+			const start = 0.35;
+			source.start(start);
+			const tickCount = new Map<number, number>();
+			const record = (_: number, tick: number) => {
+				tickCount.set(tick, (tickCount.get(tick) ?? 0) + 1);
+			};
+			const eps = 1e-10;
+			let windowStart = start;
+			for (let n = 1; n <= 8; n++) {
+				const windowEnd = start + n * 0.5 + eps;
+				source.forEachTickBetween(windowStart, windowEnd, record);
+				windowStart = windowEnd;
+			}
+			for (const [tick, count] of tickCount) {
+				expect(count).to.equal(
+					1,
+					`tick ${tick} fired ${count} times instead of once`
+				);
+			}
+			source.dispose();
+		});
 	});
 
 	context("Seconds", () => {

package/Tone/core/clock/TickSource.ts

@@ -5,7 +5,6 @@ import {
 import { Seconds, Ticks, Time } from "../type/Units.js";
 import { optionsFromArguments } from "../util/Defaults.js";
 import { readOnly } from "../util/Interface.js";
-import { EQ } from "../util/Math.js";
 import {
 	PlaybackState,
 	StateTimeline,
@@ -413,43 +412,24 @@ export class TickSource<
 		let error: Error | null = null;
 
 		if (lastStateEvent?.state === "started") {
-			const maxStartTime = Math.max(lastStateEvent.time, startTime);
-			// Figure out how far past the last whole-tick boundary maxStartTime
-			// sits, so we can compute the time of the next tick at or after it.
-			const startTicks = this.frequency.getTicksAtTime(maxStartTime);
-			const ticksAtStart = this.frequency.getTicksAtTime(
-				lastStateEvent.time
+			const origin = this.frequency.getTicksAtTime(lastStateEvent.time);
+			const endTicks = this.frequency.getTicksAtTime(endTime) - origin;
+			const tick = Math.ceil(
+				this.frequency.getTicksAtTime(
+					Math.max(lastStateEvent.time, startTime)
+				) - origin
 			);
-			const diff = startTicks - ticksAtStart;
-			const offset = Math.ceil(diff) - diff;
-			// Guard against floating-point issues: when startTicks is just barely
-			// above an integer tick boundary (offset ≈ 1), snap back to that integer
-			const firstTick = EQ(offset, 1)
-				? Math.floor(startTicks)
-				: startTicks + offset;
-			let nextTickTime = this.frequency.getTimeOfTick(firstTick);
-			// Advance past any ticks that land before the start of this window
-			// to avoid any tick that was already processed.
-			if (nextTickTime < maxStartTime) {
-				nextTickTime += this.frequency.getDurationOfTicks(
-					1,
-					nextTickTime
-				);
-			}
-			while (nextTickTime < endTime) {
+			for (let t = tick; t < endTicks; t++) {
+				const time = this.frequency.getTimeOfTick(origin + t);
 				try {
-					callback(
-						nextTickTime,
-						Math.round(this.getTicksAtTime(nextTickTime))
-					);
+					callback(time, Math.round(this.getTicksAtTime(time)));
 				} catch (e) {
 					error = e as Error;
 					break;
 				}
-				nextTickTime += this.frequency.getDurationOfTicks(
-					1,
-					nextTickTime
-				);
+				if (this.disposed) {
+					break;
+				}
 			}
 		}
 

package/Tone/version.ts

@@ -1 +1 @@
-export const version: string = "15.5.49";
+export const version: string = "15.5.51";