@joewinke/jatui 0.46.0 → 0.47.0

package/dist/ambience/index.js

@@ -0,0 +1,27 @@
+/**
+ * Ambience engine — public entry. Headless by design: hosts (e.g.
+ * AmbienceToggle.svelte) import createAmbience and wire their own UI.
+ *
+ * @example
+ *   import { createAmbience, createDefaultAmbience } from '../../../dist/ambience'; // once integration lands
+ *   const ambience = createDefaultAmbience(); // hibiscus, focus, noise, rain, waves pre-registered
+ *   ambience.register(myScape);
+ *   // inside a click handler:
+ *   await ambience.play('rain');
+ */
+export { createAmbience, TIMING } from './engine';
+export { createDefaultAmbience, DEFAULT_SCAPES } from './default';
+// The shipped scapes — hosts that want a hand-picked registry import them
+// individually instead of using createDefaultAmbience().
+export { hibiscusScape } from './scapes/hibiscus';
+export { focusScape } from './scapes/focus';
+export { noiseScapes, brownNoiseScape, pinkNoiseScape, whiteNoiseScape } from './scapes/noise';
+export { rain, waves } from './scapes/nature';
+// Playlist scape (phase 2) — host-supplied manifest of public-domain
+// recordings. NOTE: never auto-registered in DEFAULT_SCAPES — a playlist is
+// per-host (its manifest URL and licensing claims are the host's); build one
+// with createPlaylistScape() and engine.register() it yourself.
+export { createPlaylistScape } from './scapes/playlist';
+export { BreathClock, BREATHS_PER_MINUTE } from './breath';
+export { MASTER } from './master';
+export { ScapeRegistry } from './registry';

package/dist/ambience/master.d.ts

@@ -0,0 +1,49 @@
+/**
+ * The shared master chain — built ONCE per engine AudioContext, fed by every
+ * scape through one `input` gain. Written fresh from the hibiscus recipe
+ * (generative Web Audio, no files, no libraries); the node vocabulary mirrors
+ * src/lib/video/audio but the numbers and purpose are ambience's own.
+ *
+ *   input (bus gain)
+ *     ─► peaking EQ (+2.5 dB @ 220 Hz — the "warm wood" tilt)
+ *     ─► lowpass (1100 Hz — ambience lives below the hiss band)
+ *     ─► dry ──────────────────────────────┐
+ *     ─► convolver (≈6 s decaying-noise    ├─► soft-clip limiter ─► master ─► volume ─► destination
+ *        impulse) ─► wet (50%) ────────────┘
+ *
+ * The limiter is a WaveShaper with a tanh knee: bit-transparent below −6 dBFS,
+ * progressively softer above, so a loud scape can never clip the mix. The
+ * convolution reverb is synthesized (decaying noise impulse) — no IR file.
+ *
+ * Everything the host moves (bus fades, volume ramps) is scheduled on the two
+ * gain params, never `.value` writes mid-stream — a `.value` write clicks.
+ */
+import type { AudioContextLike } from './types';
+export declare const MASTER: Readonly<{
+    EQ_HZ: 220;
+    EQ_GAIN_DB: 2.5;
+    EQ_Q: 0.8;
+    LOWPASS_HZ: 1100;
+    /** Reverb send: 50% wet. */
+    WET: 0.5;
+    /** Transparent below this, tanh knee above (linear gain ≈ 0.501). */
+    KNEE: 0.501;
+    /** Impulse length and decay for the synthesized reverb. */
+    IR_SECONDS: 6;
+    IR_DECAY: 3.5;
+}>;
+/** Build the graph; returns the entry node and the two params the engine drives. */
+export interface MasterChain {
+    input: AudioNode;
+    bus: GainNode;
+    volume: GainNode;
+    dispose(): void;
+}
+export declare function createMasterChain(ctx: AudioContextLike): MasterChain;
+/**
+ * tanh soft clip. Below the knee (≈ −6 dBFS) the curve is the identity to
+ * within float noise — the limiter only exists for the peaks.
+ */
+export declare function softClipCurve(n?: number): Float32Array;
+/** Decaying-noise impulse response — a ~6 s synthesized hall, no IR file. */
+export declare function makeImpulse(ctx: AudioContextLike, seconds: number, decay: number): AudioBuffer;

package/dist/ambience/master.js

