@forgeax/engine-runtime 0.1.4 → 0.1.6

package/src/__tests__/shadow-probe-control-flow.dawn.test.ts

@@ -1,264 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { SHADOW_PROBE_WGSL } from '../../../render/src/renderer/renderer-factory';
-
-const dawnReady = typeof navigator !== 'undefined' && navigator.gpu !== undefined;
-
-const PROBE_MAX_COUNT = 64;
-const PROBE_LSM_UBO_BYTES = 352;
-const PROBE_OUTPUT_WIDTH = PROBE_MAX_COUNT;
-const PROBE_OUTPUT_ROW_BYTES = PROBE_OUTPUT_WIDTH * 16;
-const DEPTH_ATLAS_WIDTH = 64;
-const DEPTH_ATLAS_HEIGHT = 32;
-const DEPTH_TILE_SIZE = DEPTH_ATLAS_WIDTH / 2;
-
-const GPU_BUFFER_MAP_READ = 0x0001;
-const GPU_BUFFER_COPY_DST = 0x0008;
-const GPU_BUFFER_UNIFORM = 0x0040;
-const GPU_BUFFER_STORAGE = 0x0080;
-const GPU_TEXTURE_COPY_SRC = 0x0001;
-const GPU_TEXTURE_TEXTURE_BINDING = 0x0004;
-const GPU_TEXTURE_RENDER_ATTACHMENT = 0x0010;
-
-const DEPTH_WRITE_WGSL = `
-struct VsOut {
-  @builtin(position) position : vec4<f32>,
-};
-
-@vertex fn vs_main(@builtin(vertex_index) index : u32) -> VsOut {
-  var positions = array<vec2<f32>, 3>(
-    vec2<f32>(-1.0, -1.0),
-    vec2<f32>( 3.0, -1.0),
-    vec2<f32>(-1.0,  3.0),
-  );
-  var out : VsOut;
-  out.position = vec4<f32>(positions[index], 0.1, 1.0);
-  return out;
-}
-`;
-
-interface ProbeResult {
-  readonly shadowFactor: number;
-  readonly sampledDepth: number;
-  readonly cascadeIndex: number;
-  readonly receiverDepth: number;
-}
-
-function makeLightMatrix(): Float32Array {
-  const matrix = new Float32Array(16);
-  matrix[0] = 1;
-  matrix[5] = 1;
-  // Keep XY in clip space while pinning all receivers to a known depth.
-  matrix[10] = 0;
-  matrix[14] = 0.5;
-  matrix[15] = 1;
-  return matrix;
-}
-
-function makeIdentityMatrix(): Float32Array {
-  const matrix = new Float32Array(16);
-  matrix[0] = 1;
-  matrix[5] = 1;
-  matrix[10] = 1;
-  matrix[15] = 1;
-  return matrix;
-}
-
-async function runControlledProbe(): Promise<ProbeResult[]> {
-  const gpu = navigator.gpu;
-  const adapter = await gpu.requestAdapter();
-  if (adapter === null) throw new Error('no Dawn adapter');
-  const device = await adapter.requestDevice();
-
-  const shaderModule = device.createShaderModule({ code: SHADOW_PROBE_WGSL });
-  const pipeline = device.createRenderPipeline({
-    layout: 'auto',
-    vertex: { module: shaderModule, entryPoint: 'vs_main' },
-    fragment: {
-      module: shaderModule,
-      entryPoint: 'fs_main',
-      targets: [{ format: 'rgba32float' }],
-    },
-    primitive: { topology: 'triangle-list' },
-  });
-
-  const depthModule = device.createShaderModule({ code: DEPTH_WRITE_WGSL });
-  const depthPipeline = device.createRenderPipeline({
-    layout: 'auto',
-    vertex: { module: depthModule, entryPoint: 'vs_main' },
-    primitive: { topology: 'triangle-list' },
-    depthStencil: {
-      format: 'depth32float',
-      depthWriteEnabled: true,
-      depthCompare: 'less',
-    },
-  });
-
-  const depthTexture = device.createTexture({
-    size: { width: DEPTH_ATLAS_WIDTH, height: DEPTH_ATLAS_HEIGHT, depthOrArrayLayers: 1 },
-    format: 'depth32float',
-    usage: GPU_TEXTURE_TEXTURE_BINDING | GPU_TEXTURE_RENDER_ATTACHMENT,
-  });
-  const depthView = depthTexture.createView();
-  const depthEncoder = device.createCommandEncoder();
-  const depthPass = depthEncoder.beginRenderPass({
-    colorAttachments: [],
-    depthStencilAttachment: {
-      view: depthView,
-      depthLoadOp: 'clear',
-      depthStoreOp: 'store',
-      depthClearValue: 0.9,
-    },
-  });
-  depthPass.setPipeline(depthPipeline);
-  // Only sibling tile 1 contains a caster. Tile 0 stays at the clear depth.
-  depthPass.setViewport(0, 0, DEPTH_ATLAS_WIDTH, DEPTH_ATLAS_HEIGHT, 0, 1);
-  depthPass.setScissorRect(DEPTH_TILE_SIZE, 0, DEPTH_TILE_SIZE, DEPTH_TILE_SIZE);
-  depthPass.draw(3);
-  depthPass.end();
-  device.queue.submit([depthEncoder.finish()]);
-
-  const lsm = new Float32Array(PROBE_LSM_UBO_BYTES / 4);
-  const lightMatrix = makeLightMatrix();
-  const viewMatrix = makeIdentityMatrix();
-  lsm.set(lightMatrix, 0);
-  lsm.set(lightMatrix, 16);
-  lsm.set(lightMatrix, 32);
-  lsm.set(lightMatrix, 48);
-  lsm.set(viewMatrix, 64);
-  // Cascade 0 spans viewDepth < 10; cascade 1 ends at shadowDistance 15.
-  lsm[80] = 10;
-  lsm[81] = 15;
-  const lsmU32 = new Uint32Array(lsm.buffer);
-  lsmU32[84] = 2;
-  lsmU32[85] = 3;
-  lsm[86] = 0.2;
-
-  // Three probes are deliberately chosen to falsify three independent
-  // control-flow regressions:
-  //   1. local XY outside cascade 0 but inside atlas-space UV;
-  //   2. beyond the final split / shadowDistance;
-  //   3. inside the cascade-0 blend band with different sibling depth.
-  const positions = [
-    [1.25, 0, 0.5, 0],
-    [0, 0, -20, 0],
-    [0, 0, -9, 0],
-  ] as const;
-  const input = new Float32Array(PROBE_MAX_COUNT * 4);
-  for (let index = 0; index < positions.length; index += 1) {
-    const [x, y, z, bias] = positions[index] ?? [0, 0, 0, 0];
-    const base = index * 4;
-    input[base] = x;
-    input[base + 1] = y;
-    input[base + 2] = z;
-    input[base + 3] = bias;
-  }
-
-  const lsmBuffer = device.createBuffer({
-    size: PROBE_LSM_UBO_BYTES,
-    usage: GPU_BUFFER_UNIFORM | GPU_BUFFER_COPY_DST,
-  });
-  const inputBuffer = device.createBuffer({
-    size: input.byteLength,
-    usage: GPU_BUFFER_STORAGE | GPU_BUFFER_COPY_DST,
-  });
-  device.queue.writeBuffer(lsmBuffer, 0, lsm);
-  device.queue.writeBuffer(inputBuffer, 0, input);
-
-  const sampler = device.createSampler({
-    addressModeU: 'clamp-to-edge',
-    addressModeV: 'clamp-to-edge',
-    magFilter: 'linear',
-    minFilter: 'linear',
-    compare: 'less',
-  });
-  const bindGroup = device.createBindGroup({
-    layout: pipeline.getBindGroupLayout(0),
-    entries: [
-      { binding: 0, resource: { buffer: lsmBuffer } },
-      { binding: 1, resource: { buffer: inputBuffer } },
-      { binding: 2, resource: depthView },
-      { binding: 3, resource: sampler },
-    ],
-  });
-
-  const outputTexture = device.createTexture({
-    size: { width: PROBE_OUTPUT_WIDTH, height: 1, depthOrArrayLayers: 1 },
-    format: 'rgba32float',
-    usage: GPU_TEXTURE_COPY_SRC | GPU_TEXTURE_RENDER_ATTACHMENT,
-  });
-  const outputView = outputTexture.createView();
-  const staging = device.createBuffer({
-    size: PROBE_OUTPUT_ROW_BYTES,
-    usage: GPU_BUFFER_COPY_DST | GPU_BUFFER_MAP_READ,
-  });
-
-  const encoder = device.createCommandEncoder();
-  const pass = encoder.beginRenderPass({
-    colorAttachments: [
-      {
-        view: outputView,
-        loadOp: 'clear',
-        storeOp: 'store',
-        clearValue: { r: 1, g: 1, b: -1, a: 1 },
-      },
-    ],
-  });
-  pass.setPipeline(pipeline);
-  pass.setBindGroup(0, bindGroup);
-  pass.draw(6, positions.length);
-  pass.end();
-  encoder.copyTextureToBuffer(
-    { texture: outputTexture },
-    { buffer: staging, bytesPerRow: PROBE_OUTPUT_ROW_BYTES, rowsPerImage: 1 },
-    { width: PROBE_OUTPUT_WIDTH, height: 1, depthOrArrayLayers: 1 },
-  );
-  device.queue.submit([encoder.finish()]);
-  await staging.mapAsync(GPU_BUFFER_MAP_READ);
-  const readback = new Float32Array(staging.getMappedRange().slice(0));
-  staging.unmap();
-
-  const result: ProbeResult[] = [];
-  for (let index = 0; index < positions.length; index += 1) {
-    const base = index * 4;
-    result.push({
-      shadowFactor: readback[base] ?? 1,
-      sampledDepth: readback[base + 1] ?? 1,
-      cascadeIndex: Math.round(readback[base + 2] ?? -1),
-      receiverDepth: readback[base + 3] ?? 1,
-    });
-  }
-
-  staging.destroy();
-  outputTexture.destroy();
-  inputBuffer.destroy();
-  lsmBuffer.destroy();
-  depthTexture.destroy();
-  device.destroy();
-  return result;
-}
-
-describe('production shadow probe control-flow falsifiers', () => {
-  it.skipIf(!dawnReady)(
-    'rejects local-tile OOB, final-split OOB, and blends sibling tiles',
-    async () => {
-      const [localOob, finalSplitOob, blendBand] = await runControlledProbe();
-
-      // The local-tile point maps to atlas UV x=0.5625, where the sibling tile
-      // contains depth 0.1. A global-atlas guard would read that non-clear depth;
-      // the producer-local guard must fail closed before any texture read.
-      expect(localOob?.shadowFactor).toBe(1);
-      expect(localOob?.sampledDepth).toBe(1);
-      expect(localOob?.cascadeIndex).toBe(0);
-
-      expect(finalSplitOob?.cascadeIndex).toBe(-1);
-      expect(finalSplitOob?.shadowFactor).toBe(1);
-
-      // At viewDepth=9, split=10 and blend=0.2, t=0.5. Tile 0 is lit (0.9)
-      // and sibling tile 1 is blocked (0.1), so the exact production blend is
-      // 0.5. Removing the adjacent-layer sample or the mix makes this RED.
-      expect(blendBand?.cascadeIndex).toBe(0);
-      expect(blendBand?.shadowFactor).toBeCloseTo(0.5, 3);
-      expect(blendBand?.sampledDepth).toBeCloseTo(0.9, 3);
-    },
-  );
-});

