┌─────────────────────────────────────┐
│         应用交互层 (React/Vue)       │
├─────────────────────────────────────┤
│       环境感知编排服务 (Orchestrator) │
├──────────┬──────────────┬───────────┤
│ 音频感知  │   视频感知    │  网络感知  │
│ Pipeline │   Pipeline   │  Pipeline  │
├──────────┴──────────────┴───────────┤
│      WebRTC Native API / WebAssembly │
└─────────────────────────────────────┘

// audio-perception-processor.js (AudioWorkletProcessor)
class AudioPerceptionProcessor extends AudioWorkletProcessor {
  constructor() {
    super();
    this.rnnoise = null; // WASM模块实例
    this.reverbBuffer = new Float32Array(48000); // 1s @ 48kHz
    this.frameCount = 0;
  }

  async initialize() {
    const response = await fetch('/models/rnnoise.wasm');
    const bytes = await response.arrayBuffer();
    this.rnnoise = await RNNoiseModule({ wasmBinary: bytes });
  }

  process(inputs, outputs, parameters) {
    const input = inputs[0][0]; // Float32Array[128]
    if (!this.rnnoise) return true;

    // 1. 噪声抑制 + 概率输出
    const vadProb = this.rnnoise.processFrame(input);
    
    // 2. 混响尾时间估计 (简化版 Schroeder 积分法)
    this.updateReverbEstimate(input);

    // 3. 向上抛出特征
    this.port.postMessage({
      type: 'audio_features',
      payload: {
        vadProb,
        snrEst: this.estimateSNR(input),
        rt60: this.currentRT60,
        timestamp: currentTime
      }
    });
    return true;
  }
}
registerProcessor('audio-perception', AudioPerceptionProcessor);

// orchestrator/audio-strategy.js
function computeAudioConstraints(features) {
  const { vadProb, rt60, snrEst } = features;
  let noiseSuppression = 'moderate';
  let targetLevel = -24;

  if (rt60 > 0.6) noiseSuppression = 'high';
  if (snrEst < 5) targetLevel = -21;

  return {
    noiseSuppression,
    autoGainControl: true,
    echoCancellation: true,
    // 非标准扩展，需设备端固件配合
    googTargetLevel: targetLevel,
    googHighpassFilter: rt60 > 0.5
  };
}

// video-perception-worker.js (OffscreenCanvas + Worker)
import { SelfieSegmentation } from '@mediapipe/selfie-segmentation';

const segmentation = new SelfieSegmentation({
  locateFile: (file) => `/models/${file}`
});
segmentation.setOptions({ modelSelection: 1 }); // 通用模型

let canvasCtx, analysisInterval;

self.onmessage = async (e) => {
  if (e.data.type === 'init') {
    const offscreen = e.data.canvas.transferControlToOffscreen();
    canvasCtx = offscreen.getContext('2d');
    await segmentation.initialize();
    startAnalysis(e.data.videoTrack);
  }
};

function startAnalysis(videoTrack) {
  const processor = new MediaStreamTrackProcessor({ track: videoTrack });
  const reader = processor.readable.getReader();

  analysisInterval = setInterval(async () => {
    const { done, value: frame } = await reader.read();
    if (done) return;

    canvasCtx.drawImage(frame, 0, 0, 320, 180);
    const imageData = canvasCtx.getImageData(0, 0, 320, 180);
    
    // 1. 光照均值/方差 (YUV Y分量)
    const luminance = computeLuminanceStats(imageData);
    
    // 2. 人脸区域曝光评估 (结合分割掩码)
    const segmentationMask = await segmentation.send({ image: frame });
    const faceExposure = evaluateFaceExposure(imageData, segmentationMask);

    self.postMessage({
      type: 'video_features',
      payload: {
        globalLux: luminance.mean,
        contrastRatio: luminance.std / (luminance.mean + 1e-6),
        faceExposureScore: faceExposure, // 0-1
        timestamp: performance.now()
      }
    });
    frame.close();
  }, 1000); // 1Hz 分析频率
}

