@denaudio/den 0.0.0-stage → 0.1.0

package/dist/resident-time-stretch.d.ts

@@ -0,0 +1,44 @@
+import { type EveryNSamples, type Node } from '@unworklet/core';
+import type { ResidentSample } from './sample.js';
+export interface ResidentTimeStretchConfig {
+    /** Match ctx.sampleRate; integer 8000..192000. */
+    sampleRate: number;
+    /** Resident sourceSampleRate must also be an integer in [8000,192000]. */
+    sample: ResidentSample;
+    /** Fixed synthesis hop. Window length is twice this value; default 256. */
+    hopSamples?: 128 | 256;
+    /** Integer source-frame offsets searched, independently of source rate.
+     * Zero disables alignment. Default 64; compare 64 points per candidate. */
+    searchFrames?: 0 | 8 | 16 | 32 | 64 | 128;
+}
+export interface ResidentTimeStretchControls {
+    gate: Node<'bool'>;
+    /** Level-sensitive request. Starts at the next global hop boundary while
+     * gate stays high. Held trigger restarts each hop; it can click. */
+    trigger: Node<'bool'>;
+    /** Silences/cancels now. Does not rephase the global hop clock. */
+    reset: Node<'bool'>;
+    /** Output duration / original duration, [0.5,2], latched at actual launch.
+     * Invalid values reject that launch. Changes need a fresh trigger. */
+    durationScale: Node<'f32'>;
+    /** Grain-local pitch multiplier, [0.5,2], latched at actual launch. */
+    pitchRatio: Node<'f32'>;
+}
+/** Fixed-capacity mono resident WSOLA variant. Native 64-point squared-error
+ * alignment and complementary linear overlap; no normalization or clipping.
+ * True independent duration/pitch controls, with bounded search/transient and
+ * interpolation/alias limitations. Call once in stride-1 forSample, passing
+ * that loop's everyNSamples. Native snapshots continue only the same schema.
+ */
+export declare const residentTimeStretch: import("@unworklet/core").SubgraphDecl<[config: ResidentTimeStretchConfig], {
+    tick(c: ResidentTimeStretchControls, everyNSamples: EveryNSamples): {
+        output: Node<"f32">;
+        active: Node<"bool">;
+        position: Node<"f32">;
+        ended: Node<"bool">;
+        pending: Node<"bool">;
+        rejected: Node<"bool">;
+        missing: Node<"bool">;
+        selectedOffset: Node<"i32">;
+    };
+}>;

package/dist/resident-time-stretch.js

