@gentomiyano/optimized-web-audio-player 0.1.0

package/dist/react/index.js

@@ -0,0 +1,2393 @@
+import { createContext, useRef, useState, useEffect, useSyncExternalStore, useContext } from 'react';
+import { jsxs, Fragment, jsx } from 'react/jsx-runtime';
+
+// src/react/player-provider.tsx
+
+// src/adapters/browser/browser-media-element-port.ts
+function clampVolume(value) {
+  if (!Number.isFinite(value)) {
+    return 0;
+  }
+  return Math.min(Math.max(value, 0), 1);
+}
+function classifyMediaError(mediaError) {
+  if (mediaError === null) {
+    return null;
+  }
+  switch (mediaError.code) {
+    case MediaError.MEDIA_ERR_NETWORK:
+      return {
+        code: "network",
+        recoverable: true,
+        messageKey: "player.error.network"
+      };
+    case MediaError.MEDIA_ERR_DECODE:
+      return {
+        code: "decode",
+        recoverable: false,
+        messageKey: "player.error.decode"
+      };
+    case MediaError.MEDIA_ERR_SRC_NOT_SUPPORTED:
+      return {
+        code: "unsupported",
+        recoverable: false,
+        messageKey: "player.error.unsupported"
+      };
+    default:
+      return {
+        code: "unknown",
+        recoverable: true,
+        messageKey: "player.error.unknown"
+      };
+  }
+}
+var BrowserMediaElementPort = class {
+  #element;
+  #listeners = /* @__PURE__ */ new Map();
+  #assignedSourceUrl = null;
+  constructor(element) {
+    this.#element = element;
+  }
+  getCurrentTimeSec() {
+    return Number.isFinite(this.#element.currentTime) ? Math.max(this.#element.currentTime, 0) : 0;
+  }
+  getDurationSec() {
+    return Number.isFinite(this.#element.duration) && this.#element.duration > 0 ? this.#element.duration : null;
+  }
+  getVolume() {
+    return clampVolume(this.#element.volume);
+  }
+  isMuted() {
+    return this.#element.muted;
+  }
+  isPaused() {
+    return this.#element.paused;
+  }
+  getStateSnapshot() {
+    const currentSource = this.#element.currentSrc || this.#element.getAttribute("src") || "";
+    const baseUrl = this.#element.baseURI;
+    let normalizedCurrentSource = currentSource;
+    if (currentSource.length > 0) {
+      try {
+        normalizedCurrentSource = new URL(
+          currentSource,
+          baseUrl
+        ).href;
+      } catch {
+      }
+    }
+    return Object.freeze({
+      currentTimeSec: this.getCurrentTimeSec(),
+      durationSec: this.getDurationSec(),
+      volume: this.getVolume(),
+      muted: this.isMuted(),
+      paused: this.isPaused(),
+      ended: this.#element.ended,
+      hasCurrentSource: currentSource.length > 0,
+      currentSourceMatchesAssigned: this.#assignedSourceUrl !== null && normalizedCurrentSource === this.#assignedSourceUrl
+    });
+  }
+  getError() {
+    return classifyMediaError(this.#element.error);
+  }
+  setSource(source) {
+    this.#element.pause();
+    this.#element.crossOrigin = source.crossOrigin;
+    this.#element.src = source.url;
+    this.#assignedSourceUrl = this.#element.src;
+  }
+  clearSource() {
+    this.#element.pause();
+    this.#assignedSourceUrl = null;
+    this.#element.removeAttribute("src");
+    this.#element.load();
+  }
+  load() {
+    this.#element.load();
+  }
+  async play() {
+    await this.#element.play();
+  }
+  pause() {
+    this.#element.pause();
+  }
+  seekTo(seconds) {
+    if (!Number.isFinite(seconds)) {
+      return;
+    }
+    this.#element.currentTime = Math.max(seconds, 0);
+  }
+  setVolume(volume) {
+    this.#element.volume = clampVolume(volume);
+  }
+  setMuted(muted) {
+    this.#element.muted = muted;
+  }
+  addEventListener(type, listener) {
+    const typeListeners = this.#listeners.get(type) ?? /* @__PURE__ */ new Map();
+    if (typeListeners.has(listener)) {
+      return;
+    }
+    const nativeListener = () => {
+      listener({ type });
+    };
+    typeListeners.set(listener, nativeListener);
+    this.#listeners.set(type, typeListeners);
+    this.#element.addEventListener(type, nativeListener);
+  }
+  removeEventListener(type, listener) {
+    const typeListeners = this.#listeners.get(type);
+    const nativeListener = typeListeners?.get(listener);
+    if (nativeListener === void 0) {
+      return;
+    }
+    this.#element.removeEventListener(type, nativeListener);
+    typeListeners?.delete(listener);
+    if (typeListeners?.size === 0) {
+      this.#listeners.delete(type);
+    }
+  }
+};
+
+// src/adapters/browser/audio-playback-mode.ts
+function isIOSWebPlatform(platform) {
+  if (/\b(iPhone|iPad|iPod)\b/i.test(platform.userAgent)) {
+    return true;
+  }
+  return platform.platform === "MacIntel" && (platform.maxTouchPoints ?? 0) > 1;
+}
+function resolvePlayerAudioMode(requested, platform) {
+  if (requested !== "auto") {
+    return requested;
+  }
+  return isIOSWebPlatform(platform) ? "html-media" : "web-audio";
+}
+var HtmlMediaElementGainPort = class {
+  activateFromUserGesture() {
+    return Promise.resolve();
+  }
+  resumeIfSuspended() {
+    return Promise.resolve(false);
+  }
+  getValue() {
+    return 1;
+  }
+  setValue() {
+  }
+  cancelTransition() {
+  }
+  transitionTo() {
+    return Promise.resolve();
+  }
+  destroy() {
+    return Promise.resolve();
+  }
+};
+
+// src/adapters/browser/lazy-web-audio-gain-port.ts
+var MIN_TRANSITION_SETTLE_MS = 32;
+function clampGain(value) {
+  if (!Number.isFinite(value)) {
+    return 0;
+  }
+  return Math.min(Math.max(value, 0), 1);
+}
+function easingProgress(curve, progress, isFadeIn) {
+  switch (curve) {
+    case "ease-in":
+      return progress * progress;
+    case "ease-out":
+      return 1 - (1 - progress) ** 2;
+    case "equal-power":
+      return isFadeIn ? Math.sin(progress * Math.PI / 2) : 1 - Math.cos(progress * Math.PI / 2);
+    case "linear":
+      return progress;
+  }
+}
+function createCurve(start, target, curve) {
+  const values = new Float32Array(64);
+  const isFadeIn = target >= start;
+  for (let index = 0; index < values.length; index += 1) {
+    const progress = index / (values.length - 1);
+    const eased = easingProgress(curve, progress, isFadeIn);
+    values[index] = start + (target - start) * eased;
+  }
+  return values;
+}
+function transitionSettleMs(context) {
+  const contextWithLatency = context;
+  const baseLatency = Number.isFinite(contextWithLatency.baseLatency) ? Math.max(0, contextWithLatency.baseLatency) : 0;
+  const outputLatency = Number.isFinite(contextWithLatency.outputLatency) ? Math.max(0, contextWithLatency.outputLatency) : 0;
+  return Math.max(
+    MIN_TRANSITION_SETTLE_MS,
+    Math.ceil((baseLatency + outputLatency) * 1e3) + 8
+  );
+}
+var LazyWebAudioGainPort = class {
+  #element;
+  #createAudioContext;
+  #onContextStateChange;
+  #pendingTransitions = /* @__PURE__ */ new Set();
+  #context = null;
+  #source = null;
+  #gain = null;
+  #value = 1;
+  constructor(element, options = {}) {
+    this.#element = element;
+    this.#createAudioContext = options.createAudioContext ?? (() => {
+      const audioWindow = window;
+      const AudioContextConstructor = audioWindow.AudioContext ?? audioWindow.webkitAudioContext;
+      if (AudioContextConstructor === void 0) {
+        throw new Error("Web Audio is not supported.");
+      }
+      return new AudioContextConstructor();
+    });
+    this.#onContextStateChange = options.onContextStateChange;
+    this.#notifyState();
+  }
+  activateFromUserGesture() {
+    if (this.#context === null) {
+      const context = this.#createAudioContext();
+      const gain = context.createGain();
+      const source = context.createMediaElementSource(this.#element);
+      gain.gain.value = this.#value;
+      source.connect(gain);
+      gain.connect(context.destination);
+      this.#context = context;
+      this.#source = source;
+      this.#gain = gain;
+      context.addEventListener("statechange", this.#notifyState);
+      this.#notifyState();
+    }
+    if (this.#context.state === "suspended") {
+      return this.#context.resume().then(() => {
+        this.#notifyState();
+      });
+    }
+    return Promise.resolve();
+  }
+  async resumeIfSuspended() {
+    if (this.#context === null || this.#context.state !== "suspended") {
+      return false;
+    }
+    await this.#context.resume();
+    this.#notifyState();
+    return true;
+  }
+  getValue() {
+    return this.#gain?.gain.value ?? this.#value;
+  }
+  getContextState() {
+    return this.#context?.state ?? "uninitialized";
+  }
+  setValue(value) {
+    this.cancelTransition();
+    this.#value = clampGain(value);
+    if (this.#context !== null && this.#gain !== null) {
+      const now = this.#context.currentTime;
+      this.#gain.gain.setValueAtTime(this.#value, now);
+    }
+  }
+  cancelTransition() {
+    if (this.#context !== null && this.#gain !== null) {
+      const now = this.#context.currentTime;
+      const heldValue = this.#gain.gain.value;
+      this.#gain.gain.cancelScheduledValues(0);
+      this.#gain.gain.setValueAtTime(heldValue, now);
+    }
+    for (const pending of this.#pendingTransitions) {
+      clearTimeout(pending.timerId);
+      pending.resolve();
+    }
+    this.#pendingTransitions.clear();
+  }
+  transitionTo(value, transition) {
+    const target = clampGain(value);
+    const durationMs = Math.max(0, transition.durationMs);
+    if (this.#context === null || this.#gain === null || durationMs === 0) {
+      this.setValue(target);
+      return Promise.resolve();
+    }
+    this.cancelTransition();
+    const start = this.#gain.gain.value;
+    const durationSec = durationMs / 1e3;
+    this.#gain.gain.setValueCurveAtTime(
+      createCurve(start, target, transition.curve),
+      this.#context.currentTime,
+      durationSec
+    );
+    this.#value = target;
+    return new Promise((resolve) => {
+      const pending = {
+        timerId: setTimeout(() => {
+          this.#pendingTransitions.delete(pending);
+          resolve();
+        }, durationMs + transitionSettleMs(this.#context)),
+        resolve
+      };
+      this.#pendingTransitions.add(pending);
+    });
+  }
+  async destroy() {
+    this.cancelTransition();
+    const context = this.#context;
+    if (context === null) {
+      return;
+    }
+    context.removeEventListener("statechange", this.#notifyState);
+    this.#source?.disconnect();
+    this.#gain?.disconnect();
+    this.#source = null;
+    this.#gain = null;
+    this.#context = null;
+    await context.close();
+    this.#notifyState();
+  }
+  #notifyState = () => {
+    this.#onContextStateChange?.(
+      this.#context?.state ?? "uninitialized"
+    );
+  };
+};
+
+// src/adapters/browser/media-session-controller.ts
+var PLAYER_MEDIA_SESSION_ACTIONS = [
+  "play",
+  "pause",
+  "stop",
+  "previoustrack",
+  "nexttrack",
+  "seekto",
+  "seekbackward",
+  "seekforward"
+];
+var MUSIC_MEDIA_SESSION_ACTIONS = [
+  "play",
+  "pause",
+  "stop",
+  "previoustrack",
+  "nexttrack",
+  "seekto"
+];
+function observeCommand(command, action, onError) {
+  void command.catch(() => {
+    onError?.(action);
+  });
+}
+function defaultSeekOffset(state, direction) {
+  if (state.mediaKind !== "podcastEpisode") {
+    return 10;
+  }
+  return direction === "backward" ? state.experienceConfig.podcastBackSec : state.experienceConfig.podcastForwardSec;
+}
+function playbackStateFor(state) {
+  if (state.currentItem === null) {
+    return "none";
+  }
+  return state.status === "playing" ? "playing" : "paused";
+}
+var BrowserMediaSessionController = class {
+  #commands;
+  #getState;
+  #session;
+  #createMetadata;
+  #registeredActions = /* @__PURE__ */ new Set();
+  #onAction;
+  #onActionError;
+  #metadataIdentity = null;
+  #actionsEnabled = false;
+  constructor(options) {
+    this.#commands = options.commands;
+    this.#getState = options.getState;
+    this.#session = options.mediaSession;
+    this.#createMetadata = options.createMetadata;
+    this.#onAction = options.onAction;
+    this.#onActionError = options.onActionError;
+  }
+  get supported() {
+    return this.#session !== void 0;
+  }
+  get actionsEnabled() {
+    return this.#actionsEnabled;
+  }
+  enableActionHandlers() {
+    if (this.#actionsEnabled || this.#session === void 0) {
+      return;
+    }
+    this.#actionsEnabled = true;
+    this.#synchronizeActionHandlers(this.#getState());
+  }
+  update(state) {
+    const session = this.#session;
+    if (session === void 0) {
+      return;
+    }
+    try {
+      session.playbackState = playbackStateFor(state);
+    } catch {
+    }
+    this.#updateMetadata(state);
+    this.#updatePosition(state);
+    if (this.#actionsEnabled) {
+      this.#synchronizeActionHandlers(state);
+    }
+  }
+  destroy() {
+    const session = this.#session;
+    if (session === void 0) {
+      return;
+    }
+    for (const action of this.#registeredActions) {
+      try {
+        session.setActionHandler(action, null);
+      } catch {
+      }
+    }
+    this.#registeredActions.clear();
+    this.#actionsEnabled = false;
+    try {
+      session.metadata = null;
+      session.playbackState = "none";
+      session.setPositionState();
+    } catch {
+    }
+  }
+  #createHandler(action) {
+    const reportAction = () => {
+      this.#onAction?.(action);
+    };
+    switch (action) {
+      case "play":
+        return () => {
+          reportAction();
+          observeCommand(this.#commands.play(), action, this.#onActionError);
+        };
+      case "pause":
+        return () => {
+          reportAction();
+          observeCommand(this.#commands.pause(), action, this.#onActionError);
+        };
+      case "stop":
+        return () => {
+          reportAction();
+          observeCommand(
+            this.#commands.stop({ resetPosition: true }),
+            action,
+            this.#onActionError
+          );
+        };
+      case "previoustrack":
+        return () => {
+          reportAction();
+          observeCommand(
+            this.#commands.previous(),
+            action,
+            this.#onActionError
+          );
+        };
+      case "nexttrack":
+        return () => {
+          reportAction();
+          observeCommand(this.#commands.next(), action, this.#onActionError);
+        };
+      case "seekto":
+        return (details) => {
+          reportAction();
+          if (details.seekTime !== void 0 && Number.isFinite(details.seekTime)) {
+            this.#commands.seekTo(details.seekTime);
+          }
+        };
+      case "seekbackward":
+        return (details) => {
+          reportAction();
+          const fallback = defaultSeekOffset(
+            this.#getState(),
+            "backward"
+          );
+          const offset = details.seekOffset !== void 0 && Number.isFinite(details.seekOffset) ? Math.max(details.seekOffset, 0) : fallback;
+          this.#commands.seekBy(-offset);
+        };
+      case "seekforward":
+        return (details) => {
+          reportAction();
+          const fallback = defaultSeekOffset(
+            this.#getState(),
+            "forward"
+          );
+          const offset = details.seekOffset !== void 0 && Number.isFinite(details.seekOffset) ? Math.max(details.seekOffset, 0) : fallback;
+          this.#commands.seekBy(offset);
+        };
+    }
+  }
+  #synchronizeActionHandlers(state) {
+    const session = this.#session;
+    if (session === void 0) {
+      return;
+    }
+    const desiredActions = new Set(
+      state.mediaKind === "podcastEpisode" ? PLAYER_MEDIA_SESSION_ACTIONS : MUSIC_MEDIA_SESSION_ACTIONS
+    );
+    for (const action of PLAYER_MEDIA_SESSION_ACTIONS) {
+      const shouldRegister = desiredActions.has(action);
+      const isRegistered = this.#registeredActions.has(action);
+      if (shouldRegister === isRegistered) {
+        continue;
+      }
+      try {
+        session.setActionHandler(
+          action,
+          shouldRegister ? this.#createHandler(action) : null
+        );
+        if (shouldRegister) {
+          this.#registeredActions.add(action);
+        } else {
+          this.#registeredActions.delete(action);
+        }
+      } catch {
+      }
+    }
+  }
+  #updateMetadata(state) {
+    const session = this.#session;
+    const item = state.currentItem;
+    if (session === void 0) {
+      return;
+    }
+    if (item === null) {
+      if (this.#metadataIdentity !== null) {
+        try {
+          session.metadata = null;
+        } catch {
+        }
+        this.#metadataIdentity = null;
+      }
+      return;
+    }
+    const identity = [
+      item.id,
+      item.title,
+      item.creatorName ?? "",
+      item.collectionTitle ?? "",
+      item.artwork?.url ?? ""
+    ].join("\0");
+    if (identity === this.#metadataIdentity || this.#createMetadata === void 0) {
+      return;
+    }
+    try {
+      session.metadata = this.#createMetadata({
+        title: item.title,
+        artist: item.creatorName ?? "",
+        album: item.collectionTitle ?? "",
+        artwork: item.artwork === void 0 ? [] : [{ src: item.artwork.url }]
+      });
+      this.#metadataIdentity = identity;
+    } catch {
+    }
+  }
+  #updatePosition(state) {
+    const session = this.#session;
+    if (session === void 0) {
+      return;
+    }
+    const duration = state.durationSec;
+    if (duration === null || !Number.isFinite(duration) || duration <= 0) {
+      try {
+        session.setPositionState();
+      } catch {
+      }
+      return;
+    }
+    const position = Math.min(
+      Math.max(
+        Number.isFinite(state.currentTimeSec) ? state.currentTimeSec : 0,
+        0
+      ),
+      duration
+    );
+    try {
+      session.setPositionState({
+        duration,
+        playbackRate: 1,
+        position
+      });
+    } catch {
+    }
+  }
+};
+function createBrowserMediaSessionController(options) {
+  const mediaSession = typeof navigator !== "undefined" && "mediaSession" in navigator ? navigator.mediaSession : void 0;
+  const createMetadata = typeof MediaMetadata === "function" ? (init) => new MediaMetadata(init) : void 0;
+  return new BrowserMediaSessionController({
+    ...options,
+    ...mediaSession === void 0 ? {} : { mediaSession },
+    ...createMetadata === void 0 ? {} : { createMetadata }
+  });
+}
+
+// src/config/defaults.ts
+var PLAYER_EXPERIENCE_CONFIG_LIMITS = Object.freeze({
+  fadeMs: Object.freeze({ min: 0, max: 1e4 }),
+  previousRestartThresholdSec: Object.freeze({ min: 0, max: 60 }),
+  waveformOpacity: Object.freeze({ min: 0, max: 1 }),
+  initialVolume: Object.freeze({ min: 0, max: 1 }),
+  podcastSkipSec: Object.freeze({ minExclusive: 0, max: 3600 })
+});
+var PREVIEW_PLAYER_EXPERIENCE_CONFIG = Object.freeze({
+  playFadeInMs: 300,
+  pauseFadeOutMs: 600,
+  trackChangeFadeOutMs: 300,
+  trackChangeFadeInMs: 300,
+  seekFadeMs: 120,
+  fadeCurve: "ease-out",
+  previousRestartThresholdSec: 3,
+  seekCommitMode: "on-release",
+  waveformPlayedStateEnabled: true,
+  waveformOpacity: 0.72,
+  initialShuffleEnabled: false,
+  initialRepeatMode: "off",
+  initialVolume: 0.8,
+  persistMode: "none",
+  podcastBackSec: 15,
+  podcastForwardSec: 30,
+  podcastPreviousMode: "previous-episode"
+});
+
+// src/config/validation.ts
+var CONFIG_KEYS = [
+  "playFadeInMs",
+  "pauseFadeOutMs",
+  "trackChangeFadeOutMs",
+  "trackChangeFadeInMs",
+  "seekFadeMs",
+  "fadeCurve",
+  "previousRestartThresholdSec",
+  "seekCommitMode",
+  "waveformPlayedStateEnabled",
+  "waveformOpacity",
+  "initialShuffleEnabled",
+  "initialRepeatMode",
+  "initialVolume",
+  "persistMode",
+  "podcastBackSec",
+  "podcastForwardSec",
+  "podcastPreviousMode"
+];
+var FADE_CURVES = /* @__PURE__ */ new Set([
+  "linear",
+  "ease-in",
+  "ease-out",
+  "equal-power"
+]);
+var SEEK_COMMIT_MODES = /* @__PURE__ */ new Set(["live", "on-release"]);
+var REPEAT_MODES = /* @__PURE__ */ new Set(["off", "all", "one"]);
+var PERSIST_MODES = /* @__PURE__ */ new Set(["none", "session", "local"]);
+var PODCAST_PREVIOUS_MODES = /* @__PURE__ */ new Set([
+  "previous-episode",
+  "restart-episode"
+]);
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function validateFiniteRange(value, path, min, max, errors) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value < min || value > max) {
+    errors.push(
+      `${path} must be a finite number between ${String(min)} and ${String(max)}.`
+    );
+    return false;
+  }
+  return true;
+}
+function validateBoolean(value, path, errors) {
+  if (typeof value !== "boolean") {
+    errors.push(`${path} must be a boolean.`);
+    return false;
+  }
+  return true;
+}
+function validateConfigRecord(value, options) {
+  if (!isRecord(value)) {
+    return { ok: false, errors: ["config must be an object."] };
+  }
+  const errors = [];
+  const allowedKeys = new Set(CONFIG_KEYS);
+  for (const key of Object.keys(value)) {
+    if (!allowedKeys.has(key)) {
+      errors.push(`config.${key} is not supported.`);
+    }
+  }
+  if (!options.partial) {
+    for (const key of CONFIG_KEYS) {
+      if (!Object.hasOwn(value, key)) {
+        errors.push(`config.${key} is required.`);
+      }
+    }
+  }
+  const has = (key) => Object.hasOwn(value, key);
+  const fadeLimits = PLAYER_EXPERIENCE_CONFIG_LIMITS.fadeMs;
+  for (const key of [
+    "playFadeInMs",
+    "pauseFadeOutMs",
+    "trackChangeFadeOutMs",
+    "trackChangeFadeInMs",
+    "seekFadeMs"
+  ]) {
+    if (has(key)) {
+      validateFiniteRange(value[key], `config.${key}`, fadeLimits.min, fadeLimits.max, errors);
+    }
+  }
+  const thresholdLimits = PLAYER_EXPERIENCE_CONFIG_LIMITS.previousRestartThresholdSec;
+  if (has("previousRestartThresholdSec")) {
+    validateFiniteRange(
+      value.previousRestartThresholdSec,
+      "config.previousRestartThresholdSec",
+      thresholdLimits.min,
+      thresholdLimits.max,
+      errors
+    );
+  }
+  const volumeLimits = PLAYER_EXPERIENCE_CONFIG_LIMITS.initialVolume;
+  if (has("initialVolume")) {
+    validateFiniteRange(
+      value.initialVolume,
+      "config.initialVolume",
+      volumeLimits.min,
+      volumeLimits.max,
+      errors
+    );
+  }
+  const waveformOpacityLimits = PLAYER_EXPERIENCE_CONFIG_LIMITS.waveformOpacity;
+  if (has("waveformOpacity")) {
+    validateFiniteRange(
+      value.waveformOpacity,
+      "config.waveformOpacity",
+      waveformOpacityLimits.min,
+      waveformOpacityLimits.max,
+      errors
+    );
+  }
+  for (const key of [
+    "waveformPlayedStateEnabled",
+    "initialShuffleEnabled"
+  ]) {
+    if (has(key)) {
+      validateBoolean(value[key], `config.${key}`, errors);
+    }
+  }
+  const skipLimits = PLAYER_EXPERIENCE_CONFIG_LIMITS.podcastSkipSec;
+  for (const key of ["podcastBackSec", "podcastForwardSec"]) {
+    if (has(key)) {
+      const candidate = value[key];
+      const valid = validateFiniteRange(
+        candidate,
+        `config.${key}`,
+        skipLimits.minExclusive,
+        skipLimits.max,
+        errors
+      );
+      if (valid && candidate <= skipLimits.minExclusive) {
+        errors.push(`config.${key} must be greater than 0.`);
+      }
+    }
+  }
+  if (has("fadeCurve") && !FADE_CURVES.has(value.fadeCurve)) {
+    errors.push("config.fadeCurve is not supported.");
+  }
+  if (has("seekCommitMode") && !SEEK_COMMIT_MODES.has(value.seekCommitMode)) {
+    errors.push("config.seekCommitMode is not supported.");
+  }
+  if (has("initialRepeatMode") && !REPEAT_MODES.has(value.initialRepeatMode)) {
+    errors.push("config.initialRepeatMode is not supported.");
+  }
+  if (has("persistMode") && !PERSIST_MODES.has(value.persistMode)) {
+    errors.push("config.persistMode is not supported.");
+  }
+  if (has("podcastPreviousMode") && !PODCAST_PREVIOUS_MODES.has(
+    value.podcastPreviousMode
+  )) {
+    errors.push("config.podcastPreviousMode is not supported.");
+  }
+  if (errors.length > 0) {
+    return { ok: false, errors: Object.freeze(errors) };
+  }
+  const merged = options.partial ? { ...PREVIEW_PLAYER_EXPERIENCE_CONFIG, ...value } : value;
+  return {
+    ok: true,
+    errors: [],
+    value: Object.freeze({ ...merged })
+  };
+}
+function validatePlayerExperienceConfig(value) {
+  return validateConfigRecord(value, { partial: false });
+}
+function validatePlayerExperienceConfigOverride(value) {
+  return validateConfigRecord(value, { partial: true });
+}
+function resolvePlayerExperienceConfig(override) {
+  return validatePlayerExperienceConfigOverride(override ?? {});
+}
+
+// src/config/initial-state.ts
+function createInitialPlayerState(experienceConfig) {
+  const resolved = resolvePlayerExperienceConfig(experienceConfig);
+  if (!resolved.ok) {
+    throw new TypeError(resolved.errors.join(" "));
+  }
+  return Object.freeze({
+    currentItem: null,
+    currentItemId: null,
+    currentQueueItemId: null,
+    mediaKind: null,
+    status: "idle",
+    currentTimeSec: 0,
+    durationSec: null,
+    volume: resolved.value.initialVolume,
+    muted: false,
+    shuffleEnabled: resolved.value.initialShuffleEnabled,
+    repeatMode: resolved.value.initialRepeatMode,
+    queue: Object.freeze([]),
+    currentQueueIndex: null,
+    canSeek: false,
+    canGoPrevious: false,
+    canGoNext: false,
+    needsUserGesture: false,
+    lastTransitionCause: null,
+    error: null,
+    experienceConfig: resolved.value
+  });
+}
+
+// src/core/fade.ts
+var AUDIO_CONTEXT_ERROR = Object.freeze({
+  code: "audio-context",
+  recoverable: true,
+  messageKey: "player.error.audio-context"
+});
+async function runFade(gain, request) {
+  if (gain === void 0) {
+    return { completed: true, error: null };
+  }
+  try {
+    if (request.durationMs <= 0) {
+      gain.setValue(request.target);
+    } else {
+      await gain.transitionTo(request.target, {
+        durationMs: request.durationMs,
+        curve: request.curve
+      });
+    }
+    return { completed: true, error: null };
+  } catch {
+    return { completed: false, error: AUDIO_CONTEXT_ERROR };
+  }
+}
+
+// src/core/media-events.ts
+var PLAYER_MEDIA_EVENT_TYPES = Object.freeze([
+  "loadstart",
+  "loadedmetadata",
+  "canplay",
+  "play",
+  "playing",
+  "pause",
+  "waiting",
+  "stalled",
+  "seeking",
+  "seeked",
+  "timeupdate",
+  "ended",
+  "error",
+  "durationchange",
+  "volumechange"
+]);
+var PLAY_ERROR_DETAILS = Object.freeze({
+  NotAllowedError: Object.freeze({
+    code: "autoplay-blocked",
+    recoverable: true
+  }),
+  NotSupportedError: Object.freeze({
+    code: "unsupported",
+    recoverable: false
+  }),
+  AbortError: Object.freeze({
+    code: "unknown",
+    recoverable: true
+  })
+});
+function createPlayerError(code, recoverable) {
+  return Object.freeze({
+    code,
+    recoverable,
+    messageKey: `player.error.${code}`
+  });
+}
+function classifyPlayError(error, media) {
+  const mediaError = media.getError();
+  if (mediaError !== null) {
+    return mediaError;
+  }
+  const name = typeof error === "object" && error !== null && "name" in error && typeof error.name === "string" ? error.name : "";
+  const detail = PLAY_ERROR_DETAILS[name];
+  return detail === void 0 ? createPlayerError("unknown", true) : createPlayerError(detail.code, detail.recoverable);
+}
+function readFiniteCurrentTime(media) {
+  const value = media.getCurrentTimeSec();
+  return Number.isFinite(value) && value >= 0 ? value : 0;
+}
+function readFiniteDuration(media) {
+  const value = media.getDurationSec();
+  return value !== null && Number.isFinite(value) && value >= 0 ? value : null;
+}
+
+// src/core/persistence.ts
+var DEFAULT_PODCAST_PROGRESS_SAVE_INTERVAL_SEC = 5;
+function isUsablePodcastProgress(progress, item) {
+  return progress !== null && progress.itemId === item.id && Number.isFinite(progress.positionSec) && progress.positionSec >= 0;
+}
+function createPodcastProgress(item, positionSec, now) {
+  return Object.freeze({
+    itemId: item.id,
+    positionSec,
+    updatedAt: now().toISOString()
+  });
+}
+function canUsePodcastProgress(item, port, persistMode) {
+  return item !== null && item.kind === "podcastEpisode" && port !== void 0 && persistMode !== "none";
+}
+
+// src/core/queue.ts
+function createLoadedQueueItem(item) {
+  return Object.freeze({
+    queueItemId: `loaded:${item.id}`,
+    item
+  });
+}
+function freezeQueue(queue) {
+  return Object.freeze([...queue]);
+}
+function findQueueIndex(queue, queueItemId) {
+  const index = queue.findIndex((entry) => entry.queueItemId === queueItemId);
+  return index < 0 ? null : index;
+}
+function hasUniqueQueueItemIds(queue) {
+  return new Set(queue.map((entry) => entry.queueItemId)).size === queue.length;
+}
+function getNextQueueIndex(queue, currentIndex, repeatMode) {
+  if (queue.length === 0 || currentIndex < 0) {
+    return null;
+  }
+  if (currentIndex < queue.length - 1) {
+    return currentIndex + 1;
+  }
+  return repeatMode === "all" ? 0 : null;
+}
+function getPreviousQueueIndex(queue, currentIndex) {
+  if (queue.length === 0 || currentIndex <= 0) {
+    return null;
+  }
+  return currentIndex - 1;
+}
+
+// src/core/player-reducer.ts
+function deriveCurrentIndex(queue, queueItemId) {
+  if (queueItemId === null) {
+    return null;
+  }
+  const index = queue.findIndex((entry) => entry.queueItemId === queueItemId);
+  return index < 0 ? null : index;
+}
+function createPlayerSnapshot(previous, patch) {
+  const queue = patch.queue === void 0 ? previous.queue : freezeQueue(patch.queue);
+  const currentQueueItemId = patch.currentQueueItemId === void 0 ? previous.currentQueueItemId : patch.currentQueueItemId;
+  const currentQueueIndex = deriveCurrentIndex(queue, currentQueueItemId);
+  const repeatMode = patch.repeatMode ?? previous.repeatMode;
+  const currentItem = patch.currentItem === void 0 ? previous.currentItem : patch.currentItem;
+  return Object.freeze({
+    ...previous,
+    ...patch,
+    queue,
+    currentQueueItemId,
+    currentQueueIndex,
+    canGoPrevious: patch.canGoPrevious ?? currentItem !== null,
+    canGoNext: patch.canGoNext ?? (currentQueueIndex !== null && (currentQueueIndex < queue.length - 1 || queue.length > 0 && repeatMode === "all"))
+  });
+}
+
+// src/core/shuffle.ts
+function normalizeRandom(value) {
+  if (!Number.isFinite(value)) {
+    return 0;
+  }
+  return Math.min(Math.max(value, 0), 0.999999999999);
+}
+function shuffleQueueAroundCurrent(queue, currentQueueItemId, random) {
+  const current = queue.find(
+    (entry) => entry.queueItemId === currentQueueItemId
+  );
+  if (current === void 0) {
+    return Object.freeze([...queue]);
+  }
+  const remaining = queue.filter(
+    (entry) => entry.queueItemId !== currentQueueItemId
+  );
+  for (let index = remaining.length - 1; index > 0; index -= 1) {
+    const swapIndex = Math.floor(normalizeRandom(random()) * (index + 1));
+    const candidate = remaining[index];
+    const replacement = remaining[swapIndex];
+    if (candidate !== void 0 && replacement !== void 0) {
+      remaining[index] = replacement;
+      remaining[swapIndex] = candidate;
+    }
+  }
+  return Object.freeze([current, ...remaining]);
+}
+
+// src/core/create-player-store.ts
+var OK_RESULT = Object.freeze({ ok: true });
+var NO_ITEM_ERROR = createPlayerError("unknown", false);
+var INVALID_QUEUE_ERROR = Object.freeze({
+  code: "unknown",
+  recoverable: false,
+  messageKey: "player.error.invalid-queue"
+});
+var DESTROYED_ERROR = Object.freeze({
+  code: "unknown",
+  recoverable: false,
+  messageKey: "player.error.destroyed"
+});
+var MAX_SHUFFLE_HISTORY_ITEMS = 512;
+var RETAINED_SHUFFLE_HISTORY_ITEMS = 128;
+function failed(error) {
+  return Object.freeze({ ok: false, error });
+}
+function clampVolume2(value) {
+  if (!Number.isFinite(value)) {
+    return 0;
+  }
+  return Math.min(Math.max(value, 0), 1);
+}
+var CorePlayerStore = class {
+  commands;
+  experience;
+  #media;
+  #gain;
+  #podcastProgress;
+  #random;
+  #now;
+  #podcastProgressSaveIntervalSec;
+  #listeners = /* @__PURE__ */ new Set();
+  #experienceListeners = /* @__PURE__ */ new Set();
+  #mediaListener = (event) => {
+    this.#handleMediaEvent(event);
+  };
+  #state;
+  #playbackOrderQueueItemIds = Object.freeze([]);
+  #playbackOrderCursor = -1;
+  #commandVersion = 0;
+  #desiredPlayback = "paused";
+  #ignoreNextPauseEvent = false;
+  #handlingEnded = false;
+  #destroyed = false;
+  #lastSavedPodcastPositions = /* @__PURE__ */ new Map();
+  #progressSaveChain = Promise.resolve();
+  constructor(options) {
+    this.#media = options.media;
+    this.#gain = options.gain;
+    this.#podcastProgress = options.podcastProgress;
+    this.#random = options.random ?? Math.random;
+    this.#now = options.now ?? (() => /* @__PURE__ */ new Date());
+    this.#podcastProgressSaveIntervalSec = options.podcastProgressSaveIntervalSec ?? DEFAULT_PODCAST_PROGRESS_SAVE_INTERVAL_SEC;
+    if (!Number.isFinite(this.#podcastProgressSaveIntervalSec) || this.#podcastProgressSaveIntervalSec <= 0) {
+      throw new RangeError(
+        "podcastProgressSaveIntervalSec must be a positive finite number."
+      );
+    }
+    this.#state = createInitialPlayerState(options.experienceConfig);
+    this.#media.setVolume(this.#state.volume);
+    this.#media.setMuted(this.#state.muted);
+    try {
+      this.#gain?.setValue(1);
+    } catch {
+      this.#state = createPlayerSnapshot(this.#state, {
+        error: createPlayerError("audio-context", true)
+      });
+    }
+    for (const eventType of PLAYER_MEDIA_EVENT_TYPES) {
+      this.#media.addEventListener(eventType, this.#mediaListener);
+    }
+    const commands = {
+      load: (item) => this.#load(item),
+      setQueue: (queue, commandOptions) => this.#setQueue(queue, commandOptions),
+      play: () => this.#play(),
+      pause: (commandOptions) => this.#pause(commandOptions),
+      stop: (commandOptions) => this.#stop(commandOptions),
+      togglePlayback: () => this.#togglePlayback(),
+      seekTo: (seconds) => {
+        this.#seekTo(seconds);
+      },
+      seekBy: (deltaSeconds) => {
+        this.#seekBy(deltaSeconds);
+      },
+      setVolume: (volume) => {
+        this.#setVolume(volume);
+      },
+      toggleMute: () => {
+        this.#toggleMute();
+      },
+      setShuffle: (enabled) => {
+        this.#setShuffle(enabled);
+      },
+      setRepeatMode: (mode) => {
+        this.#setRepeatMode(mode);
+      },
+      next: () => this.#next(),
+      previous: () => this.#previous(),
+      retry: () => this.#retry(),
+      clear: () => this.#clear()
+    };
+    this.commands = Object.freeze(commands);
+    const experience = {
+      getConfig: () => this.#state.experienceConfig,
+      updateConfig: (patch) => {
+        this.#updateExperienceConfig(patch);
+      },
+      resetConfig: () => {
+        this.#replaceExperienceConfig(PREVIEW_PLAYER_EXPERIENCE_CONFIG);
+      },
+      subscribe: (listener) => this.#subscribeTo(this.#experienceListeners, listener)
+    };
+    this.experience = Object.freeze(experience);
+  }
+  getState() {
+    return this.#state;
+  }
+  subscribe(listener) {
+    return this.#subscribeTo(this.#listeners, listener);
+  }
+  async synchronizeFromMedia(reason) {
+    if (this.#destroyed || this.#state.currentItem === null) {
+      return;
+    }
+    const snapshot = this.#media.getStateSnapshot();
+    if (!snapshot.hasCurrentSource || !snapshot.currentSourceMatchesAssigned) {
+      const error = createPlayerError("unknown", true);
+      this.#desiredPlayback = "paused";
+      this.#setState({
+        status: "error",
+        lastTransitionCause: "source-error",
+        error
+      });
+      return;
+    }
+    if (snapshot.ended) {
+      await this.#handleEnded();
+      return;
+    }
+    const wasPlaying = this.#state.status === "playing";
+    const externallyPaused = wasPlaying && snapshot.paused;
+    this.#desiredPlayback = snapshot.paused ? "paused" : "playing";
+    this.#setState({
+      status: snapshot.paused ? "paused" : "playing",
+      currentTimeSec: snapshot.currentTimeSec,
+      durationSec: snapshot.durationSec,
+      volume: clampVolume2(snapshot.volume),
+      muted: snapshot.muted,
+      canSeek: snapshot.durationSec !== null,
+      ...externallyPaused ? {
+        lastTransitionCause: reason === "visibilitychange" || reason === "pageshow" || reason === "focus" || reason === "audio-context-statechange" ? "background-suspension" : "os-interruption"
+      } : {}
+    });
+  }
+  async destroy() {
+    if (this.#destroyed) {
+      return;
+    }
+    await this.#clear();
+    this.#destroyed = true;
+    this.#commandVersion += 1;
+    try {
+      this.#gain?.cancelTransition();
+    } catch {
+    }
+    for (const eventType of PLAYER_MEDIA_EVENT_TYPES) {
+      this.#media.removeEventListener(eventType, this.#mediaListener);
+    }
+    await this.#progressSaveChain;
+    await this.#gain?.destroy();
+    this.#listeners.clear();
+    this.#experienceListeners.clear();
+  }
+  #subscribeTo(collection, listener) {
+    if (this.#destroyed) {
+      return () => void 0;
+    }
+    collection.add(listener);
+    return () => {
+      collection.delete(listener);
+    };
+  }
+  #setState(patch) {
+    const queue = patch.queue ?? this.#state.queue;
+    const currentItem = patch.currentItem === void 0 ? this.#state.currentItem : patch.currentItem;
+    const currentQueueItemId = patch.currentQueueItemId === void 0 ? this.#state.currentQueueItemId : patch.currentQueueItemId;
+    const repeatMode = patch.repeatMode ?? this.#state.repeatMode;
+    const playbackIndex = currentQueueItemId === null ? -1 : this.#playbackOrderCursor;
+    this.#state = createPlayerSnapshot(this.#state, {
+      ...patch,
+      canGoPrevious: currentItem !== null,
+      canGoNext: playbackIndex >= 0 && (playbackIndex < this.#playbackOrderQueueItemIds.length - 1 || this.#playbackOrderQueueItemIds.length > 0 && repeatMode === "all"),
+      queue
+    });
+    for (const listener of this.#listeners) {
+      listener();
+    }
+  }
+  #beginCommand(desiredPlayback = this.#desiredPlayback) {
+    this.#commandVersion += 1;
+    this.#desiredPlayback = desiredPlayback;
+    try {
+      this.#gain?.cancelTransition();
+    } catch {
+      this.#setState({ error: createPlayerError("audio-context", true) });
+    }
+    return this.#commandVersion;
+  }
+  #isCurrentCommand(version) {
+    return !this.#destroyed && version === this.#commandVersion;
+  }
+  #pauseMediaElement() {
+    if (!this.#media.isPaused()) {
+      this.#ignoreNextPauseEvent = true;
+    }
+    this.#media.pause();
+  }
+  #replaceExperienceConfig(config) {
+    const result = validatePlayerExperienceConfig(config);
+    if (!result.ok) {
+      throw new TypeError(result.errors.join(" "));
+    }
+    this.#setState({ experienceConfig: result.value });
+    for (const listener of this.#experienceListeners) {
+      listener();
+    }
+  }
+  #updateExperienceConfig(patch) {
+    this.#replaceExperienceConfig({
+      ...this.#state.experienceConfig,
+      ...patch
+    });
+  }
+  async #load(item) {
+    return this.#setQueue([createLoadedQueueItem(item)]);
+  }
+  async #setQueue(queue, options = {}) {
+    if (this.#destroyed) {
+      return failed(DESTROYED_ERROR);
+    }
+    if (!hasUniqueQueueItemIds(queue)) {
+      return failed(INVALID_QUEUE_ERROR);
+    }
+    if (queue.length === 0) {
+      await this.#clear();
+      return OK_RESULT;
+    }
+    const normalizedQueue = freezeQueue(queue);
+    const startQueueItemId = options.startQueueItemId ?? normalizedQueue[0]?.queueItemId;
+    const startIndex = startQueueItemId === void 0 ? null : findQueueIndex(normalizedQueue, startQueueItemId);
+    if (startIndex === null) {
+      return failed(INVALID_QUEUE_ERROR);
+    }
+    const version = this.#beginCommand(
+      options.autoplay === true ? "playing" : "paused"
+    );
+    const playbackQueue = this.#state.shuffleEnabled && startQueueItemId !== void 0 ? shuffleQueueAroundCurrent(
+      normalizedQueue,
+      startQueueItemId,
+      this.#random
+    ) : normalizedQueue;
+    this.#playbackOrderQueueItemIds = Object.freeze(
+      playbackQueue.map((entry) => entry.queueItemId)
+    );
+    this.#playbackOrderCursor = this.#state.shuffleEnabled ? 0 : startIndex;
+    this.#setState({
+      queue: normalizedQueue,
+      repeatMode: this.#state.repeatMode,
+      error: null
+    });
+    return this.#selectQueueIndex(
+      version,
+      startIndex,
+      options.autoplay === true
+    );
+  }
+  async #selectQueueIndex(version, index, autoplay) {
+    const selected = this.#state.queue[index];
+    if (selected === void 0) {
+      return failed(INVALID_QUEUE_ERROR);
+    }
+    const config = this.#state.experienceConfig;
+    const replacingCurrent = this.#state.currentItem !== null;
+    let transitionError = null;
+    if (replacingCurrent) {
+      void this.#savePodcastProgress(true);
+      if (this.#state.status === "playing") {
+        const fadeResult = await runFade(this.#gain, {
+          target: 0,
+          durationMs: config.trackChangeFadeOutMs,
+          curve: config.fadeCurve
+        });
+        if (!this.#isCurrentCommand(version)) {
+          return OK_RESULT;
+        }
+        if (fadeResult.error !== null) {
+          transitionError = fadeResult.error;
+        }
+      }
+      if (!this.#isCurrentCommand(version)) {
+        return OK_RESULT;
+      }
+      this.#pauseMediaElement();
+    }
+    this.#setState({
+      currentItem: selected.item,
+      currentItemId: selected.item.id,
+      currentQueueItemId: selected.queueItemId,
+      mediaKind: selected.item.kind,
+      status: "loading",
+      currentTimeSec: 0,
+      durationSec: null,
+      canSeek: false,
+      needsUserGesture: false,
+      error: transitionError
+    });
+    try {
+      this.#media.setSource(selected.item.source);
+      this.#media.load();
+    } catch {
+      const error = createPlayerError("unknown", true);
+      this.#setState({ status: "error", error });
+      return failed(error);
+    }
+    await this.#restorePodcastProgress(version, selected.item);
+    if (!this.#isCurrentCommand(version)) {
+      return OK_RESULT;
+    }
+    return autoplay ? this.#playWithCommand(
+      version,
+      config.trackChangeFadeInMs,
+      config.fadeCurve
+    ) : OK_RESULT;
+  }
+  async #restorePodcastProgress(version, item) {
+    const port = this.#podcastProgress;
+    if (port === void 0 || !canUsePodcastProgress(
+      item,
+      port,
+      this.#state.experienceConfig.persistMode
+    )) {
+      return;
+    }
+    try {
+      const progress = await port.load(item.id);
+      if (!this.#isCurrentCommand(version) || this.#state.currentItemId !== item.id || !isUsablePodcastProgress(progress, item)) {
+        return;
+      }
+      const duration = readFiniteDuration(this.#media);
+      const target = duration === null ? progress.positionSec : Math.min(progress.positionSec, duration);
+      this.#media.seekTo(target);
+      this.#lastSavedPodcastPositions.set(item.id, target);
+      this.#setState({ currentTimeSec: target });
+    } catch {
+    }
+  }
+  async #play() {
+    if (this.#destroyed) {
+      return failed(DESTROYED_ERROR);
+    }
+    const version = this.#beginCommand("playing");
+    const config = this.#state.experienceConfig;
+    const result = await this.#playWithCommand(
+      version,
+      config.playFadeInMs,
+      config.fadeCurve
+    );
+    if (result.ok && this.#isCurrentCommand(version)) {
+      this.#setState({ lastTransitionCause: "user-play" });
+    }
+    return result;
+  }
+  async #playWithCommand(version, fadeDurationMs, fadeCurve) {
+    if (this.#state.currentItem === null) {
+      this.#desiredPlayback = "paused";
+      return failed(NO_ITEM_ERROR);
+    }
+    if (this.#gain !== void 0) {
+      try {
+        this.#gain.setValue(fadeDurationMs > 0 ? 0 : 1);
+      } catch {
+        this.#setState({ error: createPlayerError("audio-context", true) });
+      }
+    }
+    try {
+      await this.#media.play();
+    } catch (error) {
+      if (!this.#isCurrentCommand(version)) {
+        return OK_RESULT;
+      }
+      const playerError = classifyPlayError(error, this.#media);
+      this.#desiredPlayback = "paused";
+      this.#restoreGain();
+      this.#setState({
+        status: "error",
+        needsUserGesture: playerError.code === "autoplay-blocked",
+        ...playerError.code === "autoplay-blocked" ? { lastTransitionCause: "autoplay-blocked" } : {},
+        error: playerError
+      });
+      return failed(playerError);
+    }
+    if (!this.#isCurrentCommand(version)) {
+      if (this.#desiredPlayback === "paused") {
+        this.#pauseMediaElement();
+      }
+      return OK_RESULT;
+    }
+    this.#setState({
+      status: "playing",
+      needsUserGesture: false,
+      error: null
+    });
+    const fadeResult = await runFade(this.#gain, {
+      target: 1,
+      durationMs: fadeDurationMs,
+      curve: fadeCurve
+    });
+    if (this.#isCurrentCommand(version) && fadeResult.error !== null) {
+      this.#setState({ error: fadeResult.error });
+    }
+    return OK_RESULT;
+  }
+  async #pause(options = {}) {
+    if (this.#destroyed) {
+      return;
+    }
+    const version = this.#beginCommand("paused");
+    const config = this.#state.experienceConfig;
+    await this.#halt(version, {
+      fadeDurationMs: options.fade === false ? 0 : config.pauseFadeOutMs,
+      fadeCurve: config.fadeCurve,
+      resetPosition: false,
+      transitionCause: "user-pause"
+    });
+  }
+  async #stop(options = {}) {
+    if (this.#destroyed) {
+      return;
+    }
+    const version = this.#beginCommand("paused");
+    const config = this.#state.experienceConfig;
+    await this.#halt(version, {
+      fadeDurationMs: options.fade === false ? 0 : config.pauseFadeOutMs,
+      fadeCurve: config.fadeCurve,
+      resetPosition: options.resetPosition ?? true,
+      transitionCause: "user-stop"
+    });
+  }
+  async #halt(version, options) {
+    void this.#savePodcastProgress(true);
+    const fadeResult = await runFade(this.#gain, {
+      target: 0,
+      durationMs: options.fadeDurationMs,
+      curve: options.fadeCurve
+    });
+    if (!this.#isCurrentCommand(version)) {
+      return false;
+    }
+    if (fadeResult.error !== null) {
+      this.#setState({ error: fadeResult.error });
+    }
+    this.#pauseMediaElement();
+    if (options.resetPosition && this.#state.currentItem !== null) {
+      this.#media.seekTo(0);
+    }
+    this.#setState({
+      status: this.#state.currentItem === null ? "idle" : "paused",
+      currentTimeSec: options.resetPosition ? 0 : readFiniteCurrentTime(this.#media),
+      ...options.transitionCause === void 0 ? {} : { lastTransitionCause: options.transitionCause }
+    });
+    return true;
+  }
+  async #togglePlayback() {
+    if (this.#state.status === "playing") {
+      await this.#pause();
+      return OK_RESULT;
+    }
+    return this.#play();
+  }
+  #seekTo(seconds) {
+    if (this.#destroyed || this.#state.currentItem === null || !Number.isFinite(seconds)) {
+      return;
+    }
+    const duration = readFiniteDuration(this.#media);
+    const lowerBounded = Math.max(seconds, 0);
+    const target = duration === null ? lowerBounded : Math.min(lowerBounded, duration);
+    const version = this.#beginCommand(this.#desiredPlayback);
+    const config = this.#state.experienceConfig;
+    void this.#performSeek(
+      version,
+      target,
+      config.seekFadeMs,
+      config.fadeCurve
+    );
+  }
+  #seekBy(deltaSeconds) {
+    if (!Number.isFinite(deltaSeconds)) {
+      return;
+    }
+    this.#seekTo(readFiniteCurrentTime(this.#media) + deltaSeconds);
+  }
+  async #performSeek(version, target, fadeDurationMs, fadeCurve) {
+    const fadeOut = await runFade(this.#gain, {
+      target: 0,
+      durationMs: fadeDurationMs,
+      curve: fadeCurve
+    });
+    if (!this.#isCurrentCommand(version)) {
+      return;
+    }
+    if (fadeOut.error !== null) {
+      this.#setState({ error: fadeOut.error });
+    }
+    this.#setState({ status: "seeking" });
+    this.#media.seekTo(target);
+    this.#setState({ currentTimeSec: target });
+    const fadeIn = await runFade(this.#gain, {
+      target: 1,
+      durationMs: fadeDurationMs,
+      curve: fadeCurve
+    });
+    if (!this.#isCurrentCommand(version)) {
+      return;
+    }
+    if (fadeIn.error !== null) {
+      this.#setState({ error: fadeIn.error });
+    }
+    this.#setState({
+      status: this.#media.isPaused() ? "paused" : "playing"
+    });
+  }
+  #setVolume(volume) {
+    if (this.#destroyed) {
+      return;
+    }
+    const normalized = clampVolume2(volume);
+    this.#media.setVolume(normalized);
+    this.#setState({ volume: normalized });
+  }
+  #toggleMute() {
+    if (this.#destroyed) {
+      return;
+    }
+    const muted = !this.#state.muted;
+    this.#media.setMuted(muted);
+    this.#setState({ muted });
+  }
+  #setShuffle(enabled) {
+    if (this.#destroyed || enabled === this.#state.shuffleEnabled) {
+      return;
+    }
+    const currentQueueItemId = this.#state.currentQueueItemId;
+    if (currentQueueItemId === null) {
+      this.#setState({ shuffleEnabled: enabled });
+      return;
+    }
+    const playbackQueue = enabled ? shuffleQueueAroundCurrent(
+      this.#state.queue,
+      currentQueueItemId,
+      this.#random
+    ) : this.#state.queue;
+    this.#playbackOrderQueueItemIds = Object.freeze(
+      playbackQueue.map((entry) => entry.queueItemId)
+    );
+    this.#playbackOrderCursor = enabled ? 0 : findQueueIndex(this.#state.queue, currentQueueItemId) ?? -1;
+    this.#setState({
+      shuffleEnabled: enabled
+    });
+  }
+  #setRepeatMode(mode) {
+    if (this.#destroyed) {
+      return;
+    }
+    this.#setState({ repeatMode: mode });
+  }
+  async #next() {
+    if (this.#destroyed) {
+      return failed(DESTROYED_ERROR);
+    }
+    const currentQueueItemId = this.#state.currentQueueItemId;
+    if (currentQueueItemId === null) {
+      return failed(NO_ITEM_ERROR);
+    }
+    const nextPlaybackIndex = this.#getNextPlaybackIndex(
+      currentQueueItemId
+    );
+    if (nextPlaybackIndex === null) {
+      return OK_RESULT;
+    }
+    const nextQueueItemId = this.#playbackOrderQueueItemIds[nextPlaybackIndex];
+    const nextIndex = nextQueueItemId === void 0 ? null : findQueueIndex(this.#state.queue, nextQueueItemId);
+    if (nextIndex === null) {
+      return failed(INVALID_QUEUE_ERROR);
+    }
+    this.#playbackOrderCursor = nextPlaybackIndex;
+    const autoplay = this.#state.status === "playing";
+    const version = this.#beginCommand(
+      autoplay ? "playing" : "paused"
+    );
+    return this.#selectQueueIndex(version, nextIndex, autoplay);
+  }
+  async #previous() {
+    if (this.#destroyed) {
+      return failed(DESTROYED_ERROR);
+    }
+    const currentIndex = this.#state.currentQueueIndex;
+    const currentItem = this.#state.currentItem;
+    if (currentIndex === null || currentItem === null) {
+      return failed(NO_ITEM_ERROR);
+    }
+    const config = this.#state.experienceConfig;
+    const currentTime = readFiniteCurrentTime(this.#media);
+    const shouldRestartTrack = currentItem.kind === "track" && config.previousRestartThresholdSec > 0 && currentTime >= config.previousRestartThresholdSec;
+    const shouldRestartPodcast = currentItem.kind === "podcastEpisode" && config.podcastPreviousMode === "restart-episode";
+    const previousPlaybackIndex = getPreviousQueueIndex(
+      this.#playbackOrderQueueItemIds,
+      this.#playbackOrderCursor
+    );
+    const previousQueueItemId = previousPlaybackIndex === null ? void 0 : this.#playbackOrderQueueItemIds[previousPlaybackIndex];
+    const previousIndex = previousQueueItemId === void 0 ? null : findQueueIndex(this.#state.queue, previousQueueItemId);
+    if (shouldRestartTrack || shouldRestartPodcast || previousPlaybackIndex === null || previousIndex === null) {
+      this.#seekTo(0);
+      return OK_RESULT;
+    }
+    this.#playbackOrderCursor = previousPlaybackIndex;
+    const autoplay = this.#state.status === "playing";
+    const version = this.#beginCommand(
+      autoplay ? "playing" : "paused"
+    );
+    return this.#selectQueueIndex(version, previousIndex, autoplay);
+  }
+  async #retry() {
+    if (this.#destroyed) {
+      return failed(DESTROYED_ERROR);
+    }
+    if (this.#state.currentQueueIndex === null || this.#state.error === null || !this.#state.error.recoverable) {
+      return failed(this.#state.error ?? NO_ITEM_ERROR);
+    }
+    const version = this.#beginCommand("playing");
+    this.#setState({ error: null, needsUserGesture: false });
+    return this.#selectQueueIndex(
+      version,
+      this.#state.currentQueueIndex,
+      true
+    );
+  }
+  async #clear() {
+    if (this.#destroyed) {
+      return;
+    }
+    const version = this.#beginCommand("paused");
+    const config = this.#state.experienceConfig;
+    const halted = await this.#halt(version, {
+      fadeDurationMs: config.pauseFadeOutMs,
+      fadeCurve: config.fadeCurve,
+      resetPosition: true
+    });
+    if (!halted || !this.#isCurrentCommand(version)) {
+      return;
+    }
+    this.#media.clearSource();
+    this.#playbackOrderQueueItemIds = Object.freeze([]);
+    this.#playbackOrderCursor = -1;
+    this.#setState({
+      currentItem: null,
+      currentItemId: null,
+      currentQueueItemId: null,
+      mediaKind: null,
+      status: "idle",
+      currentTimeSec: 0,
+      durationSec: null,
+      queue: Object.freeze([]),
+      canSeek: false,
+      needsUserGesture: false,
+      error: null
+    });
+  }
+  #restoreGain() {
+    try {
+      this.#gain?.setValue(1);
+    } catch {
+      this.#setState({ error: createPlayerError("audio-context", true) });
+    }
+  }
+  async #savePodcastProgress(force) {
+    const item = this.#state.currentItem;
+    const port = this.#podcastProgress;
+    if (port === void 0 || !canUsePodcastProgress(
+      item,
+      port,
+      this.#state.experienceConfig.persistMode
+    )) {
+      return;
+    }
+    const position = readFiniteCurrentTime(this.#media);
+    const lastPosition = this.#lastSavedPodcastPositions.get(item.id);
+    if (!force && lastPosition !== void 0 && Math.abs(position - lastPosition) < this.#podcastProgressSaveIntervalSec) {
+      return;
+    }
+    const progress = createPodcastProgress(item, position, this.#now);
+    this.#lastSavedPodcastPositions.set(item.id, position);
+    this.#progressSaveChain = this.#progressSaveChain.then(() => port.save(progress)).catch(() => void 0);
+    await this.#progressSaveChain;
+  }
+  #handleMediaEvent(event) {
+    if (this.#destroyed) {
+      return;
+    }
+    const snapshot = this.#media.getStateSnapshot();
+    if (this.#state.currentItem !== null && (!snapshot.hasCurrentSource || !snapshot.currentSourceMatchesAssigned)) {
+      this.#desiredPlayback = "paused";
+      this.#setState({
+        status: "error",
+        lastTransitionCause: "source-error",
+        error: createPlayerError("unknown", true)
+      });
+      return;
+    }
+    this.#setState({
+      currentTimeSec: snapshot.currentTimeSec,
+      durationSec: snapshot.durationSec,
+      volume: clampVolume2(snapshot.volume),
+      muted: snapshot.muted,
+      canSeek: snapshot.durationSec !== null
+    });
+    switch (event.type) {
+      case "loadstart":
+        this.#setState({ status: "loading" });
+        break;
+      case "loadedmetadata":
+      case "durationchange": {
+        const duration = readFiniteDuration(this.#media);
+        this.#setState({
+          durationSec: duration,
+          canSeek: duration !== null
+        });
+        break;
+      }
+      case "canplay":
+        this.#setState({
+          status: this.#media.isPaused() ? "paused" : "playing"
+        });
+        break;
+      case "play":
+      case "playing":
+        if (this.#desiredPlayback === "paused") {
+          this.#pauseMediaElement();
+          break;
+        }
+        this.#setState({
+          status: "playing",
+          needsUserGesture: false,
+          error: null
+        });
+        break;
+      case "pause":
+        if (this.#ignoreNextPauseEvent) {
+          this.#ignoreNextPauseEvent = false;
+          break;
+        }
+        if (this.#desiredPlayback === "playing") {
+          this.#desiredPlayback = "paused";
+        }
+        if (this.#state.status !== "ended") {
+          this.#setState({
+            status: this.#state.currentItem === null ? "idle" : "paused",
+            ...this.#state.status === "playing" ? { lastTransitionCause: "os-interruption" } : {}
+          });
+        }
+        break;
+      case "waiting":
+      case "stalled":
+        this.#setState({ status: "loading" });
+        break;
+      case "seeking":
+        this.#setState({ status: "seeking" });
+        break;
+      case "seeked":
+        this.#setState({
+          currentTimeSec: readFiniteCurrentTime(this.#media),
+          status: this.#media.isPaused() ? "paused" : "playing"
+        });
+        break;
+      case "timeupdate":
+        this.#setState({
+          currentTimeSec: readFiniteCurrentTime(this.#media),
+          ...this.#state.status === "loading" && !snapshot.paused ? { status: "playing" } : {}
+        });
+        void this.#savePodcastProgress(false);
+        break;
+      case "ended":
+        void this.#handleEnded();
+        break;
+      case "error": {
+        const error = this.#media.getError() ?? createPlayerError("unknown", true);
+        this.#desiredPlayback = "paused";
+        this.#setState({
+          status: "error",
+          lastTransitionCause: "source-error",
+          error
+        });
+        break;
+      }
+      case "volumechange":
+        this.#setState({
+          volume: clampVolume2(this.#media.getVolume()),
+          muted: this.#media.isMuted()
+        });
+        break;
+    }
+  }
+  async #handleEnded() {
+    if (this.#handlingEnded) {
+      return;
+    }
+    this.#handlingEnded = true;
+    try {
+      await this.#advanceAfterEnded();
+    } finally {
+      this.#handlingEnded = false;
+    }
+  }
+  async #advanceAfterEnded() {
+    this.#setState({ lastTransitionCause: "natural-end" });
+    void this.#savePodcastProgress(true);
+    const currentQueueItemId = this.#state.currentQueueItemId;
+    if (currentQueueItemId === null) {
+      return;
+    }
+    if (this.#state.repeatMode === "one") {
+      const version2 = this.#beginCommand("playing");
+      const config = this.#state.experienceConfig;
+      this.#media.seekTo(0);
+      this.#setState({ currentTimeSec: 0, status: "loading" });
+      await this.#playWithCommand(
+        version2,
+        config.trackChangeFadeInMs,
+        config.fadeCurve
+      );
+      return;
+    }
+    const nextPlaybackIndex = this.#getNextPlaybackIndex(
+      currentQueueItemId
+    );
+    if (nextPlaybackIndex === null) {
+      this.#desiredPlayback = "paused";
+      this.#setState({
+        status: "ended",
+        currentTimeSec: readFiniteDuration(this.#media) ?? readFiniteCurrentTime(this.#media)
+      });
+      return;
+    }
+    const nextQueueItemId = this.#playbackOrderQueueItemIds[nextPlaybackIndex];
+    const nextIndex = nextQueueItemId === void 0 ? null : findQueueIndex(this.#state.queue, nextQueueItemId);
+    if (nextIndex === null) {
+      this.#desiredPlayback = "paused";
+      this.#setState({
+        status: "error",
+        error: INVALID_QUEUE_ERROR
+      });
+      return;
+    }
+    this.#playbackOrderCursor = nextPlaybackIndex;
+    const version = this.#beginCommand("playing");
+    await this.#selectQueueIndex(version, nextIndex, true);
+  }
+  #getNextPlaybackIndex(currentQueueItemId) {
+    if (this.#playbackOrderCursor >= 0 && this.#playbackOrderCursor < this.#playbackOrderQueueItemIds.length - 1) {
+      return this.#playbackOrderCursor + 1;
+    }
+    if (!this.#state.shuffleEnabled) {
+      return getNextQueueIndex(
+        this.#playbackOrderQueueItemIds,
+        this.#playbackOrderCursor,
+        this.#state.repeatMode
+      );
+    }
+    if (this.#state.repeatMode !== "all") {
+      return null;
+    }
+    const shuffled = shuffleQueueAroundCurrent(
+      this.#state.queue,
+      currentQueueItemId,
+      this.#random
+    );
+    const continuation = shuffled.slice(1).map((entry) => entry.queueItemId);
+    if (continuation.length === 0) {
+      if (this.#state.queue.length !== 1) {
+        return null;
+      }
+      continuation.push(currentQueueItemId);
+    }
+    this.#playbackOrderQueueItemIds = Object.freeze([
+      ...this.#playbackOrderQueueItemIds,
+      ...continuation
+    ]);
+    let appendedIndex = this.#playbackOrderCursor + 1;
+    if (this.#playbackOrderQueueItemIds.length > MAX_SHUFFLE_HISTORY_ITEMS && this.#playbackOrderCursor > RETAINED_SHUFFLE_HISTORY_ITEMS) {
+      const removeCount = this.#playbackOrderCursor - RETAINED_SHUFFLE_HISTORY_ITEMS;
+      this.#playbackOrderQueueItemIds = Object.freeze(
+        this.#playbackOrderQueueItemIds.slice(removeCount)
+      );
+      this.#playbackOrderCursor -= removeCount;
+      appendedIndex -= removeCount;
+    }
+    return appendedIndex;
+  }
+};
+function createPlayerStore(options) {
+  return new CorePlayerStore(options);
+}
+
+// src/react/runtime-commands.ts
+function activate(gain, options) {
+  options.onUserActivation?.();
+  try {
+    const activation = gain.activateFromUserGesture();
+    if (activation !== void 0) {
+      void activation.catch(() => {
+        options.onActivationError?.();
+      });
+    }
+  } catch {
+    options.onActivationError?.();
+  }
+}
+function reportCommand(options, command) {
+  options.onCommand?.(command);
+}
+function createGestureAwareCommands(commands, gain, activationOptions = {}) {
+  return Object.freeze({
+    load(item) {
+      reportCommand(activationOptions, "load");
+      return commands.load(item);
+    },
+    setQueue(queue, commandOptions) {
+      reportCommand(activationOptions, "setQueue");
+      if (commandOptions?.autoplay === true) {
+        activate(gain, activationOptions);
+      }
+      return commands.setQueue(queue, commandOptions);
+    },
+    play() {
+      reportCommand(activationOptions, "play");
+      activate(gain, activationOptions);
+      return commands.play();
+    },
+    pause(options) {
+      reportCommand(activationOptions, "pause");
+      return commands.pause(options);
+    },
+    stop(options) {
+      reportCommand(activationOptions, "stop");
+      return commands.stop(options);
+    },
+    togglePlayback() {
+      reportCommand(activationOptions, "togglePlayback");
+      activate(gain, activationOptions);
+      return commands.togglePlayback();
+    },
+    seekTo(seconds) {
+      reportCommand(activationOptions, "seekTo");
+      activate(gain, activationOptions);
+      commands.seekTo(seconds);
+    },
+    seekBy(deltaSeconds) {
+      reportCommand(activationOptions, "seekBy");
+      activate(gain, activationOptions);
+      commands.seekBy(deltaSeconds);
+    },
+    setVolume(volume) {
+      reportCommand(activationOptions, "setVolume");
+      commands.setVolume(volume);
+    },
+    toggleMute() {
+      reportCommand(activationOptions, "toggleMute");
+      commands.toggleMute();
+    },
+    setShuffle(enabled) {
+      reportCommand(activationOptions, "setShuffle");
+      commands.setShuffle(enabled);
+    },
+    setRepeatMode(mode) {
+      reportCommand(activationOptions, "setRepeatMode");
+      commands.setRepeatMode(mode);
+    },
+    next() {
+      reportCommand(activationOptions, "next");
+      activate(gain, activationOptions);
+      return commands.next();
+    },
+    previous() {
+      reportCommand(activationOptions, "previous");
+      activate(gain, activationOptions);
+      return commands.previous();
+    },
+    retry() {
+      reportCommand(activationOptions, "retry");
+      activate(gain, activationOptions);
+      return commands.retry();
+    },
+    clear() {
+      reportCommand(activationOptions, "clear");
+      return commands.clear();
+    }
+  });
+}
+var DIAGNOSTIC_MEDIA_EVENTS = [
+  "loadstart",
+  "loadedmetadata",
+  "canplay",
+  "play",
+  "playing",
+  "pause",
+  "waiting",
+  "stalled",
+  "seeking",
+  "seeked",
+  "timeupdate",
+  "ended",
+  "error",
+  "durationchange",
+  "volumechange"
+];
+var EMPTY_INITIAL_QUEUE = Object.freeze([]);
+var PlayerRuntimeContext = createContext(null);
+function PlayerProvider({
+  audioMode = "auto",
+  children,
+  experienceConfig,
+  initialQueue = EMPTY_INITIAL_QUEUE,
+  initialQueueItemId,
+  loadingFallback = null,
+  onDiagnosticEvent
+}) {
+  const audioRef = useRef(null);
+  const initialQueueRef = useRef(initialQueue);
+  const initialQueueItemIdRef = useRef(initialQueueItemId);
+  const initialExperienceConfigRef = useRef(experienceConfig);
+  const diagnosticListenerRef = useRef(onDiagnosticEvent);
+  const [runtime, setRuntime] = useState(null);
+  const [audioContextState, setAudioContextState] = useState("uninitialized");
+  const [resolvedAudioMode, setResolvedAudioMode] = useState("web-audio");
+  const [mediaSessionSupported, setMediaSessionSupported] = useState(false);
+  const [
+    mediaSessionActionsEnabled,
+    setMediaSessionActionsEnabled
+  ] = useState(false);
+  useEffect(() => {
+    diagnosticListenerRef.current = onDiagnosticEvent;
+  }, [onDiagnosticEvent]);
+  useEffect(() => {
+    const audioElement = audioRef.current;
+    if (audioElement === null) {
+      return;
+    }
+    let active = true;
+    let synchronizeFromLifecycle = null;
+    const emitDiagnostic = (event) => {
+      diagnosticListenerRef.current?.({
+        ...event,
+        occurredAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    };
+    const media = new BrowserMediaElementPort(audioElement);
+    const navigatorPlatform = Reflect.get(
+      navigator,
+      "platform"
+    );
+    const nextAudioMode = resolvePlayerAudioMode(audioMode, {
+      userAgent: navigator.userAgent,
+      ...typeof navigatorPlatform === "string" ? { platform: navigatorPlatform } : {},
+      maxTouchPoints: navigator.maxTouchPoints
+    });
+    const gain = nextAudioMode === "web-audio" ? new LazyWebAudioGainPort(audioElement, {
+      onContextStateChange: (state) => {
+        if (active) {
+          setAudioContextState(state);
+          emitDiagnostic({
+            type: "audio-context-statechange",
+            state
+          });
+          synchronizeFromLifecycle?.(
+            "audio-context-statechange"
+          );
+        }
+      }
+    }) : new HtmlMediaElementGainPort();
+    setResolvedAudioMode(nextAudioMode);
+    setAudioContextState(
+      gain instanceof LazyWebAudioGainPort ? gain.getContextState() : "uninitialized"
+    );
+    const store = createPlayerStore({
+      gain,
+      media,
+      ...initialExperienceConfigRef.current === void 0 ? {} : { experienceConfig: initialExperienceConfigRef.current }
+    });
+    let mediaSessionController = null;
+    const commands = createGestureAwareCommands(store.commands, gain, {
+      onUserActivation: () => {
+        mediaSessionController?.enableActionHandlers();
+        if (active) {
+          setMediaSessionActionsEnabled(
+            mediaSessionController?.actionsEnabled ?? false
+          );
+        }
+      },
+      onCommand: (command) => {
+        emitDiagnostic({ type: "command", command });
+      },
+      onActivationError: () => {
+        emitDiagnostic({
+          type: "audio-context-resume",
+          outcome: "failed",
+          state: gain instanceof LazyWebAudioGainPort ? gain.getContextState() : "uninitialized",
+          errorCode: "audio-context"
+        });
+      }
+    });
+    mediaSessionController = createBrowserMediaSessionController({
+      commands,
+      getState: () => store.getState(),
+      onAction: (action) => {
+        emitDiagnostic({
+          type: "media-session-action",
+          action,
+          failed: false
+        });
+      },
+      onActionError: (action) => {
+        emitDiagnostic({
+          type: "media-session-action",
+          action,
+          failed: true
+        });
+      }
+    });
+    const activeMediaSessionController = mediaSessionController;
+    setMediaSessionSupported(activeMediaSessionController.supported);
+    setMediaSessionActionsEnabled(false);
+    const unsubscribeMediaSession = store.subscribe(() => {
+      activeMediaSessionController.update(store.getState());
+    });
+    activeMediaSessionController.update(store.getState());
+    const synchronize = (reason) => {
+      const resumeAudioContext = async () => {
+        if (!(gain instanceof LazyWebAudioGainPort) || gain.getContextState() !== "suspended") {
+          return;
+        }
+        try {
+          const resumed = await gain.resumeIfSuspended();
+          if (resumed) {
+            emitDiagnostic({
+              type: "audio-context-resume",
+              outcome: "resumed",
+              state: gain.getContextState(),
+              errorCode: null
+            });
+          }
+        } catch {
+          emitDiagnostic({
+            type: "audio-context-resume",
+            outcome: "failed",
+            state: gain.getContextState(),
+            errorCode: "audio-context"
+          });
+        }
+      };
+      void resumeAudioContext().then(() => store.synchronizeFromMedia(reason)).finally(() => {
+        if (!active) {
+          return;
+        }
+        if (gain instanceof LazyWebAudioGainPort) {
+          setAudioContextState(gain.getContextState());
+        }
+        activeMediaSessionController.update(store.getState());
+        emitDiagnostic({
+          type: "lifecycle-sync",
+          reason,
+          visibility: document.visibilityState,
+          media: media.getStateSnapshot()
+        });
+      });
+    };
+    synchronizeFromLifecycle = synchronize;
+    const handleVisibilityChange = () => {
+      if (document.visibilityState === "visible") {
+        synchronize("visibilitychange");
+      }
+    };
+    const handlePageShow = () => {
+      synchronize("pageshow");
+    };
+    const handleFocus = () => {
+      synchronize("focus");
+    };
+    const mediaEventListeners = /* @__PURE__ */ new Map();
+    for (const eventType of DIAGNOSTIC_MEDIA_EVENTS) {
+      const listener = () => {
+        emitDiagnostic({
+          type: "media-event",
+          event: eventType,
+          media: media.getStateSnapshot()
+        });
+        activeMediaSessionController.update(store.getState());
+      };
+      mediaEventListeners.set(eventType, listener);
+      media.addEventListener(eventType, listener);
+    }
+    document.addEventListener(
+      "visibilitychange",
+      handleVisibilityChange
+    );
+    window.addEventListener("pageshow", handlePageShow);
+    window.addEventListener("focus", handleFocus);
+    const contextValue2 = {
+      store,
+      commands,
+      experience: store.experience,
+      audioContextState: "uninitialized",
+      audioMode: nextAudioMode,
+      mediaSessionSupported: activeMediaSessionController.supported,
+      mediaSessionActionsEnabled: false
+    };
+    setRuntime(contextValue2);
+    void store.commands.setQueue(initialQueueRef.current, {
+      ...initialQueueItemIdRef.current === void 0 ? {} : { startQueueItemId: initialQueueItemIdRef.current },
+      autoplay: false
+    });
+    return () => {
+      active = false;
+      synchronizeFromLifecycle = null;
+      document.removeEventListener(
+        "visibilitychange",
+        handleVisibilityChange
+      );
+      window.removeEventListener("pageshow", handlePageShow);
+      window.removeEventListener("focus", handleFocus);
+      for (const [eventType, listener] of mediaEventListeners) {
+        media.removeEventListener(eventType, listener);
+      }
+      unsubscribeMediaSession();
+      activeMediaSessionController.destroy();
+      setRuntime(
+        (current) => current?.store === store ? null : current
+      );
+      void store.destroy();
+    };
+  }, [
+    audioMode
+  ]);
+  const contextValue = runtime === null ? null : {
+    ...runtime,
+    audioContextState,
+    audioMode: resolvedAudioMode,
+    mediaSessionSupported,
+    mediaSessionActionsEnabled
+  };
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx(
+      "audio",
+      {
+        "aria-hidden": "true",
+        "data-audio-context-state": audioContextState,
+        "data-audio-mode": resolvedAudioMode,
+        "data-media-session-actions": mediaSessionActionsEnabled ? "enabled" : "inactive",
+        "data-media-session-supported": mediaSessionSupported ? "true" : "false",
+        "data-player-audio": "true",
+        preload: "metadata",
+        ref: audioRef
+      }
+    ),
+    contextValue === null ? loadingFallback : /* @__PURE__ */ jsx(PlayerRuntimeContext.Provider, { value: contextValue, children })
+  ] });
+}
+function MiniPlayerHost({
+  children,
+  className,
+  onInsetChange,
+  visible
+}) {
+  const hostRef = useRef(null);
+  useEffect(() => {
+    if (!visible) {
+      onInsetChange?.(0);
+      return;
+    }
+    const host = hostRef.current;
+    if (host === null) {
+      return;
+    }
+    const publishInset = () => {
+      onInsetChange?.(Math.ceil(host.getBoundingClientRect().height));
+    };
+    publishInset();
+    if (typeof ResizeObserver === "undefined") {
+      return () => {
+        onInsetChange?.(0);
+      };
+    }
+    const observer = new ResizeObserver(publishInset);
+    observer.observe(host);
+    return () => {
+      observer.disconnect();
+      onInsetChange?.(0);
+    };
+  }, [onInsetChange, visible]);
+  if (!visible) {
+    return null;
+  }
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      className,
+      "data-player-mini-host": "true",
+      ref: hostRef,
+      children
+    }
+  );
+}
+function usePlayerRuntimeContext() {
+  const context = useContext(PlayerRuntimeContext);
+  if (context === null) {
+    throw new Error("usePlayer must be used inside PlayerProvider.");
+  }
+  return context;
+}
+function usePlayer() {
+  const context = usePlayerRuntimeContext();
+  const state = useSyncExternalStore(
+    (listener) => context.store.subscribe(listener),
+    () => context.store.getState(),
+    () => context.store.getState()
+  );
+  return {
+    state,
+    commands: context.commands,
+    experience: context.experience,
+    audioContextState: context.audioContextState,
+    audioMode: context.audioMode,
+    mediaSessionSupported: context.mediaSessionSupported,
+    mediaSessionActionsEnabled: context.mediaSessionActionsEnabled
+  };
+}
+
+export { MiniPlayerHost, PlayerProvider, usePlayer };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map