@denaudio/den 0.0.0-stage → 0.2.0

package/dist/formant-bank.d.ts

@@ -0,0 +1,15 @@
+import { type Node } from '@unworklet/core';
+export interface FormantBand {
+    frequencyHz: number;
+    q: number;
+    gain: number;
+}
+export interface FormantBankConfig {
+    sampleRate: number;
+    bands: readonly FormantBand[];
+}
+/** Fixed 1–8 parallel, unity-peak bandpasses. A resonator bank, not a speech synthesizer. */
+export declare const formantBank: import("@unworklet/core").SubgraphDecl<[config: FormantBankConfig], {
+    /** Linear frequency ratio [.25,4] and Q scale [.25,4]; per-band cutoff/Q limits still apply. */
+    tick(input: Node<"f32">, frequencyRatio: Node<"f32">, resonanceScale: Node<"f32">, reset: Node<"bool">): Node<"f32">;
+}>;

package/dist/formant-bank.js

@@ -0,0 +1,28 @@
+import { defineSubgraph, f32, instantiate } from '@unworklet/core';
+import { stateVariableFilter } from './state-variable-filter.js';
+import { checkedSampleRate } from './catalog-filter-math.js';
+/** Fixed 1–8 parallel, unity-peak bandpasses. A resonator bank, not a speech synthesizer. */
+export const formantBank = defineSubgraph((config) => {
+    const maximum = checkedSampleRate(config.sampleRate);
+    if (!Array.isArray(config.bands) || config.bands.length < 1 || config.bands.length > 8)
+        throw new RangeError('formant bank requires 1–8 fixed bands');
+    const bands = config.bands.map((band, index) => {
+        if (!Number.isFinite(band.frequencyHz) || band.frequencyHz < 20 || band.frequencyHz > maximum ||
+            !Number.isFinite(band.q) || band.q < .5 || band.q > 10 || !Number.isFinite(band.gain) || Math.abs(band.gain) > 1) {
+            throw new RangeError('formant band frequency/Q/gain is outside its supported bounds');
+        }
+        return { frequencyHz: band.frequencyHz, q: band.q, gain: band.gain,
+            filter: instantiate(stateVariableFilter, { sampleRate: config.sampleRate }, { name: `band${index}` }) };
+    });
+    return {
+        /** Linear frequency ratio [.25,4] and Q scale [.25,4]; per-band cutoff/Q limits still apply. */
+        tick(input, frequencyRatio, resonanceScale, reset) {
+            let output = f32(0);
+            for (const band of bands) {
+                const response = band.filter.tick(input, frequencyRatio.clamp(.25, 4).mul(band.frequencyHz), resonanceScale.clamp(.25, 4).mul(band.q), reset);
+                output = output.add(response.bandpass.mul(band.gain));
+            }
+            return output;
+        },
+    };
+});

package/dist/freeze-reverb.d.ts

@@ -0,0 +1,35 @@
+import { type Node } from '@unworklet/core';
+export interface FreezeReverbConfig {
+    /** Match ctx.sampleRate; integer 8000..192000. */
+    sampleRate: number;
+    /** Fixed delay-length scale, [0.5,2], default 1. Rebuild to change. */
+    roomScale?: number;
+    /** Fixed nominal loop-loss time, [0.1,10] seconds, default 1.5.
+     * Describes the unfrozen network, not a frozen-tail duration. */
+    decaySeconds?: number;
+    /** Samples from fully live to fully frozen, or back; integer 0..192000.
+     * Default 256. Zero switches immediately and may click. Reversals continue
+     * from the current integer progress, without restarting the ramp. */
+    transitionSamples?: number;
+}
+export interface FreezeReverbControls {
+    /** Level control: ramp to muted excitation + unity feedback while true. */
+    freeze: Node<'bool'>;
+    /** Highest priority: output silence, discard current excitation, invalidate
+     * all delay history and set progress to live. Held reset keeps doing this. */
+    reset: Node<'bool'>;
+}
+/** Wet-only four-line integer-delay FDN. Call tick exactly once per sample.
+ * The fully frozen, unforced real-arithmetic network preserves stored energy.
+ * Actual f64 state has rounding and very-small-state limits, not perpetual
+ * exact energy. Finite normalized inputs and adequate output headroom required.
+ * No interpolation, damping filter, shimmer, limiter, dry path or normalization.
+ */
+export declare const freezeReverb: import("@unworklet/core").SubgraphDecl<[config: FreezeReverbConfig], {
+    tick(inputLeft: Node<"f32">, inputRight: Node<"f32">, c: FreezeReverbControls): {
+        left: Node<"f32">;
+        right: Node<"f32">;
+        freezeAmount: Node<"f32">;
+        frozen: Node<"bool">;
+    };
+}>;

