@denaudio/den 0.0.0-stage → 0.2.0

package/dist/multiband-dynamics.d.ts

@@ -0,0 +1,50 @@
+import { type Node } from '@unworklet/core';
+import { type DynamicsConfig, type DynamicsControls } from './dynamics.js';
+export type MultibandDynamicsBandConfig = Omit<DynamicsConfig, 'sampleRate'>;
+export interface MultibandDynamicsConfig {
+    sampleRate: number;
+    /** Fixed low/mid/high operations and detector modes. */
+    bands: readonly [MultibandDynamicsBandConfig, MultibandDynamicsBandConfig, MultibandDynamicsBandConfig];
+}
+export type MultibandDynamicsBandControls = Omit<DynamicsControls, 'reset'>;
+export interface MultibandDynamicsControls {
+    /** Finite fallbacks 200/2000 Hz, individually clamped and then sorted. Equality is permitted. */
+    lowCutoffHz: Node<'f32'>;
+    highCutoffHz: Node<'f32'>;
+    bands: readonly [MultibandDynamicsBandControls, MultibandDynamicsBandControls, MultibandDynamicsBandControls];
+    reset: Node<'bool'>;
+}
+/** Three phase-compensated LR4 bands with independent linked-stereo dynamics. */
+export declare const multibandDynamics: import("@unworklet/core").SubgraphDecl<[config: MultibandDynamicsConfig], {
+    /** No explicit sample delay. IIR phase/group delay is frequency dependent. */
+    tick(left: Node<"f32">, right: Node<"f32">, controls: MultibandDynamicsControls): {
+        left: Node<"f32">;
+        right: Node<"f32">;
+        /** Phase-matched unprocessed recombination; not the original dry PCM. */
+        dryLeft: Node<"f32">;
+        dryRight: Node<"f32">;
+        low: {
+            left: Node<"f32">;
+            right: Node<"f32">;
+            envelope: Node<"f32">;
+            gain: Node<"f32">;
+            gainDb: Node<"f32">;
+        };
+        mid: {
+            left: Node<"f32">;
+            right: Node<"f32">;
+            envelope: Node<"f32">;
+            gain: Node<"f32">;
+            gainDb: Node<"f32">;
+        };
+        high: {
+            left: Node<"f32">;
+            right: Node<"f32">;
+            envelope: Node<"f32">;
+            gain: Node<"f32">;
+            gainDb: Node<"f32">;
+        };
+        lowCutoffHz: Node<"f32">;
+        highCutoffHz: Node<"f32">;
+    };
+}>;

package/dist/multiband-dynamics.js

@@ -0,0 +1,60 @@
+import { defineSubgraph, f32, f64, instantiate, select, state } from '@unworklet/core';
+import { crossover } from './crossover.js';
+import { dynamics } from './dynamics.js';
+function finite(input, fallback = 0) {
+    return select(input.eq(input).and(input.abs().lte(3.4028234663852886e38)), input, f32(fallback));
+}
+const sum = (a, b, c) => f32(f64(a).add(f64(b)).add(c ? f64(c) : f64(0)));
+/** Three phase-compensated LR4 bands with independent linked-stereo dynamics. */
+export const multibandDynamics = defineSubgraph((config) => {
+    const { sampleRate } = config;
+    if (!Number.isInteger(sampleRate) || sampleRate < 8000 || sampleRate > 192000) {
+        throw new RangeError('multibandDynamics sampleRate must be an integer in [8000,192000]');
+    }
+    if (!Array.isArray(config.bands) || config.bands.length !== 3)
+        throw new RangeError('multibandDynamics requires exactly three bands');
+    const maximum = Math.min(20000, 0.45 * sampleRate);
+    const splits = ['left', 'right'].map(channel => ({
+        low: instantiate(crossover, { sampleRate }, { name: `${channel}LowSplit` }),
+        high: instantiate(crossover, { sampleRate }, { name: `${channel}HighSplit` }),
+        compensate: instantiate(crossover, { sampleRate }, { name: `${channel}LowCompensation` }),
+    }));
+    // Materialize the existing f32 stage boundaries once. Without these native
+    // scratch buffers, 0.4.1 re-expands returned expressions at every consumer.
+    // Exact binary64 scaling prevents the native <1e-30 buffer-store flush from
+    // changing tiny audio; each slot is overwritten before read on every tick.
+    const scale = 2 ** 128;
+    const scratch = ['left', 'right'].map(channel => state.buffer.f64({ size: 5 })
+        .expose({ name: `${channel}StageScratchScaled`, snapshot: 'transient' }));
+    const processors = config.bands.map((band, i) => instantiate(dynamics, { ...band, sampleRate }, { name: `band${i}` }));
+    return {
+        /** No explicit sample delay. IIR phase/group delay is frequency dependent. */
+        tick(left, right, controls) {
+            const a = finite(controls.lowCutoffHz, 200).clamp(20, maximum);
+            const b = finite(controls.highCutoffHz, 2000).clamp(20, maximum);
+            const lowCutoffHz = a.min(b), highCutoffHz = a.max(b);
+            const bands = [left, right].map((input, ch) => {
+                const first = splits[ch].low.tick(finite(input), lowCutoffHz, controls.reset);
+                const store = (index, value) => scratch[ch].write(index, f64(value).mul(scale));
+                const read = (index) => f32(scratch[ch].read(index).div(scale));
+                store(0, first.low);
+                store(1, first.high);
+                const upper = splits[ch].high.tick(read(1), highCutoffHz, controls.reset);
+                const compensation = splits[ch].compensate.tick(read(0), highCutoffHz, controls.reset);
+                store(2, sum(compensation.low, compensation.high));
+                store(3, upper.low);
+                store(4, upper.high);
+                return [read(2), read(3), read(4)];
+            });
+            const processed = processors.map((unit, i) => unit.tick(bands[0][i], bands[1][i], bands[0][i], bands[1][i], { ...controls.bands[i], reset: controls.reset }));
+            return {
+                left: sum(processed[0].left, processed[1].left, processed[2].left),
+                right: sum(processed[0].right, processed[1].right, processed[2].right),
+                /** Phase-matched unprocessed recombination; not the original dry PCM. */
+                dryLeft: sum(...bands[0]), dryRight: sum(...bands[1]),
+                low: processed[0], mid: processed[1], high: processed[2],
+                lowCutoffHz, highCutoffHz,
+            };
+        },
+    };
+});

