gitframes 1.2.35

package/dist/audio-C4kiPbrV.mjs

@@ -0,0 +1,1866 @@
+import { F as defineRenderer } from "./dist-CMF9eNLB.mjs";
+import { T as WebGPUAudioProcessor } from "./dist-C37594c6.mjs";
+
+//#region ../../nodes/node-audio-compressor/dist/renderers-BxN6ejmd.mjs
+const PARAM_ORDER$5 = [
+	"threshold",
+	"ratio",
+	"attack",
+	"release",
+	"knee",
+	"makeupGain"
+];
+const COMPRESSOR_SHADER_TEMPLATE = () => `
+struct Uniforms {
+    sampleRate        : f32,
+    threshold         : f32,
+    ratio             : f32,
+    attack            : f32,
+    release           : f32,
+    knee              : f32,
+    makeupGain        : f32,
+    hasThresholdSig   : f32,
+    hasRatioSig       : f32,
+    hasAttackSig      : f32,
+    hasReleaseSig     : f32,
+    hasKneeSig        : f32,
+    hasMakeupGainSig  : f32,
+    baseTime          : f32,
+    frame             : f32,
+    numSamples        : f32,
+    numChannels       : f32,
+    pad1              : f32,
+    pad2              : f32,
+    pad3              : f32,
+};
+
+@group(0) @binding(0) var<uniform> u : Uniforms;
+@group(0) @binding(1) var<storage, read> inputChannels : array<f32>;
+@group(0) @binding(2) var<storage, read_write> outputChannels : array<f32>;
+@group(0) @binding(3) var<storage, read_write> state : array<f32>; // state[0] = envelope
+@group(0) @binding(4) var<storage, read> thresholdSignal  : array<f32>;
+@group(0) @binding(5) var<storage, read> ratioSignal      : array<f32>;
+@group(0) @binding(6) var<storage, read> attackSignal     : array<f32>;
+@group(0) @binding(7) var<storage, read> releaseSignal    : array<f32>;
+@group(0) @binding(8) var<storage, read> kneeSignal       : array<f32>;
+@group(0) @binding(9) var<storage, read> makeupGainSignal : array<f32>;
+
+fn log10(x: f32) -> f32 {
+    return log(x) * 0.4342944819032518f;
+}
+
+fn tanh(x: f32) -> f32 {
+    let exp2x = exp(2.0f * x);
+    return (exp2x - 1.0f) / (exp2x + 1.0f);
+}
+
+fn is_nan_or_inf(v: f32) -> bool {
+    return (v != v) || (abs(v) > 3.402823466e+38f);
+}
+
+@compute @workgroup_size(1)
+fn main(@builtin(global_invocation_id) gid : vec3<u32>) {
+    if (gid.x != 0u) { return; }
+
+    let numSamples = u32(u.numSamples);
+    let numChannels = u32(u.numChannels);
+
+    var envelope = state[0];
+    if (is_nan_or_inf(envelope)) {
+        envelope = 0.0f;
+    }
+
+    for (var index = 0u; index < numSamples; index = index + 1u) {
+        // 1. Dynamic Parameter Modulation & Anti-Explosion Clamping
+        var effThreshold = u.threshold;
+        if (u.hasThresholdSig > 0.5f) {
+            effThreshold = thresholdSignal[index];
+        }
+        effThreshold = clamp(effThreshold, -120.0f, 0.0f);
+
+        var effRatio = u.ratio;
+        if (u.hasRatioSig > 0.5f) {
+            effRatio = ratioSignal[index];
+        }
+        effRatio = clamp(effRatio, 1.0f, 100.0f);
+
+        var effAttack = u.attack;
+        if (u.hasAttackSig > 0.5f) {
+            effAttack = attackSignal[index];
+        }
+        effAttack = clamp(effAttack, 0.0001f, 10.0f);
+
+        var effRelease = u.release;
+        if (u.hasReleaseSig > 0.5f) {
+            effRelease = releaseSignal[index];
+        }
+        effRelease = clamp(effRelease, 0.001f, 10.0f);
+
+        var effKnee = u.knee;
+        if (u.hasKneeSig > 0.5f) {
+            effKnee = kneeSignal[index];
+        }
+        effKnee = clamp(effKnee, 0.0f, 40.0f);
+
+        var effMakeupGain = u.makeupGain;
+        if (u.hasMakeupGainSig > 0.5f) {
+            effMakeupGain = makeupGainSignal[index];
+        }
+        effMakeupGain = clamp(effMakeupGain, -60.0f, 36.0f);
+
+        // 2. Safe Attack / Release Coefficients
+        let attackCoeff = clamp(1.0f - exp(-1.0f / (u.sampleRate * effAttack)), 0.00001f, 1.0f);
+        let releaseCoeff = clamp(1.0f - exp(-1.0f / (u.sampleRate * effRelease)), 0.00001f, 1.0f);
+
+        // 3. Peak Detection with NaN / Inf sanitization
+        var peak = 0.0f;
+        for (var c = 0u; c < numChannels; c = c + 1u) {
+            var val = abs(inputChannels[c * numSamples + index]);
+            if (is_nan_or_inf(val)) {
+                val = 0.0f;
+            }
+            if (val > peak) {
+                peak = val;
+            }
+        }
+        
+        // 4. Convert Peak to dBFS
+        let dB = 20.0f * log10(max(peak, 1e-9f));
+
+        // 5. Compute target reduction (soft-knee & ratio)
+        var targetReductiondB = 0.0f;
+        if (effKnee > 0.0f) {
+            let x = dB - effThreshold;
+            if (x <= -effKnee / 2.0f) {
+                targetReductiondB = 0.0f;
+            } else if (x >= effKnee / 2.0f) {
+                targetReductiondB = (dB - effThreshold) * (1.0f - 1.0f / effRatio);
+            } else {
+                let kneeTerm = x + effKnee / 2.0f;
+                targetReductiondB = ((kneeTerm * kneeTerm) / (2.0f * effKnee)) * (1.0f - 1.0f / effRatio);
+            }
+        } else {
+            if (dB > effThreshold) {
+                targetReductiondB = (dB - effThreshold) * (1.0f - 1.0f / effRatio);
+            }
+        }
+
+        targetReductiondB = clamp(targetReductiondB, 0.0f, 120.0f);
+
+        // 6. Envelope Smoothing
+        let targetGaindB = -targetReductiondB;
+        if (targetGaindB < envelope) {
+            envelope += (targetGaindB - envelope) * attackCoeff;
+        } else {
+            envelope += (targetGaindB - envelope) * releaseCoeff;
+        }
+
+        if (is_nan_or_inf(envelope)) {
+            envelope = 0.0f;
+        }
+        envelope = clamp(envelope, -120.0f, 0.0f);
+
+        // 7. Apply linear gain and soft clipping
+        let totalGaindB = clamp(envelope + effMakeupGain, -120.0f, 36.0f);
+        let gainLinear = clamp(pow(10.0f, totalGaindB / 20.0f), 0.0f, 63.1f);
+
+        for (var c = 0u; c < numChannels; c = c + 1u) {
+            let sampleIndex = c * numSamples + index;
+            var inVal = inputChannels[sampleIndex];
+            if (is_nan_or_inf(inVal)) {
+                inVal = 0.0f;
+            }
+
+            var outVal = inVal * gainLinear;
+            if (is_nan_or_inf(outVal)) {
+                outVal = 0.0f;
+            }
+            
+            // Soft clipping at ±1.0 with smooth tanh transition starting at ±0.9
+            if (outVal > 1.0f) {
+                outVal = 1.0f;
+            } else if (outVal < -1.0f) {
+                outVal = -1.0f;
+            } else if (outVal > 0.9f) {
+                outVal = 0.9f + 0.1f * tanh((outVal - 0.9f) / 0.1f);
+            } else if (outVal < -0.9f) {
+                outVal = -0.9f + 0.1f * tanh((outVal + 0.9f) / 0.1f);
+            }
+            
+            outputChannels[sampleIndex] = outVal;
+        }
+    }
+
+    if (is_nan_or_inf(envelope)) {
+        state[0] = 0.0f;
+    } else {
+        state[0] = clamp(envelope, -120.0f, 0.0f);
+    }
+}
+`;
+const compressorAudioProcessor = async (channels, sampleRate, virtualMedia, ctx) => {
+	if (!ctx?.device) throw new Error("GPUDevice is required for WebGPU Dynamics Compressor.");
+	const op = virtualMedia.operation || {};
+	const inputs = op.inputs || {};
+	const threshold = typeof op.threshold === "number" ? op.threshold : -24;
+	const ratio = typeof op.ratio === "number" ? op.ratio : 4;
+	const attack = typeof op.attack === "number" ? op.attack : .003;
+	const release = typeof op.release === "number" ? op.release : .25;
+	const knee = typeof op.knee === "number" ? op.knee : 6;
+	const makeupGain = typeof op.makeupGain === "number" ? op.makeupGain : 0;
+	const isHandleConnected = (handleIdKey) => {
+		const handleId = op[handleIdKey];
+		if (typeof handleId !== "string" || !handleId) return false;
+		const input = inputs[handleId];
+		return Boolean(input?.connectionValid && input.outputItem && (input.outputItem.type === "Signal" || input.outputItem.type === "Number"));
+	};
+	const hasThresholdSig = isHandleConnected("thresholdHandleId") ? 1 : 0;
+	const hasRatioSig = isHandleConnected("ratioHandleId") ? 1 : 0;
+	const hasAttackSig = isHandleConnected("attackHandleId") ? 1 : 0;
+	const hasReleaseSig = isHandleConnected("releaseHandleId") ? 1 : 0;
+	const hasKneeSig = isHandleConnected("kneeHandleId") ? 1 : 0;
+	const hasMakeupGainSig = isHandleConnected("makeupGainHandleId") ? 1 : 0;
+	const numChannels = channels.length;
+	if (numChannels === 0) return;
+	const numSamples = channels[0].length;
+	if (numSamples === 0) return;
+	const nodeId = op.id || "audio-compressor";
+	const frame = ctx.frame ?? 0;
+	const fps = ctx.fps ?? 24;
+	await WebGPUAudioProcessor.process(ctx.device, nodeId, channels, sampleRate, virtualMedia, frame, fps, COMPRESSOR_SHADER_TEMPLATE, (t) => [
+		sampleRate,
+		threshold,
+		ratio,
+		attack,
+		release,
+		knee,
+		makeupGain,
+		hasThresholdSig,
+		hasRatioSig,
+		hasAttackSig,
+		hasReleaseSig,
+		hasKneeSig,
+		hasMakeupGainSig,
+		t,
+		frame,
+		numSamples,
+		numChannels,
+		0,
+		0,
+		0
+	], 20, 1, ctx?.renderId, true, ctx?.elapsedMs, ctx?.durationMs, void 0, void 0, PARAM_ORDER$5);
+};
+var renderers_default$6 = defineRenderer({ audioProcessor: compressorAudioProcessor });
+
+//#endregion
+//#region ../../nodes/node-audio-delay/dist/renderers-DxDAZF2y.mjs
+const PARAM_ORDER$4 = [
+	"delayTime",
+	"feedback",
+	"wet",
+	"dry"
+];
+const DELAY_SHADER_TEMPLATE = () => `
+struct Uniforms {
+    sampleRate       : f32,
+    delaySec         : f32,
+    feedback         : f32,
+    wet              : f32,
+    dry              : f32,
+    pingPong         : f32,
+    bufferLength     : f32,
+    hasDelayTimeSig  : f32,
+    hasFeedbackSig   : f32,
+    hasWetSig        : f32,
+    hasDrySig        : f32,
+    baseTime         : f32,
+    frame            : f32,
+    numSamples       : f32,
+    numChannels      : f32,
+    pad1             : f32,
+};
+
+@group(0) @binding(0) var<uniform> u : Uniforms;
+@group(0) @binding(1) var<storage, read> inputChannels : array<f32>;
+@group(0) @binding(2) var<storage, read_write> outputChannels : array<f32>;
+@group(0) @binding(3) var<storage, read_write> state : array<f32>;
+@group(0) @binding(4) var<storage, read> delayTimeSignal : array<f32>;
+@group(0) @binding(5) var<storage, read> feedbackSignal  : array<f32>;
+@group(0) @binding(6) var<storage, read> wetSignal       : array<f32>;
+@group(0) @binding(7) var<storage, read> drySignal       : array<f32>;
+
+fn tanh(x: f32) -> f32 {
+    let exp2x = exp(2.0f * x);
+    return (exp2x - 1.0f) / (exp2x + 1.0f);
+}
+
+fn is_nan_or_inf(v: f32) -> bool {
+    return (v != v) || (abs(v) > 3.402823466e+38f);
+}
+
+@compute @workgroup_size(1)
+fn main(@builtin(global_invocation_id) gid : vec3<u32>) {
+    if (gid.x != 0u) { return; }
+
+    let numSamples = u32(u.numSamples);
+    let numChannels = u32(u.numChannels);
+    let bufferLength = u32(u.bufferLength);
+
+    var writeIndex = u32(state[0]);
+    if (is_nan_or_inf(state[0])) {
+        writeIndex = 0u;
+    }
+
+    for (var index = 0u; index < numSamples; index = index + 1u) {
+        // 1. Dynamic Parameter Modulation & Anti-Explosion Clamping
+        var effDelaySec = u.delaySec;
+        if (u.hasDelayTimeSig > 0.5f) {
+            effDelaySec = delayTimeSignal[index];
+        }
+        effDelaySec = clamp(effDelaySec, 0.001f, 5.0f);
+
+        var effFeedback = u.feedback;
+        if (u.hasFeedbackSig > 0.5f) {
+            effFeedback = feedbackSignal[index];
+        }
+        effFeedback = clamp(effFeedback, 0.0f, 0.95f);
+
+        var effWet = u.wet;
+        if (u.hasWetSig > 0.5f) {
+            effWet = wetSignal[index];
+        }
+        effWet = clamp(effWet, 0.0f, 2.0f);
+
+        var effDry = u.dry;
+        if (u.hasDrySig > 0.5f) {
+            effDry = drySignal[index];
+        }
+        effDry = clamp(effDry, 0.0f, 2.0f);
+
+        // 2. Safe Dynamic Read Index
+        let readOffset = u32(clamp(effDelaySec * u.sampleRate, 1.0f, f32(bufferLength - 1u)));
+        let readIndex = (writeIndex + bufferLength - readOffset) % bufferLength;
+
+        if (numChannels == 1u || u.pingPong == 0.0f) {
+            // Standard Delay
+            for (var c = 0u; c < numChannels; c = c + 1u) {
+                let sampleIndex = c * numSamples + index;
+                var inputVal = inputChannels[sampleIndex];
+                if (is_nan_or_inf(inputVal)) {
+                    inputVal = 0.0f;
+                }
+
+                let stateOffset = c * bufferLength + 1u;
+                var delayedSample = state[stateOffset + readIndex];
+                if (is_nan_or_inf(delayedSample)) {
+                    delayedSample = 0.0f;
+                }
+
+                var nextStateVal = inputVal + delayedSample * effFeedback;
+                if (is_nan_or_inf(nextStateVal)) {
+                    nextStateVal = 0.0f;
+                }
+                state[stateOffset + writeIndex] = clamp(nextStateVal, -4.0f, 4.0f);
+
+                var outVal = effDry * inputVal + effWet * delayedSample;
+                if (is_nan_or_inf(outVal)) {
+                    outVal = 0.0f;
+                }
+                if (outVal > 1.0f) {
+                    outVal = 1.0f;
+                } else if (outVal < -1.0f) {
+                    outVal = -1.0f;
+                } else if (outVal > 0.9f) {
+                    outVal = 0.9f + 0.1f * tanh((outVal - 0.9f) / 0.1f);
+                } else if (outVal < -0.9f) {
+                    outVal = -0.9f + 0.1f * tanh((outVal + 0.9f) / 0.1f);
+                }
+
+                outputChannels[sampleIndex] = outVal;
+            }
+        } else {
+            // Stereo Ping-Pong Delay
+            var sampleL = inputChannels[index];
+            if (is_nan_or_inf(sampleL)) { sampleL = 0.0f; }
+
+            var sampleR = inputChannels[numSamples + index];
+            if (is_nan_or_inf(sampleR)) { sampleR = 0.0f; }
+
+            var delayedL = state[1u + readIndex];
+            if (is_nan_or_inf(delayedL)) { delayedL = 0.0f; }
+
+            var delayedR = state[bufferLength + 1u + readIndex];
+            if (is_nan_or_inf(delayedR)) { delayedR = 0.0f; }
+
+            // Ping-pong cross-feedback
+            var nextL = sampleL + delayedR * effFeedback;
+            var nextR = sampleR + delayedL * effFeedback;
+            if (is_nan_or_inf(nextL)) { nextL = 0.0f; }
+            if (is_nan_or_inf(nextR)) { nextR = 0.0f; }
+
+            state[1u + writeIndex] = clamp(nextL, -4.0f, 4.0f);
+            state[bufferLength + 1u + writeIndex] = clamp(nextR, -4.0f, 4.0f);
+
+            var outL = effDry * sampleL + effWet * delayedL;
+            var outR = effDry * sampleR + effWet * delayedR;
+            if (is_nan_or_inf(outL)) { outL = 0.0f; }
+            if (is_nan_or_inf(outR)) { outR = 0.0f; }
+
+            if (outL > 1.0f) { outL = 1.0f; } else if (outL < -1.0f) { outL = -1.0f; }
+            else if (outL > 0.9f) { outL = 0.9f + 0.1f * tanh((outL - 0.9f) / 0.1f); }
+            else if (outL < -0.9f) { outL = -0.9f + 0.1f * tanh((outL + 0.9f) / 0.1f); }
+
+            if (outR > 1.0f) { outR = 1.0f; } else if (outR < -1.0f) { outR = -1.0f; }
+            else if (outR > 0.9f) { outR = 0.9f + 0.1f * tanh((outR - 0.9f) / 0.1f); }
+            else if (outR < -0.9f) { outR = -0.9f + 0.1f * tanh((outR + 0.9f) / 0.1f); }
+
+            outputChannels[index] = outL;
+            outputChannels[numSamples + index] = outR;
+        }
+
+        writeIndex = (writeIndex + 1u) % bufferLength;
+    }
+
+    state[0] = f32(writeIndex);
+}
+`;
+const delayAudioProcessor = async (channels, sampleRate, virtualMedia, ctx) => {
+	if (!ctx?.device) throw new Error("GPUDevice is required for WebGPU Audio Delay.");
+	const op = virtualMedia.operation || {};
+	const inputs = op.inputs || {};
+	const numChannels = channels.length;
+	if (numChannels === 0) return;
+	const numSamples = channels[0].length;
+	if (numSamples === 0) return;
+	const delaySec = Math.max(.001, Math.min(typeof op.delayTime === "number" ? op.delayTime : .25, 5));
+	const feedbackInternal = Math.max(0, Math.min(typeof op.feedback === "number" ? op.feedback : .4, .95));
+	const wetInternal = Math.max(0, Math.min(typeof op.wet === "number" ? op.wet : .3, 1));
+	const dryInternal = Math.max(0, Math.min(typeof op.dry === "number" ? op.dry : 1, 1));
+	const pingPongInternal = typeof op.pingPong === "boolean" ? op.pingPong : false;
+	const isHandleConnected = (handleIdKey) => {
+		const handleId = op[handleIdKey];
+		if (typeof handleId !== "string" || !handleId) return false;
+		const input = inputs[handleId];
+		return Boolean(input?.connectionValid && input.outputItem && (input.outputItem.type === "Signal" || input.outputItem.type === "Number"));
+	};
+	const hasDelayTimeSig = isHandleConnected("delayTimeHandleId") ? 1 : 0;
+	const hasFeedbackSig = isHandleConnected("feedbackHandleId") ? 1 : 0;
+	const hasWetSig = isHandleConnected("wetHandleId") ? 1 : 0;
+	const hasDrySig = isHandleConnected("dryHandleId") ? 1 : 0;
+	const bufferLength = Math.ceil(5 * sampleRate);
+	const nodeId = op.id || "audio-delay";
+	const frame = ctx.frame ?? 0;
+	const fps = ctx.fps ?? 24;
+	const stateFloatCount = numChannels * bufferLength + 1;
+	await WebGPUAudioProcessor.process(ctx.device, nodeId, channels, sampleRate, virtualMedia, frame, fps, DELAY_SHADER_TEMPLATE, () => [
+		sampleRate,
+		delaySec,
+		feedbackInternal,
+		wetInternal,
+		dryInternal,
+		pingPongInternal ? 1 : 0,
+		bufferLength,
+		hasDelayTimeSig,
+		hasFeedbackSig,
+		hasWetSig,
+		hasDrySig,
+		0,
+		frame,
+		numSamples,
+		numChannels,
+		0
+	], 16, stateFloatCount, ctx?.renderId, true, ctx?.elapsedMs, ctx?.durationMs, void 0, void 0, PARAM_ORDER$4);
+};
+var renderers_default$5 = defineRenderer({ audioProcessor: delayAudioProcessor });
+
+//#endregion
+//#region ../../nodes/node-audio-fade/dist/renderers-HxDOLxTs.mjs
+const PARAM_ORDER$3 = ["fadeInDuration", "fadeOutDuration"];
+const FADE_SHADER_TEMPLATE = () => `
+struct Uniforms {
+    sampleRate            : f32,
+    fadeInDuration        : f32,
+    fadeOutDuration       : f32,
+    fadeInCurve           : f32,
+    fadeOutCurve          : f32,
+    clipDuration          : f32,
+    hasFadeInDurationSig  : f32,
+    hasFadeOutDurationSig : f32,
+    baseTime              : f32,
+    frame                 : f32,
+    numSamples            : f32,
+    numChannels           : f32,
+    pad1                  : f32,
+    pad2                  : f32,
+    pad3                  : f32,
+    pad4                  : f32,
+};
+
+@group(0) @binding(0) var<uniform> u : Uniforms;
+@group(0) @binding(1) var<storage, read> inputChannels : array<f32>;
+@group(0) @binding(2) var<storage, read_write> outputChannels : array<f32>;
+@group(0) @binding(3) var<storage, read_write> state : array<f32>; // state[0] = samplesProcessed
+@group(0) @binding(4) var<storage, read> fadeInDurationSignal  : array<f32>;
+@group(0) @binding(5) var<storage, read> fadeOutDurationSignal : array<f32>;
+
+fn applyCurve(p: f32, curve: f32) -> f32 {
+    let clampedP = max(0.0f, min(p, 1.0f));
+    if (curve == 1.0f) { // exponential
+        return clampedP * clampedP;
+    }
+    if (curve == 2.0f) { // scurve
+        return clampedP * clampedP * (3.0f - 2.0f * clampedP);
+    }
+    return clampedP; // linear
+}
+
+fn tanh(x: f32) -> f32 {
+    let exp2x = exp(2.0f * x);
+    return (exp2x - 1.0f) / (exp2x + 1.0f);
+}
+
+fn is_nan_or_inf(v: f32) -> bool {
+    return (v != v) || (abs(v) > 3.402823466e+38f);
+}
+
+@compute @workgroup_size(1)
+fn main(@builtin(global_invocation_id) gid : vec3<u32>) {
+    if (gid.x != 0u) { return; }
+
+    let numSamples = u32(u.numSamples);
+    let numChannels = u32(u.numChannels);
+
+    for (var index = 0u; index < numSamples; index = index + 1u) {
+        let t = u.baseTime + f32(index) / u.sampleRate;
+        var gain = 1.0f;
+
+        var effFadeIn = u.fadeInDuration;
+        if (u.hasFadeInDurationSig > 0.5f) {
+            effFadeIn = fadeInDurationSignal[index];
+        }
+        effFadeIn = clamp(effFadeIn, 0.0f, 60.0f);
+
+        var effFadeOut = u.fadeOutDuration;
+        if (u.hasFadeOutDurationSig > 0.5f) {
+            effFadeOut = fadeOutDurationSignal[index];
+        }
+        effFadeOut = clamp(effFadeOut, 0.0f, 60.0f);
+
+        if (effFadeIn > 0.0f && t < effFadeIn) {
+            let p = t / effFadeIn;
+            gain = gain * applyCurve(p, u.fadeInCurve);
+        }
+
+        if (effFadeOut > 0.0f && t > u.clipDuration - effFadeOut) {
+            let p = (u.clipDuration - t) / effFadeOut;
+            gain = gain * applyCurve(p, u.fadeOutCurve);
+        }
+
+        gain = clamp(gain, 0.0f, 1.0f);
+
+        for (var c = 0u; c < numChannels; c = c + 1u) {
+            let sampleIndex = c * numSamples + index;
+            var inVal = inputChannels[sampleIndex];
+            if (is_nan_or_inf(inVal)) {
+                inVal = 0.0f;
+            }
+
+            var outVal = inVal * gain;
+            if (is_nan_or_inf(outVal)) {
+                outVal = 0.0f;
+            }
+
+            if (outVal > 1.0f) {
+                outVal = 1.0f;
+            } else if (outVal < -1.0f) {
+                outVal = -1.0f;
+            } else if (outVal > 0.9f) {
+                outVal = 0.9f + 0.1f * tanh((outVal - 0.9f) / 0.1f);
+            } else if (outVal < -0.9f) {
+                outVal = -0.9f + 0.1f * tanh((outVal + 0.9f) / 0.1f);
+            }
+
+            outputChannels[sampleIndex] = outVal;
+        }
+    }
+
+    // Dummy reference to keep state binding active
+    state[0] = state[0];
+}
+`;
+const getCurveCode = (curve) => {
+	if (curve === "exponential") return 1;
+	if (curve === "scurve") return 2;
+	return 0;
+};
+const fadeAudioProcessor = async (channels, sampleRate, virtualMedia, ctx) => {
+	if (!ctx?.device) throw new Error("GPUDevice is required for WebGPU Audio Fade.");
+	const op = virtualMedia.operation || {};
+	const inputs = op.inputs || {};
+	const numChannels = channels.length;
+	if (numChannels === 0) return;
+	const numSamples = channels[0].length;
+	if (numSamples === 0) return;
+	const fadeInDuration = Math.max(0, typeof op.fadeInDuration === "number" ? op.fadeInDuration : 0);
+	const fadeOutDuration = Math.max(0, typeof op.fadeOutDuration === "number" ? op.fadeOutDuration : 0);
+	const fadeInCurve = typeof op.fadeInCurve === "string" ? op.fadeInCurve : "linear";
+	const fadeOutCurve = typeof op.fadeOutCurve === "string" ? op.fadeOutCurve : "linear";
+	const clipDuration = (virtualMedia.metadata?.durationMs ?? 0) / 1e3;
+	let fadeIn = fadeInDuration;
+	let fadeOut = fadeOutDuration;
+	if (fadeIn + fadeOut > clipDuration) {
+		const half = clipDuration / 2;
+		fadeIn = Math.min(fadeIn, half);
+		fadeOut = Math.min(fadeOut, half);
+	}
+	const isHandleConnected = (handleIdKey) => {
+		const handleId = op[handleIdKey];
+		if (typeof handleId !== "string" || !handleId) return false;
+		const input = inputs[handleId];
+		return Boolean(input?.connectionValid && input.outputItem && (input.outputItem.type === "Signal" || input.outputItem.type === "Number"));
+	};
+	const hasFadeInDurationSig = isHandleConnected("fadeInDurationHandleId") ? 1 : 0;
+	const hasFadeOutDurationSig = isHandleConnected("fadeOutDurationHandleId") ? 1 : 0;
+	const nodeId = op.id || "audio-fade";
+	const frame = ctx.frame ?? 0;
+	const fps = ctx.fps ?? 24;
+	await WebGPUAudioProcessor.process(ctx.device, nodeId, channels, sampleRate, virtualMedia, frame, fps, FADE_SHADER_TEMPLATE, (chunkTimeSec) => {
+		const startFrame = typeof op.startFrame === "number" ? op.startFrame : frame;
+		const localTimeSec = ctx.elapsedMs !== void 0 ? ctx.elapsedMs / 1e3 + (chunkTimeSec - frame / fps) : Math.max(0, chunkTimeSec - startFrame / fps);
+		return [
+			sampleRate,
+			fadeIn,
+			fadeOut,
+			getCurveCode(fadeInCurve),
+			getCurveCode(fadeOutCurve),
+			clipDuration,
+			hasFadeInDurationSig,
+			hasFadeOutDurationSig,
+			localTimeSec,
+			frame,
+			numSamples,
+			numChannels,
+			0,
+			0,
+			0,
+			0
+		];
+	}, 16, 1, ctx?.renderId, true, ctx?.elapsedMs, ctx?.durationMs, void 0, void 0, PARAM_ORDER$3);
+};
+var renderers_default$4 = defineRenderer({ audioProcessor: fadeAudioProcessor });
+
+//#endregion
+//#region ../../nodes/node-audio-noise-gate/dist/renderers-Dn1K3bcD.mjs
+const PARAM_ORDER$2 = [
+	"threshold",
+	"attack",
+	"hold",
+	"release",
+	"range"
+];
+const NOISE_GATE_SHADER_TEMPLATE = () => `
+struct Uniforms {
+    sampleRate       : f32,
+    threshold        : f32,
+    attack           : f32,
+    hold             : f32,
+    release          : f32,
+    closedGain       : f32,
+    windowLength     : f32,
+    hasThresholdSig  : f32,
+    hasAttackSig     : f32,
+    hasHoldSig       : f32,
+    hasReleaseSig    : f32,
+    hasRangeSig      : f32,
+    baseTime         : f32,
+    frame            : f32,
+    numSamples       : f32,
+    numChannels      : f32,
+};
+
+@group(0) @binding(0) var<uniform> u : Uniforms;
+@group(0) @binding(1) var<storage, read> inputChannels : array<f32>;
+@group(0) @binding(2) var<storage, read_write> outputChannels : array<f32>;
+@group(0) @binding(3) var<storage, read_write> state : array<f32>;
+@group(0) @binding(4) var<storage, read> thresholdSignal : array<f32>;
+@group(0) @binding(5) var<storage, read> attackSignal    : array<f32>;
+@group(0) @binding(6) var<storage, read> holdSignal      : array<f32>;
+@group(0) @binding(7) var<storage, read> releaseSignal   : array<f32>;
+@group(0) @binding(8) var<storage, read> rangeSignal     : array<f32>;
+
+fn log10(x: f32) -> f32 {
+    return log(x) * 0.4342944819032518f;
+}
+
+fn tanh(x: f32) -> f32 {
+    let exp2x = exp(2.0f * x);
+    return (exp2x - 1.0f) / (exp2x + 1.0f);
+}
+
+fn is_nan_or_inf(v: f32) -> bool {
+    return (v != v) || (abs(v) > 3.402823466e+38f);
+}
+
+@compute @workgroup_size(1)
+fn main(@builtin(global_invocation_id) gid : vec3<u32>) {
+    if (gid.x != 0u) { return; }
+
+    let numSamples = u32(u.numSamples);
+    let numChannels = u32(u.numChannels);
+    let windowLength = u32(u.windowLength);
+
+    var gateState = u32(state[0]); // 0=CLOSED, 1=ATTACK, 2=OPEN, 3=HOLD, 4=RELEASE
+    if (is_nan_or_inf(state[0])) { gateState = 0u; }
+
+    var currentGain = state[1];
+    if (is_nan_or_inf(currentGain)) { currentGain = 0.0f; }
+
+    var gainAtTransition = state[2];
+    if (is_nan_or_inf(gainAtTransition)) { gainAtTransition = 0.0f; }
+
+    var attackSamplesLeft = i32(state[3]);
+    var holdSamplesLeft = i32(state[4]);
+    var releaseSamplesLeft = i32(state[5]);
+    var writeIndex = u32(state[6]);
+    var sumSquares = state[7];
+    if (is_nan_or_inf(sumSquares)) { sumSquares = 0.0f; }
+
+    let sampleRate = u.sampleRate;
+
+    for (var index = 0u; index < numSamples; index = index + 1u) {
+        // 1. Dynamic Parameter Modulation & Anti-Explosion Clamping
+        var effThreshold = u.threshold;
+        if (u.hasThresholdSig > 0.5f) {
+            effThreshold = thresholdSignal[index];
+        }
+        effThreshold = clamp(effThreshold, -120.0f, 0.0f);
+
+        var effAttack = u.attack;
+        if (u.hasAttackSig > 0.5f) {
+            effAttack = attackSignal[index];
+        }
+        effAttack = clamp(effAttack, 0.0001f, 5.0f);
+
+        var effHold = u.hold;
+        if (u.hasHoldSig > 0.5f) {
+            effHold = holdSignal[index];
+        }
+        effHold = clamp(effHold, 0.001f, 10.0f);
+
+        var effRelease = u.release;
+        if (u.hasReleaseSig > 0.5f) {
+            effRelease = releaseSignal[index];
+        }
+        effRelease = clamp(effRelease, 0.01f, 10.0f);
+
+        var effRange = u.closedGain;
+        if (u.hasRangeSig > 0.5f) {
+            let rDb = clamp(rangeSignal[index], -120.0f, 0.0f);
+            effRange = select(0.0f, pow(10.0f, rDb / 20.0f), rDb > -96.0f);
+        }
+        effRange = clamp(effRange, 0.0f, 1.0f);
+
+        // 2. Peak & RMS Window Calculation
+        var peak = 0.0f;
+        for (var c = 0u; c < numChannels; c = c + 1u) {
+            var val = abs(inputChannels[c * numSamples + index]);
+            if (is_nan_or_inf(val)) { val = 0.0f; }
+            if (val > peak) {
+                peak = val;
+            }
+        }
+
+        let inputPowerSq = peak * peak;
+        let oldestSq = state[8u + writeIndex];
+        state[8u + writeIndex] = inputPowerSq;
+        sumSquares = max(0.0f, sumSquares - oldestSq + inputPowerSq);
+        writeIndex = (writeIndex + 1u) % windowLength;
+
+        if (writeIndex == 0u) {
+            var sum = 0.0f;
+            for (var j = 0u; j < windowLength; j = j + 1u) {
+                sum = sum + state[8u + j];
+            }
+            sumSquares = sum;
+        }
+
+        let rms = sqrt(sumSquares / f32(windowLength));
+        let db = 20.0f * log10(max(rms, 1e-9f));
+
+        let signalAboveThreshold = db >= effThreshold;
+
+        if (signalAboveThreshold) {
+            if (gateState == 0u || gateState == 4u) {
+                gateState = 1u; // ATTACK
+                gainAtTransition = currentGain;
+                var samples = i32(round(effAttack * sampleRate));
+                if (samples <= 0) { samples = 1; }
+                attackSamplesLeft = samples;
+            } else if (gateState == 3u) {
+                gateState = 2u; // OPEN
+                currentGain = 1.0f;
+            }
+        } else {
+            if (gateState == 2u || gateState == 1u) {
+                gateState = 3u; // HOLD
+                var samples = i32(round(effHold * sampleRate));
+                if (samples <= 0) { samples = 1; }
+                holdSamplesLeft = samples;
+            }
+        }
+
+        if (gateState == 0u) {
+            currentGain = effRange;
+        } else if (gateState == 2u) {
+            currentGain = 1.0f;
+        } else if (gateState == 1u) {
+            var totalAttackSamples = i32(round(effAttack * sampleRate));
+            if (totalAttackSamples <= 0) { totalAttackSamples = 1; }
+            let progress = 1.0f - f32(attackSamplesLeft) / f32(totalAttackSamples);
+            currentGain = gainAtTransition + progress * (1.0f - gainAtTransition);
+
+            attackSamplesLeft = attackSamplesLeft - 1;
+            if (attackSamplesLeft <= 0) {
+                gateState = 2u;
+                currentGain = 1.0f;
+            }
+        } else if (gateState == 3u) {
+            currentGain = 1.0f;
+            holdSamplesLeft = holdSamplesLeft - 1;
+            if (holdSamplesLeft <= 0) {
+                gateState = 4u; // RELEASE
+                gainAtTransition = 1.0f;
+                var samples = i32(round(effRelease * sampleRate));
+                if (samples <= 0) { samples = 1; }
+                releaseSamplesLeft = samples;
+            }
+        } else if (gateState == 4u) {
+            var totalReleaseSamples = i32(round(effRelease * sampleRate));
+            if (totalReleaseSamples <= 0) { totalReleaseSamples = 1; }
+            let progress = 1.0f - f32(releaseSamplesLeft) / f32(totalReleaseSamples);
+            currentGain = gainAtTransition + progress * (effRange - gainAtTransition);
+
+            releaseSamplesLeft = releaseSamplesLeft - 1;
+            if (releaseSamplesLeft <= 0) {
+                gateState = 0u;
+                currentGain = effRange;
+            }
+        }
+
+        currentGain = clamp(currentGain, 0.0f, 1.0f);
+
+        for (var c = 0u; c < numChannels; c = c + 1u) {
+            let sampleIndex = c * numSamples + index;
+            var inVal = inputChannels[sampleIndex];
+            if (is_nan_or_inf(inVal)) { inVal = 0.0f; }
+
+            var outVal = inVal * currentGain;
+            if (is_nan_or_inf(outVal)) { outVal = 0.0f; }
+
+            if (outVal > 1.0f) {
+                outVal = 1.0f;
+            } else if (outVal < -1.0f) {
+                outVal = -1.0f;
+            } else if (outVal > 0.9f) {
+                outVal = 0.9f + 0.1f * tanh((outVal - 0.9f) / 0.1f);
+            } else if (outVal < -0.9f) {
+                outVal = -0.9f + 0.1f * tanh((outVal + 0.9f) / 0.1f);
+            }
+
+            outputChannels[sampleIndex] = outVal;
+        }
+    }
+
+    state[0] = f32(gateState);
+    state[1] = currentGain;
+    state[2] = gainAtTransition;
+    state[3] = f32(attackSamplesLeft);
+    state[4] = f32(holdSamplesLeft);
+    state[5] = f32(releaseSamplesLeft);
+    state[6] = f32(writeIndex);
+    state[7] = sumSquares;
+}
+`;
+const noiseGateAudioProcessor = async (channels, sampleRate, virtualMedia, ctx) => {
+	if (!ctx?.device) throw new Error("GPUDevice is required for WebGPU Noise Gate.");
+	const op = virtualMedia.operation || {};
+	const inputs = op.inputs || {};
+	const threshold = typeof op.threshold === "number" ? op.threshold : -40;
+	const attack = typeof op.attack === "number" ? op.attack : .005;
+	const hold = typeof op.hold === "number" ? op.hold : .05;
+	const release = typeof op.release === "number" ? op.release : .1;
+	const range = typeof op.range === "number" ? op.range : -80;
+	const closedGain = range <= -96 ? 0 : 10 ** (range / 20);
+	const isHandleConnected = (handleIdKey) => {
+		const handleId = op[handleIdKey];
+		if (typeof handleId !== "string" || !handleId) return false;
+		const input = inputs[handleId];
+		return Boolean(input?.connectionValid && input.outputItem && (input.outputItem.type === "Signal" || input.outputItem.type === "Number"));
+	};
+	const hasThresholdSig = isHandleConnected("thresholdHandleId") ? 1 : 0;
+	const hasAttackSig = isHandleConnected("attackHandleId") ? 1 : 0;
+	const hasHoldSig = isHandleConnected("holdHandleId") ? 1 : 0;
+	const hasReleaseSig = isHandleConnected("releaseHandleId") ? 1 : 0;
+	const hasRangeSig = isHandleConnected("rangeHandleId") ? 1 : 0;
+	const numChannels = channels.length;
+	if (numChannels === 0) return;
+	const numSamples = channels[0].length;
+	if (numSamples === 0) return;
+	const windowLength = Math.max(1, Math.round(.01 * sampleRate));
+	const nodeId = op.id || "audio-noise-gate";
+	const frame = ctx.frame ?? 0;
+	const fps = ctx.fps ?? 24;
+	const stateFloatCount = 8 + windowLength;
+	await WebGPUAudioProcessor.process(ctx.device, nodeId, channels, sampleRate, virtualMedia, frame, fps, NOISE_GATE_SHADER_TEMPLATE, () => [
+		sampleRate,
+		threshold,
+		attack,
+		hold,
+		release,
+		closedGain,
+		windowLength,
+		hasThresholdSig,
+		hasAttackSig,
+		hasHoldSig,
+		hasReleaseSig,
+		hasRangeSig,
+		0,
+		frame,
+		numSamples,
+		numChannels
+	], 16, stateFloatCount, ctx?.renderId, true, ctx?.elapsedMs, ctx?.durationMs, void 0, void 0, PARAM_ORDER$2);
+};
+var renderers_default$3 = defineRenderer({ audioProcessor: noiseGateAudioProcessor });
+
+//#endregion
+//#region ../../nodes/node-audio-parametric-eq/dist/renderers-CI8P2akC.mjs
+const PARAM_ORDER$1 = [
+	"frequency",
+	"gain",
+	"q"
+];
+const PARAMETRIC_EQ_SHADER_TEMPLATE = () => `
+struct Uniforms {
+    sampleRate      : f32,
+    numBands        : f32,
+    frequency       : f32,
+    gain            : f32,
+    q               : f32,
+    bandType        : f32,
+    hasFrequencySig : f32,
+    hasGainSig      : f32,
+    hasQSig         : f32,
+    baseTime        : f32,
+    frame           : f32,
+    numSamples      : f32,
+    numChannels     : f32,
+    pad1            : f32,
+    pad2            : f32,
+    pad3            : f32,
+};
+
+@group(0) @binding(0) var<uniform> u : Uniforms;
+@group(0) @binding(1) var<storage, read> inputChannels : array<f32>;
+@group(0) @binding(2) var<storage, read_write> outputChannels : array<f32>;
+@group(0) @binding(3) var<storage, read_write> state : array<f32>;
+@group(0) @binding(4) var<storage, read> frequencySignal : array<f32>;
+@group(0) @binding(5) var<storage, read> gainSignal      : array<f32>;
+@group(0) @binding(6) var<storage, read> qSignal         : array<f32>;
+
+const PI: f32 = 3.141592653589793f;
+
+fn tanh(x: f32) -> f32 {
+    let exp2x = exp(2.0f * x);
+    return (exp2x - 1.0f) / (exp2x + 1.0f);
+}
+
+fn is_nan_or_inf(v: f32) -> bool {
+    return (v != v) || (abs(v) > 3.402823466e+38f);
+}
+
+@compute @workgroup_size(1)
+fn main(@builtin(global_invocation_id) gid : vec3<u32>) {
+    if (gid.x != 0u) { return; }
+
+    let numSamples = u32(u.numSamples);
+    let numChannels = u32(u.numChannels);
+    let sampleRate = u.sampleRate;
+    let bandType = u.bandType; // 0=peak, 1=lowShelf, 2=highShelf, 3=lowPass, 4=highPass, 5=notch
+
+    let biquadStateOffset = 4u;
+
+    for (var c = 0u; c < numChannels; c = c + 1u) {
+        let offset = biquadStateOffset + c * 4u;
+        var x1 = state[offset];
+        var x2 = state[offset + 1u];
+        var y1 = state[offset + 2u];
+        var y2 = state[offset + 3u];
+
+        if (is_nan_or_inf(x1)) { x1 = 0.0f; }
+        if (is_nan_or_inf(x2)) { x2 = 0.0f; }
+        if (is_nan_or_inf(y1)) { y1 = 0.0f; }
+        if (is_nan_or_inf(y2)) { y2 = 0.0f; }
+
+        for (var index = 0u; index < numSamples; index = index + 1u) {
+            let sampleIndex = c * numSamples + index;
+            var x = inputChannels[sampleIndex];
+            if (is_nan_or_inf(x)) { x = 0.0f; }
+
+            // 1. Dynamic Parameter Signal Resolution & Clamping
+            var effFreq = u.frequency;
+            if (u.hasFrequencySig > 0.5f) {
+                effFreq = frequencySignal[index];
+            }
+            effFreq = clamp(effFreq, 20.0f, sampleRate / 2.0f - 1.0f);
+
+            var effQ = u.q;
+            if (u.hasQSig > 0.5f) {
+                effQ = qSignal[index];
+            }
+            effQ = clamp(effQ, 0.01f, 10.0f);
+
+            var effGain = u.gain;
+            if (u.hasGainSig > 0.5f) {
+                effGain = gainSignal[index];
+            }
+            effGain = clamp(effGain, -24.0f, 24.0f);
+
+            if (bandType == 0.0f && abs(effGain) < 1e-5f) {
+                // Bypass filter if peak gain is zero
+                outputChannels[sampleIndex] = x;
+                continue;
+            }
+
+            // 2. Biquad Coefficients Calculation
+            let w0 = (2.0f * PI * effFreq) / sampleRate;
+            let cos_w0 = cos(w0);
+            let sin_w0 = sin(w0);
+            let A = clamp(pow(10.0f, effGain / 40.0f), 0.25f, 4.0f);
+            let alpha = sin_w0 / (2.0f * effQ);
+
+            var b0 = 0.0f; var b1 = 0.0f; var b2 = 0.0f;
+            var a0 = 0.0f; var a1 = 0.0f; var a2 = 0.0f;
+
+            if (bandType == 0.0f) { // peak
+                b0 = 1.0f + alpha * A;
+                b1 = -2.0f * cos_w0;
+                b2 = 1.0f - alpha * A;
+                a0 = 1.0f + alpha / A;
+                a1 = -2.0f * cos_w0;
+                a2 = 1.0f - alpha / A;
+            } else if (bandType == 1.0f) { // lowShelf
+                let sqrtA = sqrt(A);
+                let twoSqrtAAlpha = 2.0f * sqrtA * alpha;
+                b0 = A * (A + 1.0f - (A - 1.0f) * cos_w0 + twoSqrtAAlpha);
+                b1 = 2.0f * A * (A - 1.0f - (A + 1.0f) * cos_w0);
+                b2 = A * (A + 1.0f - (A - 1.0f) * cos_w0 - twoSqrtAAlpha);
+                a0 = A + 1.0f + (A - 1.0f) * cos_w0 + twoSqrtAAlpha;
+                a1 = -2.0f * (A - 1.0f + (A + 1.0f) * cos_w0);
+                a2 = A + 1.0f + (A - 1.0f) * cos_w0 - twoSqrtAAlpha;
+            } else if (bandType == 2.0f) { // highShelf
+                let sqrtA = sqrt(A);
+                let twoSqrtAAlpha = 2.0f * sqrtA * alpha;
+                b0 = A * (A + 1.0f + (A - 1.0f) * cos_w0 + twoSqrtAAlpha);
+                b1 = -2.0f * A * (A - 1.0f + (A + 1.0f) * cos_w0);
+                b2 = A * (A + 1.0f + (A - 1.0f) * cos_w0 - twoSqrtAAlpha);
+                a0 = A + 1.0f - (A - 1.0f) * cos_w0 + twoSqrtAAlpha;
+                a1 = 2.0f * (A - 1.0f - (A + 1.0f) * cos_w0);
+                a2 = A + 1.0f - (A - 1.0f) * cos_w0 - twoSqrtAAlpha;
+            } else if (bandType == 3.0f) { // lowPass
+                b0 = (1.0f - cos_w0) / 2.0f;
+                b1 = 1.0f - cos_w0;
+                b2 = (1.0f - cos_w0) / 2.0f;
+                a0 = 1.0f + alpha;
+                a1 = -2.0f * cos_w0;
+                a2 = 1.0f - alpha;
+            } else if (bandType == 4.0f) { // highPass
+                b0 = (1.0f + cos_w0) / 2.0f;
+                b1 = -(1.0f + cos_w0);
+                b2 = (1.0f + cos_w0) / 2.0f;
+                a0 = 1.0f + alpha;
+                a1 = -2.0f * cos_w0;
+                a2 = 1.0f - alpha;
+            } else if (bandType == 5.0f) { // notch
+                b0 = 1.0f;
+                b1 = -2.0f * cos_w0;
+                b2 = 1.0f;
+                a0 = 1.0f + alpha;
+                a1 = -2.0f * cos_w0;
+                a2 = 1.0f - alpha;
+            }
+
+            if (abs(a0) < 1e-9f) {
+                outputChannels[sampleIndex] = x;
+                continue;
+            }
+
+            let b0_norm = b0 / a0;
+            let b1_norm = b1 / a0;
+            let b2_norm = b2 / a0;
+            let a1_norm = a1 / a0;
+            let a2_norm = a2 / a0;
+
+            var y = b0_norm * x + b1_norm * x1 + b2_norm * x2 - a1_norm * y1 - a2_norm * y2;
+            if (is_nan_or_inf(y)) { y = 0.0f; }
+
+            // Biquad State History Update with Soft Anti-Explosion Clamping
+            x2 = x1;
+            x1 = x;
+            y2 = clamp(y1, -4.0f, 4.0f);
+            y1 = clamp(y, -4.0f, 4.0f);
+
+            // Output Soft Clipping
+            if (y > 1.0f) {
+                y = 1.0f;
+            } else if (y < -1.0f) {
+                y = -1.0f;
+            } else if (y > 0.9f) {
+                y = 0.9f + 0.1f * tanh((y - 0.9f) / 0.1f);
+            } else if (y < -0.9f) {
+                y = -0.9f + 0.1f * tanh((y + 0.9f) / 0.1f);
+            }
+
+            outputChannels[sampleIndex] = y;
+        }
+
+        state[offset] = x1;
+        state[offset + 1u] = x2;
+        state[offset + 2u] = y1;
+        state[offset + 3u] = y2;
+    }
+}
+`;
+const getBandTypeVal = (type) => {
+	if (type === "peak") return 0;
+	if (type === "lowShelf") return 1;
+	if (type === "highShelf") return 2;
+	if (type === "lowPass") return 3;
+	if (type === "highPass") return 4;
+	if (type === "notch") return 5;
+	return 0;
+};
+const parametricEqAudioProcessor = async (channels, sampleRate, virtualMedia, ctx) => {
+	if (!ctx?.device) throw new Error("GPUDevice is required for WebGPU Parametric EQ.");
+	const op = virtualMedia.operation || {};
+	const inputs = op.inputs || {};
+	const config = {
+		type: typeof op.type === "string" && [
+			"lowShelf",
+			"highShelf",
+			"peak",
+			"lowPass",
+			"highPass",
+			"notch"
+		].includes(op.type) ? op.type : "peak",
+		frequency: typeof op.frequency === "number" ? op.frequency : 1e3,
+		frequencyHandleId: typeof op.frequencyHandleId === "string" ? op.frequencyHandleId : null,
+		gain: typeof op.gain === "number" ? op.gain : 0,
+		gainHandleId: typeof op.gainHandleId === "string" ? op.gainHandleId : null,
+		q: typeof op.q === "number" ? op.q : 1,
+		qHandleId: typeof op.qHandleId === "string" ? op.qHandleId : null
+	};
+	const isHandleConnected = (handleIdKey) => {
+		const handleId = op[handleIdKey];
+		if (typeof handleId !== "string" || !handleId) return false;
+		const input = inputs[handleId];
+		return Boolean(input?.connectionValid && input.outputItem && (input.outputItem.type === "Signal" || input.outputItem.type === "Number"));
+	};
+	const hasFrequencySig = isHandleConnected("frequencyHandleId") ? 1 : 0;
+	const hasGainSig = isHandleConnected("gainHandleId") ? 1 : 0;
+	const hasQSig = isHandleConnected("qHandleId") ? 1 : 0;
+	const numChannels = channels.length;
+	if (numChannels === 0) return;
+	const numSamples = channels[0].length;
+	if (numSamples === 0) return;
+	const nodeId = op.id || "audio-parametric-eq";
+	const frame = ctx.frame ?? 0;
+	const fps = ctx.fps ?? 24;
+	const stateFloatCount = 4 + numChannels * 4;
+	await WebGPUAudioProcessor.process(ctx.device, nodeId, channels, sampleRate, virtualMedia, frame, fps, PARAMETRIC_EQ_SHADER_TEMPLATE, () => [
+		sampleRate,
+		1,
+		config.frequency,
+		config.gain,
+		config.q,
+		getBandTypeVal(config.type),
+		hasFrequencySig,
+		hasGainSig,
+		hasQSig,
+		0,
+		frame,
+		numSamples,
+		numChannels,
+		0,
+		0,
+		0
+	], 16, stateFloatCount, ctx?.renderId, true, ctx?.elapsedMs, ctx?.durationMs, void 0, void 0, PARAM_ORDER$1);
+};
+var renderers_default$2 = defineRenderer({ audioProcessor: parametricEqAudioProcessor });
+
+//#endregion
+//#region ../../nodes/node-audio-reverb/dist/renderers-Dz30LBKg.mjs
+const PARAM_ORDER = [
+	"roomSize",
+	"damping",
+	"wet",
+	"dry",
+	"width"
+];
+const REVERB_SHADER_TEMPLATE = () => `
+struct Uniforms {
+    sampleRate     : f32,
+    roomSize       : f32,
+    damping        : f32,
+    wet            : f32,
+    dry            : f32,
+    width          : f32,
+    hasRoomSizeSig : f32,
+    hasDampingSig  : f32,
+    hasWetSig      : f32,
+    hasDrySig      : f32,
+    hasWidthSig    : f32,
+    baseTime       : f32,
+    frame          : f32,
+    numSamples     : f32,
+    numChannels    : f32,
+    pad1           : f32,
+};
+
+@group(0) @binding(0) var<uniform> u : Uniforms;
+@group(0) @binding(1) var<storage, read> inputChannels : array<f32>;
+@group(0) @binding(2) var<storage, read_write> outputChannels : array<f32>;
+@group(0) @binding(3) var<storage, read_write> state : array<f32>;
+@group(0) @binding(4) var<storage, read> roomSizeSignal : array<f32>;
+@group(0) @binding(5) var<storage, read> dampingSignal  : array<f32>;
+@group(0) @binding(6) var<storage, read> wetSignal      : array<f32>;
+@group(0) @binding(7) var<storage, read> drySignal      : array<f32>;
+@group(0) @binding(8) var<storage, read> widthSignal    : array<f32>;
+
+fn tanh(x: f32) -> f32 {
+    let exp2x = exp(2.0f * x);
+    return (exp2x - 1.0f) / (exp2x + 1.0f);
+}
+
+fn is_nan_or_inf(v: f32) -> bool {
+    return (v != v) || (abs(v) > 3.402823466e+38f);
+}
+
+@compute @workgroup_size(1)
+fn main(@builtin(global_invocation_id) gid : vec3<u32>) {
+    if (gid.x != 0u) { return; }
+
+    let numSamples = u32(u.numSamples);
+    let numChannels = u32(u.numChannels);
+    let fixedgain: f32 = 0.015f;
+
+    var bufIndices: array<u32, 24>;
+    var filterStores: array<f32, 24>;
+    var sizes: array<u32, 24>;
+    var startOffsets: array<u32, 24>;
+
+    for (var f = 0u; f < 24u; f = f + 1u) {
+        let metaOffset = f * 4u;
+        sizes[f] = u32(state[metaOffset]);
+        startOffsets[f] = u32(state[metaOffset + 1u]);
+        bufIndices[f] = u32(state[metaOffset + 2u]);
+        var fs = state[metaOffset + 3u];
+        if (is_nan_or_inf(fs)) { fs = 0.0f; }
+        filterStores[f] = fs;
+    }
+
+    if (numChannels == 1u) {
+        for (var index = 0u; index < numSamples; index = index + 1u) {
+            // Dynamic parameter signal evaluation
+            var effRoomSize = u.roomSize;
+            if (u.hasRoomSizeSig > 0.5f) { effRoomSize = roomSizeSignal[index]; }
+            effRoomSize = clamp(effRoomSize, 0.0f, 0.98f);
+
+            var effDamping = u.damping;
+            if (u.hasDampingSig > 0.5f) { effDamping = dampingSignal[index]; }
+            effDamping = clamp(effDamping, 0.0f, 1.0f) * 0.4f;
+
+            var effWet = u.wet;
+            if (u.hasWetSig > 0.5f) { effWet = wetSignal[index]; }
+            effWet = clamp(effWet, 0.0f, 1.0f) * 3.0f;
+
+            var effDry = u.dry;
+            if (u.hasDrySig > 0.5f) { effDry = drySignal[index]; }
+            effDry = clamp(effDry, 0.0f, 2.0f);
+
+            var x = inputChannels[index];
+            if (is_nan_or_inf(x)) { x = 0.0f; }
+            let inputVal = x * fixedgain;
+
+            var combSum = 0.0f;
+            for (var j = 0u; j < 8u; j = j + 1u) {
+                let size = sizes[j];
+                let startOffset = startOffsets[j];
+                let bufferIndex = bufIndices[j];
+                var fs = filterStores[j];
+
+                var output = state[startOffset + bufferIndex];
+                if (is_nan_or_inf(output)) { output = 0.0f; }
+
+                fs = output * (1.0f - effDamping) + fs * effDamping;
+                var nextVal = inputVal + fs * effRoomSize;
+                if (is_nan_or_inf(nextVal)) { nextVal = 0.0f; }
+                state[startOffset + bufferIndex] = clamp(nextVal, -4.0f, 4.0f);
+
+                bufIndices[j] = (bufferIndex + 1u) % size;
+                filterStores[j] = fs;
+                combSum = combSum + output;
+            }
+
+            var revOut = combSum;
+            for (var j = 0u; j < 4u; j = j + 1u) {
+                let f = 8u + j;
+                let size = sizes[f];
+                let startOffset = startOffsets[f];
+                let bufferIndex = bufIndices[f];
+
+                var bufOut = state[startOffset + bufferIndex];
+                if (is_nan_or_inf(bufOut)) { bufOut = 0.0f; }
+
+                var nextVal = revOut + bufOut * 0.5f;
+                if (is_nan_or_inf(nextVal)) { nextVal = 0.0f; }
+                state[startOffset + bufferIndex] = clamp(nextVal, -4.0f, 4.0f);
+
+                let output = bufOut - revOut;
+                bufIndices[f] = (bufferIndex + 1u) % size;
+                revOut = output;
+            }
+
+            var outVal = x * effDry + revOut * effWet;
+            if (is_nan_or_inf(outVal)) { outVal = 0.0f; }
+
+            if (outVal > 1.0f) { outVal = 1.0f; }
+            else if (outVal < -1.0f) { outVal = -1.0f; }
+            else if (outVal > 0.9f) { outVal = 0.9f + 0.1f * tanh((outVal - 0.9f) / 0.1f); }
+            else if (outVal < -0.9f) { outVal = -0.9f + 0.1f * tanh((outVal + 0.9f) / 0.1f); }
+
+            outputChannels[index] = outVal;
+        }
+    } else {
+        for (var index = 0u; index < numSamples; index = index + 1u) {
+            // Dynamic parameter signal evaluation
+            var effRoomSize = u.roomSize;
+            if (u.hasRoomSizeSig > 0.5f) { effRoomSize = roomSizeSignal[index]; }
+            effRoomSize = clamp(effRoomSize, 0.0f, 0.98f);
+
+            var effDamping = u.damping;
+            if (u.hasDampingSig > 0.5f) { effDamping = dampingSignal[index]; }
+            effDamping = clamp(effDamping, 0.0f, 1.0f) * 0.4f;
+
+            var effWet = u.wet;
+            if (u.hasWetSig > 0.5f) { effWet = wetSignal[index]; }
+            effWet = clamp(effWet, 0.0f, 1.0f) * 3.0f;
+
+            var effDry = u.dry;
+            if (u.hasDrySig > 0.5f) { effDry = drySignal[index]; }
+            effDry = clamp(effDry, 0.0f, 2.0f);
+
+            var effWidth = u.width;
+            if (u.hasWidthSig > 0.5f) { effWidth = widthSignal[index]; }
+            effWidth = clamp(effWidth, 0.0f, 1.0f);
+
+            let wet1 = effWet * (effWidth / 2.0f + 0.5f);
+            let wet2 = effWet * ((1.0f - effWidth) / 2.0f);
+
+            var inputL = inputChannels[index];
+            if (is_nan_or_inf(inputL)) { inputL = 0.0f; }
+            var inputR = inputChannels[numSamples + index];
+            if (is_nan_or_inf(inputR)) { inputR = 0.0f; }
+
+            let inputVal = (inputL + inputR) * fixedgain;
+
+            // Left channel (Filters 0-11)
+            var combSumL = 0.0f;
+            for (var j = 0u; j < 8u; j = j + 1u) {
+                let size = sizes[j];
+                let startOffset = startOffsets[j];
+                let bufferIndex = bufIndices[j];
+                var fs = filterStores[j];
+
+                var output = state[startOffset + bufferIndex];
+                if (is_nan_or_inf(output)) { output = 0.0f; }
+
+                fs = output * (1.0f - effDamping) + fs * effDamping;
+                var nextVal = inputVal + fs * effRoomSize;
+                if (is_nan_or_inf(nextVal)) { nextVal = 0.0f; }
+                state[startOffset + bufferIndex] = clamp(nextVal, -4.0f, 4.0f);
+
+                bufIndices[j] = (bufferIndex + 1u) % size;
+                filterStores[j] = fs;
+                combSumL = combSumL + output;
+            }
+            var revOutL = combSumL;
+            for (var j = 0u; j < 4u; j = j + 1u) {
+                let f = 8u + j;
+                let size = sizes[f];
+                let startOffset = startOffsets[f];
+                let bufferIndex = bufIndices[f];
+
+                var bufOut = state[startOffset + bufferIndex];
+                if (is_nan_or_inf(bufOut)) { bufOut = 0.0f; }
+
+                var nextVal = revOutL + bufOut * 0.5f;
+                if (is_nan_or_inf(nextVal)) { nextVal = 0.0f; }
+                state[startOffset + bufferIndex] = clamp(nextVal, -4.0f, 4.0f);
+
+                let output = bufOut - revOutL;
+                bufIndices[f] = (bufferIndex + 1u) % size;
+                revOutL = output;
+            }
+
+            // Right channel (Filters 12-23)
+            var combSumR = 0.0f;
+            for (var j = 0u; j < 8u; j = j + 1u) {
+                let f = 12u + j;
+                let size = sizes[f];
+                let startOffset = startOffsets[f];
+                let bufferIndex = bufIndices[f];
+                var fs = filterStores[f];
+
+                var output = state[startOffset + bufferIndex];
+                if (is_nan_or_inf(output)) { output = 0.0f; }
+
+                fs = output * (1.0f - effDamping) + fs * effDamping;
+                var nextVal = inputVal + fs * effRoomSize;
+                if (is_nan_or_inf(nextVal)) { nextVal = 0.0f; }
+                state[startOffset + bufferIndex] = clamp(nextVal, -4.0f, 4.0f);
+
+                bufIndices[f] = (bufferIndex + 1u) % size;
+                filterStores[f] = fs;
+                combSumR = combSumR + output;
+            }
+            var revOutR = combSumR;
+            for (var j = 0u; j < 4u; j = j + 1u) {
+                let f = 20u + j;
+                let size = sizes[f];
+                let startOffset = startOffsets[f];
+                let bufferIndex = bufIndices[f];
+
+                var bufOut = state[startOffset + bufferIndex];
+                if (is_nan_or_inf(bufOut)) { bufOut = 0.0f; }
+
+                var nextVal = revOutR + bufOut * 0.5f;
+                if (is_nan_or_inf(nextVal)) { nextVal = 0.0f; }
+                state[startOffset + bufferIndex] = clamp(nextVal, -4.0f, 4.0f);
+
+                let output = bufOut - revOutR;
+                bufIndices[f] = (bufferIndex + 1u) % size;
+                revOutR = output;
+            }
+
+            var outL = inputL * effDry + revOutL * wet1 + revOutR * wet2;
+            var outR = inputR * effDry + revOutR * wet1 + revOutL * wet2;
+            if (is_nan_or_inf(outL)) { outL = 0.0f; }
+            if (is_nan_or_inf(outR)) { outR = 0.0f; }
+
+            if (outL > 1.0f) { outL = 1.0f; } else if (outL < -1.0f) { outL = -1.0f; }
+            else if (outL > 0.9f) { outL = 0.9f + 0.1f * tanh((outL - 0.9f) / 0.1f); }
+            else if (outL < -0.9f) { outL = -0.9f + 0.1f * tanh((outL + 0.9f) / 0.1f); }
+
+            if (outR > 1.0f) { outR = 1.0f; } else if (outR < -1.0f) { outR = -1.0f; }
+            else if (outR > 0.9f) { outR = 0.9f + 0.1f * tanh((outR - 0.9f) / 0.1f); }
+            else if (outR < -0.9f) { outR = -0.9f + 0.1f * tanh((outR + 0.9f) / 0.1f); }
+
+            outputChannels[index] = outL;
+            outputChannels[numSamples + index] = outR;
+        }
+    }
+
+    for (var f = 0u; f < 24u; f = f + 1u) {
+        let metaOffset = f * 4u;
+        state[metaOffset + 2u] = f32(bufIndices[f]);
+        state[metaOffset + 3u] = filterStores[f];
+    }
+}
+`;
+const leftCombLengths = [
+	1116,
+	1188,
+	1277,
+	1356,
+	1422,
+	1491,
+	1557,
+	1617
+];
+const leftAllpassLengths = [
+	556,
+	441,
+	341,
+	225
+];
+const reverbAudioProcessor = async (channels, sampleRate, virtualMedia, ctx) => {
+	if (!ctx?.device) throw new Error("GPUDevice is required for WebGPU Reverb.");
+	const op = virtualMedia.operation || {};
+	const inputs = op.inputs || {};
+	const numChannels = channels.length;
+	if (numChannels === 0) return;
+	const numSamples = channels[0].length;
+	if (numSamples === 0) return;
+	const roomSizeInternal = Math.max(0, Math.min(typeof op.roomSize === "number" ? op.roomSize : .5, .98));
+	const dampingInternal = Math.max(0, Math.min(typeof op.damping === "number" ? op.damping : .5, 1));
+	const wetInternal = Math.max(0, Math.min(typeof op.wet === "number" ? op.wet : .3, 1));
+	const dryInternal = Math.max(0, Math.min(typeof op.dry === "number" ? op.dry : 1, 1));
+	const widthInternal = Math.max(0, Math.min(typeof op.width === "number" ? op.width : 1, 1));
+	const isHandleConnected = (handleIdKey) => {
+		const handleId = op[handleIdKey];
+		if (typeof handleId !== "string" || !handleId) return false;
+		const input = inputs[handleId];
+		return Boolean(input?.connectionValid && input.outputItem && (input.outputItem.type === "Signal" || input.outputItem.type === "Number"));
+	};
+	const hasRoomSizeSig = isHandleConnected("roomSizeHandleId") ? 1 : 0;
+	const hasDampingSig = isHandleConnected("dampingHandleId") ? 1 : 0;
+	const hasWetSig = isHandleConnected("wetHandleId") ? 1 : 0;
+	const hasDrySig = isHandleConnected("dryHandleId") ? 1 : 0;
+	const hasWidthSig = isHandleConnected("widthHandleId") ? 1 : 0;
+	const scale = sampleRate / 44100;
+	const nodeId = op.id || "audio-reverb";
+	const frame = ctx.frame ?? 0;
+	const fps = ctx.fps ?? 24;
+	const sizesL = [];
+	const sizesR = [];
+	leftCombLengths.forEach((len) => {
+		sizesL.push(Math.round(len * scale));
+	});
+	leftCombLengths.forEach((len) => {
+		sizesR.push(Math.round((len + 23) * scale));
+	});
+	leftAllpassLengths.forEach((len) => {
+		sizesL.push(Math.round(len * scale));
+	});
+	leftAllpassLengths.forEach((len) => {
+		sizesR.push(Math.round((len + 23) * scale));
+	});
+	const totalMetadataFloats = 96;
+	let totalDelaySamples = 0;
+	const filterSizes = [...sizesL, ...sizesR];
+	for (const size of filterSizes) totalDelaySamples += size;
+	const stateFloatCount = totalMetadataFloats + totalDelaySamples;
+	const metaData = new Float32Array(totalMetadataFloats);
+	let currentOffset = totalMetadataFloats;
+	for (let f = 0; f < 24; f++) {
+		const size = filterSizes[f];
+		metaData[f * 4] = size;
+		metaData[f * 4 + 1] = currentOffset;
+		metaData[f * 4 + 2] = 0;
+		metaData[f * 4 + 3] = 0;
+		currentOffset += size;
+	}
+	await WebGPUAudioProcessor.process(ctx.device, nodeId, channels, sampleRate, virtualMedia, frame, fps, REVERB_SHADER_TEMPLATE, () => [
+		sampleRate,
+		roomSizeInternal,
+		dampingInternal,
+		wetInternal,
+		dryInternal,
+		widthInternal,
+		hasRoomSizeSig,
+		hasDampingSig,
+		hasWetSig,
+		hasDrySig,
+		hasWidthSig,
+		0,
+		frame,
+		numSamples,
+		numChannels,
+		0
+	], 16, stateFloatCount, ctx?.renderId, true, ctx?.elapsedMs, ctx?.durationMs, metaData, void 0, PARAM_ORDER);
+};
+var renderers_default$1 = defineRenderer({ audioProcessor: reverbAudioProcessor });
+
+//#endregion
+//#region ../../nodes/node-stereo-panning/dist/renderers-Csm8iHs7.mjs
+const PANNING_SHADER_TEMPLATE = () => `
+struct Uniforms {
+    sampleRate  : f32,
+    pan         : f32,
+    baseTime    : f32,
+    frame       : f32,
+    numSamples  : f32,
+    numChannels : f32,
+    pad1        : f32,
+    pad2        : f32,
+};
+
+@group(0) @binding(0) var<uniform> u : Uniforms;
+@group(0) @binding(1) var<storage, read> inputChannels : array<f32>;
+@group(0) @binding(2) var<storage, read_write> outputChannels : array<f32>;
+@group(0) @binding(3) var<storage, read_write> state : array<f32>;
+
+@compute @workgroup_size(1)
+fn main(@builtin(global_invocation_id) gid : vec3<u32>) {
+    if (gid.x != 0u) { return; }
+
+    let numSamples = u32(u.numSamples);
+    let numChannels = u32(u.numChannels);
+    
+    let clampedPan = max(-1.0f, min(1.0f, u.pan));
+    var leftGain = 1.0f;
+    var rightGain = 1.0f;
+
+    if (clampedPan < 0.0f) {
+        rightGain = 1.0f + clampedPan;
+    } else if (clampedPan > 0.0f) {
+        leftGain = 1.0f - clampedPan;
+    }
+
+    for (var index = 0u; index < numSamples; index = index + 1u) {
+        if (numChannels > 1u) {
+            outputChannels[index] = inputChannels[index] * leftGain;
+            outputChannels[numSamples + index] = inputChannels[numSamples + index] * rightGain;
+        } else {
+            outputChannels[index] = inputChannels[index] * leftGain;
+        }
+    }
+
+    // Dummy reference to prevent state binding from being optimized out
+    state[0] = state[0];
+}
+`;
+const stereoPanningAudioProcessor = async (channels, sampleRate, node, ctx) => {
+	if (!ctx?.device) throw new Error("GPUDevice is required for WebGPU Stereo Panning.");
+	const pan = node.operation?.pan ?? 0;
+	const clampedPan = Math.max(-1, Math.min(1, pan));
+	if (channels.length === 0) return;
+	const numSamples = channels[0].length;
+	if (numSamples === 0) return;
+	if (channels.length === 1) {
+		const rightChannel = new Float32Array(numSamples);
+		rightChannel.set(channels[0]);
+		channels.push(rightChannel);
+	}
+	const numChannels = channels.length;
+	const nodeId = node.operation?.id || "stereo-panning";
+	const frame = ctx.frame ?? 0;
+	const fps = ctx.fps ?? 24;
+	await WebGPUAudioProcessor.process(ctx.device, nodeId, channels, sampleRate, node, frame, fps, PANNING_SHADER_TEMPLATE, () => [
+		sampleRate,
+		clampedPan,
+		0,
+		frame,
+		numSamples,
+		numChannels,
+		0,
+		0
+	], 8, 1, ctx?.renderId, true, ctx?.elapsedMs, ctx?.durationMs);
+};
+var renderers_default = defineRenderer({ audioProcessor: stereoPanningAudioProcessor });
+
+//#endregion
+//#region src/audio/synth/sfx.ts
+const DEFAULT_DURATION_SEC = {
+	whoosh: .7,
+	riser: 2,
+	impact: 1.8,
+	downshifter: 1.2,
+	glitch: .35
+};
+/** Small, fast, seedable PRNG returning values in [-1, 1). */
+function createNoise(seed) {
+	let state = (seed ^ 2654435769) >>> 0;
+	return () => {
+		state = state + 1831565813 >>> 0;
+		let t = state;
+		t = Math.imul(t ^ t >>> 15, t | 1);
+		t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+		return ((t ^ t >>> 14) >>> 0) / 4294967296 * 2 - 1;
+	};
+}
+/** Chamberlin state-variable filter; returns the band-pass output of one sample. */
+var BandPass = class {
+	low = 0;
+	band = 0;
+	process(input, freq, q, sampleRate) {
+		const f = 2 * Math.sin(Math.PI * Math.min(freq, sampleRate * .45) / sampleRate);
+		this.low += f * this.band;
+		const high = input - this.low - q * this.band;
+		this.band += f * high;
+		return this.band;
+	}
+};
+/** Exponential sweep from `a` to `b` as `x` moves 0 → 1. */
+const expSweep = (a, b, x) => a * (b / a) ** x;
+/** Fast rise, longer fall: a bell centred at `peak` in 0..1. */
+const bell = (x, peak) => x < peak ? Math.sin(x / peak * (Math.PI / 2)) ** 2 : Math.cos((x - peak) / (1 - peak) * (Math.PI / 2)) ** 2;
+function whoosh(n, sr, noise, reverse) {
+	const left = new Float32Array(n);
+	const right = new Float32Array(n);
+	const filter = new BandPass();
+	for (let i = 0; i < n; i++) {
+		const x = i / n;
+		const sweep = reverse ? 1 - x : x;
+		const env = bell(x, reverse ? .35 : .6);
+		const s = filter.process(noise(), expSweep(250, 7e3, sweep), .35, sr) * env * .9;
+		const pan = (reverse ? 1 - x : x) * 2 - 1;
+		left[i] = s * Math.sqrt((1 - pan) / 2) * 1.4;
+		right[i] = s * Math.sqrt((1 + pan) / 2) * 1.4;
+	}
+	return [left, right];
+}
+function riser(n, sr, noise, reverse) {
+	const left = new Float32Array(n);
+	const right = new Float32Array(n);
+	const air = new BandPass();
+	let phase = 0;
+	for (let i = 0; i < n; i++) {
+		const x = i / n;
+		const sweep = reverse ? 1 - x : x;
+		const env = reverse ? (1 - x) ** 1.5 : x ** 2.2;
+		const freq = expSweep(110, 880, sweep);
+		phase += 2 * Math.PI * freq / sr;
+		const s = ((Math.sin(phase) + .5 * Math.sin(phase * 2) + .25 * Math.sin(phase * 3)) * .3 + air.process(noise(), expSweep(300, 9e3, sweep), .5, sr) * 1.2) * env * .6;
+		left[i] = s;
+		right[i] = s;
+	}
+	return [left, right];
+}
+function impact(n, sr, noise) {
+	const left = new Float32Array(n);
+	const right = new Float32Array(n);
+	const burst = new BandPass();
+	let phase = 0;
+	for (let i = 0; i < n; i++) {
+		const t = i / sr;
+		const freq = 38 + 62 * Math.exp(-t * 14);
+		phase += 2 * Math.PI * freq / sr;
+		const sub = Math.sin(phase) * Math.exp(-t * 2.6);
+		const body = burst.process(noise(), 900 * Math.exp(-t * 6) + 120, .6, sr) * Math.exp(-t * 9) * 1.6;
+		const click = i < 96 ? noise() * (1 - i / 96) * .5 : 0;
+		const s = (sub * 1.1 + body + click) * .85;
+		const tail = noise() * Math.exp(-t * 5) * .08;
+		left[i] = s + tail;
+		right[i] = s - tail;
+	}
+	return [left, right];
+}
+function glitch(n, sr, noise) {
+	const left = new Float32Array(n);
+	const right = new Float32Array(n);
+	const slice = Math.max(1, Math.round(sr * .022));
+	let held = 0;
+	let gate = 1;
+	let crush = 1;
+	for (let i = 0; i < n; i++) {
+		if (i % slice === 0) {
+			gate = noise() > -.2 ? 1 : 0;
+			crush = 2 + Math.floor((noise() + 1) * 6);
+		}
+		if (i % crush === 0) held = noise() > 0 ? 1 : -1;
+		const env = 1 - i / n;
+		const s = held * gate * env * .45;
+		left[i] = s;
+		right[i] = gate ? -s * .6 : 0;
+	}
+	return [left, right];
+}
+/**
+* Renders one trigger to stereo PCM positioned at `atBar` on the score timeline.
+* `atBar` is where the effect *starts*; a riser meant to land on a cut starts
+* `durationSec / secondsPerBar` bars before it.
+*/
+function renderSfx(trigger, ctx) {
+	const durationSec = trigger.durationSec ?? DEFAULT_DURATION_SEC[trigger.type];
+	const sr = ctx.sampleRate;
+	const n = Math.max(1, Math.round(durationSec * sr));
+	const noise = createNoise(ctx.seed + n);
+	let channels;
+	switch (trigger.type) {
+		case "whoosh":
+			channels = whoosh(n, sr, noise, false);
+			break;
+		case "riser":
+			channels = riser(n, sr, noise, false);
+			break;
+		case "downshifter":
+			channels = riser(n, sr, noise, true);
+			break;
+		case "impact":
+			channels = impact(n, sr, noise);
+			break;
+		case "glitch":
+			channels = glitch(n, sr, noise);
+			break;
+	}
+	const gain = trigger.volume ?? .8;
+	for (const channel of channels) for (let i = 0; i < n; i++) channel[i] = Math.tanh((channel[i] ?? 0) * gain);
+	return {
+		startSample: Math.max(0, Math.round(trigger.atBar * ctx.secondsPerBar * sr)),
+		channels
+	};
+}
+/** Adds rendered effects into `target` in place, clipping to its length. */
+function mixSfxInto(target, effects) {
+	for (const fx of effects) for (let c = 0; c < 2; c++) {
+		const dst = target[c];
+		const src = fx.channels[c];
+		if (!dst || !src) continue;
+		const limit = Math.min(src.length, dst.length - fx.startSample);
+		for (let i = 0; i < limit; i++) {
+			const val = dst[fx.startSample + i];
+			const s = src[i];
+			if (val !== void 0 && s !== void 0) dst[fx.startSample + i] = val + s;
+		}
+	}
+}
+/**
+* Soft-knee limiter for sums that may exceed full scale (impacts stacked on a
+* loud mix): transparent below the knee, asymptotically bounded by 1.0 above it.
+*/
+function softLimit(target, knee = .7, ceiling = .97) {
+	const headroom = ceiling - knee;
+	for (const channel of target) for (let i = 0; i < channel.length; i++) {
+		const x = channel[i] ?? 0;
+		const a = Math.abs(x);
+		if (a > knee) channel[i] = Math.sign(x) * (knee + headroom * Math.tanh((a - knee) / headroom));
+	}
+}
+
+//#endregion
+//#region src/audio/synth/wav-encoder.ts
+/**
+* Encodes stereo Float32Array PCM channels (-1.0 to +1.0) into a standard 16-bit RIFF/WAVE Buffer.
+*/
+function encodeStereoWav(channels, options = {}) {
+	const sampleRate = options.sampleRate ?? 48e3;
+	const numChannels = 2;
+	const left = channels[0];
+	const right = channels[1];
+	const numSamples = Math.min(left.length, right.length);
+	const blockAlign = numChannels * 2;
+	const byteRate = sampleRate * blockAlign;
+	const dataSize = numSamples * blockAlign;
+	const totalSize = 44 + dataSize;
+	const buffer = Buffer.alloc(totalSize);
+	buffer.write("RIFF", 0, "ascii");
+	buffer.writeUInt32LE(36 + dataSize, 4);
+	buffer.write("WAVE", 8, "ascii");
+	buffer.write("fmt ", 12, "ascii");
+	buffer.writeUInt32LE(16, 16);
+	buffer.writeUInt16LE(1, 20);
+	buffer.writeUInt16LE(numChannels, 22);
+	buffer.writeUInt32LE(sampleRate, 24);
+	buffer.writeUInt32LE(byteRate, 28);
+	buffer.writeUInt16LE(blockAlign, 32);
+	buffer.writeUInt16LE(16, 34);
+	buffer.write("data", 36, "ascii");
+	buffer.writeUInt32LE(dataSize, 40);
+	let offset = 44;
+	for (let i = 0; i < numSamples; i++) {
+		const sl = Math.max(-1, Math.min(1, left[i] ?? 0));
+		const intL = sl < 0 ? sl * 32768 : sl * 32767;
+		buffer.writeInt16LE(Math.round(intL), offset);
+		offset += 2;
+		const sr = Math.max(-1, Math.min(1, right[i] ?? 0));
+		const intR = sr < 0 ? sr * 32768 : sr * 32767;
+		buffer.writeInt16LE(Math.round(intR), offset);
+		offset += 2;
+	}
+	return buffer;
+}
+
+//#endregion
+export { renderers_default as a, renderers_default$3 as c, renderers_default$6 as d, softLimit as i, renderers_default$4 as l, mixSfxInto as n, renderers_default$1 as o, renderSfx as r, renderers_default$2 as s, encodeStereoWav as t, renderers_default$5 as u };
+//# sourceMappingURL=audio-C4kiPbrV.mjs.map