rn-gamekit 0.1.0 → 0.2.0

package/lib/module/audio/createGameAudio.js

@@ -0,0 +1,784 @@
+"use strict";
+
+import { createAudioInstallationError, GameAudioError } from "./errors.js";
+import { loadAudioApi } from "./resolver.js";
+const CATEGORIES = ['master', 'music', 'sfx', 'ui'];
+function isValidVolume(volume) {
+  return Number.isFinite(volume) && volume >= 0 && volume <= 1;
+}
+function assertCategory(category) {
+  if (!CATEGORIES.includes(category)) {
+    throw new GameAudioError(`Unknown audio category "${String(category)}"`);
+  }
+}
+function assertVolume(volume) {
+  if (!isValidVolume(volume)) {
+    throw new GameAudioError(`Volume must be a finite number in [0, 1], got ${String(volume)}`);
+  }
+}
+
+// GS-AUDIO-04: backend-global interruption observation is reference
+// counted — the first live instance enables it, the last dispose disables
+// it, so two instances can never disable each other's observation.
+let interruptionObserverCount = 0;
+let assetInputLoader = null;
+export function __setAssetInputLoader(fn) {
+  assetInputLoader = fn;
+}
+export function __getAssetInputLoader() {
+  return assetInputLoader;
+}
+export async function createGameAudio(options) {
+  let api;
+  try {
+    api = await loadAudioApi();
+  } catch {
+    throw createAudioInstallationError();
+  }
+  if (!api || !api.AudioContext) {
+    throw createAudioInstallationError();
+  }
+  if (!options || typeof options.sounds !== 'object' || options.sounds === null) {
+    throw new GameAudioError('createGameAudio requires { sounds: Record<string, number> }');
+  }
+  const soundIds = Object.keys(options.sounds);
+  if (soundIds.length === 0) {
+    throw new GameAudioError('createGameAudio sounds must not be empty');
+  }
+  for (const id of soundIds) {
+    const v = options.sounds[id];
+    if (typeof v !== 'number' || !Number.isFinite(v)) {
+      throw new GameAudioError(`Sound "${id}" must be a finite asset ID (require result)`);
+    }
+  }
+  const {
+    AudioContext,
+    AudioManager
+  } = api;
+  let context = null;
+  let masterGain = null;
+  const categoryGains = {
+    master: null,
+    music: null,
+    sfx: null,
+    ui: null
+  };
+  let interruptionSub = null;
+  let interruptionEnabled = false;
+  let appStateSub = null;
+  let idleSuspendTimer = null;
+
+  // Create context in a transaction so failure cleans up
+  try {
+    context = new AudioContext();
+  } catch (e) {
+    throw e;
+  }
+  const volumes = {
+    master: 1,
+    music: 1,
+    sfx: 1,
+    ui: 1
+  };
+  let muted = false;
+  let disposed = false;
+  let userPaused = false;
+  let sessionPaused = false;
+  let appPaused = false;
+  let interruptionPaused = false;
+  let interruptionRequiresExplicitResume = false;
+  const bufferCache = new Map();
+  const pendingDecodes = new Map();
+  async function getBuffer(id) {
+    if (disposed) throw new GameAudioError('GameAudio is disposed');
+    if (bufferCache.has(id)) return bufferCache.get(id);
+    if (pendingDecodes.has(id)) return pendingDecodes.get(id);
+    const assetId = options.sounds[id];
+    const promise = (async () => {
+      let input;
+      if (assetInputLoader) {
+        input = await assetInputLoader(assetId);
+      } else {
+        let assetUri = null;
+        let expoAssetFailed = false;
+        try {
+          const {
+            Asset: ExpoAsset
+          } = await import('expo-asset');
+          const asset = ExpoAsset.fromModule(assetId);
+          await asset.downloadAsync();
+          assetUri = asset.localUri ?? asset.uri;
+        } catch {
+          expoAssetFailed = true;
+        }
+        if (assetUri) input = assetUri;else if (expoAssetFailed) input = assetId;else throw new GameAudioError(`Failed to resolve asset for sound "${String(id)}" — expo-asset returned no URI`);
+      }
+      let buffer;
+      try {
+        buffer = await context.decodeAudioData(input);
+      } catch (e) {
+        throw new GameAudioError(`Failed to decode audio asset "${String(id)}": ${e.message}`);
+      }
+      bufferCache.set(id, buffer);
+      pendingDecodes.delete(id);
+      return buffer;
+    })();
+    pendingDecodes.set(id, promise);
+    try {
+      return await promise;
+    } catch (e) {
+      pendingDecodes.delete(id);
+      throw e;
+    }
+  }
+  function applyGain(category) {
+    const gain = categoryGains[category];
+    if (!gain) return;
+    // F1: write only own volume; composition happens in graph (master * category)
+    const value = volumes[category];
+    try {
+      const param = gain.gain;
+      const now = context.currentTime ?? 0;
+      if (param.cancelScheduledValues) param.cancelScheduledValues(now);
+      if (param.setValueAtTime) param.setValueAtTime(param.value, now);
+      if (param.linearRampToValueAtTime) param.linearRampToValueAtTime(value, now + 0.02);else param.value = value;
+    } catch {
+      try {
+        gain.gain.value = value;
+      } catch {}
+    }
+  }
+  function applyAllGains() {
+    for (const c of CATEGORIES) applyGain(c);
+  }
+
+  // Transaction: gain graph plus eager decode, with cleanup on failure
+  // (F3, GS-AUDIO-03). Any failure closes the half-built context before
+  // rethrowing — init never returns a silent partial object.
+  try {
+    // Gain setup — master -> destination, categories -> master (F1).
+    // GS-AUDIO-03: the gain graph is REQUIRED setup. A failure throws
+    // transactionally (the init boundary closes the context and rethrows)
+    // instead of returning an apparently usable but silent object.
+    const mg = context.createGain?.();
+    if (!mg) {
+      throw new GameAudioError('createGameAudio requires a working channel gain graph (master createGain failed)');
+    }
+    masterGain = mg;
+    try {
+      mg.connect(context.destination);
+    } catch (e) {
+      throw new GameAudioError(`createGameAudio requires a working channel gain graph (master connect failed: ${e.message})`);
+    }
+    for (const cat of CATEGORIES) {
+      if (cat === 'master') {
+        categoryGains[cat] = mg;
+        continue;
+      }
+      const cg = context.createGain?.();
+      if (!cg) {
+        throw new GameAudioError(`createGameAudio requires a working channel gain graph (category ${cat} createGain failed)`);
+      }
+      categoryGains[cat] = cg;
+      try {
+        cg.connect(mg);
+      } catch (e) {
+        throw new GameAudioError(`createGameAudio requires a working channel gain graph (category ${cat} connect failed: ${e.message})`);
+      }
+    }
+    await Promise.all(soundIds.map(id => getBuffer(id)));
+  } catch (e) {
+    // Close context exactly once before rethrowing
+    try {
+      await context.close();
+    } catch {}
+    pendingDecodes.clear();
+    bufferCache.clear();
+    throw e;
+  }
+  let currentMusicId = null;
+  let currentMusicNode = null;
+  let musicGeneration = 0;
+  let activeMusicGeneration = 0;
+  let pendingMusic = null;
+  const activeVoices = new Set();
+  const concurrencyMap = new Map();
+  // GS-AUDIO-02: pending reservations are tracked distinctly from live
+  // voices. Only pending work takes cancellation tokens (removed when its
+  // continuation runs); live voices use normal stop/cleanup and lose all
+  // owner references immediately — never a token.
+  const pendingReservations = new Set();
+  const cancelledReservations = new Set();
+  function isEffectivelyPaused() {
+    return userPaused || sessionPaused || appPaused || interruptionPaused || muted;
+  }
+
+  // GS-AUDIO-04: serialized suspend/resume intents. Every pause-affecting
+  // call enqueues one link; each link re-reads the CURRENT effective pause
+  // state and converges the context to it, so rapid intent changes settle
+  // to the latest request instead of racing delayed native promises.
+  // Native calls never overlap: at most one suspend/resume is in flight.
+  let suspendChain = Promise.resolve();
+  async function runSuspendLink() {
+    if (disposed || !context) return;
+    if (isEffectivelyPaused()) {
+      if (idleSuspendTimer) {
+        clearTimeout(idleSuspendTimer);
+        idleSuspendTimer = null;
+      }
+      try {
+        await context.suspend();
+      } catch {}
+      return;
+    }
+    try {
+      const state = context.state;
+      if (state === 'suspended') {
+        await context.resume();
+      }
+    } catch {}
+    applyAllGains();
+    // If we have deferred music intent and now unpaused, start it (F4)
+    if (pendingMusic && !isEffectivelyPaused()) {
+      const {
+        id,
+        generation
+      } = pendingMusic;
+      pendingMusic = null;
+      void startMusicInternal(id, generation);
+    }
+    scheduleIdleSuspend();
+  }
+  function requestSuspendUpdate() {
+    suspendChain = suspendChain.then(runSuspendLink, runSuspendLink);
+  }
+  function updateSuspendState() {
+    requestSuspendUpdate();
+  }
+  function scheduleIdleSuspend() {
+    if (idleSuspendTimer) clearTimeout(idleSuspendTimer);
+    if (disposed || !context || isEffectivelyPaused()) return;
+    if (activeVoices.size === 0 && currentMusicNode === null && !pendingMusic) {
+      idleSuspendTimer = setTimeout(() => {
+        if (!disposed && context && activeVoices.size === 0 && currentMusicNode === null && !pendingMusic && !isEffectivelyPaused()) {
+          void context.suspend().catch(() => {});
+        }
+      }, 1500);
+    }
+  }
+
+  /** Drop one live voice: normal stop/cleanup with no token (GS-AUDIO-02). */
+  function dropVoice(voice, concurrencyKey) {
+    activeVoices.delete(voice);
+    if (concurrencyKey !== undefined) {
+      const set = concurrencyMap.get(concurrencyKey);
+      if (set) {
+        set.delete(voice);
+        if (set.size === 0) concurrencyMap.delete(concurrencyKey);
+      }
+    }
+    cancelledReservations.delete(voice);
+    scheduleIdleSuspend();
+  }
+
+  /** Drop one pending reservation from every collection that holds it. */
+  function dropReservation(reservation, concurrencyKey) {
+    pendingReservations.delete(reservation);
+    const set = concurrencyMap.get(concurrencyKey);
+    if (set) {
+      set.delete(reservation);
+      if (set.size === 0) concurrencyMap.delete(concurrencyKey);
+    }
+    cancelledReservations.delete(reservation);
+  }
+  const ensureNotDisposed = () => {
+    if (disposed) throw new GameAudioError('GameAudio is disposed');
+  };
+  function handleInterruption(event) {
+    const e = event;
+    if (e.type === 'began') {
+      interruptionPaused = true;
+      interruptionRequiresExplicitResume = false;
+      requestSuspendUpdate();
+    } else if (e.type === 'ended') {
+      if (e.shouldResume) {
+        if (interruptionRequiresExplicitResume) {
+          // Denied auto-resume persists until explicit user action (F2)
+          requestSuspendUpdate();
+          return;
+        }
+        interruptionPaused = false;
+        interruptionRequiresExplicitResume = false;
+        updateSuspendState();
+      } else {
+        // Platform says don't auto-resume: keep paused until explicit user action (F2)
+        interruptionPaused = true;
+        interruptionRequiresExplicitResume = true;
+        requestSuspendUpdate();
+      }
+    }
+  }
+  try {
+    // GS-AUDIO-03: interruption observation is explicitly optional. Without
+    // an AudioManager the service still plays, but warns once so the gap
+    // is visible instead of silently disappearing behind a no-op fallback.
+    if (AudioManager) {
+      if (interruptionObserverCount === 0) {
+        AudioManager.observeAudioInterruptions(true);
+      }
+      interruptionObserverCount++;
+      interruptionEnabled = true;
+      interruptionSub = AudioManager.addSystemEventListener('interruption', handleInterruption);
+    } else {
+      console.warn('[GameAudio] AudioManager unavailable — interruption observation disabled');
+    }
+  } catch {
+    interruptionSub = null;
+  }
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const RN = require('react-native');
+    const AppState = RN?.AppState;
+    if (AppState?.addEventListener) {
+      const isInactive = s => s === 'inactive' || s === 'background';
+      if (isInactive(AppState.currentState)) {
+        appPaused = true;
+        requestSuspendUpdate();
+      }
+      appStateSub = AppState.addEventListener('change', next => {
+        if (isInactive(next)) {
+          appPaused = true;
+          requestSuspendUpdate();
+        } else if (next === 'active') {
+          appPaused = false;
+          updateSuspendState();
+        }
+      });
+    }
+  } catch {}
+  applyAllGains();
+  // Initial idle suspend (F2): resource with no playback should suspend
+  scheduleIdleSuspend();
+  async function startMusicInternal(id, generation) {
+    if (disposed || !context) return;
+    if (isEffectivelyPaused()) {
+      // Defer until resume
+      pendingMusic = {
+        id,
+        generation
+      };
+      return;
+    }
+    if (generation !== musicGeneration) return;
+    try {
+      const buffer = await getBuffer(id);
+      if (disposed || !context) return;
+      if (generation !== musicGeneration) return;
+      if (isEffectivelyPaused()) {
+        pendingMusic = {
+          id,
+          generation
+        };
+        return;
+      }
+      if (currentMusicId !== id || activeMusicGeneration !== generation) {
+        // If another generation has taken over, don't start
+        if (generation !== musicGeneration) return;
+      }
+      const source = context.createBufferSource();
+      source.buffer = buffer;
+      source.loop = true;
+      const dest = categoryGains['music'] ?? masterGain ?? context.destination;
+      source.connect(dest);
+      // Stop previous
+      if (currentMusicNode) {
+        try {
+          currentMusicNode.stop();
+        } catch {}
+      }
+      currentMusicNode = source;
+      currentMusicId = id;
+      activeMusicGeneration = generation;
+      try {
+        source.start();
+      } catch (e) {
+        // GS-AUDIO-01: a failed music start must not wedge the music node —
+        // clear it so idle suspension and retries proceed, then report.
+        try {
+          source.disconnect?.();
+        } catch {}
+        if (currentMusicNode === source) {
+          currentMusicNode = null;
+        }
+        scheduleIdleSuspend();
+        throw e;
+      }
+      if (idleSuspendTimer) {
+        clearTimeout(idleSuspendTimer);
+        idleSuspendTimer = null;
+      }
+      const state = context.state;
+      if (state === 'suspended' && !isEffectivelyPaused()) await context.resume().catch(() => {});
+    } catch (e) {
+      if (generation === musicGeneration) {
+        console.warn(`[GameAudio] playMusic("${String(id)}") failed:`, e);
+        if (currentMusicId === id && activeMusicGeneration === generation) {
+          currentMusicId = null;
+        }
+      }
+    }
+  }
+  let lifecycleDetach = null;
+  const setSessionPaused = paused => {
+    sessionPaused = paused;
+    requestSuspendUpdate();
+  };
+  const audio = {
+    play(id, opts) {
+      ensureNotDisposed();
+      if (isEffectivelyPaused()) return;
+      if (opts?.category !== undefined) assertCategory(opts.category);
+      if (opts?.volume !== undefined) assertVolume(opts.volume);
+      const category = opts?.category ?? 'sfx';
+      const concurrencyKey = opts?.concurrency?.key ?? String(id);
+      const limit = opts?.concurrency?.limit;
+      const overflow = opts?.concurrency?.overflow ?? 'drop-new';
+      let reservation = null;
+      if (limit !== undefined) {
+        if (!Number.isFinite(limit) || limit < 1 || Math.floor(limit) !== limit) {
+          throw new GameAudioError(`Concurrency limit must be a positive integer, got ${String(limit)}`);
+        }
+        let set = concurrencyMap.get(concurrencyKey);
+        if (!set) {
+          set = new Set();
+          concurrencyMap.set(concurrencyKey, set);
+        }
+        if (set.size >= limit) {
+          if (overflow === 'drop-new') return;
+          if (overflow === 'stop-oldest') {
+            const oldest = set.values().next().value;
+            if (oldest) {
+              if (pendingReservations.has(oldest)) {
+                cancelledReservations.add(oldest);
+              } else {
+                try {
+                  oldest.stop();
+                } catch {}
+                dropVoice(oldest, concurrencyKey);
+              }
+            }
+          }
+        }
+        reservation = {};
+        set.add(reservation);
+        pendingReservations.add(reservation);
+      }
+      try {
+        const state = context.state;
+        if (state === 'suspended' && !isEffectivelyPaused()) void context.resume().catch(() => {});
+      } catch {}
+      if (idleSuspendTimer) {
+        clearTimeout(idleSuspendTimer);
+        idleSuspendTimer = null;
+      }
+      void (async () => {
+        if (disposed || !context || isEffectivelyPaused()) {
+          if (reservation) {
+            dropReservation(reservation, concurrencyKey);
+          }
+          return;
+        }
+        try {
+          const buffer = await getBuffer(id);
+          if (disposed || !context || isEffectivelyPaused()) {
+            if (reservation) {
+              dropReservation(reservation, concurrencyKey);
+            }
+            return;
+          }
+          if (reservation && cancelledReservations.has(reservation)) {
+            dropReservation(reservation, concurrencyKey);
+            return;
+          }
+          // GS-AUDIO-01: one idempotent cleanup owns every stage from here.
+          // A failure in create/connect/start removes BOTH the reservation
+          // and the actual source, detaches handlers, disconnects owned
+          // nodes, and reconsiders idle suspension — never half-registered.
+          let voiceGain = null;
+          let cleaned = false;
+          let source = null;
+          const releaseVoice = () => {
+            if (cleaned) return;
+            cleaned = true;
+            if (source !== null) {
+              dropVoice(source, limit !== undefined ? concurrencyKey : undefined);
+            }
+            if (reservation && limit !== undefined) {
+              dropReservation(reservation, concurrencyKey);
+            }
+            const anySource = source;
+            if (anySource !== null && anySource.onended === cleanup) anySource.onended = null;
+            try {
+              source?.disconnect?.();
+            } catch {}
+            try {
+              if (voiceGain !== null) {
+                voiceGain.disconnect?.();
+              }
+            } catch {}
+            scheduleIdleSuspend();
+          };
+          const cleanup = () => {
+            releaseVoice();
+          };
+          try {
+            source = context.createBufferSource();
+            source.buffer = buffer;
+            if (opts?.loop) source.loop = true;
+            let dest = context.destination;
+            const catGain = categoryGains[category];
+            if (catGain) dest = catGain;else if (masterGain) dest = masterGain;
+            if (opts?.volume !== undefined) {
+              try {
+                voiceGain = context.createGain();
+                if (voiceGain) {
+                  const v = opts.volume;
+                  try {
+                    voiceGain.gain.value = v;
+                  } catch {}
+                  voiceGain.connect(dest);
+                  dest = voiceGain;
+                }
+              } catch {}
+            }
+            source.connect(dest);
+            activeVoices.add(source);
+            if (reservation) {
+              pendingReservations.delete(reservation);
+              const set = concurrencyMap.get(concurrencyKey);
+              if (set) {
+                set.delete(reservation);
+                set.add(source);
+              }
+            }
+            const anySource = source;
+            if (typeof anySource.addEventListener === 'function') anySource.addEventListener('ended', cleanup);else anySource.onended = cleanup;
+            source.start();
+            if (idleSuspendTimer) {
+              clearTimeout(idleSuspendTimer);
+              idleSuspendTimer = null;
+            }
+          } catch (e) {
+            releaseVoice();
+            console.warn(`[GameAudio] play("${String(id)}") failed:`, e);
+          }
+        } catch (e) {
+          // Pre-voice stages (decode/buffer) failed: no voice exists, but
+          // the reservation must still be released exactly once.
+          if (reservation) {
+            const set = concurrencyMap.get(concurrencyKey);
+            if (set) {
+              set.delete(reservation);
+              if (set.size === 0) concurrencyMap.delete(concurrencyKey);
+            }
+            cancelledReservations.delete(reservation);
+          }
+          console.warn(`[GameAudio] play("${String(id)}") failed:`, e);
+        }
+      })();
+    },
+    async playMusic(id) {
+      ensureNotDisposed();
+      musicGeneration++;
+      const gen = musicGeneration;
+      // Stop previous immediately and mark generation
+      if (currentMusicNode) {
+        try {
+          currentMusicNode.stop();
+        } catch {}
+        currentMusicNode = null;
+      }
+      currentMusicId = id;
+      // If effectively paused, defer (F4)
+      if (isEffectivelyPaused()) {
+        pendingMusic = {
+          id: id,
+          generation: gen
+        };
+        return;
+      }
+      await startMusicInternal(id, gen);
+    },
+    stopMusic() {
+      ensureNotDisposed();
+      musicGeneration++;
+      if (currentMusicNode) {
+        try {
+          currentMusicNode.stop();
+        } catch {}
+        currentMusicNode = null;
+      }
+      currentMusicId = null;
+      pendingMusic = null;
+      scheduleIdleSuspend();
+    },
+    pause() {
+      ensureNotDisposed();
+      if (userPaused) return;
+      userPaused = true;
+      requestSuspendUpdate();
+      // FF1: keep denied-interruption flag intact; only explicit resume() clears it
+    },
+    resume() {
+      ensureNotDisposed();
+      if (!userPaused && !interruptionRequiresExplicitResume) return;
+      const wasExplicit = interruptionRequiresExplicitResume;
+      userPaused = false;
+      if (wasExplicit) {
+        // Explicit user action clears denied auto-resume (F2)
+        interruptionPaused = false;
+        interruptionRequiresExplicitResume = false;
+      }
+      updateSuspendState();
+    },
+    setVolume(category, volume) {
+      ensureNotDisposed();
+      assertCategory(category);
+      assertVolume(volume);
+      volumes[category] = volume;
+      applyGain(category);
+      // F1: don't re-apply master when changing category, and vice versa — only own gain
+    },
+    getVolume(category) {
+      ensureNotDisposed();
+      assertCategory(category);
+      return volumes[category];
+    },
+    setMuted(next) {
+      ensureNotDisposed();
+      muted = Boolean(next);
+      updateSuspendState();
+    },
+    isMuted() {
+      ensureNotDisposed();
+      return muted;
+    },
+    setPaused(next) {
+      ensureNotDisposed();
+      setSessionPaused(Boolean(next));
+    },
+    bindLifecycle(source) {
+      return bindAudioLifecycle(source);
+    },
+    /** Compat alias for the pre-T20.7 session channel; use setPaused. */
+    _setSessionPaused(p) {
+      ensureNotDisposed();
+      setSessionPaused(Boolean(p));
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      currentMusicId = null;
+      pendingMusic = null;
+      if (currentMusicNode) {
+        try {
+          currentMusicNode.stop();
+        } catch {}
+        currentMusicNode = null;
+      }
+      for (const v of activeVoices) {
+        try {
+          v.stop();
+        } catch {}
+      }
+      activeVoices.clear();
+      concurrencyMap.clear();
+      cancelledReservations.clear();
+      pendingDecodes.clear();
+      bufferCache.clear();
+      if (idleSuspendTimer) {
+        clearTimeout(idleSuspendTimer);
+        idleSuspendTimer = null;
+      }
+      lifecycleDetach?.();
+      lifecycleDetach = null;
+      if (interruptionSub) {
+        try {
+          interruptionSub.remove();
+        } catch {}
+        interruptionSub = null;
+      }
+      if (interruptionEnabled) {
+        interruptionObserverCount = Math.max(0, interruptionObserverCount - 1);
+        if (interruptionObserverCount === 0) {
+          try {
+            AudioManager?.observeAudioInterruptions(false);
+          } catch {}
+        }
+        interruptionEnabled = false;
+      }
+      if (appStateSub) {
+        try {
+          appStateSub.remove();
+        } catch {}
+        appStateSub = null;
+      }
+      if (context) void context.close().catch(() => {});
+    }
+  };
+  const bindAudioLifecycle = source => {
+    ensureNotDisposed();
+    // One active source: a replacement detaches the previous one first.
+    lifecycleDetach?.();
+    lifecycleDetach = null;
+    // Apply the current status immediately, then follow transitions.
+    // AppState backgrounding stays independent (separate flag).
+    setSessionPaused(source.getStatus() !== 'running');
+    const sourceDetach = source.subscribe(status => {
+      setSessionPaused(status !== 'running');
+    });
+    let detached = false;
+    const detach = () => {
+      if (detached) return;
+      detached = true;
+      sourceDetach();
+      if (lifecycleDetach === detach) lifecycleDetach = null;
+    };
+    lifecycleDetach = detach;
+    return detach;
+  };
+  audio._isIdleSuspended = () => {
+    try {
+      return context.state === 'suspended';
+    } catch {
+      return false;
+    }
+  };
+  audio._getConcurrencyCount = k => concurrencyMap.get(k)?.size ?? 0;
+  // Test-only collection sizes for the ownership suites (GS-AUDIO-01/02).
+  audio._getVoiceCounts = () => ({
+    activeVoices: activeVoices.size,
+    concurrencyKeys: concurrencyMap.size,
+    cancelled: cancelledReservations.size
+  });
+  audio._handleInterruption = handleInterruption;
+  audio._getVolumes = () => ({
+    ...volumes
+  });
+  audio._getGainTargets = () => {
+    const out = {};
+    for (const c of CATEGORIES) {
+      const g = categoryGains[c];
+      if (g) {
+        try {
+          out[c] = g.gain.value;
+        } catch {
+          out[c] = volumes[c];
+        }
+      }
+    }
+    return out;
+  };
+  return audio;
+}
+//# sourceMappingURL=createGameAudio.js.map