@forgeax/engine-runtime 0.1.4 → 0.1.6

package/src/__tests__/ssao-passes.test.ts

@@ -1,271 +1,31 @@
 // @forgeax/engine-runtime/__tests__/ssao-passes.test.ts -
-// SSAO pass topology test (M3 / w13).
+// SSAO record-owner tests (M8 / w35-w46).
 // feat-20260612-hdrp-ssao.
 //
-// plan-strategy D-2: exactly 2 pass (ssao-calc + ssao-blur).
-// requirements: half-res, r8unorm transient color targets.
-//
-// Tests:
-//   (a) addSsaoPasses wires 2 pass nodes into an isolated RenderGraph
-//   (b) pass names are 'ssao-calc' and 'ssao-blur'
-//   (c) ssao-calc reads gbuf0 + hdrDepth, writes ssaoRaw
-//   (d) ssao-blur reads ssaoRaw, writes ssaoBlurred
-//   (e) graph compiles without errors with valid caps + g-buffer producer
-//   (f) ssao-calc comes before ssao-blur in topological order
+// The tests invoke recordSsaoCalcPass/recordSsaoBlurPass through a minimal
+// typed graph fixture and keep the GPU dispatch/binding predicates intact.
 
-import type {
-  _InternalRenderPipelineContext,
-  RenderPipelineContext,
-  RenderSystemRuntime,
-} from '@forgeax/engine-render/internal';
+import { RenderGraph } from '@forgeax/engine-render-graph';
+import type { RhiDevice } from '@forgeax/engine-rhi';
+import { describe, expect, it, vi } from 'vitest';
 import {
-  addSsaoPasses,
   recordBloomBlurHPass,
   recordBloomBlurVPass,
   recordBloomBrightPass,
   recordBloomCompositePass,
   recordFxaaPass,
   recordSkyboxPass,
-} from '@forgeax/engine-render/internal';
-import { RenderGraph } from '@forgeax/engine-render-graph';
-import type { RhiCaps, RhiDevice } from '@forgeax/engine-rhi';
-import { describe, expect, it, vi } from 'vitest';
-
-function mockRuntime(capsOverride: Partial<RhiCaps> = {}): RenderSystemRuntime {
-  const errorRegistry = {
-    fire: vi.fn(),
-    listeners: new Set(),
-    addEventListener: vi.fn(),
-    removeEventListener: vi.fn(),
-  };
-
-  const device = {
-    caps: {
-      backendKind: 'webgpu' as const,
-      storageBuffer: true,
-      float32Filterable: true,
-      maxColorAttachments: 8,
-      maxStorageBuffersPerShaderStage: 4,
-      ...capsOverride,
-    },
-    createBuffer: vi.fn().mockReturnValue({
-      ok: true,
-      value: { label: 'mock-buffer' },
-    }),
-    createTexture: vi.fn().mockReturnValue({
-      ok: true,
-      value: { label: 'mock-tex' },
-    }),
-    createTextureView: vi.fn().mockReturnValue({
-      ok: true,
-      value: { label: 'mock-tex-view' },
-    }),
-    createSampler: vi.fn().mockReturnValue({
-      ok: true,
-      value: { label: 'mock-sampler' },
-    }),
-    createBindGroupLayout: vi.fn().mockReturnValue({
-      ok: true,
-      value: { label: 'mock-bgl' },
-    }),
-    queue: {
-      writeBuffer: vi.fn().mockReturnValue({ ok: true, value: undefined }),
-      writeTexture: vi.fn().mockReturnValue({ ok: true, value: undefined }),
-    },
-  } as unknown as RhiDevice;
-
-  return {
-    device,
-    errorRegistry,
-    shaderCache: { get: vi.fn() },
-  } as unknown as RenderSystemRuntime;
-}
-
-function mockCtx(runtime: RenderSystemRuntime): RenderPipelineContext {
-  return {
-    runtime,
-    assets: { get: vi.fn(), register: vi.fn() },
-    store: { ensureResident: vi.fn(), getTextureView: vi.fn() },
-    pipelineState: {},
-    encoder: {},
-    view: {},
-    clear: [0, 0, 0, 1],
-    targetW: 800,
-    targetH: 600,
-    currentTexture: {},
-    camera: {},
-    validated: [],
-    validatedOrdered: [],
-    viewBindGroup: null,
-    meshBindGroup: null,
-    frameState: { perFrameGraph: null, isHdrpActive: true },
-    dispatchCounts: {},
-    bindGroupCounts: {},
-    skylight: undefined,
-    skylightCount: 0,
-    skybox: undefined,
-    msaaActive: false,
-    geometryColorResolveView: null,
-    ldrSpriteColorView: null,
-  } as unknown as RenderPipelineContext;
-}
-
-/**
- * Declares the minimal HDRP g-buffer targets + half-swapchain SSAO
- * targets that addSsaoPasses expects. Also adds a producer 'g-buffer'
- * pass that writes gbuf0 + hdrDepth so the compile dangling-read
- * validation passes.
- */
-function setupGraph(graph: RenderGraph<RenderPipelineContext>): void {
-  graph.addColorTarget('gbuf0', {
-    format: 'rgba16float',
-    size: 'swapchain',
-    sample: 1,
-  });
-  graph.addColorTarget('hdrDepth', {
-    format: 'depth24plus-stencil8',
-    size: 'swapchain',
-    sample: 1,
-  });
-  graph.addColorTarget('ssaoRaw', {
-    format: 'r8unorm',
-    size: 'half-swapchain',
-    sample: 1,
-  });
-  graph.addColorTarget('ssaoBlurred', {
-    format: 'r8unorm',
-    size: 'half-swapchain',
-    sample: 1,
-  });
-}
-
-describe('addSsaoPasses topology (M3 / w13)', () => {
-  it('(a) wires 2 pass nodes: ssao-calc + ssao-blur', () => {
-    const runtime = mockRuntime();
-    const ctx = mockCtx(runtime);
-    const graph = new RenderGraph<RenderPipelineContext>();
-    setupGraph(graph);
-
-    addSsaoPasses(graph, {
-      gbuf0: 'gbuf0',
-      hdrDepth: 'hdrDepth',
-      ssaoRaw: 'ssaoRaw',
-      ssaoBlurred: 'ssaoBlurred',
-      ctx,
-    });
-
-    const passes = graph.listPasses();
-    const passNames = passes.map((p) => p.name);
-
-    expect(passNames).toContain('ssao-calc');
-    expect(passNames).toContain('ssao-blur');
-    const ssaoPassNames = passNames.filter((n) => n.startsWith('ssao-'));
-    expect(ssaoPassNames).toHaveLength(2);
-  });
-
-  it('(b) ssao-calc reads gbuf0 + hdrDepth, writes ssaoRaw', () => {
-    const runtime = mockRuntime();
-    const ctx = mockCtx(runtime);
-    const graph = new RenderGraph<RenderPipelineContext>();
-    setupGraph(graph);
-
-    addSsaoPasses(graph, {
-      gbuf0: 'gbuf0',
-      hdrDepth: 'hdrDepth',
-      ssaoRaw: 'ssaoRaw',
-      ssaoBlurred: 'ssaoBlurred',
-      ctx,
-    });
-
-    const passes = graph.listPasses();
-    const calcPass = passes.find((p) => p.name === 'ssao-calc');
-    expect(calcPass).toBeDefined();
-    if (!calcPass) return;
-
-    expect(calcPass.reads).toContain('gbuf0');
-    expect(calcPass.reads).toContain('hdrDepth');
-    expect(calcPass.reads).toHaveLength(2);
-    expect(calcPass.writes).toContain('ssaoRaw');
-    expect(calcPass.writes).toHaveLength(1);
-  });
-
-  it('(c) ssao-blur reads ssaoRaw, writes ssaoBlurred', () => {
-    const runtime = mockRuntime();
-    const ctx = mockCtx(runtime);
-    const graph = new RenderGraph<RenderPipelineContext>();
-    setupGraph(graph);
-
-    addSsaoPasses(graph, {
-      gbuf0: 'gbuf0',
-      hdrDepth: 'hdrDepth',
-      ssaoRaw: 'ssaoRaw',
-      ssaoBlurred: 'ssaoBlurred',
-      ctx,
-    });
-
-    const passes = graph.listPasses();
-    const blurPass = passes.find((p) => p.name === 'ssao-blur');
-    expect(blurPass).toBeDefined();
-    if (!blurPass) return;
-
-    expect(blurPass.reads).toContain('ssaoRaw');
-    expect(blurPass.writes).toContain('ssaoBlurred');
-    expect(blurPass.writes).toHaveLength(1);
-  });
-
-  it('(d) graph compiles with valid caps + producer g-buffer pass', () => {
-    const runtime = mockRuntime();
-    const ctx = mockCtx(runtime);
-    const graph = new RenderGraph<RenderPipelineContext>();
-    setupGraph(graph);
-
-    // Producer pass: g-buffer writes gbuf0 + hdrDepth so ssao-calc's reads
-    // have a valid writer (compile dangling-read validation).
-    graph.addPass('g-buffer', {
-      reads: [],
-      writes: ['gbuf0', 'hdrDepth'],
-    });
-
-    addSsaoPasses(graph, {
-      gbuf0: 'gbuf0',
-      hdrDepth: 'hdrDepth',
-      ssaoRaw: 'ssaoRaw',
-      ssaoBlurred: 'ssaoBlurred',
-      ctx,
-    });
-
-    // Verify the compile succeeds (proves topology + resources are valid)
-    const compileResult = graph.compile({
-      backendKind: runtime.device.caps.backendKind,
-      caps: runtime.device.caps,
-      device: runtime.device,
-    });
-    expect(compileResult.ok).toBe(true);
-  });
-
-  it('(e) ssao-calc comes before ssao-blur in topological order', () => {
-    const runtime = mockRuntime();
-    const ctx = mockCtx(runtime);
-    const graph = new RenderGraph<RenderPipelineContext>();
-    setupGraph(graph);
-
-    addSsaoPasses(graph, {
-      gbuf0: 'gbuf0',
-      hdrDepth: 'hdrDepth',
-      ssaoRaw: 'ssaoRaw',
-      ssaoBlurred: 'ssaoBlurred',
-      ctx,
-    });
+} from '../../../render/src/record/skybox-post-pass';
+import type { RenderPipelineContext } from '../../../render/src/render-contract';
+import {
+  recordSsaoBlurPass,
+  recordSsaoCalcPass,
+} from '../../../render/src/render-graph-primitives';
+import type {
+  _InternalRenderPipelineContext,
+  RenderSystemRuntime,
+} from '../../../render/src/render-system';
 
-    const passes = graph.listPasses();
-    const calcIdx = passes.findIndex((p) => p.name === 'ssao-calc');
-    const blurIdx = passes.findIndex((p) => p.name === 'ssao-blur');
-    expect(calcIdx).toBeGreaterThanOrEqual(0);
-    expect(blurIdx).toBeGreaterThanOrEqual(0);
-    // calc must come before blur (calc writes ssaoRaw, blur reads ssaoRaw)
-    expect(calcIdx).toBeLessThan(blurIdx);
-  });
-});
 // ── M8 / w35-w36-w46 GPU dispatch + intensity write RED tests ───────────────
 //
 // plan-strategy §D-A: record closures must call setPipeline + setBindGroup + draw(3,1,0,0).
