@forgeax/engine-render 0.1.7 → 0.1.20

package/src/transmission/__tests__/standard-transmission.dawn.test.ts

@@ -0,0 +1,437 @@
+import { World } from '@forgeax/engine-ecs';
+import { createPlaneGeometry } from '@forgeax/engine-geometry';
+import {
+  _internal_getRawDevice,
+  createShaderModule,
+  rhi,
+  translateErrorEventToRhiError as translateWebgpuError,
+} from '@forgeax/engine-rhi-webgpu';
+import { Transform } from '@forgeax/engine-scene';
+import type { TextureAsset } from '@forgeax/engine-types';
+import { describe, expect, it } from 'vitest';
+import {
+  Camera,
+  DirectionalLight,
+  MeshFilter,
+  MeshRenderer,
+  TONEMAP_LINEAR,
+} from '../../components';
+import { constructRendererHost, type RhiBackendPack } from '../../construct-renderer';
+import { Materials } from '../../materials';
+import { DEFAULT_STANDARD_PROFILE } from '../../pipeline/standard-profile';
+
+const WIDTH = 32;
+const HEIGHT = 32;
+const TEXTURE_USAGE_COPY_SRC = 0x01;
+const TEXTURE_USAGE_RENDER_ATTACHMENT = 0x10;
+const BUFFER_USAGE_MAP_READ = 0x0001;
+const BUFFER_USAGE_COPY_DST = 0x0008;
+const GPU_MAP_MODE_READ = 0x0001;
+const TEST_REACTIVE = 0;
+
+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),
+)}`;
+const DAWN_BACKEND: RhiBackendPack = {
+  rhi,
+  createShaderModule,
+  _internal_getRawDevice,
+  translateErrorEventToRhiError: translateWebgpuError as NonNullable<
+    RhiBackendPack['translateErrorEventToRhiError']
+  >,
+};
+
+interface TransmissionCase {
+  readonly name: string;
+  readonly transmission: number;
+  readonly ior: number;
+  readonly thickness: number;
+  readonly roughness: number;
+  readonly attenuationColor: readonly [number, number, number];
+  readonly attenuationDistance?: number;
+  readonly transmissionTexture?: number;
+  readonly thicknessTexture?: number;
+  readonly masked?: boolean;
+  readonly overlap?: boolean;
+  readonly lane?: 'direct' | 'clustered';
+  readonly surfaceQuat?: readonly [number, number, number, number];
+}
+
+function textureAsset(value: number): TextureAsset {
+  const channel = Math.round(value * 255);
+  return {
+    kind: 'texture',
+    shape: { viewDimension: '2d', extent: { width: 1, height: 1 } },
+    format: 'rgba8unorm',
+    data: Uint8Array.from([channel, channel, channel, 255]),
+    colorSpace: 'linear',
+    mips: { kind: 'none' },
+  };
+}
+
+async function readCenter(
+  device: GPUDevice,
+  target: GPUTexture,
+): Promise<[number, number, number, number]> {
+  const bytesPerRow = Math.ceil((WIDTH * 4) / 256) * 256;
+  const readback = device.createBuffer({
+    size: bytesPerRow * HEIGHT,
+    usage: BUFFER_USAGE_MAP_READ | BUFFER_USAGE_COPY_DST,
+  });
+  const encoder = device.createCommandEncoder();
+  encoder.copyTextureToBuffer(
+    { texture: target },
+    { buffer: readback, bytesPerRow, rowsPerImage: HEIGHT },
+    { width: WIDTH, height: HEIGHT, depthOrArrayLayers: 1 },
+  );
+  device.queue.submit([encoder.finish()]);
+  await readback.mapAsync(GPU_MAP_MODE_READ);
+  const bytes = new Uint8Array(readback.getMappedRange().slice(0));
+  readback.unmap();
+  readback.destroy();
+  const offset = Math.floor(HEIGHT / 2) * bytesPerRow + Math.floor(WIDTH / 2) * 4;
+  return [
+    bytes[offset] ?? 0,
+    bytes[offset + 1] ?? 0,
+    bytes[offset + 2] ?? 0,
+    bytes[offset + 3] ?? 0,
+  ];
+}
+
+async function renderCase(testCase: TransmissionCase): Promise<{
+  readonly pixel: readonly [number, number, number, number];
+  readonly passNames: readonly string[];
+  readonly observation: boolean;
+}> {
+  let device: GPUDevice | undefined;
+  let configuredDevice: GPUDevice | undefined;
+  let target: GPUTexture | undefined;
+  const originalRequestAdapter = globalThis.navigator.gpu.requestAdapter.bind(
+    globalThis.navigator.gpu,
+  );
+  globalThis.navigator.gpu.requestAdapter = async (options) => {
+    const adapter = await originalRequestAdapter(options);
+    if (adapter === null) return adapter;
+    const requestDevice = adapter.requestDevice.bind(adapter);
+    adapter.requestDevice = async (descriptor) => {
+      const next = await requestDevice(descriptor);
+      device ??= next;
+      return next;
+    };
+    return adapter;
+  };
+  const canvas = {
+    width: WIDTH,
+    height: HEIGHT,
+    getContext(kind: string): unknown {
+      if (kind !== 'webgpu') return null;
+      return {
+        configure(desc: { device: GPUDevice; format?: GPUTextureFormat }) {
+          configuredDevice ??= desc.device;
+          target ??= desc.device.createTexture({
+            size: { width: WIDTH, height: HEIGHT, depthOrArrayLayers: 1 },
+            format: desc.format ?? 'rgba8unorm',
+            usage: TEXTURE_USAGE_COPY_SRC | TEXTURE_USAGE_RENDER_ATTACHMENT,
+            viewFormats: ['rgba8unorm-srgb'],
+          });
+        },
+        unconfigure() {},
+        getCurrentTexture() {
+          if (target === undefined) throw new Error('render target was not configured');
+          return target;
+        },
+      };
+    },
+    addEventListener() {},
+    removeEventListener() {},
+  } as unknown as HTMLCanvasElement;
+
+  let host: Awaited<ReturnType<typeof constructRendererHost>>;
+  try {
+    host = await constructRendererHost(
+      canvas,
+      {
+        standardProfile: {
+          ...DEFAULT_STANDARD_PROFILE,
+          lighting: testCase.lane ?? 'direct',
+        },
+      },
+      { shaderManifestUrl: ENGINE_MANIFEST_URL },
+      DAWN_BACKEND,
+    );
+  } finally {
+    globalThis.navigator.gpu.requestAdapter = originalRequestAdapter;
+  }
+  expect(host.ok).toBe(true);
+  if (!host.ok || device === undefined) {
+    throw new Error('runtime Dawn renderer was not ready');
+  }
+
+  const { renderer } = host.value;
+  const world = new World();
+  const lease = renderer.attach(world);
+  if (!lease.ok) throw lease.error;
+  const plane = createPlaneGeometry(2, 2);
+  if (!plane.ok) throw plane.error;
+  const mesh = world.allocSharedRef('MeshAsset', {
+    ...plane.value,
+    materialSlots: [{ slotName: 'Default' }],
+  });
+  const transmissionHandle =
+    testCase.transmissionTexture === undefined
+      ? undefined
+      : world.allocSharedRef('TextureAsset', textureAsset(testCase.transmissionTexture));
+  const thicknessHandle =
+    testCase.thicknessTexture === undefined
+      ? undefined
+      : world.allocSharedRef('TextureAsset', textureAsset(testCase.thicknessTexture));
+  const material = Materials.standard({
+    baseColor: [0.7, 0.8, 0.9, testCase.masked ? 0.35 : 1],
+    metallic: 0,
+    roughness: testCase.roughness,
+    transmission: testCase.transmission,
+    ior: testCase.ior,
+    thickness: testCase.thickness,
+    attenuationColor: testCase.attenuationColor,
+    castShadow: false,
+    ...(testCase.attenuationDistance === undefined
+      ? {}
+      : { attenuationDistance: testCase.attenuationDistance }),
+    ...(testCase.masked
+      ? {
+          queue: 2450,
+          alphaCutoff: 0.5,
+          baseColorTexture: {
+            texture: world.allocSharedRef('TextureAsset', {
+              kind: 'texture',
+              width: 2,
+              height: 2,
+              format: 'rgba8unorm',
+              data: Uint8Array.from([
+                255, 255, 255, 0, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 0,
+              ]),
+              colorSpace: 'linear',
+              mipmap: false,
+            }),
+          },
+        }
+      : { queue: 2000 }),
+    ...(testCase.surfaceQuat === undefined ? {} : { renderState: { cullMode: 'none' as const } }),
+    ...(transmissionHandle === undefined
+      ? {}
+      : { transmissionTexture: { texture: transmissionHandle as never } }),
+    ...(thicknessHandle === undefined
+      ? {}
+      : { thicknessTexture: { texture: thicknessHandle as never } }),
+  });
+  const materialHandle = world.allocSharedRef('MaterialAsset', material);
+  const meshEntity = world.spawn(
+    {
+      component: Transform,
+      data: testCase.surfaceQuat === undefined ? {} : { quat: testCase.surfaceQuat },
+    },
+    { component: MeshFilter, data: { assetHandle: mesh } },
+    { component: MeshRenderer, data: { materials: [materialHandle] } },
+  );
+  expect(meshEntity.ok, `${testCase.name}: mesh spawn must succeed`).toBe(true);
+  if (!meshEntity.ok) throw meshEntity.error;
+  if (testCase.overlap) {
+    const overlay = Materials.unlit([0.1, 0.9, 0.2, 0.35], {
+      castShadow: false,
+      queue: 3000,
+      renderState: {
+        cullMode: 'none',
+        depthWriteEnabled: false,
+        blend: {
+          color: { srcFactor: 'src-alpha', dstFactor: 'one-minus-src-alpha', operation: 'add' },
+          alpha: { srcFactor: 'one', dstFactor: 'one-minus-src-alpha', operation: 'add' },
+        },
+      },
+    });
+    const overlayHandle = world.allocSharedRef('MaterialAsset', overlay);
+    const overlayEntity = world.spawn(
+      { component: Transform, data: { pos: [0, 0, -0.1] } },
+      { component: MeshFilter, data: { assetHandle: mesh } },
+      { component: MeshRenderer, data: { materials: [overlayHandle] } },
+    );
+    expect(overlayEntity.ok, `${testCase.name}: overlay spawn must succeed`).toBe(true);
+    if (!overlayEntity.ok) throw overlayEntity.error;
+  }
+  const cameraEntity = world.spawn(
+    { component: Transform, data: { pos: [0, 0, 3] } },
+    {
+      component: Camera,
+      data: {
+        fov: Math.PI / 4,
+        aspect: 1,
+        near: 0.1,
+        far: 10,
+        tonemap: TONEMAP_LINEAR,
+        clearColor: [0.05, 0.1, 0.15, 1],
+      },
+    },
+  );
+  expect(cameraEntity.ok, `${testCase.name}: camera spawn must succeed`).toBe(true);
+  if (!cameraEntity.ok) throw cameraEntity.error;
+  const lightEntity = world.spawn({
+    component: DirectionalLight,
+    data: { direction: [0, 0, -1], color: [1, 1, 1], intensity: 1, castShadow: false },
+  });
+  expect(lightEntity.ok, `${testCase.name}: light spawn must succeed`).toBe(true);
+  if (!lightEntity.ok) throw lightEntity.error;
+  world.update().unwrap();
+  const drawn = renderer.draw({
+    leases: [lease.value],
+    camera: { lease: lease.value },
+    environment: { lease: lease.value },
+  });
+  expect(drawn.ok, drawn.ok ? undefined : JSON.stringify(drawn.error)).toBe(true);
+  if (!drawn.ok) throw drawn.error;
+  await drawn.value.completed;
+  const observation = await renderer.observe(drawn.value, { include: ['draws', 'bindings'] });
+  expect(observation.ok).toBe(true);
+  await device.queue.onSubmittedWorkDone();
+  if (target === undefined) throw new Error('render target was not configured after draw');
+  const renderDevice = configuredDevice ?? device;
+  const passNames = renderer.inspect().perFramePassNames;
+  expect(renderer.inspect().renderScene.projectionRecords).toBeGreaterThanOrEqual(1);
+  return {
+    pixel: await readCenter(renderDevice, target),
+    passNames,
+    observation: observation.ok,
+  };
+}
+
+function luma(pixel: readonly [number, number, number, number]): number {
+  return 0.2126 * pixel[0] + 0.7152 * pixel[1] + 0.0722 * pixel[2];
+}
+
+describe('Standard transmission Dawn ROI', () => {
+  it('uses linear HDR observation and responds to F0, Beer, texture, TIR, and fallback inputs', async () => {
+    const baseline = await renderCase({
+      name: 'baseline',
+      transmission: 0,
+      ior: 1.5,
+      thickness: 0,
+      roughness: 0.5,
+      attenuationColor: [1, 1, 1],
+    });
+    const transmitted = await renderCase({
+      name: 'transmitted',
+      transmission: 1,
+      ior: 1.5,
+      thickness: 0.5,
+      roughness: 0.5,
+      attenuationColor: [0.1, 0.4, 0.8],
+      attenuationDistance: 1,
+      transmissionTexture: 1,
+      thicknessTexture: 1,
+    });
+    const tir = await renderCase({
+      name: 'total-internal-reflection',
+      transmission: 1,
+      ior: 1.5,
+      thickness: 0.5,
+      roughness: 0.5,
+      attenuationColor: [0.1, 0.4, 0.8],
+      attenuationDistance: 1,
+      transmissionTexture: 1,
+      thicknessTexture: 1,
+      // Back side at a grazing angle: eta=ior exercises TIR. The old case
+      // duplicated the air-to-glass inputs (eta=1/ior), where TIR is impossible.
+      surfaceQuat: [0, Math.sin((Math.PI * 235) / 360), 0, Math.cos((Math.PI * 235) / 360)],
+    });
+
+    expect(baseline.passNames).not.toContain('transmission-forward');
+    expect(transmitted.passNames).toContain('linear-hdr-observation');
+    expect(transmitted.passNames).toContain('transmission-forward');
+    expect(transmitted.observation).toBe(true);
+    expect(transmitted.pixel.every(Number.isFinite)).toBe(true);
+    expect(transmitted.pixel).not.toEqual(baseline.pixel);
+    expect(tir.pixel).not.toEqual(transmitted.pixel);
+    expect(TEST_REACTIVE).toBe(0);
+  }, 120_000);
+
+  it('keeps IOR, thickness, and roughness monotonic in a finite linear ROI', async () => {
+    const cases = await Promise.all([
+      renderCase({
+        name: 'ior-low',
+        transmission: 1,
+        ior: 1.1,
+        thickness: 0.1,
+        roughness: 0.1,
+        attenuationColor: [0.8, 0.8, 0.8],
+        attenuationDistance: 4,
+      }),
+      renderCase({
+        name: 'ior-high',
+        transmission: 1,
+        ior: 2.2,
+        thickness: 0.1,
+        roughness: 0.1,
+        attenuationColor: [0.8, 0.8, 0.8],
+        attenuationDistance: 4,
+      }),
+      renderCase({
+        name: 'thick',
+        transmission: 1,
+        ior: 1.5,
+        thickness: 1.5,
+        roughness: 0.1,
+        attenuationColor: [0.1, 0.1, 0.1],
+        attenuationDistance: 1,
+      }),
+      renderCase({
+        name: 'rough',
+        transmission: 1,
+        ior: 1.5,
+        thickness: 0.1,
+        roughness: 0.9,
+        attenuationColor: [0.8, 0.8, 0.8],
+        attenuationDistance: 4,
+      }),
+    ]);
+    for (const result of cases) expect(result.pixel.every(Number.isFinite)).toBe(true);
+    expect(cases[1]?.pixel).not.toEqual(cases[0]?.pixel);
+    expect(cases[2]?.pixel).not.toEqual(cases[0]?.pixel);
+    expect(luma(cases[3]?.pixel ?? [0, 0, 0, 0])).toBeLessThanOrEqual(
+      luma(cases[0]?.pixel ?? [0, 0, 0, 0]) + 2,
+    );
+  }, 120_000);
+
+  it('exercises direct/clustered lanes and transmission-before-BLEND overlap order', async () => {
+    const direct = await renderCase({
+      name: 'direct',
+      transmission: 1,
+      ior: 1.5,
+      thickness: 0.5,
+      roughness: 0.3,
+      attenuationColor: [0.7, 0.8, 0.9],
+      attenuationDistance: 2,
+      overlap: true,
+      lane: 'direct',
+    });
+    const clustered = await renderCase({
+      name: 'clustered',
+      transmission: 1,
+      ior: 1.5,
+      thickness: 0.5,
+      roughness: 0.3,
+      attenuationColor: [0.7, 0.8, 0.9],
+      attenuationDistance: 2,
+      overlap: true,
+      lane: 'clustered',
+    });
+    const transmissionIndex = direct.passNames.indexOf('transmission-forward');
+    const transparentIndex = direct.passNames.indexOf('transparent');
+    expect(transmissionIndex).toBeGreaterThanOrEqual(0);
+    expect(transparentIndex).toBeGreaterThan(transmissionIndex);
+    expect(clustered.pixel).not.toEqual(direct.pixel);
+    expect(clustered.pixel.every(Number.isFinite)).toBe(true);
+    expect(direct.pixel.every(Number.isFinite)).toBe(true);
+  }, 120_000);
+});

package/src/transmission/__tests__/transmission-backdrop-topology.unit.test.ts

@@ -0,0 +1,109 @@
+import { RenderGraphBuilder } from '@forgeax/engine-render-graph';
+import { describe, expect, it } from 'vitest';
+import type { RenderPipelineFrame } from '../../render-pipeline';
+import { createRenderPipelineTarget } from '../../render-pipeline';
+import {
+  addTransmissionBackdropPasses,
+  resolveTransmissionBackdropTopology,
+  type TransmissionBackdropTopologyInput,
+} from '../backdrop';
+
+function topology(
+  overrides: Partial<TransmissionBackdropTopologyInput> = {},
+): TransmissionBackdropTopologyInput {
+  return {
+    demand: { activeCount: 1, needsRoughMips: false },
+    sourceSampleCount: 1,
+    ...overrides,
+  };
+}
+
+describe('TransmissionBackdrop typed topology', () => {
+  it('keeps the demand-off path exact zero', () => {
+    expect(
+      resolveTransmissionBackdropTopology({
+        demand: { activeCount: 0, needsRoughMips: false },
+        sourceSampleCount: 4,
+      }),
+    ).toEqual({
+      active: false,
+      sourceSampleCount: 4,
+      copyCount: 0,
+      mipCount: 0,
+      submitCount: 1,
+      aliasCount: 0,
+      phases: [],
+    });
+  });
+
+  it('places one resolved copy before transmission and ordinary transparent work', () => {
+    expect(resolveTransmissionBackdropTopology(topology()).phases).toEqual([
+      'opaque-resolve',
+      'transmission-backdrop-copy',
+      'transmission-forward',
+      'transparent',
+      'temporal',
+    ]);
+    expect(resolveTransmissionBackdropTopology(topology())).toMatchObject({
+      active: true,
+      copyCount: 1,
+      mipCount: 0,
+    });
+  });
+
+  it('adds only shared raster mip work for rough transmission', () => {
+    expect(
+      resolveTransmissionBackdropTopology(
+        topology({ demand: { activeCount: 2, needsRoughMips: true } }),
+      ),
+    ).toMatchObject({
+      active: true,
+      copyCount: 1,
+      mipCount: 1,
+      phases: [
+        'opaque-resolve',
+        'transmission-backdrop-copy',
+        'transmission-backdrop-mip',
+        'transmission-forward',
+        'transparent',
+        'temporal',
+      ],
+    });
+  });
+
+  it('never creates a second submission or aliases the backdrop source', () => {
+    const result = resolveTransmissionBackdropTopology(topology({ sourceSampleCount: 4 }));
+
+    expect(result).toMatchObject({ sourceSampleCount: 4, submitCount: 1, aliasCount: 0 });
+  });
+
+  it('rejects rough mips without a renderer-owned sampling encoder', () => {
+    const graph = new RenderGraphBuilder<RenderPipelineFrame>();
+    const source = createRenderPipelineTarget(graph, 'opaque-resolved', {
+      format: 'rgba16float',
+      size: 'surface',
+    });
+    expect(source.ok).toBe(true);
+    if (!source.ok) return;
+
+    const result = addTransmissionBackdropPasses({
+      graph,
+      source: source.value,
+      demand: { activeCount: 1, needsRoughMips: true },
+      copySize: { width: 8, height: 4 },
+    });
+
+    expect(result.ok).toBe(false);
+    if (result.ok) return;
+    expect(result.error).toMatchObject({
+      code: 'resource-descriptor-invalid',
+      detail: {
+        resourceLabel: 'transmission-backdrop',
+        field: 'roughMipEncoder',
+        actual: 'missing',
+      },
+    });
+    expect(result.error.expected).toContain('fullscreen/downsample owner');
+    expect(result.error.hint).toContain('encodeRoughMip');
+  });
+});

package/src/transmission/__tests__/transmission-backdrop.dawn.test.ts

@@ -0,0 +1,105 @@
+import { RenderGraphBuilder } from '@forgeax/engine-render-graph';
+import type { RhiDevice } from '@forgeax/engine-rhi';
+import { rhi } from '@forgeax/engine-rhi-webgpu';
+import { describe, expect, it } from 'vitest';
+import type { RenderPipelineFrame } from '../../render-pipeline';
+import { createRenderPipelineTarget } from '../../render-pipeline';
+import { addTransmissionBackdropPasses, type TransmissionBackdropGraph } from '../backdrop';
+
+async function buildBackdrop(device: RhiDevice): Promise<TransmissionBackdropGraph> {
+  const graph = new RenderGraphBuilder<RenderPipelineFrame>();
+  const source = createRenderPipelineTarget(graph, 'opaque-resolved', {
+    format: 'rgba16float',
+    size: 'surface',
+    sampleCount: 1,
+  });
+  expect(source.ok).toBe(true);
+  if (!source.ok) throw source.error;
+  graph
+    .addRasterPass('opaque', {
+      accesses: [{ resource: source.value.view, usage: 'color-attachment' }],
+      colorAttachments: [{ view: source.value.view, loadOp: 'clear', storeOp: 'store' }],
+      encode: () => undefined,
+    })
+    .unwrap();
+  const added = addTransmissionBackdropPasses({
+    graph,
+    source: source.value,
+    demand: { activeCount: 2, needsRoughMips: true },
+    copySize: { width: 4, height: 4 },
+    encodeRoughMip: ({ pass }) => {
+      pass.draw(3, 1, 0, 0);
+    },
+  });
+  expect(added.ok).toBe(true);
+  if (!added.ok) throw added.error;
+  const compiled = graph.compile({ device, surfaceSize: { width: 4, height: 4 } });
+  if (!compiled.ok) throw compiled.error;
+  const names = compiled.value.inspect().passes.map((pass) => pass.name);
+  expect(names).toEqual([
+    'opaque',
+    'transmission-backdrop-copy',
+    'transmission-backdrop-mip',
+    'transmission-backdrop-mip-2',
+    'transmission-forward',
+    'transparent',
+    'temporal',
+  ]);
+  expect(compiled.value.inspect().resources.map((resource) => resource.label)).toContain(
+    'transmission-backdrop',
+  );
+  return added.value;
+}
+
+describe('TransmissionBackdrop Dawn topology', () => {
+  it('compiles the single rgba16float backdrop with one copy and raster mip', async () => {
+    const adapter = (await rhi.requestAdapter()).unwrap();
+    const device = (await adapter.requestDevice()).unwrap();
+    const result = await buildBackdrop(device);
+
+    expect(result.topology).toMatchObject({
+      active: true,
+      copyCount: 1,
+      mipCount: 1,
+      submitCount: 1,
+      aliasCount: 0,
+    });
+  });
+
+  it('does not allocate a backdrop on exact-zero demand', async () => {
+    const adapter = (await rhi.requestAdapter()).unwrap();
+    const device = (await adapter.requestDevice()).unwrap();
+    const graph = new RenderGraphBuilder<RenderPipelineFrame>();
+    const source = createRenderPipelineTarget(graph, 'opaque-resolved', {
+      format: 'rgba16float',
+      size: 'surface',
+    });
+    expect(source.ok).toBe(true);
+    if (!source.ok) return;
+    const added = addTransmissionBackdropPasses({
+      graph,
+      source: source.value,
+      demand: { activeCount: 0, needsRoughMips: false },
+      copySize: { width: 1, height: 1 },
+    });
+    expect(added).toEqual({
+      ok: true,
+      value: {
+        topology: {
+          active: false,
+          sourceSampleCount: 1,
+          copyCount: 0,
+          mipCount: 0,
+          submitCount: 1,
+          aliasCount: 0,
+          phases: [],
+        },
+        backdrop: undefined,
+        mipViews: [],
+      },
+    });
+    const compiled = graph.compile({ device, surfaceSize: { width: 1, height: 1 } });
+    expect(compiled.ok).toBe(true);
+    if (compiled.ok) expect(compiled.value.inspect().passes).toEqual([]);
+  });
+});