// orchestrator/video-strategy.js
const VIDEO_PROFILES = {
  low_light: { 
    width: 1280, height: 720, frameRate: 15,
    exposureMode: 'manual', exposureTime: 33000, // 33ms
    whiteBalanceMode: 'manual', colorTemperature: 4000
  },
  normal_office: { 
    width: 1920, height: 1080, frameRate: 30,
    exposureMode: 'auto', whiteBalanceMode: 'auto'
  },
  backlight_scene: {
    width: 1920, height: 1080, frameRate: 30,
    exposureMode: 'manual', exposureTime: 16000,
    whiteBalanceMode: 'manual', colorTemperature: 5500,
    // 需摄像头支持 WDR/HDR
    googWideDynamicRange: true
  }
};

async function applyVideoAdaptation(track, features) {
  const { globalLux, faceExposureScore, contrastRatio } = features;
  let profileKey = 'normal_office';

  if (globalLux < 150) profileKey = 'low_light';
  else if (faceExposureScore < 0.3 && contrastRatio > 0.6) profileKey = 'backlight_scene';

  const constraints = VIDEO_PROFILES[profileKey];
  try {
    await track.applyConstraints({ advanced: [constraints] });
    console.log('[VideoAdapt] Applied profile:', profileKey);
  } catch (err) {
    console.warn('[VideoAdapt] Constraint failed, fallback:', err);
    // 降级策略：仅调整分辨率/帧率
    await track.applyConstraints({ 
      width: { ideal: constraints.width },
      frameRate: { ideal: constraints.frameRate }
    });
  }
}

// network-monitor.js
class NetworkMonitor {
  constructor(peerConnection) {
    this.pc = peerConnection;
    this.bandwidthEstimate = 2_000_000; // 初始 2Mbps
    this.intervalId = null;
  }

  start() {
    this.intervalId = setInterval(() => this.collectStats(), 1000);
  }

  async collectStats() {
    const stats = await this.pc.getStats();
    let bytesReceived = 0, packetsLost = 0, jitter = 0;
    let lastTimestamp = 0;

    stats.forEach((report) => {
      if (report.type === 'inbound-rtp' && report.mediaType === 'video') {
        bytesReceived = report.bytesReceived;
        packetsLost = report.packetsLost;
        jitter = report.jitter;
        lastTimestamp = report.timestamp;
      }
    });

    // 简化版 GCC 逻辑：基于到达间延迟梯度估算带宽
    const bitrate = this.calculateBitrate(bytesReceived, lastTimestamp);
    const lossRate = packetsLost / (packetsLost + report.packetsReceived || 1);

    this.bandwidthEstimate = this.updateEstimate(bitrate, lossRate, jitter);
    this.adaptEncoding();
  }

  adaptEncoding() {
    const senders = this.pc.getSenders();
    const videoSender = senders.find(s => s.track?.kind === 'video');
    if (!videoSender) return;

    const params = videoSender.getParameters();
    const targetBitrate = Math.min(this.bandwidthEstimate * 0.9, 4_000_000); // 留 10% 余量
    
    params.encodings[0].maxBitrate = targetBitrate;
    params.encodings[0].scaleResolutionDownBy = targetBitrate < 800_000 ? 2.0 : 1.0;
    
    videoSender.setParameters(params).catch(console.error);
  }
}

stateDiagram-v2
    [*] --> INIT: 设备就绪
    INIT --> CALIBRATING: 首帧采集完成
    CALIBRATING --> STABLE: 连续3轮特征收敛
    STABLE --> ADAPTING: 环境特征漂移 > 阈值
    ADAPTING --> STABLE: 参数生效并验证通过
    STABLE --> DEGRADED: 网络/设备异常
    DEGRADED --> STABLE: 恢复检测通过

// orchestrator/decision-engine.js
class DecisionEngine {
  constructor() {
    this.weights = {
      audioQuality: 0.4,
      videoQuality: 0.3,
      networkStability: 0.3
    };
  }

  decide(audioFeat, videoFeat, netFeat) {
    // 归一化评分 0-1
    const aScore = this.scoreAudio(audioFeat);
    const vScore = this.scoreVideo(videoFeat);
    const nScore = this.scoreNetwork(netFeat);

    const composite = 
      aScore * this.weights.audioQuality +
      vScore * this.weights.videoQuality +
      nScore * this.weights.networkStability;

    // 阈值触发重配置
    if (composite < 0.65) return { action: 'RECONFIGURE', priority: 'HIGH' };
    if (composite < 0.80) return { action: 'FINE_TUNE', priority: 'LOW' };
    return { action: 'MAINTAIN', priority: 'NONE' };
  }
}

