@denaudio/den 0.0.0-stage → 0.1.0

package/dist/musical-controls.js

@@ -0,0 +1,125 @@
+import { defineSubgraph, f32, f64, i32, instantiate, select, state } from '@unworklet/core';
+import { musicalClock } from './modulation.js';
+function checkSampleRate(sampleRate) {
+    if (!Number.isInteger(sampleRate) || sampleRate < 8000 || sampleRate > 192000) {
+        throw new RangeError('musical controls sampleRate must be an integer in [8000,192000]');
+    }
+}
+// Core 0.4.1 flushes tiny scalar-state writes. Scaling by this exact power of two
+// preserves the entire finite f32 range in the bounded level/bend histories.
+const SCALE = 2 ** 128;
+/**
+ * Segment-relative curved ADSR. Tick exactly once per sample; finite controls.
+ * C(t,b)=t+b*t*(1-t), with exact endpoints. Segment settings latch on entry;
+ * decay latches at the preceding positive attack endpoint. Sustain follows its
+ * current input in the sustain stage. Retrigger/note-off start at the last
+ * emitted f32 level. Zero attack collapses into decay on the same sample.
+ * Reset > gate-off > retrigger. Reset consumes held gate. No smoothing/tail
+ * threshold; zero sustain remains active. Bend zero is linear, not a promise of
+ * byte identity with the legacy iterative envelope. See the entry contract.
+ */
+export const curvedAdsr = defineSubgraph((config) => {
+    checkSampleRate(config.sampleRate);
+    const stage = state.i32(0).named('stage'); // idle, attack, decay, sustain, release
+    const previousGate = state.bool(false).named('previousGate');
+    const total = state.i32(0).named('total');
+    const elapsed = state.i32(0).named('elapsed');
+    const start = state.f64(0).named('startScaled');
+    const target = state.f64(0).named('targetScaled');
+    const bend = state.f64(0).named('bendScaled');
+    const level = state.f64(0).named('levelScaled');
+    const frames = (seconds) => i32(f64(seconds.clamp(0, 30)).mul(config.sampleRate).add(0.5).floor());
+    return { tick(c) {
+            const oldStage = stage.read();
+            const on = c.gate.and(previousGate.read().not().or(c.retrigger));
+            const off = c.gate.not().and(previousGate.read()).and(oldStage.eq(0).not());
+            const a = frames(c.attack), d = frames(c.decay), r = frames(c.release);
+            const sustain = f64(c.sustain.clamp(0, 1)).mul(SCALE);
+            const attackBend = f64(c.attackBend.clamp(-1, 1)).mul(SCALE);
+            const decayBend = f64(c.decayBend.clamp(-1, 1)).mul(SCALE);
+            const releaseBend = f64(c.releaseBend.clamp(-1, 1)).mul(SCALE);
+            stage.write(select(off, i32(4), select(on, i32(1), oldStage)));
+            const active = stage.read(), attack = active.eq(1), release = active.eq(4);
+            const zeroAttack = attack.and(select(on, a, total.read()).eq(0));
+            const decay = active.eq(2).or(zeroAttack);
+            const moving = attack.or(decay).or(release);
+            total.write(select(release, select(off, r, total.read()), select(decay, select(zeroAttack, d, total.read()), select(on, a, total.read()))));
+            elapsed.write(select(on.or(off).or(zeroAttack), i32(0), elapsed.read()));
+            start.write(select(zeroAttack, f64(SCALE), select(on.or(off), level.read(), start.read())));
+            target.write(select(release, f64(0), select(decay, select(zeroAttack, sustain, target.read()), f64(SCALE))));
+            bend.write(select(release, select(off, releaseBend, bend.read()), select(decay, select(zeroAttack, decayBend, bend.read()), select(on, attackBend, bend.read()))));
+            elapsed.write(select(moving, elapsed.read().add(1).min(total.read()), elapsed.read()));
+            const t = f64(elapsed.read()).div(f64(total.read().max(1)));
+            const curved = t.add(bend.read().div(SCALE).mul(t).mul(f64(1).sub(t)));
+            const last = elapsed.read().gte(total.read()).or(release.and(start.read().eq(0)));
+            const advanced = select(last, target.read(), start.read().add(target.read().sub(start.read()).mul(curved)));
+            const emitted = f32(select(c.reset, f64(0), select(moving, advanced, select(active.eq(3), sustain, f64(0)))).div(SCALE)).clamp(0, 1);
+            // Store the actual f32 output: interruption starts at the observable level,
+            // not a hidden higher-precision value or a post-warped absolute amplitude.
+            level.write(f64(emitted).mul(SCALE));
+            const nextStage = select(c.reset, i32(0), select(moving.and(last), select(release, i32(0), select(decay, i32(3), i32(2))), select(decay, i32(2), active)));
+            const prepareDecay = attack.and(decay.not()).and(last);
+            total.write(select(c.reset, i32(0), select(prepareDecay, d, total.read())));
+            elapsed.write(select(c.reset.or(prepareDecay), i32(0), elapsed.read()));
+            start.write(select(c.reset, f64(0), select(prepareDecay, f64(SCALE), start.read())));
+            target.write(select(c.reset, f64(0), select(prepareDecay, sustain, target.read())));
+            bend.write(select(c.reset, f64(0), select(prepareDecay, decayBend, bend.read())));
+            stage.write(nextStage);
+            previousGate.write(c.gate);
+            return { level: f32(level.read().div(SCALE)), done: nextStage.eq(0) };
+        } };
+});
+const PHASE_MAX = 1 - 2 ** -24;
+function sineAtPhase(phase) {
+    const centered = phase.sub(select(phase.gt(.5), f64(1), f64(0)));
+    const folded = select(centered.gt(.25), f64(.5).sub(centered), select(centered.lt(-.25), f64(-.5).sub(centered), centered));
+    const x = folded.mul(2 * Math.PI), x2 = x.mul(x);
+    // Same degree-13 reflected sine as the legacy LFO. At this canonical public
+    // f32 phase, |Taylor remainder| <= (pi/2)^15/15! < 7e-10 before output rounding.
+    const polynomial = f64(1 / 6227020800).mul(x2).sub(1 / 39916800)
+        .mul(x2).add(1 / 362880).mul(x2).sub(1 / 5040)
+        .mul(x2).add(1 / 120).mul(x2).sub(1 / 6).mul(x2).add(1);
+    return x.mul(polynomial);
+}
+/**
+ * Fixed-waveform LFO composed from musicalClock. Tick once per sample with finite
+ * inputs. Output precedes integration. Held reset pins base zero; release emits
+ * zero base before resuming. Hold/rate zero preserve base phase. Tempo follows
+ * BPM/(60*beatsPerCycle) exactly within the clock's numerical contract, including
+ * up to 1066 2/3 Hz. Public f32 clock-phase quantization is intentional, not the
+ * legacy sine LFO's internal-f64 phase guarantee. Waveforms are non-bandlimited;
+ * phase/offset/reset changes can jump. No smoothing/depth/routing/transport.
+ */
+export const musicalLfo = defineSubgraph((config) => {
+    checkSampleRate(config.sampleRate);
+    if (config.mode !== 'free' && config.mode !== 'tempo')
+        throw new RangeError('musicalLfo mode must be free or tempo');
+    if (!['sine', 'triangle', 'saw', 'square'].includes(config.waveform))
+        throw new RangeError('unsupported musicalLfo waveform');
+    const beats = config.beatsPerCycle ?? 1;
+    if (!Number.isFinite(beats) || beats < 1 / 64 || beats > 64 || !Number.isInteger(Math.log2(beats))) {
+        throw new RangeError('beatsPerCycle must be a power of two in [1/64,64]');
+    }
+    if (config.mode === 'free' && beats !== 1)
+        throw new RangeError('beatsPerCycle applies only to tempo mode');
+    const clock = instantiate(musicalClock, {
+        sampleRate: config.sampleRate, mode: config.mode, steps: 1, stepsPerBeat: config.mode === 'tempo' ? 1 / beats : 1,
+    }, { name: 'clock' });
+    return { tick(c) {
+            const base = clock.tick({ rate: select(c.hold, f32(0), c.rate.clamp(0, config.mode === 'free' ? 20 : 1000)),
+                reset: c.reset, seek: c.seek, position: c.position });
+            const offset = f64(c.phaseOffset.clamp(-1048576, 1048576));
+            // Remove the integer part toward zero, preserving negative tiny fractions.
+            // Add only the signed fraction so large integral offsets cannot erase a
+            // tiny base phase. Wrap once afterward and cap the rounded upper endpoint.
+            const fraction = offset.sub(select(offset.lt(0), offset.neg().floor().neg(), offset.floor()));
+            const shifted = f64(base.phase).add(fraction);
+            const phase = f32(shifted.sub(shifted.floor())).clamp(0, PHASE_MAX);
+            const p = f64(phase);
+            const value = config.waveform === 'sine' ? sineAtPhase(p)
+                : config.waveform === 'triangle' ? select(p.lt(.25), p.mul(4), select(p.lt(.75), f64(2).sub(p.mul(4)), p.mul(4).sub(4)))
+                    : config.waveform === 'saw' ? p.mul(2).sub(1)
+                        : select(p.lt(.5), f64(1), f64(-1));
+            return { value: f32(value).clamp(-1, 1), phase };
+        } };
+});

