@jadujoel/web-audio-clip-node 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Joel Löf
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,91 @@
+# @jadujoel/web-audio-clip-node
+
+Full-featured AudioWorklet-based audio clip player for the Web Audio API.
+
+## Features
+
+- Playback rate control (-2x to 2x, including reverse)
+- Detune (-2400 to +2400 cents)
+- Gain (dB scale with equal-power curves)
+- Stereo pan
+- Highpass / lowpass filters
+- Loop with crossfade
+- Fade in / fade out
+- Streaming buffer support
+- Offset & duration control
+- React components & hooks (optional)
+
+## Install
+
+```sh
+npm install @jadujoel/web-audio-clip-node
+```
+
+## Quick Start (Core API)
+
+```ts
+import { ClipNode, getProcessorBlobUrl } from "@jadujoel/web-audio-clip-node";
+
+const ctx = new AudioContext();
+await ctx.audioWorklet.addModule(getProcessorBlobUrl());
+
+const clip = new ClipNode(ctx, {
+  processorOptions: { sampleRate: ctx.sampleRate },
+});
+clip.connect(ctx.destination);
+
+const response = await fetch("audio.mp3");
+const buffer = await ctx.decodeAudioData(await response.arrayBuffer());
+clip.buffer = buffer;
+clip.start();
+```
+
+## Quick Start (React)
+
+```tsx
+import { useClipNode, useClipControls, TransportButtons, AudioControl } from "@jadujoel/web-audio-clip-node/react";
+import "@jadujoel/web-audio-clip-node/styles.css";
+
+function Player() {
+  const controls = useClipControls();
+  const clip = useClipNode({ ...controls });
+  return (
+    <>
+      <TransportButtons />
+      <AudioControl />
+    </>
+  );
+}
+```
+
+## CDN Usage (No Bundler)
+
+```html
+<script type="module">
+  const ctx = new AudioContext();
+  await ctx.audioWorklet.addModule(
+    "https://cdn.jsdelivr.net/npm/@jadujoel/web-audio-clip-node@0.1.0/dist/processor.js"
+  );
+</script>
+```
+
+## Processor Loading Options
+
+| Method | Function | Use case |
+|--------|----------|----------|
+| Blob URL (default) | `getProcessorBlobUrl()` | Zero-config, works everywhere |
+| CDN | `getProcessorCdnUrl("0.1.0")` | No bundler / script-tag usage |
+| Self-hosted | `getProcessorModuleUrl(baseUrl)` | You serve `processor.js` yourself |
+
+## Exports
+
+| Entry point | Import path | Contents |
+|-------------|-------------|----------|
+| Core | `@jadujoel/web-audio-clip-node` | `ClipNode`, types, utils, controls, processor kernel |
+| React | `@jadujoel/web-audio-clip-node/react` | Store, hooks, UI components |
+| Processor | `@jadujoel/web-audio-clip-node/processor` | Standalone worklet script |
+| Styles | `@jadujoel/web-audio-clip-node/styles.css` | CSS for React components |
+
+## License
+
+MIT

package/dist/audio/ClipNode.d.ts

@@ -0,0 +1,86 @@
+import type { ClipNodeState, ClipWorkletOptions, FrameData } from "./types";
+export declare class ClipNode extends AudioWorkletNode {
+    onscheduled?: () => void;
+    onstarted?: () => void;
+    onpaused?: () => void;
+    onresumed?: () => void;
+    onended?: () => void;
+    onlooped?: () => void;
+    onstopped?: () => void;
+    onframe?: (data: FrameData) => void;
+    ondisposed?: () => void;
+    onstatechange?: (state: ClipNodeState) => void;
+    private _buffer?;
+    private _loopStart;
+    private _loopEnd;
+    private _loop;
+    private _offset;
+    private _playhead;
+    private _fadeIn;
+    private _fadeOut;
+    private _loopCrossfade;
+    private _duration;
+    private _previousState;
+    private _bufferWriteCursor;
+    timesLooped: number;
+    state: ClipNodeState;
+    cpu: number;
+    constructor(context: BaseAudioContext, options?: ClipWorkletOptions);
+    private handleMessage;
+    private setState;
+    toggleGain(value?: boolean): void;
+    togglePlaybackRate(value?: boolean): void;
+    toggleDetune(value?: boolean): void;
+    togglePan(value?: boolean): void;
+    toggleHighpass(value?: boolean): void;
+    toggleLowpass(value?: boolean): void;
+    toggleFadeIn(value?: boolean): void;
+    toggleFadeOut(value?: boolean): void;
+    toggleLoopCrossfade(value?: boolean): void;
+    toggleLoopStart(value?: boolean): void;
+    toggleLoopEnd(value?: boolean): void;
+    logState(): void;
+    get buffer(): AudioBuffer | undefined;
+    set buffer(ab: AudioBuffer);
+    initializeBuffer(totalLength: number, channels: number, options?: {
+        streaming?: boolean;
+    }): void;
+    replaceBufferRange(startSample: number, channelData: Float32Array[], options?: {
+        totalLength?: number | null;
+        streamEnded?: boolean;
+    }): void;
+    appendBufferRange(channelData: Float32Array[], options?: {
+        totalLength?: number | null;
+        streamEnded?: boolean;
+    }): void;
+    finalizeBuffer(totalLength?: number): void;
+    start(when?: number, offset?: number, duration?: number): void;
+    stop(when?: number, initialDelay?: number): void;
+    pause(when?: number): void;
+    resume(when?: number): void;
+    get loop(): boolean;
+    set loop(value: boolean);
+    get loopStart(): number;
+    set loopStart(value: number);
+    get loopEnd(): number;
+    set loopEnd(value: number);
+    get duration(): number;
+    set duration(value: number);
+    get offset(): number;
+    set offset(value: number);
+    get playhead(): number;
+    set playhead(value: number);
+    get playbackRate(): AudioParam;
+    get detune(): AudioParam;
+    get highpass(): AudioParam;
+    get lowpass(): AudioParam;
+    get gain(): AudioParam;
+    get pan(): AudioParam;
+    get fadeIn(): number;
+    set fadeIn(value: number);
+    get fadeOut(): number;
+    set fadeOut(value: number);
+    get loopCrossfade(): number;
+    set loopCrossfade(value: number);
+    dispose(): void;
+}

