@holoscript/engine 6.0.3 → 6.0.4

package/dist/chunk-KCDPVQRY.js

@@ -0,0 +1,4088 @@
+import {
+  __export
+} from "./chunk-AKLW2MUS.js";
+
+// src/audio/index.ts
+var audio_exports = {};
+__export(audio_exports, {
+  AUDIO_DEFAULTS: () => AUDIO_DEFAULTS,
+  AudioAnalyzer: () => AudioAnalyzer,
+  AudioContextImpl: () => AudioContextImpl,
+  AudioDiffractionSystem: () => AudioDiffractionSystem,
+  AudioDynamics: () => AudioDynamics,
+  AudioEngine: () => AudioEngine,
+  AudioEnvelope: () => AudioEnvelope,
+  AudioFilter: () => AudioFilter,
+  AudioGraph: () => AudioGraph,
+  AudioMixer: () => AudioMixer,
+  AudioOcclusionSystem: () => AudioOcclusionSystem,
+  AudioPresets: () => AudioPresets,
+  DEFAULT_BANDS: () => DEFAULT_BANDS,
+  MusicGenerator: () => MusicGenerator,
+  OCCLUSION_MATERIALS: () => OCCLUSION_MATERIALS,
+  REVERB_PRESETS: () => REVERB_PRESETS,
+  SequencerImpl: () => SequencerImpl,
+  SoundPool: () => SoundPool,
+  SpatialAudioSource: () => SpatialAudioSource,
+  SpatialAudioZoneSystem: () => SpatialAudioZoneSystem,
+  SynthEngine: () => SynthEngine,
+  VoiceManager: () => VoiceManager,
+  audioTraitHandler: () => audioTraitHandler,
+  bandpassFilter: () => bandpassFilter,
+  bufferSource: () => bufferSource,
+  compressorEffect: () => compressorEffect,
+  createAudioContext: () => createAudioContext,
+  createNote: () => createNote,
+  createPattern: () => createPattern,
+  createSequence: () => createSequence,
+  createSequencer: () => createSequencer,
+  createTrack: () => createTrack,
+  defaultOrientation: () => defaultOrientation,
+  delayEffect: () => delayEffect,
+  distortionEffect: () => distortionEffect,
+  eqBand: () => eqBand,
+  equalizerEffect: () => equalizerEffect,
+  filterEffect: () => filterEffect,
+  frequencyToMidi: () => frequencyToMidi,
+  gainEffect: () => gainEffect,
+  getSharedAudioEngine: () => getSharedAudioEngine,
+  highpassFilter: () => highpassFilter,
+  lowpassFilter: () => lowpassFilter,
+  midiToFrequency: () => midiToFrequency,
+  midiToNoteName: () => midiToNoteName,
+  noiseSource: () => noiseSource,
+  noteNameToMidi: () => noteNameToMidi,
+  oscillatorSource: () => oscillatorSource,
+  panEffect: () => panEffect,
+  reverbEffect: () => reverbEffect,
+  setSharedAudioEngine: () => setSharedAudioEngine,
+  spatialSource: () => spatialSource,
+  streamSource: () => streamSource,
+  zeroVector: () => zeroVector
+});
+
+// src/audio/AudioTypes.ts
+var AUDIO_DEFAULTS = {
+  sampleRate: 44100,
+  maxSources: 32,
+  masterVolume: 1,
+  spatialEnabled: true,
+  defaultRolloff: "inverse",
+  defaultRefDistance: 1,
+  defaultMaxDistance: 1e4,
+  doppler: true,
+  dopplerFactor: 1,
+  speedOfSound: 343
+};
+function zeroVector() {
+  return { x: 0, y: 0, z: 0 };
+}
+function defaultOrientation() {
+  return {
+    forward: { x: 0, y: 0, z: -1 },
+    up: { x: 0, y: 1, z: 0 }
+  };
+}
+function bufferSource(id, url, options = {}) {
+  return {
+    id,
+    type: "buffer",
+    url,
+    volume: 1,
+    pitch: 1,
+    loop: false,
+    spatial: false,
+    position: zeroVector(),
+    ...options
+  };
+}
+function oscillatorSource(id, waveform, frequency, options = {}) {
+  return {
+    id,
+    type: "oscillator",
+    oscillatorType: waveform,
+    frequency,
+    volume: 1,
+    pitch: 1,
+    loop: true,
+    spatial: false,
+    position: zeroVector(),
+    ...options
+  };
+}
+function streamSource(id, url, options = {}) {
+  return {
+    id,
+    type: "stream",
+    url,
+    volume: 1,
+    pitch: 1,
+    loop: false,
+    spatial: false,
+    position: zeroVector(),
+    ...options
+  };
+}
+function noiseSource(id, noiseType, options = {}) {
+  return {
+    id,
+    type: "noise",
+    noiseType,
+    volume: 1,
+    pitch: 1,
+    loop: true,
+    spatial: false,
+    position: zeroVector(),
+    ...options
+  };
+}
+function spatialSource(config, position, options = {}) {
+  return {
+    ...config,
+    spatial: true,
+    position,
+    maxDistance: AUDIO_DEFAULTS.defaultMaxDistance,
+    refDistance: AUDIO_DEFAULTS.defaultRefDistance,
+    rolloffFactor: 1,
+    coneInnerAngle: 360,
+    coneOuterAngle: 360,
+    coneOuterGain: 0,
+    ...options
+  };
+}
+function gainEffect(id, gain = 1) {
+  return {
+    id,
+    type: "gain",
+    gain,
+    wet: 1,
+    bypass: false
+  };
+}
+function reverbEffect(id, decay = 2, wet = 0.5, options = {}) {
+  return {
+    id,
+    type: "reverb",
+    roomSize: 0.5,
+    decay,
+    damping: 0.5,
+    preDelay: 0.01,
+    wet,
+    bypass: false,
+    ...options
+  };
+}
+function delayEffect(id, time = 0.5, feedback = 0.3, options = {}) {
+  return {
+    id,
+    type: "delay",
+    time,
+    delayTime: time,
+    feedback,
+    maxDelay: 5,
+    wet: 0.5,
+    bypass: false,
+    ...options
+  };
+}
+function filterEffect(id, filterType, frequency, options = {}) {
+  return {
+    id,
+    type: "filter",
+    filterType,
+    frequency,
+    Q: 1,
+    gain: 0,
+    wet: 1,
+    bypass: false,
+    ...options
+  };
+}
+function compressorEffect(id, threshold = -24, ratio = 4, options = {}) {
+  return {
+    id,
+    type: "compressor",
+    threshold,
+    ratio,
+    knee: 10,
+    attack: 3e-3,
+    release: 0.25,
+    makeupGain: 0,
+    wet: 1,
+    bypass: false,
+    ...options
+  };
+}
+function midiToFrequency(note) {
+  return 440 * Math.pow(2, (note - 69) / 12);
+}
+function frequencyToMidi(frequency) {
+  return Math.round(69 + 12 * Math.log2(frequency / 440));
+}
+function noteNameToMidi(name) {
+  const match = name.match(/^([A-Ga-g])([#b]?)(-?[0-9])$/);
+  if (!match) return 60;
+  const notes = {
+    C: 0,
+    D: 2,
+    E: 4,
+    F: 5,
+    G: 7,
+    A: 9,
+    B: 11
+  };
+  const noteName = match[1].toUpperCase();
+  const accidental = match[2];
+  const octave = parseInt(match[3], 10);
+  let midi = notes[noteName] + (octave + 1) * 12;
+  if (accidental === "#") midi += 1;
+  if (accidental === "b") midi -= 1;
+  return midi;
+}
+function midiToNoteName(midi) {
+  const noteNames = ["C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B"];
+  const octave = Math.floor(midi / 12) - 1;
+  const note = noteNames[midi % 12];
+  return `${note}${octave}`;
+}
+function lowpassFilter(id, frequency, Q = 1) {
+  return filterEffect(id, "lowpass", frequency, { Q });
+}
+function highpassFilter(id, frequency, Q = 1) {
+  return filterEffect(id, "highpass", frequency, { Q });
+}
+function bandpassFilter(id, frequency, Q = 1) {
+  return filterEffect(id, "bandpass", frequency, { Q });
+}
+function distortionEffect(id, amount = 0.5, options = {}) {
+  return {
+    id,
+    type: "distortion",
+    amount,
+    oversample: "2x",
+    wet: 1,
+    bypass: false,
+    ...options
+  };
+}
+function panEffect(id, pan = 0) {
+  return {
+    id,
+    type: "pan",
+    pan,
+    wet: 1,
+    bypass: false
+  };
+}
+function eqBand(frequency, Q = 1, gain = 0) {
+  return { frequency, Q, gain };
+}
+function equalizerEffect(id, bands, options = {}) {
+  return {
+    id,
+    type: "equalizer",
+    bands,
+    wet: 1,
+    bypass: false,
+    ...options
+  };
+}
+function createNote(pitch, start, duration, velocity = 100) {
+  return {
+    pitch: typeof pitch === "string" ? noteNameToMidi(pitch) : pitch,
+    startBeat: start,
+    start,
+    duration,
+    velocity
+  };
+}
+function createPattern(id, notes, options = {}) {
+  const maxEnd = notes.reduce(
+    (max, n) => Math.max(max, (n.start ?? n.startBeat ?? 0) + n.duration),
+    0
+  );
+  return {
+    id,
+    notes,
+    length: options.length ?? Math.ceil(maxEnd),
+    loop: options.loop ?? true,
+    ...options
+  };
+}
+function createTrack(id, patterns, options = {}) {
+  return {
+    id,
+    patterns,
+    sourceId: options.sourceId,
+    volume: options.volume ?? 1,
+    muted: options.muted ?? false,
+    solo: options.solo ?? false,
+    ...options
+  };
+}
+function createSequence(id, patternOrder, tracks, options = {}) {
+  return {
+    id,
+    patternOrder,
+    tracks,
+    bpm: options.bpm ?? 120,
+    timeSignature: options.timeSignature ?? [4, 4],
+    loop: options.loop ?? false,
+    ...options
+  };
+}
+
+// src/audio/AudioContextImpl.ts
+var AudioContextImpl = class {
+  _state = "suspended";
+  _currentTime = 0;
+  _masterVolume = 1;
+  _isMuted = false;
+  _previousVolume = 1;
+  config;
+  sources = /* @__PURE__ */ new Map();
+  effects = /* @__PURE__ */ new Map();
+  groups = /* @__PURE__ */ new Map();
+  bufferCache = /* @__PURE__ */ new Map();
+  decodedBuffers = /* @__PURE__ */ new Map();
+  eventListeners = /* @__PURE__ */ new Map();
+  listenerPosition = zeroVector();
+  listenerOrientation = defaultOrientation();
+  listenerVelocity = zeroVector();
+  timeUpdateInterval = null;
+  constructor(config = {}) {
+    this.config = { ...AUDIO_DEFAULTS, ...config };
+    this._masterVolume = this.config.masterVolume;
+  }
+  // ==========================================================================
+  // Lifecycle
+  // ==========================================================================
+  async initialize() {
+    if (this._state === "running") return;
+    this._state = "running";
+    this._currentTime = 0;
+    this.timeUpdateInterval = setInterval(() => {
+      if (this._state === "running") {
+        this._currentTime += 0.01;
+        this.updatePlayingSources();
+      }
+    }, 10);
+  }
+  async suspend() {
+    if (this._state !== "running") return;
+    this._state = "suspended";
+  }
+  async resume() {
+    if (this._state !== "suspended") return;
+    this._state = "running";
+  }
+  dispose() {
+    if (this.timeUpdateInterval) {
+      clearInterval(this.timeUpdateInterval);
+      this.timeUpdateInterval = null;
+    }
+    this.sources.clear();
+    this.effects.clear();
+    this.groups.clear();
+    this.bufferCache.clear();
+    this.decodedBuffers.clear();
+    this.eventListeners.clear();
+    this._state = "closed";
+  }
+  get state() {
+    return this._state;
+  }
+  get currentTime() {
+    return this._currentTime;
+  }
+  get sampleRate() {
+    return this.config.sampleRate;
+  }
+  // ==========================================================================
+  // Master Controls
+  // ==========================================================================
+  setMasterVolume(volume) {
+    this._masterVolume = Math.max(0, Math.min(1, volume));
+    if (!this._isMuted) {
+      this._previousVolume = this._masterVolume;
+    }
+  }
+  getMasterVolume() {
+    return this._masterVolume;
+  }
+  mute() {
+    if (!this._isMuted) {
+      this._previousVolume = this._masterVolume;
+      this._masterVolume = 0;
+      this._isMuted = true;
+    }
+  }
+  unmute() {
+    if (this._isMuted) {
+      this._masterVolume = this._previousVolume;
+      this._isMuted = false;
+    }
+  }
+  get isMuted() {
+    return this._isMuted;
+  }
+  // ==========================================================================
+  // Listener
+  // ==========================================================================
+  setListenerPosition(position) {
+    this.listenerPosition = { ...position };
+  }
+  setListenerOrientation(orientation) {
+    this.listenerOrientation = {
+      forward: { ...orientation.forward },
+      up: { ...orientation.up }
+    };
+  }
+  setListenerVelocity(velocity) {
+    this.listenerVelocity = { ...velocity };
+  }
+  getListenerConfig() {
+    return {
+      position: { ...this.listenerPosition },
+      orientation: {
+        forward: { ...this.listenerOrientation.forward },
+        up: { ...this.listenerOrientation.up }
+      },
+      velocity: { ...this.listenerVelocity }
+    };
+  }
+  // ==========================================================================
+  // Source Management
+  // ==========================================================================
+  async createSource(config) {
+    if (this.sources.has(config.id)) {
+      throw new Error(`Source with id '${config.id}' already exists`);
+    }
+    if (this.sources.size >= this.config.maxSources) {
+      throw new Error(`Maximum sources (${this.config.maxSources}) reached`);
+    }
+    if (config.type === "buffer" && config.url) {
+      if (!this.bufferCache.has(config.url)) {
+        const buffer = await this.loadBuffer(config.url);
+        this.bufferCache.set(config.url, buffer);
+      }
+    }
+    const source = {
+      id: config.id,
+      config,
+      state: "stopped",
+      volume: config.volume ?? 1,
+      pitch: config.pitch ?? 1,
+      loop: config.loop ?? false,
+      position: config.position ?? zeroVector(),
+      currentTime: 0,
+      duration: config.duration ?? 0,
+      startedAt: 0,
+      pausedAt: 0,
+      effects: config.effects ?? [],
+      analyzerData: new Float32Array(1024),
+      frequencyData: new Uint8Array(512)
+    };
+    this.sources.set(config.id, source);
+    if (config.group) {
+      const group = this.groups.get(config.group);
+      if (group) {
+        group.sources.add(config.id);
+      }
+    }
+    return config.id;
+  }
+  getSource(id) {
+    const source = this.sources.get(id);
+    if (!source) return void 0;
+    return {
+      id: source.id,
+      type: source.config.type,
+      state: source.state,
+      volume: source.volume,
+      pitch: source.pitch,
+      loop: source.loop,
+      position: { ...source.position },
+      currentTime: source.currentTime,
+      duration: source.duration,
+      spatial: source.config.spatial ?? false
+    };
+  }
+  getAllSources() {
+    return Array.from(this.sources.values()).map((source) => ({
+      id: source.id,
+      type: source.config.type,
+      state: source.state,
+      volume: source.volume,
+      pitch: source.pitch,
+      loop: source.loop,
+      position: { ...source.position },
+      currentTime: source.currentTime,
+      duration: source.duration,
+      spatial: source.config.spatial ?? false
+    }));
+  }
+  removeSource(id) {
+    const source = this.sources.get(id);
+    if (!source) return false;
+    if (source.state === "playing") {
+      this.stop(id);
+    }
+    if (source.config.group) {
+      const group = this.groups.get(source.config.group);
+      if (group) {
+        group.sources.delete(id);
+      }
+    }
+    this.sources.delete(id);
+    return true;
+  }
+  // ==========================================================================
+  // Playback Control
+  // ==========================================================================
+  play(sourceId, when) {
+    const source = this.sources.get(sourceId);
+    if (!source) return;
+    if (when !== void 0 && when > this._currentTime) {
+      source.state = "scheduled";
+      source.startedAt = when;
+    } else {
+      source.state = "playing";
+      source.startedAt = this._currentTime;
+      source.currentTime = 0;
+    }
+    this.emit({
+      type: "sourceStarted",
+      sourceId,
+      timestamp: this._currentTime
+    });
+  }
+  stop(sourceId) {
+    const source = this.sources.get(sourceId);
+    if (!source) return;
+    source.state = "stopped";
+    source.currentTime = 0;
+    source.startedAt = 0;
+    source.pausedAt = 0;
+    this.emit({
+      type: "sourceStopped",
+      sourceId,
+      timestamp: this._currentTime
+    });
+  }
+  pause(sourceId) {
+    const source = this.sources.get(sourceId);
+    if (!source || source.state !== "playing") return;
+    source.state = "paused";
+    source.pausedAt = this._currentTime;
+    this.emit({
+      type: "sourcePaused",
+      sourceId,
+      timestamp: this._currentTime
+    });
+  }
+  resumeSource(sourceId) {
+    const source = this.sources.get(sourceId);
+    if (!source || source.state !== "paused") return;
+    const pauseDuration = this._currentTime - source.pausedAt;
+    source.startedAt += pauseDuration;
+    source.state = "playing";
+    source.pausedAt = 0;
+    this.emit({
+      type: "sourceResumed",
+      sourceId,
+      timestamp: this._currentTime
+    });
+  }
+  // ==========================================================================
+  // Source Properties
+  // ==========================================================================
+  setVolume(sourceId, volume) {
+    const source = this.sources.get(sourceId);
+    if (source) {
+      source.volume = Math.max(0, Math.min(1, volume));
+    }
+  }
+  setPitch(sourceId, pitch) {
+    const source = this.sources.get(sourceId);
+    if (source && pitch > 0) {
+      source.pitch = pitch;
+    }
+  }
+  setLoop(sourceId, loop, start, end) {
+    const source = this.sources.get(sourceId);
+    if (source) {
+      source.loop = loop;
+      if (start !== void 0) source.config.loopStart = start;
+      if (end !== void 0) source.config.loopEnd = end;
+    }
+  }
+  setPosition(sourceId, position) {
+    const source = this.sources.get(sourceId);
+    if (source) {
+      source.position = { ...position };
+    }
+  }
+  setOrientation(sourceId, orientation) {
+    const source = this.sources.get(sourceId);
+    if (source) {
+      source.config.orientation = { ...orientation };
+    }
+  }
+  // ==========================================================================
+  // Effects
+  // ==========================================================================
+  createEffect(config) {
+    if (this.effects.has(config.id)) {
+      throw new Error(`Effect with id '${config.id}' already exists`);
+    }
+    this.effects.set(config.id, { id: config.id, config });
+    return config.id;
+  }
+  getEffect(id) {
+    return this.effects.get(id)?.config;
+  }
+  removeEffect(id) {
+    if (!this.effects.has(id)) return false;
+    for (const source of this.sources.values()) {
+      const index = source.effects.indexOf(id);
+      if (index !== -1) {
+        source.effects.splice(index, 1);
+      }
+    }
+    this.effects.delete(id);
+    return true;
+  }
+  connectSourceToEffect(sourceId, effectId) {
+    const source = this.sources.get(sourceId);
+    const effect = this.effects.get(effectId);
+    if (source && effect && !source.effects.includes(effectId)) {
+      source.effects.push(effectId);
+    }
+  }
+  disconnectSourceFromEffect(sourceId, effectId) {
+    const source = this.sources.get(sourceId);
+    if (source) {
+      const index = source.effects.indexOf(effectId);
+      if (index !== -1) {
+        source.effects.splice(index, 1);
+      }
+    }
+  }
+  // ==========================================================================
+  // Groups
+  // ==========================================================================
+  createGroup(config) {
+    if (this.groups.has(config.id)) {
+      throw new Error(`Group with id '${config.id}' already exists`);
+    }
+    this.groups.set(config.id, {
+      id: config.id,
+      config,
+      sources: /* @__PURE__ */ new Set()
+    });
+    return config.id;
+  }
+  getGroup(id) {
+    return this.groups.get(id)?.config;
+  }
+  setGroupVolume(groupId, volume) {
+    const group = this.groups.get(groupId);
+    if (group) {
+      group.config.volume = Math.max(0, Math.min(1, volume));
+    }
+  }
+  setGroupMuted(groupId, muted) {
+    const group = this.groups.get(groupId);
+    if (group) {
+      group.config.muted = muted;
+    }
+  }
+  setGroupSolo(groupId, solo) {
+    const group = this.groups.get(groupId);
+    if (group) {
+      group.config.solo = solo;
+    }
+  }
+  // ==========================================================================
+  // Buffer Management
+  // ==========================================================================
+  async loadBuffer(url) {
+    const cached = this.bufferCache.get(url);
+    if (cached) return cached;
+    const buffer = new ArrayBuffer(44100 * 2 * 2);
+    this.bufferCache.set(url, buffer);
+    this.emit({
+      type: "bufferLoaded",
+      timestamp: this._currentTime,
+      data: { url }
+    });
+    return buffer;
+  }
+  async decodeBuffer(buffer) {
+    return {
+      length: buffer.byteLength / 4,
+      duration: buffer.byteLength / (44100 * 4),
+      sampleRate: 44100,
+      numberOfChannels: 2,
+      getChannelData: (_channel) => new Float32Array(buffer.byteLength / 4),
+      copyFromChannel: () => {
+      },
+      copyToChannel: () => {
+      }
+    };
+  }
+  getCachedBuffer(url) {
+    return this.bufferCache.get(url);
+  }
+  clearBufferCache() {
+    this.bufferCache.clear();
+    this.decodedBuffers.clear();
+  }
+  // ==========================================================================
+  // Events
+  // ==========================================================================
+  on(event, callback) {
+    let listeners = this.eventListeners.get(event);
+    if (!listeners) {
+      listeners = /* @__PURE__ */ new Set();
+      this.eventListeners.set(event, listeners);
+    }
+    listeners.add(callback);
+  }
+  off(event, callback) {
+    const listeners = this.eventListeners.get(event);
+    if (listeners) {
+      listeners.delete(callback);
+    }
+  }
+  emit(event) {
+    const listeners = this.eventListeners.get(event.type);
+    if (listeners) {
+      for (const callback of listeners) {
+        try {
+          callback(event);
+        } catch (e) {
+          console.error("Error in audio event callback:", e);
+        }
+      }
+    }
+  }
+  // ==========================================================================
+  // Analysis
+  // ==========================================================================
+  getAnalyzerData(sourceId) {
+    const source = this.sources.get(sourceId);
+    if (!source || !source.analyzerData) return void 0;
+    if (source.state === "playing") {
+      for (let i = 0; i < source.analyzerData.length; i++) {
+        source.analyzerData[i] = Math.sin(i * 0.1 + this._currentTime * 10) * 0.5;
+      }
+    }
+    return source.analyzerData;
+  }
+  getFrequencyData(sourceId) {
+    const source = this.sources.get(sourceId);
+    if (!source || !source.frequencyData) return void 0;
+    if (source.state === "playing") {
+      for (let i = 0; i < source.frequencyData.length; i++) {
+        const freq = i / source.frequencyData.length;
+        source.frequencyData[i] = Math.floor(Math.random() * 128 + 64 * (1 - freq));
+      }
+    }
+    return source.frequencyData;
+  }
+  // ==========================================================================
+  // Private Methods
+  // ==========================================================================
+  updatePlayingSources() {
+    for (const source of this.sources.values()) {
+      if (source.state === "scheduled" && this._currentTime >= source.startedAt) {
+        source.state = "playing";
+        this.emit({
+          type: "sourceStarted",
+          sourceId: source.id,
+          timestamp: this._currentTime
+        });
+      }
+      if (source.state === "playing") {
+        source.currentTime = (this._currentTime - source.startedAt) * source.pitch;
+        if (source.duration > 0 && source.currentTime >= source.duration) {
+          if (source.loop) {
+            source.currentTime = source.config.loopStart ?? 0;
+            source.startedAt = this._currentTime;
+            this.emit({
+              type: "sourceLooped",
+              sourceId: source.id,
+              timestamp: this._currentTime
+            });
+          } else {
+            source.state = "stopped";
+            source.currentTime = 0;
+            this.emit({
+              type: "sourceEnded",
+              sourceId: source.id,
+              timestamp: this._currentTime
+            });
+          }
+        }
+      }
+    }
+  }
+  /**
+   * Calculate spatial audio gain based on distance
+   */
+  calculateSpatialGain(sourcePosition) {
+    const dx = sourcePosition.x - this.listenerPosition.x;
+    const dy = sourcePosition.y - this.listenerPosition.y;
+    const dz = sourcePosition.z - this.listenerPosition.z;
+    const distance = Math.sqrt(dx * dx + dy * dy + dz * dz);
+    const refDistance = this.config.defaultRefDistance;
+    const maxDistance = this.config.defaultMaxDistance;
+    if (distance <= refDistance) return 1;
+    if (distance >= maxDistance) return 0;
+    switch (this.config.defaultRolloff) {
+      case "linear":
+        return 1 - (distance - refDistance) / (maxDistance - refDistance);
+      case "exponential":
+        return Math.pow(distance / refDistance, -1);
+      case "inverse":
+      default:
+        return refDistance / (refDistance + (distance - refDistance));
+    }
+  }
+};
+function createAudioContext(config) {
+  return new AudioContextImpl(config);
+}
+
+// src/audio/Sequencer.ts
+var SequencerImpl = class {
+  _state = "stopped";
+  _bpm = 120;
+  _swing = 0;
+  _currentBeat = 0;
+  _currentBar = 0;
+  _currentPatternIndex = 0;
+  _loopMode = "pattern";
+  _loopStart = 0;
+  _loopEnd = 4;
+  _metronomeEnabled = false;
+  _countInBars = 0;
+  _countingIn = false;
+  context;
+  sequences = /* @__PURE__ */ new Map();
+  patterns = /* @__PURE__ */ new Map();
+  tracks = /* @__PURE__ */ new Map();
+  scheduledNotes = [];
+  eventListeners = /* @__PURE__ */ new Map();
+  triggerCallbacks = /* @__PURE__ */ new Map();
+  currentSequenceId = null;
+  startTime = 0;
+  pausedTime = 0;
+  lastScheduledBeat = -1;
+  scheduleAheadTime = 0.1;
+  // seconds
+  tickInterval = null;
+  constructor(context) {
+    this.context = context;
+  }
+  // ==========================================================================
+  // Lifecycle
+  // ==========================================================================
+  load(sequence) {
+    this.createSequence(sequence);
+    this.loadSequence(sequence.id);
+  }
+  unload() {
+    if (this.currentSequenceId) {
+      this.removeSequence(this.currentSequenceId);
+    }
+  }
+  play() {
+    this.start();
+  }
+  start() {
+    if (this._state === "playing") return;
+    if (this._state === "paused") {
+      const pauseDuration = this.context.currentTime - this.pausedTime;
+      this.startTime += pauseDuration;
+    } else {
+      this.startTime = this.context.currentTime;
+      this._currentBeat = 0;
+      this._currentBar = 0;
+      this._currentPatternIndex = 0;
+      this.lastScheduledBeat = -1;
+      this.scheduledNotes.length = 0;
+      if (this._countInBars > 0) {
+        this._countingIn = true;
+        this.startTime += this.barsToSeconds(this._countInBars);
+      }
+    }
+    this._state = "playing";
+    this.startScheduler();
+    this.emit({
+      type: "sequencerStarted",
+      timestamp: this.context.currentTime
+    });
+  }
+  stop() {
+    if (this._state === "stopped") return;
+    this._state = "stopped";
+    this.stopScheduler();
+    this._currentBeat = 0;
+    this._currentBar = 0;
+    this._currentPatternIndex = 0;
+    this.lastScheduledBeat = -1;
+    this.scheduledNotes.length = 0;
+    this._countingIn = false;
+    this.emit({
+      type: "sequencerStopped",
+      timestamp: this.context.currentTime
+    });
+  }
+  pause() {
+    if (this._state !== "playing") return;
+    this._state = "paused";
+    this.pausedTime = this.context.currentTime;
+    this.stopScheduler();
+    this.emit({
+      type: "sequencerPaused",
+      timestamp: this.context.currentTime
+    });
+  }
+  get state() {
+    return this._state;
+  }
+  getState() {
+    return {
+      isPlaying: this._state === "playing",
+      isPaused: this._state === "paused",
+      currentBeat: this._currentBeat,
+      currentBar: this._currentBar,
+      bpm: this._bpm,
+      looping: this._loopMode !== "none",
+      loopStart: this._loopStart,
+      loopEnd: this._loopEnd
+    };
+  }
+  get isPlaying() {
+    return this._state === "playing";
+  }
+  dispose() {
+    this.stop();
+    this.sequences.clear();
+    this.patterns.clear();
+    this.tracks.clear();
+    this.eventListeners.clear();
+    this.triggerCallbacks.clear();
+  }
+  // ==========================================================================
+  // Transport Properties
+  // ==========================================================================
+  get bpm() {
+    return this._bpm;
+  }
+  set bpm(value) {
+    if (value > 0 && value <= 999) {
+      this._bpm = value;
+      this.emit({
+        type: "bpmChanged",
+        timestamp: this.context.currentTime,
+        data: { bpm: value }
+      });
+    }
+  }
+  get swing() {
+    return this._swing;
+  }
+  set swing(value) {
+    this._swing = Math.max(0, Math.min(1, value));
+  }
+  get currentBeat() {
+    return this._currentBeat;
+  }
+  get currentBar() {
+    return this._currentBar;
+  }
+  get currentPatternIndex() {
+    return this._currentPatternIndex;
+  }
+  setBPM(bpm) {
+    this.bpm = bpm;
+  }
+  getBPM() {
+    return this.bpm;
+  }
+  get loopMode() {
+    return this._loopMode;
+  }
+  set loopMode(value) {
+    this._loopMode = value;
+  }
+  setLoop(enabled, startBeat, endBeat) {
+    this._loopMode = enabled ? "sequence" : "none";
+    if (startBeat !== void 0 && endBeat !== void 0) {
+      this.setLoopRange(startBeat, endBeat);
+    }
+  }
+  get metronomeEnabled() {
+    return this._metronomeEnabled;
+  }
+  set metronomeEnabled(value) {
+    this._metronomeEnabled = value;
+  }
+  get countInBars() {
+    return this._countInBars;
+  }
+  set countInBars(value) {
+    this._countInBars = Math.max(0, Math.floor(value));
+  }
+  get isCountingIn() {
+    return this._countingIn;
+  }
+  // ==========================================================================
+  // Transport Controls
+  // ==========================================================================
+  setLoopRange(start, end) {
+    if (start >= 0 && end > start) {
+      this._loopStart = start;
+      this._loopEnd = end;
+    }
+  }
+  getLoopRange() {
+    return {
+      start: this._loopStart,
+      end: this._loopEnd
+    };
+  }
+  seek(beat, bar) {
+    if (beat < 0) return;
+    const wasPlaying = this._state === "playing";
+    if (wasPlaying) {
+      this.pause();
+    }
+    this._currentBeat = beat;
+    if (bar !== void 0) {
+      this._currentBar = bar;
+    }
+    const elapsedBeats = this._currentBar * this.getBeatsPerBar() + this._currentBeat;
+    this.startTime = this.context.currentTime - this.beatsToSeconds(elapsedBeats);
+    this.lastScheduledBeat = Math.floor(this._currentBeat) - 1;
+    this.scheduledNotes.length = 0;
+    if (wasPlaying) {
+      this._state = "stopped";
+      this.start();
+    }
+    this.emit({
+      type: "sequencerSeeked",
+      timestamp: this.context.currentTime,
+      data: { beat: this._currentBeat, bar: this._currentBar }
+    });
+  }
+  getPlaybackPosition() {
+    return {
+      beat: this._currentBeat,
+      bar: this._currentBar,
+      pattern: this._currentPatternIndex
+    };
+  }
+  // ==========================================================================
+  // Sequence Management
+  // ==========================================================================
+  createSequence(config) {
+    if (this.sequences.has(config.id)) {
+      throw new Error(`Sequence with id '${config.id}' already exists`);
+    }
+    this.sequences.set(config.id, { ...config });
+    return config.id;
+  }
+  getSequence(id) {
+    const seq = this.sequences.get(id);
+    return seq ? { ...seq } : void 0;
+  }
+  updateSequence(id, updates) {
+    const seq = this.sequences.get(id);
+    if (seq) {
+      Object.assign(seq, updates);
+    }
+  }
+  removeSequence(id) {
+    if (this.currentSequenceId === id) {
+      this.stop();
+      this.currentSequenceId = null;
+    }
+    return this.sequences.delete(id);
+  }
+  loadSequence(id) {
+    if (!this.sequences.has(id)) return false;
+    const wasPlaying = this._state === "playing";
+    this.stop();
+    this.currentSequenceId = id;
+    if (wasPlaying) {
+      this.start();
+    }
+    return true;
+  }
+  getCurrentSequence() {
+    return this.currentSequenceId ? this.getSequence(this.currentSequenceId) : void 0;
+  }
+  // ==========================================================================
+  // Pattern Management
+  // ==========================================================================
+  createPattern(config) {
+    if (this.patterns.has(config.id)) {
+      throw new Error(`Pattern with id '${config.id}' already exists`);
+    }
+    this.patterns.set(config.id, { ...config, notes: [...config.notes] });
+    return config.id;
+  }
+  addPattern(pattern) {
+    this.createPattern(pattern);
+  }
+  getPattern(id) {
+    const pattern = this.patterns.get(id);
+    if (!pattern) return void 0;
+    return { ...pattern, notes: [...pattern.notes] };
+  }
+  updatePattern(id, updates) {
+    const pattern = this.patterns.get(id);
+    if (pattern) {
+      if (updates.notes) {
+        pattern.notes = [...updates.notes];
+      }
+      if (updates.name) pattern.name = updates.name;
+      if (updates.bars !== void 0) pattern.bars = updates.bars;
+      if (updates.beatsPerBar !== void 0) pattern.beatsPerBar = updates.beatsPerBar;
+      if (updates.subdivision !== void 0) pattern.subdivision = updates.subdivision;
+    }
+  }
+  removePattern(id) {
+    return this.patterns.delete(id);
+  }
+  addNoteToPattern(patternId, note) {
+    const pattern = this.patterns.get(patternId);
+    if (pattern) {
+      pattern.notes.push({ ...note });
+    }
+  }
+  removeNoteFromPattern(patternId, noteIndex) {
+    const pattern = this.patterns.get(patternId);
+    if (pattern && noteIndex >= 0 && noteIndex < pattern.notes.length) {
+      pattern.notes.splice(noteIndex, 1);
+    }
+  }
+  scheduleNote(trackId, note) {
+    const track = this.tracks.get(trackId);
+    const patternRef = track?.patterns[0];
+    if (!patternRef) return;
+    const pattern = this.patterns.get(patternRef.patternId);
+    if (!pattern) return;
+    pattern.notes.push({ ...note });
+  }
+  quantize(beat, grid) {
+    if (grid <= 0) return beat;
+    return Math.round(beat / grid) * grid;
+  }
+  quantizePattern(patternId, subdivision) {
+    const pattern = this.patterns.get(patternId);
+    if (!pattern || subdivision <= 0) return;
+    const step = 1 / subdivision;
+    for (const note of pattern.notes) {
+      const start = note.start ?? note.startBeat ?? 0;
+      note.start = Math.round(start / step) * step;
+      note.startBeat = note.start;
+      if (note.duration !== void 0) {
+        note.duration = Math.max(step, Math.round(note.duration / step) * step);
+      }
+    }
+  }
+  // ==========================================================================
+  // Track Management
+  // ==========================================================================
+  createTrack(config) {
+    if (this.tracks.has(config.id)) {
+      throw new Error(`Track with id '${config.id}' already exists`);
+    }
+    this.tracks.set(config.id, {
+      ...config,
+      patterns: [...config.patterns],
+      effects: config.effects ? [...config.effects] : []
+    });
+    return config.id;
+  }
+  getTrack(id) {
+    const track = this.tracks.get(id);
+    if (!track) return void 0;
+    return {
+      ...track,
+      patterns: [...track.patterns],
+      effects: track.effects ? [...track.effects] : []
+    };
+  }
+  updateTrack(id, updates) {
+    const track = this.tracks.get(id);
+    if (track) {
+      if (updates.patterns) track.patterns = [...updates.patterns];
+      if (updates.effects) track.effects = [...updates.effects];
+      if (updates.name !== void 0) track.name = updates.name;
+      if (updates.volume !== void 0) track.volume = updates.volume;
+      if (updates.pan !== void 0) track.pan = updates.pan;
+      if (updates.muted !== void 0) track.muted = updates.muted;
+      if (updates.solo !== void 0) track.solo = updates.solo;
+      if (updates.outputSource !== void 0) track.outputSource = updates.outputSource;
+    }
+  }
+  removeTrack(id) {
+    return this.tracks.delete(id);
+  }
+  setTrackVolume(trackId, volume) {
+    const track = this.tracks.get(trackId);
+    if (track) {
+      track.volume = volume;
+    }
+  }
+  setTrackMuted(trackId, muted) {
+    const track = this.tracks.get(trackId);
+    if (track) {
+      track.muted = muted;
+    }
+  }
+  setTrackSolo(trackId, solo) {
+    const track = this.tracks.get(trackId);
+    if (track) {
+      track.solo = solo;
+    }
+  }
+  // ==========================================================================
+  // Note Triggers
+  // ==========================================================================
+  onNoteTrigger(trackId, callback) {
+    let callbacks = this.triggerCallbacks.get(trackId);
+    if (!callbacks) {
+      callbacks = /* @__PURE__ */ new Set();
+      this.triggerCallbacks.set(trackId, callbacks);
+    }
+    callbacks.add(callback);
+  }
+  offNoteTrigger(trackId, callback) {
+    const callbacks = this.triggerCallbacks.get(trackId);
+    if (callbacks) {
+      callbacks.delete(callback);
+    }
+  }
+  // ==========================================================================
+  // Events
+  // ==========================================================================
+  on(event, callback) {
+    let listeners = this.eventListeners.get(event);
+    if (!listeners) {
+      listeners = /* @__PURE__ */ new Set();
+      this.eventListeners.set(event, listeners);
+    }
+    listeners.add(callback);
+  }
+  off(event, callback) {
+    const listeners = this.eventListeners.get(event);
+    if (listeners) {
+      listeners.delete(callback);
+    }
+  }
+  // ==========================================================================
+  // Utilities
+  // ==========================================================================
+  beatsToSeconds(beats) {
+    return beats * 60 / this._bpm;
+  }
+  secondsToBeats(seconds) {
+    return seconds * this._bpm / 60;
+  }
+  barsToSeconds(bars) {
+    return this.beatsToSeconds(bars * this.getBeatsPerBar());
+  }
+  secondsToBars(seconds) {
+    return this.secondsToBeats(seconds) / this.getBeatsPerBar();
+  }
+  getMidiFrequency(midiNote) {
+    return midiToFrequency(midiNote);
+  }
+  getNoteToMidi(noteName) {
+    return noteNameToMidi(noteName);
+  }
+  // ==========================================================================
+  // Private Methods
+  // ==========================================================================
+  getBeatsPerBar() {
+    const currentPattern = this.getCurrentPattern();
+    return currentPattern?.beatsPerBar ?? 4;
+  }
+  getCurrentPattern() {
+    const sequence = this.getCurrentSequence();
+    const patternOrder = sequence?.patternOrder ?? sequence?.patterns?.map((p) => p.id) ?? [];
+    if (!sequence || patternOrder.length === 0) return void 0;
+    const patternId = patternOrder[this._currentPatternIndex];
+    return patternId ? this.patterns.get(patternId) : void 0;
+  }
+  startScheduler() {
+    if (this.tickInterval) return;
+    this.tickInterval = setInterval(() => {
+      this.schedulerTick();
+    }, 25);
+  }
+  stopScheduler() {
+    if (this.tickInterval) {
+      clearInterval(this.tickInterval);
+      this.tickInterval = null;
+    }
+  }
+  schedulerTick() {
+    if (this._state !== "playing") return;
+    const currentTime = this.context.currentTime;
+    const elapsedSeconds = currentTime - this.startTime;
+    const elapsedBeats = this.secondsToBeats(elapsedSeconds);
+    const beatsPerBar = this.getBeatsPerBar();
+    this._currentBeat = elapsedBeats % beatsPerBar;
+    this._currentBar = Math.floor(elapsedBeats / beatsPerBar);
+    if (this._countingIn && elapsedSeconds >= 0) {
+      this._countingIn = false;
+    }
+    const currentBeatInt = Math.floor(elapsedBeats);
+    if (currentBeatInt > this.lastScheduledBeat) {
+      for (let beat = this.lastScheduledBeat + 1; beat <= currentBeatInt; beat++) {
+        const beatInBar = beat % beatsPerBar;
+        this.emit({
+          type: "beat",
+          timestamp: this.beatsToSeconds(beat) + this.startTime,
+          data: { beat: beatInBar, bar: Math.floor(beat / beatsPerBar) }
+        });
+        if (beatInBar === 0) {
+          this.emit({
+            type: "bar",
+            timestamp: this.beatsToSeconds(beat) + this.startTime,
+            data: { bar: Math.floor(beat / beatsPerBar) }
+          });
+        }
+        if (this._metronomeEnabled) {
+          this.playMetronome(beatInBar === 0);
+        }
+      }
+      this.lastScheduledBeat = currentBeatInt;
+    }
+    this.scheduleNotes(elapsedBeats);
+    this.handleLooping();
+    this.triggerScheduledNotes(currentTime);
+  }
+  scheduleNotes(elapsedBeats) {
+    const sequence = this.getCurrentSequence();
+    if (!sequence) return;
+    const scheduleAheadBeats = this.secondsToBeats(this.scheduleAheadTime);
+    const lookAheadEnd = elapsedBeats + scheduleAheadBeats;
+    const pattern = this.getCurrentPattern();
+    if (!pattern) return;
+    for (const trackEntry of sequence.tracks) {
+      const trackId = trackEntry.id;
+      const track = this.tracks.get(trackId) ?? trackEntry;
+      if (!track || track.muted) continue;
+      const patternBars = pattern.bars ?? 1;
+      const patternOffset = this._currentPatternIndex * patternBars * (pattern.beatsPerBar ?? 4);
+      for (const note of pattern.notes) {
+        const noteStartBeat = patternOffset + (note.start ?? note.startBeat ?? 0);
+        const noteEndBeat = noteStartBeat + (note.duration ?? 0.25);
+        if (noteStartBeat >= elapsedBeats && noteStartBeat < lookAheadEnd) {
+          const alreadyScheduled = this.scheduledNotes.some(
+            (sn) => sn.track === trackId && Math.abs(sn.startTime - this.beatsToSeconds(noteStartBeat)) < 1e-3 && sn.note.pitch === note.pitch
+          );
+          if (!alreadyScheduled) {
+            this.scheduledNotes.push({
+              track: trackId,
+              note,
+              startTime: this.startTime + this.beatsToSeconds(noteStartBeat),
+              endTime: this.startTime + this.beatsToSeconds(noteEndBeat),
+              triggered: false,
+              released: false
+            });
+          }
+        }
+      }
+    }
+  }
+  triggerScheduledNotes(currentTime) {
+    for (const scheduled of this.scheduledNotes) {
+      if (!scheduled.triggered && currentTime >= scheduled.startTime) {
+        scheduled.triggered = true;
+        const callbacks = this.triggerCallbacks.get(scheduled.track);
+        if (callbacks) {
+          for (const callback of callbacks) {
+            try {
+              callback(scheduled.note, scheduled.startTime);
+            } catch (e) {
+              console.error("Error in note trigger callback:", e);
+            }
+          }
+        }
+        this.emit({
+          type: "noteTriggered",
+          timestamp: scheduled.startTime,
+          data: { track: scheduled.track, note: scheduled.note }
+        });
+      }
+      if (!scheduled.released && currentTime >= scheduled.endTime) {
+        scheduled.released = true;
+        this.emit({
+          type: "noteReleased",
+          timestamp: scheduled.endTime,
+          data: { track: scheduled.track, note: scheduled.note }
+        });
+      }
+    }
+    const cutoffTime = currentTime - 1;
+    for (let i = this.scheduledNotes.length - 1; i >= 0; i--) {
+      if (this.scheduledNotes[i].released && this.scheduledNotes[i].endTime < cutoffTime) {
+        this.scheduledNotes.splice(i, 1);
+      }
+    }
+  }
+  handleLooping() {
+    const sequence = this.getCurrentSequence();
+    if (!sequence) return;
+    const pattern = this.getCurrentPattern();
+    if (!pattern) return;
+    const patternBars = pattern.bars ?? 1;
+    const patternLength = patternBars * (pattern.beatsPerBar ?? 4);
+    const totalBeats = this._currentBar * this.getBeatsPerBar() + this._currentBeat;
+    const patternEnd = (this._currentPatternIndex + 1) * patternLength;
+    const patternOrder = sequence.patternOrder ?? sequence.patterns?.map((p) => p.id) ?? [];
+    if (totalBeats >= patternEnd) {
+      if (this._loopMode === "pattern") {
+        this.seek(0, this._currentPatternIndex * (pattern.bars ?? 1));
+      } else if (this._loopMode === "sequence") {
+        this._currentPatternIndex++;
+        if (this._currentPatternIndex >= patternOrder.length) {
+          this._currentPatternIndex = 0;
+          this.seek(0, 0);
+          this.emit({
+            type: "sequenceLooped",
+            timestamp: this.context.currentTime
+          });
+        }
+      } else if (this._loopMode === "none") {
+        this._currentPatternIndex++;
+        if (this._currentPatternIndex >= patternOrder.length) {
+          this.stop();
+        }
+      }
+    }
+  }
+  playMetronome(isDownbeat) {
+    this.emit({
+      type: "metronomeClick",
+      timestamp: this.context.currentTime,
+      data: { isDownbeat }
+    });
+  }
+  emit(event) {
+    const listeners = this.eventListeners.get(event.type);
+    if (listeners) {
+      for (const callback of listeners) {
+        try {
+          callback(event);
+        } catch (e) {
+          console.error("Error in sequencer event callback:", e);
+        }
+      }
+    }
+  }
+};
+function createSequencer(context) {
+  return new SequencerImpl(context);
+}
+
+// src/audio/AudioEngine.ts
+function computeAttenuation(distance, model, refDist, maxDist, rolloff) {
+  const d = Math.max(distance, refDist);
+  switch (model) {
+    case "linear": {
+      const clamped = Math.min(d, maxDist);
+      return 1 - rolloff * (clamped - refDist) / (maxDist - refDist);
+    }
+    case "inverse":
+      return refDist / (refDist + rolloff * (d - refDist));
+    case "exponential":
+      return Math.pow(d / refDist, -rolloff);
+    default:
+      return 1;
+  }
+}
+function vec3Dist(a, b) {
+  const dx = a.x - b.x;
+  const dy = a.y - b.y;
+  const dz = a.z - b.z;
+  return Math.sqrt(dx * dx + dy * dy + dz * dz);
+}
+function computePan(listener, sourcePos) {
+  const rx = listener.forward.y * listener.up.z - listener.forward.z * listener.up.y;
+  const rz = listener.forward.x * listener.up.y - listener.forward.y * listener.up.x;
+  const dx = sourcePos.x - listener.position.x;
+  const dz = sourcePos.z - listener.position.z;
+  const dist = Math.sqrt(dx * dx + dz * dz);
+  if (dist < 1e-3) return 0;
+  const dot = dx * rx + dz * rz;
+  const rLen = Math.sqrt(rx * rx + rz * rz);
+  if (rLen < 1e-3) return 0;
+  return Math.max(-1, Math.min(1, dot / (dist * rLen)));
+}
+var AudioEngine = class {
+  sources = /* @__PURE__ */ new Map();
+  listener = {
+    position: [0, 0, 0],
+    forward: { x: 0, y: 0, z: -1 },
+    up: { x: 0, y: 1, z: 0 }
+  };
+  masterVolume = 1;
+  muted = false;
+  /**
+   * Update the listener position (typically from VR headset).
+   */
+  setListenerPosition(pos) {
+    this.listener.position = { ...pos };
+  }
+  setListenerOrientation(forward, up) {
+    this.listener.forward = { ...forward };
+    this.listener.up = { ...up };
+  }
+  getListener() {
+    return { ...this.listener };
+  }
+  /**
+   * Create and play a new audio source.
+   */
+  play(soundId, config = {}) {
+    const id = config.id || `src_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`;
+    const fullConfig = {
+      id,
+      position: [0, 0, 0],
+      volume: 1,
+      pitch: 1,
+      loop: false,
+      maxDistance: 50,
+      refDistance: 1,
+      rolloffFactor: 1,
+      distanceModel: "inverse",
+      channel: "master",
+      spatialize: true,
+      ...config
+    };
+    const source = {
+      config: fullConfig,
+      isPlaying: true,
+      currentTime: 0,
+      computedVolume: fullConfig.volume,
+      computedPan: 0,
+      soundId
+    };
+    this.sources.set(id, source);
+    return id;
+  }
+  /**
+   * Stop a playing source.
+   */
+  stop(sourceId) {
+    const source = this.sources.get(sourceId);
+    if (source) {
+      source.isPlaying = false;
+      this.sources.delete(sourceId);
+    }
+  }
+  /**
+   * Update a source's position.
+   */
+  setSourcePosition(sourceId, pos) {
+    const source = this.sources.get(sourceId);
+    if (source) source.config.position = { ...pos };
+  }
+  /**
+   * Update all sources. Call every frame.
+   */
+  update(delta) {
+    const toRemove = [];
+    for (const [id, source] of this.sources) {
+      if (!source.isPlaying) {
+        toRemove.push(id);
+        continue;
+      }
+      source.currentTime += delta * source.config.pitch;
+      if (source.config.spatialize) {
+        const dist = vec3Dist(this.listener.position, source.config.position);
+        const attenuation = computeAttenuation(
+          dist,
+          source.config.distanceModel,
+          source.config.refDistance,
+          source.config.maxDistance,
+          source.config.rolloffFactor
+        );
+        source.computedVolume = source.config.volume * attenuation * this.masterVolume * (this.muted ? 0 : 1);
+        source.computedPan = computePan(this.listener, source.config.position);
+      } else {
+        source.computedVolume = source.config.volume * this.masterVolume * (this.muted ? 0 : 1);
+        source.computedPan = 0;
+      }
+    }
+    for (const id of toRemove) this.sources.delete(id);
+  }
+  /**
+   * Get a source by ID.
+   */
+  getSource(sourceId) {
+    return this.sources.get(sourceId);
+  }
+  /**
+   * Get all active sources.
+   */
+  getActiveSources() {
+    return Array.from(this.sources.values()).filter((s) => s.isPlaying);
+  }
+  /**
+   * Set master volume.
+   */
+  setMasterVolume(vol) {
+    this.masterVolume = Math.max(0, Math.min(1, vol));
+  }
+  getMasterVolume() {
+    return this.masterVolume;
+  }
+  /**
+   * Mute/unmute all audio.
+   */
+  setMuted(muted) {
+    this.muted = muted;
+  }
+  isMuted() {
+    return this.muted;
+  }
+  /**
+   * Get active source count.
+   */
+  getActiveCount() {
+    return this.sources.size;
+  }
+  /**
+   * Stop all sources.
+   */
+  stopAll() {
+    this.sources.clear();
+  }
+};
+
+// src/audio/AudioAnalyzer.ts
+function simpleDFT(samples, binCount) {
+  const magnitudes = new Float32Array(binCount);
+  const N = samples.length;
+  for (let k = 0; k < binCount; k++) {
+    let real = 0;
+    let imag = 0;
+    for (let n = 0; n < N; n++) {
+      const angle = 2 * Math.PI * k * n / N;
+      real += samples[n] * Math.cos(angle);
+      imag -= samples[n] * Math.sin(angle);
+    }
+    magnitudes[k] = Math.sqrt(real * real + imag * imag) / N;
+  }
+  return magnitudes;
+}
+var DEFAULT_BANDS = [
+  { name: "sub", low: 20, high: 60, energy: 0 },
+  { name: "bass", low: 60, high: 250, energy: 0 },
+  { name: "lowMid", low: 250, high: 500, energy: 0 },
+  { name: "mid", low: 500, high: 2e3, energy: 0 },
+  { name: "highMid", low: 2e3, high: 4e3, energy: 0 },
+  { name: "presence", low: 4e3, high: 6e3, energy: 0 },
+  { name: "brilliance", low: 6e3, high: 2e4, energy: 0 }
+];
+var AudioAnalyzer = class {
+  fftSize;
+  sampleRate;
+  currentSpectrum = null;
+  bands;
+  beatConfig;
+  beatHistory = [];
+  energyHistory = [];
+  lastBeatTime = 0;
+  smoothedEnergy = 0;
+  loudness = { rms: 0, peak: 0, lufs: -100, dynamicRange: 0 };
+  constructor(fftSize = 256, sampleRate = 44100, beatConfig) {
+    this.fftSize = fftSize;
+    this.sampleRate = sampleRate;
+    this.bands = DEFAULT_BANDS.map((b) => ({ ...b }));
+    this.beatConfig = {
+      sensitivity: 0.5,
+      minInterval: 200,
+      energyThreshold: 0.1,
+      frequencyRange: { low: 60, high: 250 },
+      ...beatConfig
+    };
+  }
+  // ---------------------------------------------------------------------------
+  // Analysis
+  // ---------------------------------------------------------------------------
+  /**
+   * Analyze a buffer of audio samples.
+   */
+  analyze(samples, currentTimeMs) {
+    const binCount = Math.min(this.fftSize / 2, samples.length / 2);
+    const frequencies = simpleDFT(samples, binCount);
+    let peakMag = 0;
+    let peakBin = 0;
+    for (let i = 0; i < frequencies.length; i++) {
+      if (frequencies[i] > peakMag) {
+        peakMag = frequencies[i];
+        peakBin = i;
+      }
+    }
+    this.currentSpectrum = {
+      frequencies,
+      binCount,
+      sampleRate: this.sampleRate,
+      peakFrequency: peakBin * this.sampleRate / (binCount * 2),
+      peakMagnitude: peakMag
+    };
+    this.computeBands(frequencies, binCount);
+    this.computeLoudness(samples);
+    this.detectBeat(currentTimeMs);
+  }
+  computeBands(frequencies, binCount) {
+    const binWidth = this.sampleRate / (binCount * 2);
+    for (const band of this.bands) {
+      const startBin = Math.floor(band.low / binWidth);
+      const endBin = Math.min(Math.ceil(band.high / binWidth), binCount - 1);
+      let sum = 0;
+      let count = 0;
+      for (let i = startBin; i <= endBin; i++) {
+        sum += frequencies[i];
+        count++;
+      }
+      band.energy = count > 0 ? sum / count : 0;
+    }
+  }
+  computeLoudness(samples) {
+    let sumSquares = 0;
+    let peak = 0;
+    for (let i = 0; i < samples.length; i++) {
+      const abs = Math.abs(samples[i]);
+      sumSquares += samples[i] * samples[i];
+      if (abs > peak) peak = abs;
+    }
+    const rms = Math.sqrt(sumSquares / samples.length);
+    const lufs = rms > 0 ? 20 * Math.log10(rms) : -100;
+    const peakDb = peak > 0 ? 20 * Math.log10(peak) : -100;
+    this.loudness = {
+      rms,
+      peak,
+      lufs,
+      dynamicRange: peakDb - lufs
+    };
+  }
+  detectBeat(currentTimeMs) {
+    const bassEnergy = this.getBandEnergy("bass");
+    this.energyHistory.push(bassEnergy);
+    if (this.energyHistory.length > 43) this.energyHistory.shift();
+    const avgEnergy = this.energyHistory.reduce((a, b) => a + b, 0) / this.energyHistory.length;
+    this.smoothedEnergy = this.smoothedEnergy * 0.8 + bassEnergy * 0.2;
+    const threshold = avgEnergy * (1 + this.beatConfig.sensitivity * 2) + this.beatConfig.energyThreshold;
+    const timeSinceLastBeat = currentTimeMs - this.lastBeatTime;
+    if (bassEnergy > threshold && timeSinceLastBeat > this.beatConfig.minInterval) {
+      const bpm = this.estimateBPM();
+      const strength = Math.min(1, (bassEnergy - avgEnergy) / Math.max(avgEnergy, 0.01));
+      const beat = {
+        timestamp: currentTimeMs,
+        energy: bassEnergy,
+        bpm,
+        strength
+      };
+      this.beatHistory.push(beat);
+      if (this.beatHistory.length > 20) this.beatHistory.shift();
+      this.lastBeatTime = currentTimeMs;
+    }
+  }
+  estimateBPM() {
+    if (this.beatHistory.length < 2) return 0;
+    const intervals = [];
+    for (let i = 1; i < this.beatHistory.length; i++) {
+      intervals.push(this.beatHistory[i].timestamp - this.beatHistory[i - 1].timestamp);
+    }
+    const avgInterval = intervals.reduce((a, b) => a + b, 0) / intervals.length;
+    return avgInterval > 0 ? 6e4 / avgInterval : 0;
+  }
+  // ---------------------------------------------------------------------------
+  // Queries
+  // ---------------------------------------------------------------------------
+  getSpectrum() {
+    return this.currentSpectrum;
+  }
+  getBands() {
+    return this.bands.map((b) => ({ ...b }));
+  }
+  getBandEnergy(bandName) {
+    return this.bands.find((b) => b.name === bandName)?.energy ?? 0;
+  }
+  getLoudness() {
+    return { ...this.loudness };
+  }
+  getBeats() {
+    return [...this.beatHistory];
+  }
+  getLastBeat() {
+    return this.beatHistory.length > 0 ? this.beatHistory[this.beatHistory.length - 1] : null;
+  }
+  getEstimatedBPM() {
+    return this.estimateBPM();
+  }
+  getSmoothedEnergy() {
+    return this.smoothedEnergy;
+  }
+  /**
+   * Get a normalized 0-1 value for audio-reactive use.
+   * Combines bass energy with beat strength.
+   */
+  getReactiveValue() {
+    const bass = this.getBandEnergy("bass");
+    const lastBeat = this.getLastBeat();
+    const beatBoost = lastBeat ? lastBeat.strength * 0.3 : 0;
+    return Math.min(1, bass + beatBoost);
+  }
+  reset() {
+    this.currentSpectrum = null;
+    this.bands = DEFAULT_BANDS.map((b) => ({ ...b }));
+    this.beatHistory = [];
+    this.energyHistory = [];
+    this.smoothedEnergy = 0;
+    this.lastBeatTime = 0;
+    this.loudness = { rms: 0, peak: 0, lufs: -100, dynamicRange: 0 };
+  }
+};
+
+// src/audio/AudioDiffraction.ts
+var AudioDiffractionSystem = class {
+  config = {
+    enabled: true,
+    maxPaths: 2,
+    // Compute up to 2 diffraction paths
+    minDiffractionGain: 0.01,
+    // Ignore paths with <1% contribution
+    frequency: 1e3,
+    // 1kHz reference frequency
+    speedOfSound: 343
+    // m/s at 20°C
+  };
+  edgeProvider = null;
+  losProvider = null;
+  cache = /* @__PURE__ */ new Map();
+  // ---------------------------------------------------------------------------
+  // Configuration
+  // ---------------------------------------------------------------------------
+  setConfig(config) {
+    this.config = { ...this.config, ...config };
+  }
+  getConfig() {
+    return { ...this.config };
+  }
+  setEdgeDetectionProvider(provider) {
+    this.edgeProvider = provider;
+  }
+  setLineOfSightProvider(provider) {
+    this.losProvider = provider;
+  }
+  // ---------------------------------------------------------------------------
+  // Diffraction Computation
+  // ---------------------------------------------------------------------------
+  /**
+   * Compute diffraction paths between source and listener.
+   * Returns all valid diffraction paths sorted by coefficient (strongest first).
+   */
+  computeDiffraction(sourcePos, listenerPos, sourceId) {
+    if (!this.config.enabled || !this.edgeProvider || !this.losProvider) {
+      return {
+        sourceId,
+        hasDiffraction: false,
+        paths: [],
+        combinedCoefficient: 0,
+        volumeMultiplier: 1
+      };
+    }
+    const hasDirectPath = this.losProvider(sourcePos, listenerPos);
+    if (hasDirectPath) {
+      const result2 = {
+        sourceId,
+        hasDiffraction: false,
+        paths: [],
+        combinedCoefficient: 0,
+        volumeMultiplier: 1
+      };
+      this.cache.set(sourceId, result2);
+      return result2;
+    }
+    const edges = this.edgeProvider(sourcePos, listenerPos);
+    const paths = [];
+    for (const edge of edges) {
+      const path = this.computeEdgeDiffraction(edge, sourcePos, listenerPos);
+      if (path && path.diffractionCoefficient >= this.config.minDiffractionGain) {
+        paths.push(path);
+      }
+    }
+    paths.sort((a, b) => b.diffractionCoefficient - a.diffractionCoefficient);
+    const validPaths = paths.slice(0, this.config.maxPaths);
+    const combinedCoefficient = this.combineDiffractionPaths(validPaths);
+    const result = {
+      sourceId,
+      hasDiffraction: validPaths.length > 0,
+      paths: validPaths,
+      combinedCoefficient,
+      volumeMultiplier: combinedCoefficient
+    };
+    this.cache.set(sourceId, result);
+    return result;
+  }
+  /**
+   * Compute diffraction for a specific edge.
+   * Returns null if edge is not valid for diffraction.
+   */
+  computeEdgeDiffraction(edge, sourcePos, listenerPos) {
+    if (!this.losProvider) return null;
+    const edgePoint = this.findDiffractionPoint(edge, sourcePos, listenerPos);
+    const sourceToEdge = this.losProvider(sourcePos, edgePoint);
+    const edgeToListener = this.losProvider(edgePoint, listenerPos);
+    if (!sourceToEdge || !edgeToListener) {
+      return null;
+    }
+    const d1 = this.distance3D(sourcePos, edgePoint);
+    const d2 = this.distance3D(edgePoint, listenerPos);
+    const totalDistance = d1 + d2;
+    const directDistance = this.distance3D(sourcePos, listenerPos);
+    const pathDifference = totalDistance - directDistance;
+    const angle = this.calculateDiffractionAngle(sourcePos, edgePoint, listenerPos);
+    const coefficient = this.calculateFresnelCoefficient(pathDifference, angle);
+    return {
+      edgeId: edge.id,
+      diffractionPoint: edgePoint,
+      totalDistance,
+      directDistance,
+      pathDifference,
+      diffractionCoefficient: coefficient,
+      angle
+    };
+  }
+  /**
+   * Find the optimal diffraction point on an edge.
+   * Uses closest point on line segment to the midpoint between source and listener.
+   */
+  findDiffractionPoint(edge, sourcePos, listenerPos) {
+    const midpoint = {
+      x: (sourcePos.x + listenerPos.x) / 2,
+      y: (sourcePos.y + listenerPos.y) / 2,
+      z: (sourcePos.z + listenerPos.z) / 2
+    };
+    return this.closestPointOnSegment(edge.point1, edge.point2, midpoint);
+  }
+  /**
+   * Calculate the diffraction angle in radians.
+   * This is the angle between source->edge and edge->listener vectors.
+   */
+  calculateDiffractionAngle(sourcePos, edgePoint, listenerPos) {
+    const v1 = {
+      x: sourcePos.x - edgePoint.x,
+      y: sourcePos.y - edgePoint.y,
+      z: sourcePos.z - edgePoint.z
+    };
+    const v2 = {
+      x: listenerPos.x - edgePoint.x,
+      y: listenerPos.y - edgePoint.y,
+      z: listenerPos.z - edgePoint.z
+    };
+    const len1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y + v1.z * v1.z);
+    const len2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y + v2.z * v2.z);
+    if (len1 === 0 || len2 === 0) return 0;
+    v1.x /= len1;
+    v1.y /= len1;
+    v1.z /= len1;
+    v2.x /= len2;
+    v2.y /= len2;
+    v2.z /= len2;
+    const dot = v1.x * v2.x + v1.y * v2.y + v1.z * v2.z;
+    const clampedDot = Math.max(-1, Math.min(1, dot));
+    return Math.acos(clampedDot);
+  }
+  /**
+   * 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)
+   */
+  calculateFresnelCoefficient(pathDifference, angle) {
+    const wavelength = this.config.speedOfSound / this.config.frequency;
+    const v = Math.sqrt(2 * pathDifference / wavelength);
+    let coefficient;
+    if (v <= -1) {
+      coefficient = 1;
+    } else if (v >= 1) {
+      coefficient = 0.5 / (v * v);
+    } else {
+      coefficient = 0.5 * (1 - v);
+    }
+    const angleFactor = Math.sin(angle / 2);
+    coefficient *= angleFactor;
+    return Math.max(0, Math.min(1, coefficient));
+  }
+  /**
+   * Combine multiple diffraction paths using energy-based summation.
+   * Paths contribute independently (incoherent sum).
+   */
+  combineDiffractionPaths(paths) {
+    if (paths.length === 0) return 0;
+    const sumSquared = paths.reduce((sum, path) => {
+      return sum + path.diffractionCoefficient * path.diffractionCoefficient;
+    }, 0);
+    return Math.sqrt(sumSquared);
+  }
+  // ---------------------------------------------------------------------------
+  // Geometry Utilities
+  // ---------------------------------------------------------------------------
+  distance3D(p1, p2) {
+    const dx = p2.x - p1.x;
+    const dy = p2.y - p1.y;
+    const dz = p2.z - p1.z;
+    return Math.sqrt(dx * dx + dy * dy + dz * dz);
+  }
+  /**
+   * Find closest point on line segment AB to point P.
+   */
+  closestPointOnSegment(a, b, p) {
+    const ab = { x: b.x - a.x, y: b.y - a.y, z: b.z - a.z };
+    const ap = { x: p.x - a.x, y: p.y - a.y, z: p.z - a.z };
+    const abLenSq = ab.x * ab.x + ab.y * ab.y + ab.z * ab.z;
+    if (abLenSq === 0) return { ...a };
+    const t = Math.max(0, Math.min(1, (ap.x * ab.x + ap.y * ab.y + ap.z * ab.z) / abLenSq));
+    return {
+      x: a.x + t * ab.x,
+      y: a.y + t * ab.y,
+      z: a.z + t * ab.z
+    };
+  }
+  // ---------------------------------------------------------------------------
+  // Cache Management
+  // ---------------------------------------------------------------------------
+  getCachedResult(sourceId) {
+    return this.cache.get(sourceId);
+  }
+  clearCache() {
+    this.cache.clear();
+  }
+  // ---------------------------------------------------------------------------
+  // Integration Helpers
+  // ---------------------------------------------------------------------------
+  /**
+   * Get volume multiplier for a source based on diffraction.
+   * Returns 1.0 if direct path exists, otherwise returns diffraction coefficient.
+   */
+  getVolumeMultiplier(sourceId) {
+    const result = this.cache.get(sourceId);
+    return result?.volumeMultiplier ?? 1;
+  }
+  /**
+   * Check if a source has active diffraction paths.
+   */
+  hasDiffraction(sourceId) {
+    const result = this.cache.get(sourceId);
+    return result?.hasDiffraction ?? false;
+  }
+  /**
+   * Get all diffraction paths for a source.
+   */
+  getDiffractionPaths(sourceId) {
+    const result = this.cache.get(sourceId);
+    return result?.paths ?? [];
+  }
+};
+
+// src/audio/AudioDynamics.ts
+var AudioDynamics = class {
+  compressor;
+  gate;
+  gainReduction = 0;
+  gateOpen = false;
+  envelope = 0;
+  sidechainLevel = 0;
+  ducking = false;
+  duckAmount = 0;
+  // dB
+  constructor() {
+    this.compressor = { threshold: -20, ratio: 4, attack: 3e-3, release: 0.1, makeup: 0, knee: 6 };
+    this.gate = { threshold: -40, attack: 1e-3, release: 0.05, range: -80 };
+  }
+  // ---------------------------------------------------------------------------
+  // Configuration
+  // ---------------------------------------------------------------------------
+  setCompressor(config) {
+    Object.assign(this.compressor, config);
+  }
+  setGate(config) {
+    Object.assign(this.gate, config);
+  }
+  getCompressor() {
+    return { ...this.compressor };
+  }
+  // ---------------------------------------------------------------------------
+  // Processing
+  // ---------------------------------------------------------------------------
+  processCompressor(inputDb) {
+    const c = this.compressor;
+    let outputDb;
+    if (inputDb <= c.threshold - c.knee / 2) {
+      outputDb = inputDb;
+    } else if (inputDb >= c.threshold + c.knee / 2) {
+      outputDb = c.threshold + (inputDb - c.threshold) / c.ratio;
+    } else {
+      const x = inputDb - c.threshold + c.knee / 2;
+      outputDb = inputDb + (1 / c.ratio - 1) * (x * x) / (2 * c.knee);
+    }
+    this.gainReduction = inputDb - outputDb;
+    return outputDb + c.makeup;
+  }
+  processGate(inputDb, dt) {
+    const g = this.gate;
+    if (inputDb > g.threshold) {
+      this.envelope = Math.min(1, this.envelope + dt / g.attack);
+      this.gateOpen = true;
+    } else {
+      this.envelope = Math.max(0, this.envelope - dt / g.release);
+      if (this.envelope <= 0) this.gateOpen = false;
+    }
+    const attenuation = g.range * (1 - this.envelope);
+    return inputDb + attenuation;
+  }
+  // ---------------------------------------------------------------------------
+  // Sidechain Ducking
+  // ---------------------------------------------------------------------------
+  setSidechainLevel(db) {
+    this.sidechainLevel = db;
+  }
+  processDucking(inputDb, threshold, amount) {
+    if (this.sidechainLevel > threshold) {
+      this.ducking = true;
+      this.duckAmount = amount;
+      return inputDb - amount;
+    }
+    this.ducking = false;
+    this.duckAmount = 0;
+    return inputDb;
+  }
+  // ---------------------------------------------------------------------------
+  // Limiter
+  // ---------------------------------------------------------------------------
+  limit(inputDb, ceiling) {
+    return Math.min(inputDb, ceiling);
+  }
+  // ---------------------------------------------------------------------------
+  // Queries
+  // ---------------------------------------------------------------------------
+  getGainReduction() {
+    return this.gainReduction;
+  }
+  isGateOpen() {
+    return this.gateOpen;
+  }
+  isDucking() {
+    return this.ducking;
+  }
+  getDuckAmount() {
+    return this.duckAmount;
+  }
+};
+
+// src/audio/AudioEnvelope.ts
+var AudioEnvelope = class {
+  config;
+  stage = "idle";
+  level = 0;
+  elapsed = 0;
+  curve;
+  constructor(config, curve = "linear") {
+    this.config = { attack: 0.01, decay: 0.1, sustain: 0.7, release: 0.3, ...config };
+    this.curve = curve;
+  }
+  // ---------------------------------------------------------------------------
+  // Gate On/Off
+  // ---------------------------------------------------------------------------
+  noteOn() {
+    this.stage = "attack";
+    this.elapsed = 0;
+  }
+  noteOff() {
+    if (this.stage !== "idle") {
+      this.stage = "release";
+      this.elapsed = 0;
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Process
+  // ---------------------------------------------------------------------------
+  process(dt) {
+    this.elapsed += dt;
+    switch (this.stage) {
+      case "idle":
+        this.level = 0;
+        break;
+      case "attack": {
+        const t = Math.min(1, this.elapsed / this.config.attack);
+        this.level = this.applyCurve(t);
+        if (t >= 1) {
+          this.stage = "decay";
+          this.elapsed = 0;
+        }
+        break;
+      }
+      case "decay": {
+        const t = Math.min(1, this.elapsed / this.config.decay);
+        this.level = 1 - (1 - this.config.sustain) * this.applyCurve(t);
+        if (t >= 1) {
+          this.stage = "sustain";
+          this.elapsed = 0;
+        }
+        break;
+      }
+      case "sustain":
+        this.level = this.config.sustain;
+        break;
+      case "release": {
+        const t = Math.min(1, this.elapsed / this.config.release);
+        this.level = this.config.sustain * (1 - this.applyCurve(t));
+        if (t >= 1) {
+          this.stage = "idle";
+          this.level = 0;
+        }
+        break;
+      }
+    }
+    return this.level;
+  }
+  // ---------------------------------------------------------------------------
+  // Curve Shaping
+  // ---------------------------------------------------------------------------
+  applyCurve(t) {
+    switch (this.curve) {
+      case "linear":
+        return t;
+      case "exponential":
+        return t * t;
+      case "logarithmic":
+        return Math.sqrt(t);
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Queries
+  // ---------------------------------------------------------------------------
+  getLevel() {
+    return this.level;
+  }
+  getStage() {
+    return this.stage;
+  }
+  setConfig(config) {
+    Object.assign(this.config, config);
+  }
+  getConfig() {
+    return { ...this.config };
+  }
+  isActive() {
+    return this.stage !== "idle";
+  }
+};
+
+// src/audio/AudioFilter.ts
+var AudioFilter = class {
+  bands = /* @__PURE__ */ new Map();
+  // ---------------------------------------------------------------------------
+  // Band Management
+  // ---------------------------------------------------------------------------
+  addBand(id, config) {
+    this.bands.set(id, { id, config, enabled: true });
+  }
+  removeBand(id) {
+    this.bands.delete(id);
+  }
+  setBandEnabled(id, enabled) {
+    const band = this.bands.get(id);
+    if (band) band.enabled = enabled;
+  }
+  setFrequency(id, freq) {
+    const band = this.bands.get(id);
+    if (band) band.config.frequency = Math.max(20, Math.min(2e4, freq));
+  }
+  setQ(id, q) {
+    const band = this.bands.get(id);
+    if (band) band.config.q = Math.max(0.1, Math.min(30, q));
+  }
+  setGain(id, gain) {
+    const band = this.bands.get(id);
+    if (band) band.config.gain = Math.max(-24, Math.min(24, gain));
+  }
+  // ---------------------------------------------------------------------------
+  // Processing (simplified magnitude response)
+  // ---------------------------------------------------------------------------
+  getResponse(frequency) {
+    let totalGain = 0;
+    for (const band of this.bands.values()) {
+      if (!band.enabled) continue;
+      totalGain += this.computeBandResponse(band.config, frequency);
+    }
+    return totalGain;
+  }
+  computeBandResponse(config, freq) {
+    const ratio = freq / config.frequency;
+    switch (config.type) {
+      case "lowpass":
+        return ratio <= 1 ? 0 : -12 * Math.log2(ratio) * config.q;
+      case "highpass":
+        return ratio >= 1 ? 0 : -12 * Math.log2(1 / ratio) * config.q;
+      case "bandpass": {
+        const bw = config.frequency / config.q;
+        const dist = Math.abs(freq - config.frequency);
+        return dist <= bw / 2 ? 0 : -(dist / bw) * 6;
+      }
+      case "notch": {
+        const bw = config.frequency / config.q;
+        const dist = Math.abs(freq - config.frequency);
+        return dist <= bw / 2 ? -config.gain : 0;
+      }
+      case "peaking": {
+        const bw = config.frequency / config.q;
+        const dist = Math.abs(freq - config.frequency);
+        if (dist >= bw) return 0;
+        return config.gain * (1 - dist / bw);
+      }
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Queries
+  // ---------------------------------------------------------------------------
+  getBand(id) {
+    return this.bands.get(id);
+  }
+  getBandCount() {
+    return this.bands.size;
+  }
+  getEnabledBandCount() {
+    return [...this.bands.values()].filter((b) => b.enabled).length;
+  }
+};
+
+// src/audio/AudioGraph.ts
+var _nodeId = 0;
+var _connId = 0;
+var AudioGraph = class {
+  nodes = /* @__PURE__ */ new Map();
+  connections = /* @__PURE__ */ new Map();
+  automations = [];
+  processingOrder = [];
+  dirty = true;
+  // ---------------------------------------------------------------------------
+  // Node Management
+  // ---------------------------------------------------------------------------
+  addNode(type, params) {
+    const id = `anode_${_nodeId++}`;
+    const node = {
+      id,
+      type,
+      params: new Map(Object.entries(params ?? {})),
+      inputs: [],
+      outputs: [],
+      bypassed: false
+    };
+    this.nodes.set(id, node);
+    this.dirty = true;
+    switch (type) {
+      case "gain":
+        if (!node.params.has("gain")) node.params.set("gain", 1);
+        break;
+      case "filter":
+        if (!node.params.has("cutoff")) node.params.set("cutoff", 1e3);
+        break;
+      case "delay":
+        if (!node.params.has("time")) node.params.set("time", 0.5);
+        break;
+      case "reverb":
+        if (!node.params.has("decay")) node.params.set("decay", 1.5);
+        break;
+      case "compressor":
+        if (!node.params.has("threshold")) node.params.set("threshold", -24);
+        break;
+    }
+    return node;
+  }
+  removeNode(id) {
+    for (const [connId, conn] of this.connections) {
+      if (conn.sourceId === id || conn.targetId === id) {
+        this.disconnect(connId);
+      }
+    }
+    this.dirty = true;
+    return this.nodes.delete(id);
+  }
+  // ---------------------------------------------------------------------------
+  // Connections
+  // ---------------------------------------------------------------------------
+  connect(sourceId, targetId, sourcePort = 0, targetPort = 0) {
+    const source = this.nodes.get(sourceId);
+    const target = this.nodes.get(targetId);
+    if (!source || !target) return null;
+    const id = `conn_${_connId++}`;
+    this.connections.set(id, { id, sourceId, targetId, sourcePort, targetPort });
+    source.outputs.push(targetId);
+    target.inputs.push(sourceId);
+    this.dirty = true;
+    return id;
+  }
+  disconnect(connId) {
+    const conn = this.connections.get(connId);
+    if (!conn) return false;
+    const source = this.nodes.get(conn.sourceId);
+    const target = this.nodes.get(conn.targetId);
+    if (source) source.outputs = source.outputs.filter((id) => id !== conn.targetId);
+    if (target) target.inputs = target.inputs.filter((id) => id !== conn.sourceId);
+    this.dirty = true;
+    return this.connections.delete(connId);
+  }
+  // ---------------------------------------------------------------------------
+  // Automation
+  // ---------------------------------------------------------------------------
+  automate(nodeId, paramName, points) {
+    this.automations.push({
+      nodeId,
+      paramName,
+      points: [...points].sort((a, b) => a.time - b.time)
+    });
+  }
+  applyAutomation(time) {
+    for (const auto of this.automations) {
+      const node = this.nodes.get(auto.nodeId);
+      if (!node) continue;
+      const value = this.evaluateAutomation(auto.points, time);
+      if (value !== null) node.params.set(auto.paramName, value);
+    }
+  }
+  evaluateAutomation(points, time) {
+    if (points.length === 0) return null;
+    if (time <= points[0].time) return points[0].value;
+    if (time >= points[points.length - 1].time) return points[points.length - 1].value;
+    for (let i = 0; i < points.length - 1; i++) {
+      if (time >= points[i].time && time < points[i + 1].time) {
+        const t = (time - points[i].time) / (points[i + 1].time - points[i].time);
+        switch (points[i + 1].curve) {
+          case "step":
+            return points[i].value;
+          case "exponential":
+            return points[i].value * Math.pow(points[i + 1].value / points[i].value, t);
+          case "linear":
+          default:
+            return points[i].value + (points[i + 1].value - points[i].value) * t;
+        }
+      }
+    }
+    return null;
+  }
+  // ---------------------------------------------------------------------------
+  // Processing Order (topological sort)
+  // ---------------------------------------------------------------------------
+  getProcessingOrder() {
+    if (!this.dirty) return [...this.processingOrder];
+    const visited = /* @__PURE__ */ new Set();
+    const order = [];
+    const visit = (id) => {
+      if (visited.has(id)) return;
+      visited.add(id);
+      const node = this.nodes.get(id);
+      if (node) for (const inputId of node.inputs) visit(inputId);
+      order.push(id);
+    };
+    for (const id of this.nodes.keys()) visit(id);
+    this.processingOrder = order;
+    this.dirty = false;
+    return [...order];
+  }
+  // ---------------------------------------------------------------------------
+  // Node Controls
+  // ---------------------------------------------------------------------------
+  setParam(nodeId, param, value) {
+    this.nodes.get(nodeId)?.params.set(param, value);
+  }
+  getParam(nodeId, param) {
+    return this.nodes.get(nodeId)?.params.get(param);
+  }
+  bypass(nodeId, bypassed) {
+    const node = this.nodes.get(nodeId);
+    if (node) node.bypassed = bypassed;
+  }
+  // ---------------------------------------------------------------------------
+  // Queries
+  // ---------------------------------------------------------------------------
+  getNode(id) {
+    return this.nodes.get(id);
+  }
+  getNodeCount() {
+    return this.nodes.size;
+  }
+  getConnectionCount() {
+    return this.connections.size;
+  }
+};
+
+// src/audio/AudioMixer.ts
+var AudioMixer = class {
+  channels = /* @__PURE__ */ new Map();
+  masterVolume = 1;
+  masterMuted = false;
+  // Advanced features
+  duckingStates = /* @__PURE__ */ new Map();
+  sidechains = /* @__PURE__ */ new Map();
+  activeSources = /* @__PURE__ */ new Map();
+  voiceStealingStrategy = { mode: "oldest" };
+  currentContext = null;
+  constructor() {
+    this.createChannel("master", 1, 10, 0);
+    this.createChannel("sfx", 1, 5, 32);
+    this.createChannel("music", 0.5, 7, 4);
+    this.createChannel("ambient", 0.6, 4, 16);
+    this.createChannel("ui", 0.8, 8, 8);
+    this.createChannel("voice", 1, 10, 8);
+  }
+  /**
+   * Create or update a channel.
+   */
+  createChannel(name, volume = 1, priority = 5, maxVoices = 0) {
+    const existing = this.channels.get(name);
+    this.channels.set(name, {
+      name,
+      volume,
+      muted: existing?.muted ?? false,
+      priority,
+      maxVoices,
+      currentVoices: existing?.currentVoices ?? 0
+    });
+  }
+  /**
+   * Set channel volume.
+   */
+  setChannelVolume(name, volume) {
+    const ch = this.channels.get(name);
+    if (ch) ch.volume = Math.max(0, Math.min(1, volume));
+  }
+  /**
+   * Get channel volume.
+   */
+  getChannelVolume(name) {
+    return this.channels.get(name)?.volume ?? 1;
+  }
+  /**
+   * Mute/unmute a channel.
+   */
+  setChannelMuted(name, muted) {
+    const ch = this.channels.get(name);
+    if (ch) ch.muted = muted;
+  }
+  /**
+   * Check if a channel is muted.
+   */
+  isChannelMuted(name) {
+    return this.channels.get(name)?.muted ?? false;
+  }
+  /**
+   * Set master volume.
+   */
+  setMasterVolume(volume) {
+    this.masterVolume = Math.max(0, Math.min(1, volume));
+  }
+  getMasterVolume() {
+    return this.masterVolume;
+  }
+  /**
+   * Mute/unmute all audio.
+   */
+  setMasterMuted(muted) {
+    this.masterMuted = muted;
+  }
+  isMasterMuted() {
+    return this.masterMuted;
+  }
+  /**
+   * List all channels.
+   */
+  getChannels() {
+    return Array.from(this.channels.values());
+  }
+  /**
+   * Mute a group of channels.
+   */
+  muteGroup(channelNames) {
+    for (const name of channelNames) {
+      this.setChannelMuted(name, true);
+    }
+  }
+  /**
+   * Unmute a group of channels.
+   */
+  unmuteGroup(channelNames) {
+    for (const name of channelNames) {
+      this.setChannelMuted(name, false);
+    }
+  }
+  // =========================================================================
+  // DUCKING SYSTEM
+  // =========================================================================
+  /**
+   * Configure ducking for a channel.
+   * Example: Duck music and ambient when voice plays.
+   */
+  configureDucking(config) {
+    const duckId = `${config.triggerChannel}_ducks_${config.targetChannels.join("_")}`;
+    this.duckingStates.set(duckId, {
+      config,
+      isActive: false,
+      currentDuckAmount: 0,
+      targetDuckAmount: 0
+    });
+  }
+  /**
+   * Remove ducking configuration.
+   */
+  removeDucking(triggerChannel, targetChannels) {
+    const duckId = `${triggerChannel}_ducks_${targetChannels.join("_")}`;
+    this.duckingStates.delete(duckId);
+  }
+  /**
+   * Update ducking state. Call every frame with delta time.
+   */
+  updateDucking(delta) {
+    for (const [_id, state] of this.duckingStates) {
+      if (!state.config.enabled) continue;
+      const triggerActive = this.isChannelActiveAboveThreshold(
+        state.config.triggerChannel,
+        state.config.threshold
+      );
+      state.targetDuckAmount = triggerActive ? state.config.ratio : 0;
+      const speed = triggerActive ? 1 / state.config.attackTime * delta : 1 / state.config.releaseTime * delta;
+      if (state.currentDuckAmount < state.targetDuckAmount) {
+        state.currentDuckAmount = Math.min(state.currentDuckAmount + speed, state.targetDuckAmount);
+      } else if (state.currentDuckAmount > state.targetDuckAmount) {
+        state.currentDuckAmount = Math.max(state.currentDuckAmount - speed, state.targetDuckAmount);
+      }
+      state.isActive = state.currentDuckAmount > 0.01;
+      if (state.isActive) {
+        for (const targetChannel of state.config.targetChannels) {
+          const ch = this.channels.get(targetChannel);
+          if (ch) {
+          }
+        }
+      }
+    }
+  }
+  /**
+   * Get ducking attenuation for a channel (0-1, where 0 = no attenuation, 1 = full duck).
+   */
+  getDuckingAttenuation(channelName) {
+    let maxDuck = 0;
+    for (const state of this.duckingStates.values()) {
+      if (!state.config.enabled || !state.isActive) continue;
+      if (state.config.targetChannels.includes(channelName)) {
+        maxDuck = Math.max(maxDuck, state.currentDuckAmount);
+      }
+    }
+    return maxDuck;
+  }
+  /**
+   * Check if a channel has active sources above a dB threshold.
+   */
+  isChannelActiveAboveThreshold(channelName, thresholdDb) {
+    const sources = Array.from(this.activeSources.values()).filter(
+      (s) => s.channel === channelName
+    );
+    if (sources.length === 0) return false;
+    const maxVolume = Math.max(...sources.map((s) => s.volume));
+    const db = 20 * Math.log10(maxVolume + 1e-4);
+    return db >= thresholdDb;
+  }
+  // =========================================================================
+  // SIDECHAIN COMPRESSION
+  // =========================================================================
+  /**
+   * Configure sidechain compression.
+   * Example: Compress SFX when music peaks.
+   */
+  configureSidechain(config) {
+    const scId = `${config.sourceChannel}_to_${config.targetChannel}`;
+    this.sidechains.set(scId, config);
+  }
+  /**
+   * Remove sidechain configuration.
+   */
+  removeSidechain(sourceChannel, targetChannel) {
+    const scId = `${sourceChannel}_to_${targetChannel}`;
+    this.sidechains.delete(scId);
+  }
+  // =========================================================================
+  // VOICE STEALING
+  // =========================================================================
+  /**
+   * Set voice stealing strategy.
+   */
+  setVoiceStealingStrategy(strategy) {
+    this.voiceStealingStrategy = strategy;
+  }
+  /**
+   * Register a new audio source. Returns true if allowed, false if stolen.
+   */
+  registerSource(source) {
+    const ch = this.channels.get(source.channel);
+    if (!ch) return false;
+    if (ch.maxVoices > 0 && ch.currentVoices >= ch.maxVoices) {
+      const stolen = this.stealVoice(source.channel, source.priority);
+      if (!stolen) return false;
+    }
+    this.activeSources.set(source.id, source);
+    ch.currentVoices++;
+    return true;
+  }
+  /**
+   * Unregister an audio source.
+   */
+  unregisterSource(sourceId) {
+    const source = this.activeSources.get(sourceId);
+    if (!source) return;
+    const ch = this.channels.get(source.channel);
+    if (ch) {
+      ch.currentVoices = Math.max(0, ch.currentVoices - 1);
+    }
+    this.activeSources.delete(sourceId);
+  }
+  /**
+   * Steal a voice from a channel based on strategy.
+   * Returns the ID of the stolen source, or null if no voice could be stolen.
+   */
+  stealVoice(channelName, newPriority) {
+    const sources = Array.from(this.activeSources.values()).filter(
+      (s) => s.channel === channelName
+    );
+    if (sources.length === 0) return null;
+    let victimSource = null;
+    switch (this.voiceStealingStrategy.mode) {
+      case "oldest":
+        victimSource = sources.reduce((oldest, s) => s.startTime < oldest.startTime ? s : oldest);
+        break;
+      case "quietest":
+        victimSource = sources.reduce((quietest, s) => s.volume < quietest.volume ? s : quietest);
+        break;
+      case "lowest_priority":
+        victimSource = sources.reduce((lowest, s) => s.priority < lowest.priority ? s : lowest);
+        if (victimSource.priority >= newPriority) return null;
+        break;
+    }
+    if (victimSource) {
+      this.unregisterSource(victimSource.id);
+      return victimSource.id;
+    }
+    return null;
+  }
+  /**
+   * Get active source count for a channel.
+   */
+  getChannelVoiceCount(channelName) {
+    return this.channels.get(channelName)?.currentVoices ?? 0;
+  }
+  /**
+   * Get all active sources for a channel.
+   */
+  getChannelSources(channelName) {
+    return Array.from(this.activeSources.values()).filter((s) => s.channel === channelName);
+  }
+  // =========================================================================
+  // CONTEXT-AWARE MIXING
+  // =========================================================================
+  /**
+   * Set mixing context (e.g., 'combat', 'dialogue', 'ambient').
+   * Automatically adjusts channel volumes based on context.
+   */
+  setMixingContext(context) {
+    this.currentContext = context;
+    if (context) {
+      for (const [channelName, volume] of Object.entries(context.channelVolumes)) {
+        this.setChannelVolume(channelName, volume);
+      }
+    }
+  }
+  /**
+   * Get current mixing context.
+   */
+  getMixingContext() {
+    return this.currentContext;
+  }
+  // =========================================================================
+  // ENHANCED VOLUME CALCULATION
+  // =========================================================================
+  /**
+   * Compute the effective volume for a source on a given channel.
+   * Now includes ducking, sidechain, and context-aware adjustments.
+   */
+  getEffectiveVolume(channelName, sourceVolume) {
+    if (this.masterMuted) return 0;
+    const ch = this.channels.get(channelName);
+    if (!ch || ch.muted) return 0;
+    let effectiveVolume = sourceVolume * ch.volume * this.masterVolume;
+    const duckAmount = this.getDuckingAttenuation(channelName);
+    if (duckAmount > 0) {
+      effectiveVolume *= 1 - duckAmount;
+    }
+    return effectiveVolume;
+  }
+};
+
+// src/audio/AudioOcclusion.ts
+var OCCLUSION_MATERIALS = {
+  glass: {
+    id: "glass",
+    name: "Glass",
+    absorptionCoefficient: 0.1,
+    transmissionLoss: 6,
+    frequencyAbsorption: {
+      125: 0.35,
+      250: 0.25,
+      500: 0.18,
+      1e3: 0.12,
+      2e3: 0.07,
+      4e3: 0.04,
+      8e3: 0.03
+    }
+  },
+  wood: {
+    id: "wood",
+    name: "Wood",
+    absorptionCoefficient: 0.3,
+    transmissionLoss: 12,
+    frequencyAbsorption: {
+      125: 0.15,
+      250: 0.11,
+      500: 0.1,
+      1e3: 0.07,
+      2e3: 0.06,
+      4e3: 0.07,
+      8e3: 0.09
+    }
+  },
+  drywall: {
+    id: "drywall",
+    name: "Drywall",
+    absorptionCoefficient: 0.2,
+    transmissionLoss: 10,
+    frequencyAbsorption: {
+      125: 0.29,
+      250: 0.1,
+      500: 0.05,
+      1e3: 0.04,
+      2e3: 0.07,
+      4e3: 0.09,
+      8e3: 0.08
+    }
+  },
+  brick: {
+    id: "brick",
+    name: "Brick",
+    absorptionCoefficient: 0.4,
+    transmissionLoss: 20,
+    frequencyAbsorption: {
+      125: 0.03,
+      250: 0.03,
+      500: 0.03,
+      1e3: 0.04,
+      2e3: 0.05,
+      4e3: 0.07,
+      8e3: 0.07
+    }
+  },
+  concrete: {
+    id: "concrete",
+    name: "Concrete",
+    absorptionCoefficient: 0.5,
+    transmissionLoss: 30,
+    frequencyAbsorption: {
+      125: 0.01,
+      250: 0.01,
+      500: 0.02,
+      1e3: 0.02,
+      2e3: 0.02,
+      4e3: 0.03,
+      8e3: 0.04
+    }
+  },
+  metal: {
+    id: "metal",
+    name: "Metal",
+    absorptionCoefficient: 0.05,
+    transmissionLoss: 35,
+    frequencyAbsorption: {
+      125: 0.01,
+      250: 0.01,
+      500: 0.01,
+      1e3: 0.01,
+      2e3: 0.02,
+      4e3: 0.02,
+      8e3: 0.03
+    }
+  },
+  fabric: {
+    id: "fabric",
+    name: "Fabric",
+    absorptionCoefficient: 0.7,
+    transmissionLoss: 3,
+    frequencyAbsorption: {
+      125: 0.03,
+      250: 0.09,
+      500: 0.2,
+      1e3: 0.54,
+      2e3: 0.7,
+      4e3: 0.72,
+      8e3: 0.75
+    }
+  },
+  water: {
+    id: "water",
+    name: "Water",
+    absorptionCoefficient: 0.02,
+    transmissionLoss: 8,
+    frequencyAbsorption: {
+      125: 0.01,
+      250: 0.01,
+      500: 0.01,
+      1e3: 0.01,
+      2e3: 0.02,
+      4e3: 0.03,
+      8e3: 0.04
+    }
+  }
+};
+var AudioOcclusionSystem = class {
+  materials = /* @__PURE__ */ new Map();
+  raycastProvider = null;
+  maxTransmissionLoss = 60;
+  // dB cap
+  cache = /* @__PURE__ */ new Map();
+  enableFrequencyFiltering = true;
+  // Enable frequency-dependent occlusion
+  constructor() {
+    for (const mat of Object.values(OCCLUSION_MATERIALS)) {
+      this.materials.set(mat.id, mat);
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Configuration
+  // ---------------------------------------------------------------------------
+  setRaycastProvider(provider) {
+    this.raycastProvider = provider;
+  }
+  registerMaterial(material) {
+    this.materials.set(material.id, material);
+  }
+  getMaterial(id) {
+    return this.materials.get(id);
+  }
+  setMaxTransmissionLoss(db) {
+    this.maxTransmissionLoss = Math.max(0, db);
+  }
+  setFrequencyFilteringEnabled(enabled) {
+    this.enableFrequencyFiltering = enabled;
+  }
+  isFrequencyFilteringEnabled() {
+    return this.enableFrequencyFiltering;
+  }
+  // ---------------------------------------------------------------------------
+  // Computation
+  // ---------------------------------------------------------------------------
+  /**
+   * 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, sourcePos, sourceId) {
+    if (!this.raycastProvider) {
+      return {
+        sourceId,
+        occluded: false,
+        occlusionFactor: 0,
+        hitCount: 0,
+        totalTransmissionLoss: 0,
+        materials: [],
+        lowPassCutoff: 22e3,
+        frequencyAttenuation: {}
+      };
+    }
+    const dx = sourcePos.x - listenPos.x;
+    const dy = sourcePos.y - listenPos.y;
+    const dz = sourcePos.z - listenPos.z;
+    const dist = Math.sqrt(dx * dx + dy * dy + dz * dz);
+    if (dist === 0) {
+      return {
+        sourceId,
+        occluded: false,
+        occlusionFactor: 0,
+        hitCount: 0,
+        totalTransmissionLoss: 0,
+        materials: [],
+        lowPassCutoff: 22e3,
+        frequencyAttenuation: {}
+      };
+    }
+    const ray = {
+      origin: { ...listenPos },
+      direction: { x: dx / dist, y: dy / dist, z: dz / dist },
+      maxDistance: dist
+    };
+    const hits = this.raycastProvider(ray);
+    if (hits.length === 0) {
+      return {
+        sourceId,
+        occluded: false,
+        occlusionFactor: 0,
+        hitCount: 0,
+        totalTransmissionLoss: 0,
+        materials: [],
+        lowPassCutoff: 22e3,
+        frequencyAttenuation: {}
+      };
+    }
+    let totalLoss = 0;
+    const hitMaterials = [];
+    const frequencyAttenuation = {};
+    const freqBands = [125, 250, 500, 1e3, 2e3, 4e3, 8e3];
+    for (const freq of freqBands) {
+      frequencyAttenuation[freq] = 0;
+    }
+    for (const hit of hits) {
+      const mat = this.materials.get(hit.materialId);
+      if (mat) {
+        totalLoss += mat.transmissionLoss;
+        hitMaterials.push(hit.materialId);
+        if (this.enableFrequencyFiltering && mat.frequencyAbsorption) {
+          for (const freq of freqBands) {
+            const absorp = mat.frequencyAbsorption[freq] || 0;
+            frequencyAttenuation[freq] = Math.min(
+              1,
+              (frequencyAttenuation[freq] || 0) + absorp * hit.thickness
+            );
+          }
+        }
+      }
+    }
+    totalLoss = Math.min(totalLoss, this.maxTransmissionLoss);
+    const factor = totalLoss / this.maxTransmissionLoss;
+    const lowPassCutoff = this.calculateLowPassCutoff(factor, frequencyAttenuation);
+    const result = {
+      sourceId,
+      occluded: totalLoss > 0,
+      occlusionFactor: factor,
+      hitCount: hits.length,
+      totalTransmissionLoss: totalLoss,
+      materials: hitMaterials,
+      lowPassCutoff,
+      frequencyAttenuation: this.enableFrequencyFiltering ? frequencyAttenuation : {}
+    };
+    this.cache.set(sourceId, result);
+    return result;
+  }
+  /**
+   * Compute without raycasting — direct manual hit specification.
+   * Useful for testing or pre-computed occlusion.
+   */
+  computeFromHits(sourceId, hits) {
+    let totalLoss = 0;
+    const hitMaterials = [];
+    for (const hit of hits) {
+      const mat = this.materials.get(hit.materialId);
+      if (mat) {
+        totalLoss += mat.transmissionLoss;
+        hitMaterials.push(hit.materialId);
+      }
+    }
+    totalLoss = Math.min(totalLoss, this.maxTransmissionLoss);
+    const factor = totalLoss / this.maxTransmissionLoss;
+    return {
+      sourceId,
+      occluded: totalLoss > 0,
+      occlusionFactor: factor,
+      hitCount: hits.length,
+      totalTransmissionLoss: totalLoss,
+      materials: hitMaterials,
+      lowPassCutoff: this.calculateLowPassCutoff(factor, {}),
+      frequencyAttenuation: {}
+    };
+  }
+  /**
+   * Get the volume multiplier for a given occlusion factor.
+   * Converts transmission loss to a linear volume reduction.
+   */
+  getVolumeMultiplier(occlusionFactor) {
+    const dbLoss = occlusionFactor * this.maxTransmissionLoss;
+    return Math.pow(10, -dbLoss / 20);
+  }
+  getCachedResult(sourceId) {
+    return this.cache.get(sourceId);
+  }
+  clearCache() {
+    this.cache.clear();
+  }
+  // ---------------------------------------------------------------------------
+  // Frequency-Dependent Occlusion
+  // ---------------------------------------------------------------------------
+  /**
+   * Calculate low-pass filter cutoff frequency based on occlusion.
+   * Returns cutoff in Hz (500Hz fully occluded, 22kHz no occlusion).
+   */
+  calculateLowPassCutoff(occlusionFactor, frequencyAttenuation) {
+    if (!this.enableFrequencyFiltering || Object.keys(frequencyAttenuation).length === 0) {
+      const minCutoff = 500;
+      const maxCutoff = 22e3;
+      return maxCutoff - occlusionFactor * (maxCutoff - minCutoff);
+    }
+    const freqBands = [125, 250, 500, 1e3, 2e3, 4e3, 8e3];
+    for (let i = freqBands.length - 1; i >= 0; i--) {
+      const freq = freqBands[i];
+      const atten = frequencyAttenuation[freq] || 0;
+      if (atten < 0.5) {
+        const nextFreq = i < freqBands.length - 1 ? freqBands[i + 1] : 22e3;
+        return (freq + nextFreq) / 2;
+      }
+    }
+    return 500;
+  }
+  /**
+   * Get frequency attenuation for a specific source.
+   * Returns per-band attenuation (0-1, where 1 = fully absorbed).
+   */
+  getFrequencyAttenuation(sourceId) {
+    const result = this.cache.get(sourceId);
+    return result?.frequencyAttenuation || {};
+  }
+  /**
+   * Get low-pass cutoff for a specific source.
+   */
+  getLowPassCutoff(sourceId) {
+    const result = this.cache.get(sourceId);
+    return result?.lowPassCutoff || 22e3;
+  }
+};
+
+// src/audio/AudioPresets.ts
+var AudioPresets = {
+  /** Close-range UI click/tap */
+  uiClick: {
+    volume: 0.6,
+    spatialize: false,
+    loop: false,
+    channel: "ui",
+    maxDistance: 5
+  },
+  /** UI hover feedback */
+  uiHover: {
+    volume: 0.3,
+    spatialize: false,
+    loop: false,
+    channel: "ui"
+  },
+  /** Ambient environmental loop */
+  ambientLoop: {
+    volume: 0.4,
+    spatialize: false,
+    loop: true,
+    channel: "ambient",
+    maxDistance: 100
+  },
+  /** Spatial object interaction (grab, drop) */
+  objectInteraction: {
+    volume: 0.8,
+    spatialize: true,
+    loop: false,
+    refDistance: 0.5,
+    maxDistance: 10,
+    rolloffFactor: 2,
+    channel: "sfx"
+  },
+  /** Distant environmental sound */
+  distantAmbient: {
+    volume: 0.5,
+    spatialize: true,
+    loop: true,
+    refDistance: 5,
+    maxDistance: 100,
+    rolloffFactor: 0.5,
+    channel: "ambient"
+  },
+  /** Footstep / movement */
+  footstep: {
+    volume: 0.5,
+    spatialize: true,
+    loop: false,
+    refDistance: 1,
+    maxDistance: 15,
+    rolloffFactor: 1.5,
+    channel: "sfx"
+  },
+  /** Alert / notification */
+  notification: {
+    volume: 0.7,
+    spatialize: false,
+    loop: false,
+    channel: "ui"
+  },
+  /** Music background */
+  music: {
+    volume: 0.3,
+    spatialize: false,
+    loop: true,
+    channel: "music"
+  }
+};
+
+// src/audio/AudioTrait.ts
+var nodeAudioSources = /* @__PURE__ */ new Map();
+var sharedAudioEngine = null;
+function setSharedAudioEngine(engine) {
+  sharedAudioEngine = engine;
+}
+function getSharedAudioEngine() {
+  if (!sharedAudioEngine) {
+    sharedAudioEngine = new AudioEngine();
+  }
+  return sharedAudioEngine;
+}
+var defaultConfig = {
+  soundId: "",
+  volume: 1,
+  loop: false,
+  spatialize: true,
+  maxDistance: 50,
+  refDistance: 1,
+  rolloffFactor: 1,
+  channel: "master",
+  autoPlay: true,
+  pitch: 1
+};
+var audioTraitHandler = {
+  name: "audio",
+  defaultConfig,
+  onAttach(node, config, _context) {
+    if (!config.soundId || !config.autoPlay) return;
+    const engine = getSharedAudioEngine();
+    const nodeId = node.id ?? "unknown";
+    const pos = node.properties?.position || {
+      x: 0,
+      y: 0,
+      z: 0
+    };
+    const sourceId = engine.play(config.soundId, {
+      position: pos,
+      volume: config.volume,
+      pitch: config.pitch,
+      loop: config.loop,
+      maxDistance: config.maxDistance,
+      refDistance: config.refDistance,
+      rolloffFactor: config.rolloffFactor,
+      spatialize: config.spatialize,
+      channel: config.channel
+    });
+    nodeAudioSources.set(nodeId, sourceId);
+  },
+  onDetach(node, _config, _context) {
+    const nodeId = node.id ?? "unknown";
+    const sourceId = nodeAudioSources.get(nodeId);
+    if (sourceId) {
+      getSharedAudioEngine().stop(sourceId);
+      nodeAudioSources.delete(nodeId);
+    }
+  },
+  onUpdate(node, _config, _context, _delta) {
+    const nodeId = node.id ?? "unknown";
+    const sourceId = nodeAudioSources.get(nodeId);
+    if (!sourceId) return;
+    const pos = node.properties?.position || {
+      x: 0,
+      y: 0,
+      z: 0
+    };
+    getSharedAudioEngine().setSourcePosition(sourceId, pos);
+  }
+};
+
+// src/audio/MusicGenerator.ts
+var SCALES = {
+  major: [0, 2, 4, 5, 7, 9, 11],
+  minor: [0, 2, 3, 5, 7, 8, 10],
+  pentatonic: [0, 2, 4, 7, 9],
+  blues: [0, 3, 5, 6, 7, 10],
+  dorian: [0, 2, 3, 5, 7, 9, 10],
+  mixolydian: [0, 2, 4, 5, 7, 9, 10]
+};
+var CHORD_INTERVALS = {
+  major: [0, 4, 7],
+  minor: [0, 3, 7],
+  dim: [0, 3, 6],
+  aug: [0, 4, 8],
+  sus2: [0, 2, 7],
+  sus4: [0, 5, 7],
+  "7th": [0, 4, 7, 10]
+};
+var MusicGenerator = class {
+  scale = "major";
+  rootNote = 60;
+  // Middle C
+  bpm = 120;
+  seed = 42;
+  rng;
+  constructor(seed = 42) {
+    this.seed = seed;
+    this.rng = this.createRng(seed);
+  }
+  // ---------------------------------------------------------------------------
+  // Configuration
+  // ---------------------------------------------------------------------------
+  setScale(scale) {
+    this.scale = scale;
+  }
+  setRoot(note) {
+    this.rootNote = note;
+  }
+  setBPM(bpm) {
+    this.bpm = bpm;
+  }
+  getScale() {
+    return this.scale;
+  }
+  getBPM() {
+    return this.bpm;
+  }
+  // ---------------------------------------------------------------------------
+  // Scale Helpers
+  // ---------------------------------------------------------------------------
+  getScaleNotes(octaves = 2) {
+    const intervals = SCALES[this.scale];
+    const notes = [];
+    for (let oct = 0; oct < octaves; oct++) {
+      for (const interval of intervals) {
+        notes.push(this.rootNote + oct * 12 + interval);
+      }
+    }
+    return notes;
+  }
+  isInScale(note) {
+    const relative = ((note - this.rootNote) % 12 + 12) % 12;
+    return SCALES[this.scale].includes(relative);
+  }
+  // ---------------------------------------------------------------------------
+  // Chord Generation
+  // ---------------------------------------------------------------------------
+  generateChord(scaleDegree, quality = "major", duration = 4) {
+    const intervals = SCALES[this.scale];
+    const rootOffset = intervals[(scaleDegree - 1) % intervals.length];
+    const root = this.rootNote + rootOffset;
+    const chordIntervals = CHORD_INTERVALS[quality];
+    const notes = chordIntervals.map((i) => root + i);
+    return { root, quality, notes, duration };
+  }
+  generateProgression(degrees, qualities) {
+    return degrees.map((deg, i) => {
+      const quality = qualities?.[i] ?? "major";
+      return this.generateChord(deg, quality);
+    });
+  }
+  // ---------------------------------------------------------------------------
+  // Rhythm Generation
+  // ---------------------------------------------------------------------------
+  generateRhythm(beats, density = 0.5, subdivision = 4) {
+    const totalSlots = beats * subdivision;
+    const hitSlots = [];
+    for (let i = 0; i < totalSlots; i++) {
+      hitSlots.push(this.rng() < density);
+    }
+    hitSlots[0] = true;
+    return { name: "generated", beats: hitSlots, subdivision, swing: 0 };
+  }
+  // ---------------------------------------------------------------------------
+  // Melody Generation
+  // ---------------------------------------------------------------------------
+  generateMelody(bars, noteDensity = 0.6) {
+    const scaleNotes = this.getScaleNotes(2);
+    const melody = [];
+    const beatsPerBar = 4;
+    const totalBeats = bars * beatsPerBar;
+    let currentTime = 0;
+    let lastNoteIndex = Math.floor(scaleNotes.length / 2);
+    while (currentTime < totalBeats) {
+      if (this.rng() < noteDensity) {
+        const step = this.rng() < 0.7 ? this.rng() < 0.5 ? -1 : 1 : Math.floor(this.rng() * 5) - 2;
+        lastNoteIndex = Math.max(0, Math.min(scaleNotes.length - 1, lastNoteIndex + step));
+        const durations = [0.25, 0.5, 1, 2];
+        const duration = durations[Math.floor(this.rng() * durations.length)];
+        const velocity = 0.5 + this.rng() * 0.5;
+        melody.push({
+          pitch: scaleNotes[lastNoteIndex],
+          duration,
+          velocity,
+          time: currentTime
+        });
+        currentTime += duration;
+      } else {
+        currentTime += 0.5;
+      }
+    }
+    return melody;
+  }
+  // ---------------------------------------------------------------------------
+  // Seeded RNG
+  // ---------------------------------------------------------------------------
+  createRng(seed) {
+    let s = seed;
+    return () => {
+      s = s * 1664525 + 1013904223 & 2147483647;
+      return s / 2147483647;
+    };
+  }
+  reseed(seed) {
+    this.seed = seed;
+    this.rng = this.createRng(seed);
+  }
+};
+
+// src/audio/SoundPool.ts
+var SoundPool = class {
+  sounds = /* @__PURE__ */ new Map();
+  /**
+   * Register a sound definition.
+   */
+  register(sound) {
+    this.sounds.set(sound.id, sound);
+  }
+  /**
+   * Register multiple sounds.
+   */
+  registerAll(sounds) {
+    for (const s of sounds) this.register(s);
+  }
+  /**
+   * Get a sound definition by ID.
+   */
+  get(id) {
+    return this.sounds.get(id);
+  }
+  /**
+   * Check if a sound is registered.
+   */
+  has(id) {
+    return this.sounds.has(id);
+  }
+  /**
+   * Get all sounds in a category.
+   */
+  getByCategory(category) {
+    return Array.from(this.sounds.values()).filter((s) => s.category === category);
+  }
+  /**
+   * Get a random sound from a category (for variation).
+   */
+  getRandomFromCategory(category) {
+    const sounds = this.getByCategory(category);
+    if (sounds.length === 0) return void 0;
+    return sounds[Math.floor(Math.random() * sounds.length)];
+  }
+  /**
+   * Get count of registered sounds.
+   */
+  get count() {
+    return this.sounds.size;
+  }
+  /**
+   * List all registered sound IDs.
+   */
+  listIds() {
+    return Array.from(this.sounds.keys());
+  }
+};
+
+// src/audio/SpatialAudioSource.ts
+var SpatialAudioSource = class {
+  config;
+  playing = false;
+  paused = false;
+  time = 0;
+  clipDuration = 0;
+  gain = 1;
+  // Computed gain after attenuation
+  pan = 0;
+  // -1 (left) to 1 (right)
+  constructor(config) {
+    this.config = {
+      position: [0, 0, 0],
+      velocity: { x: 0, y: 0, z: 0 },
+      rolloff: "inverse",
+      minDistance: 3,
+      // Tuned for voice: audible within 3m
+      maxDistance: 100,
+      volume: 1,
+      pitch: 1,
+      loop: false,
+      cone: null,
+      dopplerFactor: 1,
+      rolloffFactor: 1,
+      spatialBlend: 1,
+      ...config
+    };
+  }
+  // ---------------------------------------------------------------------------
+  // Playback
+  // ---------------------------------------------------------------------------
+  play(duration = 5) {
+    this.playing = true;
+    this.paused = false;
+    this.time = 0;
+    this.clipDuration = duration;
+  }
+  stop() {
+    this.playing = false;
+    this.paused = false;
+    this.time = 0;
+  }
+  pause() {
+    if (this.playing) this.paused = true;
+  }
+  resume() {
+    this.paused = false;
+  }
+  isPlaying() {
+    return this.playing && !this.paused;
+  }
+  // ---------------------------------------------------------------------------
+  // Position / Properties
+  // ---------------------------------------------------------------------------
+  setPosition(x, y, z) {
+    this.config.position = { x, y, z };
+  }
+  getPosition() {
+    return { ...this.config.position };
+  }
+  setVelocity(x, y, z) {
+    this.config.velocity = { x, y, z };
+  }
+  setVolume(v) {
+    this.config.volume = Math.max(0, Math.min(1, v));
+  }
+  getVolume() {
+    return this.config.volume;
+  }
+  setPitch(p) {
+    this.config.pitch = Math.max(0.1, p);
+  }
+  setLoop(loop) {
+    this.config.loop = loop;
+  }
+  setRolloff(model) {
+    this.config.rolloff = model;
+  }
+  setMinDistance(d) {
+    this.config.minDistance = Math.max(0.01, d);
+  }
+  setMaxDistance(d) {
+    this.config.maxDistance = Math.max(this.config.minDistance, d);
+  }
+  setSpatialBlend(blend) {
+    this.config.spatialBlend = Math.max(0, Math.min(1, blend));
+  }
+  setCone(cone) {
+    this.config.cone = { ...cone };
+  }
+  // ---------------------------------------------------------------------------
+  // Update
+  // ---------------------------------------------------------------------------
+  update(dt, listenerPos) {
+    if (!this.playing || this.paused) return;
+    this.time += dt * this.config.pitch;
+    if (this.time >= this.clipDuration) {
+      if (this.config.loop) {
+        this.time %= this.clipDuration;
+      } else {
+        this.playing = false;
+        return;
+      }
+    }
+    const dx = this.config.position.x - listenerPos.x;
+    const dy = this.config.position.y - listenerPos.y;
+    const dz = this.config.position.z - listenerPos.z;
+    const distance = Math.sqrt(dx * dx + dy * dy + dz * dz);
+    this.gain = this.computeAttenuation(distance) * this.config.volume;
+    if (distance > 1e-3) {
+      this.pan = Math.max(-1, Math.min(1, dx / distance)) * this.config.spatialBlend;
+    } else {
+      this.pan = 0;
+    }
+    if (this.config.cone) {
+      this.gain *= this.computeConeGain(listenerPos);
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Attenuation
+  // ---------------------------------------------------------------------------
+  computeAttenuation(distance) {
+    const min = this.config.minDistance;
+    const max = this.config.maxDistance;
+    const clamped = Math.max(min, Math.min(max, distance));
+    switch (this.config.rolloff) {
+      case "linear": {
+        return 1 - (clamped - min) / (max - min);
+      }
+      case "inverse": {
+        return min / (min + this.config.rolloffFactor * (clamped - min));
+      }
+      case "exponential": {
+        return Math.pow(clamped / min, -this.config.rolloffFactor);
+      }
+      default:
+        return 1;
+    }
+  }
+  computeConeGain(listenerPos) {
+    if (!this.config.cone) return 1;
+    const dx = listenerPos.x - this.config.position.x;
+    const dz = listenerPos.z - this.config.position.z;
+    const angle = Math.abs(Math.atan2(dz, dx) * (180 / Math.PI));
+    const halfInner = this.config.cone.innerAngle / 2;
+    const halfOuter = this.config.cone.outerAngle / 2;
+    if (angle <= halfInner) return 1;
+    if (angle >= halfOuter) return this.config.cone.outerGain;
+    const t = (angle - halfInner) / (halfOuter - halfInner);
+    return 1 - t * (1 - this.config.cone.outerGain);
+  }
+  // ---------------------------------------------------------------------------
+  // Queries
+  // ---------------------------------------------------------------------------
+  getGain() {
+    return this.gain;
+  }
+  getPan() {
+    return this.pan;
+  }
+  getTime() {
+    return this.time;
+  }
+  getConfig() {
+    return {
+      ...this.config,
+      position: { ...this.config.position },
+      velocity: { ...this.config.velocity }
+    };
+  }
+};
+
+// src/audio/SpatialAudioZone.ts
+var REVERB_PRESETS = {
+  outdoor: {
+    name: "outdoor",
+    decay: 0.3,
+    density: 0.2,
+    diffusion: 0.1,
+    wetLevel: 0.1,
+    earlyReflections: 5
+  },
+  room: {
+    name: "room",
+    decay: 0.8,
+    density: 0.5,
+    diffusion: 0.5,
+    wetLevel: 0.3,
+    earlyReflections: 10
+  },
+  hall: {
+    name: "hall",
+    decay: 2,
+    density: 0.7,
+    diffusion: 0.8,
+    wetLevel: 0.5,
+    earlyReflections: 20
+  },
+  cathedral: {
+    name: "cathedral",
+    decay: 4.5,
+    density: 0.9,
+    diffusion: 0.9,
+    wetLevel: 0.7,
+    earlyReflections: 40
+  },
+  cave: {
+    name: "cave",
+    decay: 3,
+    density: 0.8,
+    diffusion: 0.6,
+    wetLevel: 0.6,
+    earlyReflections: 30
+  },
+  underwater: {
+    name: "underwater",
+    decay: 1.5,
+    density: 1,
+    diffusion: 1,
+    wetLevel: 0.9,
+    earlyReflections: 5
+  }
+};
+var SpatialAudioZoneSystem = class {
+  zones = /* @__PURE__ */ new Map();
+  portals = /* @__PURE__ */ new Map();
+  activeZones = /* @__PURE__ */ new Map();
+  listenerPos = { x: 0, y: 0, z: 0 };
+  // ---------------------------------------------------------------------------
+  // Zone Management
+  // ---------------------------------------------------------------------------
+  addZone(config) {
+    this.zones.set(config.id, config);
+  }
+  removeZone(zoneId) {
+    this.zones.delete(zoneId);
+    this.activeZones.delete(zoneId);
+  }
+  getZone(zoneId) {
+    return this.zones.get(zoneId);
+  }
+  getZoneCount() {
+    return this.zones.size;
+  }
+  // ---------------------------------------------------------------------------
+  // Portals
+  // ---------------------------------------------------------------------------
+  addPortal(portal) {
+    this.portals.set(portal.id, portal);
+  }
+  removePortal(portalId) {
+    this.portals.delete(portalId);
+  }
+  // ---------------------------------------------------------------------------
+  // Update
+  // ---------------------------------------------------------------------------
+  updateListenerPosition(pos) {
+    this.listenerPos = { ...pos };
+    this.recalculate();
+  }
+  recalculate() {
+    this.activeZones.clear();
+    for (const [id, zone] of this.zones) {
+      const distance = this.distanceToZone(zone);
+      const isInside = distance <= 0;
+      let blendWeight = 0;
+      if (isInside) {
+        blendWeight = 1;
+      } else if (distance < zone.fadeDistance) {
+        blendWeight = 1 - distance / zone.fadeDistance;
+      }
+      if (blendWeight > 0) {
+        this.activeZones.set(id, { zoneId: id, blendWeight, isInside });
+      }
+    }
+  }
+  distanceToZone(zone) {
+    const dx = this.listenerPos.x - zone.position.x;
+    const dy = this.listenerPos.y - zone.position.y;
+    const dz = this.listenerPos.z - zone.position.z;
+    if (zone.shape === "sphere") {
+      const dist = Math.sqrt(dx * dx + dy * dy + dz * dz);
+      return Math.max(0, dist - zone.size.x);
+    }
+    const cx = Math.max(0, Math.abs(dx) - zone.size.x);
+    const cy = Math.max(0, Math.abs(dy) - zone.size.y);
+    const cz = Math.max(0, Math.abs(dz) - zone.size.z);
+    return Math.sqrt(cx * cx + cy * cy + cz * cz);
+  }
+  // ---------------------------------------------------------------------------
+  // Queries
+  // ---------------------------------------------------------------------------
+  getActiveZones() {
+    return [...this.activeZones.values()].sort((a, b) => {
+      const za = this.zones.get(a.zoneId);
+      const zb = this.zones.get(b.zoneId);
+      return zb.priority - za.priority;
+    });
+  }
+  /**
+   * Returns the highest-priority active reverb preset, blended by weight.
+   */
+  getEffectiveReverb() {
+    const active = this.getActiveZones();
+    if (active.length === 0) return null;
+    const primary = active[0];
+    const zone = this.zones.get(primary.zoneId);
+    if (active.length === 1 || primary.blendWeight >= 1) {
+      return { ...zone.reverb };
+    }
+    const secondary = active[1];
+    const zone2 = this.zones.get(secondary.zoneId);
+    const w = primary.blendWeight;
+    return {
+      name: `${zone.reverb.name}+${zone2.reverb.name}`,
+      decay: zone.reverb.decay * w + zone2.reverb.decay * (1 - w),
+      density: zone.reverb.density * w + zone2.reverb.density * (1 - w),
+      diffusion: zone.reverb.diffusion * w + zone2.reverb.diffusion * (1 - w),
+      wetLevel: zone.reverb.wetLevel * w + zone2.reverb.wetLevel * (1 - w),
+      earlyReflections: zone.reverb.earlyReflections * w + zone2.reverb.earlyReflections * (1 - w)
+    };
+  }
+  isListenerInsideZone(zoneId) {
+    return this.activeZones.get(zoneId)?.isInside ?? false;
+  }
+  /**
+   * Get portal attenuation between two zones.
+   */
+  getPortalAttenuation(fromZone, toZone) {
+    for (const portal of this.portals.values()) {
+      if (portal.fromZoneId === fromZone && portal.toZoneId === toZone || portal.fromZoneId === toZone && portal.toZoneId === fromZone) {
+        return portal.attenuation;
+      }
+    }
+    return 0;
+  }
+};
+
+// src/audio/SynthEngine.ts
+var _oscId = 0;
+var SynthEngine = class {
+  voices = /* @__PURE__ */ new Map();
+  maxPolyphony = 16;
+  masterVolume = 1;
+  filter = null;
+  sampleRate = 44100;
+  // ---------------------------------------------------------------------------
+  // Voice Management
+  // ---------------------------------------------------------------------------
+  noteOn(frequency, waveform = "sine", envelope) {
+    if (this.voices.size >= this.maxPolyphony) {
+      const oldest = [...this.voices.entries()].sort((a, b) => a[1].elapsed - b[1].elapsed).pop();
+      if (oldest) this.voices.delete(oldest[0]);
+    }
+    const id = `voice_${_oscId++}`;
+    const osc = {
+      id,
+      waveform,
+      frequency,
+      amplitude: 1,
+      phase: 0,
+      detune: 0,
+      envelope: { attack: 0.01, decay: 0.1, sustain: 0.7, release: 0.3, ...envelope }
+    };
+    this.voices.set(id, {
+      id,
+      oscillator: osc,
+      noteOn: true,
+      noteOnTime: 0,
+      noteOffTime: -1,
+      currentAmplitude: 0,
+      elapsed: 0
+    });
+    return id;
+  }
+  noteOff(id) {
+    const voice = this.voices.get(id);
+    if (voice) {
+      voice.noteOn = false;
+      voice.noteOffTime = voice.elapsed;
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Sample Generation
+  // ---------------------------------------------------------------------------
+  generateSample(time) {
+    let sample = 0;
+    for (const voice of this.voices.values()) {
+      const osc = voice.oscillator;
+      const env = this.computeEnvelope(voice);
+      voice.currentAmplitude = env;
+      if (env <= 1e-3 && !voice.noteOn) {
+        continue;
+      }
+      const freq = osc.frequency * Math.pow(2, osc.detune / 1200);
+      const t = time + osc.phase;
+      let wave = 0;
+      switch (osc.waveform) {
+        case "sine":
+          wave = Math.sin(2 * Math.PI * freq * t);
+          break;
+        case "square":
+          wave = Math.sin(2 * Math.PI * freq * t) >= 0 ? 1 : -1;
+          break;
+        case "saw":
+          wave = 2 * (freq * t % 1) - 1;
+          break;
+        case "triangle":
+          wave = 2 * Math.abs(2 * (freq * t % 1) - 1) - 1;
+          break;
+        case "noise":
+          wave = Math.random() * 2 - 1;
+          break;
+        default:
+          wave = 0;
+      }
+      sample += wave * osc.amplitude * env;
+    }
+    return Math.max(-1, Math.min(1, sample * this.masterVolume));
+  }
+  computeEnvelope(voice) {
+    const env = voice.oscillator.envelope;
+    const t = voice.elapsed;
+    if (voice.noteOn) {
+      if (t < env.attack) return t / env.attack;
+      const decayT = t - env.attack;
+      if (decayT < env.decay) return 1 - (1 - env.sustain) * (decayT / env.decay);
+      return env.sustain;
+    } else {
+      const releaseT = voice.elapsed - voice.noteOffTime;
+      if (releaseT >= env.release) return 0;
+      return env.sustain * (1 - releaseT / env.release);
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Update
+  // ---------------------------------------------------------------------------
+  update(dt) {
+    const toRemove = [];
+    for (const [id, voice] of this.voices) {
+      voice.elapsed += dt;
+      if (!voice.noteOn && voice.currentAmplitude <= 1e-3) {
+        toRemove.push(id);
+      }
+    }
+    for (const id of toRemove) this.voices.delete(id);
+  }
+  // ---------------------------------------------------------------------------
+  // Config
+  // ---------------------------------------------------------------------------
+  setMasterVolume(vol) {
+    this.masterVolume = Math.max(0, Math.min(1, vol));
+  }
+  setMaxPolyphony(n) {
+    this.maxPolyphony = n;
+  }
+  setFilter(filter) {
+    this.filter = filter;
+  }
+  getFilter() {
+    return this.filter;
+  }
+  // ---------------------------------------------------------------------------
+  // Queries
+  // ---------------------------------------------------------------------------
+  getActiveVoiceCount() {
+    return this.voices.size;
+  }
+  getVoice(id) {
+    return this.voices.get(id);
+  }
+  getMasterVolume() {
+    return this.masterVolume;
+  }
+};
+
+// src/audio/VoiceManager.ts
+var VoiceManager = class {
+  constructor(input, transport) {
+    this.input = input;
+    this.transport = transport;
+  }
+  input;
+  transport;
+  isPttPressed = false;
+  isMuted = false;
+  mutedPeers = /* @__PURE__ */ new Set();
+  update() {
+  }
+  /**
+   * Call this when input state changes
+   */
+  setPushToTalkState(pressed) {
+    this.isPttPressed = pressed;
+    this.updateMicState();
+  }
+  toggleMute() {
+    this.isMuted = !this.isMuted;
+    this.updateMicState();
+  }
+  mutePeer(peerId, muted) {
+    if (muted) {
+      this.mutedPeers.add(peerId);
+    } else {
+      this.mutedPeers.delete(peerId);
+    }
+  }
+  updateMicState() {
+    const isActive = !this.isMuted && this.isPttPressed;
+    this.transport.setMicrophoneEnabled(isActive);
+  }
+  isPeerMuted(peerId) {
+    return this.mutedPeers.has(peerId);
+  }
+};
+
+export {
+  AUDIO_DEFAULTS,
+  zeroVector,
+  defaultOrientation,
+  bufferSource,
+  oscillatorSource,
+  streamSource,
+  noiseSource,
+  spatialSource,
+  gainEffect,
+  reverbEffect,
+  delayEffect,
+  filterEffect,
+  compressorEffect,
+  midiToFrequency,
+  frequencyToMidi,
+  noteNameToMidi,
+  midiToNoteName,
+  lowpassFilter,
+  highpassFilter,
+  bandpassFilter,
+  distortionEffect,
+  panEffect,
+  eqBand,
+  equalizerEffect,
+  createNote,
+  createPattern,
+  createTrack,
+  createSequence,
+  AudioContextImpl,
+  createAudioContext,
+  SequencerImpl,
+  createSequencer,
+  AudioEngine,
+  DEFAULT_BANDS,
+  AudioAnalyzer,
+  AudioDiffractionSystem,
+  AudioDynamics,
+  AudioEnvelope,
+  AudioFilter,
+  AudioGraph,
+  AudioMixer,
+  OCCLUSION_MATERIALS,
+  AudioOcclusionSystem,
+  AudioPresets,
+  setSharedAudioEngine,
+  getSharedAudioEngine,
+  audioTraitHandler,
+  MusicGenerator,
+  SoundPool,
+  SpatialAudioSource,
+  REVERB_PRESETS,
+  SpatialAudioZoneSystem,
+  SynthEngine,
+  VoiceManager,
+  audio_exports
+};