package/dist/musical-examples.d.ts

@@ -0,0 +1,21 @@
+export { musicalMaterialsStatus, glassDyadParameters, glassDyadBrightParameters, glassDyadConstruction, makeGlassDyadTable, fmModalHitParameters, fmModalHitBellParameters, fmModalHitModes, grainCloudParameters, grainCloudReverseParameters, grainCloudConstruction, makeGrainCloudSample, shapedEchoParameters, shapedEchoDarkParameters, } from './musical-materials.js';
+/** CANDIDATE fixed two-voice instrument. Independent native gate/frequency params,
+ * shared resident morph table and ordinary native snapshot state; no MIDI allocator.
+ * Send `load` with makeGlassDyadTable() before gate-on. Output `main` is stereo.
+ */
+export declare const glassDyad: import("@unworklet/core").CompiledProcessor<unknown>;
+/** CANDIDATE fixed-pitch A3 struck voice. Gate rise excites one normalized modal
+ * impulse and restarts FM/amp. Each new hit clears the old modal tail, keeping
+ * its impulse bound; gate-off releases FM while the fixed modal tail continues.
+ */
+export declare const fmModalHit: import("@unworklet/core").CompiledProcessor<unknown>;
+/** CANDIDATE two-grain resident texture. `load` accepts makeGrainCloudSample().
+ * Gate-off stops new grains and lets existing windows finish. Parameters latch
+ * at each grain onset as specified by granularSource; no streaming or time stretch.
+ */
+export declare const grainCloud: import("@unworklet/core").CompiledProcessor<unknown>;
+/** CANDIDATE mono-in/stereo-out chain: soft first-order ADAA -> Q=.5 low-pass
+ * -> asymmetric feed into stereo ping-pong. `main` input is finite mono <=1.
+ * Dry/wet is intentional delay coloration; no external parallel-path alignment.
+ */
+export declare const shapedEcho: import("@unworklet/core").CompiledProcessor<unknown>;

