@flighthq/render-wgpu 0.2.1-next.841.373388f → 0.3.0-next.1032.e2b99fc

package/src/wgpuCompressedTexture.test.ts

@@ -1,4 +1,5 @@
-import type { ImageResource, TextureContainer, WgpuCompressedTextureSupport } from '@flighthq/types';
+import type { CompressedImage, TextureContainer, WgpuCompressedTextureSupport } from '@flighthq/types/contract';
+import { CompressedImageTextureBackingKind } from '@flighthq/types/contract';
 
 import {
   detectWgpuCompressedTextureSupport,
@@ -8,7 +9,7 @@ import {
   registerWgpuCompressedTextureUpload,
   uploadWgpuCompressedTextureContainer,
 } from './wgpuCompressedTexture';
-import { bindWgpuImageResourceTexture } from './wgpuDraw';
+import { bindWgpuCompressedImageTexture } from './wgpuDraw';
 import { getWgpuRenderStateRuntime } from './wgpuRenderState';
 import { createWgpuRenderStateForTest, installWgpuMock } from './wgpuTestHelper';
 
@@ -29,6 +30,16 @@ function container(overrides: Partial<TextureContainer> = {}): TextureContainer
   };
 }
 
+function compressedImage(): CompressedImage {
+  return {
+    compressed: { container: container(), payload: new Uint8Array(8) },
+    height: 4,
+    kind: CompressedImageTextureBackingKind,
+    version: 1,
+    width: 4,
+  } as unknown as CompressedImage;
+}
+
 describe('detectWgpuCompressedTextureSupport', () => {
   it('reads the three WebGPU compression features', async () => {
     const state = await createWgpuRenderStateForTest();
@@ -69,7 +80,7 @@ describe('registerWgpuCompressedTextureDecoder', () => {
 });
 
 describe('registerWgpuCompressedTextureUpload', () => {
-  it('installs and clears the ImageResource upload seam', async () => {
+  it('installs and clears the CompressedImage upload seam', async () => {
     const state = await createWgpuRenderStateForTest();
     registerWgpuCompressedTextureUpload(state);
     expect(getWgpuRenderStateRuntime(state).compressedTextureUpload).toBeTypeOf('function');
@@ -77,23 +88,14 @@ describe('registerWgpuCompressedTextureUpload', () => {
     expect(getWgpuRenderStateRuntime(state).compressedTextureUpload).toBeNull();
   });
 
-  it('lets the normal image binder consume a compressed-only resource', async () => {
+  it('lets the compressed-image binder consume its backing', async () => {
     const state = await createWgpuRenderStateForTest();
     registerWgpuCompressedTextureUpload(state);
     registerWgpuCompressedTextureDecoder(state, (_format, width, height) => {
       return new Uint8ClampedArray(width * height * 4);
     });
-    const image = {
-      alphaType: 'straight',
-      compressed: { container: container(), payload: new Uint8Array(8) },
-      data: null,
-      height: 4,
-      source: null,
-      version: 1,
-      width: 4,
-    } as unknown as ImageResource;
     const writeTexture = vi.spyOn(state.device.queue, 'writeTexture');
-    expect(bindWgpuImageResourceTexture(state, image).view).toBeDefined();
+    expect(bindWgpuCompressedImageTexture(state, compressedImage())?.view).toBeDefined();
     expect(writeTexture).toHaveBeenCalledTimes(1);
   });
 
@@ -109,18 +111,9 @@ describe('registerWgpuCompressedTextureUpload', () => {
       }
       return rgba;
     });
-    const image = {
-      alphaType: 'straight',
-      compressed: { container: container(), payload: new Uint8Array(8) },
-      data: null,
-      height: 4,
-      source: null,
-      version: 1,
-      width: 4,
-    } as unknown as ImageResource;
     const writeTexture = vi.spyOn(state.device.queue, 'writeTexture');
 
-    const entry = bindWgpuImageResourceTexture(state, image);
+    const entry = bindWgpuCompressedImageTexture(state, compressedImage())!;
 
     expect(entry.straightAlpha).toBe(false);
     expect(Array.from(writeTexture.mock.calls[0][1] as Uint8ClampedArray).slice(0, 4)).toEqual([128, 32, 0, 128]);
@@ -130,17 +123,7 @@ describe('registerWgpuCompressedTextureUpload', () => {
     const state = await createWgpuRenderStateForTest();
     (state.device.features as Set<GPUFeatureName>).add('texture-compression-bc');
     registerWgpuCompressedTextureUpload(state);
-    const image = {
-      alphaType: 'straight',
-      compressed: { container: container(), payload: new Uint8Array(8) },
-      data: null,
-      height: 4,
-      source: null,
-      version: 1,
-      width: 4,
-    } as unknown as ImageResource;
-
-    expect(bindWgpuImageResourceTexture(state, image).straightAlpha).toBe(true);
+    expect(bindWgpuCompressedImageTexture(state, compressedImage())?.straightAlpha).toBe(true);
   });
 });
 

package/src/wgpuDraw.test.ts

@@ -1,11 +1,19 @@
-import { getOrCreateRenderProxy2D, prepareScene2DRender } from '@flighthq/render';
-import { createBitmap } from '@flighthq/scene2d';
-import type { ImageResource, VideoTexture } from '@flighthq/types';
-import { BlendMode } from '@flighthq/types';
+import { getOrCreateRenderProxy2D, prepareScene2DRender } from '@flighthq/render/contract';
+import { createSprite } from '@flighthq/scene2d/contract';
+import type { Bitmap, CompressedImage, ImageResource, Texture } from '@flighthq/types/contract';
+import {
+  BitmapTextureBackingKind,
+  BlendMode,
+  CompressedImageTextureBackingKind,
+  ImageTextureBackingKind,
+} from '@flighthq/types/contract';
 
 import { renderWgpuBackground, submitWgpuRenderPass } from './wgpuBackground';
+import { registerWgpuCompressedTextureDecoder, registerWgpuCompressedTextureUpload } from './wgpuCompressedTexture';
 import {
   applyWgpuBlendMode,
+  bindWgpuBitmapTexture,
+  bindWgpuCompressedImageTexture,
   bindWgpuImageResourceTexture,
   bindWgpuTexture,
   bindWgpuVideoTexture,
@@ -15,7 +23,7 @@ import {
   drawWgpuQuadWithTransform,
   destroyWgpuVideoTexture,
   enableWgpuBlendModeSupport,
-  getWgpuRenderProxyColorTransform,
+  getWgpuRenderProxyColorScaleBias,
   resolveWgpuSmoothingBindGroup,
   submitWgpuQuadDraw,
   updateWgpuTextureEntry,
@@ -28,6 +36,42 @@ beforeAll(() => {
   installWgpuMock();
 });
 
+function bitmap(size: number, version: number): Bitmap {
+  return {
+    alphaType: 'straight',
+    colorSpace: 'srgb',
+    data: new Uint8ClampedArray(size * size * 4),
+    format: 'rgba8unorm',
+    height: size,
+    kind: BitmapTextureBackingKind,
+    version,
+    width: size,
+  } as unknown as Bitmap;
+}
+
+function compressedBc3Image(): CompressedImage {
+  return {
+    compressed: {
+      container: {
+        depth: 1,
+        faces: 1,
+        format: 'bc3',
+        height: 4,
+        layers: 1,
+        levels: [{ byteLength: 16, byteOffset: 0, height: 4, width: 4 }],
+        mipLevels: 1,
+        supercompression: 'None',
+        width: 4,
+      },
+      payload: new Uint8Array(16),
+    },
+    height: 4,
+    kind: CompressedImageTextureBackingKind,
+    version: 1,
+    width: 4,
+  } as unknown as CompressedImage;
+}
+
 describe('applyWgpuBlendMode', () => {
   it('updates currentBlendMode on the state', async () => {
     const state = await createWgpuRenderStateForTest();
@@ -42,27 +86,46 @@ describe('applyWgpuBlendMode', () => {
   });
 });
 
-describe('bindWgpuImageResourceTexture', () => {
-  function dataResource(size: number, version: number): ImageResource {
-    return {
-      source: null,
-      data: new Uint8ClampedArray(size * size * 4),
-      width: size,
-      height: size,
-      version,
-      alphaType: 'straight',
-    } as unknown as ImageResource;
-  }
-
-  it('uploads a data-only ImageResource (a generated Surface) via writeTexture', async () => {
+describe('bindWgpuBitmapTexture', () => {
+  it('uploads CPU-readable pixels via writeTexture', async () => {
     const state = await createWgpuRenderStateForTest();
     const writeTexture = vi.spyOn(state.device.queue, 'writeTexture');
-    const entry = bindWgpuImageResourceTexture(state, dataResource(4, 1));
+    const entry = bindWgpuBitmapTexture(state, bitmap(4, 1));
     expect(entry.texture).toBeDefined();
     expect(writeTexture).toHaveBeenCalled();
   });
 
-  it('uploads an element-backed ImageResource via copyExternalImageToTexture', async () => {
+  it('caches by resource identity and re-uploads only when the version changes', async () => {
+    const state = await createWgpuRenderStateForTest();
+    const image = bitmap(2, 1);
+    const first = bindWgpuBitmapTexture(state, image);
+    expect(bindWgpuBitmapTexture(state, image)).toBe(first);
+    const createTexture = vi.spyOn(state.device, 'createTexture');
+    image.version = 2;
+    bindWgpuBitmapTexture(state, image);
+    expect(createTexture).toHaveBeenCalled();
+  });
+});
+
+describe('bindWgpuCompressedImageTexture', () => {
+  it('routes through the registered compressed upload seam', async () => {
+    const state = await createWgpuRenderStateForTest();
+    const decode = vi.fn(() => new Uint8ClampedArray(4 * 4 * 4));
+    registerWgpuCompressedTextureUpload(state);
+    registerWgpuCompressedTextureDecoder(state, decode);
+    const entry = bindWgpuCompressedImageTexture(state, compressedBc3Image());
+    expect(entry?.texture).toBeDefined();
+    expect(decode).toHaveBeenCalledWith('bc3', 4, 4, expect.any(Uint8Array));
+  });
+
+  it('returns null when no compressed uploader is registered', async () => {
+    const state = await createWgpuRenderStateForTest();
+    expect(bindWgpuCompressedImageTexture(state, compressedBc3Image())).toBeNull();
+  });
+});
+
+describe('bindWgpuImageResourceTexture', () => {
+  it('uploads a host-backed image via copyExternalImageToTexture', async () => {
     const state = await createWgpuRenderStateForTest();
     const copy = vi.spyOn(state.device.queue, 'copyExternalImageToTexture');
     const canvas = document.createElement('canvas');
@@ -70,26 +133,14 @@ describe('bindWgpuImageResourceTexture', () => {
     canvas.height = 4;
     const image = {
       source: canvas,
-      data: null,
       width: 4,
       height: 4,
+      kind: ImageTextureBackingKind,
       version: 1,
-      alphaType: 'straight',
     } as unknown as ImageResource;
     bindWgpuImageResourceTexture(state, image);
     expect(copy).toHaveBeenCalled();
   });
-
-  it('caches by resource identity and re-uploads only when the version changes', async () => {
-    const state = await createWgpuRenderStateForTest();
-    const image = dataResource(2, 1);
-    const first = bindWgpuImageResourceTexture(state, image);
-    expect(bindWgpuImageResourceTexture(state, image)).toBe(first);
-    const createTexture = vi.spyOn(state.device, 'createTexture');
-    image.version = 2;
-    bindWgpuImageResourceTexture(state, image);
-    expect(createTexture).toHaveBeenCalled();
-  });
 });
 
 describe('bindWgpuTexture', () => {
@@ -129,9 +180,8 @@ describe('bindWgpuTexture', () => {
 });
 
 describe('bindWgpuVideoTexture', () => {
-  function videoTexture(frameId: number, readyState = 4, width = 320, height = 240): VideoTexture {
+  function videoTexture(version: number, readyState = 4, width = 320, height = 240): Texture {
     return {
-      frameId,
       sampler: {
         anisotropy: 1,
         magFilter: 'linear',
@@ -140,11 +190,18 @@ describe('bindWgpuVideoTexture', () => {
         wrapU: 'clamp-to-edge',
         wrapV: 'clamp-to-edge',
       },
-      source: { element: { readyState, videoHeight: height, videoWidth: width } as HTMLVideoElement },
-    } as unknown as VideoTexture;
+      storage: {
+        dimension: '2d',
+        image: {
+          source: { readyState, videoHeight: height, videoWidth: width } as HTMLVideoElement,
+          version,
+        },
+      },
+      version,
+    } as unknown as Texture;
   }
 
-  it('uploads once per frameId and caches the texture by VideoTexture identity', async () => {
+  it('uploads once per backing version and caches the texture by backing identity', async () => {
     const state = await createWgpuRenderStateForTest();
     const copy = vi.spyOn(state.device.queue, 'copyExternalImageToTexture');
     const video = videoTexture(1);
@@ -153,7 +210,7 @@ describe('bindWgpuVideoTexture', () => {
     expect(copy).toHaveBeenCalledTimes(1);
     expect(bindWgpuVideoTexture(state, video)).toBe(first);
     expect(copy).toHaveBeenCalledTimes(1);
-    video.frameId = 2;
+    video.storage.image!.version = 2;
     expect(bindWgpuVideoTexture(state, video)).toBe(first);
     expect(copy).toHaveBeenCalledTimes(2);
   });
@@ -162,7 +219,7 @@ describe('bindWgpuVideoTexture', () => {
     const state = await createWgpuRenderStateForTest();
     const video = videoTexture(1, 1, 0, 0);
     expect(bindWgpuVideoTexture(state, video)).toBeNull();
-    const element = video.source.element!;
+    const element = (video.storage.image as ImageResource).source as HTMLVideoElement;
     Object.assign(element, { readyState: 4, videoHeight: 120, videoWidth: 160 });
     const first = bindWgpuVideoTexture(state, video)!;
     const destroy = vi.spyOn(first.texture, 'destroy');
@@ -214,7 +271,7 @@ describe('drawWgpuQuad', () => {
   it('does not throw when render pass is open', async () => {
     const state = await createWgpuRenderStateForTest();
     renderWgpuBackground(state);
-    const bitmap = createBitmap();
+    const bitmap = createSprite();
     prepareScene2DRender(state, bitmap);
     const renderProxy = getOrCreateRenderProxy2D(state, bitmap);
     const canvas = document.createElement('canvas');
@@ -230,7 +287,7 @@ describe('drawWgpuQuadWithTransform', () => {
   it('does not throw when render pass is open', async () => {
     const state = await createWgpuRenderStateForTest();
     renderWgpuBackground(state);
-    const bitmap = createBitmap();
+    const bitmap = createSprite();
     prepareScene2DRender(state, bitmap);
     const renderProxy = getOrCreateRenderProxy2D(state, bitmap);
     const canvas = document.createElement('canvas');
@@ -251,33 +308,22 @@ describe('enableWgpuBlendModeSupport', () => {
   });
 });
 
-describe('getWgpuRenderProxyColorTransform', () => {
-  it('returns null when the node has no color transform', () => {
-    expect(getWgpuRenderProxyColorTransform({} as never)).toBeNull();
-    expect(getWgpuRenderProxyColorTransform({ colorTransform: null } as never)).toBeNull();
+describe('getWgpuRenderProxyColorScaleBias', () => {
+  it('returns null when the node has no color adjustment', () => {
+    expect(getWgpuRenderProxyColorScaleBias({} as never)).toBeNull();
+    expect(getWgpuRenderProxyColorScaleBias({ colorScaleBias: null } as never)).toBeNull();
   });
 
-  it('returns the resolved node-level color transform trait', () => {
-    const colorTransform = { redMultiplier: 0.5 };
-    expect(getWgpuRenderProxyColorTransform({ colorTransform } as never)).toBe(colorTransform);
+  it('returns the resolved node-level color adjustment trait', () => {
+    const colorScaleBias = { redScale: 0.5 };
+    expect(getWgpuRenderProxyColorScaleBias({ colorScaleBias } as never)).toBe(colorScaleBias);
   });
 });
 
 describe('resolveWgpuSmoothingBindGroup', () => {
-  function dataResource(size: number, version: number): ImageResource {
-    return {
-      source: null,
-      data: new Uint8ClampedArray(size * size * 4),
-      width: size,
-      height: size,
-      version,
-      alphaType: 'straight',
-    } as unknown as ImageResource;
-  }
-
   it('returns the default bind group for a null smoothing (no variant built)', async () => {
     const state = await createWgpuRenderStateForTest();
-    const entry = bindWgpuImageResourceTexture(state, dataResource(4, 1));
+    const entry = bindWgpuBitmapTexture(state, bitmap(4, 1));
     expect(resolveWgpuSmoothingBindGroup(state, entry, null)).toBe(entry.bindGroup);
     expect(entry.bindGroupLinear).toBeUndefined();
     expect(entry.bindGroupNearest).toBeUndefined();
@@ -285,7 +331,7 @@ describe('resolveWgpuSmoothingBindGroup', () => {
 
   it('builds and caches distinct LINEAR and NEAREST variants for true/false', async () => {
     const state = await createWgpuRenderStateForTest();
-    const entry = bindWgpuImageResourceTexture(state, dataResource(4, 1));
+    const entry = bindWgpuBitmapTexture(state, bitmap(4, 1));
     const createBindGroup = vi.spyOn(state.device, 'createBindGroup');
 
     resolveWgpuSmoothingBindGroup(state, entry, true);
@@ -304,13 +350,13 @@ describe('resolveWgpuSmoothingBindGroup', () => {
 
   it('drops the cached variants when the texture re-uploads (version bump)', async () => {
     const state = await createWgpuRenderStateForTest();
-    const image = dataResource(4, 1);
-    const entry = bindWgpuImageResourceTexture(state, image);
+    const image = bitmap(4, 1);
+    const entry = bindWgpuBitmapTexture(state, image);
     resolveWgpuSmoothingBindGroup(state, entry, true);
     resolveWgpuSmoothingBindGroup(state, entry, false);
     expect(entry.bindGroupLinear).toBeDefined();
     image.version = 2;
-    bindWgpuImageResourceTexture(state, image);
+    bindWgpuBitmapTexture(state, image);
     expect(entry.bindGroupLinear).toBeUndefined();
     expect(entry.bindGroupNearest).toBeUndefined();
   });

package/src/wgpuExternalTexture.test.ts

@@ -0,0 +1,35 @@
+import { getTextureBackingKind } from '@flighthq/texture/contract';
+import { ExternalTextureBackingKind } from '@flighthq/types/contract';
+
+import { createExternalWgpuTexture, disposeExternalWgpuTexture } from './wgpuExternalTexture';
+import { createWgpuRenderStateForTest, installWgpuMock } from './wgpuTestHelper';
+import { resolveWgpuTexture } from './wgpuTextureResolver';
+
+beforeAll(() => {
+  installWgpuMock();
+});
+
+describe('createExternalWgpuTexture', () => {
+  it('resolves a borrowed handle and forgets it without destroying the allocation', async () => {
+    const state = await createWgpuRenderStateForTest();
+    const destroy = vi.fn();
+    const handle = { createView: vi.fn(() => ({})), destroy } as unknown as GPUTexture;
+    const texture = createExternalWgpuTexture(state, handle, { height: 16, width: 32 });
+
+    expect(getTextureBackingKind(texture)).toBe(ExternalTextureBackingKind);
+    expect(resolveWgpuTexture(state, texture)?.texture).toBe(handle);
+    expect(disposeExternalWgpuTexture(state, texture)).toBe(true);
+    expect(resolveWgpuTexture(state, texture)).toBeNull();
+    expect(destroy).not.toHaveBeenCalled();
+  });
+});
+
+describe('disposeExternalWgpuTexture', () => {
+  it('returns false after the borrowed handle has already been forgotten', async () => {
+    const state = await createWgpuRenderStateForTest();
+    const handle = { createView: () => ({}) } as unknown as GPUTexture;
+    const texture = createExternalWgpuTexture(state, handle, { height: 1, width: 1 });
+    expect(disposeExternalWgpuTexture(state, texture)).toBe(true);
+    expect(disposeExternalWgpuTexture(state, texture)).toBe(false);
+  });
+});

package/src/wgpuMaterialRegistry.test.ts

@@ -1,5 +1,5 @@
-import type { Material, WgpuMaterialRenderer, WgpuRenderState } from '@flighthq/types';
-import { DefaultMaterialKind, EntityRuntimeKey } from '@flighthq/types';
+import type { Material, WgpuMaterialRenderer, WgpuRenderState } from '@flighthq/types/contract';
+import { StandardMaterialKind, EntityRuntimeKey } from '@flighthq/types/contract';
 
 import {
   getWgpuMaterialRenderer,
@@ -47,9 +47,9 @@ describe('resolveWgpuMaterialRenderer', () => {
     expect(resolveWgpuMaterialRenderer(state, makeMaterial(TestKind))).toBe(testRenderer);
   });
 
-  it('falls back to the renderer registered for DefaultMaterialKind', () => {
+  it('falls back to the renderer registered for StandardMaterialKind', () => {
     const state = makeState();
-    registerWgpuMaterialRenderer(state, DefaultMaterialKind, testRenderer);
+    registerWgpuMaterialRenderer(state, StandardMaterialKind, testRenderer);
     expect(resolveWgpuMaterialRenderer(state, makeMaterial('Other'))).toBe(testRenderer);
     expect(resolveWgpuMaterialRenderer(state, null)).toBe(testRenderer);
   });

package/src/wgpuMipmap.test.ts

@@ -1,4 +1,4 @@
-import type { WgpuRenderState } from '@flighthq/types';
+import type { WgpuRenderState } from '@flighthq/types/contract';
 
 import { generateWgpuMipmaps, getWgpuMipLevelCount } from './wgpuMipmap';
 import { getWgpuRenderStateRuntime } from './wgpuRenderState';

package/src/wgpuRenderTarget.test.ts

@@ -1,4 +1,4 @@
-import { createMatrix } from '@flighthq/geometry';
+import { createMatrix } from '@flighthq/geometry/contract';
 
 import { renderWgpuBackground, submitWgpuRenderPass } from './wgpuBackground';
 import { getWgpuRenderStateRuntime } from './wgpuRenderState';
@@ -155,6 +155,20 @@ describe('endWgpuRenderPass', () => {
 });
 
 describe('resizeWgpuRenderTarget', () => {
+  it('preserves the allocation when dimensions are unchanged', async () => {
+    const state = await createWgpuRenderStateForTest();
+    const target = createWgpuRenderTarget(state, 64, 64);
+    const texture = target.texture;
+    const depthStencilTexture = target.depthStencilTexture;
+    const bindGroup = target.bindGroup;
+
+    resizeWgpuRenderTarget(state, target, 64, 64);
+
+    expect(target.texture).toBe(texture);
+    expect(target.depthStencilTexture).toBe(depthStencilTexture);
+    expect(target.bindGroup).toBe(bindGroup);
+  });
+
   it('updates width, height, and bind group', async () => {
     const state = await createWgpuRenderStateForTest();
     const target = createWgpuRenderTarget(state, 64, 64);

package/src/wgpuRenderTexture.test.ts

@@ -0,0 +1,99 @@
+import type { RenderTexture } from '@flighthq/types/contract';
+import { RenderTextureBackingKind } from '@flighthq/types/contract';
+
+import { renderWgpuBackground, submitWgpuRenderPass } from './wgpuBackground';
+import { getWgpuRenderStateRuntime } from './wgpuRenderState';
+import {
+  bindWgpuRenderTexture,
+  destroyWgpuRenderTexture,
+  isWgpuRenderTextureReady,
+  renderIntoWgpuRenderTexture,
+} from './wgpuRenderTexture';
+import { createWgpuRenderStateForTest, installWgpuMock } from './wgpuTestHelper';
+
+beforeAll(() => {
+  installWgpuMock();
+});
+
+function texture(): RenderTexture {
+  return {
+    colorSpace: 'linear',
+    flipX: false,
+    flipY: false,
+    sampler: {
+      anisotropy: 1,
+      magFilter: 'linear',
+      minFilter: 'linear',
+      mipmaps: false,
+      wrapU: 'clamp-to-edge',
+      wrapV: 'clamp-to-edge',
+    },
+    storage: {
+      dimension: '2d',
+      image: null,
+      target: { height: 8, kind: RenderTextureBackingKind, width: 8 },
+    },
+    uvOffset: { x: 0, y: 0 },
+    uvRotation: 0,
+    uvScale: { x: 1, y: 1 },
+    version: 0,
+  } as RenderTexture;
+}
+
+describe('bindWgpuRenderTexture', () => {
+  it('returns null before render and the state-owned target after render', async () => {
+    const state = await createWgpuRenderStateForTest();
+    const renderTexture = texture();
+    expect(bindWgpuRenderTexture(state, renderTexture)).toBeNull();
+
+    renderWgpuBackground(state);
+    renderIntoWgpuRenderTexture(state, renderTexture, () => {});
+    expect(bindWgpuRenderTexture(state, renderTexture)).not.toBeNull();
+    submitWgpuRenderPass(state);
+  });
+});
+
+describe('destroyWgpuRenderTexture', () => {
+  it('destroys and removes the hidden target', async () => {
+    const state = await createWgpuRenderStateForTest();
+    const renderTexture = texture();
+    renderWgpuBackground(state);
+    renderIntoWgpuRenderTexture(state, renderTexture, () => {});
+    const entry = getWgpuRenderStateRuntime(state).wgpuRenderTextureCache!.get(renderTexture)!;
+    const destroy = vi.spyOn(entry.target.texture, 'destroy');
+
+    destroyWgpuRenderTexture(state, renderTexture);
+    expect(destroy).toHaveBeenCalled();
+    expect(bindWgpuRenderTexture(state, renderTexture)).toBeNull();
+    submitWgpuRenderPass(state);
+  });
+});
+
+describe('isWgpuRenderTextureReady', () => {
+  it('tracks the successful rendered-content transition', async () => {
+    const state = await createWgpuRenderStateForTest();
+    const renderTexture = texture();
+    expect(isWgpuRenderTextureReady(state, renderTexture)).toBe(false);
+    renderWgpuBackground(state);
+    renderIntoWgpuRenderTexture(state, renderTexture, () => {});
+    expect(isWgpuRenderTextureReady(state, renderTexture)).toBe(true);
+    submitWgpuRenderPass(state);
+  });
+});
+
+describe('renderIntoWgpuRenderTexture', () => {
+  it('restores the enclosing pass and bumps version after success', async () => {
+    const state = await createWgpuRenderStateForTest();
+    const renderTexture = texture();
+    renderWgpuBackground(state);
+    const enclosingPass = getWgpuRenderStateRuntime(state).renderPass;
+
+    renderIntoWgpuRenderTexture(state, renderTexture, () => {});
+
+    expect(renderTexture.version).toBe(1);
+    expect(renderTexture.colorSpace).toBe('linear');
+    expect(getWgpuRenderStateRuntime(state).renderPass).not.toBeNull();
+    expect(getWgpuRenderStateRuntime(state).renderPass).not.toBe(enclosingPass);
+    submitWgpuRenderPass(state);
+  });
+});

package/src/wgpuShader.test.ts

@@ -1,4 +1,4 @@
-import { AdvancedBlendMode, BlendMode } from '@flighthq/types';
+import { AdvancedBlendMode, BlendMode } from '@flighthq/types/contract';
 
 import { renderWgpuBackground } from './wgpuBackground';
 import { getWgpuRenderStateRuntime } from './wgpuRenderState';
@@ -159,7 +159,7 @@ describe('writeWgpuMatrixOnlyUniforms', () => {
     const runtime = getWgpuRenderStateRuntime(state);
     renderWgpuBackground(state);
     const before = runtime.uniformOffset;
-    const fakeNode = { alpha: 1, useColorTransform: false, colorTransform: null };
+    const fakeNode = { alpha: 1, useColorScaleBias: false, colorScaleBias: null };
     const t = { a: 1, b: 0, c: 0, d: 1, tx: 0, ty: 0 };
     writeWgpuMatrixOnlyUniforms(state, fakeNode as never, t, 0, 0, 10, 10, 0, 0, 1, 1);
     expect(runtime.uniformOffset).toBe(before + runtime.uniformStride);
@@ -174,8 +174,8 @@ describe('writeWgpuQuadUniforms', () => {
     const before = runtime.uniformOffset;
     const fakeNode = {
       alpha: 1,
-      useColorTransform: false,
-      colorTransform: null,
+      useColorScaleBias: false,
+      colorScaleBias: null,
       transform2D: { a: 1, b: 0, c: 0, d: 1, tx: 0, ty: 0 },
     };
     writeWgpuQuadUniforms(state, fakeNode, null, 0, 0, 100, 100, 0, 0, 1, 1);
@@ -188,8 +188,8 @@ describe('writeWgpuQuadUniforms', () => {
     renderWgpuBackground(state);
     const fakeNode = {
       alpha: 0.5,
-      useColorTransform: false,
-      colorTransform: null,
+      useColorScaleBias: false,
+      colorScaleBias: null,
       transform2D: { a: 1, b: 0, c: 0, d: 1, tx: 0, ty: 0 },
     };
     const offset = writeWgpuQuadUniforms(state, fakeNode, null, 10, 20, 30, 40, 0.1, 0.2, 0.9, 0.8);
@@ -208,8 +208,8 @@ describe('writeWgpuQuadUniforms', () => {
     renderWgpuBackground(state);
     const fakeNode = {
       alpha: 1,
-      useColorTransform: false,
-      colorTransform: null,
+      useColorScaleBias: false,
+      colorScaleBias: null,
       transform2D: { a: 1, b: 0, c: 0, d: 1, tx: 0, ty: 0 },
     };