@flighthq/render-wgpu 0.5.1-next.1069.554a2ac → 0.5.1-next.1201.9b49dee

package/src/wgpuScreenAntialias.test.ts

@@ -0,0 +1,60 @@
+import { beginWgpuRenderPass, endWgpuRenderPass } from './wgpuRenderPass';
+import { enableWgpuScreenRenderTargetAntialias } from './wgpuScreenAntialias';
+import { bindWgpuScreenRenderTarget } from './wgpuScreenRenderTarget';
+import { createWgpuRenderStateForTest, createWgpuScreenRenderTargetForTest, installWgpuMock } from './wgpuTestHelper';
+
+beforeAll(() => {
+  installWgpuMock();
+});
+
+describe('enableWgpuScreenRenderTargetAntialias', () => {
+  // ★ THE COST IS OPT-IN, AND THAT IS THE POINT OF THE SLOTS. A screen target that was never asked for
+  // antialiasing carries no resolve hook, so the module holding the resolve pipeline and its shader is
+  // unreachable from an ordinary frame loop and tree-shakes out of the bundle entirely.
+  it('installs the hooks a plain screen target does not carry', async () => {
+    const state = await createWgpuRenderStateForTest();
+    const screen = createWgpuScreenRenderTargetForTest(state);
+
+    expect(screen.antialias).toBe(false);
+    expect(screen.acquireAntialiasView).toBeNull();
+    expect(screen.encodeAntialiasResolve).toBeNull();
+
+    enableWgpuScreenRenderTargetAntialias(screen);
+
+    expect(screen.antialias).toBe(true);
+    expect(screen.acquireAntialiasView).not.toBeNull();
+    expect(screen.encodeAntialiasResolve).not.toBeNull();
+  });
+
+  it('draws into supersample storage twice the surface extent', async () => {
+    const state = await createWgpuRenderStateForTest();
+    const screen = createWgpuScreenRenderTargetForTest(state, { antialias: true }, 400, 300);
+
+    const view = bindWgpuScreenRenderTarget(state, screen);
+
+    expect(screen.width).toBe(800);
+    expect(view).toBe(screen.antialiasView);
+    expect(view).not.toBe(screen.presentationView);
+    expect(screen.antialiasTexture?.width).toBe(800);
+  });
+
+  it('resolves the supersample texture into the presentation view', async () => {
+    const state = await createWgpuRenderStateForTest();
+    const screen = createWgpuScreenRenderTargetForTest(state, { antialias: true });
+    const pass = beginWgpuRenderPass(state, screen, { color: [0, 0, 0, 0] });
+    const presentationView = screen.presentationView;
+    const encoded: GPURenderPassDescriptor[] = [];
+    const encoder = {
+      beginRenderPass: (descriptor: GPURenderPassDescriptor) => {
+        encoded.push(descriptor);
+        return { draw: () => {}, end: () => {}, setBindGroup: () => {}, setPipeline: () => {} };
+      },
+    } as unknown as GPUCommandEncoder;
+
+    screen.encodeAntialiasResolve!(state, screen, encoder);
+
+    expect(encoded.length).toBe(1);
+    expect(Array.from(encoded[0]!.colorAttachments)[0]!.view).toBe(presentationView);
+    endWgpuRenderPass(pass);
+  });
+});

package/src/wgpuScreenCapture.test.ts

