Skip to content

A fast 2D and 3D game engine — TypeScript SDK, C++/WebAssembly core, visual editor. Ship one project to web, desktop, WeChat MiniGames, playable ads, and native Android / iOS.

215 KB
Raw Blame
// SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: Copyright (c) 2024-present ESEngine Team
/**
 * @file  renderScenes.mjs — the pixel gates, as a registry.
 *
 * There were two lists. CI inlined twenty scene invocations in build.yml, and
 * desktop/package.json declared forty-four `verify:render:*` scripts. Neither
 * was authoritative, so they drifted both ways: thirty-two declared verifiers
 * were run by nothing at all (spine, video, particles, every material scene,
 * text, ktx2, four tilemap variants), and five scenes CI runs had no name a
 * developer could reproduce them by.
 *
 * All of them pass — this is not a list of broken checks. It is a list of
 * checks that could not have caught anything, which is the same problem the
 * golden corpus exists to refuse: green about the things it happens to run.
 *
 * `tier` is the cheapest run that pays for a scene; each tier includes the
 * cheaper ones. `pr` is exactly what CI ran before this file existed, so
 * adopting the registry changed no CI cost.
 */

/** Cheapest tier a scene runs at; tiers are cumulative. */
import { ORACLE, oracleEntry } from './oracle/index.mjs';

export const TIERS = ['pr', 'nightly'];

/** Electron's own bundled SwiftShader is the adapter a GPU-less runner gets, and
 *  what the whole list passes on locally. Only the boot log names the one a run
 *  actually took. */
export const WEBGPU_GAP = 'CI runs the pr tier of them on a runner of its own,'
    + ' informationally and inside a budget — whether that tier fits there, and'
    + ' passes, is the open question; the 85 that declared it then all passed on'
    + ' this machine\'s SwiftShader on 2026-08-17 (`--tier nightly --backend webgpu`)';

/**
 * How long a scene gets to reach a verdict, by backend — the runner hands this
 * to the scene as its own watchdog and kills the process a launch margin later.
 * WebGL2 is measured (a 65-scene tier averages 1.4s each); the second backend
 * rasterises the same frames on a CPU, and every run prints what each took.
 */
export const SCENE_WATCHDOG_MS = { webgl2: 45_000, webgpu: 120_000 };

/**
 * A floor for a host that starts slower than the one the 45s above was measured
 * on. Booting the engine through the whole editor costs 12s on the CI runner
 * (`createWebApp` alone measured 9.8s) against the engine host's ~1s, and two
 * scenes were failed at 45s while the ones after them passed at 50.
 */
export const HOST_WATCHDOG_MS = { editor: 150_000 };

/** How long one scene gets, for the host that draws it on the backend it names. */
export function sceneWatchdogMs(backend, host) {
    return Math.max(SCENE_WATCHDOG_MS[backend] ?? 45_000, HOST_WATCHDOG_MS[host] ?? 0);
}

/**
 * Every pixel gate. `env` is handed to desktop/scripts/headless-verify.mjs
 * verbatim — an empty one is the default sprite scene.
 */
