// 典型 WebNN 编程模型
const context = await navigator.ml.createContext({ deviceType: 'gpu' });
const builder = new MLGraphBuilder(context);

// 1. 声明式图构建
const input = builder.input('input', { type: 'float32', dimensions: [1, 3, 256, 256] });
const weight = builder.constant(weightBuffer);
const conv = builder.conv2d(input, weight, { padding: [1,1,1,1], strides: [1,1] });
const relu = builder.relu(conv);
const output = builder.sigmoid(relu);

// 2. 图编译与执行
const graph = await builder.build({ 'output': output });
const results = await graph.compute({ 'input': inputTensor }, { 'output': outputTensor });

┌─────────────────────────────────────────────────────────────────┐
│                    WebNN Unified Acceleration Pipeline          │
├─────────────────────────────────────────────────────────────────┤
│  WebRTC Track → VideoFrame → [Preprocess Graph] → Model Inference │
│       ↑                              │                    │       │
│       │                    ┌─────────┴─────────┐      │       │
│       │                    ▼                   ▼      │       │
│       │            ┌─────────────┐       ┌─────────────┐  │
│       │            │  Shared     │       │  Operator   │  │
│       │            │  Memory     │◄─────►│  Fusion     │  │
│       │            │  Pool       │       │  Engine     │  │
│       │            └─────────────┘       └─────────────┘  │
│       │                    │                   │           │
│       └────────────────────┴───────────────────┴───────────┘
│                            ▼
│                   [Postprocess Graph] → VideoFrame → WebRTC Track
└─────────────────────────────────────────────────────────────────┘

// 前处理图构建：Letterbox + Normalize + NHWC→NCHW + FP16 Cast
function buildPreprocessGraph(builder, inputShape, targetSize, mean, std) {
  const input = builder.input('video_frame', { 
    type: 'float32', 
    dimensions: [1, ...inputShape] // NHWC from VideoFrame
  });
  
  // 1. Letterbox Resize (保持长宽比 + 填充)
  const resized = builder.resize2d(input, {
    sizes: [targetSize.height, targetSize.width],
    mode: 'letterbox',
    fillValue: 114 // YOLO 风格灰填充
  });
  
  // 2. NHWC → NCHW (WebNN 原生 NCHW 布局优化)
  const transposed = builder.transpose(resized, { permutation: [0, 3, 1, 2] });
  
  // 3. Normalize: (x/255 - mean) / std
  const normalized = builder.div(
    builder.sub(
      builder.div(transposed, builder.constant(255.0)),
      builder.constant(mean)
    ),
    builder.constant(std)
  );
  
  // 4. FP16 Cast (节省显存带宽)
  const fp16 = builder.cast(normalized, 'float16');
  
  return builder.build({ 'model_input': fp16 });
}

class ZeroCopyMemoryPool {
  constructor(context, poolSize = 8) {
    this.context = context;
    this.pool = [];
    this.inUse = new Set();
    
    // 预分配 MLBufferResource，绑定 GPU 内存
    for (let i = 0; i < poolSize; i++) {
      this.pool.push(context.createBuffer({
        size: MAX_TENSOR_BYTES,
        usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST
      }));
    }
  }
  
  async acquire(videoFrame) {
    const buffer = this.pool.find(b => !this.inUse.has(b));
    if (!buffer) throw new Error('Pool exhausted');
    
    this.inUse.add(buffer);
    
    // VideoFrame → GPU Buffer 零拷贝（需浏览器支持 WebCodecs + WebNN 互操作）
    await videoFrame.copyTo(buffer, { 
      layout: 'nchw', 
      colorSpace: 'bt709',
      premultiplyAlpha: false 
    });
    
    return this.context.createTensor({ 
      dataType: 'float16', 
      dimensions: [1, 3, videoFrame.displayHeight, videoFrame.displayWidth],
      resource: buffer 
    });
  }
  
  release(tensor) {
    this.inUse.delete(tensor.resource);
  }
}