@@ -0,0 +1,156 @@
+import type { WgpuScreenRenderTarget } from '@flighthq/types/contract';
+import { beforeAll, describe, expect, it } from 'vitest';
+
+import { beginWgpuRenderPass, endWgpuRenderPass } from './wgpuRenderPass';
+import {
+  createBitmapFromWgpuScreenRenderTarget,
+  enableWgpuScreenRenderTargetCapture,
+  encodeWgpuScreenRenderTargetCapture,
+} from './wgpuScreenCapture';
+import { createWgpuRenderStateForTest, createWgpuScreenRenderTargetForTest, installWgpuMock } from './wgpuTestHelper';
+
+beforeAll(() => {
+  installWgpuMock();
+});
+
+describe('createBitmapFromWgpuScreenRenderTarget', () => {
+  it('throws when capture was never enabled (no buffer to read)', async () => {
+    const state = await createWgpuRenderStateForTest();
+    const screen = createWgpuScreenRenderTargetForTest(state);
+    await expect(createBitmapFromWgpuScreenRenderTarget(screen)).rejects.toThrow(/enableWgpuScreenRenderTargetCapture/);
+  });
+
+  it('reads the mapped buffer within the bound', async () => {
+    const state = await createWgpuRenderStateForTest();
+    const screen = createWgpuScreenRenderTargetForTest(state);
+    installCaptureBuffer(screen, () => Promise.resolve());
+
+    const bitmap = await createBitmapFromWgpuScreenRenderTarget(screen, 1_000);
+
+    expect(bitmap.width).toBe(1);
+    expect(bitmap.height).toBe(1);
+  });
+
+  it('fails by name when the buffer never maps, instead of awaiting forever', async () => {
+    // The driver failure this bounds: mapAsync neither resolves nor rejects. Before the bound, the
+    // caller sat here until something outside it gave up and reported a stall with no location.
+    const state = await createWgpuRenderStateForTest();
+    const screen = createWgpuScreenRenderTargetForTest(state);
+    installCaptureBuffer(screen, () => new Promise<void>(() => {}));
+
+    await expect(createBitmapFromWgpuScreenRenderTarget(screen, 25)).rejects.toThrow(/did not map within 25ms/);
+  });
+
+  it('leaves the wait unbounded when the caller passes 0', async () => {
+    const state = await createWgpuRenderStateForTest();
+    const screen = createWgpuScreenRenderTargetForTest(state);
+    let settle = (): void => {};
+    installCaptureBuffer(screen, () => new Promise<void>((resolve) => (settle = resolve)));
+
+    let done = false;
+    const pending = createBitmapFromWgpuScreenRenderTarget(screen, 0).then(() => (done = true));
+    await new Promise((resolve) => setTimeout(resolve, 40));
+    expect(done).toBe(false);
+
+    settle();
+    await pending;
+    expect(done).toBe(true);
+  });
+});
+
+describe('enableWgpuScreenRenderTargetCapture', () => {
+  it('sets the capture flag on the screen target', async () => {
+    const state = await createWgpuRenderStateForTest();
+    const screen = createWgpuScreenRenderTargetForTest(state);
+    expect(screen.captureEnabled).toBe(false);
+    enableWgpuScreenRenderTargetCapture(screen);
+    expect(screen.captureEnabled).toBe(true);
+  });
+
+  it('redirects the frame into an offscreen texture rather than the swap chain', async () => {
+    // The whole reason capture exists: software and headless adapters never present the swap chain, and
+    // its texture reads back as zeros, so a captured frame must be drawn somewhere readable instead.
+    const state = await createWgpuRenderStateForTest();
+    const screen = createWgpuScreenRenderTargetForTest(state);
+    expect(screen.captureTexture).toBeNull();
+
+    enableWgpuScreenRenderTargetCapture(screen);
+    endWgpuRenderPass(beginWgpuRenderPass(state, screen, { color: [0, 0, 0, 0] }));
+
+    expect(screen.captureTexture).not.toBeNull();
+  });
+});
+
+describe('encodeWgpuScreenRenderTargetCapture', () => {
+  it('is a no-op when capture is disabled', async () => {
+    const state = await createWgpuRenderStateForTest();
+    const screen = createWgpuScreenRenderTargetForTest(state);
+    let copied = false;
+    const encoder = { copyTextureToBuffer: () => (copied = true) } as unknown as GPUCommandEncoder;
+    encodeWgpuScreenRenderTargetCapture(screen, encoder);
+    expect(copied).toBe(false);
+  });
+
+  it('skips the copy while a readback holds the buffer, and resumes once it lets go', async () => {
+    // The writer/reader handshake over the single retained buffer: an animating scene must not keep
+    // enqueueing copies into a buffer a readback has mapped or is waiting to map.
+    const state = await createWgpuRenderStateForTest();
+    const screen = captureReadyScreenRenderTarget(state);
+    let mapState: GPUBufferMapState = 'unmapped';
+    installCaptureBuffer(screen, () => Promise.resolve());
+    Object.defineProperty(screen.captureBuffer, 'mapState', { get: () => mapState });
+
+    let copies = 0;
+    const encoder = { copyTextureToBuffer: () => copies++ } as unknown as GPUCommandEncoder;
+
+    mapState = 'pending';
+    encodeWgpuScreenRenderTargetCapture(screen, encoder);
+    mapState = 'mapped';
+    encodeWgpuScreenRenderTargetCapture(screen, encoder);
+    expect(copies).toBe(0);
+
+    mapState = 'unmapped';
+    encodeWgpuScreenRenderTargetCapture(screen, encoder);
+    expect(copies).toBe(1);
+  });
+
+  it('still copies when the implementation reports no map state at all', async () => {
+    // Fails safe in the direction that keeps capturing: an undefined mapState must not read as "busy"
+    // and silence every copy for the rest of the run.
+    const state = await createWgpuRenderStateForTest();
+    const screen = captureReadyScreenRenderTarget(state);
+    installCaptureBuffer(screen, () => Promise.resolve());
+    Object.defineProperty(screen.captureBuffer, 'mapState', { get: () => undefined });
+
+    let copies = 0;
+    encodeWgpuScreenRenderTargetCapture(screen, {
+      copyTextureToBuffer: () => copies++,
+    } as unknown as GPUCommandEncoder);
+
+    expect(copies).toBe(1);
+  });
+});
+
+// A screen target that has drawn one captured frame, so its capture texture exists.
+function captureReadyScreenRenderTarget(
+  state: Awaited<ReturnType<typeof createWgpuRenderStateForTest>>,
+): WgpuScreenRenderTarget {
+  const screen = createWgpuScreenRenderTargetForTest(state);
+  enableWgpuScreenRenderTargetCapture(screen);
+  endWgpuRenderPass(beginWgpuRenderPass(state, screen, { color: [0, 0, 0, 0] }));
+  return screen;
+}
+
+// Installs a 1x1 retained capture buffer whose map step the caller controls, so the map bound can be
+// exercised without a GPU. The mock device's buffers carry no map surface of their own.
+function installCaptureBuffer(target: WgpuScreenRenderTarget, mapAsync: () => Promise<void>): void {
+  target.captureBuffer = {
+    mapAsync,
+    getMappedRange: () => new ArrayBuffer(256),
+    unmap: () => {},
+    destroy: () => {},
+  } as unknown as GPUBuffer;
+  target.captureWidth = 1;
+  target.captureHeight = 1;
+  target.captureBytesPerRow = 256;
+}