package/dist/freeze-reverb.js

@@ -0,0 +1,61 @@
+import { defineSubgraph, f32, f64, i32, select, state } from '@unworklet/core';
+// Exact binary representation scaling, not audio normalization. Keeps the
+// smallest f32 excitations above the native tiny-state scrub threshold.
+const SCALE = 2 ** 256;
+const ROWS = [[1, 1, 1, 1], [1, -1, 1, -1], [1, 1, -1, -1], [1, -1, -1, 1]];
+/** Wet-only four-line integer-delay FDN. Call tick exactly once per sample.
+ * The fully frozen, unforced real-arithmetic network preserves stored energy.
+ * Actual f64 state has rounding and very-small-state limits, not perpetual
+ * exact energy. Finite normalized inputs and adequate output headroom required.
+ * No interpolation, damping filter, shimmer, limiter, dry path or normalization.
+ */
+export const freezeReverb = defineSubgraph((config) => {
+    const { sampleRate, roomScale = 1, decaySeconds = 1.5, transitionSamples = 256 } = config;
+    if (!Number.isInteger(sampleRate) || sampleRate < 8000 || sampleRate > 192000 ||
+        !Number.isFinite(roomScale) || roomScale < 0.5 || roomScale > 2 ||
+        !Number.isFinite(decaySeconds) || decaySeconds < 0.1 || decaySeconds > 10 ||
+        !Number.isInteger(transitionSamples) || transitionSamples < 0 || transitionSamples > 192000) {
+        throw new RangeError('freezeReverb requires integer sampleRate [8000,192000], roomScale [0.5,2], decaySeconds [0.1,10], integer transitionSamples [0,192000]');
+    }
+    const steps = Math.max(1, transitionSamples);
+    const progress = state.i32(0).named('freezeProgress');
+    const lines = [0.0297, 0.0371, 0.0411, 0.0437].map((seconds, index) => {
+        const size = Math.round(seconds * roomScale * sampleRate);
+        return {
+            size,
+            gain: 10 ** (-3 * size / (sampleRate * decaySeconds)),
+            history: state.buffer.f64({ size }).expose({ name: `line${index}/historyScaled`, snapshot: 'persistent' }),
+            cursor: state.i32(0).named(`line${index}/cursor`),
+            valid: state.i32(0).named(`line${index}/valid`),
+            wet: state.f64(0).expose({ name: `line${index}/wetScaled`, snapshot: 'transient' }),
+        };
+    });
+    return {
+        tick(inputLeft, inputRight, c) {
+            const next = transitionSamples === 0
+                ? select(c.freeze, i32(1), i32(0))
+                : select(c.freeze, select(progress.read().lt(steps), progress.read().add(1), i32(steps)), select(progress.read().gt(0), progress.read().sub(1), i32(0)));
+            progress.write(select(c.reset, i32(0), next));
+            const amount = f64(progress.read()).div(steps);
+            const excitation = f64(1).sub(amount);
+            // Materialize every outgoing sample before any buffer write. Integer
+            // cursors avoid the fractional seconds/interpolation of delayReadhead.
+            for (const line of lines) {
+                line.wet.write(select(c.reset.or(line.valid.read().lt(line.size)), f64(0), line.history.read(line.cursor.read())));
+            }
+            const returns = lines.map(line => line.wet.read().mul(amount.add(excitation.mul(line.gain))));
+            const left = select(c.reset, f64(0), f64(inputLeft).mul(SCALE).mul(excitation));
+            const right = select(c.reset, f64(0), f64(inputRight).mul(SCALE).mul(excitation));
+            for (let row = 0; row < lines.length; row++) {
+                const line = lines[row];
+                const feedback = returns.reduce((sum, value, column) => sum.add(value.mul(ROWS[row][column] * 0.5)), f64(0));
+                const injection = left.add(right.mul(ROWS[1][row])).mul(0.5);
+                line.history.write(select(c.reset, i32(0), line.cursor.read()), injection.add(feedback));
+                line.cursor.write(select(c.reset, i32(0), select(line.cursor.read().eq(line.size - 1), i32(0), line.cursor.read().add(1))));
+                line.valid.write(select(c.reset, i32(0), select(line.valid.read().lt(line.size), line.valid.read().add(1), i32(line.size))));
+            }
+            const output = (row) => f32(lines.reduce((sum, line, column) => sum.add(line.wet.read().mul(ROWS[row][column] * 0.5)), f64(0)).div(SCALE));
+            return { left: output(2), right: output(3), freezeAmount: f32(amount), frozen: progress.read().eq(steps) };
+        },
+    };
+});