package/dist/audio/processor-code.d.ts

@@ -0,0 +1 @@
+export declare const processorCode = "var z={Initial:0,Started:1,Stopped:2,Paused:3,Scheduled:4,Ended:5,Disposed:6};var y=128;function i(V=[]){let A=V[0]?.length??0,F=A>0;return{totalLength:F?A:null,committedLength:F?A:0,streamEnded:F,streaming:!1,writtenSpans:F?[{startSample:0,endSample:A}]:[],pendingWrites:[],lowWaterThreshold:y*4,lowWaterNotified:!1,lastUnderrunSample:null}}function M0(V){return V[0]?.length??0}function o(V){return V.streamBuffer.totalLength??M0(V.buffer)}function G0(V,A){return Array.from({length:V},()=>new Float32Array(A))}function E0(V,A){let F=[...V,A].sort((Q,J)=>Q.startSample-J.startSample),T=[];for(let Q of F){let J=T[T.length-1];if(!J||Q.startSample>J.endSample){T.push({...Q});continue}J.endSample=Math.max(J.endSample,Q.endSample)}return T}function I0(V){let A=0;for(let F of V){if(F.startSample>A)break;A=Math.max(A,F.endSample)}return A}function w0(V,A){if(V.committedLength-Math.floor(A)>=V.lowWaterThreshold)V.lowWaterNotified=!1}function R0(V,A,F){let T=M0(V.buffer),Q=V.buffer.length;if(T>=F&&Q>=A)return;let J=Math.max(T,F),U=Math.max(Q,A),Y=G0(U,J);for(let X=0;X<Q;X++)Y[X].set(V.buffer[X].subarray(0,T));if(V.buffer=Y,V.streamBuffer.totalLength==null||V.streamBuffer.totalLength<J)V.streamBuffer.totalLength=J}function B0(V,A){let F=Math.max(Math.floor(A.startSample),0),T=A.channelData[0]?.length??0,Q=A.totalLength??null,J=Math.max(F+T,Q??0);R0(V,Math.max(A.channelData.length,V.buffer.length,1),J);for(let U=0;U<A.channelData.length;U++)V.buffer[U].set(A.channelData[U],F);if(Q!=null)V.streamBuffer.totalLength=Q;if(T>0)V.streamBuffer.writtenSpans=E0(V.streamBuffer.writtenSpans,{startSample:F,endSample:F+T}),V.streamBuffer.committedLength=I0(V.streamBuffer.writtenSpans);if(A.streamEnded===!0)V.streamBuffer.streamEnded=!0;w0(V.streamBuffer,V.playhead)}function _0(V){if(V.streamBuffer.pendingWrites.length===0)return;for(let A of V.streamBuffer.pendingWrites)B0(V,A);V.streamBuffer.pendingWrites=[]}function y0(V,A){V.buffer=A,V.streamBuffer=i(A)}function v0(V={},A){let{buffer:F=[],streamBuffer:T=i(F),duration:Q=-1,loop:J=!1,loopStart:U=0,loopEnd:Y=(F[0]?.length??0)/A,loopCrossfade:X=0,playhead:k=0,offset:H=0,startWhen:$=0,stopWhen:j=0,pauseWhen:P=0,resumeWhen:C=0,playedSamples:N=0,state:K=z.Initial,timesLooped:w=0,fadeInDuration:v=0,fadeOutDuration:Z=0,enableFadeIn:E=v>0,enableFadeOut:O=Z>0,enableLoopStart:R=!0,enableLoopEnd:h=!0,enableLoopCrossfade:b=X>0,enableHighpass:c=!0,enableLowpass:g=!0,enableGain:s=!0,enablePan:r=!0,enableDetune:t=!0,enablePlaybackRate:p=!0}=V;return{buffer:F,streamBuffer:T,loop:J,loopStart:U,loopEnd:Y,loopCrossfade:X,duration:Q,playhead:k,offset:H,startWhen:$,stopWhen:j,pauseWhen:P,resumeWhen:C,playedSamples:N,state:K,timesLooped:w,fadeInDuration:v,fadeOutDuration:Z,enableFadeIn:E,enableFadeOut:O,enableLoopStart:R,enableLoopEnd:h,enableHighpass:c,enableLowpass:g,enableGain:s,enablePan:r,enableDetune:t,enablePlaybackRate:p,enableLoopCrossfade:b}}function b0(V,A){return o(V)/A}function n(V,A){let F=b0(V,A);if(F<=0){V.loopStart=0,V.loopEnd=0;return}if(!Number.isFinite(V.loopStart)||V.loopStart<0)V.loopStart=0;if(V.loopStart>=F)V.loopStart=0;if(!Number.isFinite(V.loopEnd)||V.loopEnd<=V.loopStart||V.loopEnd>F)V.loopEnd=F}function e(V,A,F){if(A===void 0)return V.offset=0,0;if(A<0)return e(V,o(V)+A,F);if(A>(o(V)||1)-1)return e(V,o(V)%A,F);let T=Math.floor(A*F);return V.offset=T,T}function L0(V){let{playhead:A,bufferLength:F,loop:T,loopStartSamples:Q,loopEndSamples:J}=V,U=128;if(!T&&A+128>F)U=Math.max(F-A,0);let Y=Array(U);if(!T){for(let $=0,j=A;$<U;$++,j++)Y[$]=j;let H=A+U;return{playhead:H,indexes:Y,looped:!1,ended:H>=F}}let X=A,k=!1;for(let H=0;H<U;H++,X++){if(X>=J)X=Q+(X-J),k=!0;Y[H]=X}return{indexes:Y,looped:k,ended:!1,playhead:X}}function x0(V){let{playhead:A,bufferLength:F,loop:T,loopStartSamples:Q,loopEndSamples:J,playbackRates:U}=V,Y=128;if(!T&&A+128>F)Y=Math.max(F-A,0);let X=Array(Y),k=A,H=!1;if(T){for(let $=0;$<Y;$++){X[$]=Math.min(Math.max(Math.floor(k),0),F-1);let j=U[$]??U[0]??1;if(k+=j,j>=0&&(k>J||k>F))k=Q,H=!0;else if(j<0&&(k<Q||k<0))k=J,H=!0}return{playhead:k,indexes:X,looped:H,ended:!1}}for(let $=0;$<Y;$++)X[$]=Math.min(Math.max(Math.floor(k),0),F-1),k+=U[$]??U[0]??1;return{playhead:k,indexes:X,looped:!1,ended:k>=F||k<0}}function m0(V,A,F){for(let T=0;T<F.length;T++)for(let Q=0;Q<V.length;Q++)V[Q][T]=A[Q][F[T]];for(let T=F.length;T<V[0].length;T++)for(let Q=0;Q<V.length;Q++)V[Q][T]=0}function d(V){for(let A=0;A<V.length;A++)for(let F=0;F<V[A].length;F++)V[A][F]=0}function S0(V){let A=new Float32Array(V[0].length);for(let F=0;F<V[0].length;F++)A[F]=V[0][F];V.push(A)}function H0(V,A){for(let F=A.length;F<V.length;F++)A[F]=new Float32Array(V[F].length);for(let F=0;F<V.length;F++)for(let T=0;T<V[F].length;T++)A[F][T]=V[F][T]}function c0(V){let A=0;for(let F=0;F<V.length;F++)for(let T=0;T<V[F].length;T++)if(Number.isNaN(V[F][T]))A++,V[F][T]=0;return A}function V0(){return[{x_1:0,x_2:0,y_1:0,y_2:0},{x_1:0,x_2:0,y_1:0,y_2:0}]}function g0(V,A){if(A.length===1){let T=A[0];if(T===1)return;for(let Q of V)for(let J=0;J<Q.length;J++)Q[J]*=T;return}let F=A[0];for(let T of V)for(let Q=0;Q<T.length;Q++)F=A[Q]??F,T[Q]*=F}function d0(V,A){let F=A[0];for(let T=0;T<V[0].length;T++){F=A[T]??F;let Q=F<=0?1:1-F,J=F>=0?1:1+F;V[0][T]*=Q,V[1][T]*=J}}function h0(V,A,F,T){for(let Q=0;Q<V.length;Q++){let J=V[Q],{x_1:U,x_2:Y,y_1:X,y_2:k}=T[Q]??{x_1:0,x_2:0,y_1:0,y_2:0};if(A.length===1){let H=A[0];if(H>=20000)return;let $=2*Math.PI*H/F,j=Math.sin($)/2,P=(1-Math.cos($))/2,C=1-Math.cos($),N=(1-Math.cos($))/2,K=1+j,w=-2*Math.cos($),v=1-j,Z=P/K,E=C/K,O=N/K,R=w/K,h=v/K;for(let b=0;b<J.length;b++){let c=J[b],g=Z*c+E*U+O*Y-R*X-h*k;Y=U,U=c,k=X,X=g,J[b]=g}}else{let H=A[0];for(let $=0;$<J.length;$++){let j=A[$]??H,P=2*Math.PI*j/F,C=Math.sin(P)/2,N=(1-Math.cos(P))/2,K=1-Math.cos(P),w=(1-Math.cos(P))/2,v=1+C,Z=-2*Math.cos(P),E=1-C,O=J[$],R=N/v*O+K/v*U+w/v*Y-Z/v*X-E/v*k;Y=U,U=O,k=X,X=R,J[$]=R}}T[Q]={x_1:U,x_2:Y,y_1:X,y_2:k}}}function l0(V,A,F,T){for(let Q=0;Q<V.length;Q++){let J=V[Q],{x_1:U,x_2:Y,y_1:X,y_2:k}=T[Q]??{x_1:0,x_2:0,y_1:0,y_2:0};if(A.length===1){let H=A[0];if(H<=20)return;let $=2*Math.PI*H/F,j=Math.sin($)/2,P=(1+Math.cos($))/2,C=-(1+Math.cos($)),N=(1+Math.cos($))/2,K=1+j,w=-2*Math.cos($),v=1-j;for(let Z=0;Z<J.length;Z++){let E=J[Z],O=P/K*E+C/K*U+N/K*Y-w/K*X-v/K*k;Y=U,U=E,k=X,X=O,J[Z]=O}}else{let H=A[0];for(let $=0;$<J.length;$++){let j=A[$]??H,P=2*Math.PI*j/F,C=Math.sin(P)/2,N=(1+Math.cos(P))/2,K=-(1+Math.cos(P)),w=(1+Math.cos(P))/2,v=1+C,Z=-2*Math.cos(P),E=1-C,O=J[$],R=N/v*O+K/v*U+w/v*Y-Z/v*X-E/v*k;Y=U,U=O,k=X,X=R,J[$]=R}}T[Q]={x_1:U,x_2:Y,y_1:X,y_2:k}}}function z0(V,A,F,T){let{type:Q,data:J}=A;switch(Q){case\"buffer\":return y0(V,J),n(V,T),[];case\"bufferInit\":{let U=J;return V.buffer=G0(U.channels,U.totalLength),V.streamBuffer={...i(),totalLength:U.totalLength,streamEnded:!1,streaming:U.streaming??!0},n(V,T),[]}case\"bufferRange\":return V.streamBuffer.pendingWrites.push(J),[];case\"bufferEnd\":{let U=J;if(U?.totalLength!=null)V.streamBuffer.totalLength=U.totalLength;return V.streamBuffer.streamEnded=!0,[]}case\"bufferReset\":return V.buffer=[],V.streamBuffer=i(),n(V,T),[];case\"start\":V.timesLooped=0;{let U=J;if(V.duration=U?.duration??-1,V.duration===-1)V.duration=V.loop?Number.MAX_SAFE_INTEGER:(V.buffer[0]?.length??0)/T;e(V,U?.offset,T),n(V,T),V.playhead=V.offset,V.startWhen=U?.when??F,V.stopWhen=V.startWhen+V.duration,V.playedSamples=0,V.state=z.Scheduled}return[{type:\"scheduled\"}];case\"stop\":if(V.state===z.Ended||V.state===z.Initial)return[];return V.stopWhen=J??V.stopWhen,V.state=z.Stopped,[{type:\"stopped\"}];case\"pause\":return V.state=z.Paused,V.pauseWhen=J??F,[{type:\"paused\"}];case\"resume\":return V.state=z.Started,V.startWhen=J??F,[{type:\"resume\"}];case\"dispose\":return V.state=z.Disposed,V.buffer=[],V.streamBuffer=i(),[{type:\"disposed\"}];case\"loop\":{let U=J,Y=V.state;if(U&&(Y===z.Scheduled||Y===z.Started))V.stopWhen=Number.MAX_SAFE_INTEGER,V.duration=Number.MAX_SAFE_INTEGER;if(V.loop=U,U)n(V,T);return[]}case\"loopStart\":return V.loopStart=J,[];case\"loopEnd\":return V.loopEnd=J,[];case\"loopCrossfade\":return V.loopCrossfade=J,[];case\"playhead\":return V.playhead=Math.floor(J),[];case\"fadeIn\":return V.fadeInDuration=J,[];case\"fadeOut\":return V.fadeOutDuration=J,[];case\"toggleGain\":return V.enableGain=J??!V.enableGain,[];case\"togglePan\":return V.enablePan=J??!V.enablePan,[];case\"toggleLowpass\":return V.enableLowpass=J??!V.enableLowpass,[];case\"toggleHighpass\":return V.enableHighpass=J??!V.enableHighpass,[];case\"toggleDetune\":return V.enableDetune=J??!V.enableDetune,[];case\"togglePlaybackRate\":return V.enablePlaybackRate=J??!V.enablePlaybackRate,[];case\"toggleFadeIn\":return V.enableFadeIn=J??!V.enableFadeIn,[];case\"toggleFadeOut\":return V.enableFadeOut=J??!V.enableFadeOut,[];case\"toggleLoopStart\":return V.enableLoopStart=J??!V.enableLoopStart,[];case\"toggleLoopEnd\":return V.enableLoopEnd=J??!V.enableLoopEnd,[];case\"toggleLoopCrossfade\":return V.enableLoopCrossfade=J??!V.enableLoopCrossfade,[];case\"logState\":return[]}return[]}function j0(V,A,F,T,Q){let J=[],U=V.state;if(U===z.Disposed)return{keepAlive:!1,messages:J};if(_0(V),U===z.Initial)return{keepAlive:!0,messages:J};if(U===z.Ended)return d(A[0]),{keepAlive:!0,messages:J};if(U===z.Scheduled)if(T.currentTime>=V.startWhen)U=V.state=z.Started,J.push({type:\"started\"});else return d(A[0]),{keepAlive:!0,messages:J};else if(U===z.Paused){if(T.currentTime>V.pauseWhen)return d(A[0]),{keepAlive:!0,messages:J}}if(T.currentTime>V.stopWhen)return d(A[0]),V.state=z.Ended,J.push({type:\"ended\"}),V.playedSamples=0,{keepAlive:!0,messages:J};let Y=A[0],X=o(V);if(X===0)return d(Y),{keepAlive:!0,messages:J};let{playbackRate:k,detune:H,lowpass:$,highpass:j,gain:P,pan:C}=F,{buffer:N,loopStart:K,loopEnd:w,loopCrossfade:v,stopWhen:Z,playedSamples:E,enableLowpass:O,enableHighpass:R,enableGain:h,enablePan:b,enableDetune:c,enableFadeOut:g,enableFadeIn:s,enableLoopStart:r,enableLoopEnd:t,enableLoopCrossfade:p,playhead:D,fadeInDuration:A0,fadeOutDuration:F0}=V,K0=V.streamBuffer.streaming&&V.streamBuffer.committedLength<X,T0=V.loop&&!K0,l=Math.min(N.length,Y.length),W0=V.duration*T.sampleRate,Z0=Math.floor(T.sampleRate*v),q0=Math.max(X-y,0),L=r?Math.min(Math.floor(K*T.sampleRate),q0):0,x=t?Math.min(Math.floor(w*T.sampleRate),X):X,N0=x-L,J0=c&&H.length>0&&H[0]!==0,u=k;if(J0){let M=Math.max(k.length,H.length,y);u=new Float32Array(M);for(let W=0;W<M;W++){let I=k[W]??k[k.length-1],G=H[W]??H[H.length-1];u[W]=I*2**(G/1200)}}let Q0=V.enablePlaybackRate||J0,O0=Q0&&u.length>0&&u.every((M)=>M===0);if(V.streamBuffer.streaming&&!V.streamBuffer.streamEnded&&!V.streamBuffer.lowWaterNotified&&V.streamBuffer.committedLength-Math.floor(D)<V.streamBuffer.lowWaterThreshold)J.push({type:\"bufferLowWater\",data:{playhead:Math.floor(D),committedLength:V.streamBuffer.committedLength}}),V.streamBuffer.lowWaterNotified=!0;if(O0){d(Y);for(let M=1;M<A.length;M++)H0(Y,A[M]);return{keepAlive:!0,messages:J}}let U0={bufferLength:X,loop:T0,playhead:D,loopStartSamples:L,loopEndSamples:x,durationSamples:W0,playbackRates:u},{indexes:a,ended:X0,looped:Y0,playhead:$0}=Q0?x0(U0):L0(U0),f=a.find((M)=>M>=V.streamBuffer.committedLength&&M<X);if(f!==void 0&&!V.streamBuffer.streamEnded&&V.streamBuffer.lastUnderrunSample!==f)J.push({type:\"bufferUnderrun\",data:{playhead:Math.floor(D),committedLength:V.streamBuffer.committedLength,requestedSample:f}}),V.streamBuffer.lastUnderrunSample=f;else if(f===void 0)V.streamBuffer.lastUnderrunSample=null;m0(Y,N,a);let m=Math.min(Math.floor(v*T.sampleRate),N0),D0=T0&&D>L&&D<x,C0=p&&Z0>0&&X>y;if(D0&&C0){{let M=L+m;if(m>0&&D>L&&D<M){let W=D-L,I=Math.min(Math.floor(M-D),y);for(let G=0;G<I;G++){let B=(W+G)/m,S=Math.cos(Math.PI*B/2),q=Math.floor(x-m+W+G);if(q>=0&&q<X)for(let _=0;_<l;_++)Y[_][G]+=N[_][q]*S}}}{let M=x-m;if(m>0&&D>M&&D<x){let W=D-M,I=Math.min(Math.floor(x-D),y);for(let G=0;G<I;G++){let B=(W+G)/m,S=Math.sin(Math.PI*B/2),q=Math.floor(L+W+G);if(q>=0&&q<X)for(let _=0;_<l;_++)Y[_][G]+=N[_][q]*S}}}}if(s&&A0>0){let M=Math.floor(A0*T.sampleRate),W=M-E;if(W>0){let I=Math.min(W,y);for(let G=0;G<I;G++){let B=(E+G)/M,S=B*B*B;for(let q=0;q<l;q++)Y[q][G]*=S}}}if(g&&F0>0){let M=Math.floor(F0*T.sampleRate),W=Math.floor(T.sampleRate*(Z-T.currentTime));if(W<M+y)for(let I=0;I<y;I++){let G=W-I;if(G>=M)continue;let B=G<=0?0:G/M,S=B*B*B;for(let q=0;q<l;q++)Y[q][I]*=S}}if(O)h0(Y,$,T.sampleRate,Q.lowpass);if(R)l0(Y,j,T.sampleRate,Q.highpass);if(h)g0(Y,P);if(l===1)S0(Y);if(b)d0(Y,C);if(Y0)V.timesLooped++,J.push({type:\"looped\",data:V.timesLooped});if(X0)V.state=z.Ended,J.push({type:\"ended\"});V.playedSamples+=a.length,V.playhead=$0;let k0=c0(Y);if(k0>0)return console.log({numNans:k0,indexes:a,playhead:$0,ended:X0,looped:Y0,sourceLength:X}),{keepAlive:!0,messages:J};for(let M=1;M<A.length;M++)H0(Y,A[M]);return{keepAlive:!0,messages:J}}class P0 extends AudioWorkletProcessor{static get parameterDescriptors(){return[{name:\"playbackRate\",automationRate:\"a-rate\",defaultValue:1},{name:\"detune\",automationRate:\"a-rate\",defaultValue:0},{name:\"gain\",automationRate:\"a-rate\",defaultValue:1,minValue:0},{name:\"pan\",automationRate:\"a-rate\",defaultValue:0},{name:\"highpass\",automationRate:\"a-rate\",defaultValue:20,minValue:20,maxValue:20000},{name:\"lowpass\",automationRate:\"a-rate\",defaultValue:20000,minValue:20,maxValue:20000}]}properties;filterState={lowpass:V0(),highpass:V0()};lastFrameTime=0;constructor(V){super(V);this.properties=v0(V?.processorOptions,sampleRate),this.port.onmessage=(A)=>{let F=z0(this.properties,A.data,currentTime,sampleRate);for(let T of F)this.port.postMessage(T);if(this.properties.state===z.Disposed)this.port.close()}}process(V,A,F){try{let T=j0(this.properties,A,F,{currentTime,currentFrame,sampleRate},this.filterState);for(let J of T.messages)this.port.postMessage(J);let Q=currentTime-this.lastFrameTime;return this.lastFrameTime=currentTime,this.port.postMessage({type:\"frame\",data:[currentTime,currentFrame,Math.floor(this.properties.playhead),Q*1000]}),T.keepAlive}catch(T){return console.log(T),!0}}}registerProcessor(\"ClipProcessor\",P0);\n\n//# debugId=5101232AAE128B1064756E2164756E21\n//# sourceMappingURL=processor.js.map\n";