package/src/wgpuScreenRenderTarget.test.ts

@@ -0,0 +1,152 @@
+import { beginWgpuRenderPass, endWgpuRenderPass } from './wgpuRenderPass';
+import { getWgpuRenderStateRuntime } from './wgpuRenderState';
+import {
+  bindWgpuScreenRenderTarget,
+  createWgpuScreenRenderTarget,
+  destroyWgpuScreenRenderTarget,
+  endWgpuScreenRenderTargetFrame,
+  initializeWgpuScreenRenderTarget,
+  isWgpuScreenRenderTarget,
+  syncWgpuScreenRenderTargetExtent,
+} from './wgpuScreenRenderTarget';
+import { createWgpuRenderStateForTest, createWgpuScreenRenderTargetForTest, installWgpuMock } from './wgpuTestHelper';
+import { createWgpuTextureRenderTarget } from './wgpuTextureRenderTarget';
+
+beforeAll(() => {
+  installWgpuMock();
+});
+
+describe('bindWgpuScreenRenderTarget', () => {
+  it('acquires one swap-chain view per frame and releases it at the end of the frame', async () => {
+    // Nothing may hold a swap-chain view across frames — that is the property that makes a screen target
+    // unsampleable — so the view is acquired inside the frame and dropped when it is submitted.
+    const state = await createWgpuRenderStateForTest();
+    const screen = createWgpuScreenRenderTargetForTest(state);
+
+    const first = bindWgpuScreenRenderTarget(state, screen);
+    expect(bindWgpuScreenRenderTarget(state, screen)).toBe(first);
+    expect(screen.presentationView).toBe(first);
+
+    endWgpuScreenRenderTargetFrame(screen);
+    expect(screen.presentationView).toBeNull();
+  });
+
+  it('follows a surface that resized between frames', async () => {
+    const state = await createWgpuRenderStateForTest();
+    const canvas = document.createElement('canvas');
+    canvas.width = 320;
+    canvas.height = 240;
+    const screen = createWgpuScreenRenderTarget(state.device, canvas, { format: state.format });
+
+    canvas.width = 640;
+    canvas.height = 480;
+    bindWgpuScreenRenderTarget(state, screen);
+
+    expect(screen.width).toBe(640);
+    expect(screen.height).toBe(480);
+    expect(screen.depthStencilTexture.width).toBe(640);
+  });
+
+  it('draws into supersample storage when the target is antialiased', async () => {
+    const state = await createWgpuRenderStateForTest();
+    const screen = createWgpuScreenRenderTargetForTest(state, { antialias: true }, 400, 300);
+
+    const view = bindWgpuScreenRenderTarget(state, screen);
+
+    expect(screen.width).toBe(800);
+    expect(view).toBe(screen.antialiasView);
+    expect(view).not.toBe(screen.presentationView);
+    expect(screen.antialiasTexture?.width).toBe(800);
+  });
+});
+
+describe('createWgpuScreenRenderTarget', () => {
+  it('configures the surface context and declares one color attachment', async () => {
+    const state = await createWgpuRenderStateForTest();
+    const canvas = document.createElement('canvas');
+    canvas.width = 800;
+    canvas.height = 600;
+    const context = canvas.getContext('webgpu')!;
+    const configure = vi.spyOn(context, 'configure');
+
+    const screen = createWgpuScreenRenderTarget(state.device, canvas, { format: 'rgba8unorm' });
+
+    expect(configure).toHaveBeenCalledOnce();
+    expect(configure.mock.calls[0]![0].format).toBe('rgba8unorm');
+    expect(screen.context).toBe(context);
+    expect(screen.colorAttachments).toBe(1);
+    expect(screen.format).toBe('rgba8unorm');
+    expect(screen.width).toBe(800);
+    expect(screen.height).toBe(600);
+  });
+
+  it('reports a surface the host cannot present rather than returning a target that cannot bind', async () => {
+    const state = await createWgpuRenderStateForTest();
+    const surface = { getContext: () => null, height: 100, width: 100 };
+
+    expect(() => createWgpuScreenRenderTarget(state.device, surface)).toThrow(/cannot present WebGPU/);
+  });
+});
+
+describe('destroyWgpuScreenRenderTarget', () => {
+  it('frees the storage it owns and unconfigures the context', async () => {
+    const state = await createWgpuRenderStateForTest();
+    const screen = createWgpuScreenRenderTargetForTest(state, { antialias: true });
+    bindWgpuScreenRenderTarget(state, screen);
+    const depth = vi.spyOn(screen.depthStencilTexture, 'destroy');
+    const antialias = vi.spyOn(screen.antialiasTexture!, 'destroy');
+    const unconfigure = vi.spyOn(screen.context, 'unconfigure');
+
+    destroyWgpuScreenRenderTarget(screen);
+
+    expect(depth).toHaveBeenCalledOnce();
+    expect(antialias).toHaveBeenCalledOnce();
+    expect(unconfigure).toHaveBeenCalledOnce();
+    expect(screen.antialiasView).toBeNull();
+    expect(screen.presentationView).toBeNull();
+  });
+});
+
+describe('endWgpuScreenRenderTargetFrame', () => {
+  it('is what a submitted frame calls, leaving no view behind', async () => {
+    const state = await createWgpuRenderStateForTest();
+    const screen = createWgpuScreenRenderTargetForTest(state);
+
+    endWgpuRenderPass(beginWgpuRenderPass(state, screen, { color: [0, 0, 0, 0] }));
+
+    expect(screen.presentationView).toBeNull();
+    expect(getWgpuRenderStateRuntime(state).frameScreenTarget).toBeNull();
+  });
+});
+
+describe('initializeWgpuScreenRenderTarget', () => {
+  it('is the construction initializer of createWgpuScreenRenderTarget', () => {
+    expect(typeof initializeWgpuScreenRenderTarget).toBe('function');
+  });
+});
+
+describe('isWgpuScreenRenderTarget', () => {
+  it('separates the two realizations by the field that says where the pixels live', async () => {
+    const state = await createWgpuRenderStateForTest();
+
+    expect(isWgpuScreenRenderTarget(createWgpuScreenRenderTargetForTest(state))).toBe(true);
+    expect(isWgpuScreenRenderTarget(createWgpuTextureRenderTarget(state, 16, 16))).toBe(false);
+  });
+});
+
+describe('syncWgpuScreenRenderTargetExtent', () => {
+  it('follows the surface without a resize call', async () => {
+    const state = await createWgpuRenderStateForTest();
+    const canvas = document.createElement('canvas');
+    canvas.width = 320;
+    canvas.height = 240;
+    const screen = createWgpuScreenRenderTarget(state.device, canvas, { format: state.format });
+
+    canvas.width = 500;
+    canvas.height = 400;
+    syncWgpuScreenRenderTargetExtent(screen);
+
+    expect(screen.width).toBe(500);
+    expect(screen.height).toBe(400);
+  });
+});

