@xmov/avatar 2.4.0 → 2.5.0-alpha.1

package/src/utils/capability-checker.ts

@@ -1,762 +0,0 @@
-import type { CapabilitySeverity, ICapabilityCheckItem, ICapabilityCheckReport } from '../types/capability';
-import { VIDEO_PROBE_BASE64 } from './video-probe-asset';
-
-// ==================== 平台判定 ====================
-
-/**
- * 判定是否为 Android 系平台（含 OpenHarmony / ArkWeb）
- *
- * 与 streaming-video.ts 的解码策略保持一致：
- * - Android：主路径为 prefer-software 软解码
- * - 其余环境：默认配置（硬解码）或客户传入配置
- */
-function isAndroidPlatform(): boolean {
-  const userAgent = (navigator.userAgent || '').toLowerCase();
-  return /android/.test(userAgent) || /openharmony|arkweb/.test(userAgent);
-}
-
-// ==================== 同步检查（constructor 使用） ====================
-
-/**
- * 同步检查安全上下文（HTTPS / localhost）
- */
-function checkSecureContextSync(): ICapabilityCheckItem {
-  const supported = window.isSecureContext;
-  return {
-    name: 'secureContext',
-    supported,
-    severity: 'fatal',
-    reason: supported ? undefined : '当前环境不是安全上下文，请使用 HTTPS 或 localhost',
-  };
-}
-
-/**
- * 同步检查 WebGL2 支持（创建上下文）
- */
-function checkWebGL2Sync(): ICapabilityCheckItem {
-  try {
-    const canvas = document.createElement('canvas');
-    const gl = canvas.getContext('webgl2', { failIfMajorPerformanceCaveat: true });
-    if (!gl) {
-      return {
-        name: 'webgl2',
-        supported: false,
-        severity: 'fatal',
-        reason: '浏览器不支持 WebGL2',
-      };
-    }
-    // 获取基本信息
-    const debugInfo = gl.getExtension('WEBGL_debug_renderer_info');
-    const detail = {
-      version: gl.getParameter(gl.VERSION),
-      vendor: gl.getParameter(gl.VENDOR),
-      renderer: gl.getParameter(gl.RENDERER),
-      gpuVendor: debugInfo ? gl.getParameter(debugInfo.UNMASKED_VENDOR_WEBGL) : undefined,
-      gpuRenderer: debugInfo ? gl.getParameter(debugInfo.UNMASKED_RENDERER_WEBGL) : undefined,
-    };
-    return {
-      name: 'webgl2',
-      supported: true,
-      severity: 'fatal',
-      detail,
-    };
-  } catch (e) {
-    return {
-      name: 'webgl2',
-      supported: false,
-      severity: 'fatal',
-      reason: 'WebGL2 初始化失败',
-      detail: e,
-    };
-  }
-}
-
-/**
- * 同步检查音频系统（PCM 或 MSE 任一可用即可）
- *
- * SDK 有两种音频播放器：
- * 1. PCM 播放器：AudioWorklet + AudioContext（raw_audio = true）
- * 2. MSE 播放器：MediaSource + HTMLAudioElement（raw_audio = false）
- *
- * 两者二选一，任一可用则 SDK 音频能力可用
- */
-function checkAudioSystemSync(): ICapabilityCheckItem {
-  // PCM 路径：需要 AudioContext + AudioWorkletNode
-  const hasAudioContext = typeof (window as any).AudioContext !== 'undefined'
-    || typeof (window as any).webkitAudioContext !== 'undefined';
-  const hasAudioWorklet = typeof (window as any).AudioWorkletNode !== 'undefined';
-  const pcmSupported = hasAudioContext && hasAudioWorklet;
-
-  // MSE 路径：需要 MediaSource + SourceBuffer
-  const hasMediaSource = typeof (window as any).MediaSource !== 'undefined';
-  const mseSupported = hasMediaSource;
-
-  const supported = pcmSupported || mseSupported;
-
-  const detail = {
-    pcm: {
-      supported: pcmSupported,
-      hasAudioContext,
-      hasAudioWorklet,
-    },
-    mse: {
-      supported: mseSupported,
-      hasMediaSource,
-    },
-  };
-
-  if (!supported) {
-    return {
-      name: 'audio',
-      supported: false,
-      severity: 'fatal',
-      reason: '音频播放能力不可用：PCM（AudioWorklet）和 MSE（MediaSource）均不支持',
-      detail,
-    };
-  }
-
-  return {
-    name: 'audio',
-    supported: true,
-    severity: 'fatal',
-    detail,
-  };
-}
-
-/**
- * 同步检查 WebCodecs API 是否存在（不探测具体编解码器）
- *
- * 与 streaming-video.ts 解码策略一致标注平台解码路径：
- * - Android（含 OpenHarmony/ArkWeb）：prefer-software 软解码
- * - 其余环境：默认配置（硬解码）
- * 实际解码配置支持度由异步 checkWebCodecsDetailed 探测
- */
-function checkWebCodecsSync(): ICapabilityCheckItem {
-  const hasVideoDecoder = typeof (window as any).VideoDecoder !== 'undefined';
-  const isAndroid = isAndroidPlatform();
-
-  return {
-    name: 'webcodecs',
-    supported: hasVideoDecoder,
-    severity: 'fatal',
-    reason: hasVideoDecoder ? undefined : '浏览器不支持 WebCodecs VideoDecoder API',
-    detail: {
-      hasVideoDecoder,
-      isAndroid,
-      hardwareAcceleration: isAndroid ? 'prefer-software' : 'default',
-    },
-  };
-}
-
-/**
- * 同步检查视频解码能力（仅判定 API 存在性，不探测具体编解码器）
- *
- * 真实解码探测由异步 checkVideoDecodeDetailed 完成（新增能力项 videoDecode）。
- * 此处仅作为 constructor 阶段的快速占位：VideoDecoder API 缺失是确定性缺陷，
- * 任何平台都判 fatal。
- */
-function checkVideoDecodeSync(): ICapabilityCheckItem {
-  const hasVideoDecoder = typeof (window as any).VideoDecoder !== 'undefined';
-  return {
-    name: 'videoDecode',
-    supported: hasVideoDecoder,
-    severity: 'fatal',
-    reason: hasVideoDecoder ? undefined : '浏览器不支持 WebCodecs VideoDecoder API',
-  };
-}
-
-/**
- * 同步检查 Web Worker 构造函数是否存在
- */
-function checkWorkerSync(): ICapabilityCheckItem {
-  const supported = typeof Worker !== 'undefined';
-  return {
-    name: 'worker',
-    supported,
-    severity: 'fatal',
-    reason: supported ? undefined : '浏览器不支持 Web Worker',
-  };
-}
-
-/**
- * 同步检查所有浏览器能力（用于 constructor 快速校验）
- *
- * 检查项：
- * - secureContext：安全上下文（HTTPS / localhost）
- * - webgl2：WebGL2 渲染能力
- * - audio：音频播放能力（PCM 或 MSE 任一可用即可）
- * - webcodecs：WebCodecs API 存在性
- * - videoDecode：VideoDecoder API 存在性（真实解码探测见异步 checkVideoDecodeDetailed）
- * - worker：Web Worker 支持
- *
- * 音频检查逻辑：SDK 有两种音频播放器（PCM 和 MSE），只需其中一种可用即可
- * - PCM 播放器依赖：AudioContext + AudioWorkletNode
- * - MSE 播放器依赖：MediaSource
- * - 两者都不可用时，音频能力检查失败
- */
-export function checkCapabilitySync(audioOnlyMode = false): ICapabilityCheckReport {
-  const items: ICapabilityCheckItem[] = [
-    checkSecureContextSync(),
-  ];
-
-  if (audioOnlyMode) {
-    // audioOnlyMode: only check secureContext, audio, and worker
-    items.push(checkAudioSystemSync());
-    items.push(checkWorkerSync());
-  } else {
-    // Full mode: check all capabilities
-    items.push(
-      checkWebGL2Sync(),
-      checkAudioSystemSync(),
-      checkWebCodecsSync(),
-      checkVideoDecodeSync(),
-      checkWorkerSync(),
-    );
-  }
-
-  const fatalCount = items.filter(i => i.severity === 'fatal' && !i.supported).length;
-  const warnCount = items.filter(i => i.severity === 'warn' && !i.supported).length;
-
-  return {
-    supported: fatalCount === 0,
-    fatalCount,
-    warnCount,
-    items,
-  };
-}
-
-// ==================== 异步检查（init 详细探测使用） ====================
-
-/**
- * 异步检查 WebCodecs 编解码器声明支持度（仅作诊断信息）
- *
- * 与 streaming-video.ts 解码策略一致：
- * - Android（含 OpenHarmony/ArkWeb）：主路径为 prefer-software 软解码，默认配置兜底
- * - 其余环境：主路径为默认配置（硬解码）
- *
- * 注意：本检查使用不带 description（avcC/SPS-PPS）的 config，与真实解码 config 并不等价，
- * 其 isConfigSupported 结论存在假通过/假失败，因此统一降级为 warn，不再参与 SDK 可用性判定。
- * SDK 可用性由 videoDecode（真实解码探测）负责。
- */
-async function checkWebCodecsDetailed(): Promise<ICapabilityCheckItem> {
-  try {
-    const hasVideoDecoder = typeof (window as any).VideoDecoder !== 'undefined';
-
-    if (!hasVideoDecoder) {
-      return {
-        name: 'webcodecs',
-        supported: false,
-        severity: 'warn',
-        reason: '浏览器不支持 WebCodecs VideoDecoder API',
-        detail: { hasVideoDecoder },
-      };
-    }
-
-    // 平台判定与 streaming-video.ts 保持一致
-    const isAndroid = isAndroidPlatform();
-
-    // 探测配置补全尺寸字段：与业务 isConfigSupported(config) 一致（纯 codec 在部分浏览器被拒）
-    const probeW = 2160;
-    const probeH = 1920;
-
-    // 探测具体编解码器支持
-    // 注意：WebCodecs 的 codec 字段是纯编解码器字符串（如 avc1.640032），
-    //       不能用 video/mp4; codecs="..." 的 MIME 形式（会导致 isConfigSupported 抛异常）
-    let codecSupport: Record<string, { default: boolean; software: boolean | null; error?: string }> = {};
-    const testCodecs = [
-      'avc1.42E01E',  // H.264 Baseline
-      'avc1.4D001F',  // H.264 Main
-      'avc1.64001F',  // H.264 High
-    ];
-
-    // Android：仅以 prefer-software 软解码为准（硬解/默认配置不算通过）
-    // 其余平台：主路径（默认配置）与兜底配置任一支持即判定可用
-    let primarySupported = false;
-    let fallbackSupported = false;
-    // 探测过程是否出现异常（区别于"确实不支持"）：异常时降级 warn，避免误杀可用环境
-    let probeFailed = false;
-    for (const codec of testCodecs) {
-      try {
-        // 默认配置（浏览器默认/硬解），业务兜底路径
-        const defaultResult = await (window as any).VideoDecoder.isConfigSupported({
-          codec,
-          codedWidth: probeW,
-          codedHeight: probeH,
-        });
-        const defaultOk = !!defaultResult?.supported;
-        if (defaultOk) {
-          fallbackSupported = true;
-        }
-
-        // Android 主路径：prefer-software 软解码（与 streaming-video.ts 一致）
-        let softwareOk: boolean | null = null;
-        if (isAndroid) {
-          try {
-            const softwareResult = await (window as any).VideoDecoder.isConfigSupported({
-              codec,
-              codedWidth: probeW,
-              codedHeight: probeH,
-              hardwareAcceleration: 'prefer-software',
-            });
-            softwareOk = !!softwareResult?.supported;
-          } catch {
-            softwareOk = false;
-          }
-          if (softwareOk) {
-            primarySupported = true;
-          }
-        } else if (defaultOk) {
-          primarySupported = true;
-        }
-
-        codecSupport[codec] = { default: defaultOk, software: softwareOk };
-      } catch {
-        // isConfigSupported 抛异常：探测方式受限（如浏览器实现差异），非"确实不支持"
-        probeFailed = true;
-        codecSupport[codec] = { default: false, software: null, error: 'probe-failed' };
-      }
-    }
-
-    const supported = isAndroid ? primarySupported : (primarySupported || fallbackSupported);
-    return {
-      name: 'webcodecs',
-      supported,
-      // 诊断项：结论仅供参考，不参与 SDK 可用性判定（真实判据见 videoDecode）
-      severity: 'warn',
-      reason: supported
-        ? undefined
-        : probeFailed
-          ? 'WebCodecs 声明支持度探测异常（运行时将以实际视频配置二次确认）'
-          : isAndroid
-            ? 'Android 不支持软解码（prefer-software 声明不可用）'
-            : 'WebCodecs 声明不支持 H.264（默认/软解配置均不可用）',
-      detail: {
-        hasVideoDecoder,
-        isAndroid,
-        hardwareAcceleration: isAndroid ? 'prefer-software' : 'default',
-        codecSupport,
-      },
-    };
-  } catch (e) {
-    return {
-      name: 'webcodecs',
-      supported: false,
-      severity: 'warn',
-      reason: 'WebCodecs 声明支持度探测失败',
-      detail: e,
-    };
-  }
-}
-
-// ==================== 视频解码真实探测 ====================
-
-/** 探测超时：需覆盖 Worker 冷启动 + 内联 MP4Box 脚本解析 + 解码 flush */
-const VIDEO_PROBE_TIMEOUT_MS = 2000;
-/** 通过所需的最少输出帧数：排除"只吐出首帧即挂掉"的假活 */
-const VIDEO_PROBE_MIN_FRAMES = 2;
-/** 探测片帧数（10 帧），解码区间为 [0, VIDEO_PROBE_LAST_FRAME_INDEX] */
-const VIDEO_PROBE_LAST_FRAME_INDEX = 9;
-
-interface IVideoDecodeProbeResult {
-  supported: boolean;
-  reason?: string;
-  /** 实际输出的帧数 */
-  frames: number;
-  /** 探测耗时（毫秒） */
-  duration: number;
-  /** Worker 回报的实际探测 config 中的 codec 字符串 */
-  codec?: string;
-  width?: number;
-  height?: number;
-  detail?: unknown;
-  /** Worker 回报的主配置声明支持情况（Android 主配置为 prefer-software 软解码） */
-  primaryConfig?: { hardwareAcceleration?: string; supported: boolean };
-}
-
-/** base64 解码为 ArrayBuffer（探测片以内联 base64 交付，避免引入网络依赖） */
-function base64ToArrayBuffer(base64: string): ArrayBuffer {
-  const binary = atob(base64);
-  const bytes = new Uint8Array(binary.length);
-  for (let i = 0; i < binary.length; i += 1) {
-    bytes[i] = binary.charCodeAt(i);
-  }
-  return bytes.buffer;
-}
-
-/**
- * 复用 streaming-video 的 Worker 执行一次真实解码
- *
- * 判定以"输出帧数"为主、done 为辅：
- * - worker 在区间内扫不到关键帧时会零帧直接 done，仅判 done 会假通过
- * - worker 内 flush() 的 catch 为空实现，flush 失败表现为"既无 done 也无 error"，靠超时兜底
- */
-function probeVideoDecode(
-  workerURL: string,
-  hardwareAcceleration: string,
-): Promise<IVideoDecodeProbeResult> {
-  return new Promise((resolve) => {
-    let worker: Worker | null = null;
-    let settled = false;
-    let timeout: ReturnType<typeof setTimeout> | null = null;
-    let frames = 0;
-    let codec: string | undefined;
-    let primaryConfig: { hardwareAcceleration?: string; supported: boolean } | undefined;
-    let width: number | undefined;
-    let height: number | undefined;
-    const startAt = Date.now();
-
-    const elapsed = () => Date.now() - startAt;
-
-    const finish = (result: IVideoDecodeProbeResult) => {
-      if (settled) return;
-      settled = true;
-      if (timeout !== null) clearTimeout(timeout);
-      worker?.terminate();
-      resolve({ ...result, primaryConfig });
-    };
-
-    try {
-      worker = new Worker(workerURL);
-    } catch (error) {
-      finish({
-        supported: false,
-        reason: '视频解码探测 Worker 创建失败',
-        frames,
-        duration: elapsed(),
-        detail: error,
-      });
-      return;
-    }
-
-    worker.onerror = (event) => {
-      finish({
-        supported: false,
-        reason: '视频解码探测 Worker 运行时错误',
-        frames,
-        duration: elapsed(),
-        detail: event,
-      });
-    };
-
-    worker.onmessage = (event: MessageEvent) => {
-      const data = event.data ?? {};
-
-      if (data.type === 'frame') {
-        frames += 1;
-        if (width == null || height == null) {
-          width = data.frame?.codedWidth ?? data.frame?.displayWidth;
-          height = data.frame?.codedHeight ?? data.frame?.displayHeight;
-        }
-        // 探测只需判定"能否出帧"，帧数据不参与渲染，必须显式释放
-        data.frame?.close?.();
-        if (frames >= VIDEO_PROBE_MIN_FRAMES) {
-          finish({ supported: true, frames, duration: elapsed(), codec, width, height });
-        }
-        return;
-      }
-
-      if (data.type === 'configSupport') {
-        // 用于回报"实际探测用的 codec 字符串"，便于与探测片期望值比对（保鲜排查）
-        codec = data.configSupport?.config?.codec ?? codec;
-        // 只取首条：Worker 先回报主配置（Android 为 prefer-software），其后才是 defaultConfig 兜底配置
-        if (primaryConfig === undefined) {
-          primaryConfig = {
-            hardwareAcceleration: data.configSupport?.config?.hardwareAcceleration,
-            supported: !!data.configSupport?.configSupport?.supported,
-          };
-        }
-        return;
-      }
-
-      if (data.type === 'error') {
-        finish({
-          supported: false,
-          reason: data.error || '视频解码失败',
-          frames,
-          duration: elapsed(),
-          codec,
-          detail: data,
-        });
-        return;
-      }
-
-      if (data.type === 'done' && frames < VIDEO_PROBE_MIN_FRAMES) {
-        // done 仅作辅助信号：正常情况下帧数达标时已提前返回
-        finish({
-          supported: false,
-          reason: `视频解码未输出足够帧（${frames}/${VIDEO_PROBE_MIN_FRAMES}）`,
-          frames,
-          duration: elapsed(),
-          codec,
-          detail: { done: true },
-        });
-      }
-    };
-
-    let probeData: ArrayBuffer;
-    try {
-      probeData = base64ToArrayBuffer(VIDEO_PROBE_BASE64);
-    } catch (error) {
-      finish({
-        supported: false,
-        reason: '视频解码探测片解析失败',
-        frames,
-        duration: elapsed(),
-        detail: error,
-      });
-      return;
-    }
-
-    worker.postMessage(
-      {
-        type: 'decode',
-        file: { data: probeData },
-        start: 0,
-        end: VIDEO_PROBE_LAST_FRAME_INDEX,
-        hardwareAcceleration,
-      },
-      [probeData],
-    );
-
-    timeout = setTimeout(() => {
-      finish({
-        supported: false,
-        reason: `视频解码探测超时（${VIDEO_PROBE_TIMEOUT_MS}ms）`,
-        frames,
-        duration: elapsed(),
-        codec,
-      });
-    }, VIDEO_PROBE_TIMEOUT_MS);
-  });
-}
-
-/**
- * 异步检查视频解码真实能力（使用内置最小探测片执行一次完整解码）
- *
- * 与 streaming-video.ts 走同一条解码链路（同一 Worker、同一份 avcC description 提取逻辑、
- * 同一套 Android prefer-software 规则），因此探测结论等价于生产结论。
- *
- * severity 策略：
- * - VideoDecoder API 缺失：确定性缺陷，任何平台均 fatal
- * - 解码失败/超时：Android 为 fatal（本次修复的目标平台，故障已确诊）；
- *   其余平台缺乏故障证据且 WebCodecs 实现差异较大，降级 warn，避免误杀可用设备
- *
- * 失败后不做任何重试或换配置兜底：生产在 configure() 成功后遇到 decode() 报错即直接失败，
- * 探测若通过换配置而通过会制造假通过。
- *
- * Android 额外强制软解码：即使真实解码出帧，只要主配置（prefer-software）声明不被支持，
- * 也判定为不支持（硬解/default 兜底不算通过），reason 返回"Android 不支持软解码"。
- */
-async function checkVideoDecodeDetailed(hardwareAcceleration: string): Promise<ICapabilityCheckItem> {
-  const isAndroid = isAndroidPlatform();
-  const acceleration = hardwareAcceleration || 'default';
-
-  if (typeof (window as any).VideoDecoder === 'undefined') {
-    return {
-      name: 'videoDecode',
-      supported: false,
-      severity: 'fatal',
-      reason: '浏览器不支持 WebCodecs VideoDecoder API',
-      detail: { isAndroid, hardwareAcceleration: isAndroid ? 'prefer-software' : acceleration },
-    };
-  }
-
-  const severity: CapabilitySeverity = isAndroid ? 'fatal' : 'warn';
-
-  let workerURL: string;
-  try {
-    // 动态引入：streaming-video 模块加载时会执行 URL.createObjectURL，
-    // 顶层静态引入会让 import 阶段就产生副作用（影响 node 环境单测）
-    workerURL = (await import('../worker/streaming-video')).workerURL;
-  } catch (error) {
-    return {
-      name: 'videoDecode',
-      supported: false,
-      severity,
-      reason: '视频解码探测模块加载失败',
-      detail: { isAndroid, hardwareAcceleration: acceleration, error },
-    };
-  }
-
-  const result = await probeVideoDecode(workerURL, acceleration);
-
-  // Android 强制要求软解码：主配置（prefer-software）声明不支持即判定失败。
-  // 生产 Worker 在 Android 上仍会用 defaultConfig（硬解）兜底，但校验不接受该兜底结果。
-  const primaryConfig = result.primaryConfig;
-  const softwareRejected = isAndroid
-    && primaryConfig !== undefined
-    && (primaryConfig.hardwareAcceleration !== 'prefer-software' || !primaryConfig.supported);
-  const supported = result.supported && !softwareRejected;
-
-  return {
-    name: 'videoDecode',
-    supported,
-    severity,
-    reason: supported
-      ? undefined
-      : softwareRejected
-        ? 'Android 不支持软解码（prefer-software 声明不可用）'
-        : result.reason,
-    detail: {
-      isAndroid,
-      hardwareAcceleration: isAndroid ? 'prefer-software' : acceleration,
-      declaredSoftwareSupported: primaryConfig?.supported,
-      probeCodec: result.codec,
-      outputFrames: result.frames,
-      outputSize: result.width != null && result.height != null
-        ? `${result.width}x${result.height}`
-        : undefined,
-      duration: result.duration,
-      cause: result.detail,
-    },
-  };
-}
-
-/**
- * 异步检查 Worker 实际执行能力
- */
-const WORKER_CHECK_TIMEOUT_MS = 3000;
-const WORKER_CHECK_MAX_ATTEMPTS = 2;
-
-type WorkerProbeResult =
-  | { status: 'supported' }
-  | { status: 'timeout' }
-  | { status: 'failed'; reason: string; detail?: unknown };
-
-function probeWorkerExecution(): Promise<WorkerProbeResult> {
-  return new Promise((resolve) => {
-    let worker: Worker | null = null;
-    let url: string | null = null;
-    let settled = false;
-    let timeout: ReturnType<typeof setTimeout> | null = null;
-
-    const finish = (result: WorkerProbeResult) => {
-      if (settled) return;
-      settled = true;
-      if (timeout !== null) clearTimeout(timeout);
-      worker?.terminate();
-      if (url) URL.revokeObjectURL(url);
-      resolve(result);
-    };
-
-    try {
-      const blob = new Blob(['self.postMessage("ok");'], { type: 'application/javascript' });
-      url = URL.createObjectURL(blob);
-      worker = new Worker(url);
-      worker.onmessage = (event) => {
-        finish(event.data === 'ok'
-          ? { status: 'supported' }
-          : { status: 'failed', reason: 'Web Worker 执行异常' });
-      };
-      worker.onerror = (event) => {
-        finish({ status: 'failed', reason: 'Web Worker 创建失败', detail: event });
-      };
-      timeout = setTimeout(() => {
-        finish({ status: 'timeout' });
-      }, WORKER_CHECK_TIMEOUT_MS);
-    } catch (error) {
-      finish({ status: 'failed', reason: 'Web Worker 异常', detail: error });
-    }
-  });
-}
-
-async function checkWorkerDetailed(): Promise<ICapabilityCheckItem> {
-  if (typeof Worker === 'undefined') {
-    return {
-      name: 'worker',
-      supported: false,
-      severity: 'fatal',
-      reason: '浏览器不支持 Web Worker',
-    };
-  }
-
-  for (let attempt = 1; attempt <= WORKER_CHECK_MAX_ATTEMPTS; attempt += 1) {
-    const result = await probeWorkerExecution();
-    if (result.status === 'supported') {
-      return {
-        name: 'worker',
-        supported: true,
-        severity: 'fatal',
-        detail: { attempts: attempt },
-      };
-    }
-    if (result.status === 'failed') {
-      return {
-        name: 'worker',
-        supported: false,
-        severity: 'fatal',
-        reason: result.reason,
-        detail: result.detail,
-      };
-    }
-  }
-
-  // iOS/WebKit can suspend or delay a Blob Worker while the page is being
-  // inspected, backgrounded, or recovering from a reload. The Worker API is
-  // present and no explicit error was raised, so a timing-only probe must not
-  // reject the entire SDK initialization. Real worker creation still reports
-  // its own fatal error later if the capability is genuinely unavailable.
-  return {
-    name: 'worker',
-    supported: false,
-    severity: 'warn',
-    reason: `Web Worker 创建超时（已重试 ${WORKER_CHECK_MAX_ATTEMPTS} 次）`,
-    detail: { attempts: WORKER_CHECK_MAX_ATTEMPTS },
-  };
-}
-
-/**
- * 异步检查所有浏览器能力（详细版，用于 init 阶段详细探测）
- *
- * 包含真实视频解码探测（videoDecode）和 Worker 执行测试。
- * audioOnlyMode 下跳过画面相关检查（webgl2 / webcodecs / videoDecode）。
- *
- * @param audioOnlyMode 纯音频模式，仅检查安全上下文、音频与 Worker
- * @param hardwareAcceleration 客户传入的解码加速配置，需与生产解码保持一致
- */
-export async function checkCapability(
-  audioOnlyMode = false,
-  hardwareAcceleration = 'default',
-): Promise<ICapabilityCheckReport> {
-  // 先执行同步检查
-  const syncReport = checkCapabilitySync(audioOnlyMode);
-
-  if (audioOnlyMode) {
-    // audioOnlyMode: only detailed check worker
-    const detailedItems = await Promise.all([
-      Promise.resolve(syncReport.items.find(i => i.name === 'secureContext')!),
-      Promise.resolve(syncReport.items.find(i => i.name === 'audio')!),
-      checkWorkerDetailed(),
-    ]);
-
-    const fatalCount = detailedItems.filter(i => i.severity === 'fatal' && !i.supported).length;
-    const warnCount = detailedItems.filter(i => i.severity === 'warn' && !i.supported).length;
-
-    return {
-      supported: fatalCount === 0,
-      fatalCount,
-      warnCount,
-      items: detailedItems,
-    };
-  }
-
-  // 替换 webcodecs / videoDecode / worker 为详细版本
-  const detailedItems = await Promise.all([
-    Promise.resolve(syncReport.items.find(i => i.name === 'secureContext')!),
-    Promise.resolve(syncReport.items.find(i => i.name === 'webgl2')!),
-    Promise.resolve(syncReport.items.find(i => i.name === 'audio')!),
-    checkWebCodecsDetailed(),
-    checkVideoDecodeDetailed(hardwareAcceleration),
-    checkWorkerDetailed(),
-  ]);
-
-  const fatalCount = detailedItems.filter(i => i.severity === 'fatal' && !i.supported).length;
-  const warnCount = detailedItems.filter(i => i.severity === 'warn' && !i.supported).length;
-
-  return {
-    supported: fatalCount === 0,
-    fatalCount,
-    warnCount,
-    items: detailedItems,
-  };
-}