@forgeax/engine-runtime 0.1.24 → 0.1.26

package/src/__tests__/render-system-extract.test.ts

@@ -178,6 +178,112 @@ import { makeMockShaderRegistry } from './helpers/mock-shader-registry';
       for (const renderable of frame.renderables) expect(renderable.material).toBe(first);
     });
 
+    it('projects the cooked Standard artifact identity into extraction and dispatch', () => {
+      const world = new World();
+      spawnCamera(world);
+      const assets = new AssetRegistry(makeMockShaderRegistry());
+      const mesh = registerMesh(world);
+      const materialGuid = '019ffa97-4000-7000-8000-000000000101';
+      const cookedShaderId = 'sha256:rusted-iron-cooked-specialization';
+      const cookedShadowShaderId = 'sha256:rusted-iron-cooked-shadow-specialization';
+      const materialContext = {
+        backend: 'webgpu' as const,
+        capability: 'storage-buffer' as const,
+        pipeline: 'forward' as const,
+        geometry: 'mesh' as const,
+        pass: 'forward' as const,
+        profile: 'forgeax-material-wgsl-v1' as const,
+        toolchain: 'naga-oil' as const,
+        instrumentation: 'none' as const,
+      };
+      const material = world.allocSharedRef<'MaterialAsset', MaterialAsset>('MaterialAsset', {
+        kind: 'material',
+        passes: [
+          {
+            name: 'forward',
+            program: {
+              module: 'forgeax_material::standard',
+              moduleSlots: { surface: 'game_3d::rusted_iron_surface' },
+            },
+            renderState: { tags: { LightMode: 'Forward' }, queue: 2000 },
+          },
+          {
+            name: 'shadow-caster',
+            program: {
+              module: 'forgeax_material::standard',
+              moduleSlots: { surface: 'game_3d::rusted_iron_surface' },
+            },
+            renderState: { tags: { LightMode: 'ShadowCaster' }, queue: 1000 },
+          },
+        ],
+        parameters: [
+          { name: 'baseColor', type: 'color' },
+          { name: 'metallic', type: 'f32' },
+          { name: 'roughness', type: 'f32' },
+        ],
+        values: { baseColor: [0.4, 0.45, 0.47, 1], metallic: 0.8, roughness: 0.25 },
+      });
+      vi.spyOn(assets, 'getMaterialProjectionForPayload').mockReturnValue({
+        materialGuid,
+        publicationGeneration: 1,
+        specializationKey: cookedShaderId,
+        artifactHash: 'sha256:rusted-iron-artifact',
+        passes: [
+          {
+            name: 'forward',
+            module: 'forgeax_material::standard',
+            moduleSlots: { surface: 'game_3d::rusted_iron_surface' },
+            artifactHash: 'sha256:rusted-iron-artifact',
+            programs: [
+              {
+                context: materialContext,
+                specializationKey: cookedShaderId,
+                artifactHash: 'sha256:rusted-iron-forward-artifact',
+              },
+            ],
+          },
+          {
+            name: 'shadow-caster',
+            module: 'forgeax_material::standard',
+            moduleSlots: { surface: 'game_3d::rusted_iron_surface' },
+            artifactHash: 'sha256:rusted-iron-artifact',
+            programs: [
+              {
+                context: { ...materialContext, pass: 'shadow' as const },
+                specializationKey: cookedShadowShaderId,
+                artifactHash: 'sha256:rusted-iron-shadow-artifact',
+              },
+            ],
+          },
+        ],
+        runtimeValues: {},
+        staticSelection: [],
+      });
+      world
+        .spawn(
+          { component: Transform, data: { ...identity(), pos: [0, 0, -2] } },
+          { component: MeshFilter, data: { assetHandle: mesh } },
+          { component: MeshRenderer, data: { materials: [material] } },
+        )
+        .unwrap();
+
+      const frame = extractFrame(world, prepareExtractContext(world, { assets, materialContext }));
+      expect(frame.renderables[0]?.material.materialShaderId).toBe(cookedShaderId);
+      const materialDispatch = frame.dispatch.filter((entry) => entry.materialHandle === material);
+      expect(materialDispatch).toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({
+            tags: { LightMode: 'Forward' },
+            materialShaderId: cookedShaderId,
+          }),
+          expect.objectContaining({
+            tags: { LightMode: 'ShadowCaster' },
+            materialShaderId: cookedShadowShaderId,
+          }),
+        ]),
+      );
+    });
+
     it('mesh-walk: RenderableSnapshot.transform.world is the resolved world mat4 (parent x child), zero per-snapshot compose', () => {
       const world = new World();
       world
@@ -574,7 +680,7 @@ import { makeMockShaderRegistry } from './helpers/mock-shader-registry';
   ): { handle: Handle<'MaterialAsset', 'shared'>; guid: AssetGuid } {
     const asset: MaterialAsset = {
       kind: 'material',
-      passes,
+      ...(passes === undefined ? {} : { passes }),
       values: values ?? {},
     } as unknown as MaterialAsset;
     if (parentGuid !== undefined) {

package/src/__tests__/shadow-caster-empty-schema.test.ts

@@ -1,16 +1,13 @@
 // @ts-nocheck — node:fs / node:path / node:url imports outside @types/node
 // coverage in runtime tsconfig (mirrors pipeline.unit.test.ts header).
-// shadow-caster-empty-schema.test.ts -- M4 / w21 explicit empty-schema gate.
+// shadow-caster-surface-schema.test.ts -- shared Surface shadow contract.
 //
 // feat-20260613-material-paramschema-driven-binding M4 / w21.
 //
 // Decision anchors (plan-strategy §2 + §3.4):
-//   - D-12  empty schema is graceful: derive([]) -> bglEntries=[],
-//           totalBytes=0, textureFieldNames=empty, samplerForTexture=empty,
-//           userRegionBindingEnd=0. The shadow_caster shader has zero
-//           @group(1) bindings and registers under an empty paramSchema.
-//   - the shadow-caster module has no authored material parameter sidecar;
-//           its empty MaterialAsset parameter list is derived at runtime.
+//   - derive([]) remains a valid generic empty-schema path.
+//   - the shadow-caster module has no authored sidecar; its generated
+//           MaterialParameters contract is the Standard pipeline schema.
 //
 // What this test asserts:
 //   (a) derive([]) produces all-empty / zero output -- the graceful path.
@@ -18,14 +15,13 @@
 //   (c) appendInjection over the empty user-region starts injected
 //       bindings at binding 0 (covered also in append-injection.test.ts;
 //       this test pins the empty-schema path explicitly).
-//   (d) The runtime registers `forgeax::default-shadow-caster` with
-//       paramSchema=[] (createRenderer.ts:3172) -- structural assertion that
-//       no static literal in createRenderer hardcodes a non-empty schema
-//       for this identifier.
+//   (d) The runtime fallback registers `forgeax::default-shadow-caster` with
+//       the shared Standard pipeline schema.
 
 import { existsSync, readFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { STANDARD_PIPELINE_PARAM_SCHEMA } from '@forgeax/engine-shader';
 import { derive } from '@forgeax/engine-types';
 import { describe, expect, it } from 'vitest';
 import { appendInjection } from '../../../render/src/pbr-pipeline';
@@ -36,7 +32,7 @@ const repoRoot = (() => {
   return join(here, '..', '..', '..', '..');
 })();
 
-describe('shadow_caster empty schema (M4 w21)', () => {
+describe('shadow_caster shared Surface schema', () => {
   it('(a) derive([]) returns all-empty/zero output (D-12 graceful path)', () => {
     const out = derive([]);
     expect(out.bglEntries.length).toBe(0);
@@ -66,7 +62,7 @@ describe('shadow_caster empty schema (M4 w21)', () => {
     expect(injected[0]?.binding).toBe(0);
   });
 
-  it('(d) shadow_caster register call site carries paramSchema: []', () => {
+  it('(d) shadow_caster fallback register call carries the Standard schema', () => {
     const createRendererPath = join(
       repoRoot,
       'packages',
@@ -77,7 +73,8 @@ describe('shadow_caster empty schema (M4 w21)', () => {
     );
     const src = readFileSync(createRendererPath, 'utf8');
     const re =
-      /installMaterialArtifact\(\s*shadowCasterIdentifier\s*,\s*\{[^}]*paramSchema\s*:\s*\[\s*\][^}]*\}\s*\)/s;
+      /installMaterialArtifact\(\s*shadowCasterIdentifier\s*,\s*\{[^}]*paramSchema\s*:\s*STANDARD_PIPELINE_PARAM_SCHEMA[^}]*\}\s*\)/s;
     expect(src).toMatch(re);
+    expect(STANDARD_PIPELINE_PARAM_SCHEMA.length).toBeGreaterThan(0);
   });
 });

package/src/__tests__/shadow-csm-runtime-vary.dawn.test.ts

@@ -83,6 +83,11 @@ describe('M3 RhiNull structural admission', () => {
 
 const WIDTH = 320;
 const HEIGHT = 240;
+const LIGHTWEIGHT_DAWN = process.env.FORGEAX_DAWN_LIGHTWEIGHT === '1';
+// The variation gate only needs to observe graph rebuilds. Keep the full
+// 2048 atlas for local/nightly diagnostics, while avoiding a 4-cascade 16MiB
+// allocation on the overloaded PR lane.
+const LARGE_MAP_SIZE = LIGHTWEIGHT_DAWN ? 1024 : 2048;
 
 interface MockCanvas {
   width: number;
@@ -182,19 +187,19 @@ describe('CSM runtime cascade + mapSize variation (M5/w26)', () => {
     if (!host.ok) throw host.error;
     const { renderer } = host.value;
     expect(renderer.inspect().state).toBe('alive');
-    const { world, shadowEntity } = buildScene(4, 2048);
+    const { world, shadowEntity } = buildScene(4, LARGE_MAP_SIZE);
 
     expect(drawPublished(renderer, world).ok).toBe(true);
 
     world.set(shadowEntity, DirectionalLight, {
-      mapSize: 2048,
+      mapSize: LARGE_MAP_SIZE,
       shadowDistance: 50,
       cascadeCount: 2,
     });
     expect(drawPublished(renderer, world).ok).toBe(true);
 
     world.set(shadowEntity, DirectionalLight, {
-      mapSize: 2048,
+      mapSize: LARGE_MAP_SIZE,
       shadowDistance: 50,
       cascadeCount: 4,
     });
@@ -213,7 +218,7 @@ describe('CSM runtime cascade + mapSize variation (M5/w26)', () => {
     if (!host.ok) throw host.error;
     const { renderer } = host.value;
     expect(renderer.inspect().state).toBe('alive');
-    const { world, shadowEntity } = buildScene(4, 2048);
+    const { world, shadowEntity } = buildScene(4, LARGE_MAP_SIZE);
 
     expect(drawPublished(renderer, world).ok).toBe(true);
 
@@ -225,7 +230,7 @@ describe('CSM runtime cascade + mapSize variation (M5/w26)', () => {
     expect(drawPublished(renderer, world).ok).toBe(true);
 
     world.set(shadowEntity, DirectionalLight, {
-      mapSize: 2048,
+      mapSize: LARGE_MAP_SIZE,
       shadowDistance: 50,
       cascadeCount: 4,
     });

package/src/__tests__/shadow-fields-observable.dawn.test.ts

@@ -32,9 +32,9 @@ import { drawPublished } from './draw-published';
 const LIGHTWEIGHT_DAWN = process.env.FORGEAX_DAWN_LIGHTWEIGHT === '1';
 // The CI observability lane only needs enough settled frames to prove the
 // field-owned pixel/UBO deltas. Keep the full 300-frame, 256x256 window for
-// local and nightly runs, while the isolated PR process uses a bounded 24-frame
+// local and nightly runs, while the isolated PR process uses a bounded 12-frame
 // 128x128 target to avoid retaining a large lavapipe command backlog.
-const SHADOW_FIELDS_RENDER_FRAMES = LIGHTWEIGHT_DAWN ? 24 : 300;
+const SHADOW_FIELDS_RENDER_FRAMES = LIGHTWEIGHT_DAWN ? 12 : 300;
 const WIDTH = LIGHTWEIGHT_DAWN ? 128 : 256;
 const HEIGHT = LIGHTWEIGHT_DAWN ? 128 : 256;
 const BPR = Math.ceil((WIDTH * 4) / 256) * 256;

package/src/__tests__/surface-standard-pipeline.browser.test.ts

@@ -0,0 +1,353 @@
+import { forgeaxBundlerAdapter } from 'virtual:forgeax/bundler';
+import { createRuntimeAssetImportTransport, runtimeBinding } from 'virtual:forgeax/pack-runtime';
+import { World } from '@forgeax/engine-ecs';
+import type { Renderer } from '@forgeax/engine-render';
+import type { MaterialAsset } from '@forgeax/engine-types';
+import { afterEach, describe, expect, it } from 'vitest';
+import { page } from 'vitest/browser';
+import { constructRuntimeRendererHost } from '../renderer-host';
+import {
+  assertMaterialPayload,
+  assertSurfacePixelFalsification,
+  parseSurfaceGuid,
+  populateSurfaceWorld,
+  SURFACE_CASES,
+  SURFACE_CLOSURE,
+  SURFACE_HEIGHT,
+  SURFACE_WIDTH,
+} from './surface-standard-pipeline.runtime-fixture';
+
+const evidenceEnv = (import.meta as ImportMeta & { env?: Record<string, string | undefined> }).env;
+const EVIDENCE_SOURCE_SHA = evidenceEnv?.VITE_FORGEAX_EVIDENCE_SOURCE_SHA ?? 'unavailable';
+const EVIDENCE_BUILD_ID = evidenceEnv?.VITE_FORGEAX_EVIDENCE_BUILD_ID ?? 'unavailable';
+
+type SurfaceReadback = {
+  pixels: Uint8Array;
+  width: number;
+  height: number;
+  bytesPerRow: number;
+  format: string;
+};
+
+async function readScreenshotPixels(canvas: HTMLCanvasElement): Promise<{
+  pixels: Uint8Array;
+  width: number;
+  height: number;
+  bytesPerRow: number;
+  format: string;
+}> {
+  let latest: Uint8Array | undefined;
+  let width = canvas.width;
+  let height = canvas.height;
+  for (let attempt = 0; attempt < 6; attempt += 1) {
+    await new Promise<void>((resolve) => requestAnimationFrame(() => resolve()));
+    await new Promise<void>((resolve) => setTimeout(resolve, 25));
+    const shot = await page.elementLocator(canvas).screenshot({ base64: true, save: false });
+    const b64 = typeof shot === 'string' ? shot : shot.base64;
+    const binary = atob(b64);
+    const bytes = new Uint8Array(binary.length);
+    for (let index = 0; index < binary.length; index += 1) bytes[index] = binary.charCodeAt(index);
+    const bitmap = await createImageBitmap(new Blob([bytes], { type: 'image/png' }));
+    width = bitmap.width;
+    height = bitmap.height;
+    const offscreen = new OffscreenCanvas(width, height);
+    const context = offscreen.getContext('2d', { willReadFrequently: true });
+    if (context === null) {
+      bitmap.close();
+      throw new Error('surface-standard: OffscreenCanvas 2D context unavailable for screenshot');
+    }
+    context.drawImage(bitmap, 0, 0);
+    const image = context.getImageData(0, 0, width, height);
+    bitmap.close();
+    latest = new Uint8Array(image.data.buffer, image.data.byteOffset, image.data.byteLength);
+    if (latest.some((value, index) => index % 4 !== 3 && value !== 0)) break;
+  }
+  return {
+    pixels: latest ?? new Uint8Array(width * height * 4),
+    width,
+    height,
+    bytesPerRow: width * 4,
+    format: 'rgba8unorm',
+  };
+}
+
+function hasPixelSignal(readback: SurfaceReadback): boolean {
+  for (let offset = 0; offset < readback.pixels.length; offset += 4) {
+    if (
+      (readback.pixels[offset] ?? 0) !== 0 ||
+      (readback.pixels[offset + 1] ?? 0) !== 0 ||
+      (readback.pixels[offset + 2] ?? 0) !== 0
+    ) {
+      return true;
+    }
+  }
+  return false;
+}
+
+function samplePresentedPixel(
+  readback: SurfaceReadback,
+  index: number,
+): readonly [number, number, number, number] {
+  const startX = Math.floor((index * readback.width) / SURFACE_CASES.length);
+  const endX = Math.floor(((index + 1) * readback.width) / SURFACE_CASES.length);
+  const candidates: Array<readonly [number, number, number, number]> = [];
+  for (let y = 0; y < readback.height; y += 8) {
+    for (let x = startX; x < endX; x += 8) {
+      const offset = y * readback.bytesPerRow + x * 4;
+      const raw = [
+        readback.pixels[offset] ?? 0,
+        readback.pixels[offset + 1] ?? 0,
+        readback.pixels[offset + 2] ?? 0,
+        readback.pixels[offset + 3] ?? 0,
+      ] as const;
+      const rgb = readback.format.startsWith('bgra') ? [raw[2], raw[1], raw[0]] : raw;
+      const brightness = rgb[0] + rgb[1] + rgb[2];
+      // The screenshot fallback is composited over a white page. Sample the
+      // median lit/non-white texel in each cell so a center point landing on
+      // that compositor background cannot hide a real Surface difference.
+      if (brightness > 0 && brightness < 750) {
+        candidates.push([rgb[0], rgb[1], rgb[2], raw[3]]);
+      }
+    }
+  }
+  candidates.sort((left, right) => left[0] + left[1] + left[2] - (right[0] + right[1] + right[2]));
+  const selected = candidates[Math.floor(candidates.length / 2)];
+  if (selected !== undefined) return selected;
+  const x = Math.min(
+    readback.width - 1,
+    Math.max(0, Math.floor(((index + 0.5) * readback.width) / SURFACE_CASES.length)),
+  );
+  const offset = Math.floor(readback.height / 2) * readback.bytesPerRow + x * 4;
+  const raw = [
+    readback.pixels[offset] ?? 0,
+    readback.pixels[offset + 1] ?? 0,
+    readback.pixels[offset + 2] ?? 0,
+    readback.pixels[offset + 3] ?? 0,
+  ] as const;
+  return readback.format.startsWith('bgra') ? [raw[2], raw[1], raw[0], raw[3]] : raw;
+}
+
+async function refreshSurfaceCatalog(
+  assets: { refreshCatalog(): Promise<boolean>; listCatalog(): readonly unknown[] },
+  expectedGuids: readonly string[],
+): Promise<readonly unknown[]> {
+  const deadline = Date.now() + 60_000;
+  while (Date.now() < deadline) {
+    await assets.refreshCatalog();
+    const catalog = assets.listCatalog();
+    const observed = new Set(
+      catalog
+        .filter((entry): entry is { guid: string } => {
+          return (
+            typeof entry === 'object' &&
+            entry !== null &&
+            'guid' in entry &&
+            typeof entry.guid === 'string'
+          );
+        })
+        .map((entry) => entry.guid.toLowerCase()),
+    );
+    if (expectedGuids.every((guid) => observed.has(guid.toLowerCase()))) return catalog;
+    await new Promise((resolve) => setTimeout(resolve, 250));
+  }
+  return assets.listCatalog();
+}
+
+describe('Standard Surface runtime Browser WebGPU provenance', () => {
+  let renderer: Renderer | undefined;
+  let canvas: HTMLCanvasElement | undefined;
+
+  afterEach(async () => {
+    await renderer?.dispose();
+    canvas?.remove();
+    renderer = undefined;
+    canvas = undefined;
+  });
+
+  it('loads one published tuple per GUID and renders every cell through Runtime Renderer', {
+    timeout: 120_000,
+  }, async () => {
+    if (runtimeBinding === undefined) {
+      throw new Error('surface-standard: Pack runtime binding unavailable in Browser Vitest');
+    }
+    canvas = document.createElement('canvas');
+    canvas.id = 'surface-standard-pipeline-test-canvas';
+    canvas.width = SURFACE_WIDTH;
+    canvas.height = SURFACE_HEIGHT;
+    // Keep the full four-cell evidence surface inside the Browser Vitest
+    // viewport. Playwright clips an oversized element screenshot to the
+    // available viewport, which would otherwise turn the right two cells into
+    // compositor-white pixels instead of a real Surface observation.
+    const displayWidth = Math.min(SURFACE_WIDTH, Math.max(320, window.innerWidth - 32));
+    const displayHeight = Math.round((displayWidth * SURFACE_HEIGHT) / SURFACE_WIDTH);
+    canvas.style.width = `${displayWidth}px`;
+    canvas.style.height = `${displayHeight}px`;
+    document.body.append(canvas);
+    const webgpuContext = canvas.getContext('webgpu');
+    if (webgpuContext === null) {
+      throw new Error('surface-standard: WebGPU canvas context unavailable');
+    }
+    const bundler = forgeaxBundlerAdapter();
+    const constructed = await constructRuntimeRendererHost(
+      canvas,
+      {},
+      {
+        ...bundler,
+        importTransport: createRuntimeAssetImportTransport(runtimeBinding),
+      },
+    );
+    expect(constructed.ok).toBe(true);
+    if (!constructed.ok) throw constructed.error;
+    const runtimeHost = constructed.value;
+    renderer = runtimeHost.renderer;
+    const assets = runtimeHost.assets;
+    assets.configureRuntimeBinding(runtimeBinding);
+    const catalog = (await refreshSurfaceCatalog(
+      assets,
+      SURFACE_CASES.map((surfaceCase) => surfaceCase.guid),
+    )) as readonly {
+      guid: string;
+      sourceKey?: string;
+      packageUrl?: string;
+    }[];
+    const seenGuids = new Set<string>();
+    const materials: MaterialAsset[] = [];
+    const publications = [];
+    for (const surfaceCase of SURFACE_CASES) {
+      const row = catalog.find((entry) => entry.guid.toLowerCase() === surfaceCase.guid);
+      expect(row?.sourceKey).toBe(surfaceCase.sourceKey);
+      expect(row?.packageUrl).toBeTruthy();
+      const packageResponse = await fetch(row?.packageUrl ?? '');
+      expect(packageResponse.ok).toBe(true);
+      const packageBody = await packageResponse.json();
+      const publication = packageBody as {
+        generation?: unknown;
+        digest?: unknown;
+      };
+      expect(Number.isSafeInteger(publication.generation)).toBe(true);
+      expect(typeof publication.digest).toBe('string');
+      const loaded = await assets.loadByGuid<MaterialAsset>(parseSurfaceGuid(surfaceCase.guid));
+      expect(loaded.ok).toBe(true);
+      if (!loaded.ok) throw loaded.error;
+      const material = assertMaterialPayload(surfaceCase, loaded.value);
+      const projection = assets.getMaterialProjectionForPayload(material);
+      if (surfaceCase.id.startsWith('custom-')) {
+        expect(projection?.specializationKey).toBeTruthy();
+        const programKeys =
+          projection?.passes.flatMap((pass) =>
+            pass.programs.map((program) => program.specializationKey),
+          ) ?? [];
+        expect(programKeys.length).toBeGreaterThan(0);
+        for (const specializationKey of new Set(programKeys)) {
+          expect(assets.getMaterialArtifact(specializationKey)).toBeDefined();
+        }
+      }
+      materials.push(material);
+      publications.push({ surfaceCase, row, publication, material });
+      seenGuids.add(surfaceCase.guid);
+    }
+    const world = new World();
+    populateSurfaceWorld(world, materials);
+    const renderErrors: Array<{ code: string; detail?: unknown; hint?: string }> = [];
+    const unsubscribeRenderErrors = renderer.subscribe((event) => {
+      if (event.kind === 'error') {
+        renderErrors.push({
+          code: event.error.code,
+          detail: event.error.detail,
+          hint: event.error.hint,
+        });
+      }
+    });
+    const attached = renderer?.attach(world);
+    if (attached === undefined) throw new Error('surface-standard: renderer unavailable');
+    expect(attached.ok).toBe(true);
+    if (!attached.ok) throw attached.error;
+    // Standard material pipelines are compiled lazily on their first use. Keep
+    // submitting frames until the renderer has had a chance to publish the
+    // ready PSOs before inspecting the presented surface.
+    for (let frame = 0; frame < 6; frame += 1) {
+      world.update(1 / 60).unwrap();
+      const drawn = renderer.draw({
+        leases: [attached.value],
+        camera: { lease: attached.value },
+        environment: { lease: attached.value },
+      });
+      expect(drawn.ok).toBe(true);
+      if (!drawn.ok) throw drawn.error;
+      const completion = await drawn.value.completed;
+      expect(completion.ok).toBe(true);
+      if (!completion.ok) throw completion.error;
+    }
+    const observed = renderer.inspect();
+    expect(renderErrors).toHaveLength(0);
+    expect(observed.perFramePassNames.some((name) => name.toLowerCase().includes('shadow'))).toBe(
+      true,
+    );
+    expect(observed.perFramePassNames).toContain('main');
+    const screenshotReadback = await readScreenshotPixels(canvas);
+    expect(hasPixelSignal(screenshotReadback)).toBe(true);
+    const readback = screenshotReadback;
+    const records = publications.map(({ surfaceCase, row, publication, material }, index) => {
+      const samples = samplePresentedPixel(readback, index);
+      const program = material.passes?.[0]?.program;
+      expect(samples[3]).toBeGreaterThan(0);
+      expect(samples[0] + samples[1] + samples[2]).toBeGreaterThan(0);
+      return {
+        id: surfaceCase.id,
+        materialGuid: surfaceCase.guid,
+        sourceKey: row?.sourceKey,
+        publicationGeneration: publication.generation,
+        publicationDigest: publication.digest,
+        closure: SURFACE_CLOSURE,
+        rootPlan: surfaceCase.rootPlan,
+        pass: surfaceCase.pass,
+        actualPasses: material.passes?.map((entry) => entry.name),
+        selectedEntries: material.passes?.map((entry) => ({
+          name: entry.name,
+          fragmentEntry: entry.program.fragmentEntry,
+          lightMode: (entry.renderState?.tags as Record<string, string> | undefined)?.LightMode,
+        })),
+        cookIdentity: publication.digest,
+        programIdentity: program?.module ?? 'unavailable',
+        pipelineIdentity: `${surfaceCase.pass}:${surfaceCase.rootPlan}:${program?.module ?? 'unavailable'}`,
+        sourceClosure: surfaceCase.sourceClosure,
+        samples,
+        frameId: observed.observation.frameId,
+        backend: observed.capabilities.backendKind,
+        artifact: row?.packageUrl,
+        provenance: {
+          sourceSha: EVIDENCE_SOURCE_SHA,
+          buildId: EVIDENCE_BUILD_ID,
+          frameId: observed.observation.frameId,
+          artifact: row?.packageUrl,
+          readbackKind: 'compositor-screenshot',
+          readbackFormat: readback.format,
+          readbackWidth: readback.width,
+          readbackHeight: readback.height,
+          clearColor: [0, 0, 0, 1],
+          closure: SURFACE_CLOSURE,
+          rootPlan: surfaceCase.rootPlan,
+          pass: surfaceCase.pass,
+          actualPasses: material.passes?.map((entry) => entry.name),
+          selectedEntries: material.passes?.map((entry) => ({
+            name: entry.name,
+            fragmentEntry: entry.program.fragmentEntry,
+            lightMode: (entry.renderState?.tags as Record<string, string> | undefined)?.LightMode,
+          })),
+          cookIdentity: publication.digest,
+          programIdentity: program?.module ?? 'unavailable',
+          pipelineIdentity: `${surfaceCase.pass}:${surfaceCase.rootPlan}:${program?.module ?? 'unavailable'}`,
+          sourceClosure: surfaceCase.sourceClosure,
+          lane: 'browser-webgpu',
+        },
+      };
+    });
+    expect(seenGuids).toHaveLength(4);
+    expect(records).toHaveLength(4);
+    assertSurfacePixelFalsification(records);
+    expect(records.every((record) => record.backend === 'webgpu')).toBe(true);
+    // biome-ignore lint/suspicious/noConsole: runtime provenance is the test artifact.
+    console.log(JSON.stringify({ backend: 'browser-webgpu', lane: 'runtime', records }));
+    unsubscribeRenderErrors();
+  });
+});