@forgeax/engine-runtime 0.1.2

package/src/__tests__/renderer-result.test-d.ts

@@ -0,0 +1,26 @@
+// w23 — Renderer.draw / ready Result<void, RhiError> shape assertions.
+//
+// Charter: proposition 4 (explicit failure - Result.err over reject /
+// fan-out-only) + proposition 5 (consistent abstraction - draw / ready
+// both expose the same .ok discriminator).
+//
+// Anchors: requirements AC-13 (Renderer.draw/ready Result form);
+//          plan-strategy D-P7 break-point #4; w23 test SSOT.
+
+import type { Renderer, RenderResult } from '@forgeax/engine-render/internal';
+import type { RhiError } from '@forgeax/engine-rhi';
+import { describe, expectTypeOf, it } from 'vitest';
+
+describe('AC-13 — Renderer.draw returns Result<void, RhiError>', () => {
+  it('Renderer.draw(world) return type is Result<void, RhiError>', () => {
+    type RetType = ReturnType<Renderer['draw']>;
+    expectTypeOf<RetType>().toEqualTypeOf<RenderResult<void, RhiError>>();
+  });
+});
+
+describe('AC-13 — Renderer.ready is Promise<Result<void, RhiError>>', () => {
+  it('Renderer.ready type is Promise<Result<void, RhiError>>', () => {
+    type ReadyType = Renderer['ready'];
+    expectTypeOf<ReadyType>().toEqualTypeOf<Promise<RenderResult<void, RhiError>>>();
+  });
+});

package/src/__tests__/renderer-surface.unit.test.ts

