import { expect, test } from "@playwright/test";
import path from "node:path";

const basicBlend = path.resolve(import.meta.dirname, "../../../tests/files/web/basic_scene.blend");
const attributeBlend = path.resolve(import.meta.dirname, "../../../tests/files/web/attribute_scene.blend");
const animationBlend = path.resolve(import.meta.dirname, "../../../tests/files/web/animation_scene.blend");
const riggedBlend = path.resolve(import.meta.dirname, "../../../tests/files/web/rigged_shape_scene.blend");
const nonMeshBlend = path.resolve(import.meta.dirname, "../../../tests/files/web/nonmesh_scene.blend");
const greasePencilBlend = path.resolve(import.meta.dirname, "../../../tests/files/web/modifier_grease_pencil_scene.blend");
const localTexturePng = path.resolve(import.meta.dirname, "../../../tests/golden/W-010/desktop-1440x900.png");
const deformationGolden = path.resolve(import.meta.dirname, "../../../tests/golden/W-079/blender-deformation.json");

interface DepsgraphE2EReport {
  status: string;
  objectCount: number;
  meshObjectCount: number;
  meshes: Array<{
    sourceMeshId: string;
    vertexCount: number;
    triangleCount: number;
    positions: number[];
    indices: number[];
    modifierCount: number;
    modifiers: Array<{
      uuid: string;
      index: number;
      type: string;
      status: "EVALUATED" | "DISABLED" | "BLOCKED";
      showViewport: boolean;
      targetObjectIds?: string[];
      errorCode?: string;
      suggestion?: string;
      dependsOn?: string[];
    }>;
  }>;
}

test("opens the Blender-style editor and initializes workers", async ({ page }) => {
  const externalRequests: string[] = [];
  let appOrigin = "";
  page.on("request", (request) => {
    if (appOrigin && new URL(request.url()).origin !== appOrigin) externalRequests.push(request.url());
  });
  await page.setViewportSize({ width: 1440, height: 900 });
  await page.goto("/");
  appOrigin = new URL(page.url()).origin;

  await expect(page.getByText("Blender Web", { exact: true }).first()).toBeVisible();
  await expect(page.getByRole("button", { name: "Layout" })).toHaveClass(/active/);
  await expect(page.locator(".status-bar")).toContainText("Manifest: verified r1");
  await expect(page.locator(".status-bar")).toContainText("Engine: ready, open a .blend file", { timeout: 20_000 });
  await expect(page.locator(".status-bar")).toContainText(/Storage: (IndexedDB \+ OPFS|IndexedDB)/, { timeout: 20_000 });
  await expect(page.locator("canvas.viewport-canvas")).toBeVisible();
  await page.reload();
  await expect(page.locator(".status-bar")).toContainText(/Storage: (IndexedDB \+ OPFS|IndexedDB)/, { timeout: 20_000 });
  expect(externalRequests).toEqual([]);
});

test("migrates IndexedDB metadata and creates a validated OPFS project layout", async ({ page }) => {
  await page.goto("/");
  const result = await page.evaluate(() => new Promise<{ schemaVersion: number; stores: string[]; projectPath?: string }>((resolve, reject) => {
    const worker = new Worker("/src/workers/storage.worker.ts", { type: "module" });
    const infoId = "storage-info-e2e";
    const projectId = "layout-e2e";
    let info: { schemaVersion: number; stores: string[] } | undefined;
    worker.onmessage = (event: MessageEvent<{ requestId: string; ok: boolean; result?: { schemaVersion: number; stores: string[]; scenePath?: string }; error?: string }>) => {
      if (event.data.requestId === infoId && event.data.ok) {
        info = event.data.result;
        worker.postMessage({ requestId: "storage-project-e2e", command: { type: "ensureProject", projectId } });
        return;
      }
      if (event.data.requestId !== "storage-project-e2e") return;
      worker.terminate();
      if (!event.data.ok || !event.data.result) {
        reject(new Error(event.data.error ?? "storage project layout failed"));
        return;
      }
      if (!info) {
        reject(new Error("storage info response missing"));
        return;
      }
      resolve({ schemaVersion: info.schemaVersion, stores: info.stores, projectPath: event.data.result.scenePath });
    };
    worker.onerror = (event) => { worker.terminate(); reject(new Error(event.message)); };
    worker.postMessage({ requestId: infoId, command: { type: "info" } });
  }));
  expect(result.schemaVersion).toBe(6);
  expect(result.stores).toEqual(expect.arrayContaining(["project", "asset", "snapshot", "operation_log", "operation_quarantine", "setting", "lod_manifest", "simulation_manifest", "migration"]));
  expect(result.projectPath).toBe("projects/layout-e2e/scene.blend");
});

test("atomically persists a verified blend before updating project metadata", async ({ page }) => {
  await page.goto("/");
  const result = await page.evaluate(() => new Promise<{ backend: string; bytes: number; revision: number; persisted: boolean; sha256: string }>((resolve, reject) => {
    const worker = new Worker("/src/workers/storage.worker.ts", { type: "module" });
    const buffer = Uint8Array.from([0x42, 0x4c, 0x45, 0x4e, 0x44]).buffer;
    const requestId = "storage-save-e2e";
    worker.onmessage = (event: MessageEvent<{ requestId: string; ok: boolean; result?: { backend: string; bytes: number; revision: number; persisted: boolean; sha256: string }; error?: string }>) => {
      if (event.data.requestId !== requestId) return;
      worker.terminate();
      if (!event.data.ok || !event.data.result) {
        reject(new Error(event.data.error ?? "storage save failed"));
        return;
      }
      resolve(event.data.result);
    };
    worker.onerror = (event) => { worker.terminate(); reject(new Error(event.message)); };
    worker.postMessage({ requestId, command: { type: "saveProject", projectId: "save-e2e", revision: 7, buffer } }, [buffer]);
  }));
  expect(result.backend).toBe("opfs");
  expect(result.bytes).toBe(5);
  expect(result.revision).toBe(7);
  expect(result.persisted).toBe(true);
  expect(result.sha256).toMatch(/^[a-f0-9]{64}$/);
});

test("recovers verified atomic saves after worker failures at both commit boundaries", async ({ page }) => {
  await page.goto("/");
  const result = await page.evaluate(async () => {
    const { StorageClient } = await import("/src/storage/StorageClient.ts");
    const cases = ["after-stage", "after-scene-commit"] as const;
    const recovered = [];
    for (const [index, faultAt] of cases.entries()) {
      const projectId = `recovery-e2e-${Date.now()}-${index}`;
      const expected = Uint8Array.from([0x42, 0x4c, 0x45, 0x4e, 0x44, index, 10, 20, 30]);
      const firstClient = new StorageClient();
      let fault = "";
      try {
        await firstClient.saveProject(projectId, 40 + index, expected.slice().buffer, faultAt);
      }
      catch (error) {
        fault = error instanceof Error ? error.message : String(error);
      }
      firstClient.terminate();

      const restartedClient = new StorageClient();
      const restored = await restartedClient.readProject(projectId);
      const clean = await restartedClient.recoverProject(projectId);
      restartedClient.terminate();
      recovered.push({
        faultAt,
        fault,
        revision: restored.revision,
        bytes: Array.from(new Uint8Array(restored.buffer)),
        sha256: restored.sha256,
        recovered: restored.recovered,
        cleanStatus: clean.status,
        cleanRecovered: clean.recovered,
      });
    }
    return recovered;
  });
  expect(result).toHaveLength(2);
  for (const [index, item] of result.entries()) {
    expect(item.fault).toContain(`PROJECT_SAVE_FAULT_INJECTED: ${item.faultAt}`);
    expect(item.revision).toBe(40 + index);
    expect(item.bytes).toEqual([0x42, 0x4c, 0x45, 0x4e, 0x44, index, 10, 20, 30]);
    expect(item.sha256).toMatch(/^[a-f0-9]{64}$/);
    expect(item.recovered).toBe(true);
    expect(item.cleanStatus).toBe("clean");
    expect(item.cleanRecovered).toBe(false);
  }
});

test("serializes concurrent saves for one project without journal races", async ({ page }) => {
  await page.goto("/");
  const result = await page.evaluate(async () => {
    const { StorageClient } = await import("/src/storage/StorageClient.ts");
    const client = new StorageClient();
    const projectId = `save-order-e2e-${Date.now()}`;
    await Promise.all([
      client.saveProject(projectId, 8, Uint8Array.from([8, 8, 8]).buffer),
      client.saveProject(projectId, 9, Uint8Array.from([9, 9, 9, 9]).buffer),
    ]);
    const restored = await client.readProject(projectId);
    client.terminate();
    return {
      revision: restored.revision,
      bytes: Array.from(new Uint8Array(restored.buffer)),
      recovered: restored.recovered,
    };
  });
  expect(result).toEqual({ revision: 9, bytes: [9, 9, 9, 9], recovered: false });
});

test("content-addresses assets, deduplicates them, and rediscovers them after worker restart", async ({ page }) => {
  await page.goto("/");
  const result = await page.evaluate(async () => {
    const { StorageClient } = await import("/src/storage/StorageClient.ts");
    const firstClient = new StorageClient();
    const concurrent = await Promise.all([firstClient.info(), firstClient.ensureProject("asset-e2e")]);
    const firstBytes = Uint8Array.from([137, 80, 78, 71, 13, 10, 26, 10, 1, 2, 3, 4]).buffer;
    const first = await firstClient.putAsset("asset-e2e", firstBytes, "image/png", "//textures/checker.png");
    const second = await firstClient.putAsset("asset-e2e", Uint8Array.from([137, 80, 78, 71, 13, 10, 26, 10, 1, 2, 3, 4]).buffer, "image/png", "textures/checker.png");
    firstClient.terminate();

    const secondClient = new StorageClient();
    const listed = await secondClient.listAssets("asset-e2e");
    const restored = await secondClient.readAsset("asset-e2e", first.sha256);
    let traversalError = "";
    try {
      await secondClient.putAsset("asset-e2e", Uint8Array.from([1]).buffer, "image/png", "../escape.png");
    }
    catch (error) {
      traversalError = error instanceof Error ? error.message : String(error);
    }
    secondClient.terminate();
    return {
      concurrent: concurrent.length,
      sha256: first.sha256,
      firstDeduplicated: first.deduplicated,
      secondDeduplicated: second.deduplicated,
      path: first.path,
      sourcePath: first.sourcePath,
      listed: listed.assets.length,
      listedHash: listed.assets[0]?.sha256,
      restored: Array.from(new Uint8Array(restored.data)),
      traversalError,
    };
  });
  expect(result.concurrent).toBe(2);
  expect(result.sha256).toMatch(/^[a-f0-9]{64}$/);
  expect(result.firstDeduplicated).toBe(false);
  expect(result.secondDeduplicated).toBe(true);
  expect(result.path).toMatch(/projects\/asset-e2e\/assets\/sha256\/[a-f0-9]{2}\/[a-f0-9]{64}$/);
  expect(result.sourcePath).toBe("textures/checker.png");
  expect(result.listed).toBe(1);
  expect(result.listedHash).toBe(result.sha256);
  expect(result.restored).toEqual([137, 80, 78, 71, 13, 10, 26, 10, 1, 2, 3, 4]);
  expect(result.traversalError).toContain("ASSET_PATH_OUTSIDE_PROJECT");
});

test("viewport accepts orbit input without rebuilding the shell", async ({ page }) => {
  await page.setViewportSize({ width: 1440, height: 900 });
  await page.goto("/");
  const canvas = page.locator("canvas.viewport-canvas");
  await expect(canvas).toBeVisible();
  const box = await canvas.boundingBox();
  expect(box).not.toBeNull();
  if (!box) return;
  await page.mouse.move(box.x + box.width / 2, box.y + box.height / 2);
  await page.mouse.down();
  await page.mouse.move(box.x + box.width / 2 + 80, box.y + box.height / 2 + 20);
  await page.mouse.up();
  await page.setInputFiles("[data-testid=blend-file-input]", basicBlend);
  await expect(page.getByText("BasicCube", { exact: true })).toBeVisible();
  await expect(page.locator("[data-testid=scene-stats]")).toContainText("Objects 3 · Vertices 8 · Faces 6");
});

test("opens a local .blend into SceneIR and Three.js", async ({ page }) => {
  await page.goto("/");
  await page.setInputFiles("[data-testid=blend-file-input]", basicBlend);
  await expect(page.getByText("BasicCube", { exact: true })).toBeVisible();
  await expect(page.getByText("BasicCamera", { exact: true })).toBeVisible();
  await expect(page.getByText("BasicArea", { exact: true })).toBeVisible();
  await expect(page.locator("[data-testid=engine-status]")).toContainText("SceneIR r1 (3 objects)");
  await expect(page.locator("[data-testid=scene-stats]")).toContainText("Objects 3 · Vertices 8 · Faces 6");
  const renderedPixels = await page.locator("canvas.viewport-canvas").evaluate((canvas) => {
    const gl = canvas.getContext("webgl2") ?? canvas.getContext("webgl");
    if (!gl) return 0;
    const pixels = new Uint8Array(4 * 16 * 16);
    gl.readPixels(Math.max(0, (gl.drawingBufferWidth - 16) / 2), Math.max(0, (gl.drawingBufferHeight - 16) / 2), 16, 16, gl.RGBA, gl.UNSIGNED_BYTE, pixels);
    let changed = 0;
    for (let index = 0; index < pixels.length; index += 4) {
      if (pixels[index] > 50 || pixels[index + 1] > 50 || pixels[index + 2] > 50) changed++;
    }
    return changed;
  });
  expect(renderedPixels).toBeGreaterThan(0);
});

test("reads bounded non-mesh data blocks and previews supported geometry", async ({ page }, testInfo) => {
  await page.setViewportSize({ width: 1440, height: 900 });
  await page.goto("/");
  await page.setInputFiles("[data-testid=blend-file-input]", nonMeshBlend);
  await expect(page.getByText("WebCurveObject", { exact: true })).toBeVisible({ timeout: 20_000 });
  await expect(page.getByText("WebMetaballObject", { exact: true })).toBeVisible();
  await expect(page.getByText("WebVolumeObject", { exact: true })).toBeVisible();
  const canvas = page.locator("canvas.viewport-canvas");
  await expect(canvas).toHaveAttribute("data-non-mesh-count", "6");
  await expect(canvas).toHaveAttribute("data-non-mesh-blocked-count", "2");
  const renderedPixels = await canvas.evaluate((element) => {
    const gl = element.getContext("webgl2") ?? element.getContext("webgl");
    if (!gl) return 0;
    const pixels = new Uint8Array(4 * 16 * 16);
    gl.readPixels(Math.max(0, (gl.drawingBufferWidth - 16) / 2), Math.max(0, (gl.drawingBufferHeight - 16) / 2), 16, 16, gl.RGBA, gl.UNSIGNED_BYTE, pixels);
    let changed = 0;
    for (let index = 0; index < pixels.length; index += 4) {
      if (pixels[index] > 50 || pixels[index + 1] > 50 || pixels[index + 2] > 50) changed++;
    }
    return changed;
  });
  expect(renderedPixels).toBeGreaterThan(0);
  await page.screenshot({ path: testInfo.outputPath("nonmesh-desktop-1440x900.png"), fullPage: true });
  await page.setViewportSize({ width: 390, height: 844 });
  await expect(canvas).toBeVisible();
  expect(await page.evaluate(() => document.documentElement.scrollWidth)).toBe(390);
  const bounds = await canvas.boundingBox();
  expect(bounds?.width ?? 0).toBeGreaterThan(100);
  expect(bounds?.height ?? 0).toBeGreaterThan(100);
  const mobilePixels = await canvas.evaluate((element) => {
    const gl = element.getContext("webgl2") ?? element.getContext("webgl");
    if (!gl) return 0;
    const pixels = new Uint8Array(4 * 16 * 16);
    gl.readPixels(Math.max(0, (gl.drawingBufferWidth - 16) / 2), Math.max(0, (gl.drawingBufferHeight - 16) / 2), 16, 16, gl.RGBA, gl.UNSIGNED_BYTE, pixels);
    let changed = 0;
    for (let index = 0; index < pixels.length; index += 4) {
      if (pixels[index] > 50 || pixels[index + 1] > 50 || pixels[index + 2] > 50) changed++;
    }
    return changed;
  });
  expect(mobilePixels).toBeGreaterThan(0);
  await page.screenshot({ path: testInfo.outputPath("nonmesh-mobile-390x844.png"), fullPage: true });
});

test("reports structured N-015 gates for previewable and resource-backed data", async ({ page }) => {
  await page.goto("/");
  const bytes = await import("node:fs").then((fs) => fs.readFileSync(nonMeshBlend));
  const report = await page.evaluate((input) => new Promise<{ gates: Array<{ id: string; taskId: string; status: string; code?: string }>; metaball: { position: number[]; scale: number[] }; binaryDataIds: string[]; hairType: string }>((resolve, reject) => {
    type Response = { kind: string; requestId: string; ok?: boolean; result?: { snapshot?: { nonMeshData?: Array<{ id: string; type?: string; elements?: Array<{ position: number[]; scale: number[] }> }> }; nonMeshGeometryBuffers?: Array<{ dataId: string; pointCount: number }>; capabilityGate?: { taskId: string; status: string; issues: Array<{ code: string }> } }; error?: { message?: string } };
    const worker = new Worker("/src/workers/web-engine.worker.ts", { type: "module" });
    const ids = ["curve:WebCurveData", "volume:WebVolumeData"];
    const results: Array<{ id: string; taskId: string; status: string; code?: string }> = [];
    let metaball: { position: number[]; scale: number[] } | undefined;
    let binaryDataIds: string[] = [];
    let hairType = "";
    worker.onmessage = (event: MessageEvent<Response>) => {
      if (event.data.kind !== "result") return;
      if (event.data.requestId === "nonmesh-open") {
        if (!event.data.ok) {
          worker.terminate();
          reject(new Error(event.data.error?.message ?? "non-mesh fixture open failed"));
          return;
        }
        const data = event.data.result?.snapshot?.nonMeshData?.find((candidate) => candidate.id === "metaball:WebMetaballData");
        const element = data?.elements?.[0];
        if (!element) {
          worker.terminate();
          reject(new Error("metaball metadata missing"));
          return;
        }
        metaball = element;
        binaryDataIds = [...new Set((event.data.result?.nonMeshGeometryBuffers ?? []).map((chunk) => chunk.dataId))].sort();
        hairType = event.data.result?.snapshot?.nonMeshData?.find((candidate) => candidate.id === "curves:WebHairData")?.type ?? "";
        ids.forEach((dataId, index) => worker.postMessage({ requestId: `nonmesh-gate-${index}`, command: { type: "queryNonMeshCapability", dataId } }));
        return;
      }
      const index = Number(event.data.requestId.replace("nonmesh-gate-", ""));
      const gate = event.data.result?.capabilityGate;
      if (!event.data.ok || !gate || !Number.isSafeInteger(index)) return;
      results.push({ id: ids[index], taskId: gate.taskId, status: gate.status, code: gate.issues[0]?.code });
      if (results.length === ids.length) {
        worker.terminate();
        if (!metaball) {
          reject(new Error("metaball metadata missing after gate queries"));
          return;
        }
        resolve({ gates: results.sort((left, right) => left.id.localeCompare(right.id)), metaball, binaryDataIds, hairType });
      }
    };
    worker.onerror = (event) => { worker.terminate(); reject(new Error(event.message)); };
    const buffer = input.buffer.slice(input.byteOffset, input.byteOffset + input.byteLength);
    worker.postMessage({ requestId: "nonmesh-open", command: { type: "openBlend", buffer } }, [buffer]);
  }), new Uint8Array(bytes));
  expect(report.gates).toEqual([
    { id: "curve:WebCurveData", taskId: "N-015", status: "READY", code: undefined },
    { id: "volume:WebVolumeData", taskId: "N-015", status: "BLOCKED", code: "NON_MESH_RESOURCE_MISSING" },
  ]);
  expect(report.binaryDataIds).toEqual(["curve:WebCurveData", "curve:WebSurfaceData", "curves:WebCurvesData", "curves:WebHairData", "pointcloud:WebPointCloudData"]);
  expect(report.hairType).toBe("HAIR");
  expect(report.metaball.position[0]).toBeCloseTo(-0.65, 5);
  expect(report.metaball.position[1]).toBeCloseTo(0, 5);
  expect(report.metaball.position[2]).toBeCloseTo(0.4, 5);
  expect(report.metaball.scale).toEqual([1, 1, 1]);
});