package/dist/audio/processor-kernel.d.ts

@@ -0,0 +1,43 @@
+import { type BlockParameters, type BlockReturnState, type ClipProcessorOptions } from "./types";
+export declare const SAMPLE_BLOCK_SIZE = 128;
+export declare function getProperties(opts: ClipProcessorOptions | undefined, sampleRate: number): Required<ClipProcessorOptions>;
+export declare function setOffset(properties: Required<ClipProcessorOptions>, offset: number | undefined, sampleRate: number): number;
+export declare function findIndexesNormal(p: BlockParameters): BlockReturnState;
+export declare function findIndexesWithPlaybackRates(p: BlockParameters): BlockReturnState;
+export declare function fill(target: Float32Array[], source: Float32Array[], indexes: number[]): void;
+export declare function fillWithSilence(buffer: Float32Array[]): void;
+export declare function monoToStereo(signal: Float32Array[]): void;
+export declare function copy(source: Float32Array[], target: Float32Array[]): void;
+export declare function checkNans(output: Float32Array[]): number;
+export interface BiquadState {
+    x_1: number;
+    x_2: number;
+    y_1: number;
+    y_2: number;
+}
+export declare function createFilterState(): BiquadState[];
+export declare function gainFilter(arr: Float32Array[], gains: Float32Array): void;
+export declare function panFilter(signal: Float32Array[], pans: Float32Array): void;
+export declare function lowpassFilter(buffer: Float32Array[], cutoffs: Float32Array, sampleRate: number, states: BiquadState[]): void;
+export declare function highpassFilter(buffer: Float32Array[], cutoffs: Float32Array, sampleRate: number, states: BiquadState[]): void;
+export interface OutboundMessage {
+    type: string;
+    data?: unknown;
+}
+export declare function handleProcessorMessage(properties: Required<ClipProcessorOptions>, message: {
+    type: string;
+    data?: unknown;
+}, currentTime: number, sampleRate: number): OutboundMessage[];
+export interface ProcessContext {
+    currentTime: number;
+    currentFrame: number;
+    sampleRate: number;
+}
+export interface ProcessResult {
+    keepAlive: boolean;
+    messages: OutboundMessage[];
+}
+export declare function processBlock(props: Required<ClipProcessorOptions>, outputs: Float32Array[][], parameters: Record<string, Float32Array>, ctx: ProcessContext, filterState: {
+    lowpass: BiquadState[];
+    highpass: BiquadState[];
+}): ProcessResult;

