@f8team/reel-core 1.0.0

package/dist/index.cjs

@@ -0,0 +1,2014 @@
+'use strict';
+
+// src/errors/registry.ts
+var RETRYABLE_BY_DEFAULT = {
+  source: false,
+  network: true,
+  decode: false,
+  unauthorized: false,
+  unsupported: false,
+  internal: false
+};
+function createPlayerError(input) {
+  const error = {
+    code: input.code,
+    message: input.message,
+    retryable: input.retryable ?? RETRYABLE_BY_DEFAULT[input.code]
+  };
+  if (input.cause !== void 0) error.cause = input.cause;
+  if (input.status !== void 0) error.status = input.status;
+  if (input.url !== void 0) error.url = input.url;
+  return error;
+}
+
+// src/errors/classify.ts
+function classifyMediaError(err, url) {
+  const code = err?.code ?? 0;
+  const message = err?.message || "Media error";
+  switch (code) {
+    case 1:
+      return createPlayerError({ code: "internal", message: "Media playback aborted", url });
+    case 2:
+      return createPlayerError({ code: "network", message, url, retryable: true });
+    case 3:
+      return createPlayerError({ code: "decode", message, url });
+    case 4:
+      return createPlayerError({ code: "unsupported", message, url });
+    default:
+      return createPlayerError({ code: "internal", message, url, cause: err });
+  }
+}
+function classifyUnknown(err, url) {
+  if (err instanceof Error) {
+    return createPlayerError({
+      code: "internal",
+      message: err.message || "Unknown error",
+      cause: err,
+      url
+    });
+  }
+  return createPlayerError({
+    code: "internal",
+    message: typeof err === "string" ? err : "Unknown error",
+    cause: err,
+    url
+  });
+}
+
+// src/events/bus.ts
+function createEventBus() {
+  const buckets = /* @__PURE__ */ new Map();
+  function on(event, listener) {
+    const key = String(event);
+    let set = buckets.get(key);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      buckets.set(key, set);
+    }
+    set.add(listener);
+    return () => off(event, listener);
+  }
+  function off(event, listener) {
+    const key = String(event);
+    const set = buckets.get(key);
+    if (!set) return;
+    set.delete(listener);
+    if (set.size === 0) buckets.delete(key);
+  }
+  function emit(event, payload) {
+    const key = String(event);
+    const set = buckets.get(key);
+    if (!set || set.size === 0) return;
+    const snapshot = Array.from(set);
+    for (const listener of snapshot) {
+      try {
+        listener(payload);
+      } catch (err) {
+        console.error(`[@f8team/reel-core] listener for "${key}" threw:`, err);
+      }
+    }
+  }
+  function clear() {
+    buckets.clear();
+  }
+  function listenerCount(event) {
+    return buckets.get(event)?.size ?? 0;
+  }
+  return {
+    on,
+    off,
+    emit,
+    clear,
+    listenerCount
+  };
+}
+
+// src/plugins/bus.ts
+function createPluginBus({ player, host }) {
+  const entries = [];
+  function findIndex(name) {
+    return entries.findIndex((e) => e.plugin.name === name);
+  }
+  function register(plugin) {
+    if (findIndex(plugin.name) >= 0) {
+      throw new Error(`[@f8team/reel-core] plugin "${plugin.name}" is already registered`);
+    }
+    let teardown = null;
+    try {
+      const result = plugin.setup(player, host);
+      teardown = typeof result === "function" ? result : null;
+    } catch (err) {
+      throw new Error(
+        `[@f8team/reel-core] plugin "${plugin.name}" setup threw: ${err.message}`,
+        { cause: err }
+      );
+    }
+    entries.push({ plugin, teardown });
+  }
+  function unregister(name) {
+    const idx = findIndex(name);
+    if (idx < 0) return;
+    const entry = entries.splice(idx, 1)[0];
+    if (!entry) return;
+    if (entry.teardown) {
+      try {
+        entry.teardown();
+      } catch (err) {
+        console.error(`[@f8team/reel-core] plugin "${name}" teardown threw:`, err);
+      }
+    }
+  }
+  function has(name) {
+    return findIndex(name) >= 0;
+  }
+  function list() {
+    return entries.map((e) => e.plugin.name);
+  }
+  function disposeAll() {
+    while (entries.length) {
+      const entry = entries.pop();
+      if (entry?.teardown) {
+        try {
+          entry.teardown();
+        } catch (err) {
+          console.error(
+            `[@f8team/reel-core] plugin "${entry.plugin.name}" teardown threw on dispose:`,
+            err
+          );
+        }
+      }
+    }
+  }
+  return { register, unregister, has, list, disposeAll };
+}
+
+// src/plugins/commands.ts
+function createCommandRegistry() {
+  const handlers = /* @__PURE__ */ new Map();
+  function add(name, handler) {
+    if (handlers.has(name)) {
+      throw new Error(`[@f8team/reel-core] command "${name}" is already registered`);
+    }
+    handlers.set(name, handler);
+    return () => {
+      const current = handlers.get(name);
+      if (current === handler) handlers.delete(name);
+    };
+  }
+  function run(name, payload) {
+    const handler = handlers.get(name);
+    if (!handler) return;
+    try {
+      handler(payload);
+    } catch (err) {
+      console.error(`[@f8team/reel-core] command "${name}" threw:`, err);
+    }
+  }
+  function has(name) {
+    return handlers.has(name);
+  }
+  return { add, run, has };
+}
+
+// src/plugins/host.ts
+function createControlsRegistry() {
+  const slots = /* @__PURE__ */ new Map();
+  function contribute(slot, render) {
+    let set = slots.get(slot);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      slots.set(slot, set);
+    }
+    set.add(render);
+    return () => {
+      slots.get(slot)?.delete(render);
+    };
+  }
+  function snapshot(slot) {
+    const set = slots.get(slot);
+    return set ? Array.from(set) : [];
+  }
+  function clear() {
+    slots.clear();
+  }
+  return { contribute, snapshot, clear };
+}
+function createPluginHost({ commands, controls, store, bus }) {
+  return {
+    controls: {
+      contribute: (slot, render) => controls.contribute(slot, render)
+    },
+    commands,
+    store,
+    emit: (event, payload) => {
+      bus.emit(event, payload);
+    }
+  };
+}
+
+// src/util/url.ts
+function looksLikeHls(input) {
+  if (!input) return false;
+  const lower = input.toLowerCase();
+  if (lower.includes("youtube.com") || lower.includes("youtu.be")) return false;
+  if (lower.includes(".m3u8")) return true;
+  if (lower.includes("application/vnd.apple.mpegurl")) return true;
+  return false;
+}
+function looksLikeYouTube(input) {
+  if (!input) return false;
+  const lower = input.toLowerCase();
+  return lower.includes("youtube.com") || lower.includes("youtu.be");
+}
+function looksLikeProgressive(input) {
+  if (!input) return false;
+  const lower = input.toLowerCase();
+  if (lower.startsWith("blob:") || lower.startsWith("data:")) return true;
+  return /\.(mp4|m4v|webm|ogv)(\?|#|$)/.test(lower);
+}
+function detectSourceType(source) {
+  if (source.type && source.type !== "auto") return source.type;
+  if (looksLikeHls(source.src)) return "hls";
+  if (looksLikeYouTube(source.src)) return "youtube";
+  if (looksLikeProgressive(source.src)) return "mp4";
+  return "native";
+}
+function resolveWithCredentials(policy, url) {
+  if (typeof policy === "boolean") return policy;
+  if (typeof policy === "function") {
+    try {
+      return policy(url);
+    } catch {
+      return false;
+    }
+  }
+  return false;
+}
+
+// src/sources/hls.ts
+var defaultLoad = () => {
+  return import('hls.js').then((m) => m.default);
+};
+function makeAbortError() {
+  const err = new Error("HLS loader aborted");
+  err.name = "AbortError";
+  return err;
+}
+var HlsLoader = class {
+  constructor(options) {
+    this.options = options;
+    this.hls = null;
+    this.video = null;
+    this.detachListeners = [];
+    this.qualities = [];
+    this.currentSource = null;
+    this.unauthorizedFired = false;
+    // Track every XHR that hls.js spawns so we can abort and remove their
+    // readystatechange watcher on `abort()` / `detach()`. Without this set the
+    // watcher closure leaks for every media segment (A1 in the review).
+    this.liveXhrs = /* @__PURE__ */ new Set();
+    this.rejectAttach = null;
+    this.manifestTimeout = null;
+    this.aborted = false;
+    /** `false` idle; `'auto'` → first `LEVEL_SWITCHED` clears; otherwise await this level index. */
+    this.qualityAwait = false;
+    this.qualitySwitchTimer = null;
+    /** Tracks consecutive menu selections so redundant "Auto → Auto" skips the spinner. */
+    this.lastChosenQualityWasAuto = false;
+    /**
+     * `null` — user chose ABR auto (menu shows "Auto"). Real hls.js still exposes
+     * `currentLevel >= 0` for the playing rendition; we must not mirror that into UI state.
+     */
+    this.manualLevelIndex = null;
+  }
+  async attach(video, source) {
+    this.detach();
+    this.aborted = false;
+    this.video = video;
+    this.currentSource = source;
+    this.unauthorizedFired = false;
+    const Hls = await (this.options.loadRuntime ?? defaultLoad)();
+    if (this.aborted) {
+      throw makeAbortError();
+    }
+    if (!Hls.isSupported()) {
+      return this.attachNative(video, source);
+    }
+    return this.attachWithHlsJs(Hls, video, source);
+  }
+  /**
+   * Native-HLS branch (Safari iOS / desktop without MSE). Listeners are
+   * pushed into `detachListeners` so that an early `detach()` / `abort()`
+   * cleans them up instead of leaking (C3 in the review).
+   */
+  attachNative(video, source) {
+    return new Promise((resolve, reject) => {
+      this.rejectAttach = reject;
+      let settled = false;
+      const settle = (run) => {
+        if (settled) return;
+        settled = true;
+        run();
+      };
+      const onMeta = () => settle(() => resolve());
+      const onError = () => settle(() => reject(new Error("Native HLS playback failed")));
+      video.addEventListener("loadedmetadata", onMeta);
+      video.addEventListener("error", onError);
+      this.detachListeners.push(
+        () => video.removeEventListener("loadedmetadata", onMeta),
+        () => video.removeEventListener("error", onError),
+        () => settle(() => {
+          reject(makeAbortError());
+        })
+      );
+      try {
+        video.src = source.src;
+        video.load();
+      } catch (err) {
+        settle(() => reject(err instanceof Error ? err : new Error(String(err))));
+      }
+    });
+  }
+  attachWithHlsJs(Hls, video, source) {
+    const hls = new Hls({
+      enableWorker: true,
+      xhrSetup: (xhr, url) => this.installXhrWatcher(xhr, url, source)
+    });
+    this.hls = hls;
+    return new Promise((resolve, reject) => {
+      this.rejectAttach = reject;
+      let settled = false;
+      const settle = (run) => {
+        if (settled) return;
+        settled = true;
+        this.clearManifestTimeout();
+        run();
+      };
+      const onParsed = () => {
+        this.refreshQualities();
+        settle(() => resolve());
+      };
+      const onSwitched = (...args) => {
+        this.onLevelEventuallyStabilized(...args);
+        this.refreshActiveQuality();
+      };
+      const onError = (..._args) => {
+        const data = _args[1] ?? {};
+        const status = data.response?.code;
+        const isHttpError = typeof status === "number" && status >= 400;
+        if (data.fatal || isHttpError) {
+          const message = data.fatal ? `HLS fatal error: ${data.type ?? "unknown"}` : `HLS load error: HTTP ${status}`;
+          this.options.onError?.({
+            message,
+            cause: data,
+            status,
+            url: data.response?.url ?? data.url
+          });
+          settle(() => reject(new Error(message)));
+        }
+      };
+      hls.on(Hls.Events.MANIFEST_PARSED, onParsed);
+      hls.on(Hls.Events.LEVEL_SWITCHED, onSwitched);
+      hls.on(Hls.Events.ERROR, onError);
+      this.detachListeners.push(
+        () => hls.off(Hls.Events.MANIFEST_PARSED, onParsed),
+        () => hls.off(Hls.Events.LEVEL_SWITCHED, onSwitched),
+        () => hls.off(Hls.Events.ERROR, onError),
+        () => settle(() => reject(makeAbortError()))
+      );
+      const timeoutMs = this.options.manifestTimeoutMs ?? 3e4;
+      if (timeoutMs > 0) {
+        this.manifestTimeout = setTimeout(() => {
+          const message = `HLS manifest timeout after ${timeoutMs}ms`;
+          this.options.onError?.({ message, cause: { type: "timeout" }, url: source.src });
+          settle(() => reject(new Error(message)));
+        }, timeoutMs);
+      }
+      try {
+        hls.loadSource(source.src);
+        hls.attachMedia(video);
+      } catch (err) {
+        settle(() => reject(err instanceof Error ? err : new Error(String(err))));
+      }
+    });
+  }
+  /**
+   * Wire the readystatechange watcher and remove it as soon as the XHR
+   * completes — without this cleanup hls.js (which spawns one XHR per segment)
+   * leaks a closure per request (A1).
+   */
+  installXhrWatcher(xhr, url, source) {
+    if (resolveWithCredentials(source.withCredentials, url)) {
+      xhr.withCredentials = true;
+    }
+    this.liveXhrs.add(xhr);
+    const watcher = () => {
+      if (xhr.readyState !== 4) return;
+      try {
+        if ((xhr.status === 401 || xhr.status === 403) && !this.unauthorizedFired) {
+          this.unauthorizedFired = true;
+          this.options.onUnauthorized?.({
+            url,
+            status: xhr.status,
+            source
+          });
+        }
+      } finally {
+        xhr.removeEventListener("readystatechange", watcher);
+        this.liveXhrs.delete(xhr);
+      }
+    };
+    xhr.addEventListener("readystatechange", watcher);
+  }
+  abort() {
+    if (this.aborted) return;
+    this.aborted = true;
+    this.clearManifestTimeout();
+    for (const xhr of [...this.liveXhrs]) {
+      try {
+        xhr.abort();
+      } catch {
+      }
+    }
+    this.liveXhrs.clear();
+    const reject = this.rejectAttach;
+    this.rejectAttach = null;
+    reject?.(makeAbortError());
+  }
+  detach() {
+    this.completeQualityAwaitIfBusy();
+    this.abort();
+    while (this.detachListeners.length) {
+      try {
+        this.detachListeners.pop()?.();
+      } catch {
+      }
+    }
+    if (this.hls) {
+      try {
+        this.hls.detachMedia();
+        this.hls.destroy();
+      } catch {
+      }
+      this.hls = null;
+    }
+    if (this.video) {
+      try {
+        this.video.removeAttribute("src");
+        this.video.load();
+      } catch {
+      }
+      this.video = null;
+    }
+    this.qualities = [];
+    this.currentSource = null;
+    this.unauthorizedFired = false;
+    this.aborted = false;
+    this.lastChosenQualityWasAuto = false;
+    this.manualLevelIndex = null;
+  }
+  clearQualitySwitchTimerOnly() {
+    if (this.qualitySwitchTimer !== null) {
+      clearTimeout(this.qualitySwitchTimer);
+      this.qualitySwitchTimer = null;
+    }
+  }
+  armQualitySwitchTimeout() {
+    this.clearQualitySwitchTimerOnly();
+    this.qualitySwitchTimer = setTimeout(() => {
+      this.qualitySwitchTimer = null;
+      if (this.qualityAwait !== false) {
+        this.completeQualityAwaitIfBusy();
+      }
+    }, 12e3);
+  }
+  /** Start or refresh awaited UI for a rendition change (rapid toggles reuse one spinner). */
+  armQualityAwait(kind) {
+    const wasIdle = this.qualityAwait === false;
+    this.qualityAwait = kind;
+    if (wasIdle) this.options.onQualitySwitch?.(true);
+    this.armQualitySwitchTimeout();
+  }
+  resolveQualityAwaitIfDone(levelIdxHint) {
+    const awaiting = this.qualityAwait;
+    if (awaiting === false) return;
+    const engineLevel = this.hls !== null && typeof this.hls.currentLevel === "number" ? this.hls.currentLevel : levelIdxHint;
+    const done = awaiting === "auto" || typeof awaiting === "number" && awaiting === engineLevel;
+    if (done) this.completeQualityAwaitIfBusy();
+  }
+  onLevelEventuallyStabilized(...args) {
+    let levelIdx;
+    for (let i = args.length - 1; i >= 0; i--) {
+      const a = args[i];
+      if (a !== null && typeof a === "object" && typeof a.level === "number") {
+        levelIdx = a.level;
+        break;
+      }
+    }
+    if (levelIdx === void 0) levelIdx = this.hls?.currentLevel;
+    if (typeof levelIdx === "number") this.resolveQualityAwaitIfDone(levelIdx);
+  }
+  completeQualityAwaitIfBusy() {
+    if (this.qualityAwait === false) return;
+    this.qualityAwait = false;
+    this.clearQualitySwitchTimerOnly();
+    this.options.onQualitySwitch?.(false);
+  }
+  clearManifestTimeout() {
+    if (this.manifestTimeout !== null) {
+      clearTimeout(this.manifestTimeout);
+      this.manifestTimeout = null;
+    }
+  }
+  getQualities() {
+    return this.qualities.slice();
+  }
+  setQuality(level) {
+    if (!this.hls) return;
+    if (level === "auto") {
+      this.manualLevelIndex = null;
+      this.hls.currentLevel = -1;
+      this.options.onActiveQuality?.(null, true);
+      if (!this.lastChosenQualityWasAuto) {
+        this.armQualityAwait("auto");
+      }
+      this.lastChosenQualityWasAuto = true;
+      queueMicrotask(() => {
+        this.completeQualityAwaitIfBusy();
+      });
+      return;
+    }
+    let idx = this.qualities.findIndex((q) => q.id === level.id);
+    if (idx < 0 && typeof level.height === "number" && level.height > 0) {
+      const byHeight = this.qualities.findIndex((q) => q.height === level.height);
+      if (byHeight >= 0) {
+        idx = byHeight;
+      }
+    }
+    if (idx < 0) {
+      return;
+    }
+    const resolved = this.qualities[idx];
+    if (!resolved) return;
+    this.manualLevelIndex = idx;
+    this.lastChosenQualityWasAuto = false;
+    if (this.hls.currentLevel === idx) {
+      this.options.onActiveQuality?.(resolved, false);
+      return;
+    }
+    if (this.hls.currentLevel !== -1) {
+      this.armQualityAwait(idx);
+    }
+    this.hls.currentLevel = idx;
+    this.options.onActiveQuality?.(resolved, false);
+    queueMicrotask(() => {
+      if (!this.hls) return;
+      this.resolveQualityAwaitIfDone(this.hls.currentLevel);
+    });
+  }
+  refreshQualities() {
+    if (!this.hls) return;
+    const next = this.hls.levels.map((lvl, i) => ({
+      id: String(i),
+      height: lvl.height ?? 0,
+      bitrate: lvl.bitrate ?? 0,
+      label: lvl.name ?? (lvl.height ? `${lvl.height}p` : `Level ${i + 1}`)
+    }));
+    this.qualities = next;
+    this.options.onQualities?.(next);
+    this.refreshActiveQuality();
+  }
+  refreshActiveQuality() {
+    if (!this.hls) return;
+    if (this.manualLevelIndex === null) {
+      this.options.onActiveQuality?.(null, true);
+      return;
+    }
+    const locked = this.qualities[this.manualLevelIndex] ?? null;
+    this.options.onActiveQuality?.(locked, false);
+  }
+  /** @internal — for tests. */
+  _getInternalState() {
+    return { source: this.currentSource, qualities: this.qualities };
+  }
+};
+function createHlsProvider(options = {}) {
+  return {
+    name: "hls",
+    canHandle: (source) => {
+      if (source.type === "hls") return true;
+      const type = detectSourceType(source);
+      return type === "hls" || type === "auto" && looksLikeHls(source.src);
+    },
+    createLoader: () => new HlsLoader(options)
+  };
+}
+
+// src/sources/native.ts
+var NativeLoader = class {
+  constructor() {
+    this.video = null;
+    this.cleanups = [];
+  }
+  async attach(video, source) {
+    this.detach();
+    this.video = video;
+    return new Promise((resolve, reject) => {
+      const onMeta = () => {
+        cleanupListeners();
+        resolve();
+      };
+      const onError = () => {
+        cleanupListeners();
+        const err = video.error;
+        const message = err ? `MediaError code=${err.code} message=${err.message}` : "Native loader failed";
+        reject(new Error(message));
+      };
+      const cleanupListeners = () => {
+        video.removeEventListener("loadedmetadata", onMeta);
+        video.removeEventListener("error", onError);
+      };
+      video.addEventListener("loadedmetadata", onMeta);
+      video.addEventListener("error", onError);
+      this.cleanups.push(cleanupListeners);
+      video.src = source.src;
+      video.load();
+    });
+  }
+  detach() {
+    while (this.cleanups.length) {
+      try {
+        this.cleanups.pop()?.();
+      } catch {
+      }
+    }
+    if (this.video) {
+      try {
+        this.video.removeAttribute("src");
+        this.video.load();
+      } catch {
+      }
+      this.video = null;
+    }
+  }
+};
+var nativeProvider = {
+  name: "native",
+  canHandle: (source) => {
+    if (source.type === "native") return true;
+    if (source.type === "mp4") return true;
+    if (source.type && source.type !== "auto") return false;
+    const type = detectSourceType(source);
+    if (type === "mp4") return true;
+    if (type === "hls" || type === "youtube") return false;
+    return "maybe";
+  },
+  createLoader: () => new NativeLoader()
+};
+
+// src/sources/registry.ts
+function createSourceRegistry() {
+  const providers = [];
+  function register(provider) {
+    if (providers.some((p) => p.name === provider.name)) {
+      throw new Error(
+        `[@f8team/reel-core] source provider "${provider.name}" is already registered`
+      );
+    }
+    providers.push(provider);
+    return () => unregister(provider.name);
+  }
+  function unregister(name) {
+    const idx = providers.findIndex((p) => p.name === name);
+    if (idx >= 0) providers.splice(idx, 1);
+  }
+  function resolve(source) {
+    let fallback = null;
+    for (const p of providers) {
+      const verdict = p.canHandle(source);
+      if (verdict === true) return p;
+      if (verdict === "maybe" && !fallback) fallback = p;
+    }
+    return fallback;
+  }
+  function list() {
+    return providers.slice();
+  }
+  function clear() {
+    providers.length = 0;
+  }
+  return { register, unregister, resolve, list, clear };
+}
+
+// src/sources/youtube.ts
+var YT_SCRIPT_SRC = "https://www.youtube.com/iframe_api";
+var defaultLoad2 = () => {
+  if (typeof window === "undefined") {
+    return Promise.reject(new Error("YouTube source provider requires a browser environment"));
+  }
+  const w = window;
+  if (w.YT && typeof w.YT.Player === "function") return Promise.resolve(w.YT);
+  return new Promise((resolve, reject) => {
+    const existing = document.querySelector(`script[src="${YT_SCRIPT_SRC}"]`);
+    const onReady = () => {
+      if (w.YT && typeof w.YT.Player === "function") resolve(w.YT);
+      else reject(new Error("YouTube IFrame API loaded without YT.Player"));
+    };
+    const previousReady = w.onYouTubeIframeAPIReady;
+    w.onYouTubeIframeAPIReady = () => {
+      previousReady?.();
+      onReady();
+    };
+    if (!existing) {
+      const script = document.createElement("script");
+      script.src = YT_SCRIPT_SRC;
+      script.async = true;
+      script.onerror = () => reject(new Error("Failed to load YouTube IFrame API"));
+      document.head.appendChild(script);
+    }
+  });
+};
+function extractYouTubeId(url) {
+  const m = url.match(/[?&]v=([^&]+)/) ?? url.match(/youtu\.be\/([^?&/]+)/) ?? url.match(/youtube\.com\/embed\/([^?&/]+)/) ?? url.match(/youtube\.com\/shorts\/([^?&/]+)/);
+  return m?.[1] ?? null;
+}
+var YT_HIDDEN_ATTR = "data-reel-yt-hidden";
+var staticParentWarned = false;
+var YouTubeLoader = class {
+  constructor(options) {
+    this.options = options;
+    this.yt = null;
+    this.video = null;
+    this.host = null;
+    this.timeIntervalId = null;
+    this.duration = 0;
+    this.rejectAttach = null;
+    this.aborted = false;
+  }
+  async attach(video, source) {
+    this.detach();
+    this.aborted = false;
+    const id = extractYouTubeId(source.src);
+    if (!id) {
+      throw new Error(`Cannot extract YouTube videoId from "${source.src}"`);
+    }
+    this.video = video;
+    const YT = await (this.options.loadRuntime ?? defaultLoad2)();
+    if (this.aborted) {
+      throw makeYtAbortError();
+    }
+    const parent = video.parentElement;
+    if (!parent) {
+      throw new Error("YouTube source provider requires <video> to be attached to the DOM");
+    }
+    if (typeof window !== "undefined" && !staticParentWarned) {
+      try {
+        const computed = window.getComputedStyle(parent).position;
+        if (computed === "static") {
+          staticParentWarned = true;
+          console.warn(
+            "[@f8team/reel-core] YouTube source: <video>'s parent has `position: static`. Set the player container to `position: relative` (or absolute/fixed) so the YouTube iframe can fill the stage."
+          );
+        }
+      } catch {
+      }
+    }
+    const host = document.createElement("div");
+    host.setAttribute("data-reel-yt-host", "");
+    host.style.cssText = "position:absolute;inset:0;width:100%;height:100%;overflow:hidden;background:#000;";
+    parent.appendChild(host);
+    this.host = host;
+    video.setAttribute(YT_HIDDEN_ATTR, "");
+    return new Promise((resolve, reject) => {
+      this.rejectAttach = reject;
+      let settled = false;
+      const settle = (run) => {
+        if (settled) return;
+        settled = true;
+        run();
+      };
+      try {
+        this.yt = new YT.Player(host, {
+          videoId: id,
+          // 100% so the iframe fills the host div rather than using default px dimensions.
+          width: "100%",
+          height: "100%",
+          playerVars: {
+            playsinline: 1,
+            modestbranding: 1,
+            rel: 0,
+            // enablejsapi is implicitly set by the IFrame API; explicit = good practice.
+            enablejsapi: 1
+          },
+          events: {
+            onReady: () => {
+              const iframe = host.querySelector("iframe");
+              if (iframe) {
+                iframe.style.cssText = "width:100%;height:100%;border:none;display:block;";
+              }
+              try {
+                this.duration = this.yt?.getDuration() ?? 0;
+                if (this.duration > 0) {
+                  this.options.onDuration?.(this.duration);
+                }
+              } catch {
+              }
+              this.startTimeBridge();
+              this.options.onStateChange?.("ready");
+              settle(() => resolve());
+            },
+            onStateChange: ({ data }) => {
+              switch (data) {
+                case YT.PlayerState.PLAYING:
+                  this.options.onStateChange?.("playing");
+                  break;
+                case YT.PlayerState.PAUSED:
+                  this.options.onStateChange?.("paused");
+                  break;
+                case YT.PlayerState.ENDED:
+                  this.options.onStateChange?.("ended");
+                  break;
+                case YT.PlayerState.BUFFERING:
+                  this.options.onStateChange?.("buffering");
+                  break;
+                default:
+                  break;
+              }
+            },
+            onError: ({ data }) => {
+              const err = { message: `YouTube error code=${data}`, cause: { code: data } };
+              this.options.onError?.(err);
+              settle(() => reject(new Error(err.message)));
+            }
+          }
+        });
+      } catch (err) {
+        settle(() => reject(err instanceof Error ? err : new Error(String(err))));
+      }
+    });
+  }
+  abort() {
+    if (this.aborted) return;
+    this.aborted = true;
+    const reject = this.rejectAttach;
+    this.rejectAttach = null;
+    reject?.(makeYtAbortError());
+  }
+  detach() {
+    this.abort();
+    if (this.timeIntervalId !== null) {
+      clearInterval(this.timeIntervalId);
+      this.timeIntervalId = null;
+    }
+    if (this.yt) {
+      try {
+        this.yt.destroy();
+      } catch {
+      }
+      this.yt = null;
+    }
+    if (this.host && this.host.parentElement) {
+      try {
+        this.host.parentElement.removeChild(this.host);
+      } catch {
+      }
+    }
+    this.host = null;
+    if (this.video) {
+      this.video.removeAttribute(YT_HIDDEN_ATTR);
+      this.video = null;
+    }
+    this.duration = 0;
+    this.aborted = false;
+  }
+  startTimeBridge() {
+    if (this.timeIntervalId !== null) return;
+    const interval = this.options.timeBridgeIntervalMs ?? 250;
+    this.timeIntervalId = setInterval(() => {
+      if (!this.yt) return;
+      try {
+        const currentTime = this.yt.getCurrentTime();
+        this.options.onTimeUpdate?.(currentTime);
+        const duration = this.yt.getDuration();
+        if (duration > 0 && duration !== this.duration) {
+          this.duration = duration;
+          this.options.onDuration?.(duration);
+        }
+      } catch {
+      }
+    }, interval);
+  }
+  /** @internal */
+  _instance() {
+    return this.yt;
+  }
+};
+function makeYtAbortError() {
+  const err = new Error("YouTube loader aborted");
+  err.name = "AbortError";
+  return err;
+}
+function createYouTubeProvider(options = {}) {
+  return {
+    name: "youtube",
+    canHandle: (source) => {
+      if (source.type === "youtube") return true;
+      const type = detectSourceType(source);
+      return type === "youtube" || type === "auto" && looksLikeYouTube(source.src);
+    },
+    createLoader: () => new YouTubeLoader(options)
+  };
+}
+
+// src/state/machine.ts
+var STAY = { effects: Object.freeze([]) };
+var noop = (status) => ({ next: status, ...STAY });
+function reduce(status, event) {
+  if (event.type === "dispose") {
+    if (status === "idle") return noop("idle");
+    return { next: "idle", effects: [{ type: "detachSource" }] };
+  }
+  switch (status) {
+    case "idle":
+      if (event.type === "setSource") {
+        if (event.source === null) return noop("idle");
+        return {
+          next: "loading",
+          effects: [{ type: "clearError" }, { type: "attachSource", source: event.source }]
+        };
+      }
+      return noop("idle");
+    case "loading":
+      switch (event.type) {
+        case "loaded":
+          return noop("ready");
+        case "loadFailed":
+          return { next: "error", effects: [{ type: "setError", error: event.error }] };
+        case "setSource":
+          if (event.source === null) {
+            return { next: "idle", effects: [{ type: "detachSource" }] };
+          }
+          return {
+            next: "loading",
+            effects: [
+              { type: "detachSource" },
+              { type: "clearError" },
+              { type: "attachSource", source: event.source }
+            ]
+          };
+        default:
+          return noop("loading");
+      }
+    case "ready":
+      switch (event.type) {
+        case "play":
+          return { next: "playing", effects: [{ type: "mediaPlay" }] };
+        case "runtimeError":
+          return { next: "error", effects: [{ type: "setError", error: event.error }] };
+        case "setSource":
+          if (event.source === null) {
+            return { next: "idle", effects: [{ type: "detachSource" }] };
+          }
+          return {
+            next: "loading",
+            effects: [
+              { type: "detachSource" },
+              { type: "clearError" },
+              { type: "attachSource", source: event.source }
+            ]
+          };
+        default:
+          return noop("ready");
+      }
+    case "playing":
+      switch (event.type) {
+        case "pause":
+          return { next: "paused", effects: [{ type: "mediaPause" }] };
+        case "ended":
+          return noop("ended");
+        case "runtimeError":
+          return { next: "error", effects: [{ type: "setError", error: event.error }] };
+        case "setSource":
+          if (event.source === null) {
+            return { next: "idle", effects: [{ type: "detachSource" }] };
+          }
+          return {
+            next: "loading",
+            effects: [
+              { type: "detachSource" },
+              { type: "clearError" },
+              { type: "attachSource", source: event.source }
+            ]
+          };
+        default:
+          return noop("playing");
+      }
+    case "paused":
+      switch (event.type) {
+        case "play":
+          return { next: "playing", effects: [{ type: "mediaPlay" }] };
+        case "ended":
+          return noop("ended");
+        case "runtimeError":
+          return { next: "error", effects: [{ type: "setError", error: event.error }] };
+        case "setSource":
+          if (event.source === null) {
+            return { next: "idle", effects: [{ type: "detachSource" }] };
+          }
+          return {
+            next: "loading",
+            effects: [
+              { type: "detachSource" },
+              { type: "clearError" },
+              { type: "attachSource", source: event.source }
+            ]
+          };
+        default:
+          return noop("paused");
+      }
+    case "ended":
+      switch (event.type) {
+        case "play":
+          return {
+            next: "playing",
+            effects: [{ type: "mediaSeek", seconds: 0 }, { type: "mediaPlay" }]
+          };
+        case "setSource":
+          if (event.source === null) {
+            return { next: "idle", effects: [{ type: "detachSource" }] };
+          }
+          return {
+            next: "loading",
+            effects: [
+              { type: "detachSource" },
+              { type: "clearError" },
+              { type: "attachSource", source: event.source }
+            ]
+          };
+        default:
+          return noop("ended");
+      }
+    case "error":
+      switch (event.type) {
+        case "retry": {
+          return { next: "loading", effects: [{ type: "clearError" }] };
+        }
+        case "setSource":
+          if (event.source === null) {
+            return { next: "idle", effects: [{ type: "detachSource" }] };
+          }
+          return {
+            next: "loading",
+            effects: [
+              { type: "detachSource" },
+              { type: "clearError" },
+              { type: "attachSource", source: event.source }
+            ]
+          };
+        default:
+          return noop("error");
+      }
+    default: {
+      const _exhaustive = status;
+      return _exhaustive;
+    }
+  }
+}
+
+// src/state/store.ts
+var defaultEquals = (a, b) => Object.is(a, b);
+function createStore(initial, options = {}) {
+  const schedule = options.scheduleFlush ?? queueMicrotask;
+  const defaultIsEqual = options.isEqual ?? defaultEquals;
+  let state = initial;
+  const subscribers = /* @__PURE__ */ new Set();
+  let dirty = false;
+  let disposed = false;
+  function flush() {
+    dirty = false;
+    if (disposed) return;
+    const snapshot = Array.from(subscribers);
+    for (const sub of snapshot) {
+      const next = sub.selector(state);
+      if (sub.isEqual(next, sub.last)) continue;
+      sub.last = next;
+      try {
+        sub.listener(next);
+      } catch (err) {
+        console.error("[@f8team/reel-core] store subscriber threw:", err);
+      }
+    }
+  }
+  function getState() {
+    return state;
+  }
+  function setState(patch) {
+    if (disposed) return;
+    const next = typeof patch === "function" ? patch(state) : patch;
+    state = { ...state, ...next };
+    if (!dirty) {
+      dirty = true;
+      schedule(flush);
+    }
+  }
+  function subscribe(selector, listener) {
+    if (disposed) {
+      return () => {
+      };
+    }
+    const sub = {
+      selector,
+      listener,
+      last: selector(state),
+      isEqual: defaultIsEqual
+    };
+    subscribers.add(sub);
+    return () => {
+      subscribers.delete(sub);
+    };
+  }
+  function dispose() {
+    if (disposed) return;
+    disposed = true;
+    subscribers.clear();
+  }
+  return { getState, setState, subscribe, dispose };
+}
+
+// src/createPlayer.ts
+var NATIVE_EVENTS = [
+  "loadedmetadata",
+  "durationchange",
+  "timeupdate",
+  "play",
+  "pause",
+  "ended",
+  "error",
+  "volumechange",
+  "ratechange",
+  "seeking",
+  "seeked",
+  "waiting",
+  "playing"
+];
+function makeInitialState(options) {
+  return {
+    status: "idle",
+    source: options.source ?? null,
+    currentTime: 0,
+    duration: 0,
+    buffered: [],
+    playbackRate: options.playbackRate ?? 1,
+    volume: options.volume ?? 1,
+    muted: options.muted ?? options.autoplay === "muted",
+    videoWidth: 0,
+    videoHeight: 0,
+    pip: false,
+    fullscreen: false,
+    qualities: [],
+    activeQuality: null,
+    error: null
+  };
+}
+function bufferedToRanges(buffered) {
+  if (!buffered) return [];
+  const out = [];
+  for (let i = 0; i < buffered.length; i++) {
+    out.push({ start: buffered.start(i), end: buffered.end(i) });
+  }
+  return out;
+}
+function createPlayer(options = {}, internal = {}) {
+  const store = createStore(makeInitialState(options), internal.storeOptions);
+  const bus = createEventBus();
+  const commands = createCommandRegistry();
+  const controls = createControlsRegistry();
+  let status = "idle";
+  let video = null;
+  let activeLoader = null;
+  let pendingAttachAbort = null;
+  let disposed = false;
+  let initialOptionsApplied = false;
+  let pendingPlay = false;
+  const registry = createSourceRegistry();
+  function emitUnauthorized(payload) {
+    bus.emit("unauthorized", payload);
+    options.hooks?.onUnauthorized?.(payload);
+  }
+  function applyError(err) {
+    store.setState({ error: err });
+    bus.emit("error", err);
+    options.hooks?.onError?.(err);
+  }
+  function setQualities(qualities) {
+    store.setState({ qualities });
+  }
+  function setActiveQuality(quality, auto) {
+    store.setState({ activeQuality: quality });
+    bus.emit("qualitychange", { quality, auto });
+  }
+  commands.add("hls:setQuality", (level) => {
+    if (level === null) {
+      bus.emit("qualitypreference", { qualityHeight: null });
+    } else if (level !== null && typeof level === "object" && typeof level.height === "number") {
+      bus.emit("qualitypreference", { qualityHeight: level.height });
+    }
+    const loader = activeLoader;
+    if (typeof loader?.setQuality === "function") {
+      loader.setQuality(level === null ? "auto" : level);
+    }
+  });
+  for (const provider of internal.extraProviders ?? []) registry.register(provider);
+  registry.register(
+    createHlsProvider({
+      onUnauthorized: (e) => emitUnauthorized(e),
+      onQualities: (q) => setQualities(q),
+      onActiveQuality: (q, auto) => setActiveQuality(q, auto),
+      onError: (err) => applyError(createPlayerError({ ...err, code: "network" })),
+      onQualitySwitch: (active) => bus.emit("qualityswitch", { active })
+    })
+  );
+  registry.register(
+    createYouTubeProvider({
+      onError: (err) => applyError(createPlayerError({ ...err, code: "source" })),
+      // Bridge YouTube's polled time/duration into the same store fields and
+      // bus events that hls.js / native engines populate. Without this, the
+      // seek bar, transcripts, resume-position and analytics plugins would
+      // never tick on YouTube sources (A3).
+      onTimeUpdate: (currentTime) => {
+        const duration = store.getState().duration;
+        store.setState({ currentTime });
+        bus.emit("timeupdate", { currentTime, playedSeconds: currentTime, duration });
+      },
+      onDuration: (duration) => {
+        store.setState({ duration });
+        bus.emit("durationchange", { duration });
+      }
+    })
+  );
+  registry.register(nativeProvider);
+  const playerRef = {};
+  const host = createPluginHost({
+    commands,
+    controls,
+    store: { getState: store.getState, subscribe: store.subscribe },
+    bus
+  });
+  const plugins = createPluginBus({ player: playerRef, host });
+  function dispatch(event) {
+    if (disposed) return;
+    const prev = status;
+    const result = reduce(status, event);
+    status = result.next;
+    store.setState({ status });
+    for (const effect of result.effects) applyEffect(effect);
+    if (prev !== "ready" && status === "ready") {
+      bus.emit("ready", { duration: store.getState().duration });
+    }
+  }
+  function applyEffect(effect) {
+    switch (effect.type) {
+      case "attachSource":
+        runAttachSource(effect.source);
+        return;
+      case "detachSource":
+        runDetachSource();
+        return;
+      case "mediaPlay":
+        runMediaPlay();
+        return;
+      case "mediaPause":
+        runMediaPause();
+        return;
+      case "mediaSeek":
+        runMediaSeek(effect.seconds);
+        return;
+      case "clearError":
+        if (store.getState().error) store.setState({ error: null });
+        return;
+      case "setError":
+        applyError(effect.error);
+        return;
+      default: {
+        const _exhaustive = effect;
+        return _exhaustive;
+      }
+    }
+  }
+  function runAttachSource(source) {
+    pendingAttachAbort?.();
+    pendingAttachAbort = null;
+    store.setState({
+      source,
+      currentTime: 0,
+      duration: 0,
+      buffered: [],
+      qualities: [],
+      activeQuality: null
+    });
+    bus.emit("qualitychange", { quality: null, auto: true });
+    if (!video) return;
+    const provider = registry.resolve(source);
+    if (!provider) {
+      dispatch({
+        type: "loadFailed",
+        error: createPlayerError({
+          code: "unsupported",
+          message: `No source provider for ${source.src}`
+        })
+      });
+      return;
+    }
+    const loader = provider.createLoader();
+    activeLoader = loader;
+    let aborted = false;
+    pendingAttachAbort = () => {
+      aborted = true;
+      try {
+        loader.abort?.();
+      } catch (err) {
+        console.error("[@f8team/reel-core] loader.abort() threw:", err);
+      }
+    };
+    loader.attach(video, source).then(() => {
+      if (aborted) return;
+      if (!video) return;
+      store.setState({
+        duration: Number.isFinite(video.duration) ? video.duration : 0,
+        videoWidth: video.videoWidth,
+        videoHeight: video.videoHeight,
+        buffered: bufferedToRanges(video.buffered)
+      });
+      dispatch({ type: "loaded" });
+    }).catch((err) => {
+      if (aborted) return;
+      const playerError = classifyUnknown(err, source.src);
+      dispatch({ type: "loadFailed", error: playerError });
+    });
+  }
+  function runDetachSource() {
+    pendingAttachAbort?.();
+    pendingAttachAbort = null;
+    if (activeLoader) {
+      try {
+        activeLoader.detach();
+      } catch (err) {
+        console.error("[@f8team/reel-core] active loader detach threw:", err);
+      }
+      activeLoader = null;
+    }
+    store.setState({
+      source: null,
+      duration: 0,
+      currentTime: 0,
+      buffered: [],
+      qualities: [],
+      activeQuality: null
+    });
+  }
+  function runMediaPlay() {
+    if (!video) return;
+    const result = video.play();
+    if (result && typeof result.then === "function") {
+      result.catch((err) => {
+        dispatch({
+          type: "runtimeError",
+          error: classifyUnknown(err)
+        });
+      });
+    }
+  }
+  function runMediaPause() {
+    if (!video) return;
+    try {
+      video.pause();
+    } catch {
+    }
+  }
+  function runMediaSeek(seconds) {
+    if (!video) return;
+    try {
+      video.currentTime = seconds;
+    } catch {
+    }
+  }
+  const nativeListeners = [];
+  function bindNativeEvents(target) {
+    function on2(name, fn) {
+      const handler = (e) => fn(e);
+      target.addEventListener(name, handler);
+      nativeListeners.push(() => target.removeEventListener(name, handler));
+    }
+    for (const _ of NATIVE_EVENTS) {
+    }
+    on2("loadedmetadata", () => {
+      store.setState({
+        duration: Number.isFinite(target.duration) ? target.duration : 0,
+        videoWidth: target.videoWidth,
+        videoHeight: target.videoHeight,
+        buffered: bufferedToRanges(target.buffered)
+      });
+      if (status === "loading") dispatch({ type: "loaded" });
+    });
+    on2("durationchange", () => {
+      const duration = Number.isFinite(target.duration) ? target.duration : 0;
+      store.setState({ duration });
+      bus.emit("durationchange", { duration });
+    });
+    on2("timeupdate", () => {
+      const currentTime = target.currentTime;
+      store.setState({ currentTime, buffered: bufferedToRanges(target.buffered) });
+      bus.emit("timeupdate", {
+        currentTime,
+        playedSeconds: currentTime,
+        duration: target.duration
+      });
+    });
+    on2("play", () => {
+      bus.emit("play");
+      dispatch({ type: "play" });
+    });
+    on2("pause", () => {
+      bus.emit("pause");
+      dispatch({ type: "pause" });
+    });
+    on2("ended", () => {
+      bus.emit("ended");
+      dispatch({ type: "ended" });
+    });
+    on2("error", () => {
+      const err = classifyMediaError(target.error, target.currentSrc);
+      if (status === "loading") dispatch({ type: "loadFailed", error: err });
+      else dispatch({ type: "runtimeError", error: err });
+    });
+    on2("volumechange", () => {
+      store.setState({ volume: target.volume, muted: target.muted });
+      bus.emit("volumechange", { volume: target.volume, muted: target.muted });
+    });
+    on2("ratechange", () => {
+      store.setState({ playbackRate: target.playbackRate });
+      bus.emit("ratechange", { playbackRate: target.playbackRate });
+    });
+    on2("seeking", () => {
+      bus.emit("seeking", { time: target.currentTime });
+      bus.emit("buffering", { isBuffering: true });
+    });
+    on2("seeked", () => {
+      bus.emit("seeked", { time: target.currentTime });
+      if (target.paused) {
+        bus.emit("buffering", { isBuffering: false });
+        return;
+      }
+      if (target.readyState >= 3) {
+        bus.emit("buffering", { isBuffering: false });
+      }
+    });
+    on2("waiting", () => {
+      if (target.readyState < 2) return;
+      bus.emit("buffering", { isBuffering: true });
+    });
+    on2("playing", () => {
+      bus.emit("buffering", { isBuffering: false });
+    });
+    if (typeof document !== "undefined") {
+      const onFullscreenChange = () => {
+        const isFullscreen = !!document.fullscreenElement;
+        store.setState({ fullscreen: isFullscreen });
+        bus.emit("fullscreenchange", { fullscreen: isFullscreen });
+      };
+      document.addEventListener("fullscreenchange", onFullscreenChange);
+      nativeListeners.push(
+        () => document.removeEventListener("fullscreenchange", onFullscreenChange)
+      );
+    }
+  }
+  function unbindNativeEvents() {
+    while (nativeListeners.length) {
+      try {
+        nativeListeners.pop()?.();
+      } catch {
+      }
+    }
+  }
+  function applyInitialOptions() {
+    if (initialOptionsApplied || !video) return;
+    if (typeof options.volume === "number") video.volume = options.volume;
+    if (typeof options.muted === "boolean") video.muted = options.muted;
+    if (typeof options.playbackRate === "number") video.playbackRate = options.playbackRate;
+    if (options.poster) video.poster = options.poster;
+    if (options.preload) video.preload = options.preload;
+    if (options.playsInline ?? true) {
+      video.playsInline = true;
+      video.setAttribute("webkit-playsinline", "");
+    }
+    if ("crossOrigin" in options) {
+      if (options.crossOrigin) video.crossOrigin = options.crossOrigin;
+    } else {
+      video.crossOrigin = "anonymous";
+    }
+    if (options.loop) video.loop = true;
+    initialOptionsApplied = true;
+  }
+  const attachDisposers = [];
+  function flushAttachDisposers() {
+    while (attachDisposers.length) {
+      try {
+        attachDisposers.pop()?.();
+      } catch {
+      }
+    }
+  }
+  function applyStartTimeNow() {
+    if (video && typeof options.startTime === "number" && options.startTime > 0) {
+      video.currentTime = options.startTime;
+    }
+  }
+  function applyAutoplayNow() {
+    if (!options.autoplay || options.autoplay === "off") return;
+    if (options.autoplay === "muted" && video) video.muted = true;
+    playerRef.play().catch(() => {
+    });
+  }
+  async function attach(el) {
+    if (disposed) throw new Error("[@f8team/reel-core] cannot attach: player disposed");
+    if (video === el) return;
+    if (video) detach();
+    video = el;
+    bindNativeEvents(el);
+    applyInitialOptions();
+    if (options.source) dispatch({ type: "setSource", source: options.source });
+    const wantStartTime = typeof options.startTime === "number" && options.startTime > 0;
+    const wantAutoplay = !!options.autoplay && options.autoplay !== "off" && !!options.source;
+    if (status === "ready") {
+      if (wantStartTime) applyStartTimeNow();
+      if (wantAutoplay) applyAutoplayNow();
+    } else {
+      if (wantStartTime) {
+        const off2 = bus.on("ready", () => {
+          applyStartTimeNow();
+          off2();
+        });
+        attachDisposers.push(off2);
+      }
+      if (wantAutoplay) {
+        const off2 = bus.on("ready", () => {
+          applyAutoplayNow();
+          off2();
+        });
+        attachDisposers.push(off2);
+      }
+    }
+  }
+  function detach() {
+    pendingAttachAbort?.();
+    pendingAttachAbort = null;
+    flushAttachDisposers();
+    unbindNativeEvents();
+    if (activeLoader) {
+      try {
+        activeLoader.detach();
+      } catch {
+      }
+      activeLoader = null;
+    }
+    video = null;
+  }
+  function dispose() {
+    if (disposed) return;
+    disposed = true;
+    plugins.disposeAll();
+    dispatch({ type: "dispose" });
+    detach();
+    bus.clear();
+    controls.clear();
+    store.dispose();
+  }
+  function setSource(source) {
+    pendingPlay = false;
+    dispatch({ type: "setSource", source });
+  }
+  function getSource() {
+    return store.getState().source;
+  }
+  function retry() {
+    const current = store.getState().source;
+    if (!current) return false;
+    dispatch({ type: "setSource", source: current });
+    return true;
+  }
+  async function play() {
+    if (disposed) throw new Error("[@f8team/reel-core] cannot play: player disposed");
+    if (!video) throw new Error("[@f8team/reel-core] cannot play: no <video> attached");
+    if (!store.getState().source) throw new Error("[@f8team/reel-core] cannot play: no source set");
+    if (status === "error") {
+      pendingPlay = false;
+      if (!retry()) {
+        throw new Error("[@f8team/reel-core] cannot play: error state without replayable source");
+      }
+    }
+    if (status === "loading") {
+      if (pendingPlay) {
+        return;
+      }
+      pendingPlay = true;
+      const off2 = bus.on("ready", () => {
+        off2();
+        if (!pendingPlay) return;
+        pendingPlay = false;
+        if (disposed || !video || !store.getState().source) return;
+        dispatch({ type: "play" });
+      });
+      attachDisposers.push(() => {
+        pendingPlay = false;
+        off2();
+      });
+      return;
+    }
+    dispatch({ type: "play" });
+  }
+  function pause() {
+    pendingPlay = false;
+    dispatch({ type: "pause" });
+  }
+  function paused() {
+    if (!video) return true;
+    return video.paused;
+  }
+  function seekTo(seconds) {
+    if (!Number.isFinite(seconds)) return;
+    if (!video) return;
+    const duration = Number.isFinite(video.duration) ? video.duration : Number.POSITIVE_INFINITY;
+    const clamped = Math.max(0, Math.min(seconds, duration));
+    video.currentTime = clamped;
+  }
+  function syncVolumeMutedStoreFromVideo() {
+    if (!video) return;
+    store.setState({ volume: video.volume, muted: video.muted });
+  }
+  function syncPlaybackRateStoreFromVideo() {
+    if (!video) return;
+    store.setState({ playbackRate: video.playbackRate });
+  }
+  function setPlaybackRate(rate) {
+    if (!Number.isFinite(rate) || rate <= 0) return;
+    if (!video) return;
+    video.playbackRate = rate;
+    syncPlaybackRateStoreFromVideo();
+  }
+  function setVolume(volume) {
+    if (!Number.isFinite(volume)) return;
+    if (!video) return;
+    video.volume = Math.max(0, Math.min(1, volume));
+    syncVolumeMutedStoreFromVideo();
+  }
+  function setMuted(muted) {
+    if (!video) return;
+    video.muted = muted;
+    syncVolumeMutedStoreFromVideo();
+  }
+  function getState() {
+    return store.getState();
+  }
+  function getCurrentTime() {
+    return store.getState().currentTime;
+  }
+  function getDuration() {
+    return store.getState().duration;
+  }
+  function getBuffered() {
+    return store.getState().buffered.slice();
+  }
+  function on(event, handler) {
+    return bus.on(event, handler);
+  }
+  function off(event, handler) {
+    bus.off(event, handler);
+  }
+  function subscribe(selector, listener) {
+    return store.subscribe(selector, listener);
+  }
+  function use(plugin) {
+    plugins.register(plugin);
+  }
+  function removePlugin(name) {
+    plugins.unregister(name);
+  }
+  Object.assign(playerRef, {
+    setSource,
+    getSource,
+    retry,
+    play,
+    pause,
+    paused,
+    seekTo,
+    setPlaybackRate,
+    setVolume,
+    setMuted,
+    getState,
+    getCurrentTime,
+    getDuration,
+    getBuffered,
+    on,
+    off,
+    subscribe,
+    use,
+    removePlugin,
+    commands,
+    attach,
+    detach,
+    dispose
+  });
+  for (const plugin of options.plugins ?? []) plugins.register(plugin);
+  return playerRef;
+}
+
+// src/plugins/definePlugin.ts
+function definePlugin(spec) {
+  return spec;
+}
+
+// src/theme/tokens.ts
+var TOKEN_TO_CSS_VAR = {
+  "color-bg": "--reel-color-bg",
+  "color-fg": "--reel-color-fg",
+  "color-accent": "--reel-color-accent",
+  "color-overlay": "--reel-color-overlay",
+  "control-size": "--reel-control-size",
+  "control-radius": "--reel-control-radius",
+  "control-gap": "--reel-control-gap",
+  "control-padding": "--reel-control-padding",
+  "focus-ring-color": "--reel-focus-ring-color",
+  "focus-ring-width": "--reel-focus-ring-width",
+  "seekbar-height": "--reel-seekbar-height",
+  "seekbar-buffered": "--reel-seekbar-buffered",
+  "seekbar-played": "--reel-seekbar-played",
+  "seekbar-knob-size": "--reel-seekbar-knob-size",
+  "font-family": "--reel-font-family",
+  "font-size-sm": "--reel-font-size-sm",
+  "font-size-md": "--reel-font-size-md",
+  "motion-fast": "--reel-motion-fast",
+  "motion-base": "--reel-motion-base"
+};
+var DEFAULT_TOKENS = {
+  "color-bg": "#0d0d0d",
+  "color-fg": "#ffffff",
+  "color-accent": "#ff5722",
+  "color-overlay": "rgba(0, 0, 0, 0.55)",
+  "control-size": "3.6rem",
+  "control-radius": "0.8rem",
+  "control-gap": "0.8rem",
+  "control-padding": "0.8rem",
+  "focus-ring-color": "#3ea6ff",
+  "focus-ring-width": "0.2rem",
+  "seekbar-height": "0.4rem",
+  "seekbar-buffered": "rgba(255, 255, 255, 0.35)",
+  "seekbar-played": "var(--reel-color-accent)",
+  "seekbar-knob-size": "1.2rem",
+  "font-family": "system-ui, -apple-system, 'Segoe UI', sans-serif",
+  "font-size-sm": "1.2rem",
+  "font-size-md": "1.4rem",
+  "motion-fast": "120ms",
+  "motion-base": "200ms"
+};
+var THEME_PRESETS = {
+  classroom: {
+    "color-bg": "#0e1117",
+    "color-accent": "#ff6b00",
+    "control-size": "4.0rem",
+    "seekbar-height": "0.4rem"
+  },
+  story: {
+    "color-bg": "transparent",
+    "color-overlay": "rgba(0, 0, 0, 0.45)",
+    "control-size": "4.4rem",
+    "seekbar-height": "0.3rem"
+  },
+  admin: {
+    "color-bg": "#1a1d23",
+    "color-accent": "#3ea6ff",
+    "control-size": "3.2rem",
+    "seekbar-height": "0.5rem"
+  },
+  minimal: {
+    "color-bg": "transparent",
+    "control-size": "3.0rem",
+    "seekbar-height": "0.3rem"
+  }
+};
+
+// src/theme/apply.ts
+function resolveTokens(args = {}) {
+  const out = {};
+  if (args.applyDefaults !== false) Object.assign(out, DEFAULT_TOKENS);
+  if (args.preset) Object.assign(out, THEME_PRESETS[args.preset]);
+  if (args.overrides) Object.assign(out, args.overrides);
+  return out;
+}
+function applyTheme(element, args = {}) {
+  const tokens = resolveTokens(args);
+  const previous = {};
+  for (const [key, value] of Object.entries(tokens)) {
+    if (typeof value !== "string") continue;
+    const cssVar = TOKEN_TO_CSS_VAR[key];
+    if (!cssVar) continue;
+    previous[key] = element.style.getPropertyValue(cssVar);
+    element.style.setProperty(cssVar, value);
+  }
+  return () => {
+    for (const [key, prev] of Object.entries(previous)) {
+      const cssVar = TOKEN_TO_CSS_VAR[key];
+      if (!cssVar) continue;
+      if (prev) element.style.setProperty(cssVar, prev);
+      else element.style.removeProperty(cssVar);
+    }
+  };
+}
+
+// src/a11y/announce.ts
+var REGION_ID = "reel-live-region";
+var region = null;
+function ensureRegion() {
+  if (typeof document === "undefined") return null;
+  if (region && region.isConnected) return region;
+  const existing = document.getElementById(REGION_ID);
+  if (existing) {
+    region = existing;
+    return region;
+  }
+  const node = document.createElement("div");
+  node.id = REGION_ID;
+  node.setAttribute("aria-live", "polite");
+  node.setAttribute("aria-atomic", "true");
+  node.setAttribute("role", "status");
+  Object.assign(node.style, {
+    position: "absolute",
+    width: "1px",
+    height: "1px",
+    padding: "0",
+    margin: "-1px",
+    overflow: "hidden",
+    clip: "rect(0,0,0,0)",
+    whiteSpace: "nowrap",
+    border: "0"
+  });
+  document.body.appendChild(node);
+  region = node;
+  return region;
+}
+function announce(message) {
+  if (!message) return;
+  const node = ensureRegion();
+  if (!node) return;
+  if (node.textContent === message) {
+    node.textContent = "";
+  }
+  queueMicrotask(() => {
+    if (node.isConnected) node.textContent = message;
+  });
+}
+
+// src/a11y/focusTrap.ts
+var FOCUSABLE_SELECTOR = [
+  "a[href]",
+  "area[href]",
+  "input:not([disabled])",
+  "select:not([disabled])",
+  "textarea:not([disabled])",
+  "button:not([disabled])",
+  "iframe",
+  "object",
+  "embed",
+  "[tabindex]:not([tabindex='-1'])",
+  "[contenteditable]"
+].join(",");
+function isFocusable(el) {
+  if (!(el instanceof HTMLElement)) return false;
+  if (el.hidden) return false;
+  if (el.tabIndex === -1) return false;
+  return true;
+}
+function focusables(container) {
+  const all = Array.from(container.querySelectorAll(FOCUSABLE_SELECTOR));
+  return all.filter(isFocusable);
+}
+function createFocusTrap(container) {
+  let active = false;
+  let previouslyFocused = null;
+  function onKeyDown(event) {
+    if (!active) return;
+    if (event.key !== "Tab") return;
+    const items = focusables(container);
+    if (items.length === 0) {
+      event.preventDefault();
+      return;
+    }
+    const first = items[0];
+    const last = items[items.length - 1];
+    if (!first || !last) return;
+    const current = document.activeElement;
+    if (event.shiftKey) {
+      if (current === first || !container.contains(current)) {
+        event.preventDefault();
+        last.focus();
+      }
+    } else if (current === last || !container.contains(current)) {
+      event.preventDefault();
+      first.focus();
+    }
+  }
+  function activate(opts = {}) {
+    if (active) return;
+    active = true;
+    previouslyFocused = document.activeElement;
+    container.addEventListener("keydown", onKeyDown, true);
+    if (opts.focusFirst) {
+      const items = focusables(container);
+      items[0]?.focus();
+    }
+  }
+  function deactivate(opts = {}) {
+    if (!active) return;
+    active = false;
+    container.removeEventListener("keydown", onKeyDown, true);
+    if (opts.restoreFocus && previouslyFocused instanceof HTMLElement) {
+      try {
+        previouslyFocused.focus();
+      } catch {
+      }
+    }
+    previouslyFocused = null;
+  }
+  return { activate, deactivate };
+}
+
+// src/util/time.ts
+var TIME_RE = /^(?:(\d+):)?(\d{1,2}):(\d{1,2})(?:\.(\d+))?$/;
+function parseTime(input) {
+  if (typeof input !== "string") return Number.NaN;
+  const trimmed = input.trim();
+  const match = TIME_RE.exec(trimmed);
+  if (!match) return Number.NaN;
+  const [, hStr, mStr, sStr, fracStr] = match;
+  const h = hStr ? Number.parseInt(hStr, 10) : 0;
+  const m = Number.parseInt(mStr ?? "0", 10);
+  const s = Number.parseInt(sStr ?? "0", 10);
+  const frac = fracStr ? Number.parseFloat(`0.${fracStr}`) : 0;
+  if (m > 59 || s > 59) return Number.NaN;
+  return h * 3600 + m * 60 + s + frac;
+}
+function formatTime(seconds) {
+  if (!Number.isFinite(seconds) || seconds < 0) return "0:00";
+  const total = Math.floor(seconds);
+  const h = Math.floor(total / 3600);
+  const m = Math.floor(total % 3600 / 60);
+  const s = total % 60;
+  const pad = (n, len = 2) => n.toString().padStart(len, "0");
+  if (h > 0) return `${h}:${pad(m)}:${pad(s)}`;
+  return `${m}:${pad(s)}`;
+}
+function toSeconds(input) {
+  if (typeof input === "number") {
+    if (!Number.isFinite(input)) return Number.NaN;
+    return input < 0 ? 0 : input;
+  }
+  return parseTime(input);
+}
+
+exports.DEFAULT_TOKENS = DEFAULT_TOKENS;
+exports.THEME_PRESETS = THEME_PRESETS;
+exports.TOKEN_TO_CSS_VAR = TOKEN_TO_CSS_VAR;
+exports.announce = announce;
+exports.applyTheme = applyTheme;
+exports.createFocusTrap = createFocusTrap;
+exports.createPlayer = createPlayer;
+exports.definePlugin = definePlugin;
+exports.detectSourceType = detectSourceType;
+exports.formatTime = formatTime;
+exports.looksLikeHls = looksLikeHls;
+exports.looksLikeProgressive = looksLikeProgressive;
+exports.looksLikeYouTube = looksLikeYouTube;
+exports.parseTime = parseTime;
+exports.resolveTokens = resolveTokens;
+exports.toSeconds = toSeconds;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map