@holoscript/engine 6.0.3 → 6.0.4

package/dist/index-B2PIsAmR.d.ts

@@ -0,0 +1,2180 @@
+import { InputBindings, WebRTCTransport } from '@holoscript/core';
+
+/**
+ * AudioTypes.ts
+ *
+ * Core type definitions for the HoloScript audio system.
+ * Provides interfaces for audio sources, listeners, effects,
+ * spatial audio, and music sequencing.
+ *
+ * @module audio
+ */
+/**
+ * 3D vector for audio positioning
+ */
+interface IVector3 {
+    x: number;
+    y: number;
+    z: number;
+}
+/**
+ * Orientation for audio listener (forward and up vectors)
+ */
+interface IAudioOrientation {
+    forward: IVector3;
+    up: IVector3;
+}
+/**
+ * Audio source types
+ */
+type AudioSourceType = 'buffer' | 'stream' | 'oscillator' | 'noise';
+/**
+ * Oscillator waveform types
+ */
+type OscillatorType = 'sine' | 'square' | 'sawtooth' | 'triangle' | 'custom';
+/**
+ * Noise types for procedural audio
+ */
+type NoiseType = 'white' | 'pink' | 'brown' | 'blue' | 'violet';
+/**
+ * Spatial audio model
+ */
+type SpatialModel = 'HRTF' | 'panning' | 'equalpower';
+/**
+ * Distance rolloff types for spatial audio
+ */
+type RolloffType = 'linear' | 'inverse' | 'exponential';
+/**
+ * Loop mode for sequencer
+ */
+type LoopMode = 'none' | 'pattern' | 'sequence' | 'all';
+/**
+ * Sequencer state enum
+ */
+type SequencerState = 'stopped' | 'playing' | 'paused' | 'recording';
+/**
+ * Playback state of an audio source
+ */
+type PlaybackState = 'stopped' | 'playing' | 'paused' | 'scheduled';
+/**
+ * Audio source configuration
+ */
+interface IAudioSourceConfig {
+    id: string;
+    type: AudioSourceType;
+    url?: string;
+    buffer?: ArrayBuffer;
+    oscillatorType?: OscillatorType;
+    frequency?: number;
+    noiseType?: NoiseType;
+    volume?: number;
+    pitch?: number;
+    loop?: boolean;
+    loopStart?: number;
+    loopEnd?: number;
+    spatial?: boolean;
+    position?: IVector3;
+    maxDistance?: number;
+    refDistance?: number;
+    rolloffFactor?: number;
+    coneInnerAngle?: number;
+    coneOuterAngle?: number;
+    coneOuterGain?: number;
+    orientation?: IVector3;
+    startTime?: number;
+    duration?: number;
+    fadeInTime?: number;
+    fadeOutTime?: number;
+    effects?: string[];
+    group?: string;
+}
+/**
+ * Audio source runtime state
+ */
+interface IAudioSourceState {
+    id: string;
+    type: AudioSourceType;
+    state: PlaybackState;
+    volume: number;
+    pitch: number;
+    loop: boolean;
+    position: IVector3;
+    currentTime: number;
+    duration: number;
+    spatial: boolean;
+}
+/**
+ * Audio listener configuration (usually follows camera)
+ */
+interface IAudioListenerConfig {
+    position: IVector3;
+    orientation: IAudioOrientation;
+    velocity?: IVector3;
+}
+/**
+ * Effect types
+ */
+type EffectType = 'gain' | 'filter' | 'reverb' | 'delay' | 'distortion' | 'compressor' | 'eq' | 'equalizer' | 'spatial' | 'chorus' | 'flanger' | 'phaser' | 'tremolo' | 'pan';
+/**
+ * Filter types for EQ and filter effects
+ */
+type FilterType$1 = 'lowpass' | 'highpass' | 'bandpass' | 'lowshelf' | 'highshelf' | 'peaking' | 'notch' | 'allpass';
+/**
+ * Base effect configuration
+ */
+interface IEffectConfig {
+    id: string;
+    type: EffectType;
+    bypass?: boolean;
+    wet?: number;
+}
+/**
+ * Gain effect
+ */
+interface IGainEffect extends IEffectConfig {
+    type: 'gain';
+    gain: number;
+}
+/**
+ * Filter effect
+ */
+interface IFilterEffect extends IEffectConfig {
+    type: 'filter';
+    filterType: FilterType$1;
+    frequency: number;
+    Q?: number;
+    gain?: number;
+}
+/**
+ * Reverb effect
+ */
+interface IReverbEffect extends IEffectConfig {
+    type: 'reverb';
+    roomSize?: number;
+    decay?: number;
+    damping?: number;
+    preDelay?: number;
+    impulseUrl?: string;
+}
+/**
+ * Delay effect
+ */
+interface IDelayEffect extends IEffectConfig {
+    type: 'delay';
+    delayTime: number;
+    /** Alias for delayTime */
+    time?: number;
+    feedback?: number;
+    maxDelay?: number;
+}
+/**
+ * Distortion effect
+ */
+interface IDistortionEffect extends IEffectConfig {
+    type: 'distortion';
+    amount: number;
+    oversample?: 'none' | '2x' | '4x';
+}
+/**
+ * Compressor effect
+ */
+interface ICompressorEffect extends IEffectConfig {
+    type: 'compressor';
+    threshold: number;
+    knee?: number;
+    ratio: number;
+    attack?: number;
+    release?: number;
+    makeupGain?: number;
+}
+/**
+ * EQ band
+ */
+interface IEQBand {
+    frequency: number;
+    gain: number;
+    Q?: number;
+    type?: FilterType$1;
+}
+/**
+ * Equalizer effect
+ */
+interface IEQEffect extends IEffectConfig {
+    type: 'eq';
+    bands: IEQBand[];
+}
+/**
+ * Panner effect
+ */
+interface IPanEffect extends IEffectConfig {
+    type: 'pan';
+    pan: number;
+}
+/**
+ * Union type for all effects
+ */
+type AudioEffect = IGainEffect | IFilterEffect | IReverbEffect | IDelayEffect | IDistortionEffect | ICompressorEffect | IEQEffect | IPanEffect | ISpatialEffect;
+/**
+ * Alias for EQ band (API compatibility)
+ */
+type IEqualizerBand = IEQBand;
+/**
+ * Equalizer effect interface (extends EQ with 'equalizer' type)
+ */
+interface IEqualizerEffect extends IEffectConfig {
+    type: 'equalizer';
+    bands: IEQBand[];
+}
+/**
+ * Spatial audio effect
+ */
+interface ISpatialEffect extends IEffectConfig {
+    type: 'spatial';
+    model: SpatialModel;
+    refDistance: number;
+    maxDistance: number;
+    rolloff: RolloffType;
+    coneInnerAngle?: number;
+    coneOuterAngle?: number;
+    coneOuterGain?: number;
+}
+/**
+ * Audio bus interface
+ */
+interface IAudioBus {
+    id: string;
+    name: string;
+    volume: number;
+    muted: boolean;
+    solo: boolean;
+    effects: string[];
+    inputs: string[];
+    output?: string;
+}
+/**
+ * Sequencer configuration
+ */
+interface ISequencerConfig {
+    bpm: number;
+    beatsPerBar: number;
+    swingAmount?: number;
+    lookAheadTime?: number;
+    scheduleAheadTime?: number;
+}
+/**
+ * Pattern reference in track
+ */
+interface IPatternRef {
+    patternId: string;
+    startBeat: number;
+    loop?: boolean;
+    loopCount?: number;
+}
+/**
+ * Audio group (bus) for managing multiple sources
+ */
+interface IAudioGroup {
+    id: string;
+    name: string;
+    volume: number;
+    muted: boolean;
+    solo: boolean;
+    effects: string[];
+    parent?: string;
+}
+/**
+ * Musical note
+ */
+interface INote {
+    pitch: number | string;
+    velocity: number;
+    duration: number;
+    startBeat: number;
+    /** Alias for startBeat (for compatibility) */
+    start?: number;
+}
+/**
+ * Pattern of notes
+ */
+interface IPattern {
+    id: string;
+    name?: string;
+    notes: INote[];
+    lengthBeats?: number;
+    /** Alias for lengthBeats */
+    length?: number;
+    loop?: boolean;
+    /** Number of bars in pattern */
+    bars?: number;
+    /** Beats per bar */
+    beatsPerBar?: number;
+    /** Subdivision (notes per beat) */
+    subdivision?: number;
+}
+/**
+ * Track in a sequence
+ */
+interface ITrack {
+    id: string;
+    name?: string;
+    instrument?: string;
+    patterns: IPatternRef[];
+    volume?: number;
+    pan?: number;
+    muted?: boolean;
+    solo?: boolean;
+    /** Source ID for this track */
+    sourceId?: string;
+    /** Effect chain IDs */
+    effects?: string[];
+    /** Output source ID */
+    outputSource?: string;
+}
+/**
+ * Music sequence configuration
+ */
+interface ISequence {
+    id: string;
+    name?: string;
+    bpm?: number;
+    beatsPerBar?: number;
+    bars?: number;
+    tracks: ITrack[];
+    patterns?: IPattern[];
+    /** Order of patterns to play */
+    patternOrder?: string[];
+    /** Time signature [beats, noteValue] */
+    timeSignature?: [number, number];
+    /** Loop the sequence */
+    loop?: boolean;
+}
+/**
+ * Sequencer state
+ */
+interface ISequencerState {
+    isPlaying: boolean;
+    isPaused: boolean;
+    currentBeat: number;
+    currentBar: number;
+    bpm: number;
+    looping: boolean;
+    loopStart: number;
+    loopEnd: number;
+}
+/**
+ * Audio event types
+ */
+type AudioEventType = 'sourceStarted' | 'sourceStopped' | 'sourceEnded' | 'sourcePaused' | 'sourceResumed' | 'sourceLooped' | 'bufferLoaded' | 'bufferError' | 'beatTick' | 'barTick' | 'beat' | 'bar' | 'sequenceEnd' | 'sequencerStarted' | 'sequencerStopped' | 'sequencerPaused' | 'sequencerSeeked' | 'sequenceLooped' | 'noteTriggered' | 'noteReleased' | 'metronomeClick' | 'bpmChanged';
+/**
+ * Audio event
+ */
+interface IAudioEvent {
+    type: AudioEventType;
+    sourceId?: string;
+    timestamp: number;
+    data?: Record<string, unknown>;
+}
+/**
+ * Audio event callback
+ */
+type AudioEventCallback = (event: IAudioEvent) => void;
+/**
+ * Audio system configuration
+ */
+interface IAudioSystemConfig {
+    sampleRate?: number;
+    maxSources?: number;
+    masterVolume?: number;
+    spatialEnabled?: boolean;
+    defaultRolloff?: 'linear' | 'inverse' | 'exponential';
+    defaultRefDistance?: number;
+    defaultMaxDistance?: number;
+    doppler?: boolean;
+    dopplerFactor?: number;
+    speedOfSound?: number;
+}
+/**
+ * Audio system defaults
+ */
+declare const AUDIO_DEFAULTS: Required<IAudioSystemConfig>;
+/**
+ * Main audio context interface
+ */
+interface IAudioContext {
+    initialize(): Promise<void>;
+    suspend(): Promise<void>;
+    resume(): Promise<void>;
+    dispose(): void;
+    readonly state: 'suspended' | 'running' | 'closed';
+    readonly currentTime: number;
+    readonly sampleRate: number;
+    setMasterVolume(volume: number): void;
+    getMasterVolume(): number;
+    mute(): void;
+    unmute(): void;
+    readonly isMuted: boolean;
+    setListenerPosition(position: IVector3): void;
+    setListenerOrientation(orientation: IAudioOrientation): void;
+    setListenerVelocity(velocity: IVector3): void;
+    getListenerConfig(): IAudioListenerConfig;
+    createSource(config: IAudioSourceConfig): Promise<string>;
+    getSource(id: string): IAudioSourceState | undefined;
+    getAllSources(): IAudioSourceState[];
+    removeSource(id: string): boolean;
+    play(sourceId: string, when?: number): void;
+    stop(sourceId: string): void;
+    pause(sourceId: string): void;
+    resumeSource(sourceId: string): void;
+    setVolume(sourceId: string, volume: number): void;
+    setPitch(sourceId: string, pitch: number): void;
+    setLoop(sourceId: string, loop: boolean, start?: number, end?: number): void;
+    setPosition(sourceId: string, position: IVector3): void;
+    setOrientation(sourceId: string, orientation: IVector3): void;
+    createEffect(config: AudioEffect): string;
+    getEffect(id: string): AudioEffect | undefined;
+    removeEffect(id: string): boolean;
+    connectSourceToEffect(sourceId: string, effectId: string): void;
+    disconnectSourceFromEffect(sourceId: string, effectId: string): void;
+    createGroup(config: IAudioGroup): string;
+    getGroup(id: string): IAudioGroup | undefined;
+    setGroupVolume(groupId: string, volume: number): void;
+    setGroupMuted(groupId: string, muted: boolean): void;
+    setGroupSolo(groupId: string, solo: boolean): void;
+    loadBuffer(url: string): Promise<ArrayBuffer>;
+    decodeBuffer(buffer: ArrayBuffer): Promise<AudioBuffer>;
+    getCachedBuffer(url: string): ArrayBuffer | undefined;
+    clearBufferCache(): void;
+    on(event: AudioEventType, callback: AudioEventCallback): void;
+    off(event: AudioEventType, callback: AudioEventCallback): void;
+    emit(event: IAudioEvent): void;
+    getAnalyzerData(sourceId: string): Float32Array | undefined;
+    getFrequencyData(sourceId: string): Uint8Array | undefined;
+}
+/**
+ * Music sequencer interface
+ */
+interface ISequencer {
+    load(sequence: ISequence): void;
+    unload(): void;
+    play(): void;
+    pause(): void;
+    stop(): void;
+    seek(beat: number): void;
+    getState(): ISequencerState;
+    readonly isPlaying: boolean;
+    readonly currentBeat: number;
+    setBPM(bpm: number): void;
+    getBPM(): number;
+    setLoop(enabled: boolean, startBeat?: number, endBeat?: number): void;
+    setTrackVolume(trackId: string, volume: number): void;
+    setTrackMuted(trackId: string, muted: boolean): void;
+    setTrackSolo(trackId: string, solo: boolean): void;
+    on(event: 'beatTick' | 'barTick' | 'sequenceEnd', callback: AudioEventCallback): void;
+    off(event: 'beatTick' | 'barTick' | 'sequenceEnd', callback: AudioEventCallback): void;
+    addPattern(pattern: IPattern): void;
+    removePattern(patternId: string): boolean;
+    getPattern(patternId: string): IPattern | undefined;
+    scheduleNote(trackId: string, note: INote): void;
+    quantize(beat: number, grid: number): number;
+}
+/**
+ * Create a zero vector
+ */
+declare function zeroVector(): IVector3;
+/**
+ * Create default listener orientation
+ */
+declare function defaultOrientation(): IAudioOrientation;
+/**
+ * Create a buffer source config
+ */
+declare function bufferSource(id: string, url: string, options?: Partial<IAudioSourceConfig>): IAudioSourceConfig;
+/**
+ * Create an oscillator source config
+ */
+declare function oscillatorSource(id: string, waveform: OscillatorType, frequency: number, options?: Partial<IAudioSourceConfig>): IAudioSourceConfig;
+/**
+ * Create a stream source config
+ */
+declare function streamSource(id: string, url: string, options?: Partial<IAudioSourceConfig>): IAudioSourceConfig;
+/**
+ * Create a noise source config
+ */
+declare function noiseSource(id: string, noiseType: NoiseType, options?: Partial<IAudioSourceConfig>): IAudioSourceConfig;
+/**
+ * Add spatial properties to an existing source config (decorator pattern)
+ */
+declare function spatialSource(config: IAudioSourceConfig, position: IVector3, options?: Partial<IAudioSourceConfig>): IAudioSourceConfig;
+/**
+ * Create a gain effect config
+ */
+declare function gainEffect(id: string, gain?: number): IGainEffect;
+/**
+ * Create a reverb effect config
+ */
+declare function reverbEffect(id: string, decay?: number, wet?: number, options?: Partial<IReverbEffect>): IReverbEffect;
+/**
+ * Create a delay effect config
+ */
+declare function delayEffect(id: string, time?: number, feedback?: number, options?: Partial<IDelayEffect>): IDelayEffect;
+/**
+ * Create a filter effect config
+ */
+declare function filterEffect(id: string, filterType: FilterType$1, frequency: number, options?: Partial<IFilterEffect>): IFilterEffect;
+/**
+ * Create a compressor effect config
+ */
+declare function compressorEffect(id: string, threshold?: number, ratio?: number, options?: Partial<ICompressorEffect>): ICompressorEffect;
+/**
+ * Convert MIDI note number to frequency
+ */
+declare function midiToFrequency(note: number): number;
+/**
+ * Convert frequency to MIDI note number (rounded to nearest integer)
+ */
+declare function frequencyToMidi(frequency: number): number;
+/**
+ * Convert note name to MIDI number
+ * e.g., 'C4' -> 60, 'A4' -> 69
+ */
+declare function noteNameToMidi(name: string): number;
+/**
+ * Convert MIDI number to note name
+ */
+declare function midiToNoteName(midi: number): string;
+/**
+ * Create a lowpass filter effect
+ */
+declare function lowpassFilter(id: string, frequency: number, Q?: number): IFilterEffect;
+/**
+ * Create a highpass filter effect
+ */
+declare function highpassFilter(id: string, frequency: number, Q?: number): IFilterEffect;
+/**
+ * Create a bandpass filter effect
+ */
+declare function bandpassFilter(id: string, frequency: number, Q?: number): IFilterEffect;
+/**
+ * Create a distortion effect config
+ */
+declare function distortionEffect(id: string, amount?: number, options?: Partial<IDistortionEffect>): IDistortionEffect;
+/**
+ * Create a pan effect config
+ */
+declare function panEffect(id: string, pan?: number): IPanEffect;
+/**
+ * Create an EQ band config
+ */
+declare function eqBand(frequency: number, Q?: number, gain?: number): IEQBand;
+/**
+ * Create an equalizer effect config
+ */
+declare function equalizerEffect(id: string, bands: IEQBand[], options?: Partial<IEqualizerEffect>): IEqualizerEffect;
+/**
+ * Create a note config for sequencer
+ */
+declare function createNote(pitch: number | string, start: number, duration: number, velocity?: number): INote;
+/**
+ * Create a pattern config for sequencer
+ */
+declare function createPattern(id: string, notes: INote[], options?: Partial<IPattern>): IPattern;
+/**
+ * Create a track config for sequencer
+ */
+declare function createTrack(id: string, patterns: IPatternRef[], options?: Partial<ITrack>): ITrack;
+/**
+ * Create a sequence config for sequencer
+ */
+declare function createSequence(id: string, patternOrder: string[], tracks: ITrack[], options?: Partial<ISequence>): ISequence;
+
+/**
+ * AudioContextImpl.ts
+ *
+ * Implementation of the HoloScript audio context with support for
+ * buffer sources, oscillators, spatial audio, and effects chains.
+ *
+ * @module audio
+ */
+
+/**
+ * HoloScript audio context implementation
+ */
+declare class AudioContextImpl implements IAudioContext {
+    private _state;
+    private _currentTime;
+    private _masterVolume;
+    private _isMuted;
+    private _previousVolume;
+    private readonly config;
+    private readonly sources;
+    private readonly effects;
+    private readonly groups;
+    private readonly bufferCache;
+    private readonly decodedBuffers;
+    private readonly eventListeners;
+    private listenerPosition;
+    private listenerOrientation;
+    private listenerVelocity;
+    private timeUpdateInterval;
+    constructor(config?: IAudioSystemConfig);
+    initialize(): Promise<void>;
+    suspend(): Promise<void>;
+    resume(): Promise<void>;
+    dispose(): void;
+    get state(): 'suspended' | 'running' | 'closed';
+    get currentTime(): number;
+    get sampleRate(): number;
+    setMasterVolume(volume: number): void;
+    getMasterVolume(): number;
+    mute(): void;
+    unmute(): void;
+    get isMuted(): boolean;
+    setListenerPosition(position: IVector3): void;
+    setListenerOrientation(orientation: IAudioOrientation): void;
+    setListenerVelocity(velocity: IVector3): void;
+    getListenerConfig(): IAudioListenerConfig;
+    createSource(config: IAudioSourceConfig): Promise<string>;
+    getSource(id: string): IAudioSourceState | undefined;
+    getAllSources(): IAudioSourceState[];
+    removeSource(id: string): boolean;
+    play(sourceId: string, when?: number): void;
+    stop(sourceId: string): void;
+    pause(sourceId: string): void;
+    resumeSource(sourceId: string): void;
+    setVolume(sourceId: string, volume: number): void;
+    setPitch(sourceId: string, pitch: number): void;
+    setLoop(sourceId: string, loop: boolean, start?: number, end?: number): void;
+    setPosition(sourceId: string, position: IVector3): void;
+    setOrientation(sourceId: string, orientation: IVector3): void;
+    createEffect(config: AudioEffect): string;
+    getEffect(id: string): AudioEffect | undefined;
+    removeEffect(id: string): boolean;
+    connectSourceToEffect(sourceId: string, effectId: string): void;
+    disconnectSourceFromEffect(sourceId: string, effectId: string): void;
+    createGroup(config: IAudioGroup): string;
+    getGroup(id: string): IAudioGroup | undefined;
+    setGroupVolume(groupId: string, volume: number): void;
+    setGroupMuted(groupId: string, muted: boolean): void;
+    setGroupSolo(groupId: string, solo: boolean): void;
+    loadBuffer(url: string): Promise<ArrayBuffer>;
+    decodeBuffer(buffer: ArrayBuffer): Promise<AudioBuffer>;
+    getCachedBuffer(url: string): ArrayBuffer | undefined;
+    clearBufferCache(): void;
+    on(event: AudioEventType, callback: AudioEventCallback): void;
+    off(event: AudioEventType, callback: AudioEventCallback): void;
+    emit(event: IAudioEvent): void;
+    getAnalyzerData(sourceId: string): Float32Array | undefined;
+    getFrequencyData(sourceId: string): Uint8Array | undefined;
+    private updatePlayingSources;
+    /**
+     * Calculate spatial audio gain based on distance
+     */
+    calculateSpatialGain(sourcePosition: IVector3): number;
+}
+/**
+ * Create a new audio context
+ */
+declare function createAudioContext(config?: IAudioSystemConfig): IAudioContext;
+
+/**
+ * Sequencer.ts
+ *
+ * Music sequencer implementation for HoloScript with pattern-based
+ * composition, multi-track support, and BPM-based timing.
+ *
+ * @module audio
+ */
+
+/**
+ * HoloScript music sequencer implementation
+ */
+declare class SequencerImpl implements ISequencer {
+    private _state;
+    private _bpm;
+    private _swing;
+    private _currentBeat;
+    private _currentBar;
+    private _currentPatternIndex;
+    private _loopMode;
+    private _loopStart;
+    private _loopEnd;
+    private _metronomeEnabled;
+    private _countInBars;
+    private _countingIn;
+    private readonly context;
+    private readonly sequences;
+    private readonly patterns;
+    private readonly tracks;
+    private readonly scheduledNotes;
+    private readonly eventListeners;
+    private readonly triggerCallbacks;
+    private currentSequenceId;
+    private startTime;
+    private pausedTime;
+    private lastScheduledBeat;
+    private scheduleAheadTime;
+    private tickInterval;
+    constructor(context: IAudioContext);
+    load(sequence: ISequence): void;
+    unload(): void;
+    play(): void;
+    start(): void;
+    stop(): void;
+    pause(): void;
+    get state(): SequencerState;
+    getState(): ISequencerState;
+    get isPlaying(): boolean;
+    dispose(): void;
+    get bpm(): number;
+    set bpm(value: number);
+    get swing(): number;
+    set swing(value: number);
+    get currentBeat(): number;
+    get currentBar(): number;
+    get currentPatternIndex(): number;
+    setBPM(bpm: number): void;
+    getBPM(): number;
+    get loopMode(): LoopMode;
+    set loopMode(value: LoopMode);
+    setLoop(enabled: boolean, startBeat?: number, endBeat?: number): void;
+    get metronomeEnabled(): boolean;
+    set metronomeEnabled(value: boolean);
+    get countInBars(): number;
+    set countInBars(value: number);
+    get isCountingIn(): boolean;
+    setLoopRange(start: number, end: number): void;
+    getLoopRange(): {
+        start: number;
+        end: number;
+    };
+    seek(beat: number, bar?: number): void;
+    getPlaybackPosition(): {
+        beat: number;
+        bar: number;
+        pattern: number;
+    };
+    createSequence(config: ISequence): string;
+    getSequence(id: string): ISequence | undefined;
+    updateSequence(id: string, updates: Partial<ISequence>): void;
+    removeSequence(id: string): boolean;
+    loadSequence(id: string): boolean;
+    getCurrentSequence(): ISequence | undefined;
+    createPattern(config: IPattern): string;
+    addPattern(pattern: IPattern): void;
+    getPattern(id: string): IPattern | undefined;
+    updatePattern(id: string, updates: Partial<IPattern>): void;
+    removePattern(id: string): boolean;
+    addNoteToPattern(patternId: string, note: INote): void;
+    removeNoteFromPattern(patternId: string, noteIndex: number): void;
+    scheduleNote(trackId: string, note: INote): void;
+    quantize(beat: number, grid: number): number;
+    quantizePattern(patternId: string, subdivision: number): void;
+    createTrack(config: ITrack): string;
+    getTrack(id: string): ITrack | undefined;
+    updateTrack(id: string, updates: Partial<ITrack>): void;
+    removeTrack(id: string): boolean;
+    setTrackVolume(trackId: string, volume: number): void;
+    setTrackMuted(trackId: string, muted: boolean): void;
+    setTrackSolo(trackId: string, solo: boolean): void;
+    onNoteTrigger(trackId: string, callback: (note: INote, time: number) => void): void;
+    offNoteTrigger(trackId: string, callback: (note: INote, time: number) => void): void;
+    on(event: AudioEventType, callback: AudioEventCallback): void;
+    off(event: AudioEventType, callback: AudioEventCallback): void;
+    beatsToSeconds(beats: number): number;
+    secondsToBeats(seconds: number): number;
+    barsToSeconds(bars: number): number;
+    secondsToBars(seconds: number): number;
+    getMidiFrequency(midiNote: number): number;
+    getNoteToMidi(noteName: string): number;
+    private getBeatsPerBar;
+    private getCurrentPattern;
+    private startScheduler;
+    private stopScheduler;
+    private schedulerTick;
+    private scheduleNotes;
+    private triggerScheduledNotes;
+    private handleLooping;
+    private playMetronome;
+    private emit;
+}
+/**
+ * Create a new sequencer instance
+ */
+declare function createSequencer(context: IAudioContext): ISequencer;
+
+/**
+ * AudioEngine.ts
+ *
+ * Core spatial audio engine for HoloScript+.
+ * Manages 3D listener position, audio sources with distance attenuation,
+ * and provides a unified API for positional sound in VR.
+ *
+ * Note: This is a *simulation* layer that models spatial audio behavior.
+ * In production, it delegates to Web Audio API (AudioContext/PannerNode).
+ * For testing and headless environments, all state is tracked internally.
+ */
+type DistanceModel = 'linear' | 'inverse' | 'exponential';
+interface AudioSourceConfig {
+    id: string;
+    position: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    volume: number;
+    pitch: number;
+    loop: boolean;
+    maxDistance: number;
+    refDistance: number;
+    rolloffFactor: number;
+    distanceModel: DistanceModel;
+    channel: string;
+    spatialize: boolean;
+}
+interface AudioSource$1 {
+    config: AudioSourceConfig;
+    isPlaying: boolean;
+    currentTime: number;
+    computedVolume: number;
+    computedPan: number;
+    soundId: string;
+}
+interface ListenerState {
+    position: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    forward: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    up: {
+        x: number;
+        y: number;
+        z: number;
+    };
+}
+declare class AudioEngine {
+    private sources;
+    private listener;
+    private masterVolume;
+    private muted;
+    /**
+     * Update the listener position (typically from VR headset).
+     */
+    setListenerPosition(pos: {
+        x: number;
+        y: number;
+        z: number;
+    }): void;
+    setListenerOrientation(forward: {
+        x: number;
+        y: number;
+        z: number;
+    }, up: {
+        x: number;
+        y: number;
+        z: number;
+    }): void;
+    getListener(): ListenerState;
+    /**
+     * Create and play a new audio source.
+     */
+    play(soundId: string, config?: Partial<AudioSourceConfig>): string;
+    /**
+     * Stop a playing source.
+     */
+    stop(sourceId: string): void;
+    /**
+     * Update a source's position.
+     */
+    setSourcePosition(sourceId: string, pos: {
+        x: number;
+        y: number;
+        z: number;
+    }): void;
+    /**
+     * Update all sources. Call every frame.
+     */
+    update(delta: number): void;
+    /**
+     * Get a source by ID.
+     */
+    getSource(sourceId: string): AudioSource$1 | undefined;
+    /**
+     * Get all active sources.
+     */
+    getActiveSources(): AudioSource$1[];
+    /**
+     * Set master volume.
+     */
+    setMasterVolume(vol: number): void;
+    getMasterVolume(): number;
+    /**
+     * Mute/unmute all audio.
+     */
+    setMuted(muted: boolean): void;
+    isMuted(): boolean;
+    /**
+     * Get active source count.
+     */
+    getActiveCount(): number;
+    /**
+     * Stop all sources.
+     */
+    stopAll(): void;
+}
+
+/**
+ * AudioAnalyzer.ts
+ *
+ * Real-time audio analysis: FFT spectrum, beat detection,
+ * loudness metering, and audio-reactive parameter extraction.
+ *
+ * @module audio
+ */
+interface SpectrumData {
+    frequencies: Float32Array;
+    binCount: number;
+    sampleRate: number;
+    peakFrequency: number;
+    peakMagnitude: number;
+}
+interface BeatDetectionConfig {
+    sensitivity: number;
+    minInterval: number;
+    energyThreshold: number;
+    frequencyRange: {
+        low: number;
+        high: number;
+    };
+}
+interface BeatEvent {
+    timestamp: number;
+    energy: number;
+    bpm: number;
+    strength: number;
+}
+interface LoudnessMetrics {
+    rms: number;
+    peak: number;
+    lufs: number;
+    dynamicRange: number;
+}
+interface AudioBand {
+    name: string;
+    low: number;
+    high: number;
+    energy: number;
+}
+declare const DEFAULT_BANDS: AudioBand[];
+declare class AudioAnalyzer {
+    private fftSize;
+    private sampleRate;
+    private currentSpectrum;
+    private bands;
+    private beatConfig;
+    private beatHistory;
+    private energyHistory;
+    private lastBeatTime;
+    private smoothedEnergy;
+    private loudness;
+    constructor(fftSize?: number, sampleRate?: number, beatConfig?: Partial<BeatDetectionConfig>);
+    /**
+     * Analyze a buffer of audio samples.
+     */
+    analyze(samples: Float32Array, currentTimeMs: number): void;
+    private computeBands;
+    private computeLoudness;
+    private detectBeat;
+    private estimateBPM;
+    getSpectrum(): SpectrumData | null;
+    getBands(): AudioBand[];
+    getBandEnergy(bandName: string): number;
+    getLoudness(): LoudnessMetrics;
+    getBeats(): BeatEvent[];
+    getLastBeat(): BeatEvent | null;
+    getEstimatedBPM(): number;
+    getSmoothedEnergy(): number;
+    /**
+     * Get a normalized 0-1 value for audio-reactive use.
+     * Combines bass energy with beat strength.
+     */
+    getReactiveValue(): number;
+    reset(): void;
+}
+
+/**
+ * AudioDiffraction.ts
+ *
+ * Advanced diffraction modeling for spatial audio:
+ * - Edge detection for diffraction points
+ * - Kirchhoff-Fresnel diffraction coefficient calculation
+ * - Secondary raycast paths for indirect sound propagation
+ * - Integration with AudioOcclusion system
+ *
+ * @module audio
+ */
+interface DiffractionEdge {
+    id: string;
+    point1: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    point2: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    obstacleId?: string;
+}
+interface DiffractionPath {
+    edgeId: string;
+    diffractionPoint: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    totalDistance: number;
+    directDistance: number;
+    pathDifference: number;
+    diffractionCoefficient: number;
+    angle: number;
+}
+interface DiffractionResult {
+    sourceId: string;
+    hasDiffraction: boolean;
+    paths: DiffractionPath[];
+    combinedCoefficient: number;
+    volumeMultiplier: number;
+}
+interface DiffractionConfig {
+    enabled: boolean;
+    maxPaths: number;
+    minDiffractionGain: number;
+    frequency: number;
+    speedOfSound: number;
+}
+/**
+ * Provider function to detect edges in the scene.
+ * Implementations should return edges that could cause diffraction.
+ */
+type EdgeDetectionProvider = (sourcePos: {
+    x: number;
+    y: number;
+    z: number;
+}, listenerPos: {
+    x: number;
+    y: number;
+    z: number;
+}) => DiffractionEdge[];
+/**
+ * Provider function to check line-of-sight between two points.
+ * Returns true if the path is clear, false if obstructed.
+ */
+type LineOfSightProvider = (point1: {
+    x: number;
+    y: number;
+    z: number;
+}, point2: {
+    x: number;
+    y: number;
+    z: number;
+}) => boolean;
+declare class AudioDiffractionSystem {
+    private config;
+    private edgeProvider;
+    private losProvider;
+    private cache;
+    setConfig(config: Partial<DiffractionConfig>): void;
+    getConfig(): DiffractionConfig;
+    setEdgeDetectionProvider(provider: EdgeDetectionProvider): void;
+    setLineOfSightProvider(provider: LineOfSightProvider): void;
+    /**
+     * Compute diffraction paths between source and listener.
+     * Returns all valid diffraction paths sorted by coefficient (strongest first).
+     */
+    computeDiffraction(sourcePos: {
+        x: number;
+        y: number;
+        z: number;
+    }, listenerPos: {
+        x: number;
+        y: number;
+        z: number;
+    }, sourceId: string): DiffractionResult;
+    /**
+     * Compute diffraction for a specific edge.
+     * Returns null if edge is not valid for diffraction.
+     */
+    private computeEdgeDiffraction;
+    /**
+     * Find the optimal diffraction point on an edge.
+     * Uses closest point on line segment to the midpoint between source and listener.
+     */
+    private findDiffractionPoint;
+    /**
+     * Calculate the diffraction angle in radians.
+     * This is the angle between source->edge and edge->listener vectors.
+     */
+    private calculateDiffractionAngle;
+    /**
+     * Calculate Fresnel diffraction coefficient.
+     * Based on Kirchhoff-Fresnel theory for edge diffraction.
+     *
+     * @param pathDifference - Extra distance traveled via edge (meters)
+     * @param angle - Diffraction angle (radians)
+     * @returns Attenuation coefficient (0-1)
+     */
+    private calculateFresnelCoefficient;
+    /**
+     * Combine multiple diffraction paths using energy-based summation.
+     * Paths contribute independently (incoherent sum).
+     */
+    private combineDiffractionPaths;
+    private distance3D;
+    /**
+     * Find closest point on line segment AB to point P.
+     */
+    private closestPointOnSegment;
+    getCachedResult(sourceId: string): DiffractionResult | undefined;
+    clearCache(): void;
+    /**
+     * Get volume multiplier for a source based on diffraction.
+     * Returns 1.0 if direct path exists, otherwise returns diffraction coefficient.
+     */
+    getVolumeMultiplier(sourceId: string): number;
+    /**
+     * Check if a source has active diffraction paths.
+     */
+    hasDiffraction(sourceId: string): boolean;
+    /**
+     * Get all diffraction paths for a source.
+     */
+    getDiffractionPaths(sourceId: string): DiffractionPath[];
+}
+
+/**
+ * AudioDynamics.ts
+ *
+ * Audio dynamics processing: compressor, limiter,
+ * noise gate, and sidechain ducking.
+ *
+ * @module audio
+ */
+interface CompressorConfig {
+    threshold: number;
+    ratio: number;
+    attack: number;
+    release: number;
+    makeup: number;
+    knee: number;
+}
+interface GateConfig {
+    threshold: number;
+    attack: number;
+    release: number;
+    range: number;
+}
+declare class AudioDynamics {
+    private compressor;
+    private gate;
+    private gainReduction;
+    private gateOpen;
+    private envelope;
+    private sidechainLevel;
+    private ducking;
+    private duckAmount;
+    constructor();
+    setCompressor(config: Partial<CompressorConfig>): void;
+    setGate(config: Partial<GateConfig>): void;
+    getCompressor(): CompressorConfig;
+    processCompressor(inputDb: number): number;
+    processGate(inputDb: number, dt: number): number;
+    setSidechainLevel(db: number): void;
+    processDucking(inputDb: number, threshold: number, amount: number): number;
+    limit(inputDb: number, ceiling: number): number;
+    getGainReduction(): number;
+    isGateOpen(): boolean;
+    isDucking(): boolean;
+    getDuckAmount(): number;
+}
+
+/**
+ * AudioEnvelope.ts
+ *
+ * ADSR envelope generator: attack/decay/sustain/release,
+ * fade curves, ducking, and sidechain compression trigger.
+ *
+ * @module audio
+ */
+interface ADSRConfig {
+    attack: number;
+    decay: number;
+    sustain: number;
+    release: number;
+}
+type EnvelopeStage = 'idle' | 'attack' | 'decay' | 'sustain' | 'release';
+type CurveType = 'linear' | 'exponential' | 'logarithmic';
+declare class AudioEnvelope {
+    private config;
+    private stage;
+    private level;
+    private elapsed;
+    private curve;
+    constructor(config?: Partial<ADSRConfig>, curve?: CurveType);
+    noteOn(): void;
+    noteOff(): void;
+    process(dt: number): number;
+    private applyCurve;
+    getLevel(): number;
+    getStage(): EnvelopeStage;
+    setConfig(config: Partial<ADSRConfig>): void;
+    getConfig(): ADSRConfig;
+    isActive(): boolean;
+}
+
+/**
+ * AudioFilter.ts
+ *
+ * Audio filters: low-pass, high-pass, band-pass,
+ * parametric EQ, resonance, and cascaded biquads.
+ *
+ * @module audio
+ */
+type FilterType = 'lowpass' | 'highpass' | 'bandpass' | 'notch' | 'peaking';
+interface FilterConfig {
+    type: FilterType;
+    frequency: number;
+    q: number;
+    gain: number;
+}
+interface EQBand {
+    id: string;
+    config: FilterConfig;
+    enabled: boolean;
+}
+declare class AudioFilter {
+    private bands;
+    addBand(id: string, config: FilterConfig): void;
+    removeBand(id: string): void;
+    setBandEnabled(id: string, enabled: boolean): void;
+    setFrequency(id: string, freq: number): void;
+    setQ(id: string, q: number): void;
+    setGain(id: string, gain: number): void;
+    getResponse(frequency: number): number;
+    private computeBandResponse;
+    getBand(id: string): EQBand | undefined;
+    getBandCount(): number;
+    getEnabledBandCount(): number;
+}
+
+/**
+ * AudioGraph.ts
+ *
+ * Node-based audio processing graph: connections, parameter
+ * automation, processing order, and mix routing.
+ *
+ * @module audio
+ */
+type AudioNodeType = 'source' | 'gain' | 'filter' | 'delay' | 'reverb' | 'compressor' | 'output' | 'mixer';
+interface AudioGraphNode {
+    id: string;
+    type: AudioNodeType;
+    params: Map<string, number>;
+    inputs: string[];
+    outputs: string[];
+    bypassed: boolean;
+}
+interface AudioConnection {
+    id: string;
+    sourceId: string;
+    targetId: string;
+    sourcePort: number;
+    targetPort: number;
+}
+interface AutomationPoint {
+    time: number;
+    value: number;
+    curve: 'linear' | 'exponential' | 'step';
+}
+interface ParameterAutomation {
+    nodeId: string;
+    paramName: string;
+    points: AutomationPoint[];
+}
+declare class AudioGraph {
+    private nodes;
+    private connections;
+    private automations;
+    private processingOrder;
+    private dirty;
+    addNode(type: AudioNodeType, params?: Record<string, number>): AudioGraphNode;
+    removeNode(id: string): boolean;
+    connect(sourceId: string, targetId: string, sourcePort?: number, targetPort?: number): string | null;
+    disconnect(connId: string): boolean;
+    automate(nodeId: string, paramName: string, points: AutomationPoint[]): void;
+    applyAutomation(time: number): void;
+    private evaluateAutomation;
+    getProcessingOrder(): string[];
+    setParam(nodeId: string, param: string, value: number): void;
+    getParam(nodeId: string, param: string): number | undefined;
+    bypass(nodeId: string, bypassed: boolean): void;
+    getNode(id: string): AudioGraphNode | undefined;
+    getNodeCount(): number;
+    getConnectionCount(): number;
+}
+
+/**
+ * AudioMixer.ts
+ *
+ * Advanced channel-based audio mixer with dynamic mixing features:
+ * - Channel-based volume control and mute groups
+ * - Ducking (auto-lower music when dialogue plays)
+ * - Sidechain compression
+ * - Priority-based voice stealing
+ * - Context-aware mixing
+ */
+interface MixerChannel {
+    name: string;
+    volume: number;
+    muted: boolean;
+    priority: number;
+    maxVoices: number;
+    currentVoices: number;
+}
+interface DuckingConfig {
+    enabled: boolean;
+    triggerChannel: string;
+    targetChannels: string[];
+    threshold: number;
+    ratio: number;
+    attackTime: number;
+    releaseTime: number;
+}
+interface SidechainConfig {
+    enabled: boolean;
+    sourceChannel: string;
+    targetChannel: string;
+    threshold: number;
+    ratio: number;
+    attackTime: number;
+    releaseTime: number;
+}
+interface VoiceStealingStrategy {
+    mode: 'oldest' | 'quietest' | 'lowest_priority';
+}
+interface AudioSource {
+    id: string;
+    channel: string;
+    volume: number;
+    priority: number;
+    startTime: number;
+}
+interface MixingContext {
+    name: string;
+    channelVolumes: Record<string, number>;
+}
+declare class AudioMixer {
+    private channels;
+    private masterVolume;
+    private masterMuted;
+    private duckingStates;
+    private sidechains;
+    private activeSources;
+    private voiceStealingStrategy;
+    private currentContext;
+    constructor();
+    /**
+     * Create or update a channel.
+     */
+    createChannel(name: string, volume?: number, priority?: number, maxVoices?: number): void;
+    /**
+     * Set channel volume.
+     */
+    setChannelVolume(name: string, volume: number): void;
+    /**
+     * Get channel volume.
+     */
+    getChannelVolume(name: string): number;
+    /**
+     * Mute/unmute a channel.
+     */
+    setChannelMuted(name: string, muted: boolean): void;
+    /**
+     * Check if a channel is muted.
+     */
+    isChannelMuted(name: string): boolean;
+    /**
+     * Set master volume.
+     */
+    setMasterVolume(volume: number): void;
+    getMasterVolume(): number;
+    /**
+     * Mute/unmute all audio.
+     */
+    setMasterMuted(muted: boolean): void;
+    isMasterMuted(): boolean;
+    /**
+     * List all channels.
+     */
+    getChannels(): MixerChannel[];
+    /**
+     * Mute a group of channels.
+     */
+    muteGroup(channelNames: string[]): void;
+    /**
+     * Unmute a group of channels.
+     */
+    unmuteGroup(channelNames: string[]): void;
+    /**
+     * Configure ducking for a channel.
+     * Example: Duck music and ambient when voice plays.
+     */
+    configureDucking(config: DuckingConfig): void;
+    /**
+     * Remove ducking configuration.
+     */
+    removeDucking(triggerChannel: string, targetChannels: string[]): void;
+    /**
+     * Update ducking state. Call every frame with delta time.
+     */
+    updateDucking(delta: number): void;
+    /**
+     * Get ducking attenuation for a channel (0-1, where 0 = no attenuation, 1 = full duck).
+     */
+    getDuckingAttenuation(channelName: string): number;
+    /**
+     * Check if a channel has active sources above a dB threshold.
+     */
+    private isChannelActiveAboveThreshold;
+    /**
+     * Configure sidechain compression.
+     * Example: Compress SFX when music peaks.
+     */
+    configureSidechain(config: SidechainConfig): void;
+    /**
+     * Remove sidechain configuration.
+     */
+    removeSidechain(sourceChannel: string, targetChannel: string): void;
+    /**
+     * Set voice stealing strategy.
+     */
+    setVoiceStealingStrategy(strategy: VoiceStealingStrategy): void;
+    /**
+     * Register a new audio source. Returns true if allowed, false if stolen.
+     */
+    registerSource(source: AudioSource): boolean;
+    /**
+     * Unregister an audio source.
+     */
+    unregisterSource(sourceId: string): void;
+    /**
+     * Steal a voice from a channel based on strategy.
+     * Returns the ID of the stolen source, or null if no voice could be stolen.
+     */
+    private stealVoice;
+    /**
+     * Get active source count for a channel.
+     */
+    getChannelVoiceCount(channelName: string): number;
+    /**
+     * Get all active sources for a channel.
+     */
+    getChannelSources(channelName: string): AudioSource[];
+    /**
+     * Set mixing context (e.g., 'combat', 'dialogue', 'ambient').
+     * Automatically adjusts channel volumes based on context.
+     */
+    setMixingContext(context: MixingContext | null): void;
+    /**
+     * Get current mixing context.
+     */
+    getMixingContext(): MixingContext | null;
+    /**
+     * Compute the effective volume for a source on a given channel.
+     * Now includes ducking, sidechain, and context-aware adjustments.
+     */
+    getEffectiveVolume(channelName: string, sourceVolume: number): number;
+}
+
+/**
+ * AudioOcclusion.ts
+ *
+ * Advanced obstacle-based audio occlusion and obstruction:
+ * - Raycast-based occlusion detection
+ * - dB-based transmission loss
+ * - Frequency-dependent filtering (realistic "behind wall" muffled sound)
+ * - Per-material frequency absorption curves
+ *
+ * @module audio
+ */
+/**
+ * Frequency-dependent absorption coefficients (0-1 per frequency band)
+ */
+interface FrequencyAbsorption {
+    125: number;
+    250: number;
+    500: number;
+    1000: number;
+    2000: number;
+    4000: number;
+    8000: number;
+}
+interface OcclusionMaterial {
+    id: string;
+    name: string;
+    absorptionCoefficient: number;
+    transmissionLoss: number;
+    frequencyAbsorption?: FrequencyAbsorption;
+}
+interface OcclusionResult {
+    sourceId: string;
+    occluded: boolean;
+    occlusionFactor: number;
+    hitCount: number;
+    totalTransmissionLoss: number;
+    materials: string[];
+    lowPassCutoff: number;
+    frequencyAttenuation: Partial<FrequencyAbsorption>;
+}
+interface OcclusionRay {
+    origin: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    direction: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    maxDistance: number;
+}
+interface OcclusionHit {
+    distance: number;
+    materialId: string;
+    thickness: number;
+}
+declare const OCCLUSION_MATERIALS: Record<string, OcclusionMaterial>;
+type RaycastProvider = (ray: OcclusionRay) => OcclusionHit[];
+declare class AudioOcclusionSystem {
+    private materials;
+    private raycastProvider;
+    private maxTransmissionLoss;
+    private cache;
+    private enableFrequencyFiltering;
+    constructor();
+    setRaycastProvider(provider: RaycastProvider): void;
+    registerMaterial(material: OcclusionMaterial): void;
+    getMaterial(id: string): OcclusionMaterial | undefined;
+    setMaxTransmissionLoss(db: number): void;
+    setFrequencyFilteringEnabled(enabled: boolean): void;
+    isFrequencyFilteringEnabled(): boolean;
+    /**
+     * Compute occlusion between listener and a source.
+     * Uses the registered raycast provider to detect obstacles.
+     * Now includes frequency-dependent filtering for realistic muffled sound.
+     */
+    computeOcclusion(listenPos: {
+        x: number;
+        y: number;
+        z: number;
+    }, sourcePos: {
+        x: number;
+        y: number;
+        z: number;
+    }, sourceId: string): OcclusionResult;
+    /**
+     * Compute without raycasting — direct manual hit specification.
+     * Useful for testing or pre-computed occlusion.
+     */
+    computeFromHits(sourceId: string, hits: OcclusionHit[]): OcclusionResult;
+    /**
+     * Get the volume multiplier for a given occlusion factor.
+     * Converts transmission loss to a linear volume reduction.
+     */
+    getVolumeMultiplier(occlusionFactor: number): number;
+    getCachedResult(sourceId: string): OcclusionResult | undefined;
+    clearCache(): void;
+    /**
+     * Calculate low-pass filter cutoff frequency based on occlusion.
+     * Returns cutoff in Hz (500Hz fully occluded, 22kHz no occlusion).
+     */
+    private calculateLowPassCutoff;
+    /**
+     * Get frequency attenuation for a specific source.
+     * Returns per-band attenuation (0-1, where 1 = fully absorbed).
+     */
+    getFrequencyAttenuation(sourceId: string): Partial<FrequencyAbsorption>;
+    /**
+     * Get low-pass cutoff for a specific source.
+     */
+    getLowPassCutoff(sourceId: string): number;
+}
+
+/**
+ * AudioPresets.ts
+ *
+ * Pre-configured audio source settings for common VR scenarios.
+ */
+
+type PartialAudioConfig = Partial<Omit<AudioSourceConfig, 'id'>>;
+declare const AudioPresets: Record<string, PartialAudioConfig>;
+
+/**
+ * AudioTrait.ts
+ *
+ * Declarative audio attachment for HoloScript+ nodes.
+ * Plays spatial audio from a node's position in 3D space.
+ *
+ * @trait audio
+ */
+
+interface HSPlusNode {
+    id?: string;
+    properties?: Record<string, unknown>;
+}
+interface TraitHandler<TConfig> {
+    name: string;
+    defaultConfig: TConfig;
+    onAttach(node: HSPlusNode, config: TConfig, context: unknown): void;
+    onDetach(node: HSPlusNode, config: TConfig, context: unknown): void;
+    onUpdate(node: HSPlusNode, config: TConfig, context: unknown, delta: number): void;
+}
+interface AudioTraitConfig {
+    soundId: string;
+    volume: number;
+    loop: boolean;
+    spatialize: boolean;
+    maxDistance: number;
+    refDistance: number;
+    rolloffFactor: number;
+    channel: string;
+    autoPlay: boolean;
+    pitch: number;
+}
+declare function setSharedAudioEngine(engine: AudioEngine): void;
+declare function getSharedAudioEngine(): AudioEngine;
+declare const audioTraitHandler: TraitHandler<AudioTraitConfig>;
+
+/**
+ * MusicGenerator.ts
+ *
+ * Procedural music: chord progressions, rhythm patterns,
+ * melody generation, scale systems, and song structure.
+ *
+ * @module audio
+ */
+type ScaleType = 'major' | 'minor' | 'pentatonic' | 'blues' | 'dorian' | 'mixolydian';
+type ChordQuality = 'major' | 'minor' | 'dim' | 'aug' | 'sus2' | 'sus4' | '7th';
+interface ChordDef {
+    root: number;
+    quality: ChordQuality;
+    notes: number[];
+    duration: number;
+}
+interface RhythmPattern {
+    name: string;
+    beats: boolean[];
+    subdivision: number;
+    swing: number;
+}
+interface MelodyNote {
+    pitch: number;
+    duration: number;
+    velocity: number;
+    time: number;
+}
+declare class MusicGenerator {
+    private scale;
+    private rootNote;
+    private bpm;
+    private seed;
+    private rng;
+    constructor(seed?: number);
+    setScale(scale: ScaleType): void;
+    setRoot(note: number): void;
+    setBPM(bpm: number): void;
+    getScale(): ScaleType;
+    getBPM(): number;
+    getScaleNotes(octaves?: number): number[];
+    isInScale(note: number): boolean;
+    generateChord(scaleDegree: number, quality?: ChordQuality, duration?: number): ChordDef;
+    generateProgression(degrees: number[], qualities?: ChordQuality[]): ChordDef[];
+    generateRhythm(beats: number, density?: number, subdivision?: number): RhythmPattern;
+    generateMelody(bars: number, noteDensity?: number): MelodyNote[];
+    private createRng;
+    reseed(seed: number): void;
+}
+
+/**
+ * SoundPool.ts
+ *
+ * Pre-registered sound bank with instance pooling.
+ * Provides named sound references for the AudioEngine.
+ */
+interface SoundDefinition {
+    id: string;
+    name: string;
+    duration: number;
+    category: string;
+    volume: number;
+    loop: boolean;
+}
+declare class SoundPool {
+    private sounds;
+    /**
+     * Register a sound definition.
+     */
+    register(sound: SoundDefinition): void;
+    /**
+     * Register multiple sounds.
+     */
+    registerAll(sounds: SoundDefinition[]): void;
+    /**
+     * Get a sound definition by ID.
+     */
+    get(id: string): SoundDefinition | undefined;
+    /**
+     * Check if a sound is registered.
+     */
+    has(id: string): boolean;
+    /**
+     * Get all sounds in a category.
+     */
+    getByCategory(category: string): SoundDefinition[];
+    /**
+     * Get a random sound from a category (for variation).
+     */
+    getRandomFromCategory(category: string): SoundDefinition | undefined;
+    /**
+     * Get count of registered sounds.
+     */
+    get count(): number;
+    /**
+     * List all registered sound IDs.
+     */
+    listIds(): string[];
+}
+
+/**
+ * SpatialAudioSource.ts
+ *
+ * 3D audio source: positioning, distance attenuation,
+ * rolloff models, panning, cone, and Doppler.
+ *
+ * @module audio
+ */
+type RolloffModel = 'linear' | 'inverse' | 'exponential' | 'custom';
+interface AudioCone {
+    innerAngle: number;
+    outerAngle: number;
+    outerGain: number;
+}
+interface SpatialAudioConfig {
+    position: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    velocity: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    rolloff: RolloffModel;
+    minDistance: number;
+    maxDistance: number;
+    volume: number;
+    pitch: number;
+    loop: boolean;
+    cone: AudioCone | null;
+    dopplerFactor: number;
+    rolloffFactor: number;
+    spatialBlend: number;
+}
+declare class SpatialAudioSource {
+    private config;
+    private playing;
+    private paused;
+    private time;
+    private clipDuration;
+    private gain;
+    private pan;
+    constructor(config?: Partial<SpatialAudioConfig>);
+    play(duration?: number): void;
+    stop(): void;
+    pause(): void;
+    resume(): void;
+    isPlaying(): boolean;
+    setPosition(x: number, y: number, z: number): void;
+    getPosition(): {
+        x: number;
+        y: number;
+        z: number;
+    };
+    setVelocity(x: number, y: number, z: number): void;
+    setVolume(v: number): void;
+    getVolume(): number;
+    setPitch(p: number): void;
+    setLoop(loop: boolean): void;
+    setRolloff(model: RolloffModel): void;
+    setMinDistance(d: number): void;
+    setMaxDistance(d: number): void;
+    setSpatialBlend(blend: number): void;
+    setCone(cone: AudioCone): void;
+    update(dt: number, listenerPos: {
+        x: number;
+        y: number;
+        z: number;
+    }): void;
+    private computeAttenuation;
+    private computeConeGain;
+    getGain(): number;
+    getPan(): number;
+    getTime(): number;
+    getConfig(): SpatialAudioConfig;
+}
+
+/**
+ * SpatialAudioZone.ts
+ *
+ * Region-based audio environments: reverb zones, ambient areas,
+ * and audio portals for zone transitions.
+ *
+ * @module audio
+ */
+interface ReverbPreset {
+    name: string;
+    decay: number;
+    density: number;
+    diffusion: number;
+    wetLevel: number;
+    earlyReflections: number;
+}
+interface AudioZoneConfig {
+    id: string;
+    shape: 'box' | 'sphere';
+    position: [number, number, number];
+    size: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    reverb: ReverbPreset;
+    ambientClipId?: string;
+    ambientVolume?: number;
+    priority: number;
+    fadeDistance: number;
+}
+interface AudioPortal {
+    id: string;
+    position: [number, number, number];
+    normal: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    width: number;
+    height: number;
+    fromZoneId: string;
+    toZoneId: string;
+    attenuation: number;
+}
+interface ZoneState {
+    zoneId: string;
+    blendWeight: number;
+    isInside: boolean;
+}
+declare const REVERB_PRESETS: Record<string, ReverbPreset>;
+declare class SpatialAudioZoneSystem {
+    private zones;
+    private portals;
+    private activeZones;
+    private listenerPos;
+    addZone(config: AudioZoneConfig): void;
+    removeZone(zoneId: string): void;
+    getZone(zoneId: string): AudioZoneConfig | undefined;
+    getZoneCount(): number;
+    addPortal(portal: AudioPortal): void;
+    removePortal(portalId: string): void;
+    updateListenerPosition(pos: {
+        x: number;
+        y: number;
+        z: number;
+    }): void;
+    private recalculate;
+    private distanceToZone;
+    getActiveZones(): ZoneState[];
+    /**
+     * Returns the highest-priority active reverb preset, blended by weight.
+     */
+    getEffectiveReverb(): ReverbPreset | null;
+    isListenerInsideZone(zoneId: string): boolean;
+    /**
+     * Get portal attenuation between two zones.
+     */
+    getPortalAttenuation(fromZone: string, toZone: string): number;
+}
+
+/**
+ * SynthEngine.ts
+ *
+ * Software synthesizer: oscillators (sine/square/saw/triangle),
+ * ADSR envelopes, filters, wavetables, and polyphony.
+ *
+ * @module audio
+ */
+type WaveformType = 'sine' | 'square' | 'saw' | 'triangle' | 'noise' | 'wavetable';
+interface ADSREnvelope {
+    attack: number;
+    decay: number;
+    sustain: number;
+    release: number;
+}
+interface OscillatorDef {
+    id: string;
+    waveform: WaveformType;
+    frequency: number;
+    amplitude: number;
+    phase: number;
+    detune: number;
+    envelope: ADSREnvelope;
+    wavetable?: number[];
+}
+interface SynthVoice {
+    id: string;
+    oscillator: OscillatorDef;
+    noteOn: boolean;
+    noteOnTime: number;
+    noteOffTime: number;
+    currentAmplitude: number;
+    elapsed: number;
+}
+interface FilterDef {
+    type: 'lowpass' | 'highpass' | 'bandpass';
+    cutoff: number;
+    resonance: number;
+}
+declare class SynthEngine {
+    private voices;
+    private maxPolyphony;
+    private masterVolume;
+    private filter;
+    private sampleRate;
+    noteOn(frequency: number, waveform?: WaveformType, envelope?: Partial<ADSREnvelope>): string;
+    noteOff(id: string): void;
+    generateSample(time: number): number;
+    private computeEnvelope;
+    update(dt: number): void;
+    setMasterVolume(vol: number): void;
+    setMaxPolyphony(n: number): void;
+    setFilter(filter: FilterDef | null): void;
+    getFilter(): FilterDef | null;
+    getActiveVoiceCount(): number;
+    getVoice(id: string): SynthVoice | undefined;
+    getMasterVolume(): number;
+}
+
+declare class VoiceManager {
+    private input;
+    private transport;
+    private isPttPressed;
+    private isMuted;
+    private mutedPeers;
+    constructor(input: InputBindings, transport: WebRTCTransport);
+    update(): void;
+    /**
+     * Call this when input state changes
+     */
+    setPushToTalkState(pressed: boolean): void;
+    toggleMute(): void;
+    mutePeer(peerId: string, muted: boolean): void;
+    private updateMicState;
+    isPeerMuted(peerId: string): boolean;
+}
+
+/**
+ * Audio Subsystem — @holoscript/engine
+ *
+ * Extracted from @holoscript/core as part of A.011 architecture reorganization.
+ * Full spatial audio engine, effects processing, analysis, synthesis,
+ * and music sequencing capabilities.
+ *
+ * @module audio
+ * @packageDocumentation
+ */
+
+type index_ADSRConfig = ADSRConfig;
+type index_ADSREnvelope = ADSREnvelope;
+declare const index_AUDIO_DEFAULTS: typeof AUDIO_DEFAULTS;
+type index_AudioAnalyzer = AudioAnalyzer;
+declare const index_AudioAnalyzer: typeof AudioAnalyzer;
+type index_AudioBand = AudioBand;
+type index_AudioCone = AudioCone;
+type index_AudioConnection = AudioConnection;
+type index_AudioContextImpl = AudioContextImpl;
+declare const index_AudioContextImpl: typeof AudioContextImpl;
+type index_AudioDiffractionSystem = AudioDiffractionSystem;
+declare const index_AudioDiffractionSystem: typeof AudioDiffractionSystem;
+type index_AudioDynamics = AudioDynamics;
+declare const index_AudioDynamics: typeof AudioDynamics;
+type index_AudioEffect = AudioEffect;
+type index_AudioEngine = AudioEngine;
+declare const index_AudioEngine: typeof AudioEngine;
+type index_AudioEnvelope = AudioEnvelope;
+declare const index_AudioEnvelope: typeof AudioEnvelope;
+type index_AudioEventCallback = AudioEventCallback;
+type index_AudioEventType = AudioEventType;
+type index_AudioFilter = AudioFilter;
+declare const index_AudioFilter: typeof AudioFilter;
+type index_AudioGraph = AudioGraph;
+declare const index_AudioGraph: typeof AudioGraph;
+type index_AudioGraphNode = AudioGraphNode;
+type index_AudioMixer = AudioMixer;
+declare const index_AudioMixer: typeof AudioMixer;
+type index_AudioNodeType = AudioNodeType;
+type index_AudioOcclusionSystem = AudioOcclusionSystem;
+declare const index_AudioOcclusionSystem: typeof AudioOcclusionSystem;
+type index_AudioPortal = AudioPortal;
+declare const index_AudioPresets: typeof AudioPresets;
+type index_AudioSourceConfig = AudioSourceConfig;
+type index_AudioSourceType = AudioSourceType;
+type index_AudioTraitConfig = AudioTraitConfig;
+type index_AudioZoneConfig = AudioZoneConfig;
+type index_AutomationPoint = AutomationPoint;
+type index_BeatDetectionConfig = BeatDetectionConfig;
+type index_BeatEvent = BeatEvent;
+type index_ChordDef = ChordDef;
+type index_ChordQuality = ChordQuality;
+type index_CompressorConfig = CompressorConfig;
+type index_CurveType = CurveType;
+declare const index_DEFAULT_BANDS: typeof DEFAULT_BANDS;
+type index_DiffractionConfig = DiffractionConfig;
+type index_DiffractionEdge = DiffractionEdge;
+type index_DiffractionPath = DiffractionPath;
+type index_DiffractionResult = DiffractionResult;
+type index_DistanceModel = DistanceModel;
+type index_DuckingConfig = DuckingConfig;
+type index_EQBand = EQBand;
+type index_EdgeDetectionProvider = EdgeDetectionProvider;
+type index_EnvelopeStage = EnvelopeStage;
+type index_FilterConfig = FilterConfig;
+type index_FilterDef = FilterDef;
+type index_FilterType = FilterType;
+type index_FrequencyAbsorption = FrequencyAbsorption;
+type index_GateConfig = GateConfig;
+type index_IAudioBus = IAudioBus;
+type index_IAudioContext = IAudioContext;
+type index_IAudioEvent = IAudioEvent;
+type index_IAudioGroup = IAudioGroup;
+type index_IAudioListenerConfig = IAudioListenerConfig;
+type index_IAudioOrientation = IAudioOrientation;
+type index_IAudioSourceConfig = IAudioSourceConfig;
+type index_IAudioSourceState = IAudioSourceState;
+type index_IAudioSystemConfig = IAudioSystemConfig;
+type index_ICompressorEffect = ICompressorEffect;
+type index_IDelayEffect = IDelayEffect;
+type index_IDistortionEffect = IDistortionEffect;
+type index_IEqualizerBand = IEqualizerBand;
+type index_IEqualizerEffect = IEqualizerEffect;
+type index_IFilterEffect = IFilterEffect;
+type index_IGainEffect = IGainEffect;
+type index_INote = INote;
+type index_IPanEffect = IPanEffect;
+type index_IPattern = IPattern;
+type index_IReverbEffect = IReverbEffect;
+type index_ISequence = ISequence;
+type index_ISequencer = ISequencer;
+type index_ISequencerConfig = ISequencerConfig;
+type index_ISpatialEffect = ISpatialEffect;
+type index_ITrack = ITrack;
+type index_LineOfSightProvider = LineOfSightProvider;
+type index_ListenerState = ListenerState;
+type index_LoopMode = LoopMode;
+type index_LoudnessMetrics = LoudnessMetrics;
+type index_MelodyNote = MelodyNote;
+type index_MixerChannel = MixerChannel;
+type index_MixingContext = MixingContext;
+type index_MusicGenerator = MusicGenerator;
+declare const index_MusicGenerator: typeof MusicGenerator;
+type index_NoiseType = NoiseType;
+declare const index_OCCLUSION_MATERIALS: typeof OCCLUSION_MATERIALS;
+type index_OcclusionHit = OcclusionHit;
+type index_OcclusionMaterial = OcclusionMaterial;
+type index_OcclusionRay = OcclusionRay;
+type index_OcclusionResult = OcclusionResult;
+type index_OscillatorDef = OscillatorDef;
+type index_OscillatorType = OscillatorType;
+type index_ParameterAutomation = ParameterAutomation;
+type index_PlaybackState = PlaybackState;
+declare const index_REVERB_PRESETS: typeof REVERB_PRESETS;
+type index_RaycastProvider = RaycastProvider;
+type index_ReverbPreset = ReverbPreset;
+type index_RhythmPattern = RhythmPattern;
+type index_RolloffModel = RolloffModel;
+type index_RolloffType = RolloffType;
+type index_ScaleType = ScaleType;
+type index_SequencerImpl = SequencerImpl;
+declare const index_SequencerImpl: typeof SequencerImpl;
+type index_SequencerState = SequencerState;
+type index_SidechainConfig = SidechainConfig;
+type index_SoundDefinition = SoundDefinition;
+type index_SoundPool = SoundPool;
+declare const index_SoundPool: typeof SoundPool;
+type index_SpatialAudioConfig = SpatialAudioConfig;
+type index_SpatialAudioSource = SpatialAudioSource;
+declare const index_SpatialAudioSource: typeof SpatialAudioSource;
+type index_SpatialAudioZoneSystem = SpatialAudioZoneSystem;
+declare const index_SpatialAudioZoneSystem: typeof SpatialAudioZoneSystem;
+type index_SpatialModel = SpatialModel;
+type index_SpectrumData = SpectrumData;
+type index_SynthEngine = SynthEngine;
+declare const index_SynthEngine: typeof SynthEngine;
+type index_SynthVoice = SynthVoice;
+type index_VoiceManager = VoiceManager;
+declare const index_VoiceManager: typeof VoiceManager;
+type index_VoiceStealingStrategy = VoiceStealingStrategy;
+type index_WaveformType = WaveformType;
+type index_ZoneState = ZoneState;
+declare const index_audioTraitHandler: typeof audioTraitHandler;
+declare const index_bandpassFilter: typeof bandpassFilter;
+declare const index_bufferSource: typeof bufferSource;
+declare const index_compressorEffect: typeof compressorEffect;
+declare const index_createAudioContext: typeof createAudioContext;
+declare const index_createNote: typeof createNote;
+declare const index_createPattern: typeof createPattern;
+declare const index_createSequence: typeof createSequence;
+declare const index_createSequencer: typeof createSequencer;
+declare const index_createTrack: typeof createTrack;
+declare const index_defaultOrientation: typeof defaultOrientation;
+declare const index_delayEffect: typeof delayEffect;
+declare const index_distortionEffect: typeof distortionEffect;
+declare const index_eqBand: typeof eqBand;
+declare const index_equalizerEffect: typeof equalizerEffect;
+declare const index_filterEffect: typeof filterEffect;
+declare const index_frequencyToMidi: typeof frequencyToMidi;
+declare const index_gainEffect: typeof gainEffect;
+declare const index_getSharedAudioEngine: typeof getSharedAudioEngine;
+declare const index_highpassFilter: typeof highpassFilter;
+declare const index_lowpassFilter: typeof lowpassFilter;
+declare const index_midiToFrequency: typeof midiToFrequency;
+declare const index_midiToNoteName: typeof midiToNoteName;
+declare const index_noiseSource: typeof noiseSource;
+declare const index_noteNameToMidi: typeof noteNameToMidi;
+declare const index_oscillatorSource: typeof oscillatorSource;
+declare const index_panEffect: typeof panEffect;
+declare const index_reverbEffect: typeof reverbEffect;
+declare const index_setSharedAudioEngine: typeof setSharedAudioEngine;
+declare const index_spatialSource: typeof spatialSource;
+declare const index_streamSource: typeof streamSource;
+declare const index_zeroVector: typeof zeroVector;
+declare namespace index {
+  export { type index_ADSRConfig as ADSRConfig, type index_ADSREnvelope as ADSREnvelope, index_AUDIO_DEFAULTS as AUDIO_DEFAULTS, index_AudioAnalyzer as AudioAnalyzer, type index_AudioBand as AudioBand, type index_AudioCone as AudioCone, type index_AudioConnection as AudioConnection, index_AudioContextImpl as AudioContextImpl, index_AudioDiffractionSystem as AudioDiffractionSystem, index_AudioDynamics as AudioDynamics, type index_AudioEffect as AudioEffect, index_AudioEngine as AudioEngine, type AudioSource$1 as AudioEngineSource, index_AudioEnvelope as AudioEnvelope, type index_AudioEventCallback as AudioEventCallback, type index_AudioEventType as AudioEventType, index_AudioFilter as AudioFilter, type FilterType$1 as AudioFilterType, index_AudioGraph as AudioGraph, type index_AudioGraphNode as AudioGraphNode, index_AudioMixer as AudioMixer, type index_AudioNodeType as AudioNodeType, index_AudioOcclusionSystem as AudioOcclusionSystem, type index_AudioPortal as AudioPortal, index_AudioPresets as AudioPresets, type index_AudioSourceConfig as AudioSourceConfig, type index_AudioSourceType as AudioSourceType, type index_AudioTraitConfig as AudioTraitConfig, type index_AudioZoneConfig as AudioZoneConfig, type index_AutomationPoint as AutomationPoint, type index_BeatDetectionConfig as BeatDetectionConfig, type index_BeatEvent as BeatEvent, type index_ChordDef as ChordDef, type index_ChordQuality as ChordQuality, type index_CompressorConfig as CompressorConfig, type index_CurveType as CurveType, index_DEFAULT_BANDS as DEFAULT_BANDS, type index_DiffractionConfig as DiffractionConfig, type index_DiffractionEdge as DiffractionEdge, type index_DiffractionPath as DiffractionPath, type index_DiffractionResult as DiffractionResult, type index_DistanceModel as DistanceModel, type index_DuckingConfig as DuckingConfig, type index_EQBand as EQBand, type index_EdgeDetectionProvider as EdgeDetectionProvider, type index_EnvelopeStage as EnvelopeStage, type index_FilterConfig as FilterConfig, type index_FilterDef as FilterDef, type index_FilterType as FilterType, type index_FrequencyAbsorption as FrequencyAbsorption, type index_GateConfig as GateConfig, type index_IAudioBus as IAudioBus, type index_IAudioContext as IAudioContext, type index_IAudioEvent as IAudioEvent, type index_IAudioGroup as IAudioGroup, type index_IAudioListenerConfig as IAudioListenerConfig, type index_IAudioOrientation as IAudioOrientation, type index_IAudioSourceConfig as IAudioSourceConfig, type index_IAudioSourceState as IAudioSourceState, type index_IAudioSystemConfig as IAudioSystemConfig, type index_ICompressorEffect as ICompressorEffect, type index_IDelayEffect as IDelayEffect, type index_IDistortionEffect as IDistortionEffect, type index_IEqualizerBand as IEqualizerBand, type index_IEqualizerEffect as IEqualizerEffect, type index_IFilterEffect as IFilterEffect, type index_IGainEffect as IGainEffect, type index_INote as INote, type index_IPanEffect as IPanEffect, type index_IPattern as IPattern, type index_IReverbEffect as IReverbEffect, type index_ISequence as ISequence, type index_ISequencer as ISequencer, type index_ISequencerConfig as ISequencerConfig, type index_ISpatialEffect as ISpatialEffect, type index_ITrack as ITrack, type index_LineOfSightProvider as LineOfSightProvider, type index_ListenerState as ListenerState, type index_LoopMode as LoopMode, type index_LoudnessMetrics as LoudnessMetrics, type index_MelodyNote as MelodyNote, type AudioSource as MixerAudioSource, type index_MixerChannel as MixerChannel, type index_MixingContext as MixingContext, index_MusicGenerator as MusicGenerator, type index_NoiseType as NoiseType, index_OCCLUSION_MATERIALS as OCCLUSION_MATERIALS, type index_OcclusionHit as OcclusionHit, type index_OcclusionMaterial as OcclusionMaterial, type index_OcclusionRay as OcclusionRay, type index_OcclusionResult as OcclusionResult, type index_OscillatorDef as OscillatorDef, type index_OscillatorType as OscillatorType, type index_ParameterAutomation as ParameterAutomation, type index_PlaybackState as PlaybackState, index_REVERB_PRESETS as REVERB_PRESETS, type index_RaycastProvider as RaycastProvider, type index_ReverbPreset as ReverbPreset, type index_RhythmPattern as RhythmPattern, type index_RolloffModel as RolloffModel, type index_RolloffType as RolloffType, type index_ScaleType as ScaleType, index_SequencerImpl as SequencerImpl, type index_SequencerState as SequencerState, type index_SidechainConfig as SidechainConfig, type index_SoundDefinition as SoundDefinition, index_SoundPool as SoundPool, type index_SpatialAudioConfig as SpatialAudioConfig, index_SpatialAudioSource as SpatialAudioSource, index_SpatialAudioZoneSystem as SpatialAudioZoneSystem, type index_SpatialModel as SpatialModel, type index_SpectrumData as SpectrumData, index_SynthEngine as SynthEngine, type index_SynthVoice as SynthVoice, index_VoiceManager as VoiceManager, type index_VoiceStealingStrategy as VoiceStealingStrategy, type index_WaveformType as WaveformType, type index_ZoneState as ZoneState, index_audioTraitHandler as audioTraitHandler, index_bandpassFilter as bandpassFilter, index_bufferSource as bufferSource, index_compressorEffect as compressorEffect, index_createAudioContext as createAudioContext, index_createNote as createNote, index_createPattern as createPattern, index_createSequence as createSequence, index_createSequencer as createSequencer, index_createTrack as createTrack, index_defaultOrientation as defaultOrientation, index_delayEffect as delayEffect, index_distortionEffect as distortionEffect, index_eqBand as eqBand, index_equalizerEffect as equalizerEffect, index_filterEffect as filterEffect, index_frequencyToMidi as frequencyToMidi, index_gainEffect as gainEffect, index_getSharedAudioEngine as getSharedAudioEngine, index_highpassFilter as highpassFilter, index_lowpassFilter as lowpassFilter, index_midiToFrequency as midiToFrequency, index_midiToNoteName as midiToNoteName, index_noiseSource as noiseSource, index_noteNameToMidi as noteNameToMidi, index_oscillatorSource as oscillatorSource, index_panEffect as panEffect, index_reverbEffect as reverbEffect, index_setSharedAudioEngine as setSharedAudioEngine, index_spatialSource as spatialSource, index_streamSource as streamSource, index_zeroVector as zeroVector };
+}
+
+export { type IAudioContext as $, type ADSRConfig as A, type AudioTraitConfig as B, type AudioZoneConfig as C, type AutomationPoint as D, type BeatDetectionConfig as E, type FilterType$1 as F, type BeatEvent as G, type ChordDef as H, type ChordQuality as I, type CompressorConfig as J, type CurveType as K, DEFAULT_BANDS as L, type DiffractionConfig as M, type DiffractionEdge as N, type DiffractionPath as O, type DiffractionResult as P, type DistanceModel as Q, type DuckingConfig as R, type EQBand as S, type EdgeDetectionProvider as T, type EnvelopeStage as U, type FilterConfig as V, type FilterDef as W, type FilterType as X, type FrequencyAbsorption as Y, type GateConfig as Z, type IAudioBus as _, type ADSREnvelope as a, type WaveformType as a$, type IAudioEvent as a0, type IAudioGroup as a1, type IAudioListenerConfig as a2, type IAudioOrientation as a3, type IAudioSourceConfig as a4, type IAudioSourceState as a5, type IAudioSystemConfig as a6, type ICompressorEffect as a7, type IDelayEffect as a8, type IDistortionEffect as a9, type OcclusionRay as aA, type OcclusionResult as aB, type OscillatorDef as aC, type OscillatorType as aD, type ParameterAutomation as aE, type PlaybackState as aF, REVERB_PRESETS as aG, type RaycastProvider as aH, type ReverbPreset as aI, type RhythmPattern as aJ, type RolloffModel as aK, type RolloffType as aL, type ScaleType as aM, SequencerImpl as aN, type SequencerState as aO, type SidechainConfig as aP, type SoundDefinition as aQ, SoundPool as aR, type SpatialAudioConfig as aS, SpatialAudioSource as aT, SpatialAudioZoneSystem as aU, type SpatialModel as aV, type SpectrumData as aW, SynthEngine as aX, type SynthVoice as aY, VoiceManager as aZ, type VoiceStealingStrategy as a_, type IEqualizerBand as aa, type IEqualizerEffect as ab, type IFilterEffect as ac, type IGainEffect as ad, type INote as ae, type IPanEffect as af, type IPattern as ag, type IReverbEffect as ah, type ISequence as ai, type ISequencer as aj, type ISequencerConfig as ak, type ISpatialEffect as al, type ITrack as am, type LineOfSightProvider as an, type ListenerState as ao, type LoopMode as ap, type LoudnessMetrics as aq, type MelodyNote as ar, type AudioSource as as, type MixerChannel as at, type MixingContext as au, MusicGenerator as av, type NoiseType as aw, OCCLUSION_MATERIALS as ax, type OcclusionHit as ay, type OcclusionMaterial as az, AUDIO_DEFAULTS as b, type ZoneState as b0, audioTraitHandler as b1, bandpassFilter as b2, bufferSource as b3, compressorEffect as b4, createAudioContext as b5, createNote as b6, createPattern as b7, createSequence as b8, createSequencer as b9, createTrack as ba, defaultOrientation as bb, delayEffect as bc, distortionEffect as bd, eqBand as be, equalizerEffect as bf, filterEffect as bg, frequencyToMidi as bh, gainEffect as bi, getSharedAudioEngine as bj, highpassFilter as bk, lowpassFilter as bl, midiToFrequency as bm, midiToNoteName as bn, noiseSource as bo, noteNameToMidi as bp, oscillatorSource as bq, panEffect as br, reverbEffect as bs, setSharedAudioEngine as bt, spatialSource as bu, streamSource as bv, zeroVector as bw, AudioAnalyzer as c, type AudioBand as d, type AudioCone as e, type AudioConnection as f, AudioContextImpl as g, AudioDiffractionSystem as h, index as i, AudioDynamics as j, type AudioEffect as k, AudioEngine as l, type AudioSource$1 as m, AudioEnvelope as n, type AudioEventCallback as o, type AudioEventType as p, AudioFilter as q, AudioGraph as r, type AudioGraphNode as s, AudioMixer as t, type AudioNodeType as u, AudioOcclusionSystem as v, type AudioPortal as w, AudioPresets as x, type AudioSourceConfig as y, type AudioSourceType as z };