// WebNN 图构建时自动融合（伪代码展示融合逻辑）
function fuseConvBnRelu(builder, input, convWeight, bnParams, activation = 'relu') {
  const { gamma, beta, mean, var, epsilon } = bnParams;
  
  // 数学推导：BN 参数吸收进 Conv 权重与偏置
  // y = gamma * (x - mean) / sqrt(var + eps) + beta
  //   = (gamma / sqrt(var + eps)) * x + (beta - gamma * mean / sqrt(var + eps))
  const scale = gamma / Math.sqrt(var + epsilon);
  const shift = beta - gamma * mean / Math.sqrt(var + epsilon);
  
  const fusedWeight = convWeight.mul(scale.reshape([-1, 1, 1, 1]));
  const fusedBias = convBias ? convBias.mul(scale).add(shift) : shift;
  
  let conv = builder.conv2d(input, fusedWeight, { 
    bias: fusedBias, 
    padding: [1,1,1,1], 
    strides: [1,1] 
  });
  
  if (activation === 'relu') conv = builder.relu(conv);
  if (activation === 'relu6') conv = builder.clamp(conv, 0, 6);
  
  return conv;
}

// 后处理图：Mask Resize + Blur + Alpha Blend + Color Space Convert
function buildPostprocessGraph(builder, modelOutputShape, targetResolution) {
  const mask = builder.input('seg_mask', { 
    type: 'float16', 
    dimensions: modelOutputShape // [1, 1, H, W]
  });
  const original = builder.input('original_frame', { 
    type: 'float16', 
    dimensions: [1, 3, targetResolution.height, targetResolution.width]
  });
  const background = builder.input('bg_image', { 
    type: 'float16', 
    dimensions: [1, 3, targetResolution.height, targetResolution.width]
  });
  
  // 1. Mask 双线性上采样至目标分辨率
  const upsampled = builder.resize2d(mask, {
    sizes: [targetResolution.height, targetResolution.width],
    mode: 'bilinear'
  });
  
  // 2. 高斯模糊平滑边缘 (3×3 Separable)
  const blurred = builder.conv2d(upsampled, gaussianKernel3x3, { 
    groups: 1, padding: [1,1,1,1] 
  });
  
  // 3. Alpha Blend: out = fg * alpha + bg * (1 - alpha)
  const fg = builder.mul(original, blurred);
  const bg = builder.mul(background, builder.sub(builder.constant(1.0), blurred));
  const blended = builder.add(fg, bg);
  
  // 4. BT.709 → sRGB (WebGL 渲染需要)
  const srgb = builder.clamp(blended, 0, 1); // 简化版，生产用 OETF
  
  return builder.build({ 'output_frame': srgb });
}

class TemporalConsistentSuperResolution {
  constructor(webnnContext) {
    this.context = webnnContext;
    this.prevFrame = null;
    this.opticalFlowGraph = this.buildOpticalFlowGraph();
    this.srGraph = this.buildSRGraph();
  }
  
  async process(currentFrame) {
    // 1. 光流估计 (当前帧 vs 前帧)
    const flow = await this.opticalFlowGraph.compute({
      'frame_t': currentFrame,
      'frame_t-1': this.prevFrame
    });
    
    // 2. 基于光流的特征对齐 (Deformable Conv 思想)
    const alignedFeat = await this.alignFeatures(currentFrame, flow);
    
    // 3. 超分重建
    const srFrame = await this.srGraph.compute({ 'input': alignedFeat });
    
    this.prevFrame = currentFrame;
    return srFrame;
  }
}

class WebNNCapabilityDetector {
  static async detect() {
    const caps = {
      webnn: false,
      webnnDevice: 'cpu',
      webgpu: false,
      wasmSimd: false,
      maxTensorSize: 0
    };
    
    // 1. WebNN 可用性
    if ('ml' in navigator) {
      try {
        const ctx = await navigator.ml.createContext({ deviceType: 'gpu' });
        caps.webnn = true;
        caps.webnnDevice = 'gpu';
        caps.maxTensorSize = await this.estimateMaxTensorSize(ctx);
      } catch {
        try {
          await navigator.ml.createContext({ deviceType: 'cpu' });
          caps.webnn = true;
          caps.webnnDevice = 'cpu';
        } catch { /* WebNN 不可用 */ }
      }
    }
    
    // 2. WebGPU 回退
    if (!caps.webnn && 'gpu' in navigator) {
      caps.webgpu = true;
    }
    
    // 3. WASM SIMD 兜底
    caps.wasmSimd = typeof WebAssembly !== 'undefined' && 
                    WebAssembly.validate(new Uint8Array([0x00, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00]));
    
    return caps;
  }
}