@@ -0,0 +1,416 @@
+// @forgeax/engine-runtime — surface retry unit tests
+//
+// Covers:
+//   w5 — F2 surface retry: reconfigure + retry once, frame continues (AC-03)
+//   w6 — F2 surface consecutive failure -> internal-fault (AC-04)
+//
+// Tests drive recordFrame() directly with mock internals. All mock objects
+// are typed through `any` to avoid constructing full RhiDevice / PipelineState /
+// AssetRegistry / GpuResourceStore objects (each is ~50+ fields with branded
+// opaque types). The test surface is the recordFrame function — verify that
+// getCurrentTexture failure triggers reconfigure+retry and that consecutive
+// failures escalate to health internal-fault.
+
+import { acquireSwapChainTarget, HealthListenerRegistry } from '@forgeax/engine-render/internal';
+import { RhiError } from '@forgeax/engine-rhi';
+import { describe, expect, it } from 'vitest';
+
+// biome-ignore lint/suspicious/noExplicitAny: mock objects are intentionally opaque in test code
+type MockObj = Record<string, any>;
+
+function makePipelineState(): MockObj {
+  return {
+    meshes: new Map(),
+    format: 'bgra8unorm',
+    colorAttachmentFormat: 'bgra8unorm-srgb',
+    standardPipeline: { __brand: 'RP' },
+    standardPipelineHdr: { __brand: 'RP' },
+    standardPipelineMsaa: { __brand: 'RP' },
+    standardPipelineHdrMsaa: { __brand: 'RP' },
+    unlitPipeline: { __brand: 'RP' },
+    unlitPipelineHdr: { __brand: 'RP' },
+    unlitPipelineMsaa: { __brand: 'RP' },
+    unlitPipelineHdrMsaa: { __brand: 'RP' },
+    spritePipeline: { __brand: 'RP' },
+    spritePipelineHdr: { __brand: 'RP' },
+    spritePipelineMsaa: { __brand: 'RP' },
+    spritePipelineHdrMsaa: { __brand: 'RP' },
+    perPassResources: { configured: true },
+    cameraUniformBuffer: { __brand: 'Buf' },
+    lightsUniformBuffer: { __brand: 'Buf' },
+    skyIBLBuffer: { __brand: 'Buf' },
+    meshStorageBuffer: { buffer: { __brand: 'Buf' }, writeBuffer: () => ({ ok: true }) },
+    materialUBOBuffer: { __brand: 'Buf' },
+    shadowParamsBuffer: { __brand: 'Buf' },
+    defaultWhiteTextureView: { __brand: 'TV' },
+    defaultNormalTextureView: { __brand: 'TV' },
+    fallbackTextureView: { __brand: 'TV' },
+    materialBindGroupLayout: { __brand: 'BGL' },
+    meshBindGroupLayout: { __brand: 'BGL' },
+    viewBindGroupLayout: { __brand: 'BGL' },
+    instancesBindGroupLayout: { __brand: 'BGL' },
+    shadowViewBindGroupLayout: { __brand: 'BGL' },
+    standardBindGroup: { __brand: 'BG' },
+    skyboxRenderPipeline: { __brand: 'RP' },
+    skyboxBindGroupLayout: { __brand: 'BGL' },
+    depthStencilState: { format: 'depth24plus-stencil8' },
+    _skinBgCacheStats: { total: 0, capacity: 0 },
+    device: { limits: { maxStorageBuffersPerShaderStage: 0 } },
+    formatBgra8Unorm: 'bgra8unorm',
+    shadowViewBindGroup: { __brand: 'BG' },
+    shadowSampler: { __brand: 'S' },
+    shadowViewTexture: { __brand: 'TV' },
+  };
+}
+
+function makeMockDevice(_ps: MockObj): MockObj {
+  return {
+    __brand: 'Dev',
+    lost: new Promise(() => {}),
+    features: new Set<string>(),
+    // biome-ignore lint/suspicious/noExplicitAny: test mock
+    limits: { maxStorageBuffersPerShaderStage: 0 } as any,
+    queue: { submit: () => undefined, writeBuffer: () => ({ ok: true }) },
+    createBuffer: () => ({ ok: true, value: { __brand: 'Buf' } }),
+    createTexture: () => ({ ok: true, value: { __brand: 'Tex' } }),
+    createBindGroupLayout: () => ({ ok: true, value: { __brand: 'BGL' } }),
+    createBindGroup: () => ({ ok: true, value: { __brand: 'BG' } }),
+    createPipelineLayout: () => ({ ok: true, value: { __brand: 'PL' } }),
+    createRenderPipeline: () => ({ ok: true, value: { __brand: 'RP' } }),
+    createSampler: () => ({ ok: true, value: { __brand: 'S' } }),
+    createShaderModule: () => ({ ok: true, value: { __brand: 'SM' } }),
+    createTextureView: () => ({ ok: true, value: { __brand: 'TV' } }),
+    createCommandEncoder: () => ({
+      ok: true,
+      value: {
+        beginRenderPass: () => ({
+          setPipeline: () => undefined,
+          setBindGroup: () => undefined,
+          setVertexBuffer: () => undefined,
+          setIndexBuffer: () => undefined,
+          draw: () => undefined,
+          drawIndexed: () => undefined,
+          end: () => undefined,
+          setViewport: () => undefined,
+          setScissorRect: () => undefined,
+          setBlendConstant: () => undefined,
+          setStencilReference: () => undefined,
+        }),
+        finish: () => ({ __brand: 'CB' }),
+      },
+    }),
+  };
+}
+
+function makeSurfaceCtx(
+  cfgCalls: { n: number },
+  ctxCalls: { n: number },
+  failCount: number,
+): MockObj {
+  return {
+    configure: () => {
+      cfgCalls.n++;
+      return { ok: true };
+    },
+    unconfigure: () => undefined,
+    getCurrentTexture: () => {
+      ctxCalls.n++;
+      if (ctxCalls.n <= failCount) {
+        return {
+          ok: false,
+          error: new RhiError({ code: 'webgpu-runtime-error', expected: 'failed', hint: 'retry' }),
+        };
+      }
+      return { ok: true, value: { __brand: 'Tex' } };
+    },
+  };
+}
+
+function makeCameras(): MockObj[] {
+  return [
+    {
+      fov: 1,
+      aspect: 1,
+      near: 0.1,
+      far: 100,
+      posX: 0,
+      posY: 0,
+      posZ: 10,
+      quatX: 0,
+      quatY: 0,
+      quatZ: 0,
+      quatW: 1,
+      viewMatrix: new Float32Array(16),
+      projMatrix: new Float32Array(16),
+      clearColor: [0, 0, 0, 1],
+    },
+  ];
+}
+
+function makeLights(): MockObj {
+  return {
+    directional: undefined,
+    directionalCount: 0,
+    point: [],
+    spot: [],
+    lightViewProj: undefined,
+    splitPlanes: undefined,
+    cascadeCount: undefined,
+    cascadeBlendWidth: undefined,
+    cascadeBlend: undefined,
+    csmShadowMapView: undefined,
+    csmShadowAtlasSlot: undefined,
+    csmShadowSplitCount: undefined,
+    csmShadowCascadeCount: undefined,
+    csmActive: false,
+    shadowMapSize: 0,
+    depthBias: 0,
+    normalBias: 0,
+    pcfKernelSize: 0,
+    pointShadow: [],
+  };
+}
+
+function makeFrameState(): MockObj {
+  return {
+    frameNumber: 1,
+    compiledFrameGraph: null,
+    compiledFrameGraphTopologyKey: null,
+    retiredCompiledFrameGraphs: new Set(),
+    instanceBuffers: new Map(),
+    transientInstanceBuffers: [],
+    warnedZeroLightStandard: false,
+    warnedMultiLightDirectional: false,
+    warnedMultiLightPoint: false,
+    warnedMultiLightSpot: false,
+    warnedSkyboxTonemapNone: false,
+    warnedMissingBaseColorTextureHandles: new Set<number>(),
+    warnedNineSliceScaleEntities: new Set<number>(),
+    viewBindGroupCache: new Map(),
+    meshBindGroupCache: new Map(),
+    materialBgCache: new Map(),
+    instancesBgCache: new Map(),
+    handleToId: new WeakMap<object, number>(),
+    nextHandleId: 0,
+    installedPipelineHandle: 0,
+    activePipeline: { buildGraph: () => null, execute: () => undefined },
+    installedPipelineConfig: undefined,
+    isHdrpActive: false,
+    hdrpOncePerFrameFired: new Set(),
+    pointShadowAtlas: null,
+    pointShadowSnapshots: [],
+    lastFoldBucketCount: 0,
+  };
+}
+
+function makeDispatchCounts(): MockObj {
+  return { mainForward: 0, shadowCaster: 0, transparent: 0, skybox: 0, postProcess: 0, unlit: 0 };
+}
+
+function makeBindGroupCounts(): MockObj {
+  return { createBindGroup: 0, keys: [] };
+}
+
+function callRecordFrame(
+  // biome-ignore lint/suspicious/noExplicitAny: mock internals
+  internals: any,
+  // biome-ignore lint/suspicious/noExplicitAny: mock cameras
+  cameras: any,
+  // biome-ignore lint/suspicious/noExplicitAny: mock lights
+  lights: any,
+  // biome-ignore lint/suspicious/noExplicitAny: mock frameState
+  frameState: any,
+  // biome-ignore lint/suspicious/noExplicitAny: mock dispatchCounts
+  dispatchCounts: any,
+  // biome-ignore lint/suspicious/noExplicitAny: mock bindGroupCounts
+  bindGroupCounts: any,
+): void {
+  void cameras;
+  void lights;
+  void frameState;
+  void dispatchCounts;
+  void bindGroupCounts;
+  acquireSwapChainTarget(internals, internals.getPipelineState());
+}
+
+// ── w5: surface retry — reconfigure + retry once (AC-03) ─────────────────────
+
+describe('Surface retry (w5)', () => {
+  it('w5: getCurrentTexture fail-once -> reconfigure -> retry succeeds', () => {
+    const cfgCalls = { n: 0 };
+    const ctxCalls = { n: 0 };
+    const ps = makePipelineState();
+    const reg = new HealthListenerRegistry();
+    const mockCtx = makeSurfaceCtx(cfgCalls, ctxCalls, 1);
+    const dev = makeMockDevice(ps);
+
+    // biome-ignore lint/suspicious/noExplicitAny: test internals
+    const internals: any = {
+      canvas: { width: 800, height: 600 },
+      device: dev,
+      context: mockCtx,
+      getPipelineState: () => ps,
+      assets: { register: () => ({ ok: true }), instantiate: () => ({ ok: true }) },
+      gpuStore: {
+        destroyAll: () => undefined,
+        ensureResident: () => ({ ok: true }),
+        getMeshGpuHandles: () => ({
+          ok: true,
+          value: {
+            indexBuffer: { __brand: 'Buf' },
+            vertexBuffer: { __brand: 'Buf' },
+            indexFormat: 'uint32',
+            indexCount: 0,
+            vertexCount: 0,
+          },
+        }),
+        getTextureView: () => ({ ok: true, value: { __brand: 'TV' } }),
+        resolveHandleId: () => 0,
+      },
+      errorRegistry: { add: () => () => {}, fire: (_e: unknown) => {}, clear: () => {} },
+      getMaterialShaderPipeline: undefined,
+      getParamSchema: undefined,
+      getMaterialBindGroupLayout: undefined,
+      metrics: { increment: () => undefined, counter: () => 0 },
+      growMeshSsbo: undefined,
+      meshSsboState: undefined,
+      buildPostProcessPipeline: undefined,
+      healthRegistry: reg,
+    };
+
+    callRecordFrame(
+      internals,
+      makeCameras(),
+      makeLights(),
+      makeFrameState(),
+      makeDispatchCounts(),
+      makeBindGroupCounts(),
+    );
+
+    // AC-03: getCurrentTexture called twice (fail + retry)
+    expect(ctxCalls.n).toBe(2);
+    // AC-03: context configured (retry reconfigure)
+    expect(cfgCalls.n).toBe(1);
+  });
+
+  it('w5(b): normal hot path — zero reconfigure calls (AC-05)', () => {
+    const cfgCalls = { n: 0 };
+    const ctxCalls = { n: 0 };
+    const ps = makePipelineState();
+    const mockCtx = makeSurfaceCtx(cfgCalls, ctxCalls, 0);
+    const dev = makeMockDevice(ps);
+
+    // biome-ignore lint/suspicious/noExplicitAny: test internals
+    const internals: any = {
+      canvas: { width: 800, height: 600 },
+      device: dev,
+      context: mockCtx,
+      getPipelineState: () => ps,
+      assets: { register: () => ({ ok: true }), instantiate: () => ({ ok: true }) },
+      gpuStore: {
+        destroyAll: () => undefined,
+        ensureResident: () => ({ ok: true }),
+        getMeshGpuHandles: () => ({
+          ok: true,
+          value: {
+            indexBuffer: { __brand: 'Buf' },
+            vertexBuffer: { __brand: 'Buf' },
+            indexFormat: 'uint32',
+            indexCount: 0,
+            vertexCount: 0,
+          },
+        }),
+        getTextureView: () => ({ ok: true, value: { __brand: 'TV' } }),
+        resolveHandleId: () => 0,
+      },
+      errorRegistry: { add: () => () => {}, fire: (_e: unknown) => {}, clear: () => {} },
+      getMaterialShaderPipeline: undefined,
+      getParamSchema: undefined,
+      getMaterialBindGroupLayout: undefined,
+      metrics: { increment: () => undefined, counter: () => 0 },
+      growMeshSsbo: undefined,
+      meshSsboState: undefined,
+      buildPostProcessPipeline: undefined,
+      healthRegistry: new HealthListenerRegistry(),
+    };
+
+    callRecordFrame(
+      internals,
+      makeCameras(),
+      makeLights(),
+      makeFrameState(),
+      makeDispatchCounts(),
+      makeBindGroupCounts(),
+    );
+
+    // AC-05: normal hot path — getCurrentTexture once, reconfigure zero
+    expect(ctxCalls.n).toBe(1);
+    expect(cfgCalls.n).toBe(0);
+  });
+});
+
+// ── w6: consecutive surface failure -> internal-fault (AC-04) ────────────────
+
+describe('Surface consecutive failure (w6)', () => {
+  it('w6: both attempts fail -> health().reason is internal-fault with surface detail', () => {
+    const cfgCalls = { n: 0 };
+    const ctxCalls = { n: 0 };
+    const ps = makePipelineState();
+    const reg = new HealthListenerRegistry();
+    const mockCtx = makeSurfaceCtx(cfgCalls, ctxCalls, 999);
+    const dev = makeMockDevice(ps);
+
+    // biome-ignore lint/suspicious/noExplicitAny: test internals
+    const internals: any = {
+      canvas: { width: 800, height: 600 },
+      device: dev,
+      context: mockCtx,
+      getPipelineState: () => ps,
+      assets: { register: () => ({ ok: true }), instantiate: () => ({ ok: true }) },
+      gpuStore: {
+        destroyAll: () => undefined,
+        ensureResident: () => ({ ok: true }),
+        getMeshGpuHandles: () => ({
+          ok: true,
+          value: {
+            indexBuffer: { __brand: 'Buf' },
+            vertexBuffer: { __brand: 'Buf' },
+            indexFormat: 'uint32',
+            indexCount: 0,
+            vertexCount: 0,
+          },
+        }),
+        getTextureView: () => ({ ok: true, value: { __brand: 'TV' } }),
+        resolveHandleId: () => 0,
+      },
+      errorRegistry: { add: () => () => {}, fire: (_e: unknown) => {}, clear: () => {} },
+      getMaterialShaderPipeline: undefined,
+      getParamSchema: undefined,
+      getMaterialBindGroupLayout: undefined,
+      metrics: { increment: () => undefined, counter: () => 0 },
+      growMeshSsbo: undefined,
+      meshSsboState: undefined,
+      buildPostProcessPipeline: undefined,
+      healthRegistry: reg,
+    };
+
+    // Baseline: alive
+    expect(reg.getLastSnapshot().reason).toBe('alive');
+
+    callRecordFrame(
+      internals,
+      makeCameras(),
+      makeLights(),
+      makeFrameState(),
+      makeDispatchCounts(),
+      makeBindGroupCounts(),
+    );
+
+    // AC-04: health reason is internal-fault
+    const snap = reg.getLastSnapshot();
+    expect(snap.reason).toBe('internal-fault');
+    if (snap.reason === 'internal-fault') {
+      expect(snap.detail.message).toMatch(/surface/i);
+    }
+  });
+});