test("enforces the N-015 one-million-point binary transfer gate", async ({ page }) => {
  await page.goto("/");
  const gate = await page.evaluate(() => new Promise<{ status: string; metrics: { pointCount: number; chunkCount: number; transferredBytes: number; elapsedMs: number; peakBytes: number } }>((resolve, reject) => {
    const worker = new Worker("/src/workers/nonmesh-binary-test.worker.ts", { type: "module" });
    worker.onmessage = (event) => { worker.terminate(); resolve(event.data); };
    worker.onerror = (event) => { worker.terminate(); reject(new Error(event.message)); };
    worker.postMessage({ pointCount: 1_000_000 });
  }));
  expect(gate.status).toBe("READY");
  expect(gate.metrics.pointCount).toBe(1_000_000);
  expect(gate.metrics.chunkCount).toBe(16);
  expect(gate.metrics.transferredBytes).toBeGreaterThan(16 * 65_536 * 12);
  expect(gate.metrics.peakBytes).toBeLessThan(512 * 1024 * 1024);
});

test("rejects malformed N-015 binary chunks, integer overflow and budget overflow", async ({ page }) => {
  await page.goto("/");
  const result = await page.evaluate(() => new Promise<{ hash: string; length: string; integerOverflow: string; invalidAttributes: string; attributeOverflow: string; negativeOffset: string; missingAttribute: string; duplicateId: string; hundredThousandBudget: string; pointBudget: string }>((resolve, reject) => {
    const worker = new Worker("/src/workers/nonmesh-binary-malformed-test.worker.ts", { type: "module" });
    worker.onmessage = (event) => { worker.terminate(); if (event.data.error) reject(new Error(event.data.error)); else resolve(event.data); };
    worker.onerror = (event) => { worker.terminate(); reject(new Error(event.message)); };
    worker.postMessage({});
  }));
  expect(result.hash).toContain("NON_MESH_BINARY_INVALID");
  expect(result.length).toContain("NON_MESH_BINARY_INVALID");
  expect(result.integerOverflow).toContain("NON_MESH_BINARY_INVALID");
  expect(result.invalidAttributes).toContain("NON_MESH_BINARY_INVALID");
  expect(result.attributeOverflow).toContain("NON_MESH_BINARY_INVALID");
  expect(result.missingAttribute).toContain("NON_MESH_BINARY_INVALID");
  expect(result.negativeOffset).toContain("NON_MESH_BINARY_INVALID");
  expect(result.duplicateId).toContain("NON_MESH_BINARY_INVALID");
  expect(result.hundredThousandBudget).toContain("NON_MESH_BINARY_INVALID");
  expect(result.pointBudget).toContain("NON_MESH_BINARY_INVALID");
});

test("enforces the N-016 Grease Pencil layer/frame/drawing/stroke/point schema budget", async ({ page }) => {
  await page.goto("/");
  const result = await page.evaluate(() => new Promise<{ validStatus: string; malformed: string; budget: string }>((resolve, reject) => {
    const worker = new Worker("/src/workers/grease-pencil-schema-test.worker.ts", { type: "module" });
    worker.onmessage = (event: MessageEvent<{ validStatus: string; malformed: string; budget: string }>) => {
      worker.terminate();
      resolve(event.data);
    };
    worker.onerror = (event) => { worker.terminate(); reject(new Error(event.message)); };
    worker.postMessage({});
  }));
  expect(result.validStatus).toBe("available");
  expect(result.malformed).toContain("GREASE_PENCIL_SCHEMA_INVALID");
  expect(result.budget).toBe("accepted-blocked-budget");
});

test("renders a bounded previous/next N-016 Grease Pencil onion-skin preview", async ({ page }) => {
  await page.goto("/");
  const result = await page.evaluate(async () => {
    const { createGreasePencilObject } = await import("/src/three-adapter/grease-pencil.ts");
    const point = (x: number) => ({ position: [x, 0, 0] as [number, number, number], radius: 0.1, opacity: 1, vertexColor: [0.2, 0.4, 0.8, 1] as [number, number, number, number] });
    const drawing = (id: string, x: number) => ({ id, strokeCount: 1, pointCount: 2, strokes: [{ cyclic: false, pointCount: 2, materialIndex: 0, points: [point(x), point(x + 1)] }] });
    const object = createGreasePencilObject({
      id: "grease-pencil:onion",
      name: "Onion",
      geometryStatus: "available",
      layerCount: 1,
      frameCount: 3,
      strokeCount: 3,
      pointCount: 6,
      layers: [{ id: "layer:1", name: "Lines", visible: true, locked: false, opacity: 1, onionSkinning: true, frames: [
        { frame: 1, drawing: drawing("drawing:1", -2) },
        { frame: 5, drawing: drawing("drawing:5", 0) },
        { frame: 9, drawing: drawing("drawing:9", 2) },
      ] }],
    }, 5);
    if (!object) return null;
    return {
      onion: object.userData.greasePencilOnionStrokeCount,
      current: object.userData.greasePencilCurrentStrokeCount,
      kinds: object.children.map((child) => child.userData.greasePencilOnion),
      opacities: object.children.map((child) => "material" in child && !Array.isArray(child.material) ? (child.material as { opacity?: number }).opacity : undefined),
    };
  });
  expect(result).toEqual({ onion: 2, current: 1, kinds: ["PREVIOUS", "NONE", "NEXT"], opacities: [0.28, 1, 0.28] });
});

for (const offscreen of [false, true]) {
  test(`renders the N-016 Grease Pencil current-frame strokes in ${offscreen ? "OffscreenCanvas" : "main-thread"} Chromium`, async ({ page }) => {
    await page.goto(offscreen ? "/?offscreen=1" : "/");
    await page.setInputFiles("[data-testid=blend-file-input]", greasePencilBlend);
    await expect(page.getByText("GreasePencilObject", { exact: true })).toBeVisible({ timeout: 20_000 });
    const canvas = page.locator("canvas.viewport-canvas");
    await expect(canvas).toHaveAttribute("data-renderer-backend", offscreen ? "offscreen-worker" : "webgl-pbr");
    await expect(canvas).toHaveAttribute("data-grease-pencil-count", "1", { timeout: 20_000 });
    await expect(canvas).toHaveAttribute("data-grease-pencil-blocked-count", "0");
    if (offscreen) {
      await expect.poll(async () => Number(await canvas.getAttribute("data-renderer-pixels") ?? "0"), { timeout: 20_000 }).toBeGreaterThan(0);
    }
    else {
      const renderedPixels = await canvas.evaluate((element) => {
        const gl = element.getContext("webgl2") ?? element.getContext("webgl");
        if (!gl) return 0;
        const pixels = new Uint8Array(4 * 16 * 16);
        gl.readPixels(Math.max(0, (gl.drawingBufferWidth - 16) / 2), Math.max(0, (gl.drawingBufferHeight - 16) / 2), 16, 16, gl.RGBA, gl.UNSIGNED_BYTE, pixels);
        return pixels.reduce((count, value) => count + (value > 0 ? 1 : 0), 0);
      });
      expect(renderedPixels).toBeGreaterThan(0);
    }
    expect(await canvas.getAttribute("data-renderer-error")).toBeNull();
  });
}

test("enforces the N-017 paint stroke, PBVH/UV hit and brush budgets", async ({ page }) => {
  await page.goto("/");
  const result = await page.evaluate(() => new Promise<Record<string, string>>((resolve, reject) => {
    const worker = new Worker("/src/workers/paint-schema-test.worker.ts", { type: "module" });
    worker.onmessage = (event: MessageEvent<Record<string, string>>) => { worker.terminate(); resolve(event.data); };
    worker.onerror = (event) => { worker.terminate(); reject(new Error(event.message)); };
    worker.postMessage({});
  }));
  expect(result.valid).toBe("VERTEX_COLOR");
  expect(result.weight).toBe("Group");
  expect(result.hit).toContain("PAINT_SCHEMA_INVALID");
  expect(result.budget).toContain("PAINT_BUDGET_EXCEEDED");
});

test("derives an N-017 source-face, barycentric and UV paint hit from a real raycast", async ({ page }) => {
  await page.goto("/");
  const result = await page.evaluate(async () => {
    const three = await import("/src/vendor/three/three.module.js");
    const { paintHitFromIntersection } = await import("/src/three-adapter/paint-hit.ts");
    const geometry = new three.BufferGeometry();
    geometry.setAttribute("position", new three.Float32BufferAttribute([0, 0, 0, 1, 0, 0, 0, 1, 0], 3));
    geometry.setAttribute("uv", new three.Float32BufferAttribute([0, 0, 1, 0, 0, 1], 2));
    geometry.setIndex([0, 1, 2]);
    const mesh = new three.Mesh(geometry, new three.MeshBasicMaterial());
    mesh.userData.blenderId = "object:paint";
    mesh.userData.meshId = "mesh:paint";
    mesh.userData.triangleFaceIndices = [17];
    mesh.updateMatrixWorld(true);
    const raycaster = new three.Raycaster(new three.Vector3(0.25, 0.25, 1), new three.Vector3(0, 0, -1));
    const intersection = raycaster.intersectObject(mesh)[0];
    return intersection ? paintHitFromIntersection(intersection, 0.75) : null;
  });
  expect(result?.objectId).toBe("object:paint");
  expect(result?.dataId).toBe("mesh:paint");
  expect(result?.faceIndex).toBe(17);
  expect(result?.pressure).toBe(0.75);
  expect(result?.barycentric).toEqual(expect.arrayContaining([0.5, 0.25, 0.25]));
  expect(result?.uv).toEqual([0.25, 0.25]);
  expect(result?.normal).toEqual([0, 0, 1]);
});

test("validates the N-018 physics capability and cache manifests without claiming solvers", async ({ page }) => {
  await page.goto("/");
  const result = await page.evaluate(() => new Promise<Record<string, unknown>>((resolve, reject) => {
    const worker = new Worker("/src/workers/physics-simulation-test.worker.ts", { type: "module" });
    worker.onmessage = (event: MessageEvent<Record<string, unknown>>) => { worker.terminate(); resolve(event.data); };
    worker.onerror = (event) => { worker.terminate(); reject(new Error(event.message)); };
    worker.postMessage({});
  }));
  expect(result.valid).toBe("CLOTH:2");
  expect(result.familyCount).toBe(7);
  expect(result.families).toEqual(["RIGID_BODY", "SOFT_BODY", "CLOTH", "FLUID", "DYNAMIC_PAINT", "PARTICLE", "HAIR"]);
  expect(result.inventoryBlocked).toBe(true);
  expect(result.cycle).toContain("PHYSICS_DEPENDENCY_CYCLE");
  expect(result.budget).toContain("PHYSICS_BUDGET_EXCEEDED");
  expect(result.missingFrame).toContain("PHYSICS_CACHE_FRAME_MISMATCH");
  expect(result.solver).toBe("PHYSICS_SOLVER_UNAVAILABLE");
  expect(result.manifest).toBe("READY");
});

test("maps N-019 Scene exposure and light shadow metadata without using legacy World exposure", async ({ page }) => {
  await page.goto("/");
  await page.setInputFiles("[data-testid=blend-file-input]", basicBlend);
  await expect(page.getByText("BasicCube", { exact: true })).toBeVisible();
  const canvas = page.locator("canvas.viewport-canvas");
  await expect(canvas).toHaveAttribute("data-view-transform", "AgX");
  await expect(canvas).toHaveAttribute("data-view-look", "None");
  await expect(canvas).toHaveAttribute("data-mist", "disabled");
  const mapping = await page.evaluate(async () => {
    const { blenderLightIntensity, configurePBRLight, createPBRLight } = await import("/src/three-adapter/pbr.ts");
    const { Object3D } = await import("/src/vendor/three/three.module.js");
    const definition = {
      id: "light:test", name: "Test", lightType: 0, color: [1, 1, 1], energy: 100, exposure: 2,
      radius: 0, spotAngle: 1, spotBlend: 0, areaShape: 0, areaSize: 1, areaSizeY: 1, sunAngle: 0,
      castsShadow: false,
    };
    const light = createPBRLight(definition);
    configurePBRLight(light, {
      id: "object:test", name: "Test", type: "LIGHT", parentId: null, dataId: "light:test", visible: true,
      selectable: true, localMatrix: new Array(16).fill(0), worldMatrix: new Array(16).fill(0),
      transform: { translation: [0, 0, 0], rotationEuler: [0, 0, 0], scale: [1, 1, 1], rotationMode: 1 },
    }, new Object3D());
    return { intensity: blenderLightIntensity(definition), castShadow: light.castShadow, sourceShadow: light.userData.blenderCastsShadow };
  });
  expect(mapping).toEqual({ intensity: 40, castShadow: false, sourceShadow: false });
});

test("executes the bounded N-020 CPU compositor and preserves unsupported nodes as gates", async ({ page }) => {
  await page.goto("/");
  const result = await page.evaluate(() => new Promise<Record<string, unknown>>((resolve, reject) => {
    const worker = new Worker("/src/workers/compositor-test.worker.ts", { type: "module" });
    worker.onmessage = (event: MessageEvent<Record<string, unknown>>) => { worker.terminate(); resolve(event.data); };
    worker.onerror = (event) => { worker.terminate(); reject(new Error(event.message)); };
    worker.postMessage({});
  }));
  expect(result.valid).toEqual([0.25, 0, 0.5, 0.75]);
  expect(result.viewer).toBe(true);
  expect(result.gate).toBe("READY");
  expect(result.cycle).toContain("COMPOSITOR_GRAPH_CYCLE");
  expect(result.unsupported).toBe("COMPOSITOR_NODE_UNSUPPORTED");
  expect(result.budget).toContain("COMPOSITOR_BUDGET_EXCEEDED");
  expect(result.cancelled).toContain("COMPOSITOR_CANCELLED");
});

test("validates N-021 sequencer strips, deterministic edits, sandbox paths and codec gates", async ({ page }) => {
  await page.goto("/");
  const result = await page.evaluate(() => new Promise<Record<string, unknown>>((resolve, reject) => {
    const worker = new Worker("/src/workers/sequencer-test.worker.ts", { type: "module" });
    worker.onmessage = (event: MessageEvent<Record<string, unknown>>) => { worker.terminate(); resolve(event.data); };
    worker.onerror = (event) => { worker.terminate(); reject(new Error(event.message)); };
    worker.postMessage({});
  }));
  expect(result.valid).toBe(105);
  expect(result.edit).toEqual([5, [["strip:Movie", 15, 20, 100, 105], ["strip:MovieRight", 20, 25, 105, 110]]]);
  expect(result.revision).toContain("REVISION_CONFLICT");
  expect(result.path).toContain("SEQUENCER_RESOURCE_OUTSIDE_PROJECT");
  expect(result.cycle).toContain("SEQUENCER_DEPENDENCY_CYCLE");
  expect(result.budget).toContain("SEQUENCER_BUDGET_EXCEEDED");
  expect(result.codec).toBe("SEQUENCER_CODEC_UNSUPPORTED");
  expect((result.runtime as { localEncoding: string }).localEncoding).toBe("BLOCKED");
});

test("validates N-022 tracking markers, masks, resource bindings and solve gates", async ({ page }) => {
  await page.goto("/");
  const result = await page.evaluate(() => new Promise<Record<string, unknown>>((resolve, reject) => {
    const worker = new Worker("/src/workers/tracking-mask-test.worker.ts", { type: "module" });
    worker.onmessage = (event: MessageEvent<Record<string, unknown>>) => { worker.terminate(); resolve(event.data); };
    worker.onerror = (event) => { worker.terminate(); reject(new Error(event.message)); };
    worker.postMessage({});
  }));
  expect(result.edit).toEqual([6, [1, 10], [0.4, 0.6]]);
  expect(result.revision).toContain("REVISION_CONFLICT");
  expect(result.path).toContain("TRACKING_RESOURCE_OUTSIDE_PROJECT");
  expect(result.binding).toContain("TRACKING_BINDING_MISSING");
  expect(result.budget).toContain("TRACKING_BUDGET_EXCEEDED");
  expect(result.browserGate).toBe("TRACKING_SOLVE_UNAVAILABLE");
  expect(result.verifiedGate).toBe("READY");
  expect(result.solveGate).toBe("BLOCKED");
});

test("validates N-023 asset catalogs, library graphs, archive budgets and IO gates", async ({ page }) => {
  await page.goto("/");
  const result = await page.evaluate(() => new Promise<Record<string, unknown>>((resolve, reject) => {
    const worker = new Worker("/src/workers/asset-library-io-test.worker.ts", { type: "module" });
    worker.onmessage = (event: MessageEvent<Record<string, unknown>>) => { worker.terminate(); resolve(event.data); };
    worker.onerror = (event) => { worker.terminate(); reject(new Error(event.message)); };
    worker.postMessage({});
  }));
  expect(result.valid).toEqual(["CC0-1.0", ["library:b", "library:a"]]);
  expect(result.hash).toContain("ASSET_SOURCE_HASH_MISMATCH");
  expect(result.license).toContain("ASSET_LICENSE_MISSING");
  expect(result.cycle).toContain("LIBRARY_DEPENDENCY_CYCLE");
  expect(result.archive).toContain("IO_ARCHIVE_UNSAFE");
  expect(result.uri).toContain("IO_EXTERNAL_URI_BLOCKED");
  expect(result.glb).toBe("READY");
  expect(result.obj).toBe("IO_FORMAT_UNSUPPORTED");
  expect(result.library).toBe("BLOCKED");
  expect((result.storage as { contentAddressedIndex: string }).contentAddressedIndex).toBe("LOCAL_BOUNDED");
});

test("validates N-024 editor context, selection sync, layout budgets and workflow gates", async ({ page }) => {
  await page.goto("/");
  const result = await page.evaluate(() => new Promise<Record<string, unknown>>((resolve, reject) => {
    const worker = new Worker("/src/workers/editor-workflow-test.worker.ts", { type: "module" });
    worker.onmessage = (event: MessageEvent<Record<string, unknown>>) => { worker.terminate(); resolve(event.data); };
    worker.onerror = (event) => { worker.terminate(); reject(new Error(event.message)); };
    worker.postMessage({});
  }));
  expect(result.edit).toEqual([2, "TIMELINE", ["object:2"]]);
  expect(result.revision).toContain("REVISION_CONFLICT");
  expect(result.overlap).toContain("EDITOR_LAYOUT_INVALID");
  expect(result.budget).toContain("EDITOR_SELECTION_INVALID");
  expect(result.view).toBe("READY");
  expect(result.writer).toBe("EDITOR_WRITER_UNAVAILABLE");
  expect(result.gizmo).toBe("EDITOR_GIZMO_UNAVAILABLE");
});

test("validates N-025 script policy, signatures, budgets and platform gates", async ({ page }) => {
  await page.goto("/");
  const result = await page.evaluate(() => new Promise<Record<string, unknown>>((resolve, reject) => {
    const worker = new Worker("/src/workers/scripting-platform-test.worker.ts", { type: "module" });
    worker.onmessage = (event: MessageEvent<Record<string, unknown>>) => { worker.terminate(); resolve(event.data); };
    worker.onerror = (event) => { worker.terminate(); reject(new Error(event.message)); };
    worker.postMessage({});
  }));
  expect(result.valid).toBe("scripts/clean.py");
  expect(result.exec).toBe("SCRIPT_SANDBOX_UNAVAILABLE");
  expect(result.server).toBe("SERVER_JOB_UNAVAILABLE");
  expect(result.path).toContain("SCRIPT_MANIFEST_INVALID");
  expect(result.policy).toContain("SCRIPT_POLICY_DENIED");
  expect(result.budget).toContain("SCRIPT_BUDGET_EXCEEDED");
  expect(result.signature).toContain("SCRIPT_SIGNATURE_INVALID");
  expect((result.platform as { nativeWindow: string }).nativeWindow).toBe("BLOCKED");
});