@@ -0,0 +1,135 @@
+import { defineSubgraph, f32, f64, i32, select, state } from '@unworklet/core';
+import { spectralForEach } from './spectral-fft.js';
+// Exact binary internal scaling protects tiny waveform differences from the
+// native 1e-30 scalar-store scrub. Even opposite finite f32 extrema produce
+// a 64-term squared score below 2**649, far inside finite f64 range.
+const SCALE = 2 ** 192;
+/** Fixed-capacity mono resident WSOLA variant. Native 64-point squared-error
+ * alignment and complementary linear overlap; no normalization or clipping.
+ * True independent duration/pitch controls, with bounded search/transient and
+ * interpolation/alias limitations. Call once in stride-1 forSample, passing
+ * that loop's everyNSamples. Native snapshots continue only the same schema.
+ */
+export const residentTimeStretch = defineSubgraph((config) => {
+    const { sample, sampleRate, hopSamples: H = 256, searchFrames: S = 64 } = config;
+    if (!Number.isInteger(sampleRate) || sampleRate < 8000 || sampleRate > 192000 ||
+        !Number.isInteger(sample.sourceSampleRate) || sample.sourceSampleRate < 8000 || sample.sourceSampleRate > 192000 ||
+        ![128, 256].includes(H) || ![0, 8, 16, 32, 64, 128].includes(S)) {
+        throw new RangeError('residentTimeStretch requires integer sampleRate/sourceSampleRate [8000,192000], hopSamples 128/256 and searchFrames 0/8/16/32/64/128');
+    }
+    const active = state.bool(false).named('active'), pending = state.bool(false).named('pending');
+    const ended = state.bool(false).named('ended'), rejected = state.bool(false).named('rejected');
+    const previousGate = state.bool(false).named('previousGate'), revision = state.i32(-1).named('revision');
+    const clock = state.i32(0).named('clock'), age = state.i32(0).named('age'), total = state.i32(0).named('total');
+    const sourceLength = state.i32(0).named('sourceLength'), pitchStep = state.f64(1).named('pitchStep');
+    const current = state.f64(0).named('currentStart'), previous = state.f64(0).named('previousStart');
+    const first = state.bool(true).named('first'), offset = state.i32(0).named('selectedOffset');
+    const reference = state.buffer.f64({ size: 64 }).expose({ name: 'referenceScaled', snapshot: 'transient' });
+    const score = state.f64(0).expose({ name: 'scoreScaled', snapshot: 'transient' });
+    const bestScore = state.f64(0).expose({ name: 'bestScoreScaled', snapshot: 'transient' });
+    const bestOffset = state.i32(0).expose({ name: 'bestOffset', snapshot: 'transient' });
+    const launching = state.bool(false).expose({ name: 'launching', snapshot: 'transient' });
+    const oldValue = state.f64(0).expose({ name: 'oldValueScaled', snapshot: 'transient' });
+    const wet = state.f64(0).expose({ name: 'wetScaled', snapshot: 'transient' });
+    // Each PCM endpoint outside [0,length) is zero, including fractional reads
+    // straddling either boundary. Clamp indices BEFORE calling the shared reader.
+    const readScaled = (position) => {
+        const whole = position.floor(), fraction = position.sub(whole), end = sample.length();
+        const a = f64(sample.read(whole.clamp(0, f64(end.sub(1).max(0))), i32(0), end, false));
+        oldValue.write(select(whole.gte(0).and(whole.lt(f64(end))), a, f64(0)).mul(SCALE));
+        const next = whole.add(1);
+        const b = f64(sample.read(next.clamp(0, f64(end.sub(1).max(0))), i32(0), end, false));
+        return oldValue.read().mul(f64(1).sub(fraction)).add(select(next.gte(0).and(next.lt(f64(end))), b, f64(0)).mul(SCALE).mul(fraction));
+    };
+    // Exact rational ceil(L * R * D / Rs) for integer rates and finite f32 D.
+    // A=L*R<2**34 and K=D*2**24<=2**25. Split the >53-bit A*K product:
+    // hi*K<2**43 and lo*K<2**41 are exact integers. Numerator / 2**16 is
+    // represented by its integer part and a 16-bit remainder. The nearest
+    // approximate integer q is either floor(exact) or ceil(exact), since the
+    // absolute arithmetic error is far below 0.5. Exact comparison with
+    // q*Rs*256 then returns the true ceil without an epsilon adjustment.
+    const durationFrames = (duration) => {
+        const a = f64(sample.length()).mul(sampleRate), k = f64(duration).mul(2 ** 24);
+        const hi = a.div(65536).floor(), loProduct = a.sub(hi.mul(65536)).mul(k);
+        const integerPart = hi.mul(k).add(loProduct.div(65536).floor()), remainder = loProduct.mod(65536);
+        const q = a.mul(f64(duration)).div(sample.sourceSampleRate).add(.5).floor();
+        const target = q.mul(sample.sourceSampleRate).mul(256);
+        const greater = integerPart.gt(target).or(integerPart.eq(target).and(remainder.gt(0)));
+        return i32(q.add(select(greater, f64(1), f64(0))));
+    };
+    return {
+        tick(c, everyNSamples) {
+            const missing = sample.length().eq(0), changed = sample.revision().eq(revision.read()).not();
+            const clear = c.reset.or(changed).or(missing);
+            active.write(active.read().and(clear.not()).and(c.gate));
+            pending.write(pending.read().and(clear.not()).and(c.gate));
+            ended.write(ended.read().and(clear.not()));
+            rejected.write(rejected.read().and(c.reset.not()));
+            age.write(select(clear, i32(0), age.read()));
+            total.write(select(clear, i32(0), total.read()));
+            sourceLength.write(select(clear, i32(0), sourceLength.read()));
+            const request = c.trigger.or(c.gate.and(previousGate.read().not())).and(c.gate).and(c.reset.not()).and(missing.not());
+            pending.write(pending.read().or(request));
+            // 0.4.1 does not snapshot native everyNSamples counters. A 128-sample
+            // scheduler realigns at every allowed snapshot boundary; persistent clock
+            // carries H=256 phase. Search is eager every 128, even when not committing.
+            everyNSamples(128, () => {
+                const due = clock.read().eq(0), attempt = due.and(pending.read()).and(c.gate).and(c.reset.not());
+                const valid = c.durationScale.gte(.5).and(c.durationScale.lte(2)).and(c.pitchRatio.gte(.5)).and(c.pitchRatio.lte(2));
+                launching.write(attempt.and(valid).and(missing.not()));
+                const launch = launching.read();
+                pending.write(pending.read().and(attempt.not()));
+                rejected.write(select(attempt, valid.not(), rejected.read()));
+                age.write(select(launch, i32(0), age.read()));
+                total.write(select(launch, durationFrames(select(valid, c.durationScale, f32(1))), total.read()));
+                sourceLength.write(select(launch, sample.length(), sourceLength.read()));
+                pitchStep.write(select(launch, f64(c.pitchRatio).mul(sample.sourceSampleRate / sampleRate), pitchStep.read()));
+                active.write(active.read().or(launch));
+                ended.write(ended.read().and(launch.not()));
+                const nominal = f64(age.read()).mul(f64(sourceLength.read())).div(f64(total.read().max(1)));
+                const priorTail = current.read().add(pitchStep.read().mul(H));
+                spectralForEach(64, j => reference.write(j, readScaled(priorTail.add(f64(j).mul(H / 64).mul(pitchStep.read())))));
+                const compare = (candidate) => {
+                    score.write(0);
+                    spectralForEach(64, j => {
+                        const value = readScaled(nominal.add(f64(candidate)).add(f64(j).mul(H / 64).mul(pitchStep.read())));
+                        const difference = value.sub(reference.read(j));
+                        score.write(score.read().add(difference.mul(difference)));
+                    });
+                };
+                compare(i32(0));
+                bestScore.write(score.read());
+                bestOffset.write(0);
+                if (S > 0)
+                    spectralForEach(S * 2, j => {
+                        const distance = j.div(2).add(1), candidate = select(j.mod(2).eq(0), distance, distance.mul(-1));
+                        compare(candidate);
+                        const improve = score.read().lt(bestScore.read());
+                        bestOffset.write(select(improve, candidate, bestOffset.read()));
+                        bestScore.write(select(improve, score.read(), bestScore.read()));
+                    });
+                const commit = due.and(active.read());
+                previous.write(select(commit, select(launch, f64(0), priorTail), previous.read()));
+                current.write(select(commit, select(launch, f64(0), nominal.add(f64(bestOffset.read()))), current.read()));
+                offset.write(select(commit, select(launch, i32(0), bestOffset.read()), offset.read()));
+                first.write(select(commit, launch, first.read()));
+            });
+            const exhausted = active.read().and(age.read().gte(total.read()));
+            ended.write(ended.read().or(exhausted));
+            active.write(active.read().and(exhausted.not()));
+            const playing = active.read();
+            const local = f64(clock.read()).mul(pitchStep.read()), blend = f64(clock.read()).div(H);
+            // Capture the first read because resident.read uses a shared transient.
+            wet.write(readScaled(previous.read().add(local)));
+            const incoming = readScaled(current.read().add(local));
+            const mixed = select(first.read(), incoming, wet.read().mul(f64(1).sub(blend)).add(incoming.mul(blend)));
+            const output = select(playing, f32(mixed.div(SCALE)), f32(0));
+            const position = f32(f64(age.read().min(total.read())).mul(f64(sourceLength.read())).div(f64(total.read().max(1))));
+            age.write(select(playing, age.read().add(1), age.read()));
+            clock.write(clock.read().add(1).mod(H));
+            previousGate.write(c.gate.and(c.reset.not()));
+            revision.write(sample.revision());
+            return { output, active: playing, position, ended: ended.read(), pending: pending.read(), rejected: rejected.read(), missing, selectedOffset: offset.read() };
+        },
+    };
+});