@@ -0,0 +1,83 @@
+export const MASTER = Object.freeze({
+    EQ_HZ: 220,
+    EQ_GAIN_DB: 2.5,
+    EQ_Q: 0.8,
+    LOWPASS_HZ: 1100,
+    /** Reverb send: 50% wet. */
+    WET: 0.5,
+    /** Transparent below this, tanh knee above (linear gain ≈ 0.501). */
+    KNEE: 0.501,
+    /** Impulse length and decay for the synthesized reverb. */
+    IR_SECONDS: 6,
+    IR_DECAY: 3.5
+});
+export function createMasterChain(ctx) {
+    const bus = ctx.createGain();
+    const eq = ctx.createBiquadFilter();
+    eq.type = 'peaking';
+    eq.frequency.value = MASTER.EQ_HZ;
+    eq.gain.value = MASTER.EQ_GAIN_DB;
+    eq.Q.value = MASTER.EQ_Q;
+    const lowpass = ctx.createBiquadFilter();
+    lowpass.type = 'lowpass';
+    lowpass.frequency.value = MASTER.LOWPASS_HZ;
+    const shaper = ctx.createWaveShaper();
+    shaper.curve = softClipCurve();
+    const convolver = ctx.createConvolver();
+    convolver.buffer = makeImpulse(ctx, MASTER.IR_SECONDS, MASTER.IR_DECAY);
+    const wet = ctx.createGain();
+    wet.gain.value = MASTER.WET;
+    const master = ctx.createGain();
+    const volume = ctx.createGain();
+    bus.connect(eq);
+    eq.connect(lowpass);
+    lowpass.connect(shaper); // dry
+    lowpass.connect(convolver);
+    convolver.connect(wet);
+    wet.connect(shaper); // wet send sums into the limiter
+    shaper.connect(master);
+    master.connect(volume);
+    volume.connect(ctx.destination);
+    return {
+        input: bus,
+        bus,
+        volume,
+        dispose() {
+            for (const n of [bus, eq, lowpass, shaper, convolver, wet, master, volume]) {
+                try {
+                    n.disconnect();
+                }
+                catch {
+                    /* already torn down */
+                }
+            }
+        }
+    };
+}
+/**
+ * tanh soft clip. Below the knee (≈ −6 dBFS) the curve is the identity to
+ * within float noise — the limiter only exists for the peaks.
+ */
+export function softClipCurve(n = 2048) {
+    const curve = new Float32Array(n);
+    for (let i = 0; i < n; i++) {
+        const x = (i / (n - 1)) * 2 - 1;
+        const a = Math.abs(x);
+        curve[i] =
+            a <= MASTER.KNEE ? x : Math.tanh((x - Math.sign(x) * MASTER.KNEE) / (1 - MASTER.KNEE)) * (1 - MASTER.KNEE) + Math.sign(x) * MASTER.KNEE;
+    }
+    return curve;
+}
+/** Decaying-noise impulse response — a ~6 s synthesized hall, no IR file. */
+export function makeImpulse(ctx, seconds, decay) {
+    const rate = ctx.sampleRate;
+    const len = Math.max(1, Math.floor(rate * seconds));
+    const buf = ctx.createBuffer(2, len, rate);
+    for (let ch = 0; ch < 2; ch++) {
+        const data = buf.getChannelData(ch);
+        for (let i = 0; i < len; i++) {
+            data[i] = (Math.random() * 2 - 1) * Math.pow(1 - i / len, decay);
+        }
+    }
+    return buf;
+}

package/dist/ambience/persist.d.ts

@@ -0,0 +1,11 @@
+/**
+ * localStorage persistence, try/catch everywhere: private mode, storage
+ * disabled and SSR all degrade to "no memory" and the engine still works.
+ * Restoring NEVER plays — it only preselects.
+ */
+export interface PersistedAmbience {
+    volume?: number;
+    lastScape?: string;
+}
+export declare function loadPersisted(key: string): PersistedAmbience;
+export declare function savePersisted(key: string, value: PersistedAmbience): void;

package/dist/ambience/persist.js