package/dist/musical-controls.d.ts

@@ -0,0 +1,76 @@
+import { type Node } from '@unworklet/core';
+export interface CurvedAdsrConfig {
+    sampleRate: number;
+}
+export interface CurvedAdsrControls {
+    gate: Node<'bool'>;
+    /** Level-sensitive; ignored while gate is false. */
+    retrigger: Node<'bool'>;
+    /** Wins over all other controls and consumes the gate level. */
+    reset: Node<'bool'>;
+    /** Seconds, clamped [0,30], rounded to the nearest sample (half up). */
+    attack: Node<'f32'>;
+    decay: Node<'f32'>;
+    sustain: Node<'f32'>;
+    release: Node<'f32'>;
+    /** Latched segment bends [-1,1]: -1 ease-in, 0 linear, +1 ease-out. */
+    attackBend: Node<'f32'>;
+    decayBend: Node<'f32'>;
+    releaseBend: Node<'f32'>;
+}
+export interface CurvedAdsrOutput {
+    level: Node<'f32'>;
+    done: Node<'bool'>;
+}
+/**
+ * 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 declare const curvedAdsr: import("@unworklet/core").SubgraphDecl<[config: CurvedAdsrConfig], {
+    tick(c: CurvedAdsrControls): CurvedAdsrOutput;
+}>;
+export type MusicalLfoWaveform = 'sine' | 'triangle' | 'saw' | 'square';
+export interface MusicalLfoConfig {
+    sampleRate: number;
+    mode: 'free' | 'tempo';
+    waveform: MusicalLfoWaveform;
+    /** Tempo mode only, power of two in [1/64,64], default 1. */
+    beatsPerCycle?: number;
+}
+export interface MusicalLfoControls {
+    /** Free: Hz [0,20]. Tempo: BPM [0,1000]. */
+    rate: Node<'f32'>;
+    /** Hold the base clock at zero; offset still applies. Consumes seek level. */
+    reset: Node<'bool'>;
+    /** Rising-edge seek, including while held. Reset wins. */
+    seek: Node<'bool'>;
+    /** Seek position in cycles, clamped +/-1048576 then wrapped. */
+    position: Node<'f32'>;
+    /** Live cycles offset, clamped +/-1048576. May deliberately jump. */
+    phaseOffset: Node<'f32'>;
+    /** Stops base-phase integration; seek/reset and live offset still apply. */
+    hold: Node<'bool'>;
+}
+export interface MusicalLfoOutput {
+    value: Node<'f32'>;
+    /** Canonical f32 waveform phase [0,1), capped at 1-2^-24. */
+    phase: Node<'f32'>;
+}
+/**
+ * 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 declare const musicalLfo: import("@unworklet/core").SubgraphDecl<[config: MusicalLfoConfig], {
+    tick(c: MusicalLfoControls): MusicalLfoOutput;
+}>;

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,
+};