package/dist/audio/processor.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/audio/types.d.ts

@@ -0,0 +1,192 @@
+export declare const State: {
+    readonly Initial: 0;
+    readonly Started: 1;
+    readonly Stopped: 2;
+    readonly Paused: 3;
+    readonly Scheduled: 4;
+    readonly Ended: 5;
+    readonly Disposed: 6;
+};
+export type ClipProcessorState = (typeof State)[keyof typeof State];
+export interface ClipProcessorOptions {
+    buffer?: Float32Array[];
+    streamBuffer?: StreamBufferState;
+    loop?: boolean;
+    loopStart?: number;
+    loopEnd?: number;
+    loopCrossfade?: number;
+    offset?: number;
+    duration?: number;
+    playhead?: number;
+    state?: ClipProcessorState;
+    startWhen?: number;
+    stopWhen?: number;
+    pauseWhen?: number;
+    resumeWhen?: number;
+    playedSamples?: number;
+    timesLooped?: number;
+    fadeInDuration?: number;
+    fadeOutDuration?: number;
+    enableFadeIn?: boolean;
+    enableFadeOut?: boolean;
+    enableLoopStart?: boolean;
+    enableLoopEnd?: boolean;
+    enableLoopCrossfade?: boolean;
+    enableGain?: boolean;
+    enablePan?: boolean;
+    enableHighpass?: boolean;
+    enableLowpass?: boolean;
+    enableDetune?: boolean;
+    enablePlaybackRate?: boolean;
+}
+export interface ClipWorkletOptions extends AudioWorkletNodeOptions {
+    processorOptions?: ClipProcessorOptions;
+}
+export type ClipNodeState = "initial" | "scheduled" | "started" | "stopped" | "paused" | "resumed" | "ended" | "disposed";
+export type FrameData = readonly [
+    currentTime: number,
+    currentFrame: number,
+    playhead: number,
+    timeTaken: number
+];
+export type ClipProcessorToggleMessageType = "toggleFadeIn" | "toggleFadeOut" | "toggleLoopStart" | "toggleLoopEnd" | "toggleLoopCrossfade" | "toggleGain" | "togglePan" | "toggleHighpass" | "toggleLowpass" | "toggleDetune" | "togglePlaybackRate";
+export interface ClipProcessorOnmessageEvent {
+    readonly data: ClipProcessorMessageRx;
+}
+export type ClipProcessorOnmessage = (ev: ClipProcessorOnmessageEvent) => void;
+export interface ProcessorWorkletOptions extends AudioWorkletNodeOptions {
+    readonly processorOptions?: ClipProcessorOptions;
+}
+export interface ClipProcessorStateMap {
+    readonly Initial: 0;
+    readonly Started: 1;
+    readonly Stopped: 2;
+    readonly Paused: 3;
+    readonly Scheduled: 4;
+    readonly Ended: 5;
+    readonly Disposed: 6;
+}
+export type ClipProcessorMessageRx = ClipProcessorBufferMessageRx | ClipProcessorBufferInitMessageRx | ClipProcessorBufferRangeMessageRx | ClipProcessorBufferEndMessageRx | ClipProcessorBufferResetMessageRx | ClipProcessorStartMessageRx | ClipProcessorStopMessageRx | ClipProcessorPauseMessageRx | ClipProcessorResumeMessageRx | ClipProcessorDisposeMessageRx | ClipProcessorLoopMessageRx | ClipProcessorLoopStartMessageRx | ClipProcessorLoopEndMessageRx | ClipProcessorPlayheadMessageRx | ClipProcessorFadeInMessageRx | ClipProcessorFadeOutMessageRx | ClipProcessorLoopCrossfadeMessageRx | ClipProcessorToggleMessageRx | ClipProcessorLogStateMessageRx;
+export type ClipProcessorMessageType = "buffer" | "bufferInit" | "bufferRange" | "bufferEnd" | "bufferReset" | "start" | "stop" | "pause" | "resume" | "dispose" | "loop" | "loopStart" | "loopEnd" | "playhead" | "playbackRate" | "offset" | "fadeIn" | "fadeOut" | "loopCrossfade" | ClipProcessorToggleMessageType | "logState";
+export interface ClipProcessorLogStateMessageRx {
+    readonly type: "logState";
+    readonly data?: never;
+}
+export interface ClipProcessorToggleMessageRx {
+    readonly type: ClipProcessorToggleMessageType;
+    readonly data?: boolean;
+}
+export interface ClipProcessorBufferMessageRx {
+    readonly type: "buffer";
+    readonly data: Float32Array[];
+}
+export interface StreamBufferSpan {
+    startSample: number;
+    endSample: number;
+}
+export interface BufferRangeWrite {
+    readonly startSample: number;
+    readonly channelData: Float32Array[];
+    readonly totalLength?: number | null;
+    readonly streamEnded?: boolean;
+}
+export interface StreamBufferState {
+    totalLength: number | null;
+    committedLength: number;
+    streamEnded: boolean;
+    streaming: boolean;
+    writtenSpans: StreamBufferSpan[];
+    pendingWrites: BufferRangeWrite[];
+    lowWaterThreshold: number;
+    lowWaterNotified: boolean;
+    lastUnderrunSample: number | null;
+}
+export interface ClipProcessorBufferInitMessageRx {
+    readonly type: "bufferInit";
+    readonly data: {
+        readonly channels: number;
+        readonly totalLength: number;
+        readonly streaming?: boolean;
+    };
+}
+export interface ClipProcessorBufferRangeMessageRx {
+    readonly type: "bufferRange";
+    readonly data: BufferRangeWrite;
+}
+export interface ClipProcessorBufferEndMessageRx {
+    readonly type: "bufferEnd";
+    readonly data?: {
+        readonly totalLength?: number;
+    };
+}
+export interface ClipProcessorBufferResetMessageRx {
+    readonly type: "bufferReset";
+    readonly data?: never;
+}
+export interface ClipProcessorStartMessageRx {
+    readonly type: "start";
+    readonly data?: {
+        readonly duration?: number;
+        readonly offset?: number;
+        readonly when?: number;
+    };
+}
+export interface ClipProcessorStopMessageRx {
+    readonly type: "stop";
+    readonly data?: number;
+}
+export interface ClipProcessorPauseMessageRx {
+    readonly type: "pause";
+    readonly data?: number;
+}
+export interface ClipProcessorResumeMessageRx {
+    readonly type: "resume";
+    readonly data?: number;
+}
+export interface ClipProcessorDisposeMessageRx {
+    readonly type: "dispose";
+    readonly data?: never;
+}
+export interface ClipProcessorLoopMessageRx {
+    readonly type: "loop";
+    readonly data: boolean;
+}
+export interface ClipProcessorLoopStartMessageRx {
+    readonly type: "loopStart";
+    readonly data: number;
+}
+export interface ClipProcessorLoopEndMessageRx {
+    readonly type: "loopEnd";
+    readonly data: number;
+}
+export interface ClipProcessorPlayheadMessageRx {
+    readonly type: "playhead";
+    readonly data: number;
+}
+export interface ClipProcessorFadeInMessageRx {
+    readonly type: "fadeIn";
+    readonly data: number;
+}
+export interface ClipProcessorFadeOutMessageRx {
+    readonly type: "fadeOut";
+    readonly data: number;
+}
+export interface ClipProcessorLoopCrossfadeMessageRx {
+    readonly type: "loopCrossfade";
+    readonly data: number;
+}
+export interface BlockParameters {
+    readonly playhead: number;
+    readonly durationSamples: number;
+    readonly loop: boolean;
+    readonly loopStartSamples: number;
+    readonly loopEndSamples: number;
+    readonly bufferLength: number;
+    readonly playbackRates: Float32Array;
+}
+export interface BlockReturnState {
+    readonly playhead: number;
+    readonly ended: boolean;
+    readonly looped: boolean;
+    readonly indexes: number[];
+}

