┌─────────────────────────────────────┐
│  Business Channel (业务总线)         │  ← 业务消息：字幕、元数据、信令
│  - 基于 MessagePort / BroadcastChannel
│  - 支持背压、分片、优先级队列
├─────────────────────────────────────┤
│  Control Plane (控制平面)            │  ← 低频控制：窗口管理、原生能力调用
│  - 标准 ipcMain.handle / invoke
│  - 统一超时、重试、熔断、审计日志
├─────────────────────────────────────┤
│  Media Data Plane (媒体数据面)       │  ← 大块二进制：共享内存 / WebCodecs
│  - SharedArrayBuffer + Atomics
│  - Zero-copy 传递给 <video> / WebGL
└─────────────────────────────────────┘

// preload/business-bus.ts
const { MessageChannelMain } = require('electron');
const { v4: uuid } = require('uuid');

class BusinessBus {
  #ports = new Map<string, Electron.MessagePortMain>();
  #seq = 0;

  // 主进程侧：为每个渲染进程建立专属端口
  attach(webContents: Electron.WebContents) {
    const { port1, port2 } = new MessageChannelMain();
    webContents.postMessage('business-port', null, [port2]);
    this.#ports.set(webContents.id, port1);
    port1.on('message', this.#onMessage.bind(this, webContents.id));
  }

  // 统一帧结构：{ id, type, payload, meta: { priority, compress } }
  send(targetId: string, type: string, payload: unknown, meta = {}) {
    const port = this.#ports.get(targetId);
    if (!port) return false;
    port.postMessage({ id: ++this.#seq, type, payload, meta });
    return true;
  }

  // 渲染端同构实现（省略），通过 navigator.serviceWorker 或 window.postMessage 接入
}
module.exports = new BusinessBus();

// main/control-plane.ts
import { ipcMain } from 'electron';
import pLimit from 'p-limit';

const limit = pLimit(8); // 并发限制，防止原生模块线程池耗尽

ipcMain.handle('ctrl:/**', async (event, api, args) => {
  const start = performance.now();
  try {
    return await limit(() => ctrlRegistry[api](args));
  } finally {
    const cost = performance.now() - start;
    if (cost > 100) logger.warn({ api, cost }, 'ctrl slow');
  }
});

// shared/serializer.ts
import * as pb from 'protobufjs';
import { compress, decompress } from '@msgpack/msgpack'; // 复用 msgpackr 的 zstd 封装

const root = await pb.load('proto/meeting.proto');
const SubtitleMsg = root.lookupType('meeting.Subtitle');

export function encodeSubtitle(obj: SubtitleInput): Uint8Array {
  const buf = SubtitleMsg.encode(SubtitleMsg.create(obj)).finish();
  return compress(buf); // zstd level 3，单包 < 1 ms
}

export function decodeSubtitle(data: Uint8Array): SubtitleOutput {
  return SubtitleMsg.toObject(SubtitleMsg.decode(decompress(data)), { longs: String });
}

// main/media-plane.ts
const { SharedArrayBuffer } = require('electron').webFrameMain;

// 1. 主进程创建环形缓冲区（环形避免频繁分配）
const RING_SLOTS = 4;
const SLOT_BYTES = 320 * 180 * 4;
const sab = new SharedArrayBuffer(RING_SLOTS * SLOT_BYTES + 4); // 尾部 4 字节存写指针
const view = new Uint32Array(sab, RING_SLOTS * SLOT_BYTES, 1); // 原子写指针

// 2. 发送端（Native C++ 模块填充像素后）
function pushFrame(ptr: number, size: number) {
  const idx = Atomics.add(view, 0, 1) % RING_SLOTS;
  const dst = new Uint8Array(sab, idx * SLOT_BYTES, size);
  // 假设 native 模块已将数据拷贝到 dst
  Atomics.store(view, 0, idx); // 发布索引
  // 通知渲染端：port.postMessage({ type: 'frame-ready', idx });
}

// 3. 渲染端消费
port.onmessage = (e) => {
  if (e.data.type === 'frame-ready') {
    const idx = e.data.idx;
    const bitmap = new ImageData(
      new Uint8ClampedArray(sab, idx * SLOT_BYTES, SLOT_BYTES),
      320, 180
    );
    offscreenCanvas.transferToImageBitmap(bitmap).then(bmp => {
      // 交给 WebGL / OffscreenCanvas 渲染
    });
  }
};

// main/flow-control.ts
class TokenBucket {
  constructor(private rate: number, private burst: number) {
    this.tokens = burst;
    setInterval(() => { this.tokens = Math.min(this.burst, this.tokens + this.rate / 1000); }, 1);
  }
  private tokens: number;
  take(n = 1): boolean {
    if (this.tokens >= n) { this.tokens -= n; return true; }
    return false;
  }
  async wait(n = 1) {
    while (!this.take(n)) await new Promise(r => setTimeout(r, 1));
  }
}

const buckets = new Map<string, TokenBucket>(); // key: webContentsId

// 业务总线发送前拦截
async function guardedSend(targetId: string, frame: BusinessFrame) {
  const bucket = buckets.get(targetId) ?? new TokenBucket(1000, 2000); // 1k msg/s, burst 2k
  await bucket.wait(frame.meta.priority === 'high' ? 0.5 : 1);
  return businessBus.send(targetId, frame.type, frame.payload, frame.meta);
}

// 渲染端主动上报处理能力（每 500 ms）
ipcMain.on('ctrl:flow-report', (e, { processed, dropped }) => {
  // 动态调整 bucket.rate，实现端到端自适应
});

// main/telemetry.ts
import { metrics } from '@opentelemetry/api';
const meter = metrics.getMeter('electron.ipc');
const latencyHist = meter.createHistogram('ipc_latency_ms');

ipcMain.on('*', (event, ...args) => {
  const start = performance.now();
  event.returnValue = (async () => {
    try { return await originalHandler(...args); }
    finally { latencyHist.record(performance.now() - start, { api: event.channel }); }
  })();
});

// shared/caps.ts
export const caps = {
  messageChannelMain: !!require('electron').MessageChannelMain,
  sharedArrayBuffer: typeof SharedArrayBuffer !== 'undefined' &&
                     typeof Atomics.waitAsync === 'function',
  zstdWasm: true // 构建时注入
};

// preload/secure-bridge.ts
import { contextBridge, ipcRenderer } from 'electron';

// 1. 定义严格 TypeScript 接口，编译期拦截非法调用
interface SecureAPI {
  // 仅允许带超时的单向调用，返回 Promise
  invoke: <T>(channel: `ctrl:${string}`, args: unknown) => Promise<T>;
  // 业务总线仅允许订阅，不允许主动发送（发送走独立 Port）
  onBusiness: (type: string, handler: (payload: unknown) => void) => () => void;
}

// 2. 实现：所有通道名强制前缀校验，参数深度结构化克隆
const api: SecureAPI = {
  invoke: (channel, args) => {
    if (!channel.startsWith('ctrl:')) throw new Error('Invalid channel prefix');
    // 结构化克隆切断原型链，防止原型污染传递
    const safeArgs = structuredClone(args, { transfer: extractTransferables(args) });
    return ipcRenderer.invoke(channel, safeArgs) as Promise<T>;
  },
  onBusiness: (type, handler) => {
    const wrapped = (e: MessageEvent, data: unknown) => {
      if (data?.type === type) handler(structuredClone(data.payload));
    };
    window.addEventListener('message', wrapped);
    return () => window.removeEventListener('message', wrapped);
  }
};

// 3. 冻结暴露对象，防止运行期被篡改
Object.freeze(api);
contextBridge.exposeInMainWorld('secureAPI', api);

// shared/crypto-channel.ts
const ALGO = { name: 'AES-GCM', length: 256 }; // 或 ChaCha20-Poly1305
let sessionKey: CryptoKey;

export async function initCryptoChannel() {
  const keyPair = await crypto.subtle.generateKey({ name: 'ECDH', namedCurve: 'X25519' }, true, ['deriveKey']);
  const publicKey = await crypto.subtle.exportKey('raw', keyPair.publicKey);
  // 通过安全控制平面交换公钥，派生 sessionKey
  sessionKey = await crypto.subtle.deriveKey(
    { name: 'ECDH', public: await crypto.subtle.importKey('raw', peerPublicKey, 'X25519', false, []) },
    keyPair.privateKey,
    ALGO, false, ['encrypt', 'decrypt']
  );
}

export async function encryptFrame(payload: Uint8Array): Promise<Uint8Array> {
  const iv = crypto.getRandomValues(new Uint8Array(12));
  const ct = await crypto.subtle.encrypt({ name: 'AES-GCM', iv }, sessionKey, payload);
  return concatUint8Arrays([iv, new Uint8Array(ct)]);
}

// main/window-registry.ts
interface WindowMeta {
  id: string;           // 业务 ID: 'main', 'share-screen-1', 'float', 'virtual-cam'
  webContentsId: number;
  role: 'master' | 'slave' | 'overlay';
  capabilities: string[]; // ['media-capture', 'screen-record', 'gpu-accelerated']
  port: MessagePortMain;  // 业务总线专属端口
}

class WindowRegistry {
  private map = new Map<string, WindowMeta>();
  private masterId: string | null = null;

  register(meta: WindowMeta) {
    this.map.set(meta.id, meta);
    if (meta.role === 'master') this.masterId = meta.id;
    // 自动建立全互联 MessagePort 网状（N<5 时开销可接受）
    this.#meshConnect(meta);
  }

  // 业务路由：@broadcast / @master / @slave / @id
  route(frame: BusinessFrame) {
    const targets = this.#resolveTargets(frame.meta?.to);
    targets.forEach(t => t.port.postMessage(frame));
  }
}

// main/media-coordinator.ts
class MediaCoordinator {
  private sourceMap = new Map<string, MediaStreamTrack>(); // sourceId -> track
  private subscribers = new Map<string, Set<string>>();    // sourceId -> Set<windowId>

  // 渲染端请求订阅
  async subscribe(windowId: string, sourceId: string, constraints: MediaTrackConstraints) {
    let track = this.sourceMap.get(sourceId);
    if (!track) {
      track = await this.#captureSource(sourceId, constraints); // 调用 desktopCapturer
      this.sourceMap.set(sourceId, track);
    }
    // 克隆 Track 给渲染端（零拷贝，GPU 内存共享）
    const cloned = track.clone();
    const port = registry.getPort(windowId);
    port.postMessage({ type: 'track-ready', sourceId, track: cloned }, [cloned]); // Transferable
    this.subscribers.get(sourceId)?.add(windowId);
  }

  // 统一码率控制：主进程根据网络质量下发统一指令，避免多窗口各自为政
  setEncodingParams(sourceId: string, params: RTCRtpEncodingParameters) {
    const sender = this.#getSender(sourceId);
    sender?.setParameters({ encodings: [params] });
  }
}

┌─────────────┐     ┌──────────────────┐     ┌─────────────┐
│  Renderer   │────▶│  Main (EventLoop) │────▶│  NAPI-RS    │
│  (JS/TS)    │ IPC │  (控制平面/分发)  │ NAPI │  Worker Pool│
└─────────────┘     └──────────────────┘     │  (C++/Rust) │
        ▲                                      │  - AEC      │
        │   Business Bus (MessagePort)         │  - Encoder  │
        └──────────────────────────────────────│  - Crypto   │
           Zero-copy SharedArrayBuffer          └─────────────┘

// native/audio-processor/src/lib.rs
use napi::{threadsafe_function::ThreadsafeFunction, Env, Result};
use napi_derive::napi;

#[napi]
pub struct AudioProcessor {
  // 持有 JS 回调函数的线程安全引用
  on_frame: ThreadsafeFunction<AudioFrame>,
  // 内部工作线程
  worker: std::thread::JoinHandle<()>,
}

#[napi]
impl AudioProcessor {
  #[napi(constructor)]
  pub fn new(env: Env, on_frame: napi::JsFunction) -> Result<Self> {
    // 创建 ThreadsafeFunction，指定并发调用策略
    let tsfn: ThreadsafeFunction<AudioFrame> = env
      .create_threadsafe_function(&on_frame, 0, |ctx| {
        ctx.env.create_object().and_then(|mut obj| {
          obj.set("data", ctx.value.data)?;
          obj.set("timestamp", ctx.value.timestamp)?;
          Ok(vec![obj])
        })
      })?;

    let worker = std::thread::spawn(move || {
      // 核心音频处理循环（C++/Rust 实时线程，无锁环形缓冲区）
      loop {
        let frame = process_audio_frame(); // 耗时 0.5-1ms
        // 非阻塞投递到 JS 事件循环
        tsfn.call(Ok(frame), napi::threadsafe_function::ThreadsafeFunctionCallMode::NonBlocking);
      }
    });

    Ok(Self { on_frame: tsfn, worker })
  }
}

// main/audio-pipeline.ts
import { AudioProcessor } from 'native-audio-processor'; // NAPI-RS 生成的绑定

const processor = new AudioProcessor((frame: AudioFrame) => {
  // 此回调运行在主进程 EventLoop，耗时 < 0.1ms
  // 直接通过 BusinessBus 零拷贝转发给渲染端/编码器
  businessBus.sendToEncoder(frame);
});

// 启动采集流 -> 原生层自动跑起工作线程
await processor.start(captureConfig);

# .github/workflows/proto-compat.yml
name: Protobuf Compatibility Check
on: [pull_request]
jobs:
  buf-breaking:
    runs-on: ubuntu-latest
    steps:
      - uses: bufbuild/buf-action@v1
      - name: Check breaking changes against main branch
        run: buf breaking --against '.git#branch=main' --config buf.yaml

// test/chaos/ipc-chaos.test.ts
import { app, BrowserWindow, ipcMain } from 'electron';
import { ChaosMonkey } from './chaos-monkey';

describe('IPC Chaos Engineering', () => {
  let monkey: ChaosMonkey;
  let win: BrowserWindow;

  beforeEach(async () => {
    win = new BrowserWindow({ webPreferences: { preload: PRELOAD_PATH } });
    await win.loadFile('test/fixtures/renderer.html');
    monkey = new ChaosMonkey(win.webContents);
  });

  it('should survive 200ms main-process lag + 10% packet loss', async () => {
    // 1. 注入主进程 EventLoop 延迟
    monkey.injectMainLoopLag(200); // 通过 setInterval 占用主线程
    // 2. 注入消息丢包（随机 drop postMessage）
    monkey.injectPacketLoss(0.1);
    // 3. 压测：并发 50 个渲染端发送 1000 条消息
    const results = await Promise.all(
      Array(50).fill(0).map(() => stressSend(1000))
    );
    // 4. 断言：无消息丢失（业务层 ACK 机制兜底），P99 延迟 < 200ms
    expect(verifyAckIntegrity(results)).toBe(true);
    expect(calcP99(results)).toBeLessThan(200);
  });

  it('should recover gracefully when renderer crashes', async () => {
    const port = await getBusinessPort(win.webContents.id);
    // 模拟渲染进程崩溃
    win.webContents.destroy();
    // 主进程应在 100ms 内清理端口、释放 SharedArrayBuffer、取消订阅
    await waitForCleanup(100);
    expect(port.isClosed).toBe(true);
    expect(sharedMemoryLeakDetected()).toBe(false);
  });
});

// package.json
"scripts": {
  "bench:ipc": "node bench/ipc-throughput.js --ci-mode",
  "bench:mem": "node bench/memory-leak.js --duration=60s"
}

// main/compat-layer.ts
// 统一入口：自动识别渲染端能力，路由到新/旧处理器
ipcMain.handle('unified:api', async (event, { api, args, __proto_ver }) => {
  const isNewRenderer = __proto_ver >= 2; // 渲染端启动时上报协议版本
  const handler = isNewRenderer ? newCtrlRegistry[api] : legacyCtrlRegistry[api];
  
  if (!handler) throw new Error(`API ${api} not found for ver ${__proto_ver}`);
  
  // 统一参数转换：旧渲染端传 Base64 -> 新处理器期望 Uint8Array
  const normalizedArgs = isNewRenderer ? args : legacyToModern(args);
  return handler(normalizedArgs);
});