test("keeps N-026 release manifest deterministic and blocks missing evidence", async ({ page }) => {
  await page.goto("/");
  const result = await page.evaluate(() => new Promise<Record<string, unknown>>((resolve, reject) => {
    const worker = new Worker("/src/workers/release-gate-test.worker.ts", { type: "module" });
    worker.onmessage = (event: MessageEvent<Record<string, unknown>>) => { worker.terminate(); resolve(event.data); };
    worker.onerror = (event) => { worker.terminate(); reject(new Error(event.message)); };
    worker.postMessage({});
  }));
  expect(result.valid).toEqual([2, true]);
  expect(result.gate).toEqual(["BLOCKED", expect.arrayContaining(["RELEASE_EVIDENCE_MISSING", "RELEASE_TEST_CHANNEL_MISSING", "RELEASE_PERFORMANCE_MISSING", "RELEASE_FAULT_EVIDENCE_MISSING", "RELEASE_PROVENANCE_MISSING"])]);
  expect(result.oldSchema).toContain("PROTOCOL_MISMATCH");
  expect(result.cycle).toContain("RELEASE_DEPENDENCY_CYCLE");
  expect(result.status).toContain("RELEASE_MANIFEST_INVALID");
});

test("keeps N-015 selection history bounded and rejects stale raycast hits", async ({ page }) => {
  await page.goto("/");
  const result = await page.evaluate(() => new Promise<Record<string, unknown>>((resolve, reject) => {
    const worker = new Worker("/src/workers/selection-history-test.worker.ts", { type: "module" });
    worker.onmessage = (event: MessageEvent<Record<string, unknown>>) => { worker.terminate(); resolve(event.data); };
    worker.onerror = (event) => { worker.terminate(); reject(new Error(event.message)); };
    worker.postMessage({});
  }));
  expect(result.history).toEqual([3, 1, [
    ["curve:1", [1, 3], "HANDLE_LEFT"],
    ["curve:2", [2], "HANDLE_RIGHT"],
  ]]);
  expect(result.revision).toContain("REVISION_CONFLICT");
  expect(result.budget).toContain("SELECTION_HISTORY_BUDGET_EXCEEDED");
  expect(result.raycast).toContain("RAYCAST_HIT_INVALID");
  expect(result.handleHit).toEqual(["object:1", "HANDLE_RIGHT"]);
  expect(result.rangePatch).toEqual([["curve:1", [1, 2, 4]]]);
  expect(result.migrated).toEqual([2, "mesh:1"]);
  expect(result.gates).toEqual(["READY", "READY", "BLOCKED"]);
});

test("validates bounded OpenVDB metadata, SHA and cancellation", async ({ page }) => {
  await page.goto("/");
  const result = await page.evaluate(() => new Promise<{ decodedByteLength: number; outsideProject: string; cancelled: boolean }>((resolve, reject) => {
    const worker = new Worker("/src/workers/vdb-test.worker.ts", { type: "module" });
    worker.onmessage = (event) => { worker.terminate(); if (event.data.error) reject(new Error(event.data.error)); else resolve(event.data); };
    worker.onerror = (event) => { worker.terminate(); reject(new Error(event.message)); };
    worker.postMessage({});
  }));
  expect(result.decodedByteLength).toBe(4);
  expect(result.outsideProject).toContain("NON_MESH_RESOURCE_OUTSIDE_PROJECT");
  expect(result.cancelled).toBe(true);
});

test("returns real Blender evaluations for legacy non-mesh geometry", async ({ page }) => {
  await page.goto("/");
  const bytes = await import("node:fs").then((fs) => fs.readFileSync(nonMeshBlend));
  const geometries = await page.evaluate((input) => new Promise<Array<{ sourceType: string; status: string; vertexCount: number; triangleCount: number; positions?: number[]; indices?: number[] }>>((resolve, reject) => {
    const worker = new Worker("/src/workers/web-engine.worker.ts", { type: "module" });
    worker.onmessage = (event) => {
      if (event.data.kind !== "result") return;
      if (!event.data.ok) {
        worker.terminate();
        reject(new Error(event.data.error?.message ?? "depsgraph evaluation failed"));
      }
      else if (event.data.requestId === "evaluation-open") {
        worker.postMessage({ requestId: "evaluation-run", command: { type: "evaluateDepsgraph" } });
      }
      else if (event.data.requestId === "evaluation-run") {
        worker.terminate();
        resolve(event.data.result?.depsgraph?.nonMeshGeometries ?? []);
      }
    };
    worker.onerror = (event) => { worker.terminate(); reject(new Error(event.message)); };
    const buffer = input.buffer.slice(input.byteOffset, input.byteOffset + input.byteLength);
    worker.postMessage({ requestId: "evaluation-open", command: { type: "openBlend", buffer } }, [buffer]);
  }), new Uint8Array(bytes));
  expect(new Set(geometries.filter((geometry) => geometry.status === "EVALUATED").map((geometry) => geometry.sourceType))).toEqual(new Set(["CURVE", "SURFACE", "FONT", "METABALL"]));
  for (const geometry of geometries) {
    if (geometry.status !== "EVALUATED") continue;
    expect(geometry.vertexCount).toBeGreaterThan(0);
    expect(geometry.positions).toHaveLength(geometry.vertexCount * 3);
    expect(geometry.indices).toHaveLength(geometry.triangleCount * 3);
  }
});

test("keeps N-015 non-mesh previews in the OffscreenCanvas renderer", async ({ page }) => {
  await page.goto("/?offscreen=1");
  await page.setInputFiles("[data-testid=blend-file-input]", nonMeshBlend);
  const canvas = page.locator("canvas.viewport-canvas");
  await expect(canvas).toHaveAttribute("data-renderer-backend", "offscreen-worker");
  await expect(canvas).toHaveAttribute("data-non-mesh-count", "6", { timeout: 20_000 });
  await expect(canvas).toHaveAttribute("data-non-mesh-blocked-count", "2");
  await expect.poll(async () => Number(await canvas.getAttribute("data-renderer-pixels") ?? "0"), { timeout: 20_000 }).toBeGreaterThan(0);
  expect(await canvas.getAttribute("data-renderer-error")).toBeNull();
});

test("runs Main-authoritative object and edit-mode modeling workflows", async ({ page }) => {
  await page.goto("/");
  await page.setInputFiles("[data-testid=blend-file-input]", basicBlend);
  await expect(page.locator("[data-testid=scene-stats]")).toContainText("Objects 3");
  await page.getByRole("button", { name: "添加立方体" }).click();
  await expect(page.locator("[data-testid=scene-stats]")).toContainText("Objects 4");
  await page.getByRole("button", { name: "复制对象", exact: true }).click();
  await expect(page.locator("[data-testid=scene-stats]")).toContainText("Objects 5");
  await page.getByRole("button", { name: "Object Mode" }).click();
  await expect(page.getByRole("button", { name: "Edit Mode" })).toBeVisible();
  await page.getByRole("button", { name: "移动工具" }).click();
  await expect(page.locator("[data-testid=engine-status]")).toContainText("SceneIR r");
  await page.getByRole("button", { name: "Edit Mode" }).click();
  await page.getByRole("button", { name: "删除对象" }).click();
  await expect(page.locator("[data-testid=scene-stats]")).toContainText("Objects 4");
  await page.getByText("BasicCube", { exact: true }).click();
  await page.getByText("BasicCamera", { exact: true }).click({ modifiers: ["Shift"] });
  await expect(page.getByText("2 selected", { exact: true })).toBeVisible();
});

test("saves the opened blend through StorageWorker before download", async ({ page }) => {
  await page.goto("/");
  await page.setInputFiles("[data-testid=blend-file-input]", basicBlend);
  await expect(page.getByText("BasicCube", { exact: true })).toBeVisible();
  const downloadPromise = page.waitForEvent("download");
  await page.getByRole("button", { name: "保存项目" }).click();
  const download = await downloadPromise;
  expect(download.suggestedFilename()).toBe("blender-web.blend");
});

test("autosaves a dirty project without starting a download", async ({ page }) => {
  await page.goto("/");
  await page.setInputFiles("[data-testid=blend-file-input]", basicBlend);
  await expect(page.getByText("BasicCube", { exact: true })).toBeVisible();
  await page.getByRole("button", { name: "已保存" }).click();
  await expect(page.getByRole("button", { name: "已保存" })).toBeVisible({ timeout: 5_000 });
});

test("persists an operation log entry with an inverse payload", async ({ page }) => {
  await page.goto("/");
  const result = await page.evaluate(() => new Promise<{ id: string; revision: number; persisted: boolean }>((resolve, reject) => {
    const worker = new Worker("/src/workers/storage.worker.ts", { type: "module" });
    const requestId = "storage-operation-e2e";
    worker.onmessage = (event: MessageEvent<{ requestId: string; ok: boolean; result?: { id: string; revision: number; persisted: boolean }; error?: string }>) => {
      if (event.data.requestId !== requestId) return;
      worker.terminate();
      if (!event.data.ok || !event.data.result) {
        reject(new Error(event.data.error ?? "operation log failed"));
        return;
      }
      resolve(event.data.result);
    };
    worker.onerror = (event) => { worker.terminate(); reject(new Error(event.message)); };
    worker.postMessage({ requestId, command: { type: "appendOperation", id: "op-e2e", projectId: "save-e2e", revision: 8, payload: { type: "transform" }, inversePayload: { type: "restore" } } });
  }));
  expect(result).toEqual({ id: "op-e2e", projectId: "save-e2e", revision: 8, persisted: true });
});

test("retains bounded snapshots and returns a validated operation replay plan", async ({ page }) => {
  await page.goto("/");
  const result = await page.evaluate(async () => {
    const { StorageClient } = await import("/src/storage/StorageClient.ts");
    const projectId = `replay-e2e-${Date.now()}`;
    const client = new StorageClient();
    for (let revision = 1; revision <= 4; revision++) {
      await client.saveSnapshot(projectId, revision, Uint8Array.from([revision, revision + 1]).buffer, 2, 16);
    }
    await client.appendOperation("op-r3", projectId, 3, { type: "setFrame", frame: 3 });
    await client.appendOperation("op-r5", projectId, 5, { type: "setFrame", frame: 5 });
    await client.appendOperation("op-r4", projectId, 4, { type: "setFrame", frame: 4 });
    const db = await new Promise<IDBDatabase>((resolve, reject) => {
      const request = indexedDB.open("blender-web-metadata", 6);
      request.onsuccess = () => resolve(request.result);
      request.onerror = () => reject(request.error);
    });
    const corrupt = db.transaction("operation_log", "readwrite");
    corrupt.objectStore("operation_log").put({ id: "broken-op", projectId, revision: "bad", payload: null, createdAt: "never" });
    await new Promise<void>((resolve, reject) => { corrupt.oncomplete = () => resolve(); corrupt.onerror = () => reject(corrupt.error); });
    db.close();
    const snapshots = await client.listSnapshots(projectId);
    const latest = await client.readSnapshot(projectId, snapshots.snapshots[0].revision);
    const replay = await client.listOperations(projectId, 3);
    const pruned = await client.pruneOperations(projectId, 4);
    client.terminate();
    return {
      snapshotRevisions: snapshots.snapshots.map((item) => item.revision),
      latest: Array.from(new Uint8Array(latest.buffer)),
      replayRevisions: replay.operations.map((item) => item.revision),
      quarantined: replay.quarantined,
      pruned: pruned.removed,
    };
  });
  expect(result).toEqual({ snapshotRevisions: [4, 3], latest: [4, 5], replayRevisions: [4, 5], quarantined: 1, pruned: 2 });
});

test("reports quota exhaustion without replacing the committed project", async ({ page }) => {
  await page.goto("/");
  const result = await page.evaluate(async () => {
    const { StorageClient } = await import("/src/storage/StorageClient.ts");
    const client = new StorageClient();
    const projectId = `quota-e2e-${Date.now()}`;
    await client.saveProject(projectId, 1, Uint8Array.from([1, 2, 3]).buffer);
    let error = "";
    try { await client.saveProject(projectId, 2, Uint8Array.from([9, 9, 9]).buffer, "quota"); }
    catch (caught) { error = caught instanceof Error ? caught.message : String(caught); }
    const restored = await client.readProject(projectId);
    client.terminate();
    return { error, revision: restored.revision, bytes: Array.from(new Uint8Array(restored.buffer)) };
  });
  expect(result.error).toContain("QuotaExceededError");
  expect(result.revision).toBe(1);
  expect(result.bytes).toEqual([1, 2, 3]);
});

test("enforces a real OPFS quota without replacing the committed project", async ({ page }) => {
  await page.goto("/");
  const cdp = await page.context().newCDPSession(page);
  await cdp.send("Storage.overrideQuotaForOrigin", { origin: new URL(page.url()).origin, quotaSize: 64 * 1024 });
  const result = await page.evaluate(async () => {
    const { StorageClient } = await import("/src/storage/StorageClient.ts");
    const projectId = `real-quota-e2e-${Date.now()}`;
    const client = new StorageClient();
    const initial = await client.saveProject(projectId, 1, Uint8Array.from({ length: 1024 }, (_, index) => index & 0xff).buffer);
    let error = "";
    try {
      await client.saveProject(projectId, 2, Uint8Array.from({ length: 128 * 1024 }, (_, index) => (index * 7) & 0xff).buffer);
    }
    catch (caught) {
      error = caught instanceof Error ? caught.message : String(caught);
    }
    const restored = await client.readProject(projectId);
    client.terminate();
    const restarted = new StorageClient();
    const reopened = await restarted.readProject(projectId);
    restarted.terminate();
    return {
      backend: initial.backend,
      error,
      revision: restored.revision,
      reopenedRevision: reopened.revision,
      bytes: Array.from(new Uint8Array(reopened.buffer.slice(0, 4))),
    };
  });
  expect(result.backend).toBe("opfs");
  expect(result.error).toMatch(/QuotaExceededError|quota/i);
  expect(result.revision).toBe(1);
  expect(result.reopenedRevision).toBe(1);
  expect(result.bytes).toEqual([0, 1, 2, 3]);
});

test("persists and revalidates content-addressed Simulation caches across Worker restarts", async ({ page }) => {
  await page.goto("/");
  const result = await page.evaluate(async () => {
    const { StorageClient } = await import("/src/storage/StorageClient.ts");
    const digest = async (data: ArrayBuffer): Promise<string> => {
      const hash = await crypto.subtle.digest("SHA-256", data);
      return Array.from(new Uint8Array(hash), (value) => value.toString(16).padStart(2, "0")).join("");
    };
    const projectId = `simulation-e2e-${Date.now()}`;
    const sourceBlend = Uint8Array.from([0x42, 0x4c, 0x45, 0x4e, 0x44]).buffer;
    const source = Uint8Array.from([11, 12, 13, 21, 22, 23, 24]);
    const frameOne = source.buffer.slice(0, 3);
    const frameTwo = source.buffer.slice(3);
    const payload = source.buffer.slice(0);
    const fixedHash = await digest(Uint8Array.from([1, 2, 3]).buffer);
    const manifest = {
      schemaVersion: 1 as const,
      graphId: "geometry-node-tree:simulation-e2e",
      graphHash: fixedHash,
      sourceBlendSha256: await digest(sourceBlend),
      inputHash: await digest(Uint8Array.from([4, 5, 6]).buffer),
      cacheSha256: await digest(payload),
      blenderVersion: "5.2.0",
      frameStart: 1,
      frameEnd: 2,
      byteLength: payload.byteLength,
      frames: [
        { frame: 1, byteOffset: 0, byteLength: 3, sha256: await digest(frameOne) },
        { frame: 2, byteOffset: 3, byteLength: 4, sha256: await digest(frameTwo) },
      ],
    };
    const first = new StorageClient();
    await first.saveProject(projectId, 1, sourceBlend.slice(0));
    const stored = await first.putSimulationCache(projectId, manifest, payload);
    first.terminate();

    const restarted = new StorageClient();
    const listed = await restarted.listSimulationCaches(projectId);
    const read = await restarted.readSimulationCache(projectId, stored.cacheKey);
    const frameRead = await restarted.readSimulationCacheFrame(projectId, stored.cacheKey, 2);
    let missingFrameCode = "";
    try {
      await restarted.readSimulationCacheFrame(projectId, stored.cacheKey, 3);
    }
    catch (error) {
      missingFrameCode = String((error as Error & { code?: string }).code ?? "");
    }
    let corruptCode = "";
    try {
      await restarted.putSimulationCache(projectId, { ...manifest, cacheSha256: "0".repeat(64) }, source.buffer.slice(0));
    }
    catch (error) {
      corruptCode = String((error as Error & { code?: string }).code ?? "");
    }
    restarted.terminate();
    return {
      cacheKey: stored.cacheKey,
      path: stored.path,
      listed: listed.caches.map((cache) => cache.cacheKey),
      bytes: Array.from(new Uint8Array(read.data)),
      frame: frameRead.frame,
      frameOffset: frameRead.byteOffset,
      frameBytes: Array.from(new Uint8Array(frameRead.data)),
      missingFrameCode,
      corruptCode,
    };
  });
  expect(result.cacheKey).toMatch(/^[a-f0-9]{16}-[a-f0-9]{16}-[a-f0-9]{16}-1-2$/);
  expect(result.path).toMatch(/^projects\/simulation-e2e-[0-9]+\/assets\/sha256\/[a-f0-9]{2}\/[a-f0-9]{64}$/);
  expect(result.listed).toContain(result.cacheKey);
  expect(result.bytes).toEqual([11, 12, 13, 21, 22, 23, 24]);
  expect(result.frame).toBe(2);
  expect(result.frameOffset).toBe(3);
  expect(result.frameBytes).toEqual([21, 22, 23, 24]);
  expect(result.missingFrameCode).toBe("SIMULATION_CACHE_MISSING");
  expect(result.corruptCode).toBe("SIMULATION_CACHE_HASH_MISMATCH");
});

test("stores LOD cache bytes in OPFS and indexes its manifest", async ({ page }) => {
  await page.goto("/");
  const result = await page.evaluate(async () => {
    const { buildLODCacheKey } = await import("/src/three-adapter/lod.ts");
    return new Promise<{ bytes: number; path: string; persisted: boolean; manifest?: { cacheKey: string } }>((resolve, reject) => {
    const worker = new Worker("/src/workers/storage.worker.ts", { type: "module" });
    const cacheKey = buildLODCacheKey({ objectId: "object-e2e", meshRevision: 7, modifierStackHash: "stack-hash", profileHash: "profile-hash", poseOrRestState: "REST" });
    const manifest = {
      schemaVersion: 1,
      meshId: "mesh-e2e",
      sourceMeshRevision: 7,
      cacheKey,
      objectId: "object-e2e",
      modifierStackHash: "stack-hash",
      profileHash: "profile-hash",
      poseOrRestState: "REST",
      generatedAt: "2026-08-06T00:00:00.000Z",
      levels: [
        { level: 0, sourceMeshRevision: 7, triangleBudget: 1200, meshId: "mesh-e2e-l0" },
        { level: 1, sourceMeshRevision: 7, triangleBudget: 400, meshId: "mesh-e2e-l1" },
      ],
    };
    const bytes = Uint8Array.from([0x4c, 0x4f, 0x44, 0x31]).buffer;
    worker.onmessage = (event: MessageEvent<{ requestId: string; ok: boolean; result?: { bytes?: number; path?: string; persisted?: boolean; manifest?: { cacheKey: string }; manifests?: Array<{ cacheKey: string }> }; error?: string }>) => {
      if (event.data.requestId === "lod-save-e2e" && event.data.ok) {
        worker.postMessage({ requestId: "lod-put-e2e", command: { type: "putLODManifest", projectId: "lod-e2e", manifest } });
      }
      else if (event.data.requestId === "lod-put-e2e" && event.data.ok) {
        worker.postMessage({ requestId: "lod-get-e2e", command: { type: "getLODManifest", projectId: "lod-e2e", cacheKey } });
      }
      else if (event.data.requestId === "lod-get-e2e") {
        if (!event.data.ok || !event.data.result) reject(new Error(event.data.error ?? "LOD manifest read failed"));
        else worker.postMessage({ requestId: "lod-list-e2e", command: { type: "listLODManifests", projectId: "lod-e2e" } });
      }
      else if (event.data.requestId === "lod-list-e2e") {
        worker.terminate();
        if (!event.data.ok || !event.data.result) reject(new Error(event.data.error ?? "LOD manifest list failed"));
        else resolve({ bytes: 4, path: `projects/lod-e2e/cache/lod/${cacheKey}.mesh`, persisted: event.data.result.manifests?.some((item: { cacheKey: string }) => item.cacheKey === cacheKey) ?? false, manifest: { cacheKey } });
      }
      else if (!event.data.ok) {
        worker.terminate();
        reject(new Error(event.data.error ?? "LOD storage failed"));
      }
    };
    worker.onerror = (event) => { worker.terminate(); reject(new Error(event.message)); };
    worker.postMessage({ requestId: "lod-save-e2e", command: { type: "saveLOD", projectId: "lod-e2e", cacheKey, data: bytes } }, [bytes]);
    });
  });
  expect(result.bytes).toBe(4);
  expect(result.path).toMatch(/^projects\/lod-e2e\/cache\/lod\/lod-[0-9a-f]+\.mesh$/);
  expect(result.persisted).toBe(true);
  expect(result.manifest?.cacheKey).toMatch(/^lod-[0-9a-f]+$/);
});