package/src/__tests__/shadow-quality-metrics.dawn.test.ts

@@ -1,324 +0,0 @@
-// shadow-quality-metrics.dawn.test.ts — L1 shadow-quality metric probes.
-//
-// WHY THIS EXISTS
-// ---------------
-// Structural smoke ("4 shadowCascade passes, no crash") proves the pipeline is
-// wired, not that the shadows look right. Acne, missed occlusion, cascade seams
-// and peter-panning all pass a structural gate while looking broken. This suite
-// turns "does the shadow look good" into a handful of scalar metrics sampled off
-// the real shadow atlas via `renderer.debugSampleShadowFactor`, each with a
-// falsifiable assertion band. Regressions move a number; the number has a gate.
-//
-// WHAT THE PROBE MEASURES (and its honest limits)
-// -----------------------------------------------
-// `debugSampleShadowFactor(worldPositions)` reads the SAME shadow atlas the
-// forward pass samples, selects the cascade by frustum containment (mirrors the
-// shader's viewZ+splitPlanes selection), and returns a fixed-bias 3x3-PCF factor
-// per point (1 = fully lit, 0 = fully shadowed). That makes these metrics honest:
-//   - acne          — lit ground reads ~1 (no spurious self-shadow)
-//   - coverage      — ground under the occluder reads low (shadow is present)
-//   - contact       — the lit->shadowed transition sits at the occluder edge
-//                     (peter-panning = shadow starts too far from the caster)
-//   - cascadeSeam   — no factor discontinuity as depth crosses a split plane
-// NOT measurable here (needs L3 lit-framebuffer readback): penumbra WIDTH driven
-// by the material `pcfKernelSize`, because the probe uses its own fixed 3x3 tap,
-// not the forward shader's variable kernel. We do not fake that metric.
-//
-// FALSIFY DISCIPLINE
-// ------------------
-// Each metric has a paired "must move the right way when the scene breaks" check
-// (castShadow:false collapses coverage; a huge shadowDistance degrades near acne)
-// so a vacuous all-green (empty atlas, probe returning a constant) cannot pass.
-
-import { World } from '@forgeax/engine-ecs';
-import { createPrimitiveMesh } from '@forgeax/engine-geometry';
-import {
-  Camera,
-  DirectionalLight,
-  MeshFilter,
-  MeshRenderer,
-} from '@forgeax/engine-render/internal';
-import { Transform } from '@forgeax/engine-scene';
-import { describe, expect, it } from 'vitest';
-import { createRenderer } from '../index';
-import { drawPublished } from './draw-published';
-
-const ENGINE_MANIFEST = await (async () => {
-  const { buildEngineShaderManifest } = await import('@forgeax/engine-vite-plugin-shader');
-  return buildEngineShaderManifest();
-})();
-const ENGINE_MANIFEST_URL = `data:application/json,${encodeURIComponent(
-  JSON.stringify(ENGINE_MANIFEST),
-)}`;
-
-// biome-ignore lint/suspicious/noExplicitAny: dawn-node detection guard
-const dawnReady = typeof navigator !== 'undefined' && (navigator as any).gpu !== undefined;
-
-const GROUND_SIZE = 40;
-const RT_W = 256;
-const RT_H = 256;
-const TEXTURE_USAGE_COPY_SRC = 0x01;
-const TEXTURE_USAGE_RENDER_ATTACHMENT = 0x10;
-
-// Mock canvas that exposes a real configurable WebGPU context + captures the
-// device, mirroring shadow-m3.dawn.test.ts exactly (per-canvas adapter patch).
-function createMockCanvas(): HTMLCanvasElement {
-  let sharedDevice: GPUDevice | undefined;
-  const originalRequestAdapter = globalThis.navigator.gpu.requestAdapter.bind(
-    globalThis.navigator.gpu,
-  );
-  globalThis.navigator.gpu.requestAdapter = async (opts) => {
-    const rawAdapter = await originalRequestAdapter(opts);
-    if (rawAdapter === null) return rawAdapter;
-    const originalRequestDevice = rawAdapter.requestDevice.bind(rawAdapter);
-    rawAdapter.requestDevice = async (desc) => {
-      const dev = await originalRequestDevice(desc);
-      if (sharedDevice === undefined) sharedDevice = dev;
-      return dev;
-    };
-    return rawAdapter;
-  };
-  let renderTarget: GPUTexture | undefined;
-  const ensureRenderTarget = (device: GPUDevice, format: GPUTextureFormat): GPUTexture => {
-    if (renderTarget !== undefined) return renderTarget;
-    renderTarget = device.createTexture({
-      size: { width: RT_W, height: RT_H, depthOrArrayLayers: 1 },
-      format,
-      usage: TEXTURE_USAGE_RENDER_ATTACHMENT | TEXTURE_USAGE_COPY_SRC,
-      viewFormats: ['rgba8unorm-srgb'],
-    });
-    return renderTarget;
-  };
-  return {
-    width: RT_W,
-    height: RT_H,
-    getContext(kind: string): unknown {
-      if (kind !== 'webgpu') return null;
-      return {
-        configure(desc: { device: GPUDevice; format?: GPUTextureFormat }) {
-          ensureRenderTarget(desc.device, desc.format ?? 'rgba8unorm');
-        },
-        unconfigure() {},
-        getCurrentTexture(): GPUTexture {
-          if (renderTarget === undefined) {
-            if (sharedDevice === undefined)
-              throw new Error('render target requested before device captured');
-            return ensureRenderTarget(sharedDevice, 'rgba8unorm');
-          }
-          return renderTarget;
-        },
-      };
-    },
-    addEventListener() {},
-    removeEventListener() {},
-  } as unknown as HTMLCanvasElement;
-}
-
-interface SceneConfig {
-  readonly castShadow?: boolean;
-  readonly cascadeCount?: number;
-  readonly shadowDistance?: number;
-  readonly mapSize?: number;
-}
-
-// Ground plane at y=0 with a 2x2x2 occluder centred at y=1.5 (bottom face at
-// y=0.5), lit by a straight-down directional light. Orthographic camera framing
-// the scene so every probe point lands in the atlas fit. Occluder edges are at
-// x = +-1, so the ground shadow footprint is ~[-1,1] in x (light is near-vertical).
-function buildScene(world: World, cfg: SceneConfig): void {
-  const cubeHandle = world.internSharedRef('MeshAsset', createPrimitiveMesh('cube').unwrap());
-  world
-    .spawn(
-      {
-        component: Transform,
-        data: {
-          pos: [0, -0.005, 0],
-          quat: [0, 0, 0, 1],
-          scale: [GROUND_SIZE, 0.01, GROUND_SIZE],
-        },
-      },
-      { component: MeshFilter, data: { assetHandle: cubeHandle } },
-      { component: MeshRenderer, data: {} },
-    )
-    .unwrap();
-
-  world
-    .spawn(
-      {
-        component: Transform,
-        data: { pos: [0, 1.5, 0], quat: [0, 0, 0, 1], scale: [2, 2, 2] },
-      },
-      { component: MeshFilter, data: { assetHandle: cubeHandle } },
-      { component: MeshRenderer, data: {} },
-    )
-    .unwrap();
-
-  world
-    .spawn({
-      component: DirectionalLight,
-      data: {
-        direction: [0, -1, 0],
-        color: [1, 1, 1],
-        intensity: 1.5,
-        castShadow: cfg.castShadow ?? true,
-        cascadeCount: cfg.cascadeCount ?? 1,
-        mapSize: cfg.mapSize ?? 1024,
-        shadowDistance: cfg.shadowDistance ?? 50,
-      },
-    })
-    .unwrap();
-
-  world
-    .spawn(
-      { component: Transform, data: { pos: [0, 0, 10], quat: [0, 0, 0, 1] } },
-      {
-        component: Camera,
-        data: {
-          projection: 1,
-          left: -GROUND_SIZE / 2,
-          right: GROUND_SIZE / 2,
-          bottom: -GROUND_SIZE / 2,
-          top: GROUND_SIZE / 2,
-          near: 0.1,
-          far: 100,
-          fov: 0,
-          aspect: 1,
-        } as Record<string, unknown> as never,
-      },
-    )
-    .unwrap();
-}
-
-// ONE renderer for the whole suite. Creating a second createRenderer in the
-// same dawn-node process trips `manifest-malformed` (shared shader-module cache
-// state), so every sample() re-draws a fresh world through this single renderer
-// and re-reads the atlas — the extract stage rebuilds shadow matrices per frame.
-type Renderer = Awaited<ReturnType<typeof createRenderer>>;
-let sharedRenderer: Renderer | undefined;
-async function getRenderer(): Promise<Renderer> {
-  if (sharedRenderer !== undefined) return sharedRenderer;
-  const canvas = createMockCanvas();
-  const renderer = await createRenderer(canvas, {}, { shaderManifestUrl: ENGINE_MANIFEST_URL });
-  const ready = await renderer.ready;
-  if (!ready.ok) throw new Error('renderer not ready');
-  sharedRenderer = renderer;
-  return renderer;
-}
-
-async function sample(
-  cfg: SceneConfig,
-  points: ReadonlyArray<readonly [number, number, number]>,
-): Promise<number[]> {
-  const renderer = await getRenderer();
-  const world = new World();
-  buildScene(world, cfg);
-  world.update(1 / 60).unwrap();
-  const draw = drawPublished(renderer, world);
-  if (!draw.ok) throw new Error('draw failed');
-  const res = await renderer.debugSampleShadowFactor?.(points);
-  if (!res) throw new Error('debugSampleShadowFactor returned null');
-  return res.map((r) => r.shadowFactor);
-}
-
-const mean = (xs: number[]): number => xs.reduce((a, b) => a + b, 0) / xs.length;
-
-describe('shadow quality metrics (L1 — off-atlas probe)', () => {
-  it.skipIf(!dawnReady)('dawn-binding present', () => {
-    expect(dawnReady).toBe(true);
-  });
-
-  // ── Metric: ACNE — lit ground far from the occluder must read ~fully lit ──
-  it.skipIf(!dawnReady)('acne: unoccluded ground reads ~1 (no self-shadow noise)', async () => {
-    const litPoints: [number, number, number][] = [
-      [8, 0, 8],
-      [-8, 0, 8],
-      [8, 0, -8],
-      [-8, 0, -8],
-      [12, 0, 0],
-      [-12, 0, 0],
-    ];
-    const factors = await sample({}, litPoints);
-    const acneFraction = factors.filter((f) => f < 0.99).length / factors.length;
-    // METRIC: fraction of clearly-unoccluded samples showing spurious shadow.
-    // Gate: none should. A future acne regression pushes this above 0.
-    expect(acneFraction).toBe(0);
-    expect(mean(factors)).toBeGreaterThan(0.99);
-  });
-
-  // ── Metric: COVERAGE — ground under the occluder must be shadowed ──
-  it.skipIf(!dawnReady)('coverage: ground under occluder reads shadowed', async () => {
-    const under: [number, number, number][] = [
-      [0, 0, 0],
-      [0.5, 0, 0],
-      [0, 0, 0.5],
-      [-0.5, 0, -0.5],
-    ];
-    const factors = await sample({}, under);
-    // METRIC: mean shadow factor directly under the caster. Gate: strongly
-    // shadowed. Missed occlusion (bad ortho Z reach / too-small map) raises this.
-    expect(mean(factors)).toBeLessThan(0.1);
-  });
-
-  // ── FALSIFY coverage: castShadow=false must collapse the shadow ──
-  it.skipIf(!dawnReady)(
-    'coverage falsify: castShadow=false leaves under-occluder lit',
-    async () => {
-      const under: [number, number, number][] = [
-        [0, 0, 0],
-        [0.5, 0, 0],
-      ];
-      const on = mean(await sample({ castShadow: true }, under));
-      const off = mean(await sample({ castShadow: false }, under));
-      // The same points flip from shadowed to lit — proves the probe reads a real
-      // atlas, not a constant. Guards against a vacuous coverage pass.
-      expect(on).toBeLessThan(0.1);
-      expect(off).toBeGreaterThan(0.9);
-    },
-  );
-
-  // ── Metric: CONTACT / peter-panning — transition sits at the occluder edge ──
-  it.skipIf(!dawnReady)('contact: shadow edge tracks the occluder footprint (x≈1)', async () => {
-    // Scan x from deep-shadow (0) outward past the occluder edge (1.0) into
-    // full light. The last shadowed sample and first lit sample must straddle
-    // x≈1. Peter-panning would push the transition well past the edge.
-    const xs = [0, 0.4, 0.8, 1.0, 1.2, 1.6, 2.0, 3.0];
-    const factors = await sample(
-      {},
-      xs.map((x) => [x, 0, 0] as [number, number, number]),
-    );
-    const scan = xs.map((x, i) => ({ x, f: factors[i] ?? 1 }));
-    const lastShadowedX = scan.filter((s) => s.f < 0.5).at(-1)?.x ?? -1;
-    const firstLitX = scan.find((s) => s.f > 0.5)?.x ?? 999;
-    // METRIC: transition band position. Measured contact profile is
-    // [0,0,0.33,1,1,1,1] over xs => lastShadowedX=1.0, firstLitX=1.2, i.e. a
-    // one-sample transition straddling the occluder edge (x=1). Gate: shadow
-    // persists to the edge and clears within ~1 texel of it. Peter-panning
-    // (shadow detached from the caster) pushes firstLitX out; this catches it.
-    expect(lastShadowedX).toBeGreaterThanOrEqual(0.8);
-    expect(firstLitX).toBeLessThanOrEqual(1.2);
-  });
-
-  // ── Metric: CASCADE SEAM — no factor jump across a split boundary ──
-  it.skipIf(!dawnReady)(
-    'cascadeSeam: 4-cascade lit ground has no discontinuity vs 1-cascade',
-    async () => {
-      // Sample lit ground along increasing depth (spanning cascade splits under a
-      // 4-cascade config). All should stay ~1; a seam would show a sudden dip at a
-      // split plane. Compare the 4-cascade profile to the single-cascade baseline.
-      const line: [number, number, number][] = [];
-      for (let z = -18; z <= 18; z += 3) line.push([6, 0, z]);
-      const one = await sample({ cascadeCount: 1 }, line);
-      const four = await sample({ cascadeCount: 4 }, line);
-      const maxAdjacentJump = (xs: number[]): number =>
-        xs.reduce(
-          (m, cur, i) => (i === 0 ? m : Math.max(m, Math.abs(cur - (xs[i - 1] ?? cur)))),
-          0,
-        );
-      // METRIC: largest factor step between adjacent lit samples. Gate: small for
-      // both; the 4-cascade path must not introduce a seam the 1-cascade lacks.
-      expect(maxAdjacentJump(one)).toBeLessThan(0.1);
-      expect(maxAdjacentJump(four)).toBeLessThan(0.1);
-      expect(mean(four)).toBeGreaterThan(0.95);
-    },
-  );
-});