package/dist/audio/utils.d.ts

@@ -0,0 +1,22 @@
+export declare function dbFromLin(lin: number): number;
+export declare function linFromDb(db: number): number;
+declare const TEMPO_RELATIVE_SNAPS: readonly ["beat", "bar", "8th", "16th"];
+export type TempoRelativeSnap = (typeof TEMPO_RELATIVE_SNAPS)[number];
+export declare function isTempoRelativeSnap(snap: string): snap is TempoRelativeSnap;
+export declare function getTempoSnapInterval(snap: string, tempo: number): number | null;
+export declare function remapTempoRelativeValue(value: number, snap: string, oldTempo: number, newTempo: number, min: number, max: number): number;
+export declare function getSnappedValue(value: number, snap: string, tempo: number): number;
+export interface SliderPreset {
+    snaps?: number[];
+    ticks?: number[];
+    min?: number;
+    max?: number;
+    skew?: number;
+    step?: number;
+    logarithmic?: boolean;
+}
+export declare const presets: Record<string, SliderPreset>;
+export declare function float32ArrayFromAudioBuffer(buffer: AudioBuffer): Float32Array[];
+export declare function audioBufferFromFloat32Array(context: BaseAudioContext, data?: Float32Array[]): AudioBuffer | undefined;
+export declare function generateSnapPoints(snap: string, tempo: number, min: number, max: number): number[];
+export {};