package/dist/musical-examples.js

@@ -0,0 +1,142 @@
+import { audioInput, audioOutput, bool, CAPACITY_16, defineProcessor, event, f32, forSample, instantiate, param, select, state, } from '@unworklet/core';
+import { envelope } from './envelope.js';
+import { residentSample, granularSource } from './sample.js';
+import { wavetableSource } from './wavetable.js';
+import { frequencyModulation } from './source.js';
+import { modalResonator } from './resonator.js';
+import { drive } from './drive.js';
+import { stateVariableFilter } from './state-variable-filter.js';
+import { pingPongDelay } from './stereo-delay.js';
+import { glassDyadParameters as glass, fmModalHitParameters as hit, grainCloudParameters as grain, shapedEchoParameters as echo, fmModalHitModes, } from './musical-materials.js';
+export { musicalMaterialsStatus, glassDyadParameters, glassDyadBrightParameters, glassDyadConstruction, makeGlassDyadTable, fmModalHitParameters, fmModalHitBellParameters, fmModalHitModes, grainCloudParameters, grainCloudReverseParameters, grainCloudConstruction, makeGrainCloudSample, shapedEchoParameters, shapedEchoDarkParameters, } from './musical-materials.js';
+/** CANDIDATE fixed two-voice instrument. Independent native gate/frequency params,
+ * shared resident morph table and ordinary native snapshot state; no MIDI allocator.
+ * Send `load` with makeGlassDyadTable() before gate-on. Output `main` is stereo.
+ */
+export const glassDyad = defineProcessor(({ sampleRate }) => {
+    const asset = instantiate(residentSample, { capacity: 384, sourceSampleRate: 48000 }, { name: 'asset' });
+    event({ from: 'main', name: 'load', capacity: CAPACITY_16, payloadCapacity: 1536 })
+        .onReceive(({ data }) => asset.load(data));
+    const gateA = param.f32({ default: glass.gateA, min: 0, max: 1, automationRate: 'a-rate' }).named('gateA');
+    const gateB = param.f32({ default: glass.gateB, min: 0, max: 1, automationRate: 'a-rate' }).named('gateB');
+    const frequencyA = param.f32({ default: glass.frequencyA, min: 55, max: 1200, automationRate: 'a-rate' }).named('frequencyA');
+    const frequencyB = param.f32({ default: glass.frequencyB, min: 55, max: 1200, automationRate: 'a-rate' }).named('frequencyB');
+    const frame = param.f32({ default: glass.frame, min: 0, max: 2, automationRate: 'a-rate' }).named('frame');
+    const gain = param.f32({ default: glass.gain, min: 0, max: .3, automationRate: 'a-rate' }).named('gain');
+    const reset = param.f32({ default: 0, min: 0, max: 1, automationRate: 'a-rate' }).named('reset');
+    const voices = [0, 1].map(n => ({
+        wave: instantiate(wavetableSource, { sampleRate, sample: asset, frameLength: 128, frameCount: 3 }, { name: `wave${n}` }),
+        amp: instantiate(envelope, { sampleRate }, { name: `amp${n}` }),
+        gate: state.bool(false).named(`previousGate${n}`),
+    }));
+    const out = audioOutput({ channels: 2, name: 'main' });
+    return { process() {
+            forSample(i => {
+                const clear = reset.at(i).gte(.5);
+                const values = voices.map((v, n) => {
+                    const gate = (n === 0 ? gateA : gateB).at(i).gte(.5), trigger = gate.and(v.gate.read().not());
+                    const amp = v.amp.tick({ gate, retrigger: bool(false), reset: clear,
+                        attack: f32(.012), decay: f32(.2), sustain: f32(.65), release: f32(.28) });
+                    const wave = v.wave.tick({ frequencyHz: (n === 0 ? frequencyA : frequencyB).at(i), frame: frame.at(i), reset: clear.or(trigger) });
+                    v.gate.write(gate);
+                    return select(clear, f32(0), wave.output.mul(amp.level));
+                });
+                out.ch(0).at(i).write(values[0].mul(.75).add(values[1].mul(.25)).mul(gain.at(i)));
+                out.ch(1).at(i).write(values[0].mul(.25).add(values[1].mul(.75)).mul(gain.at(i)));
+            });
+        } };
+});
+/** CANDIDATE fixed-pitch A3 struck voice. Gate rise excites one normalized modal
+ * impulse and restarts FM/amp. Each new hit clears the old modal tail, keeping
+ * its impulse bound; gate-off releases FM while the fixed modal tail continues.
+ */
+export const fmModalHit = defineProcessor(({ sampleRate }) => {
+    const gate = param.f32({ default: hit.gate, min: 0, max: 1, automationRate: 'a-rate' }).named('gate');
+    const strength = param.f32({ default: hit.strength, min: 0, max: 1, automationRate: 'a-rate' }).named('strength');
+    const ratio = param.f32({ default: hit.ratio, min: .5, max: 4, automationRate: 'a-rate' }).named('ratio');
+    const deviation = param.f32({ default: hit.deviationHz, min: 0, max: 180, automationRate: 'a-rate' }).named('deviationHz');
+    const mix = param.f32({ default: hit.modalMix, min: 0, max: 1, automationRate: 'a-rate' }).named('modalMix');
+    const gain = param.f32({ default: hit.gain, min: 0, max: .3, automationRate: 'a-rate' }).named('gain');
+    const reset = param.f32({ default: 0, min: 0, max: 1, automationRate: 'a-rate' }).named('reset');
+    const previousGate = state.bool(false).named('previousGate');
+    const velocity = state.f32(0).named('strength');
+    const fm = instantiate(frequencyModulation, { sampleRate }, { name: 'fm' });
+    const modes = instantiate(modalResonator, { sampleRate, modes: fmModalHitModes }, { name: 'modes' });
+    const amp = instantiate(envelope, { sampleRate }, { name: 'amp' });
+    const out = audioOutput({ channels: 2, name: 'main' });
+    return { process() {
+            forSample(i => {
+                const on = gate.at(i).gte(.5), clear = reset.at(i).gte(.5);
+                const strike = on.and(previousGate.read().not()).and(clear.not());
+                velocity.write(select(clear, f32(0), select(strike, strength.at(i), velocity.read())));
+                const a = amp.tick({ gate: on, retrigger: strike, reset: clear,
+                    attack: f32(.001), decay: f32(.18), sustain: f32(0), release: f32(.04) });
+                const tone = fm.tick({ carrierHz: f32(220), modulatorHz: ratio.at(i).mul(220),
+                    deviationHz: deviation.at(i).mul(a.level), feedbackHz: f32(0), reset: clear.or(strike) });
+                const ring = modes.tick(select(strike, velocity.read(), f32(0)), clear.or(strike));
+                const m = mix.at(i);
+                const value = select(clear, f32(0), tone.mul(a.level).mul(velocity.read()).mul(f32(1).sub(m)).add(ring.mul(m)).mul(gain.at(i)));
+                out.ch(0).at(i).write(value);
+                out.ch(1).at(i).write(value);
+                previousGate.write(on);
+            });
+        } };
+});
+/** CANDIDATE two-grain resident texture. `load` accepts makeGrainCloudSample().
+ * Gate-off stops new grains and lets existing windows finish. Parameters latch
+ * at each grain onset as specified by granularSource; no streaming or time stretch.
+ */
+export const grainCloud = defineProcessor(({ sampleRate }) => {
+    const asset = instantiate(residentSample, { capacity: 4096, sourceSampleRate: 48000 }, { name: 'asset' });
+    event({ from: 'main', name: 'load', capacity: CAPACITY_16, payloadCapacity: 16384 })
+        .onReceive(({ data }) => asset.load(data));
+    const source = instantiate(granularSource, { sampleRate, sample: asset, maxGrains: 2, seed: 1741, loop: true }, { name: 'grains' });
+    const gate = param.f32({ default: 0, min: 0, max: 1, automationRate: 'a-rate' }).named('gate');
+    const position = param.f32({ default: grain.positionFrames, min: 0, max: 4095, automationRate: 'a-rate' }).named('positionFrames');
+    const jitter = param.f32({ default: grain.jitterFrames, min: 0, max: 4095, automationRate: 'a-rate' }).named('jitterFrames');
+    const rate = param.f32({ default: grain.rate, min: -2, max: 2, automationRate: 'a-rate' }).named('rate');
+    const duration = param.f32({ default: grain.durationSeconds, min: .02, max: .15, automationRate: 'a-rate' }).named('durationSeconds');
+    const density = param.f32({ default: grain.densityHz, min: 0, max: 20, automationRate: 'a-rate' }).named('densityHz');
+    const gain = param.f32({ default: grain.gain, min: 0, max: .4, automationRate: 'a-rate' }).named('gain');
+    const reset = param.f32({ default: 0, min: 0, max: 1, automationRate: 'a-rate' }).named('reset');
+    const out = audioOutput({ channels: 2, name: 'main' });
+    return { process() {
+            forSample(i => {
+                const result = source.tick({ gate: gate.at(i).gte(.5), reset: reset.at(i).gte(.5),
+                    positionFrames: position.at(i), jitterFrames: jitter.at(i), rate: rate.at(i),
+                    durationSeconds: duration.at(i), densityHz: density.at(i) });
+                const value = result.output.mul(gain.at(i));
+                out.ch(0).at(i).write(value);
+                out.ch(1).at(i).write(value);
+            });
+        } };
+});
+/** CANDIDATE mono-in/stereo-out chain: soft first-order ADAA -> Q=.5 low-pass
+ * -> asymmetric feed into stereo ping-pong. `main` input is finite mono <=1.
+ * Dry/wet is intentional delay coloration; no external parallel-path alignment.
+ */
+export const shapedEcho = defineProcessor(({ sampleRate }) => {
+    const input = audioInput({ channels: 1, name: 'main' });
+    const out = audioOutput({ channels: 2, name: 'main' });
+    const shaper = instantiate(drive, { sampleRate, curve: 'soft', quality: 'adaa' }, { name: 'drive' });
+    const filter = instantiate(stateVariableFilter, { sampleRate }, { name: 'filter' });
+    const delay = instantiate(pingPongDelay, { sampleRate, maxDelaySeconds: .25 }, { name: 'echo' });
+    const driveGain = param.f32({ default: echo.drive, min: 0, max: 8, automationRate: 'a-rate' }).named('drive');
+    const cutoff = param.f32({ default: echo.cutoffHz, min: 100, max: 4000, automationRate: 'a-rate' }).named('cutoffHz');
+    const time = param.f32({ default: echo.delaySeconds, min: .04, max: .25, automationRate: 'a-rate' }).named('delaySeconds');
+    const feedback = param.f32({ default: echo.feedback, min: 0, max: .4, automationRate: 'a-rate' }).named('feedback');
+    const mix = param.f32({ default: echo.mix, min: 0, max: .6, automationRate: 'a-rate' }).named('mix');
+    const gain = param.f32({ default: echo.gain, min: 0, max: .25, automationRate: 'a-rate' }).named('gain');
+    const reset = param.f32({ default: 0, min: 0, max: 1, automationRate: 'a-rate' }).named('reset');
+    return { process() {
+            forSample(i => {
+                const clear = reset.at(i).gte(.5);
+                const x = shaper.tick(select(clear, f32(0), input.ch(0).at(i)), driveGain.at(i), f32(1), clear);
+                const tone = filter.tick(x, cutoff.at(i), f32(.5), clear).lowpass;
+                const wet = delay.tick(tone, tone.mul(.5), { timeSeconds: time.at(i), feedback: feedback.at(i),
+                    mix: mix.at(i), bypass: bool(false), reset: clear });
+                out.ch(0).at(i).write(select(clear, f32(0), wet.left.mul(gain.at(i))));
+                out.ch(1).at(i).write(select(clear, f32(0), wet.right.mul(gain.at(i))));
+            });
+        } };
+});