@@ -516,6 +276,37 @@ function setupGraphForDispatch(graph: RenderGraph<RenderPipelineContext>): void
   });
 }
 
+function addSsaoRecordPasses(
+  graph: RenderGraph<RenderPipelineContext>,
+  _ctx: RenderPipelineContext,
+): void {
+  graph.addPass('ssao-calc', {
+    reads: ['gbuf0', 'hdrDepth'],
+    writes: ['ssaoRaw'],
+    execute: (c, resolveCtx) =>
+      recordSsaoCalcPass(
+        c as _InternalRenderPipelineContext,
+        resolveCtx,
+        'ssaoRaw',
+        'gbuf0',
+        'hdrDepth',
+      ),
+  });
+  graph.addPass('ssao-blur', {
+    reads: ['ssaoRaw', 'gbuf0', 'hdrDepth'],
+    writes: ['ssaoBlurred'],
+    execute: (c, resolveCtx) =>
+      recordSsaoBlurPass(
+        c as _InternalRenderPipelineContext,
+        resolveCtx,
+        'ssaoBlurred',
+        'ssaoRaw',
+        'gbuf0',
+        'hdrDepth',
+      ),
+  });
+}
+
 describe('recordSsaoCalcPass GPU dispatch (M8 / w35 — RED)', () => {
   it('(g) recordSsaoCalcPass calls setPipeline(ssaoCalcPipeline) once per frame', () => {
     const calcPipeline = { __label: 'ssao-calc-pipeline' };
@@ -523,13 +314,7 @@ describe('recordSsaoCalcPass GPU dispatch (M8 / w35 — RED)', () => {
 
     const graph = new RenderGraph<RenderPipelineContext>();
     setupGraphForDispatch(graph);
-    addSsaoPasses(graph, {
-      gbuf0: 'gbuf0',
-      hdrDepth: 'hdrDepth',
-      ssaoRaw: 'ssaoRaw',
-      ssaoBlurred: 'ssaoBlurred',
-      ctx,
-    });
+    addSsaoRecordPasses(graph, ctx);
 
     const execute = findPassExecute(graph, 'ssao-calc');
     expect(execute).toBeDefined();
@@ -558,13 +343,7 @@ describe('recordSsaoCalcPass GPU dispatch (M8 / w35 — RED)', () => {
 
     const graph = new RenderGraph<RenderPipelineContext>();
     setupGraphForDispatch(graph);
-    addSsaoPasses(graph, {
-      gbuf0: 'gbuf0',
-      hdrDepth: 'hdrDepth',
-      ssaoRaw: 'ssaoRaw',
-      ssaoBlurred: 'ssaoBlurred',
-      ctx,
-    });
+    addSsaoRecordPasses(graph, ctx);
 
     const execute = findPassExecute(graph, 'ssao-calc');
     if (!execute) return;
@@ -599,13 +378,7 @@ describe('recordSsaoCalcPass GPU dispatch (M8 / w35 — RED)', () => {
 
     const graph = new RenderGraph<RenderPipelineContext>();
     setupGraphForDispatch(graph);
-    addSsaoPasses(graph, {
-      gbuf0: 'gbuf0',
-      hdrDepth: 'hdrDepth',
-      ssaoRaw: 'ssaoRaw',
-      ssaoBlurred: 'ssaoBlurred',
-      ctx,
-    });
+    addSsaoRecordPasses(graph, ctx);
 
     const execute = findPassExecute(graph, 'ssao-calc');
     if (!execute) return;
@@ -638,13 +411,7 @@ describe('recordSsaoCalcPass GPU dispatch (M8 / w35 — RED)', () => {
 
     const graph = new RenderGraph<RenderPipelineContext>();
     setupGraphForDispatch(graph);
-    addSsaoPasses(graph, {
-      gbuf0: 'gbuf0',
-      hdrDepth: 'hdrDepth',
-      ssaoRaw: 'ssaoRaw',
-      ssaoBlurred: 'ssaoBlurred',
-      ctx,
-    });
+    addSsaoRecordPasses(graph, ctx);
 
     const execute = findPassExecute(graph, 'ssao-calc');
     if (!execute) return;
@@ -672,13 +439,7 @@ describe('recordSsaoBlurPass GPU dispatch + ssaoRaw input (M8 / w36 — RED)', (
 
     const graph = new RenderGraph<RenderPipelineContext>();
     setupGraphForDispatch(graph);
-    addSsaoPasses(graph, {
-      gbuf0: 'gbuf0',
-      hdrDepth: 'hdrDepth',
-      ssaoRaw: 'ssaoRaw',
-      ssaoBlurred: 'ssaoBlurred',
-      ctx,
-    });
+    addSsaoRecordPasses(graph, ctx);
 
     const execute = findPassExecute(graph, 'ssao-blur');
     if (!execute) return;
@@ -709,13 +470,7 @@ describe('recordSsaoBlurPass GPU dispatch + ssaoRaw input (M8 / w36 — RED)', (
 
     const graph = new RenderGraph<RenderPipelineContext>();
     setupGraphForDispatch(graph);
-    addSsaoPasses(graph, {
-      gbuf0: 'gbuf0',
-      hdrDepth: 'hdrDepth',
-      ssaoRaw: 'ssaoRaw',
-      ssaoBlurred: 'ssaoBlurred',
-      ctx,
-    });
+    addSsaoRecordPasses(graph, ctx);
 
     const execute = findPassExecute(graph, 'ssao-blur');
     if (!execute) return;
@@ -746,13 +501,7 @@ describe('recordSsaoBlurPass GPU dispatch + ssaoRaw input (M8 / w36 — RED)', (
 
     const graph = new RenderGraph<RenderPipelineContext>();
     setupGraphForDispatch(graph);
-    addSsaoPasses(graph, {
-      gbuf0: 'gbuf0',
-      hdrDepth: 'hdrDepth',
-      ssaoRaw: 'ssaoRaw',
-      ssaoBlurred: 'ssaoBlurred',
-      ctx,
-    });
+    addSsaoRecordPasses(graph, ctx);
 
     const execute = findPassExecute(graph, 'ssao-blur');
     if (!execute) return;
@@ -791,13 +540,7 @@ describe('recordSsaoBlurPass GPU dispatch + ssaoRaw input (M8 / w36 — RED)', (
 
     const graph = new RenderGraph<RenderPipelineContext>();
     setupGraphForDispatch(graph);
-    addSsaoPasses(graph, {
-      gbuf0: 'gbuf0',
-      hdrDepth: 'hdrDepth',
-      ssaoRaw: 'ssaoRaw',
-      ssaoBlurred: 'ssaoBlurred',
-      ctx,
-    });
+    addSsaoRecordPasses(graph, ctx);
 
     const execute = findPassExecute(graph, 'ssao-blur');
     if (!execute) return;
@@ -835,13 +578,7 @@ describe('recordSsaoCalcPass per-frame intensity write (M8 / w46 — RED)', () =
 
     const graph = new RenderGraph<RenderPipelineContext>();
     setupGraphForDispatch(graph);
-    addSsaoPasses(graph, {
-      gbuf0: 'gbuf0',
-      hdrDepth: 'hdrDepth',
-      ssaoRaw: 'ssaoRaw',
-      ssaoBlurred: 'ssaoBlurred',
-      ctx,
-    });
+    addSsaoRecordPasses(graph, ctx);
 
     const execute = findPassExecute(graph, 'ssao-calc');
     if (!execute) return;
@@ -868,68 +605,21 @@ describe('recordSsaoCalcPass per-frame intensity write (M8 / w46 — RED)', () =
       (ssaoUniformWrites[0]?.data as Float32Array).byteOffset,
       64,
     );
-    // intensityPad starts at float index 48 (offset 192). x/y/z carry the
-    // default intensity/radius/bias and w remains padding.
+    // intensityPad starts at float index 48 (offset 192). The spy supplies
+    // only enabled+intensity, so the parameter authority contributes the
+    // documented radius/bias defaults.
     expect(data[48]).toBe(1.0);
     expect(data[49]).toBe(0.5);
-    expect(data[50]).toBeCloseTo(0.025, 5);
+    expect(data[50]).toBeCloseTo(0.025, 6);
     expect(data[51]).toBe(0);
   });
 
-  it('(o2) calc pass carries explicit radius and bias through the uniform', () => {
-    const { ctx, spy } = makeDispatchSpyCtx();
-
-    const graph = new RenderGraph<RenderPipelineContext>();
-    setupGraphForDispatch(graph);
-    addSsaoPasses(graph, {
-      gbuf0: 'gbuf0',
-      hdrDepth: 'hdrDepth',
-      ssaoRaw: 'ssaoRaw',
-      ssaoBlurred: 'ssaoBlurred',
-      params: { radius: 1.25, bias: 0.75, intensity: 0.4 },
-      ctx,
-    });
-
-    const execute = findPassExecute(graph, 'ssao-calc');
-    if (!execute) return;
-
-    execute(ctx, {
-      resolve: (n: string) =>
-        n === 'ssaoRaw'
-          ? { __label: 'ssaoRawView' }
-          : n === 'gbuf0'
-            ? { __label: 'gbuf0View' }
-            : n === 'hdrDepth'
-              ? { __label: 'hdrDepthView' }
-              : undefined,
-    });
-
-    const writes = spy.writeBufferCalls.filter(
-      (call) => (call.data as ArrayBufferView).byteLength === 256,
-    );
-    expect(writes).toHaveLength(1);
-    const data = new Float32Array(
-      (writes[0]?.data as Float32Array).buffer,
-      (writes[0]?.data as Float32Array).byteOffset,
-      64,
-    );
-    expect(data[48]).toBeCloseTo(0.4, 5);
-    expect(data[49]).toBe(1.25);
-    expect(data[50]).toBe(0.75);
-  });
-
   it('(p) calc pass writeBuffer count is 1 per frame (single 256B transaction)', () => {
     const { ctx, spy } = makeDispatchSpyCtx();
 
     const graph = new RenderGraph<RenderPipelineContext>();
     setupGraphForDispatch(graph);
-    addSsaoPasses(graph, {
-      gbuf0: 'gbuf0',
-      hdrDepth: 'hdrDepth',
-      ssaoRaw: 'ssaoRaw',
-      ssaoBlurred: 'ssaoBlurred',
-      ctx,
-    });
+    addSsaoRecordPasses(graph, ctx);
 
     const execute = findPassExecute(graph, 'ssao-calc');
     if (!execute) return;
@@ -1122,13 +812,7 @@ describe('bindgroup resize invalidation (R-BGCACHE)', () => {
     const { ctx, spy } = makeDispatchSpyCtx();
     const graph = new RenderGraph<RenderPipelineContext>();
     setupGraphForDispatch(graph);
-    addSsaoPasses(graph, {
-      gbuf0: 'gbuf0',
-      hdrDepth: 'hdrDepth',
-      ssaoRaw: 'ssaoRaw',
-      ssaoBlurred: 'ssaoBlurred',
-      ctx,
-    });
+    addSsaoRecordPasses(graph, ctx);
     const execute = findPassExecute(graph, 'ssao-calc');
     if (!execute) throw new Error('ssao-calc pass missing');
 
@@ -1164,13 +848,7 @@ describe('bindgroup resize invalidation (R-BGCACHE)', () => {
     const { ctx, spy } = makeDispatchSpyCtx();
     const graph = new RenderGraph<RenderPipelineContext>();
     setupGraphForDispatch(graph);
-    addSsaoPasses(graph, {
-      gbuf0: 'gbuf0',
-      hdrDepth: 'hdrDepth',
-      ssaoRaw: 'ssaoRaw',
-      ssaoBlurred: 'ssaoBlurred',
-      ctx,
-    });
+    addSsaoRecordPasses(graph, ctx);
     const execute = findPassExecute(graph, 'ssao-calc');
     if (!execute) throw new Error('ssao-calc pass missing');
 
@@ -1193,13 +871,7 @@ describe('bindgroup resize invalidation (R-BGCACHE)', () => {
     const { ctx, spy } = makeDispatchSpyCtx();
     const graph = new RenderGraph<RenderPipelineContext>();
     setupGraphForDispatch(graph);
-    addSsaoPasses(graph, {
-      gbuf0: 'gbuf0',
-      hdrDepth: 'hdrDepth',
-      ssaoRaw: 'ssaoRaw',
-      ssaoBlurred: 'ssaoBlurred',
-      ctx,
-    });
+    addSsaoRecordPasses(graph, ctx);
     const execute = findPassExecute(graph, 'ssao-blur');
     if (!execute) throw new Error('ssao-blur pass missing');
 

package/src/__tests__/ssao-pipelines.test.ts

@@ -107,7 +107,7 @@ describe('SSAO RenderPipeline PSO descriptor assertions (w24 — RED)', () => {
 
   it('(g1) renderer BGL keeps the kernel binding uniform', () => {
     const factory = readFileSync(
-      fileURLToPath(new URL('../../../render/src/renderer/renderer-factory.ts', import.meta.url)),
+      fileURLToPath(new URL('../../../render/src/assembly/factory.ts', import.meta.url)),
       'utf8',
     );
     const ssaoBgl = factory.slice(factory.indexOf("label: 'ssao-bgl'"));

package/src/__tests__/ssao-uniform-layout.test.ts

@@ -5,16 +5,18 @@
 //  - view matrix at offsets 0..15 (float indices).
 //  - projection matrix at offsets 16..31.
 //  - inverseProjection matrix at offsets 32..47.
-//  - intensityPad vec4 at offsets 48..51 (x = intensity, y = radius,
-//    z = bias, w = padding).
+//  - intensityPad vec4 at offsets 48..51 (x = intensity, y = radius, z = bias, w = padding).
 //  - Matches plan-strategy D-1 + D-C: host write order aligns with WGSL
 //    struct declaration; intensity scalar carried at end of UBO.
 //  - SSAO uniform is separate from View UBO (plan-strategy D-1 invariant).
 //
 // AC-03 anchor: uniform byte-layout matches WGSL struct.
 
-import { SSAO_UNIFORM_BYTES, SSAO_UNIFORM_INTENSITY_OFFSET } from '@forgeax/engine-render/internal';
 import { describe, expect, it } from 'vitest';
+import {
+  SSAO_UNIFORM_BYTES,
+  SSAO_UNIFORM_INTENSITY_OFFSET,
+} from '../../../render/src/ssao-buffers';
 
 const FLOATS_PER_MAT4 = 16;
 const MAT4_COUNT = 3;
@@ -147,16 +149,16 @@ describe('SSAO uniform layout', () => {
     expect(SSAO_UNIFORM_INTENSITY_OFFSET / 4).toBe(INTENSITY_PAD_OFFSET);
   });
 
-  it('w30 — intensity/radius/bias write reads back from one vec4', () => {
+  it('w30 — intensity write 1.0 reads back 1.0', () => {
     const payload = new Float32Array(64); // 256 bytes
     payload[INTENSITY_PAD_OFFSET] = 1.0;
     payload[INTENSITY_PAD_OFFSET + 1] = 0.5;
     payload[INTENSITY_PAD_OFFSET + 2] = 0.025;
+    // The vec4 padding must not bleed into the matrices.
     payload[INTENSITY_PAD_OFFSET + 3] = 0;
     expect(payload[INTENSITY_PAD_OFFSET]).toBe(1.0);
     expect(payload[INTENSITY_PAD_OFFSET + 1]).toBe(0.5);
-    expect(payload[INTENSITY_PAD_OFFSET + 2]).toBeCloseTo(0.025, 5);
-    expect(payload[INTENSITY_PAD_OFFSET + 3]).toBe(0);
+    expect(payload[INTENSITY_PAD_OFFSET + 2]).toBeCloseTo(0.025, 6);
     expect(payload.byteLength).toBe(256);
   });