package/dist/frequency-shifter.d.ts

@@ -0,0 +1,24 @@
+import { type Node } from '@unworklet/core';
+/** Matched real/Hilbert group delay; the FIR transient spans 63 samples. */
+export declare const FREQUENCY_SHIFTER_LATENCY_SAMPLES = 31;
+export interface FrequencyShifterConfig {
+    sampleRate: number;
+}
+export interface FrequencyShifterControls {
+    /** Signed Hz, clamped to [-sampleRate/4, sampleRate/4]. Zero holds phase. */
+    shiftHz: Node<'f32'>;
+    /** Linear, latency-aligned dry/wet blend, clamped to [0,1]. */
+    mix: Node<'f32'>;
+    /** Select delayed dry; history and oscillator continue running. */
+    bypass: Node<'bool'>;
+    /** Level reset: silence/discard this sample, clear history and phase. */
+    reset: Node<'bool'>;
+}
+/** Fixed 63-tap Blackman Hilbert frequency shifter. Call once per sample.
+ * Finite controls and normalized finite input [-1,1] required. Output may exceed
+ * unity. Approximate single-sideband behavior only in the documented useful
+ * band; there is no input bandpass, antialiasing, pitch-ratio or time stretching.
+ */
+export declare const frequencyShifter: import("@unworklet/core").SubgraphDecl<[config: FrequencyShifterConfig], {
+    tick(input: Node<"f32">, c: FrequencyShifterControls): Node<"f32">;
+}>;

package/dist/frequency-shifter.js