test("selects Three.js LOD levels with hysteresis and stable cache keys", async ({ page }) => {
  await page.goto("/");
  const result = await page.evaluate(async () => {
    const { buildLODCacheKey, selectLODLevel } = await import("/src/three-adapter/lod.ts");
    const policy = { screenHeightThresholds: [512, 128, 32], hysteresis: 0.1 };
    return {
      near: selectLODLevel(600, policy).level,
      boundary: selectLODLevel(490, policy, 0).level,
      far: selectLODLevel(20, policy, 1).level,
      keyA: buildLODCacheKey({ objectId: "cube", meshRevision: 4, modifierStackHash: "stack", profileHash: "profile", poseOrRestState: "REST" }),
      keyB: buildLODCacheKey({ objectId: "cube", meshRevision: 4, modifierStackHash: "stack", profileHash: "profile", poseOrRestState: "REST" }),
    };
  });
  expect(result.near).toBe(0);
  expect(result.boundary).toBe(0);
  expect(result.far).toBe(2);
  expect(result.keyA).toBe(result.keyB);
});

test("reads and evicts LOD cache entries by byte budget", async ({ page }) => {
  await page.goto("/");
  const result = await page.evaluate(async () => {
    const { buildLODCacheKey } = await import("/src/three-adapter/lod.ts");
    return new Promise<{ readBytes: number; removed: number; removedBytes: number }>((resolve, reject) => {
      const worker = new Worker("/src/workers/storage.worker.ts", { type: "module" });
      const cacheKey = buildLODCacheKey({ objectId: "evict-object", meshRevision: 3, modifierStackHash: "stack", profileHash: "profile", poseOrRestState: "REST" });
      const manifest = {
        schemaVersion: 1,
        meshId: "evict-mesh",
        sourceMeshRevision: 3,
        cacheKey,
        objectId: "evict-object",
        modifierStackHash: "stack",
        profileHash: "profile",
        poseOrRestState: "REST",
        generatedAt: "2026-08-06T00:00:00.000Z",
        byteLength: 6,
        levels: [{ level: 0, sourceMeshRevision: 3, triangleBudget: 100, meshId: "evict-l0" }],
      };
      const bytes = Uint8Array.from([1, 2, 3, 4, 5, 6]).buffer;
      let readBytes = 0;
      worker.onmessage = (event: MessageEvent<{ requestId: string; ok: boolean; result?: { data?: ArrayBuffer; bytes?: number; removed?: number; removedBytes?: number }; error?: string }>) => {
        if (!event.data.ok) {
          worker.terminate();
          reject(new Error(event.data.error ?? "LOD cache operation failed"));
        }
        else if (event.data.requestId === "lod-read-e2e") {
          readBytes = event.data.result?.bytes ?? 0;
          worker.postMessage({ requestId: "lod-prune-e2e", command: { type: "pruneLOD", projectId: "lod-evict-e2e", maxBytes: 0 } });
        }
        else if (event.data.requestId === "lod-prune-e2e") {
          worker.terminate();
          resolve({ readBytes, removed: event.data.result?.removed ?? 0, removedBytes: event.data.result?.bytes ?? 0 });
        }
        else if (event.data.requestId === "lod-save-e2e") worker.postMessage({ requestId: "lod-put-e2e", command: { type: "putLODManifest", projectId: "lod-evict-e2e", manifest } });
        else if (event.data.requestId === "lod-put-e2e") worker.postMessage({ requestId: "lod-read-e2e", command: { type: "readLOD", projectId: "lod-evict-e2e", cacheKey } });
      };
      worker.onerror = (event) => { worker.terminate(); reject(new Error(event.message)); };
      worker.postMessage({ requestId: "lod-save-e2e", command: { type: "saveLOD", projectId: "lod-evict-e2e", cacheKey, data: bytes } }, [bytes]);
    });
  });
  expect(result.readBytes).toBe(6);
  expect(result.removed).toBe(1);
  expect(result.removedBytes).toBe(6);
});

test("renders local UV/color/material-slot geometry", async ({ page }) => {
  await page.goto("/");
  await page.setInputFiles("[data-testid=blend-file-input]", attributeBlend);
  await expect(page.getByText("AttributeMeshObject", { exact: true })).toBeVisible();
  await expect(page.locator("[data-testid=scene-stats]")).toContainText("Objects 1 · Vertices 5 · Faces 2");
  const canvas = page.locator("canvas.viewport-canvas");
  await expect(canvas).toHaveAttribute("data-renderer-backend", "webgl-pbr");
  await expect(canvas).toHaveAttribute("data-pbr-profile", "physical-v1");
  await expect(canvas).toHaveAttribute("data-tone-mapping", "aces");
  await expect(canvas).toHaveAttribute("data-shadow-map", "pcf-1024");
  const renderedPixels = await canvas.evaluate((canvas) => {
    const gl = canvas.getContext("webgl2") ?? canvas.getContext("webgl");
    if (!gl) return 0;
    const pixels = new Uint8Array(4 * 16 * 16);
    gl.readPixels(Math.max(0, (gl.drawingBufferWidth - 16) / 2), Math.max(0, (gl.drawingBufferHeight - 16) / 2), 16, 16, gl.RGBA, gl.UNSIGNED_BYTE, pixels);
    return pixels.reduce((count, value, index) => count + (index % 4 !== 3 && value > 50 ? 1 : 0), 0);
  });
  expect(renderedPixels).toBeGreaterThan(0);
});

test("maps Blender Principled values to the bounded physical viewport material", async ({ page }) => {
  await page.goto("/");
  const mapped = await page.evaluate(async () => {
    const { createPBRMaterial } = await import("/src/three-adapter/pbr.ts");
    const material = createPBRMaterial({
      id: "material:pbr",
      name: "PBR",
      baseColor: [0.2, 0.4, 0.8, 0.9],
      roughness: 0.21,
      metallic: 0.62,
      emissionColor: [0.05, 0.1, 0.2, 1],
      alpha: 0.9,
      ior: 1.52,
      specularIORLevel: 0.35,
      transmissionWeight: 0.27,
      coatWeight: 0.64,
      coatRoughness: 0.12,
      emissionStrength: 3.5,
    });
    const result = {
      type: material.type,
      roughness: material.roughness,
      metalness: material.metalness,
      ior: material.ior,
      specularIntensity: material.specularIntensity,
      transmission: material.transmission,
      clearcoat: material.clearcoat,
      clearcoatRoughness: material.clearcoatRoughness,
      emissiveIntensity: material.emissiveIntensity,
      opacity: material.opacity,
      transparent: material.transparent,
      depthWrite: material.depthWrite,
      profile: material.userData.pbrProfile,
    };
    material.dispose();
    return result;
  });
  expect(mapped).toEqual({
    type: "MeshPhysicalMaterial",
    roughness: 0.21,
    metalness: 0.62,
    ior: 1.52,
    specularIntensity: 0.7,
    transmission: 0.27,
    clearcoat: 0.64,
    clearcoatRoughness: 0.12,
    emissiveIntensity: 3.5,
    opacity: 0.9,
    transparent: true,
    depthWrite: false,
    profile: "physical-v1",
  });
});

test("authors advanced Principled PBR controls through Blender Main", async ({ page }) => {
  await page.goto("/");
  await page.setInputFiles("[data-testid=blend-file-input]", attributeBlend);
  await expect(page.getByText("AttributeMeshObject", { exact: true })).toBeVisible();
  await page.getByRole("slider", { name: "材质 IOR" }).fill("1.52");
  await page.getByRole("slider", { name: "材质镜面 IOR" }).fill("0.35");
  await page.getByRole("slider", { name: "材质透射" }).fill("0.27");
  await page.getByRole("slider", { name: "材质涂层", exact: true }).fill("0.64");
  await page.getByRole("slider", { name: "材质涂层粗糙度" }).fill("0.12");
  await page.getByRole("spinbutton", { name: "材质自发光强度" }).fill("3.5");
  await page.getByRole("button", { name: "应用 Principled" }).click();
  await expect(page.locator("[data-testid=engine-status]")).toContainText(/SceneIR r\d+/, { timeout: 15_000 });
});

test("captures nonblank PBR viewport framing at desktop and mobile sizes", async ({ page }, testInfo) => {
  await page.setViewportSize({ width: 1440, height: 900 });
  await page.goto("/");
  await page.setInputFiles("[data-testid=blend-file-input]", attributeBlend);
  await expect(page.getByText("AttributeMeshObject", { exact: true })).toBeVisible();
  const canvas = page.locator("canvas.viewport-canvas");
  await expect(canvas).toHaveAttribute("data-pbr-profile", "physical-v1");
  await page.screenshot({ path: testInfo.outputPath("pbr-desktop-1440x900.png"), fullPage: true });
  await page.setViewportSize({ width: 390, height: 844 });
  await expect(canvas).toBeVisible();
  expect(await page.evaluate(() => document.documentElement.scrollWidth)).toBe(390);
  const bounds = await canvas.boundingBox();
  expect(bounds?.width ?? 0).toBeGreaterThan(100);
  expect(bounds?.height ?? 0).toBeGreaterThan(100);
  const sampleCanvas = (): Promise<{ visible: number; hash: number }> => canvas.evaluate((element) => {
    const gl = element.getContext("webgl2") ?? element.getContext("webgl");
    if (!gl) return { visible: 0, hash: 0 };
    const size = 32;
    const pixels = new Uint8Array(size * size * 4);
    gl.readPixels(Math.max(0, Math.floor((gl.drawingBufferWidth - size) / 2)), Math.max(0, Math.floor((gl.drawingBufferHeight - size) / 2)), size, size, gl.RGBA, gl.UNSIGNED_BYTE, pixels);
    let visible = 0;
    let hash = 2166136261;
    for (let index = 0; index < pixels.length; index += 4) {
      if (pixels[index] > 40 || pixels[index + 1] > 40 || pixels[index + 2] > 40) visible++;
      hash = Math.imul(hash ^ pixels[index], 16777619);
      hash = Math.imul(hash ^ pixels[index + 1], 16777619);
      hash = Math.imul(hash ^ pixels[index + 2], 16777619);
    }
    return { visible, hash: hash >>> 0 };
  });
  const beforeOrbit = await sampleCanvas();
  expect(beforeOrbit.visible).toBeGreaterThan(0);
  if (!bounds) throw new Error("mobile viewport has no bounds");
  await page.mouse.move(bounds.x + bounds.width * 0.25, bounds.y + bounds.height * 0.45);
  await page.mouse.down();
  await page.mouse.move(bounds.x + bounds.width * 0.35, bounds.y + bounds.height * 0.5, { steps: 6 });
  await page.mouse.up();
  await page.waitForTimeout(200);
  const afterOrbit = await sampleCanvas();
  expect(afterOrbit.visible).toBeGreaterThan(0);
  expect(afterOrbit.hash).not.toBe(beforeOrbit.hash);
  await page.screenshot({ path: testInfo.outputPath("pbr-mobile-390x844.png"), fullPage: true });
});

test("shows mode-specific Blender Decimate inspector controls", async ({ page }) => {
  await page.goto("/");
  await page.setInputFiles("[data-testid=blend-file-input]", basicBlend);
  await expect(page.getByText("BasicCube", { exact: true })).toBeVisible();
  const mode = page.getByRole("combobox", { name: "Decimate 模式" });
  await mode.selectOption("UNSUBDIV");
  await expect(page.getByRole("spinbutton", { name: "Un-Subdivide 迭代" })).toHaveValue("1");
  await mode.selectOption("DISSOLVE_PLANAR");
  await expect(page.getByRole("slider", { name: "Dissolve 角度" })).toHaveValue("5");
  await expect(page.getByRole("checkbox", { name: "Dissolve 边界" })).toBeVisible();
  await expect(page.getByRole("group", { name: "分隔" })).toBeVisible();
  await mode.selectOption("COLLAPSE");
  await expect(page.getByRole("slider", { name: "Decimate 比例" })).toHaveValue("0.5");
  await expect(page.getByRole("checkbox", { name: "Decimate 三角化" })).toBeVisible();
  await expect(page.getByRole("checkbox", { name: "Decimate 对称" })).toBeVisible();
  await expect(page.getByRole("combobox", { name: "Decimate 属性策略" })).toHaveValue("PRESERVE");
  await page.getByRole("button", { name: "预览 Decimate" }).click();
  await expect(page.locator("[data-testid=engine-status]")).toContainText("Preview", { timeout: 10_000 });
  await page.getByRole("button", { name: "取消 Decimate 预览" }).click();
  await expect(page.locator("[data-testid=engine-status]")).toContainText("SceneIR r1");
  await page.getByRole("button", { name: "生成 LOD" }).click();
  await expect(page.locator("[data-testid=engine-status]")).toContainText("LOD:", { timeout: 15_000 });
});

test("discovers and reuses a valid LOD cache after an application refresh", async ({ page }) => {
  await page.goto("/");
  await page.setInputFiles("[data-testid=blend-file-input]", basicBlend);
  await expect(page.getByText("BasicCube", { exact: true })).toBeVisible();
  await page.getByRole("button", { name: "生成 LOD" }).click();
  await expect(page.locator("[data-testid=engine-status]")).toContainText("LOD:", { timeout: 15_000 });
  await page.reload();
  await page.setInputFiles("[data-testid=blend-file-input]", basicBlend);
  await expect(page.locator("[data-testid=engine-status]")).toContainText("cached LOD mesh", { timeout: 15_000 });
});

test("workspace context routes mode and operator search state", async ({ page }) => {
  await page.goto("/");
  await page.getByRole("button", { name: "Modeling" }).click();
  await expect(page.locator("main.blender-app")).toHaveAttribute("data-workspace", "Modeling");
  await page.getByRole("button", { name: "Object Mode" }).click();
  await expect(page.getByRole("button", { name: "Edit Mode" })).toBeVisible();
  await page.getByRole("button", { name: "操作搜索" }).click();
  await page.getByRole("textbox", { name: "搜索操作" }).fill("cube");
  await expect(page.getByRole("button", { name: "Add Cube" })).toBeVisible();
});

test("keeps Outliner selection bound to SceneIR activeObjectId", async ({ page }) => {
  await page.goto("/");
  await page.setInputFiles("[data-testid=blend-file-input]", basicBlend);
  await expect(page.getByText("BasicCube", { exact: true })).toBeVisible();
  await page.locator(".tree-row.child", { hasText: "BasicCamera" }).click();
  await expect(page.locator(".tree-row.selected")).toContainText("BasicCamera");
});

test("Outliner visibility button applies a native command", async ({ page }) => {
  await page.goto("/");
  await page.setInputFiles("[data-testid=blend-file-input]", basicBlend);
  await expect(page.getByText("BasicCube", { exact: true })).toBeVisible();
  const visibilityButton = page.getByRole("button", { name: "隐藏 BasicCube", exact: true });
  await visibilityButton.click();
  await expect(page.getByRole("button", { name: "显示 BasicCube", exact: true })).toBeVisible();
  await expect(page.locator("[data-testid=engine-status]")).toContainText("SceneIR r2 (3 objects)");
});

test("timeline transport controls update the imported frame range", async ({ page }) => {
  await page.goto("/");
  await page.setInputFiles("[data-testid=blend-file-input]", basicBlend);
  await expect(page.getByText("BasicCube", { exact: true })).toBeVisible();
  await page.getByRole("button", { name: "跳到最后一帧" }).click();
  await expect(page.locator(".frame-number")).toHaveText("24");
  await page.getByRole("button", { name: "跳到第一帧" }).click();
  await expect(page.locator(".frame-number")).toHaveText("1");
});

test("loads the local web_engine WASM worker", async ({ page }) => {
  await page.goto("/");
  const result = await page.evaluate(() => new Promise<{ ok: boolean; ready?: boolean; error?: string }>((resolve) => {
    const worker = new Worker("/src/workers/web-engine.worker.ts", { type: "module" });
    const requestId = "e2e-web-engine";
    worker.onmessage = (event: MessageEvent<{ kind: string; requestId: string; ok?: boolean; result?: { status: { ready: boolean } }; error?: { message: string } }>) => {
      if (event.data.requestId !== requestId) return;
      worker.terminate();
      resolve({ ok: event.data.kind === "result" && event.data.ok === true, ready: event.data.result?.status.ready, error: event.data.error?.message });
    };
    worker.onerror = (event) => {
      worker.terminate();
      resolve({ ok: false, error: event.message });
    };
    worker.postMessage({ requestId, command: { type: "init" } });
  }));
  expect(result).toEqual({ ok: true, ready: true });
});

test("transfers binary mesh buffers from the WebEngine worker", async ({ page }) => {
  await page.goto("/");
  const bytes = await import("node:fs").then((fs) => fs.readFileSync(basicBlend));
  const result = await page.evaluate((input) => new Promise<{ status: string; positions: number; indices: number; byteLength: number }>((resolve, reject) => {
    const worker = new Worker("/src/workers/web-engine.worker.ts", { type: "module" });
    const requestId = "e2e-binary-geometry";
    worker.onmessage = (event: MessageEvent<{ kind: string; requestId: string; ok?: boolean; result?: { snapshot?: { meshes: Array<{ geometryStatus: string }> }; geometryBuffers?: Array<{ positions: ArrayBuffer; indices: ArrayBuffer; byteLength: number }> }; error?: { message: string } }>) => {
      if (event.data.requestId !== requestId) return;
      if (event.data.kind !== "result") return;
      worker.terminate();
      if (!event.data.ok || !event.data.result?.snapshot || !event.data.result.geometryBuffers?.[0]) {
        reject(new Error(event.data.error?.message ?? `binary geometry response missing: ${JSON.stringify(event.data)}`));
        return;
      }
      const mesh = event.data.result.snapshot.meshes[0];
      const payload = event.data.result.geometryBuffers[0];
      resolve({ status: mesh.geometryStatus, positions: payload.positions.byteLength, indices: payload.indices.byteLength, byteLength: payload.byteLength });
    };
    worker.onerror = (event) => { worker.terminate(); reject(new Error(event.message)); };
    const buffer = input.buffer.slice(input.byteOffset, input.byteOffset + input.byteLength);
    worker.postMessage({ requestId, command: { type: "openBlend", buffer } }, [buffer]);
  }), new Uint8Array(bytes));
  expect(result.status).toBe("binary");
  expect(result.positions).toBe(8 * 3 * 4);
  expect(result.indices).toBe(12 * 3 * 4);
  expect(result.byteLength).toBeGreaterThan(result.positions + result.indices);
});

test("returns a revisioned native SceneDelta", async ({ page }) => {
  await page.goto("/");
  const bytes = await import("node:fs").then((fs) => fs.readFileSync(basicBlend));
  const result = await page.evaluate((input) => new Promise<{ baseRevision: number; nextRevision: number; added: number }>((resolve, reject) => {
    const worker = new Worker("/src/workers/web-engine.worker.ts", { type: "module" });
    const openRequestId = "e2e-delta-open";
    const deltaRequestId = "e2e-delta-read";
    worker.onmessage = (event: MessageEvent<{ kind: string; requestId: string; ok?: boolean; result?: { delta?: { baseRevision: number; nextRevision: number; nodes?: { added?: unknown[] } } }; error?: { message: string } }>) => {
      if (event.data.kind !== "result") return;
      if (event.data.requestId === openRequestId && event.data.ok) {
        worker.postMessage({ requestId: deltaRequestId, command: { type: "delta" } });
        return;
      }
      if (event.data.requestId !== deltaRequestId) return;
      worker.terminate();
      const delta = event.data.result?.delta;
      if (!event.data.ok || !delta) {
        reject(new Error(event.data.error?.message ?? "delta response missing"));
        return;
      }
      resolve({ baseRevision: delta.baseRevision, nextRevision: delta.nextRevision, added: delta.nodes?.added?.length ?? 0 });
    };
    worker.onerror = (event) => { worker.terminate(); reject(new Error(event.message)); };
    const buffer = input.buffer.slice(input.byteOffset, input.byteOffset + input.byteLength);
    worker.postMessage({ requestId: openRequestId, command: { type: "openBlend", buffer } }, [buffer]);
  }), new Uint8Array(bytes));
  expect(result).toEqual({ baseRevision: 0, nextRevision: 1, added: 3 });
});

