tone 14.8.29 → 14.8.33

package/Tone/component/dynamics/Limiter.ts

@@ -7,7 +7,7 @@ import { readOnly } from "../../core/util/Interface";
 
 export interface LimiterOptions extends ToneAudioNodeOptions {
 	threshold: Decibels;
-};
+}
 
 /**
  * Limiter will limit the loudness of an incoming signal.

package/Tone/component/envelope/Envelope.ts

@@ -605,8 +605,8 @@ const EnvelopeCurves: EnvelopeCurveMap = (() => {
 			In: cosineCurve,
 			Out: reverseCurve(cosineCurve),
 		},
-		exponential: "exponential" as "exponential",
-		linear: "linear" as "linear",
+		exponential: "exponential" as const,
+		linear: "linear" as const,
 		ripple: {
 			In: rippleCurve,
 			Out: invertCurve(rippleCurve),

package/Tone/component/filter/FeedbackCombFilter.ts

@@ -88,9 +88,9 @@ export class FeedbackCombFilter extends ToneAudioWorklet<FeedbackCombFilterOptio
 
 	onReady(node: AudioWorkletNode) {
 		connectSeries(this.input, node, this.output);
-		const delayTime = node.parameters.get("delayTime") as AudioParam;;
+		const delayTime = node.parameters.get("delayTime") as AudioParam;
 		this.delayTime.setParam(delayTime);
-		const feedback = node.parameters.get("feedback") as AudioParam;;
+		const feedback = node.parameters.get("feedback") as AudioParam;
 		this.resonance.setParam(feedback);
 	}
 

package/Tone/core/clock/TickSource.ts

@@ -66,7 +66,7 @@ export class TickSource<TypeName extends "bpm" | "hertz"> extends ToneWithContex
 	static getDefaults(): TickSourceOptions {
 		return Object.assign({
 			frequency: 1,
-			units: "hertz" as "hertz",
+			units: "hertz" as const,
 		}, ToneWithContext.getDefaults());
 	}
 

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

@@ -7,6 +7,8 @@ import { TransportTime } from "../type/TransportTime";
 import { Transport } from "./Transport";
 // importing for side affects
 import "../context/Destination";
+import { warns } from "test/helper/Basic";
+import { Synth } from "Tone/instrument/Synth";
 
 describe("Transport", () => {
 
@@ -546,6 +548,19 @@ describe("Transport", () => {
 			});
 		});
 
+		it("warns if the scheduled time was not used in the callback", async () => {
+			return Offline(({ transport }) => {
+				const synth = new Synth();
+				transport.schedule(() => {
+					warns(() => {
+						synth.triggerAttackRelease("C2", 0.1);
+					});
+				}, 0);
+				transport.start(0);
+			}, 0.3).then(() => {
+			});
+		});
+
 	});
 
 	context("scheduleRepeat", () => {

package/Tone/core/clock/Transport.ts

@@ -2,15 +2,29 @@ import { TimeClass } from "../../core/type/Time";
 import { PlaybackState } from "../../core/util/StateTimeline";
 import { TimelineValue } from "../../core/util/TimelineValue";
 import { Signal } from "../../signal/Signal";
-import { onContextClose, onContextInit } from "../context/ContextInitialization";
+import {
+	onContextClose,
+	onContextInit,
+} from "../context/ContextInitialization";
 import { Gain } from "../context/Gain";
-import { ToneWithContext, ToneWithContextOptions } from "../context/ToneWithContext";
+import {
+	ToneWithContext,
+	ToneWithContextOptions,
+} from "../context/ToneWithContext";
 import { TicksClass } from "../type/Ticks";
 import { TransportTimeClass } from "../type/TransportTime";
 import {
-	BarsBeatsSixteenths, BPM, NormalRange, Seconds,
-	Subdivision, Ticks, Time, TimeSignature, TransportTime
+	BarsBeatsSixteenths,
+	BPM,
+	NormalRange,
+	Seconds,
+	Subdivision,
+	Ticks,
+	Time,
+	TimeSignature,
+	TransportTime,
 } from "../type/Units";
+import { enterScheduledCallback } from "../util/Debug";
 import { optionsFromArguments } from "../util/Defaults";
 import { Emitter } from "../util/Emitter";
 import { readOnly, writable } from "../util/Interface";
@@ -32,7 +46,14 @@ interface TransportOptions extends ToneWithContextOptions {
 	ppq: number;
 }
 
-type TransportEventNames = "start" | "stop" | "pause" | "loop" | "loopEnd" | "loopStart" | "ticks";
+type TransportEventNames =
+	| "start"
+	| "stop"
+	| "pause"
+	| "loop"
+	| "loopEnd"
+	| "loopStart"
+	| "ticks";
 
 interface SyncedSignalEvent {
 	signal: Signal;
@@ -64,8 +85,9 @@ type TransportCallback = (time: Seconds) => void;
  * Tone.Transport.start();
  * @category Core
  */