// hal/hid-device-manager.ts
interface BeamControlReport {
  reportId: 0x01;
  azimuth: Int16;      // -18000 ~ 18000 (0.01度)
  elevation: Int16;    // -9000 ~ 9000
  mode: BeamMode;      // 0:Auto 1:Fixed 2:SpeakerTrack
}

class MicArrayHAL {
  private device: HIDDevice | null = null;
  private readonly VENDOR_ID = 0x1234;
  private readonly PRODUCT_ID = 0x5678;

  async connect(): Promise<boolean> {
    try {
      const devices = await navigator.hid.requestDevice({
        filters: [{ vendorId: this.VENDOR_ID, productId: this.PRODUCT_ID }]
      });
      this.device = devices[0];
      await this.device.open();
      this.device.addEventListener('inputreport', this.onInputReport);
      return true;
    } catch (e) {
      console.warn('[HAL] HID connect failed, fallback to UAC:', e);
      return false;
    }
  }

  /** 根据 DOA 角度实时调整波束指向 */
  async setBeamDirection(azimuthDeg: number, mode: BeamMode = BeamMode.Auto): Promise<void> {
    if (!this.device?.opened) return;
    
    const report: BeamControlReport = {
      reportId: 0x01,
      azimuth: Math.round(azimuthDeg * 100),
      elevation: 0,
      mode
    };
    await this.device.sendReport(0x01, new Int16Array([report.azimuth, report.elevation, report.mode]).buffer);
  }

  private onInputReport = (event: HIDInputReportEvent) => {
    // 解析设备上报的 VAD 方向、信噪比、温度等遥测数据
    const dv = new DataView(event.data.buffer);
    const doa = dv.getInt16(0, true) / 100;
    this.eventBus.emit('doa-update', { azimuth: doa, timestamp: performance.now() });
  };
}

// hal/camera-ptz-controller.ts
class CameraPTZController {
  private presets: Map<string, PTZPreset> = new Map();
  private currentPreset: string | null = null;

  /** 结合视频感知模块的人脸框坐标，实现平滑跟随 */
  async trackFace(faceBox: DOMRect, videoRes: {w: number, h: number}): Promise<void> {
    const centerX = (faceBox.x + faceBox.width / 2) / videoRes.w;  // 0~1
    const centerY = (faceBox.y + faceBox.height / 2) / videoRes.h;

    // 归一化映射到 PTZ 角度范围 (假设水平 ±170°, 垂直 ±90°)
    const targetPan = (centerX - 0.5) * 340;
    const targetTilt = (0.5 - centerY) * 180;

    // PID 控制器平滑移动，抖动抑制
    const pan = this.panPID.compute(targetPan);
    const tilt = this.tiltPID.compute(targetTilt);

    await this.sendAbsoluteMove(pan, tilt, 1.0); // 速度归一化
  }

  /** 场景切换一键调用预置位 */
  async recallPreset(scene: 'speaker' | 'whiteboard' | 'panorama'): Promise<void> {
    const preset = this.presets.get(scene);
    if (preset) await this.sendPresetRecall(preset.id);
  }
}

flowchart LR
    subgraph Client[客户端浏览器/设备]
        A[原始音视频流] --> B{本地推理 WASM}
        B --> C[环境特征向量<br/>无PII]
        B -.-> D[原始流留存<br/>仅内存/加密缓存]
    end
    
    C --> E[决策引擎]
    E --> F[控制参数下发]
    
    C --> G[遥测上报<br/>聚合统计]
    G --> H[(服务端分析平台)]
    
    style A fill:#ffebee,stroke:#c62828
    style C fill:#e8f5e9,stroke:#2e7d32
    style D fill:#fff3e0,stroke:#ef6c00

// utils/compliance-copy-guard.ts
const FORBIDDEN_PATTERNS = [
  /最(强|好|快|优|低|高)/,
  /零(延迟|丢包|误差)/,
  /完美|彻底|根治|绝对/,
  /全国首(创|家)|全球领先/,
  /100%|百分之百/
];

export function validateMarketingCopy(text: string): {pass: boolean, hits: string[]} {
  const hits = FORBIDDEN_PATTERNS
    .map(reg => text.match(reg)?.[0])
    .filter(Boolean) as string[];
  return { pass: hits.length === 0, hits };
}