@@ -0,0 +1,57 @@
+import { defineSubgraph, f32, f64, i32, select, state } from '@unworklet/core';
+/** Matched real/Hilbert group delay; the FIR transient spans 63 samples. */
+export const FREQUENCY_SHIFTER_LATENCY_SAMPLES = 31;
+// Full-cycle degree-15 sine with f64 arithmetic and a <7e-12 remainder.
+function sine(cycles) {
+    const p = cycles.sub(cycles.add(0.5).floor());
+    const folded = select(p.gt(0.25), f64(0.5).sub(p), select(p.lt(-0.25), f64(-0.5).sub(p), p));
+    const angle = folded.mul(2 * Math.PI), square = angle.mul(angle);
+    return angle.mul(f64(-1 / 1307674368000).mul(square).add(1 / 6227020800).mul(square).sub(1 / 39916800)
+        .mul(square).add(1 / 362880).mul(square).sub(1 / 5040)
+        .mul(square).add(1 / 120).mul(square).sub(1 / 6).mul(square).add(1));
+}
+/** Fixed 63-tap Blackman Hilbert frequency shifter. Call once per sample.
+ * Finite controls and normalized finite input [-1,1] required. Output may exceed
+ * unity. Approximate single-sideband behavior only in the documented useful
+ * band; there is no input bandpass, antialiasing, pitch-ratio or time stretching.
+ */
+export const frequencyShifter = defineSubgraph((config) => {
+    const { sampleRate } = config;
+    if (!Number.isInteger(sampleRate) || sampleRate < 8000 || sampleRate > 192000) {
+        throw new RangeError('frequencyShifter requires an integer sampleRate in [8000,192000]');
+    }
+    const delay = FREQUENCY_SHIFTER_LATENCY_SAMPLES, size = 63;
+    // Public 0.4.1 scrubs buffer writes below 1e-30. Exact power-of-two scaling
+    // preserves the full finite normalized f32 input range, including subnormals.
+    const scale = 2 ** 128;
+    const history = state.buffer.f64({ size }).expose({ name: 'historyScaled', snapshot: 'persistent' });
+    const cursor = state.i32(0).named('cursor');
+    const valid = state.i32(0).named('valid');
+    // Centered scaled phase also preserves tiny signed increments near zero.
+    // As with any f64 accumulator, increments below its current ULP can stall.
+    const phase = state.f64(0).named('phaseScaled');
+    const quadrature = state.f64(0).expose({ name: 'quadratureScaled', snapshot: 'transient' });
+    return {
+        tick(input, c) {
+            valid.write(select(c.reset, i32(0), valid.read().add(1).min(size)));
+            history.write(cursor.read(), f64(select(c.reset, f32(0), input)).mul(scale));
+            const at = (lag) => select(valid.read().gt(lag), history.read(cursor.read().add(size - lag).mod(size)), f64(0));
+            quadrature.write(0);
+            // Odd antisymmetric taps. The Blackman endpoints are exactly zero;
+            // pair differences reduce the 63-tap FIR to 15 bounded multiply-adds.
+            for (let offset = 1; offset < delay; offset += 2) {
+                const window = 0.42 + 0.5 * Math.cos(Math.PI * offset / delay) + 0.08 * Math.cos(2 * Math.PI * offset / delay);
+                quadrature.write(quadrature.read().add(at(delay + offset).sub(at(delay - offset)).mul(2 * window / (Math.PI * offset))));
+            }
+            const dry = at(delay), p = select(c.reset, f64(0), phase.read().div(scale));
+            const wet = dry.mul(sine(p.add(0.25))).sub(quadrature.read().mul(sine(p)));
+            const mix = f64(c.mix).clamp(0, 1);
+            const output = select(c.bypass, dry, dry.mul(f64(1).sub(mix)).add(wet.mul(mix)));
+            const next = p.add(f64(c.shiftHz).clamp(-sampleRate / 4, sampleRate / 4).div(sampleRate));
+            // A held reset holds phase zero; the first subsequent sample uses zero.
+            phase.write(select(c.reset, f64(0), next.sub(next.add(0.5).floor()).mul(scale)));
+            cursor.write(cursor.read().add(1).mod(size));
+            return select(c.reset, f32(0), f32(output.div(scale)));
+        },
+    };
+});

package/dist/gate.d.ts

@@ -0,0 +1,2 @@
+/** One-sample memory with gain: only an entry-path verification fixture. */
+export declare const gate: import("@unworklet/core").CompiledProcessor<unknown>;

package/dist/gate.js

@@ -0,0 +1,12 @@
+import { audioInput, audioOutput, defineProcessor, forSample, instantiate, param } from '@unworklet/core';
+import { gateCell } from './index.js';
+/** One-sample memory with gain: only an entry-path verification fixture. */
+export const gate = defineProcessor(() => {
+    const input = audioInput({ channels: 1, name: 'main' });
+    const output = audioOutput({ channels: 1, name: 'main' });
+    const gain = param.f32({ default: 0.5, min: 0, max: 1, automationRate: 'a-rate' }).named('gain');
+    const cell = instantiate(gateCell, { scale: 1 }, { name: 'cell' });
+    return { process() {
+            forSample(i => output.ch(0).at(i).write(cell.tick(input.ch(0).at(i), gain.at(i))));
+        } };
+}, { id: 'den.entry.gate.v1' });

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+import { type Node } from '@unworklet/core';
+/** Minimal composition fixture, not a production DSP module. Required config avoids upstream #104. */
+export declare const gateCell: import("@unworklet/core").SubgraphDecl<[config: {
+    scale: number;
+}], {
+    tick(input: Node<"f32">, gain: Node<"f32">): Node<"f32">;
+}>;