test("applies an object-mode command and returns the matching SceneDelta", async ({ page }) => {
  await page.goto("/");
  const bytes = await import("node:fs").then((fs) => fs.readFileSync(basicBlend));
  const result = await page.evaluate((input) => new Promise<{
    frame: number;
    frameBase: number;
    frameNext: number;
    visible: boolean;
    visibilityBase: number;
    visibilityNext: number;
  }>((resolve, reject) => {
    const worker = new Worker("/src/workers/web-engine.worker.ts", { type: "module" });
    const openRequestId = "e2e-command-open";
    const frameRequestId = "e2e-command-frame";
    const visibilityRequestId = "e2e-command-visibility";
    let openedRevision = 0;
    worker.onmessage = (event: MessageEvent<{
      kind: string;
      requestId: string;
      ok?: boolean;
      result?: {
        snapshot?: { revision: number; frame: { current: number }; nodes: Array<{ id: string; visible: boolean }> };
        delta?: { baseRevision: number; nextRevision: number; frame?: { current: number } };
      };
      error?: { message: string };
    }>) => {
      if (event.data.kind !== "result") return;
      if (event.data.requestId === openRequestId && event.data.ok && event.data.result?.snapshot) {
        openedRevision = event.data.result.snapshot.revision;
        worker.postMessage({ requestId: frameRequestId, command: { type: "applyCommand", payload: { type: "setFrame", frame: 12 } } });
        return;
      }
      if (event.data.requestId === frameRequestId && event.data.ok && event.data.result?.delta) {
        const delta = event.data.result.delta;
        if (delta.baseRevision !== openedRevision || delta.nextRevision !== openedRevision + 1 || delta.frame?.current !== 12) {
          worker.terminate();
          reject(new Error(`unexpected frame command delta: ${JSON.stringify(delta)}`));
          return;
        }
        worker.postMessage({ requestId: visibilityRequestId, command: { type: "applyCommand", payload: { type: "setObjectVisibility", objectId: "object:BasicCube", visible: false } } });
        return;
      }
      if (event.data.requestId !== visibilityRequestId) return;
      worker.terminate();
      if (!event.data.ok || !event.data.result?.snapshot || !event.data.result.delta) {
        reject(new Error(event.data.error?.message ?? "visibility command failed"));
        return;
      }
      const snapshot = event.data.result.snapshot;
      const delta = event.data.result.delta;
      resolve({
        frame: snapshot.frame.current,
        frameBase: openedRevision,
        frameNext: openedRevision + 1,
        visible: snapshot.nodes.find((node) => node.id === "object:BasicCube")?.visible ?? true,
        visibilityBase: delta.baseRevision,
        visibilityNext: delta.nextRevision,
      });
    };
    worker.onerror = (event) => { worker.terminate(); reject(new Error(event.message)); };
    const buffer = input.buffer.slice(input.byteOffset, input.byteOffset + input.byteLength);
    worker.postMessage({ requestId: openRequestId, command: { type: "openBlend", buffer } }, [buffer]);
  }), new Uint8Array(bytes));
  expect(result.frame).toBe(12);
  expect(result.frameBase).toBe(1);
  expect(result.frameNext).toBe(2);
  expect(result.visible).toBe(false);
  expect(result.visibilityBase).toBe(2);
  expect(result.visibilityNext).toBe(3);
});

test("undoes and redoes native scene commands without a Three.js shadow state", async ({ page }) => {
  await page.goto("/");
  const bytes = await import("node:fs").then((fs) => fs.readFileSync(basicBlend));
  const result = await page.evaluate((input) => new Promise<{ undoFrame: number; redoFrame: number; undoRevision: number; redoRevision: number }>((resolve, reject) => {
    const worker = new Worker("/src/workers/web-engine.worker.ts", { type: "module" });
    const ids = { open: "history-open", apply: "history-apply", undo: "history-undo", redo: "history-redo" };
    let undoFrame = 0;
    let undoRevision = 0;
    worker.onmessage = (event: MessageEvent<{ kind: string; requestId: string; ok?: boolean; result?: { snapshot?: { revision: number; frame: { current: number } } }; error?: { message: string } }>) => {
      if (event.data.kind !== "result") return;
      if (!event.data.ok) { worker.terminate(); reject(new Error(event.data.error?.message ?? "history command failed")); return; }
      if (event.data.requestId === ids.open) worker.postMessage({ requestId: ids.apply, command: { type: "applyCommand", payload: { type: "setFrame", frame: 12 } } });
      else if (event.data.requestId === ids.apply) worker.postMessage({ requestId: ids.undo, command: { type: "applyCommand", payload: { type: "undo" } } });
      else if (event.data.requestId === ids.undo && event.data.result?.snapshot) {
        undoFrame = event.data.result.snapshot.frame.current;
        undoRevision = event.data.result.snapshot.revision;
        worker.postMessage({ requestId: ids.redo, command: { type: "applyCommand", payload: { type: "redo" } } });
      }
      else if (event.data.requestId === ids.redo && event.data.result?.snapshot) {
        worker.terminate();
        resolve({ undoFrame, redoFrame: event.data.result.snapshot.frame.current, undoRevision, redoRevision: event.data.result.snapshot.revision });
      }
    };
    worker.onerror = (event) => { worker.terminate(); reject(new Error(event.message)); };
    const buffer = input.buffer.slice(input.byteOffset, input.byteOffset + input.byteLength);
    worker.postMessage({ requestId: ids.open, command: { type: "openBlend", buffer } }, [buffer]);
  }), new Uint8Array(bytes));
  expect(result.undoFrame).toBe(1);
  expect(result.redoFrame).toBe(12);
  expect(result.undoRevision).toBe(3);
  expect(result.redoRevision).toBe(4);
});

test("wires Blender Web top-bar undo and redo to native history", async ({ page }) => {
  await page.goto("/");
  await page.setInputFiles("[data-testid=blend-file-input]", basicBlend);
  await expect(page.getByText("BasicCube", { exact: true })).toBeVisible();
  await page.getByRole("button", { name: "跳到最后一帧" }).click();
  await expect(page.locator(".frame-number")).toHaveText("24");
  await page.getByRole("button", { name: "撤销" }).click();
  await expect(page.locator(".frame-number")).toHaveText("1");
  await page.getByRole("button", { name: "重做" }).click();
  await expect(page.locator(".frame-number")).toHaveText("24");
});

test("applies Blender's native Decimate topology through the WebEngine command path", async ({ page }) => {
  await page.goto("/");
  const bytes = await import("node:fs").then((fs) => fs.readFileSync(basicBlend));
  const result = await page.evaluate((input) => new Promise<{ originalTriangles: number; outputTriangles: number; reportedOriginal: number; reportedOutput: number; originalVertices: number; outputVertices: number; geometryBytes: number; normals: number; corners: number; uvs: number; materials: number }>((resolve, reject) => {
    const worker = new Worker("/src/workers/web-engine.worker.ts", { type: "module" });
    const openRequestId = "e2e-decimate-open";
    const decimateRequestId = "e2e-decimate-apply";
    worker.onmessage = (event: MessageEvent<{
      kind: string;
      requestId: string;
      ok?: boolean;
      result?: { snapshot?: { revision: number; meshes: Array<{ id: string; vertexCount: number; triangleCount?: number }> }; geometryDelta?: { replaced: Array<{ meshId: string; positions: ArrayBuffer; indices: ArrayBuffer; normals?: ArrayBuffer; triangleCornerIndices?: ArrayBuffer; uvs?: ArrayBuffer; triangleMaterialIndices?: ArrayBuffer }> }; simplify?: { originalTriangleCount: number; outputTriangleCount: number } };
      error?: { message: string };
    }>) => {
      if (event.data.kind !== "result") return;
      if (event.data.requestId === openRequestId && event.data.ok && event.data.result?.snapshot) {
        const mesh = event.data.result.snapshot.meshes[0];
        worker.postMessage({ requestId: decimateRequestId, command: { type: "applyCommand", payload: {
          type: "decimateMesh",
          meshId: mesh.id,
          profile: { schemaVersion: 1, sourceMeshRevision: event.data.result.snapshot.revision, attributePolicy: "PRESERVE", mode: "COLLAPSE", ratio: 0.5, vertexGroup: null, vertexGroupFactor: 1, vertexGroupInvert: false, triangulate: false, useSymmetry: false, symmetryAxis: 0, symmetryTolerance: 1e-4 },
        } } });
        return;
      }
      if (event.data.requestId !== decimateRequestId) return;
      worker.terminate();
      if (!event.data.ok || !event.data.result?.snapshot || !event.data.result.geometryDelta?.replaced[0] || !event.data.result.simplify) {
        reject(new Error(event.data.error?.message ?? "native decimate command failed"));
        return;
      }
      const mesh = event.data.result.snapshot.meshes[0];
      const geometry = event.data.result.geometryDelta.replaced[0];
      resolve({
        originalTriangles: 12,
        outputTriangles: mesh.triangleCount ?? 0,
        reportedOriginal: event.data.result.simplify.originalTriangleCount,
        reportedOutput: event.data.result.simplify.outputTriangleCount,
        originalVertices: 8,
        outputVertices: mesh.vertexCount,
        geometryBytes: geometry.positions.byteLength + geometry.indices.byteLength,
        normals: geometry.normals ? new Float32Array(geometry.normals).length : 0,
        corners: geometry.triangleCornerIndices ? new Uint32Array(geometry.triangleCornerIndices).length : 0,
        uvs: geometry.uvs ? new Float32Array(geometry.uvs).length : 0,
        materials: geometry.triangleMaterialIndices ? new Uint32Array(geometry.triangleMaterialIndices).length : 0,
      });
    };
    worker.onerror = (event) => { worker.terminate(); reject(new Error(event.message)); };
    const buffer = input.buffer.slice(input.byteOffset, input.byteOffset + input.byteLength);
    worker.postMessage({ requestId: openRequestId, command: { type: "openBlend", buffer } }, [buffer]);
  }), new Uint8Array(bytes));
  expect(result.outputTriangles).toBeLessThan(result.originalTriangles);
  expect(result.reportedOriginal).toBe(result.originalTriangles);
  expect(result.reportedOutput).toBe(result.outputTriangles);
  expect(result.outputVertices).toBeLessThan(result.originalVertices);
  expect(result.geometryBytes).toBeGreaterThan(0);
  expect(result.normals).toBe(result.outputVertices * 3);
  expect(result.corners).toBe(result.outputTriangles * 3);
  expect(result.uvs).toBe(result.outputTriangles * 6);
  expect(result.materials).toBe(result.outputTriangles);
});

test("previews Decimate on an isolated WASM handle without changing source revision", async ({ page }) => {
  await page.goto("/");
  const bytes = await import("node:fs").then((fs) => fs.readFileSync(basicBlend));
  const result = await page.evaluate((input) => new Promise<{ openedRevision: number; previewRevision: number; previewTriangles: number; sourceRevision: number; sourceTriangles: number }>((resolve, reject) => {
    const worker = new Worker("/src/workers/web-engine.worker.ts", { type: "module" });
    const openRequestId = "e2e-preview-open";
    const previewRequestId = "e2e-preview-run";
    const sourceRequestId = "e2e-preview-source";
    let previewTriangles = 0;
    worker.onmessage = (event: MessageEvent<{ kind: string; requestId: string; ok?: boolean; result?: { snapshot?: { revision: number; meshes: Array<{ id: string; triangleCount?: number }> }; simplify?: { outputTriangleCount: number } }; error?: { message: string } }>) => {
      if (event.data.kind !== "result") return;
      if (event.data.requestId === openRequestId && event.data.ok && event.data.result?.snapshot) {
        const snapshot = event.data.result.snapshot;
        const mesh = snapshot.meshes[0];
        worker.postMessage({ requestId: previewRequestId, command: { type: "applyCommand", payload: {
          type: "previewDecimateMesh",
          meshId: mesh.id,
          profile: { schemaVersion: 1, sourceMeshRevision: snapshot.revision, attributePolicy: "PRESERVE", mode: "COLLAPSE", ratio: 0.5, triangulate: false, useSymmetry: false },
        } } });
        return;
      }
      if (event.data.requestId === previewRequestId && event.data.ok && event.data.result?.snapshot && event.data.result.simplify) {
        previewTriangles = event.data.result.snapshot.meshes[0].triangleCount ?? 0;
        worker.postMessage({ requestId: sourceRequestId, command: { type: "snapshot" } });
        return;
      }
      if (event.data.requestId !== sourceRequestId) return;
      worker.terminate();
      if (!event.data.ok || !event.data.result?.snapshot) {
        reject(new Error(event.data.error?.message ?? "preview source snapshot failed"));
        return;
      }
      resolve({
        openedRevision: 1,
        previewRevision: event.data.result.snapshot.revision,
        previewTriangles,
        sourceRevision: event.data.result.snapshot.revision,
        sourceTriangles: event.data.result.snapshot.meshes[0].triangleCount ?? 0,
      });
    };
    worker.onerror = (event) => { worker.terminate(); reject(new Error(event.message)); };
    const buffer = input.buffer.slice(input.byteOffset, input.byteOffset + input.byteLength);
    worker.postMessage({ requestId: openRequestId, command: { type: "openBlend", buffer } }, [buffer]);
  }), new Uint8Array(bytes));
  expect(result.openedRevision).toBe(1);
  expect(result.previewRevision).toBe(result.openedRevision);
  expect(result.previewTriangles).toBeLessThan(result.sourceTriangles);
  expect(result.sourceRevision).toBe(result.openedRevision);
  expect(result.sourceTriangles).toBe(12);
});

test("generates independent multi-level LOD geometry from the original mesh", async ({ page }) => {
  await page.goto("/");
  const bytes = await import("node:fs").then((fs) => fs.readFileSync(basicBlend));
  const result = await page.evaluate((input) => new Promise<{ sourceRevision: number; sourceTriangles: number; levels: Array<{ level: number; meshId: string; budget: number; triangles: number; vertices: number; bytes: number }>; manifestBudgets: number[] }>((resolve, reject) => {
    const worker = new Worker("/src/workers/web-engine.worker.ts", { type: "module" });
    const openRequestId = "e2e-lod-open";
    const generateRequestId = "e2e-lod-generate";
    const sourceRequestId = "e2e-lod-source";
    let generated: { levels: Array<{ level: number; meshId: string; triangleBudget: number; outputTriangleCount: number; outputVertexCount: number; geometryBuffers: Array<{ positions: ArrayBuffer; indices: ArrayBuffer }> }>; manifest: { sourceMeshRevision: number; levels: Array<{ triangleBudget: number }> } } | undefined;
    worker.onmessage = (event: MessageEvent<{ kind: string; requestId: string; ok?: boolean; result?: { snapshot?: { revision: number; meshes: Array<{ id: string; triangleCount?: number }> }; lod?: typeof generated }; error?: { message: string } }>) => {
      if (event.data.kind !== "result") return;
      if (event.data.requestId === openRequestId && event.data.ok && event.data.result?.snapshot) {
        const snapshot = event.data.result.snapshot;
        const mesh = snapshot.meshes[0];
        worker.postMessage({ requestId: generateRequestId, command: { type: "generateLOD", payload: {
          meshId: mesh.id,
          sourceMeshRevision: snapshot.revision,
          levels: [
            { triangleBudget: 10, profile: { schemaVersion: 1, sourceMeshRevision: snapshot.revision, attributePolicy: "PRESERVE", mode: "COLLAPSE", ratio: 0.9, triangulate: false, useSymmetry: false } },
            { triangleBudget: 6, profile: { schemaVersion: 1, sourceMeshRevision: snapshot.revision, attributePolicy: "PRESERVE", mode: "COLLAPSE", ratio: 0.5, triangulate: false, useSymmetry: false } },
          ],
        } } });
        return;
      }
      if (event.data.requestId === generateRequestId && event.data.ok && event.data.result?.lod) {
        generated = event.data.result.lod;
        worker.postMessage({ requestId: sourceRequestId, command: { type: "snapshot" } });
        return;
      }
      if (event.data.requestId !== sourceRequestId) return;
      worker.terminate();
      if (!event.data.ok || !event.data.result?.snapshot || !generated) {
        reject(new Error(event.data.error?.message ?? "LOD generation failed"));
        return;
      }
      resolve({
        sourceRevision: event.data.result.snapshot.revision,
        sourceTriangles: event.data.result.snapshot.meshes[0].triangleCount ?? 0,
        manifestBudgets: generated.manifest.levels.map((level) => level.triangleBudget),
        levels: generated.levels.map((level) => ({
          level: level.level,
          meshId: level.meshId,
          budget: level.triangleBudget,
          triangles: level.outputTriangleCount,
          vertices: level.outputVertexCount,
          bytes: level.geometryBuffers.reduce((total, geometry) => total + geometry.positions.byteLength + geometry.indices.byteLength, 0),
        })),
      });
    };
    worker.onerror = (event) => { worker.terminate(); reject(new Error(event.message)); };
    const buffer = input.buffer.slice(input.byteOffset, input.byteOffset + input.byteLength);
    worker.postMessage({ requestId: openRequestId, command: { type: "openBlend", buffer } }, [buffer]);
  }), new Uint8Array(bytes));
  expect(result.sourceRevision).toBe(1);
  expect(result.sourceTriangles).toBe(12);
  expect(result.manifestBudgets).toEqual([10, 6]);
  expect(result.levels).toHaveLength(2);
  expect(result.levels[0].meshId).toBe("mesh:Cube.001:lod:0");
  expect(result.levels[1].meshId).toBe("mesh:Cube.001:lod:1");
  expect(result.levels.every((level) => level.triangles > 0 && level.vertices > 0 && level.bytes > 0)).toBe(true);
});

test("isolates unstable native Collapse targets and keeps successful LOD levels", async ({ page }) => {
  await page.goto("/");
  const bytes = await import("node:fs").then((fs) => fs.readFileSync(basicBlend));
  const result = await page.evaluate((input) => new Promise<{ levels: number; errors: number }>((resolve, reject) => {
    const worker = new Worker("/src/workers/web-engine.worker.ts", { type: "module" });
    worker.onmessage = (event: MessageEvent<{ kind: string; requestId: string; ok?: boolean; result?: { snapshot?: { revision: number; meshes: Array<{ id: string; triangleCount?: number }> }; lod?: { levels: unknown[]; errors?: unknown[] } }; error?: { message: string } }>) => {
      if (event.data.kind !== "result") return;
      if (!event.data.ok) { worker.terminate(); reject(new Error(event.data.error?.message ?? "LOD isolation failed")); return; }
      if (event.data.requestId === "lod-unstable-open" && event.data.result?.snapshot) {
        const mesh = event.data.result.snapshot.meshes[0];
        worker.postMessage({ requestId: "lod-unstable-generate", command: { type: "generateLOD", payload: { meshId: mesh.id, sourceMeshRevision: event.data.result.snapshot.revision, levels: [
          { triangleBudget: 9, profile: { schemaVersion: 1, sourceMeshRevision: event.data.result.snapshot.revision, attributePolicy: "PRESERVE", mode: "COLLAPSE", ratio: 0.75, triangulate: false, useSymmetry: false } },
          { triangleBudget: 6, profile: { schemaVersion: 1, sourceMeshRevision: event.data.result.snapshot.revision, attributePolicy: "PRESERVE", mode: "COLLAPSE", ratio: 0.5, triangulate: false, useSymmetry: false } },
        ] } } });
      }
      else if (event.data.requestId === "lod-unstable-generate" && event.data.result?.lod) {
        worker.terminate();
        resolve({ levels: event.data.result.lod.levels.length, errors: event.data.result.lod.errors?.length ?? 0 });
      }
    };
    worker.onerror = (event) => { worker.terminate(); reject(new Error(event.message)); };
    const buffer = input.buffer.slice(input.byteOffset, input.byteOffset + input.byteLength);
    worker.postMessage({ requestId: "lod-unstable-open", command: { type: "openBlend", buffer } }, [buffer]);
  }), new Uint8Array(bytes));
  expect(result.levels).toBeGreaterThan(0);
  expect(result.errors).toBeGreaterThanOrEqual(0);
});