package/dist/resonator.d.ts

@@ -0,0 +1,32 @@
+import { type Node } from '@unworklet/core';
+export interface ResonatorMode {
+    frequencyHz: number;
+    decaySeconds: number;
+    gain: number;
+}
+export interface ModalResonatorConfig {
+    sampleRate: number;
+    modes: readonly ResonatorMode[];
+}
+/** Fixed stable two-pole modes. Decay is amplitude T60 in seconds. */
+export declare const modalResonator: import("@unworklet/core").SubgraphDecl<[config: ModalResonatorConfig], {
+    /** Excitation clamps to [-1,1]. Reset clears each mode before current excitation. */
+    tick(input: Node<"f32">, reset: Node<"bool">): Node<"f32">;
+}>;
+export interface TunedCombConfig {
+    sampleRate: number;
+    minFrequencyHz: number;
+}
+export interface TunedCombControls {
+    input: Node<'f32'>;
+    frequencyHz: Node<'f32'>;
+    feedback: Node<'f32'>;
+    /** One-pole memory coefficient in [0,1]; 0 bypasses damping, 1 freezes it. */
+    damping: Node<'f32'>;
+    reset: Node<'bool'>;
+}
+/** Fractional moving-delay resonator. Interpolation and damping change tuning/decay. */
+export declare const tunedComb: import("@unworklet/core").SubgraphDecl<[config: TunedCombConfig], {
+    /** Normalize excitation by (1-|feedback|) before storage; return the raw tap. */
+    tick(c: TunedCombControls): Node<"f32">;
+}>;