interface IInferenceBackend {
  readonly name: 'webnn' | 'webgpu' | 'wasm';
  loadModel(modelUrl: string): Promise<ModelInstance>;
  infer(inputs: TensorMap): Promise<TensorMap>;
  dispose(): void;
}

class BackendFactory {
  static create(caps: Capability): IInferenceBackend {
    if (caps.webnn) return new WebNNBackend(caps.webnnDevice);
    if (caps.webgpu) return new WebGPUBackend(); // 基于 ONNX Runtime Web / TVM WebGPU
    return new WASMBackend(); // 基于 ONNX Runtime WASM / MediaPipe WASM
  }
}

interface PerfMetrics {
  preprocessMs: number;
  inferenceMs: number;
  postprocessMs: number;
  memoryPeakMB: number;
  backend: string;
  deviceTier: 'high' | 'mid' | 'low';
  modelVersion: string;
}

// 上报策略：采样 10% + 异常全量 + P95/P99 聚合
function reportMetrics(metrics: PerfMetrics) {
  if (Math.random() < 0.1 || metrics.inferenceMs > BUDGET_MS * 1.5) {
    beacon.send('/api/perf/webnn', metrics);
  }
}

// WebNN 原生不支持显式状态张量持久化，需通过 Graph Input/Output 显式建模状态流
function buildStreamingDprnnGraph(builder, chunkSize = 320, hiddenDim = 256) {
  // 1. 定义输入：当前音频帧 + 上一帧隐状态
  const inputFrame = builder.input('audio_frame', { 
    type: 'float32', dimensions: [1, 1, chunkSize] // [B, C, T]
  });
  const hIn = builder.input('lstm_h_in', { type: 'float32', dimensions: [1, hiddenDim] });
  const cIn = builder.input('lstm_c_in', { type: 'float32', dimensions: [1, hiddenDim] });

  // 2. Encoder (Conv1D + ReLU) - 利用 WebNN groups=1 实现深度可分离
  const encWeight = builder.constant(encoderWeight); // [N, C, K]
  const encBias = builder.constant(encoderBias);
  let x = builder.conv1d(inputFrame, encWeight, { bias: encBias, padding: [0,0], strides: [1] });
  x = builder.relu(x); // [B, N, L]

  // 3. Chunk-level RNN (简化为单层 LSTM Cell 循环展开)
  // WebNN 无原生 Loop 算子，需在 JS 层显式展开时间步或使用 Scan 近似 (若标准支持)
  // 工程实践：将单帧内的时间步展开为静态图，或拆分为 Frame-Level Graph + State Buffer
  const { hOut, cOut, mask } = lstmCellFusedGraph(builder, x, hIn, cIn, weights);

  // 4. Decoder (ConvTranspose1D 模拟)
  const decWeight = builder.constant(decoderWeight);
  const enhanced = builder.conv1dTranspose(mask, decWeight, { 
    outputPadding: [0], strides: [1], padding: [0,0] 
  });

  // 5. 图输出：增强音频 + 更新后的隐状态
  return builder.build({ 
    'enhanced_audio': enhanced, 
    'lstm_h_out': hOut, 
    'lstm_c_out': cOut 
  });
}

