tone 14.8.36 → 14.8.39

package/Tone/event/Pattern.ts

@@ -27,12 +27,17 @@ export class Pattern<ValueType> extends Loop<PatternOptions<ValueType>> {
 	/**
 	 * The pattern generator function
 	 */
-	private _pattern: Iterator<ValueType>;
+	private _pattern: Iterator<number>;
+
+	/**
+	 * The current index
+	 */
+	 private _index?: number;
 
 	/**
 	 * The current value
 	 */
-	private _value?: ValueType;
+	 private _value?: ValueType;
 
 	/**
 	 * Hold the pattern type
@@ -67,7 +72,7 @@ export class Pattern<ValueType> extends Loop<PatternOptions<ValueType>> {
 
 		this.callback = options.callback;
 		this._values = options.values;
-		this._pattern = PatternGenerator(options.values, options.pattern);
+		this._pattern = PatternGenerator(options.values.length, options.pattern);
 		this._type = options.pattern;
 	}
 
@@ -83,8 +88,9 @@ export class Pattern<ValueType> extends Loop<PatternOptions<ValueType>> {
 	 * Internal function called when the notes should be called
 	 */
 	protected _tick(time: Seconds): void {
-		const value = this._pattern.next() as IteratorResult<ValueType>;
-		this._value = value.value;
+		const index = this._pattern.next() as IteratorResult<ValueType>;
+		this._index = index.value;
+		this._value = this._values[index.value];
 		this.callback(time, this._value);
 	}
 
@@ -107,6 +113,13 @@ export class Pattern<ValueType> extends Loop<PatternOptions<ValueType>> {
 		return this._value;
 	}
 
+	/**
+	 * The current index of the pattern.
+	 */
+	 get index(): number | undefined {
+		return this._index;
+	}
+
 	/**
 	 * The pattern type. See Tone.CtrlPattern for the full list of patterns.
 	 */
@@ -115,7 +128,7 @@ export class Pattern<ValueType> extends Loop<PatternOptions<ValueType>> {
 	}
 	set pattern(pattern) {
 		this._type = pattern;
-		this._pattern = PatternGenerator(this._values, this._type);
+		this._pattern = PatternGenerator(this._values.length, this._type);
 	}
 }
 

package/Tone/event/PatternGenerator.test.ts