package/dist/resonator.js

@@ -0,0 +1,63 @@
+import { defineSubgraph, f32, f64, instantiate, select, state } from '@unworklet/core';
+import { delayReadhead } from './delay-readhead.js';
+function maximumFrequency(sampleRate) {
+    if (!Number.isFinite(sampleRate) || sampleRate < 8000 || sampleRate > 192000)
+        throw new RangeError('resonator sampleRate must be in [8000,192000] Hz');
+    return 0.45 * sampleRate;
+}
+/** Fixed stable two-pole modes. Decay is amplitude T60 in seconds. */
+export const modalResonator = defineSubgraph((config) => {
+    const maximum = maximumFrequency(config.sampleRate);
+    if (config.modes.length < 1 || config.modes.length > 16)
+        throw new RangeError('modalResonator requires 1–16 modes');
+    const scale = 2 ** 128; // Keep valid f32 subnormal tails above upstream scalar-state flush.
+    const modes = config.modes.map((mode, i) => {
+        if (!Number.isFinite(mode.frequencyHz) || mode.frequencyHz < 20 || mode.frequencyHz > maximum ||
+            !Number.isFinite(mode.decaySeconds) || mode.decaySeconds < 0.005 || mode.decaySeconds > 30 ||
+            !Number.isFinite(mode.gain) || Math.abs(mode.gain) > 16)
+            throw new RangeError('invalid mode frequency, T60 or gain');
+        const omega = 2 * Math.PI * mode.frequencyHz / config.sampleRate;
+        const radius = Math.exp(-Math.LN10 * 3 / (mode.decaySeconds * config.sampleRate));
+        return { gain: mode.gain, a1: 2 * radius * Math.cos(omega), a2: -radius * radius, b: Math.sin(omega),
+            first: state.f64(0).named(`mode${i}First`), second: state.f64(0).named(`mode${i}Second`) };
+    });
+    const normalization = modes.reduce((sum, mode) => sum + Math.abs(mode.gain), 0) || 1;
+    return {
+        /** Excitation clamps to [-1,1]. Reset clears each mode before current excitation. */
+        tick(input, reset) {
+            let sum = f64(0);
+            for (const mode of modes) {
+                const first = select(reset, f64(0), mode.first.read().div(scale));
+                const second = select(reset, f64(0), mode.second.read().div(scale));
+                const next = f64(input).clamp(-1, 1).mul(mode.b).add(first.mul(mode.a1)).add(second.mul(mode.a2));
+                mode.second.write(first.mul(scale));
+                mode.first.write(next.mul(scale));
+                sum = sum.add(next.mul(mode.gain / normalization));
+            }
+            return f32(sum);
+        },
+    };
+});
+/** Fractional moving-delay resonator. Interpolation and damping change tuning/decay. */
+export const tunedComb = defineSubgraph((config) => {
+    const maximum = maximumFrequency(config.sampleRate);
+    if (!Number.isFinite(config.minFrequencyHz) || config.minFrequencyHz < 20 || config.minFrequencyHz > maximum) {
+        throw new RangeError('comb minFrequencyHz must be in [20,.45*sampleRate]');
+    }
+    const line = instantiate(delayReadhead, { sampleRate: config.sampleRate, maxDelaySeconds: 1 / config.minFrequencyHz }, { name: 'line' });
+    const history = state.f64(0).named('dampingHistory');
+    const scale = 2 ** 128;
+    return {
+        /** Normalize excitation by (1-|feedback|) before storage; return the raw tap. */
+        tick(c) {
+            const frequency = f64(c.frequencyHz).clamp(config.minFrequencyHz, maximum);
+            const feedback = f64(c.feedback).clamp(-0.999, 0.999), damping = f64(c.damping).clamp(0, 1);
+            const tap = line.read(f32(f64(1).div(frequency)), c.reset);
+            const previous = select(c.reset, f64(0), history.read().div(scale));
+            const filtered = f64(tap.output).mul(f64(1).sub(damping)).add(previous.mul(damping));
+            history.write(filtered.mul(scale));
+            tap.write(f32(f64(c.input).mul(f64(1).sub(feedback.abs())).add(filtered.mul(feedback))));
+            return tap.output;
+        },
+    };
+});