// LSTM Cell 算子融合实现 (单步)
function lstmCellFusedGraph(builder, x, h, c, w) {
  // x: [B, N, 1] (单步), h/c: [B, H]
  // 权重预融合: W_ih, W_hh -> [4H, N], [4H, H]
  const xProj = builder.matmul(w.W_ih, x.reshape([-1, 1])); // [4H, 1]
  const hProj = builder.matmul(w.W_hh, h.reshape([-1, 1])); // [4H, 1]
  const gates = builder.add(xProj, hProj).add(w.bias);      // [4H, 1]
  
  // 切片分离 i/f/g/o (WebNN split 支持)
  const [i, f, g, o] = builder.split(gates, 4, 0); // 各 [H, 1]
  
  const iSig = builder.sigmoid(i);
  const fSig = builder.sigmoid(f);
  const gTanh = builder.tanh(g);
  const oSig = builder.sigmoid(o);
  
  const cNext = builder.add(builder.mul(fSig, c), builder.mul(iSig, gTanh));
  const hNext = builder.mul(oSig, builder.tanh(cNext));
  
  // Mask 估计头 (简化)
  const mask = builder.sigmoid(builder.matmul(w.W_mask, hNext).add(w.b_mask));
  
  return { hOut: hNext, cOut: cNext, mask: mask.reshape([1, 1, -1]) };
}

┌──────────────────┐     PostMessage (Transferable)      ┌──────────────────┐
│  AudioWorklet    │ ──────────────────────────────────► │  Dedicated Worker │
│  (Real-time     │  AudioData (Float32Array) + State    │  (WebNN Inference)│
│   Thread, 1ms)  │ ◄──────────────────────────────────  │  (Off-main-thread)│
└──────────────────┘  Enhanced Audio + New State         └──────────────────┘
        │                                                    ▲
        │ Web Audio API (ScriptProcessorNode 替代)           │ OffscreenCanvas/MessageChannel
        ▼                                                    │
┌──────────────────┐                                        │
│  Audio Output    │                                        │
│  (Speaker/Track) │                                        │
└──────────────────┘                                        │

// audio-processor.js (运行在 AudioWorkletGlobalScope)
class WebNNAudioProcessor extends AudioWorkletProcessor {
  constructor(options) {
    super();
    this.port = options.processorOptions.port; // MessageChannel 连接 Worker
    this.stateBuffers = { h: new Float32Array(HIDDEN_DIM), c: new Float32Array(HIDDEN_DIM) };
    this.ringBuffer = new RingBuffer(CHUNK_SIZE * 2); // 吸收抖动
    
    this.port.onmessage = (e) => {
      if (e.data.type === 'result') {
        this.ringBuffer.push(e.data.audio); // 写入环形缓冲区
        this.stateBuffers.h.set(e.data.h);
        this.stateBuffers.c.set(e.data.c);
      }
    };
  }

  process(inputs, outputs) {
    const input = inputs[0][0]; // Float32Array [128] @ 48kHz
    const output = outputs[0][0];
    
    // 1. 累积至模型所需帧长 (如 320 采样点 @ 16kHz 需重采样)
    this.resampler.push(input); 
    if (this.resampler.hasFrame()) {
      const frame = this.resampler.popFrame();
      // 2. 零拷贝发送至 Worker (Transferable ArrayBuffer)
      this.port.postMessage({ 
        type: 'infer', 
        audio: frame.buffer, 
        h: this.stateBuffers.h.buffer, 
        c: this.stateBuffers.c.buffer 
      }, [frame.buffer, this.stateBuffers.h.buffer, this.stateBuffers.c.buffer]);
    }
    
    // 3. 从环形缓冲区拉取增强后音频 (欠载静音保护)
    if (this.ringBuffer.length >= output.length) {
      this.ringBuffer.pop(output);
    } else {
      output.fill(0); // 隐藏丢包/延迟
      this.metrics.underruns++;
    }
    return true; // 保持存活
  }
}
registerProcessor('webnn-audio-processor', WebNNAudioProcessor);

// 分辨率桶策略：将任意分辨率映射至最近的「编译桶」
const RESOLUTION_BUCKETS = [
  { w: 256, h: 144 },  // 144p
  { w: 426, h: 240 },  // 240p
  { w: 640, h: 360 },  // 360p
  { w: 960, h: 540 },  // 540p
  { w: 1280, h: 720 }, // 720p
  { w: 1920, h: 1080 } // 1080p
];

function getBucketResolution(targetW, targetH) {
  // 寻找面积最接近且宽高比误差 < 5% 的桶
  return RESOLUTION_BUCKETS.reduce((best, bucket) => {
    const areaDiff = Math.abs(bucket.w * bucket.h - targetW * targetH);
    const ratioDiff = Math.abs(bucket.w / bucket.h - targetW / targetH);
    if (ratioDiff < 0.05 && areaDiff < best.diff) {
      return { diff: areaDiff, bucket };
    }
    return best;
  }, { diff: Infinity, bucket: RESOLUTION_BUCKETS[3] }).bucket;
}