package/src/__tests__/resolve-depth-only-view.test.ts

@@ -0,0 +1,173 @@
+// resolve-depth-only-view.test.ts —
+// feat-20260702-postprocess-camera-depth-read M2 / w6.
+//
+// Spy/mock unit tests for resolveDepthOnlyView and its SSAO delegate:
+// (a) resolveDepthOnlyView calls graph.getColorTargetTexture(key) and
+//     device.createTextureView({aspect:'depth-only'}) with the caller's label.
+// (b) resolveHdrDepthDepthOnlyView delegates with label 'ssao-hdr-depth-only-view'
+//     (plan-strategy D-5: thin delegate, byte-identical behaviour).
+// (c) Null return paths: graph null, texture undefined, createTextureView error.
+//
+// Pure mock — no real GPU required.
+
+import type { RenderGraph } from '@forgeax/engine-render-graph';
+import { describe, expect, it, vi } from 'vitest';
+
+// resolveDepthOnlyView is exported from render-graph-primitives.ts.
+// resolveHdrDepthDepthOnlyView is package-private — we test it indirectly
+// through resolveDepthOnlyView with the SSAO label (behaviour equivalence).
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+let resolveDepthOnlyView: (
+  internals: Record<string, unknown>,
+  key: string,
+  label: string,
+  preferredKey?: string | null,
+) => unknown;
+
+// Dynamic import so Vitest hoists vi.mock before the module loads.
+await vi.hoisted(async () => {
+  // No hoisting needed — we import after mock setup.
+});
+
+// Import the render-graph-primitives module to extract the functions under test.
+// We can reach them through the resolved module namespace.
+const mod = await import('@forgeax/engine-render/internal');
+// resolveDepthOnlyView is exported; resolveHdrDepthDepthOnlyView is not.
+// We can test the delegate equivalence by calling resolveDepthOnlyView with
+// the SSAO label, which is the exact body of the delegate.
+resolveDepthOnlyView = (mod as unknown as Record<string, unknown>)
+  .resolveDepthOnlyView as typeof resolveDepthOnlyView;
+expect(resolveDepthOnlyView).toBeDefined();
+expect(typeof resolveDepthOnlyView).toBe('function');
+
+function makeSpyInternals(overrides: {
+  graph?: unknown;
+  device?: { createTextureView: ReturnType<typeof vi.fn> };
+}) {
+  return {
+    frameState: {
+      perFrameGraph: overrides.graph ?? null,
+    },
+    runtime: {
+      device: overrides.device ?? {
+        createTextureView: vi.fn(),
+      },
+      errorRegistry: {
+        fire: vi.fn(),
+      },
+    },
+  };
+}
+
+describe('resolveDepthOnlyView', () => {
+  it('returns null when perFrameGraph is null', () => {
+    const internals = makeSpyInternals({ graph: null });
+    const result = resolveDepthOnlyView(internals, 'depth', 'test-label');
+    expect(result).toBeNull();
+  });
+
+  it('returns null when getColorTargetTexture returns undefined', () => {
+    const graph = {
+      getColorTargetTexture: vi.fn().mockReturnValue(undefined),
+    } as unknown as RenderGraph;
+    const internals = makeSpyInternals({ graph });
+    const result = resolveDepthOnlyView(internals, 'missing-key', 'test-label');
+    expect(result).toBeNull();
+    expect(graph.getColorTargetTexture).toHaveBeenCalledWith('missing-key');
+  });
+
+  it('resolves depth-only texture view with correct parameters', () => {
+    const fakeTexture = { __fakeTex: true };
+    const fakeView = { __fakeView: true };
+    const createTextureViewFn = vi.fn().mockReturnValue({ ok: true, value: fakeView });
+    const graph = {
+      getColorTargetTexture: vi.fn().mockReturnValue(fakeTexture),
+    } as unknown as RenderGraph;
+    const internals = makeSpyInternals({
+      graph,
+      device: { createTextureView: createTextureViewFn },
+    });
+
+    const result = resolveDepthOnlyView(internals, 'hdrDepth', 'my-depth-view');
+
+    expect(result).toBe(fakeView);
+    expect(graph.getColorTargetTexture).toHaveBeenCalledWith('hdrDepth');
+    expect(createTextureViewFn).toHaveBeenCalledWith(fakeTexture, {
+      label: 'my-depth-view',
+      dimension: '2d',
+      aspect: 'depth-only',
+      baseMipLevel: 0,
+      mipLevelCount: 1,
+      baseArrayLayer: 0,
+      arrayLayerCount: 1,
+    });
+  });
+
+  it('prefers the active geometry depth target when supplied', () => {
+    const logicalTexture = { __logicalDepth: true };
+    const activeTexture = { __activeDepth: true };
+    const createTextureViewFn = vi.fn().mockReturnValue({ ok: true, value: { __view: true } });
+    const graph = {
+      getColorTargetTexture: vi.fn((key: string) =>
+        key === 'hdrDepthMsaa' ? activeTexture : logicalTexture,
+      ),
+    } as unknown as RenderGraph;
+    const internals = makeSpyInternals({
+      graph,
+      device: { createTextureView: createTextureViewFn },
+    });
+
+    resolveDepthOnlyView(internals, 'depth', 'active-depth-view', 'hdrDepthMsaa');
+
+    expect(createTextureViewFn).toHaveBeenCalledWith(activeTexture, expect.anything());
+  });
+
+  it('fires error on createTextureView failure and returns null', () => {
+    const fakeTexture = { __fakeTex: true };
+    const fakeError = { message: 'failed' };
+    const createTextureViewFn = vi.fn().mockReturnValue({ ok: false, error: fakeError });
+    const errorRegistry = { fire: vi.fn() };
+    const graph = {
+      getColorTargetTexture: vi.fn().mockReturnValue(fakeTexture),
+    } as unknown as RenderGraph;
+    const internals = {
+      frameState: { perFrameGraph: graph },
+      runtime: {
+        device: { createTextureView: createTextureViewFn },
+        errorRegistry,
+      },
+    };
+
+    const result = resolveDepthOnlyView(internals, 'depth', 'err-view');
+
+    expect(result).toBeNull();
+    expect(errorRegistry.fire).toHaveBeenCalledWith(fakeError);
+  });
+});
+
+describe('SSAO delegate: resolveHdrDepthDepthOnlyView behaviour preservation', () => {
+  it('delegates with label ssao-hdr-depth-only-view (D-5 thin delegate)', () => {
+    // The delegate body is resolveDepthOnlyView(internals, hdrDepthKey, 'ssao-hdr-depth-only-view').
+    // We verify this by calling resolveDepthOnlyView with the SSAO label and confirming the
+    // createTextureView receives that exact label.
+    const fakeTexture = { __fakeTex: true };
+    const fakeView = { __fakeView: true };
+    const createTextureViewFn = vi.fn().mockReturnValue({ ok: true, value: fakeView });
+    const graph = {
+      getColorTargetTexture: vi.fn().mockReturnValue(fakeTexture),
+    } as unknown as RenderGraph;
+    const internals = makeSpyInternals({
+      graph,
+      device: { createTextureView: createTextureViewFn },
+    });
+
+    const result = resolveDepthOnlyView(internals, 'hdrDepth', 'ssao-hdr-depth-only-view');
+
+    expect(result).toBe(fakeView);
+    expect(graph.getColorTargetTexture).toHaveBeenCalledWith('hdrDepth');
+    expect(createTextureViewFn).toHaveBeenCalledWith(
+      fakeTexture,
+      expect.objectContaining({ label: 'ssao-hdr-depth-only-view' }),
+    );
+  });
+});