package/dist/index.js

@@ -0,0 +1,12 @@
+import { defineSubgraph, state } from '@unworklet/core';
+/** Minimal composition fixture, not a production DSP module. Required config avoids upstream #104. */
+export const gateCell = defineSubgraph((config) => {
+    const previous = state.f32(0).named('previous');
+    return {
+        tick(input, gain) {
+            const output = previous.read().mul(gain).mul(config.scale);
+            previous.write(input);
+            return output;
+        },
+    };
+});

package/dist/instrument-example.d.ts

@@ -0,0 +1,12 @@
+import { type Node } from '@unworklet/core';
+import type { OscillatorConfig } from './oscillator.js';
+import type { FilterConfig } from './filter.js';
+/** Replacement demonstration: half-level sine using unworklet's math primitive. */
+export declare const exampleOscillator: import("@unworklet/core").SubgraphDecl<[config: OscillatorConfig], {
+    tick(frequency: Node<"f32">, reset: Node<"bool">): Node<"f32">;
+}>;
+/** Replacement demonstration: one-pole low-pass, intentionally ignores Q. */
+export declare const exampleFilter: import("@unworklet/core").SubgraphDecl<[config: FilterConfig], {
+    tick(input: Node<"f32">, cutoff: Node<"f32">, _q: Node<"f32">, reset: Node<"bool">): Node<"f32">;
+}>;
+export declare const replacementInstrument: import("@unworklet/core").CompiledProcessor<unknown>;

package/dist/instrument-example.js

@@ -0,0 +1,29 @@
+import { defineSubgraph, f32, f64, select, state } from '@unworklet/core';
+import { createInstrument } from './instrument.js';
+/** Replacement demonstration: half-level sine using unworklet's math primitive. */
+export const exampleOscillator = defineSubgraph((config) => {
+    if (config.waveform !== 'sine')
+        throw new RangeError('exampleOscillator supports sine only');
+    const phase = state.f64(0).named('phase');
+    return { tick(frequency, reset) {
+            const p = select(reset, f64(0), phase.read());
+            phase.write(p.add(f64(frequency.clamp(0, 0.45 * config.sampleRate)).div(config.sampleRate)).frac());
+            return f32(p.mul(2 * Math.PI).sin()).mul(0.5);
+        } };
+});
+/** Replacement demonstration: one-pole low-pass, intentionally ignores Q. */
+export const exampleFilter = defineSubgraph((config) => {
+    const previous = state.f64(0).named('previous');
+    return { tick(input, cutoff, _q, reset) {
+            // Backward Euler one-pole: alpha = w/(1+w), w=2*pi*fc/fs.
+            const w = f64(cutoff.clamp(20, Math.min(20000, 0.45 * config.sampleRate))).mul(2 * Math.PI / config.sampleRate);
+            const old = select(reset, f64(0), previous.read());
+            const output = old.add(w.div(w.add(1)).mul(f64(input).sub(old)));
+            previous.write(output);
+            return f32(output);
+        } };
+});
+export const replacementInstrument = createInstrument({
+    mode: 'poly', capacity: 4, heldCapacity: 32, waveform: 'sine',
+    oscillator: exampleOscillator, filter: exampleFilter,
+});

package/dist/instrument-settings.d.ts