// 前处理图动态插入 Letterbox 至 Bucket 尺寸
function buildDynamicPreprocessGraph(builder, bucketW, bucketH) {
  const input = builder.input('frame', { type: 'float32', dimensions: [1, -1, -1, 3] }); // 动态 H,W
  const resized = builder.resize2d(input, { 
    sizes: [bucketH, bucketW], 
    mode: 'letterbox' 
  });
  // 后续 Norm/Transpose 固定 Shape [1, 3, bucketH, bucketW]
  return builder.build({ 'model_input': normalizeTranspose(resized) });
}

class GraphCompilerCache {
  constructor(context) {
    this.context = context;
    this.cache = new Map(); // Key -> Promise<MLGraph>
    this.compiling = new Set();
  }

  // 缓存键包含：模型哈希 + 设备类型 + 量化策略 + Shape Bucket + 算子融合级别
  getCacheKey(modelHash, bucket, precision, fusionLevel) {
    return `${modelHash}|${this.context.deviceType}|${precision}|${bucket.w}x${bucket.h}|${fusionLevel}`;
  }

  async getOrCompile(key, buildFn) {
    if (this.cache.has(key)) return this.cache.get(key);
    if (this.compiling.has(key)) {
      // 合并同步编译请求，避免并发编译抢占 NPU 驱动锁
      return this.waitForCompile(key);
    }
    
    this.compiling.add(key);
    try {
      const graphPromise = buildFn().then(graph => {
        this.cache.set(key, graph);
        this.persistToIndexedDB(key, graph); // 异步持久化
        return graph;
      });
      this.cache.set(key, graphPromise);
      return await graphPromise;
    } finally {
      this.compiling.delete(key);
    }
  }

  // 启动时预热核心桶 (720p/1080p INT8/FP16)
  async warmupCoreBuckets(modelRegistry) {
    const tasks = [];
    for (const bucket of [RESOLUTION_BUCKETS[3], RESOLUTION_BUCKETS[5]]) {
      for (const precision of ['int8', 'fp16']) {
        tasks.push(this.getOrCompile(
          this.getCacheKey(modelRegistry.seg.hash, bucket, precision, 'full'),
          () => modelRegistry.seg.buildGraph(this.context, bucket, precision)
        ));
      }
    }
    await Promise.all(tasks);
    console.log('[WebNN] Core buckets warmed up.');
  }
}

// WebGPU NMS Kernel (GLSL/WGSL 片段)
const nmsWgsl = `
  @group(0) @binding(0) var<storage, read> boxes: array<vec4<f32>>;
  @group(0) @binding(1) var<storage, read> scores: array<f32>;
  @group(0) @binding(2) var<storage, read_write> selected_indices: array<u32>;
  @group(0) @binding(3) var<storage, read_write> selected_count: atomic<u32>;
  
  @compute @workgroup_size(256)
  fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
    // 并行 NMS 实现 (参考 TensorRT Plugin 思路)
    // 利用共享内存块加载、原子计数器写入结果
  }
`;

class HybridPostProcessor {
  constructor(webnnContext, gpuDevice) {
    this.webnnGraph = webnnContext.buildGraph(...);
    this.nmsPipeline = await gpuDevice.createComputePipelineAsync({ 
      layout: 'auto', 
      compute: { module: gpuDevice.createShaderModule({ code: nmsWgsl }), entryPoint: 'main' } 
    });
    this.bindGroupLayout = this.nmsPipeline.getBindGroupLayout(0);
  }

