@flighthq/render-wgpu 0.3.0-next.906.07cea63 → 0.3.1-next.209.43ef1bc

package/src/wgpuDraw.test.ts

@@ -1,11 +1,20 @@
 import { getOrCreateRenderProxy2D, prepareScene2DRender } from '@flighthq/render/contract';
-import { createBitmap } from '@flighthq/scene2d/contract';
-import type { ImageResource, Texture } from '@flighthq/types/contract';
-import { BlendMode } from '@flighthq/types/contract';
+import { createSprite } from '@flighthq/scene2d/contract';
+import { getTextureSource } from '@flighthq/texture/contract';
+import type { Bitmap, CompressedImage, Image, Texture, WgpuTextureEntry } from '@flighthq/types/contract';
+import {
+  BitmapTextureSourceKind,
+  BlendMode,
+  CompressedImageTextureSourceKind,
+  ImageTextureSourceKind,
+} from '@flighthq/types/contract';
 
 import { renderWgpuBackground, submitWgpuRenderPass } from './wgpuBackground';
+import { registerWgpuCompressedTextureDecoder, registerWgpuCompressedTextureUpload } from './wgpuCompressedTexture';
 import {
   applyWgpuBlendMode,
+  bindWgpuBitmapTexture,
+  bindWgpuCompressedImageTexture,
   bindWgpuImageResourceTexture,
   bindWgpuTexture,
   bindWgpuVideoTexture,
@@ -28,6 +37,47 @@ beforeAll(() => {
   installWgpuMock();
 });
 
+function requireTextureEntry(entry: WgpuTextureEntry | null): WgpuTextureEntry {
+  if (entry === null) throw new Error('Expected a ready WebGPU texture entry');
+  return entry;
+}
+
+function bitmap(size: number, version: number): Bitmap {
+  return {
+    alphaType: 'straight',
+    colorSpace: 'srgb',
+    data: new Uint8ClampedArray(size * size * 4),
+    format: 'rgba8unorm',
+    height: size,
+    kind: BitmapTextureSourceKind,
+    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: CompressedImageTextureSourceKind,
+    version: 1,
+    width: 4,
+  } as unknown as CompressedImage;
+}
+
 describe('applyWgpuBlendMode', () => {
   it('updates currentBlendMode on the state', async () => {
     const state = await createWgpuRenderStateForTest();
@@ -42,27 +92,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,25 +139,52 @@ describe('bindWgpuImageResourceTexture', () => {
     canvas.height = 4;
     const image = {
       source: canvas,
-      data: null,
       width: 4,
       height: 4,
+      kind: ImageTextureSourceKind,
       version: 1,
-      alphaType: 'straight',
-    } as unknown as ImageResource;
+    } as unknown as Image;
     bindWgpuImageResourceTexture(state, image);
     expect(copy).toHaveBeenCalled();
   });
 
-  it('caches by resource identity and re-uploads only when the version changes', async () => {
+  it('skips an initial upload when the canvas has no pixels', 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');
+    const copy = vi.spyOn(state.device.queue, 'copyExternalImageToTexture');
+    const canvas = document.createElement('canvas');
+    canvas.width = 0;
+    canvas.height = 4;
+    const image = {
+      source: canvas,
+      width: 0,
+      height: 4,
+      kind: ImageTextureSourceKind,
+      version: 1,
+    } as unknown as Image;
+    expect(bindWgpuImageResourceTexture(state, image)).toBeNull();
+    expect(copy).not.toHaveBeenCalled();
+  });
+
+  it('keeps the previous upload when the browser cannot snapshot the current source', async () => {
+    const state = await createWgpuRenderStateForTest();
+    const copy = vi.spyOn(state.device.queue, 'copyExternalImageToTexture');
+    const canvas = document.createElement('canvas');
+    canvas.width = 4;
+    canvas.height = 4;
+    const image = {
+      source: canvas,
+      width: 4,
+      height: 4,
+      kind: ImageTextureSourceKind,
+      version: 1,
+    } as unknown as Image;
+    const entry = requireTextureEntry(bindWgpuImageResourceTexture(state, image));
+    copy.mockImplementation(() => {
+      throw new TypeError('Failed to copy content from external image.');
+    });
     image.version = 2;
-    bindWgpuImageResourceTexture(state, image);
-    expect(createTexture).toHaveBeenCalled();
+    expect(bindWgpuImageResourceTexture(state, image)).toBe(entry);
+    expect(copy).toHaveBeenCalledTimes(2);
   });
 });
 
@@ -98,7 +194,7 @@ describe('bindWgpuTexture', () => {
     const canvas = document.createElement('canvas');
     canvas.width = 8;
     canvas.height = 8;
-    const entry = bindWgpuTexture(state, canvas);
+    const entry = requireTextureEntry(bindWgpuTexture(state, canvas));
     expect(entry).toBeDefined();
     expect(entry.texture).toBeDefined();
     expect(bindWgpuTexture(state, canvas)).toBe(entry);
@@ -130,7 +226,14 @@ describe('bindWgpuTexture', () => {
 
 describe('bindWgpuVideoTexture', () => {
   function videoTexture(version: number, readyState = 4, width = 320, height = 240): Texture {
+    const source = document.createElement('video');
+    Object.defineProperties(source, {
+      readyState: { configurable: true, value: readyState, writable: true },
+      videoHeight: { configurable: true, value: height, writable: true },
+      videoWidth: { configurable: true, value: width, writable: true },
+    });
     return {
+      colorSpace: 'srgb',
       sampler: {
         anisotropy: 1,
         magFilter: 'linear',
@@ -139,18 +242,16 @@ describe('bindWgpuVideoTexture', () => {
         wrapU: 'clamp-to-edge',
         wrapV: 'clamp-to-edge',
       },
-      storage: {
-        dimension: '2d',
-        image: {
-          source: { readyState, videoHeight: height, videoWidth: width } as HTMLVideoElement,
-          version,
-        },
+      dimension: '2d',
+      source: {
+        source,
+        version,
       },
       version,
     } as unknown as Texture;
   }
 
-  it('uploads once per backing version and caches the texture by backing identity', async () => {
+  it('uploads once per source version and caches the texture by source identity', async () => {
     const state = await createWgpuRenderStateForTest();
     const copy = vi.spyOn(state.device.queue, 'copyExternalImageToTexture');
     const video = videoTexture(1);
@@ -159,7 +260,7 @@ describe('bindWgpuVideoTexture', () => {
     expect(copy).toHaveBeenCalledTimes(1);
     expect(bindWgpuVideoTexture(state, video)).toBe(first);
     expect(copy).toHaveBeenCalledTimes(1);
-    video.storage.image!.version = 2;
+    getTextureSource(video)!.version = 2;
     expect(bindWgpuVideoTexture(state, video)).toBe(first);
     expect(copy).toHaveBeenCalledTimes(2);
   });
@@ -168,7 +269,7 @@ describe('bindWgpuVideoTexture', () => {
     const state = await createWgpuRenderStateForTest();
     const video = videoTexture(1, 1, 0, 0);
     expect(bindWgpuVideoTexture(state, video)).toBeNull();
-    const element = video.storage.image!.source as HTMLVideoElement;
+    const element = (getTextureSource(video) as Image).source as HTMLVideoElement;
     Object.assign(element, { readyState: 4, videoHeight: 120, videoWidth: 160 });
     const first = bindWgpuVideoTexture(state, video)!;
     const destroy = vi.spyOn(first.texture, 'destroy');
@@ -178,6 +279,18 @@ describe('bindWgpuVideoTexture', () => {
     expect(destroy).toHaveBeenCalled();
   });
 
+  it('realizes distinct linear and sRGB textures for one video source', async () => {
+    const state = await createWgpuRenderStateForTest();
+    const createTexture = vi.spyOn(state.device, 'createTexture');
+    const video = videoTexture(1);
+    const srgb = bindWgpuVideoTexture(state, video);
+    expect(createTexture).toHaveBeenLastCalledWith(expect.objectContaining({ format: 'rgba8unorm-srgb' }));
+    video.colorSpace = 'linear';
+    const linear = bindWgpuVideoTexture(state, video);
+    expect(linear).not.toBe(srgb);
+    expect(createTexture).toHaveBeenLastCalledWith(expect.objectContaining({ format: 'rgba8unorm' }));
+  });
+
   it('destroys and removes an uploaded video texture', async () => {
     const state = await createWgpuRenderStateForTest();
     const video = videoTexture(1);
@@ -204,7 +317,7 @@ describe('createWgpuTextureEntry', () => {
     const canvas = document.createElement('canvas');
     canvas.width = 4;
     canvas.height = 4;
-    const entry = createWgpuTextureEntry(state, 4, 4, canvas);
+    const entry = requireTextureEntry(createWgpuTextureEntry(state, 4, 4, canvas));
     expect(entry.texture).toBeDefined();
     expect(entry.bindGroup).toBeDefined();
   });
@@ -220,13 +333,13 @@ 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');
     canvas.width = 4;
     canvas.height = 4;
-    const entry = bindWgpuTexture(state, canvas);
+    const entry = requireTextureEntry(bindWgpuTexture(state, canvas));
     expect(() => drawWgpuQuad(state, renderProxy, entry, 0, 0, 4, 4, 0, 0, 1, 1)).not.toThrow();
     submitWgpuRenderPass(state);
   });
@@ -236,13 +349,13 @@ 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');
     canvas.width = 4;
     canvas.height = 4;
-    const entry = bindWgpuTexture(state, canvas);
+    const entry = requireTextureEntry(bindWgpuTexture(state, canvas));
     const t = { a: 1, b: 0, c: 0, d: 1, tx: 0, ty: 0 };
     expect(() => drawWgpuQuadWithTransform(state, renderProxy, t, entry, 0, 0, 4, 4, 0, 0, 1, 1)).not.toThrow();
     submitWgpuRenderPass(state);
@@ -270,20 +383,9 @@ describe('getWgpuRenderProxyColorScaleBias', () => {
 });
 
 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();
@@ -291,7 +393,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);
@@ -310,13 +412,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();
   });
@@ -329,7 +431,7 @@ describe('submitWgpuQuadDraw', () => {
     const canvas = document.createElement('canvas');
     canvas.width = 4;
     canvas.height = 4;
-    const entry = bindWgpuTexture(state, canvas);
+    const entry = requireTextureEntry(bindWgpuTexture(state, canvas));
     expect(() => submitWgpuQuadDraw(state, 0, entry.bindGroup)).not.toThrow();
     submitWgpuRenderPass(state);
   });
@@ -339,7 +441,7 @@ describe('submitWgpuQuadDraw', () => {
     const canvas = document.createElement('canvas');
     canvas.width = 4;
     canvas.height = 4;
-    const entry = bindWgpuTexture(state, canvas);
+    const entry = requireTextureEntry(bindWgpuTexture(state, canvas));
     expect(() => submitWgpuQuadDraw(state, 0, entry.bindGroup)).not.toThrow();
   });
 });
@@ -350,7 +452,7 @@ describe('updateWgpuTextureEntry', () => {
     const canvas = document.createElement('canvas');
     canvas.width = 4;
     canvas.height = 4;
-    const entry = createWgpuTextureEntry(state, 4, 4, canvas);
+    const entry = requireTextureEntry(createWgpuTextureEntry(state, 4, 4, canvas));
     expect(() => updateWgpuTextureEntry(state, entry, canvas)).not.toThrow();
   });
 });

package/src/wgpuExternalImageSource.test.ts

@@ -0,0 +1,89 @@
+import { isWgpuExternalImageSourceReady, tryCopyWgpuExternalImageToTexture } from './wgpuExternalImageSource';
+import { createReadyImageElementForTest } from './wgpuTestHelper';
+
+describe('isWgpuExternalImageSourceReady', () => {
+  it('accepts a dimension-valid canvas without probing or binding its context', () => {
+    const canvas = document.createElement('canvas');
+    canvas.width = 4;
+    canvas.height = 4;
+    const getContext = vi.spyOn(canvas, 'getContext');
+    expect(isWgpuExternalImageSourceReady(canvas, 4, 4)).toBe(true);
+    expect(getContext).not.toHaveBeenCalled();
+  });
+
+  it('accepts a decoded image with enough pixels', () => {
+    const image = createReadyImageElementForTest(4, 4);
+    expect(isWgpuExternalImageSourceReady(image, 4, 4)).toBe(true);
+  });
+
+  it('rejects zero extents and undersized sources', () => {
+    const canvas = document.createElement('canvas');
+    canvas.width = 4;
+    canvas.height = 4;
+    expect(isWgpuExternalImageSourceReady(canvas, 0, 4)).toBe(false);
+    expect(isWgpuExternalImageSourceReady(canvas, 5, 4)).toBe(false);
+  });
+
+  it('rejects an undecoded image element', () => {
+    const image = document.createElement('img');
+    expect(isWgpuExternalImageSourceReady(image, 1, 1)).toBe(false);
+  });
+
+  it('rejects an unrecognized source instead of failing open', () => {
+    expect(isWgpuExternalImageSourceReady({} as GPUCopyExternalImageSource, 1, 1)).toBe(false);
+  });
+});
+
+describe('tryCopyWgpuExternalImageToTexture', () => {
+  it('copies a ready source', () => {
+    const copyExternalImageToTexture = vi.fn();
+    const queue = { copyExternalImageToTexture } as unknown as GPUQueue;
+    const texture = {} as GPUTexture;
+    const source = createReadyImageElementForTest(4, 4);
+    expect(tryCopyWgpuExternalImageToTexture(queue, { source }, { texture }, 4, 4)).toBe(true);
+    expect(copyExternalImageToTexture).toHaveBeenCalledWith({ source }, { texture }, [4, 4, 1]);
+  });
+
+  it('fails closed when a canvas has no usable context', () => {
+    const canvas = document.createElement('canvas');
+    canvas.width = 4;
+    canvas.height = 4;
+    const copyExternalImageToTexture = vi.fn(() => {
+      throw new DOMException('canvas has no rendering context', 'OperationError');
+    });
+    const queue = { copyExternalImageToTexture } as unknown as GPUQueue;
+    expect(tryCopyWgpuExternalImageToTexture(queue, { source: canvas }, { texture: {} as GPUTexture }, 4, 4)).toBe(
+      false,
+    );
+  });
+
+  it('fails closed when the browser cannot snapshot current canvas content', () => {
+    const canvas = document.createElement('canvas');
+    canvas.width = 4;
+    canvas.height = 4;
+    const copyExternalImageToTexture = vi.fn(() => {
+      throw new TypeError(
+        "Failed to execute 'copyExternalImageToTexture' on 'GPUQueue': Failed to copy content from external image.",
+      );
+    });
+    const queue = { copyExternalImageToTexture } as unknown as GPUQueue;
+    expect(tryCopyWgpuExternalImageToTexture(queue, { source: canvas }, { texture: {} as GPUTexture }, 4, 4)).toBe(
+      false,
+    );
+  });
+
+  it('rethrows security failures', () => {
+    const canvas = document.createElement('canvas');
+    canvas.width = 4;
+    canvas.height = 4;
+    const error = new DOMException('tainted canvas', 'SecurityError');
+    const queue = {
+      copyExternalImageToTexture: vi.fn(() => {
+        throw error;
+      }),
+    } as unknown as GPUQueue;
+    expect(() =>
+      tryCopyWgpuExternalImageToTexture(queue, { source: canvas }, { texture: {} as GPUTexture }, 4, 4),
+    ).toThrow(error);
+  });
+});

package/src/wgpuExternalTexture.test.ts

@@ -0,0 +1,35 @@
+import { getTextureSourceKind } from '@flighthq/texture/contract';
+import { ExternalTextureSourceKind } 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(getTextureSourceKind(texture)).toBe(ExternalTextureSourceKind);
+    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,7 @@
+import { addLogSink, createMemoryLogSink, getMemoryLogSinkEntries, removeLogSink } from '@flighthq/log/contract';
+import { enableRenderRegistryGuards, explainRenderRegistryMisses } from '@flighthq/render/contract';
 import type { Material, WgpuMaterialRenderer, WgpuRenderState } from '@flighthq/types/contract';
-import { StandardMaterialKind, EntityRuntimeKey } from '@flighthq/types/contract';
+import { StandardMaterialKind, EntityRuntimeKey, RenderRegistry } from '@flighthq/types/contract';
 
 import {
   getWgpuMaterialRenderer,
@@ -12,7 +14,8 @@ const TestKind = 'TestMaterial';
 const testRenderer: WgpuMaterialRenderer = { instanceFloatCount: 0, getShaderModule: () => ({}) as GPUShaderModule };
 
 function makeState(): WgpuRenderState {
-  const state = {} as WgpuRenderState;
+  // `device` is what the guard's message table dispatches on to name the wgpu registrar.
+  const state = { device: {} } as WgpuRenderState;
   state[EntityRuntimeKey] = createWgpuRenderStateRuntime();
   return state;
 }
@@ -53,4 +56,27 @@ describe('resolveWgpuMaterialRenderer', () => {
     expect(resolveWgpuMaterialRenderer(state, makeMaterial('Other'))).toBe(testRenderer);
     expect(resolveWgpuMaterialRenderer(state, null)).toBe(testRenderer);
   });
+
+  it('reports the missing kind against the wgpu registrar, not the gl one', () => {
+    const state = makeState();
+    enableRenderRegistryGuards(state);
+    const sink = createMemoryLogSink(4);
+    addLogSink(sink.sink);
+
+    try {
+      resolveWgpuMaterialRenderer(state, makeMaterial(TestKind));
+
+      expect(explainRenderRegistryMisses(state).misses).toEqual([
+        { kind: TestKind, registry: RenderRegistry.MaterialRenderer },
+      ]);
+      expect(getMemoryLogSinkEntries(sink)[0]?.data).toMatchObject({
+        kind: TestKind,
+        message:
+          'resolveWgpuMaterialRenderer: material kind has no registered renderer, so nodes using it do not draw — call registerWgpuMaterialRenderer(state, kind, renderer)',
+        registry: RenderRegistry.MaterialRenderer,
+      });
+    } finally {
+      removeLogSink(sink.sink);
+    }
+  });
 });

package/src/wgpuMipmap.test.ts

@@ -53,10 +53,18 @@ describe('generateWgpuMipmaps', () => {
     const state = await createWgpuRenderStateForTest();
     spyEncoderPasses(state);
     generateWgpuMipmaps(state, makeTextureSpy(), 4, 4, 'rgba8unorm');
-    const pipeline = getWgpuRenderStateRuntime(state).mipmapPipeline;
+    const pipeline = getWgpuRenderStateRuntime(state).mipmapPipelineCache.get('rgba8unorm')?.pipeline;
     expect(pipeline).toBeDefined();
     generateWgpuMipmaps(state, makeTextureSpy(), 8, 8, 'rgba8unorm');
-    expect(getWgpuRenderStateRuntime(state).mipmapPipeline).toBe(pipeline);
+    expect(getWgpuRenderStateRuntime(state).mipmapPipelineCache.get('rgba8unorm')?.pipeline).toBe(pipeline);
+  });
+
+  it('keeps linear and sRGB downsample pipelines distinct', async () => {
+    const state = await createWgpuRenderStateForTest();
+    spyEncoderPasses(state);
+    generateWgpuMipmaps(state, makeTextureSpy(), 4, 4, 'rgba8unorm');
+    generateWgpuMipmaps(state, makeTextureSpy(), 4, 4, 'rgba8unorm-srgb');
+    expect(getWgpuRenderStateRuntime(state).mipmapPipelineCache.size).toBe(2);
   });
 });