package/dist/reverb.d.ts

@@ -0,0 +1,27 @@
+import { type Node } from '@unworklet/core';
+export interface AlgorithmicReverbConfig {
+    sampleRate: number;
+    /** Fixed delay-time scale, [0.5, 2]. Default 1. Rebuild to change. */
+    roomScale?: number;
+    /** Nominal loop-gain loss time in seconds, [0.1, 10]. Default 1.5.
+     * Not an exact RT60 or hard tail-duration ceiling: very low damping adds
+     * loop group delay and can lengthen low-band decay. Rebuild to change. */
+    decaySeconds?: number;
+    /** Fixed one-pole loop lowpass corner, [20, 0.45*sampleRate]. Default min(6000, 0.45*sampleRate). */
+    dampingHz?: number;
+}
+export interface ReverbControls {
+    mix: Node<'f32'>;
+    /** Dry output, no new input; existing tail continues internally. */
+    bypass: Node<'bool'>;
+    reset: Node<'bool'>;
+}
+/** Four-line Hadamard FDN candidate. Fixed capacities and coefficients, no FFT.
+ * Finite inputs required. No predelay; the shortest network delay precedes wet audio.
+ */
+export declare const algorithmicReverb: import("@unworklet/core").SubgraphDecl<[config: AlgorithmicReverbConfig], {
+    tick(inputLeft: Node<"f32">, inputRight: Node<"f32">, c: ReverbControls): {
+        left: Node<"f32">;
+        right: Node<"f32">;
+    };
+}>;

package/dist/reverb.js