@@ -13,22 +13,14 @@ describe("PatternGenerator", () => {
 
 	context("API", () => {
 
-		it("can be constructed with an array and type", () => {
-			const pattern = PatternGenerator([0, 1, 2, 3], "down");
+		it("can be constructed with an number and type", () => {
+			const pattern = PatternGenerator(4, "down");
 			expect(getArrayValues(pattern, 10)).to.deep.equal([3, 2, 1, 0, 3, 2, 1, 0, 3, 2]);
 		});
 
-		it("can be resized smaller when the index is after the previous length", () => {
-			const values = [0, 1, 2, 3, 4];
-			const pattern = PatternGenerator(values);
-			expect(pattern.next().value).to.equal(0);
-			values.shift();
-			expect(pattern.next().value).to.equal(2);
-		});
-
-		it("throws an error with an empty array", () => {
+		it("throws an error with a number less than 1", () => {
 			expect(() => {
-				const pattern = PatternGenerator([]);
+				const pattern = PatternGenerator(0);
 				pattern.next();
 			}).to.throw(Error);
 		});
@@ -37,54 +29,54 @@ describe("PatternGenerator", () => {
 	context("Patterns", () => {
 
 		it("does the up pattern", () => {
-			const pattern = PatternGenerator([0, 1, 2, 3], "up");
+			const pattern = PatternGenerator(4, "up");
 			expect(getArrayValues(pattern, 6)).to.deep.equal([0, 1, 2, 3, 0, 1]);
 		});
 
 		it("does the down pattern", () => {
-			const pattern = PatternGenerator([0, 1, 2, 3], "down");
+			const pattern = PatternGenerator(4, "down");
 			expect(getArrayValues(pattern, 6)).to.deep.equal([3, 2, 1, 0, 3, 2]);
 		});
 
 		it("does the upDown pattern", () => {
-			const pattern = PatternGenerator([0, 1, 2, 3], "upDown");
+			const pattern = PatternGenerator(4, "upDown");
 			expect(getArrayValues(pattern, 10)).to.deep.equal([0, 1, 2, 3, 2, 1, 0, 1, 2, 3]);
 		});
 
 		it("does the downUp pattern", () => {
-			const pattern = PatternGenerator([0, 1, 2, 3], "downUp");
+			const pattern = PatternGenerator(4, "downUp");
 			expect(getArrayValues(pattern, 10)).to.deep.equal([3, 2, 1, 0, 1, 2, 3, 2, 1, 0]);
 		});
 
 		it("does the alternateUp pattern", () => {
-			const pattern = PatternGenerator([0, 1, 2, 3, 4], "alternateUp");
+			const pattern = PatternGenerator(5, "alternateUp");
 			expect(getArrayValues(pattern, 10)).to.deep.equal([0, 2, 1, 3, 2, 4, 3, 0, 2, 1]);
 		});
 
 		it("does the alternateDown pattern", () => {
-			const pattern = PatternGenerator([0, 1, 2, 3, 4], "alternateDown");
+			const pattern = PatternGenerator(5, "alternateDown");
 			expect(getArrayValues(pattern, 10)).to.deep.equal([4, 2, 3, 1, 2, 0, 1, 4, 2, 3]);
 		});
 
 		it("outputs random elements from the values", () => {
-			const values = [0, 1, 2, 3, 4];
-			const pattern = PatternGenerator(values, "random");
+			const numValues = 5;
+			const pattern = PatternGenerator(numValues, "random");
 			for (let i = 0; i < 10; i++) {
-				expect(values.indexOf(pattern.next().value)).to.not.equal(-1);
+				expect(pattern.next().value).to.be.at.least(0).and.at.most(numValues - 1);
 			}
 		});
 
 		it("does randomOnce pattern", () => {
-			const pattern = PatternGenerator([4, 5, 6, 7, 8], "randomOnce");
-			expect(getArrayValues(pattern, 10).sort()).to.deep.equal([4, 4, 5, 5, 6, 6, 7, 7, 8, 8]);
+			const pattern = PatternGenerator(5, "randomOnce");
+			expect(getArrayValues(pattern, 10).sort()).to.deep.equal([0, 0, 1, 1, 2, 2, 3, 3, 4, 4]);
 		});
                 
 		it("randomly walks up or down 1 step without repeating", () => {
 			const values = [0, 1, 2, 3, 4];
-			const pattern = PatternGenerator(values, "randomWalk");
-			let currentIndex = values.indexOf(pattern.next().value);
+			const pattern = PatternGenerator(5, "randomWalk");
+			let currentIndex = pattern.next().value;
 			for (let i = 0; i < 10; i++) {
-				const nextIndex = values.indexOf(pattern.next().value);
+				const nextIndex = pattern.next().value;
 				expect(currentIndex).to.not.equal(nextIndex);
 				// change always equals 1
 				expect(Math.abs(currentIndex - nextIndex)).to.equal(1);

package/Tone/event/PatternGenerator.ts

@@ -9,11 +9,11 @@ export type PatternName = "up" | "down" | "upDown" | "downUp" | "alternateUp" |
 /**
  * Start at the first value and go up to the last
  */
-function* upPatternGen<T>(values: T[]): IterableIterator<T> {
+function* upPatternGen<T>(numValues: number): IterableIterator<number> {
 	let index = 0;
-	while (index < values.length) {
-		index = clampToArraySize(index, values);
-		yield values[index];
+	while (index < numValues) {
+		index = clamp(index, 0, numValues - 1);
+		yield index;
 		index++;
 	}
 }
@@ -21,11 +21,11 @@ function* upPatternGen<T>(values: T[]): IterableIterator<T> {
 /**
  * Start at the last value and go down to 0
  */
-function* downPatternGen<T>(values: T[]): IterableIterator<T> {
-	let index = values.length - 1;
+function* downPatternGen<T>(numValues: number): IterableIterator<number> {
+	let index = numValues - 1;
 	while (index >= 0) {
-		index = clampToArraySize(index, values);
-		yield values[index];
+		index = clamp(index, 0, numValues - 1);
+		yield index;
 		index--;
 	}
 }
@@ -33,30 +33,23 @@ function* downPatternGen<T>(values: T[]): IterableIterator<T> {
 /**
  * Infinitely yield the generator
  */
-function* infiniteGen<T>(values: T[], gen: typeof upPatternGen): IterableIterator<T> {
+function* infiniteGen<T>(numValues: number, gen: typeof upPatternGen): IterableIterator<number> {
 	while (true) {
-		yield* gen(values);
+		yield* gen(numValues);
 	}
 }
 
-/**
- * Make sure that the index is in the given range
- */
-function clampToArraySize(index: number, values: any[]): number {
-	return clamp(index, 0, values.length - 1);
-}
-
 /**
  * Alternate between two generators
  */
-function* alternatingGenerator<T>(values: T[], directionUp: boolean): IterableIterator<T> {
-	let index = directionUp ? 0 : values.length - 1;
+function* alternatingGenerator<T>(numValues: number, directionUp: boolean): IterableIterator<number> {
+	let index = directionUp ? 0 : numValues - 1;
 	while (true) {
-		index = clampToArraySize(index, values);
-		yield values[index];
+		index = clamp(index, 0, numValues - 1);
+		yield index;
 		if (directionUp) {
 			index++;
-			if (index >= values.length - 1) {
+			if (index >= numValues - 1) {
 				directionUp = false;
 			}
 		} else {
@@ -71,12 +64,12 @@ function* alternatingGenerator<T>(values: T[], directionUp: boolean): IterableIt
 /**
  * Starting from the bottom move up 2, down 1
  */
-function* jumpUp<T>(values: T[]): IterableIterator<T> {
+function* jumpUp<T>(numValues: number): IterableIterator<number> {
 	let index = 0;
 	let stepIndex = 0;
-	while (index < values.length) {
-		index = clampToArraySize(index, values);
-		yield values[index];
+	while (index < numValues) {
+		index = clamp(index, 0, numValues - 1);
+		yield index;
 		stepIndex++;
 		index += (stepIndex % 2 ? 2 : -1);
 	}
@@ -85,12 +78,12 @@ function* jumpUp<T>(values: T[]): IterableIterator<T> {
 /**
  * Starting from the top move down 2, up 1
  */
-function* jumpDown<T>(values: T[]): IterableIterator<T> {
-	let index = values.length - 1;
+function* jumpDown<T>(numValues: number): IterableIterator<number> {
+	let index = numValues - 1;
 	let stepIndex = 0;
 	while (index >= 0) {
-		index = clampToArraySize(index, values);
-		yield values[index];
+		index = clamp(index, 0, numValues - 1);
+		yield index;
 		stepIndex++;
 		index += (stepIndex % 2 ? -2 : 1);
 	}
@@ -99,78 +92,78 @@ function* jumpDown<T>(values: T[]): IterableIterator<T> {
 /**
  * Choose a random index each time
  */
-function* randomGen<T>(values: T[]): IterableIterator<T> {
+function* randomGen<T>(numValues: number): IterableIterator<number> {
 	while (true) {
-		const randomIndex = Math.floor(Math.random() * values.length);
-		yield values[randomIndex];
+		const randomIndex = Math.floor(Math.random() * numValues);
+		yield randomIndex;
 	}
 }
 
 /**
  * Randomly go through all of the values once before choosing a new random order
  */
-function* randomOnce<T>(values: T[]): IterableIterator<T> {
+function* randomOnce<T>(numValues: number): IterableIterator<number> {
 	// create an array of indices
 	const copy: number[] = [];
-	for (let i = 0; i < values.length; i++) {
+	for (let i = 0; i < numValues; i++) {
 		copy.push(i);
 	}
 	while (copy.length > 0) {
 		// random choose an index, and then remove it so it's not chosen again
 		const randVal = copy.splice(Math.floor(copy.length * Math.random()), 1);
-		const index = clampToArraySize(randVal[0], values);
-		yield values[index];
+		const index = clamp(randVal[0], 0, numValues - 1);
+		yield index;
 	}
 }
 
 /**
- * Randomly choose to walk up or down 1 index in the values array
+ * Randomly choose to walk up or down 1 index
  */
-function* randomWalk<T>(values: T[]): IterableIterator<T> {
-	// randomly choose a starting index in the values array
-	let index = Math.floor(Math.random() * values.length);
+function* randomWalk<T>(numValues: number): IterableIterator<number> {
+	// randomly choose a starting index
+	let index = Math.floor(Math.random() * numValues);
 	while (true) {
 		if (index === 0) {
-			index++; // at bottom of array, so force upward step
-		} else if (index === values.length - 1) {
-			index--; // at top of array, so force downward step
+			index++; // at bottom, so force upward step
+		} else if (index === numValues - 1) {
+			index--; // at top, so force downward step
 		} else if (Math.random() < 0.5) { // else choose random downward or upward step
 			index--;
 		} else {
 			index++;
 		}
-		yield values[index];
+		yield index;
 	}
 }
 
 /**
- * PatternGenerator returns a generator which will iterate over the given array
- * of values and yield the items according to the passed in pattern
- * @param values An array of values to iterate over
+ * PatternGenerator returns a generator which will yield numbers between 0 and numValues
+ * according to the passed in pattern that can be used as indexes into an array of size numValues.
+ * @param numValues The size of the array to emit indexes for
  * @param pattern The name of the pattern use when iterating over
  * @param index Where to start in the offset of the values array
  */
-export function* PatternGenerator<T>(values: T[], pattern: PatternName = "up", index = 0): Iterator<T> {
+export function* PatternGenerator(numValues: number, pattern: PatternName = "up", index = 0): Iterator<number> {
 	// safeguards
-	assert(values.length > 0, "The array must have more than one value in it");
+	assert(numValues >= 1, "The number of values must be at least one");
 	switch (pattern) {
 		case "up" :
-			yield* infiniteGen(values, upPatternGen);
+			yield* infiniteGen(numValues, upPatternGen);
 		case "down" :
-			yield* infiniteGen(values, downPatternGen);
+			yield* infiniteGen(numValues, downPatternGen);
 		case "upDown" :
-			yield* alternatingGenerator(values, true);
+			yield* alternatingGenerator(numValues, true);
 		case "downUp" :
-			yield* alternatingGenerator(values, false);
+			yield* alternatingGenerator(numValues, false);
 		case "alternateUp":
-			yield* infiniteGen(values, jumpUp);
+			yield* infiniteGen(numValues, jumpUp);
 		case "alternateDown":
-			yield* infiniteGen(values, jumpDown);
+			yield* infiniteGen(numValues, jumpDown);
 		case "random":
-			yield* randomGen(values);
+			yield* randomGen(numValues);
 		case "randomOnce":
-			yield* infiniteGen(values, randomOnce);
+			yield* infiniteGen(numValues, randomOnce);
 		case "randomWalk":
-			yield* randomWalk(values);
+			yield* randomWalk(numValues);
 	}
 }

package/Tone/event/Sequence.ts

@@ -20,7 +20,7 @@ interface SequenceOptions<T> extends Omit<ToneEventOptions<T>, "value"> {
  * in an array of events which will be spaced at the
  * given subdivision. Sub-arrays will subdivide that beat
  * by the number of items are in the array.
- * Sequence notation inspiration from [Tidal](http://yaxu.org/tidal/)
+ * Sequence notation inspiration from [Tidal Cycles](http://tidalcycles.org/)
  * @example
  * const synth = new Tone.Synth().toDestination();
  * const seq = new Tone.Sequence((time, note) => {

package/Tone/instrument/MetalSynth.ts

@@ -1,9 +1,22 @@
 import { Envelope, EnvelopeOptions } from "../component/envelope/Envelope";
 import { Filter } from "../component/filter/Filter";
 import { Gain } from "../core/context/Gain";
-import { ToneAudioNode, ToneAudioNodeOptions } from "../core/context/ToneAudioNode";
-import { Frequency, NormalRange, Positive, Seconds, Time } from "../core/type/Units";
-import { deepMerge, omitFromObject, optionsFromArguments } from "../core/util/Defaults";
+import {
+	ToneAudioNode,
+	ToneAudioNodeOptions,
+} from "../core/context/ToneAudioNode";
+import {
+	Frequency,
+	NormalRange,
+	Positive,
+	Seconds,
+	Time,
+} from "../core/type/Units";
+import {
+	deepMerge,
+	omitFromObject,
+	optionsFromArguments,
+} from "../core/util/Defaults";
 import { noOp, RecursivePartial } from "../core/util/Interface";
 import { Multiply } from "../signal/Multiply";
 import { Scale } from "../signal/Scale";
@@ -23,17 +36,15 @@ export interface MetalSynthOptions extends MonophonicOptions {
  * Inharmonic ratio of frequencies based on the Roland TR-808
  * Taken from https://ccrma.stanford.edu/papers/tr-808-cymbal-physically-informed-circuit-bendable-digital-model
  */
-const inharmRatios: number[] = [1.0, 1.483, 1.932, 2.546, 2.630, 3.897];
+const inharmRatios: number[] = [1.0, 1.483, 1.932, 2.546, 2.63, 3.897];
 
 /**
  * A highly inharmonic and spectrally complex source with a highpass filter
  * and amplitude envelope which is good for making metallophone sounds.
  * Based on CymbalSynth by [@polyrhythmatic](https://github.com/polyrhythmatic).
- * Inspiration from [Sound on Sound](https://shorturl.at/rSZ12).
  * @category Instrument
  */
 export class MetalSynth extends Monophonic<MetalSynthOptions> {
-
 	readonly name: string = "MetalSynth";
 
 	/**
@@ -84,10 +95,13 @@ export class MetalSynth extends Monophonic<MetalSynthOptions> {
 	 */
 	readonly envelope: Envelope;
 
-	constructor(options?: RecursivePartial<MetalSynthOptions>)
+	constructor(options?: RecursivePartial<MetalSynthOptions>);
 	constructor() {
 		super(optionsFromArguments(MetalSynth.getDefaults(), arguments));
-		const options = optionsFromArguments(MetalSynth.getDefaults(), arguments);
+		const options = optionsFromArguments(
+			MetalSynth.getDefaults(),
+			arguments
+		);
 
 		this.detune = new Signal({
 			context: this.context,
@@ -158,12 +172,15 @@ export class MetalSynth extends Monophonic<MetalSynthOptions> {
 	static getDefaults(): MetalSynthOptions {
 		return deepMerge(Monophonic.getDefaults(), {
 			envelope: Object.assign(
-				omitFromObject(Envelope.getDefaults(), Object.keys(ToneAudioNode.getDefaults())),
+				omitFromObject(
+					Envelope.getDefaults(),
+					Object.keys(ToneAudioNode.getDefaults())
+				),
 				{
 					attack: 0.001,
 					decay: 1.4,
 					release: 0.2,
-				},
+				}
 			),
 			harmonicity: 5.1,
 			modulationIndex: 32,
@@ -177,24 +194,33 @@ export class MetalSynth extends Monophonic<MetalSynthOptions> {
 	 * @param time When the attack should be triggered.
 	 * @param velocity The velocity that the envelope should be triggered at.
 	 */
-	protected _triggerEnvelopeAttack(time: Seconds, velocity: NormalRange = 1): this {
+	protected _triggerEnvelopeAttack(
+		time: Seconds,
+		velocity: NormalRange = 1
+	): this {
 		this.envelope.triggerAttack(time, velocity);
-		this._oscillators.forEach(osc => osc.start(time));
+		this._oscillators.forEach((osc) => osc.start(time));
 		if (this.envelope.sustain === 0) {
-			this._oscillators.forEach(osc => {
-				osc.stop(time + this.toSeconds(this.envelope.attack) + this.toSeconds(this.envelope.decay));
+			this._oscillators.forEach((osc) => {
+				osc.stop(
+					time +
+						this.toSeconds(this.envelope.attack) +
+						this.toSeconds(this.envelope.decay)
+				);
 			});
 		}
 		return this;
 	}
-	
+
 	/**
 	 * Trigger the release of the envelope.
 	 * @param time When the release should be triggered.
 	 */
 	protected _triggerEnvelopeRelease(time: Seconds): this {
 		this.envelope.triggerRelease(time);
-		this._oscillators.forEach(osc => osc.stop(time + this.toSeconds(this.envelope.release)));
+		this._oscillators.forEach((osc) =>
+			osc.stop(time + this.toSeconds(this.envelope.release))
+		);
 		return this;
 	}
 
@@ -213,7 +239,7 @@ export class MetalSynth extends Monophonic<MetalSynthOptions> {
 		return this._oscillators[0].modulationIndex.value;
 	}
 	set modulationIndex(val) {
-		this._oscillators.forEach(osc => (osc.modulationIndex.value = val));
+		this._oscillators.forEach((osc) => (osc.modulationIndex.value = val));
 	}
 
 	/**
@@ -226,7 +252,7 @@ export class MetalSynth extends Monophonic<MetalSynthOptions> {
 		return this._oscillators[0].harmonicity.value;
 	}
 	set harmonicity(val) {
-		this._oscillators.forEach(osc => (osc.harmonicity.value = val));
+		this._oscillators.forEach((osc) => (osc.harmonicity.value = val));
 	}
 
 	/**
@@ -254,13 +280,14 @@ export class MetalSynth extends Monophonic<MetalSynthOptions> {
 	}
 	set octaves(val) {
 		this._octaves = val;
-		this._filterFreqScaler.max = this._filterFreqScaler.min * Math.pow(2, val);
+		this._filterFreqScaler.max =
+			this._filterFreqScaler.min * Math.pow(2, val);
 	}
 
 	dispose(): this {
 		super.dispose();
-		this._oscillators.forEach(osc => osc.dispose());
-		this._freqMultipliers.forEach(freqMult => freqMult.dispose());
+		this._oscillators.forEach((osc) => osc.dispose());
+		this._freqMultipliers.forEach((freqMult) => freqMult.dispose());
 		this.frequency.dispose();
 		this.detune.dispose();
 		this._filterFreqScaler.dispose();

package/Tone/signal/ToneConstantSource.test.ts

@@ -152,7 +152,7 @@ describe("ToneConstantSource", () => {
 				expect(source.getStateAtTime(0)).to.equal("stopped");
 				expect(source.getStateAtTime(currentTime)).to.equal("started");
 				setTimeout(() => {
-					currentTime = source.context.currentTime;
+					currentTime = source.now();
 					source.stop(0);
 					expect(source.getStateAtTime(currentTime + 0.01)).to.equal("stopped");
 					source.dispose();

package/Tone/source/OneShotSource.ts

@@ -168,7 +168,7 @@ export abstract class OneShotSource<
 
 		// schedule the stop callback
 		this._stopTime = this.toSeconds(time) + fadeOutTime;
-		this._stopTime = Math.max(this._stopTime, this.context.currentTime);
+		this._stopTime = Math.max(this._stopTime, this.now());
 		if (fadeOutTime > 0) {
 			// start the fade out curve at the given time
 			if (this._curve === "linear") {

package/Tone/source/buffer/Player.test.ts

@@ -696,5 +696,30 @@ describe("Player", () => {
 				expect(buff.getRmsAtTime(duration + 0.1)).to.be.closeTo(0, 0.1);
 			});
 		});
+
+		it("stops only last activeSource when restarting at intervals < latencyHint", (done) => {
+			const originalLookAhead = getContext().lookAhead;
+			getContext().lookAhead = .3;
+			const player = new Player({
+				onload(): void {
+					player.start(undefined, undefined, 1);
+					setTimeout(() => player.restart(undefined, undefined, 1), 50);
+					setTimeout(() => player.restart(undefined, undefined, 1), 100);
+					setTimeout(() => player.restart(undefined, undefined, 1), 150);
+					setTimeout(() => {
+						player.restart(undefined, undefined, 1);
+						const checkStopTimes = new Set();
+						player["_activeSources"].forEach(source => {
+							checkStopTimes.add(source["_stopTime"]);
+						});
+						getContext().lookAhead = originalLookAhead;
+						// ensure each source has a different stopTime
+						expect(checkStopTimes.size).to.equal(player["_activeSources"].size);
+						done();
+					}, 250);
+				},
+				url: "./audio/sine.wav",
+			});
+		});
 	});
 });

package/Tone/source/buffer/Player.ts

@@ -284,7 +284,7 @@ export class Player extends Source<PlayerOptions> {
 	}
 
 	protected _restart(time?: Seconds, offset?: Time, duration?: Time): void {
-		this._stop(time);
+		[...this._activeSources].pop()?.stop(time); // explicitly stop only the most recently created source, to avoid edge case when > 1 source exists and _stop() erroneously sets all stop times past original end offset
 		this._start(time, offset, duration);
 	}
 

package/Tone/source/oscillator/ToneOscillatorNode.test.ts

@@ -191,7 +191,7 @@ describe("ToneOscillatorNode", () => {
 				expect(osc.getStateAtTime(0)).to.equal("stopped");
 				expect(osc.getStateAtTime(currentTime)).to.equal("started");
 				setTimeout(() => {
-					currentTime = osc.context.currentTime;
+					currentTime = osc.now();
 					osc.stop(0);
 					expect(osc.getStateAtTime(currentTime + 0.01)).to.equal("stopped");
 					osc.dispose();

package/Tone/version.ts

@@ -1 +1 @@
-export const version: string = "14.8.36";
+export const version: string = "14.8.39";