  async compute(webnnInputTensor) {
    // 1. WebNN 推理主干 (输出 Boxes/Scores Tensor)
    const { boxes, scores } = await this.webnnGraph.compute({ input: webnnInputTensor });
    
    // 2. 零拷贝获取 GPUBuffer (需浏览器支持 MLTensor -> GPUBuffer 导出)
    const boxesBuffer = boxes.resource; // GPUBuffer
    const scoresBuffer = scores.resource;
    
    // 3. 分配结果 Buffer
    const maxDets = 100;
    const indicesBuffer = this.gpuDevice.createBuffer({
      size: maxDets * 4, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC
    });
    const countBuffer = this.gpuDevice.createBuffer({
      size: 4, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC
    });
    
    // 4. 启动 WebGPU NMS
    const bindGroup = this.gpuDevice.createBindGroup({
      layout: this.bindGroupLayout,
      entries: [
        { binding: 0, resource: { buffer: boxesBuffer }},
        { binding: 1, resource: { buffer: scoresBuffer }},
        { binding: 2, resource: { buffer: indicesBuffer }},
        { binding: 3, resource: { buffer: countBuffer }}
      ]
    });
    
    const cmdEncoder = this.gpuDevice.createCommandEncoder();
    const pass = cmdEncoder.beginComputePass();
    pass.setPipeline(this.nmsPipeline);
    pass.setBindGroup(0, bindGroup);
    pass.dispatchWorkgroups(Math.ceil(numBoxes / 256));
    pass.end();
    this.gpuDevice.queue.submit([cmdEncoder.finish()]);
    
    // 5. 读回结果 (异步，不阻塞渲染帧)
    const count = await this.readBufferU32(countBuffer);
    const indices = await this.readBufferU32(indicesBuffer, count);
    return indices.map(i => ({ box: boxesData[i], score: scoresData[i] }));
  }
}

graph LR
    A[模型训练平台] -->|签名| B(模型制品库)
    B -->|分发| C[CDN 边缘节点]
    C -->|下载| D[客户端 WebNN Runtime]
    D -->|验签| E{验证通过?}
    E -- 是 --> F[加载执行]
    E -- 否 --> G[降级/拦截/上报]

// 模型清单文件 manifest.json (由发布流水线生成签名)
{
  "version": "2.4.1",
  "models": {
    "segmentation": {
      "url": "seg_int8.webnn.bin",
      "sha384": "sha384-xxx...",
      "ed25519_sig": "base64_sig...",
      "public_key_id": "prod-key-2024-q3"
    }
  }
}

class SecureModelLoader {
  constructor(trustedPublicKeys) { // 内置或远程配置下发的信任公钥池
    this.keys = trustedPublicKeys;
  }

  async loadAndVerify(manifestUrl) {
    const manifest = await fetch(manifestUrl).then(r => r.json());
    
    for (const [name, meta] of Object.entries(manifest.models)) {
      // 1. SRI 校验 (浏览器原生支持)
      const response = await fetch(meta.url, { integrity: meta.sha384 });
      const arrayBuffer = await response.arrayBuffer();
      
      // 2. Ed25519 签名校验 (防 CDN 劫持/中间人替换同哈希不同内容)
      const pubKey = this.keys[meta.public_key_id];
      if (!pubKey) throw new Error(`Untrusted key: ${meta.public_key_id}`);
      
      const isValid = await crypto.subtle.verify(
        { name: 'Ed25519' },
        await crypto.subtle.importKey('raw', pubKey, { name: 'Ed25519' }, false, ['verify']),
        base64ToArrayBuffer(meta.ed25519_sig),
        arrayBuffer
      );
      
      if (!isValid) {
        await this.reportSecurityEvent('MODEL_SIG_MISMATCH', { name, url: meta.url });
        throw new Error(`Model signature verification failed: ${name}`);
      }
      
      // 3. 结构校验 (防恶意构造图结构攻击 WebNN 编译器)
      this.validateGraphStructure(arrayBuffer);
      
      yield { name, buffer: arrayBuffer };
    }
  }
  
  validateGraphStructure(buffer) {
    // 解析 ONNX/WebNN 图头，校验算子白名单、输入输出维度范围、常量张量数值范围
    // 禁止: DynamicQuantizeLinear (易构造异常输入), 自定义算子域
  }
}

