@bardway/trpg-media 0.0.0-stage → 0.1.0

package/dist/audio.js

@@ -0,0 +1,625 @@
+// src/AudioByteCache.ts
+var AudioByteCache = class {
+  constructor(fetchAudio = fetch) {
+    this.fetchAudio = fetchAudio;
+  }
+  fetchAudio;
+  records = /* @__PURE__ */ new Map();
+  async load(url) {
+    let record = this.records.get(url);
+    if (!record) {
+      const controller = new AbortController();
+      const promise = this.fetchAudio(url, { signal: controller.signal }).then(async (response) => {
+        if (!response.ok) throw new Error(`Audio request failed: ${response.status}`);
+        const bytes = await response.arrayBuffer();
+        if (controller.signal.aborted) throw new DOMException("Audio load cancelled", "AbortError");
+        return bytes;
+      });
+      record = { controller, promise };
+      this.records.set(url, record);
+      const owner = record;
+      void promise.catch(() => {
+        if (this.records.get(url) === owner) this.records.delete(url);
+      });
+    }
+    return (await record.promise).slice(0);
+  }
+  clear() {
+    for (const record of this.records.values()) record.controller.abort();
+    this.records.clear();
+  }
+};
+
+// src/audio/SessionAudioEngine.ts
+var SessionAudioEngine = class {
+  constructor(createContext = () => new AudioContext(), fetchAudio = fetch, busIds = [
+    "ui",
+    "action",
+    "impact",
+    "status",
+    "dice",
+    "field",
+    "cinematic"
+  ], limiterBuses = ["dice"], report = () => void 0) {
+    this.createContext = createContext;
+    this.busIds = busIds;
+    this.limiterBuses = limiterBuses;
+    this.report = report;
+    if (busIds.length === 0 || new Set(busIds).size !== busIds.length || busIds.some((bus) => !bus.trim()))
+      throw new Error("Audio bus IDs must be nonempty and unique");
+    this.bytes = new AudioByteCache(fetchAudio.bind(globalThis));
+  }
+  createContext;
+  busIds;
+  limiterBuses;
+  report;
+  bytes;
+  context = null;
+  master = null;
+  buses = /* @__PURE__ */ new Map();
+  busGains = /* @__PURE__ */ new Map();
+  buffers = /* @__PURE__ */ new Map();
+  activeVoices = /* @__PURE__ */ new Map();
+  playbackCleanups = /* @__PURE__ */ new Map();
+  lastCueTimes = /* @__PURE__ */ new Map();
+  busMute = /* @__PURE__ */ new Set();
+  soloBus = null;
+  masterGain = 1;
+  fieldSource = null;
+  fieldUrl = null;
+  fieldRevision = 0;
+  unlockGeneration = 0;
+  destroying = false;
+  _state = "blocked";
+  get state() {
+    return this._state;
+  }
+  async unlock(preloadUrls = []) {
+    if (this.destroying) return false;
+    if (this._state === "ready") return true;
+    const generation = ++this.unlockGeneration;
+    this._state = "initializing";
+    try {
+      this.ensureGraph();
+      await this.context.resume();
+      if (generation !== this.unlockGeneration) return false;
+      this._state = "ready";
+      void this.preload(preloadUrls);
+      return true;
+    } catch (error) {
+      if (generation !== this.unlockGeneration) return false;
+      this._state = error instanceof DOMException && (error.name === "NotAllowedError" || error.name === "AbortError") ? "blocked" : "failed";
+      return false;
+    }
+  }
+  async preload(urls) {
+    await Promise.allSettled(urls.map((url) => this.load(url)));
+  }
+  async play(url, options) {
+    if (this._state !== "ready" || options.signal?.aborted) return null;
+    const context = this.context;
+    const generation = this.unlockGeneration;
+    let cleanup;
+    try {
+      const buffer = await this.load(url);
+      if (this._state !== "ready" || !this.context || this.context !== context || generation !== this.unlockGeneration || options.signal?.aborted)
+        return null;
+      const source = this.context.createBufferSource();
+      const voiceGain = this.context.createGain();
+      const panner = "createStereoPanner" in this.context && typeof this.context.createStereoPanner === "function" ? this.context.createStereoPanner() : null;
+      const now = this.context.currentTime;
+      const volumeCeiling = Math.max(1, Math.min(4, options.volumeCeiling ?? 1));
+      const volume = Math.max(0, Math.min(volumeCeiling, options.volume ?? 1));
+      const fadeInSeconds = Math.max(0, options.fadeInMs ?? 0) / 1e3;
+      voiceGain.gain.setValueAtTime(fadeInSeconds > 0 ? 0 : volume, now);
+      if (fadeInSeconds > 0) voiceGain.gain.linearRampToValueAtTime(volume, now + fadeInSeconds);
+      source.buffer = buffer;
+      source.loop = options.loop ?? false;
+      const playbackRate = source.playbackRate;
+      if (playbackRate) playbackRate.value = Math.max(0.01, options.playbackRate ?? 1);
+      source.connect(voiceGain);
+      if (panner) {
+        panner.pan.value = Math.max(-1, Math.min(1, options.pan ?? 0));
+        voiceGain.connect(panner);
+        panner.connect(this.buses.get(options.bus));
+      } else voiceGain.connect(this.buses.get(options.bus));
+      let finished = false;
+      const finish = () => {
+        if (finished) return;
+        finished = true;
+        options.signal?.removeEventListener("abort", abort);
+        this.playbackCleanups.delete(source);
+        source.disconnect();
+        voiceGain.disconnect();
+        panner?.disconnect();
+        try {
+          options.onEnded?.();
+        } catch (error) {
+          this.reportSafely(error);
+        }
+      };
+      const abort = () => {
+        try {
+          source.stop();
+        } finally {
+          finish();
+        }
+      };
+      cleanup = finish;
+      source.onended = finish;
+      this.playbackCleanups.set(source, finish);
+      options.signal?.addEventListener("abort", abort, { once: true });
+      if (options.signal?.aborted) {
+        finish();
+        return null;
+      }
+      source.start(0, Math.max(0, options.startOffsetMs ?? 0) / 1e3);
+      return source;
+    } catch {
+      cleanup?.();
+      if (options.signal?.aborted || this.context !== context || generation !== this.unlockGeneration)
+        return null;
+      this._state = "failed";
+      return null;
+    }
+  }
+  async playCue(cue, optionsOrSeed = {}, legacyOnEnded) {
+    const options = typeof optionsOrSeed === "string" ? { deterministicSeed: optionsOrSeed, onEnded: legacyOnEnded } : optionsOrSeed;
+    const deterministicSeed = options.deterministicSeed ?? cue.id;
+    const onEnded = options.onEnded;
+    if (this._state !== "ready" || !this.context || options.signal?.aborted) return null;
+    const nowMs = this.context.currentTime * 1e3;
+    const cooldownId = options.cooldownId ?? cue.id;
+    const voiceGroupId = options.voiceGroupId ?? cue.id;
+    const lastTime = this.lastCueTimes.get(cooldownId);
+    if (lastTime !== void 0 && nowMs - lastTime < Math.max(0, options.cooldownMs ?? cue.cooldownMs))
+      return null;
+    const voices = this.activeVoices.get(voiceGroupId) ?? [];
+    if (voices.length >= Math.max(1, options.maxVoices ?? cue.polyphony)) {
+      if (cue.stealMode === "ignoreNewest") return null;
+      voices.shift()?.stop();
+    }
+    const random = deterministicUnit(deterministicSeed);
+    const rate = options.playbackRate ?? interpolate(cue.pitchMin ?? 1, cue.pitchMax ?? cue.pitchMin ?? 1, random);
+    let source = null;
+    source = await this.play(cue.asset, {
+      signal: options.signal,
+      bus: cue.bus,
+      loop: cue.loop,
+      volume: options.volume ?? cue.gain,
+      volumeCeiling: options.volumeCeiling,
+      playbackRate: rate,
+      pan: options.pan ?? interpolate(cue.panMin ?? 0, cue.panMax ?? cue.panMin ?? 0, random),
+      startOffsetMs: cue.startOffsetMs,
+      fadeInMs: cue.fadeInMs,
+      fadeOutMs: cue.fadeOutMs,
+      onEnded: () => {
+        this.releaseVoice(voiceGroupId, source);
+        onEnded?.();
+      }
+    });
+    if (!source || options.signal?.aborted) return null;
+    this.lastCueTimes.set(cooldownId, nowMs);
+    this.activeVoices.set(voiceGroupId, [...voices, source]);
+    return source;
+  }
+  stopCueGroup(groupId) {
+    for (const source of this.activeVoices.get(groupId) ?? []) source.stop();
+    this.activeVoices.delete(groupId);
+  }
+  async playField(url, volume = 1) {
+    await this.replaceField(url, volume);
+  }
+  async replaceField(url, volume = 1) {
+    const revision = ++this.fieldRevision;
+    this.stopFieldSource();
+    if (!url) return;
+    const source = await this.play(url, { bus: "field", loop: true, volume });
+    if (revision !== this.fieldRevision) {
+      source?.stop();
+      return;
+    }
+    this.fieldUrl = url;
+    this.fieldSource = source;
+  }
+  suspendField() {
+    this.buses.get("field")?.gain.setValueAtTime(0, this.context?.currentTime ?? 0);
+  }
+  resumeField() {
+    if (this.fieldUrl)
+      this.buses.get("field")?.gain.setValueAtTime(1, this.context?.currentTime ?? 0);
+  }
+  stopField() {
+    this.fieldRevision += 1;
+    this.stopFieldSource();
+  }
+  stopFieldSource() {
+    const source = this.fieldSource;
+    this.fieldSource = null;
+    this.fieldUrl = null;
+    source?.stop();
+  }
+  setMasterGain(value) {
+    this.masterGain = Math.max(0, Math.min(1, value));
+    if (this.master) this.master.gain.value = this.masterGain;
+  }
+  setBusGain(bus, value, rampMs = 0) {
+    const node = this.buses.get(bus);
+    if (!node) return;
+    this.busGains.set(bus, Math.max(0, Math.min(1, value)));
+    this.applyBusAudibility(rampMs);
+  }
+  setBusMuted(bus, muted) {
+    if (muted) this.busMute.add(bus);
+    else this.busMute.delete(bus);
+    this.applyBusAudibility();
+  }
+  solo(bus) {
+    this.soloBus = bus;
+    this.applyBusAudibility();
+  }
+  async destroy() {
+    this.destroying = true;
+    this.unlockGeneration += 1;
+    this._state = "blocked";
+    try {
+      this.stopField();
+    } catch (error) {
+      this.reportSafely(error);
+    }
+    const cleanups = [...this.playbackCleanups];
+    this.playbackCleanups.clear();
+    this.buffers.clear();
+    this.bytes.clear();
+    this.activeVoices.clear();
+    this.lastCueTimes.clear();
+    this.buses.clear();
+    this.busGains.clear();
+    const context = this.context;
+    this.context = null;
+    this.master = null;
+    try {
+      for (const [source, finish] of cleanups) {
+        try {
+          source.stop();
+        } catch (error) {
+          this.reportSafely(error);
+        }
+        try {
+          finish();
+        } catch (error) {
+          this.reportSafely(error);
+        }
+      }
+      await context?.close();
+    } finally {
+      this.destroying = false;
+    }
+  }
+  reportSafely(error) {
+    try {
+      this.report(error);
+    } catch {
+    }
+  }
+  ensureGraph() {
+    if (this.context) return;
+    this.context = this.createContext();
+    this.master = this.context.createGain();
+    this.master.gain.value = this.masterGain;
+    this.master.connect(this.context.destination);
+    for (const bus of this.busIds) {
+      const gain = this.context.createGain();
+      if (this.limiterBuses.includes(bus) && typeof this.context.createDynamicsCompressor === "function") {
+        const limiter = this.context.createDynamicsCompressor();
+        limiter.threshold.value = -1;
+        limiter.knee.value = 0;
+        limiter.ratio.value = 20;
+        limiter.attack.value = 1e-3;
+        limiter.release.value = 0.08;
+        gain.connect(limiter);
+        limiter.connect(this.master);
+      } else gain.connect(this.master);
+      this.buses.set(bus, gain);
+      this.busGains.set(bus, 1);
+    }
+  }
+  load(url) {
+    const existing = this.buffers.get(url);
+    if (existing) return existing;
+    const context = this.context;
+    const generation = this.unlockGeneration;
+    if (!context) return Promise.reject(new Error("Audio context is not initialized"));
+    const loading = this.bytes.load(url).then((data) => {
+      if (context !== this.context || generation !== this.unlockGeneration)
+        throw new DOMException("Audio context replaced", "AbortError");
+      return context.decodeAudioData(data);
+    }).catch((error) => {
+      if (this.buffers.get(url) === loading) this.buffers.delete(url);
+      throw error;
+    });
+    this.buffers.set(url, loading);
+    return loading;
+  }
+  releaseVoice(cueId, source) {
+    if (!source) return;
+    const voices = this.activeVoices.get(cueId);
+    if (!voices) return;
+    const next = voices.filter((voice) => voice !== source);
+    if (next.length === 0) this.activeVoices.delete(cueId);
+    else this.activeVoices.set(cueId, next);
+  }
+  applyBusAudibility(rampMs = 0) {
+    for (const [bus, node] of this.buses) {
+      const audible = !this.busMute.has(bus) && (!this.soloBus || this.soloBus === bus);
+      const value = audible ? this.busGains.get(bus) ?? 1 : 0;
+      const now = this.context?.currentTime ?? 0;
+      if (rampMs > 0) {
+        if (typeof node.gain.cancelAndHoldAtTime === "function") node.gain.cancelAndHoldAtTime(now);
+        else {
+          node.gain.cancelScheduledValues(now);
+          node.gain.setValueAtTime(node.gain.value, now);
+        }
+        node.gain.linearRampToValueAtTime(value, now + rampMs / 1e3);
+      } else {
+        node.gain.cancelScheduledValues(now);
+        node.gain.setValueAtTime(value, now);
+      }
+    }
+  }
+};
+var interpolate = (min, max, amount) => min + (max - min) * amount;
+var deterministicUnit = (value) => {
+  let hash = 2166136261;
+  for (let index = 0; index < value.length; index += 1) {
+    hash ^= value.charCodeAt(index);
+    hash = Math.imul(hash, 16777619);
+  }
+  return (hash >>> 0) / 4294967295;
+};
+
+// src/audio/HtmlAudioSessionBackend.ts
+var classifyFailure = (error) => error instanceof DOMException && (error.name === "NotAllowedError" || error.name === "AbortError") ? "blocked" : "failed";
+var HtmlAudioSessionBackend = class {
+  constructor(report = () => void 0) {
+    this.report = report;
+  }
+  report;
+  elements = /* @__PURE__ */ new Map();
+  activeCueGroups = /* @__PURE__ */ new Map();
+  playbackOwners = /* @__PURE__ */ new WeakMap();
+  playbackCleanups = /* @__PURE__ */ new Map();
+  fieldElement = null;
+  masterGain = 1;
+  busGains = /* @__PURE__ */ new Map();
+  unlockGeneration = 0;
+  destroying = false;
+  _state = "blocked";
+  get state() {
+    return this._state;
+  }
+  async unlock(preloadUrls = []) {
+    if (this.destroying) return false;
+    if (this._state === "ready") return true;
+    const generation = ++this.unlockGeneration;
+    this._state = "initializing";
+    try {
+      const firstUrl = preloadUrls.at(0);
+      if (firstUrl) {
+        const firstAudio = this.getElement(firstUrl);
+        firstAudio.pause();
+        firstAudio.currentTime = 0;
+        await firstAudio.play();
+        if (generation !== this.unlockGeneration) return false;
+        firstAudio.pause();
+        firstAudio.currentTime = 0;
+      }
+      for (const url of preloadUrls.slice(1)) this.getElement(url).load();
+      this._state = "ready";
+      return true;
+    } catch (error) {
+      if (generation !== this.unlockGeneration) return false;
+      this._state = classifyFailure(error);
+      return false;
+    }
+  }
+  async preload(urls) {
+    urls.forEach((url) => this.getElement(url).load());
+  }
+  async play(url, options) {
+    if (this._state !== "ready" || options.signal?.aborted) return null;
+    const generation = this.unlockGeneration;
+    const audio = this.getElement(url);
+    this.playbackCleanups.get(audio)?.();
+    const owner = Symbol(url);
+    this.playbackOwners.set(audio, owner);
+    audio.pause();
+    audio.currentTime = 0;
+    audio.loop = options.loop ?? false;
+    audio.playbackRate = Math.max(0.01, options.playbackRate ?? 1);
+    audio.volume = Math.max(0, Math.min(1, options.volume ?? 1)) * this.masterGain * (this.busGains.get(options.bus) ?? 1);
+    let finished = false;
+    const finish = () => {
+      if (finished) return;
+      finished = true;
+      options.signal?.removeEventListener("abort", abort);
+      if (this.playbackOwners.get(audio) === owner) this.playbackCleanups.delete(audio);
+      try {
+        options.onEnded?.();
+      } catch (error) {
+        this.reportSafely(error);
+      }
+    };
+    const abort = () => {
+      if (this.playbackOwners.get(audio) === owner) {
+        audio.pause();
+        audio.currentTime = 0;
+      }
+      finish();
+    };
+    audio.onended = finish;
+    this.playbackCleanups.set(audio, finish);
+    options.signal?.addEventListener("abort", abort, { once: true });
+    try {
+      await audio.play();
+      if (this.playbackOwners.get(audio) !== owner || generation !== this.unlockGeneration || this._state !== "ready") {
+        finish();
+        return null;
+      }
+      if (options.signal?.aborted) {
+        abort();
+        return null;
+      }
+      return audio;
+    } catch (error) {
+      if (this.playbackOwners.get(audio) !== owner || generation !== this.unlockGeneration || this._state !== "ready" || options.signal?.aborted) {
+        finish();
+        return null;
+      }
+      if (error instanceof DOMException && error.name === "AbortError") return audio;
+      this._state = classifyFailure(error);
+      finish();
+      return null;
+    }
+  }
+  async playCue(cue, options = {}) {
+    const groupId = options.voiceGroupId ?? cue.id;
+    let audio = null;
+    audio = await this.play(cue.asset, {
+      signal: options.signal,
+      bus: cue.bus,
+      loop: cue.loop,
+      volume: options.volume ?? cue.gain,
+      playbackRate: options.playbackRate,
+      pan: options.pan,
+      startOffsetMs: cue.startOffsetMs,
+      fadeInMs: cue.fadeInMs,
+      fadeOutMs: cue.fadeOutMs,
+      onEnded: () => {
+        if (audio) this.releaseCueGroup(groupId, audio);
+        options.onEnded?.();
+      }
+    });
+    if (audio && !options.signal?.aborted) {
+      const active = this.activeCueGroups.get(groupId) ?? /* @__PURE__ */ new Set();
+      active.add(audio);
+      this.activeCueGroups.set(groupId, active);
+    }
+    return audio;
+  }
+  stopCueGroup(groupId) {
+    for (const audio of this.activeCueGroups.get(groupId) ?? []) {
+      audio.pause();
+      audio.currentTime = 0;
+      this.playbackCleanups.get(audio)?.();
+    }
+    this.activeCueGroups.delete(groupId);
+  }
+  async playField(url, volume = 1) {
+    await this.replaceField(url, volume);
+  }
+  async replaceField(url, volume = 1) {
+    this.stopField();
+    if (!url) return;
+    const audio = this.getElement(url);
+    audio.loop = true;
+    this.fieldElement = audio;
+    await this.play(url, { bus: "field", loop: true, volume });
+  }
+  suspendField() {
+    this.fieldElement?.pause();
+  }
+  resumeField() {
+    if (this.fieldElement && this._state === "ready") void this.fieldElement.play();
+  }
+  stopField() {
+    const audio = this.fieldElement;
+    if (!audio) return;
+    audio.pause();
+    audio.currentTime = 0;
+    this.fieldElement = null;
+  }
+  setMasterGain(value) {
+    this.masterGain = Math.max(0, Math.min(1, value));
+  }
+  setBusGain(bus, value) {
+    this.busGains.set(bus, Math.max(0, Math.min(1, value)));
+  }
+  setBusMuted(bus, muted) {
+    void bus;
+    void muted;
+  }
+  solo(bus) {
+    void bus;
+  }
+  async destroy() {
+    this.destroying = true;
+    this.unlockGeneration += 1;
+    this._state = "blocked";
+    const elements = [...this.elements.values()];
+    const cleanups = [...this.playbackCleanups.values()];
+    this.playbackCleanups.clear();
+    this.elements.clear();
+    this.activeCueGroups.clear();
+    this.fieldElement = null;
+    try {
+      for (const audio of elements) {
+        try {
+          audio.pause();
+        } catch (error) {
+          this.reportSafely(error);
+        }
+      }
+      for (const cleanup of cleanups) {
+        try {
+          cleanup();
+        } catch (error) {
+          this.reportSafely(error);
+        }
+      }
+    } finally {
+      this.destroying = false;
+    }
+  }
+  reportSafely(error) {
+    try {
+      this.report(error);
+    } catch {
+    }
+  }
+  getElement(url) {
+    const existing = this.elements.get(url);
+    if (existing) return existing;
+    const audio = new Audio(url);
+    audio.preload = "auto";
+    this.elements.set(url, audio);
+    return audio;
+  }
+  releaseCueGroup(groupId, audio) {
+    const active = this.activeCueGroups.get(groupId);
+    if (!active) return;
+    active.delete(audio);
+    if (active.size === 0) this.activeCueGroups.delete(groupId);
+  }
+};
+
+// src/audio/SessionAudioPlaybackPolicy.ts
+var productionAudioPlaybackPolicy = {
+  mode: "production",
+  allowSemanticSideEffects: true,
+  allowScrubAudio: false
+};
+var previewAudioPlaybackPolicy = {
+  mode: "preview",
+  allowSemanticSideEffects: true,
+  allowScrubAudio: false,
+  deterministicSeed: "visual-lab"
+};
+export {
+  AudioByteCache,
+  HtmlAudioSessionBackend,
+  SessionAudioEngine,
+  previewAudioPlaybackPolicy,
+  productionAudioPlaybackPolicy
+};
+//# sourceMappingURL=audio.js.map