diff --git a/docs/js/lib/AudioSourceNode.d.ts b/docs/js/lib/AudioSourceNode.d.ts
index dc3408f..2e36b44 100644
--- a/docs/js/lib/AudioSourceNode.d.ts
+++ b/docs/js/lib/AudioSourceNode.d.ts
@@ -37,6 +37,12 @@ declare class AudioSourceNode implements AudioBufferSourceNode {
     private readonly gainNode;
     private readonly stereoPannerNode;
     private path;
+    private _isDestroyed;
+    private _isStarted;
+    private _isStopped;
+    private _isEnded;
+    private onEndedMainCallback;
+    private onEndedCallback;
     private readonly analyser;
     private merger?;
     private splitter?;
@@ -61,33 +67,95 @@ declare class AudioSourceNode implements AudioBufferSourceNode {
     connect(destination: AudioNode, outputIndex?: number, inputIndex?: number): AudioNode;
     connect(destination: AudioParam, outputIndex?: number): void;
     disconnect(): void;
+    disconnect(output: number): void;
+    disconnect(destinationNode: AudioNode): void;
+    disconnect(destinationNode: AudioNode, output: number): void;
+    disconnect(destinationNode: AudioNode, output: number, input: number): void;
+    disconnect(destinationParam: AudioParam): void;
+    disconnect(destinationParam: AudioParam, output: number): void;
     load(path: string): Promise<void>;
     volume(volume: number, options?: AudioAdjustmentOptions): AudioSourceNode;
     pan(pan: number, options?: AudioAdjustmentOptions): AudioSourceNode;
     pan3d(): AudioSourceNode;
+    /**
+     * This method may be called multiple times during the lifetime of the AudioSourceNode.
+     * To acheive this utility, the active sourceNode is "released" following a call to stop(),
+     * and a new source is constructed that shares the same buffer.
+     *
+     * Implementation Notes:
+     * - If no buffer has been loaded, this method does nothing
+     * - Upon constructing a new internal AudioBufferSourceNode, only the loaded buffer will be
+     *   shared from the old node. All properties managed by the AudioBufferSourceNode, such as
+     *   playbackRate, looping, stopping, and events (onended) will remain on the old one.
+     * - At the moment start() is called, methods that operate on the source node directly will
+     *   operate on the new source node, even if playback hasn't yet begun.
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/AudioBufferSourceNode/start
+     */
     start(when?: number, offset?: number, duration?: number): void;
     stop(when?: number): void;
     /**
      * Retrieve the [playhead position][1] of the source buffer in seconds.
-     * A value of -1 means the buffer is null.
+     * A value of -1 means the buffer is null, or the source is playing silence (all zeros).
      *
      * [1]: <https://webaudio.github.io/web-audio-api/#playhead-position> "Playhead Position"
      */
     position(): number;
     /**
      * Retrieve the buffer sample index, represented by the internal position track.
-     * See [playhead position][1]. A value of -1 means the buffer is null.
+     * See [playhead position][1].
+     *
+     * A value of -1 is returned in these conditions:
+     *   - The source is not playing
+     *   - The buffer is not set
      *
      * [1]: <https://webaudio.github.io/web-audio-api/#playhead-position> "Playhead Position"
      */
     positionSample(): number;
-    get onended(): ((this: AudioScheduledSourceNode, ev: Event) => any) | null;
-    set onended(callback: ((this: AudioScheduledSourceNode, ev: Event) => any) | null);
+    /**
+     * Due to the nature of event timers, this can return `true` after a source has ended.
+     * The recommendation is to check `isEnded()` inside a setTimer() with no delay, and
+     * do some fallback logic if it's `true`, or to make use of the `onended` callback.
+     * @returns `true` if the source has been started, and has probably not yet ended.
+     */
+    get isActive(): boolean;
+    /**
+     * @returns `true` if the source has been scheduled to start
+     */
+    get isStarted(): boolean;
+    /**
+     * @returns `true` if the source has been scheduled to stop
+     */
+    get isStopped(): boolean;
+    /**
+     * In the case that the source hasn't been started yet, this will be `false`.
+     * Use `isStarted()` to determine if the source has been started.
+     * @returns `true` if the source has ended and is therefore outputting silence.
+     */
+    get isEnded(): boolean;
+    /**
+     * @returns `true` if this AudioSourceNode has been destroyed
+     */
+    get isDestroyed(): boolean;
+    get onended(): ((event: Event) => void) | null;
+    set onended(callback: ((event: Event) => void) | null);
     get buffer(): AudioBuffer | null;
     set buffer(buffer: AudioBuffer | null);
     /**
-     * Custom implementation of buffer assignment to support reading [playhead position][1] from
-     * the source node, which is currently unsupported.
+     * Static definition for how to compute the half-length of a buffer.
+     *
+     * Why? Because it's computed twice and I want to be certain that it is always the same.
+     *
+     * Why is this computed twice? To avoid a race condition caused by loading a buffer and then
+     * building the node graph.
+     *
+     * Why do we do it in that order? You ask a lot of questions! Go look at the code!
+     * @param buffer the buffer to compute half-length for
+     */
+    private static computeBufferHalfLength;
+    /**
+     * Custom buffer computation to support reading [playhead position][1] from the source node,
+     * which is currently unsupported by Web Audio API (but maybe someday it'll be exposed).
      *
      * See [first unrepresentable IEEE 754 integer][2] for the reasoning behind using a
      * pigeon hole type implementation.
@@ -95,8 +163,21 @@ declare class AudioSourceNode implements AudioBufferSourceNode {
      * [1]: <https://webaudio.github.io/web-audio-api/#playhead-position> "Playhead Position"
      * [2]: <https://stackoverflow.com/a/3793950/4561008> "First unrepresentable IEEE 754 integer"
      */
-    private computeBuffer;
+    private static computeBufferWithPositionChannel;
+    /**
+     * Constructs the internal audio graph for this AudioSourceNode based on the number of channels
+     * provided. The splitter will construct with `bufferChannels` channel outputs, where the last
+     * channel is presumed to be the position channel. The merge node, if required, will construct
+     * with `bufferChannels - 1` channel inputs, so that the position channel is not output
+     * @param bufferChannels number of channels to initialize
+     */
     private computeConnections;
+    private throwIfDestroyed;
+    /**
+     * Rapidly deconstruct this object and its properties in the hopes of freeing memory quickly.
+     * Is it okay to call this method multiple times.
+     */
+    destroy(): void;
     get detune(): AudioParam;
     get loop(): boolean;
     set loop(value: boolean);
diff --git a/docs/js/lib/AudioSourceNode.js b/docs/js/lib/AudioSourceNode.js
index 322f6da..2f188ea 100644
--- a/docs/js/lib/AudioSourceNode.js
+++ b/docs/js/lib/AudioSourceNode.js
@@ -36,6 +36,17 @@ class AudioSourceNode {
     gainNode;
     stereoPannerNode;
     path = null;
+    _isDestroyed = false;
+    _isStarted = false;
+    _isStopped = false;
+    _isEnded = false;
+    onEndedMainCallback = (event) => {
+        this._isEnded = true;
+        if (this.onEndedCallback) {
+            this.onEndedCallback.call(this, event);
+        }
+    };
+    onEndedCallback = null;
     // Nodes necessary for tracking position
     analyser;
     merger;
@@ -56,6 +67,7 @@ class AudioSourceNode {
         if (destination) {
             this.connect(destination);
         }
+        this.sourceNode.onended = this.onEndedMainCallback;
     }
     /**
      * Creates and returns a clone of this AudioSourceNode, specifically of just the
@@ -65,11 +77,10 @@ class AudioSourceNode {
      * @returns clone
      */
     clone() {
+        this.throwIfDestroyed();
         const selfClone = new AudioSourceNode(this.audioContext);
         selfClone.path = this.path;
-        if (this.buffer) {
-            this.copyBufferTo(selfClone);
-        }
+        this.copyBufferTo(selfClone);
         return selfClone;
     }
     /**
@@ -77,6 +88,7 @@ class AudioSourceNode {
      * @param other AudioSourceNode to copy into
      */
     copyBufferTo(other) {
+        this.throwIfDestroyed();
         if (!this.buffer) {
             other.buffer = null;
             return;
@@ -91,11 +103,12 @@ class AudioSourceNode {
         for (let i = 0; i < bufferChannels; i++) {
             bufferClone.copyToChannel(this.buffer.getChannelData(i), i);
         }
+        other.computeConnections(bufferChannels);
+        other.bufferHalfLength = AudioSourceNode.computeBufferHalfLength(bufferClone);
         other.sourceNode.buffer = bufferClone;
-        other.bufferHalfLength = Math.floor(bufferLength / 2);
-        other.computeConnections();
     }
     connect(destination, outputIndex, inputIndex) {
+        this.throwIfDestroyed();
         // We only want to diconnect/ connect the final gain node, doing anything else splits too much logic around
         // that is needed to track the playhead position on the source node. Source connections are made only when
         // the buffer source is known.
@@ -104,42 +117,126 @@ class AudioSourceNode {
         }
         return this.gainNode.connect(destination, outputIndex);
     }
-    disconnect() {
+    disconnect(param1, output, input) {
+        this.throwIfDestroyed();
         // Only diconnect the final gain node, the other nodes will all stay connected
-        this.gainNode.disconnect();
+        if (param1 == undefined) {
+            return this.gainNode.disconnect();
+        }
+        if (typeof param1 == 'number') {
+            return this.gainNode.disconnect(param1);
+        }
+        if (param1 instanceof AudioParam) {
+            if (output != undefined) {
+                return this.gainNode.disconnect(param1, output);
+            }
+            return this.gainNode.disconnect(param1);
+        }
+        if (output != undefined && input != undefined) {
+            return this.gainNode.disconnect(param1, output, input);
+        }
+        if (output != undefined) {
+            return this.gainNode.disconnect(param1, output);
+        }
+        this.gainNode.disconnect(param1);
     }
     async load(path) {
+        this.throwIfDestroyed();
         this.path = path;
         const audioFile = await fetch(this.path);
         const decodedBuffer = await this.audioContext.decodeAudioData(await audioFile.arrayBuffer());
         this.buffer = decodedBuffer;
     }
     volume(volume, options) {
+        this.throwIfDestroyed();
         console.log(`stub volume ${volume} with options ${options}`);
         return this;
     }
     pan(pan, options) {
+        this.throwIfDestroyed();
         console.log(`stub pan ${pan} with options ${options}`);
         return this;
     }
     pan3d() {
         // TODO: ...someday...
         // https://github.com/twoz/hrtf-panner-js/blob/master/hrtf.js
+        this.throwIfDestroyed();
         return this;
     }
+    /**
+     * This method may be called multiple times during the lifetime of the AudioSourceNode.
+     * To acheive this utility, the active sourceNode is "released" following a call to stop(),
+     * and a new source is constructed that shares the same buffer.
+     *
+     * Implementation Notes:
+     * - If no buffer has been loaded, this method does nothing
+     * - Upon constructing a new internal AudioBufferSourceNode, only the loaded buffer will be
+     *   shared from the old node. All properties managed by the AudioBufferSourceNode, such as
+     *   playbackRate, looping, stopping, and events (onended) will remain on the old one.
+     * - At the moment start() is called, methods that operate on the source node directly will
+     *   operate on the new source node, even if playback hasn't yet begun.
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/AudioBufferSourceNode/start
+     */
     start(when, offset, duration) {
+        this.throwIfDestroyed();
+        if (!this.buffer) {
+            console.warn(`Cannot start an AudioSourceNode without first loading a buffer.`);
+            return;
+        }
+        if (this._isStarted || this._isStopped) {
+            const buffer = this.sourceNode.buffer;
+            this.sourceNode.onended = this.onEndedCallback;
+            this.stop(when);
+            this._isStopped = false;
+            const oldSourceNode = this.sourceNode;
+            if (when && when > this.audioContext.currentTime) {
+                setTimeout(() => {
+                    oldSourceNode.stop();
+                    oldSourceNode.disconnect();
+                    oldSourceNode.buffer = null;
+                }, when && when > this.audioContext.currentTime
+                    ? 1000 * (this.audioContext.currentTime - when)
+                    : 0);
+            }
+            this.sourceNode = this.audioContext.createBufferSource();
+            this.sourceNode.buffer = buffer;
+            this.sourceNode.onended = this.onEndedMainCallback;
+            if (this.sourceNode.buffer && !this.splitter) {
+                console.warn(`An AudioSourceNode appears to be in an invalid state, as a buffer has been ` +
+                    `loaded, and no internal splitter node has been constructed. ` +
+                    `This is a mistake.`);
+            }
+            else if (this.splitter) {
+                this.sourceNode.connect(this.splitter);
+            }
+        }
+        if (when && when > this.audioContext.currentTime) {
+            setTimeout(() => {
+                this._isEnded = false;
+            }, 1000 * (this.audioContext.currentTime - when));
+        }
+        else {
+            this._isEnded = false;
+        }
+        this._isStarted = true;
         return this.sourceNode.start(when, offset, duration);
     }
     stop(when) {
-        return this.sourceNode.stop(when);
+        this.throwIfDestroyed();
+        if (this._isStarted) {
+            this._isStopped = true;
+            return this.sourceNode.stop(when);
+        }
     }
     /**
      * Retrieve the [playhead position][1] of the source buffer in seconds.
-     * A value of -1 means the buffer is null.
+     * A value of -1 means the buffer is null, or the source is playing silence (all zeros).
      *
      * [1]: <https://webaudio.github.io/web-audio-api/#playhead-position> "Playhead Position"
      */
     position() {
+        this.throwIfDestroyed();
         if (this.buffer == null) {
             return -1;
         }
@@ -147,16 +244,21 @@ class AudioSourceNode {
         if (sampleIndex == -1) {
             return sampleIndex;
         }
-        return sampleIndex * this.buffer.sampleRate;
+        return sampleIndex / this.buffer.sampleRate;
     }
     /**
      * Retrieve the buffer sample index, represented by the internal position track.
-     * See [playhead position][1]. A value of -1 means the buffer is null.
+     * See [playhead position][1].
+     *
+     * A value of -1 is returned in these conditions:
+     *   - The source is not playing
+     *   - The buffer is not set
      *
      * [1]: <https://webaudio.github.io/web-audio-api/#playhead-position> "Playhead Position"
      */
     positionSample() {
-        if (this.bufferHalfLength == null) {
+        this.throwIfDestroyed();
+        if (this.bufferHalfLength == null || this._isEnded) {
             return -1;
         }
         this.analyser.getFloatTimeDomainData(this.positionContainer);
@@ -166,22 +268,77 @@ class AudioSourceNode {
         }
         return index + this.bufferHalfLength;
     }
+    /**
+     * Due to the nature of event timers, this can return `true` after a source has ended.
+     * The recommendation is to check `isEnded()` inside a setTimer() with no delay, and
+     * do some fallback logic if it's `true`, or to make use of the `onended` callback.
+     * @returns `true` if the source has been started, and has probably not yet ended.
+     */
+    get isActive() {
+        return this.isStarted && !this.isEnded;
+    }
+    /**
+     * @returns `true` if the source has been scheduled to start
+     */
+    get isStarted() {
+        return this._isStarted;
+    }
+    /**
+     * @returns `true` if the source has been scheduled to stop
+     */
+    get isStopped() {
+        return this._isStopped;
+    }
+    /**
+     * In the case that the source hasn't been started yet, this will be `false`.
+     * Use `isStarted()` to determine if the source has been started.
+     * @returns `true` if the source has ended and is therefore outputting silence.
+     */
+    get isEnded() {
+        return this._isEnded;
+    }
+    /**
+     * @returns `true` if this AudioSourceNode has been destroyed
+     */
+    get isDestroyed() {
+        return this._isDestroyed;
+    }
     get onended() {
-        return this.sourceNode.onended;
+        this.throwIfDestroyed();
+        return this.onEndedCallback;
     }
     set onended(callback) {
-        this.sourceNode.onended = callback;
+        this.throwIfDestroyed();
+        this.onEndedCallback = callback;
     }
     get buffer() {
+        this.throwIfDestroyed();
         return this.sourceNode.buffer;
     }
     set buffer(buffer) {
-        this.computeBuffer(buffer);
-        this.computeConnections();
+        this.throwIfDestroyed();
+        const computedBuffer = AudioSourceNode.computeBufferWithPositionChannel(buffer);
+        this.computeConnections(computedBuffer?.numberOfChannels ?? 0);
+        this.bufferHalfLength = AudioSourceNode.computeBufferHalfLength(computedBuffer);
+        this.sourceNode.buffer = computedBuffer;
+    }
+    /**
+     * Static definition for how to compute the half-length of a buffer.
+     *
+     * Why? Because it's computed twice and I want to be certain that it is always the same.
+     *
+     * Why is this computed twice? To avoid a race condition caused by loading a buffer and then
+     * building the node graph.
+     *
+     * Why do we do it in that order? You ask a lot of questions! Go look at the code!
+     * @param buffer the buffer to compute half-length for
+     */
+    static computeBufferHalfLength(buffer) {
+        return Math.floor((buffer?.length ?? 0) / 2);
     }
     /**
-     * Custom implementation of buffer assignment to support reading [playhead position][1] from
-     * the source node, which is currently unsupported.
+     * Custom buffer computation to support reading [playhead position][1] from the source node,
+     * which is currently unsupported by Web Audio API (but maybe someday it'll be exposed).
      *
      * See [first unrepresentable IEEE 754 integer][2] for the reasoning behind using a
      * pigeon hole type implementation.
@@ -189,12 +346,10 @@ class AudioSourceNode {
      * [1]: <https://webaudio.github.io/web-audio-api/#playhead-position> "Playhead Position"
      * [2]: <https://stackoverflow.com/a/3793950/4561008> "First unrepresentable IEEE 754 integer"
      */
-    computeBuffer(buffer) {
+    static computeBufferWithPositionChannel(buffer) {
         // Credit to @kurtsmurf for the original implementation, @p-himik for the POC, and @selimachour for the concept
         if (!buffer) {
-            this.sourceNode.buffer = null;
-            this.bufferHalfLength = null;
-            return;
+            return null;
         }
         const bufferLength = buffer.length;
         const bufferChannels = buffer.numberOfChannels;
@@ -208,15 +363,21 @@ class AudioSourceNode {
         }
         // Credit to @westarne for this improvement
         const trackedArray = new Float32Array(bufferLength);
-        const halfBufferLength = Math.floor(bufferLength / 2);
-        this.bufferHalfLength = halfBufferLength;
+        const halfBufferLength = AudioSourceNode.computeBufferHalfLength(trackedBuffer);
         for (let i = 0; i < bufferLength; i++) {
             trackedArray[i] = i - halfBufferLength;
         }
         trackedBuffer.copyToChannel(trackedArray, bufferChannels);
-        this.sourceNode.buffer = trackedBuffer;
+        return trackedBuffer;
     }
-    computeConnections() {
+    /**
+     * Constructs the internal audio graph for this AudioSourceNode based on the number of channels
+     * provided. The splitter will construct with `bufferChannels` channel outputs, where the last
+     * channel is presumed to be the position channel. The merge node, if required, will construct
+     * with `bufferChannels - 1` channel inputs, so that the position channel is not output
+     * @param bufferChannels number of channels to initialize
+     */
+    computeConnections(bufferChannels) {
         this.sourceNode.disconnect();
         if (this.splitter) {
             this.splitter.disconnect();
@@ -224,7 +385,6 @@ class AudioSourceNode {
         if (this.merger) {
             this.merger.disconnect();
         }
-        const bufferChannels = this.sourceNode.buffer?.numberOfChannels;
         if (!bufferChannels) {
             this.splitter = undefined;
             this.merger = undefined;
@@ -250,51 +410,103 @@ class AudioSourceNode {
         }
         this.merger.connect(this.stereoPannerNode);
     }
+    throwIfDestroyed() {
+        if (this._isDestroyed) {
+            throw new Error('This AudioSourceNode has been destroyed, it is invalid behavior to call this method. Check the stack trace.');
+        }
+    }
+    /**
+     * Rapidly deconstruct this object and its properties in the hopes of freeing memory quickly.
+     * Is it okay to call this method multiple times.
+     */
+    destroy() {
+        this._isDestroyed = true;
+        if (this.sourceNode) {
+            this.sourceNode.stop();
+            this.sourceNode.disconnect();
+            this.sourceNode.buffer = null;
+            this.sourceNode = undefined;
+        }
+        if (this.gainNode) {
+            this.gainNode.disconnect();
+            this.gainNode = undefined;
+        }
+        if (this.stereoPannerNode) {
+            this.stereoPannerNode.disconnect();
+            this.stereoPannerNode = undefined;
+        }
+        if (this.analyser) {
+            this.analyser = undefined;
+        }
+        if (this.merger) {
+            this.merger.disconnect();
+            this.merger = undefined;
+        }
+        if (this.splitter) {
+            this.splitter.disconnect();
+            this.splitter = undefined;
+        }
+    }
     get detune() {
+        this.throwIfDestroyed();
         return this.sourceNode.detune;
     }
     get loop() {
+        this.throwIfDestroyed();
         return this.sourceNode.loop;
     }
     set loop(value) {
+        this.throwIfDestroyed();
         this.sourceNode.loop = value;
     }
     get loopStart() {
+        this.throwIfDestroyed();
         return this.sourceNode.loopStart;
     }
     set loopStart(value) {
+        this.throwIfDestroyed();
         this.sourceNode.loopStart = value;
     }
     get loopEnd() {
+        this.throwIfDestroyed();
         return this.sourceNode.loopEnd;
     }
     set loopEnd(value) {
+        this.throwIfDestroyed();
         this.sourceNode.loopEnd = value;
     }
     get playbackRate() {
+        this.throwIfDestroyed();
         return this.sourceNode.playbackRate;
     }
     get context() {
+        this.throwIfDestroyed();
         return this.audioContext;
     }
     get channelCount() {
+        this.throwIfDestroyed();
         return this.sourceNode.channelCount;
     }
     get channelCountMode() {
+        this.throwIfDestroyed();
         return this.sourceNode.channelCountMode;
     }
     get channelInterpretation() {
+        this.throwIfDestroyed();
         return this.sourceNode.channelInterpretation;
     }
     addEventListener(type, listener, options) {
+        this.throwIfDestroyed();
         this.sourceNode.addEventListener(type, listener, options);
     }
     removeEventListener(type, listener, options) {
+        this.throwIfDestroyed();
         this.sourceNode.removeEventListener(type, listener, options);
     }
     dispatchEvent(event) {
+        this.throwIfDestroyed();
         return this.sourceNode.dispatchEvent(event);
     }
 }
 export default AudioSourceNode;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"AudioSourceNode.js","sourceRoot":"","sources":["../src/AudioSourceNode.ts"],"names":[],"mappings":"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"}
\ No newline at end of file
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"AudioSourceNode.js","sourceRoot":"","sources":["../src/AudioSourceNode.ts"],"names":[],"mappings":"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"}
\ No newline at end of file
diff --git a/docs/js/lib/MusicMixer.js b/docs/js/lib/MusicMixer.js
index 08b23fe..93066b8 100644
--- a/docs/js/lib/MusicMixer.js
+++ b/docs/js/lib/MusicMixer.js
@@ -83,9 +83,7 @@ class MusicMixer {
      * @returns {MusicMixer} this MusicMixer
      */
     volume(volume, options) {
-        const adjustment = options
-            ? buildOptions(options, defaults.automationDefault)
-            : defaults.automationDefault;
+        const adjustment = buildOptions(options, defaults.automationDefault);
         automation(this.audioContext, this.gainNode.gain, volume, adjustment);
         return this;
     }
@@ -94,4 +92,4 @@ class MusicMixer {
     }
 }
 export default MusicMixer;
-//# sourceMappingURL=data:application/json;base64,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
\ No newline at end of file
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiTXVzaWNNaXhlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy9NdXNpY01peGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sZUFBZSxNQUFNLHNCQUFzQixDQUFDO0FBQ25ELE9BQU8sV0FBVyxFQUFFLEVBQVMsVUFBVSxFQUFFLE1BQU0sWUFBWSxDQUFDO0FBQzVELE9BQU8sVUFBc0MsTUFBTSxpQkFBaUIsQ0FBQztBQUNyRSxPQUFPLFlBQVksTUFBTSxlQUFlLENBQUM7QUFDekMsT0FBTyxLQUFLLFFBQVEsTUFBTSxlQUFlLENBQUM7QUFFMUM7O0dBRUc7QUFDSCxNQUFNLFVBQVU7SUFDSyxZQUFZLEdBQWlCLElBQUksWUFBWSxFQUFFLENBQUM7SUFDaEQsUUFBUSxDQUFXO0lBQzVCLE1BQU0sR0FFVixFQUFFLENBQUM7SUFFUDtRQUNJLElBQUksQ0FBQyxRQUFRLEdBQUcsSUFBSSxDQUFDLFlBQVksQ0FBQyxVQUFVLEVBQUUsQ0FBQztRQUMvQyxJQUFJLENBQUMsUUFBUSxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsWUFBWSxDQUFDLFdBQVcsQ0FBQyxDQUFDO0lBQ3pELENBQUM7SUFFRDs7Ozs7T0FLRztJQUNJLFVBQVUsQ0FBQyxJQUFhO1FBQzNCLE1BQU0sV0FBVyxHQUFHLElBQUksZUFBZSxDQUFDLElBQUksQ0FBQyxZQUFZLENBQUMsQ0FBQztRQUMzRCxJQUFJLElBQUksRUFBRSxDQUFDO1lBQ1AsV0FBVyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsQ0FBQztRQUMzQixDQUFDO1FBQ0QsT0FBTyxXQUFXLENBQUM7SUFDdkIsQ0FBQztJQUVEOzs7Ozs7O09BT0c7SUFDSSxRQUFRLENBQUMsSUFBWSxFQUFFLElBQWEsRUFBRSxNQUF3QjtRQUNqRSxJQUFJLE1BQU0sQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxDQUFDLFFBQVEsQ0FBQyxJQUFJLENBQUMsRUFBRSxDQUFDO1lBQzFDLE1BQU0sSUFBSSxLQUFLLENBQUMsb0JBQW9CLElBQUksc0NBQXNDLENBQUMsQ0FBQztRQUNwRixDQUFDO1FBQ0QsSUFBSSxXQUFXLEdBQUcsTUFBTSxDQUFDO1FBQ3pCLElBQUksQ0FBQyxXQUFXLEVBQUUsQ0FBQztZQUNmLFdBQVcsR0FBRyxJQUFJLENBQUMsVUFBVSxDQUFDLElBQUksQ0FBQyxDQUFDO1FBQ3hDLENBQUM7UUFDRCxNQUFNLEtBQUssR0FBRyxJQUFJLFdBQVcsQ0FBQyxJQUFJLEVBQUUsSUFBSSxDQUFDLFlBQVksRUFBRSxJQUFJLENBQUMsUUFBUSxFQUFFLFdBQVcsQ0FBQyxDQUFDO1FBQ25GLElBQUksQ0FBQyxNQUFNLENBQUMsSUFBSSxDQUFDLEdBQUcsS0FBSyxDQUFDO1FBQzFCLE9BQU8sS0FBSyxDQUFDO0lBQ2pCLENBQUM7SUFFRDs7Ozs7OztPQU9HO0lBQ0ksYUFBYSxDQUFDLElBQVksRUFBRSxJQUFhLEVBQUUsTUFBd0I7UUFDdEUsSUFBSSxNQUFNLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxNQUFNLENBQUMsQ0FBQyxRQUFRLENBQUMsSUFBSSxDQUFDLEVBQUUsQ0FBQztZQUMxQyxNQUFNLElBQUksS0FBSyxDQUFDLG9CQUFvQixJQUFJLHNDQUFzQyxDQUFDLENBQUM7UUFDcEYsQ0FBQztRQUNELElBQUksV0FBVyxHQUFHLE1BQU0sQ0FBQztRQUN6QixJQUFJLENBQUMsV0FBVyxFQUFFLENBQUM7WUFDZixXQUFXLEdBQUcsSUFBSSxDQUFDLFVBQVUsQ0FBQyxJQUFJLENBQUMsQ0FBQztRQUN4QyxDQUFDO1FBQ0QsTUFBTSxLQUFLLEdBQUcsSUFBSSxVQUFVLENBQUMsSUFBSSxFQUFFLElBQUksQ0FBQyxZQUFZLEVBQUUsSUFBSSxDQUFDLFFBQVEsRUFBRSxXQUFXLENBQUMsQ0FBQztRQUNsRixJQUFJLENBQUMsTUFBTSxDQUFDLElBQUksQ0FBQyxHQUFHLEtBQUssQ0FBQztRQUMxQixPQUFPLEtBQUssQ0FBQztJQUNqQixDQUFDO0lBRUQ7Ozs7O09BS0c7SUFDSSxLQUFLLENBQUMsSUFBWTtRQUNyQixPQUFPLElBQUksQ0FBQyxNQUFNLENBQUMsSUFBSSxDQUFDLENBQUM7SUFDN0IsQ0FBQztJQUVEOzs7OztPQUtHO0lBQ0ksTUFBTSxDQUFDLE1BQWMsRUFBRSxPQUFnQztRQUMxRCxNQUFNLFVBQVUsR0FBRyxZQUFZLENBQUMsT0FBTyxFQUFFLFFBQVEsQ0FBQyxpQkFBaUIsQ0FBQyxDQUFDO1FBRXJFLFVBQVUsQ0FBQyxJQUFJLENBQUMsWUFBWSxFQUFFLElBQUksQ0FBQyxRQUFRLENBQUMsSUFBSSxFQUFFLE1BQU0sRUFBRSxVQUFVLENBQUMsQ0FBQztRQUV0RSxPQUFPLElBQUksQ0FBQztJQUNoQixDQUFDO0lBRUQsSUFBSSxXQUFXO1FBQ1gsT0FBTyxJQUFJLENBQUMsWUFBWSxDQUFDLFdBQVcsQ0FBQztJQUN6QyxDQUFDO0NBQ0o7QUFFRCxlQUFlLFVBQVUsQ0FBQyJ9
\ No newline at end of file
diff --git a/docs/js/lib/Track.d.ts b/docs/js/lib/Track.d.ts
index 330921b..8e69c94 100644
--- a/docs/js/lib/Track.d.ts
+++ b/docs/js/lib/Track.d.ts
@@ -139,6 +139,7 @@ interface Track {
      * Implementation Notes:
      * - If `options.delay` is provided, it will be used over `delay`.
      * - Does nothing if there is no playing AudioSource.
+     * - For consecutive calls, the earliest time from consecuitive calls will be used.
      * - Saves the playhead position of the AudioSource at the time this method is called,
      *   so that a future `start()` call will resume from the saved position.
      * @param delay optional delay time
@@ -173,6 +174,9 @@ interface Track {
      * Implementation Notes:
      * - After this method returns, all methods that modify the AudioSource of this Track will
      *   modify the new source that has been swapped in.
+     * - After this method returns, the internal state of the Track will be restored as if the
+     *   Track has been reconstructed with the previously loaded AudioSourceNode, and then start()
+     *   was called.
      * @param options swap parameters
      * @returns {Track} this Track
      */
@@ -257,10 +261,54 @@ declare class TrackSingle implements Track {
     private readonly audioContext;
     readonly destination: AudioNode;
     readonly source: AudioSourceNode;
+    /**
+     * The master gain for the track, it is exposed for automation
+     */
     private readonly gainNode;
+    /**
+     * Internal gain node for fading in/ out the primary source, for stopping and starting
+     */
+    private readonly gainPrimaryNode;
+    /**
+     * Internal gain node for fading in the secondary source, swapping primary sources
+     */
+    private readonly gainSecondaryNode;
+    /**
+     * Tracks the most recently loaded source, used in swaping/ starting
+     */
     private loadedSource?;
+    /**
+     * Tracks the playing source, on which automations and stopping effect
+     */
     private playingSource?;
+    /**
+     * Stores a position, in seconds, on which stop() will save the playhead
+     * position at the moment of activation, on which play() will resume from
+     */
+    private resumeMarker;
+    /**
+     * Stores the earliest scheduled stop time, used to disable the ability to call
+     * stop continuously with future times such that the underlying AudioSourceNode
+     * never reaches a stop time.
+     */
+    private nextStopTime;
+    /**
+     * Tracks whether or not the loadSource() method has previously been called,
+     * used by start() to determine if a swap() or plain start() will occur.
+     */
     private isLoadSourceCalled;
+    /**
+     * Implementation Notes:
+     * - If the given AudioSourceNode has outgoing connections, they will be disconnected at the
+     *   time this Track begins playback of the AudioSourceNode.
+     * - Providing an AudioSourceNode that is controlled by another Track has undefined behavior.
+     *   If you must reuse an AudioSourceNode that may be controlled by another Track, use the
+     *   clone() method to obtain a new node.
+     * @param name
+     * @param audioContext
+     * @param destination
+     * @param source
+     */
     constructor(name: string, audioContext: AudioContext, destination: AudioNode, source: AudioSourceNode);
     toString(): string;
     start(delay?: number, options?: AudioAdjustmentOptions, duration?: number): Track;
diff --git a/docs/js/lib/Track.js b/docs/js/lib/Track.js
index 1e08bc8..529da22 100644
--- a/docs/js/lib/Track.js
+++ b/docs/js/lib/Track.js
@@ -84,10 +84,54 @@ class TrackSingle {
     audioContext;
     destination;
     source;
+    /**
+     * The master gain for the track, it is exposed for automation
+     */
     gainNode;
+    /**
+     * Internal gain node for fading in/ out the primary source, for stopping and starting
+     */
+    gainPrimaryNode;
+    /**
+     * Internal gain node for fading in the secondary source, swapping primary sources
+     */
+    gainSecondaryNode;
+    /**
+     * Tracks the most recently loaded source, used in swaping/ starting
+     */
     loadedSource;
+    /**
+     * Tracks the playing source, on which automations and stopping effect
+     */
     playingSource;
+    /**
+     * Stores a position, in seconds, on which stop() will save the playhead
+     * position at the moment of activation, on which play() will resume from
+     */
+    resumeMarker = 0;
+    /**
+     * Stores the earliest scheduled stop time, used to disable the ability to call
+     * stop continuously with future times such that the underlying AudioSourceNode
+     * never reaches a stop time.
+     */
+    nextStopTime = 0;
+    /**
+     * Tracks whether or not the loadSource() method has previously been called,
+     * used by start() to determine if a swap() or plain start() will occur.
+     */
     isLoadSourceCalled = false;
+    /**
+     * Implementation Notes:
+     * - If the given AudioSourceNode has outgoing connections, they will be disconnected at the
+     *   time this Track begins playback of the AudioSourceNode.
+     * - Providing an AudioSourceNode that is controlled by another Track has undefined behavior.
+     *   If you must reuse an AudioSourceNode that may be controlled by another Track, use the
+     *   clone() method to obtain a new node.
+     * @param name
+     * @param audioContext
+     * @param destination
+     * @param source
+     */
     constructor(name, audioContext, destination, source) {
         this.name = name;
         this.audioContext = audioContext;
@@ -96,47 +140,79 @@ class TrackSingle {
         this.gainNode = audioContext.createGain();
         this.gainNode.connect(destination);
         this.loadedSource = source;
+        this.gainPrimaryNode = audioContext.createGain();
+        this.gainSecondaryNode = audioContext.createGain();
+        this.gainPrimaryNode.connect(this.gainNode);
+        this.gainSecondaryNode.connect(this.gainNode);
     }
     toString() {
         return `TrackSingle[${this.name}] with context ${this.audioContext} and source ${this.source}`;
     }
     start(delay, options, duration) {
         // Implicitly load a copy of the same source to call swap
-        if (this.playingSource && !this.loadedSource) {
+        if (this.playingSource?.isActive && !this.loadedSource) {
             this.loadedSource = this.playingSource.clone();
             this.isLoadSourceCalled = true;
         }
         // Swap after loading a source with loadSource()
-        if (this.isLoadSourceCalled && this.loadedSource) {
+        if (this.playingSource?.isActive && this.isLoadSourceCalled && this.loadedSource) {
             const swapOptions = buildOptions(options, defaults.trackSwapDefault);
-            this.swap(swapOptions); // resets isLoadSourceCalled and loadedSource
+            this.swap(swapOptions);
             if (duration != undefined) {
                 this.stop((options?.delay ?? delay ?? 0) + duration);
             }
             return this;
         }
+        const startOptions = buildOptions(options, defaults.startImmediate);
+        if (delay != undefined && options?.delay == undefined) {
+            startOptions.delay += delay;
+        }
+        // Move the loaded source into the playing source
         if (this.loadedSource) {
-            this.playingSource = this.loadedSource;
-            this.playingSource.connect(this.gainNode);
-            const startOptions = buildOptions(options, defaults.startImmediate);
-            if (delay != undefined && options?.delay == undefined) {
-                startOptions.delay += delay;
+            this.loadedSource.disconnect(); // claim the loadedSource
+            if (this.playingSource) {
+                const fadeOut = structuredClone(defaults.automationNatural);
+                this.playingSource.volume(0, fadeOut);
+                this.playingSource.stop(this._time + fadeOut.delay + fadeOut.duration);
+                setTimeout(this.playingSource.destroy, fadeOut.delay + fadeOut.duration);
             }
-            const currentGain = this.gainNode.gain.value;
-            this.gainNode.gain.value = 0;
-            this.playingSource.start(this._time + startOptions.delay);
+            this.playingSource = this.loadedSource;
+            this.gainPrimaryNode.gain.value = 0;
+            this.playingSource.connect(this.gainPrimaryNode);
             this.loadedSource = undefined;
-            automation(this.audioContext, this.gainNode.gain, currentGain, startOptions);
-            if (duration != undefined) {
-                this.stop(startOptions.delay + duration);
-            }
+        }
+        if (!this.playingSource) {
+            console.warn('Track.start() called with no source loaded. This is likely a mistake.');
             return this;
         }
-        console.warn('Track.start() called with no source loaded. This is likely a mistake.');
+        this.playingSource.start(this._time + startOptions.delay, this.resumeMarker);
+        automation(this.audioContext, this.gainPrimaryNode.gain, 1, startOptions, true);
+        this.nextStopTime = 0;
+        this.resumeMarker = 0;
+        if (duration != undefined) {
+            this.stop(startOptions.delay + duration);
+        }
         return this;
     }
     stop(delay, options) {
-        console.log(`stub stop with ${delay} seconds of delay with options ${options}`);
+        if (!this.playingSource?.isActive) {
+            return this;
+        }
+        const position = this.playingSource.position();
+        if (position != -1) {
+            this.resumeMarker = position;
+        }
+        console.log({ resumeMarker: this.resumeMarker });
+        const stopOptions = buildOptions(options, defaults.stopImmediate);
+        if (delay != undefined && options?.delay == undefined) {
+            stopOptions.delay += delay;
+        }
+        const scheduledStop = this._time + stopOptions.delay + stopOptions.duration;
+        if (this.nextStopTime == 0 || scheduledStop < this.nextStopTime) {
+            this.nextStopTime = scheduledStop;
+        }
+        this.playingSource.stop(this.nextStopTime);
+        automation(this.audioContext, this.gainPrimaryNode.gain, 0, stopOptions, true);
         return this;
     }
     playSource(path, options) {
@@ -151,6 +227,7 @@ class TrackSingle {
     }
     swap(options) {
         console.log(`stub swap with ${options}`);
+        this.loadedSource = undefined;
         return this;
     }
     volume(volume, options) {
@@ -338,4 +415,4 @@ class TrackGroup {
 }
 export default TrackSingle;
 export { TrackGroup };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Track.js","sourceRoot":"","sources":["../src/Track.ts"],"names":[],"mappings":"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"}
\ No newline at end of file
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Track.js","sourceRoot":"","sources":["../src/Track.ts"],"names":[],"mappings":"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"}
\ No newline at end of file
diff --git a/docs/js/lib/automation.d.ts b/docs/js/lib/automation.d.ts
index 70b2132..e7f286d 100644
--- a/docs/js/lib/automation.d.ts
+++ b/docs/js/lib/automation.d.ts
@@ -40,5 +40,16 @@ export type AudioAdjustmentOptions = {
 };
 /**
  * Automation function for AudioParam
+ *
+ * Set `skipImmediate` to `true` if you want the automation to play out in its entirety, even if
+ * the current value of the audioParam is at `value`. By default, the automation will cancel active
+ * automations, so in many cases playing the full duration of the automation is not needed.
+ *
+ * @param audioContext the audioContext from which to use as the time system
+ * @param audioParam the audioParam to automate
+ * @param value the value to automate towards
+ * @param options the method of automation
+ * @param skipImmediate if true, dont short the automation if the current value is already at the
+ *                      given value, allow the automation to play out.
  */
-export default function automation(audioContext: AudioContext, audioParam: AudioParam, value: number, options: Required<AudioAdjustmentOptions>): void;
+export default function automation(audioContext: AudioContext, audioParam: AudioParam, value: number, options: Required<AudioAdjustmentOptions>, skipImmediate?: boolean): void;
diff --git a/docs/js/lib/automation.js b/docs/js/lib/automation.js
index ba09c88..02c1195 100644
--- a/docs/js/lib/automation.js
+++ b/docs/js/lib/automation.js
@@ -21,19 +21,30 @@ export var AudioRampType;
 })(AudioRampType || (AudioRampType = {}));
 /**
  * Automation function for AudioParam
+ *
+ * Set `skipImmediate` to `true` if you want the automation to play out in its entirety, even if
+ * the current value of the audioParam is at `value`. By default, the automation will cancel active
+ * automations, so in many cases playing the full duration of the automation is not needed.
+ *
+ * @param audioContext the audioContext from which to use as the time system
+ * @param audioParam the audioParam to automate
+ * @param value the value to automate towards
+ * @param options the method of automation
+ * @param skipImmediate if true, dont short the automation if the current value is already at the
+ *                      given value, allow the automation to play out.
  */
-export default function automation(audioContext, audioParam, value, options) {
+export default function automation(audioContext, audioParam, value, options, skipImmediate = false) {
     const currentValue = audioParam.value;
     const difference = value - currentValue;
     // Stop automations and immediately ramp.
-    if (Math.abs(difference) < Number.EPSILON) {
-        audioParam.cancelAndHoldAtTime(audioContext.currentTime);
+    if (!skipImmediate && Math.abs(difference) < Number.EPSILON) {
         audioParam.setValueAtTime(currentValue, audioContext.currentTime);
+        audioParam.cancelAndHoldAtTime(audioContext.currentTime);
         audioParam.linearRampToValueAtTime(value, options.delay + audioContext.currentTime);
         return;
     }
-    audioParam.cancelAndHoldAtTime(options.delay + audioContext.currentTime);
     audioParam.setValueAtTime(currentValue, options.delay + audioContext.currentTime);
+    audioParam.cancelAndHoldAtTime(options.delay + audioContext.currentTime);
     if (Array.isArray(options.ramp)) {
         const valueCurve = [];
         for (const markiplier of options.ramp) {
@@ -42,6 +53,25 @@ export default function automation(audioContext, audioParam, value, options) {
         audioParam.setValueCurveAtTime(valueCurve, options.delay + audioContext.currentTime, options.duration);
         return;
     }
+    /**
+     * It is necessary to explain the function of exponential ramping:
+     *
+     * - Ramping from zero to any value is the same as using setValueAtTime()
+     * - Ramping from any value to zero is undefined
+     * - Ramping to values near zero have an instantaneous effect
+     *
+     * The only way to "exponentially" ramp to or away from zero is to use
+     * natural ramping; `setTargetAtTime()`. Therefore, an exponential ramp is
+     * converted to a natural ramp when the start or end is near zero.
+     *
+     * This conversion is done with the goal of being intuitive, as it may not
+     * be well understood that normal exponential ramping has these limitations.
+     */
+    if (options.ramp == AudioRampType.EXPONENTIAL &&
+        (Math.abs(currentValue) < Number.EPSILON || Math.abs(value) < Number.EPSILON)) {
+        options = structuredClone(options);
+        options.ramp = AudioRampType.NATURAL;
+    }
     switch (options.ramp) {
         case AudioRampType.EXPONENTIAL: {
             audioParam.exponentialRampToValueAtTime(value, options.delay + options.duration + audioContext.currentTime);
@@ -53,19 +83,22 @@ export default function automation(audioContext, audioParam, value, options) {
         }
         case AudioRampType.NATURAL: {
             // Logarithmic approach to value, it is 95% the way there after 3 timeConstant, so we linearly ramp at that point
-            const timeConstant = options.duration / 4;
+            const timeSteps = 4;
+            const timeConstant = options.duration / timeSteps;
             audioParam.setTargetAtTime(value, options.delay + audioContext.currentTime, timeConstant);
-            audioParam.cancelAndHoldAtTime(options.delay + timeConstant * 3 + audioContext.currentTime);
-            // The following event is implicitly added, per WebAudio spec.
+            audioParam.cancelAndHoldAtTime(timeConstant * (timeSteps - 1) + options.delay + audioContext.currentTime);
+            // ThE fOlLoWiNg EvEnT iS iMpLiCiTlY aDdEd, PeR wEbAuDiO SpEc.
             // https://webaudio.github.io/web-audio-api/#dom-audioparam-cancelandholdattime
-            // this.gainNode.gain.setValueAtTime(currentValue + (difference * (1 - Math.pow(Math.E, -3))), timeConstant * 3 + this.currentTime);
+            // https://www.youtube.com/watch?v=EzWNBmjyv7Y
+            audioParam.setValueAtTime(currentValue + difference * (1 - Math.pow(Math.E, -(timeSteps - 1))), timeConstant * (timeSteps - 1) + audioContext.currentTime);
             audioParam.linearRampToValueAtTime(value, options.delay + options.duration + audioContext.currentTime);
             break;
         }
         default: {
-            audioParam.setValueAtTime(value, options.delay);
+            console.warn(`Automation function received unknown ramp type ${options.ramp}`);
+            audioParam.setValueAtTime(value, options.delay + audioContext.currentTime);
             break;
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXV0b21hdGlvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy9hdXRvbWF0aW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFOLElBQVksYUFrQlg7QUFsQkQsV0FBWSxhQUFhO0lBQ3JCOztPQUVHO0lBQ0gsa0NBQWlCLENBQUE7SUFFakI7O09BRUc7SUFDSCw0Q0FBMkIsQ0FBQTtJQUUzQjs7Ozs7T0FLRztJQUNILG9DQUFtQixDQUFBO0FBQ3ZCLENBQUMsRUFsQlcsYUFBYSxLQUFiLGFBQWEsUUFrQnhCO0FBeUJEOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE9BQU8sVUFBVSxVQUFVLENBQzlCLFlBQTBCLEVBQzFCLFVBQXNCLEVBQ3RCLEtBQWEsRUFDYixPQUF5QztJQUV6QyxNQUFNLFlBQVksR0FBRyxVQUFVLENBQUMsS0FBSyxDQUFDO0lBQ3RDLE1BQU0sVUFBVSxHQUFHLEtBQUssR0FBRyxZQUFZLENBQUM7SUFFeEMseUNBQXlDO0lBQ3pDLElBQUksSUFBSSxDQUFDLEdBQUcsQ0FBQyxVQUFVLENBQUMsR0FBRyxNQUFNLENBQUMsT0FBTyxFQUFFLENBQUM7UUFDeEMsVUFBVSxDQUFDLG1CQUFtQixDQUFDLFlBQVksQ0FBQyxXQUFXLENBQUMsQ0FBQztRQUN6RCxVQUFVLENBQUMsY0FBYyxDQUFDLFlBQVksRUFBRSxZQUFZLENBQUMsV0FBVyxDQUFDLENBQUM7UUFDbEUsVUFBVSxDQUFDLHVCQUF1QixDQUFDLEtBQUssRUFBRSxPQUFPLENBQUMsS0FBSyxHQUFHLFlBQVksQ0FBQyxXQUFXLENBQUMsQ0FBQztRQUNwRixPQUFPO0lBQ1gsQ0FBQztJQUVELFVBQVUsQ0FBQyxtQkFBbUIsQ0FBQyxPQUFPLENBQUMsS0FBSyxHQUFHLFlBQVksQ0FBQyxXQUFXLENBQUMsQ0FBQztJQUN6RSxVQUFVLENBQUMsY0FBYyxDQUFDLFlBQVksRUFBRSxPQUFPLENBQUMsS0FBSyxHQUFHLFlBQVksQ0FBQyxXQUFXLENBQUMsQ0FBQztJQUNsRixJQUFJLEtBQUssQ0FBQyxPQUFPLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxFQUFFLENBQUM7UUFDOUIsTUFBTSxVQUFVLEdBQUcsRUFBRSxDQUFDO1FBQ3RCLEtBQUssTUFBTSxVQUFVLElBQUksT0FBTyxDQUFDLElBQUksRUFBRSxDQUFDO1lBQ3BDLFVBQVUsQ0FBQyxJQUFJLENBQUMsWUFBWSxHQUFHLFVBQVUsR0FBRyxVQUFVLENBQUMsQ0FBQztRQUM1RCxDQUFDO1FBQ0QsVUFBVSxDQUFDLG1CQUFtQixDQUMxQixVQUFVLEVBQ1YsT0FBTyxDQUFDLEtBQUssR0FBRyxZQUFZLENBQUMsV0FBVyxFQUN4QyxPQUFPLENBQUMsUUFBUSxDQUNuQixDQUFDO1FBQ0YsT0FBTztJQUNYLENBQUM7SUFFRCxRQUFRLE9BQU8sQ0FBQyxJQUFJLEVBQUUsQ0FBQztRQUNuQixLQUFLLGFBQWEsQ0FBQyxXQUFXLENBQUMsQ0FBQyxDQUFDO1lBQzdCLFVBQVUsQ0FBQyw0QkFBNEIsQ0FDbkMsS0FBSyxFQUNMLE9BQU8sQ0FBQyxLQUFLLEdBQUcsT0FBTyxDQUFDLFFBQVEsR0FBRyxZQUFZLENBQUMsV0FBVyxDQUM5RCxDQUFDO1lBQ0YsTUFBTTtRQUNWLENBQUM7UUFDRCxLQUFLLGFBQWEsQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUFDO1lBQ3hCLFVBQVUsQ0FBQyx1QkFBdUIsQ0FDOUIsS0FBSyxFQUNMLE9BQU8sQ0FBQyxLQUFLLEdBQUcsT0FBTyxDQUFDLFFBQVEsR0FBRyxZQUFZLENBQUMsV0FBVyxDQUM5RCxDQUFDO1lBQ0YsTUFBTTtRQUNWLENBQUM7UUFDRCxLQUFLLGFBQWEsQ0FBQyxPQUFPLENBQUMsQ0FBQyxDQUFDO1lBQ3pCLGlIQUFpSDtZQUNqSCxNQUFNLFlBQVksR0FBRyxPQUFPLENBQUMsUUFBUSxHQUFHLENBQUMsQ0FBQztZQUMxQyxVQUFVLENBQUMsZUFBZSxDQUFDLEtBQUssRUFBRSxPQUFPLENBQUMsS0FBSyxHQUFHLFlBQVksQ0FBQyxXQUFXLEVBQUUsWUFBWSxDQUFDLENBQUM7WUFDMUYsVUFBVSxDQUFDLG1CQUFtQixDQUFDLE9BQU8sQ0FBQyxLQUFLLEdBQUcsWUFBWSxHQUFHLENBQUMsR0FBRyxZQUFZLENBQUMsV0FBVyxDQUFDLENBQUM7WUFDNUYsOERBQThEO1lBQzlELCtFQUErRTtZQUMvRSxvSUFBb0k7WUFDcEksVUFBVSxDQUFDLHVCQUF1QixDQUM5QixLQUFLLEVBQ0wsT0FBTyxDQUFDLEtBQUssR0FBRyxPQUFPLENBQUMsUUFBUSxHQUFHLFlBQVksQ0FBQyxXQUFXLENBQzlELENBQUM7WUFDRixNQUFNO1FBQ1YsQ0FBQztRQUNELE9BQU8sQ0FBQyxDQUFDLENBQUM7WUFDTixVQUFVLENBQUMsY0FBYyxDQUFDLEtBQUssRUFBRSxPQUFPLENBQUMsS0FBSyxDQUFDLENBQUM7WUFDaEQsTUFBTTtRQUNWLENBQUM7SUFDTCxDQUFDO0FBQ0wsQ0FBQyJ9
\ No newline at end of file
+//# sourceMappingURL=data:application/json;base64,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
\ No newline at end of file
diff --git a/docs/js/lib/defaults.js b/docs/js/lib/defaults.js
index 19a8948..6aa67be 100644
--- a/docs/js/lib/defaults.js
+++ b/docs/js/lib/defaults.js
@@ -38,7 +38,10 @@ function buildOptions(options, defaultOptions) {
         return fullOptions;
     }
     const fullOptions = structuredClone(defaultOptions);
-    fullOptions.ramp = structuredClone(options.ramp);
+    // while required in typescript, javascript will let this be undefined
+    if (options.ramp) {
+        fullOptions.ramp = structuredClone(options.ramp);
+    }
     if (options.delay) {
         fullOptions.delay = options.delay;
     }
@@ -183,4 +186,4 @@ export const automationDefault = Object.freeze({
     delay: 0,
     duration: 1 / 711,
 });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVmYXVsdHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvZGVmYXVsdHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxFQUEwQixhQUFhLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQWN4RSxTQUFTLFlBQVksQ0FDakIsT0FBZ0csRUFDaEcsY0FBMkU7SUFFM0UsSUFBSSxNQUFNLElBQUksY0FBYyxFQUFFLENBQUM7UUFDM0IsT0FBTyxDQUFDLElBQUksQ0FDUixrR0FBa0c7WUFDOUYsNkRBQTZELENBQ3BFLENBQUM7SUFDTixDQUFDO0lBRUQsSUFBSSxDQUFDLE9BQU8sRUFBRSxDQUFDO1FBQ1gsT0FBTyxjQUFjLENBQUM7SUFDMUIsQ0FBQztJQUVELElBQUksV0FBVyxJQUFJLE9BQU8sRUFBRSxDQUFDO1FBQ3pCLElBQUksY0FBYyxJQUFJLENBQUMsQ0FBQyxXQUFXLElBQUksY0FBYyxDQUFDLEVBQUUsQ0FBQztZQUNyRCxPQUFPLENBQUMsSUFBSSxDQUNSLDhGQUE4RjtnQkFDMUYsZ0VBQWdFLENBQ3ZFLENBQUM7WUFDRixPQUFPLGNBQWMsQ0FBQztRQUMxQixDQUFDO1FBQ0QsT0FBTyxPQUFPLENBQUM7SUFDbkIsQ0FBQztJQUVELHVEQUF1RDtJQUN2RCxJQUFJLFdBQVcsSUFBSSxjQUFjLEVBQUUsQ0FBQztRQUNoQyxNQUFNLFdBQVcsR0FBRyxlQUFlLENBQUMsY0FBYyxDQUFDLENBQUM7UUFFcEQsV0FBVyxDQUFDLFNBQVMsQ0FBQyxJQUFJLEdBQUcsT0FBTyxDQUFDLElBQUksQ0FBQztRQUMxQyxXQUFXLENBQUMsU0FBUyxDQUFDLElBQUksR0FBRyxPQUFPLENBQUMsSUFBSSxDQUFDO1FBRTFDLElBQUksT0FBTyxDQUFDLFFBQVEsRUFBRSxDQUFDO1lBQ25CLE1BQU0sU0FBUyxHQUFHLFdBQVcsQ0FBQyxTQUFTLENBQUMsS0FBSyxHQUFHLFdBQVcsQ0FBQyxTQUFTLENBQUMsUUFBUSxDQUFDO1lBQy9FLE1BQU0sU0FBUyxHQUFHLFdBQVcsQ0FBQyxTQUFTLENBQUMsS0FBSyxHQUFHLFdBQVcsQ0FBQyxTQUFTLENBQUMsUUFBUSxDQUFDO1lBQy9FLE1BQU0sVUFBVSxHQUFHLFNBQVMsR0FBRyxTQUFTLENBQUM7WUFDekMsTUFBTSxVQUFVLEdBQ1osT0FBTyxDQUFDLFFBQVE7Z0JBQ2hCLENBQUMsVUFBVSxHQUFHLENBQUMsSUFBSSxJQUFJLENBQUMsR0FBRyxDQUFDLFVBQVUsQ0FBQyxHQUFHLE1BQU0sQ0FBQyxPQUFPLENBQUMsQ0FBQyxDQUFDLFNBQVMsQ0FBQyxDQUFDLENBQUMsU0FBUyxDQUFDLENBQUM7WUFDdEYsV0FBVyxDQUFDLFNBQVMsQ0FBQyxLQUFLLElBQUksVUFBVSxDQUFDO1lBQzFDLFdBQVcsQ0FBQyxTQUFTLENBQUMsUUFBUSxJQUFJLFVBQVUsQ0FBQztZQUM3QyxXQUFXLENBQUMsU0FBUyxDQUFDLEtBQUssSUFBSSxVQUFVLENBQUM7WUFDMUMsV0FBVyxDQUFDLFNBQVMsQ0FBQyxRQUFRLElBQUksVUFBVSxDQUFDO1FBQ2pELENBQUM7UUFFRCxJQUFJLE9BQU8sQ0FBQyxLQUFLLEVBQUUsQ0FBQztZQUNoQixXQUFXLENBQUMsU0FBUyxDQUFDLEtBQUssSUFBSSxPQUFPLENBQUMsS0FBSyxDQUFDO1lBQzdDLFdBQVcsQ0FBQyxTQUFTLENBQUMsS0FBSyxJQUFJLE9BQU8sQ0FBQyxLQUFLLENBQUM7UUFDakQsQ0FBQztRQUVELE9BQU8sV0FBVyxDQUFDO0lBQ3ZCLENBQUM7SUFFRCxNQUFNLFdBQVcsR0FBRyxlQUFlLENBQUMsY0FBYyxDQUFDLENBQUM7SUFFcEQsV0FBVyxDQUFDLElBQUksR0FBRyxlQUFlLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxDQUFDO0lBRWpELElBQUksT0FBTyxDQUFDLEtBQUssRUFBRSxDQUFDO1FBQ2hCLFdBQVcsQ0FBQyxLQUFLLEdBQUcsT0FBTyxDQUFDLEtBQUssQ0FBQztJQUN0QyxDQUFDO0lBRUQsSUFBSSxPQUFPLENBQUMsUUFBUSxFQUFFLENBQUM7UUFDbkIsV0FBVyxDQUFDLFFBQVEsR0FBRyxPQUFPLENBQUMsUUFBUSxDQUFDO0lBQzVDLENBQUM7SUFFRCxJQUFJLE1BQU0sSUFBSSxPQUFPLEVBQUUsQ0FBQztRQUNwQixPQUFPLENBQUMsSUFBSSxDQUNSLHNGQUFzRjtZQUNsRixnRUFBZ0UsQ0FDdkUsQ0FBQztJQUNOLENBQUM7SUFFRCxPQUFPLFdBQVcsQ0FBQztBQUN2QixDQUFDO0FBRUQsZUFBZSxZQUFZLENBQUM7QUFFNUI7O0dBRUc7QUFDSCxNQUFNLENBQUMsTUFBTSxjQUFjLEdBQTZCLE1BQU0sQ0FBQyxNQUFNLENBQUM7SUFDbEUsU0FBUyxFQUFFLE1BQU0sQ0FBQyxNQUFNLENBQUM7UUFDckIsSUFBSSxFQUFFLGFBQWEsQ0FBQyxPQUFPO1FBQzNCLEtBQUssRUFBRSxDQUFDO1FBQ1IsUUFBUSxFQUFFLEdBQUc7S0FDaEIsQ0FBQztJQUNGLFNBQVMsRUFBRSxNQUFNLENBQUMsTUFBTSxDQUFDO1FBQ3JCLElBQUksRUFBRSxhQUFhLENBQUMsT0FBTztRQUMzQixLQUFLLEVBQUUsQ0FBQztRQUNSLFFBQVEsRUFBRSxHQUFHO0tBQ2hCLENBQUM7Q0FDTCxDQUFDLENBQUM7QUFFSDs7R0FFRztBQUNILE1BQU0sQ0FBQyxNQUFNLGNBQWMsR0FBNkIsTUFBTSxDQUFDLE1BQU0sQ0FBQztJQUNsRSxTQUFTLEVBQUUsTUFBTSxDQUFDLE1BQU0sQ0FBQztRQUNyQixJQUFJLEVBQUUsYUFBYSxDQUFDLE9BQU87UUFDM0IsS0FBSyxFQUFFLENBQUM7UUFDUixRQUFRLEVBQUUsQ0FBQztLQUNkLENBQUM7SUFDRixTQUFTLEVBQUUsTUFBTSxDQUFDLE1BQU0sQ0FBQztRQUNyQixJQUFJLEVBQUUsYUFBYSxDQUFDLE9BQU87UUFDM0IsS0FBSyxFQUFFLEdBQUc7UUFDVixRQUFRLEVBQUUsQ0FBQztLQUNkLENBQUM7Q0FDTCxDQUFDLENBQUM7QUFFSDs7R0FFRztBQUNILE1BQU0sQ0FBQyxNQUFNLGNBQWMsR0FBNkIsTUFBTSxDQUFDLE1BQU0sQ0FBQztJQUNsRSxTQUFTLEVBQUUsTUFBTSxDQUFDLE1BQU0sQ0FBQztRQUNyQixJQUFJLEVBQUUsYUFBYSxDQUFDLE9BQU87UUFDM0IsS0FBSyxFQUFFLENBQUM7UUFDUixRQUFRLEVBQUUsR0FBRztLQUNoQixDQUFDO0lBQ0YsU0FBUyxFQUFFLE1BQU0sQ0FBQyxNQUFNLENBQUM7UUFDckIsSUFBSSxFQUFFLGFBQWEsQ0FBQyxPQUFPO1FBQzNCLEtBQUssRUFBRSxDQUFDO1FBQ1IsUUFBUSxFQUFFLEdBQUc7S0FDaEIsQ0FBQztDQUNMLENBQUMsQ0FBQztBQUVIOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sWUFBWSxHQUE2QixNQUFNLENBQUMsTUFBTSxDQUFDO0lBQ2hFLFNBQVMsRUFBRSxNQUFNLENBQUMsTUFBTSxDQUFDO1FBQ3JCLElBQUksRUFBRSxhQUFhLENBQUMsT0FBTztRQUMzQixLQUFLLEVBQUUsQ0FBQztRQUNSLFFBQVEsRUFBRSxDQUFDLEdBQUcsS0FBSztLQUN0QixDQUFDO0lBQ0YsU0FBUyxFQUFFLE1BQU0sQ0FBQyxNQUFNLENBQUM7UUFDckIsSUFBSSxFQUFFLGFBQWEsQ0FBQyxPQUFPO1FBQzNCLEtBQUssRUFBRSxDQUFDO1FBQ1IsUUFBUSxFQUFFLENBQUMsR0FBRyxLQUFLO0tBQ3RCLENBQUM7Q0FDTCxDQUFDLENBQUM7QUFFSDs7R0FFRztBQUNILE1BQU0sQ0FBQyxNQUFNLGdCQUFnQixHQUE2QixNQUFNLENBQUMsTUFBTSxDQUFDO0lBQ3BFLFNBQVMsRUFBRSxNQUFNLENBQUMsTUFBTSxDQUFDO1FBQ3JCLElBQUksRUFBRSxhQUFhLENBQUMsT0FBTztRQUMzQixLQUFLLEVBQUUsQ0FBQztRQUNSLFFBQVEsRUFBRSxHQUFHO0tBQ2hCLENBQUM7SUFDRixTQUFTLEVBQUUsTUFBTSxDQUFDLE1BQU0sQ0FBQztRQUNyQixJQUFJLEVBQUUsYUFBYSxDQUFDLE9BQU87UUFDM0IsS0FBSyxFQUFFLENBQUM7UUFDUixRQUFRLEVBQUUsR0FBRztLQUNoQixDQUFDO0NBQ0wsQ0FBQyxDQUFDO0FBRUg7O0dBRUc7QUFDSCxNQUFNLENBQUMsTUFBTSxjQUFjLEdBQXFDLE1BQU0sQ0FBQyxNQUFNLENBQUM7SUFDMUUsSUFBSSxFQUFFLGFBQWEsQ0FBQyxXQUFXO0lBQy9CLEtBQUssRUFBRSxDQUFDO0lBQ1IsUUFBUSxFQUFFLENBQUMsR0FBRyxHQUFHO0NBQ3BCLENBQUMsQ0FBQztBQUVIOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sYUFBYSxHQUFxQyxNQUFNLENBQUMsTUFBTSxDQUFDO0lBQ3pFLElBQUksRUFBRSxhQUFhLENBQUMsV0FBVztJQUMvQixLQUFLLEVBQUUsQ0FBQztJQUNSLFFBQVEsRUFBRSxDQUFDLEdBQUcsS0FBSztDQUN0QixDQUFDLENBQUM7QUFFSDs7R0FFRztBQUNILE1BQU0sQ0FBQyxNQUFNLG1CQUFtQixHQUFxQyxNQUFNLENBQUMsTUFBTSxDQUFDO0lBQy9FLElBQUksRUFBRSxhQUFhLENBQUMsT0FBTztJQUMzQixLQUFLLEVBQUUsQ0FBQztJQUNSLFFBQVEsRUFBRSxDQUFDLEdBQUcsR0FBRztDQUNwQixDQUFDLENBQUM7QUFFSDs7R0FFRztBQUNILE1BQU0sQ0FBQyxNQUFNLGdCQUFnQixHQUFxQyxNQUFNLENBQUMsTUFBTSxDQUFDO0lBQzVFLElBQUksRUFBRSxhQUFhLENBQUMsTUFBTTtJQUMxQixLQUFLLEVBQUUsQ0FBQztJQUNSLFFBQVEsRUFBRSxDQUFDO0NBQ2QsQ0FBQyxDQUFDO0FBRUg7O0dBRUc7QUFDSCxNQUFNLENBQUMsTUFBTSxxQkFBcUIsR0FBcUMsTUFBTSxDQUFDLE1BQU0sQ0FBQztJQUNqRixJQUFJLEVBQUUsYUFBYSxDQUFDLFdBQVc7SUFDL0IsS0FBSyxFQUFFLENBQUM7SUFDUixRQUFRLEVBQUUsR0FBRztDQUNoQixDQUFDLENBQUM7QUFFSDs7R0FFRztBQUNILE1BQU0sQ0FBQyxNQUFNLGlCQUFpQixHQUFxQyxNQUFNLENBQUMsTUFBTSxDQUFDO0lBQzdFLElBQUksRUFBRSxhQUFhLENBQUMsT0FBTztJQUMzQixLQUFLLEVBQUUsQ0FBQztJQUNSLFFBQVEsRUFBRSxJQUFJO0NBQ2pCLENBQUMsQ0FBQztBQUVIOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0saUJBQWlCLEdBQXFDLE1BQU0sQ0FBQyxNQUFNLENBQUM7SUFDN0UsSUFBSSxFQUFFLGFBQWEsQ0FBQyxPQUFPO0lBQzNCLEtBQUssRUFBRSxDQUFDO0lBQ1IsUUFBUSxFQUFFLENBQUMsR0FBRyxHQUFHO0NBQ3BCLENBQUMsQ0FBQyJ9
\ No newline at end of file
+//# sourceMappingURL=data:application/json;base64,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
\ No newline at end of file
diff --git a/package.json b/package.json
index a8e3216..4fde15b 100644
--- a/package.json
+++ b/package.json
@@ -8,7 +8,7 @@
     },
     "scripts": {
         "build": "npm run format && tsc -b && npm run copyDistToDocs",
-        "start": "onchange --await-write-finish 1000 \"src/**/*.ts\" \"src/**/*.js\" -- npm run build",
+        "start": "onchange --await-write-finish 1500 \"src/**/*.ts\" \"src/**/*.js\" -- npm run build",
         "format": "prettier src/**/*.ts src/**/*.js test/**/*.ts test/**/*.js --write",
         "copyDistToDocs": "xcopy .\\dist\\*.js .\\docs\\js\\lib /e /y /v /i /f && xcopy .\\dist\\*.d.ts .\\docs\\js\\lib /e /y /v /i /f",
         "test": "node test/build/index.js"