export const SCENES = [
  ...[
    { id: 'mesh-shadow-placements', scene: 'mesh-shadow', shadowX: 0.708 },
    { id: 'mesh-shadow-placements-perspective', scene: 'mesh-shadow-perspective', shadowX: 0.86 },
  ].map(test => ({
    id: test.id, tier: 'pr', webgpu: true,
    env: {
      ESTELLA_VERIFY_SCENE: `/scenes/${test.scene}.esscene`,
      ESTELLA_VERIFY_W: '256', ESTELLA_VERIFY_H: '256', ESTELLA_VERIFY_STEPS: '3',
      ESTELLA_VERIFY_PLACEMENTS: JSON.stringify([
        { entity: 1, transforms: [600, 0, 0, 0, 0, 600, 0, 0, 0, 0, 1, -200, 1, 1, 1, 1] },
        { entity: 2, transforms: [150, 0, 0, 0, 0, 150, 0, 0, 0, 0, 1, 0, 1, 1, 1, 1] },
      ]),
      ESTELLA_VERIFY_SET_FIELD: JSON.stringify([1, 2].flatMap(entity => [
        { entity, component: 'Transform', key: 'position', value: { x: 0, y: 0, z: 0 } },
        { entity, component: 'Transform', key: 'scale', value: { x: 1, y: 1, z: 1 } },
      ])),
      ESTELLA_VERIFY_EXPECT: JSON.stringify([
        { x: test.shadowX, y: 0.5, rgb: [0, 0, 0], tol: 20 },
        { x: 0.1, y: 0.5, rgb: [228, 228, 228], tol: 20 },
      ]),
    },
  })),
  // A ground with no layer files reads its paint from the last of its eight textures, the one past the material's seven units:
  // 0.104.0 shipped with that texture given no unit, and every such ground one colour from edge to edge.
  {
    id: 'terrain-paint', tier: 'pr', webgpu: true,
    env: {
      ESTELLA_VERIFY_SCENE: '/scenes/terrain-paint.esscene',
      ESTELLA_VERIFY_W: '256', ESTELLA_VERIFY_H: '256', ESTELLA_VERIFY_STEPS: '30', ESTELLA_VERIFY_SETTLE_MS: '2500',
      ESTELLA_VERIFY_EXPECT: JSON.stringify([
        { x: 0.3, y: 0.5, rgb: [255, 0, 0], tol: 90 },
        { x: 0.7, y: 0.5, rgb: [0, 0, 255], tol: 90 },
      ]),
    },
  },
  // A terrain layer's sky occlusion dims the sky's light on it and nothing else: two white layers, the right one at 0.5, are half as
  // bright under the ambient light alone and the same under a sun alone.
  ...[
    { id: 'terrain-layer-occlusion', set: [], expect: [[0.3, [242, 242, 242]], [0.7, [121, 121, 121]]] },
    { id: 'terrain-layer-occlusion-sun', set: [{ entity: 1, component: 'Light', key: 'enabled', value: false }, { entity: 3, component: 'Light', key: 'enabled', value: true }], expect: [[0.3, [242, 242, 242]], [0.7, [242, 242, 242]]] },
    // The same ground drawn from its virtual texture, every node from a baked page: the same light on both layers, and pages were baked
    // (a page baked right is the picture the layers draw live, so only the count says the bake happened).
    { id: 'terrain-virtual-texture', set: [{ entity: 2, component: 'Terrain', key: 'virtualTexture', value: true }, { entity: 2, component: 'Terrain', key: 'virtualTextureFrom', value: 0 }],
      expect: [[0.3, [242, 242, 242]], [0.7, [121, 121, 121]]], steps: '90', min: { 'render.bakes.drawn': 2 } },
  ].map((test) => ({
    id: test.id, tier: 'pr', webgpu: true,
    env: {
      ESTELLA_VERIFY_SCENE: '/scenes/terrain-layer-occlusion.esscene',
      ESTELLA_VERIFY_W: '256', ESTELLA_VERIFY_H: '256', ESTELLA_VERIFY_STEPS: test.steps ?? '30', ESTELLA_VERIFY_WARM: '1',
      ...(test.set.length ? { ESTELLA_VERIFY_SET_FIELD: JSON.stringify(test.set) } : {}),
      ...(test.min ? { ESTELLA_VERIFY_COUNTERS_MIN: JSON.stringify(test.min) } : {}),
      ESTELLA_VERIFY_EXPECT: JSON.stringify(test.expect.map(([x, rgb]) => ({ x, y: 0.5, rgb, tol: 14 }))),
    },
  })),
  // The Planet shader draws its layers with the same code as Terrain Layers (layerSurfaceShader.ts). Two boxes under the sky's light
  // alone (at half its strength, so neither box saturates), white paint: on the left the layer colours (a half grey), on the right one
  // layer of the stock arrays, nothing packed into them: twice as bright. An unset texture array binds white layers
  // (MaterialStore::builtinDefault): on WebGL it read black before, a black box here.
  {
    id: 'planet-layers', tier: 'pr', webgpu: true,
    env: {
      ESTELLA_VERIFY_SCENE: '/scenes/planet-layers.esscene',
      ESTELLA_VERIFY_W: '256', ESTELLA_VERIFY_H: '256', ESTELLA_VERIFY_STEPS: '3',
      ESTELLA_VERIFY_EXPECT: JSON.stringify([{ x: 0.3, y: 0.5, rgb: [64, 64, 64], tol: 6 }, { x: 0.7, y: 0.5, rgb: [127, 127, 127], tol: 6 }]),
    },
  },
  {
    id: 'shadow-vertex-displacement', tier: 'pr', webgpu: true,
    env: {
      ESTELLA_VERIFY_SCENE: '/scenes/placement-shadow-bend.esscene',
      ESTELLA_VERIFY_W: '256', ESTELLA_VERIFY_H: '256', ESTELLA_VERIFY_STEPS: '3',
      ESTELLA_VERIFY_EXPECT: JSON.stringify([
        { x: 0.5, y: 0.5, rgb: [0, 0, 0], tol: 20 },
        { x: 0.1, y: 0.5, rgb: [255, 255, 255], tol: 20 },
      ]),
    },
  },
  ...[
    { id: 'placements-bent', entity: 2, projection: 1, records: [1, 0, 0, -300, 0, 1, 0, 0, 0, 0, 1, 0, 1, 1, 1, 1], x: 0.5, y: 0.5, coarse: 0 },
    { id: 'placements-bent-scaled', entity: 2, projection: 1, records: [3, 0, 0, -900, 0, 3, 0, 0, 0, 0, 3, 0, 1, 1, 1, 1], x: 0.5, y: 0.5, coarse: 0 },
    { id: 'placements-coarse-bounds', entity: 4, projection: 0, records: [1, 0, 0, 350, 0, 1, 0, 0, 0, 0, 1, 0, 1, 1, 1, 1], x: 0.9, y: 0.5, coarse: 1 },
    { id: 'placements-rotated-bounds', entity: 6, projection: 1, records: [0, -1, 0, 0, 1, 0, 0, 350, 0, 0, 1, 0, 1, 1, 1, 1], x: 0.5, y: 0.1, coarse: 0 },
    { id: 'placements-tight-bounds', entity: 6, projection: 1, records: [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 0, 350, 0, 0, 1, 0, 1, 1, 1, 1], x: 0.5, y: 0.5, coarse: 0, outside: 1 },
  ].map(test => ({
    id: test.id, tier: 'pr', webgpu: true,
    env: {
      ESTELLA_VERIFY_SCENE: '/scenes/placement-bounds.esscene',
      ESTELLA_VERIFY_W: '256', ESTELLA_VERIFY_H: '256', ESTELLA_VERIFY_STEPS: '3',
      ESTELLA_VERIFY_PLACEMENTS: JSON.stringify([{ entity: test.entity, transforms: test.records }]),
      ESTELLA_VERIFY_SET_FIELD: JSON.stringify([
        { entity: 0, component: 'Camera', key: 'projectionType', value: test.projection },
        { entity: 1, component: 'MeshRenderer', key: 'enabled', value: false },
        { entity: test.entity, component: 'MeshRenderer', key: 'enabled', value: true },
      ]),
      ESTELLA_VERIFY_EXPECT: JSON.stringify([{ x: test.x, y: test.y, rgb: [0, 255, 0], tol: 2 }]),
      ESTELLA_VERIFY_COUNTERS: JSON.stringify({ 'render.placements.seen': test.records.length / 16, 'render.placements.outside': test.outside ?? 0, 'render.placements.coarse': test.coarse }),
    },
  })),
  {
    id: 'render-clock', tier: 'pr',
    // WebGPU captures the next frame; GL reads the already completed frame.
    webgpu: { ESTELLA_VERIFY_EXPECT: JSON.stringify([
      { x: 0.25, y: 0.5, rgb: [21, 234, 0], tol: 2 },
      { x: 0.75, y: 0.5, rgb: [21, 234, 0], tol: 2 },
    ]) },
    env: {
      ESTELLA_VERIFY_SCENE: '/scenes/render-clock.esscene',
      ESTELLA_VERIFY_W: '256', ESTELLA_VERIFY_H: '256', ESTELLA_VERIFY_STEPS: '3',
      // The second GL readback observes the fourth completed frame (4/60 s).
      ESTELLA_VERIFY_EXPECT: JSON.stringify([
        { x: 0.25, y: 0.5, rgb: [17, 238, 0], tol: 2 },
        { x: 0.75, y: 0.5, rgb: [17, 238, 0], tol: 2 },
      ]),
    },
  },
  {
    id: 'planar-tiled-lights', tier: 'pr', webgpu: true,
    env: {
      ESTELLA_VERIFY_SCENE: '/scenes/planar-tiled-lights.esscene',
      ESTELLA_VERIFY_W: '512', ESTELLA_VERIFY_H: '512', ESTELLA_VERIFY_STEPS: '3',
      ESTELLA_VERIFY_EXPECT: JSON.stringify([
        { x: 200 / 512, y: 210 / 512, rgb: [255, 0, 0], tol: 25 },
        { x: 200 / 512, y: 290 / 512, rgb: [255, 0, 0], tol: 25 },
      ]),
      ESTELLA_VERIFY_COUNTERS: JSON.stringify({ 'render.planar.tiledLights': 1 }),
    },
  },
  // Full 8x8 corner blocks: native Sprite, 5x-wide Sprite, and shared UI geometry.
  { id: 'sprite-nine-slice', tier: 'pr', webgpu: true, env: {
      ESTELLA_VERIFY_SCENE: '/scenes/sprite-nine-slice.esscene',
      ESTELLA_VERIFY_MANIFEST: '/scenes/sprite-nine-slice.textures.json',
      ESTELLA_VERIFY_W: '320', ESTELLA_VERIFY_H: '128', ESTELLA_VERIFY_STEPS: '3',
      ESTELLA_VERIFY_TEXTURES: 'runtime', ESTELLA_VERIFY_FRAME_DEBUG: '1',
      ESTELLA_VERIFY_NINE_SLICE: '[[48,24,32,32],[120,24,160,32],[120,80,160,32]]',
  } },
  { id: "sprite-default", tier: "pr", webgpu: true, env: {  } },
  // What the BATCHER achieved, which no pixel can show: nineteen sprites over two
  // textures reach the GPU as three draws. Every break is accounted for to its
  // reason — one run head, two index gaps, no state break at all.
  { id: "sprite-batch", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/sprite-rendering.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/sprite-rendering.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_COUNTERS: "{\"render.sprites\":19,\"batch.draws\":1,\"batch.merged\":18,\"batch.break.runStart\":1}" } },
    // Editor grid on/off pixel diff — guards the custom-draw reflected material path (drawMeshWithMaterial + MaterialConstants UBO).
  { id: "editor-grid", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_GRID: "64", ESTELLA_VERIFY_STEPS: "3" } },
    // The same grid respaced after it has drawn: a uniform changed after its first upload has to reach the frame, which on WebGPU it once did not (the grid stayed where the view first looked).
  { id: "editor-grid-respace", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_GRID: "64", ESTELLA_VERIFY_GRID_RESPACE: "160", ESTELLA_VERIFY_STEPS: "3" } },
    // The same grid from straight above a 3D view. It stands on the ground there, so it fills the frame; the 2D plane would be edge-on and light one band.
  { id: "editor-grid-3d", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/mesh-instanced.esscene", ESTELLA_VERIFY_GRID: "64", ESTELLA_VERIFY_PERSPECTIVE: "1", ESTELLA_VERIFY_ORBIT: "0,90", ESTELLA_VERIFY_STEPS: "3" } },
  // The same 3D view head-on, where this fixture's eye lies IN the ground: every
  // ray meets it at the eye's own point, so it has no picture. The grid does NOT
  // hand over to the plane the eye most faces — that hand-over is for gestures.
  { id: "editor-grid-head-on", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/mesh-instanced.esscene", ESTELLA_VERIFY_GRID: "64", ESTELLA_VERIFY_GRID_EXPECT: "nothing", ESTELLA_VERIFY_PERSPECTIVE: "1", ESTELLA_VERIFY_ORBIT: "0,0", ESTELLA_VERIFY_STEPS: "3" } },
  // Just off head-on: the ground, bottom-heavy the way a floor receding to a
  // horizon is. A plane turned to meet the eye lights the frame evenly and passes
  // the coverage check, so "grazing" is what tells the two apart.
  { id: "editor-grid-grazing", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/mesh-instanced.esscene", ESTELLA_VERIFY_GRID: "64", ESTELLA_VERIFY_GRID_EXPECT: "grazing", ESTELLA_VERIFY_PERSPECTIVE: "1", ESTELLA_VERIFY_ORBIT: "0,4", ESTELLA_VERIFY_STEPS: "3" } },
  // The editor view's studio preview: a view-only light and exposure. The scene with NO light is dark
  // and the studio makes the model readable; a scene lit by its own light or an environment is
  // replaced by it; and in every case switching back is the scene's own frame to the byte.
  { id: "studio-preview-nolight", tier: "pr", webgpu: true, env: {"ESTELLA_VERIFY_SCENE": "/scenes/studio-preview-nolight.esscene", "ESTELLA_VERIFY_W": "256", "ESTELLA_VERIFY_H": "256", "ESTELLA_VERIFY_STEPS": "3", "ESTELLA_VERIFY_STUDIO": "{\"studio\":{},\"dark\":true,\"sky\":\"noop\"}"} },
  { id: "studio-preview-sun", tier: "pr", webgpu: true, env: {"ESTELLA_VERIFY_SCENE": "/scenes/mesh-builtin.esscene", "ESTELLA_VERIFY_W": "256", "ESTELLA_VERIFY_H": "256", "ESTELLA_VERIFY_STEPS": "3", "ESTELLA_VERIFY_STUDIO": "{\"studio\":{},\"dark\":false}"} },
  { id: "studio-preview-hdr", tier: "pr", webgpu: true, env: {"ESTELLA_VERIFY_SCENE": "/scenes/studio-preview-hdr.esscene", "ESTELLA_VERIFY_W": "256", "ESTELLA_VERIFY_H": "256", "ESTELLA_VERIFY_STEPS": "3", "ESTELLA_VERIFY_PERSPECTIVE": "1", "ESTELLA_VERIFY_ORBIT": "0,0", "ESTELLA_VERIFY_STUDIO": "{\"studio\":{},\"dark\":false,\"sky\":\"adds\"}"} },
  // The editor eye's clay and albedo modes: clay drops everyone's colours and keeps the light,
  // albedo keeps the colours and drops the light, and leaving either restores the authored frame.
  { id: "view-shading", tier: "pr", webgpu: true, env: {"ESTELLA_VERIFY_SCENE": "/scenes/view-shading.esscene", "ESTELLA_VERIFY_W": "256", "ESTELLA_VERIFY_H": "256", "ESTELLA_VERIFY_STEPS": "3", "ESTELLA_VERIFY_SHADING": "1"} },
  // Clay split into its two halves, as Unreal's lighting components do: the lights alone (the faces turned from the sun go
  // black) and everything that is not a light (the ambient's fill, flat and still lit). Where a shadow's light comes from.
  { id: "view-lighting-split", tier: "pr", webgpu: true, env: {"ESTELLA_VERIFY_SCENE": "/scenes/view-lighting.esscene", "ESTELLA_VERIFY_W": "256", "ESTELLA_VERIFY_H": "256", "ESTELLA_VERIFY_STEPS": "3", "ESTELLA_VERIFY_LIGHTING_SPLIT": "1"} },
  // A skinned surface coloured by one joint's weights: each of the two joints of the rig colours its own
  // half, the hot end of the ramp is on screen, and leaving the view returns the authored frame.
  { id: "view-skin-weights", tier: "pr", webgpu: true, env: {"ESTELLA_VERIFY_SCENE": "/scenes/mesh-skin.esscene", "ESTELLA_VERIFY_W": "256", "ESTELLA_VERIFY_H": "256", "ESTELLA_VERIFY_STEPS": "2", "ESTELLA_VERIFY_SKIN_WEIGHTS": "{\"id\":3,\"joints\":[0,1]}"} },
  { id: "studio-exposure", tier: "pr", webgpu: true, env: {"ESTELLA_VERIFY_SCENE": "/scenes/mesh-builtin.esscene", "ESTELLA_VERIFY_W": "256", "ESTELLA_VERIFY_H": "256", "ESTELLA_VERIFY_STEPS": "3", "ESTELLA_VERIFY_STUDIO": "{\"exposure\":-1}"} },
  { id: "studio-exposure-linear", tier: "pr", webgpu: true, env: {"ESTELLA_VERIFY_COLORSPACE": "linear", "ESTELLA_VERIFY_SCENE": "/scenes/mesh-builtin.esscene", "ESTELLA_VERIFY_W": "256", "ESTELLA_VERIFY_H": "256", "ESTELLA_VERIFY_STEPS": "3", "ESTELLA_VERIFY_STUDIO": "{\"exposure\":-1,\"linear\":true}"} },
  { id: "frame-debugger-2d", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/sprite-rendering.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/sprite-rendering.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_FRAME_DEBUG: "1" } },
  { id: "frame-debugger-3d", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/ssao.esscene", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "4", ESTELLA_VERIFY_FRAME_DEBUG: "1" } },
  { id: "frame-debugger-split", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/camera-split.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/camera-split.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_FRAME_DEBUG: "1" } },
  // The 3D counterpart: two meshes' worth of world, one camera for each half of the frame. A camera
  // that starts away from the window's corner drew nothing at all once the frame went through the
  // post chain (linear light, an output transform, any effect), because the scene was drawn at the
  // camera's offset inside an intermediate target only as big as the camera. The second entry is that path.
  { id: "camera-split-3d", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/camera-split-3d.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/mesh-renderer.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "4", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.25,\"y\":0.5,\"rgb\":[255,0,0],\"tol\":30},{\"x\":0.75,\"y\":0.5,\"rgb\":[0,255,0],\"tol\":30}]" } },
  { id: "camera-split-3d-linear", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_COLORSPACE: "linear", ESTELLA_VERIFY_SCENE: "/scenes/camera-split-3d.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/mesh-renderer.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "4", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.25,\"y\":0.5,\"rgb\":[255,0,0],\"tol\":30},{\"x\":0.75,\"y\":0.5,\"rgb\":[0,255,0],\"tol\":30}]" } },
  { id: "mesh-renderer", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/mesh-renderer.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/mesh-renderer.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "4", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.30,\"y\":0.556,\"rgb\":[255,0,0],\"tol\":40},{\"x\":0.70,\"y\":0.556,\"rgb\":[0,255,0],\"tol\":40},{\"x\":0.30,\"y\":0.40,\"rgb\":[255,0,0],\"tol\":40}]" } },
  // One mask, both its sides, and a sprite that never asked. A mask that does nothing
  // paints the frame red; a side that inverted swaps green and red. The blue bar states
  // no interaction and must survive, or masking is not opt-in.
  { id: "sprite-mask", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/sprite-mask.esscene", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.25,\"y\":0.5,\"rgb\":[0,255,0],\"tol\":30},{\"x\":0.75,\"y\":0.5,\"rgb\":[255,0,0],\"tol\":30},{\"x\":0.25,\"y\":0.9375,\"rgb\":[0,0,255],\"tol\":30},{\"x\":0.75,\"y\":0.9375,\"rgb\":[0,0,255],\"tol\":30}]" } },
  { id: "parallax-shape", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/parallax-shape.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/parallax-shape.textures.json", ESTELLA_VERIFY_STEPS: "4", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.5,\"y\":0.5,\"rgb\":[0,255,0],\"tol\":40},{\"x\":0.25,\"y\":0.5,\"rgb\":[255,0,0],\"tol\":40}]" } },
  // Frame N on screen is cell N — the clip's sheet window reaching Sprite UVs, which
  // no pixel had ever read. Four probes INSIDE one sprite: a window that failed to
  // narrow shows the whole page, so they come back four colours instead of one.
  { id: "sprite-clip-cell0", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/sprite-clip.esscene", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_PLAY: "1", ESTELLA_VERIFY_STEPS: "3", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.375,\"y\":0.375,\"rgb\":[255,0,0],\"tol\":30},{\"x\":0.625,\"y\":0.375,\"rgb\":[255,0,0],\"tol\":30},{\"x\":0.375,\"y\":0.625,\"rgb\":[255,0,0],\"tol\":30},{\"x\":0.625,\"y\":0.625,\"rgb\":[255,0,0],\"tol\":30}]" } },
  // Cells 1 and 2 are the two axes of the grid: a sheet cut transposed swaps them
  // and cells 0 and 3 stay put, so a gate on either alone is half blind.
  { id: "sprite-clip-cell1", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/sprite-clip.esscene", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_PLAY: "1", ESTELLA_VERIFY_STEPS: "9", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.375,\"y\":0.375,\"rgb\":[0,255,0],\"tol\":30},{\"x\":0.625,\"y\":0.375,\"rgb\":[0,255,0],\"tol\":30},{\"x\":0.375,\"y\":0.625,\"rgb\":[0,255,0],\"tol\":30},{\"x\":0.625,\"y\":0.625,\"rgb\":[0,255,0],\"tol\":30}]" } },
  { id: "sprite-clip-cell2", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/sprite-clip.esscene", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_PLAY: "1", ESTELLA_VERIFY_STEPS: "15", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.375,\"y\":0.375,\"rgb\":[0,0,255],\"tol\":30},{\"x\":0.625,\"y\":0.375,\"rgb\":[0,0,255],\"tol\":30},{\"x\":0.375,\"y\":0.625,\"rgb\":[0,0,255],\"tol\":30},{\"x\":0.625,\"y\":0.625,\"rgb\":[0,0,255],\"tol\":30}]" } },
  // Past the end and round again (t = 0.55s of a 0.4s clip). Cell 1 rather than 0:
  // an animator that never advanced would answer cell 0 correctly.
  { id: "sprite-clip-loop", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/sprite-clip.esscene", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_PLAY: "1", ESTELLA_VERIFY_STEPS: "33", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.375,\"y\":0.375,\"rgb\":[0,255,0],\"tol\":30},{\"x\":0.625,\"y\":0.375,\"rgb\":[0,255,0],\"tol\":30},{\"x\":0.375,\"y\":0.625,\"rgb\":[0,255,0],\"tol\":30},{\"x\":0.625,\"y\":0.625,\"rgb\":[0,255,0],\"tol\":30}]" } },
  { id: "tilemap-flip", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/tilemap-flip.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/tilemap-flip.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.40,\"y\":0.36,\"rgb\":[255,0,0]},{\"x\":0.60,\"y\":0.36,\"rgb\":[0,255,0]},{\"x\":0.40,\"y\":0.58,\"rgb\":[0,0,255]},{\"x\":0.60,\"y\":0.58,\"rgb\":[255,255,0]}]" } },
  // A layer's own offset, set through the inspector's door: 16 world units is one
  // cell here, so the whole grid steps right by one and the left column empties.
  // It rides the per-frame origin, not the cached chunk vertices.
  { id: "tilemap-origin", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SET_FIELD: "{\"entity\":1,\"component\":\"TilemapLayer\",\"key\":\"originOffset\",\"value\":[16,0]}", ESTELLA_VERIFY_SCENE: "/scenes/tilemap-flip.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/tilemap-flip.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.60,\"y\":0.36,\"rgb\":[255,0,0]},{\"x\":0.80,\"y\":0.36,\"rgb\":[0,255,0]},{\"x\":0.60,\"y\":0.58,\"rgb\":[0,0,255]},{\"x\":0.40,\"y\":0.36,\"rgb\":[0,0,0],\"tol\":20}]" } },
  // A two-bone arm. Bone 1 binds at x=60 and the scene puts it 60 higher, so
  // the half bound to it rises by exactly that and the half bound to bone 0 does
  // not: the elbow is where the geometry says, not where a whole-mesh move puts it.
  { id: "skin-fade-start", tier: "pr", env: {"ESTELLA_VERIFY_SCENE": "/scenes/skinned-fade.esscene", "ESTELLA_VERIFY_MANIFEST": "/scenes/skinned-fade.textures.json", "ESTELLA_VERIFY_W": "256", "ESTELLA_VERIFY_H": "256", "ESTELLA_VERIFY_ANIMATOR": "{\"entity\": 1, \"param\": \"bend\", \"value\": 1, \"warmup\": 2, \"frames\": 1}", "ESTELLA_VERIFY_EXPECT": "[{\"x\": 0.3, \"y\": 0.6, \"rgb\": [0, 255, 0], \"tol\": 40}, {\"x\": 0.75, \"y\": 0.6, \"rgb\": [0, 255, 0], \"tol\": 40}, {\"x\": 0.75, \"y\": 0.45, \"rgb\": [0, 0, 0], \"tol\": 25}, {\"x\": 0.45, \"y\": 0.3, \"rgb\": [0, 0, 0], \"tol\": 25}]"} },
  { id: "skin-fade-mid", tier: "pr", env: {"ESTELLA_VERIFY_SCENE": "/scenes/skinned-fade.esscene", "ESTELLA_VERIFY_MANIFEST": "/scenes/skinned-fade.textures.json", "ESTELLA_VERIFY_W": "256", "ESTELLA_VERIFY_H": "256", "ESTELLA_VERIFY_ANIMATOR": "{\"entity\": 1, \"param\": \"bend\", \"value\": 1, \"warmup\": 2, \"frames\": 31}", "ESTELLA_VERIFY_EXPECT": "[{\"x\": 0.3, \"y\": 0.6, \"rgb\": [0, 255, 0], \"tol\": 40}, {\"x\": 0.75, \"y\": 0.6, \"rgb\": [0, 0, 0], \"tol\": 25}, {\"x\": 0.75, \"y\": 0.45, \"rgb\": [0, 255, 0], \"tol\": 40}, {\"x\": 0.45, \"y\": 0.3, \"rgb\": [0, 0, 0], \"tol\": 25}]"} },
  { id: "skin-fade-end", tier: "pr", env: {"ESTELLA_VERIFY_SCENE": "/scenes/skinned-fade.esscene", "ESTELLA_VERIFY_MANIFEST": "/scenes/skinned-fade.textures.json", "ESTELLA_VERIFY_W": "256", "ESTELLA_VERIFY_H": "256", "ESTELLA_VERIFY_ANIMATOR": "{\"entity\": 1, \"param\": \"bend\", \"value\": 1, \"warmup\": 2, \"frames\": 90}", "ESTELLA_VERIFY_EXPECT": "[{\"x\": 0.3, \"y\": 0.6, \"rgb\": [0, 255, 0], \"tol\": 40}, {\"x\": 0.75, \"y\": 0.6, \"rgb\": [0, 0, 0], \"tol\": 25}, {\"x\": 0.75, \"y\": 0.45, \"rgb\": [0, 0, 0], \"tol\": 25}, {\"x\": 0.45, \"y\": 0.3, \"rgb\": [0, 255, 0], \"tol\": 40}]"} },
  { id: "mesh-skin", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/mesh-skin.esscene", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.35,\"y\":0.6,\"rgb\":[0,255,0],\"tol\":30},{\"x\":0.75,\"y\":0.35,\"rgb\":[0,255,0],\"tol\":30},{\"x\":0.75,\"y\":0.60,\"rgb\":[0,0,0],\"tol\":20}]" } },
  // The same arm, drawn by a MATERIAL — a program is compiled per vertex source
  // and there was no skinned one, so a skinned mesh fell back to the engine's
  // shader and ignored what it was made of (sabotage: the probes come back white).
  { id: "mesh-skin-material", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/mesh-skin-mat.esscene", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.35,\"y\":0.6,\"rgb\":[0,0,255],\"tol\":30},{\"x\":0.75,\"y\":0.35,\"rgb\":[0,0,255],\"tol\":30},{\"x\":0.75,\"y\":0.60,\"rgb\":[0,0,0],\"tol\":20}]" } },
  // The two halves of one claim: the SAME mesh, the same two points, and the
  // weight is the only thing that differs. A quad in its authored place proves
  // nothing alone — a morph that never reached the GPU passes the first.
  { id: "mesh-morph-rest", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/mesh-morph-off.esscene", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.25,\"y\":0.5,\"rgb\":[0,255,0],\"tol\":30},{\"x\":0.75,\"y\":0.5,\"rgb\":[0,0,0],\"tol\":20}]" } },
  { id: "mesh-morph-shaped", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/mesh-morph-on.esscene", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.75,\"y\":0.5,\"rgb\":[0,255,0],\"tol\":30},{\"x\":0.25,\"y\":0.5,\"rgb\":[0,0,0],\"tol\":20}]" } },
  // A material shader writes no vertex stage, so it takes the engine's — a
  // DIFFERENT copy of the deform. Through the other source, the same shape: the
  // two must move the quad alike or one of them is not deforming at all.
  { id: "mesh-morph-material", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/mesh-morph-mat.esscene", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.75,\"y\":0.5,\"rgb\":[0,0,255],\"tol\":30},{\"x\":0.25,\"y\":0.5,\"rgb\":[0,0,0],\"tol\":20}]" } },
  // A BAKE, read through the second UV set. The atlas runs red-to-blue left to
  // right and the quad's second UV set is the transpose of its first, so reading
  // the wrong channel turns the halves and swaps two of these four points.
  { id: "lightmap-unlit", tier: "pr", webgpu: true, env: { "ESTELLA_VERIFY_SCENE": "/scenes/lightmap-unlit.esscene", "ESTELLA_VERIFY_MANIFEST": "/scenes/lightmap-unlit.textures.json", "ESTELLA_VERIFY_W": "256", "ESTELLA_VERIFY_H": "256", "ESTELLA_VERIFY_STEPS": "2", "ESTELLA_VERIFY_EXPECT": "[{\"x\":0.3,\"y\":0.25,\"rgb\":[0,0,255],\"tol\":30},{\"x\":0.7,\"y\":0.25,\"rgb\":[0,0,255],\"tol\":30},{\"x\":0.3,\"y\":0.75,\"rgb\":[255,0,0],\"tol\":30},{\"x\":0.7,\"y\":0.75,\"rgb\":[255,0,0],\"tol\":30}]" } },
  // The atlas differs only by row, and is uploaded as a shipped game uploads a
  // picture: a baker and a loader that disagree on which row is v = 0 swap its halves.
  { id: "lightmap-rows", tier: "pr", webgpu: true, env: { "ESTELLA_VERIFY_SCENE": "/scenes/lightmap-rows.esscene", "ESTELLA_VERIFY_MANIFEST": "/scenes/lightmap-rows.textures.json", "ESTELLA_VERIFY_TEXTURES": "runtime", "ESTELLA_VERIFY_W": "256", "ESTELLA_VERIFY_H": "256", "ESTELLA_VERIFY_STEPS": "2", "ESTELLA_VERIFY_EXPECT": "[{\"x\":0.3,\"y\":0.25,\"rgb\":[255,0,0],\"tol\":30},{\"x\":0.3,\"y\":0.75,\"rgb\":[255,0,0],\"tol\":30},{\"x\":0.7,\"y\":0.25,\"rgb\":[0,0,255],\"tol\":30},{\"x\":0.7,\"y\":0.75,\"rgb\":[0,0,255],\"tol\":30}]" } },
  // A baked object and an unbaked one in ONE lit frame. Cyan and yellow halves
  // say the green sun SURVIVED, so the bake joins the lamps rather than replacing them; the plain
  // green quad says an unbaked one is not brightened by an unbound unit's white.
  { id: "lightmap-mixed", tier: "pr", webgpu: true, env: { "ESTELLA_VERIFY_SCENE": "/scenes/lightmap-mixed.esscene", "ESTELLA_VERIFY_MANIFEST": "/scenes/lightmap-mixed.textures.json", "ESTELLA_VERIFY_W": "256", "ESTELLA_VERIFY_H": "256", "ESTELLA_VERIFY_STEPS": "2", "ESTELLA_VERIFY_EXPECT": "[{\"x\":0.25,\"y\":0.4,\"rgb\":[0,255,255],\"tol\":40},{\"x\":0.25,\"y\":0.6,\"rgb\":[255,255,0],\"tol\":40},{\"x\":0.75,\"y\":0.4,\"rgb\":[0,255,0],\"tol\":40},{\"x\":0.75,\"y\":0.6,\"rgb\":[0,255,0],\"tol\":40}]" } },
  // The same frame under a white sky. A bake is the surface's WHOLE indirect term,
  // so it replaces the sky rather than joining it: the baked halves stay cyan and
  // yellow, where a bake added on top would wash them white like the unbaked quad.
  { id: "lightmap-sky", tier: "pr", webgpu: true, env: { "ESTELLA_VERIFY_SCENE": "/scenes/lightmap-sky.esscene", "ESTELLA_VERIFY_MANIFEST": "/scenes/lightmap-sky.textures.json", "ESTELLA_VERIFY_W": "256", "ESTELLA_VERIFY_H": "256", "ESTELLA_VERIFY_STEPS": "2", "ESTELLA_VERIFY_EXPECT": "[{\"x\":0.25,\"y\":0.4,\"rgb\":[0,255,255],\"tol\":40},{\"x\":0.25,\"y\":0.6,\"rgb\":[255,255,0],\"tol\":40},{\"x\":0.75,\"y\":0.4,\"rgb\":[255,255,255],\"tol\":40},{\"x\":0.75,\"y\":0.6,\"rgb\":[255,255,255],\"tol\":40}]" } },
  // The bake through an imported model's material under an environment: it replaces the
  // environment's diffuse half. The quad carries a normal and the material a tint, so a
  // program that fails to link (seventeen samplers with the batch stream's eight) shows.
  // A room of built-in cubes lit by a sun through a skylight and baked (8 bounces): the walls are bounce light alone, so a bake the frame
  // never reads (a built-in mesh with no lightmap UV set) leaves them black, and too few bounces leave them at half. Probe colours are the
  // engine's, each within 4 of Cycles' own render of the same room (tools/render-lab, gi_room).
  { id: "gi-room-baked", tier: "pr", webgpu: true, env: { "ESTELLA_VERIFY_COLORSPACE": "linear", "ESTELLA_VERIFY_SCENE": "/scenes/gi-room-baked.esscene", "ESTELLA_VERIFY_MANIFEST": "/scenes/gi-room-baked.textures.json", "ESTELLA_VERIFY_TEXTURES": "runtime", "ESTELLA_VERIFY_W": "320", "ESTELLA_VERIFY_H": "180", "ESTELLA_VERIFY_STEPS": "4", "ESTELLA_VERIFY_EXPECT": "[{\"x\":0.5,\"y\":0.099,\"rgb\":[66,63,60],\"tol\":10},{\"x\":0.239,\"y\":0.508,\"rgb\":[69,30,26],\"tol\":10},{\"x\":0.761,\"y\":0.508,\"rgb\":[23,46,21],\"tol\":10},{\"x\":0.441,\"y\":0.344,\"rgb\":[61,55,53],\"tol\":10},{\"x\":0.375,\"y\":0.711,\"rgb\":[64,54,51],\"tol\":10}]" } },
  // The same room unbaked, lit by Voxel GI: the bounce light on the red wall is red, because it is reflected by the albedo the wall wrote beside its
  // normal. Before the albedo attachment it was guessed from the lit picture, and a wall the sun does not reach came out grey. Both backends' caches
  // also take the sun's shadow map and feed each bounce back, and land within a few levels of each other.
  { id: "gi-room-voxel", tier: "pr", webgpu: true, softwareGpu: false, env: { "ESTELLA_VERIFY_PLAY": "1", "ESTELLA_VERIFY_COLORSPACE": "linear", "ESTELLA_VERIFY_SCENE": "/scenes/gi-room-voxel.esscene", "ESTELLA_VERIFY_MANIFEST": "/scenes/gi-room-voxel.textures.json", "ESTELLA_VERIFY_W": "320", "ESTELLA_VERIFY_H": "180", "ESTELLA_VERIFY_STEPS": "120", "ESTELLA_VERIFY_EXPECT": "[{\"x\":0.5,\"y\":0.099,\"rgb\":[81,77,76],\"tol\":18},{\"x\":0.239,\"y\":0.508,\"rgb\":[77,35,30],\"tol\":18},{\"x\":0.761,\"y\":0.508,\"rgb\":[30,55,28],\"tol\":18}]" } },
  { id: "lightmap-model", tier: "pr", webgpu: true, env: { "ESTELLA_VERIFY_MESH_MATERIAL": "/scenes/lightmap-model/rough.esmaterial", "ESTELLA_VERIFY_SCENE": "/scenes/lightmap-model.esscene", "ESTELLA_VERIFY_MANIFEST": "/scenes/lightmap-model.textures.json", "ESTELLA_VERIFY_W": "256", "ESTELLA_VERIFY_H": "256", "ESTELLA_VERIFY_STEPS": "2", "ESTELLA_VERIFY_EXPECT": "[{\"x\":0.25,\"y\":0.4,\"rgb\":[0,255,255],\"tol\":20},{\"x\":0.25,\"y\":0.6,\"rgb\":[128,255,0],\"tol\":20},{\"x\":0.75,\"y\":0.4,\"rgb\":[29,255,61],\"tol\":20},{\"x\":0.75,\"y\":0.6,\"rgb\":[29,255,61],\"tol\":20}]" } },
  // Why the rectangle rides the per-object record: ONE mesh and ONE atlas, and
  // the two objects drawn from them read different halves of it. A rectangle
  // that belonged to the mesh would paint these two the same colour.
  { id: "lightmap-atlas", tier: "pr", webgpu: true, env: { "ESTELLA_VERIFY_SCENE": "/scenes/lightmap-atlas-share.esscene", "ESTELLA_VERIFY_MANIFEST": "/scenes/lightmap-atlas-share.textures.json", "ESTELLA_VERIFY_W": "256", "ESTELLA_VERIFY_H": "256", "ESTELLA_VERIFY_STEPS": "2", "ESTELLA_VERIFY_EXPECT": "[{\"x\":0.25,\"y\":0.4,\"rgb\":[255,0,0],\"tol\":30},{\"x\":0.25,\"y\":0.6,\"rgb\":[255,0,0],\"tol\":30},{\"x\":0.75,\"y\":0.4,\"rgb\":[0,0,255],\"tol\":30},{\"x\":0.75,\"y\":0.6,\"rgb\":[0,0,255],\"tol\":30}]" } },
  // TWO morphed draws in one pass, a quarter of the way and all of it. A per-draw
  // block they SHARE is written twice before either draws on a backend that queues
  // uploads, so both wear the last weight — invisible to a single-object scene.
  { id: "mesh-morph-two", tier: "pr", webgpu: true, env: { "ESTELLA_VERIFY_SCENE": "/scenes/mesh-morph-two.esscene", "ESTELLA_VERIFY_W": "256", "ESTELLA_VERIFY_H": "256", "ESTELLA_VERIFY_STEPS": "2", "ESTELLA_VERIFY_EXPECT": "[{\"x\":0.375,\"y\":0.25,\"rgb\":[0,255,0],\"tol\":30},{\"x\":0.75,\"y\":0.25,\"rgb\":[0,0,0],\"tol\":20},{\"x\":0.75,\"y\":0.75,\"rgb\":[0,255,0],\"tol\":30}]" } },
  // WHAT LIGHTS A THING THAT MOVES. There is no light in this scene at all: the
  // only thing that can colour these triangles is the grid the volume holds.
  { id: "probe-lit", tier: "pr", webgpu: true, env: { "ESTELLA_VERIFY_SCENE": "/scenes/probe-lit.esscene", "ESTELLA_VERIFY_MANIFEST": "/scenes/probe-lit.textures.json", "ESTELLA_VERIFY_W": "256", "ESTELLA_VERIFY_H": "256", "ESTELLA_VERIFY_STEPS": "2", "ESTELLA_VERIFY_EXPECT": "[{\"x\":0.3,\"y\":0.556,\"rgb\":[255,0,0],\"tol\":30},{\"x\":0.7,\"y\":0.556,\"rgb\":[255,0,0],\"tol\":30}]" } },
  // The nine coefficients carry a DIRECTION, not just an amount. The fixture's
  // two triangles face +Z and +X, and the grid is grey with red along +X — so a
  // volume flattened to its constant term paints these two the same grey.
  // A grid baked with sky occlusion: no light of its own, a fifth of the sky seen everywhere, under a plain white Ambient light. The sky
  // is the frame's, seen through the grid: a fifth of white, 54. Read as a grid of the old kind (the sky left out) it is black, 3.
  { id: "lit-builtin-lightmap-uv", tier: "pr", webgpu: true, env: { "ESTELLA_VERIFY_COLORSPACE": "linear", "ESTELLA_VERIFY_SCENE": "/scenes/lit-builtin-lightmap-uv.esscene", "ESTELLA_VERIFY_W": "256", "ESTELLA_VERIFY_H": "256", "ESTELLA_VERIFY_STEPS": "4", "ESTELLA_VERIFY_EXPECT": "[{\"x\":0.5,\"y\":0.75,\"rgb\":[183,179,164],\"tol\":20}]" } },
  { id: "probe-sky", tier: "pr", webgpu: true, env: { "ESTELLA_VERIFY_SCENE": "/scenes/probe-sky.esscene", "ESTELLA_VERIFY_MANIFEST": "/scenes/probe-sky.textures.json", "ESTELLA_VERIFY_W": "256", "ESTELLA_VERIFY_H": "256", "ESTELLA_VERIFY_STEPS": "2", "ESTELLA_VERIFY_EXPECT": "[{\"x\":0.3,\"y\":0.556,\"rgb\":[54,54,54],\"tol\":10}]" } },
  { id: "probe-facing", tier: "pr", webgpu: true, env: { "ESTELLA_VERIFY_SCENE": "/scenes/probe-facing.esscene", "ESTELLA_VERIFY_MANIFEST": "/scenes/probe-facing.textures.json", "ESTELLA_VERIFY_W": "256", "ESTELLA_VERIFY_H": "256", "ESTELLA_VERIFY_STEPS": "2", "ESTELLA_VERIFY_EXPECT": "[{\"x\":0.3,\"y\":0.556,\"rgb\":[128,128,128],\"tol\":30},{\"x\":0.7,\"y\":0.556,\"rgb\":[255,128,128],\"tol\":30}]" } },
  // Red at one end of the box, blue at the other. The object in the MIDDLE is the
  // claim: nearest-probe would paint it one of the two, and only a read that
  // interpolates can put it between them.
  { id: "probe-blend", tier: "pr", webgpu: true, env: { "ESTELLA_VERIFY_SCENE": "/scenes/probe-blend.esscene", "ESTELLA_VERIFY_MANIFEST": "/scenes/probe-blend.textures.json", "ESTELLA_VERIFY_W": "256", "ESTELLA_VERIFY_H": "256", "ESTELLA_VERIFY_STEPS": "2", "ESTELLA_VERIFY_EXPECT": "[{\"x\":0.26,\"y\":0.5,\"rgb\":[255,0,0],\"tol\":30},{\"x\":0.46,\"y\":0.5,\"rgb\":[128,0,128],\"tol\":30},{\"x\":0.66,\"y\":0.5,\"rgb\":[0,0,255],\"tol\":30}]" } },
  // A baked surface and a probe-lit one inside ONE volume. The bake already holds
  // every bounce that reached it, so the atlas half must stay red: a draw taking
  // both would come out purple, and only a frame with both in it can say so.
  // ONE mesh across the same box. Read per object it would be the purple its centre stands in, end to end; read per
  // pixel (the grid through the frame's probe atlas) its left end is red and its right blue, as a merged building
  // spanning a shed and the yard is dark under the roof and lit outside.
  { id: "probe-per-pixel", tier: "pr", webgpu: true, env: { "ESTELLA_VERIFY_SCENE": "/scenes/probe-per-pixel.esscene", "ESTELLA_VERIFY_MANIFEST": "/scenes/probe-per-pixel.textures.json", "ESTELLA_VERIFY_W": "256", "ESTELLA_VERIFY_H": "256", "ESTELLA_VERIFY_STEPS": "2", "ESTELLA_VERIFY_EXPECT": "[{\"x\":0.36,\"y\":0.5,\"rgb\":[213,0,38],\"tol\":20},{\"x\":0.625,\"y\":0.5,\"rgb\":[43,0,193],\"tol\":20}]" } },
  // The same box, and a mesh whose ORIGIN is outside it (x -200) while its right end draws inside: an imported level's
  // walls keep the origin the file gave them. Chosen by its origin it is in no volume and black; by its box it reads the
  // grid where each pixel stands.
  { id: "probe-off-origin", tier: "pr", webgpu: true, env: { "ESTELLA_VERIFY_SCENE": "/scenes/probe-off-origin.esscene", "ESTELLA_VERIFY_MANIFEST": "/scenes/probe-off-origin.textures.json", "ESTELLA_VERIFY_W": "256", "ESTELLA_VERIFY_H": "256", "ESTELLA_VERIFY_STEPS": "2", "ESTELLA_VERIFY_EXPECT": "[{\"x\":0.353,\"y\":0.508,\"rgb\":[205,0,31],\"tol\":20},{\"x\":0.432,\"y\":0.508,\"rgb\":[158,0,77],\"tol\":20}]" } },
  { id: "probe-lightmap", tier: "pr", webgpu: true, env: { "ESTELLA_VERIFY_SCENE": "/scenes/probe-lightmap.esscene", "ESTELLA_VERIFY_MANIFEST": "/scenes/probe-lightmap.textures.json", "ESTELLA_VERIFY_W": "256", "ESTELLA_VERIFY_H": "256", "ESTELLA_VERIFY_STEPS": "2", "ESTELLA_VERIFY_EXPECT": "[{\"x\":0.25,\"y\":0.5667,\"rgb\":[255,0,0],\"tol\":30},{\"x\":0.85,\"y\":0.5,\"rgb\":[0,0,255],\"tol\":30}]" } },
  // A clip driving the weight, which is what an imported `weights` channel
  // becomes. The shape has to cross the boundary as a LIST — a weight written
  // into a component the runtime hands back as an embind vector goes nowhere.
  { id: "mesh-morph-animated", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_PLAY: "1", ESTELLA_VERIFY_SCENE: "/scenes/mesh-morph-anim.esscene", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "30", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.75,\"y\":0.5,\"rgb\":[0,255,0],\"tol\":30},{\"x\":0.25,\"y\":0.5,\"rgb\":[0,0,0],\"tol\":20}]" } },
    // A mesh casting on a mesh: a floor 200 units below a blocker, sun leaning 0.5 in
    // x, so the shadow lands 100 along +x and x 75..175 is floor the light cannot see.
    // The blocker itself stays lit — shadowing one's own caster is the classic bug.
  { id: "mesh-shadow", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/mesh-shadow.esscene", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_COUNTERS: "{\"render.shadow.atlasBudget\":2048,\"render.shadow.atlasSize\":1024,\"render.targets.bytes\":8388608}", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.708,\"y\":0.5,\"rgb\":[0,0,0],\"tol\":20},{\"x\":0.167,\"y\":0.5,\"rgb\":[228,228,228],\"tol\":20},{\"x\":0.5,\"y\":0.5,\"rgb\":[228,228,228],\"tol\":20}]" } },
  // A shadow map kept from frame to frame follows its caster: drawn, kept for frames (render.shadow.reused), then the blocker moves up, across the light, so nothing but its record says it moved. A stale map would leave the old shadow at (0.708, 0.5).
  { id: "mesh-shadow-moved", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/mesh-shadow.esscene", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_SET_FIELD: "[{\"entity\":2,\"component\":\"Transform\",\"key\":\"position\",\"value\":{\"x\":0,\"y\":0,\"z\":0},\"steps\":10},{\"entity\":2,\"component\":\"Transform\",\"key\":\"position\",\"value\":{\"x\":0,\"y\":150,\"z\":0},\"steps\":3}]", ESTELLA_VERIFY_COUNTERS: "{\"render.shadow.reused\":1}", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.708,\"y\":0.5,\"rgb\":[228,228,228],\"tol\":20},{\"x\":0.708,\"y\":0.25,\"rgb\":[0,0,0],\"tol\":20},{\"x\":0.5,\"y\":0.25,\"rgb\":[228,228,228],\"tol\":20}]" } },
  // The same shadow turned 30 degrees with a hard source, so its edges cross the map's
  // texel grid; a filter that draws that grid into them strays by a quarter pixel.
  { id: "mesh-shadow-tilt", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/mesh-shadow-tilt.esscene", ESTELLA_VERIFY_W: "512", ESTELLA_VERIFY_H: "512", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_EDGE: "{\"box\":[0.6,0.36,0.9,0.52],\"lit\":228,\"dark\":0,\"maxJag\":0.12}", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.167,\"y\":0.5,\"rgb\":[228,228,228],\"tol\":20}]" } },
  // The same with the light's default source, the sun's 0.53°: a penumbra, as clean.
  { id: "mesh-shadow-tilt-sun", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/mesh-shadow-tilt-sun.esscene", ESTELLA_VERIFY_W: "512", ESTELLA_VERIFY_H: "512", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_EDGE: "{\"box\":[0.6,0.36,0.9,0.52],\"lit\":228,\"dark\":0,\"maxJag\":0.12}", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.167,\"y\":0.5,\"rgb\":[228,228,228],\"tol\":20}]" } },

    // The same scene with a MATERIAL on the occluder, over three frames because a
    // stale sampler unit needs a previous frame. Red at the centre says the material
    // ran in the CAMERA's pass; black at 0.708 says the occluder still cast.
  // A shadow pass INSIDE a capture, which nothing else here puts together: the other
  // linear gates cast nothing and the other shadow gates are gamma. The atlas takes
  // the target away mid-frame; whether the capture is handed back is what this pins.
  { id: "mesh-shadow-linear", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_COLORSPACE: "linear", ESTELLA_VERIFY_SCENE: "/scenes/mesh-shadow.esscene", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.708,\"y\":0.5,\"rgb\":[0,0,0],\"tol\":20},{\"x\":0.167,\"y\":0.5,\"rgb\":[243,243,243],\"tol\":20},{\"x\":0.5,\"y\":0.5,\"rgb\":[243,243,243],\"tol\":20}]" } },
  // A caster cut out by its alpha: the left half of the blocker is opaque and the right half clear, so only the left half casts. The floor
  // at x=60 is in its shadow (and seen through the clear half), the floor at x=150 is where the right half would have shaded it.
  // The Skin shader's detail layer: two quads under a light nearly along the surface, the right one with a detail normal map tilted toward the light
  // at strength 1 and the left with strength 0. Only the shine reads the detail, and it lights up where the tilt turns the normal toward the half vector.
  // The Skin shader's per-channel, curvature-shaped wrap: two spheres lit from the side, the right with u_preIntegrate 1. Past the terminator
  // the wrap carries red further than green and blue, so the right sphere's shade is redder where the left's is the same in every channel.
  { id: "skin-preintegrate", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/skin-preint.esscene", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.3125,\"y\":0.5,\"rgb\":[77,32,24],\"tol\":15},{\"x\":0.8125,\"y\":0.5,\"rgb\":[94,13,0],\"tol\":15}]" } },
  // The Eye shader's lid shadow: two quads facing up under a light from above, the right with u_lidShadow 1, so the surface the upper lid sits over is darker.
  { id: "eye-lid", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/eye-lid.esscene", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.117,\"y\":0.5,\"rgb\":[159,157,154],\"tol\":15},{\"x\":0.859,\"y\":0.5,\"rgb\":[64,63,62],\"tol\":15}]" } },
  // The Hair shader's tip pass: two cards whose alpha ramps from 0 to 1 across them, cut at 0.6; the right one draws the band below the cutoff as a
  // second, blended pass fading in toward it, so a pixel at alpha 0.45 shows the card half over the background where the left shows only the background.
  { id: "hair-tips", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/hair-tips.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/hair-tips.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.229,\"y\":0.5,\"rgb\":[0,0,0],\"tol\":10},{\"x\":0.729,\"y\":0.5,\"rgb\":[106,106,106],\"tol\":15},{\"x\":0.39,\"y\":0.5,\"rgb\":[204,204,204],\"tol\":15}]" } },
  { id: "skin-detail", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/skin-detail.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/skin-detail.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.25,\"y\":0.5,\"rgb\":[137,89,80],\"tol\":20},{\"x\":0.75,\"y\":0.5,\"rgb\":[253,205,197],\"tol\":20}]" } },
  { id: "mesh-shadow-cutout", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/mesh-shadow-cutout.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/mesh-shadow-cutout.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "3", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.6,\"y\":0.5,\"rgb\":[0,0,0],\"tol\":20},{\"x\":0.75,\"y\":0.5,\"rgb\":[228,228,228],\"tol\":20},{\"x\":0.167,\"y\":0.5,\"rgb\":[228,228,228],\"tol\":20}]" } },
  { id: "mesh-shadow-material", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/mesh-shadow-material.esscene", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "3", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.5,\"y\":0.5,\"rgb\":[255,0,0],\"tol\":40},{\"x\":0.708,\"y\":0.5,\"rgb\":[0,0,0],\"tol\":20},{\"x\":0.167,\"y\":0.5,\"rgb\":[228,228,228],\"tol\":20}]" } },

  // The same question through a PERSPECTIVE camera, which is what a 3D scene uses:
  // coverage derived from the camera's NDC z=0 slice is the whole view for the
  // orthographic one above and a sliver near the near plane for this one.
  // The caster behind the camera still shades the floor in front of it (the sun-shadow cull keeps what reaches the view); one far off to the side, whose shadow falls outside it, is left out of the map.
  { id: "mesh-shadow-cull", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/mesh-shadow-cull.esscene", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_COUNTERS: "{\"render.shadow.castersCulled\": 1}", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.7,\"y\":0.21,\"rgb\":[0,0,0],\"tol\":20},{\"x\":0.48,\"y\":0.21,\"rgb\":[255,255,255],\"tol\":20},{\"x\":0.7,\"y\":0.6,\"rgb\":[255,255,255],\"tol\":20}]" } },
  // A sun whose map spans 16000 units has texels of 31: a 60-unit caster is two of them wide, and the blocker search's sparse wide disc used to step over it, so it cast nothing.
  { id: "mesh-shadow-far-backdrop", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/mesh-shadow-far-backdrop.esscene", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.656,\"y\":0.22,\"rgb\":[0,0,0],\"tol\":30},{\"x\":0.2,\"y\":0.5,\"rgb\":[255,255,255],\"tol\":20}]" } },
  { id: "mesh-shadow-small", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/mesh-shadow-small.esscene", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.656,\"y\":0.22,\"rgb\":[0,0,0],\"tol\":30},{\"x\":0.2,\"y\":0.5,\"rgb\":[255,255,255],\"tol\":20}]" } },
  { id: "mesh-shadow-caster-behind", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/mesh-shadow-caster-behind.esscene", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.7,\"y\":0.21,\"rgb\":[0,0,0],\"tol\":20},{\"x\":0.48,\"y\":0.21,\"rgb\":[255,255,255],\"tol\":20},{\"x\":0.7,\"y\":0.6,\"rgb\":[255,255,255],\"tol\":20}]" } },
  // A CONE casting, through the tile and the pass a cascade uses. The shadow is offset
  // from the caster because a point light projects rather than sweeps; the probes either
  // side of x = 162 are its edge, and the caster is lit because it must not shadow itself.
  { id: "spot-shadow", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/spot-shadow.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/spot-shadow.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_COUNTERS: "{\"render.shadow.atlasBudget\":2048,\"render.shadow.atlasSize\":512,\"render.targets.bytes\":2097152}", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.7,\"y\":0.5,\"rgb\":[0,0,0],\"tol\":20},{\"x\":0.8,\"y\":0.5,\"rgb\":[155,155,155],\"tol\":25},{\"x\":0.25,\"y\":0.5,\"rgb\":[178,178,178],\"tol\":25},{\"x\":0.5,\"y\":0.5,\"rgb\":[196,196,196],\"tol\":25}]" } },
  // A POINT light opens no cone, so its map is a cube and a fragment is shadowed by the face
  // it lands in: report one tile for every tile and both shadows come back lit. The casters
  // are probed too, and the sixth face never renders — nothing above the lamp is a mesh.
  { id: "point-shadow", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/point-shadow.esscene", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_COUNTERS: "{\"render.shadow.heldTiles\":5,\"render.targets\":1,\"render.targets.bytes\":33554432}", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.167,\"y\":0.5,\"rgb\":[0,0,0],\"tol\":20},{\"x\":0.5,\"y\":0.833,\"rgb\":[0,0,0],\"tol\":20},{\"x\":0.333,\"y\":0.5,\"rgb\":[108,108,108],\"tol\":25},{\"x\":0.833,\"y\":0.5,\"rgb\":[102,102,102],\"tol\":25},{\"x\":0.5,\"y\":0.5,\"rgb\":[242,242,242],\"tol\":20}]" } },
  // A shadow map holds depth, so only geometry drawn depth-only belongs in one. A BLACK
  // sprite stands opposite a mesh blocker, both between lamp and floor: black unpacks as
  // depth 0, so a collected sprite would shadow its half — which has to come back lit.
  { id: "shadow-map-meshes-only", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/shadow-map-meshes-only.esscene", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.167,\"y\":0.5,\"rgb\":[102,102,102],\"tol\":20},{\"x\":0.833,\"y\":0.5,\"rgb\":[0,0,0],\"tol\":20},{\"x\":0.667,\"y\":0.5,\"rgb\":[108,108,108],\"tol\":25},{\"x\":0.5,\"y\":0.5,\"rgb\":[242,242,242],\"tol\":20}]" } },
  // A lamp with every mesh off to one side. Four of its six faces miss the box the whole
  // of the geometry sits in and never gather at all; a fifth gathers and comes back empty.
  // Both skips are invisible in a pixel, which is what the two counters are here for.
  { id: "point-shadow-offset", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/point-shadow-offset.esscene", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_COUNTERS: "{\"render.shadow.heldTiles\":2,\"render.shadow.collects\":3}", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.20,\"y\":0.5,\"rgb\":[0,0,0],\"tol\":20},{\"x\":0.35,\"y\":0.5,\"rgb\":[135,135,135],\"tol\":25},{\"x\":0.5,\"y\":0.5,\"rgb\":[191,191,191],\"tol\":25},{\"x\":0.6,\"y\":0.5,\"rgb\":[173,173,173],\"tol\":25}]" } },
  // TWO point lights, which nothing else in the corpus has: twelve faces claimed from a
  // sixteen-cell atlas, ten of them drawn. The dark probes are dim and not black because the
  // far lamp reaches that floor past the near blocker — the second map read, not a leak.
  { id: "point-shadow-pair", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/point-shadow-pair.esscene", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_COUNTERS: "{\"render.shadow.heldTiles\":10,\"render.shadow.heldDraws\":10}", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.15,\"y\":0.5,\"rgb\":[66,66,66],\"tol\":20},{\"x\":0.85,\"y\":0.5,\"rgb\":[66,66,66],\"tol\":20},{\"x\":0.25,\"y\":0.5,\"rgb\":[220,220,220],\"tol\":25},{\"x\":0.5,\"y\":0.5,\"rgb\":[255,255,255],\"tol\":20}]" } },
  // A SUN WITH A SIZE: its source is infinitely far away, so what it carries is an angle
  // and not a length — the penumbra is tan(sourceAngle/2) times how far the caster stands
  // above what it falls on.

  // The whole ramp, not just its ends: what the probes pin is the SHAPE of that penumbra,
  // which is where a sun of the wrong angular size shows. One expectation for every
  // rasterizer — webgl2, webgpu and SwiftShader read these to the value.
  { id: "sun-shadow", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/sun-shadow.esscene", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.62,\"y\":0.5,\"rgb\":[0,0,0],\"tol\":20},{\"x\":0.66,\"y\":0.5,\"rgb\":[70,70,70],\"tol\":10},{\"x\":0.68,\"y\":0.5,\"rgb\":[116,116,116],\"tol\":10},{\"x\":0.7,\"y\":0.5,\"rgb\":[170,170,170],\"tol\":10},{\"x\":0.72,\"y\":0.5,\"rgb\":[209,209,209],\"tol\":10},{\"x\":0.85,\"y\":0.5,\"rgb\":[247,247,247],\"tol\":20}]" } },
  // The same scene with the caster moved DOWN the sun's own ray: its shadow lands where it
  // did and the edge sharpens by the ratio of the distances. Two of these four probes
  // differ from the gate above by 70 and 38, which a fixed blur could not produce.
  { id: "sun-shadow-contact", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/sun-shadow-contact.esscene", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.62,\"y\":0.5,\"rgb\":[0,0,0],\"tol\":20},{\"x\":0.66,\"y\":0.5,\"rgb\":[0,0,0],\"tol\":20},{\"x\":0.72,\"y\":0.5,\"rgb\":[247,247,247],\"tol\":25},{\"x\":0.85,\"y\":0.5,\"rgb\":[247,247,247],\"tol\":20}]" } },
  // A SOURCE WITH SIZE. The light's half-extent, the blocker's distance from it and the
  // receiver's are the whole penumbra, so these probes read a soft edge here and a hard
  // one in the gate below, where the same scene's caster stands near what it falls on.
  { id: "soft-shadow", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/soft-shadow.esscene", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.73,\"y\":0.5,\"rgb\":[0,0,0],\"tol\":20},{\"x\":0.759,\"y\":0.5,\"rgb\":[0,0,0],\"tol\":20},{\"x\":0.833,\"y\":0.5,\"rgb\":[75,75,75],\"tol\":45},{\"x\":0.9,\"y\":0.5,\"rgb\":[158,158,158],\"tol\":25}]" } },
  // The same scene with the caster moved DOWN the light's own ray: its shadow lands where
  // it did and the edge sharpens by the ratio of the two distances. A fixed blur would
  // read the same in both gates, and one that ignores the source's size neither.
  { id: "soft-shadow-contact", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/soft-shadow-contact.esscene", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.745,\"y\":0.5,\"rgb\":[0,0,0],\"tol\":20},{\"x\":0.759,\"y\":0.5,\"rgb\":[85,85,85],\"tol\":55},{\"x\":0.77,\"y\":0.5,\"rgb\":[180,180,180],\"tol\":25},{\"x\":0.833,\"y\":0.5,\"rgb\":[170,170,170],\"tol\":25}]" } },
  // The same scene stepped far enough to leave a deep queue behind it: on the second
  // backend the copy of the frame lands about 2.7 seconds after it is asked for, so this
  // is the gate that says waiting for one is bounded by the device, not by a poll count.
  { id: "point-shadow-stepped", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/point-shadow.esscene", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "64", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.167,\"y\":0.5,\"rgb\":[0,0,0],\"tol\":20},{\"x\":0.5,\"y\":0.833,\"rgb\":[0,0,0],\"tol\":20},{\"x\":0.5,\"y\":0.5,\"rgb\":[242,242,242],\"tol\":20}]" } },
  { id: "mesh-shadow-cascade", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/mesh-shadow-cascade.esscene", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.657,\"y\":0.452,\"rgb\":[0,0,0],\"tol\":20},{\"x\":0.6,\"y\":0.452,\"rgb\":[252,252,252],\"tol\":20},{\"x\":0.72,\"y\":0.452,\"rgb\":[252,252,252],\"tol\":20}]" } },
  { id: "mesh-shadow-perspective", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/mesh-shadow-perspective.esscene", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.86,\"y\":0.5,\"rgb\":[0,0,0],\"tol\":20},{\"x\":0.10,\"y\":0.5,\"rgb\":[228,228,228],\"tol\":20},{\"x\":0.5,\"y\":0.5,\"rgb\":[228,228,228],\"tol\":20}]" } },
  // A sun aimed OUT of the plane: 0.25 in x and 0.25 in depth throws the blocker's
  // shadow to world +200, where a depth of -1 puts it at +50. Measured: the probe
  // at 0.833 reads 247 at depth -1 and 0 at this one.
  { id: "mesh-shadow-aimed", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/mesh-shadow-aimed.esscene", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.833,\"y\":0.5,\"rgb\":[0,0,0],\"tol\":20},{\"x\":0.167,\"y\":0.5,\"rgb\":[180,180,180],\"tol\":20},{\"x\":0.5,\"y\":0.5,\"rgb\":[180,180,180],\"tol\":20}]" } },
  // Y up, as a 3D scene is: ground in XZ, a board standing on it, a sun coming DOWN
  // with a depth component. Every gate above aims its sun in the view plane.
  { id: "mesh-shadow-yup", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/mesh-shadow-yup.esscene", ESTELLA_VERIFY_W: "512", ESTELLA_VERIFY_H: "512", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.396,\"y\":0.713,\"rgb\":[0,0,0],\"tol\":25},{\"x\":0.549,\"y\":0.891,\"rgb\":[210,210,210],\"tol\":25},{\"x\":0.598,\"y\":0.414,\"rgb\":[210,210,210],\"tol\":25}]" } },
  // A light FOLLOWING the environment's sun: its Transform aims level with the ground,
  // so only the panorama's sun, turned with it, throws the board's shadow — and inside
  // that shadow is the sky alone, without the sun the environment gave away.
  { id: "environment-sun", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/environment-sun.esscene", ESTELLA_VERIFY_W: "512", ESTELLA_VERIFY_H: "512", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.402,\"y\":0.709,\"rgb\":[39,39,39],\"tol\":12},{\"x\":0.556,\"y\":0.884,\"rgb\":[249,249,249],\"tol\":16},{\"x\":0.598,\"y\":0.414,\"rgb\":[249,249,249],\"tol\":16}]" } },
  // A lamp 120 units ABOVE a panel, a height only real geometry measures against.
  // Hand-derived, 255·NdotL·atten: 224 under it and 101 at world +200, where the
  // plane's convention reads 255 and 200.
  { id: "mesh-flat-point-3d", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/mesh-flat-point-3d.esscene", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.7,\"y\":0.5,\"rgb\":[149,149,149],\"tol\":20},{\"x\":0.7,\"y\":0.6,\"rgb\":[139,139,139],\"tol\":20},{\"x\":0.5,\"y\":0.5,\"rgb\":[0,0,0],\"tol\":10}]" } },
  { id: "mesh-point-3d", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/mesh-point-3d.esscene", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.5,\"y\":0.5,\"rgb\":[224,224,224],\"tol\":20},{\"x\":0.833,\"y\":0.5,\"rgb\":[102,102,102],\"tol\":20}]" } },
  // Geometry with no file under it. Sun 22.5° off the view axis: the cube's two faces
  // read 255·cos22.5 and 255·cos67.5, swapped if the winding is inside out; the sphere
  // reads 155 at -25 against 236 at its middle, which a flat quad could not.
  { id: "mesh-instanced", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/mesh-instanced.esscene", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_DRAW_CALLS: "1", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.25,\"y\":0.25,\"rgb\":[255,0,0],\"tol\":20},{\"x\":0.75,\"y\":0.25,\"rgb\":[0,255,0],\"tol\":20},{\"x\":0.25,\"y\":0.75,\"rgb\":[0,0,255],\"tol\":20},{\"x\":0.75,\"y\":0.75,\"rgb\":[255,255,0],\"tol\":20},{\"x\":0.5,\"y\":0.5,\"rgb\":[0,0,0],\"tol\":20}]" } },
  // What the frame COST: nine cubes inside the ortho view and six a thousand units out,
  // same mesh and same material, so render.culled is the only place the six can show.
  // batch.draws holds the nine to ONE instanced call; render.triangles counts 9 x 12.
  // Five different primitives, four of each, one shared draw state. The renderer instances each shape, so the
  // frame costs one draw per DISTINCT mesh — five. The same scene with `StaticBatch` on the meshes folds all
  // twenty into one merged mesh, and the picture must not move: the same twenty points are the claim.
  { id: "static-batch-off", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_PLAY: "1", ESTELLA_VERIFY_SCENE: "/scenes/static-batch-off.esscene", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "12", ESTELLA_VERIFY_DRAW_CALLS: "5", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.1,\"y\":0.2,\"rgb\":[255,0,0],\"tol\":30},{\"x\":0.1,\"y\":0.4,\"rgb\":[255,0,0],\"tol\":30},{\"x\":0.1,\"y\":0.6,\"rgb\":[255,0,0],\"tol\":30},{\"x\":0.1,\"y\":0.8,\"rgb\":[255,0,0],\"tol\":30},{\"x\":0.3,\"y\":0.2,\"rgb\":[255,0,0],\"tol\":30},{\"x\":0.3,\"y\":0.4,\"rgb\":[255,0,0],\"tol\":30},{\"x\":0.3,\"y\":0.6,\"rgb\":[255,0,0],\"tol\":30},{\"x\":0.3,\"y\":0.8,\"rgb\":[255,0,0],\"tol\":30},{\"x\":0.5,\"y\":0.2,\"rgb\":[255,0,0],\"tol\":30},{\"x\":0.5,\"y\":0.4,\"rgb\":[255,0,0],\"tol\":30},{\"x\":0.5,\"y\":0.6,\"rgb\":[255,0,0],\"tol\":30},{\"x\":0.5,\"y\":0.8,\"rgb\":[255,0,0],\"tol\":30},{\"x\":0.7,\"y\":0.2,\"rgb\":[255,0,0],\"tol\":30},{\"x\":0.7,\"y\":0.4,\"rgb\":[255,0,0],\"tol\":30},{\"x\":0.7,\"y\":0.6,\"rgb\":[255,0,0],\"tol\":30},{\"x\":0.7,\"y\":0.8,\"rgb\":[255,0,0],\"tol\":30},{\"x\":0.9,\"y\":0.2,\"rgb\":[255,0,0],\"tol\":30},{\"x\":0.9,\"y\":0.4,\"rgb\":[255,0,0],\"tol\":30},{\"x\":0.9,\"y\":0.6,\"rgb\":[255,0,0],\"tol\":30},{\"x\":0.9,\"y\":0.8,\"rgb\":[255,0,0],\"tol\":30},{\"x\":0.5,\"y\":0.5,\"rgb\":[0,0,0],\"tol\":20}]" } },
  { id: "static-batch-on", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_PLAY: "1", ESTELLA_VERIFY_SCENE: "/scenes/static-batch-on.esscene", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "12", ESTELLA_VERIFY_DRAW_CALLS: "1", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.1,\"y\":0.2,\"rgb\":[255,0,0],\"tol\":30},{\"x\":0.1,\"y\":0.4,\"rgb\":[255,0,0],\"tol\":30},{\"x\":0.1,\"y\":0.6,\"rgb\":[255,0,0],\"tol\":30},{\"x\":0.1,\"y\":0.8,\"rgb\":[255,0,0],\"tol\":30},{\"x\":0.3,\"y\":0.2,\"rgb\":[255,0,0],\"tol\":30},{\"x\":0.3,\"y\":0.4,\"rgb\":[255,0,0],\"tol\":30},{\"x\":0.3,\"y\":0.6,\"rgb\":[255,0,0],\"tol\":30},{\"x\":0.3,\"y\":0.8,\"rgb\":[255,0,0],\"tol\":30},{\"x\":0.5,\"y\":0.2,\"rgb\":[255,0,0],\"tol\":30},{\"x\":0.5,\"y\":0.4,\"rgb\":[255,0,0],\"tol\":30},{\"x\":0.5,\"y\":0.6,\"rgb\":[255,0,0],\"tol\":30},{\"x\":0.5,\"y\":0.8,\"rgb\":[255,0,0],\"tol\":30},{\"x\":0.7,\"y\":0.2,\"rgb\":[255,0,0],\"tol\":30},{\"x\":0.7,\"y\":0.4,\"rgb\":[255,0,0],\"tol\":30},{\"x\":0.7,\"y\":0.6,\"rgb\":[255,0,0],\"tol\":30},{\"x\":0.7,\"y\":0.8,\"rgb\":[255,0,0],\"tol\":30},{\"x\":0.9,\"y\":0.2,\"rgb\":[255,0,0],\"tol\":30},{\"x\":0.9,\"y\":0.4,\"rgb\":[255,0,0],\"tol\":30},{\"x\":0.9,\"y\":0.6,\"rgb\":[255,0,0],\"tol\":30},{\"x\":0.9,\"y\":0.8,\"rgb\":[255,0,0],\"tol\":30},{\"x\":0.5,\"y\":0.5,\"rgb\":[0,0,0],\"tol\":20}]" } },
  { id: "mesh-cost", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/mesh-cost.esscene", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_COUNTERS: "{\"render.meshes\":9,\"render.culled\":6,\"render.triangles\":108,\"batch.draws\":1}", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.1667,\"y\":0.1667,\"rgb\":[255,0,0],\"tol\":20},{\"x\":0.5,\"y\":0.5,\"rgb\":[255,0,255],\"tol\":20},{\"x\":0.8333,\"y\":0.8333,\"rgb\":[0,255,0],\"tol\":20},{\"x\":0.3,\"y\":0.5,\"rgb\":[0,0,0],\"tol\":10}]" } },
  // A lit quad says which lights can reach it, and its pixels work out only those. No pixel shows that: a light out of
  // reach added nothing before either. So the count of light slots spared is pinned (1024 quads under sixteen lamps,
  // fifteen of which a quad can decline), beside two points a lamp must still light and one none may.
  { id: "sprite-lit-reach", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/sprite-lit-local-cost.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/sprite-lit.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_SCALE: "{\"copies\":256,\"cols\":16,\"spacing\":[40,40]}", ESTELLA_VERIFY_COUNTERS: "{\"render.sprites\":1024,\"render.lights2d.spared\":14476}", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.7217,\"y\":0.375,\"rgb\":[213,151,100],\"tol\":20},{\"x\":0.2783,\"y\":0.625,\"rgb\":[213,151,100],\"tol\":20},{\"x\":0.5,\"y\":0.5,\"rgb\":[0,0,0],\"tol\":10}]" } },
  // A tilemap layer that is lit, which it could not be: four layers of tiles under sixteen lamps. Its strips carry no reach of
  // their own, so which lights a pixel works out is its screen tile's say, and what is pinned is how many (tile, light) pairs
  // are left set: 180 of 192 x 16. The points are lamps in the rows nearest the picture's top and bottom edges and two in
  // the middle, which a tile wrongly left unmarked would black out, and the gap between lamps, which none may light.
  { id: "tilemap-lit", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/tilemap-lit-cost.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/tilemap-flip.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_COUNTERS: "{\"render.lights2d.tileBits\":180}", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.2783,\"y\":0.865,\"rgb\":[224,0,0],\"tol\":25},{\"x\":0.7217,\"y\":0.135,\"rgb\":[224,0,0],\"tol\":25},{\"x\":0.7217,\"y\":0.865,\"rgb\":[224,224,0],\"tol\":25},{\"x\":0.2783,\"y\":0.135,\"rgb\":[224,224,0],\"tol\":25},{\"x\":0.7217,\"y\":0.375,\"rgb\":[236,236,0],\"tol\":25},{\"x\":0.2783,\"y\":0.625,\"rgb\":[236,236,0],\"tol\":25},{\"x\":0.5,\"y\":0.5,\"rgb\":[0,0,0],\"tol\":10}]" } },
  // A CEILING, not an exact value: at scale the question is whether submission stays O(1)
  // in the count, and render.sprites stays exact so a frame that dropped content cannot pass
  // under it. The grid is odd (99x99) so the centre probe lands ON a 2-pixel sprite.
  { id: "sprite-scale-cost", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/scale-sprites.esscene", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_SCALE: "{\"copies\":9801,\"cols\":99,\"spacing\":[6,6]}", ESTELLA_VERIFY_COUNTERS: "{\"render.sprites\":9801}", ESTELLA_VERIFY_COUNTERS_MAX: "{\"batch.draws\":8}", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.5,\"y\":0.5,\"rgb\":[230,102,26],\"tol\":20}]" } },
  // The 3D shape of the same claim: identical geometry merges by INSTANCING, so 4225 cubes
  // are one draw. A fallback to a draw per mesh leaves the picture identical and moves only
  // batch.draws, which is why the ceiling is the assertion and render.triangles the witness.
  { id: "mesh-scale-cost", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/scale-meshes.esscene", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_SCALE: "{\"copies\":4225,\"cols\":65,\"spacing\":[9,9]}", ESTELLA_VERIFY_COUNTERS: "{\"render.meshes\":4225,\"render.triangles\":50700}", ESTELLA_VERIFY_COUNTERS_MAX: "{\"batch.draws\":8}", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.5,\"y\":0.5,\"rgb\":[51,204,102],\"tol\":20}]" } },
  // Does an atlas draw scale with the CASTER count: 3249 casters are two draws (a ground quad,
  // then every cube instanced), and a fallback to one draw each changes no pixel. The probes take
  // the only ground the grid leaves bare — lit past its left edge, shadowed past its right.
  { id: "shadow-scale-cost", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/scale-shadow.esscene", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_SCALE: "{\"copies\":3249,\"cols\":57,\"spacing\":[10,10],\"keep\":[\"Camera\",\"Light\",\"Ground\"]}", ESTELLA_VERIFY_COUNTERS_MAX: "{\"render.shadow.heldDraws\":8,\"render.targets.bytes\":33554432}", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.012,\"y\":0.5,\"rgb\":[228,228,228],\"tol\":20},{\"x\":0.984,\"y\":0.5,\"rgb\":[0,0,0],\"tol\":20}]" } },
  // Two opaque cubes overlapping on screen, the red one 120 units nearer. Declares NO
  // depth layer and boots LINEAR — the cheap way to engage the post-process capture.
  // Opaque sorts front-to-back, so with no attachment the far cube paints over.
  { id: "mesh-depth-through-capture", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_COLORSPACE: "linear", ESTELLA_VERIFY_SCENE: "/scenes/mesh-depth-through-capture.esscene", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.57,\"y\":0.5,\"rgb\":[255,0,0],\"tol\":30},{\"x\":0.4,\"y\":0.5,\"rgb\":[255,0,0],\"tol\":30},{\"x\":0.74,\"y\":0.5,\"rgb\":[0,255,0],\"tol\":30},{\"x\":0.1,\"y\":0.5,\"rgb\":[0,0,0],\"tol\":20}]" } },
  // Four identical groups on the view axis, where the projected size is exactly
  // 300/distance: 0.60, 0.30, 0.15, 0.0375 against thresholds 0.5, 0.25, cull 0.05.
  // 224 + 8 + 4 triangles is the second witness — one of each mesh, nothing else.
  { id: "lod-levels", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/lod-3d.esscene", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "4", ESTELLA_VERIFY_COUNTERS: "{\"render.lod.groups\":4,\"render.lod.level0\":1,\"render.lod.level1\":1,\"render.lod.level2\":1,\"render.lod.level3\":0,\"render.lod.culled\":1,\"render.culled\":1,\"render.meshes\":3,\"render.triangles\":236}" } },
  // The same scene with nothing moved and the field of view halved. Every level
  // steps one finer, which is the claim a world distance cannot make: a distance
  // threshold answers the same at 60 degrees and at 30.
  { id: "lod-fov", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/lod-3d.esscene", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "4", ESTELLA_VERIFY_SET_FIELD: "{\"entity\":0,\"component\":\"Camera\",\"key\":\"fov\",\"value\":30,\"steps\":4}", ESTELLA_VERIFY_COUNTERS: "{\"render.lod.groups\":4,\"render.lod.level0\":2,\"render.lod.level1\":1,\"render.lod.level2\":1,\"render.lod.culled\":0,\"render.triangles\":460}" } },
  // Two of the same group at the SAME distance, one scaled to two fifths. They take
  // different levels, which is what "how big does it look" means and what a distance
  // cannot express: a hundred metres is one answer for a tower and another for a pebble.
  { id: "lod-size", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/lod-size.esscene", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "4", ESTELLA_VERIFY_COUNTERS: "{\"render.lod.groups\":2,\"render.lod.level0\":0,\"render.lod.level1\":1,\"render.lod.level2\":1,\"render.triangles\":12}" } },
  // ONE object, two cameras, one frame — and two levels, only possible if the choice
  // belongs to the view. Their sizes sit either side of one boundary and inside each
  // other's band, so a memory SHARED between the views drags both onto one level.
  { id: "lod-multi-camera", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/lod-multicam.esscene", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "8", ESTELLA_VERIFY_COUNTERS: "{\"render.lod.groups\":2,\"render.lod.level0\":1,\"render.lod.level1\":1,\"render.lod.level2\":0,\"render.lod.culled\":0}" } },
  // Sixty-four copies of one group, all at one distance and so all at one level. What
  // the batcher achieved is the whole assertion: choosing a level changes which
  // geometry a draw names and nothing else, so the copies still fold into ONE call.
  { id: "lod-instancing", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/lod-instanced.esscene", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "4", ESTELLA_VERIFY_SCALE: "{\"copies\":64,\"cols\":8,\"spacing\":[110,110]}", ESTELLA_VERIFY_COUNTERS: "{\"render.lod.groups\":64,\"render.lod.level1\":64,\"render.meshes\":64,\"render.triangles\":512,\"batch.draws\":1}" } },
  // Parked at 577 units, where the size is 0.5199 — past the 0.5 boundary, inside the
  // tenth of hysteresis above it. Arrived at from FARTHER away, so the coarse level
  // holds. The pair below is the same place reached from the other side.
  { id: "lod-hysteresis-coarse", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/lod-hyst.esscene", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "4", ESTELLA_VERIFY_SET_FIELD: "[{\"entity\":1,\"component\":\"Transform\",\"key\":\"position.z\",\"value\":-900,\"steps\":4},{\"entity\":1,\"component\":\"Transform\",\"key\":\"position.z\",\"value\":-577,\"steps\":4}]", ESTELLA_VERIFY_COUNTERS: "{\"render.lod.level0\":0,\"render.lod.level1\":1,\"render.triangles\":8}" } },
  // The same object at the same 577 units, reached from NEARER. Level 0 holds, and the
  // two gates differ in nothing a frame can see but where the object came from.
  { id: "lod-hysteresis-fine", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/lod-hyst.esscene", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "4", ESTELLA_VERIFY_SET_FIELD: "[{\"entity\":1,\"component\":\"Transform\",\"key\":\"position.z\",\"value\":-400,\"steps\":4},{\"entity\":1,\"component\":\"Transform\",\"key\":\"position.z\",\"value\":-577,\"steps\":4}]", ESTELLA_VERIFY_COUNTERS: "{\"render.lod.level0\":1,\"render.lod.level1\":0,\"render.triangles\":224}" } },
  // The swap as a PICTURE, which no counter is: the three meshes are red, green and
  // blue, so the pixel at the centre says which geometry the frame actually holds.
  { id: "lod-swap-near", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/lod-swap.esscene", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "4", ESTELLA_VERIFY_COUNTERS: "{\"render.lod.level0\":1,\"render.triangles\":224}", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.5,\"y\":0.5,\"rgb\":[255,0,0],\"tol\":40}]" } },
  { id: "lod-swap-mid", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/lod-swap.esscene", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "4", ESTELLA_VERIFY_SET_FIELD: "{\"entity\":1,\"component\":\"Transform\",\"key\":\"position.z\",\"value\":-360,\"steps\":4}", ESTELLA_VERIFY_COUNTERS: "{\"render.lod.level1\":1,\"render.triangles\":8}", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.5,\"y\":0.5,\"rgb\":[0,255,0],\"tol\":40}]" } },
  { id: "lod-swap-far", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/lod-swap.esscene", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "4", ESTELLA_VERIFY_SET_FIELD: "{\"entity\":1,\"component\":\"Transform\",\"key\":\"position.z\",\"value\":-400,\"steps\":4}", ESTELLA_VERIFY_COUNTERS: "{\"render.lod.level2\":1,\"render.triangles\":4}", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.5,\"y\":0.5,\"rgb\":[0,0,255],\"tol\":40}]" } },
  // A group whose stand-in cannot be posed by the same skeleton is REFUSED whole
  // rather than honoured into a bind pose: the skin draws as it always did
  // (mesh-skin's own points), and thresholds that would cull it decide nothing.
  { id: "lod-skin-refused", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/lod-skin.esscene", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_COUNTERS: "{\"render.lod.groups\":0,\"render.lod.culled\":0,\"render.meshes\":1}", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.35,\"y\":0.6,\"rgb\":[0,255,0],\"tol\":30},{\"x\":0.75,\"y\":0.35,\"rgb\":[0,255,0],\"tol\":30},{\"x\":0.75,\"y\":0.60,\"rgb\":[0,0,0],\"tol\":20}]" } },
  // A PAIR differing in ONE field: nine cubes behind a wall an Occluder declares
  // solid, two beside it. Three draws here, twelve with that field off below — and
  // the SAME four pixels, which is the whole claim about what an occluder changes.
  { id: "occlusion-cull", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/occlusion-cost.esscene", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_COUNTERS: "{\"render.meshes\": 3, \"render.culled\": 9, \"render.cull.occluded\": 9, \"render.cull.occluders\": 1}", ESTELLA_VERIFY_EXPECT: "[{\"x\": 0.5, \"y\": 0.5, \"rgb\": [255, 255, 255], \"tol\": 20}, {\"x\": 0.918, \"y\": 0.5, \"rgb\": [0, 255, 0], \"tol\": 30}, {\"x\": 0.082, \"y\": 0.5, \"rgb\": [0, 255, 0], \"tol\": 30}, {\"x\": 0.98, \"y\": 0.02, \"rgb\": [0, 0, 0], \"tol\": 10}]" } },
  { id: "occlusion-off", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/occlusion-cost.esscene", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_SET_FIELD: "{\"entity\": 1, \"component\": \"Occluder\", \"key\": \"enabled\", \"value\": false, \"steps\": 2}", ESTELLA_VERIFY_COUNTERS: "{\"render.meshes\": 12, \"render.culled\": 0, \"render.cull.occluded\": 0, \"render.cull.occluders\": 0}", ESTELLA_VERIFY_EXPECT: "[{\"x\": 0.5, \"y\": 0.5, \"rgb\": [255, 255, 255], \"tol\": 20}, {\"x\": 0.918, \"y\": 0.5, \"rgb\": [0, 255, 0], \"tol\": 30}, {\"x\": 0.082, \"y\": 0.5, \"rgb\": [0, 255, 0], \"tol\": 30}, {\"x\": 0.98, \"y\": 0.02, \"rgb\": [0, 0, 0], \"tol\": 10}]" } },
  { id: "mesh-builtin", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/mesh-builtin.esscene", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.3667,\"y\":0.5,\"rgb\":[236,236,236],\"tol\":20},{\"x\":0.1333,\"y\":0.5,\"rgb\":[98,98,98],\"tol\":20},{\"x\":0.75,\"y\":0.5,\"rgb\":[236,236,236],\"tol\":20},{\"x\":0.6667,\"y\":0.5,\"rgb\":[155,155,155],\"tol\":20},{\"x\":0.5,\"y\":0.5,\"rgb\":[0,0,0],\"tol\":20}]" } },
  // A baked panorama lighting a surface BY DIRECTION: two coplanar triangles, one
  // white colour, normals up and down under a sky blue above and red below. A flat
  // ambient term draws the halves identically, which is why the probes invert.
  { id: "mesh-sky", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/mesh-sky.esscene", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.5,\"y\":0.15,\"rgb\":[0,0,153],\"tol\":20},{\"x\":0.5,\"y\":0.85,\"rgb\":[153,0,0],\"tol\":20},{\"x\":0.5,\"y\":0.5,\"rgb\":[106,0,33],\"tol\":20},{\"x\":0.15,\"y\":0.5,\"rgb\":[76,0,70],\"tol\":20}]" } },
  // The sky from the editor eye. Level is where a quad on the far plane rounded past
  // it and was clipped whole; down and up hold which half is which. The editor's own
  // sweep (desktop editor check sky-angles) covers the angles this eye does not.
  { id: "sky-eye-down", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/mesh-sky.esscene", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_PERSPECTIVE: "1", ESTELLA_VERIFY_ORBIT: "0,60", ESTELLA_VERIFY_UNIFORM: "1", ESTELLA_VERIFY_COUNT: "[{\"rgb\":[153,0,0],\"tol\":48,\"atLeast\":60000}]" } },
  { id: "sky-eye-up", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/mesh-sky.esscene", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_PERSPECTIVE: "1", ESTELLA_VERIFY_ORBIT: "0,-60", ESTELLA_VERIFY_UNIFORM: "1", ESTELLA_VERIFY_COUNT: "[{\"rgb\":[0,0,153],\"tol\":48,\"atLeast\":60000}]" } },
  { id: "sky-eye-level", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/mesh-sky.esscene", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_PERSPECTIVE: "1", ESTELLA_VERIFY_ORBIT: "180,0", ESTELLA_VERIFY_COUNT: "[{\"rgb\":[0,0,153],\"tol\":48,\"atLeast\":6000},{\"rgb\":[153,0,0],\"tol\":48,\"atLeast\":2500}]" } },
  { id: "mat-env", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/mat-env.esscene", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.25,\"y\":0.55,\"rgb\":[0,6,149],\"tol\":20},{\"x\":0.75,\"y\":0.55,\"rgb\":[148,8,0],\"tol\":20},{\"x\":0.5,\"y\":0.55,\"rgb\":[0,0,0],\"tol\":20}]" } },
  // The same sky in a MIRROR: two metal quads, roughness 0 and 1. A head-on
  // surface reflects +Z, which is the image centre — green there, and the whole
  // sphere averaged at the rough end. One flat term would draw them alike.

  // Dynamic captures keep source geometry and the clipped reflection visible together.
  {"id": "planar-reflection", "tier": "pr", "webgpu": true, "env": {"ESTELLA_VERIFY_SCENE": "/scenes/planar-reflection.esscene", "ESTELLA_VERIFY_W": "512", "ESTELLA_VERIFY_H": "512", "ESTELLA_VERIFY_STEPS": "3", "ESTELLA_VERIFY_EXPECT": "[{\"x\": 0.390625, \"y\": 0.41015625, \"rgb\": [255, 0, 0], \"tol\": 25}, {\"x\": 0.390625, \"y\": 0.56640625, \"rgb\": [255, 0, 0], \"tol\": 25}, {\"x\": 0.60546875, \"y\": 0.5234375, \"rgb\": [0, 255, 0], \"tol\": 25}]", "ESTELLA_VERIFY_COUNTERS": "{\"render.planar.draws\": 1}"}},
  // A mirror shows all of what it sees, and a sun or a hot spot is far past 1: the reflected colour is brought down to a cap by its
  // brightest channel, hue kept. A red cube at (6, 0.6, 0), in a linear frame, is seen directly as 255,203,0 and in the mirror as (1.5, 0.15, 0): 255,108,0 (unclamped it would be 255,203,0 again).
  {"id": "planar-reflection-hot", "tier": "pr", "webgpu": true, "env": {"ESTELLA_VERIFY_SCENE": "/scenes/planar-reflection-hot.esscene", "ESTELLA_VERIFY_W": "512", "ESTELLA_VERIFY_H": "512", "ESTELLA_VERIFY_COLORSPACE": "linear", "ESTELLA_VERIFY_STEPS": "3", "ESTELLA_VERIFY_EXPECT": "[{\"x\": 0.390625, \"y\": 0.41015625, \"rgb\": [255, 203, 0], \"tol\": 25}, {\"x\": 0.390625, \"y\": 0.56640625, \"rgb\": [255, 108, 0], \"tol\": 25}]", "ESTELLA_VERIFY_COUNTERS": "{\"render.planar.draws\": 1}"}},
  {"id": "planar-reflection-off", "tier": "pr", "webgpu": true, "env": {"ESTELLA_VERIFY_SCENE": "/scenes/planar-reflection.esscene", "ESTELLA_VERIFY_W": "512", "ESTELLA_VERIFY_H": "512", "ESTELLA_VERIFY_STEPS": "3", "ESTELLA_VERIFY_EXPECT": "[{\"x\": 0.390625, \"y\": 0.41015625, \"rgb\": [255, 0, 0], \"tol\": 25}, {\"x\": 0.390625, \"y\": 0.56640625, \"rgb\": [0, 0, 0], \"tol\": 15}]", "ESTELLA_VERIFY_SET_FIELD": "{\"entity\": 2, \"component\": \"PlanarReflection\", \"key\": \"enabled\", \"value\": false, \"steps\": 3}"}},
  // TWO mirrors under one sky, one inside a ReflectionProbe: the baked column is
  // red and the sky green, so the picture says which answer each surface took.
  // One atlas serves both — a reflection is a number per instance, not a bind.
  { id: "reflection-probe", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/reflection-probe.esscene", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_COUNTERS: "{\"render.reflection.probes\": 1}", ESTELLA_VERIFY_EXPECT: "[{\"x\": 0.25, \"y\": 0.5, \"rgb\": [255, 0, 0], \"tol\": 30}, {\"x\": 0.75, \"y\": 0.5, \"rgb\": [0, 228, 0], \"tol\": 30}, {\"x\": 0.5, \"y\": 0.5, \"rgb\": [0, 0, 0], \"tol\": 20}]" } },
  // The same scene with the probe switched off: both mirrors take the sky again,
  // which is the claim that a probe REPLACES an answer rather than adding one.
  // The same probe, shown at half strength: a weather that darkens the scene turns the baked reflection down with it,
  // so the red the probe mirrors is a darker red, and the sky outside it is untouched.
  { id: "reflection-probe-dim", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/reflection-probe.esscene", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_SET_FIELD: "{\"entity\": 1, \"component\": \"Light\", \"key\": \"reflectionScale\", \"value\": 0.25, \"steps\": 2}", ESTELLA_VERIFY_EXPECT: "[{\"x\": 0.25, \"y\": 0.5, \"rgb\": [64, 0, 0], \"tol\": 20}, {\"x\": 0.75, \"y\": 0.5, \"rgb\": [0, 228, 0], \"tol\": 30}]" } },
  { id: "reflection-probe-off", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/reflection-probe.esscene", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_SET_FIELD: "{\"entity\": 2, \"component\": \"ReflectionProbe\", \"key\": \"enabled\", \"value\": false, \"steps\": 2}", ESTELLA_VERIFY_EXPECT: "[{\"x\": 0.25, \"y\": 0.5, \"rgb\": [0, 228, 0], \"tol\": 30}, {\"x\": 0.75, \"y\": 0.5, \"rgb\": [0, 228, 0], \"tol\": 30}]" } },
  // A BAKED room and a mirror ball in it: red on its left, green on its right.
  // A baked atlas has mixed channels at low alpha, which is what texture-alpha
  // guards on WebGPU: dividing by alpha twice turns this ball grey.
  { id: "reflection-room", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/reflection-room.esscene", ESTELLA_VERIFY_W: "512", ESTELLA_VERIFY_H: "384", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_EXPECT: "[{\"x\": 0.2, \"y\": 0.55, \"rgb\": [255, 62, 54], \"tol\": 45}, {\"x\": 0.42, \"y\": 0.62, \"rgb\": [42, 255, 71], \"tol\": 45}]" } },
  // A mirror ball filling the frame inside a probe whose column is one red everywhere (the
  // marker a darker red, so the frame is not flat): every pixel is that red. A tap letting the
  // hardware pick a mip reads the next column across the octahedral fold — 65310 of 65536.
  { id: "reflection-fold", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/reflection-fold.esscene", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_COUNT: "[{\"rgb\": [243, 0, 0], \"tol\": 45, \"atLeast\": 65536}]" } },
  // The same ball with the probe off: both sides take the flat sky, and the room
  // stops being visible in it.
  { id: "reflection-room-sky", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/reflection-room.esscene", ESTELLA_VERIFY_W: "512", ESTELLA_VERIFY_H: "384", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_SET_FIELD: "{\"entity\": 8, \"component\": \"ReflectionProbe\", \"key\": \"enabled\", \"value\": false, \"steps\": 2}", ESTELLA_VERIFY_EXPECT: "[{\"x\": 0.2, \"y\": 0.55, \"rgb\": [37, 37, 39], \"tol\": 25}, {\"x\": 0.42, \"y\": 0.62, \"rgb\": [37, 37, 39], \"tol\": 25}]" } },
  // The rough metal keeps the energy its microfacets bounce between them: a white metal reflects
  // the whole environment, where single scattering alone gave back Ess (0.45 at roughness 1).
  { id: "mat-env-mirror", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/mat-env-mirror.esscene", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.25,\"y\":0.5,\"rgb\":[0,228,0],\"tol\":20},{\"x\":0.75,\"y\":0.5,\"rgb\":[65,53,53],\"tol\":20},{\"x\":0.5,\"y\":0.5,\"rgb\":[0,0,0],\"tol\":20}]" } },
  // Sky and DIELECTRIC apart: they read the atlas and the irradiance coefficients
  // through different code, and one turning without the other is the defect. The
  // fixture is half bright — a symmetric sky reads the same at every angle.
  { id: "sky-azimuth", tier: "pr", webgpu: false, env: { ESTELLA_VERIFY_SCENE: "/scenes/sky-azimuth.esscene", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.1,\"y\":0.5,\"rgb\":[5,5,5],\"tol\":18},{\"x\":0.5,\"y\":0.5,\"rgb\":[145,9,9],\"tol\":24},{\"x\":0.9,\"y\":0.5,\"rgb\":[255,14,14],\"tol\":24}]" } },
  { id: "sky-azimuth-turned", tier: "pr", webgpu: false, env: { ESTELLA_VERIFY_SCENE: "/scenes/sky-azimuth.esscene", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_SET_FIELD: "{\"entity\":1,\"component\":\"Light\",\"key\":\"environmentRotation\",\"value\":20}", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.1,\"y\":0.5,\"rgb\":[5,5,5],\"tol\":18},{\"x\":0.5,\"y\":0.5,\"rgb\":[255,14,14],\"tol\":24},{\"x\":0.9,\"y\":0.5,\"rgb\":[255,14,14],\"tol\":24}]" } },
  // A panorama is seen from inside as its photographer saw it: red left of the
  // centre column, blue right, and a camera facing that column sees them so. A
  // mirrored mapping passes every gate above, which compare the sky with itself.
  { id: "env-handed", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/env-handed.esscene", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.25,\"y\":0.5,\"rgb\":[255,8,8],\"tol\":30},{\"x\":0.75,\"y\":0.5,\"rgb\":[8,8,255],\"tol\":30}]" } },
  { id: "env-handed-sky", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/env-handed-sky.esscene", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.25,\"y\":0.5,\"rgb\":[255,8,8],\"tol\":30},{\"x\":0.75,\"y\":0.5,\"rgb\":[8,8,255],\"tol\":30}]" } },
  { id: "diffuse-azimuth", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/diffuse-azimuth.esscene", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.25,\"y\":0.5,\"rgb\":[157,10,10],\"tol\":24},{\"x\":0.75,\"y\":0.5,\"rgb\":[157,10,10],\"tol\":24}]" } },
  // An ambient light's diffuse scale and tint reach the irradiance a surface is lit by: half the scale is half the light, and a
  // tint with no red leaves a red sky's surfaces dark. A copy that scaled nothing, or scaled the sky drawn behind them, passes the rest.
  { id: "diffuse-scale", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/diffuse-azimuth.esscene", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_SET_FIELD: "{\"entity\":1,\"component\":\"Light\",\"key\":\"diffuseScale\",\"value\":0.5}", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.25,\"y\":0.5,\"rgb\":[79,5,5],\"tol\":12},{\"x\":0.75,\"y\":0.5,\"rgb\":[79,5,5],\"tol\":12}]" } },
  { id: "diffuse-tint", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/diffuse-azimuth.esscene", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_SET_FIELD: "{\"entity\":1,\"component\":\"Light\",\"key\":\"diffuseTint\",\"value\":{\"r\":0,\"g\":1,\"b\":1,\"a\":1}}", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.25,\"y\":0.5,\"rgb\":[2,10,10],\"tol\":8},{\"x\":0.75,\"y\":0.5,\"rgb\":[2,10,10],\"tol\":8}]" } },
  { id: "diffuse-azimuth-turned", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/diffuse-azimuth.esscene", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_SET_FIELD: "{\"entity\":1,\"component\":\"Light\",\"key\":\"environmentRotation\",\"value\":-90}", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.25,\"y\":0.5,\"rgb\":[255,14,14],\"tol\":24},{\"x\":0.75,\"y\":0.5,\"rgb\":[255,14,14],\"tol\":24}]" } },  // A glTF animation, through the shipped importer. The scene puts the quad at
  // x=150 and the clip runs -120 to 120 over a second, so 30 fixed steps is its
  // midpoint: the model is at the origin and where the SCENE put it is empty.
  { id: "model-animation", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_PLAY: "1", ESTELLA_VERIFY_SCENE: "/scenes/model-animation.esscene", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "30", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.5,\"y\":0.5,\"rgb\":[0,255,0],\"tol\":30},{\"x\":0.875,\"y\":0.5,\"rgb\":[0,0,0],\"tol\":20},{\"x\":0.2,\"y\":0.5,\"rgb\":[0,0,0],\"tol\":20}]" } },
  // Cells the atlas does not hold, both ways one can be asked for: an id past a
  // 2x2 tileset, and four declared columns over a two-column atlas. The in-range
  // cells still draw — a layer that stopped drawing satisfies empty probes alone.
  { id: "tilemap-oob", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/tilemap-oob.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/tilemap-flip.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.60,\"y\":0.36,\"rgb\":[0,0,0],\"tol\":20},{\"x\":0.40,\"y\":0.80,\"rgb\":[0,0,0],\"tol\":20},{\"x\":0.40,\"y\":0.36,\"rgb\":[255,0,0]},{\"x\":0.40,\"y\":0.58,\"rgb\":[0,0,255]},{\"x\":0.60,\"y\":0.58,\"rgb\":[255,255,0]}]" } },
    // Parallax on a cached-chunk tilemap: the camera moves while the layer model is untouched, so only the per-frame origin/parallax merge (not a revision-bump rebuild) can place the tiles — guards against baking camera-dependent offsets into the chunk cache.
  { id: "tilemap-parallax", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/tilemap-parallax.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/tilemap-flip.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_MOVE: "{\"component\":\"Camera\",\"to\":[48,-16],\"steps\":3}", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.30,\"y\":0.40,\"rgb\":[255,0,0]},{\"x\":0.10,\"y\":0.40,\"rgb\":[0,0,0],\"tol\":20},{\"x\":0.50,\"y\":0.40,\"rgb\":[0,255,0]}]" } },
    // BitmapText's first pixel coverage: a 2-glyph synthetic .fnt atlas (red A, green B) pins glyph layout, atlas UV orientation and the one-DrawCommand-per-text path.
  { id: "bitmaptext", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/bitmaptext.esscene", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "3", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.40,\"y\":0.5,\"rgb\":[255,0,0],\"tol\":20},{\"x\":0.60,\"y\":0.5,\"rgb\":[0,255,0],\"tol\":20},{\"x\":0.5,\"y\":0.15,\"rgb\":[0,0,0],\"tol\":20}]" } },
  { id: "ui-mask", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/ui-list-mask.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/ui-list-mask.textures.json", ESTELLA_VERIFY_W: "800", ESTELLA_VERIFY_H: "600", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.5,\"y\":0.5,\"rgb\":[255,0,0],\"tol\":60},{\"x\":0.9,\"y\":0.5,\"rgb\":[0,0,255],\"tol\":60},{\"x\":0.5,\"y\":0.85,\"rgb\":[0,0,255],\"tol\":60},{\"x\":0.5,\"y\":0.15,\"rgb\":[0,0,255],\"tol\":60}]" } },
    // Camera.cullingMask over sorting layers, for world content AND for UI — whose `layer` encodes tree order, so it belongs to its Canvas' layer instead. Layers 1 (the Canvas) and 2 (blue) are cleared from the mask, so only green and yellow survive; unmasked, the full-screen HUD covers both.
  { id: "camera-culling", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_PLAY: "1", ESTELLA_VERIFY_SCENE: "/scenes/camera-culling.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/camera-culling.textures.json", ESTELLA_VERIFY_W: "320", ESTELLA_VERIFY_H: "180", ESTELLA_VERIFY_STEPS: "4", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.25,\"y\":0.5,\"rgb\":[0,255,0],\"tol\":30},{\"x\":0.75,\"y\":0.5,\"rgb\":[255,255,0],\"tol\":30}]" } },
    // Where the UI layout box SITS. The camera is driven away from the origin at runtime, so the box moves without resizing: the unparented Canvas (a screen root) must travel with it — red/green stay in their quadrants — while the Canvas parented to a world entity must not, landing blue at the anchor's own world position. Before screen roots existed the whole HUD stayed at the origin and this frame came back black.
  { id: "ui-screen-root", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_PLAY: "1", ESTELLA_VERIFY_SCENE: "/scenes/ui-screen-root.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/ui-screen-root.textures.json", ESTELLA_VERIFY_W: "640", ESTELLA_VERIFY_H: "360", ESTELLA_VERIFY_STEPS: "4", ESTELLA_VERIFY_MOVE: "{\"component\":\"Camera\",\"to\":[5000,-800],\"steps\":4}", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.25,\"y\":0.25,\"rgb\":[255,0,0],\"tol\":30},{\"x\":0.75,\"y\":0.75,\"rgb\":[0,255,0],\"tol\":30},{\"x\":0.75,\"y\":0.25,\"rgb\":[0,0,255],\"tol\":30},{\"x\":0.25,\"y\":0.75,\"rgb\":[0,0,0],\"tol\":30}]" } },
  // A HUD over a PERSPECTIVE camera. That view has no world rectangle, so a
  // layout box taken from a camera resolves every HUD element to 0x0 and the two
  // corners here come back black.
  { id: "ui-screen-3d", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_PLAY: "1", ESTELLA_VERIFY_SCENE: "/scenes/ui-screen-3d.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/ui-screen-3d.textures.json", ESTELLA_VERIFY_W: "640", ESTELLA_VERIFY_H: "360", ESTELLA_VERIFY_STEPS: "4", ESTELLA_VERIFY_EXPECT: "[{\"x\": 0.25, \"y\": 0.25, \"rgb\": [255, 0, 0], \"tol\": 30}, {\"x\": 0.75, \"y\": 0.75, \"rgb\": [0, 255, 0], \"tol\": 30}, {\"x\": 0.75, \"y\": 0.25, \"rgb\": [0, 0, 255], \"tol\": 40}, {\"x\": 0.25, \"y\": 0.75, \"rgb\": [0, 0, 0], \"tol\": 30}]" } },
  // ...and the camera leaves. The world blob goes with it — the control, without
  // which this would pass on a frame where nothing moved — and the two corners
  // stay exactly where they were.
  { id: "ui-screen-3d-camera-moved", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_PLAY: "1", ESTELLA_VERIFY_SCENE: "/scenes/ui-screen-3d.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/ui-screen-3d.textures.json", ESTELLA_VERIFY_W: "640", ESTELLA_VERIFY_H: "360", ESTELLA_VERIFY_STEPS: "4", ESTELLA_VERIFY_MOVE: "{\"component\": \"Camera\", \"to\": [4000, 1000], \"steps\": 4}", ESTELLA_VERIFY_EXPECT: "[{\"x\": 0.25, \"y\": 0.25, \"rgb\": [255, 0, 0], \"tol\": 30}, {\"x\": 0.75, \"y\": 0.75, \"rgb\": [0, 255, 0], \"tol\": 30}, {\"x\": 0.75, \"y\": 0.25, \"rgb\": [0, 0, 0], \"tol\": 30}, {\"x\": 0.25, \"y\": 0.75, \"rgb\": [0, 0, 0], \"tol\": 30}]" } },
  // What a screen element's z may decide, which is nothing. Three roots carry
  // z -10000 / 0 / +10000 and all three must draw; a fourth, LATER sibling with
  // the furthest z of all covers the first, because the tree orders a screen.
  { id: "ui-screen-order", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_PLAY: "1", ESTELLA_VERIFY_SCENE: "/scenes/ui-screen-order.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/ui-screen-order.textures.json", ESTELLA_VERIFY_W: "640", ESTELLA_VERIFY_H: "360", ESTELLA_VERIFY_STEPS: "4", ESTELLA_VERIFY_EXPECT: "[{\"x\": 0.16, \"y\": 0.1, \"rgb\": [255, 0, 0], \"tol\": 30}, {\"x\": 0.5, \"y\": 0.5, \"rgb\": [0, 255, 0], \"tol\": 30}, {\"x\": 0.83, \"y\": 0.5, \"rgb\": [0, 0, 255], \"tol\": 30}, {\"x\": 0.16, \"y\": 0.5, \"rgb\": [255, 255, 255], \"tol\": 30}]" } },
  // Where the overlay sits, which is after the post chain. A vignette crushes
  // the WORLD quad to black a third of the way in (the two black points are the
  // control) while the badge in the very corner keeps the red it was authored.
  { id: "ui-screen-post", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_PLAY: "1", ESTELLA_VERIFY_SCENE: "/scenes/ui-screen-post.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/ui-screen-post.textures.json", ESTELLA_VERIFY_W: "640", ESTELLA_VERIFY_H: "360", ESTELLA_VERIFY_STEPS: "4", ESTELLA_VERIFY_EXPECT: "[{\"x\": 0.03, \"y\": 0.03, \"rgb\": [255, 0, 0], \"tol\": 6}, {\"x\": 0.3, \"y\": 0.03, \"rgb\": [0, 0, 0], \"tol\": 6}, {\"x\": 0.97, \"y\": 0.97, \"rgb\": [0, 0, 0], \"tol\": 6}, {\"x\": 0.5, \"y\": 0.5, \"rgb\": [51, 153, 255], \"tol\": 10}]" } },
  // HUD TEXT, which the SDK submits itself — the one screen primitive that could
  // be left in a camera's list while the panel under it moved. Under this
  // perspective camera such text lands nowhere and the panel comes back blue.
  // Asked as HOW MUCH yellow, not where: which stroke covers x=0.4 is a fact
  // about the runner's fonts, and probes at named strokes read the panel on
  // Linux while the text was drawn. 13282 pixels here; the floor of 2000 stands.
  { id: "ui-screen-text", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_PLAY: "1", ESTELLA_VERIFY_SCENE: "/scenes/ui-screen-text.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/ui-screen-text.textures.json", ESTELLA_VERIFY_W: "640", ESTELLA_VERIFY_H: "360", ESTELLA_VERIFY_STEPS: "6", ESTELLA_VERIFY_EXPECT: "[{\"x\": 0.05, \"y\": 0.5, \"rgb\": [0, 0, 153], \"tol\": 40}]", ESTELLA_VERIFY_COUNT: "[{\"rgb\": [255, 255, 0], \"tol\": 40, \"atLeast\": 2000}]" } },
  // A Canvas and NO Camera. The screen is a surface and a design fit, so neither
  // the layout NOR the presentation needs a view to exist — this is the scene
  // that keeps that a promise rather than an accident of the mask union.
  { id: "ui-screen-no-camera", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_PLAY: "1", ESTELLA_VERIFY_SCENE: "/scenes/ui-screen-no-camera.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/ui-screen-no-camera.textures.json", ESTELLA_VERIFY_W: "640", ESTELLA_VERIFY_H: "360", ESTELLA_VERIFY_STEPS: "4", ESTELLA_VERIFY_EXPECT: "[{\"x\": 0.25, \"y\": 0.25, \"rgb\": [255, 0, 0], \"tol\": 30}, {\"x\": 0.75, \"y\": 0.75, \"rgb\": [0, 255, 0], \"tol\": 30}]" } },
    // Y-sort: same scene twice — mask on flips the overlap to the lower (higher-Y-key) entity; mask off preserves submission order. Both asserted so neither path can silently regress.
  // Slices of one continuous pattern, each its OWN texture, at a fractional
  // world-units-per-pixel — seamless art and a non-integer ratio are what a seam
  // needs. The PAIR is the gate: `-off` asserts the measurement still finds one.
  // WebGL2 only, and measured: on WebGPU these frames differ at ONE pixel of one
  // boundary, so the ratio is 1.68 without the policy and 1.36 with it - both under
  // the limit, which leaves the pair proving nothing there.
  //
  // atLeast is 1.8 because the seam's SIZE is the rasterizer's and its absence is
  // not: policy on / off reads 1.354 / 3.033 on a real GPU and 1.356 / 2.196 on
  // the software GL CI runs, so only 1.8 is mid-gap on both.
  { id: "sprite-seam", tier: "pr", env: { ESTELLA_VERIFY_SCENE: "/scenes/sprite-seam.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/sprite-seam.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_RENDER_RESOLUTION: "1", ESTELLA_VERIFY_SEAM: "{\"period\":73.143,\"phase\":54.857,\"band\":{\"y0\":100,\"y1\":156},\"limit\":2}" } },
  { id: "sprite-seam-off", tier: "pr", env: { ESTELLA_VERIFY_SCENE: "/scenes/sprite-seam.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/sprite-seam.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_SEAM: "{\"period\":73.143,\"phase\":54.857,\"band\":{\"y0\":100,\"y1\":156},\"atLeast\":1.8}" } },
  { id: "ysort-on", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_YSORT: "1", ESTELLA_VERIFY_SCENE: "/scenes/ysort.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/ysort.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.5,\"y\":0.5,\"rgb\":[0,255,0],\"tol\":30},{\"x\":0.5,\"y\":0.25,\"rgb\":[255,0,0],\"tol\":30},{\"x\":0.5,\"y\":0.75,\"rgb\":[0,255,0],\"tol\":30}]" } },
  { id: "ysort-off", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/ysort.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/ysort.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.5,\"y\":0.5,\"rgb\":[255,0,0],\"tol\":30}]" } },
    // Depth layers (2.5D): same scene twice, one project setting apart. The near sprite is in the LOWER layer and both merge into ONE draw call, so inside the batch the order is fixed by index — no amount of sorting can produce the depth answer, which is what makes the pair discriminating.
  { id: "depth-on", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_DEPTH_LAYERS: "6", ESTELLA_VERIFY_SCENE: "/scenes/depth-layers.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/depth-layers.textures.json", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.573,\"y\":0.5,\"rgb\":[255,0,0],\"tol\":60}]" } },
  { id: "depth-off", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/depth-layers.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/depth-layers.textures.json", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.573,\"y\":0.5,\"rgb\":[0,0,255],\"tol\":60}]" } },
    // Motion trail: move a TrailRenderer entity across the frame in play mode, asserting the ribbon rasterizes as a green band (head/mid/tail) with black above it — the CPU-ribbon-through-the-batch-face path.
  { id: "trail", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_PLAY: "1", ESTELLA_VERIFY_SCENE: "/scenes/trail.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/trail.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_TRAIL: "{\"from\":[-200,0],\"to\":[200,0],\"steps\":20}", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.80,\"y\":0.5,\"rgb\":[0,255,0],\"tol\":50},{\"x\":0.5,\"y\":0.5,\"rgb\":[0,255,0],\"tol\":50},{\"x\":0.25,\"y\":0.5,\"rgb\":[0,255,0],\"tol\":60},{\"x\":0.5,\"y\":0.15,\"rgb\":[0,0,0],\"tol\":30}]" } },
    // A ribbon whose path runs through depth. Measured both ways: per-point z spans
    // x 0.20-0.65, flattened onto the head's plane only 0.40-0.60 — hence two left
    // probes, and none at the head, the plane a flat ribbon collapses ONTO.
  { id: "trail-depth", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_PLAY: "1", ESTELLA_VERIFY_SCENE: "/scenes/trail-depth.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/trail-depth.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_TRAIL: "{\"from\":[-200,0,0],\"to\":[200,0,-400],\"steps\":20}", ESTELLA_VERIFY_EXPECT: "[{\"x\": 0.22, \"y\": 0.5, \"rgb\": [0, 255, 0], \"tol\": 50}, {\"x\": 0.3, \"y\": 0.5, \"rgb\": [0, 255, 0], \"tol\": 50}, {\"x\": 0.5, \"y\": 0.5, \"rgb\": [0, 255, 0], \"tol\": 50}, {\"x\": 0.8, \"y\": 0.5, \"rgb\": [0, 0, 0], \"tol\": 30}, {\"x\": 0.5, \"y\": 0.3, \"rgb\": [0, 0, 0], \"tol\": 30}]" } },
    // Linear-light pipeline (colorSpace: 'linear'). The lit falloff moves 52 to 125 (perceptually-uniform light); the mid-gray texture must ROUND-TRIP exactly (sRGB store → hw decode → blit encode = identity) — a missing sRGB upload variant would read ~187, so tol 6 is a hard discriminator.
  { id: "linear-lit", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_COLORSPACE: "linear", ESTELLA_VERIFY_SCENE: "/scenes/mat-lit-point.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/mat-lit-point.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.5,\"y\":0.5,\"rgb\":[0,254,0],\"tol\":25},{\"x\":0.75,\"y\":0.5,\"rgb\":[0,125,0],\"tol\":25}]" } },
  { id: "linear-midtone", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_COLORSPACE: "linear", ESTELLA_VERIFY_SCENE: "/scenes/srgb-midtone.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/srgb-midtone.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.5,\"y\":0.5,\"rgb\":[128,128,128],\"tol\":6}]" } },
  // A half-transparent texel whose channels are neither 0 nor 255: (200,100,40) at alpha 128 over
  // black is (100,50,20) on every backend. Dividing by alpha a second time reads (128,100,40) —
  // and a texture of pure channels hides that, since 0 and 255 survive the division.
  { id: "texture-alpha", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/alpha-midtone.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/alpha-midtone.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.5,\"y\":0.5,\"rgb\":[100,50,20],\"tol\":6}]" } },
  // The output transform on the scene whose whole subject is one known value:
  // 0.502 sRGB in, 157 out, with the capture engaged by the curve alone — no
  // effects, no linear mode. Hand-derived, so a wrong shoulder is a wrong number.
  { id: "output-aces", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/srgb-midtone.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/srgb-midtone.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_OUTPUT_TRANSFORM: "aces", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.5,\"y\":0.5,\"rgb\":[157,157,157],\"tol\":4}]" } },
  // The same curve in linear light: 0.502 decodes to 0.2158, ACES maps it to
  // 0.3242, the OETF encodes that to 154. Applied ONCE — twice would read 182,
  // and linear-midtone beside this one reads 128 with no transform at all.
  { id: "output-aces-linear", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/srgb-midtone.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/srgb-midtone.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_COLORSPACE: "linear", ESTELLA_VERIFY_OUTPUT_TRANSFORM: "aces", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.5,\"y\":0.5,\"rgb\":[154,154,154],\"tol\":4}]" } },
  // A second camera that clears depth only, over a linear frame: how every first-person view model is drawn. A linear frame
  // sends each camera through a capture of its own, and the overlay's started black and was copied over the first camera's
  // picture whole — the grey in the middle read 0 and only the held red square was left. Composited by coverage, both stay.
  { id: "overlay-camera-linear", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/overlay-camera-linear.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/overlay-camera-linear.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_COLORSPACE: "linear", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.5,\"y\":0.5,\"rgb\":[128,128,128],\"tol\":8},{\"x\":0.133,\"y\":0.5,\"rgb\":[128,0,0],\"tol\":12},{\"x\":0.85,\"y\":0.15,\"rgb\":[0,0,0],\"tol\":10}]" } },
    // Post-process chain guards — bloom's first CI pixel coverage. The gamma scene pins the LDR multi-pass chain; the linear scene is the HDR discriminator: threshold 1.5 sits above anything an 8-bit chain can store, so glow OUTSIDE the sprite (x=0.64) proves over-range light survived the float intermediates — the same scene blooms NOTHING in gamma mode.
    // Since the pyramid bloom the glow has a long tail: the HDR scene (intensity 2, radius 3) lights the far corner too, and the gamma scene's falls to black within a third of the frame.
  // Colour Grade's split toning, S-curve and lift (acting on what the display shows): three flat greys, a blue-ish shadow tint, a warm
  // highlight tint and a blue lift. The dark grey takes the shadow tint and the lift, the bright one the highlight tint, the middle one
  // half and half: (0.05,0.05,0.05) -> (6,10,26), (0.35) -> (67,71,80), (0.8) -> (204,163,115).
  { id: "color-grade-split", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_PLAY: "1", ESTELLA_VERIFY_SCENE: "/scenes/color-grade-split.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/color-grade-split.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "6", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.25,\"y\":0.5,\"rgb\":[6,10,26],\"tol\":6},{\"x\":0.5,\"y\":0.5,\"rgb\":[67,71,80],\"tol\":8},{\"x\":0.75,\"y\":0.5,\"rgb\":[204,163,115],\"tol\":8}]" } },
  // Wet ground: a 3-texel mask over a lit grey slab (puddle | damp | dry), seen from above under a sun straight overhead. Dry is the
  // diffuse alone (102); damp darkens by Wet Darken but is smoother, so it takes more of the sun's highlight (152); a puddle is flat and
  // near-mirror, and the sun is in it (236).
  { id: "wet-ground", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_PLAY: "1", ESTELLA_VERIFY_SCENE: "/scenes/wet-ground.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/wet-ground.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "6", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.1667,\"y\":0.5,\"rgb\":[236,236,236],\"tol\":14},{\"x\":0.5,\"y\":0.5,\"rgb\":[152,152,152],\"tol\":12},{\"x\":0.8333,\"y\":0.5,\"rgb\":[102,102,102],\"tol\":8}]" } },
  { id: "bloom-ldr", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_PLAY: "1", ESTELLA_VERIFY_SCENE: "/scenes/bloom-ldr.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/bloom-ldr.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "10", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.61,\"y\":0.5,\"rgb\":[0,58,0],\"tol\":25},{\"x\":0.7,\"y\":0.5,\"rgb\":[0,12,0],\"tol\":10},{\"x\":0.85,\"y\":0.5,\"rgb\":[0,0,0],\"tol\":12}]" } },
  { id: "hdr-bloom", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_PLAY: "1", ESTELLA_VERIFY_COLORSPACE: "linear", ESTELLA_VERIFY_SCENE: "/scenes/hdr-bloom.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/hdr-bloom.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "10", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.5,\"y\":0.5,\"rgb\":[0,255,0],\"tol\":25},{\"x\":0.64,\"y\":0.5,\"rgb\":[0,208,0],\"tol\":35},{\"x\":0.85,\"y\":0.5,\"rgb\":[0,76,0],\"tol\":25}]" } },
  // A small hot spot, and the glow it throws: as far out along a diagonal as along an axis, so the halo is round. A blur
  // that samples four diagonal taps per pass (the Kawase chain bloom was) throws a diamond, and a dark edge against a
  // bright sky then carries a hard-cornered band; the pyramid's tents throw a round one with a long, faint tail.
  { id: "bloom-round", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_PLAY: "1", ESTELLA_VERIFY_COLORSPACE: "linear", ESTELLA_VERIFY_SCENE: "/scenes/bloom-round.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/bloom-round.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "10", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.5,\"y\":0.5,\"rgb\":[0,255,0],\"tol\":25},{\"x\":0.5479,\"y\":0.5,\"rgb\":[0,96,0],\"tol\":22},{\"x\":0.5322,\"y\":0.5322,\"rgb\":[0,96,0],\"tol\":22},{\"x\":0.626,\"y\":0.5,\"rgb\":[0,21,0],\"tol\":10},{\"x\":0.5908,\"y\":0.5908,\"rgb\":[0,21,0],\"tol\":10}]" } },
  // Lens flare, the first pixel coverage it has. A bright quad stands left of centre (the source at x=0.35), and the flare mirrors it through the centre: ghosts along the line to the other side, and a halo a fixed way out. Without the effect those places are black.
  { id: "hdr-lens-flare", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_PLAY: "1", ESTELLA_VERIFY_COLORSPACE: "linear", ESTELLA_VERIFY_SCENE: "/scenes/hdr-lens-flare.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/hdr-lens-flare.textures.json", ESTELLA_VERIFY_W: "512", ESTELLA_VERIFY_H: "512", ESTELLA_VERIFY_STEPS: "10", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.75,\"y\":0.55,\"rgb\":[255,255,253],\"tol\":25},{\"x\":0.85,\"y\":0.8,\"rgb\":[255,255,182],\"tol\":35},{\"x\":0.5,\"y\":0.5,\"rgb\":[0,0,0],\"tol\":12},{\"x\":0.5,\"y\":0.1,\"rgb\":[0,0,0],\"tol\":12},{\"x\":0.9,\"y\":0.1,\"rgb\":[0,0,0],\"tol\":12}]" } },
  // AgX: five patches of known scene-linear colour read against what Blender's own AgX displays for them (tools/render-align/agx_chart.py in the
  // star-neighbors game, look None): a grey ramp, a skin tone and a dim blue. The curve and the table are what is under test, on both backends.
  { id: "agx-chart", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_PLAY: "1", ESTELLA_VERIFY_COLORSPACE: "linear", ESTELLA_VERIFY_SCENE: "/scenes/agx-chart.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/agx-chart.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "10", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.1,\"y\":0.5,\"rgb\":[66,66,66],\"tol\":10},{\"x\":0.3,\"y\":0.5,\"rgb\":[136,136,136],\"tol\":10},{\"x\":0.5,\"y\":0.5,\"rgb\":[197,197,197],\"tol\":10},{\"x\":0.7,\"y\":0.5,\"rgb\":[160,135,125],\"tol\":10},{\"x\":0.9,\"y\":0.5,\"rgb\":[45,77,118],\"tol\":10}]" } },
  { id: "video", tier: "nightly", webgpu: true, env: { ESTELLA_VERIFY_PLAY: "1", ESTELLA_VERIFY_SETTLE_MS: "2500", ESTELLA_VERIFY_SCENE: "/scenes/video-playback.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/video-playback.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.5,\"y\":0.25,\"rgb\":[255,0,0],\"tol\":90},{\"x\":0.5,\"y\":0.75,\"rgb\":[0,0,255],\"tol\":90}]" } },
  { id: "video-ui", tier: "nightly", webgpu: true, env: { ESTELLA_VERIFY_PLAY: "1", ESTELLA_VERIFY_SETTLE_MS: "2500", ESTELLA_VERIFY_SCENE: "/scenes/video-ui.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/video-ui.textures.json", ESTELLA_VERIFY_W: "800", ESTELLA_VERIFY_H: "600", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.5,\"y\":0.25,\"rgb\":[255,0,0],\"tol\":90},{\"x\":0.5,\"y\":0.75,\"rgb\":[0,0,255],\"tol\":90}]" } },
  // The other skeletal runtime, on the same terms as spine below it: a side
  // module that quietly stops drawing looks exactly like one that never ran, and
  // spine had a scene here while dragonbones had only a device smoke.
  { id: "dragonbones", tier: "pr", webgpu: true, rendersOnly: "a skeleton has no interior flat enough to name a point in — the claim is that it reached the frame at all", env: { ESTELLA_VERIFY_SCENE: "/scenes/dragonbones-test.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/dragonbones-test.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256" } },
  { id: "spine", tier: "nightly", webgpu: true, rendersOnly: "measured: of 2025 sampled points, none sits in a region flat enough to survive CI's rasterizer — the skeleton has no interior that wide", env: { ESTELLA_VERIFY_SCENE: "/scenes/spine-test.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/spine-test.textures.json" } },
    // Seeded on purpose: unseeded, 171 of 2025 sampled points differ between two
    // runs at the same step count, and a run nobody can reproduce is a run whose
    // failures cannot be told apart from its variety.
  { id: "particles", tier: "nightly", webgpu: true, rendersOnly: "seeded it reproduces exactly, but its particles are single points — no region is flat enough for a probe to survive CI's rasterizer", env: { ESTELLA_VERIFY_PLAY: "1", ESTELLA_VERIFY_SCENE: "/scenes/particle-demo.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/particle-demo.textures.json", ESTELLA_VERIFY_STEPS: "90", ESTELLA_VERIFY_SEED: "1234" } },
  // A camera 300 to the side, turned to look back down world -X at ONE particle.
  // A quad fixed in the x/y plane is edge-on from there and covers nothing; a
  // billboard faces the viewer wherever it stands, which is the whole claim.
  { id: "particles-billboard", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_PLAY: "1", ESTELLA_VERIFY_SCENE: "/scenes/particle-billboard.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/particle-billboard.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "20", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.5,\"y\":0.5,\"rgb\":[0,255,0],\"tol\":90}]" } },
  // A particle drawn by an AUTHORED material: the fixture's shader ignores the
  // particle's own green and paints the material's red, so the two are told
  // apart by the pixel rather than by both being plausible.
  { id: "particles-material", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_PLAY: "1", ESTELLA_VERIFY_SCENE: "/scenes/particle-material.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/particle-material.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "20", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.5,\"y\":0.5,\"rgb\":[255,0,0],\"tol\":90}]" } },
  // Trail, floor collision and force fields — fixtures that existed with nothing
  // running them. Probe-less for the reason `particles` is; each claims its path
  // still produces a frame. PR tier: half a second each, otherwise unwatched.
  { id: "particles-trail", tier: "pr", webgpu: true, rendersOnly: "seeded and reproducible, but a ribbon of moving comets has no flat region a probe survives", env: { ESTELLA_VERIFY_PLAY: "1", ESTELLA_VERIFY_SCENE: "/scenes/particle-trail.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/particle-trail.textures.json", ESTELLA_VERIFY_STEPS: "60", ESTELLA_VERIFY_SEED: "1234" } },
  { id: "particles-collision", tier: "pr", webgpu: true, rendersOnly: "sparks bouncing off a floor plane are in motion at every step a probe could read", env: { ESTELLA_VERIFY_PLAY: "1", ESTELLA_VERIFY_SCENE: "/scenes/particle-collision.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/particle-collision.textures.json", ESTELLA_VERIFY_STEPS: "70", ESTELLA_VERIFY_SEED: "1234" } },
  { id: "particles-forcefield", tier: "pr", webgpu: true, rendersOnly: "a vortex keeps every particle moving, so no cell settles", env: { ESTELLA_VERIFY_PLAY: "1", ESTELLA_VERIFY_SCENE: "/scenes/particle-forcefield.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/particle-forcefield.textures.json", ESTELLA_VERIFY_STEPS: "80", ESTELLA_VERIFY_SEED: "1234" } },
  // Simulated by a compute kernel where the device has one, by the CPU (capped) where it does not: the same scene on both,
  // so the two paths are held to one picture. A box of green squares thick enough to be solid inside its edge, black outside.
  { id: "particles-gpu", tier: "pr", webgpu: { ESTELLA_VERIFY_COUNTERS: "{\"render.particles.gpuSlots\":4000}" }, env: { ESTELLA_VERIFY_PLAY: "1", ESTELLA_VERIFY_SCENE: "/scenes/particle-gpu.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/particle-gpu.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "20", ESTELLA_VERIFY_SEED: "1234", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.5,\"y\":0.5,\"rgb\":[0,255,0],\"tol\":40},{\"x\":0.3,\"y\":0.3,\"rgb\":[0,255,0],\"tol\":40},{\"x\":0.7,\"y\":0.7,\"rgb\":[0,255,0],\"tol\":40},{\"x\":0.5,\"y\":0.06,\"rgb\":[0,0,0],\"tol\":25},{\"x\":0.94,\"y\":0.5,\"rgb\":[0,0,0],\"tol\":25}]" } },
  // The over-life curves the kernel samples: the same two scenes as the CPU gates, simulated on the GPU.
  { id: "particles-gpu-gradient", tier: "nightly", webgpu: true, env: { ESTELLA_VERIFY_PLAY: "1", ESTELLA_VERIFY_SCENE: "/scenes/particle-gpu-gradient.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/particle-gpu-gradient.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "20", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.5,\"y\":0.5,\"rgb\":[0,255,0],\"tol\":90}]" } },
  { id: "particles-gpu-sizecurve", tier: "nightly", webgpu: true, env: { ESTELLA_VERIFY_PLAY: "1", ESTELLA_VERIFY_SCENE: "/scenes/particle-gpu-sizecurve.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/particle-gpu-sizecurve.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "20", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.5,\"y\":0.5,\"rgb\":[0,255,0],\"tol\":110},{\"x\":0.28,\"y\":0.5,\"rgb\":[0,0,0],\"tol\":50}]" } },
  { id: "particles-gpu-fountain", tier: "pr", webgpu: true, rendersOnly: "a hundred thousand sparks falling, drifting on noise and bouncing off a floor are in motion at every step a probe could read", env: { ESTELLA_VERIFY_PLAY: "1", ESTELLA_VERIFY_SCENE: "/scenes/particle-gpu-fountain.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/particle-gpu-fountain.textures.json", ESTELLA_VERIFY_STEPS: "90", ESTELLA_VERIFY_SEED: "1234" } },
  { id: "particles-gradient", tier: "nightly", webgpu: true, env: { ESTELLA_VERIFY_PLAY: "1", ESTELLA_VERIFY_SCENE: "/scenes/particle-gradient.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/particle-gradient.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "20", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.5,\"y\":0.5,\"rgb\":[0,255,0],\"tol\":90}]" } },
  { id: "particles-sizecurve", tier: "nightly", webgpu: true, env: { ESTELLA_VERIFY_PLAY: "1", ESTELLA_VERIFY_SCENE: "/scenes/particle-sizecurve.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/particle-sizecurve.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "20", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.5,\"y\":0.5,\"rgb\":[0,255,0],\"tol\":110},{\"x\":0.28,\"y\":0.5,\"rgb\":[0,0,0],\"tol\":50}]" } },
      // The bright centre the chain leaves, and a corner it does not reach. Three
    // sampled points were flat interior; this takes the middle one.
  { id: "postprocess", tier: "nightly", webgpu: true, env: { ESTELLA_VERIFY_PLAY: "1", ESTELLA_VERIFY_SCENE: "/scenes/postprocess-effects.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/postprocess-effects.textures.json", ESTELLA_VERIFY_STEPS: "30", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.5,\"y\":0.5,\"rgb\":[255,255,255],\"tol\":30},{\"x\":0.06,\"y\":0.94,\"rgb\":[0,0,0],\"tol\":20}]" } },
      // One point INSIDE a glyph and one off it. Measured: of 2025 sampled points
    // exactly one sits in a stroke wide enough to be flat either side of it, and
    // the rest of the frame is the background this distinguishes it from.
  { id: "text", tier: "nightly", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/ui-text-sdf.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/ui-text-sdf.textures.json", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.42,\"y\":0.42,\"rgb\":[255,255,255],\"tol\":30},{\"x\":0.9,\"y\":0.9,\"rgb\":[0,0,0],\"tol\":20}]" } },
    // Two identical labels in one-line boxes, Visible beside Clip. The differential
    // is the point: a truncation that does nothing leaves BOTH second lines drawn,
    // which one label alone could not say. Probes measured, not guessed.
  { id: "text-overflow", tier: "nightly", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/ui-text-overflow.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/ui-text-sdf.textures.json", ESTELLA_VERIFY_W: "800", ESTELLA_VERIFY_H: "600", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.051,\"y\":0.167,\"rgb\":[255,255,255],\"tol\":30},{\"x\":0.051,\"y\":0.35,\"rgb\":[255,255,255],\"tol\":30},{\"x\":0.551,\"y\":0.167,\"rgb\":[255,255,255],\"tol\":30},{\"x\":0.551,\"y\":0.35,\"rgb\":[0,0,0],\"tol\":20}]" } },
  { id: "text-rect", tier: "nightly", webgpu: true, rendersOnly: "measured: its glyphs are thinner than any neighbourhood a probe can safely sit in — zero flat interior points", env: { ESTELLA_VERIFY_SCENE: "/scenes/ui-text-rect.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/ui-text-sdf.textures.json" } },
      // One point inside each box the flex tree lays out, taken from the middle of
    // its flat interior — so a layout that moves a box fails rather than a frame
    // that merely drew something.
  { id: "uinode", tier: "nightly", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/ui-node-flex.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/ui-node-flex.textures.json", ESTELLA_VERIFY_W: "800", ESTELLA_VERIFY_H: "600", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.08,\"y\":0.26,\"rgb\":[38,38,46],\"tol\":20},{\"x\":0.32,\"y\":0.18,\"rgb\":[64,204,89],\"tol\":25},{\"x\":0.16,\"y\":0.18,\"rgb\":[217,64,64],\"tol\":25},{\"x\":0.56,\"y\":0.16,\"rgb\":[77,115,230],\"tol\":25}]" } },
  { id: "filled", tier: "nightly", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/ui-visual-filled.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/ui-visual-filled.textures.json", ESTELLA_VERIFY_W: "800", ESTELLA_VERIFY_H: "600", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.18,\"y\":0.5,\"rgb\":[0,255,0],\"tol\":40},{\"x\":0.40,\"y\":0.5,\"rgb\":[255,0,0],\"tol\":40},{\"x\":0.58,\"y\":0.75,\"rgb\":[0,255,0],\"tol\":40},{\"x\":0.58,\"y\":0.25,\"rgb\":[255,0,0],\"tol\":40},{\"x\":0.30,\"y\":0.20,\"rgb\":[0,255,0],\"tol\":40},{\"x\":0.20,\"y\":0.333,\"rgb\":[255,0,0],\"tol\":40},{\"x\":0.30,\"y\":0.833,\"rgb\":[0,255,0],\"tol\":40},{\"x\":0.20,\"y\":0.70,\"rgb\":[255,0,0],\"tol\":40}]" } },
  { id: "tilemap-transform", tier: "nightly", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/tilemap-transform.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/tilemap-transform.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.40,\"y\":0.36,\"rgb\":[255,255,0]},{\"x\":0.60,\"y\":0.36,\"rgb\":[0,255,0]},{\"x\":0.40,\"y\":0.58,\"rgb\":[0,0,255]},{\"x\":0.60,\"y\":0.58,\"rgb\":[255,0,0]}]" } },
  { id: "tilemap-multiset", tier: "nightly", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/tilemap-multiset.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/tilemap-multiset.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "6", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.40,\"y\":0.36,\"rgb\":[255,0,0]},{\"x\":0.60,\"y\":0.36,\"rgb\":[0,255,0]},{\"x\":0.40,\"y\":0.58,\"rgb\":[0,0,255]},{\"x\":0.60,\"y\":0.58,\"rgb\":[255,255,0]}]" } },
  { id: "tilemap-spacing", tier: "nightly", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/tilemap-spacing.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/tilemap-spacing.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "6", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.40,\"y\":0.36,\"rgb\":[255,0,0]},{\"x\":0.60,\"y\":0.36,\"rgb\":[0,255,0]},{\"x\":0.40,\"y\":0.58,\"rgb\":[0,0,255]},{\"x\":0.60,\"y\":0.58,\"rgb\":[255,255,0]}]" } },
    // Tiled tile (GID) object: an object-layer object with a gid renders as a
    // positioned Sprite (bottom-left anchor, tileset UV).
  { id: "tilemap-gidobj", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/tilemap-gidobj.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/tilemap-gidobj.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "10", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.5,\"y\":0.5,\"rgb\":[0,255,0],\"tol\":40},{\"x\":0.5,\"y\":0.12,\"rgb\":[0,0,0],\"tol\":30},{\"x\":0.8125,\"y\":0.375,\"rgb\":[0,0,255],\"tol\":40},{\"x\":0.9375,\"y\":0.375,\"rgb\":[255,255,0],\"tol\":40},{\"x\":0.875,\"y\":0.8125,\"rgb\":[0,0,255],\"tol\":40},{\"x\":0.875,\"y\":0.9375,\"rgb\":[255,255,0],\"tol\":40}]" } },
  { id: "material", tier: "nightly", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/mat-tint.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/mat-tint.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.5,\"y\":0.5,\"rgb\":[255,0,0],\"tol\":40}]" } },
  { id: "ktx2", tier: "nightly", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/ktx2-sprite.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/ktx2-sprite.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.5,\"y\":0.5,\"rgb\":[0,180,0],\"tol\":50}]" } },
  { id: "material-instance", tier: "nightly", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/mat-instance.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/mat-instance.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.5,\"y\":0.5,\"rgb\":[0,255,0],\"tol\":40}]" } },
  { id: "material-texture", tier: "nightly", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/mat-tex.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/mat-tex.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.5,\"y\":0.5,\"rgb\":[0,255,0],\"tol\":50}]" } },
  { id: "material-switch", tier: "nightly", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/mat-sw.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/mat-sw.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.25,\"y\":0.5,\"rgb\":[255,0,0],\"tol\":50},{\"x\":0.75,\"y\":0.5,\"rgb\":[0,255,0],\"tol\":50}]" } },
  // A light with a SHAPE of its own: its cookie is opaque in the image's top-left
  // quadrant and nowhere else, so three of these four probes have to stay black.
  // A cookie read any way up would light a different quadrant, not a dimmer one.
  { id: "light-cookie", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/light-cookie.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/light-cookie.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "3", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.3333,\"y\":0.3333,\"rgb\":[0,155,0],\"tol\":35},{\"x\":0.6667,\"y\":0.3333,\"rgb\":[0,0,0],\"tol\":25},{\"x\":0.3333,\"y\":0.6667,\"rgb\":[0,0,0],\"tol\":25},{\"x\":0.6667,\"y\":0.6667,\"rgb\":[0,0,0],\"tol\":25}]" } },
  // The same cookie with no size of its own, which covers the light's REACH: the lit
  // quadrant runs 400 units out instead of 200. The first probe is the one that
  // says so — it is outside the authored size and inside this one.
  { id: "light-cookie-reach", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/light-cookie.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/light-cookie.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "3", ESTELLA_VERIFY_SET_FIELD: "{\"entity\":2,\"component\":\"Light\",\"key\":\"cookieSize\",\"value\":[0,0]}", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.1,\"y\":0.3333,\"rgb\":[0,76,0],\"tol\":30},{\"x\":0.4167,\"y\":0.4167,\"rgb\":[0,207,0],\"tol\":35},{\"x\":0.5833,\"y\":0.4167,\"rgb\":[0,0,0],\"tol\":25},{\"x\":0.1,\"y\":0.6667,\"rgb\":[0,0,0],\"tol\":25}]" } },
  // What a light's reach LOOKS like on the way out. One fixture, one light, three
  // probes along its radius; each gate changes exactly the field it is named for,
  // and the first changes nothing — the linear ramp every scene was written against.
  { id: "light-falloff-linear", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/light-falloff.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/light-falloff.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "3", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.5833,\"y\":0.5,\"rgb\":[0,186,0],\"tol\":20},{\"x\":0.6667,\"y\":0.5,\"rgb\":[0,114,0],\"tol\":20},{\"x\":0.75,\"y\":0.5,\"rgb\":[0,51,0],\"tol\":20}]" } },
  // A core held at full strength: the ramp starts AT the inner radius, so the first
  // two probes are only the surface's own angle to the light and the third, half
  // way out the band, keeps half where the linear ramp had it at a quarter.
  { id: "light-falloff-inner", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/light-falloff.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/light-falloff.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "3", ESTELLA_VERIFY_SET_FIELD: "{\"entity\":2,\"component\":\"Light\",\"key\":\"innerRadius\",\"value\":100}", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.5833,\"y\":0.5,\"rgb\":[0,247,0],\"tol\":20},{\"x\":0.6667,\"y\":0.5,\"rgb\":[0,228,0],\"tol\":20},{\"x\":0.75,\"y\":0.5,\"rgb\":[0,102,0],\"tol\":20}]" } },
  // The same reach, pooled: squaring the ramp darkens every point on it and moves
  // none of them, so a gate that only read the edge could not tell the two apart.
  { id: "light-falloff-curve", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/light-falloff.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/light-falloff.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "3", ESTELLA_VERIFY_SET_FIELD: "{\"entity\":2,\"component\":\"Light\",\"key\":\"falloff\",\"value\":2}", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.5833,\"y\":0.5,\"rgb\":[0,139,0],\"tol\":20},{\"x\":0.6667,\"y\":0.5,\"rgb\":[0,57,0],\"tol\":20},{\"x\":0.75,\"y\":0.5,\"rgb\":[0,13,0],\"tol\":15}]" } },

  // 2D shadows: a ShadowCaster2D box between a light and a lit surface. The
  // probes sit either side of the wall on the light's axis — lit where the
  // light reaches, dark where the box is in the way.
  { id: "shadow2d-point", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/mat-lit-shadow.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/mat-lit-shadow.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.25,\"y\":0.5,\"rgb\":[0,255,0],\"tol\":60},{\"x\":0.75,\"y\":0.5,\"rgb\":[0,0,0],\"tol\":40}]" } },
  { id: "shadow2d-hard", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/mat-lit-shadow-hard.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/mat-lit-shadow-hard.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.25,\"y\":0.5,\"rgb\":[0,255,0],\"tol\":60},{\"x\":0.75,\"y\":0.5,\"rgb\":[0,0,0],\"tol\":40}]" } },
  // A wall laid at 60 degrees. Its shadow leans with it: the probe below the
  // light's line is inside an UNTURNED box's shadow and outside this one's,
  // and a turn the other way would put it back in.
  { id: "shadow2d-turned", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/mat-lit-shadow-turned.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/mat-lit-shadow-turned.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.25,\"y\":0.5,\"rgb\":[0,255,0],\"tol\":60},{\"x\":0.75,\"y\":0.5,\"rgb\":[0,0,0],\"tol\":40},{\"x\":0.75,\"y\":0.7332,\"rgb\":[0,149,0],\"tol\":60}]" } },
  // A shadow that takes only half the light. The same scene as shadow2d-hard, whose
  // shadowed probe is black — half of it is the whole point, and 0 there would mean
  // the strength never reached the light.
  { id: "shadow2d-strength", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/mat-lit-shadow-hard.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/mat-lit-shadow-hard.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "3", ESTELLA_VERIFY_SET_FIELD: "{\"entity\":2,\"component\":\"Light\",\"key\":\"shadowStrength\",\"value\":0.5}", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.25,\"y\":0.5,\"rgb\":[0,255,0],\"tol\":60},{\"x\":0.75,\"y\":0.5,\"rgb\":[0,75,0],\"tol\":25}]" } },
  // An occluder with an OUTLINE of its own: a triangle whose shadow reaches where
  // the box beside it (20 units, and still authored) never could. The lower probe
  // is the discriminating one — lit the moment the outline stops being read.
  { id: "shadow2d-outline", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/mat-lit-shadow-outline.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/mat-lit-shadow-outline.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.75,\"y\":0.7332,\"rgb\":[0,0,0],\"tol\":40},{\"x\":0.75,\"y\":0.5,\"rgb\":[0,0,0],\"tol\":40},{\"x\":0.5833,\"y\":0.25,\"rgb\":[0,175,0],\"tol\":60}]" } },
  // Two probes inside the penumbra, where a hard shadow reads 0 and an unshadowed
  // surface reads 166: a soft edge is the only thing that lands between them.
  { id: "shadow2d-soft", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/mat-lit-shadow-soft.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/mat-lit-shadow-soft.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.25,\"y\":0.5,\"rgb\":[0,255,0],\"tol\":60},{\"x\":0.75,\"y\":0.5,\"rgb\":[0,0,0],\"tol\":40},{\"x\":0.75,\"y\":0.30,\"rgb\":[0,44,0],\"tol\":22},{\"x\":0.75,\"y\":0.70,\"rgb\":[0,52,0],\"tol\":22}]" } },
  // The sun is aimed by its Transform, a quarter turn short of face-on: its forward
  // has a component in the plane to cast along and one out of it to light with. Lit
  // at 180 rather than 255 because a directional light carries its Lambert term.
  { id: "shadow2d-directional", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/mat-lit-shadow-dir.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/mat-lit-shadow-dir.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.25,\"y\":0.5,\"rgb\":[0,180,0],\"tol\":40},{\"x\":0.75,\"y\":0.5,\"rgb\":[0,0,0],\"tol\":40}]" } },
  // Twelve occluders, the twelfth being the one the probes are about — a cap on how
  // many a frame carries drops whichever it collected last.
  { id: "shadow2d-many-occluders", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/mat-lit-shadow-many.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/mat-lit-shadow-many.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.25,\"y\":0.5,\"rgb\":[0,255,0],\"tol\":60},{\"x\":0.75,\"y\":0.5,\"rgb\":[0,0,0],\"tol\":40}]" } },
  // The same red-over-blue image as a PNG and as a KTX2, side by side: a
  // transcode that arrives upside down swaps the KTX2 pair and nothing else,
  // which a criterion probing only one half — or only the colours — cannot see.
  { id: "ktx2-orientation", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/ktx2-orientation.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/ktx2-orientation.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "4", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.2333,\"y\":0.35,\"rgb\":[220,20,20],\"tol\":25},{\"x\":0.7667,\"y\":0.35,\"rgb\":[220,20,20],\"tol\":25},{\"x\":0.2333,\"y\":0.65,\"rgb\":[20,20,220],\"tol\":25},{\"x\":0.7667,\"y\":0.65,\"rgb\":[20,20,220],\"tol\":25}]" } },
  // parallax 1 = the sprite belongs to the world, so a camera 200 to its right
  // leaves it 200 to the left of centre. Read as 0 it would be pinned to the
  // camera and sit in the middle, which is what the second probe refuses.
  { id: "parallax-control", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/parallax-control.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/parallax-control.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.1667,\"y\":0.5,\"rgb\":[0,255,0],\"tol\":30},{\"x\":0.5,\"y\":0.5,\"rgb\":[0,0,0],\"tol\":20}]" } },
  // Three absolutely-positioned boxes inside one flex panel, each a different
  // colour in a different corner: an inset read off the wrong edge moves one of
  // them onto the panel's grey, which no single-corner probe would notice.
  { id: "ui-absolute", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/ui-node-absolute.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/ui-node-absolute.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "4", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.05,\"y\":0.1,\"rgb\":[217,64,64],\"tol\":25},{\"x\":0.95,\"y\":0.1,\"rgb\":[64,204,89],\"tol\":25},{\"x\":0.5,\"y\":0.95,\"rgb\":[77,115,230],\"tol\":25},{\"x\":0.5,\"y\":0.5,\"rgb\":[31,31,38],\"tol\":20}]" } },
  // Four anchored panels, one per edge, each its own colour: an anchor resolved
  // against the wrong edge moves one onto the black behind it. The probes avoid
  // the labels — what this proves is where a box lands, not how a glyph looks.
  { id: "ui-anchor-layout", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/ui-layout.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/ui-layout.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "4", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.08,\"y\":0.08,\"rgb\":[41,82,143],\"tol\":25},{\"x\":0.78,\"y\":0.08,\"rgb\":[143,41,82],\"tol\":25},{\"x\":0.5,\"y\":0.92,\"rgb\":[41,122,62],\"tol\":25},{\"x\":0.36,\"y\":0.78,\"rgb\":[102,41,122],\"tol\":25}]" } },
  // A Text sized by its UINode box: the box is what is checked, across its width
  // and just outside it, so a box that collapsed or grew is caught without
  // asking a glyph to land on a given pixel.
  { id: "ui-text-box", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/ui-text-uinode.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/ui-text-uinode.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "4", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.36,\"y\":0.36,\"rgb\":[46,51,71],\"tol\":20},{\"x\":0.64,\"y\":0.36,\"rgb\":[46,51,71],\"tol\":20},{\"x\":0.5,\"y\":0.7,\"rgb\":[0,0,0],\"tol\":15}]" } },
  // Red at the centre exists only if a camera rendered into a texture: the fill
  // sits on a layer the screen camera culls, and the screen sprite wears that
  // target. webgl2 only — on WebGPU the frame readback returns nothing when one
  // frame holds both an offscreen and a surface pass.
  { id: "camera-render-target", tier: "pr", env: { ESTELLA_VERIFY_SCENE: "/scenes/camera-target.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/camera-target.textures.json", ESTELLA_VERIFY_CAMERA_TARGET: "{\"camera\":0,\"sprite\":3,\"width\":128,\"height\":128}", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "4", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.5,\"y\":0.5,\"rgb\":[255,0,0],\"tol\":40}]" } },
  { id: "camera-render-target-orientation", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/camera-target-orientation.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/camera-target-orientation.textures.json", ESTELLA_VERIFY_CAMERA_TARGET: "{\"camera\":0,\"sprite\":3,\"width\":128,\"height\":128}", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "4", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.5,\"y\":0.35,\"rgb\":[255,0,0],\"tol\":40},{\"x\":0.5,\"y\":0.65,\"rgb\":[0,0,255],\"tol\":40}]" } },
  { id: "fog2d-orientation", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_PLAY: "1", ESTELLA_VERIFY_SCENE: "/scenes/fog2d-orientation.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/fog2d-orientation.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "6", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.5,\"y\":0.2,\"rgb\":[255,255,255],\"tol\":40},{\"x\":0.5,\"y\":0.8,\"rgb\":[0,0,0],\"tol\":40}]" } },
  { id: "material-lit", tier: "nightly", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/mat-lit.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/mat-lit.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.5,\"y\":0.5,\"rgb\":[0,255,0],\"tol\":50}]" } },
  { id: "material-lit-point", tier: "pr", webgpu: { ESTELLA_VERIFY_EXPECT: "[{\"x\":0.5,\"y\":0.5,\"rgb\":[0,253,0],\"tol\":25},{\"x\":0.75,\"y\":0.5,\"rgb\":[0,52,0],\"tol\":25}]" }, env: { ESTELLA_VERIFY_SCENE: "/scenes/mat-lit-point.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/mat-lit-point.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.5,\"y\":0.5,\"rgb\":[0,255,0],\"tol\":50},{\"x\":0.75,\"y\":0.5,\"rgb\":[0,64,0],\"tol\":60}]" } },
  { id: "material-lit-normal", tier: "nightly", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/mat-lit-normal.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/mat-lit-normal.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.333,\"y\":0.5,\"rgb\":[0,252,0],\"tol\":45},{\"x\":0.667,\"y\":0.5,\"rgb\":[0,36,0],\"tol\":50}]" } },
  { id: "material-lit-spot", tier: "nightly", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/mat-lit-spot.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/mat-lit-spot.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.5,\"y\":0.5,\"rgb\":[0,228,0],\"tol\":55},{\"x\":0.75,\"y\":0.5,\"rgb\":[0,0,0],\"tol\":35}]" } },
  { id: "material-lit-flatnormal", tier: "nightly", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/mat-lit-flatnormal.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/mat-lit-flatnormal.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.5,\"y\":0.5,\"rgb\":[0,255,0],\"tol\":30}]" } },
  { id: "sprite-lit", tier: "nightly", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/sprite-lit.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/sprite-lit.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.5,\"y\":0.5,\"rgb\":[0,255,0],\"tol\":30}]" } },
    // The general lighting form and the camera it needs: three surfaces, a point
    // light over each. Specular 1 saturates white, specular 0 stays diffuse green,
    // and the view vector under a PERSPECTIVE camera no untouched block can fake.
  { id: "mat-pbr", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/mat-pbr.esscene", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.5,\"y\":0.5,\"rgb\":[255,255,255],\"tol\":20},{\"x\":0.2,\"y\":0.5,\"rgb\":[0,76,0],\"tol\":20},{\"x\":0.8,\"y\":0.5,\"rgb\":[86,128,248],\"tol\":20},{\"x\":0.5,\"y\":0.08,\"rgb\":[0,0,0],\"tol\":20}]" } },
    // What an imported model's material now says: same albedo, same light, same
    // roughness — metal 1 has no diffuse and reflects its own colour, metal 0
    // keeps the diffuse and adds a white lobe (ignore roughness: white drops 97).
  { id: "mat-model-pbr", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/mat-model.esscene", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.25,\"y\":0.5,\"rgb\":[0,255,0],\"tol\":20},{\"x\":0.75,\"y\":0.5,\"rgb\":[100,253,100],\"tol\":20},{\"x\":0.5,\"y\":0.5,\"rgb\":[0,0,0],\"tol\":20}]" } },
  // Equal BRDF inputs expressed once as constants and once through the legacy
  // specular/glossiness map. RGB is sRGB; alpha stays linear. Using metallic/
  // roughness, decoding alpha, or ignoring either factor breaks this pair.
  { id: 'mat-specular-glossiness', tier: 'pr', webgpu: true, env: {
    ESTELLA_VERIFY_SCENE: '/scenes/mat-specular-glossiness.esscene',
    ESTELLA_VERIFY_W: '256', ESTELLA_VERIFY_H: '256', ESTELLA_VERIFY_STEPS: '4',
    ESTELLA_VERIFY_TWINS: JSON.stringify({ pairs: [[0.25, 0.5, 0.75, 0.5]], tol: 2 }),
    ESTELLA_VERIFY_EXPECT: JSON.stringify([{ x: 0.25, y: 0.5, rgb: [95, 103, 235], tol: 8 }]),
  } },
  // Exercise the shipped texture uploader and colour-space handling too.
  { id: 'mat-specular-glossiness-runtime', tier: 'pr', webgpu: true, env: {
    ESTELLA_VERIFY_SCENE: '/scenes/mat-specular-glossiness.esscene',
    ESTELLA_VERIFY_W: '256', ESTELLA_VERIFY_H: '256', ESTELLA_VERIFY_STEPS: '4',
    ESTELLA_VERIFY_COLORSPACE: 'linear', ESTELLA_VERIFY_TEXTURES: 'runtime',
    ESTELLA_VERIFY_TWINS: JSON.stringify({ pairs: [[0.25, 0.5, 0.75, 0.5]], tol: 2 }),
  } },
    // The same two materials with NO light on them, only the ambient environment.
    // A metal has no diffuse, so reflecting that environment is all it has: remove
    // the reflection and the left probe is black while the right one barely moves.
  { id: "mat-model-env", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/mat-model-env.esscene", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.25,\"y\":0.5,\"rgb\":[0,101,0],\"tol\":20},{\"x\":0.75,\"y\":0.5,\"rgb\":[4,106,4],\"tol\":20},{\"x\":0.5,\"y\":0.5,\"rgb\":[0,0,0],\"tol\":20}]" } },
  { id: "material-builtin-lit", tier: "nightly", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/mat-builtin-lit.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/mat-builtin-lit.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.5,\"y\":0.5,\"rgb\":[0,255,0],\"tol\":30}]" } },
  { id: "material-toon", tier: "nightly", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/toon.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/toon.textures.json", ESTELLA_VERIFY_W: "900", ESTELLA_VERIFY_H: "360", ESTELLA_VERIFY_STEPS: "4", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.2,\"y\":0.45,\"rgb\":[229,136,80],\"tol\":20},{\"x\":0.27,\"y\":0.4,\"rgb\":[195,114,74],\"tol\":20},{\"x\":0.3,\"y\":0.62,\"rgb\":[126,70,62],\"tol\":20},{\"x\":0.67,\"y\":0.42,\"rgb\":[255,255,255],\"tol\":20},{\"x\":0.77,\"y\":0.65,\"rgb\":[37,37,37],\"tol\":20},{\"x\":0.05,\"y\":0.5,\"rgb\":[0,0,0],\"tol\":10}]" } },
  { id: "vector-paths", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/vector-paths.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/vector-paths.textures.json", ESTELLA_VERIFY_W: "900", ESTELLA_VERIFY_H: "300", ESTELLA_VERIFY_STEPS: "3", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.2,\"y\":0.55,\"rgb\":[255,140,26],\"tol\":20},{\"x\":0.168,\"y\":0.5,\"rgb\":[0,0,0],\"tol\":10},{\"x\":0.5,\"y\":0.5,\"rgb\":[51,204,230],\"tol\":20},{\"x\":0.82,\"y\":0.52,\"rgb\":[56,56,140],\"tol\":20},{\"x\":0.05,\"y\":0.5,\"rgb\":[0,0,0],\"tol\":10}]" } },
  { id: "sharpen", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/sharpen.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/sharpen.textures.json", ESTELLA_VERIFY_W: "900", ESTELLA_VERIFY_H: "300", ESTELLA_VERIFY_STEPS: "4", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.2,\"y\":0.55,\"rgb\":[255,140,26],\"tol\":20},{\"x\":0.5,\"y\":0.5,\"rgb\":[51,204,230],\"tol\":20},{\"x\":0.05,\"y\":0.5,\"rgb\":[0,0,0],\"tol\":10},{\"x\":0.8928,\"y\":0.615,\"rgb\":[207,207,229],\"tol\":10},{\"x\":0.7583,\"y\":0.6617,\"rgb\":[26,26,123],\"tol\":10}]" } },
  { id: "sharpen-fragment", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_NO_COMPUTE: "1", ESTELLA_VERIFY_SCENE: "/scenes/sharpen.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/sharpen.textures.json", ESTELLA_VERIFY_W: "900", ESTELLA_VERIFY_H: "300", ESTELLA_VERIFY_STEPS: "4", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.2,\"y\":0.55,\"rgb\":[255,140,26],\"tol\":20},{\"x\":0.5,\"y\":0.5,\"rgb\":[51,204,230],\"tol\":20},{\"x\":0.05,\"y\":0.5,\"rgb\":[0,0,0],\"tol\":10},{\"x\":0.8928,\"y\":0.615,\"rgb\":[207,207,229],\"tol\":10},{\"x\":0.7583,\"y\":0.6617,\"rgb\":[26,26,123],\"tol\":10}]" } },
  { id: "material-dissolve", tier: "nightly", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/mat-dissolve.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/mat-dissolve.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.5,\"y\":0.5,\"rgb\":[255,0,0],\"tol\":30}]" } },
  { id: "material-graph", tier: "nightly", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/mat-graph.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/mat-graph.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.5,\"y\":0.5,\"rgb\":[255,0,0],\"tol\":40}]" } },
  { id: "material-preview", tier: "pr", host: "editor", webgpu: { ESTELLA_VERIFY_EXPECT: "[{\"x\":0.5,\"y\":0.5,\"rgb\":[255,0,0],\"tol\":40}]" }, env: { ESTELLA_VERIFY_SCENE: "/scenes/mat-tint.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/mat-tint.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_PREVIEW: "{\"w\":64,\"h\":64,\"rgb\":[255,0,0],\"tol\":45}" } },
  { id: "tilemap-hex", tier: "nightly", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/tilemap-hex.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/tilemap-hex.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "6", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.40,\"y\":0.40,\"rgb\":[255,0,0]},{\"x\":0.60,\"y\":0.40,\"rgb\":[0,255,0]},{\"x\":0.50,\"y\":0.55,\"rgb\":[0,0,255]},{\"x\":0.70,\"y\":0.55,\"rgb\":[255,255,0]}]" } },
  { id: "postprocess-lut", tier: "nightly", webgpu: true, env: { ESTELLA_VERIFY_PLAY: "1", ESTELLA_VERIFY_SCENE: "/scenes/lut-grade.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/lut-grade.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "10", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.292,\"y\":0.5,\"rgb\":[0,0,255],\"tol\":40},{\"x\":0.708,\"y\":0.5,\"rgb\":[255,0,0],\"tol\":40}]" } },
  // mesh-renderer's scene and assertions, with its geometry frozen onto the GPU mid-run.
  // Equal pixels IS the claim, so it borrows the assertions rather than restating
  // them; a run that froze nothing fails on its own count.
  // The same again, geometry arriving from a FILE: an .esmesh loaded through the
  // asset layer replaces the inline payload. Its fixture is written by the
  // engine's own encoder from this scene's vertices, so the assertions hold.
  { id: "mesh-asset", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_MESH_ASSET: "/scenes/two-triangles.esmesh", ESTELLA_VERIFY_SCENE: "/scenes/mesh-renderer.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/mesh-renderer.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "4", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.30,\"y\":0.556,\"rgb\":[255,0,0],\"tol\":40},{\"x\":0.70,\"y\":0.556,\"rgb\":[0,255,0],\"tol\":40},{\"x\":0.30,\"y\":0.40,\"rgb\":[255,0,0],\"tol\":40}]" } },
  // The same triangles with no colour channel, as a decal bake writes them. Every mesh
  // shader reads one: WebGL2 read black and WebGPU refused the pipeline.
  { id: "mesh-colorless", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_MESH_ASSET: "/scenes/colorless-triangles.esmesh", ESTELLA_VERIFY_SCENE: "/scenes/mesh-renderer.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/mesh-renderer.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "4", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.30,\"y\":0.556,\"rgb\":[255,255,255],\"tol\":40},{\"x\":0.70,\"y\":0.556,\"rgb\":[255,255,255],\"tol\":40}]" } },
  { id: "mesh-resident", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_MESH_RESIDENT: "1", ESTELLA_VERIFY_SCENE: "/scenes/mesh-renderer.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/mesh-renderer.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "4", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.30,\"y\":0.556,\"rgb\":[255,0,0],\"tol\":40},{\"x\":0.70,\"y\":0.556,\"rgb\":[0,255,0],\"tol\":40},{\"x\":0.30,\"y\":0.40,\"rgb\":[255,0,0],\"tol\":40}]" } },
  // A material drawing GPU-resident geometry. Its shader writes only a fragment,
  // so the ENGINE owns the vertex stage and compiles a second variant for this
  // source; wrong placement or an ignored tint moves the probes.

  // Coplanar wall and decal differing only in the decal material's bias; the
  // twin without it shows wall throughout. The decal's layer fixes it second,
  // since a material-id tie follows load order.
  { id: "mat-decal", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/mat-decal.esscene", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "4", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.5,\"y\":0.5,\"rgb\":[255,0,0],\"tol\":40},{\"x\":0.25,\"y\":0.5,\"rgb\":[0,255,0],\"tol\":40}]" } },
  // A GENERATED twin on a mesh. A generated vertex stage is frozen at the batch
  // source, so WebGPU refused the pipeline; the two halves read the uv varying.
  { id: "mat-generated-mesh", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/mat-generated-mesh.esscene", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "4", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.3,\"y\":0.5,\"rgb\":[255,0,0],\"tol\":40},{\"x\":0.7,\"y\":0.5,\"rgb\":[0,255,0],\"tol\":40}]" } },
  // A vertex hook that reads a texture (the terrain's way of lifting a vertex): the cube stands where the hook puts it, and is drawn.
  { id: "prepass-hook", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/prepass-hook.esscene", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "4", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.5,\"y\":0.5,\"rgb\":[0,255,0],\"tol\":40}]" } },
  { id: "mat-decal-flat", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/mat-decal-flat.esscene", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "4", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.5,\"y\":0.5,\"rgb\":[0,255,0],\"tol\":40},{\"x\":0.25,\"y\":0.5,\"rgb\":[0,255,0],\"tol\":40}]" } },
  { id: "mesh-material", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_MESH_ASSET: "/scenes/white-triangles.esmesh", ESTELLA_VERIFY_MESH_MATERIAL: "/scenes/mesh-material/tintonly.esmaterial", ESTELLA_VERIFY_SCENE: "/scenes/mesh-material.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/mesh-material.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "4", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.30,\"y\":0.556,\"rgb\":[0,0,255],\"tol\":40},{\"x\":0.70,\"y\":0.556,\"rgb\":[0,0,255],\"tol\":40},{\"x\":0.5,\"y\":0.12,\"rgb\":[0,0,0],\"tol\":30}]" } },
  // What a normal is FOR: two coplanar triangles, one white colour, normals
  // facing the viewer and +X, under a head-on directional light. Only a shader
  // reading them can tell the halves apart — which is what the two probes are.
  { id: "mesh-lit", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/mesh-lit.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/mesh-lit.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "4", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.30,\"y\":0.556,\"rgb\":[255,255,255],\"tol\":40},{\"x\":0.70,\"y\":0.556,\"rgb\":[0,0,0],\"tol\":40}]" } },
  // A whole glTF import on screen, through the prefab it produced: geometry, the
  // inline image, and the baseColor factor as the tint. The probes sit at the
  // texel centres of a 2x2 image, so a flipped V swaps colours between them.
  { id: "mesh-textured", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_PREFAB: "/scenes/textured-quad.esprefab", ESTELLA_VERIFY_SCENE: "/scenes/mesh-textured.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/mesh-textured.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "4", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.3333,\"y\":0.4167,\"rgb\":[128,0,0],\"tol\":40},{\"x\":0.6667,\"y\":0.4167,\"rgb\":[0,128,0],\"tol\":40},{\"x\":0.3333,\"y\":0.5833,\"rgb\":[0,0,255],\"tol\":40},{\"x\":0.6667,\"y\":0.5833,\"rgb\":[128,128,0],\"tol\":40}]" } },
  // The source's own hierarchy, placing the pieces. Two probes need the parent's
  // offset to have reached the child, and the fourth is background only if the
  // child's scale survived — ignore the tree and everything stacks on the origin.
  { id: "mesh-nodes", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_PREFAB: "/scenes/node-tree.esprefab", ESTELLA_VERIFY_SCENE: "/scenes/mesh-nodes.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/mesh-nodes.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "4", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.3667,\"y\":0.40,\"rgb\":[255,0,0],\"tol\":40},{\"x\":0.45,\"y\":0.40,\"rgb\":[255,0,0],\"tol\":40},{\"x\":0.7667,\"y\":0.60,\"rgb\":[0,255,0],\"tol\":40},{\"x\":0.7667,\"y\":0.5333,\"rgb\":[0,0,0],\"tol\":30}]" } },
  // mesh-lit's geometry and light, shaded by a MATERIAL whose fragment reads the
  // normals the engine's vertex stage hands it. RED, so the fallback (the mesh
  // shader, taken when a variant fails) cannot pass for it — that draws white.
  { id: "mesh-material-lit", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_MESH_MATERIAL: "/scenes/mesh-material-lit/litmat.esmaterial", ESTELLA_VERIFY_SCENE: "/scenes/mesh-lit.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/mesh-lit.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "4", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.30,\"y\":0.556,\"rgb\":[255,0,0],\"tol\":40},{\"x\":0.70,\"y\":0.556,\"rgb\":[0,0,0],\"tol\":40}]" } },
  // The STOCK lit template on the same geometry: a flat normal there would light
  // an imported model like a sprite — a wrong picture, not a missing one. Red
  // tint, so the engine's own mesh shader (white) cannot pass for it.
  { id: "mesh-builtin-lit", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_MESH_MATERIAL: "/scenes/mesh-material-lit/builtinlit.esmaterial", ESTELLA_VERIFY_SCENE: "/scenes/mesh-lit.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/mesh-lit.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "4", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.30,\"y\":0.556,\"rgb\":[255,0,0],\"tol\":40},{\"x\":0.70,\"y\":0.556,\"rgb\":[0,0,0],\"tol\":40}]" } },
  // `lit` is the DRAW's word, honoured whatever the geometry carries: a mesh with
  // NO normal channel, under a red light. Lit, its green half goes black off the
  // constant normal a 2D surface has; unlit, both halves are their vertex colours.
  { id: "mesh-flat-lit", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/mesh-flat-lit.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/mesh-flat-lit.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "4", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.30,\"y\":0.556,\"rgb\":[255,0,0],\"tol\":40},{\"x\":0.70,\"y\":0.556,\"rgb\":[0,0,0],\"tol\":30}]" } },
  { id: "mesh-flat-lit-off", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SET_FIELD: "{\"entity\":2,\"component\":\"MeshRenderer\",\"key\":\"lit\",\"value\":false}", ESTELLA_VERIFY_SCENE: "/scenes/mesh-flat-lit.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/mesh-flat-lit.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "4", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.30,\"y\":0.556,\"rgb\":[255,0,0],\"tol\":40},{\"x\":0.70,\"y\":0.556,\"rgb\":[0,255,0],\"tol\":40}]" } },
  // The other half of that word: geometry that DOES carry normals, told not to
  // take light. Its layout still declares the channel — the permutation a backend
  // is strictest about — and both halves come back their own colour.
  { id: "mesh-lit-off", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SET_FIELD: "{\"entity\":2,\"component\":\"MeshRenderer\",\"key\":\"lit\",\"value\":false}", ESTELLA_VERIFY_SCENE: "/scenes/mesh-lit.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/mesh-lit.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "4", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.30,\"y\":0.556,\"rgb\":[255,255,255],\"tol\":40},{\"x\":0.70,\"y\":0.556,\"rgb\":[255,255,255],\"tol\":40}]" } },
  // A thumbnail of the geometry itself, offscreen through the viewport's own
  // path. What it adds over a material ball is the FRAMING: the gate asks for a
  // clear border (nothing escaped) and an outer eighth reached (nothing shrank).
  { id: "mesh-preview", tier: "pr", host: "editor", webgpu: true, env: { ESTELLA_VERIFY_MESH_PREVIEW: "{\"w\":128,\"h\":128}", ESTELLA_VERIFY_SCENE: "/scenes/mesh-lit.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/mesh-lit.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "4" } },
  // A SCENE camera that looks from somewhere else. Two sprites on the camera's
  // own axis project to ONE point for a 2D camera; pitched 20 deg they land at
  // 0.329 and 0.158 down the frame — arithmetic — and the centre is empty.
  { id: "camera-tilt", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/camera-tilt.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/camera-tilt.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "4", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.5,\"y\":0.329,\"rgb\":[255,0,0],\"tol\":40},{\"x\":0.5,\"y\":0.158,\"rgb\":[0,255,0],\"tol\":40},{\"x\":0.5,\"y\":0.5,\"rgb\":[0,0,0],\"tol\":30}]" } },
  // A mesh assigned IN THE EDITOR: a cold ref reaches the World only through the
  // live loader + re-projection. The quad covers the gap between the scene's own
  // two triangles, so the frame says which geometry is drawn — and the hit test
  // lands 120 world units out, where only the mesh's own box reaches.
  { id: "mesh-assign", tier: "pr", host: "editor", webgpu: true, env: { ESTELLA_VERIFY_SET_FIELD: "{\"entity\":1,\"component\":\"MeshRenderer\",\"key\":\"mesh\",\"value\":\"/scenes/textured-quad.esmesh\"}", ESTELLA_VERIFY_PICK: "{\"x\":0.7,\"y\":0.3833,\"entity\":1}", ESTELLA_VERIFY_SCENE: "/scenes/mesh-renderer.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/mesh-renderer.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "4", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.5,\"y\":0.5,\"rgb\":[255,255,255],\"tol\":40},{\"x\":0.30,\"y\":0.556,\"rgb\":[255,255,255],\"tol\":40}]" } },
  // The editor's eye turned 60° about Y. Where the triangles land is arithmetic:
  // centres at x = ±120 project to 0.40 / 0.60, with 0.30 empty. The hit test at
  // the new place proves screen→world followed the turn.
  { id: "view-orbit", tier: "pr", host: "editor", webgpu: true, env: { ESTELLA_VERIFY_ORBIT: "60,0", ESTELLA_VERIFY_PICK: "{\"x\":0.40,\"y\":0.556,\"entity\":1}", ESTELLA_VERIFY_SCENE: "/scenes/mesh-renderer.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/mesh-renderer.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "4", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.40,\"y\":0.556,\"rgb\":[255,0,0],\"tol\":40},{\"x\":0.60,\"y\":0.556,\"rgb\":[0,255,0],\"tol\":40},{\"x\":0.30,\"y\":0.556,\"rgb\":[0,0,0],\"tol\":30}]" } },
  // Two blended quads side by side in X at the SAME world z, the far one submitted
  // last, seen from an eye turned -60° about Y. Equal world z ties, and the tie puts
  // the FAR quad on top; only a viewer-measured depth puts the near (green) one there.
  { id: "sort-view-depth", tier: "pr", host: "editor", webgpu: true, env: { ESTELLA_VERIFY_ORBIT: "-60,0", ESTELLA_VERIFY_SCENE: "/scenes/sort-view-depth.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/sort-view-depth.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "4", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.5,\"y\":0.5,\"rgb\":[0,255,0],\"tol\":40},{\"x\":0.30,\"y\":0.5,\"rgb\":[0,255,0],\"tol\":40},{\"x\":0.70,\"y\":0.5,\"rgb\":[255,0,0],\"tol\":40}]" } },
  // A sprite at z = +1 under an ortho camera at z = 0: inside the symmetric box the
  // engine builds, and below 0 of what WebGPU keeps. Both backends draw it only while
  // updateCameraConstants converts the projection into the clip volume each one has.
  { id: "ortho-clip-behind-camera", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/ortho-clip-behind-camera.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/ortho-clip-behind-camera.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "4", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.30,\"y\":0.5,\"rgb\":[255,0,0],\"tol\":40},{\"x\":0.70,\"y\":0.5,\"rgb\":[0,255,0],\"tol\":40}]" } },
  // Two quads crossing: one flat, one turned 60° about Y, so each is nearer on
  // one side. Painter's order cannot draw that — with `opaque` the halves resolve
  // by depth (left green, right red), and without it the later draw takes both.
  // Two quads of the SAME colour, one in front of the other: a luma Sobel has
  // nothing to find between them, so the edge in the middle of the frame came
  // from the scene's DEPTH or it came from nowhere.
  { id: "depth-outline", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/depth-outline.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/depth-outline.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "4", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.2725,\"y\":0.5,\"rgb\":[0,0,0],\"tol\":20},{\"x\":0.15,\"y\":0.5,\"rgb\":[204,51,51],\"tol\":20},{\"x\":0.5,\"y\":0.5,\"rgb\":[204,51,51],\"tol\":20}]" } },
  // The same effect over a scene that writes no depth at all. Nothing to
  // find, so the frame must come out exactly as it went in — the picture is
  // identical to scale-sprites' own, probe for probe.
  // The first two points are on the SAME flat wall at one constant depth, where
  // a 90-degree eye is 1.41x further from the frame's edge than from its centre:
  // an effect reading depth paints them alike, and tol 10 does not reach between.
  { id: "distance-fog", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/distance-fog.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/depth-outline.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "4", ESTELLA_VERIFY_EXPECT: "[{\"x\": 0.5, \"y\": 0.5, \"rgb\": [107, 176, 143], \"tol\": 10}, {\"x\": 0.0625, \"y\": 0.5, \"rgb\": [134, 174, 176], \"tol\": 10}, {\"x\": 0.4375, \"y\": 0.5, \"rgb\": [190, 85, 92], \"tol\": 14}, {\"x\": 0.6875, \"y\": 0.5, \"rgb\": [200, 60, 62], \"tol\": 14}]" } },
  // An opaque Model surface whose base alpha is 0.5 (a map's alpha is often a mask for something else; glTF's OPAQUE ignores it). Drawn
  // unblended, its alpha lands in the frame, and Sky Atmosphere reads a pixel's alpha as how much of it the sky shows through: the quad
  // must stay its own colour, not the sky's. Without ES_OPAQUE the quad reads 216,87,67: the sky through it.
  { id: "sky-opaque-alpha", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_PREFAB: "/scenes/sky-opaque-alpha.esprefab", ESTELLA_VERIFY_SCENE: "/scenes/sky-opaque-alpha.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/mesh-backface.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "4", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.5,\"y\":0.5,\"rgb\":[177,46,46],\"tol\":12},{\"x\":0.5,\"y\":0.05,\"rgb\":[21,42,73],\"tol\":12}]" } },
  // The same quad with a refracting pane and a blended one in view: the scene is built in layers (opaque, blended, the opaque put back, the
  // glass) and the opaque scene is kept aside and restored by a copy. That copy must keep alpha: through the refraction copy's 0.5 mark,
  // every pixel came back half covered and the quad read 216,87,67: the sky through it.
  { id: "sky-restore-alpha", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_PREFAB: "/scenes/sky-opaque-alpha.esprefab", ESTELLA_VERIFY_SCENE: "/scenes/sky-restore-alpha.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/mesh-backface.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "4", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.5,\"y\":0.5,\"rgb\":[177,46,46],\"tol\":12}]" } },
  // Wet ground under a roof stays dry: reflections read the rain's map of what stands over each place, as the rain does. A floor too rough
  // to reflect dry, wet by the reflections' own Wetness, under a roof over its left half: only the open right half mirrors the red wall. Reading no map, the left half reads 148,40,40 too.
  { id: "ssr-shelter", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/ssr-shelter.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/mesh-backface.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "6", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.25,\"y\":0.5,\"rgb\":[53,53,53],\"tol\":12},{\"x\":0.75,\"y\":0.5,\"rgb\":[147,39,39],\"tol\":15}]" } },
  // The same floor under a GLASS roof: rain does not fall through glass, however much light does. A blended, see-through roof
  // keeps the floor under it as dry as an opaque one; the cover map is the rain's, not the sun's, and alpha is not what stops rain.
  { id: "ssr-shelter-glass", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/ssr-shelter-glass.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/mesh-backface.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "6", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.25,\"y\":0.5,\"rgb\":[53,53,53],\"tol\":12},{\"x\":0.75,\"y\":0.5,\"rgb\":[147,39,39],\"tol\":15}]" } },
  // Sky Atmosphere's Light the Scene: a white diffuse quad lit by nothing but an Ambient light that names no environment, under a clear
  // sky with the sun up behind it. The sky lights it as an environment: the blue of the dome above it and, below, the sunlit ground's
  // bounce (Ground Albedo 0.2), which lifts it and warms it a little; off, it is the flat white 255.
  { id: "sky-lights-scene", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_COLORSPACE: "linear", ESTELLA_VERIFY_SCENE: "/scenes/sky-lights-scene.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/mesh-backface.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "6", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.5,\"y\":0.5,\"rgb\":[142,150,150],\"tol\":12}]" } },
  // A sky the project wrote (defineSkyEffect): blue above the horizon, red below. It is drawn behind the ball, and with Light
  // the Scene the engine reads back a panorama of it and lights the ball with it: blue on top, red underneath. Upside
  // down, the two swap; never captured, the ball is the Ambient light's flat white.
  // An inverse-square lamp (0.5) 1 m over a white floor, seen from above: 0.5 under it, 0.5 x cos45 / 2 one metre out,
  // 0.5 x 0.45 / 5 two metres out (0.5, 0.177, 0.045 linear) — the pool a real lamp throws; the ramp falls off far more gently.
  { id: "point-inverse-square", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_COLORSPACE: "linear", ESTELLA_VERIFY_SCENE: "/scenes/point-inverse-square.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/mesh-backface.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "3", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.5,\"y\":0.5,\"rgb\":[187,187,187],\"tol\":8},{\"x\":0.667,\"y\":0.5,\"rgb\":[117,117,117],\"tol\":8},{\"x\":0.833,\"y\":0.5,\"rgb\":[58,58,58],\"tol\":8}]" } },
  // A probe volume filled at run time: a white ball lit only by what a capture at its centre sees, a red wall to its right, blue
  // to its left, green above. The ball takes each wall's colour on the side that faces it; a capture read the wrong way round
  // swaps them, and none leaves the ball black.
  { id: "probe-capture", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_PLAY: "1", ESTELLA_VERIFY_SETTLE_MS: "3000", ESTELLA_VERIFY_SETTLE_STEPS: "60", ESTELLA_VERIFY_COLORSPACE: "linear", ESTELLA_VERIFY_SCENE: "/scenes/probe-capture.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/mesh-backface.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.645,\"y\":0.5,\"rgb\":[144,93,32],\"tol\":20},{\"x\":0.355,\"y\":0.5,\"rgb\":[34,93,142],\"tol\":20},{\"x\":0.5,\"y\":0.36,\"rgb\":[92,142,91],\"tol\":20},{\"x\":0.5,\"y\":0.645,\"rgb\":[92,34,91],\"tol\":20}]" } },
  // The same capture, mirrored: a chrome ball under a blue-above, red-below sky, a green wall to its right and a magenta one
  // to its left. Inside the box it reflects the room the capture saw — green on its right, magenta on its left — and not
  // the sky's blue and red, which is what it reflected before captures fed reflections.
  { id: "probe-capture-reflection", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_PLAY: "1", ESTELLA_VERIFY_SETTLE_MS: "3000", ESTELLA_VERIFY_SETTLE_STEPS: "60", ESTELLA_VERIFY_COLORSPACE: "linear", ESTELLA_VERIFY_SCENE: "/scenes/probe-capture-reflection.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/mesh-backface.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.352,\"y\":0.5,\"rgb\":[253,18,253],\"tol\":30},{\"x\":0.648,\"y\":0.5,\"rgb\":[33,252,33],\"tol\":30}]" } },
  { id: "custom-sky", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_PLAY: "1", ESTELLA_VERIFY_SETTLE_MS: "1500", ESTELLA_VERIFY_COLORSPACE: "linear", ESTELLA_VERIFY_SCENE: "/scenes/custom-sky.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/mesh-backface.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.08,\"y\":0.08,\"rgb\":[89,124,243],\"tol\":10},{\"x\":0.08,\"y\":0.92,\"rgb\":[231,108,63],\"tol\":10},{\"x\":0.5,\"y\":0.32,\"rgb\":[127,121,226],\"tol\":20},{\"x\":0.5,\"y\":0.68,\"rgb\":[217,111,118],\"tol\":20}]" } },
  { id: "sky-fog", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/sky-fog.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/depth-outline.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "4", ESTELLA_VERIFY_EXPECT: "[{\"x\": 0.2, \"y\": 0.1, \"rgb\": [144, 175, 187], \"tol\": 12}, {\"x\": 0.5, \"y\": 0.1, \"rgb\": [141, 174, 183], \"tol\": 12}, {\"x\": 0.8, \"y\": 0.2, \"rgb\": [143, 174, 186], \"tol\": 12}, {\"x\": 0.5, \"y\": 0.4, \"rgb\": [139, 171, 180], \"tol\": 12}, {\"x\": 0.2, \"y\": 0.8, \"rgb\": [62, 70, 70], \"tol\": 12}, {\"x\": 0.8, \"y\": 0.8, \"rgb\": [57, 64, 67], \"tol\": 12}]" } },
  // SSAO: one unlit grey floor read at seven places. Contact, corner and
  // step come back darker than the open floor they are made of, the floating
  // box does not, and the wall behind a silhouette keeps its colour.
  // Every tolerance is set against how far its point MOVES with the effect off:
  // the corner travels 49 and the step 47, so 22 and 20 still read the absence,
  // while the shallow face at 0.627 travels 19 and keeps a tight 9.
  // A quad turned 20 degrees on black, read twice: the SAME values with and
  // without a post chain is the claim. WebGPU has no MSAA yet, so both its
  // halves read the hard step — still the claim, that the chain changes nothing.
  { id: "aa-edge", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/aa-edge.esscene", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.2353,\"y\":0.502,\"rgb\":[128,128,128],\"tol\":64},{\"x\":0.2392,\"y\":0.502,\"rgb\":[128,128,128],\"tol\":64},{\"x\":0.749,\"y\":0.502,\"rgb\":[128,128,128],\"tol\":64},{\"x\":0.7529,\"y\":0.502,\"rgb\":[128,128,128],\"tol\":64},{\"x\":0.502,\"y\":0.502,\"rgb\":[255,255,255],\"tol\":6},{\"x\":0.0784,\"y\":0.0784,\"rgb\":[0,0,0],\"tol\":6}]" } },
  // The other half: the same edges, read through an identity post chain.
    { id: "aa-edge-post", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/aa-edge-post.esscene", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.2353,\"y\":0.502,\"rgb\":[128,128,128],\"tol\":64},{\"x\":0.2392,\"y\":0.502,\"rgb\":[128,128,128],\"tol\":64},{\"x\":0.749,\"y\":0.502,\"rgb\":[128,128,128],\"tol\":64},{\"x\":0.7529,\"y\":0.502,\"rgb\":[128,128,128],\"tol\":64},{\"x\":0.502,\"y\":0.502,\"rgb\":[255,255,255],\"tol\":6},{\"x\":0.0784,\"y\":0.0784,\"rgb\":[0,0,0],\"tol\":6}]" } },
  { id: "edge-outline", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/edge-outline.esscene", ESTELLA_VERIFY_W: "640", ESTELLA_VERIFY_H: "480", ESTELLA_VERIFY_STEPS: "4", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.5,\"y\":0.2458,\"rgb\":[255,0,0],\"tol\":40},{\"x\":0.5,\"y\":0.85,\"rgb\":[129,129,129],\"tol\":12},{\"x\":0.36,\"y\":0.42,\"rgb\":[137,95,70],\"tol\":15},{\"x\":0.7,\"y\":0.45,\"rgb\":[128,128,128],\"tol\":12}]" } },
  { id: "blob-shadow", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/blob-shadow.esscene", ESTELLA_VERIFY_W: "640", ESTELLA_VERIFY_H: "480", ESTELLA_VERIFY_STEPS: "6", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.5,\"y\":0.85,\"rgb\":[191,191,191],\"tol\":8},{\"x\":0.38,\"y\":0.4,\"rgb\":[204,140,102],\"tol\":10},{\"x\":0.85,\"y\":0.38,\"rgb\":[199,178,127],\"tol\":12},{\"x\":0.845,\"y\":0.475,\"rgb\":[91,91,91],\"tol\":22},{\"x\":0.61,\"y\":0.46,\"rgb\":[102,102,102],\"tol\":22},{\"x\":0.385,\"y\":0.49,\"rgb\":[124,124,124],\"tol\":22}]" } },
  // Rain darkens a 40-degree slope as it does the flat beside it (unlit grey 204 to about 139 on both). Darkening only what faced
  // straight up left the slope at 204, and a hillside in the rain cut into pale wedges.
  { id: "rain-wet-slope", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/rain-wet-slope.esscene", ESTELLA_VERIFY_W: "320", ESTELLA_VERIFY_H: "240", ESTELLA_VERIFY_STEPS: "4", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.25,\"y\":0.5,\"rgb\":[139,139,139],\"tol\":8},{\"x\":0.75,\"y\":0.4,\"rgb\":[140,140,140],\"tol\":8}]" } },
  { id: "ssao", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/ssao.esscene", ESTELLA_VERIFY_W: "320", ESTELLA_VERIFY_H: "240", ESTELLA_VERIFY_STEPS: "4", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.5016,\"y\":0.8996,\"rgb\":[191,191,191],\"tol\":6},{\"x\":0.3762,\"y\":0.4937,\"rgb\":[144,144,144],\"tol\":20},{\"x\":0.627,\"y\":0.4812,\"rgb\":[172,172,172],\"tol\":9},{\"x\":0.8527,\"y\":0.4686,\"rgb\":[147,147,147],\"tol\":9},{\"x\":0.1881,\"y\":0.5272,\"rgb\":[123,141,113],\"tol\":22},{\"x\":0.1285,\"y\":0.1967,\"rgb\":[133,136,148],\"tol\":9},{\"x\":0.627,\"y\":0.2008,\"rgb\":[179,184,199],\"tol\":5}]" } },
  // The same occlusion with a neutral colour grade ahead of it in the chain: a pass
  // behind another one still samples the scene's depth, and on WebGPU the colour it
  // lays the occlusion over is the right way up.
  { id: "ssao-after-grade", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/ssao-after-grade.esscene", ESTELLA_VERIFY_W: "320", ESTELLA_VERIFY_H: "240", ESTELLA_VERIFY_STEPS: "4", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.5016,\"y\":0.8996,\"rgb\":[191,191,191],\"tol\":6},{\"x\":0.3762,\"y\":0.4937,\"rgb\":[144,144,144],\"tol\":20},{\"x\":0.627,\"y\":0.4812,\"rgb\":[172,172,172],\"tol\":9},{\"x\":0.8527,\"y\":0.4686,\"rgb\":[147,147,147],\"tol\":9},{\"x\":0.1881,\"y\":0.5272,\"rgb\":[123,141,113],\"tol\":22},{\"x\":0.1285,\"y\":0.1967,\"rgb\":[133,136,148],\"tol\":9},{\"x\":0.627,\"y\":0.2008,\"rgb\":[179,184,199],\"tol\":5}]" } },
  { id: "depth-outline-flat", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/depth-outline-flat.esscene", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.5,\"y\":0.5,\"rgb\":[230,102,26],\"tol\":20}]" } },
  { id: "mesh-opaque", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/mesh-depth.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/mesh-depth.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "4", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.42,\"y\":0.5,\"rgb\":[0,255,0],\"tol\":40},{\"x\":0.58,\"y\":0.5,\"rgb\":[255,0,0],\"tol\":40}]" } },
  { id: "mesh-opaque-off", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SET_FIELD: "{\"entity\":2,\"component\":\"MeshRenderer\",\"key\":\"opaque\",\"value\":false}", ESTELLA_VERIFY_SCENE: "/scenes/mesh-depth.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/mesh-depth.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "4", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.42,\"y\":0.5,\"rgb\":[0,255,0],\"tol\":40},{\"x\":0.58,\"y\":0.5,\"rgb\":[0,255,0],\"tol\":40}]" } },
  // A normal map over FLAT normals: the quad faces the viewer, so without the map
  // both halves take the same light. Its texels point -X and +X, so the lit half
  // and the unlit one are the tangent frame, derived per pixel from derivatives.
  { id: "mesh-normalmap", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_PREFAB: "/scenes/normalmap-quad.esprefab", ESTELLA_VERIFY_SCENE: "/scenes/mesh-normalmap.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/mesh-normalmap.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "4", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.375,\"y\":0.5,\"rgb\":[180,180,180],\"tol\":45},{\"x\":0.625,\"y\":0.5,\"rgb\":[0,0,0],\"tol\":30}]" } },
  // Zero strength makes both oppositely tilted texels flat, even when their Z
  // is zero. Negative strength reverses which half faces the light.
  ...[
    ['zero', [[180, 180, 180], [180, 180, 180]]],
    ['negative', [[0, 0, 0], [180, 180, 180]]],
  ].map(([name, colors]) => ({ id: `mesh-normalmap-scale-${name}`, tier: 'pr', webgpu: true, env: {
    ESTELLA_VERIFY_PREFAB: `/scenes/normalmap-scale-${name}.esprefab`,
    ESTELLA_VERIFY_SCENE: '/scenes/mesh-normalmap.esscene',
    ESTELLA_VERIFY_MANIFEST: '/scenes/mesh-normalmap.textures.json',
    ESTELLA_VERIFY_W: '256', ESTELLA_VERIFY_H: '256', ESTELLA_VERIFY_STEPS: '4',
    ESTELLA_VERIFY_EXPECT: JSON.stringify(colors.map((rgb, i) => ({ x: i ? 0.625 : 0.375, y: 0.5, rgb, tol: name === 'zero' ? 12 : 45 }))),
  } })),
  // A blended green mesh behind an opaque red mesh must not paint over it.
  // This also compiles the specular/glossiness variant on the mesh path.
  { id: 'mesh-specular-glossiness-depth', tier: 'pr', webgpu: true, env: {
    ESTELLA_VERIFY_PREFAB: '/scenes/specular-glossiness-depth.esprefab',
    ESTELLA_VERIFY_SCENE: '/scenes/mesh-normalmap.esscene',
    ESTELLA_VERIFY_MANIFEST: '/scenes/mesh-normalmap.textures.json',
    ESTELLA_VERIFY_W: '256', ESTELLA_VERIFY_H: '256', ESTELLA_VERIFY_STEPS: '4',
    ESTELLA_VERIFY_EXPECT: JSON.stringify([{ x: 0.5, y: 0.5, rgb: [255, 0, 0], tol: 8 }]),
  } },
  // The quad of mesh-normalmap with a tangent a quarter turn from the one its UVs imply: read against the frame the mesh
  // carries, both halves come out alike (33), where the derived frame lights them 180 and 0.
  { id: "mesh-normalmap-tangent", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_PREFAB: "/scenes/normalmap-quad-tangent.esprefab", ESTELLA_VERIFY_SCENE: "/scenes/mesh-normalmap-tangent.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/mesh-normalmap-tangent.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "4", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.375,\"y\":0.5,\"rgb\":[33,33,33],\"tol\":12},{\"x\":0.625,\"y\":0.5,\"rgb\":[33,33,33],\"tol\":12}]" } },
  // The same quad ten thousand times smaller, seen as large. A tangent frame from
  // derivatives shrinks with the fourth power of scale, so a degenerate-UV floor
  // fixed in world units switched normal maps off on anything small up close.
  { id: "mesh-normalmap-tiny", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_PREFAB: "/scenes/normalmap-quad-tiny.esprefab", ESTELLA_VERIFY_SCENE: "/scenes/mesh-normalmap-tiny.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/mesh-normalmap-tiny.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "4", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.375,\"y\":0.5,\"rgb\":[180,180,180],\"tol\":45},{\"x\":0.625,\"y\":0.5,\"rgb\":[0,0,0],\"tol\":30}]" } },
  // The same quad under a two-channel normal map (B = 0, as BC5 and some converters
  // store it), lit from the front. Rebuilding Z from X and Y turns both halves toward
  // the light; unpacking B as Z points them into the surface and both go black.
  { id: "mesh-normalmap-xy", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_PREFAB: "/scenes/normalmap-xy.esprefab", ESTELLA_VERIFY_SCENE: "/scenes/mesh-normalmap-xy.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/mesh-normalmap-xy.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "4", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.375,\"y\":0.5,\"rgb\":[241,241,241],\"tol\":30},{\"x\":0.625,\"y\":0.5,\"rgb\":[241,241,241],\"tol\":30}]" } },
  // A double-sided quad turned away from the camera, lit from the camera's side:
  // its back is what is seen and what the light reaches, so it must be lit. Once
  // through a material (the path an imported model takes) and once without one.
  { id: "mesh-backface-material", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_PREFAB: "/scenes/backface-quad.esprefab", ESTELLA_VERIFY_SCENE: "/scenes/mesh-backface.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/mesh-backface.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "4", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.5,\"y\":0.5,\"rgb\":[255,255,255],\"tol\":40}]" } },
  { id: "mesh-backface-plain", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_PREFAB: "/scenes/backface-quad-plain.esprefab", ESTELLA_VERIFY_SCENE: "/scenes/mesh-backface.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/mesh-backface.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "4", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.5,\"y\":0.5,\"rgb\":[255,255,255],\"tol\":40}]" } },
  // Grayscale, then bloom: the red and green quads must come out grey. A multi-pass
  // effect composites over its own input, and one handed the untouched scene
  // instead drops every effect before it — the quads kept their colour.
  { id: "post-chain-order", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/post-chain-order.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/mesh-depth.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "4", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.42,\"y\":0.5,\"rgb\":[150,150,150],\"tol\":20},{\"x\":0.58,\"y\":0.5,\"rgb\":[76,76,76],\"tol\":20}]" } },
  // The same asset's 0.75 cutout, the camera rolled so its cut runs nearly upright: with
  // multisampling on, coverage from alpha makes the texel before the cut a blend in a
  // share of rows (0.35 WebGL2, 0.26 WebGPU) that an alpha test does not (0.14, 0.07).
  { id: "corpus-cutout-edge", tier: "pr", webgpu: true, corpora: ["khronos-alpha-blend-mode-test"], env: { ESTELLA_VERIFY_PREFAB: "/corpora/khronos-alpha-blend-mode-test/imported/AlphaBlendModeTest.esprefab", ESTELLA_VERIFY_SCENE: "/scenes/corpus-cutout-edge.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/corpus-alpha-modes.textures.json", ESTELLA_VERIFY_COLORSPACE: "linear", ESTELLA_VERIFY_MSAA: "4", ESTELLA_VERIFY_W: "640", ESTELLA_VERIFY_H: "640", ESTELLA_VERIFY_STEPS: "8", ESTELLA_VERIFY_CUTOUT_EDGE: "{\"box\":[0.5813,0.4219,0.6641,0.6875],\"lit\":180,\"run\":4,\"partial\":[115,180],\"minShare\":0.2}" } },
  // The same cut in gamma with no effect: no chain, so the frame draws straight into
  // the surface, which is multisampled too (0.27 WebGL2, 0.26 WebGPU; 0.12 on WebGPU
  // asking for one sample). A WebGL2 canvas is antialiased whatever the engine asks.
  { id: "corpus-cutout-edge-gamma", tier: "pr", webgpu: true, corpora: ["khronos-alpha-blend-mode-test"], env: { ESTELLA_VERIFY_PREFAB: "/corpora/khronos-alpha-blend-mode-test/imported/AlphaBlendModeTest.esprefab", ESTELLA_VERIFY_SCENE: "/scenes/corpus-cutout-edge.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/corpus-alpha-modes.textures.json", ESTELLA_VERIFY_MSAA: "4", ESTELLA_VERIFY_W: "640", ESTELLA_VERIFY_H: "640", ESTELLA_VERIFY_STEPS: "8", ESTELLA_VERIFY_CUTOUT_EDGE: "{\"box\":[0.5813,0.4219,0.6641,0.6875],\"lit\":180,\"run\":4,\"partial\":[115,180],\"minShare\":0.2}" } },
  // The same asset forty metres off, its textures uploaded as a shipped game's are:
  // with a mip chain the stripes average to a flat tint (ripple 7.8), sampling the top
  // level they shimmer (17.5); 7.9 on WebGPU, 13.7 before it built a chain.
  { id: "corpus-distant-texture", tier: "pr", webgpu: true, corpora: ["khronos-alpha-blend-mode-test"], env: { ESTELLA_VERIFY_PREFAB: "/corpora/khronos-alpha-blend-mode-test/imported/AlphaBlendModeTest.esprefab", ESTELLA_VERIFY_SCENE: "/scenes/corpus-distant-texture.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/corpus-alpha-modes.textures.json", ESTELLA_VERIFY_COLORSPACE: "linear", ESTELLA_VERIFY_TEXTURES: "runtime", ESTELLA_VERIFY_W: "640", ESTELLA_VERIFY_H: "640", ESTELLA_VERIFY_STEPS: "8", ESTELLA_VERIFY_MINIFIED: "{\"box\":[0.469,0.461,0.688,0.516],\"maxRipple\":11,\"minMean\":100}" } },
  // Khronos's NormalTangentTest: each bump as geometry and as a normal map, no tangents
  // supplied. Off the bump's peak (where parallax parts them) the twins must agree, through
  // the upload a shipped game uses, which gamma-decoded every normal map.
  { id: "corpus-normal-tangent", tier: "pr", webgpu: true, corpora: ["khronos-normal-tangent-test"], env: { ESTELLA_VERIFY_PREFAB: "/corpora/khronos-normal-tangent-test/imported/NormalTangentTest.esprefab", ESTELLA_VERIFY_SCENE: "/scenes/corpus-normal-tangent.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/corpus-alpha-modes.textures.json", ESTELLA_VERIFY_COLORSPACE: "linear", ESTELLA_VERIFY_TEXTURES: "runtime", ESTELLA_VERIFY_W: "640", ESTELLA_VERIFY_H: "640", ESTELLA_VERIFY_STEPS: "8", ESTELLA_VERIFY_TWINS: "{\"pairs\": [[0.1531, 0.1652, 0.263, 0.1652], [0.1875, 0.1995, 0.2974, 0.1995], [0.2115, 0.1411, 0.3214, 0.1411], [0.1531, 0.3025, 0.263, 0.3025], [0.1875, 0.3369, 0.2974, 0.3369], [0.2115, 0.2785, 0.3214, 0.2785], [0.1531, 0.4399, 0.263, 0.4399], [0.1875, 0.4742, 0.2974, 0.4742], [0.2115, 0.4159, 0.3214, 0.4159], [0.1531, 0.5773, 0.263, 0.5773], [0.1875, 0.6116, 0.2974, 0.6116], [0.2115, 0.5532, 0.3214, 0.5532], [0.1531, 0.7146, 0.263, 0.7146], [0.1875, 0.749, 0.2974, 0.749], [0.2115, 0.6906, 0.3214, 0.6906], [0.4279, 0.1652, 0.5378, 0.1652], [0.4622, 0.1995, 0.5721, 0.1995], [0.4863, 0.1411, 0.5962, 0.1411], [0.4279, 0.3025, 0.5378, 0.3025], [0.4622, 0.3369, 0.5721, 0.3369], [0.4863, 0.2785, 0.5962, 0.2785], [0.4279, 0.4399, 0.5378, 0.4399], [0.4622, 0.4742, 0.5721, 0.4742], [0.4863, 0.4159, 0.5962, 0.4159], [0.4279, 0.5773, 0.5378, 0.5773], [0.4622, 0.6116, 0.5721, 0.6116], [0.4863, 0.5532, 0.5962, 0.5532], [0.4279, 0.7146, 0.5378, 0.7146], [0.4622, 0.749, 0.5721, 0.749], [0.4863, 0.6906, 0.5962, 0.6906]], \"tol\": 8}" } },
  // Khronos's AlphaBlendModeTest (tools/corpora.mjs): the opaque box ignores its alpha, and
  // each cutout box is cut exactly at its own threshold — wall above the mark, stripes below.
  { id: "corpus-alpha-modes", tier: "pr", webgpu: true, corpora: ["khronos-alpha-blend-mode-test"], env: { ESTELLA_VERIFY_PREFAB: "/corpora/khronos-alpha-blend-mode-test/imported/AlphaBlendModeTest.esprefab", ESTELLA_VERIFY_SCENE: "/scenes/corpus-alpha-modes.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/corpus-alpha-modes.textures.json", ESTELLA_VERIFY_W: "960", ESTELLA_VERIFY_H: "540", ESTELLA_VERIFY_STEPS: "8", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.2344,\"y\":0.3185,\"rgb\":[255,255,107],\"tol\":40},{\"x\":0.5135,\"y\":0.3167,\"rgb\":[255,255,255],\"tol\":40},{\"x\":0.5125,\"y\":0.4444,\"rgb\":[255,255,108],\"tol\":40},{\"x\":0.651,\"y\":0.3704,\"rgb\":[255,255,255],\"tol\":40},{\"x\":0.651,\"y\":0.487,\"rgb\":[255,255,108],\"tol\":40},{\"x\":0.7896,\"y\":0.4444,\"rgb\":[255,255,255],\"tol\":40},{\"x\":0.7875,\"y\":0.5185,\"rgb\":[107,255,255],\"tol\":40}]" } },
  // The channels only a material can carry, one quad each, through the products a
  // real import wrote. Ambient light only: the black quad's lit half can only be
  // emission, the white quad's right half is occluded away, the cutout discards.
  { id: "model-material", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_PREFAB: "/scenes/model-material.esprefab", ESTELLA_VERIFY_SCENE: "/scenes/model-material.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/model-material.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "4", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.05,\"y\":0.5,\"rgb\":[0,255,0],\"tol\":40},{\"x\":0.2167,\"y\":0.5,\"rgb\":[0,0,0],\"tol\":30},{\"x\":0.4167,\"y\":0.5,\"rgb\":[255,255,255],\"tol\":40},{\"x\":0.5833,\"y\":0.5,\"rgb\":[0,0,0],\"tol\":30},{\"x\":0.8667,\"y\":0.5,\"rgb\":[0,0,0],\"tol\":30}]" } },
  // A camera parented to something looks from where the hierarchy puts it: the red
  // quad on the rig is dead centre, the green one at the origin 200 to its left,
  // and reading the LOCAL position swaps them. One step, so a stale world is zero.
  { id: "camera-parent", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/camera-parent.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/camera-parent.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "1", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.5,\"y\":0.5,\"rgb\":[255,0,0],\"tol\":40},{\"x\":0.1667,\"y\":0.5,\"rgb\":[0,255,0],\"tol\":40}]" } },
  // Takes the GPU away for real and captures AFTER the cycle: the four points
  // sample the atlas, so they fail unless the content came back. A vertex-colour
  // scene passed with the re-upload deleted. No webgpu — no GL extension there.
  // A MATERIAL across a recovery. The two below are tilemaps, which read no
  // material sampler — so a recovered material sampling every texture from unit
  // 0 looked exactly like one with no normal map, and nothing could tell.
  { id: "device-loss-material", tier: "pr", env: { ESTELLA_VERIFY_DEVICE_LOSS: "1", ESTELLA_VERIFY_SCENE: "/scenes/mat-lit-normal.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/mat-lit-normal.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.333,\"y\":0.5,\"rgb\":[0,252,0],\"tol\":45},{\"x\":0.667,\"y\":0.5,\"rgb\":[0,36,0],\"tol\":50}]" } },
  // One light casting BOTH kinds of shadow, which the component says it can: a map
  // over the mesh on the left, the 2D mask over the sprite on the right. Two
  // separate paths through one frame, and nothing else asks them to coexist.
  { id: "shadow-both-kinds", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/shadow-both.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/shadow-both.textures.json", ESTELLA_VERIFY_W: "600", ESTELLA_VERIFY_H: "600", ESTELLA_VERIFY_STEPS: "4", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.10,\"y\":0.50,\"rgb\":[0,0,0],\"tol\":30},{\"x\":0.30,\"y\":0.50,\"rgb\":[153,153,153],\"tol\":40},{\"x\":0.62,\"y\":0.50,\"rgb\":[234,234,234],\"tol\":40},{\"x\":0.78,\"y\":0.50,\"rgb\":[0,0,0],\"tol\":30}]" } },
  // A hundred occluders and four lights with width, which the analytic path could not
  // have held: the counters are the capacity, the criteria above are the correctness.
  // 0.64ms of a frame here against 0.057ms with the casters off.
  { id: "shadow2d-load", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_PLAY: "1", ESTELLA_VERIFY_SCENE: "/scenes/shadow2d-load.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/shadow2d-load.textures.json", ESTELLA_VERIFY_W: "1280", ESTELLA_VERIFY_H: "720", ESTELLA_VERIFY_STEPS: "6", ESTELLA_VERIFY_COUNTERS: "{\"render.shadow2d.occluders\":100,\"render.shadow2d.lights\":4}" } },
  // A mask with eight channels, all held by lights Light0 meets (the outer four share
  // three, the five beside it take the rest): Light0 goes without, which is a lit floor
  // rather than a dark one. The scene is asymmetric on purpose — a symmetric one cannot
  // see a mask sampled upside down.
  { id: "shadow2d-light-cap", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_PLAY: "1", ESTELLA_VERIFY_SCENE: "/scenes/shadow2d-light-cap.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/shadow2d-light-cap.textures.json", ESTELLA_VERIFY_W: "200", ESTELLA_VERIFY_H: "1000", ESTELLA_VERIFY_STEPS: "4", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.70,\"y\":0.1,\"rgb\":[0,0,0],\"tol\":40},{\"x\":0.70,\"y\":0.3,\"rgb\":[0,0,0],\"tol\":40},{\"x\":0.70,\"y\":0.7,\"rgb\":[0,0,0],\"tol\":40},{\"x\":0.70,\"y\":0.9,\"rgb\":[0,0,0],\"tol\":40},{\"x\":0.70,\"y\":0.5,\"rgb\":[0,120,0],\"tol\":70}]" } },
  // Two cameras with half the frame each: what a camera draws is bounded by the rect
  // it asked for, and one covering the other is what taking that rect off the device
  // after the collect came to.
  { id: "camera-split-viewport", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_PLAY: "1", ESTELLA_VERIFY_SCENE: "/scenes/camera-split.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/camera-split.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "4", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.25,\"y\":0.5,\"rgb\":[0,255,0],\"tol\":40},{\"x\":0.75,\"y\":0.5,\"rgb\":[0,0,255],\"tol\":40}]" } },
  // The same split with 2D shadows in it. The mask is screen space, so what a fragment
  // reads has to be the part of it its OWN camera filled.
  { id: "shadow2d-split", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_PLAY: "1", ESTELLA_VERIFY_SCENE: "/scenes/shadow2d-split.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/shadow2d-split.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "4", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.15,\"y\":0.5,\"rgb\":[0,255,0],\"tol\":70},{\"x\":0.40,\"y\":0.5,\"rgb\":[0,0,0],\"tol\":40},{\"x\":0.65,\"y\":0.5,\"rgb\":[0,0,255],\"tol\":70},{\"x\":0.90,\"y\":0.5,\"rgb\":[0,0,0],\"tol\":40}]" } },
  // The mask again after the device it was drawn on went away: the pass owns a
  // buffer, a layout and a shader, and one kept across a loss names nothing.
  { id: "device-loss-shadow2d", tier: "pr", env: { ESTELLA_VERIFY_DEVICE_LOSS: "1", ESTELLA_VERIFY_SCENE: "/scenes/mat-lit-shadow-many.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/mat-lit-shadow-many.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.25,\"y\":0.5,\"rgb\":[0,255,0],\"tol\":60},{\"x\":0.75,\"y\":0.5,\"rgb\":[0,0,0],\"tol\":40}]" } },
  // The same mask through the EDITOR's host, which draws into a target of its own
  // rather than the surface — a different path to the same frame.
  { id: "shadow2d-editor", tier: "pr", host: "editor", webgpu: true, env: { ESTELLA_VERIFY_SCENE: "/scenes/mat-lit-shadow-many.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/mat-lit-shadow-many.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "4", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.25,\"y\":0.5,\"rgb\":[0,255,0],\"tol\":60},{\"x\":0.75,\"y\":0.5,\"rgb\":[0,0,0],\"tol\":40}]" } },
  { id: "device-loss", tier: "pr", env: { ESTELLA_VERIFY_DEVICE_LOSS: "1", ESTELLA_VERIFY_SCENE: "/scenes/tilemap-flip.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/tilemap-flip.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.40,\"y\":0.36,\"rgb\":[255,0,0]},{\"x\":0.60,\"y\":0.36,\"rgb\":[0,255,0]},{\"x\":0.40,\"y\":0.58,\"rgb\":[0,0,255]},{\"x\":0.60,\"y\":0.58,\"rgb\":[255,255,0]}]" } },
  // The textures above prove content comes back; a mesh proves IDENTITY does —
  // the handles the world points at are the ones re-realized, not new ones the
  // scene happens to draw with. Through the asset layer, the only replayable path.
  { id: "device-loss-mesh", tier: "pr", env: { ESTELLA_VERIFY_DEVICE_LOSS: "1", ESTELLA_VERIFY_MESH_ASSET: "/scenes/two-triangles.esmesh", ESTELLA_VERIFY_SCENE: "/scenes/mesh-renderer.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/mesh-renderer.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "4", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.30,\"y\":0.556,\"rgb\":[255,0,0],\"tol\":40},{\"x\":0.70,\"y\":0.556,\"rgb\":[0,255,0],\"tol\":40},{\"x\":0.30,\"y\":0.40,\"rgb\":[255,0,0],\"tol\":40}]" } },
  // Where "same handle" stops being a detail: a LODGroup names its levels BY
  // handle, so a recovery that reloaded would leave every reference pointing at
  // geometry nothing rebuilt, while the frame drew whichever level came back.
  { id: "device-loss-lod", tier: "pr", env: { ESTELLA_VERIFY_DEVICE_LOSS: "1", ESTELLA_VERIFY_SCENE: "/scenes/lod-3d.esscene", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "4", ESTELLA_VERIFY_COUNTERS: "{\"render.lod.groups\":4,\"render.lod.level0\":1,\"render.lod.level1\":1,\"render.lod.level2\":1,\"render.meshes\":3}" } },
  // The player's case: nothing asks for the recovery, only frames pass, and it
  // happens FOUR times — backgrounding a tab is not a one-off, a recovery that
  // works once and never again passes any single-round check, and it takes
  // three rounds to measure whether the host's object tables are growing.
  // Three on WebGPU, where a loss is a destroyed device and the replacement can
  // only come from the page: the rounds check that the engine adopts a NEW one
  // each time. Object tables are a GL notion there and read zero.
  { id: "device-loss-auto", tier: "pr", webgpu: { ESTELLA_VERIFY_LOSS_ROUNDS: "3" }, env: { ESTELLA_VERIFY_LOSS_ROUNDS: "4", ESTELLA_VERIFY_DEVICE_LOSS: "auto", ESTELLA_VERIFY_SCENE: "/scenes/tilemap-flip.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/tilemap-flip.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.40,\"y\":0.36,\"rgb\":[255,0,0]},{\"x\":0.60,\"y\":0.36,\"rgb\":[0,255,0]},{\"x\":0.40,\"y\":0.58,\"rgb\":[0,0,255]},{\"x\":0.60,\"y\":0.58,\"rgb\":[255,255,0]}]" } },
  // The player's loss, judged by the picture: after the device comes back on its own, the frame
  // is the frame from before the loss, twice. One scene per kind of GPU object a recovery must
  // bring back, because each kind has had its own owner and its own way of being forgotten.
  { id: "device-roundtrip-grid", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_DEVICE_LOSS: "roundtrip", ESTELLA_VERIFY_LOSS_ROUNDS: "2", ESTELLA_VERIFY_SCENE: "/scenes/sprite-rendering.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/sprite-rendering.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "3", ESTELLA_VERIFY_LOSS_GRID: "64" } },
  { id: "device-roundtrip-instanced", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_DEVICE_LOSS: "roundtrip", ESTELLA_VERIFY_LOSS_ROUNDS: "2", ESTELLA_VERIFY_SCENE: "/scenes/mesh-instanced.esscene", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "3" } },
  { id: "device-roundtrip-skin-material", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_DEVICE_LOSS: "roundtrip", ESTELLA_VERIFY_LOSS_ROUNDS: "2", ESTELLA_VERIFY_SCENE: "/scenes/mesh-skin-mat.esscene", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "3" } },
  { id: "device-roundtrip-morph-material", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_DEVICE_LOSS: "roundtrip", ESTELLA_VERIFY_LOSS_ROUNDS: "2", ESTELLA_VERIFY_SCENE: "/scenes/mesh-morph-mat.esscene", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "3" } },
  { id: "device-roundtrip-shadow-material", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_DEVICE_LOSS: "roundtrip", ESTELLA_VERIFY_LOSS_ROUNDS: "2", ESTELLA_VERIFY_SCENE: "/scenes/mesh-shadow-material.esscene", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "3" } },
  { id: "device-roundtrip-sky", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_DEVICE_LOSS: "roundtrip", ESTELLA_VERIFY_LOSS_ROUNDS: "2", ESTELLA_VERIFY_SCENE: "/scenes/mesh-sky.esscene", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "3" } },
  // The built-in ripple map is drawn from code and the device keeps no copy of it: after a loss it is drawn again, and a
  // shader that asks for default(ripples) reads the same waves and not the placeholder.
  { id: "device-roundtrip-ripples", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_DEVICE_LOSS: "roundtrip", ESTELLA_VERIFY_LOSS_ROUNDS: "2", ESTELLA_VERIFY_SCENE: "/scenes/ripple-map.esscene", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "3", ESTELLA_VERIFY_COUNTERS_MAX: "{\"render.retained.bytes\":65536}" } },
  // A restored WebGL context has no extension enabled: unless the engine enables them again, the float targets of an HDR chain come back incomplete and the frame is black.
  { id: "device-roundtrip-hdr-bloom", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_DEVICE_LOSS: "roundtrip", ESTELLA_VERIFY_LOSS_ROUNDS: "2", ESTELLA_VERIFY_PLAY: "1", ESTELLA_VERIFY_COLORSPACE: "linear", ESTELLA_VERIFY_SCENE: "/scenes/hdr-bloom.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/hdr-bloom.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "10" } },
  { id: "device-roundtrip-env", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_DEVICE_LOSS: "roundtrip", ESTELLA_VERIFY_LOSS_ROUNDS: "2", ESTELLA_VERIFY_SCENE: "/scenes/mat-env.esscene", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "3" } },
  { id: "device-roundtrip-light-cookie", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_DEVICE_LOSS: "roundtrip", ESTELLA_VERIFY_LOSS_ROUNDS: "2", ESTELLA_VERIFY_SCENE: "/scenes/light-cookie.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/light-cookie.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "3" } },
  // A glyph page and a skeleton's atlas page come back from what made them, not from a copy:
  // the ceiling is under one 1024² page, which is 4 MiB kept on a mini-game's heap per page.
  { id: "device-roundtrip-text", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_COUNTERS_MAX: "{\"render.retained.bytes\":65536}", ESTELLA_VERIFY_DEVICE_LOSS: "roundtrip", ESTELLA_VERIFY_LOSS_ROUNDS: "2", ESTELLA_VERIFY_PLAY: "1", ESTELLA_VERIFY_SCENE: "/scenes/ui-screen-text.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/ui-screen-text.textures.json", ESTELLA_VERIFY_W: "640", ESTELLA_VERIFY_H: "360", ESTELLA_VERIFY_STEPS: "6" } },
  { id: "device-roundtrip-dragonbones", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_COUNTERS_MAX: "{\"render.retained.bytes\":65536}", ESTELLA_VERIFY_DEVICE_LOSS: "roundtrip", ESTELLA_VERIFY_LOSS_ROUNDS: "2", ESTELLA_VERIFY_SCENE: "/scenes/dragonbones-still.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/dragonbones-test.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "3" } },
  // A video that has ENDED, so the only way its frame comes back is the provider:
  // a playing one would paper over a missing refill with its next frame, and the
  // clip is one still image, so nothing else can tell the two apart.
  { id: "device-roundtrip-video", tier: "nightly", webgpu: true, env: { ESTELLA_VERIFY_DEVICE_LOSS: "roundtrip", ESTELLA_VERIFY_LOSS_ROUNDS: "2", ESTELLA_VERIFY_PLAY: "1", ESTELLA_VERIFY_SETTLE_MS: "4000", ESTELLA_VERIFY_SCENE: "/scenes/video-ended.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/video-ended.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2" } },
  // Content the GAME drew and nothing redraws: the target is baked once, so only the
  // deviceRestored event plus contentLost can carry it through a loss (a camera still
  // rendering into it would heal by itself). The EXPECT is read AFTER both losses.
  { id: "device-roundtrip-render-target", tier: "pr", env: { ESTELLA_VERIFY_DEVICE_LOSS: "roundtrip", ESTELLA_VERIFY_LOSS_ROUNDS: "2", ESTELLA_VERIFY_SCENE: "/scenes/camera-target.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/camera-target.textures.json", ESTELLA_VERIFY_CAMERA_TARGET: "{\"camera\":0,\"sprite\":3,\"width\":128,\"height\":128,\"once\":true}", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "4", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.5,\"y\":0.5,\"rgb\":[255,0,0],\"tol\":40}]" } },
  // The same roundtrip in the EDITOR host, which is where the 0.68 losses were
  // actually seen: its viewport draws through the editor's own camera and grid,
  // and every one of those objects had its own recovery path before RM-063.
  { id: "device-roundtrip-editor-3d", tier: "pr", host: "editor", env: { ESTELLA_VERIFY_DEVICE_LOSS: "roundtrip", ESTELLA_VERIFY_LOSS_ROUNDS: "2", ESTELLA_VERIFY_SCENE: "/scenes/mesh-lit.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/mesh-lit.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "3" } },
  { id: "device-roundtrip-editor-grid", tier: "pr", host: "editor", env: { ESTELLA_VERIFY_DEVICE_LOSS: "roundtrip", ESTELLA_VERIFY_LOSS_ROUNDS: "2", ESTELLA_VERIFY_LOSS_GRID: "64", ESTELLA_VERIFY_SCENE: "/scenes/sprite-rendering.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/sprite-rendering.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "3" } },
  { id: "device-roundtrip-post", tier: "pr", webgpu: true, env: { ESTELLA_VERIFY_DEVICE_LOSS: "roundtrip", ESTELLA_VERIFY_LOSS_ROUNDS: "2", ESTELLA_VERIFY_PLAY: "1", ESTELLA_VERIFY_SCENE: "/scenes/ui-screen-post.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/ui-screen-post.textures.json", ESTELLA_VERIFY_W: "640", ESTELLA_VERIFY_H: "360", ESTELLA_VERIFY_STEPS: "4" } },
  // Closed-form oracles (tools/oracle): the number each scene must draw comes from the maths, not from a frame.
  ...ORACLE.map(oracleEntry),
];

/**
 * The same pixels with the opaque scene drawn twice, depth alone first. A quality level turns the prepass on, and this host has none, so a scene
 * that must look the same either way runs again with `ESTELLA_VERIFY_PREPASS`; the run also fails if no draw took part in the prepass, which a
 * twin of a scene with nothing opaque to draw first would otherwise pass without having tried.
 */
const PREPASS_TWINS = [
  // Scenes that draw opaque meshes already.
  'mesh-opaque', 'mesh-instanced', 'prepass-hook', 'corpus-cutout-edge', 'mesh-normalmap', 'mesh-shadow-cutout', 'mesh-shadow', 'sun-shadow',
  { id: 'planar-reflection', counters: { 'render.planar.prepass.draws': 1 } },
  { id: 'planar-tiled-lights', counters: { 'render.planar.prepass.draws': 2 } },
  // The same scenes with their meshes made opaque (fixtures/scenes/*-opaque.esscene), for what a mesh can be besides a rigid one that is lit:
  // skinned, morphing.
  { id: 'mesh-skin', scene: 'mesh-skin-opaque.esscene' }, { id: 'mesh-morph-shaped', scene: 'mesh-morph-opaque.esscene' },
  { id: 'mesh-lit', scene: 'mesh-lit-opaque.esscene' }, { id: 'mesh-resident', scene: 'mesh-renderer-opaque.esscene', as: 'mesh-renderer' },
];
for (const entry of PREPASS_TWINS) {
  const { id, scene, as, counters } = typeof entry === 'string' ? { id: entry } : entry;
  const base = SCENES.find((s) => s.id === id);
  if (!base) throw new Error(`renderScenes: no scene "${id}" to run a prepass twin of`);
  const env = { ...base.env, ESTELLA_VERIFY_PREPASS: '1' };
  if (counters) env.ESTELLA_VERIFY_COUNTERS = JSON.stringify({ ...JSON.parse(env.ESTELLA_VERIFY_COUNTERS ?? '{}'), ...counters });
  if (scene) env.ESTELLA_VERIFY_SCENE = `/scenes/${scene}`;
  SCENES.push({ ...base, id: `${as ?? (scene ? scene.replace('.esscene', '') : id)}-prepass`, env });
}

const rank = (tier) => TIERS.indexOf(tier);

/** Scenes that run at `tier`, cheaper tiers included. */
export function scenesAtTier(tier) {
  const want = rank(tier);
  if (want < 0) throw new Error(`unknown tier "${tier}" (have: ${TIERS.join(', ')})`);
  return SCENES.filter((s) => rank(s.tier) <= want);
}

/** The scene file a registry entry loads, or null for the default scene. */
export function sceneFileOf(s) {
  const p = s.env.ESTELLA_VERIFY_SCENE;
  return p ? p.replace(/^\//, '') : null;
}