@@ -0,0 +1,95 @@
+/** CANDIDATE: low saw body, brief filter transient, last-held mono legato. */
+export declare const bassConfig: {
+    readonly mode: "mono";
+    readonly capacity: 1;
+    readonly heldCapacity: 32;
+    readonly legato: true;
+    readonly waveform: "saw";
+};
+export declare const bassParameters: {
+    readonly gain: 0.12;
+    readonly ampAttack: 0.005;
+    readonly ampDecay: 0.12;
+    readonly ampSustain: 0.7;
+    readonly ampRelease: 0.12;
+    readonly pitchAttack: 0;
+    readonly pitchDecay: 0;
+    readonly pitchSustain: 0;
+    readonly pitchRelease: 0;
+    readonly filterAttack: 0.003;
+    readonly filterDecay: 0.18;
+    readonly filterSustain: 0.2;
+    readonly filterRelease: 0.12;
+    readonly cutoff: 300;
+    readonly resonance: 0.707;
+    readonly pitchEnvelopeDepth: 0;
+    readonly filterEnvelopeDepth: 3;
+    readonly lfoRate: 0;
+    readonly lfoAmpDepth: 0;
+    readonly lfoPitchDepth: 0;
+    readonly lfoFilterDepth: 0;
+    readonly bypass: 0;
+};
+/** CANDIDATE: tonal kick/tom body, two-octave pitch drop, retriggered hits. */
+export declare const percussionConfig: {
+    readonly mode: "mono";
+    readonly capacity: 1;
+    readonly heldCapacity: 32;
+    readonly legato: false;
+    readonly waveform: "sine";
+};
+export declare const percussionParameters: {
+    readonly gain: 0.16;
+    readonly ampAttack: 0.001;
+    readonly ampDecay: 0.22;
+    readonly ampSustain: 0;
+    readonly ampRelease: 0.04;
+    readonly pitchAttack: 0;
+    readonly pitchDecay: 0.06;
+    readonly pitchSustain: 0;
+    readonly pitchRelease: 0.04;
+    readonly filterAttack: 0;
+    readonly filterDecay: 0.08;
+    readonly filterSustain: 0;
+    readonly filterRelease: 0.04;
+    readonly cutoff: 800;
+    readonly resonance: 0.5;
+    readonly pitchEnvelopeDepth: 24;
+    readonly filterEnvelopeDepth: 2;
+    readonly lfoRate: 0;
+    readonly lfoAmpDepth: 0;
+    readonly lfoPitchDepth: 0;
+    readonly lfoFilterDepth: 0;
+    readonly bypass: 0;
+};
+/** CANDIDATE: four saw voices, slow rise/release and shared slow modulation. */
+export declare const padConfig: {
+    readonly mode: "poly";
+    readonly capacity: 4;
+    readonly heldCapacity: 32;
+    readonly waveform: "saw";
+};
+export declare const padParameters: {
+    readonly gain: 0.045;
+    readonly ampAttack: 0.8;
+    readonly ampDecay: 1.2;
+    readonly ampSustain: 0.7;
+    readonly ampRelease: 2.4;
+    readonly pitchAttack: 0;
+    readonly pitchDecay: 0;
+    readonly pitchSustain: 0;
+    readonly pitchRelease: 0;
+    readonly filterAttack: 1.4;
+    readonly filterDecay: 1.6;
+    readonly filterSustain: 0.5;
+    readonly filterRelease: 2.4;
+    readonly cutoff: 1400;
+    readonly resonance: 0.5;
+    readonly pitchEnvelopeDepth: 0;
+    readonly filterEnvelopeDepth: 0.75;
+    readonly lfoRate: 0.12;
+    readonly lfoAmpDepth: 0.08;
+    readonly lfoPitchDepth: 0.03;
+    readonly lfoFilterDepth: 0.2;
+    readonly bypass: 0;
+};

package/dist/instrument-settings.js