package/dist/audio/workletUrl.d.ts

@@ -0,0 +1,6 @@
+/** Blob URL from embedded processor code. Zero-config, default for npm users. */
+export declare function getProcessorBlobUrl(): string;
+/** jsDelivr CDN URL. For script-tag / no-bundler usage. */
+export declare function getProcessorCdnUrl(version?: string): string;
+/** Custom URL relative to a base. For self-hosted processor.js. */
+export declare function getProcessorModuleUrl(baseUrl?: string): string;

package/dist/components/AudioControl.d.ts

@@ -0,0 +1,28 @@
+export interface AudioControlProps {
+    label: string;
+    controlKey?: string;
+    min: number;
+    max: number;
+    value: number;
+    defaultValue?: number;
+    step?: number;
+    tempo?: number;
+    snap?: string;
+    preset?: string;
+    title?: string;
+    enabled?: boolean;
+    hasToggle?: boolean;
+    hasSnap?: boolean;
+    hasMaxLock?: boolean;
+    audioDuration?: number | null;
+    maxLocked?: boolean;
+    onChange?: (value: number) => void;
+    onToggle?: (enabled: boolean) => void;
+    onSnapChange?: (snap: string) => void;
+    onMinChange?: (val: number) => void;
+    onMaxChange?: (val: number) => void;
+    onMaxLockedChange?: (locked: boolean) => void;
+}
+declare function AudioControlInner({ label, controlKey, min: propMin, max: propMax, value, defaultValue, step, tempo, snap, preset, title, enabled, hasToggle, hasSnap, hasMaxLock, audioDuration, maxLocked, onChange, onToggle, onSnapChange, onMinChange, onMaxChange, onMaxLockedChange, }: AudioControlProps): import("react/jsx-runtime").JSX.Element;
+export declare const AudioControl: import("react").MemoExoticComponent<typeof AudioControlInner>;
+export {};

