Add Chromium-only Blender WebEngine parity work

web/app/src/engine-client/EngineClient.ts

@@ -0,0 +1,121 @@
+import type {
+  EngineCapabilities,
+  EngineRequest,
+  EngineResponse,
+  EngineCommand,
+} from "../../../protocol/engine";
+import type { ErrorReport } from "../../../protocol/error";
+import type { SceneSnapshotIR } from "../../../protocol/scene-ir";
+
+interface PendingRequest {
+  resolve: (response: EngineResponse) => void;
+  reject: (reason: ErrorReport) => void;
+  timer: ReturnType<typeof setTimeout>;
+}
+
+export interface EngineClientOptions {
+  timeoutMs?: number;
+  workerFactory?: () => Worker;
+}
+
+const defaultWorkerFactory = () =>
+  new Worker(new URL("../workers/engine.worker.ts", import.meta.url), { type: "module" });
+
+export class EngineClient {
+  private readonly timeoutMs: number;
+  private readonly workerFactory: () => Worker;
+  private worker: Worker | null = null;
+  private requestCounter = 0;
+  private pending = new Map<string, PendingRequest>();
+  private _revision = 0;
+
+  constructor(options: EngineClientOptions = {}) {
+    this.timeoutMs = options.timeoutMs ?? 10_000;
+    this.workerFactory = options.workerFactory ?? defaultWorkerFactory;
+  }
+
+  get revision(): number {
+    return this._revision;
+  }
+
+  start(): void {
+    if (this.worker) return;
+    const worker = this.workerFactory();
+    worker.onmessage = (event: MessageEvent<EngineResponse>) => this.handleResponse(event.data);
+    worker.onerror = () => this.failPending(this.report("WORKER_TERMINATED", "EngineWorker 发生异常", true));
+    this.worker = worker;
+  }
+
+  async init(protocolVersion = 1): Promise<EngineCapabilities> {
+    const response = await this.request({ type: "init", protocolVersion });
+    if (!response.capabilities) throw this.report("WASM_INIT_FAILED", "EngineWorker 未返回能力信息", false);
+    return response.capabilities;
+  }
+
+  async getSceneSnapshot(): Promise<SceneSnapshotIR> {
+    const response = await this.request({ type: "getSceneSnapshot", sinceRevision: this._revision });
+    if (!response.snapshot) throw this.report("INVALID_ARGUMENT", "EngineWorker 未返回 SceneIR", false);
+    return response.snapshot;
+  }
+
+  async setFrame(frame: number): Promise<void> {
+    await this.request({ type: "setFrame", frame });
+  }
+
+  async setObjectVisibility(objectId: string, visible: boolean): Promise<void> {
+    await this.request({ type: "setObjectVisibility", objectId, visible });
+  }
+
+  restart(): void {
+    this.failPending(this.report("WORKER_TERMINATED", "EngineWorker 已重启", true));
+    this.worker?.terminate();
+    this.worker = null;
+    this._revision = 0;
+    this.start();
+  }
+
+  terminate(): void {
+    this.failPending(this.report("WORKER_TERMINATED", "EngineWorker 已关闭", true));
+    this.worker?.terminate();
+    this.worker = null;
+  }
+
+  private request(command: EngineCommand): Promise<EngineResponse> {
+    this.start();
+    const worker = this.worker;
+    if (!worker) return Promise.reject(this.report("WASM_INIT_FAILED", "无法创建 EngineWorker", false));
+
+    const requestId = `engine-${++this.requestCounter}`;
+    const message: EngineRequest = { requestId, expectedRevision: this._revision, command };
+    return new Promise<EngineResponse>((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(requestId);
+        reject(this.report("WORKER_TERMINATED", `请求超时: ${command.type}`, true));
+      }, this.timeoutMs);
+      this.pending.set(requestId, { resolve, reject, timer });
+      worker.postMessage(message);
+    });
+  }
+
+  private handleResponse(response: EngineResponse): void {
+    const pending = this.pending.get(response.requestId);
+    if (!pending) return;
+    this.pending.delete(response.requestId);
+    clearTimeout(pending.timer);
+    this._revision = response.revision;
+    if (response.ok) pending.resolve(response);
+    else pending.reject(response.reports?.[0] ?? this.report("INVALID_ARGUMENT", "EngineWorker 请求失败", true));
+  }
+
+  private failPending(report: ErrorReport): void {
+    for (const pending of this.pending.values()) {
+      clearTimeout(pending.timer);
+      pending.reject(report);
+    }
+    this.pending.clear();
+  }
+
+  private report(code: ErrorReport["code"], message: string, recoverable: boolean): ErrorReport {
+    return { code, severity: "error", message, recoverable };
+  }
+}