test("validates Blender Decimate and LOD profiles at the protocol boundary", async ({ page }) => {
  await page.goto("/");
  const result = await page.evaluate(async () => {
    return await new Promise<{ ok: boolean; profile?: { mode: string; ratio?: number; attributePolicy: string; skinMaxInfluences?: number }; levels?: number; errorCode?: string }>((resolve, reject) => {
      const worker = new Worker("/src/workers/simplify-test.worker.ts", { type: "module" });
      worker.onmessage = (event: MessageEvent<{ ok: boolean; profile?: { mode: string; ratio?: number; attributePolicy: string; skinMaxInfluences?: number }; levels?: number; errorCode?: string; error?: string }>) => {
        worker.terminate();
        if (!event.data.ok) reject(new Error(event.data.error ?? "simplify protocol failed"));
        else resolve(event.data);
      };
      worker.onerror = (event) => { worker.terminate(); reject(new Error(event.message)); };
      worker.postMessage({
        profile: {
          schemaVersion: 1,
          mode: "COLLAPSE",
          sourceMeshRevision: 4,
          ratio: 0.25,
          attributePolicy: "PRESERVE",
          skinPolicy: { maxInfluences: 4, minWeight: 0.001, maxPositionError: 0.01, shapeKeys: "REJECT" },
          triangleBudget: 1200,
          vertexGroup: "KeepHead",
          vertexGroupFactor: 0.8,
          vertexGroupInvert: false,
          triangulate: true,
          useSymmetry: true,
          symmetryAxis: 0,
          symmetryTolerance: 0.0001,
        },
        manifest: {
          schemaVersion: 1,
          meshId: "mesh:Character",
          sourceMeshRevision: 4,
          levels: [
            { level: 0, sourceMeshRevision: 4, triangleBudget: 4800, meshId: "mesh:Character:l0" },
            { level: 1, sourceMeshRevision: 4, triangleBudget: 1200, meshId: "mesh:Character:l1", screenSpaceError: 2 },
          ],
        },
        invalidProfile: { schemaVersion: 1, mode: "COLLAPSE", sourceMeshRevision: 4, ratio: 0.5, vertexGroupFactor: 0.2 },
      });
    });
  });
  expect(result).toEqual({ ok: true, profile: { mode: "COLLAPSE", ratio: 0.25, attributePolicy: "PRESERVE", skinMaxInfluences: 4 }, levels: 2, errorCode: "MISSING_VERTEX_GROUP" });
});

test("normalizes skin influences and rejects shape-key loss explicitly", async ({ page }) => {
  await page.goto("/");
  const result = await page.evaluate(() => new Promise<{ rejected: string; preservedAllowed: boolean; normalized?: number[] }>((resolve, reject) => {
    const worker = new Worker("/src/workers/skin-test.worker.ts", { type: "module" });
    worker.onmessage = (event: MessageEvent<{ ok: boolean; result?: { reason?: string; normalized?: { weights: number[] } }; error?: string }>) => {
      worker.terminate();
      if (!event.data.ok || !event.data.result) reject(new Error(event.data.error ?? "skin gate failed"));
      else resolve({ rejected: event.data.result.reason ?? "", preservedAllowed: event.data.result.allowed, normalized: event.data.result.normalized?.weights.slice(0, 4) });
    };
    worker.onerror = (event) => { worker.terminate(); reject(new Error(event.message)); };
    const skin = { boneNames: ["Root", "Arm"], indices: [0, 1, 0, 1, 0, 1, 0, 1], weights: [0.7, 0.3, 0, 0, 0.2, 0.8, 0, 0], bindMatrix: [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1] };
    const shapeKeys = [{ name: "Smile", positions: [0, 0, 0, 1, 0, 0] }];
    const policy = { maxInfluences: 2, minWeight: 0.001, maxPositionError: 0.01, shapeKeys: "REJECT" as const };
    worker.postMessage({ vertexCount: 2, skin, shapeKeys, policy: { ...policy, shapeKeys: "PRESERVE" } });
  }));
  const rejected = await page.evaluate(() => new Promise<string>((resolve, reject) => {
    const worker = new Worker("/src/workers/skin-test.worker.ts", { type: "module" });
    worker.onmessage = (event: MessageEvent<{ ok: boolean; result?: { reason?: string }; error?: string }>) => { worker.terminate(); if (!event.data.ok || !event.data.result) reject(new Error(event.data.error ?? "skin gate failed")); else resolve(event.data.result.reason ?? ""); };
    worker.onerror = (event) => { worker.terminate(); reject(new Error(event.message)); };
    worker.postMessage({ vertexCount: 2, skin: { boneNames: ["Root", "Arm"], indices: [0, 1, 0, 1, 0, 1, 0, 1], weights: [0.7, 0.3, 0, 0, 0.2, 0.8, 0, 0], bindMatrix: [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1] }, shapeKeys: [{ name: "Smile", positions: [0, 0, 0, 1, 0, 0] }], policy: { maxInfluences: 2, minWeight: 0.001, maxPositionError: 0.01, shapeKeys: "REJECT" } });
  }));
  result.rejected = rejected;
  expect(result).toEqual({ rejected: "SHAPE_KEYS_REJECTED", preservedAllowed: true, normalized: [0.7, 0.3, 0, 0] });
});

test("remaps skin weights and shape keys through the native Collapse worker path", async ({ page }) => {
  await page.goto("/");
  const bytes = await import("node:fs").then((fs) => fs.readFileSync(riggedBlend));
  const result = await page.evaluate((input) => new Promise<{ vertices: number; skinEntries: number; shapeEntries: number; normalized: boolean }>((resolve, reject) => {
    const worker = new Worker("/src/workers/web-engine.worker.ts", { type: "module" });
    const openId = "skin-remap-open";
    const disableDecimateId = "skin-remap-disable-decimate";
    const disableArmatureId = "skin-remap-disable-armature";
    const collapseId = "skin-remap-collapse";
    let meshId = "";
    let decimateUuid = "";
    let armatureUuid = "";
    const fail = (message: string) => { worker.terminate(); reject(new Error(message)); };
    worker.onmessage = (event: MessageEvent<{
      kind: string;
      requestId: string;
      ok?: boolean;
      result?: { snapshot?: { revision: number; meshes: Array<{ id: string; vertexCount: number; shapeKeys?: Array<{ positions: number[] }>; skinWeights?: { indices: number[]; weights: number[] }; modifierStack?: Array<{ uuid: string; type: string; name: string }> }> } };
      error?: { message: string };
    }>) => {
      if (event.data.kind !== "result") return;
      if (!event.data.ok || !event.data.result?.snapshot) return fail(event.data.error?.message ?? "skin remap worker request failed");
      const snapshot = event.data.result.snapshot;
      const mesh = snapshot.meshes.find((candidate) => candidate.id === meshId) ?? snapshot.meshes[0];
      if (!mesh) return fail("rigged mesh is missing");
      if (event.data.requestId === openId) {
        meshId = mesh.id;
        decimateUuid = mesh.modifierStack?.find((modifier) => modifier.name === "Preview Decimate")?.uuid ?? "";
        armatureUuid = mesh.modifierStack?.find((modifier) => modifier.type === "ARMATURE")?.uuid ?? "";
        if (!decimateUuid || !armatureUuid) return fail("rigged modifier stack is missing");
        worker.postMessage({ requestId: disableDecimateId, command: { type: "applyCommand", payload: { type: "setModifierEnabled", meshId, modifierUuid: decimateUuid, enabled: false } } });
        return;
      }
      if (event.data.requestId === disableDecimateId) {
        worker.postMessage({ requestId: disableArmatureId, command: { type: "applyCommand", payload: { type: "setModifierEnabled", meshId, modifierUuid: armatureUuid, enabled: false } } });
        return;
      }
      if (event.data.requestId === disableArmatureId) {
        worker.postMessage({ requestId: collapseId, command: { type: "applyCommand", payload: { type: "decimateMesh", meshId, profile: { schemaVersion: 1, sourceMeshRevision: snapshot.revision, attributePolicy: "PRESERVE", mode: "COLLAPSE", ratio: 0.5, vertexGroup: null, vertexGroupFactor: 1, vertexGroupInvert: false, triangulate: false, useSymmetry: false, symmetryAxis: 0, symmetryTolerance: 0.0001, skinPolicy: { maxInfluences: 4, minWeight: 0.001, maxPositionError: 0.001, shapeKeys: "PRESERVE" } } } } });
        return;
      }
      if (event.data.requestId !== collapseId || !mesh.skinWeights || !mesh.shapeKeys?.[0]) return fail("skin remap result is missing");
      const normalized = Array.from({ length: mesh.vertexCount }, (_, vertex) => {
        const total = mesh.skinWeights?.weights.slice(vertex * 4, vertex * 4 + 4).reduce((sum, weight) => sum + weight, 0) ?? 0;
        return Math.abs(total - 1) < 1e-5;
      }).every(Boolean);
      worker.terminate();
      resolve({ vertices: mesh.vertexCount, skinEntries: mesh.skinWeights.indices.length, shapeEntries: mesh.shapeKeys[0].positions.length, normalized });
    };
    worker.onerror = (event) => fail(event.message);
    const buffer = input.buffer.slice(input.byteOffset, input.byteOffset + input.byteLength);
    worker.postMessage({ requestId: openId, command: { type: "openBlend", buffer } }, [buffer]);
  }), new Uint8Array(bytes));
  expect(result).toEqual({ vertices: 3, skinEntries: 12, shapeEntries: 9, normalized: true });
});

test("reports GLB export blockers before any binary export", async ({ page }) => {
  await page.goto("/");
  const result = await page.evaluate(() => new Promise<{ canExport: boolean; codes: string[] }>((resolve, reject) => {
    const worker = new Worker("/src/workers/glb-test.worker.ts", { type: "module" });
    worker.onmessage = (event: MessageEvent<{ ok: boolean; report?: { canExport: boolean; warnings: Array<{ code: string }> }; error?: string }>) => { worker.terminate(); if (!event.data.ok || !event.data.report) reject(new Error(event.data.error ?? "GLB warning report missing")); else resolve({ canExport: event.data.report.canExport, codes: event.data.report.warnings.map((warning) => warning.code) }); };
    worker.onerror = (event) => { worker.terminate(); reject(new Error(event.message)); };
    worker.postMessage({ snapshot: { meshes: [{ id: "mesh:Summary", name: "Summary", geometryStatus: "summary-only", vertexCount: 0, edgeCount: 0, faceCount: 0, cornerCount: 0 }], images: [{ id: "image:External", name: "External", assetId: "asset:External", sourcePath: "textures/a.png" }], materials: [], nodes: [], collections: [], scenes: [] } });
  }));
  expect(result.canExport).toBe(false);
  expect(result.codes).toEqual(expect.arrayContaining(["SUMMARY_ONLY_MESH", "EXTERNAL_IMAGE"]));
});

test("blocks Shader graphs that cannot be mapped to glTF PBR", async ({ page }) => {
  await page.goto("/");
  const result = await page.evaluate(() => new Promise<{ canExport: boolean; codes: string[] }>((resolve, reject) => {
    const worker = new Worker("/src/workers/glb-test.worker.ts", { type: "module" });
    worker.onmessage = (event: MessageEvent<{ ok: boolean; report?: { canExport: boolean; warnings: Array<{ code: string }> }; error?: string }>) => {
      worker.terminate();
      if (!event.data.ok || !event.data.report) reject(new Error(event.data.error ?? "GLB Shader graph report missing"));
      else resolve({ canExport: event.data.report.canExport, codes: event.data.report.warnings.map((warning) => warning.code) });
    };
    worker.onerror = (event) => { worker.terminate(); reject(new Error(event.message)); };
    worker.postMessage({ snapshot: {
      meshes: [{ id: "mesh:Graph", name: "Graph", geometryStatus: "available", vertexCount: 3, edgeCount: 3, faceCount: 1, cornerCount: 3, topology: "triangles", positions: [0, 0, 0, 1, 0, 0, 0, 1, 0], indices: [0, 1, 2] }],
      materials: [{ id: "material:Graph", name: "Graph", baseColor: [1, 1, 1, 1], roughness: 0.5, metallic: 0, emissionColor: [0, 0, 0, 1], alpha: 1, ior: 1.45, nodes: [
        { id: "rgb", type: "RGB", name: "Color" },
        { id: "principled", type: "PRINCIPLED", name: "Principled" },
        { id: "output", type: "OUTPUT", name: "Output" },
      ], links: [
        { fromNodeId: "rgb", fromSocket: "Color", toNodeId: "principled", toSocket: "Base Color" },
        { fromNodeId: "principled", fromSocket: "BSDF", toNodeId: "output", toSocket: "Surface" },
      ] }],
      images: [], animations: [], nodes: [], collections: [], scenes: [], frame: { current: 1, start: 1, end: 1 },
    } });
  }));
  expect(result.canExport).toBe(false);
  expect(result.codes).toContain("SHADER_GRAPH_UNMAPPABLE");
});

test("maps bounded RGB and Value Shader constants to glTF PBR factors", async ({ page }) => {
  await page.goto("/");
  const result = await page.evaluate(() => new Promise<{ canExport: boolean; pbr?: { baseColorFactor?: number[]; roughnessFactor?: number; metallicFactor?: number } }>((resolve, reject) => {
    const worker = new Worker("/src/workers/glb-test.worker.ts", { type: "module" });
    worker.onmessage = (event: MessageEvent<{ ok: boolean; report?: { canExport: boolean }; pbrSummary?: { baseColorFactor?: number[]; roughnessFactor?: number; metallicFactor?: number }; error?: string }>) => {
      worker.terminate();
      if (!event.data.ok || !event.data.report) reject(new Error(event.data.error ?? "GLB Shader factor report missing"));
      else resolve({ canExport: event.data.report.canExport, pbr: event.data.pbrSummary });
    };
    worker.onerror = (event) => { worker.terminate(); reject(new Error(event.message)); };
    worker.postMessage({ snapshot: {
      meshes: [{ id: "mesh:Constants", name: "Constants", geometryStatus: "available", vertexCount: 3, edgeCount: 3, faceCount: 1, cornerCount: 3, topology: "triangles", positions: [0, 0, 0, 1, 0, 0, 0, 1, 0], indices: [0, 1, 2] }],
      materials: [{ id: "material:Constants", name: "Constants", baseColor: [1, 1, 1, 1], roughness: 0.5, metallic: 0.1, emissionColor: [0, 0, 0, 1], alpha: 1, ior: 1.45, nodes: [
        { id: "rgb", type: "RGB", name: "Color", defaultValue: [0.1, 0.3, 0.7, 1] },
        { id: "roughness", type: "VALUE", name: "Roughness", defaultValue: [0.42] },
        { id: "metallic", type: "VALUE", name: "Metallic", defaultValue: [0.75] },
        { id: "principled", type: "PRINCIPLED", name: "Principled" },
        { id: "output", type: "OUTPUT", name: "Output" },
      ], links: [
        { fromNodeId: "rgb", fromSocket: "Color", toNodeId: "principled", toSocket: "Base Color" },
        { fromNodeId: "roughness", fromSocket: "Value", toNodeId: "principled", toSocket: "Roughness" },
        { fromNodeId: "metallic", fromSocket: "Value", toNodeId: "principled", toSocket: "Metallic" },
        { fromNodeId: "principled", fromSocket: "BSDF", toNodeId: "output", toSocket: "Surface" },
      ] }],
      images: [], animations: [], nodes: [], collections: [], scenes: [], frame: { current: 1, start: 1, end: 1 },
    } });
  }));
  expect(result.canExport).toBe(true);
  expect(result.pbr?.baseColorFactor).toEqual([0.1, 0.3, 0.7, 1]);
  expect(result.pbr?.roughnessFactor).toBeCloseTo(0.42);
  expect(result.pbr?.metallicFactor).toBeCloseTo(0.75);
});

test("exports a local SceneIR mesh as a standards-shaped GLB", async ({ page }) => {
  await page.goto("/");
  const result = await page.evaluate(() => new Promise<{ canExport: boolean; byteLength: number; magic?: number; version?: number; firstMorphDelta?: number[] }>((resolve, reject) => {
    const worker = new Worker("/src/workers/glb-test.worker.ts", { type: "module" });
    const positions = new Float32Array([0, 0, 0, 1, 0, 0, 0, 1, 0]).buffer;
    const indices = new Uint32Array([0, 1, 2]).buffer;
    worker.onmessage = (event: MessageEvent<{ ok: boolean; report?: { canExport: boolean }; byteLength?: number; magic?: number; version?: number; firstMorphDelta?: number[]; error?: string }>) => {
      worker.terminate();
      if (!event.data.ok || !event.data.report) reject(new Error(event.data.error ?? "GLB export failed"));
      else resolve({ canExport: event.data.report.canExport, byteLength: event.data.byteLength ?? 0, magic: event.data.magic, version: event.data.version, firstMorphDelta: event.data.firstMorphDelta });
    };
    worker.onerror = (event) => { worker.terminate(); reject(new Error(event.message)); };
    worker.postMessage({
      snapshot: {
        schemaVersion: 1,
        revision: 1,
        sceneId: "scene:test",
        source: { kind: "mock" },
        coordinateSystem: { upAxis: "Z", forwardAxis: "-Y", handedness: "RIGHT", unitSystem: 0, unitScale: 1 },
        nodes: [{ id: "object:Triangle", name: "Triangle", type: "MESH", parentId: null, dataId: "mesh:Triangle", visible: true, selectable: true, localMatrix: [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1], worldMatrix: [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1], transform: { translation: [0, 0, 0], rotationEuler: [0, 0, 0], scale: [1, 1, 1], rotationMode: 1 } }],
        meshes: [{ id: "mesh:Triangle", name: "Triangle", vertexCount: 3, edgeCount: 3, faceCount: 1, cornerCount: 3, triangleCount: 1, geometryStatus: "binary", geometryBufferId: "mesh:Triangle", topology: "triangles", shapeKeys: [{ name: "Lift", positions: [0, 0, 0.5, 1, 0, 0, 0, 1, 0] }] }],
        materials: [], cameras: [], lights: [], worlds: [], images: [], animations: [], collections: [], scenes: [], activeObjectId: "object:Triangle", frame: { current: 1, start: 1, end: 1 },
      },
      geometryBuffers: [{ schemaVersion: 1, meshId: "mesh:Triangle", byteLength: positions.byteLength + indices.byteLength, positions, indices }],
    }, [positions, indices]);
  }));
  expect(result.canExport).toBe(true);
  expect(result.byteLength).toBeGreaterThan(20);
  expect(result.magic).toBe(0x46546c67);
  expect(result.version).toBe(2);
  expect(result.firstMorphDelta?.map((value) => Number(value.toFixed(4)))).toEqual([0, 0.5, 0]);
});

test("keeps per-vertex UV and color attributes in GLB output", async ({ page }) => {
  await page.goto("/");
  const result = await page.evaluate(() => new Promise<{ ok: boolean; error?: string }>((resolve, reject) => {
    const worker = new Worker("/src/workers/glb-test.worker.ts", { type: "module" });
    const positions = new Float32Array([0, 0, 0, 1, 0, 0, 0, 1, 0]).buffer;
    const indices = new Uint32Array([0, 1, 2]).buffer;
    const uvs = new Float32Array([0, 0, 1, 0, 0, 1]).buffer;
    const colors = new Float32Array([1, 0, 0, 1, 0, 1, 0, 1, 0, 0, 1, 1]).buffer;
    worker.onmessage = (event: MessageEvent<{ ok: boolean; attributes?: string[]; error?: string }>) => {
      worker.terminate();
      if (!event.data.ok) reject(new Error(event.data.error ?? "GLB vertex attributes failed"));
      else resolve({ ok: event.data.attributes?.includes("TEXCOORD_0") === true && event.data.attributes?.includes("COLOR_0") === true, error: event.data.error });
    };
    worker.onerror = (event) => { worker.terminate(); reject(new Error(event.message)); };
    worker.postMessage({
      snapshot: {
        schemaVersion: 1, revision: 1, sceneId: "scene:attributes", source: { kind: "mock" },
        nodes: [], meshes: [{ id: "mesh:Triangle", name: "Triangle", vertexCount: 3, edgeCount: 3, faceCount: 1, cornerCount: 3, triangleCount: 1, geometryStatus: "binary", geometryBufferId: "mesh:Triangle", topology: "triangles" }],
        materials: [], cameras: [], lights: [], worlds: [], images: [], animations: [], collections: [], scenes: [], activeObjectId: null,
        frame: { current: 1, start: 1, end: 1 },
      },
      geometryBuffers: [{ schemaVersion: 1, meshId: "mesh:Triangle", byteLength: positions.byteLength + indices.byteLength + uvs.byteLength + colors.byteLength, positions, indices, uvs, colors }],
    }, [positions, indices, uvs, colors]);
  }));
  expect(result).toEqual({ ok: true });
});