package/dist/musical-materials.d.ts

@@ -0,0 +1,110 @@
+/** Original synthetic materials and ordinary native AudioParam values.
+ * These are CANDIDATE examples, not a preset format or listening-approved audio.
+ * Asset creation runs on the host before the native `load` message is sent.
+ */
+export declare const musicalMaterialsStatus: "CANDIDATE";
+export declare const glassDyadParameters: {
+    readonly gateA: 0;
+    readonly gateB: 0;
+    readonly frequencyA: 220;
+    readonly frequencyB: 330;
+    readonly frame: 0.25;
+    readonly gain: 0.2;
+    readonly reset: 0;
+};
+export declare const glassDyadBrightParameters: {
+    readonly frame: 1.75;
+    readonly gateA: 0;
+    readonly gateB: 0;
+    readonly frequencyA: 220;
+    readonly frequencyB: 330;
+    readonly gain: 0.2;
+    readonly reset: 0;
+};
+export declare const glassDyadConstruction: {
+    readonly voices: 2;
+    readonly frameLength: 128;
+    readonly frameCount: 3;
+    readonly capacity: 384;
+};
+/** Three complete 128-sample cycles, no duplicate endpoint; fixed weights, no normalization. */
+export declare function makeGlassDyadTable(): Float32Array;
+export declare const fmModalHitParameters: {
+    readonly gate: 0;
+    readonly strength: 0.8;
+    readonly ratio: 1.5;
+    readonly deviationHz: 100;
+    readonly modalMix: 0.35;
+    readonly gain: 0.22;
+    readonly reset: 0;
+};
+export declare const fmModalHitBellParameters: {
+    readonly ratio: 2.75;
+    readonly deviationHz: 170;
+    readonly modalMix: 0.7;
+    readonly gate: 0;
+    readonly strength: 0.8;
+    readonly gain: 0.22;
+    readonly reset: 0;
+};
+export declare const fmModalHitModes: readonly [{
+    readonly frequencyHz: 220;
+    readonly decaySeconds: 0.42;
+    readonly gain: 1;
+}, {
+    readonly frequencyHz: 351;
+    readonly decaySeconds: 0.24;
+    readonly gain: 0.6;
+}, {
+    readonly frequencyHz: 563;
+    readonly decaySeconds: 0.15;
+    readonly gain: 0.35;
+}];
+export declare const grainCloudParameters: {
+    readonly gate: 0;
+    readonly positionFrames: 512;
+    readonly jitterFrames: 240;
+    readonly rate: 1;
+    readonly durationSeconds: 0.09;
+    readonly densityHz: 16;
+    readonly gain: 0.28;
+    readonly reset: 0;
+};
+export declare const grainCloudReverseParameters: {
+    readonly positionFrames: 2800;
+    readonly rate: -0.75;
+    readonly durationSeconds: 0.12;
+    readonly densityHz: 12;
+    readonly gate: 0;
+    readonly jitterFrames: 240;
+    readonly gain: 0.28;
+    readonly reset: 0;
+};
+export declare const grainCloudConstruction: {
+    readonly capacity: 4096;
+    readonly sourceSampleRate: 48000;
+    readonly maxGrains: 2;
+    readonly seed: 1741;
+};
+/** Original periodic tone cluster with a smooth fixed amplitude contour.
+ * Integer cycle counts make the short resident loop continuous. No recorded audio.
+ */
+export declare function makeGrainCloudSample(): Float32Array;
+export declare const shapedEchoParameters: {
+    readonly drive: 2.4;
+    readonly cutoffHz: 1800;
+    readonly delaySeconds: 0.125;
+    readonly feedback: 0.25;
+    readonly mix: 0.3;
+    readonly gain: 0.2;
+    readonly reset: 0;
+};
+export declare const shapedEchoDarkParameters: {
+    readonly drive: 4.5;
+    readonly cutoffHz: 650;
+    readonly delaySeconds: 0.1875;
+    readonly mix: 0.45;
+    readonly feedback: 0.25;
+    readonly gain: 0.2;
+    readonly reset: 0;
+};