class PrivacyModeManager {
  static async enable() {
    // 1. 销毁 WebNN 资源 (释放 NPU/GPU 显存)
    await WebNNPipeline.getInstance().dispose();
    
    // 2. 切换全局后端为 WASM (纯 CPU, 无硬件指纹风险)
    InferenceBackendRegistry.setGlobalBackend(new WASMBackend({
      modelPath: '/models/privacy/', // 专用轻量化模型
      simd: true,
      threads: navigator.hardwareConcurrency || 4
    }));
    
    // 3. 禁用遥测上报
    Telemetry.disable();
    
    // 4. 清理持久化缓存
    await IndexedDBCache.clear('webnn_graphs');
    await CacheStorage.delete('model_assets');
    
    // 5. 通知 UI 更新状态
    EventBus.emit('privacy_mode_changed', { enabled: true, backend: 'wasm' });
  }
}

# .github/workflows/model-ci.yml
jobs:
  model_ci:
    runs-on: [self-hosted, gpu, linux] # 需真实 NPU/GPU 硬件
    strategy:
      matrix:
        target: [webnn_int8, webnn_fp16, webgpu_fp16, wasm_int8]
        device: [snapdragon8g2, apple_m2, intel_arc, amd_ryzen_7000]
    steps:
      - uses: actions/checkout@v4
      
      - name: Convert ONNX -> WebNN Graph JSON
        run: |
          python tools/convert.py 
            --input models/seg.onnx 
            --output artifacts/seg_${{ matrix.target }}.webnn.json 
            --target ${{ matrix.target }} 
            --calibration-data data/calib_1000.npz 
            --fusion-level aggressive
      
      - name: Numerical Verification (精度回归)
        run: |
          python tools/verify.py 
            --ref-framework onnxruntime 
            --test-framework webnn 
            --model artifacts/seg_${{ matrix.target }}.webnn.json 
            --test-set data/val_500.npz 
            --tolerance "cosine>0.999, max_abs_diff<1e-3" 
            --output reports/precision_${{ matrix.target }}.json
      
      - name: Performance Benchmark (性能基准)
        uses: ./actions/device-benchmark
        with:
          device: ${{ matrix.device }}
          model: artifacts/seg_${{ matrix.target }}.webnn.json
          warmup: 50
          runs: 200
          input-shape: "1,3,720,1280"
          metrics: "p50, p95, p99, peak_mem_mw, power_mw"
      
      - name: Gate Check (质量闸)
        run: |
          python tools/gate.py 
            --precision-report reports/precision_${{ matrix.target }}.json 
            --perf-report reports/perf_${{ matrix.target }}_${{ matrix.device }}.json 
            --criteria config/gates/segmentation.yaml
      
      - name: Upload Artifacts
        uses: actions/upload-artifact@v4
        with:
          name: webnn-models-${{ matrix.target }}-${{ matrix.device }}
          path: artifacts/

# config/gates/segmentation.yaml
precision_gates:
  - metric: "mIoU"
    threshold: 0.82  # 相对 ONNX Runtime FP32 基线下降 < 1.5%
    action: "fail"
  - metric: "cosine_similarity_output"
    threshold: 0.9995
    action: "fail"

performance_gates:
  - device: "snapdragon8g2"
    backend: "webnn_int8"
    p99_latency_ms: 5.0
    peak_memory_mb: 80
    power_mw: 1200
    action: "fail"
  - device: "apple_m2"
    backend: "webnn_fp16"
    p99_latency_ms: 6.5
    action: "warn" # Mac 暂不硬性阻塞

compatibility_gates:
  - test: "webnn_api_surface"
    required: ["createContext", "MLGraphBuilder", "conv2d", "relu", "sigmoid"]
  - test: "memory_leak"
    iterations: 1000
    max_growth_mb: 5

enum TaskPriority {
  CRITICAL = 0,  // 主讲人视频、本地语音降噪 (硬实时)
  HIGH = 1,      // 活跃发言人缩略图
  NORMAL = 2,    // 静默参会人缩略图
  LOW = 3        // 屏幕共享超分、背景虚化预览
}

interface InferenceTask {
  id: string;
  graph: MLGraph;
  inputs: TensorMap;
  priority: TaskPriority;
  deadline: number; // 绝对时间戳
  streamId: string;
  onComplete: (outputs: TensorMap) => void;
}