test("evaluates modifier dependency order and blocks unevaluated or cyclic stacks", async ({ page }) => {
  await page.goto("/");
  const result = await page.evaluate(() => new Promise<{ status: string; order: string[]; cycleStatus: string; cycleBlockedBy: string[] }>((resolve, reject) => {
    const worker = new Worker("/src/workers/modifier-graph-test.worker.ts", { type: "module" });
    worker.onmessage = (event: MessageEvent<{ ok: boolean; report?: { status: string; order: string[] }; cycle?: { status: string; blockedBy: string[] }; error?: string }>) => {
      worker.terminate();
      if (!event.data.ok || !event.data.report || !event.data.cycle) reject(new Error(event.data.error ?? "modifier graph report missing"));
      else resolve({ status: event.data.report.status, order: event.data.report.order, cycleStatus: event.data.cycle.status, cycleBlockedBy: event.data.cycle.blockedBy });
    };
    worker.onerror = (event) => { worker.terminate(); reject(new Error(event.message)); };
    worker.postMessage({});
  }));
  expect(result).toEqual({ status: "METADATA_ONLY", order: ["mod:source", "mod:decimate"], cycleStatus: "BLOCKED", cycleBlockedBy: ["MODIFIER_DEPENDENCY_CYCLE"] });
});

test("embeds local textures and exports glTF skin and animation records", async ({ page }) => {
  await page.goto("/");
  const textureBytes = await import("node:fs").then((fs) => fs.readFileSync(localTexturePng));
  const result = await page.evaluate((input) => new Promise<{ canExport: boolean; imageCount: number; skinCount: number; animationCount: number; imageByteLength: number; imageMimeType?: string; imageSignature: number[]; skinJointCount: number; animationChannelCount: number; inverseBindType?: string; attributes: string[]; roundTripCompatible: boolean; roundTripMismatches: string[] }>((resolve, reject) => {
    const worker = new Worker("/src/workers/glb-test.worker.ts", { type: "module" });
    const positions = new Float32Array([0, 0, 0, 1, 0, 0, 0, 1, 0]).buffer;
    const indices = new Uint32Array([0, 1, 2]).buffer;
    const texture = input.buffer.slice(input.byteOffset, input.byteOffset + input.byteLength);
    worker.onmessage = (event: MessageEvent<{ ok: boolean; report?: { canExport: boolean }; attributes?: string[]; gltfSummary?: { imageCount: number; skinCount: number; animationCount: number; imageByteLength: number; imageMimeType?: string; imageSignature: number[]; skinJointCount: number; animationChannelCount: number; inverseBindType?: string }; roundTrip?: { compatible: boolean; mismatches: string[] }; error?: string }>) => {
      worker.terminate();
      if (!event.data.ok || !event.data.report || !event.data.gltfSummary || !event.data.roundTrip) reject(new Error(event.data.error ?? "GLB skin export failed"));
      else resolve({ canExport: event.data.report.canExport, ...event.data.gltfSummary, attributes: event.data.attributes ?? [], roundTripCompatible: event.data.roundTrip.compatible, roundTripMismatches: event.data.roundTrip.mismatches });
    };
    worker.onerror = (event) => { worker.terminate(); reject(new Error(event.message)); };
    worker.postMessage({
      snapshot: {
        schemaVersion: 1, revision: 3, sceneId: "scene:skin", source: { kind: "mock" },
        nodes: [
          { id: "object:Armature", name: "Armature", type: "ARMATURE", parentId: null, dataId: "armature:Rig", visible: true, selectable: true, localMatrix: [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1], worldMatrix: [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1], transform: { translation: [0, 0, 0], rotationEuler: [0, 0, 0], scale: [1, 1, 1], rotationMode: 1 } },
          { id: "object:Triangle", name: "Triangle", type: "MESH", parentId: null, dataId: "mesh:Triangle", visible: true, selectable: true, localMatrix: [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1], worldMatrix: [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1], transform: { translation: [0, 0, 0], rotationEuler: [0, 0, 0], scale: [1, 1, 1], rotationMode: 1 } },
        ],
        meshes: [{ id: "mesh:Triangle", name: "Triangle", vertexCount: 3, edgeCount: 3, faceCount: 1, cornerCount: 3, triangleCount: 1, geometryStatus: "binary", geometryBufferId: "mesh:Triangle", topology: "triangles", materialSlotIds: ["material:Skin"], skinWeights: { boneNames: ["Root", "Tip"], indices: [0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0], weights: [0.5, 0.5, 0, 0, 0.5, 0.5, 0, 0, 0.5, 0.5, 0, 0], bindMatrix: [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1], armatureId: "armature:Rig", jointIds: ["bone:Root", "bone:Tip"] } }],
        armatures: [{ id: "armature:Rig", name: "Rig", objectId: "object:Armature", bones: [
          { id: "bone:Root", name: "Root", parentId: null, head: [0, 0, 0], tail: [0, 0, 1], restMatrix: [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1], poseMatrix: [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1] },
          { id: "bone:Tip", name: "Tip", parentId: "bone:Root", head: [0, 0, 1], tail: [0, 0, 2], restMatrix: [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1], poseMatrix: [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1] },
        ] }],
        materials: [{ id: "material:Skin", name: "Skin", baseColor: [1, 1, 1, 1], roughness: 0.5, metallic: 0, emissionColor: [0, 0, 0, 1], alpha: 1, ior: 1.45, imageIds: ["image:Texture"] }],
        cameras: [], lights: [], worlds: [], images: [{ id: "image:Texture", name: "Texture", assetId: "asset:Texture", mimeType: "image/png", sourcePath: "texture.png" }], collections: [], scenes: [], activeObjectId: "object:Triangle",
        animations: [{ id: "action:Move", name: "Move", targetId: "object:Triangle", frameStart: 1, frameEnd: 2, channels: [{ path: "location[0]", keyframes: [{ frame: 1, value: [0] }, { frame: 2, value: [1] }] }, { path: "location[1]", keyframes: [{ frame: 1, value: [0] }, { frame: 2, value: [0] }] }, { path: "location[2]", keyframes: [{ frame: 1, value: [0] }, { frame: 2, value: [0] }] }] }],
        frame: { current: 1, start: 1, end: 2 },
      },
      geometryBuffers: [{ schemaVersion: 1, meshId: "mesh:Triangle", byteLength: positions.byteLength + indices.byteLength, positions, indices }],
      assetBuffers: [{ assetId: "asset:Texture", mimeType: "image/png", data: texture }],
    }, [positions, indices, texture]);
  }), new Uint8Array(textureBytes));
  expect(result.canExport).toBe(true);
  expect(result.imageCount).toBe(1);
  expect(result.skinCount).toBe(1);
  expect(result.animationCount).toBe(1);
  expect(result.imageByteLength).toBe(textureBytes.byteLength);
  expect(result.imageMimeType).toBe("image/png");
  expect(result.imageSignature).toEqual([137, 80, 78, 71, 13, 10, 26, 10]);
  expect(result.skinJointCount).toBe(2);
  expect(result.animationChannelCount).toBeGreaterThan(0);
  expect(result.inverseBindType).toBe("MAT4");
  expect(result.attributes).toEqual(expect.arrayContaining(["JOINTS_0", "WEIGHTS_0"]));
  expect(result.roundTripCompatible, result.roundTripMismatches.join("; ")).toBe(true);
  expect(result.roundTripMismatches).toEqual([]);
});

test("reports lightweight budget violations without altering usage", async ({ page }) => {
  await page.goto("/");
  const result = await page.evaluate(() => new Promise<{ withinBudget: boolean; violations: Array<[string, number]>; usage: Record<string, number> }>((resolve, reject) => {
    const worker = new Worker("/src/workers/budget-test.worker.ts", { type: "module" });
    const usage = { triangles: 1200, vertices: 700, indexBytes: 14400, materialSlots: 3, textureBytes: 4096, gpuBytes: 32768 };
    worker.onmessage = (event: MessageEvent<{ ok: boolean; report?: { withinBudget: boolean; violations: Array<{ metric: string; excess: number }>; usage: Record<string, number> }; error?: string }>) => {
      worker.terminate();
      if (!event.data.ok || !event.data.report) reject(new Error(event.data.error ?? "budget report missing"));
      else resolve({ withinBudget: event.data.report.withinBudget, violations: event.data.report.violations.map((item) => [item.metric, item.excess]), usage: event.data.report.usage });
    };
    worker.onerror = (event) => { worker.terminate(); reject(new Error(event.message)); };
    worker.postMessage({ budget: { schemaVersion: 1, triangles: 1000, vertices: 800, gpuBytes: 20000 }, usage });
  }));
  expect(result.withinBudget).toBe(false);
  expect(result.violations).toEqual([["triangles", 200], ["gpuBytes", 12768]]);
  expect(result.usage).toEqual({ triangles: 1200, vertices: 700, indexBytes: 14400, materialSlots: 3, textureBytes: 4096, gpuBytes: 32768 });
});

test("aggregates project, collection, object and LOD budgets without double counting LOD", async ({ page }) => {
  await page.goto("/");
  const result = await page.evaluate(() => new Promise<{ project: number; collection: number; object: number; lod: number; projectActual: number }>((resolve, reject) => {
    const worker = new Worker("/src/workers/budget-aggregation-test.worker.ts", { type: "module" });
    worker.onmessage = (event: MessageEvent<{ ok: boolean; report?: { project?: { violations: Array<{ excess: number }>; usage: { triangles: number } }; collections: Record<string, { violations: Array<{ excess: number }> }>; objects: Record<string, { violations: Array<{ excess: number }> }>; lod: Record<string, { violations: Array<{ excess: number }> }>; }; error?: string }>) => {
      worker.terminate();
      if (!event.data.ok || !event.data.report?.project) reject(new Error(event.data.error ?? "budget aggregation report missing"));
      else resolve({
        project: event.data.report.project.violations[0]?.excess ?? 0,
        collection: event.data.report.collections.B?.violations[0]?.excess ?? 0,
        object: event.data.report.objects.A?.violations[0]?.excess ?? 0,
        lod: event.data.report.lod.L0?.violations[0]?.excess ?? 0,
        projectActual: event.data.report.project.usage.triangles,
      });
    };
    worker.onerror = (event) => { worker.terminate(); reject(new Error(event.message)); };
    const usage = (triangles: number) => ({ triangles, vertices: triangles, indexBytes: triangles * 12, materialSlots: 1, textureBytes: 0, gpuBytes: triangles * 16 });
    worker.postMessage({
      objects: [{ objectId: "A", collectionIds: ["A", "B"], usage: usage(100) }, { objectId: "B", collectionIds: ["B"], usage: usage(50) }],
      lod: [{ lodId: "L0", objectId: "A", usage: usage(25) }],
      scopes: { project: { schemaVersion: 1, triangles: 120 }, collections: { B: { schemaVersion: 1, triangles: 120 } }, objects: { A: { schemaVersion: 1, vertices: 90 } }, lod: { L0: { schemaVersion: 1, triangles: 20 } } },
    });
  }));
  expect(result).toEqual({ project: 30, collection: 30, object: 10, lod: 5, projectActual: 150 });
});

test("round-trips LOD geometry through the local binary mesh cache container", async ({ page }) => {
  await page.goto("/");
  const result = await page.evaluate(() => new Promise<{ byteLength: number; meshId: string; positionBytes: number; uvBytes: number }>((resolve, reject) => {
    const worker = new Worker("/src/workers/mesh-cache-test.worker.ts", { type: "module" });
    worker.onmessage = (event: MessageEvent<{ ok: boolean; byteLength?: number; levels?: Array<{ geometryBuffers: Array<{ meshId: string; positions: ArrayBuffer; uvs?: ArrayBuffer }> }>; error?: string }>) => {
      worker.terminate();
      if (!event.data.ok || !event.data.levels?.[0]?.geometryBuffers[0]) reject(new Error(event.data.error ?? "mesh cache round trip failed"));
      else {
        const geometry = event.data.levels[0].geometryBuffers[0];
        resolve({ byteLength: event.data.byteLength ?? 0, meshId: geometry.meshId, positionBytes: geometry.positions.byteLength, uvBytes: geometry.uvs?.byteLength ?? 0 });
      }
    };
    worker.onerror = (event) => { worker.terminate(); reject(new Error(event.message)); };
    const positions = new Float32Array([0, 0, 0, 1, 0, 0, 0, 1, 0]).buffer;
    const indices = new Uint32Array([0, 1, 2]).buffer;
    const uvs = new Float32Array([0, 0, 1, 0, 0, 1]).buffer;
    worker.postMessage({ levels: [{ level: 0, meshId: "mesh-cache-l0", triangleBudget: 1, outputTriangleCount: 1, outputVertexCount: 3, geometryBuffers: [{ schemaVersion: 1, meshId: "mesh-cache-l0", byteLength: positions.byteLength + indices.byteLength + uvs.byteLength, positions, indices, uvs }] }] }, [positions, indices, uvs]);
  }));
  expect(result.byteLength).toBeGreaterThan(result.positionBytes + result.uvBytes);
  expect(result.meshId).toBe("mesh-cache-l0");
  expect(result.positionBytes).toBe(36);
  expect(result.uvBytes).toBe(24);
});

test("blocks ImageIR paths outside the project asset sandbox", async ({ page }) => {
  await page.goto("/");
  const bytes = await import("node:fs").then((fs) => fs.readFileSync(attributeBlend));
  const result = await page.evaluate((input) => new Promise<{ status: string; assetId: string; sourcePath?: string; safeSourcePath?: string; pathStatus?: string; errorCode?: string; hasBase64: boolean }>((resolve, reject) => {
    const worker = new Worker("/src/workers/web-engine.worker.ts", { type: "module" });
    const openRequestId = "e2e-asset-open";
    const assetRequestId = "e2e-asset-request";
    worker.onmessage = (event: MessageEvent<{ kind: string; requestId: string; ok?: boolean; result?: { asset?: { status: string; assetId: string; sourcePath?: string; [key: string]: unknown } }; error?: { message: string } }>) => {
      if (event.data.kind !== "result") return;
      if (event.data.requestId === openRequestId && event.data.ok) {
        worker.postMessage({ requestId: assetRequestId, command: { type: "requestAsset", assetId: "image:AttributeTexture" } });
        return;
      }
      if (event.data.requestId !== assetRequestId) return;
      worker.terminate();
      if (!event.data.ok || !event.data.result?.asset) {
        reject(new Error(event.data.error?.message ?? "asset request failed"));
        return;
      }
      const asset = event.data.result.asset;
      resolve({
        status: asset.status,
        assetId: asset.assetId,
        sourcePath: asset.sourcePath,
        safeSourcePath: typeof asset.safeSourcePath === "string" ? asset.safeSourcePath : undefined,
        pathStatus: typeof asset.pathStatus === "string" ? asset.pathStatus : undefined,
        errorCode: typeof asset.errorCode === "string" ? asset.errorCode : undefined,
        hasBase64: Object.keys(asset).some((key) => key.toLowerCase().includes("base64")),
      });
    };
    worker.onerror = (event) => { worker.terminate(); reject(new Error(event.message)); };
    const buffer = input.buffer.slice(input.byteOffset, input.byteOffset + input.byteLength);
    worker.postMessage({ requestId: openRequestId, command: { type: "openBlend", buffer } }, [buffer]);
  }), new Uint8Array(bytes));
  expect(result.status).toBe("blocked");
  expect(result.assetId).toBe("image:AttributeTexture");
  expect(result.sourcePath).toMatch(/textures\/attribute\.png$/);
  expect(result.safeSourcePath).toBeUndefined();
  expect(result.pathStatus).toBe("blocked");
  expect(result.errorCode).toBe("ASSET_PATH_OUTSIDE_PROJECT");
  expect(result.hasBase64).toBe(false);
});

test("extracts Blender packed image bytes through the local asset request API", async ({ page }) => {
  await page.goto("/");
  const packedBlend = path.resolve(import.meta.dirname, "../../../tests/files/web/packed_image_scene.blend");
  const expectedTexture = path.resolve(import.meta.dirname, "../../../tests/golden/W-010/desktop-1440x900.png");
  const bytes = await import("node:fs").then((fs) => fs.readFileSync(packedBlend));
  const expected = await import("node:fs").then((fs) => fs.readFileSync(expectedTexture));
  const result = await page.evaluate((input) => new Promise<{ status: string; byteLength: number; packedByteLength?: number; signature: number[]; mimeType?: string }>((resolve, reject) => {
    const worker = new Worker("/src/workers/web-engine.worker.ts", { type: "module" });
    const openRequestId = "e2e-packed-open";
    const assetRequestId = "e2e-packed-request";
    let packedByteLength: number | undefined;
    worker.onmessage = (event: MessageEvent<{ kind: string; requestId: string; ok?: boolean; result?: { snapshot?: { images: Array<{ assetId: string; packedByteLength?: number }> }; asset?: { status: string; data?: ArrayBuffer; mimeType?: string } }; error?: { message: string } }>) => {
      if (event.data.kind !== "result") return;
      if (event.data.requestId === openRequestId && event.data.ok) {
        const image = event.data.result?.snapshot?.images.find((candidate) => candidate.assetId === "image:PackedTexture");
        if (!image) {
          worker.terminate();
          reject(new Error("packed SceneIR image missing"));
          return;
        }
        packedByteLength = image.packedByteLength;
        worker.postMessage({ requestId: assetRequestId, command: { type: "requestAsset", assetId: "image:PackedTexture" } });
        return;
      }
      if (event.data.requestId !== assetRequestId) return;
      worker.terminate();
      const asset = event.data.result?.asset;
      if (!event.data.ok || !asset?.data) {
        reject(new Error(event.data.error?.message ?? "packed asset request failed"));
        return;
      }
      const data = new Uint8Array(asset.data);
      resolve({ status: asset.status, byteLength: data.byteLength, packedByteLength, signature: Array.from(data.slice(0, 8)), mimeType: asset.mimeType });
    };
    worker.onerror = (event) => { worker.terminate(); reject(new Error(event.message)); };
    const buffer = input.buffer.slice(input.byteOffset, input.byteOffset + input.byteLength);
    worker.postMessage({ requestId: openRequestId, command: { type: "openBlend", buffer } }, [buffer]);
  }), new Uint8Array(bytes));
  expect(result.status).toBe("packed");
  expect(result.byteLength).toBe(expected.byteLength);
  expect(result.packedByteLength).toBe(expected.byteLength);
  expect(result.mimeType).toBe("image/png");
  expect(result.signature).toEqual([137, 80, 78, 71, 13, 10, 26, 10]);
});