// 组件级守卫示例
function FeatureBadge({children}: {children: React.ReactNode}) {
  const text = React.Children.toArray(children).join('');
  const {pass, hits} = validateMarketingCopy(text);
  if (!pass) {
    console.error('[Compliance] 违规营销词:', hits, '原文:', text);
    // 生产环境可降级展示通用文案
    return <span className="badge-compliant">智能环境自适应</span>;
  }
  return <span className="badge">{children}</span>;
}

// permissions/permission-orchestrator.ts
const REQUIRED_PERMISSIONS: PermissionDescriptor[] = [
  { name: 'camera' },
  { name: 'microphone' },
  // 可选：仅在需要硬件控制时请求
  { name: 'hid' }, 
  { name: 'usb' }
];

export async function requestPermissionsGracefully(): Promise<PermissionState[]> {
  const states = await Promise.all(
    REQUIRED_PERMISSIONS.map(p => navigator.permissions.query(p))
  );
  
  const denied = states.filter(s => s.state === 'denied');
  if (denied.length > 0) {
    // 引导用户去浏览器设置页，而非反复弹窗骚扰
    throw new PermissionDeniedError(denied.map(d => d.name));
  }
  return states.map(s => s.state);
}

// __tests__/audio-processor.test.ts
import { RNNoiseProcessor } from '../audio/rnnoise-processor';
import { generateNoise, generateSpeech } from './fixtures/audio-generators';

describe('RNNoiseProcessor', () => {
  let processor: RNNoiseProcessor;

  beforeAll(async () => {
    processor = await RNNoiseProcessor.create('/models/rnnoise.wasm');
  });

  test('稳态噪声抑制 > 15dB', () => {
    const noisy = generateSpeech(0.5).add(generateNoise('babble', 0.3));
    const clean = processor.processFrame(noisy);
    const snrIn = calculateSNR(noisy);
    const snrOut = calculateSNR(clean);
    expect(snrOut - snrIn).toBeGreaterThan(15);
  });

  test('人声不失真 (PESQ > 3.5)', () => {
    const cleanSpeech = generateSpeech(1.0);
    const processed = processor.processFrame(cleanSpeech);
    const pesq = calculatePESQ(cleanSpeech, processed);
    expect(pesq).toBeGreaterThan(3.5);
  });
});

// __tests__/track-pipeline.integration.test.ts
import { createMockMediaStreamTrack } from 'webrtc-testing-utils';
import { AudioPerceptionPipeline } from '../pipeline/audio-perception-pipeline';

test('AudioWorklet 正常挂载并输出特征', async () => {
  const mockTrack = createMockMediaStreamTrack({kind: 'audio', sampleRate: 48000});
  const pipeline = new AudioPerceptionPipeline();
  
  const featuresPromise = new Promise<AudioFeatures>(resolve => {
    pipeline.on('features', resolve);
  });
  
  await pipeline.attach(mockTrack);
  // 注入 2s 测试向量
  mockTrack.injectTestVector(TEST_VECTORS.meeting_room_reverb);
  
  const features = await waitFor(featuresPromise, 3000);
  expect(features.rt60).toBeCloseTo(0.75, 1);
  expect(features.vadProb).toBeGreaterThan(0.8);
});

# .github/workflows/quality-gate.yml
jobs:
  av-quality-gate:
    runs-on: ubuntu-latest
    timeout-minutes: 60
    steps:
      - uses: actions/checkout@v4
      - name: 启动模拟会议室环境
        run: docker-compose -f docker/test-env.yml up -d
      - name: 运行自动化通话 (Playwright + 虚拟音视频设备)
        run: npm run test:e2e:av-quality
      - name: 计算 VMAF/POLQA
        run: |
          python tools/calc_vmaf.py --ref assets/ref_1080p.yuv --dist artifacts/out_1080p.yuv
          python tools/calc_polqa.py --ref assets/ref_speech.wav --dist artifacts/out_speech.wav
      - name: 质量门禁判定
        run: |
          VMAF=$(cat artifacts/vmaf_score.txt)
          if (( $(echo "$VMAF < 90" | bc -l) )); then
            echo "::error::VMAF $VMAF 低于阈值 90"
            exit 1
          fi

# 关键 SLI 定义 (Prometheus 规范命名)
# 1. 可用性
webrtc_session_success_total{result="success"} / webrtc_session_start_total > 0.995

# 2. 延迟 (端到端)
histogram_quantile(0.95, rate(webrtc_e2e_latency_ms_bucket[5m])) < 300