package/dist/musical-materials.js

@@ -0,0 +1,56 @@
+/** Original synthetic materials and ordinary native AudioParam values.
+ * These are CANDIDATE examples, not a preset format or listening-approved audio.
+ * Asset creation runs on the host before the native `load` message is sent.
+ */
+export const musicalMaterialsStatus = 'CANDIDATE';
+export const glassDyadParameters = {
+    gateA: 0, gateB: 0, frequencyA: 220, frequencyB: 330,
+    frame: .25, gain: .2, reset: 0,
+};
+export const glassDyadBrightParameters = { ...glassDyadParameters, frame: 1.75 };
+export const glassDyadConstruction = { voices: 2, frameLength: 128, frameCount: 3, capacity: 384 };
+/** Three complete 128-sample cycles, no duplicate endpoint; fixed weights, no normalization. */
+export function makeGlassDyadTable() {
+    return Float32Array.from({ length: 384 }, (_, n) => {
+        const phase = 2 * Math.PI * (n % 128) / 128;
+        const frame = Math.floor(n / 128);
+        return frame === 0 ? .8 * Math.sin(phase)
+            : frame === 1 ? .6 * Math.sin(phase) + .2 * Math.sin(2 * phase)
+                : .4 * Math.sin(phase) + .25 * Math.sin(2 * phase) + .15 * Math.sin(3 * phase);
+    });
+}
+export const fmModalHitParameters = {
+    gate: 0, strength: .8, ratio: 1.5, deviationHz: 100, modalMix: .35, gain: .22, reset: 0,
+};
+export const fmModalHitBellParameters = { ...fmModalHitParameters, ratio: 2.75, deviationHz: 170, modalMix: .7 };
+export const fmModalHitModes = [
+    { frequencyHz: 220, decaySeconds: .42, gain: 1 },
+    { frequencyHz: 351, decaySeconds: .24, gain: .6 },
+    { frequencyHz: 563, decaySeconds: .15, gain: .35 },
+];
+export const grainCloudParameters = {
+    gate: 0, positionFrames: 512, jitterFrames: 240, rate: 1,
+    durationSeconds: .09, densityHz: 16, gain: .28, reset: 0,
+};
+export const grainCloudReverseParameters = {
+    ...grainCloudParameters, positionFrames: 2800, rate: -.75,
+    durationSeconds: .12, densityHz: 12,
+};
+export const grainCloudConstruction = { capacity: 4096, sourceSampleRate: 48000, maxGrains: 2, seed: 1741 };
+/** Original periodic tone cluster with a smooth fixed amplitude contour.
+ * Integer cycle counts make the short resident loop continuous. No recorded audio.
+ */
+export function makeGrainCloudSample() {
+    return Float32Array.from({ length: 4096 }, (_, n) => {
+        const phase = 2 * Math.PI * n / 4096;
+        const contour = .55 - .45 * Math.cos(phase);
+        return contour * (.32 * Math.sin(19 * phase) + .17 * Math.sin(31 * phase) + .08 * Math.sin(47 * phase));
+    });
+}
+export const shapedEchoParameters = {
+    drive: 2.4, cutoffHz: 1800, delaySeconds: .125, feedback: .25,
+    mix: .3, gain: .2, reset: 0,
+};
+export const shapedEchoDarkParameters = {
+    ...shapedEchoParameters, drive: 4.5, cutoffHz: 650, delaySeconds: .1875, mix: .45,
+};