@@ -0,0 +1,52 @@
+import { defineSubgraph, f32, f64, instantiate, select, state } from '@unworklet/core';
+import { delayReadhead } from './delay-readhead.js';
+/** Four-line Hadamard FDN candidate. Fixed capacities and coefficients, no FFT.
+ * Finite inputs required. No predelay; the shortest network delay precedes wet audio.
+ */
+export const algorithmicReverb = defineSubgraph((config) => {
+    const { sampleRate, roomScale = 1, decaySeconds = 1.5 } = config;
+    const dampingHz = config.dampingHz ?? Math.min(6000, 0.45 * sampleRate);
+    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.isFinite(dampingHz) || dampingHz < 20 || dampingHz > 0.45 * sampleRate) {
+        throw new RangeError('algorithmicReverb requires sample rate [8000,192000], roomScale [0.5,2], decaySeconds [0.1,10], dampingHz [20,0.45*sampleRate]');
+    }
+    // Incommensurate reference lengths (seconds), rounded to fixed sample counts.
+    const lengths = [0.0297, 0.0371, 0.0411, 0.0437].map(seconds => Math.round(seconds * roomScale * sampleRate));
+    const lines = lengths.map((length, i) => ({
+        delay: instantiate(delayReadhead, { sampleRate, maxDelaySeconds: length / sampleRate }, { name: `line${i}` }),
+        seconds: length / sampleRate,
+        gain: 10 ** (-3 * length / (sampleRate * decaySeconds)),
+        damping: state.f64(0).named(`damping${i}`),
+        wet: state.f64(0).expose({ name: `wet${i}`, snapshot: 'transient' }),
+    }));
+    // One-pole matched-z lowpass: convex combination, unity DC, no added resonance.
+    const pole = Math.exp(-2 * Math.PI * dampingHz / sampleRate);
+    // H/2 is orthogonal. These literal rows also keep generated work fixed.
+    const matrix = [[1, 1, 1, 1], [1, -1, 1, -1], [1, 1, -1, -1], [1, -1, -1, 1]];
+    return {
+        tick(inputLeft, inputRight, c) {
+            const heads = lines.map(line => line.delay.read(f32(line.seconds), c.reset));
+            for (let i = 0; i < lines.length; i++) {
+                const line = lines[i];
+                line.wet.write(f64(heads[i].output));
+                line.damping.write(select(c.reset, f64(0), line.damping.read()).mul(pole).add(line.wet.read().mul(1 - pole)));
+            }
+            const damped = lines.map(line => line.damping.read().mul(line.gain));
+            const left = f64(select(c.bypass, f32(0), inputLeft)), right = f64(select(c.bypass, f32(0), inputRight));
+            for (let i = 0; i < lines.length; i++) {
+                const injection = left.add(right.mul(matrix[1][i])).mul(0.5);
+                const feedback = damped.reduce((sum, x, j) => sum.add(x.mul(matrix[i][j] * 0.5)), f64(0));
+                heads[i].write(f32(injection.add(feedback)));
+            }
+            const wetLeft = lines.reduce((sum, line, i) => sum.add(line.wet.read().mul(matrix[2][i] * 0.5)), f64(0));
+            const wetRight = lines.reduce((sum, line, i) => sum.add(line.wet.read().mul(matrix[3][i] * 0.5)), f64(0));
+            const mix = f64(c.mix).clamp(0, 1);
+            return {
+                left: select(c.bypass, inputLeft, f32(f64(inputLeft).mul(f64(1).sub(mix)).add(wetLeft.mul(mix)))),
+                right: select(c.bypass, inputRight, f32(f64(inputRight).mul(f64(1).sub(mix)).add(wetRight.mul(mix)))),
+            };
+        },
+    };
+});

package/dist/sample.d.ts

