@video-lab/player-core 2.0.0 → 3.0.1

package/dist/index.cjs

@@ -26,8 +26,8 @@ let xgplayer = require("xgplayer");
 xgplayer = __toESM(xgplayer, 1);
 let xgplayer_flv_js = require("xgplayer-flv.js");
 xgplayer_flv_js = __toESM(xgplayer_flv_js, 1);
-let xgplayer_hls_js = require("xgplayer-hls.js");
-xgplayer_hls_js = __toESM(xgplayer_hls_js, 1);
+let hls_js_light = require("hls.js/light");
+hls_js_light = __toESM(hls_js_light, 1);
 /**
 * 只判断 FLV 的**数据轨**连续性,不是内容声音检测。
 *
@@ -498,6 +498,646 @@ function createKernelHealthAggregator(options) {
 	};
 }
 //#endregion
+//#region src/kernels/hls-adapter.ts
+/** 内部 HLS 生命周期适配器；恢复预算由调用者持有，不属于公开导出面。 */
+var HlsAdapter = class {
+	media;
+	onError;
+	config;
+	create;
+	current = null;
+	generation = 0;
+	destroyed = false;
+	repair = null;
+	constructor(media, onError, config = {}, create = (options) => new hls_js_light.default(options)) {
+		this.media = media;
+		this.onError = onError;
+		this.config = config;
+		this.create = create;
+	}
+	/** 供现有清晰度、音轨和诊断接线访问当前内核；替换后旧实例不得再使用。 */
+	get kernel() {
+		return this.current;
+	}
+	/** 创建一次显式加载动作；不重建媒体元素，不在错误回调里自动重试。 */
+	start(url) {
+		if (this.destroyed) throw new Error("HlsAdapter is destroyed");
+		this.stop();
+		const generation = this.generation;
+		const hls = this.create({
+			...this.config,
+			autoStartLoad: false
+		});
+		this.current = hls;
+		let running = true;
+		let sourceLoaded = false;
+		let repairPosition = null;
+		const valid = () => this.current === hls && this.generation === generation && running;
+		hls.on(hls_js_light.default.Events.MEDIA_ATTACHED, () => {
+			if (!valid()) return;
+			if (!sourceLoaded) {
+				sourceLoaded = true;
+				hls.loadSource(url);
+				if (valid()) hls.startLoad();
+			} else if (repairPosition !== null) {
+				const position = repairPosition;
+				repairPosition = null;
+				hls.startLoad(position);
+			}
+		});
+		this.repair = () => {
+			if (this.current !== hls || this.generation !== generation) return;
+			running = true;
+			repairPosition = this.media.currentTime;
+			hls.recoverMediaError();
+		};
+		hls.on(hls_js_light.default.Events.ERROR, (_event, error) => {
+			if (!valid()) return;
+			if (error.fatal) {
+				running = false;
+				hls.stopLoad();
+			}
+			this.onError(error);
+		});
+		try {
+			hls.attachMedia(this.media);
+		} catch (error) {
+			if (this.current === hls && this.generation === generation) this.stop();
+			throw error;
+		}
+	}
+	/** 仅由调度器发出的显式媒体修复动作；无内核时由调用方重拉。 */
+	recoverMediaError() {
+		if (this.destroyed || !this.current || !this.repair) return false;
+		this.repair();
+		return true;
+	}
+	/** 先使回调失效再销毁内核；媒体元素由播放器持有。 */
+	stop() {
+		this.generation += 1;
+		const hls = this.current;
+		this.current = null;
+		this.repair = null;
+		hls?.destroy();
+	}
+	/** 终止生命周期；重复销毁无副作用。 */
+	destroy() {
+		this.destroyed = true;
+		this.stop();
+	}
+};
+//#endregion
+//#region src/kernels/owned-hls-plugin.ts
+/** 生产 HLS 内部装配层；恢复预算由统一调度器持有，不作为宿主扩展口导出。 */
+var OwnedHlsPlugin = class extends xgplayer.BasePlugin {
+	static get pluginName() {
+		return "HlsJsPlugin";
+	}
+	static get defaultConfig() {
+		return { hlsOpts: {} };
+	}
+	adapter = null;
+	statisticsTimer = null;
+	disposed = false;
+	urlDescriptor;
+	constructor(args) {
+		super(args);
+		this.player.handleSource = false;
+	}
+	/** 保留现有 core 对 HlsJsPlugin.hls 的访问方式。 */
+	get hls() {
+		return this.adapter?.kernel ?? void 0;
+	}
+	afterCreate() {
+		this.urlDescriptor = Object.getOwnPropertyDescriptor(this.player, "url");
+		Object.defineProperty(this.player, "url", {
+			configurable: true,
+			get: () => {
+				const media = this.player.video;
+				return media instanceof HTMLMediaElement ? media.src : void 0;
+			}
+		});
+		this.on(xgplayer.Events.URL_CHANGE, this.onUrlChange);
+	}
+	beforePlayerInit() {
+		this.register(this.playerConfig.url);
+	}
+	onUrlChange = (url) => {
+		if (url.startsWith("blob:")) return;
+		this.playerConfig.url = url;
+		this.register(url);
+	};
+	register(url) {
+		if (this.disposed || typeof url !== "string" || !url) return;
+		if (!this.adapter) {
+			const media = this.player.video;
+			if (!(media instanceof HTMLMediaElement)) return;
+			const hlsOpts = { ...this.config.hlsOpts };
+			if (hlsOpts.startPosition === void 0 && typeof this.playerConfig.startTime === "number") hlsOpts.startPosition = this.playerConfig.startTime;
+			this.adapter = new HlsAdapter(media, (error) => {
+				if (this.disposed) return;
+				this.player.emit("HLS_ERROR", {
+					errorType: error.type,
+					errorDetails: error.details,
+					errorFatal: error.fatal
+				});
+			}, hlsOpts);
+		}
+		this.clearStatistics();
+		this.adapter.start(url);
+		this.attachStatistics();
+	}
+	attachStatistics() {
+		const hls = this.hls;
+		if (!hls) return;
+		const valid = () => !this.disposed && this.hls === hls;
+		let speed = 0;
+		hls.on(hls_js_light.default.Events.FRAG_LOADED, (_event, data) => {
+			if (valid()) speed = data.frag.stats.loaded / 1e3;
+		});
+		hls.on(hls_js_light.default.Events.BUFFER_CODECS, (_event, tracks) => {
+			if (!valid()) return;
+			const audio = tracks.audio;
+			const video = tracks.video ?? tracks.audiovideo;
+			const info = {
+				videoDataRate: 0,
+				audioDataRate: 0,
+				hasAudio: Boolean(audio || tracks.audiovideo),
+				hasVideo: Boolean(video),
+				audioChannelCount: audio?.metadata?.channelCount ?? 0,
+				audioCodec: audio?.codec,
+				videoCodec: video?.codec,
+				width: video?.metadata?.width,
+				height: video?.metadata?.height
+			};
+			Object.assign(this.player, { mediainfo: info });
+			this.player.emit("media_info", info);
+		});
+		this.statisticsTimer = setInterval(() => {
+			if (!valid()) return;
+			this.player.emit("statistics_info", {
+				speed,
+				playerType: "HlsPlayer"
+			});
+			speed = 0;
+		}, 1e3);
+	}
+	clearStatistics() {
+		if (this.statisticsTimer !== null) clearInterval(this.statisticsTimer);
+		this.statisticsTimer = null;
+	}
+	/** 调度器停止当前内核，保留插件、播放器及媒体元素。 */
+	stopLoading() {
+		this.clearStatistics();
+		this.adapter?.stop();
+	}
+	/** 显式媒体修复；无可修复内核时返回 false，供调度器选择重拉。 */
+	recoverMediaError() {
+		return this.adapter?.recoverMediaError() ?? false;
+	}
+	destroy() {
+		if (this.disposed) return;
+		this.disposed = true;
+		this.clearStatistics();
+		this.off(xgplayer.Events.URL_CHANGE, this.onUrlChange);
+		const adapter = this.adapter;
+		this.adapter = null;
+		if (this.urlDescriptor) Object.defineProperty(this.player, "url", this.urlDescriptor);
+		else Reflect.deleteProperty(this.player, "url");
+		adapter?.destroy();
+	}
+};
+//#endregion
+//#region src/page-fullscreen.ts
+/**
+* 接管锁定的 xgplayer 3.0.26 网页全屏按钮与 Esc；宿主确认后才应用本地状态。
+* 不替换 CSS 全屏方法，以保留原生/旋转全屏内部退出 CSS 全屏的清理路径。
+* 无 onRequest 时保留 inline 的本地行为。播放器插件初始化完成后调用。
+*/
+function attachPageFullscreen(player, options) {
+	const managed = options.onRequest !== void 0;
+	let available = !managed;
+	let destroyed = false;
+	const cssPlugin = player.getPlugin("cssFullscreen");
+	const keyboard = player.getPlugin("keyboard");
+	const escapeKey = keyboard?.keyCodeMap?.esc;
+	const originalEscape = escapeKey?.action;
+	const originalDisplay = cssPlugin?.root?.style.display ?? "";
+	const onChange = (active) => options.onChange(active);
+	player.on("cssFullscreen_change", onChange);
+	const request = (active) => {
+		if (!destroyed && available) options.onRequest?.(active);
+	};
+	const onButton = (_plugin, event) => {
+		if (available) cssPlugin?.emitUserAction?.(event, "switch_cssfullscreen", { cssfullscreen: player.isCssfullScreen });
+		request(!player.isCssfullScreen);
+		return false;
+	};
+	const onEscape = () => {
+		if (player.fullscreen) {
+			keyboard?.emitUserAction?.("keyup", "switch_fullscreen", {
+				prop: "fullscreen",
+				from: true,
+				to: false
+			});
+			player.exitFullscreen();
+		}
+		if (player.isCssfullScreen) {
+			keyboard?.emitUserAction?.("keyup", "switch_css_fullscreen", {
+				prop: "cssfullscreen",
+				from: true,
+				to: false
+			});
+			request(false);
+		}
+	};
+	const setAvailable = (next) => {
+		if (destroyed) return;
+		available = next;
+		if (managed && cssPlugin?.root) cssPlugin.root.style.display = next ? originalDisplay : "none";
+	};
+	if (managed) {
+		if (cssPlugin && !cssPlugin.config?.disable) player.usePluginHooks("cssFullscreen", "cssFullscreen_change", onButton);
+		if (escapeKey) escapeKey.action = onEscape;
+		setAvailable(false);
+	}
+	return {
+		/** 显式协商成功后开放按钮；撤销能力不伪造实际状态。 */
+		setAvailable,
+		/** 应用已确认状态；重复确认不重复操作 xgplayer。 */
+		setActive(active) {
+			if (destroyed || player.isCssfullScreen === active) return;
+			if (active) player.getCssFullscreen();
+			else player.exitCssFullscreen();
+		},
+		/** 移除本适配器的入口与监听，恢复插件原行为。 */
+		destroy() {
+			if (destroyed) return;
+			destroyed = true;
+			player.off("cssFullscreen_change", onChange);
+			if (managed) {
+				if (cssPlugin && !cssPlugin.config?.disable) player.removePluginHooks("cssFullscreen", "cssFullscreen_change", onButton);
+				if (escapeKey && escapeKey.action === onEscape && originalEscape !== void 0) escapeKey.action = originalEscape;
+				if (cssPlugin?.root) cssPlugin.root.style.display = originalDisplay;
+			}
+		}
+	};
+}
+//#endregion
+//#region src/recovery-controller.ts
+const BACKOFF = [
+	1e3,
+	2e3,
+	4e3
+];
+/**
+* 实例级内部调度器。执行器须在 abort 时同步停止旧动作；Promise 完成仅代表命令结束。
+* 强播放证据由调用方判定后交 recovered；生产装配层负责映射公开事件。
+*/
+var RecoveryController = class {
+	execute;
+	onTransition;
+	active = null;
+	sequence = 0;
+	disposed = false;
+	suspended = false;
+	timer = null;
+	deadlineTimer = null;
+	events = [];
+	publishing = false;
+	actionDepth = 0;
+	constructor(execute, onTransition) {
+		this.execute = execute;
+		this.onTransition = onTransition;
+	}
+	/** 供装配层识别同步重入后的新 episode，不是公开播放器查询。 */
+	get activeEpisodeId() {
+		return this.active?.id ?? null;
+	}
+	/** 在途请求合并；切换会话前由调用方显式 cancel。 */
+	request(sessionId, input = {}) {
+		if (this.disposed) return null;
+		if (this.active) {
+			if (!this.active.finishing && this.active.sessionId === sessionId) {
+				if (input.strategy) this.active.strategy = input.strategy;
+				if (input.reason) this.active.reason = input.reason;
+			}
+			return this.active.id;
+		}
+		const episode = {
+			id: ++this.sequence,
+			sessionId,
+			deadline: performance.now() + 6e4,
+			startedAt: performance.now(),
+			strategy: input.strategy ?? "reconnect",
+			trigger: input.trigger ?? "error",
+			reason: input.reason,
+			attempt: 0,
+			token: null,
+			abort: null,
+			finishing: false
+		};
+		this.active = episode;
+		this.deadlineTimer = setTimeout(() => this.finish(episode, "failed"), 6e4);
+		this.publish(episode, "detected");
+		this.schedule(episode);
+		return episode.id;
+	}
+	/** 只接受当前动作的强证据，过期证据不得覆盖预算终态。 */
+	recovered(token) {
+		const episode = this.active;
+		if (!episode || episode.token !== token) return;
+		this.finish(episode, performance.now() >= episode.deadline ? "failed" : "recovered");
+	}
+	/** 第一动作尚未发出时原播放自行恢复，不制造一次成功动作。 */
+	naturalRecovered() {
+		if (this.active?.attempt === 0) this.finish(this.active, "cancelled", "natural_recovery");
+	}
+	/** 换源、用户暂停等取消原因由上层记录；取消不等同于预算耗尽。 */
+	cancel(outcome = "superseded") {
+		if (this.active) this.finish(this.active, "cancelled", outcome);
+	}
+	/** 后台暂停发动作，保留总截止时间和已消耗预算。 */
+	setSuspended(suspended) {
+		if (this.disposed || this.suspended === suspended) return;
+		this.suspended = suspended;
+		const episode = this.active;
+		if (!episode) return;
+		if (suspended) {
+			if (this.timer !== null) clearTimeout(this.timer);
+			this.timer = null;
+			episode.token = null;
+			const abort = episode.abort;
+			episode.abort = null;
+			abort?.abort();
+		} else this.schedule(episode);
+	}
+	/** 销毁后不再接受新恢复请求。 */
+	destroy() {
+		this.disposed = true;
+		this.cancel("destroyed");
+	}
+	schedule(episode) {
+		if (this.active !== episode) return;
+		const delay = BACKOFF[episode.attempt];
+		const remaining = episode.deadline - performance.now();
+		if (delay === void 0 || remaining <= 0) {
+			this.finish(episode, "failed");
+			return;
+		}
+		if (!this.suspended) this.timer = setTimeout(() => this.begin(episode), Math.min(delay, remaining));
+		this.publish(episode, "backoff");
+	}
+	begin(episode) {
+		if (this.active !== episode) return;
+		this.timer = null;
+		const remaining = episode.deadline - performance.now();
+		if (remaining <= 0) {
+			this.finish(episode, "failed");
+			return;
+		}
+		const token = Object.freeze({
+			episode: episode.id,
+			sessionId: episode.sessionId,
+			attempt: ++episode.attempt,
+			strategy: episode.strategy
+		});
+		const abort = new AbortController();
+		episode.issuedStrategy = token.strategy;
+		episode.token = token;
+		episode.abort = abort;
+		this.timer = setTimeout(() => this.failAttempt(episode, token), Math.min(15e3, remaining));
+		this.actionDepth += 1;
+		this.publish(episode, "attempting");
+		try {
+			const result = this.execute(token, abort.signal);
+			if (this.active === episode && episode.token === token) this.publish(episode, "validating");
+			Promise.resolve(result).catch(() => this.failAttempt(episode, token));
+		} catch {
+			this.failAttempt(episode, token);
+		} finally {
+			this.actionDepth -= 1;
+			this.flushEvents();
+		}
+	}
+	failAttempt(episode, token) {
+		if (this.active !== episode || episode.token !== token) return;
+		if (this.timer !== null) clearTimeout(this.timer);
+		this.timer = null;
+		episode.token = null;
+		const abort = episode.abort;
+		episode.abort = null;
+		abort?.abort();
+		this.schedule(episode);
+	}
+	finish(episode, phase, outcome) {
+		if (this.active !== episode || episode.finishing) return;
+		episode.finishing = true;
+		if (this.timer !== null) clearTimeout(this.timer);
+		if (this.deadlineTimer !== null) clearTimeout(this.deadlineTimer);
+		this.timer = null;
+		this.deadlineTimer = null;
+		episode.token = null;
+		if (phase !== "recovered") episode.abort?.abort();
+		this.active = null;
+		this.publish(episode, phase, outcome ?? (phase === "failed" ? performance.now() >= episode.deadline ? "timeout" : "attempts_exhausted" : void 0));
+	}
+	publish(episode, phase, outcome) {
+		this.events.push(Object.freeze({
+			episode: episode.id,
+			sessionId: episode.sessionId,
+			attempt: episode.attempt,
+			phase,
+			elapsedMs: Math.max(0, performance.now() - episode.startedAt),
+			maxAttempts: BACKOFF.length,
+			strategy: phase === "detected" || phase === "backoff" ? episode.strategy : episode.issuedStrategy ?? episode.strategy,
+			trigger: episode.trigger,
+			...episode.reason ? { reason: episode.reason } : {},
+			...outcome ? { outcome } : {}
+		}));
+		this.flushEvents();
+	}
+	flushEvents() {
+		if (this.publishing || this.actionDepth > 0) return;
+		this.publishing = true;
+		try {
+			while (this.events.length > 0) {
+				const event = this.events.shift();
+				if (event) try {
+					this.onTransition(event);
+				} catch {}
+			}
+		} finally {
+			this.publishing = false;
+		}
+	}
+};
+//#endregion
+//#region src/playback-recovery.ts
+/** 播放意图、故障终态与调度预算之间的实例级协调；尚未公开导出。 */
+var PlaybackRecovery = class {
+	sessionId;
+	emit;
+	display;
+	controller;
+	error = null;
+	desiredPlayback = false;
+	exhausted = false;
+	disposed = false;
+	revision = 0;
+	constructor(sessionId, execute, emit, display) {
+		this.sessionId = sessionId;
+		this.emit = emit;
+		this.display = display;
+		this.controller = new RecoveryController(execute, (event) => this.transition(event));
+	}
+	/** 执行器完成异步换源后复查最新意图，避免恢复用户已暂停的播放。 */
+	get playingIntent() {
+		return this.desiredPlayback && !this.disposed;
+	}
+	/** 已归一诊断进入此处；终态后的重复诊断不重新分配预算。 */
+	fault(error, sessionId = this.sessionId) {
+		if (this.disposed || sessionId !== this.sessionId) return;
+		const revision = ++this.revision;
+		this.error = error;
+		if (!error.retryable) {
+			this.controller.cancel();
+			if (this.disposed || revision !== this.revision) return;
+			this.display({
+				recovering: false,
+				failed: true,
+				action: this.action
+			});
+		} else if (this.desiredPlayback && !this.exhausted) this.request("error");
+		else this.display({
+			recovering: false,
+			failed: true,
+			action: this.action
+		});
+	}
+	/** 仅接显式播放/暂停意图；内核 stop 产生的 pause 不调用此方法。 */
+	setPlayingIntent(playing) {
+		if (this.disposed) return;
+		this.revision += 1;
+		this.desiredPlayback = playing;
+		if (!playing) {
+			this.exhausted = false;
+			this.controller.cancel("user_paused");
+		} else if (this.error?.retryable && !this.exhausted) this.request("manual");
+	}
+	/** 正常播放结束后不再接受自动恢复意图；不伪报用户暂停或恢复成功。 */
+	endPlayback() {
+		if (this.disposed) return;
+		const revision = ++this.revision;
+		this.desiredPlayback = false;
+		this.exhausted = false;
+		this.error = null;
+		this.controller.cancel("superseded");
+		if (this.disposed || revision !== this.revision) return;
+		this.display({
+			recovering: false,
+			failed: false,
+			action: "none"
+		});
+	}
+	/** 接受/合并手动重试；播放成功仍以当前动作的强证据为准。 */
+	async retry() {
+		if (this.disposed) throw new SentinelError((0, _video_lab_protocol.makePlayerError)("E_PLAYER_DESTROYED", _video_lab_protocol.PLAYER_DESTROYED_MESSAGE));
+		if (this.error && !this.error.retryable) throw new SentinelError((0, _video_lab_protocol.makePlayerError)("E_METHOD_NOT_SUPPORTED", "当前源不能直接重试，请按动作提示处理"));
+		this.desiredPlayback = true;
+		this.revision += 1;
+		this.exhausted = false;
+		this.request("manual");
+	}
+	/** 接收测量或可见性产生的恢复意图，不要求捏造 raw error。 */
+	requestRecovery(trigger) {
+		if (this.disposed || !this.desiredPlayback || this.exhausted) return;
+		if (this.error && !this.error.retryable) return;
+		this.request(trigger);
+	}
+	/** 执行器提交当前动作的播放证据。 */
+	recovered(token) {
+		this.controller.recovered(token);
+	}
+	/** 原播放的强证据：无动作时结束等待，有在途动作时交其专属凭据判定。 */
+	naturalRecovered() {
+		if (this.disposed) return;
+		if (this.controller.activeEpisodeId !== null) {
+			this.controller.naturalRecovered();
+			return;
+		}
+		this.error = null;
+		this.exhausted = false;
+		this.display({
+			recovering: false,
+			failed: false,
+			action: "none"
+		});
+	}
+	/** 页面隐藏只暂停动作，不暂停总预算。 */
+	setSuspended(hidden) {
+		this.controller.setSuspended(hidden);
+	}
+	/** 换源先使新会话生效，再取消旧动作，防止旧回调覆盖新展示。 */
+	setSession(sessionId) {
+		if (this.disposed) return;
+		this.revision += 1;
+		this.sessionId = sessionId;
+		this.error = null;
+		this.exhausted = false;
+		this.controller.cancel("source_changed");
+	}
+	/** 销毁后所有重试命令明确拒绝。 */
+	destroy() {
+		if (this.disposed) return;
+		this.disposed = true;
+		this.controller.destroy();
+	}
+	get action() {
+		if (!this.error || this.error.retryable) return "retry";
+		if (this.error.category === "autoplay") return "play";
+		return this.error.category === "env" ? "none" : "replace-source";
+	}
+	request(trigger) {
+		this.controller.request(this.sessionId, {
+			trigger,
+			strategy: trigger === "visibility" ? "visibility_reload" : this.error?.category === "media" ? "media_recovery" : "reconnect",
+			...this.error ? { reason: this.error.code } : {}
+		});
+	}
+	transition(event) {
+		const { episode, ...fact } = event;
+		const revision = this.revision;
+		if (event.sessionId === this.sessionId && event.phase === "failed") this.exhausted = true;
+		if (event.sessionId === this.sessionId && (event.phase === "recovered" || event.outcome === "natural_recovery")) {
+			this.error = null;
+			this.exhausted = false;
+		}
+		this.emit({
+			event: "recovery",
+			payload: _video_lab_protocol.RecoveryPayloadSchema.parse({
+				...fact,
+				recoveryId: episode,
+				...event.phase === "recovered" ? { validatedBy: "playing_position_advance" } : {}
+			})
+		});
+		if (this.disposed || event.sessionId !== this.sessionId || revision !== this.revision) return;
+		const current = this.controller.activeEpisodeId;
+		if (current !== null && current !== episode) return;
+		const recovering = [
+			"detected",
+			"backoff",
+			"attempting",
+			"validating"
+		].includes(event.phase);
+		this.display({
+			recovering,
+			failed: !recovering && (this.exhausted || this.error !== null),
+			action: recovering || !this.exhausted && !this.error ? "none" : this.action
+		});
+	}
+};
+//#endregion
 //#region src/plugins/autoplay-guard.ts
 /**
 * AutoplayGuard(P0)· 检测浏览器 autoplay 拒绝并告知业务
@@ -564,7 +1204,7 @@ function detectCompat(ua) {
 	};
 	return { incompatible: false };
 }
-const DEFAULT_CONFIG$8 = { enabled: true };
+const DEFAULT_CONFIG$6 = { enabled: true };
 /**
 * CompatPlugin(P1)· 浏览器兼容性检测
 *
@@ -584,11 +1224,11 @@ var CompatPlugin = class extends xgplayer.BasePlugin {
 		return "compat";
 	}
 	static get defaultConfig() {
-		return { ...DEFAULT_CONFIG$8 };
+		return { ...DEFAULT_CONFIG$6 };
 	}
 	get compatConfig() {
 		return {
-			...DEFAULT_CONFIG$8,
+			...DEFAULT_CONFIG$6,
 			...this.config
 		};
 	}
@@ -606,121 +1246,8 @@ var CompatPlugin = class extends xgplayer.BasePlugin {
 	}
 };
 //#endregion
-//#region src/plugins/error-recovery.ts
-const DEFAULT_CONFIG$7 = {
-	enabled: true,
-	maxRecoveries: 3
-};
-/** 原生 decode 卡死时向前跳过的秒数,跳过坏区间 */
-const SKIP_SECONDS = .5;
-/** 本插件专管的媒体错误码:坏 ts(#17)/ MP4 abort(#18) */
-const RECOVERABLE_CODES = /* @__PURE__ */ new Set(["E_MEDIA_DECODE", "E_MEDIA_ABORTED"]);
-/**
-* ErrorRecoveryPlugin(P2)· 媒体错误自愈
-*
-* 解决的 pitfall:**#17**(点播 HLS 中间某个 ts 片段坏了,整段播放中断)、
-* **#18**(MP4 中途网络 abort 无恢复)。
-*
-* 与 ReconnectPlugin 的分工(都听 `Events.ERROR`,按错误 **category** 划清):
-* - `network` / `manifest` 类(断网、拉流失败)→ ReconnectPlugin 全量 `reload()` 重连。
-* - `media` 类(解码 / abort)→ **本插件**做**局部**自愈,不全量 reload——坏 ts 全量 reload
-*   会再次撞上同一个坏片段,得跳过而不是重来。
-*   Reconnect 已加守卫跳过 media 类,避免两者对同一错误重复动作(见 plugins/reconnect.ts)。
-*
-* 自愈手段:
-* - `E_MEDIA_DECODE` 且是 HLS(有 hls.js 实例)→ `hls.recoverMediaError()`(hls.js 官方媒体
-*   错误恢复,重建 buffer / 跳过坏片段)。
-* - `E_MEDIA_ABORTED`(原生 MP4 fetch 被中断)→ `play()` 续播,恢复被中断的拉取。
-* - `E_MEDIA_DECODE` 且无 hls(原生解码卡死)→ 小步 `seek` 前跳,跳过坏区间再 `play()`。
-*
-* `maxRecoveries` 次用尽后不再自愈,交给正常 error 流程(消费方展示错误 UI)。恢复成功
-* (`playing`)清零。恢复生命周期由 create-player 注入并统一出为 `recovery` 事件。
-*
-* @example
-* new Player({ el, plugins: [ErrorRecoveryPlugin], errorRecovery: { maxRecoveries: 3 } })
-*/
-var ErrorRecoveryPlugin = class extends xgplayer.BasePlugin {
-	static get pluginName() {
-		return "errorRecovery";
-	}
-	static get defaultConfig() {
-		return { ...DEFAULT_CONFIG$7 };
-	}
-	/** 本段已自愈次数,恢复成功清零 */
-	recoveries = 0;
-	get recoveryConfig() {
-		return {
-			...DEFAULT_CONFIG$7,
-			...this.config
-		};
-	}
-	get surface() {
-		return this.player;
-	}
-	afterCreate() {
-		if (!this.recoveryConfig.enabled) return;
-		this.on(xgplayer.Events.ERROR, this.handleError);
-		this.on(xgplayer.Events.PLAYING, this.handleResumed);
-	}
-	/** 用箭头函数保持 this,否则 off 匹配不上(见 CLAUDE.md 红线) */
-	handleError = (err) => {
-		const { code, category } = mapXgplayerError(err);
-		if (category !== "media") return;
-		if (!RECOVERABLE_CODES.has(code)) return;
-		if (this.recoveries >= this.recoveryConfig.maxRecoveries) {
-			this.recoveryConfig.onRecoveryFailed?.({ outcome: "attempts_exhausted" });
-			return;
-		}
-		this.recoveryConfig.onRecoveryDetected?.({
-			trigger: "error",
-			maxAttempts: this.recoveryConfig.maxRecoveries,
-			reason: code
-		});
-		this.recoveries += 1;
-		this.recoveryConfig.onRecoveryAttempting?.({
-			attempt: this.recoveries,
-			maxAttempts: this.recoveryConfig.maxRecoveries,
-			reason: code
-		});
-		this.recoveryConfig.onRecoveryValidating?.();
-		this.recover(code);
-	};
-	/** 恢复后重新进入播放 → 本段自愈成功,计数清零 */
-	handleResumed = () => {
-		this.recoveries = 0;
-	};
-	recover(code) {
-		const player = this.surface;
-		const hls = player.getPlugin?.("HlsJsPlugin")?.hls;
-		if (hls?.recoverMediaError) {
-			hls.recoverMediaError();
-			return;
-		}
-		if (code === "E_MEDIA_ABORTED") {
-			this.resumePlay();
-			return;
-		}
-		const t = numberOr$3(player.currentTime, 0);
-		player.seek?.(t + SKIP_SECONDS);
-		this.resumePlay();
-	}
-	resumePlay() {
-		const played = this.surface.play?.();
-		if (played && typeof played.catch === "function") played.catch(() => {});
-	}
-	destroy() {
-		this.off(xgplayer.Events.ERROR, this.handleError);
-		this.off(xgplayer.Events.PLAYING, this.handleResumed);
-		super.destroy?.();
-	}
-};
-/** 有限数值否则回退 */
-function numberOr$3(value, fallback) {
-	return typeof value === "number" && Number.isFinite(value) ? value : fallback;
-}
-//#endregion
 //#region src/plugins/fullscreen-guard.ts