package/dist/components/ContextMenu.d.ts

@@ -0,0 +1,17 @@
+export interface ContextMenuProps {
+    x: number;
+    y: number;
+    snap: string;
+    snapMode?: "tempo" | "preset";
+    min: number;
+    max: number;
+    maxLocked?: boolean;
+    showMaxLock?: boolean;
+    audioDuration: number | null;
+    onSnapChange: (snap: string) => void;
+    onMinChange: (val: number) => void;
+    onMaxChange: (val: number) => void;
+    onMaxLockedChange?: (locked: boolean) => void;
+    onClose: () => void;
+}
+export declare function ContextMenu({ x, y, snap, snapMode, min, max, maxLocked, showMaxLock, audioDuration, onSnapChange, onMinChange, onMaxChange, onMaxLockedChange, onClose, }: ContextMenuProps): import("react").ReactPortal;

package/dist/components/ControlSection.d.ts

@@ -0,0 +1,26 @@
+import type { ControlDef, ControlKey } from "../controls/controlDefs";
+import type { LinkedControlPairDef, LinkedControlPairKey } from "../controls/linkedControlPairs";
+interface ControlSectionProps {
+    legend: string;
+    defs: ControlDef[];
+    values: Record<ControlKey, number>;
+    snaps: Record<ControlKey, string>;
+    enabled: Record<ControlKey, boolean>;
+    mins: Record<ControlKey, number>;
+    maxs: Record<ControlKey, number>;
+    maxLocked: Record<ControlKey, boolean>;
+    linked?: Record<LinkedControlPairKey, boolean>;
+    linkedPairs?: readonly LinkedControlPairDef[];
+    tempo: number;
+    audioDuration?: number | null;
+    onValueChange: (key: ControlKey, val: number) => void;
+    onToggle: (key: ControlKey, on: boolean) => void;
+    onLinkedChange?: (key: LinkedControlPairKey, linked: boolean) => void;
+    onSnapChange: (key: ControlKey, snap: string) => void;
+    onMinChange: (key: ControlKey, val: number) => void;
+    onMaxChange: (key: ControlKey, val: number) => void;
+    onMaxLockedChange: (key: ControlKey, locked: boolean) => void;
+}
+declare function ControlSectionInner({ legend, defs, linked, linkedPairs, onLinkedChange, ...controlProps }: ControlSectionProps): import("react/jsx-runtime").JSX.Element;
+export declare const ControlSection: import("react").MemoExoticComponent<typeof ControlSectionInner>;
+export {};