-export class Transport extends ToneWithContext<TransportOptions> implements Emitter<TransportEventNames> {
-
+export class Transport
+	extends ToneWithContext<TransportOptions>
+	implements Emitter<TransportEventNames> {
 	readonly name: string = "Transport";
 
 	//-------------------------------------
@@ -163,9 +185,11 @@ export class Transport extends ToneWithContext<TransportOptions> implements Emit
 
 	constructor(options?: Partial<TransportOptions>);
 	constructor() {
-
 		super(optionsFromArguments(Transport.getDefaults(), arguments));
-		const options = optionsFromArguments(Transport.getDefaults(), arguments);
+		const options = optionsFromArguments(
+			Transport.getDefaults(),
+			arguments
+		);
 
 		// CLOCK/TEMPO
 		this._ppq = options.ppq;
@@ -213,21 +237,34 @@ export class Transport extends ToneWithContext<TransportOptions> implements Emit
 				this.emit("loopEnd", tickTime);
 				this._clock.setTicksAtTime(this._loopStart, tickTime);
 				ticks = this._loopStart;
-				this.emit("loopStart", tickTime, this._clock.getSecondsAtTime(tickTime));
+				this.emit(
+					"loopStart",
+					tickTime,
+					this._clock.getSecondsAtTime(tickTime)
+				);
 				this.emit("loop", tickTime);
 			}
 		}
 		// handle swing
-		if (this._swingAmount > 0 &&
+		if (
+			this._swingAmount > 0 &&
 			ticks % this._ppq !== 0 && // not on a downbeat
-			ticks % (this._swingTicks * 2) !== 0) {
+			ticks % (this._swingTicks * 2) !== 0
+		) {
 			// add some swing
-			const progress = (ticks % (this._swingTicks * 2)) / (this._swingTicks * 2);
-			const amount = Math.sin((progress) * Math.PI) * this._swingAmount;
-			tickTime += new TicksClass(this.context, this._swingTicks * 2 / 3).toSeconds() * amount;
+			const progress =
+				(ticks % (this._swingTicks * 2)) / (this._swingTicks * 2);
+			const amount = Math.sin(progress * Math.PI) * this._swingAmount;
+			tickTime +=
+				new TicksClass(
+					this.context,
+					(this._swingTicks * 2) / 3
+				).toSeconds() * amount;
 		}
 		// invoke the timeline events scheduled on this tick
-		this._timeline.forEachAtTime(ticks, event => event.invoke(tickTime));
+		enterScheduledCallback(true);
+		this._timeline.forEachAtTime(ticks, (event) => event.invoke(tickTime));
+		enterScheduledCallback(false);
 	}
 
 	//-------------------------------------
@@ -246,7 +283,10 @@ export class Transport extends ToneWithContext<TransportOptions> implements Emit
 	 * 	console.log("measure 16!");
 	 * }, "16:0:0");
 	 */