class PriorityNPUScheduler {
  private queue: InferenceTask[] = [];
  private running: InferenceTask | null = null;
  private context: MLContext;
  private frameBudgetMs: number = 16.6; // 60fps 预算
  
  schedule(task: InferenceTask) {
    // 1. 插入优先队列 (按 deadline 升序, priority 升序)
    this.queue.push(task);
    this.queue.sort((a, b) => a.priority - b.priority || a.deadline - b.deadline);
    
    // 2. 尝试抢占/启动
    this.tryDispatch();
  }

  private async tryDispatch() {
    if (this.running) return; // 简化：单流水线串行，实际可多队列并发
    
    const now = performance.now();
    // 丢弃已过期任务 (如静音用户的降噪帧)
    this.queue = this.queue.filter(t => t.deadline > now + 2); // 留 2ms 余量
    
    const task = this.queue.shift();
    if (!task) return;
    
    this.running = task;
    const start = performance.now();
    
    try {
      const outputs = await task.graph.compute(task.inputs);
      task.onComplete(outputs);
    } catch (e) {
      task.onComplete({ error: e });
    } finally {
      const elapsed = performance.now() - start;
      this.recordMetric(task, elapsed);
      this.running = null;
      
      // 动态调整下一帧预算
      this.adjustBudget(elapsed);
      this.tryDispatch();
    }
  }
  
  private adjustBudget(lastLatency: number) {
    // PID 控制器思路：目标留 30% 空闲给渲染/网络
    const target = this.frameBudgetMs * 0.7;
    this.frameBudgetMs = Math.max(8, Math.min(16, this.frameBudgetMs * 0.9 + target * 0.1));
  }
}

class AdaptiveDegradationController {
  constructor(scheduler, backendRegistry) {
    this.scheduler = scheduler;
    this.backends = backendRegistry;
    this.policy = this.loadPolicy(); // 远程配置下发
  }

  async evaluate() {
    const metrics = await this.collectMetrics(); // NPU利用率、温度、电量、帧耗时分布
    
    for (const rule of this.policy.rules) {
      if (rule.condition(metrics)) {
        await rule.action(this);
        this.reportDegradation(rule.id, metrics);
        break; // 单帧仅执行一级降级，防震荡
      }
    }
  }

  // 示例动作实现
  async downgradeThumbnailResolution(controller, targetRes) {
    // 1. 更新前处理图 Bucket
    PreprocessGraphRegistry.setBucket('thumbnail', targetRes);
    // 2. 通知调度器新任务 deadline 放宽
    controller.scheduler.updateStreamConfig('thumbnail', { 
      intervalMs: 100, // 10fps
      priority: TaskPriority.LOW 
    });
  }

  async switchToWASMBackend(controller) {
    // 热切换：保持模型状态 (如 LSTM 隐状态) 迁移
    const state = await WebNNPipeline.getInstance().exportState();
    await WebNNPipeline.getInstance().dispose();
    await WASMPipeline.getInstance().importState(state);
    InferenceBackendRegistry.setGlobalBackend(WASMPipeline.getInstance());
  }
}

// 基于 W3C TraceContext 标准注入 TraceID
interface FrameTraceContext {
  traceId: string;      // 会话级
  spanId: string;       // 帧级
  parentSpanId: string; // 上一处理阶段
  baggage: {
    streamId: string;
    resolution: string;
    backend: string;
    modelVersion: string;
  };
}

// 在每个处理阶段埋点
async function tracedCompute(graph, inputs, traceCtx) {
  const span = tracer.startSpan('webnn.inference', {
    attributes: {
      'webnn.graph': graph.name,
      'webnn.backend': currentBackend.name,
      'webnn.input_shape': JSON.stringify(getShapes(inputs)),
      ...traceCtx.baggage
    }
  });
  
  try {
    const start = performance.now();
    const outputs = await graph.compute(inputs);
    span.setAttribute('webnn.latency_ms', performance.now() - start);
    span.setAttribute('webnn.output_shape', JSON.stringify(getShapes(outputs)));
    return outputs;
  } catch (e) {
    span.recordException(e);
    span.setStatus({ code: SpanStatusCode.ERROR });
    throw e;
  } finally {
    span.end();
  }
}