package/dist/oscillator.d.ts

@@ -0,0 +1,10 @@
+import { type Node } from '@unworklet/core';
+export interface OscillatorConfig {
+    sampleRate: number;
+    waveform: 'sine' | 'saw';
+}
+/** Phase accumulator with sine or four-sample polynomial BLEP saw. */
+export declare const oscillator: import("@unworklet/core").SubgraphDecl<[config: OscillatorConfig], {
+    /** Emit current phase, then advance. Reset emits phase zero on that sample. */
+    tick(frequency: Node<"f32">, reset: Node<"bool">): Node<"f32">;
+}>;

package/dist/oscillator.js

@@ -0,0 +1,35 @@
+import { defineSubgraph, f32, f64, select, state } from '@unworklet/core';
+/** Phase accumulator with sine or four-sample polynomial BLEP saw. */
+export const oscillator = defineSubgraph((config) => {
+    if (!Number.isFinite(config.sampleRate) || config.sampleRate < 8000 || config.sampleRate > 192000) {
+        throw new RangeError('oscillator sampleRate must be finite and in [8000, 192000] Hz');
+    }
+    if (config.waveform !== 'sine' && config.waveform !== 'saw')
+        throw new RangeError('unknown oscillator waveform');
+    const phase = state.f64(0).named('phase');
+    return {
+        /** Emit current phase, then advance. Reset emits phase zero on that sample. */
+        tick(frequency, reset) {
+            const dt = f64(frequency).clamp(0, 0.45 * config.sampleRate).div(config.sampleRate);
+            const p = select(reset, f64(0), phase.read());
+            phase.write(p.add(dt).frac());
+            if (config.waveform === 'sine') {
+                // Fold to [-pi/2, pi/2]; degree 13 has <7e-10 remainder here.
+                const cycles = select(p.lt(0.25), p, select(p.lt(0.75), f64(0.5).sub(p), p.sub(1)));
+                const angle = cycles.mul(2 * Math.PI), z = angle.mul(angle);
+                const polynomial = f64(1 / 6227020800).mul(z).sub(1 / 39916800).mul(z).add(1 / 362880).mul(z).sub(1 / 5040).mul(z).add(1 / 120).mul(z).sub(1 / 6).mul(z).add(1);
+                return f32(angle.mul(polynomial));
+            }
+            // A zero frequency holds phase; avoid 0/0 even in eagerly evaluated selects.
+            const width = select(dt.gt(0), dt, f64(1));
+            // Integrate a cubic B-spline kernel (four boxes convolved). Its step
+            // complement for x >= 0 has support two sample intervals.
+            const complement = (x) => {
+                const x2 = x.mul(x), outer = f64(2).sub(x).max(0);
+                return select(x.lt(1), f64(0.5).sub(x.mul(2 / 3)).add(x2.mul(x).div(3)).sub(x2.mul(x2).div(8)), outer.mul(outer).mul(outer).mul(outer).div(24));
+            };
+            const correction = complement(p.div(width)).sub(complement(f64(1).sub(p).div(width))).mul(2);
+            return f32(p.mul(2).sub(1).add(select(dt.gt(0), correction, f64(0))));
+        },
+    };
+});