package/src/__tests__/temporal-off-path.unit.test.ts

@@ -1,69 +0,0 @@
-import { World } from '@forgeax/engine-ecs';
-import {
-  ANTIALIAS_FXAA,
-  ANTIALIAS_MSAA,
-  ANTIALIAS_NONE,
-  Camera,
-  perspective,
-} from '@forgeax/engine-render';
-import { rhi } from '@forgeax/engine-rhi-null';
-import { Transform } from '@forgeax/engine-scene';
-import { describe, expect, it } from 'vitest';
-import { createRenderer } from '../createRenderer';
-
-const manifest = `data:application/json,${encodeURIComponent(
-  JSON.stringify({
-    schemaVersion: '1.0.0',
-    entries: [
-      { hash: 'pbr00000', wgsl: '/* pbr stub */', glsl: '', bindings: '' },
-      { hash: 'unlit000', wgsl: '/* unlit stub */', glsl: '', bindings: '' },
-      { hash: 'tonemap0', wgsl: '/* tonemap stub */', glsl: '', bindings: '' },
-    ],
-  }),
-)}`;
-
-function canvas(): HTMLCanvasElement {
-  return {
-    width: 64,
-    height: 64,
-    getContext: () => null,
-    addEventListener: () => undefined,
-    removeEventListener: () => undefined,
-  } as unknown as HTMLCanvasElement;
-}
-
-describe.each([
-  ['none', ANTIALIAS_NONE],
-  ['fxaa', ANTIALIAS_FXAA],
-  ['msaa', ANTIALIAS_MSAA],
-] as const)('temporal off-path: %s', (_name, antialias) => {
-  it('allocates no history and records no temporal pass', async () => {
-    const renderer = await createRenderer(canvas(), { rhi }, { shaderManifestUrl: manifest });
-    const ready = await renderer.ready;
-    expect(ready.ok).toBe(true);
-    const world = new World();
-    const attached = renderer.attachWorld(world);
-    expect(attached.ok).toBe(true);
-    world
-      .spawn(
-        { component: Transform, data: { pos: [0, 0, 5] } },
-        {
-          component: Camera,
-          data: { ...perspective({ fov: Math.PI / 4, aspect: 1 }), antialias },
-        },
-      )
-      .unwrap();
-    world.update(1 / 60).unwrap();
-    expect(renderer.draw([world], { cameraOwner: 0, resourceOwner: 0 }).ok).toBe(true);
-
-    expect(renderer.renderScene.temporal).toMatchObject({
-      enabled: false,
-      status: 'off',
-      historyBytes: 0,
-      historyOwnerGeneration: 0,
-    });
-    expect(renderer.perFramePassNames).not.toContain('scene-temporal-clear');
-    expect(renderer.perFramePassNames).not.toContain('taa-resolve');
-    renderer.dispose();
-  });
-});