-	schedule(callback: TransportCallback, time: TransportTime | TransportTimeClass): number {
+	schedule(
+		callback: TransportCallback,
+		time: TransportTime | TransportTimeClass
+	): number {
 		const event = new TransportEvent(this, {
 			callback,
 			time: new TransportTimeClass(this.context, time).toTicks(),
@@ -274,7 +314,7 @@ export class Transport extends ToneWithContext<TransportOptions> implements Emit
 		callback: TransportCallback,
 		interval: Time | TimeClass,
 		startTime?: TransportTime | TransportTimeClass,
-		duration: Time = Infinity,
+		duration: Time = Infinity
 	): number {
 		const event = new TransportRepeatEvent(this, {
 			callback,
@@ -293,7 +333,10 @@ export class Transport extends ToneWithContext<TransportOptions> implements Emit
 	 * @param time The time the callback should be invoked.
 	 * @returns The ID of the scheduled event.
 	 */
-	scheduleOnce(callback: TransportCallback, time: TransportTime | TransportTimeClass): number {
+	scheduleOnce(
+		callback: TransportCallback,
+		time: TransportTime | TransportTimeClass
+	): number {
 		const event = new TransportEvent(this, {
 			callback,
 			once: true,
@@ -338,8 +381,12 @@ export class Transport extends ToneWithContext<TransportOptions> implements Emit
 	 */
 	cancel(after: TransportTime = 0): this {
 		const computedAfter = this.toTicks(after);
-		this._timeline.forEachFrom(computedAfter, event => this.clear(event.id));
-		this._repeatedEvents.forEachFrom(computedAfter, event => this.clear(event.id));
+		this._timeline.forEachFrom(computedAfter, (event) =>
+			this.clear(event.id)
+		);
+		this._repeatedEvents.forEachFrom(computedAfter, (event) =>
+			this.clear(event.id)
+		);
 		return this;
 	}
 
@@ -381,6 +428,8 @@ export class Transport extends ToneWithContext<TransportOptions> implements Emit
 	 * Tone.Transport.start("+1", "4:0:0");
 	 */
 	start(time?: Time, offset?: TransportTime): this {
+		// start the context
+		this.context.resume();
 		let offsetTicks;
 		if (isDefined(offset)) {
 			offsetTicks = this.toTicks(offset);
@@ -486,7 +535,10 @@ export class Transport extends ToneWithContext<TransportOptions> implements Emit
 	 * Tone.Transport.setLoopPoints(0, "1m");
 	 * Tone.Transport.loop = true;
 	 */
-	setLoopPoints(startPosition: TransportTime, endPosition: TransportTime): this {
+	setLoopPoints(
+		startPosition: TransportTime,
+		endPosition: TransportTime
+	): this {
 		this.loopStart = startPosition;
 		this.loopEnd = endPosition;
 		return this;
@@ -550,7 +602,9 @@ export class Transport extends ToneWithContext<TransportOptions> implements Emit
 		if (this.loop) {
 			const now = this.now();
 			const ticks = this._clock.getTicksAtTime(now);
-			return (ticks - this._loopStart) / (this._loopEnd - this._loopStart);
+			return (
+				(ticks - this._loopStart) / (this._loopEnd - this._loopStart)
+			);
 		} else {
 			return 0;
 		}
@@ -626,7 +680,7 @@ export class Transport extends ToneWithContext<TransportOptions> implements Emit
 	 * @return  The context time of the next subdivision.
 	 * @example
 	 * // the transport must be started, otherwise returns 0
-	 * Tone.Transport.start(); 
+	 * Tone.Transport.start();
 	 * Tone.Transport.nextSubdivision("4n");
 	 */
 	nextSubdivision(subdivision?: Time): Seconds {
@@ -638,7 +692,7 @@ export class Transport extends ToneWithContext<TransportOptions> implements Emit
 			const now = this.now();
 			// the remainder of the current ticks and the subdivision
 			const transportPos = this.getTicksAtTime(now);
-			const remainingTicks = subdivision - transportPos % subdivision;
+			const remainingTicks = subdivision - (transportPos % subdivision);
 			return this._clock.nextTickTime(remainingTicks, now);
 		}
 	}
@@ -710,9 +764,18 @@ export class Transport extends ToneWithContext<TransportOptions> implements Emit
 	// EMITTER MIXIN TO SATISFY COMPILER
 	//-------------------------------------
 
-	on!: (event: TransportEventNames, callback: (...args: any[]) => void) => this;
-	once!: (event: TransportEventNames, callback: (...args: any[]) => void) => this;
-	off!: (event: TransportEventNames, callback?: ((...args: any[]) => void) | undefined) => this;
+	on!: (
+		event: TransportEventNames,
+		callback: (...args: any[]) => void
+	) => this;
+	once!: (
+		event: TransportEventNames,
+		callback: (...args: any[]) => void
+	) => this;
+	off!: (
+		event: TransportEventNames,
+		callback?: ((...args: any[]) => void) | undefined
+	) => this;
 	emit!: (event: any, ...args: any[]) => this;
 }
 
@@ -722,10 +785,10 @@ Emitter.mixin(Transport);
 // 	INITIALIZATION
 //-------------------------------------
 
-onContextInit(context => {
+onContextInit((context) => {
 	context.transport = new Transport({ context });
 });
 
-onContextClose(context => {
+onContextClose((context) => {
 	context.transport.dispose();
 });

package/Tone/core/context/ToneWithContext.ts

@@ -4,6 +4,7 @@ import { FrequencyClass } from "../type/Frequency";
 import { TimeClass } from "../type/Time";
 import { TransportTimeClass } from "../type/TransportTime";
 import { Frequency, Hertz, Seconds, Ticks, Time } from "../type/Units";
+import { assertUsedScheduleTime } from "../util/Debug";
 import { getDefaultsFromInstance, optionsFromArguments } from "../util/Defaults";
 import { RecursivePartial } from "../util/Interface";
 import { isArray, isBoolean, isDefined, isNumber, isString, isUndef } from "../util/TypeCheck";
@@ -104,6 +105,7 @@ export abstract class ToneWithContext<Options extends ToneWithContextOptions> ex
 	 * Tone.getTransport().bpm.rampTo(60, 30);
 	 */
 	toSeconds(time?: Time): Seconds {
+		assertUsedScheduleTime(time);
 		return new TimeClass(this.context, time).toSeconds();
 	}
 

package/Tone/core/type/Frequency.ts

@@ -50,7 +50,7 @@ export class FrequencyClass<Type extends number = Hertz> extends TimeClass<Type,
 				},
 			},
 			note: {
-				regexp: /^([a-g]{1}(?:b|#|x|bb)?)(-?[0-9]+)/i,
+				regexp: /^([a-g]{1}(?:b|#|##|x|bb|###|#x|x#|bbb)?)(-?[0-9]+)/i,
 				method(pitch, octave): number {
 					const index = noteToScaleIndex[pitch.toLowerCase()];
 					const noteNumber = index + (parseInt(octave, 10) + 1) * 12;
@@ -219,13 +219,13 @@ export class FrequencyClass<Type extends number = Hertz> extends TimeClass<Type,
  * @hidden
  */
 const noteToScaleIndex = {
-	cbb: -2, cb: -1, c: 0, "c#": 1, cx: 2,
-	dbb: 0, db: 1, d: 2, "d#": 3, dx: 4,
-	ebb: 2, eb: 3, e: 4, "e#": 5, ex: 6,
-	fbb: 3, fb: 4, f: 5, "f#": 6, fx: 7,
-	gbb: 5, gb: 6, g: 7, "g#": 8, gx: 9,
-	abb: 7, ab: 8, a: 9, "a#": 10, ax: 11,
-	bbb: 9, bb: 10, b: 11, "b#": 12, bx: 13,
+	cbbb: -3, cbb: -2, cb: -1, c:  0, "c#":  1, cx:  2, "c##":  2, "c###":  3, "cx#":  3, "c#x":  3,
+	dbbb: -1, dbb:  0, db:  1, d:  2, "d#":  3, dx:  4, "d##":  4, "d###":  5, "dx#":  5, "d#x":  5,
+	ebbb:  1, ebb:  2, eb:  3, e:  4, "e#":  5, ex:  6, "e##":  6, "e###":  7, "ex#":  7, "e#x":  7,
+	fbbb:  2, fbb:  3, fb:  4, f:  5, "f#":  6, fx:  7, "f##":  7, "f###":  8, "fx#":  8, "f#x":  8,
+	gbbb:  4, gbb:  5, gb:  6, g:  7, "g#":  8, gx:  9, "g##":  9, "g###": 10, "gx#": 10, "g#x": 10,
+	abbb:  6, abb:  7, ab:  8, a:  9, "a#": 10, ax: 11, "a##": 11, "a###": 12, "ax#": 12, "a#x": 12,
+	bbbb:  8, bbb:  9, bb: 10, b: 11, "b#": 12, bx: 13, "b##": 13, "b###": 14, "bx#": 14, "b#x": 14,
 };
 
 /**

package/Tone/core/util/Debug.ts

@@ -1,3 +1,5 @@
+import { isUndef } from "./TypeCheck";
+
 /**
  * Assert that the statement is true, otherwise invoke the error.
  * @param statement
@@ -14,17 +16,48 @@ export function assert(statement: boolean, error: string): asserts statement {
  */
 export function assertRange(value: number, gte: number, lte = Infinity): void {
 	if (!(gte <= value && value <= lte)) {
-		throw new RangeError(`Value must be within [${gte}, ${lte}], got: ${value}`);
+		throw new RangeError(
+			`Value must be within [${gte}, ${lte}], got: ${value}`
+		);
 	}
 }
 
 /**
- * Make sure that the given value is within the range
+ * Warn if the context is not running.
  */
-export function assertContextRunning(context: import("../context/BaseContext").BaseContext): void {
+export function assertContextRunning(
+	context: import("../context/BaseContext").BaseContext
+): void {
 	// add a warning if the context is not started
 	if (!context.isOffline && context.state !== "running") {
-		warn("The AudioContext is \"suspended\". Invoke Tone.start() from a user action to start the audio.");
+		warn(
+			"The AudioContext is \"suspended\". Invoke Tone.start() from a user action to start the audio."
+		);
+	}
+}
+
+/**
+ * If it is currently inside a scheduled callback
+ */
+let isInsideScheduledCallback = false;
+let printedScheduledWarning = false;
+
+/**
+ * Notify that the following block of code is occurring inside a Transport callback.
+ */
+export function enterScheduledCallback(insideCallback: boolean): void {
+	isInsideScheduledCallback = insideCallback;
+}
+
+/**
+ * Make sure that a time was passed into
+ */
+export function assertUsedScheduleTime(
+	time?: import("../type/Units").Time
+): void {
+	if (isUndef(time) && isInsideScheduledCallback && !printedScheduledWarning) {
+		printedScheduledWarning = true;
+		warn("Events scheduled inside of scheduled callbacks should use the passed in scheduling time. See https://github.com/Tonejs/Tone.js/wiki/Accurate-Timing");
 	}
 }
 

package/Tone/core/util/StateTimeline.ts

@@ -13,7 +13,7 @@ export interface StateTimelineEvent extends TimelineEvent {
  * A Timeline State. Provides the methods: `setStateAtTime("state", time)` and `getValueAtTime(time)`
  * @param initial The initial state of the StateTimeline.  Defaults to `undefined`
  */
-export class StateTimeline<AdditionalOptions extends {} = {}> extends Timeline<StateTimelineEvent & AdditionalOptions> {
+export class StateTimeline<AdditionalOptions extends Record<string, any> = Record<string, any>> extends Timeline<StateTimelineEvent & AdditionalOptions> {
 
 	readonly name: string = "StateTimeline";
 

package/Tone/effect/AutoFilter.ts

@@ -64,7 +64,7 @@ export class AutoFilter extends LFOEffect<AutoFilterOptions> {
 			baseFrequency: 200,
 			octaves: 2.6,
 			filter: {
-				type: "lowpass" as "lowpass",
+				type: "lowpass" as const,
 				rolloff: -12 as -12,
 				Q: 1,
 			}

package/Tone/effect/Chebyshev.ts

@@ -61,7 +61,7 @@ export class Chebyshev extends Effect<ChebyshevOptions> {
 	static getDefaults(): ChebyshevOptions {
 		return Object.assign(Effect.getDefaults(), {
 			order: 1,
-			oversample: "none" as "none"
+			oversample: "none" as const
 		});
 	}
 

package/Tone/effect/Chorus.test.ts

@@ -7,25 +7,29 @@ import { Oscillator } from "Tone/source";
 import { Offline } from "test/helper/Offline";
 
 describe("Chorus", () => {
-
 	BasicTests(Chorus);
 	EffectTests(Chorus);
 
 	it("matches a file", () => {
-		return CompareToFile(() => {
-			const chorus = new Chorus().toDestination().start();
-			const osc = new Oscillator(220, "sawtooth").connect(chorus).start();
-		}, "chorus.wav", 0.1);
+		return CompareToFile(
+			() => {
+				const chorus = new Chorus().toDestination().start();
+				const osc = new Oscillator(220, "sawtooth")
+					.connect(chorus)
+					.start();
+			},
+			"chorus.wav",
+			0.25
+		);
 	});
 
 	context("API", () => {
-
 		it("can pass in options in the constructor", () => {
 			const chorus = new Chorus({
 				frequency: 2,
 				delayTime: 1,
 				depth: 0.4,
-				spread: 90
+				spread: 90,
 			});
 			expect(chorus.frequency.value).to.be.closeTo(2, 0.01);
 			expect(chorus.delayTime).to.be.closeTo(1, 0.01);
@@ -84,4 +88,3 @@ describe("Chorus", () => {
 		});
 	});
 });
-

package/Tone/effect/Chorus.ts

@@ -118,7 +118,7 @@ export class Chorus extends StereoFeedbackEffect<ChorusOptions> {
 			frequency: 1.5,
 			delayTime: 3.5,
 			depth: 0.7,
-			type: "sine" as "sine",
+			type: "sine" as const,
 			spread: 180,
 			feedback: 0,
 			wet: 0.5,

package/Tone/effect/MidSideEffect.ts

@@ -68,14 +68,14 @@ export abstract class MidSideEffect<Options extends MidSideEffectOptions> extend
 	/**
 	 * Connect the mid chain of the effect
 	 */
-	protected connectEffectMid(...nodes: OutputNode[]): void{
+	protected connectEffectMid(...nodes: OutputNode[]): void {
 		this._midSend.chain(...nodes, this._midReturn);
 	}
 	
 	/**
 	 * Connect the side chain of the effect
 	 */
-	protected connectEffectSide(...nodes: OutputNode[]): void{
+	protected connectEffectSide(...nodes: OutputNode[]): void {
 		this._sideSend.chain(...nodes, this._sideReturn);
 	}
 

package/Tone/effect/StereoEffect.ts

@@ -68,7 +68,7 @@ export class StereoEffect<Options extends StereoEffectOptions> extends ToneAudio
 	/**
 	 * Connect the left part of the effect
 	 */
-	protected connectEffectLeft(...nodes: OutputNode[]): void{
+	protected connectEffectLeft(...nodes: OutputNode[]): void {
 		this._split.connect(nodes[0], 0, 0);
 		connectSeries(...nodes);
 		connect(nodes[nodes.length-1], this._merge, 0, 0);
@@ -77,7 +77,7 @@ export class StereoEffect<Options extends StereoEffectOptions> extends ToneAudio
 	/**
 	 * Connect the right part of the effect
 	 */
-	protected connectEffectRight(...nodes: OutputNode[]): void{
+	protected connectEffectRight(...nodes: OutputNode[]): void {
 		this._split.connect(nodes[0], 1, 0);
 		connectSeries(...nodes);
 		connect(nodes[nodes.length-1], this._merge, 0, 1);

package/Tone/effect/Tremolo.ts

@@ -111,7 +111,7 @@ export class Tremolo extends StereoEffect<TremoloOptions> {
 	static getDefaults(): TremoloOptions {
 		return Object.assign(StereoEffect.getDefaults(), {
 			frequency: 10,
-			type: "sine" as "sine",
+			type: "sine" as const,
 			depth: 0.5,
 			spread: 180,
 		});

package/Tone/effect/Vibrato.ts

@@ -79,7 +79,7 @@ export class Vibrato extends Effect<VibratoOptions> {
 			maxDelay: 0.005,
 			frequency: 5,
 			depth: 0.1,
-			type: "sine" as "sine"
+			type: "sine" as const
 		});
 	}
 

package/Tone/event/Pattern.ts

@@ -73,7 +73,7 @@ export class Pattern<ValueType> extends Loop<PatternOptions<ValueType>> {
 
 	static getDefaults(): PatternOptions<any> {
 		return Object.assign(Loop.getDefaults(), {
-			pattern: "up" as "up",
+			pattern: "up" as const,
 			values: [],
 			callback: noOp,
 		});

package/Tone/instrument/Instrument.ts

@@ -83,6 +83,10 @@ export abstract class Instrument<Options extends InstrumentOptions> extends Tone
 		if (this._syncState()) {
 			this._syncMethod("triggerAttack", 1);
 			this._syncMethod("triggerRelease", 0);
+
+			this.context.transport.on("stop", this._syncedRelease);
+			this.context.transport.on("pause", this._syncedRelease);
+			this.context.transport.on("loopEnd", this._syncedRelease);
 		}
 		return this;
 	}
@@ -126,6 +130,10 @@ export abstract class Instrument<Options extends InstrumentOptions> extends Tone
 			this._synced = false;
 			this.triggerAttack = this._original_triggerAttack;
 			this.triggerRelease = this._original_triggerRelease;
+
+			this.context.transport.off("stop", this._syncedRelease);
+			this.context.transport.off("pause", this._syncedRelease);
+			this.context.transport.off("loopEnd", this._syncedRelease);
 		}
 		return this;
 	}
@@ -166,6 +174,11 @@ export abstract class Instrument<Options extends InstrumentOptions> extends Tone
 	abstract triggerRelease(...args: any[]): this;
 	private _original_triggerRelease = this.triggerRelease;
 
+	/**
+	 * The release which is scheduled to the timeline. 
+	 */
+	protected _syncedRelease = (time: number) => this._original_triggerRelease(time);
+
 	/**
 	 * clean up
 	 * @returns {Instrument} this