package/dist/oversampled-drive.d.ts

@@ -0,0 +1,19 @@
+import { type Node } from '@unworklet/core';
+import type { DriveCurve } from './drive.js';
+/** Matched linear-phase bulk delay. FIR precursors exist before sample 32. */
+export declare const OVERSAMPLED_DRIVE_LATENCY_SAMPLES = 32;
+export interface OversampledDriveConfig {
+    /** Host rate. The fixed arithmetic shaper has no nested sample-rate runtime. */
+    sampleRate: number;
+    factor: 2 | 4;
+    curve: DriveCurve;
+}
+/** Fixed polyphase interpolation -> memoryless shape -> FIR/phase-zero
+ * decimation. Both factors have 32-sample matched bulk delay and deliberate
+ * high-frequency rolloff. Dry follows the exact linear resampling cascade.
+ */
+export declare const oversampledDrive: import("@unworklet/core").SubgraphDecl<[config: OversampledDriveConfig], {
+    /** Once per host sample. Input [-8,8], linear gain [0,32], mix [0,1].
+     * Reset invalidates old history before consuming the current sample. */
+    tick(input: Node<"f32">, gain: Node<"f32">, mix: Node<"f32">, reset: Node<"bool">): Node<"f32">;
+}>;

package/dist/oversampled-drive.js