-const DEFAULT_CONFIG$6 = {
+const DEFAULT_CONFIG$5 = {
 	enabled: true,
 	isIOSWeChat: false
 };
@@ -747,13 +1274,13 @@ var FullscreenGuardPlugin = class extends xgplayer.BasePlugin {
 		return "fullscreenGuard";
 	}
 	static get defaultConfig() {
-		return { ...DEFAULT_CONFIG$6 };
+		return { ...DEFAULT_CONFIG$5 };
 	}
 	patchedVideo = null;
 	originalEnter;
 	get guardConfig() {
 		return {
-			...DEFAULT_CONFIG$6,
+			...DEFAULT_CONFIG$5,
 			...this.config
 		};
 	}
@@ -775,7 +1302,7 @@ var FullscreenGuardPlugin = class extends xgplayer.BasePlugin {
 };
 //#endregion
 //#region src/plugins/health-monitor.ts
-const DEFAULT_CONFIG$5 = {
+const DEFAULT_CONFIG$4 = {
 	enabled: true,
 	stallThresholdMs: 2e3,
 	pollIntervalMs: 1e3
@@ -826,7 +1353,7 @@ var HealthMonitorPlugin = class extends xgplayer.BasePlugin {
 		return "healthMonitor";
 	}
 	static get defaultConfig() {
-		return { ...DEFAULT_CONFIG$5 };
+		return { ...DEFAULT_CONFIG$4 };
 	}
 	stalling = false;
 	stallStartAt = 0;
@@ -857,7 +1384,7 @@ var HealthMonitorPlugin = class extends xgplayer.BasePlugin {
 	pollTimer = null;
 	get monitorConfig() {
 		return {
-			...DEFAULT_CONFIG$5,
+			...DEFAULT_CONFIG$4,
 			...this.config
 		};
 	}
@@ -1152,7 +1679,7 @@ var MediaSessionPlugin = class extends xgplayer.BasePlugin {
 };
 //#endregion
 //#region src/plugins/playable-state.ts
-const DEFAULT_CONFIG$4 = {
+const DEFAULT_CONFIG$3 = {
 	enabled: true,
 	bufferingDebounceMs: 300,
 	droppedRateThreshold: 15,
@@ -1253,7 +1780,7 @@ var PlayableStatePlugin = class extends xgplayer.BasePlugin {
 		return "playableState";
 	}
 	static get defaultConfig() {
-		return { ...DEFAULT_CONFIG$4 };
+		return { ...DEFAULT_CONFIG$3 };
 	}
 	errored = false;
 	autoplayBlocked = false;
@@ -1262,6 +1789,7 @@ var PlayableStatePlugin = class extends xgplayer.BasePlugin {
 	buffering = false;
 	initialized = false;
 	degraded = false;
+	recovery = null;
 	bufferingTimer = null;
 	pollTimer = null;
 	/** 上次采样看到的累计帧数 —— 用来算**窗口内**掉帧率,见 sampleFrames */
@@ -1270,9 +1798,10 @@ var PlayableStatePlugin = class extends xgplayer.BasePlugin {
 	overThresholdRuns = 0;
 	/** 上次回调出去的结论。只在变化时回调,靠它去重 */
 	lastReason = null;
+	lastAction;
 	get stateConfig() {
 		return {
-			...DEFAULT_CONFIG$4,
+			...DEFAULT_CONFIG$3,
 			...this.config
 		};
 	}
@@ -1312,6 +1841,13 @@ var PlayableStatePlugin = class extends xgplayer.BasePlugin {
 		this.errored = value;
 		this.publish();
 	}
+	/** 原子更新恢复与终态；强证据由恢复协调器判定。 */
+	setRecovery(state) {
+		this.recovery = { ...state };
+		this.errored = state.failed;
+		this.reconnecting = state.recovering;
+		this.publish();
+	}
 	/** 用箭头函数保持 this,否则 off 匹配不上(见 CLAUDE.md 红线) */
 	handleLoadedData = () => {
 		this.initialized = true;
@@ -1371,6 +1907,8 @@ var PlayableStatePlugin = class extends xgplayer.BasePlugin {
 	};
 	/** 当前命中的最严重的那一支 */
 	resolve() {
+		if (this.recovery?.recovering) return "reconnecting";
+		if (this.recovery?.failed) return "error";
 		const hit = {
 			error: this.errored,
 			frame_disconnected: false,
@@ -1386,11 +1924,14 @@ var PlayableStatePlugin = class extends xgplayer.BasePlugin {
 	}
 	publish() {
 		const reason = this.resolve();
-		if (reason === this.lastReason) return;
+		const action = reason === "autoplay_blocked" ? "play" : this.recovery?.action;
+		if (reason === this.lastReason && action === this.lastAction) return;
 		this.lastReason = reason;
+		this.lastAction = action;
 		this.stateConfig.onPlayableChange?.({
 			reason,
-			...REASON_TABLE[reason]
+			...REASON_TABLE[reason],
+			...action !== void 0 ? { action } : {}
 		});
 	}
 	clearBufferingTimer() {
@@ -1416,236 +1957,6 @@ function numberOr$1(value, fallback) {
 	return typeof value === "number" && Number.isFinite(value) ? value : fallback;
 }
 //#endregion
-//#region src/plugins/reload-stream.ts
-/**
-* 让播放器重新拉一遍当前的流。
-*
-* ⚠️ **返回的 promise 要等** —— 如果调用方在重新拉流之后还要做别的事(典型是补一次 `play()`)。
-*
-* `reload()` 是同步拆重建,紧跟着 `play()` 能落到新的媒体上;
-* **`switchURL` 是异步的**,紧跟着调 `play()` 会被新的 load 打断
-*(chromium 报 `AbortError: The play() request was interrupted by a new load request`),
-* 而打断之后**没有人会再播一次**,播放器就停在 paused 上。
-*
-* 这不是推演:VisibilityPlugin 从 `reload()` 换到 `reloadStream()` 的第一版就是同步紧跟着
-* `play()`,单跑全绿,**跑满 worker 的全量里三次挂两次** —— 竞态按负载翻脸(#359)。
-*
-* @returns 重新拉流这件事**做完**之后 resolve;**永不 reject**(失败交给调用方的
-*          error 事件 / 看门狗,那才是判定恢复与否的地方)
-*/
-function reloadStream(player) {
-	const url = player?.config?.url;
-	if (player?.switchURL && typeof url === "string" && url && !url.startsWith("blob:")) return player.switchURL(url).then(() => "switchURL", () => "switchURL");
-	if (player?.reload) {
-		player.reload();
-		return Promise.resolve("reload");
-	}
-	return Promise.resolve("none");
-}
-//#endregion
-//#region src/plugins/reconnect.ts
-const DEFAULT_CONFIG$3 = {
-	enabled: true,
-	maxRetries: 3,
-	baseDelayMs: 1e3,
-	maxDelayMs: 15e3,
-	resumeTimeoutMs: 15e3
-};
-/**
-* ReconnectPlugin(P0)· 断网 / 拉流失败自动重连
-*
-* 解决的 pitfall:**#1**(断网播放中断,无自动重连)、**#2**(换源失败无重试)。
-*
-* 状态机(ARCHITECTURE § 10.3):`idle → retrying → exhausted`,**防止无限重连**。
-* - 播放中遇到**可重试**的错误(网络类,`mapXgplayerError().retryable === true`)→
-*   进入 retrying,按指数退避 reload,每次发 `reconnectstart`。
-* - reload 后恢复播放(`playing`/`canplay`)→ 发 `reconnectsuccess`,回 idle,计数清零。
-* - reload 后 `resumeTimeoutMs` 内既没恢复也没报错(静默挂住)→ 判本轮失败,继续往前推。
-*   断网时的 MSE 路径就是这个形态(hls.js 的网络错误被吞),没有这一条状态机会永远停在 retrying。
-* - 重试用满 `maxRetries` 仍失败 → 进入 exhausted,发 `reconnectfailed`,停止自动重连。
-* - 手动 `reconnect({ resetCounter })` 可从 exhausted 重新拿满 maxRetries 次机会。
-*
-* 不可重试的错误(如 `E_MEDIA_NOT_SUPPORTED`)不触发重连,交给正常 error 流程。
-*
-* @example
-* new Player({
-*   el, plugins: [ReconnectPlugin],
-*   reconnect: { maxRetries: 3, onReconnectStart, onReconnectSuccess, onReconnectFailed },
-* })
-*/
-var ReconnectPlugin = class extends xgplayer.BasePlugin {
-	static get pluginName() {
-		return "reconnect";
-	}
-	static get defaultConfig() {
-		return { ...DEFAULT_CONFIG$3 };
-	}
-	state = "idle";
-	/** 当前这轮已经发起的重试次数(1..maxRetries)。回 idle / 成功时清零 */
-	attempt = 0;
-	reloadTimer = null;
-	/** reload 发出后的看门狗:恢复信号迟迟不来就把这一轮判失败(见 resumeTimeoutMs) */
-	resumeTimer = null;
-	lastReason;
-	get reconnectConfig() {
-		return {
-			...DEFAULT_CONFIG$3,
-			...this.config
-		};
-	}
-	afterCreate() {
-		if (!this.reconnectConfig.enabled) return;
-		this.on(xgplayer.Events.ERROR, this.handleError);
-		this.on(xgplayer.Events.PLAYING, this.handleResumed);
-		this.on(xgplayer.Events.CANPLAY, this.handleResumed);
-	}
-	/** 可重试错误 → 驱动状态机往前走一步 */
-	handleError = (err) => {
-		const mapped = mapXgplayerError(err);
-		if (!mapped.retryable) return;
-		if (mapped.category === "media") return;
-		if (this.state === "exhausted") return;
-		this.lastReason = mapped.code;
-		if (this.state === "idle") this.reconnectConfig.onRecoveryDetected?.({
-			trigger: "error",
-			maxAttempts: this.reconnectConfig.maxRetries,
-			reason: mapped.code
-		});
-		this.advance(mapped.code);
-	};
-	/** reload 后恢复播放 → 本轮重连成功 */
-	handleResumed = () => {
-		if (this.state !== "retrying") return;
-		const attempts = this.attempt;
-		this.clearReloadTimer();
-		this.clearResumeTimer();
-		this.state = "idle";
-		this.attempt = 0;
-		this.reconnectConfig.onReconnectSuccess?.({ attempts });
-	};
-	/**
-	* 状态机前进一步:要么再发起一次退避 reload,要么用尽 → exhausted。
-	* @param reason 触发本次的错误码;手动重连时为 undefined
-	*/
-	advance(reason, terminalOutcome = "attempts_exhausted") {
-		const { maxRetries, baseDelayMs, maxDelayMs } = this.reconnectConfig;
-		if (this.attempt >= maxRetries) {
-			this.clearReloadTimer();
-			this.clearResumeTimer();
-			this.state = "exhausted";
-			this.reconnectConfig.onRecoveryFailed?.({ outcome: terminalOutcome });
-			this.reconnectConfig.onReconnectFailed?.({
-				attempts: this.attempt,
-				reason
-			});
-			return;
-		}
-		this.attempt += 1;
-		this.state = "retrying";
-		const nextDelayMs = Math.min(baseDelayMs * 2 ** (this.attempt - 1), maxDelayMs);
-		this.reconnectConfig.onReconnectStart?.({
-			attempt: this.attempt,
-			maxAttempts: maxRetries,
-			reason,
-			nextDelayMs
-		});
-		this.reconnectConfig.onRecoveryAttempting?.({
-			attempt: this.attempt,
-			maxAttempts: maxRetries,
-			reason
-		});
-		this.clearReloadTimer();
-		this.clearResumeTimer();
-		this.reloadTimer = setTimeout(() => {
-			this.reloadTimer = null;
-			this.reload();
-			this.reconnectConfig.onRecoveryValidating?.({ timeoutMs: this.reconnectConfig.resumeTimeoutMs });
-			this.resumeTimer = setTimeout(() => {
-				this.resumeTimer = null;
-				if (this.state !== "retrying") return;
-				this.advance(this.lastReason, "timeout");
-			}, this.reconnectConfig.resumeTimeoutMs);
-		}, nextDelayMs);
-	}
-	/**
-	* 触发 xgplayer 重新拉流。恢复与否由后续 playing / error 事件决定。
-	*
-	* 走 `switchURL` 还是 `reload` 由 {@link reloadStream} 决定 —— #192 的那条经验**抽出去了**,
-	* 因为它被漏掉过一次:`VisibilityPlugin` 接着用 `reload()` 用了几个月(#359)。
-	*/
-	reload() {
-		reloadStream(this.player);
-	}
-	/**
-	* 手动重连(命令 `reconnect`)。create-player 的 handle.reconnect 调它。
-	* @param resetCounter true = 计数清零,重新拿满 maxRetries 次机会(用户点"重试"的语义)
-	*/
-	manualReconnect(resetCounter = false) {
-		if (!this.reconnectConfig.enabled) return;
-		if (resetCounter) {
-			this.attempt = 0;
-			this.state = "idle";
-		} else if (this.state === "exhausted") return;
-		if (this.state === "idle") this.reconnectConfig.onRecoveryDetected?.({
-			trigger: "manual",
-			maxAttempts: this.reconnectConfig.maxRetries
-		});
-		this.advance(void 0);
-	}
-	/**
-	* 换源复位:把状态机整个归零,**但不发起任何重连**。由 `create-player` 的 `load()` 调。
-	*
-	* ─── 为什么必须有这个方法 ─────────────────────────
-	*
-	* `load()` 已经在 ADR-074 的名义下把换源定义成「新会话」,并复位了 `sessionId` /
-	* `qualityLevel` / `recoveryEvidence` / prematureVodEnd / MediaSession ——
-	* **重连计数曾经是这份清单里唯一漏掉的一项**。后果是永久且完全静默的:
-	*
-	* 源 A 重试用尽 → `state = 'exhausted'` → 消费方按契约语义(`recoverable: false`)
-	* 换一个可用地址 → 新源播得好好的,但 `handleResumed` 的第一行是
-	* `if (this.state !== 'retrying') return`,**`exhausted` 走不到** → 状态机原地不动 →
-	* 此后源 B 再断流,`handleError` 在 `exhausted` 分支直接 return:
-	* **不重连、不发 `reconnectstart`、不发 `reconnectfailed`**。
-	*
-	* ─── 为什么不复用 `manualReconnect(true)` ─────────
-	*
-	* 那个方法复位完会**立刻 `advance()` 发起一次重连** —— 那是「用户点了重试」的语义。
-	* 换源时新地址已经由 `switchURL` 送出去了,再重连一次是多余的一次拉流。
-	*
-	* ─── 为什么要清掉两个定时器 ───────────────────────
-	*
-	* 换源那一刻可能正有一轮退避 / 看门狗在途。它们属于**上一个源**的那次故障,
-	* 留着会在新源上凭空推进一次状态机(甚至直接判失败)。
-	*/
-	resetForNewSource() {
-		this.clearReloadTimer();
-		this.clearResumeTimer();
-		this.state = "idle";
-		this.attempt = 0;
-		this.lastReason = void 0;
-	}
-	clearReloadTimer() {
-		if (this.reloadTimer !== null) {
-			clearTimeout(this.reloadTimer);
-			this.reloadTimer = null;
-		}
-	}
-	clearResumeTimer() {
-		if (this.resumeTimer !== null) {
-			clearTimeout(this.resumeTimer);
-			this.resumeTimer = null;
-		}
-	}
-	destroy() {
-		this.clearReloadTimer();
-		this.clearResumeTimer();
-		this.off(xgplayer.Events.ERROR, this.handleError);
-		this.off(xgplayer.Events.PLAYING, this.handleResumed);
-		this.off(xgplayer.Events.CANPLAY, this.handleResumed);
-		super.destroy?.();
-	}
-};
-//#endregion
 //#region src/plugins/safe-destroy.ts
 const DEFAULT_CONFIG$2 = { restoreRootStyle: true };
 /**
@@ -1797,6 +2108,39 @@ function routeSource(source, env) {
 	throwPlayerError("E_MEDIA_NOT_SUPPORTED", "候选源为空,或类型都不受支持");
 }
 //#endregion
+//#region src/plugins/reload-stream.ts
+/**
+* 让播放器重新拉一遍当前的流。
+*
+* ⚠️ **返回的 promise 要等** —— 如果调用方在重新拉流之后还要做别的事(典型是补一次 `play()`)。
+*
+* `reload()` 是同步拆重建,紧跟着 `play()` 能落到新的媒体上;
+* **`switchURL` 是异步的**,紧跟着调 `play()` 会被新的 load 打断
+*(chromium 报 `AbortError: The play() request was interrupted by a new load request`),
+* 而打断之后**没有人会再播一次**,播放器就停在 paused 上。
+*
+* 这不是推演:VisibilityPlugin 从 `reload()` 换到 `reloadStream()` 的第一版就是同步紧跟着
+* `play()`,单跑全绿,**跑满 worker 的全量里三次挂两次** —— 竞态按负载翻脸(#359)。
+*
+* @returns 重新拉流这件事**做完**之后 resolve;**永不 reject**(失败交给调用方的
+*          error 事件 / 看门狗,那才是判定恢复与否的地方)
+*/
+function reloadStream(player) {
+	const url = player?.config?.url;
+	if (player?.switchURL && typeof url === "string" && url && !url.startsWith("blob:")) try {
+		return player.switchURL(url).then(() => "switchURL", () => "switchURL");
+	} catch {
+		return Promise.resolve("switchURL");
+	}
+	if (player?.reload) {
+		try {
+			player.reload();
+		} catch {}
+		return Promise.resolve("reload");
+	}
+	return Promise.resolve("none");
+}
+//#endregion
 //#region src/plugins/visibility.ts
 const DEFAULT_CONFIG$1 = {
 	enabled: true,
@@ -1892,6 +2236,10 @@ var VisibilityPlugin = class extends xgplayer.BasePlugin {
 	/** 探测:currentTime 没推进 或 仍 paused → 判定被系统冻死 → 重新拉流自愈 */
 	recoverIfStalled() {
 		if (numberOr(this.surface.currentTime, 0) > this.lastTime && this.surface.paused === false) return;
+		if (this.visibilityConfig.requestRecovery) {
+			this.visibilityConfig.requestRecovery();
+			return;
+		}
 		this.visibilityConfig.onRecoveryDetected?.({
 			trigger: "visibility",
 			maxAttempts: 1
@@ -2066,111 +2414,86 @@ var ZIndexGuardPlugin = class extends xgplayer.BasePlugin {
 	}
 };
 //#endregion
-//#region src/recovery-evidence.ts
+//#region src/recovery-playback.ts
 /**
-* 将各恢复策略的意图变成同一条、可验证的遥测生命周期(ADR-079)。
-*
-* 它不改变插件的重试或播放策略；只在 `playing` 后又观测到位置推进时记录恢复成功。
+* 观察一次恢复动作的强播放证据。仅 playing 后正常位置推进算成功；
+* seek、暂停和等待会重置基准。调用方负责把成功关联到当前动作凭据。
 */
-var RecoveryEvidenceCoordinator = class {
-	player;
-	emit;
-	nextRecoveryId = 1;
-	active = null;
-	validationTimer = null;
-	constructor(player, emit) {
-		this.player = player;
-		this.emit = emit;
-		player.on("playing", this.onPlaying);
-		player.on("timeupdate", this.onTimeUpdate);
-	}
-	detected(input) {
-		if (this.active) {
-			if (this.active.strategy === input.strategy && this.active.trigger === input.trigger) return;
-			this.cancel("superseded");
-		}
-		this.active = {
-			recoveryId: this.nextRecoveryId++,
-			...input,
-			attempt: 1,
-			maxAttempts: input.maxAttempts,
-			validatingFrom: null,
-			sawPlaying: false
-		};
-		this.emitPhase("detected");
-	}
-	attempting(strategy, input) {
-		if (!this.active || this.active.strategy !== strategy) return;
-		this.clearValidationTimer();
-		this.active.attempt = input.attempt;
-		this.active.maxAttempts = input.maxAttempts;
-		this.active.reason = input.reason;
-		this.active.validatingFrom = null;
-		this.active.sawPlaying = false;
-		this.emitPhase("attempting");
-	}
-	validating(strategy, timeoutMs) {
-		if (!this.active || this.active.strategy !== strategy) return;
-		this.clearValidationTimer();
-		this.active.validatingFrom = this.player.currentTime;
-		this.active.sawPlaying = false;
-		this.emitPhase("validating");
-		if (timeoutMs === void 0) return;
-		this.validationTimer = setTimeout(() => this.failed(strategy, "timeout"), timeoutMs);
-	}
-	failed(strategy, outcome) {
-		if (!this.active || this.active.strategy !== strategy) return;
-		this.clearValidationTimer();
-		this.emitPhase("failed", { outcome });
-		this.active = null;
-	}
-	cancel(outcome) {
-		if (!this.active) return;
-		this.clearValidationTimer();
-		this.emitPhase("cancelled", { outcome });
-		this.active = null;
-	}
-	dispose() {
-		this.cancel("destroyed");
-		this.player.off("playing", this.onPlaying);
-		this.player.off("timeupdate", this.onTimeUpdate);
-	}
-	onPlaying = () => {
-		const active = this.active;
-		if (!active || active.validatingFrom === null) return;
-		active.sawPlaying = true;
-	};
-	onTimeUpdate = () => {
-		const active = this.active;
-		if (!active?.sawPlaying || active.validatingFrom === null) return;
-		if (this.player.currentTime <= active.validatingFrom) return;
-		this.clearValidationTimer();
-		this.emitPhase("recovered", { validatedBy: "playing_position_advance" });
-		this.active = null;
+function observeRecoveryPlayback(media, signal, recovered) {
+	let baseline = null;
+	let playingSeen = false;
+	let disposed = false;
+	const reset = () => {
+		baseline = null;
+		playingSeen = false;
 	};
-	clearValidationTimer() {
-		if (this.validationTimer === null) return;
-		clearTimeout(this.validationTimer);
-		this.validationTimer = null;
-	}
-	emitPhase(phase, terminal = {}) {
-		const active = this.active;
-		if (!active) return;
-		this.emit({
-			event: "recovery",
-			payload: {
-				recoveryId: active.recoveryId,
-				phase,
-				strategy: active.strategy,
-				trigger: active.trigger,
-				attempt: active.attempt,
-				maxAttempts: active.maxAttempts,
-				...active.reason ? { reason: active.reason } : {},
-				...terminal
-			}
-		});
-	}
-};
+	const playing = () => {
+		playingSeen = true;
+		baseline = Number.isFinite(media.currentTime) ? media.currentTime : null;
+	};
+	const seeking = () => {
+		baseline = null;
+	};
+	const seeked = () => {
+		if (playingSeen && !media.paused && !media.seeking && media.readyState >= 2) baseline = Number.isFinite(media.currentTime) ? media.currentTime : null;
+	};
+	const resets = [
+		"pause",
+		"waiting",
+		"emptied",
+		"ended"
+	];
+	const dispose = () => {
+		if (disposed) return;
+		disposed = true;
+		media.removeEventListener("playing", playing);
+		media.removeEventListener("timeupdate", progress);
+		media.removeEventListener("seeking", seeking);
+		media.removeEventListener("seeked", seeked);
+		for (const event of resets) media.removeEventListener(event, reset);
+		signal.removeEventListener("abort", dispose);
+	};
+	const progress = () => {
+		if (disposed || baseline === null || media.paused || media.seeking || media.readyState < 2) return;
+		if (!Number.isFinite(media.currentTime) || media.currentTime <= baseline) return;
+		dispose();
+		recovered();
+	};
+	if (signal.aborted) return dispose;
+	media.addEventListener("playing", playing);
+	media.addEventListener("timeupdate", progress);
+	media.addEventListener("seeking", seeking);
+	media.addEventListener("seeked", seeked);
+	for (const event of resets) media.addEventListener(event, reset);
+	signal.addEventListener("abort", dispose, { once: true });
+	return dispose;
+}
+/** 媒体修复会重新挂载 MSE；先订阅 canplay，避免对尚未挂载的元素提前 play。 */
+function waitForMediaRepair(media, signal, repair) {
+	if (signal.aborted) return Promise.resolve(false);
+	return new Promise((resolve, reject) => {
+		const cleanup = () => {
+			media.removeEventListener("canplay", ready);
+			signal.removeEventListener("abort", abort);
+		};
+		const ready = () => {
+			cleanup();
+			resolve(true);
+		};
+		const abort = () => {
+			cleanup();
+			resolve(false);
+		};
+		media.addEventListener("canplay", ready, { once: true });
+		signal.addEventListener("abort", abort, { once: true });
+		try {
+			if (!repair()) abort();
+		} catch (error) {
+			cleanup();
+			reject(error);
+		}
+	});
+}
 //#endregion
 //#region src/runtime-profile.ts
 /**
@@ -2349,7 +2672,7 @@ function observeMediaPlayRejection(player) {
 	};
 }
 /**
-* 拿 PlayableStatePlugin 实例。走 `getPlugin(pluginName)`,同 `handle.reconnect` 的做法。
+* 拿 PlayableStatePlugin 实例。走 `getPlugin(pluginName)`,同 `handle.retry` 的做法。
 *
 * 返回 undefined 的情况都是良性的:player 还没构造好、插件被 `enabled:false` 关掉、
 * 或 xgplayer 换了 API。调用方一律用可选链,喂不进去就等于这一路信号没有,
@@ -2444,7 +2767,7 @@ function unsupportedRoutePayload(sessionId, source, env) {
 	};
 }
 function kernelPlugin(kernel) {
-	if (kernel === "hls.js") return xgplayer_hls_js.default;
+	if (kernel === "hls.js") return OwnedHlsPlugin;
 	if (kernel === "flv.js") return xgplayer_flv_js.default;
 	return null;
 }
@@ -2476,36 +2799,162 @@ function createPlayer(options) {
 	const config = (0, _video_lab_protocol.resolvePreset)(parsed.data.preset, parsed.data);
 	const normalized = normalizeSource(config.source);
 	let sessionId = newSessionId();
+	let deliverySequence = 0;
+	const makeDelivered = (event) => {
+		deliverySequence += 1;
+		return {
+			event,
+			producerSessionId: sessionId,
+			deliveryId: `${sessionId}:${deliverySequence}`,
+			occurredAtMs: Date.now(),
+			sequence: deliverySequence
+		};
+	};
+	const notify = (delivered) => {
+		try {
+			options.onEvent?.(delivered.event);
+		} catch {}
+		try {
+			options.onDeliveredEvent?.(delivered);
+		} catch {}
+	};
 	let routed;
 	try {
 		routed = routeSource(normalized, env);
 	} catch (error) {
-		if (error instanceof SentinelError && error.playerError.code === "E_MEDIA_NOT_SUPPORTED") options.onEvent?.({
+		if (error instanceof SentinelError && error.playerError.code === "E_MEDIA_NOT_SUPPORTED") notify(makeDelivered({
 			event: "sourceroute",
 			payload: unsupportedRoutePayload(sessionId, normalized, env)
-		});
+		}));
 		throw error;
 	}
 	let destroyed = false;
+	let loadRevision = 0;
+	let recovery = null;
 	let eventStreamReady = false;
 	const deferredEvents = [];
+	const reportRecoveryFault = (event, eventSession) => {
+		if (event.event === "error" && !destroyed && eventSession === sessionId && event.payload.code !== "E_SUBTITLE_LOAD_FAILED" && event.payload.code !== "E_DANMAKU_SEND_FAILED" && event.payload.code !== "E_METHOD_NOT_SUPPORTED") recovery?.fault(event.payload, eventSession);
+	};
 	const emit = (event) => {
 		if (destroyed) return;
+		const delivered = makeDelivered(event);
 		if (!eventStreamReady) {
-			deferredEvents.push(event);
+			deferredEvents.push(delivered);
 			return;
 		}
-		options.onEvent?.(event);
+		const eventSession = sessionId;
+		notify(delivered);
+		reportRecoveryFault(event, eventSession);
 	};
 	let playerRef = null;
 	const playableState = () => getPlayableState(playerRef);
-	let recoveryEvidence = null;
 	const player = new xgplayer.default(buildXgplayerConfig({
 		...options,
 		config
-	}, routed, normalized, emit, env, playableState, () => recoveryEvidence));
+	}, routed, normalized, emit, env, playableState, () => recovery));
+	let pageQueue = Promise.resolve();
+	let pageRevision = 0;
+	let applyingPageState = false;
+	let pageExpired = false;
+	const applyPageState = (active) => {
+		applyingPageState = true;
+		try {
+			pageFullscreen.setActive(active);
+		} finally {
+			applyingPageState = false;
+		}
+	};
+	const setPageFullscreen = (active) => {
+		const revision = ++pageRevision;
+		const operation = pageQueue.then(async () => {
+			if (destroyed) throw new Error(_video_lab_protocol.PLAYER_DESTROYED_MESSAGE);
+			if (pageExpired) throw new Error("网页全屏控制器已失效");
+			let timer;
+			const layout = Promise.resolve().then(() => options.pageFullscreen?.setActive(active)).then(() => {
+				if (destroyed || pageExpired) {
+					options.pageFullscreen?.dispose();
+					throw new Error("网页全屏请求已失效");
+				}
+			});
+			try {
+				await Promise.race([layout, new Promise((_, reject) => {
+					timer = setTimeout(() => {
+						pageExpired = true;
+						reject(/* @__PURE__ */ new Error("网页全屏确认超时"));
+					}, 1e4);
+				})]);
+				if (revision === pageRevision) applyPageState(active);
+			} catch (error) {
+				options.pageFullscreen?.dispose();
+				if (!destroyed) applyPageState(false);
+				throw error;
+			} finally {
+				clearTimeout(timer);
+			}
+		});
+		pageQueue = operation.catch(() => {});
+		return operation;
+	};
+	const pageFullscreen = attachPageFullscreen(player, {
+		...options.pageFullscreen ? { onRequest: (active) => {
+			setPageFullscreen(active).catch(() => {});
+		} } : {},
+		onChange: (active) => {
+			emit({
+				event: "pagefullscreenchange",
+				payload: { active }
+			});
+			if (!active && !applyingPageState && options.pageFullscreen && !options.pageFullscreenPending) setPageFullscreen(false).catch(() => {});
+		}
+	});
+	const onPageEscape = (event) => {
+		if (event.key === "Escape" && player.isCssfullScreen) setPageFullscreen(false).catch(() => {});
+	};
+	if (options.pageFullscreen && !options.pageFullscreenPending) {
+		pageFullscreen.setAvailable(true);
+		options.el.ownerDocument.addEventListener("keydown", onPageEscape);
+	}
 	playerRef = player;
-	recoveryEvidence = new RecoveryEvidenceCoordinator(player, emit);
+	let desiredPlayback = config.autoplay ?? false;
+	let recoveryCleanup = null;
+	const stopRecoveryLoad = () => {
+		if (routed.kernel === "hls.js") player.getPlugin("HlsJsPlugin")?.stopLoading();
+		else if (routed.kernel === "flv.js") player.__flv__?.unload();
+		else {
+			player.pause();
+			if (player.video instanceof HTMLMediaElement) {
+				player.video.removeAttribute("src");
+				player.video.load();
+			}
+		}
+	};
+	recovery = new PlaybackRecovery(sessionId, async (token, signal) => {
+		recoveryCleanup?.();
+		const media = player.video;
+		if (!(media instanceof HTMLMediaElement)) throw new Error("Recovery requires a media element");
+		const cleanup = () => {
+			unobserve();
+			signal.removeEventListener("abort", abort);
+			if (recoveryCleanup === cleanup) recoveryCleanup = null;
+		};
+		const abort = () => {
+			if (recoveryCleanup !== cleanup) return;
+			cleanup();
+			stopRecoveryLoad();
+		};
+		const unobserve = observeRecoveryPlayback(media, signal, () => {
+			cleanup();
+			recovery?.recovered(token);
+		});
+		recoveryCleanup = cleanup;
+		signal.addEventListener("abort", abort, { once: true });
+		const repaired = token.strategy === "media_recovery" && token.attempt === 1 && routed.kernel === "hls.js" && await waitForMediaRepair(media, signal, () => player.getPlugin("HlsJsPlugin")?.recoverMediaError() ?? false);
+		if (signal.aborted || destroyed) return;
+		if (!repaired) await player.switchURL(currentSrcUrl);
+		if (!signal.aborted && !destroyed && recovery?.playingIntent) await player.play();
+	}, emit, (state) => playableState()?.setRecovery(state));
+	recovery.setPlayingIntent(desiredPlayback);
 	const listeners = [];
 	const listen = (name, handler) => {
 		listeners.push([name, handler]);
@@ -2520,7 +2969,11 @@ function createPlayer(options) {
 		const foreground = typeof document === "undefined" || document.visibilityState !== "hidden";
 		flvAudioHealth?.setActive(flvPlaybackActive && foreground);
 	};
-	const onVisibilityChange = () => syncFlvAudioHealthActivity();
+	const onVisibilityChange = () => {
+		syncFlvAudioHealthActivity();
+		recovery?.setSuspended(document.hidden);
+		armStartupDeadline();
+	};
 	if (typeof document !== "undefined") {
 		document.addEventListener("visibilitychange", onVisibilityChange);
 		disposers.push(() => document.removeEventListener("visibilitychange", onVisibilityChange));
@@ -2591,15 +3044,19 @@ function createPlayer(options) {
 		payload: selectedRoutePayload(sessionId, normalized, routed, env)
 	});
 	emitContextChange();
-	for (const event of deferredEvents) emit(event);
+	for (const delivered of deferredEvents) {
+		notify(delivered);
+		reportRecoveryFault(delivered.event, delivered.producerSessionId);
+	}
 	deferredEvents.length = 0;
 	const attachQualityListener = () => {
 		if (destroyed) return;
 		const hls = getHlsInstance(player);
-		if (!hls?.on || !(hls.levels && hls.levels.length >= 2)) return;
 		if (hls === qualityListenerTarget) return;
 		detachQualityListener?.();
+		if (!hls?.on || !(hls.levels && hls.levels.length >= 2)) return;
 		const onSwitched = (...args) => {
+			if (destroyed || getHlsInstance(player) !== hls) return;
 			const data = args.at(-1);
 			const level = typeof data?.level === "number" ? data.level : hls.currentLevel;
 			if (level < 0) return;
@@ -2622,6 +3079,19 @@ function createPlayer(options) {
 		};
 	};
 	hlsCleanups.push(() => detachQualityListener?.());
+	let naturalProof = null;
+	const observeNaturalPlayback = () => {
+		naturalProof?.abort();
+		naturalProof = null;
+		const media = player.video;
+		if (!(media instanceof HTMLMediaElement) || destroyed) return;
+		naturalProof = new AbortController();
+		observeRecoveryPlayback(media, naturalProof.signal, () => {
+			recovery?.naturalRecovered();
+			observeNaturalPlayback();
+		});
+	};
+	disposers.push(() => naturalProof?.abort());
 	let sawFirstFrame = false;
 	let sawPlaybackStart = false;
 	let sawPlaying = false;
@@ -2630,6 +3100,27 @@ function createPlayer(options) {
 	let lastPlaybackPosition = null;
 	let seeking = false;
 	let prematureVodEnd = null;
+	let startupTimer = null;
+	const clearStartupDeadline = () => {
+		if (startupTimer !== null) clearTimeout(startupTimer);
+		startupTimer = null;
+	};
+	const armStartupDeadline = () => {
+		clearStartupDeadline();
+		if (!desiredPlayback || sawFirstFrame || seeking || document.hidden || destroyed) return;
+		startupTimer = setTimeout(() => {
+			startupTimer = null;
+			recovery?.requestRecovery("startup_timeout");
+		}, 15e3);
+	};
+	const setPlayingIntent = (playing) => {
+		desiredPlayback = playing;
+		recovery?.setPlayingIntent(playing);
+		armStartupDeadline();
+	};
+	disposers.push(clearStartupDeadline);
+	recovery.setSuspended(document.hidden);
+	armStartupDeadline();
 	const resetPrematureVodEndState = () => {
 		sawFirstFrame = false;
 		sawPlaybackStart = false;
@@ -2663,6 +3154,7 @@ function createPlayer(options) {
 		});
 	});
 	listen("play", () => {
+		observeNaturalPlayback();
 		sawPlaybackStart = true;
 		flvPlaybackActive = true;
 		syncFlvAudioHealthActivity();
@@ -2686,25 +3178,25 @@ function createPlayer(options) {
 		});
 	});
 	listen("ended", () => {
-		if (prematureVodEnd !== null) {
-			emit({
-				event: "error",
-				payload: (0, _video_lab_protocol.makePlayerError)("E_MEDIA_DECODE", "点播媒体在达到结尾前异常跳转并结束", {
-					kind: "premature_vod_end",
-					...prematureVodEnd
-				})
-			});
-			playableState()?.setError(true);
-		} else if (!normalized.live && routed.kernel === "native" && safeNumber(player.duration) > 0 && sawPlaybackStart && sawStartupWaiting && !sawPlaying && !sawFirstFrame && !sawNativeError) {
-			emit({
-				event: "error",
-				payload: (0, _video_lab_protocol.makePlayerError)("E_MEDIA_DECODE", "点播媒体未解出首帧即结束", {
-					kind: "initial_frame_decode_failure",
-					duration: safeNumber(player.duration),
-					endTime: safeNumber(player.currentTime)
-				})
-			});
-			playableState()?.setError(true);
+		if (prematureVodEnd !== null) emit({
+			event: "error",
+			payload: (0, _video_lab_protocol.makePlayerError)("E_MEDIA_DECODE", "点播媒体在达到结尾前异常跳转并结束", {
+				kind: "premature_vod_end",
+				...prematureVodEnd
+			})
+		});
+		else if (!normalized.live && routed.kernel === "native" && safeNumber(player.duration) > 0 && sawPlaybackStart && sawStartupWaiting && !sawPlaying && !sawFirstFrame && !sawNativeError) emit({
+			event: "error",
+			payload: (0, _video_lab_protocol.makePlayerError)("E_MEDIA_DECODE", "点播媒体未解出首帧即结束", {
+				kind: "initial_frame_decode_failure",
+				duration: safeNumber(player.duration),
+				endTime: safeNumber(player.currentTime)
+			})
+		});
+		else if (sawFirstFrame && !normalized.live && !config.loop) {
+			desiredPlayback = false;
+			clearStartupDeadline();
+			recovery?.endPlayback();
 		}
 		emit({
 			event: "ended",
@@ -2745,6 +3237,7 @@ function createPlayer(options) {
 	});
 	listen("seeking", () => {
 		seeking = true;
+		clearStartupDeadline();
 		lastPlaybackPosition = safeNumber(player.currentTime);
 		prematureVodEnd = null;
 		emit({
@@ -2753,6 +3246,8 @@ function createPlayer(options) {
 		});
 	});
 	listen("seeked", () => {
+		seeking = false;
+		armStartupDeadline();
 		emit({
 			event: "seeked",
 			payload: { time: safeNumber(player.currentTime) }
@@ -2765,6 +3260,7 @@ function createPlayer(options) {
 		const fvt = log.fvt;
 		if (typeof fvt !== "number" || !Number.isFinite(fvt)) return;
 		sawFirstFrame = true;
+		clearStartupDeadline();
 		emit({
 			event: "firstframe",
 			payload: { fvt }
@@ -2781,6 +3277,7 @@ function createPlayer(options) {
 	listen("user_action", (raw) => {
 		const payload = (0, _video_lab_protocol.normalizeUserAction)(raw);
 		if (payload === null) return;
+		if (payload.action === "switch_play_pause" && typeof payload.to === "boolean") setPlayingIntent(!payload.to);
 		emit({
 			event: "useraction",
 			payload
@@ -2794,7 +3291,6 @@ function createPlayer(options) {
 			event: "error",
 			payload: mapped
 		});
-		playableState()?.setError(true);
 	});
 	/**
 	* FLV 内核诊断 → 契约 error 流(#403)。
@@ -2874,12 +3370,11 @@ function createPlayer(options) {
 				event: "error",
 				payload: mapped
 			});
-			playableState()?.setError(true);
 		};
 		target.on("error", onError);
 		detachFlvDiagnostics = () => {
-			target.off?.("error", onError);
 			detachFlvDiagnostics = null;
+			if (target._emitter !== null) target.off?.("error", onError);
 		};
 	};
 	hlsCleanups.push(() => detachFlvDiagnostics?.());
@@ -2975,14 +3470,15 @@ function createPlayer(options) {
 		};
 		target.on("media_info", onMediaInfo);
 		detachFlvAudioHealth = () => {
-			target.off?.("media_info", onMediaInfo);
+			detachFlvAudioHealth = () => {};
+			if (target._emitter !== null) target.off?.("media_info", onMediaInfo);
 			for (const cleanup of sourceBufferCleanups) cleanup();
 			sourceBufferCleanups.length = 0;
 			flvAudioHealth?.dispose();
 			flvAudioHealth = null;
 		};
-		hlsCleanups.push(() => detachFlvAudioHealth());
 	};
+	hlsCleanups.push(() => detachFlvAudioHealth());
 	{
 		const holder = player;
 		let current = holder.__flv__;
@@ -2995,6 +3491,10 @@ function createPlayer(options) {
 			get: () => current,
 			set: (v) => {
 				current = v;
+				if (v === void 0 || v === null) {
+					detachFlvDiagnostics?.();
+					detachFlvAudioHealth();
+				}
 				if (v !== void 0 && v !== null) {
 					attachFlvDiagnostics(v);
 					attachFlvAudioHealth(v);
@@ -3063,7 +3563,6 @@ function createPlayer(options) {
 			event: "error",
 			payload: mapped
 		});
-		playableState()?.setError(true);
 	});
 	return {
 		get destroyed() {
@@ -3071,6 +3570,7 @@ function createPlayer(options) {
 		},
 		async play() {
 			if (destroyed) return;
+			setPlayingIntent(true);
 			try {
 				await player.play();
 			} catch (err) {
@@ -3079,6 +3579,7 @@ function createPlayer(options) {
 		},
 		pause() {
 			if (destroyed) return;
+			setPlayingIntent(false);
 			player.pause();
 		},
 		seek(time) {
@@ -3097,6 +3598,12 @@ function createPlayer(options) {
 			if (destroyed) return;
 			player.playbackRate = clamp(rate, .25, 4);
 		},
+		setPageFullscreen,
+		syncPageFullscreen(active, available) {
+			pageRevision += 1;
+			pageFullscreen.setAvailable(available);
+			applyPageState(active);
+		},
 		async enterFullscreen() {
 			if (destroyed) return;
 			await player.getFullscreen();
@@ -3180,9 +3687,20 @@ function createPlayer(options) {
 			if (nextRouted.kernel !== routed.kernel) throwPlayerError("E_METHOD_NOT_SUPPORTED", `换源需要从 ${routed.kernel} 内核切到 ${nextRouted.kernel},运行时无法切换内核。请销毁当前 player 并用新的 source 重建。`);
 			const constructionChanges = sourceConstructionChanges(normalized, nextNormalized);
 			if (constructionChanges.length > 0) throwPlayerError("E_METHOD_NOT_SUPPORTED", `换源不能改变构造期 source 配置(${constructionChanges.join("、")})。播放器仍使用创建时的直播、HLS 与字幕插件配置。请销毁当前 player 并用新的 source 重建。`);
-			recoveryEvidence?.cancel("source_changed");
+			const revision = ++loadRevision;
+			naturalProof?.abort();
+			recovery?.setSession(nextSessionId);
+			if (destroyed || revision !== loadRevision) return;
+			playableState()?.setRecovery({
+				recovering: false,
+				failed: false,
+				action: "none"
+			});
+			if (destroyed || revision !== loadRevision) return;
 			resetPrematureVodEndState();
 			sessionId = nextSessionId;
+			deliverySequence = 0;
+			armStartupDeadline();
 			currentSrcUrl = nextRouted.chosen.url;
 			currentMediaType = nextRouted.chosen.type;
 			currentQualityLevel = null;
@@ -3190,14 +3708,16 @@ function createPlayer(options) {
 				event: "sourceroute",
 				payload: selectedRoutePayload(sessionId, nextNormalized, nextRouted, env)
 			});
+			if (destroyed || revision !== loadRevision) return;
 			emitContextChange();
+			if (destroyed || revision !== loadRevision) return;
 			await player.switchURL(nextRouted.chosen.url);
+			if (destroyed || revision !== loadRevision) return;
 			getMediaSession(player)?.setMetadata(nextNormalized.metadata);
-			getReconnectPlugin(player)?.resetForNewSource?.();
 		},
-		reconnect(options) {
-			if (destroyed) return;
-			getReconnectPlugin(player)?.manualReconnect?.(options?.resetCounter ?? false);
+		async retry() {
+			clearStartupDeadline();
+			await recovery?.retry();
 		},
 		getPlaybackContext() {
 			return readPlaybackContext();
@@ -3215,8 +3735,12 @@ function createPlayer(options) {
 		*/
 		destroy() {
 			if (destroyed) return;
-			recoveryEvidence?.dispose();
+			recovery?.destroy();
+			recoveryCleanup?.();
 			destroyed = true;
+			options.pageFullscreen?.dispose();
+			pageFullscreen.destroy();
+			options.el.ownerDocument.removeEventListener("keydown", onPageEscape);
 			for (const [name, handler] of listeners) player.off(name, handler);
 			listeners.length = 0;
 			for (const cleanup of hlsCleanups) cleanup();
@@ -3280,14 +3804,12 @@ function extendInstanceI18n(player, locale, lang) {
 	if (!instanceI18n) return;
 	xgplayer.I18N.extend(entries, instanceI18n);
 }
-function buildXgplayerConfig(options, routed, normalized, emit, env, playableState, recoveryEvidence) {
+function buildXgplayerConfig(options, routed, normalized, emit, env, playableState, recovery) {
 	const { config } = options;
 	const live = normalized.live;
 	const plugins = [
 		SafeDestroyPlugin,
 		AutoplayGuardPlugin,
-		ReconnectPlugin,
-		ErrorRecoveryPlugin,
 		VisibilityPlugin,
 		CompatPlugin,
 		WakeLockPlugin,
@@ -3308,7 +3830,12 @@ function buildXgplayerConfig(options, routed, normalized, emit, env, playableSta
 		el: options.el,
 		url: routed.chosen.url,
 		isLive: live,
-		ignores: ["loading"],
+		ignores: [
+			"loading",
+			"enter",
+			...config.controlVisibility?.volume === false ? ["volume"] : [],
+			...config.controlVisibility?.time === false ? ["time"] : []
+		],
 		...toXgLang(config.locale) ? { lang: toXgLang(config.locale) } : {},
 		...(() => {
 			const lang = toXgLang(config.locale);
@@ -3332,65 +3859,16 @@ function buildXgplayerConfig(options, routed, normalized, emit, env, playableSta
 			preferManagedMediaSource: false
 		} } } : {},
 		autoplayGuard: { onAutoplayBlocked: () => {
+			recovery()?.setPlayingIntent(false);
 			emit({
 				event: "autoplayblocked",
 				payload: {}
 			});
 			playableState()?.setAutoplayBlocked(true);
 		} },
-		reconnect: {
-			onReconnectStart: (payload) => {
-				emit({
-					event: "reconnectstart",
-					payload
-				});
-				playableState()?.setReconnecting(true);
-			},
-			onReconnectSuccess: (payload) => {
-				emit({
-					event: "reconnectsuccess",
-					payload
-				});
-				playableState()?.setReconnecting(false);
-			},
-			onReconnectFailed: (payload) => {
-				emit({
-					event: "reconnectfailed",
-					payload
-				});
-				playableState()?.setReconnecting(false);
-				playableState()?.setError(true);
-			},
-			onRecoveryDetected: ({ trigger, maxAttempts, reason }) => recoveryEvidence()?.detected({
-				strategy: "reconnect",
-				trigger,
-				maxAttempts,
-				reason
-			}),
-			onRecoveryAttempting: (payload) => recoveryEvidence()?.attempting("reconnect", payload),
-			onRecoveryValidating: ({ timeoutMs }) => recoveryEvidence()?.validating("reconnect", timeoutMs),
-			onRecoveryFailed: ({ outcome }) => recoveryEvidence()?.failed("reconnect", outcome)
-		},
-		errorRecovery: {
-			onRecoveryDetected: ({ trigger, maxAttempts, reason }) => recoveryEvidence()?.detected({
-				strategy: "media_recovery",
-				trigger,
-				maxAttempts,
-				reason
-			}),
-			onRecoveryAttempting: (payload) => recoveryEvidence()?.attempting("media_recovery", payload),
-			onRecoveryValidating: () => recoveryEvidence()?.validating("media_recovery", 15e3),
-			onRecoveryFailed: ({ outcome }) => recoveryEvidence()?.failed("media_recovery", outcome)
-		},
 		visibility: {
 			isIOS: env.isIOS,
-			onRecoveryDetected: ({ trigger, maxAttempts }) => recoveryEvidence()?.detected({
-				strategy: "visibility_reload",
-				trigger,
-				maxAttempts
-			}),
-			onRecoveryAttempting: (payload) => recoveryEvidence()?.attempting("visibility_reload", payload),
-			onRecoveryValidating: () => recoveryEvidence()?.validating("visibility_reload", 15e3)
+			requestRecovery: () => recovery()?.requestRecovery("visibility")
 		},
 		compat: {
 			ua: env.ua,
@@ -3407,6 +3885,7 @@ function buildXgplayerConfig(options, routed, normalized, emit, env, playableSta
 					payload
 				});
 				playableState()?.setStalled(payload.phase === "start");
+				if (payload.phase === "start" && payload.kind === "playback") recovery()?.requestRecovery("stall");
 			},
 			onBufferHealth: (payload) => {
 				emit({
@@ -3430,19 +3909,15 @@ function buildXgplayerConfig(options, routed, normalized, emit, env, playableSta
 		...config.startTime === void 0 ? {} : { startTime: config.startTime },
 		...config.poster === void 0 ? {} : { poster: typeof config.poster === "string" ? config.poster : config.poster.url },
 		controls: config.controls !== false,
-		pip: true
+		...config.controlVisibility?.play === false ? { play: { disable: true } } : {},
+		...config.controlVisibility?.progress === false ? { progress: { disable: true } } : {},
+		...config.controlVisibility?.fullscreen === false ? { fullscreen: { disable: true } } : {},
+		...config.controlVisibility?.cssFullscreen === false ? { cssFullscreen: { disable: true } } : {},
+		...config.controlVisibility?.playbackRate === false ? { playbackRate: { isShowIcon: false } } : {},
+		pip: config.controlVisibility?.pip !== false
 	};
 }
 /**
-* 取 ReconnectPlugin 实例。`getPlugin` 用的是 pluginName(`'reconnect'`)。
-*
-* **收成一个函数**:`handle.reconnect` 和 `load()` 的换源复位都要拿它,
-* 两处各写一遍 `as unknown as { getPlugin?… }` 就是两份会漂的类型断言。
-*/
-function getReconnectPlugin(player) {
-	return player.getPlugin?.("reconnect");
-}
-/**
 * 取 xgplayer-hls.js 插件持有的 hls.js 实例。非 HLS 源(MP4 走原生、FLV 走 flv.js)
 * 拿不到,返回 undefined —— 上层据此把多码率相关能力降级成 no-op / 空档位。
 */