# 3. 音视频质量
avg(webrtc_mos_score) > 4.0
avg(webrtc_vmaf_score) > 90

# 4. 自适应触发频次 (健康度指标)
rate(webrtc_adaptation_trigger_total[5m]) < 0.1  # 过于频繁说明策略抖动

# 5. 资源占用 (客户端上报)
webrtc_cpu_usage_percent{p75} < 30
webrtc_memory_usage_mb{p90} < 300

// tracing/webrtc-tracer.ts
import { trace, context, SpanStatusCode } from '@opentelemetry/api';

const tracer = trace.getTracer('webrtc-meeting-room');

export async function tracePeerConnectionSetup(pc: RTCPeerConnection, sessionId: string) {
  return tracer.startActiveSpan('webrtc.pc.setup', { attributes: { sessionId }}, async (span) => {
    try {
      // 信令交换
      await withChildSpan('signaling.offer', async () => { /* ... */ });
      await withChildSpan('signaling.answer', async () => { /* ... */ });
      
      // ICE 收集与连通性
      await withChildSpan('ice.gathering', async () => { /* ... */ });
      await withChildSpan('ice.connectivity_check', async () => { /* ... */ });
      
      // DTLS 握手
      await withChildSpan('dtls.handshake', async () => { /* ... */ });
      
      // 首帧渲染
      await withChildSpan('render.first_frame', async () => { /* ... */ });
      
      span.setStatus({ code: SpanStatusCode.OK });
    } catch (err) {
      span.recordException(err);
      span.setStatus({ code: SpanStatusCode.ERROR, message: err.message });
      throw err;
    } finally {
      span.end();
    }
  });
}

// monitoring/client-health-reporter.ts
class ClientHealthReporter {
  private metricsBuffer: ClientMetrics[] = [];
  private reportInterval = 30_000; // 30s 上报一次

  start() {
    setInterval(() => this.flush(), this.reportInterval);
    // 页面卸载前强制上报
    window.addEventListener('beforeunload', () => this.flush(true));
  }

  private async flush(beacon = false) {
    if (this.metricsBuffer.length === 0) return;
    const payload = this.aggregateMetrics();
    
    // 使用 sendBeacon 保证卸载时也能发出
    const url = '/api/telemetry/client-health';
    if (beacon && navigator.sendBeacon) {
      navigator.sendBeacon(url, JSON.stringify(payload));
    } else {
      await fetch(url, { method: 'POST', body: JSON.stringify(payload), keepalive: true });
    }
    this.metricsBuffer = [];
  }

  private aggregateMetrics() {
    // 计算 P50/P90/P99，压缩上报体积
    return {
      sessionId: this.sessionId,
      deviceId: getDeviceFingerprint(),
      timestamp: Date.now(),
      cpu: percentile(this.cpuSamples, [50, 90, 99]),
      memory: percentile(this.memSamples, [50, 90, 99]),
      adaptations: this.adaptationCounts, // {audio: 3, video: 1, network: 5}
      errors: this.errorCounts,           // {getUserMedia: 0, applyConstraints: 2}
      quality: {
        mos: this.mosSamples.mean,
        vmaf: this.vmafSamples.mean,
        rtt: this.rttSamples.p50,
        loss: this.lossSamples.p90
      }
    };
  }
}

// config/feature-flags.ts
interface Flags {
  wasmDenoise: boolean;
  aiExposure: boolean;
  hidBeamforming: boolean;
  gccV2: boolean;
}

const defaultFlags: Flags = {
  wasmDenoise: true,
  aiExposure: true,
  hidBeamforming: false, // 依赖硬件，默认关
  gccV2: true
};

export async function loadFlags(): Promise<Flags> {
  try {
    const res = await fetch('/api/config/flags', {cache: 'no-store'});
    const remote = await res.json();
    return {...defaultFlags, ...remote, ...getLocalOverrides()}; // 本地调试覆盖
  } catch {
    return defaultFlags;
  }
}

// 使用示例
const flags = await loadFlags();
if (flags.wasmDenoise) {
  await audioPipeline.enableWASMDenoise();
}

// config/tenant-config-resolver.ts
interface TenantConfig {
  tenantId: string;
  // 品牌定制
  branding: { logo: string; primaryColor: string };
  // 能力裁剪
  capabilities: {
    maxResolution: '720p' | '1080p' | '4K';
    enableRecording: boolean;
    enableLiveStream: boolean;
  };
  // 策略定制
  adaptationPolicy: {
    audioAggressiveness: 'low' | 'medium' | 'high';
    videoPriority: 'resolution' | 'framerate' | 'balanced';
  };
}