package/src/wgpuShader.test.ts

@@ -1,6 +1,5 @@
 import { AdvancedBlendMode, BlendMode } from '@flighthq/types/contract';
 
-import { renderWgpuBackground } from './wgpuBackground';
 import { getWgpuRenderStateDeviceResources, getWgpuRenderStateRuntime } from './wgpuRenderState';
 import {
   UNIFORM_BYTE_SIZE,
@@ -14,7 +13,7 @@ import {
   writeWgpuMatrixOnlyUniforms,
   writeWgpuQuadUniforms,
 } from './wgpuShader';
-import { createWgpuRenderStateForTest, installWgpuMock } from './wgpuTestHelper';
+import { beginWgpuScreenRenderPassForTest, createWgpuRenderStateForTest, installWgpuMock } from './wgpuTestHelper';
 
 beforeAll(() => {
   installWgpuMock();
@@ -164,7 +163,7 @@ describe('writeWgpuMatrixOnlyUniforms', () => {
   it('advances uniformOffset', async () => {
     const state = await createWgpuRenderStateForTest();
     const runtime = getWgpuRenderStateRuntime(state);
-    renderWgpuBackground(state);
+    beginWgpuScreenRenderPassForTest(state);
     const before = runtime.uniformOffset;
     const fakeNode = { alpha: 1, useColorScaleBias: false, colorScaleBias: null };
     const t = { a: 1, b: 0, c: 0, d: 1, tx: 0, ty: 0 };
@@ -176,7 +175,7 @@ describe('writeWgpuQuadUniforms', () => {
   it('advances uniformOffset by uniformStride', async () => {
     const state = await createWgpuRenderStateForTest();
     const runtime = getWgpuRenderStateRuntime(state);
-    renderWgpuBackground(state);
+    beginWgpuScreenRenderPassForTest(state);
     const before = runtime.uniformOffset;
     const fakeNode = {
       alpha: 1,
@@ -191,7 +190,7 @@ describe('writeWgpuQuadUniforms', () => {
   it('writes quad coordinates into uniform data at float offset 24', async () => {
     const state = await createWgpuRenderStateForTest();
     const runtime = getWgpuRenderStateRuntime(state);
-    renderWgpuBackground(state);
+    beginWgpuScreenRenderPassForTest(state);
     const fakeNode = {
       alpha: 0.5,
       useColorScaleBias: false,
@@ -211,7 +210,7 @@ describe('writeWgpuQuadUniforms', () => {
   it('writes the native straight-alpha texture flag at u32 offset 14', async () => {
     const state = await createWgpuRenderStateForTest();
     const runtime = getWgpuRenderStateRuntime(state);
-    renderWgpuBackground(state);
+    beginWgpuScreenRenderPassForTest(state);
     const fakeNode = {
       alpha: 1,
       useColorScaleBias: false,

package/src/wgpuTextureRenderTarget.test.ts

@@ -0,0 +1,129 @@
+import { createMatrix } from '@flighthq/geometry/contract';
+
+import { resolveWgpuSmoothingBindGroup } from './wgpuDraw';
+import { submitWgpuFrame } from './wgpuFrame';
+import { getWgpuRenderStateDeviceResources } from './wgpuRenderState';
+import { beginWgpuScreenRenderPassForTest, createWgpuRenderStateForTest, installWgpuMock } from './wgpuTestHelper';
+import {
+  createWgpuTextureRenderTarget,
+  destroyWgpuTextureRenderTarget,
+  drawWgpuTextureRenderTargetResult,
+  initializeWgpuTextureRenderTarget,
+  resizeWgpuTextureRenderTarget,
+} from './wgpuTextureRenderTarget';
+
+beforeAll(() => {
+  installWgpuMock();
+});
+
+describe('createWgpuTextureRenderTarget', () => {
+  it('returns a target with texture, view, binding cache, and depth-stencil', async () => {
+    const state = await createWgpuRenderStateForTest();
+    const target = createWgpuTextureRenderTarget(state, 256, 256);
+    expect(target.texture).toBeDefined();
+    expect(target.view).toBeDefined();
+    expect(target.bindings).toBeDefined();
+    expect(target.depthStencilTexture).toBeDefined();
+    expect(target.width).toBe(256);
+    expect(target.height).toBe(256);
+  });
+
+  it('clamps to minimum 1×1', async () => {
+    const state = await createWgpuRenderStateForTest();
+    const target = createWgpuTextureRenderTarget(state, 0, 0);
+    expect(target.width).toBe(1);
+    expect(target.height).toBe(1);
+  });
+
+  it('defaults to sRGB and accepts a linear content declaration', async () => {
+    const state = await createWgpuRenderStateForTest();
+    expect(createWgpuTextureRenderTarget(state, 16, 16).colorSpace).toBe('srgb');
+    expect(createWgpuTextureRenderTarget(state, 16, 16, state.format, 'linear').colorSpace).toBe('linear');
+  });
+
+  it('realizes four coverage samples as a 2x extent in each axis', async () => {
+    const state = await createWgpuRenderStateForTest();
+    const target = createWgpuTextureRenderTarget(state, 64, 48, state.format, 'srgb', 4);
+    expect(target.width).toBe(128);
+    expect(target.height).toBe(96);
+    expect(target.sampleCount).toBe(4);
+    expect(target.texture.width).toBe(128);
+    expect(target.texture.height).toBe(96);
+  });
+});
+
+describe('destroyWgpuTextureRenderTarget', () => {
+  it('calls destroy on texture and depth-stencil', async () => {
+    const state = await createWgpuRenderStateForTest();
+    const target = createWgpuTextureRenderTarget(state, 64, 64);
+    const destroyTexture = vi.spyOn(target.texture, 'destroy');
+    const destroyDepth = vi.spyOn(target.depthStencilTexture, 'destroy');
+    destroyWgpuTextureRenderTarget(target);
+    expect(destroyTexture).toHaveBeenCalled();
+    expect(destroyDepth).toHaveBeenCalled();
+  });
+});
+
+describe('drawWgpuTextureRenderTargetResult', () => {
+  it('does not throw with an open render pass', async () => {
+    const state = await createWgpuRenderStateForTest();
+    beginWgpuScreenRenderPassForTest(state);
+    const target = createWgpuTextureRenderTarget(state, 64, 64);
+    const fakeNode = {
+      alpha: 1,
+      material: null,
+      transform2D: { a: 1, b: 0, c: 0, d: 1, tx: 0, ty: 0 },
+    };
+    expect(() => drawWgpuTextureRenderTargetResult(state, fakeNode, target, createMatrix())).not.toThrow();
+    submitWgpuFrame(state);
+  });
+});
+
+describe('initializeWgpuTextureRenderTarget', () => {
+  it('is the construction initializer of createWgpuTextureRenderTarget', () => {
+    expect(typeof initializeWgpuTextureRenderTarget).toBe('function');
+  });
+});
+
+describe('resizeWgpuTextureRenderTarget', () => {
+  it('preserves the allocation when dimensions are unchanged', async () => {
+    const state = await createWgpuRenderStateForTest();
+    const target = createWgpuTextureRenderTarget(state, 64, 64);
+    const texture = target.texture;
+    const depthStencilTexture = target.depthStencilTexture;
+    const sampler = getWgpuRenderStateDeviceResources(state).linearSampler;
+    const bindGroup = resolveWgpuSmoothingBindGroup(state, target, true);
+
+    resizeWgpuTextureRenderTarget(state, target, 64, 64);
+
+    expect(target.texture).toBe(texture);
+    expect(target.depthStencilTexture).toBe(depthStencilTexture);
+    // The view survived, so its cached bindings must survive with it.
+    expect(target.bindings.get(sampler)).toBe(bindGroup);
+  });
+
+  it('updates width, height, and drops bindings that referenced the old view', async () => {
+    const state = await createWgpuRenderStateForTest();
+    const target = createWgpuTextureRenderTarget(state, 64, 64);
+    const previousBindGroup = resolveWgpuSmoothingBindGroup(state, target, true);
+    resizeWgpuTextureRenderTarget(state, target, 200, 150);
+    expect(target.width).toBe(200);
+    expect(target.height).toBe(150);
+    // Reallocation replaces the view, so every binding over the old one is dropped and rebuilt.
+    expect(target.bindings.size).toBe(0);
+    expect(resolveWgpuSmoothingBindGroup(state, target, true)).not.toBe(previousBindGroup);
+  });
+
+  it('reallocates when the effective sample count changes', async () => {
+    const state = await createWgpuRenderStateForTest();
+    const target = createWgpuTextureRenderTarget(state, 64, 48);
+    const previousTexture = target.texture;
+
+    resizeWgpuTextureRenderTarget(state, target, 64, 48, 4);
+
+    expect(target.width).toBe(128);
+    expect(target.height).toBe(96);
+    expect(target.sampleCount).toBe(4);
+    expect(target.texture).not.toBe(previousTexture);
+  });
+});

package/src/wgpuTextureResolver.test.ts

@@ -8,10 +8,10 @@ import {
   RenderTargetTextureSourceKind,
 } from '@flighthq/types/contract';
 
-import { renderWgpuBackground, submitWgpuRenderPass } from './wgpuBackground';
+import { submitWgpuFrame } from './wgpuFrame';
 import { getWgpuRenderStateRuntime } from './wgpuRenderState';
 import { renderIntoWgpuRenderTexture } from './wgpuRenderTexture';
-import { createWgpuRenderStateForTest, installWgpuMock } from './wgpuTestHelper';
+import { beginWgpuScreenRenderPassForTest, createWgpuRenderStateForTest, installWgpuMock } from './wgpuTestHelper';
 import {
   registerWgpuImageTextureResolver,
   registerWgpuBitmapTextureResolver,
@@ -177,10 +177,10 @@ describe('registerWgpuRenderTextureResolver', () => {
     registerWgpuRenderTextureResolver(state);
     expect(resolveWgpuTexture(state, texture)).toBeNull();
 
-    renderWgpuBackground(state);
-    renderIntoWgpuRenderTexture(state, texture, () => {});
+    beginWgpuScreenRenderPassForTest(state);
+    renderIntoWgpuRenderTexture(state, texture, () => {}, { color: [0, 0, 0, 0], depth: 1.0, stencil: 0 });
     expect(resolveWgpuTexture(state, texture)).not.toBeNull();
-    submitWgpuRenderPass(state);
+    submitWgpuFrame(state);
   });
 });
 

package/dist/wgpuAntialias.d.ts

@@ -1,14 +0,0 @@
-import type { WgpuPresentationRenderState, WgpuRenderState } from '@flighthq/types/contract';
-export declare function acquireWgpuSurfaceAntialiasView(state: Readonly<WgpuPresentationRenderState>, presentationView: GPUTextureView): GPUTextureView | null;
-export declare function clearWgpuSurfacePresentation(state: Readonly<WgpuPresentationRenderState>): void;
-export declare function encodeWgpuSurfaceAntialiasResolve(state: Readonly<WgpuPresentationRenderState>, encoder: GPUCommandEncoder): void;
-export declare function getWgpuSurfaceLogicalExtent(state: Readonly<WgpuRenderState>): {
-    width: number;
-    height: number;
-};
-export declare function getWgpuSurfaceRenderExtent(state: Readonly<WgpuRenderState>): {
-    width: number;
-    height: number;
-};
-export declare function getWgpuSurfaceRenderScale(state: Readonly<WgpuRenderState>): number;
-//# sourceMappingURL=wgpuAntialias.d.ts.map

package/dist/wgpuAntialias.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"wgpuAntialias.d.ts","sourceRoot":"","sources":["../src/wgpuAntialias.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,2BAA2B,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAS7F,wBAAgB,+BAA+B,CAC7C,KAAK,EAAE,QAAQ,CAAC,2BAA2B,CAAC,EAC5C,gBAAgB,EAAE,cAAc,GAC/B,cAAc,GAAG,IAAI,CA8CvB;AAED,wBAAgB,4BAA4B,CAAC,KAAK,EAAE,QAAQ,CAAC,2BAA2B,CAAC,GAAG,IAAI,CAE/F;AAKD,wBAAgB,iCAAiC,CAC/C,KAAK,EAAE,QAAQ,CAAC,2BAA2B,CAAC,EAC5C,OAAO,EAAE,iBAAiB,GACzB,IAAI,CAqBN;AAKD,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,QAAQ,CAAC,eAAe,CAAC,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAQ/G;AAID,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,QAAQ,CAAC,eAAe,CAAC,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAW9G;AAID,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,QAAQ,CAAC,eAAe,CAAC,GAAG,MAAM,CAGlF"}