package/dist/components/DetuneControl.d.ts

@@ -0,0 +1,10 @@
+interface DetuneControlProps {
+    value: number;
+    defaultValue: number;
+    enabled: boolean;
+    onChange: (value: number) => void;
+    onToggle: (enabled: boolean) => void;
+}
+declare function DetuneControlInner({ value, defaultValue, enabled, onChange, onToggle, }: DetuneControlProps): import("react/jsx-runtime").JSX.Element;
+export declare const DetuneControl: import("react").MemoExoticComponent<typeof DetuneControlInner>;
+export {};

package/dist/components/DisplayPanel.d.ts

@@ -0,0 +1,14 @@
+import type { ClipNodeState } from "../audio/types";
+interface DisplayPanelProps {
+    nodeState: ClipNodeState;
+    statusMessage: string | null;
+    soundName: string | null;
+    currentTime: string;
+    currentFrame: string;
+    timesLooped: string;
+    latency: string;
+    timeTaken: string;
+}
+declare function DisplayPanelInner({ nodeState, statusMessage, soundName, currentTime, currentFrame, timesLooped, latency, timeTaken, }: DisplayPanelProps): import("react/jsx-runtime").JSX.Element;
+export declare const DisplayPanel: import("react").MemoExoticComponent<typeof DisplayPanelInner>;
+export {};

package/dist/components/FilterControl.d.ts

@@ -0,0 +1,12 @@
+interface FilterControlProps {
+    label: string;
+    controlKey: string;
+    value: number;
+    defaultValue: number;
+    enabled: boolean;
+    onChange: (value: number) => void;
+    onToggle: (enabled: boolean) => void;
+}
+declare function FilterControlInner({ label, controlKey: _controlKey, value, defaultValue, enabled, onChange, onToggle, }: FilterControlProps): import("react/jsx-runtime").JSX.Element;
+export declare const FilterControl: import("react").MemoExoticComponent<typeof FilterControlInner>;
+export {};

package/dist/components/GainControl.d.ts

@@ -0,0 +1,10 @@
+interface GainControlProps {
+    value: number;
+    defaultValue: number;
+    enabled: boolean;
+    onChange: (value: number) => void;
+    onToggle: (enabled: boolean) => void;
+}
+declare function GainControlInner({ value, defaultValue, enabled, onChange, onToggle, }: GainControlProps): import("react/jsx-runtime").JSX.Element;
+export declare const GainControl: import("react").MemoExoticComponent<typeof GainControlInner>;
+export {};

package/dist/components/PanControl.d.ts

@@ -0,0 +1,10 @@
+interface PanControlProps {
+    value: number;
+    defaultValue: number;
+    enabled: boolean;
+    onChange: (value: number) => void;
+    onToggle: (enabled: boolean) => void;
+}
+declare function PanControlInner({ value, defaultValue, enabled, onChange, onToggle, }: PanControlProps): import("react/jsx-runtime").JSX.Element;
+export declare const PanControl: import("react").MemoExoticComponent<typeof PanControlInner>;
+export {};

package/dist/components/PlaybackRateControl.d.ts

@@ -0,0 +1,10 @@
+interface PlaybackRateControlProps {
+    value: number;
+    defaultValue: number;
+    enabled: boolean;
+    onChange: (value: number) => void;
+    onToggle: (enabled: boolean) => void;
+}
+declare function PlaybackRateControlInner({ value, defaultValue, enabled, onChange, onToggle, }: PlaybackRateControlProps): import("react/jsx-runtime").JSX.Element;
+export declare const PlaybackRateControl: import("react").MemoExoticComponent<typeof PlaybackRateControlInner>;
+export {};