@@ -0,0 +1,113 @@
+import { type Node, type TypedArrayFieldRef } from '@unworklet/core';
+export interface ResidentSampleConfig {
+    /** Fixed mono PCM capacity, 1..65,536 frames; decoding/file I/O run outside the processor. */
+    capacity: number;
+    sourceSampleRate: number;
+}
+export interface ResidentSample {
+    readonly capacity: number;
+    readonly sourceSampleRate: number;
+    /** Call in event<{data:Float32Array}>.onReceive. Copy runs at the block boundary.
+     * Prepare/decode outside the callback and load before audible use. Oversize input
+     * truncates to capacity; empty input unloads. Each load invalidates current playback. */
+    load(data: TypedArrayFieldRef<'f32'>): void;
+    length(): Node<'i32'>;
+    revision(): Node<'i32'>;
+    /** Linear interpolation; end is exclusive and clipped to loaded length.
+     * NaN position uses start; other positions saturate to the signed i32 frame range. */
+    read(position: Node<'f64'>, start: Node<'i32'>, end: Node<'i32'>, loop: boolean): Node<'f32'>;
+}
+/** A fixed-capacity mono sample, initially missing. No asset loader or streaming. */
+export declare const residentSample: import("@unworklet/core").SubgraphDecl<[config: ResidentSampleConfig], ResidentSample>;
+export interface SamplePlayerConfig {
+    sampleRate: number;
+    sample: ResidentSample;
+    /** Fixed slice [startFrame,endFrame), intersected with the current asset length. */
+    startFrame?: number;
+    endFrame?: number;
+    loop?: boolean;
+    /** Linear gate-off ramp in output samples; zero stops immediately. */
+    releaseFrames?: number;
+}
+export interface SamplePlayerControls {
+    gate: Node<'bool'>;
+    /** Level-sensitive restart; a held trigger repeats the first sample. */
+    trigger: Node<'bool'>;
+    /** Priority over gate/trigger; held reset is silent. */
+    reset: Node<'bool'>;
+    /** Signed speed, [-16,16]; source/host sample-rate conversion is automatic. */
+    rate: Node<'f32'>;
+}
+/** Mono, one voice, one-shot or loop; nearest endpoints with linear interpolation. */
+export declare const samplePlayer: import("@unworklet/core").SubgraphDecl<[config: SamplePlayerConfig], {
+    tick(c: SamplePlayerControls): {
+        output: Node<"f32">;
+        active: Node<"bool">;
+        position: Node<"f32">;
+        missing: Node<"bool">;
+    };
+}>;
+export interface SampleZone {
+    sample: ResidentSample;
+    keyLow: number;
+    keyHigh: number;
+    /** Inclusive normalized velocity endpoints. First matching zone wins overlaps. */
+    velocityLow: number;
+    velocityHigh: number;
+    rootKey: number;
+    tuneCents?: number;
+    gain?: number;
+    startFrame?: number;
+    endFrame?: number;
+    loop?: boolean;
+}
+export interface MultisampleConfig {
+    sampleRate: number;
+    zones: readonly SampleZone[];
+    releaseFrames?: number;
+}
+export interface MultisampleControls {
+    key: Node<'f32'>;
+    velocity: Node<'f32'>;
+    gate: Node<'bool'>;
+    trigger: Node<'bool'>;
+    reset: Node<'bool'>;
+    /** Additional signed ratio, multiplied after root-key transposition; final ratio clips to ±16. */
+    rate: Node<'f32'>;
+}
+/** Monophonic key/velocity selection; zone/key/velocity latch on note-on. */
+export declare const multisamplePlayer: import("@unworklet/core").SubgraphDecl<[config: MultisampleConfig], {
+    tick(c: MultisampleControls): {
+        output: Node<"f32">;
+        active: Node<"bool">;
+        zoneIndex: Node<"i32">;
+        missing: Node<"bool">;
+    };
+}>;
+export interface GranularConfig {
+    sampleRate: number;
+    sample: ResidentSample;
+    maxGrains: number;
+    seed?: number;
+    loop?: boolean;
+}
+export interface GranularControls {
+    gate: Node<'bool'>;
+    reset: Node<'bool'>;
+    positionFrames: Node<'f32'>;
+    jitterFrames: Node<'f32'>;
+    rate: Node<'f32'>;
+    durationSeconds: Node<'f32'>;
+    /** 0..2000 onsets/second. Gate-rise creates the first grain even at zero density. */
+    densityHz: Node<'f32'>;
+}
+/** Fixed grain pool, triangular endpoint-zero windows; first free slot, drop on full. */
+export declare const granularSource: import("@unworklet/core").SubgraphDecl<[config: GranularConfig], {
+    tick(c: GranularControls): {
+        output: Node<"f32">;
+        activeGrains: Node<"i32">;
+        onset: Node<"bool">;
+        dropped: Node<"bool">;
+        missing: Node<"bool">;
+    };
+}>;