@@ -0,0 +1,99 @@
+import { defineSubgraph, f32, f64, floor, i32, select, state } from '@unworklet/core';
+/** Matched linear-phase bulk delay. FIR precursors exist before sample 32. */
+export const OVERSAMPLED_DRIVE_LATENCY_SAMPLES = 32;
+const SCALE = 2 ** 128;
+function bounded(value, low, high) {
+    const wide = f64(value);
+    return select(wide.eq(wide), wide, f64(0)).clamp(low, high);
+}
+function soft(value) {
+    const x = value.clamp(-1, 1);
+    return x.mul(f64(1.5).sub(x.mul(x).mul(.5)));
+}
+function shape(x, curve) {
+    if (curve === 'hard')
+        return x.clamp(-1, 1);
+    if (curve === 'soft')
+        return soft(x);
+    if (curve === 'asymmetric')
+        return select(x.lt(0), soft(x.mul(2)).mul(.5), soft(x));
+    const phase = x.add(1).sub(floor(x.add(1).div(4)).mul(4));
+    return select(x.abs().lte(1), x, f64(1).sub(phase.sub(2).abs()));
+}
+function kernel(factor) {
+    const half = 16 * factor, cutoff = .45 / factor;
+    const values = Array.from({ length: 2 * half + 1 }, (_, k) => {
+        const distance = Math.abs(k - half);
+        if (distance === half)
+            return 0;
+        const ideal = distance === 0 ? 2 * cutoff : Math.sin(2 * Math.PI * cutoff * distance) / (Math.PI * distance);
+        return ideal * (.42 + .5 * Math.cos(Math.PI * distance / half) + .08 * Math.cos(2 * Math.PI * distance / half));
+    });
+    const sum = values.reduce((a, b) => a + b, 0);
+    return values.map(value => value / sum);
+}
+/** Fixed polyphase interpolation -> memoryless shape -> FIR/phase-zero
+ * decimation. Both factors have 32-sample matched bulk delay and deliberate
+ * high-frequency rolloff. Dry follows the exact linear resampling cascade.
+ */
+export const oversampledDrive = defineSubgraph((config) => {
+    const { sampleRate, factor, curve } = config;
+    if (!Number.isFinite(sampleRate) || sampleRate < 8000 || sampleRate > 192000)
+        throw new RangeError('oversampledDrive sampleRate must be in [8000,192000] Hz');
+    if (factor !== 2 && factor !== 4)
+        throw new RangeError('oversampledDrive factor must be 2 or 4');
+    if (!['hard', 'soft', 'asymmetric', 'fold'].includes(curve))
+        throw new RangeError('unknown oversampledDrive curve');
+    const h = kernel(factor), size = h.length;
+    const dryKernel = Array.from({ length: 65 }, (_, j) => factor * h.reduce((sum, value, k) => sum + value * (h[factor * j - k] ?? 0), 0));
+    const driven = state.buffer.f64({ size: 33 }).expose({ name: 'driven-scaled', snapshot: 'persistent' });
+    const raw = state.buffer.f64({ size: 65 }).expose({ name: 'dry-scaled', snapshot: 'persistent' });
+    const shaped = state.buffer.f64({ size }).expose({ name: 'shaped-scaled', snapshot: 'persistent' });
+    const drivenCursor = state.i32(0).named('driven-cursor'), dryCursor = state.i32(0).named('dry-cursor');
+    const highCursor = state.i32(0).named('high-cursor');
+    const baseValid = state.i32(0).named('base-valid'), highValid = state.i32(0).named('high-valid');
+    const up = state.f64(0).expose({ name: 'interpolated-scaled', snapshot: 'transient' });
+    const wet = state.f64(0).expose({ name: 'wet-sum-scaled', snapshot: 'transient' });
+    const dry = state.f64(0).expose({ name: 'dry-sum-scaled', snapshot: 'transient' });
+    return {
+        /** Once per host sample. Input [-8,8], linear gain [0,32], mix [0,1].
+         * Reset invalidates old history before consuming the current sample. */
+        tick(input, gain, mix, reset) {
+            const audio = bounded(input, -8, 8), amount = bounded(mix, 0, 1);
+            baseValid.write(select(reset, i32(1), baseValid.read().add(1).min(65)));
+            highValid.write(select(reset, i32(0), highValid.read()));
+            raw.write(dryCursor.read(), audio.mul(SCALE));
+            driven.write(drivenCursor.read(), audio.mul(bounded(gain, 0, 32)).mul(SCALE));
+            const baseAt = (lag) => select(baseValid.read().gt(lag), driven.read(drivenCursor.read().add(33 - lag).mod(33)), f64(0));
+            const highAt = (lag) => select(highValid.read().gt(lag), shaped.read(highCursor.read().add(size - lag).mod(size)), f64(0));
+            // These are fixed construction-time phases, not a second graph scheduler.
+            // Filtering suppresses images before and after the nonlinearity.
+            for (let phase = 0; phase < factor; phase++) {
+                up.write(0);
+                for (let tap = phase; tap < size; tap += factor) {
+                    if (h[tap] !== 0)
+                        up.write(up.read().add(baseAt((tap - phase) / factor).mul(factor * h[tap])));
+                }
+                shaped.write(highCursor.read(), shape(up.read().div(SCALE), curve).mul(SCALE));
+                highValid.write(highValid.read().add(1).min(size));
+                if (phase === 0) {
+                    wet.write(0);
+                    for (let tap = 0; tap < size; tap++)
+                        if (h[tap] !== 0)
+                            wet.write(wet.read().add(highAt(tap).mul(h[tap])));
+                }
+                highCursor.write(highCursor.read().add(1).mod(size));
+            }
+            dry.write(0);
+            for (let tap = 0; tap < dryKernel.length; tap++) {
+                if (dryKernel[tap] !== 0) {
+                    const previous = select(baseValid.read().gt(tap), raw.read(dryCursor.read().add(65 - tap).mod(65)), f64(0));
+                    dry.write(dry.read().add(previous.mul(dryKernel[tap])));
+                }
+            }
+            drivenCursor.write(drivenCursor.read().add(1).mod(33));
+            dryCursor.write(dryCursor.read().add(1).mod(65));
+            return f32(dry.read().mul(f64(1).sub(amount)).add(wet.read().mul(amount)).div(SCALE));
+        },
+    };
+});