@ngxsp/core 0.0.1-next.0

package/index.cjs

@@ -0,0 +1,1355 @@
+'use strict';
+
+var rxjs = require('rxjs');
+
+// src/facade/player-facade.ts
+
+// src/engine/engine-factory.ts
+function selectEngine(config, factories, caps) {
+  const candidates = (factories ?? []).filter((f) => {
+    try {
+      if (caps && typeof f.supportsWithCaps === "function") return !!f.supportsWithCaps(config, caps);
+      return !!f.supports(config);
+    } catch {
+      return false;
+    }
+  });
+  if (candidates.length === 0) return null;
+  candidates.sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0));
+  return candidates[0];
+}
+
+// src/engine/native.engine.ts
+function mimeFromUrl(url) {
+  try {
+    const clean = url.split("?")[0].split("#")[0];
+    const parts = clean.split(".");
+    const ext = (parts.length > 1 ? parts.pop() : "")?.toLowerCase() || "";
+    switch (ext) {
+      case "mp4":
+        return "video/mp4";
+      case "m4v":
+        return "video/x-m4v";
+      case "mov":
+        return "video/quicktime";
+      case "webm":
+        return "video/webm";
+      case "mkv":
+        return "video/x-matroska";
+      case "avi":
+        return "video/x-msvideo";
+      case "mpg":
+      case "mpeg":
+        return "video/mpeg";
+      case "ts":
+        return "video/mp2t";
+      case "ogv":
+        return "video/ogg";
+      default:
+        return "";
+    }
+  } catch {
+    return "";
+  }
+}
+var NativeEngine = class {
+  id = "native";
+  video;
+  listeners = [];
+  async attach(videoEl) {
+    this.video = videoEl;
+    const v = videoEl;
+    const emit = (e) => this.listeners.forEach((l) => l(e));
+    v.addEventListener("timeupdate", () => emit({ type: "timeupdate", currentTime: v.currentTime, duration: v.duration || 0 }));
+    v.addEventListener("playing", () => emit({ type: "state", state: "playing" }));
+    v.addEventListener("pause", () => emit({ type: "state", state: "paused" }));
+    v.addEventListener("waiting", () => emit({ type: "state", state: "buffering" }));
+    v.addEventListener("ended", () => emit({ type: "state", state: "ended" }));
+    v.addEventListener("error", () => {
+      const err = v.error;
+      emit({
+        type: "error",
+        error: { code: `HTML5_${err?.code ?? "UNKNOWN"}`, message: err?.message ?? "HTML5 video error", fatal: true, details: err }
+      });
+    });
+  }
+  async load(source, opts) {
+    if (!this.video) throw new Error("NativeEngine not attached");
+    const v = this.video;
+    if (source.type === "local-file") {
+      if (!source.file) throw new Error("source.file is required");
+      v.src = URL.createObjectURL(source.file);
+    } else {
+      if (!source.url) throw new Error("source.url is required");
+      const type = mimeFromUrl(source.url);
+      while (v.firstChild) v.removeChild(v.firstChild);
+      if (type) {
+        const s = document.createElement("source");
+        s.src = source.url;
+        s.type = type;
+        v.appendChild(s);
+        v.removeAttribute("src");
+      } else {
+        v.src = source.url;
+      }
+    }
+    await v.load();
+    if (opts?.startTimeSec != null && isFinite(opts.startTimeSec)) {
+      v.currentTime = Math.max(0, opts.startTimeSec);
+    }
+  }
+  async destroy() {
+    if (!this.video) return;
+    this.video.removeAttribute("src");
+    this.video.load();
+    this.video = void 0;
+    this.listeners = [];
+  }
+  async play() {
+    await this.video?.play();
+  }
+  async pause() {
+    this.video?.pause();
+  }
+  async seekTo(timeSec) {
+    if (this.video) this.video.currentTime = Math.max(0, timeSec);
+  }
+  async setPlaybackRate(rate) {
+    if (this.video) this.video.playbackRate = rate;
+  }
+  async setVolume(volume) {
+    if (this.video) this.video.volume = Math.min(1, Math.max(0, volume));
+  }
+  async setTextTrack(_trackId) {
+  }
+  async setAudioTrack(_trackId) {
+  }
+  async setVideoTrack(_trackId) {
+  }
+  async getTracks() {
+    return [];
+  }
+  onEvent(cb) {
+    this.listeners.push(cb);
+    return () => {
+      this.listeners = this.listeners.filter((x) => x !== cb);
+    };
+  }
+};
+
+// src/engine/native.factory.ts
+function createNativeEngineFactory() {
+  return {
+    id: "native",
+    priority: 0,
+    supports: (cfg) => {
+      const drm = cfg.drm ?? cfg.source?.drm;
+      if (drm?.required) return false;
+      const t = cfg.source.type;
+      if (t === "url" || t === "local-file") return true;
+      return false;
+    },
+    create: () => new NativeEngine()
+  };
+}
+
+// src/engine/engine-profile.ts
+function getEngineProfileHints(profile) {
+  switch (profile) {
+    case "tv":
+      return {
+        abr: {
+          // Prefer higher quality by default.
+          maxHeight: 2160
+        },
+        shakaStreaming: {
+          bufferingGoalSec: 30,
+          rebufferingGoalSec: 2
+        }
+      };
+    case "mobile":
+      return {
+        abr: {
+          // Reasonable default for mobile data/CPU.
+          maxHeight: 720
+        },
+        shakaStreaming: {
+          bufferingGoalSec: 15,
+          rebufferingGoalSec: 2
+        }
+      };
+    case "low-latency":
+      return {
+        abr: {
+          // Avoid very high res by default (keeps latency predictable).
+          maxHeight: 1080
+        },
+        shakaStreaming: {
+          lowLatencyMode: true,
+          bufferingGoalSec: 6,
+          rebufferingGoalSec: 1
+        }
+      };
+    case "default":
+    default:
+      return {
+        shakaStreaming: {
+          bufferingGoalSec: 20,
+          rebufferingGoalSec: 2
+        }
+      };
+  }
+}
+function applyEngineProfileToSource(source, profile) {
+  const p = profile ?? "default";
+  const hints = getEngineProfileHints(p);
+  const anySrc = source;
+  const abrIn = anySrc.abr ?? {};
+  const abrOut = { ...abrIn };
+  if (abrOut.maxHeight == null && hints.abr?.maxHeight != null) abrOut.maxHeight = hints.abr.maxHeight;
+  if (abrOut.maxBandwidth == null && hints.abr?.maxBandwidth != null) abrOut.maxBandwidth = hints.abr.maxBandwidth;
+  const out = {
+    ...anySrc,
+    // Expose profile to engines (optional).
+    profile: p
+  };
+  if (Object.keys(abrOut).length) out.abr = abrOut;
+  if (hints.shakaStreaming) {
+    out._shakaStreaming = {
+      ...anySrc._shakaStreaming ?? {},
+      ...hints.shakaStreaming
+    };
+  }
+  return out;
+}
+
+// src/engine/playback-capabilities.ts
+function createDefaultCapabilities() {
+  return {
+    mse: false,
+    eme: false,
+    mediaCapabilities: false,
+    hls: false,
+    dash: false,
+    progressive: true,
+    codecs: { mp4_h264: false, mp4_hevc: false, webm_vp9: false, webm_av1: false },
+    drm: { widevine: false, playready: false, fairplay: false }
+  };
+}
+async function detectPlaybackCapabilities(videoEl) {
+  const caps = createDefaultCapabilities();
+  const w = globalThis;
+  caps.mse = !!w.MediaSource && typeof w.MediaSource.isTypeSupported === "function";
+  caps.eme = !!(w.navigator && w.navigator.requestMediaKeySystemAccess);
+  caps.mediaCapabilities = !!(w.navigator && w.navigator.mediaCapabilities);
+  const v = videoEl ?? (typeof document !== "undefined" ? document.createElement("video") : void 0);
+  const canPlay = (mime) => {
+    try {
+      if (caps.mse && w.MediaSource?.isTypeSupported) return !!w.MediaSource.isTypeSupported(mime);
+      if (v && typeof v.canPlayType === "function") return v.canPlayType(mime) !== "";
+      return false;
+    } catch {
+      return false;
+    }
+  };
+  caps.codecs.mp4_h264 = canPlay('video/mp4; codecs="avc1.42E01E"');
+  caps.codecs.mp4_hevc = canPlay('video/mp4; codecs="hvc1.1.6.L93.B0"');
+  caps.codecs.webm_vp9 = canPlay('video/webm; codecs="vp09.00.10.08"');
+  caps.codecs.webm_av1 = canPlay('video/webm; codecs="av01.0.05M.08"');
+  caps.dash = caps.mse;
+  caps.hls = canPlay("application/vnd.apple.mpegurl") || canPlay("application/x-mpegURL") || caps.mse;
+  caps.progressive = caps.codecs.mp4_h264 || caps.codecs.webm_vp9 || caps.codecs.webm_av1 || true;
+  if (caps.eme && w.navigator?.requestMediaKeySystemAccess) {
+    const probe = async (ks) => {
+      try {
+        const cfg = [{
+          initDataTypes: ["cenc"],
+          audioCapabilities: [{ contentType: 'audio/mp4; codecs="mp4a.40.2"' }],
+          videoCapabilities: [{ contentType: 'video/mp4; codecs="avc1.42E01E"' }]
+        }];
+        await w.navigator.requestMediaKeySystemAccess(ks, cfg);
+        return true;
+      } catch {
+        return false;
+      }
+    };
+    caps.drm.widevine = await probe("com.widevine.alpha");
+    caps.drm.playready = await probe("com.microsoft.playready");
+    caps.drm.fairplay = await probe("com.apple.fps.1_0");
+  }
+  return caps;
+}
+
+// src/engine/capability-report.ts
+async function createMediaDecodingReport() {
+  const mc = globalThis.navigator?.mediaCapabilities;
+  if (!mc?.decodingInfo) return void 0;
+  const mk = (contentType, width, height, bitrate) => ({
+    type: "media-source",
+    video: { contentType, width, height, bitrate, framerate: 30 },
+    audio: { contentType: 'audio/mp4; codecs="mp4a.40.2"', channels: 2, bitrate: 128e3, samplerate: 48e3 }
+  });
+  const probes = [
+    ["h264_720p", mk('video/mp4; codecs="avc1.64001f"', 1280, 720, 25e5)],
+    ["h264_1080p", mk('video/mp4; codecs="avc1.640028"', 1920, 1080, 5e6)],
+    ["vp9_1080p", mk('video/webm; codecs="vp09.00.51.08"', 1920, 1080, 5e6)]
+  ];
+  const out = {};
+  for (const [key, cfg] of probes) {
+    try {
+      const info = await mc.decodingInfo(cfg);
+      out[key] = {
+        supported: !!info?.supported,
+        smooth: info?.smooth,
+        powerEfficient: info?.powerEfficient
+      };
+    } catch {
+    }
+  }
+  return Object.keys(out).length ? out : void 0;
+}
+function safeUa() {
+  try {
+    return globalThis.navigator?.userAgent;
+  } catch {
+    return void 0;
+  }
+}
+function canPlayType(videoEl, mime) {
+  try {
+    const v = videoEl ?? (typeof document !== "undefined" ? document.createElement("video") : void 0);
+    if (!v || typeof v.canPlayType !== "function") return false;
+    return v.canPlayType(mime) !== "";
+  } catch {
+    return false;
+  }
+}
+function createCapabilityReport(videoEl, cfg, mediaDecoding) {
+  const w = globalThis;
+  const notes = [];
+  const mse = !!w.MediaSource && typeof w.MediaSource.isTypeSupported === "function";
+  const eme = !!(w.navigator && w.navigator.requestMediaKeySystemAccess);
+  const mediaCapabilities = !!(w.navigator && w.navigator.mediaCapabilities);
+  if (!mse) notes.push("MediaSource (MSE) not available");
+  if (!eme) notes.push("Encrypted Media Extensions (EME) not available");
+  const canPlay = {
+    'video/mp4; codecs="avc1.42E01E"': canPlayType(videoEl, 'video/mp4; codecs="avc1.42E01E"'),
+    'video/mp4; codecs="hvc1.1.6.L93.B0"': canPlayType(videoEl, 'video/mp4; codecs="hvc1.1.6.L93.B0"'),
+    'video/webm; codecs="vp09.00.10.08"': canPlayType(videoEl, 'video/webm; codecs="vp09.00.10.08"'),
+    'video/webm; codecs="av01.0.05M.08"': canPlayType(videoEl, 'video/webm; codecs="av01.0.05M.08"'),
+    "application/vnd.apple.mpegurl": canPlayType(videoEl, "application/vnd.apple.mpegurl"),
+    "application/dash+xml": canPlayType(videoEl, "application/dash+xml")
+  };
+  const secure = (() => {
+    try {
+      return !!globalThis.isSecureContext;
+    } catch {
+      return false;
+    }
+  })();
+  if (!secure) notes.push("Not running in a secure context (HTTPS). DRM and some APIs may fail.");
+  const src = cfg?.source;
+  const drmCfg = cfg ? cfg.drm ?? src?.drm : void 0;
+  const drmFlag = !!drmCfg;
+  return {
+    timestamp: Date.now(),
+    userAgent: safeUa(),
+    source: src ? {
+      type: src.type,
+      live: src.live,
+      drm: drmFlag,
+      url: src.url,
+      contentId: src.contentId
+    } : void 0,
+    platform: { isSecureContext: secure },
+    features: { mse, eme, mediaCapabilities },
+    canPlay,
+    mediaDecoding,
+    notes
+  };
+}
+
+// src/remote-config/remote-config.ts
+var DEFAULT_ALLOW = [
+  "profile",
+  "abr",
+  "resilience",
+  "drm",
+  "ads",
+  "ui",
+  "subtitles",
+  "metadata",
+  "progress",
+  "chapters",
+  "offline"
+];
+function isPlainObject(v) {
+  return !!v && typeof v === "object" && !Array.isArray(v);
+}
+function deepMerge(base, patch) {
+  const out = { ...base };
+  for (const [k, v] of Object.entries(patch)) {
+    if (isPlainObject(v) && isPlainObject(out[k])) out[k] = deepMerge(out[k], v);
+    else out[k] = v;
+  }
+  return out;
+}
+function shallowMerge(base, patch) {
+  return { ...base, ...patch };
+}
+function hashKey(url) {
+  let h = 0;
+  for (let i = 0; i < url.length; i++) h = h * 31 + url.charCodeAt(i) >>> 0;
+  return h.toString(16);
+}
+async function readCache(storage, key) {
+  if (!storage?.get) return null;
+  const raw = await storage.get(key);
+  if (!raw) return null;
+  try {
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed.ts !== "number" || !isPlainObject(parsed.data)) return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+async function writeCache(storage, key, entry) {
+  if (!storage?.set) return;
+  await storage.set(key, JSON.stringify(entry));
+}
+async function applyRemoteConfig(cfg, ports) {
+  const rc = cfg.remoteConfig;
+  if (!rc?.enabled) return { config: cfg, applied: false, source: "none" };
+  const url = rc.url;
+  const ttlMs = Math.max(1, rc.ttlSec ?? 300) * 1e3;
+  const mode = rc.mode ?? "deep";
+  const allow = rc.allow?.length ? rc.allow : DEFAULT_ALLOW;
+  const cacheKey = `remoteConfig:${hashKey(url)}`;
+  const now = Date.now();
+  try {
+    const cached = await readCache(ports.storage, cacheKey);
+    if (cached && now - cached.ts < ttlMs) {
+      const patch2 = filterAllowList(cached.data, allow);
+      const merged2 = mode === "shallow" ? shallowMerge(cfg, patch2) : deepMerge(cfg, patch2);
+      return { config: merged2, applied: true, payload: cached.data, source: "cache" };
+    }
+    const fetch2 = ports.http?.fetch;
+    if (!fetch2) throw new Error("Remote config enabled but no ports.http.fetch provided");
+    const res = await fetch2(url, { method: "GET", headers: { "accept": "application/json" } });
+    if (!res.ok) throw new Error(`Remote config HTTP ${res.status}`);
+    const json = await res.json();
+    if (!isPlainObject(json)) throw new Error("Remote config payload must be a JSON object");
+    const payload = json;
+    await writeCache(ports.storage, cacheKey, { ts: now, data: payload });
+    const patch = filterAllowList(payload, allow);
+    const merged = mode === "shallow" ? shallowMerge(cfg, patch) : deepMerge(cfg, patch);
+    return { config: merged, applied: true, payload, source: "network" };
+  } catch (err) {
+    ports.log?.warn?.("[ngxsp] remoteConfig failed", err);
+    return { config: cfg, applied: false, source: "none" };
+  }
+}
+function filterAllowList(payload, allow) {
+  const out = {};
+  for (const k of allow) {
+    if (Object.prototype.hasOwnProperty.call(payload, k)) out[k] = payload[k];
+  }
+  return out;
+}
+
+// src/ports/storage.port.ts
+var MemoryStoragePort = class {
+  map = /* @__PURE__ */ new Map();
+  async get(key) {
+    return this.map.get(key) ?? null;
+  }
+  async set(key, value) {
+    this.map.set(key, value);
+  }
+  async remove(key) {
+    this.map.delete(key);
+  }
+};
+
+// src/ports/telemetry.port.ts
+var NoopTelemetryPort = class {
+  add(_sample) {
+  }
+};
+
+// src/ports/log.port.ts
+var ConsoleLogPort = class {
+  debug(...args) {
+    console.debug(...args);
+  }
+  info(...args) {
+    console.info(...args);
+  }
+  warn(...args) {
+    console.warn(...args);
+  }
+  error(...args) {
+    console.error(...args);
+  }
+};
+
+// src/ports/ports.ts
+function createDefaultPorts() {
+  const http = { fetch: (input, init) => fetch(input, init) };
+  return {
+    http,
+    storage: new MemoryStoragePort(),
+    telemetry: new NoopTelemetryPort(),
+    log: new ConsoleLogPort()
+  };
+}
+
+// src/facade/player-facade.ts
+var PlayerFacade = class {
+  constructor(chooseEngine = defaultEngineChooser, ports = createDefaultPorts()) {
+    this.chooseEngine = chooseEngine;
+    this.ports = ports;
+  }
+  engineFactories = [createNativeEngineFactory()];
+  engineId = "native";
+  lastNonFatal = null;
+  // Optional MediaCapabilities decoding probes (async, best-effort)
+  mediaDecodingSub = new rxjs.BehaviorSubject(null);
+  video;
+  engine;
+  plugins = [];
+  ctx;
+  stateSub = new rxjs.BehaviorSubject({ kind: "idle" });
+  timeSub = new rxjs.BehaviorSubject({ currentTime: 0, duration: 0 });
+  bufferSub = new rxjs.BehaviorSubject(0);
+  tracksSub = new rxjs.BehaviorSubject([]);
+  errorSub = new rxjs.Subject();
+  metadataSub = new rxjs.BehaviorSubject(null);
+  capsSub = new rxjs.BehaviorSubject(null);
+  capabilities$ = this.capsSub.asObservable();
+  state$ = this.stateSub.asObservable();
+  time$ = this.timeSub.asObservable();
+  bufferAheadSec$ = this.bufferSub.asObservable();
+  tracks$ = this.tracksSub.asObservable();
+  error$ = this.errorSub.asObservable();
+  metadata$ = this.metadataSub.asObservable();
+  seriesIndexSub = new rxjs.BehaviorSubject(null);
+  seriesIndex$ = this.seriesIndexSub.asObservable();
+  playlistIndexSub = new rxjs.BehaviorSubject(null);
+  playlistIndex$ = this.playlistIndexSub.asObservable();
+  playlist = [];
+  playlistKey = "";
+  externalVttUrl;
+  attach(videoEl, plugins = [], config, ports, engines) {
+    if (ports) {
+      this.ports = { ...this.ports, ...ports };
+    }
+    if (engines && engines.length) {
+      this.engineFactories = [createNativeEngineFactory(), ...engines];
+    } else {
+      this.engineFactories = [createNativeEngineFactory()];
+    }
+    this.video = videoEl;
+    this.plugins = plugins ?? [];
+    this.ctx = { config, facade: this, ports: this.ports, contentId: config.source.contentId };
+    void detectPlaybackCapabilities(videoEl).then((c) => this.capsSub.next(c)).catch(() => this.capsSub.next(null));
+    void createMediaDecodingReport().then((r) => this.mediaDecodingSub.next(r ?? null)).catch(() => this.mediaDecodingSub.next(null));
+    this.emitTelemetry("player:attach", "info");
+    this.emitTelemetry("player:source_set", "info", { type: config.source.type, live: config.source.live });
+    this.installVideoEventListeners();
+    for (const p of this.plugins) {
+      try {
+        void p.onInit?.(this.ctx);
+      } catch {
+      }
+    }
+  }
+  async load(config, opts) {
+    if (!this.video) throw new Error("PlayerFacade not attached");
+    if (!this.ctx) throw new Error("PlayerFacade context missing");
+    const rc = await applyRemoteConfig(config, this.ports);
+    if (rc.applied) {
+      this.ports.telemetry?.add?.({
+        event: "remote_config:applied",
+        level: "info",
+        ts: Date.now(),
+        data: { source: rc.source, url: config.remoteConfig?.url }
+      });
+      config = rc.config;
+    }
+    const list = config.playlist ?? [];
+    if (list.length > 0) {
+      const key = list.map((s) => s.contentId ?? s.url ?? s.filePath ?? "").join("|");
+      if (key !== this.playlistKey) {
+        this.playlistKey = key;
+        this.playlist = list;
+        const startIdx = config.playlistStartIndex ?? 0;
+        this.playlistIndexSub.next(Math.max(0, Math.min(startIdx, list.length - 1)));
+      }
+      if (opts?.playlistIndex != null) {
+        this.playlistIndexSub.next(Math.max(0, Math.min(opts.playlistIndex, list.length - 1)));
+      }
+      const idx = this.playlistIndexSub.value ?? 0;
+      const src = list[idx] ?? config.source;
+      config = { ...config, source: src, autoNext: config.autoNext ?? true };
+      this.emitTelemetry("player:playlist_index", "info", { index: idx, total: list.length });
+    }
+    this.ctx.config = config;
+    this.ctx.contentId = config.source.contentId;
+    this.emitTelemetry("player:load_start", "info");
+    try {
+      const now = globalThis.performance?.now?.() ?? Date.now();
+      this.qoe.loadStartMs = now;
+      this.qoe.firstFrameMs = 0;
+      this.qoe.startupMs = 0;
+      this.qoe.rebufferCount = 0;
+      this.qoe.rebufferMs = 0;
+      this.qoe.rebufferStartMs = 0;
+      this.qoe.firstFrameEmitted = false;
+    } catch {
+    }
+    for (const p of this.plugins) {
+      try {
+        await p.onLoadStart?.(this.ctx);
+      } catch {
+      }
+    }
+    if (this.engine) {
+      try {
+        await this.engine.destroy();
+      } catch {
+      }
+      this.engine = void 0;
+    }
+    const caps = this.capsSub.value ?? void 0;
+    const chosen = selectEngine(config, this.engineFactories, caps);
+    if (!chosen) {
+      const detail = { source: config.source, caps };
+      this.emitFatal(new Error(`No engine registered for this source: ${JSON.stringify(detail)}`), "ENGINE_MISSING");
+      throw new Error("ENGINE_MISSING");
+    }
+    const engine = chosen.create();
+    this.engine = engine;
+    this.engineId = engine.id ?? (engine.constructor?.name ?? "engine");
+    this.emitTelemetry("player:engine_selected", "info", { engineId: this.engineId });
+    await engine.attach(this.video);
+    const off = engine.onEvent((ev) => this.handleEngineEvent(ev));
+    this._offEngine = off;
+    const startTime = opts?.startTimeSec;
+    const sourceWithDrm = applyEngineProfileToSource(
+      {
+        ...config.source,
+        drm: config.drm ?? config.source.drm,
+        profile: config.profile ?? config.source.profile
+      },
+      config.profile ?? config.source.profile
+    );
+    try {
+      await engine.load(sourceWithDrm, { startTimeSec: startTime ?? void 0 });
+      this.stateSub.next({ kind: "paused" });
+      this.emitTelemetry("player:load_ok", "info");
+    } catch (err) {
+      this.emitTelemetry("player:load_fail", "error", {}, err?.message);
+      this.emitFatal(err, "UNKNOWN");
+      throw err;
+    }
+    for (const p of this.plugins) {
+      try {
+        await p.onLoaded?.(this.ctx);
+      } catch {
+      }
+    }
+  }
+  async reload(opts) {
+    if (!this.ctx) throw new Error("PlayerFacade context missing");
+    const snap = this.snapshot();
+    const start = opts?.startTimeSec ?? snap.currentTime ?? 0;
+    await this.load(this.ctx.config, { startTimeSec: start });
+  }
+  async next() {
+    if (!this.ctx) return;
+    const cfg = this.ctx.config;
+    const list = cfg.playlist ?? this.playlist;
+    if (!list || list.length === 0) return;
+    const idx = (this.playlistIndexSub.value ?? 0) + 1;
+    if (idx >= list.length) return;
+    await this.load(cfg, { playlistIndex: idx, startTimeSec: 0 });
+  }
+  async previous() {
+    if (!this.ctx) return;
+    const cfg = this.ctx.config;
+    const list = cfg.playlist ?? this.playlist;
+    if (!list || list.length === 0) return;
+    const idx = (this.playlistIndexSub.value ?? 0) - 1;
+    if (idx < 0) return;
+    await this.load(cfg, { playlistIndex: idx, startTimeSec: 0 });
+  }
+  async destroy() {
+    try {
+      for (const p of this.plugins) {
+        try {
+          await p.onDestroy?.(this.ctx);
+        } catch {
+        }
+      }
+    } finally {
+      try {
+        this._offEngine?.();
+      } catch {
+      }
+      try {
+        await this.engine?.destroy();
+      } catch {
+      }
+      this.engine = void 0;
+      this.video = void 0;
+      this.ctx = void 0;
+      this.plugins = [];
+      this.emitTelemetry("player:init", "debug", { destroyed: true });
+    }
+  }
+  /** Emit a non-fatal error (does not transition to fatal error state). */
+  emitNonFatal(err, code = "UNKNOWN") {
+    const pe = this.toPlayerError(err, false, code);
+    this.lastNonFatal = pe;
+    this.emitTelemetry("player:error_nonfatal", "warn", { code: pe.code }, pe.message);
+    this.errorSub.next(pe);
+  }
+  /** Emit a fatal error (transitions to error state). */
+  emitFatal(err, code = "UNKNOWN") {
+    const pe = this.toPlayerError(err, true, code);
+    this.emitTelemetry("player:error_fatal", "error", { code: pe.code }, pe.message);
+    this.stateSub.next({ kind: "error", error: pe });
+    this.errorSub.next(pe);
+    if (this.ctx) {
+      for (const p of this.plugins) {
+        try {
+          void p.onError?.(this.ctx, pe);
+        } catch {
+        }
+      }
+    }
+  }
+  async tryAutoNext() {
+    if (!this.ctx) return;
+    const cfg = this.ctx.config;
+    const list = cfg.playlist ?? this.playlist;
+    if (!list || list.length === 0) return;
+    const auto = cfg.autoNext ?? true;
+    if (!auto) return;
+    const idx = this.playlistIndexSub.value ?? 0;
+    if (idx >= list.length - 1) return;
+    const nextIdx = idx + 1;
+    this.emitTelemetry("player:auto_next", "info", { from: idx, to: nextIdx, total: list.length });
+    try {
+      await this.load(cfg, { playlistIndex: nextIdx, startTimeSec: 0 });
+    } catch {
+    }
+  }
+  installed = false;
+  // QoE metrics (v1.7)
+  qoe = {
+    loadStartMs: 0,
+    firstFrameMs: 0,
+    startupMs: 0,
+    rebufferCount: 0,
+    rebufferMs: 0,
+    rebufferStartMs: 0,
+    firstFrameEmitted: false
+  };
+  installVideoEventListeners() {
+    const v = this.video;
+    if (!v || this.installed) return;
+    this.installed = true;
+    const nowMs = () => globalThis.performance?.now?.() ?? Date.now();
+    const maybeFirstFrame = () => {
+      if (this.qoe.firstFrameEmitted) return;
+      const t = nowMs();
+      this.qoe.firstFrameMs = t;
+      if (this.qoe.loadStartMs) this.qoe.startupMs = Math.max(0, t - this.qoe.loadStartMs);
+      this.qoe.firstFrameEmitted = true;
+      this.emitTelemetry("qoe:first_frame", "info", { firstFrameMs: this.qoe.startupMs });
+    };
+    const maybeEndRebuffer = () => {
+      if (!this.qoe.rebufferStartMs) return;
+      const t = nowMs();
+      const delta = Math.max(0, t - this.qoe.rebufferStartMs);
+      this.qoe.rebufferMs += delta;
+      this.qoe.rebufferStartMs = 0;
+      this.emitTelemetry("qoe:rebuffer_end", "debug", { deltaMs: delta, totalMs: this.qoe.rebufferMs, count: this.qoe.rebufferCount });
+    };
+    v.addEventListener("timeupdate", () => {
+      this.emitTelemetry("player:timeupdate", "debug", { t: v.currentTime, d: v.duration });
+    });
+    v.addEventListener("loadeddata", () => {
+      maybeFirstFrame();
+    });
+    v.addEventListener("playing", () => {
+      maybeFirstFrame();
+      maybeEndRebuffer();
+      this.emitTelemetry("player:playing", "info");
+    });
+    v.addEventListener("waiting", () => {
+      if (!this.qoe.rebufferStartMs) {
+        this.qoe.rebufferCount += 1;
+        this.qoe.rebufferStartMs = nowMs();
+        this.emitTelemetry("qoe:rebuffer_start", "debug", { count: this.qoe.rebufferCount });
+      }
+    });
+    v.addEventListener("stalled", () => {
+      if (!this.qoe.rebufferStartMs) {
+        this.qoe.rebufferCount += 1;
+        this.qoe.rebufferStartMs = nowMs();
+        this.emitTelemetry("qoe:rebuffer_start", "debug", { count: this.qoe.rebufferCount, reason: "stalled" });
+      }
+    });
+    v.addEventListener("ended", () => {
+      maybeEndRebuffer();
+      this.emitTelemetry("player:ended", "info");
+      this.emitTelemetry("qoe:summary", "info", { startupMs: this.qoe.startupMs, rebufferCount: this.qoe.rebufferCount, rebufferMs: this.qoe.rebufferMs });
+      void this.tryAutoNext();
+    });
+    v.addEventListener("pause", () => {
+      this.emitTelemetry("player:pause", "info");
+    });
+    v.addEventListener("error", () => {
+      const me = v.error;
+      if (!me) return;
+      const codeMap = {
+        1: "UNKNOWN",
+        2: "NETWORK_HTTP",
+        3: "DECODE_ERROR",
+        4: "SRC_NOT_SUPPORTED"
+      };
+      const c = codeMap[me.code] ?? "UNKNOWN";
+      this.emitFatal(me, c);
+    });
+  }
+  emitTelemetry(event, level = "info", data, message) {
+    try {
+      const cfg = this.ctx?.config;
+      const contentId = cfg?.source?.contentId;
+      const sample = {
+        ts: Date.now(),
+        level,
+        event,
+        contentId,
+        engineId: this.engineId,
+        message,
+        data
+      };
+      this.ports.telemetry.add(sample);
+    } catch {
+    }
+  }
+  toPlayerError(err, fatal, code = "UNKNOWN") {
+    const e = err;
+    const msg = e?.message ? String(e.message) : String(err ?? "Unknown error");
+    return { code, message: msg, fatal, details: e };
+  }
+  async play() {
+    this.emitTelemetry("player:play_request", "info");
+    try {
+      await this.engine?.play();
+      this.emitTelemetry("player:play_ok", "info");
+    } catch (err) {
+      const name = err?.name;
+      if (name === "NotAllowedError") {
+        this.emitNonFatal(err, "AUTOPLAY_BLOCKED");
+        this.emitTelemetry("player:play_fail", "warn", { code: "AUTOPLAY_BLOCKED" }, err?.message);
+      } else {
+        this.emitFatal(err, "UNKNOWN");
+        this.emitTelemetry("player:play_fail", "error", { code: "UNKNOWN" }, err?.message);
+      }
+      throw err;
+    }
+  }
+  async pause() {
+    await this.engine?.pause();
+  }
+  async seekTo(timeSec) {
+    await this.engine?.seekTo(timeSec);
+  }
+  async setRate(rate) {
+    await this.engine?.setPlaybackRate(rate);
+  }
+  async setVolume(volume) {
+    await this.engine?.setVolume(volume);
+  }
+  async setTextTrack(trackId) {
+    if (trackId === "external") {
+      if (this.video && this.externalVttUrl) {
+        this.ensureExternalTrack(this.externalVttUrl);
+      }
+      return;
+    }
+    await this.engine?.setTextTrack(trackId);
+  }
+  async setAudioTrack(trackId) {
+    await this.engine?.setAudioTrack(trackId);
+  }
+  async setVideoTrack(trackId) {
+    await this.engine?.setVideoTrack(trackId);
+  }
+  // UI helpers
+  setAspectRatio(_mode) {
+  }
+  snapshot() {
+    const time = this.timeSub.value;
+    return {
+      currentTime: time.currentTime,
+      duration: time.duration,
+      state: this.stateSub.value,
+      bufferedAheadSec: this.bufferSub.value
+    };
+  }
+  /**
+   * Diagnostics helper for UI / support logs.
+   * Safe to call anytime after attach().
+   */
+  diagnostics() {
+    const snap = this.snapshot();
+    const bufferedEnd = (snap.currentTime ?? 0) + (snap.bufferedAheadSec ?? 0);
+    const time = {
+      currentTime: snap.currentTime,
+      duration: snap.duration,
+      bufferedEnd
+    };
+    const engine = {
+      id: this.engine?.id ?? "none",
+      selectedBy: "supports",
+      reasons: []
+    };
+    const source = this.ctx?.config?.source;
+    return {
+      ts: Date.now(),
+      engine,
+      capabilities: createCapabilityReport(
+        this.video ?? void 0,
+        this.ctx?.config,
+        this.mediaDecodingSub.value ?? void 0
+      ),
+      source,
+      state: snap.state,
+      time,
+      lastNonFatal: this.lastNonFatal,
+      // backward compat
+      selectedEngineId: engine.id,
+      snapshot: {
+        currentTime: snap.currentTime,
+        duration: snap.duration,
+        state: snap.state,
+        bufferedAheadSec: snap.bufferedAheadSec
+      }
+    };
+  }
+  // External tracks (for provider-based subtitles)
+  async setExternalVttTrack(lang, vtt) {
+    if (!this.video) return;
+    const blob = new Blob([vtt], { type: "text/vtt" });
+    this.externalVttUrl = URL.createObjectURL(blob);
+    this.ensureExternalTrack(this.externalVttUrl, lang);
+  }
+  setMetadata(meta) {
+    this.metadataSub.next(meta);
+  }
+  ensureExternalTrack(url, lang = "und") {
+    if (!this.video) return;
+    const prev = this.video.querySelector('track[data-external="true"]');
+    if (prev) prev.remove();
+    const track = document.createElement("track");
+    track.kind = "subtitles";
+    track.label = `External (${lang})`;
+    track.srclang = lang;
+    track.src = url;
+    track.default = true;
+    track.setAttribute("data-external", "true");
+    this.video.appendChild(track);
+  }
+  handleEngineEvent(ev) {
+    if (ev.type === "timeupdate") {
+      this.timeSub.next({ currentTime: ev.currentTime, duration: ev.duration });
+      return;
+    }
+    if (ev.type === "bufferupdate") {
+      this.bufferSub.next(ev.bufferedAheadSec);
+      return;
+    }
+    if (ev.type === "tracks") {
+      this.tracksSub.next(ev.tracks);
+      return;
+    }
+    if (ev.type === "state") {
+      const map = {
+        loading: { kind: "loading" },
+        buffering: { kind: "buffering" },
+        playing: { kind: "playing" },
+        paused: { kind: "paused" },
+        ended: { kind: "ended" }
+      };
+      this.stateSub.next(map[ev.state] ?? { kind: "idle" });
+      try {
+        this.ctx?.ports.telemetry.add({ t: Date.now(), kind: "state", state: ev.state });
+      } catch {
+      }
+      if (ev.state === "ended") void this.tryAutoNext();
+      return;
+    }
+    if (ev.type === "error") {
+      const pe = { code: ev.error.code, message: ev.error.message, fatal: ev.error.fatal, details: ev.error.details };
+      this.stateSub.next({ kind: "error", error: pe });
+      this.errorSub.next(pe);
+      try {
+        this.ctx?.ports.telemetry.add({ t: Date.now(), kind: "error", code: pe.code, fatal: !!pe.fatal });
+      } catch {
+      }
+      if (this.ctx) for (const p of this.plugins) void p.onError?.(this.ctx, pe);
+      return;
+    }
+  }
+  async tryRestoreStartTime(_config) {
+    return null;
+  }
+};
+function defaultEngineChooser(cfg) {
+  const t = cfg.source.type;
+  const url = t === "url" ? cfg.source.url : "";
+  const looksLikeHls = typeof url === "string" && /\.m3u8($|\?)/i.test(url);
+  const looksLikeDash = typeof url === "string" && /\.mpd($|\?)/i.test(url);
+  const hasDrm = !!cfg.source.drm;
+  if (t === "hls" || t === "dash" || looksLikeHls || looksLikeDash || hasDrm) return new NativeEngine();
+  return new NativeEngine();
+}
+
+// src/plugins/metadata/providers/local-metadata.provider.ts
+var LocalMetadataProvider = class {
+  id = "local";
+  async match(_hint) {
+    return [];
+  }
+  async fetch(id) {
+    const res = await fetch(id);
+    if (!res.ok) throw new Error(`Metadata fetch failed: ${res.status}`);
+    const ct = res.headers.get("content-type") ?? "";
+    const text = await res.text();
+    if (ct.includes("application/json") || looksLikeJson(text)) {
+      try {
+        return JSON.parse(text);
+      } catch {
+      }
+    }
+    return { description: text };
+  }
+};
+function looksLikeJson(t) {
+  const s = t.trim();
+  return s.startsWith("{") && s.endsWith("}") || s.startsWith("[") && s.endsWith("]");
+}
+
+// src/plugins/subtitles/providers/local-subtitle.provider.ts
+var LocalSubtitleProvider = class {
+  id = "local";
+  async search(query) {
+    return [];
+  }
+  async fetch(candidate) {
+    if (!candidate.url) throw new Error("LocalSubtitleProvider: candidate.url is required");
+    const res = await fetch(candidate.url);
+    if (!res.ok) throw new Error(`Subtitle fetch failed: ${res.status}`);
+    return await res.text();
+  }
+};
+
+// src/utils/cache-store.ts
+var DefaultCacheStore = class {
+  dbp = null;
+  async get(key) {
+    const db = await this.db();
+    if (db) return idbGet(db, key);
+    return lsGet(key);
+  }
+  async set(key, value, ttlMs) {
+    const payload = { value, exp: Date.now() + ttlMs };
+    const db = await this.db();
+    if (db) return idbSet(db, key, payload);
+    lsSet(key, payload);
+  }
+  async del(key) {
+    const db = await this.db();
+    if (db) return idbDel(db, key);
+    localStorage.removeItem(key);
+  }
+  db() {
+    if (typeof indexedDB === "undefined") return Promise.resolve(null);
+    if (!this.dbp) this.dbp = openDb();
+    return this.dbp;
+  }
+};
+var DB_NAME = "ngx-smart-player-cache";
+var STORE = "kv";
+function openDb() {
+  return new Promise((resolve) => {
+    const req = indexedDB.open(DB_NAME, 1);
+    req.onupgradeneeded = () => {
+      const db = req.result;
+      if (!db.objectStoreNames.contains(STORE)) db.createObjectStore(STORE);
+    };
+    req.onsuccess = () => resolve(req.result);
+    req.onerror = () => resolve(null);
+  });
+}
+async function idbGet(db, key) {
+  return new Promise((resolve) => {
+    const tx = db.transaction(STORE, "readonly");
+    const st = tx.objectStore(STORE);
+    const req = st.get(key);
+    req.onsuccess = () => {
+      const v = req.result;
+      if (!v) return resolve(null);
+      if (v.exp && Date.now() > v.exp) return resolve(null);
+      resolve(v.value);
+    };
+    req.onerror = () => resolve(null);
+  });
+}
+async function idbSet(db, key, val) {
+  return new Promise((resolve) => {
+    const tx = db.transaction(STORE, "readwrite");
+    tx.objectStore(STORE).put(val, key);
+    tx.oncomplete = () => resolve();
+    tx.onerror = () => resolve();
+  });
+}
+async function idbDel(db, key) {
+  return new Promise((resolve) => {
+    const tx = db.transaction(STORE, "readwrite");
+    tx.objectStore(STORE).delete(key);
+    tx.oncomplete = () => resolve();
+    tx.onerror = () => resolve();
+  });
+}
+function lsGet(key) {
+  const raw = localStorage.getItem(key);
+  if (!raw) return null;
+  try {
+    const v = JSON.parse(raw);
+    if (v?.exp && Date.now() > v.exp) return null;
+    return v?.value ?? null;
+  } catch {
+    return null;
+  }
+}
+function lsSet(key, val) {
+  try {
+    localStorage.setItem(key, JSON.stringify(val));
+  } catch {
+  }
+}
+
+// src/commands.ts
+function isCategorizedEventType(type) {
+  return /^(playback|engine|network|drm|ads|subtitles|ui):/.test(type);
+}
+
+// src/events/event-bus.ts
+var SimpleEventBus = class {
+  handlers = /* @__PURE__ */ new Map();
+  emit(event) {
+    const set = this.handlers.get(event.type);
+    if (!set) return;
+    for (const h of Array.from(set)) h(event);
+  }
+  on(type, handler) {
+    const set = this.handlers.get(type) ?? /* @__PURE__ */ new Set();
+    set.add(handler);
+    this.handlers.set(type, set);
+    return () => set.delete(handler);
+  }
+};
+
+// src/plugins/progress/progress.plugin.ts
+function keyFor(contentId) {
+  return `progress:${contentId}`;
+}
+var ProgressPlugin = class {
+  id = "progress";
+  timer = null;
+  async onLoadStart(ctx) {
+    this.stop();
+  }
+  async onLoaded(ctx) {
+    const contentId = ctx.contentId ?? ctx.config.source.contentId;
+    if (!contentId) return;
+    try {
+      if (ctx.config.progress.mode === "local" || ctx.config.progress.mode === "hybrid") {
+        const raw = await ctx.ports.storage.get(keyFor(contentId));
+        if (raw) {
+          const rec = JSON.parse(raw);
+          if (Number.isFinite(rec.positionSec) && rec.positionSec > 0) {
+            await ctx.facade.seekTo(rec.positionSec);
+          }
+        }
+      }
+    } catch (e) {
+      ctx.ports.log.warn("[ProgressPlugin] restore failed", e);
+    }
+    const intervalMs = Math.max(3, ctx.config.progress.intervalSec ?? 10) * 1e3;
+    this.timer = setInterval(() => void this.save(ctx), intervalMs);
+  }
+  async onDestroy(ctx) {
+    this.stop();
+    await this.save(ctx);
+  }
+  stop() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+  }
+  async save(ctx) {
+    const contentId = ctx.contentId ?? ctx.config.source.contentId;
+    if (!contentId) return;
+    const snap = ctx.facade.snapshot();
+    const positionSec = Math.max(0, snap.currentTime);
+    const rec = {
+      contentId,
+      positionSec,
+      durationSec: snap.duration || void 0,
+      updatedAt: Date.now()
+    };
+    try {
+      if (ctx.config.progress.mode === "local" || ctx.config.progress.mode === "hybrid") {
+        await ctx.ports.storage.set(keyFor(contentId), JSON.stringify(rec));
+      }
+    } catch (e) {
+      ctx.ports.log.warn("[ProgressPlugin] local save failed", e);
+    }
+    try {
+      if ((ctx.config.progress.mode === "server" || ctx.config.progress.mode === "hybrid") && ctx.config.progress.endpoint) {
+        await ctx.ports.http.fetch(ctx.config.progress.endpoint, {
+          method: "POST",
+          headers: { "content-type": "application/json" },
+          body: JSON.stringify(rec)
+        });
+      }
+    } catch (e) {
+      ctx.ports.log.warn("[ProgressPlugin] server save failed", e);
+    }
+  }
+};
+
+// src/plugins/resilience/resilience.plugin.ts
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+var ResiliencePlugin = class {
+  id = "resilience";
+  attempts = 0;
+  recovering = false;
+  async onLoadStart(ctx) {
+    this.attempts = 0;
+    this.recovering = false;
+    if (ctx.config.resilience.healthEndpoint) {
+      void this.health(ctx);
+    }
+  }
+  async onError(ctx, err) {
+    if (this.recovering) return;
+    if (err.fatal) return;
+    const max = Math.max(0, ctx.config.resilience.retries ?? 0);
+    if (this.attempts >= max) return;
+    this.attempts++;
+    this.recovering = true;
+    const min = ctx.config.resilience.backoffMs?.min ?? 500;
+    const maxMs = ctx.config.resilience.backoffMs?.max ?? 8e3;
+    const backoff = Math.min(maxMs, min * Math.pow(2, this.attempts - 1));
+    ctx.ports.log.warn("[ResiliencePlugin] retry", { attempt: this.attempts, backoff, code: err.code });
+    if (ctx.config.resilience.healthEndpoint) {
+      await this.health(ctx);
+    }
+    await sleep(backoff);
+    try {
+      const snap = ctx.facade.snapshot();
+      await ctx.facade.reload({ startTimeSec: snap.currentTime || void 0 });
+    } catch (e) {
+      ctx.ports.log.error("[ResiliencePlugin] reload failed", e);
+    } finally {
+      this.recovering = false;
+    }
+  }
+  async health(ctx) {
+    try {
+      await ctx.ports.http.fetch(ctx.config.resilience.healthEndpoint, { method: "GET" });
+    } catch (e) {
+      ctx.ports.log.warn("[ResiliencePlugin] health check failed", e);
+    }
+  }
+};
+
+// src/plugins/ads/ssai.plugin.ts
+function appendQuery(url, q) {
+  try {
+    const base = typeof window !== "undefined" ? window.location.href : "http://localhost";
+    const u = new URL(url, base);
+    for (const [k, v] of Object.entries(q)) {
+      if (v === void 0 || v === null) continue;
+      u.searchParams.set(k, String(v));
+    }
+    return u.toString();
+  } catch {
+    return url;
+  }
+}
+function createSsaiManifestRewritePlugin() {
+  return {
+    id: "ads:ssai-manifest-rewrite",
+    async onLoadStart(ctx) {
+      const ads = ctx.config?.ads;
+      if (!ads || ads.enabled !== true) return;
+      if (ads.mode !== "ssai") return;
+      const provider = ads.providerConfig ?? {};
+      const src = ctx.config?.source;
+      if (!src || typeof src.url !== "string" || !src.url) return;
+      const before = src.url;
+      let after = before;
+      if (provider.stitchedUrl) after = provider.stitchedUrl;
+      if (provider.appendQuery) after = appendQuery(after, provider.appendQuery);
+      if (after !== before) {
+        src.url = after;
+        ctx.ports.telemetry?.add?.({
+          event: "ssai:manifest_rewrite",
+          level: "info",
+          ts: Date.now(),
+          payload: { before, after }
+        });
+      }
+    }
+  };
+}
+
+exports.ConsoleLogPort = ConsoleLogPort;
+exports.DefaultCacheStore = DefaultCacheStore;
+exports.LocalMetadataProvider = LocalMetadataProvider;
+exports.LocalSubtitleProvider = LocalSubtitleProvider;
+exports.MemoryStoragePort = MemoryStoragePort;
+exports.NativeEngine = NativeEngine;
+exports.NoopTelemetryPort = NoopTelemetryPort;
+exports.PlayerFacade = PlayerFacade;
+exports.ProgressPlugin = ProgressPlugin;
+exports.ResiliencePlugin = ResiliencePlugin;
+exports.SimpleEventBus = SimpleEventBus;
+exports.applyEngineProfileToSource = applyEngineProfileToSource;
+exports.applyRemoteConfig = applyRemoteConfig;
+exports.createCapabilityReport = createCapabilityReport;
+exports.createDefaultCapabilities = createDefaultCapabilities;
+exports.createDefaultPorts = createDefaultPorts;
+exports.createMediaDecodingReport = createMediaDecodingReport;
+exports.createNativeEngineFactory = createNativeEngineFactory;
+exports.createSsaiManifestRewritePlugin = createSsaiManifestRewritePlugin;
+exports.detectPlaybackCapabilities = detectPlaybackCapabilities;
+exports.getEngineProfileHints = getEngineProfileHints;
+exports.isCategorizedEventType = isCategorizedEventType;
+exports.selectEngine = selectEngine;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map