test("matches Blender Depsgraph deformation golden within the declared error budget", async ({ page }) => {
  await page.goto("/");
  const bytes = await import("node:fs").then((fs) => fs.readFileSync(riggedBlend));
  const golden = JSON.parse(await import("node:fs").then((fs) => fs.readFileSync(deformationGolden, "utf8"))) as { positions: number[]; vertexCount: number; tolerance: { maxPositionError: number; rmsPositionError: number } };
  const result = await page.evaluate((input) => new Promise<{ vertexCount: number; maxError: number; rmsError: number; positions: number[] }>((resolve, reject) => {
    const engine = new Worker("/src/workers/web-engine.worker.ts", { type: "module" });
    const openRequestId = "e2e-deformation-open";
    engine.onmessage = (event: MessageEvent<{ kind: string; requestId: string; ok?: boolean; result?: { snapshot?: unknown; geometryBuffers?: Array<{ meshId: string; positions: ArrayBuffer }> }; error?: { message: string } }>) => {
      if (event.data.kind !== "result" || event.data.requestId !== openRequestId) return;
      if (!event.data.ok || !event.data.result?.snapshot) {
        engine.terminate();
        reject(new Error(event.data.error?.message ?? "deformation fixture open failed"));
        return;
      }
      const deformation = new Worker("/src/workers/deformation-test.worker.ts", { type: "module" });
      deformation.onmessage = (deformationEvent: MessageEvent<{ ok: boolean; positions?: number[]; error?: string }>) => {
        engine.terminate();
        deformation.terminate();
        if (!deformationEvent.data.ok || !deformationEvent.data.positions) reject(new Error(deformationEvent.data.error ?? "deformation evaluation failed"));
        else {
          const positions = deformationEvent.data.positions;
          resolve({ vertexCount: positions.length / 3, maxError: 0, rmsError: 0, positions });
        }
      };
      deformation.onerror = (error) => { engine.terminate(); deformation.terminate(); reject(new Error(error.message)); };
      deformation.postMessage({ snapshot: event.data.result.snapshot, meshId: "mesh:RiggedShapeMesh", geometryBuffers: event.data.result.geometryBuffers });
    };
    engine.onerror = (error) => { engine.terminate(); reject(new Error(error.message)); };
    const buffer = input.buffer.slice(input.byteOffset, input.byteOffset + input.byteLength);
    engine.postMessage({ requestId: openRequestId, command: { type: "openBlend", buffer } }, [buffer]);
  }), new Uint8Array(bytes));
  const errors = result.positions.map((value, index) => value - golden.positions[index]);
  const maxError = Math.max(...errors.map((value) => Math.abs(value)));
  const rmsError = Math.sqrt(errors.reduce((sum, value) => sum + value * value, 0) / errors.length);
  expect(result.vertexCount).toBe(golden.vertexCount);
  expect(maxError).toBeLessThanOrEqual(golden.tolerance.maxPositionError);
  expect(rmsError).toBeLessThanOrEqual(golden.tolerance.rmsPositionError);
});

test("evaluates the full Blender Depsgraph or reports its safe capability gate", async ({ page }) => {
  await page.goto("/");
  const bytes = await import("node:fs").then((fs) => fs.readFileSync(riggedBlend));
  const golden = JSON.parse(await import("node:fs").then((fs) => fs.readFileSync(deformationGolden, "utf8"))) as { positions: number[]; tolerance: { maxPositionError: number; rmsPositionError: number } };
  const result = await page.evaluate((input) => new Promise<{ report?: DepsgraphE2EReport; blocked?: { code?: string; message?: string } }>((resolve, reject) => {
    const engine = new Worker("/src/workers/web-engine.worker.ts", { type: "module" });
    const openRequestId = "e2e-depsgraph-open";
    const evalRequestId = "e2e-depsgraph-evaluate";
    engine.onmessage = (event: MessageEvent<{ kind: string; requestId: string; ok?: boolean; result?: { depsgraph?: DepsgraphE2EReport }; error?: { code?: string; message?: string } }>) => {
      if (event.data.kind !== "result") return;
      if (event.data.requestId === openRequestId && event.data.ok) {
        engine.postMessage({ requestId: evalRequestId, command: { type: "evaluateDepsgraph" } });
        return;
      }
      if (event.data.requestId !== evalRequestId) return;
      engine.terminate();
      if (!event.data.ok || !event.data.result?.depsgraph) {
        if (event.data.error?.code === "CAPABILITY_MISSING" && event.data.error.message?.includes("headless frame evaluation is memory-safe")) {
          resolve({ blocked: event.data.error });
          return;
        }
        reject(new Error(event.data.error?.message ?? "Depsgraph evaluation failed"));
        return;
      }
      resolve({ report: event.data.result.depsgraph });
    };
    engine.onerror = (error) => { engine.terminate(); reject(new Error(error.message)); };
    const buffer = input.buffer.slice(input.byteOffset, input.byteOffset + input.byteLength);
    engine.postMessage({ requestId: openRequestId, command: { type: "openBlend", buffer } }, [buffer]);
  }), new Uint8Array(bytes));
  if (result.blocked) {
    expect(result.blocked.code).toBe("CAPABILITY_MISSING");
    expect(result.blocked.message).toContain("headless frame evaluation is memory-safe");
    return;
  }
  expect(result.report).toBeDefined();
  if (!result.report) throw new Error("Depsgraph report missing after successful evaluation");
  expect(result.report.status).toBe("EVALUATED");
  expect(result.report.objectCount).toBeGreaterThanOrEqual(result.report.meshObjectCount);
  expect(result.report.meshObjectCount).toBeGreaterThan(0);
  const mesh = result.report.meshes.find((candidate) => candidate.sourceMeshId === "mesh:RiggedShapeMesh");
  expect(mesh).toBeDefined();
  expect(mesh?.vertexCount).toBeGreaterThan(0);
  expect(mesh?.triangleCount).toBeGreaterThan(0);
  expect(mesh?.positions).toHaveLength((mesh?.vertexCount ?? 0) * 3);
  expect(mesh?.indices).toHaveLength((mesh?.triangleCount ?? 0) * 3);
  expect(mesh?.modifierCount).toBeGreaterThan(0);
  expect(mesh?.modifiers.map((modifier) => modifier.type)).toEqual(["Armature", "Decimate"]);
  expect(mesh?.modifiers.map((modifier) => modifier.status)).toEqual(["EVALUATED", "BLOCKED"]);
  expect(mesh?.modifiers[1]?.showViewport).toBe(true);
  expect(mesh?.modifiers[1]?.errorCode).toBe("BLENDER_MODIFIER_ERROR");
  expect(mesh?.modifiers[0]?.targetObjectIds).toEqual(["object:RiggedArmatureObject"]);
  expect(mesh?.modifiers[1]?.dependsOn).toEqual([mesh?.modifiers[0]?.uuid]);
  const errors = (mesh?.positions ?? []).map((value, index) => value - golden.positions[index]);
  const maxError = Math.max(...errors.map((value) => Math.abs(value)));
  const rmsError = Math.sqrt(errors.reduce((sum, value) => sum + value * value, 0) / errors.length);
  expect(maxError).toBeLessThanOrEqual(golden.tolerance.maxPositionError);
  expect(rmsError).toBeLessThanOrEqual(golden.tolerance.rmsPositionError);
});

test("exports layered Action keyframes through SceneIR", async ({ page }) => {
  await page.goto("/");
  const bytes = await import("node:fs").then((fs) => fs.readFileSync(animationBlend));
  const result = await page.evaluate((input) => new Promise<{ frame: { start: number; end: number }; target: string; channels: Array<{ path: string; keyframes: number }> }>((resolve, reject) => {
    const worker = new Worker("/src/workers/web-engine.worker.ts", { type: "module" });
    const requestId = "e2e-animation-open";
    worker.onmessage = (event: MessageEvent<{
      kind: string;
      requestId: string;
      ok?: boolean;
      result?: {
        snapshot?: {
          frame: { start: number; end: number };
          animations: Array<{ targetId: string; channels: Array<{ path: string; keyframes: unknown[] }> }>;
        };
      };
      error?: { message: string };
    }>) => {
      if (event.data.requestId !== requestId || event.data.kind !== "result") return;
      worker.terminate();
      const snapshot = event.data.result?.snapshot;
      const animation = snapshot?.animations.find((item) => item.targetId === "object:AnimatedObject");
      if (!event.data.ok || !snapshot || !animation) {
        reject(new Error(event.data.error?.message ?? "animation response missing"));
        return;
      }
      resolve({ frame: snapshot.frame, target: animation.targetId, channels: animation.channels.map((channel) => ({ path: channel.path, keyframes: channel.keyframes.length })) });
    };
    worker.onerror = (event) => { worker.terminate(); reject(new Error(event.message)); };
    const buffer = input.buffer.slice(input.byteOffset, input.byteOffset + input.byteLength);
    worker.postMessage({ requestId, command: { type: "openBlend", buffer } }, [buffer]);
  }), new Uint8Array(bytes));
  expect(result.frame).toEqual({ current: 1, start: 1, end: 10 });
  expect(result.target).toBe("object:AnimatedObject");
  expect(result.channels).toEqual([
    { path: "location[0]", keyframes: 2 },
    { path: "location[1]", keyframes: 2 },
    { path: "location[2]", keyframes: 2 },
  ]);
});

test("patches changed mesh buffer ranges without replacing stable topology", async ({ page }) => {
  await page.goto("/");
  const result = await page.evaluate(async () => {
    const { applyMeshGeometryDelta, diffMeshGeometryBuffers } = await import("/src/three-adapter/geometry-delta.ts");
    const before = [{ schemaVersion: 1 as const, meshId: "mesh:range", byteLength: 36,
      positions: new Float32Array([0, 0, 0, 1, 1, 1]).buffer,
      indices: new Uint32Array([0, 1, 0]).buffer }];
    const after = [{ ...before[0], positions: new Float32Array([0, 0, 0, 1, 1.25, 1]).buffer }];
    const delta = diffMeshGeometryBuffers(before, after);
    const applied = applyMeshGeometryDelta(before, delta);
    return {
      patches: delta.patches.length,
      replaced: delta.replaced.length,
      patchBytes: delta.patches.reduce((total, patch) => total + patch.data.byteLength, 0),
      fullBytes: after[0].positions.byteLength,
      value: new Float32Array(applied[0].positions)[4],
    };
  });
  expect(result.replaced).toBe(0);
  expect(result.patches).toBeGreaterThan(0);
  expect(result.patchBytes).toBeLessThan(result.fullBytes);
  expect(result.value).toBe(1.25);
});

test("renders through the capability-gated OffscreenCanvas worker", async ({ page }) => {
  await page.goto("/?offscreen=1");
  const canvas = page.locator("canvas.viewport-canvas");
  await expect(canvas).toHaveAttribute("data-renderer-backend", "offscreen-worker");
  await expect(canvas).toHaveAttribute("data-pbr-profile", "physical-v1");
  await expect(canvas).toHaveAttribute("data-tone-mapping", "aces");
  await expect(canvas).toHaveAttribute("data-shadow-map", "pcf-1024");
  await page.setInputFiles("[data-testid=blend-file-input]", basicBlend);
  await expect(page.getByText("BasicCube", { exact: true })).toBeVisible();
  await expect.poll(async () => Number(await canvas.getAttribute("data-renderer-pixels") ?? "0"), { timeout: 20_000 }).toBeGreaterThan(0);
  expect(await canvas.getAttribute("data-renderer-error")).toBeNull();
});

test("coalesces linked mesh objects into a raycastable instance group", async ({ page }) => {
  await page.goto("/");
  await page.setInputFiles("[data-testid=blend-file-input]", basicBlend);
  await expect(page.getByText("BasicCube", { exact: true })).toBeVisible();
  await page.getByRole("button", { name: "链接复制对象" }).click();
  await expect(page.locator("canvas.viewport-canvas")).toHaveAttribute("data-instance-groups", "1");
});

test("returns structured gates for the undeclared capability protocols", async ({ page }) => {
  await page.goto("/");
  const result = await page.evaluate(async () => {
    type Response = { requestId: string; kind: string; ok?: boolean; error?: { code?: string; message?: string } };
    const worker = new Worker("/src/workers/web-engine.worker.ts", { type: "module" });
    const pending = new Map<string, (response: Response) => void>();
    worker.onmessage = (event: MessageEvent<Response>) => pending.get(event.data.requestId)?.(event.data);
    const send = (payload: unknown, requestId: string): Promise<Response> => new Promise((resolve) => {
      pending.set(requestId, resolve);
      worker.postMessage({ requestId, command: { type: "applyCommand", payload } });
    });
    const sample = { position: [0, 0, 0], normal: [0, 0, 1], radius: 0.25, strength: 0.5, pressure: 1, time: 0 };
    const sculpt = await send({ type: "sculptStroke", stroke: { schemaVersion: 1, meshId: "mesh:missing", brush: "DRAW", samples: Array.from({ length: 2049 }, () => sample), symmetry: [false, false, false], mirrorObjectSpace: true } }, "gate-sculpt");
    const sculptMirror = await send({ type: "sculptStroke", stroke: { schemaVersion: 1, meshId: "mesh:missing", brush: "DRAW", samples: [sample], symmetry: [true, false, false], mirrorObjectSpace: false } }, "gate-sculpt-mirror");
    const cycle = await send({ type: "setGeometryNodeGraph", meshId: "mesh:missing", graph: {
      schemaVersion: 1, id: "graph:cycle", name: "Cycle", interfaceInputs: [], interfaceOutputs: [],
      nodes: [
        { id: "a", type: "GeometryNodeTransform", name: "A", sockets: [{ id: "out", name: "Out", direction: "OUTPUT", dataType: "FLOAT" }, { id: "in", name: "In", direction: "INPUT", dataType: "FLOAT" }] },
        { id: "b", type: "GeometryNodeTransform", name: "B", sockets: [{ id: "out", name: "Out", direction: "OUTPUT", dataType: "FLOAT" }, { id: "in", name: "In", direction: "INPUT", dataType: "FLOAT" }] },
      ],
      links: [{ fromNodeId: "a", fromSocketId: "out", toNodeId: "b", toSocketId: "in" }, { fromNodeId: "b", fromSocketId: "out", toNodeId: "a", toSocketId: "in" }],
    } }, "gate-gn");
    const external = await send({ type: "setGeometryNodeGraph", meshId: "mesh:missing", graph: {
      schemaVersion: 1, id: "graph:external", name: "External", interfaceInputs: [], interfaceOutputs: [], links: [],
      nodes: [{ id: "object-info", type: "GeometryNodeObjectInfo", name: "Object Info", properties: { resourceId: "object:missing" }, sockets: [] }],
    } }, "gate-gn-external");
    const shader = await send({ type: "setShaderGraph", materialId: "material:missing", graph: {
      schemaVersion: 1, id: "shader:valid", materialId: "material:missing", outputNodeId: "out", nodes: [{ id: "out", type: "MATERIAL_OUTPUT", name: "Material Output", sockets: [] }], links: [],
    } }, "gate-shader");
    const arbitraryShader = await send({ type: "setShaderGraph", materialId: "material:missing", graph: {
      schemaVersion: 1, id: "shader:math", materialId: "material:missing", outputNodeId: "out", nodes: [
        { id: "mix", type: "MIX", name: "Mix", sockets: [] },
        { id: "out", type: "MATERIAL_OUTPUT", name: "Material Output", sockets: [] },
      ], links: [],
    } }, "gate-shader-arbitrary");
    const unsupportedMath = await send({ type: "setShaderGraph", materialId: "material:missing", graph: {
      schemaVersion: 1, id: "shader:power", materialId: "material:missing", outputNodeId: "out", nodes: [
        { id: "math", type: "MATH", name: "Power", properties: { operation: "POWER" }, sockets: [] },
        { id: "out", type: "MATERIAL_OUTPUT", name: "Material Output", sockets: [] },
      ], links: [],
    } }, "gate-shader-math-operation");
    const nla = await send({ type: "setNLAStack", objectId: "object:missing", tracks: [{
      schemaVersion: 1, id: "track:1", ownerId: "object:missing", name: "Track", muted: false, solo: false, selected: true,
      strips: [{ id: "strip:1", actionId: "action:missing", frameStart: 1, frameEnd: 10, actionFrameStart: 1, actionFrameEnd: 10, scale: 1, repeat: 1, blendIn: 0, blendOut: 0, influence: 1, blendMode: "REPLACE", extrapolation: "HOLD", muted: false, selected: true }],
    }] }, "gate-nla");
    worker.terminate();
    return { sculpt: sculpt.error, sculptMirror: sculptMirror.error, cycle: cycle.error, external: external.error, shader: shader.error, arbitraryShader: arbitraryShader.error, unsupportedMath: unsupportedMath.error, nla: nla.error };
  });
  expect(result.sculpt?.code).toBe("SCULPT_STROKE_BUDGET_EXCEEDED");
  expect(result.sculptMirror?.code).toBe("CAPABILITY_MISSING");
  expect(result.cycle?.code).toBe("GN_DEPENDENCY_CYCLE");
  expect(result.external?.code).toBe("GN_EXTERNAL_RESOURCE_MISSING");
  expect(result.shader?.code).toBe("SHADER_EXTERNAL_RESOURCE_MISSING");
  expect(result.shader?.message).toContain("N-013");
  expect(result.arbitraryShader?.code).toBe("SHADER_NODE_UNSUPPORTED");
  expect(result.unsupportedMath?.code).toBe("SHADER_NODE_UNSUPPORTED");
  expect(result.nla?.code).toBe("NLA_PATH_INCOMPATIBLE");
});

test("exposes PBR-007 to PBR-012 renderer security gates", async ({ page }) => {
  await page.goto("/");
  const result = await page.evaluate(() => new Promise<Record<string, { taskId: string; status: string; code?: string }>>((resolve, reject) => {
    type Response = { requestId: string; kind: string; ok?: boolean; result?: { capabilityGate?: { taskId: string; status: string; issues: Array<{ code: string }> } }; error?: { message?: string } };
    const worker = new Worker("/src/workers/web-engine.worker.ts", { type: "module" });
    const pending = new Map<string, (response: Response) => void>();
    worker.onmessage = (event: MessageEvent<Response>) => pending.get(event.data.requestId)?.(event.data);
    const send = (requestId: string, request: unknown): Promise<Response> => new Promise((resolveRequest) => {
      pending.set(requestId, resolveRequest);
      worker.postMessage({ requestId, command: { type: "queryRenderCapability", request } });
    });
    void Promise.all([
      send("gpu", { kind: "WEBGPU_BACKEND" }),
      send("bloom", { kind: "POSTPROCESS", passes: ["BLOOM"] }),
      send("volume", { kind: "VOLUME" }),
      send("sss", { kind: "SUBSURFACE" }),
      send("shader", { kind: "ARBITRARY_SHADER", nodeTypes: ["MIX"] }),
    ]).then((responses) => {
      worker.terminate();
      const output: Record<string, { taskId: string; status: string; code?: string }> = {};
      for (const [index, name] of ["gpu", "bloom", "volume", "sss", "shader"].entries()) {
        const gate = responses[index].result?.capabilityGate;
        output[name] = { taskId: gate?.taskId ?? "", status: gate?.status ?? "", code: gate?.issues[0]?.code };
      }
      resolve(output);
    }).catch(reject);
  }));
  expect(result.gpu).toEqual({ taskId: "PBR-012", status: "BLOCKED", code: "WEBGPU_RENDERER_UNAVAILABLE" });
  expect(result.bloom).toEqual({ taskId: "PBR-012", status: "BLOCKED", code: "POSTPROCESS_PASS_UNAVAILABLE" });
  expect(result.volume).toEqual({ taskId: "PBR-012", status: "BLOCKED", code: "VOLUME_SHADER_UNAVAILABLE" });
  expect(result.sss).toEqual({ taskId: "PBR-012", status: "BLOCKED", code: "SUBSURFACE_SHADER_UNAVAILABLE" });
  expect(result.shader).toEqual({ taskId: "PBR-012", status: "BLOCKED", code: "SHADER_NODE_UNSUPPORTED" });
});

test("transfers packed raster assets into the PBR viewport with an explicit status", async ({ page }) => {
  await page.goto("/");
  await page.setInputFiles("[data-testid=blend-file-input]", path.resolve(import.meta.dirname, "../../../tests/files/web/packed_image_scene.blend"));
  await expect(page.locator("[data-testid=scene-stats]")).toContainText("Objects", { timeout: 20_000 });
  const canvas = page.locator("canvas.viewport-canvas");
  await expect.poll(async () => Number(await canvas.getAttribute("data-texture-loaded") ?? "0"), { timeout: 20_000 }).toBeGreaterThan(0);
  await expect(canvas).toHaveAttribute("data-texture-status", "ready");
});

test("uses the same packed texture payload in the OffscreenCanvas renderer", async ({ page }) => {
  await page.goto("/?offscreen=1");
  await page.setInputFiles("[data-testid=blend-file-input]", path.resolve(import.meta.dirname, "../../../tests/files/web/packed_image_scene.blend"));
  const canvas = page.locator("canvas.viewport-canvas");
  await expect.poll(async () => Number(await canvas.getAttribute("data-texture-loaded") ?? "0"), { timeout: 20_000 }).toBeGreaterThan(0);
  await expect(canvas).toHaveAttribute("data-texture-status", "ready");
  await expect.poll(async () => Number(await canvas.getAttribute("data-renderer-pixels") ?? "0"), { timeout: 20_000 }).toBeGreaterThan(0);
});