@@ -0,0 +1,36 @@
+/** CANDIDATE: low saw body, brief filter transient, last-held mono legato. */
+export const bassConfig = {
+    mode: 'mono', capacity: 1, heldCapacity: 32, legato: true, waveform: 'saw',
+};
+export const bassParameters = {
+    gain: 0.12,
+    ampAttack: 0.005, ampDecay: 0.12, ampSustain: 0.7, ampRelease: 0.12,
+    pitchAttack: 0, pitchDecay: 0, pitchSustain: 0, pitchRelease: 0,
+    filterAttack: 0.003, filterDecay: 0.18, filterSustain: 0.2, filterRelease: 0.12,
+    cutoff: 300, resonance: 0.707, pitchEnvelopeDepth: 0, filterEnvelopeDepth: 3,
+    lfoRate: 0, lfoAmpDepth: 0, lfoPitchDepth: 0, lfoFilterDepth: 0, bypass: 0,
+};
+/** CANDIDATE: tonal kick/tom body, two-octave pitch drop, retriggered hits. */
+export const percussionConfig = {
+    mode: 'mono', capacity: 1, heldCapacity: 32, legato: false, waveform: 'sine',
+};
+export const percussionParameters = {
+    gain: 0.16,
+    ampAttack: 0.001, ampDecay: 0.22, ampSustain: 0, ampRelease: 0.04,
+    pitchAttack: 0, pitchDecay: 0.06, pitchSustain: 0, pitchRelease: 0.04,
+    filterAttack: 0, filterDecay: 0.08, filterSustain: 0, filterRelease: 0.04,
+    cutoff: 800, resonance: 0.5, pitchEnvelopeDepth: 24, filterEnvelopeDepth: 2,
+    lfoRate: 0, lfoAmpDepth: 0, lfoPitchDepth: 0, lfoFilterDepth: 0, bypass: 0,
+};
+/** CANDIDATE: four saw voices, slow rise/release and shared slow modulation. */
+export const padConfig = {
+    mode: 'poly', capacity: 4, heldCapacity: 32, waveform: 'saw',
+};
+export const padParameters = {
+    gain: 0.045,
+    ampAttack: 0.8, ampDecay: 1.2, ampSustain: 0.7, ampRelease: 2.4,
+    pitchAttack: 0, pitchDecay: 0, pitchSustain: 0, pitchRelease: 0,
+    filterAttack: 1.4, filterDecay: 1.6, filterSustain: 0.5, filterRelease: 2.4,
+    cutoff: 1400, resonance: 0.5, pitchEnvelopeDepth: 0, filterEnvelopeDepth: 0.75,
+    lfoRate: 0.12, lfoAmpDepth: 0.08, lfoPitchDepth: 0.03, lfoFilterDepth: 0.2, bypass: 0,
+};

package/dist/instrument.d.ts

@@ -0,0 +1,42 @@
+import { oscillator } from './oscillator.js';
+import { filter } from './filter.js';
+import { type VoicePolicyConfig } from './voice-policy.js';
+export { bassConfig, bassParameters, percussionConfig, percussionParameters, padConfig, padParameters } from './instrument-settings.js';
+export interface InstrumentConfig extends VoicePolicyConfig {
+    waveform?: 'sine' | 'saw';
+    /** Compatible unworklet subgraphs, instantiated independently for each voice. */
+    oscillator?: typeof oscillator;
+    filter?: typeof filter;
+}
+/** Diagnostic initial AudioParam values, not an approved preset or a preset format. */
+export declare const diagnosticInstrumentParameters: {
+    readonly gain: 0.15;
+    readonly ampAttack: 0.005;
+    readonly ampDecay: 0.08;
+    readonly ampSustain: 0.7;
+    readonly ampRelease: 0.15;
+    readonly pitchAttack: 0;
+    readonly pitchDecay: 0.1;
+    readonly pitchSustain: 0;
+    readonly pitchRelease: 0.1;
+    readonly filterAttack: 0.01;
+    readonly filterDecay: 0.15;
+    readonly filterSustain: 0.2;
+    readonly filterRelease: 0.15;
+    readonly cutoff: 2500;
+    readonly resonance: 0.707;
+    readonly pitchEnvelopeDepth: 0;
+    readonly filterEnvelopeDepth: 1;
+    readonly lfoRate: 2;
+    readonly lfoAmpDepth: 0;
+    readonly lfoPitchDepth: 0;
+    readonly lfoFilterDepth: 0;
+    readonly bypass: 0;
+};
+/** MIDI input `midi`, stereo dual-mono output `main`, panic message `reset`.
+ * Capacities/mode/waveform/parts are construction choices; all musical controls
+ * use native AudioParams. See docs/instrument.md for timing and reset semantics.
+ */
+export declare function createInstrument(config: InstrumentConfig): import("@unworklet/core").CompiledProcessor<unknown>;
+/** Diagnostic default: four voices, configurable at construction. */
+export declare const instrument: import("@unworklet/core").CompiledProcessor<unknown>;