@@ -0,0 +1,24 @@
+export function loadPersisted(key) {
+    try {
+        const raw = typeof localStorage !== 'undefined' ? localStorage.getItem(key) : null;
+        if (!raw)
+            return {};
+        const parsed = JSON.parse(raw);
+        return typeof parsed === 'object' && parsed !== null
+            ? parsed
+            : {};
+    }
+    catch {
+        return {};
+    }
+}
+export function savePersisted(key, value) {
+    try {
+        if (typeof localStorage === 'undefined')
+            return;
+        localStorage.setItem(key, JSON.stringify(value));
+    }
+    catch {
+        /* private mode / quota — persistence is best-effort */
+    }
+}

package/dist/ambience/registry.d.ts

@@ -0,0 +1,11 @@
+/**
+ * The scape registry — a named map with duplicate-id protection. list()
+ * returns registration order (stable for menus).
+ */
+import type { Scape } from './types';
+export declare class ScapeRegistry {
+    #private;
+    register(scape: Scape): void;
+    get(id: string): Scape | undefined;
+    list(): Scape[];
+}

package/dist/ambience/registry.js

@@ -0,0 +1,16 @@
+export class ScapeRegistry {
+    #scapes = new Map();
+    register(scape) {
+        if (!scape?.id)
+            throw new Error('Scape must have an id');
+        if (this.#scapes.has(scape.id))
+            throw new Error(`Scape id already registered: ${scape.id}`);
+        this.#scapes.set(scape.id, scape);
+    }
+    get(id) {
+        return this.#scapes.get(id);
+    }
+    list() {
+        return [...this.#scapes.values()];
+    }
+}

package/dist/ambience/scapes/focus.d.ts

@@ -0,0 +1,55 @@
+/**
+ * The focus scape — a neutral, low-distraction drone for work. Tuned for
+ * concentration, not meditation: a static open-fifth sine drone (A2 + E3 +
+ * a quiet A3 octave, just intonation — no thirds, no melodic movement) over
+ * a slightly fuller brown/pink noise bed. NO chimes by default; the only
+ * event is an optional soft bell a host can trigger for pomodoro-style
+ * boundaries via `setParam('bell', true)`.
+ *
+ * No binaural beats, no 40 Hz gimmicks, no per-sample JS: the noise buffers
+ * are generated once per build and looped as native AudioBufferSources with
+ * randomized start offsets (so they never audibly repeat from the same
+ * point), and the only modulation is the shared breath clock nudging the
+ * drone's lowpass a few percent — subtle and slow, not a "breathing" sound.
+ *
+ * Built against the Scape contract (src/lib/ambience/types.ts) only; the
+ * integration task registers it. Everything connects into ctx.input — the
+ * shared master chain owns EQ, reverb, limiting and volume after that.
+ */
+import type { Scape } from "../types";
+export declare const FOCUS: Readonly<{
+    /** Open-fifth drone: A2 root, E3 fifth (110 × 1.5), A3 octave. */
+    ROOT_HZ: 110;
+    FIFTH_HZ: 165;
+    OCTAVE_HZ: 220;
+    /** Per-voice drone gains (sum ≈ 0.135 — present, not foreground). */
+    ROOT_GAIN: 0.07;
+    FIFTH_GAIN: 0.05;
+    OCTAVE_GAIN: 0.018;
+    /** Noise bed: the brown/pink mix, lowpassed to stay dark and behind. */
+    NOISE_SECONDS: 8;
+    BROWN_GAIN: 0.055;
+    PINK_GAIN: 0.04;
+    NOISE_LOWPASS_HZ: 500;
+    /** Drone lowpass the breath nudges. */
+    DRONE_LOWPASS_HZ: 900;
+    /** Breath modulation: shallow (±8%) and slow (2.5 s time constant) —
+     *  felt as "the room moves", never heard as a wobble. */
+    BREATH_DEPTH: 0.08;
+    BREATH_TAU: 2.5;
+    /** Scape output level and the fade the instance applies itself (the
+     *  engine fades the bus on crossfades; the instance fade keeps the very
+     *  first play click-free). */
+    LEVEL: 1;
+    FADE_IN: 3;
+    /** Optional soft bell (pomodoro boundaries): C5 fundamental + a faint
+     *  inharmonic partial, ~5 s decay, quiet enough to never jar. */
+    BELL_HZ: 523.25;
+    BELL_PARTIAL_HZ: 1255;
+    BELL_GAIN: 0.05;
+    BELL_PARTIAL_GAIN: 0.018;
+    BELL_TAU: 1.2;
+    BELL_PARTIAL_TAU: 0.5;
+    BELL_SECONDS: 5;
+}>;
+export declare const focusScape: Scape;

package/dist/ambience/scapes/focus.js

@@ -0,0 +1,245 @@
+export const FOCUS = Object.freeze({
+    /** Open-fifth drone: A2 root, E3 fifth (110 × 1.5), A3 octave. */
+    ROOT_HZ: 110,
+    FIFTH_HZ: 165,
+    OCTAVE_HZ: 220,
+    /** Per-voice drone gains (sum ≈ 0.135 — present, not foreground). */
+    ROOT_GAIN: 0.07,
+    FIFTH_GAIN: 0.05,
+    OCTAVE_GAIN: 0.018,
+    /** Noise bed: the brown/pink mix, lowpassed to stay dark and behind. */
+    NOISE_SECONDS: 8,
+    BROWN_GAIN: 0.055,
+    PINK_GAIN: 0.04,
+    NOISE_LOWPASS_HZ: 500,
+    /** Drone lowpass the breath nudges. */
+    DRONE_LOWPASS_HZ: 900,
+    /** Breath modulation: shallow (±8%) and slow (2.5 s time constant) —
+     *  felt as "the room moves", never heard as a wobble. */
+    BREATH_DEPTH: 0.08,
+    BREATH_TAU: 2.5,
+    /** Scape output level and the fade the instance applies itself (the
+     *  engine fades the bus on crossfades; the instance fade keeps the very
+     *  first play click-free). */
+    LEVEL: 1,
+    FADE_IN: 3,
+    /** Optional soft bell (pomodoro boundaries): C5 fundamental + a faint
+     *  inharmonic partial, ~5 s decay, quiet enough to never jar. */
+    BELL_HZ: 523.25,
+    BELL_PARTIAL_HZ: 1255, // ≈ C5 × 2.4 — bell-like inharmonic overtone
+    BELL_GAIN: 0.05,
+    BELL_PARTIAL_GAIN: 0.018,
+    BELL_TAU: 1.2,
+    BELL_PARTIAL_TAU: 0.5,
+    BELL_SECONDS: 5,
+});
+/** Normalize a mono buffer to a sane peak so the mix never relies on luck. */
+function normalize(data, peak = 0.5) {
+    let max = 0;
+    for (let i = 0; i < data.length; i++) {
+        const a = Math.abs(data[i]);
+        if (a > max)
+            max = a;
+    }
+    if (max === 0)
+        return;
+    const k = peak / max;
+    for (let i = 0; i < data.length; i++)
+        data[i] *= k;
+}
+/** Brown noise: leaky integrator over white — the deepest "room rumble". */
+function brownNoise(length, rand) {
+    const out = new Float32Array(length);
+    let last = 0;
+    for (let i = 0; i < length; i++) {
+        const white = rand() * 2 - 1;
+        last = (last + 0.02 * white) / 1.02;
+        out[i] = last * 3.5;
+    }
+    normalize(out);
+    return out;
+}
+/** Pink noise: Paul Kellet's economical filter bank — even power per octave. */
+function pinkNoise(length, rand) {
+    const out = new Float32Array(length);
+    let b0 = 0, b1 = 0, b2 = 0, b3 = 0, b4 = 0, b5 = 0, b6 = 0;
+    for (let i = 0; i < length; i++) {
+        const white = rand() * 2 - 1;
+        b0 = 0.99886 * b0 + white * 0.0555179;
+        b1 = 0.99332 * b1 + white * 0.0750759;
+        b2 = 0.969 * b2 + white * 0.153852;
+        b3 = 0.8665 * b3 + white * 0.3104856;
+        b4 = 0.55 * b4 + white * 0.5329522;
+        b5 = -0.7616 * b5 - white * 0.016898;
+        out[i] = (b0 + b1 + b2 + b3 + b4 + b5 + b6 + white * 0.5362) * 0.11;
+        b6 = white * 0.115926;
+    }
+    normalize(out);
+    return out;
+}
+export const focusScape = {
+    id: "focus",
+    label: "Focus",
+    group: "focus",
+    description: "Neutral low-distraction drone — open fifths over a soft brown/pink noise bed.",
+    build(ctx) {
+        const audio = ctx.audio;
+        /** Every node this instance created — disconnect() all on teardown. */
+        const nodes = [];
+        const sources = [];
+        let stopped = false;
+        const out = audio.createGain();
+        out.gain.value = 0; // start() ramps up; never a mid-stream .value write
+        out.connect(ctx.input); // the master chain owns everything after this
+        nodes.push(out);
+        // --- Noise bed: brown + pink, generated once, looped with a random
+        // --- start offset so every play begins at a different point.
+        const rate = audio.sampleRate;
+        const len = Math.round(FOCUS.NOISE_SECONDS * rate);
+        const brownBuf = audio.createBuffer(1, len, rate);
+        brownBuf.getChannelData(0).set(brownNoise(len, ctx.rand));
+        const pinkBuf = audio.createBuffer(1, len, rate);
+        pinkBuf.getChannelData(0).set(pinkNoise(len, ctx.rand));
+        const noiseFilter = audio.createBiquadFilter();
+        noiseFilter.type = "lowpass";
+        noiseFilter.frequency.value = FOCUS.NOISE_LOWPASS_HZ;
+        nodes.push(noiseFilter);
+        const bed = [
+            { buf: brownBuf, gain: FOCUS.BROWN_GAIN },
+            { buf: pinkBuf, gain: FOCUS.PINK_GAIN },
+        ];
+        const offsets = [];
+        for (const { buf, gain: level } of bed) {
+            const src = audio.createBufferSource();
+            src.buffer = buf;
+            src.loop = true;
+            const g = audio.createGain();
+            g.gain.value = level;
+            src.connect(g);
+            g.connect(noiseFilter);
+            nodes.push(src, g);
+            sources.push(src);
+            // Randomized loop offset — the bed never restarts from the same
+            // point, so the loop seam never becomes a rhythm.
+            offsets.push(ctx.rand() * (FOCUS.NOISE_SECONDS - 0.5));
+        }
+        noiseFilter.connect(out);
+        // --- Drone: static open fifths through one shared lowpass.
+        const droneFilter = audio.createBiquadFilter();
+        droneFilter.type = "lowpass";
+        droneFilter.frequency.value = FOCUS.DRONE_LOWPASS_HZ;
+        droneFilter.Q.value = 0.5;
+        nodes.push(droneFilter);
+        const voices = [
+            { hz: FOCUS.ROOT_HZ, gain: FOCUS.ROOT_GAIN },
+            { hz: FOCUS.FIFTH_HZ, gain: FOCUS.FIFTH_GAIN },
+            { hz: FOCUS.OCTAVE_HZ, gain: FOCUS.OCTAVE_GAIN },
+        ];
+        for (const { hz, gain: level } of voices) {
+            const osc = audio.createOscillator();
+            osc.type = "sine";
+            osc.frequency.value = hz;
+            const g = audio.createGain();
+            g.gain.value = level;
+            osc.connect(g);
+            g.connect(droneFilter);
+            nodes.push(osc, g);
+            sources.push(osc);
+        }
+        droneFilter.connect(out);
+        // --- Subtle breath modulation: the drone lowpass opens ~8% on the
+        // --- inhale (setTargetAtTime keeps it slow; no per-sample JS).
+        const unsubBreath = ctx.lookahead((now) => {
+            if (stopped)
+                return;
+            const b = ctx.breath.state;
+            const target = FOCUS.DRONE_LOWPASS_HZ * (1 + FOCUS.BREATH_DEPTH * b.value);
+            droneFilter.frequency.setTargetAtTime(target, now, FOCUS.BREATH_TAU);
+        });
+        // --- Optional soft bell. Its nodes disconnect via a timer one beat
+        // --- after the decay ends (see the teardown note in stop()).
+        const ringBell = (velocity) => {
+            const t0 = audio.currentTime + 0.02;
+            const partials = [
+                {
+                    hz: FOCUS.BELL_HZ,
+                    peak: FOCUS.BELL_GAIN * velocity,
+                    tau: FOCUS.BELL_TAU,
+                },
+                {
+                    hz: FOCUS.BELL_PARTIAL_HZ,
+                    peak: FOCUS.BELL_PARTIAL_GAIN * velocity,
+                    tau: FOCUS.BELL_PARTIAL_TAU,
+                },
+            ];
+            const bellNodes = [];
+            const bellEnd = t0 + FOCUS.BELL_SECONDS;
+            for (const { hz, peak, tau } of partials) {
+                const osc = audio.createOscillator();
+                osc.type = "sine";
+                osc.frequency.value = hz;
+                const g = audio.createGain();
+                g.gain.setValueAtTime(0, t0);
+                g.gain.linearRampToValueAtTime(peak, t0 + 0.012);
+                g.gain.setTargetAtTime(0, t0 + 0.012, tau);
+                osc.connect(g);
+                g.connect(out);
+                osc.start(t0);
+                osc.stop(bellEnd);
+                nodes.push(osc, g);
+                bellNodes.push(osc, g);
+            }
+            // Teardown on a TIMER, never a lookahead cb: the engine retires a
+            // stopped instance's callbacks at fade*1000 + 250 ms, so a cb parked
+            // past the bell's end can be dropped mid-decay with nodes still
+            // connected. Lookahead is for scheduling sound, not teardown.
+            setTimeout(() => {
+                for (const n of bellNodes)
+                    n.disconnect();
+            }, Math.max(0, (bellEnd - audio.currentTime) * 1000) + 50);
+        };
+        return {
+            start(at) {
+                out.gain.setValueAtTime(0, at);
+                out.gain.linearRampToValueAtTime(FOCUS.LEVEL, at + FOCUS.FADE_IN);
+                let i = 0;
+                for (const src of sources) {
+                    const offset = offsets[i++];
+                    if (offset === undefined)
+                        src.start(at);
+                    else
+                        src.start(at, offset);
+                }
+            },
+            stop(at, fade) {
+                if (stopped)
+                    return;
+                stopped = true;
+                unsubBreath();
+                const end = at + fade;
+                out.gain.cancelScheduledValues(at);
+                out.gain.setValueAtTime(out.gain.value, at);
+                out.gain.linearRampToValueAtTime(0, end);
+                for (const src of sources)
+                    src.stop(end);
+                // Disconnect on a TIMER, not a lookahead cb: the engine RETIRES a
+                // stopped instance's lookahead callbacks at fade*1000 + 250 ms
+                // (engine.ts retireCbs), so a teardown cb waiting for a tick just
+                // past the fade end races that retire and can be dropped — leaving
+                // nodes connected to the shared input forever. 50 ms past the fade
+                // end is silent (gain is 0) and cannot lose the race. Lookahead
+                // stays for scheduling sound only.
+                setTimeout(() => {
+                    for (const n of nodes)
+                        n.disconnect();
+                }, Math.max(0, (end - audio.currentTime) * 1000) + 50);
+            },
+            setParam(key, value) {
+                // Wider than the contract's `number` (method bivariance keeps it
+                // assignable) so a host can write setParam('bell', true).
+                if (key === "bell" && value && !stopped)
+                    ringBell(value === true ? 1 : Number(value));
+            },
+        };
+    },
+};

package/dist/ambience/scapes/hibiscus.d.ts

@@ -0,0 +1,103 @@
+/**
+ * The hibiscus scape — a warm F-major meditation drone, six breaths a minute.
+ * Written FRESH from the recipe in jatui-sgx2i (the tamaracleaver hibiscus
+ * audio is the inspiration, not the source).
+ *
+ * Graph (everything sums into the shared master `input`; the master chain owns
+ * the EQ, reverb, limiter and volume after us):
+ *
+ *   pad     4 partials — F2 + fifth (C3), tenth (A3), twelfth (C4) — each a
+ *           ±7-cent detuned oscillator pair through its own soft waveshaper
+ *           (y = x + a·x³ + b·x⁵: mostly fundamental, a little 3rd and 5th
+ *           harmonic), panned ±0.35 where the context supports it, summed
+ *           into a breath-modulated lowpass → pad level
+ *   float   two sine voices alternating F4 → A4 → C5 → A4 (→ F4 …), ~70 s per
+ *           tone with 16 s cross-fades, lookahead-scheduled
+ *   chimes  every 35–65 s, one current-chord-tone bell an octave up: first 3
+ *           partials, a 2.5 s swell (never a strike) and a long exponential
+ *           decay via setTargetAtTime, random pan; each chime disconnects its
+ *           own nodes on a timer once its tail is done
+ *   air     a 4 s pink-noise buffer generated once and looped from a random
+ *           offset (so it never audibly repeats), highpassed at 80 Hz and
+ *           lowpassed at 420 Hz, very quiet
+ *
+ * ONE lookahead callback does all the SOUND scheduling on each engine tick
+ * (~250 ms): breath modulation, the tone drift and the chime schedule. No
+ * per-sample JS anywhere — native nodes only.
+ *
+ * Teardown NEVER waits for a lookahead tick: the engine retires a stopped
+ * instance's callbacks at fade·1000 + 250 ms, so anything teardown-ish parked
+ * on the tick queue can be dropped mid-fade and leave nodes hanging off the
+ * shared input. disconnect() runs on timers instead (WideFrost's contract
+ * note): each chime schedules its own disconnect for tail-end + 50 ms, and
+ * stop(at, fade) schedules one final disconnect-everything at fade·1000 + 50
+ * ms — after the gains have finished ramping to 0 on the audio clock.
+ *
+ * Params (ScapeInstance.setParam):
+ *   breathsPerMinute — moves the SHARED breath clock (default 6)
+ *   chimes           — 0 turns the chimes off, anything else on
+ *
+ * `onToneChange`: the scape contract (types.ts) has no callback channel —
+ * setParam only carries numbers — so tone changes are not currently
+ * observable from outside. If the contract grows a callback hook, the drift
+ * scheduler below is the place to emit it.
+ *
+ * CPU: nothing runs per sample. The noise buffer is filled once per build;
+ * oscillators and setTargetAtTime do the rest natively.
+ */
+import type { Scape } from '../types';
+export declare const HIBISCUS: Readonly<{
+    /** Drone partials: F2 + fifth (C3), tenth (A3), twelfth (C4). */
+    DRONE_HZ: number[];
+    /** Relative level of each drone partial, brightest at the bottom. */
+    DRONE_GAINS: number[];
+    /** Stereo pair detune (± cents) — the "width" of the pad. */
+    DETUNE_CENTS: 7;
+    /** Where the detuned pairs sit in the stereo field. */
+    PAD_PAN: 0.35;
+    /** Soft wave: y = x + SOFT_3RD·x³ + SOFT_5TH·x⁵, normalised — odd
+     *  symmetry, so a sine keeps its fundamental and gains a little 3rd and
+     *  5th harmonic and nothing else. */
+    SOFT_3RD: 0.16;
+    SOFT_5TH: 0.05;
+    /** Pad lowpass: resting frequency and the in-breath lift (+Hz at peak). */
+    PAD_BASE_HZ: 420;
+    PAD_BREATH_HZ: 180;
+    PAD_Q: 0.6;
+    PAD_LEVEL: 0.15;
+    /** How much of each section's level rides the breath (0..1 — the level
+     *  sinks to (1 - depth)·level at the bottom of the exhale). */
+    PAD_BREATH_DEPTH: 0.25;
+    FLOAT_LEVEL: 0.09;
+    FLOAT_BREATH_DEPTH: 0.2;
+    NOISE_LEVEL: 0.01;
+    NOISE_BREATH_DEPTH: 0.25;
+    /** Floating tones: F4 → A4 → C5 → A4 (→ F4 …). */
+    TONES_HZ: number[];
+    TONE_HOLD_S: 70;
+    TONE_JITTER_S: 8;
+    TONE_FADE_S: 16;
+    /** Chimes: the current chord an octave up (F5, A5, C6), first 3 partials. */
+    CHIME_HZ: number[];
+    CHIME_PARTIAL_GAINS: number[];
+    CHIME_MIN_GAP_S: 35;
+    CHIME_MAX_GAP_S: 65;
+    CHIME_ATTACK_S: 2.5;
+    CHIME_TAU_S: 3.5;
+    /** Oscillators stop after this many decay taus. */
+    CHIME_TAILS: 7;
+    CHIME_LEVEL: 0.05;
+    CHIME_PAN_SPREAD: 0.8;
+    /** Air noise. */
+    AIR_SECONDS: 4;
+    AIR_HP_HZ: 80;
+    AIR_LP_HZ: 420;
+    /** Internal entrance fade — the engine bus fade handles crossfades; this
+     *  just keeps a fresh build from stepping in at full level. */
+    ENTRANCE_S: 6;
+    /** Smoothing tau for the per-tick breath modulation. */
+    MOD_TAU_S: 0.45;
+}>;
+/** A soft wave curve: fundamental plus a little 3rd and 5th, nothing else. */
+export declare function softWaveCurve(n?: number): Float32Array;
+export declare const hibiscusScape: Scape;