export async function resolveTenantConfig(tenantId: string): Promise<TenantConfig> {
  // 1. 缓存优先 (IndexedDB, TTL 1h)
  // 2. 远程拉取 (ETag 协商缓存)
  // 3. 兜底默认配置
  const cached = await idb.get(`tenant:${tenantId}`);
  if (cached && !isStale(cached)) return cached.config;

  const res = await fetch(`/api/tenants/${tenantId}/config`, {
    headers: { 'If-None-Match': cached?.etag }
  });
  
  if (res.status === 304) return cached!.config;
  const config = await res.json();
  await idb.set(`tenant:${tenantId}`, { config, etag: res.headers.get('ETag'), ts: Date.now() });
  return config;
}

meeting-room-av/
├── apps/
│   ├── web-client/          # React/Vue 会议前端
│   ├── device-agent/        # Electron/Tauri 本地 Agent (HID/USB/OTA)
│   └── admin-console/       # 运维后台
├── packages/
│   ├── core/                # 核心逻辑 (编排、策略、状态机) - 纯 TS
│   ├── media-engine/        # 音视频管线 (AudioWorklet, WASM 加载器) - 无 UI 依赖
│   ├── hal/                 # 硬件抽象层 (HID, USB, HTTP Agent 客户端)
│   ├── signaling/           # 信令客户端 (WebSocket, DataChannel)
│   ├── telemetry/           # 监控上报、埋点规范、OpenTelemetry 封装
│   ├── compliance/          # 合规工具 (敏感词扫描、权限守卫、加密工具)
│   ├── test-utils/          # 共享测试工具 (Mock Track, 向量生成器)
│   └── ui-kit/              # 共享 UI 组件 (合规 Badge, 权限引导弹窗)
├── turbo.json
└── package.json

// packages/core/src/types/environment.ts
/** 统一的环境特征向量，跨音视频网络三管线复用 */
export interface EnvironmentFeatureVector {
  timestamp: number;           // 单调递增 ms
  audio: AudioFeatures;
  video: VideoFeatures;
  network: NetworkFeatures;
  device: DeviceContext;       // 设备型号、固件版本、传感器状态
}

/** 策略决策输出，统一下发格式 */
export interface AdaptationCommand {
  target: 'audio' | 'video' | 'network' | 'device';
  action: 'set_constraints' | 'load_profile' | 'send_hid_report' | 'adjust_bitrate';
  payload: Record<string, unknown>;
  priority: 'critical' | 'high' | 'normal' | 'low';
  ttl: number;                 // 生存期 ms，过期自动撤销
  correlationId: string;       // 闭环追踪 ID
}

// packages/media-engine/src/wasm-loader.ts
interface WasmModuleMeta {
  name: string;
  version: string;          // 语义化版本
  sha256: string;           // 完整性校验
  simd: boolean;            // 是否需要 SIMD 支持
  threads: boolean;         // 是否需要 SharedArrayBuffer
}

export class WasmLoader {
  private cache = new Map<string, WebAssembly.Module>();

  async load(meta: WasmModuleMeta): Promise<WebAssembly.Module> {
    const key = `${meta.name}@${meta.version}`;
    if (this.cache.has(key)) return this.cache.get(key)!;

    // 1. 检查浏览器特性支持
    if (meta.simd && !wasmFeatureDetect.simd()) throw new Error('SIMD not supported');
    if (meta.threads && !crossOriginIsolated) throw new Error('COOP/COEP headers missing for threads');

    // 2. 下载并校验
    const response = await fetch(`/models/${meta.name}-${meta.version}.wasm`, {cache: 'immutable'});
    const bytes = await response.arrayBuffer();
    
    // 3. Subresource Integrity 校验
    const hashBuffer = await crypto.subtle.digest('SHA-256', bytes);
    const hashHex = Array.from(new Uint8Array(hashBuffer)).map(b => b.toString(16).padStart(2,'0')).join('');
    if (hashHex !== meta.sha256) throw new Error(`WASM integrity check failed: ${meta.name}`);

    // 4. 编译实例化
    const module = await WebAssembly.compile(bytes);
    this.cache.set(key, module);
    return module;
  }
}