@flighthq/render-wgpu 0.5.1-next.920.da8f530 → 0.6.0

package/dist/wgpuTextureUpload.js

@@ -1,4 +1,4 @@
-import { tryCopyWgpuExternalImageToTexture } from './wgpuExternalImageSource';
+import { tryCopyWgpuExternalImageToTexture } from './wgpuExternalImageSource.js';
 // Texel-upload primitives for one texture region. Each writes into `texture` at `origin` (the [x, y, z]
 // where z selects a cube-array layer / cube face). The wgpu mirror of render-gl's glTextureUpload; the
 // caller owns texture creation and format.

package/dist/wgpuTextureUpload.js.map

@@ -1 +1 @@
-{"version":3,"file":"wgpuTextureUpload.js","sourceRoot":"","sources":["../src/wgpuTextureUpload.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,iCAAiC,EAAE,MAAM,2BAA2B,CAAC;AAE9E,wGAAwG;AACxG,uGAAuG;AACvG,2CAA2C;AAE3C,0GAA0G;AAC1G,2GAA2G;AAC3G,wCAAwC;AACxC,MAAM,UAAU,qBAAqB,CACnC,MAAiB,EACjB,OAAmB,EACnB,MAAmB,EACnB,KAAa,EACb,MAAc,EACd,IAA8C;IAE9C,MAAM,CAAC,KAAK,CAAC,YAAY,CACvB,EAAE,OAAO,EAAE,MAAM,EAAE,EACnB,IAAsC,EACtC,EAAE,WAAW,EAAE,KAAK,GAAG,CAAC,EAAE,YAAY,EAAE,MAAM,EAAE,EAChD,CAAC,KAAK,EAAE,MAAM,EAAE,CAAC,CAAC,CACnB,CAAC;AACJ,CAAC;AAED,uGAAuG;AACvG,kDAAkD;AAClD,MAAM,UAAU,wBAAwB,CACtC,MAAiB,EACjB,OAAmB,EACnB,MAAmB,EACnB,KAAa,EACb,MAAc,EACd,MAAkC;IAElC,iCAAiC,CAAC,MAAM,CAAC,KAAK,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,OAAO,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,MAAM,CAAC,CAAC;AAClG,CAAC;AAED,6EAA6E;AAC7E,MAAM,UAAU,8BAA8B,CAC5C,MAAiB,EACjB,OAAmB,EACnB,MAAmB,EACnB,KAA8B;IAE9B,wBAAwB,CACtB,MAAM,EACN,OAAO,EACP,MAAM,EACN,KAAK,CAAC,KAAK,EACX,KAAK,CAAC,MAAM,EACZ,KAAK,CAAC,MAAoC,CAC3C,CAAC;AACJ,CAAC"}
+{"version":3,"file":"wgpuTextureUpload.js","sourceRoot":"","sources":["../src/wgpuTextureUpload.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,iCAAiC,EAAE,MAAM,8BAA8B,CAAC;AAEjF,wGAAwG;AACxG,uGAAuG;AACvG,2CAA2C;AAE3C,0GAA0G;AAC1G,2GAA2G;AAC3G,wCAAwC;AACxC,MAAM,UAAU,qBAAqB,CACnC,MAAkB,EAClB,OAAoB,EACpB,MAAoB,EACpB,KAAa,EACb,MAAc,EACd,IAAuC;IAEvC,MAAM,CAAC,KAAK,CAAC,YAAY,CACvB,EAAE,OAAO,EAAE,MAAM,EAAE,EACnB,IAA+B,EAC/B,EAAE,WAAW,EAAE,KAAK,GAAG,CAAC,EAAE,YAAY,EAAE,MAAM,EAAE,EAChD,CAAC,KAAK,EAAE,MAAM,EAAE,CAAC,CAAC,CACnB,CAAC;AACJ,CAAC;AAED,uGAAuG;AACvG,kDAAkD;AAClD,MAAM,UAAU,wBAAwB,CACtC,MAAkB,EAClB,OAAoB,EACpB,MAAoB,EACpB,KAAa,EACb,MAAc,EACd,MAA+B;IAE/B,iCAAiC,CAAC,MAAM,CAAC,KAAK,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,OAAO,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,MAAM,CAAC,CAAC;AAClG,CAAC;AAED,6EAA6E;AAC7E,MAAM,UAAU,8BAA8B,CAC5C,MAAkB,EAClB,OAAoB,EACpB,MAAoB,EACpB,KAA8B;IAE9B,wBAAwB,CAAC,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,KAAK,EAAE,KAAK,CAAC,MAAM,EAAE,KAAK,CAAC,MAAiC,CAAC,CAAC;AACxH,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flighthq/render-wgpu",
-  "version": "0.5.1-next.920.da8f530",
+  "version": "0.6.0",
   "author": "Joshua Granick and other contributors",
   "license": "MIT",
   "repository": {
@@ -19,6 +19,10 @@
     "./contract": {
       "types": "./dist/contract.d.ts",
       "default": "./dist/contract.js"
+    },
+    "./compressed-texture-decoder-contract": {
+      "types": "./dist/compressed-texture-decoder-contract/compressedTextureDecoderContract.d.ts",
+      "default": "./dist/compressed-texture-decoder-contract/compressedTextureDecoderContract.js"
     }
   },
   "files": [
@@ -32,30 +36,46 @@
   "scripts": {
     "build": "tsc -b",
     "clean": "tsc -b --clean",
+    "generate": "tsx ../../scripts/generate-rust-package.ts --crate flight-render-wgpu --package render-wgpu",
+    "generate:check": "tsx ../../scripts/generate-rust-package.ts --crate flight-render-wgpu --package render-wgpu --check",
     "test": "vitest run --config vitest.config.ts",
     "test:watch": "vitest --watch --config vitest.config.ts",
     "prepack": "npm run clean && npm run clean:dist && npm run build",
     "clean:dist": "tsx ../../scripts/clean-package-dist.ts"
   },
   "dependencies": {
-    "@flighthq/color": "0.5.1-next.920.da8f530",
-    "@flighthq/entity": "0.5.1-next.920.da8f530",
-    "@flighthq/geometry": "0.5.1-next.920.da8f530",
-    "@flighthq/log": "0.5.1-next.920.da8f530",
-    "@flighthq/render": "0.5.1-next.920.da8f530",
-    "@flighthq/registry": "0.5.1-next.920.da8f530",
-    "@flighthq/signals": "0.5.1-next.920.da8f530",
-    "@flighthq/bitmap": "0.5.1-next.920.da8f530",
-    "@flighthq/texture": "0.5.1-next.920.da8f530",
-    "@flighthq/types": "0.5.1-next.920.da8f530"
+    "@flighthq/adjustments": "0.6.0",
+    "@flighthq/app": "0.6.0",
+    "@flighthq/bitmap": "0.6.0",
+    "@flighthq/camera": "0.6.0",
+    "@flighthq/color": "0.6.0",
+    "@flighthq/effects": "0.6.0",
+    "@flighthq/entity": "0.6.0",
+    "@flighthq/geometry": "0.6.0",
+    "@flighthq/image": "0.6.0",
+    "@flighthq/lighting": "0.6.0",
+    "@flighthq/log": "0.6.0",
+    "@flighthq/materials": "0.6.0",
+    "@flighthq/meshgeometry": "0.6.0",
+    "@flighthq/node": "0.6.0",
+    "@flighthq/platform": "0.6.0",
+    "@flighthq/registry": "0.6.0",
+    "@flighthq/render": "0.6.0",
+    "@flighthq/scene2d": "0.6.0",
+    "@flighthq/scene3d": "0.6.0",
+    "@flighthq/shading": "0.6.0",
+    "@flighthq/signals": "0.6.0",
+    "@flighthq/surface": "0.6.0",
+    "@flighthq/texture": "0.6.0",
+    "@flighthq/texture-formats": "0.6.0",
+    "@flighthq/velocity": "0.6.0"
   },
   "peerDependencies": {
     "@webgpu/types": "^0.1.70"
   },
   "devDependencies": {
-    "@flighthq/scene2d": "*",
     "@webgpu/types": "*",
-    "typescript": "^5.3.0"
+    "typescript": "^7.0.2"
   },
   "description": "WebGPU renderer core: render state, targets, shaders, draw, surface, and background",
   "sideEffects": false

package/src/enableWgpuTextureResolverGuards.test.ts

@@ -1,15 +1,30 @@
-import { addLogSink, createMemoryLogSink, getMemoryLogSinkEntries, removeLogSink } from '@flighthq/log/contract';
+import type { ImageResource } from '@flighthq/image/contract';
+import {
+  addLogSink,
+  createLogState,
+  createMemoryLogSink,
+  getMemoryLogSinkEntries,
+  removeLogSink,
+} from '@flighthq/log/contract';
+import type { LogState } from '@flighthq/log/contract';
+import type { LogEntry, MemoryLogSink } from '@flighthq/log/contract';
 import { createTexture } from '@flighthq/texture/contract';
-import type { ImageResource } from '@flighthq/types/contract';
 
 import {
   areWgpuTextureResolverGuardsEnabled,
   enableWgpuTextureResolverGuards,
-} from './enableWgpuTextureResolverGuards';
-import { bindWgpuTexture } from './wgpuDraw';
-import { getWgpuRenderStateRuntime } from './wgpuRenderState';
-import { createWgpuRenderStateForTest, installWgpuMock } from './wgpuTestHelper';
-import { registerWgpuTextureResolver, resolveWgpuTexture } from './wgpuTextureResolver';
+} from './enableWgpuTextureResolverGuards.ts';
+import { bindWgpuTexture } from './wgpuDraw.ts';
+import { getWgpuRenderStateRuntime } from './wgpuRenderState.ts';
+import { createWgpuRenderStateForTest, installWgpuMock } from './wgpuTestHelper.ts';
+import { registerWgpuTextureResolver, resolveWgpuTexture } from './wgpuTextureResolver.ts';
+
+// Each test logs into a fresh caller-owned state, so logOnce keys never leak between tests.
+let logState: LogState;
+
+beforeEach(() => {
+  logState = createLogState();
+});
 
 beforeAll(() => {
   installWgpuMock();
@@ -20,7 +35,7 @@ describe('areWgpuTextureResolverGuardsEnabled', () => {
     const state = await createWgpuRenderStateForTest();
     expect(areWgpuTextureResolverGuardsEnabled(state)).toBe(false);
 
-    enableWgpuTextureResolverGuards(state);
+    enableWgpuTextureResolverGuards(state, logState);
     expect(areWgpuTextureResolverGuardsEnabled(state)).toBe(true);
   });
 });
@@ -28,8 +43,8 @@ describe('areWgpuTextureResolverGuardsEnabled', () => {
 describe('enableWgpuTextureResolverGuards', () => {
   it('is idempotent', async () => {
     const state = await createWgpuRenderStateForTest();
-    enableWgpuTextureResolverGuards(state);
-    enableWgpuTextureResolverGuards(state);
+    enableWgpuTextureResolverGuards(state, logState);
+    enableWgpuTextureResolverGuards(state, logState);
     expect(areWgpuTextureResolverGuardsEnabled(state)).toBe(true);
   });
 
@@ -38,15 +53,15 @@ describe('enableWgpuTextureResolverGuards', () => {
     const missing = textureWithKind('acme.missing.wgpu');
     const registered = textureWithKind('acme.registered.wgpu');
     const sink = createMemoryLogSink(4);
-    addLogSink(sink.sink);
-    enableWgpuTextureResolverGuards(state);
+    addLogSink(logState, sink.sink);
+    enableWgpuTextureResolverGuards(state, logState);
     registerWgpuTextureResolver(state, 'acme.registered.wgpu', () => null);
     try {
       expect(resolveWgpuTexture(state, missing)).toBeNull();
       expect(resolveWgpuTexture(state, missing)).toBeNull();
       expect(resolveWgpuTexture(state, registered)).toBeNull();
 
-      const entries = getMemoryLogSinkEntries(sink);
+      const entries = readMemoryLogEntries(sink);
       expect(entries).toHaveLength(1);
       expect(entries[0]?.data).toMatchObject({
         kind: 'acme.missing.wgpu',
@@ -54,35 +69,35 @@ describe('enableWgpuTextureResolverGuards', () => {
           'resolveWgpuTexture: texture source kind has no registered resolver — call registerWgpuTextureResolver(state, sourceKind, resolver)',
       });
     } finally {
-      removeLogSink(sink.sink);
+      removeLogSink(logState, sink.sink);
     }
   });
 
   it('installs the mipmap-degraded guard on the runtime', async () => {
     const state = await createWgpuRenderStateForTest();
     expect(getWgpuRenderStateRuntime(state).mipmapDegradedGuard).toBeNull();
-    enableWgpuTextureResolverGuards(state);
+    enableWgpuTextureResolverGuards(state, logState);
     expect(getWgpuRenderStateRuntime(state).mipmapDegradedGuard).not.toBeNull();
   });
 
   it('logs a warning when mipmaps are requested without a registered generator', async () => {
     const state = await createWgpuRenderStateForTest();
     const sink = createMemoryLogSink(4);
-    addLogSink(sink.sink);
-    enableWgpuTextureResolverGuards(state);
+    addLogSink(logState, sink.sink);
+    enableWgpuTextureResolverGuards(state, logState);
     try {
       const canvas = document.createElement('canvas');
       canvas.width = 8;
       canvas.height = 8;
       bindWgpuTexture(state, canvas, true);
 
-      const entries = getMemoryLogSinkEntries(sink);
+      const entries = readMemoryLogEntries(sink);
       expect(entries).toHaveLength(1);
       expect(entries[0]?.data).toMatchObject({
         message: expect.stringContaining('no WGPU mipmap generator registered'),
       });
     } finally {
-      removeLogSink(sink.sink);
+      removeLogSink(logState, sink.sink);
     }
   });
 });
@@ -93,3 +108,9 @@ function textureWithKind(kind: string) {
     source: { kind } as ImageResource,
   });
 }
+
+function readMemoryLogEntries(handle: Readonly<MemoryLogSink>): LogEntry[] {
+  const entries: LogEntry[] = [];
+  getMemoryLogSinkEntries(entries, handle);
+  return entries;
+}

package/src/explainWgpuTextureResolution.test.ts

@@ -1,10 +1,10 @@
-import { allocateEntity, finishEntity } from '@flighthq/entity/contract';
+import { allocateEntity } from '@flighthq/entity/contract';
 import { createTexture } from '@flighthq/texture/contract';
-import type { TextureSource } from '@flighthq/types/contract';
+import type { TextureSource } from '@flighthq/texture/contract';
 
-import { explainWgpuTextureResolution } from './explainWgpuTextureResolution';
-import { createWgpuRenderStateForTest, installWgpuMock } from './wgpuTestHelper';
-import { registerWgpuTextureResolver } from './wgpuTextureResolver';
+import { explainWgpuTextureResolution } from './explainWgpuTextureResolution.ts';
+import { createWgpuRenderStateForTest, installWgpuMock } from './wgpuTestHelper.ts';
+import { registerWgpuTextureResolver } from './wgpuTextureResolver.ts';
 
 beforeAll(() => {
   installWgpuMock();
@@ -21,7 +21,7 @@ describe('explainWgpuTextureResolution', () => {
         out.kind = 'acme.test';
         out.version = 0;
         out.width = 1;
-        return finishEntity(out) as TextureSource;
+        return out as TextureSource;
       })(),
     });
 

package/src/explainWgpuUniformEndianness.test.ts

@@ -0,0 +1,11 @@
+import { describe, expect, it } from 'vitest';
+
+import { explainWgpuUniformEndianness } from './explainWgpuUniformEndianness.ts';
+
+describe('explainWgpuUniformEndianness', () => {
+  it('reports the host endianness and validation status', () => {
+    const result = explainWgpuUniformEndianness();
+    expect(result.endianness).toBe('little');
+    expect(result.status).toBe('validated');
+  });
+});

package/src/types/WgpuBindGroupLayout.test.ts

@@ -0,0 +1,9 @@
+import { describe, expect, it } from 'vitest';
+
+import { WgpuShaderStage } from './WgpuBindGroupLayout.ts';
+
+describe('WgpuShaderStage', () => {
+  it('carries the WGPU shader stage bits', () => {
+    expect(WgpuShaderStage).toEqual({ COMPUTE: 4, FRAGMENT: 2, VERTEX: 1 });
+  });
+});

package/src/types/WgpuBuffer.test.ts

@@ -0,0 +1,26 @@
+import { describe, expect, it } from 'vitest';
+
+import { WgpuBufferUsage, WgpuMapMode } from './WgpuBuffer.ts';
+
+describe('WgpuBufferUsage', () => {
+  it('carries the WGPU buffer usage bits', () => {
+    expect(WgpuBufferUsage).toEqual({
+      COPY_DST: 8,
+      COPY_SRC: 4,
+      INDEX: 16,
+      INDIRECT: 256,
+      MAP_READ: 1,
+      MAP_WRITE: 2,
+      QUERY_RESOLVE: 512,
+      STORAGE: 128,
+      UNIFORM: 64,
+      VERTEX: 32,
+    });
+  });
+});
+
+describe('WgpuMapMode', () => {
+  it('carries the WGPU map mode bits', () => {
+    expect(WgpuMapMode).toEqual({ READ: 1, WRITE: 2 });
+  });
+});

package/src/types/WgpuGpu.test.ts

@@ -0,0 +1,56 @@
+import { describe, expect, it } from 'vitest';
+
+import type { WgpuAdapter } from './WgpuAdapter.ts';
+import type { WgpuBuffer } from './WgpuBuffer.ts';
+import type { WgpuCanvasContext } from './WgpuCanvasContext.ts';
+import type { WgpuCommandEncoder } from './WgpuCommandEncoder.ts';
+import type { WgpuDevice } from './WgpuDevice.ts';
+import type { WgpuGpu } from './WgpuGpu.ts';
+import type { WgpuQueue } from './WgpuQueue.ts';
+import type { WgpuRenderPassEncoder } from './WgpuRenderPassEncoder.ts';
+import type { WgpuTexture } from './WgpuTexture.ts';
+import type { WgpuTextureFormat } from './WgpuTextureFormat.ts';
+
+// The Flight types are the contract; the browser's objects are one provider of it. Each assignment below
+// fails to compile when the browser's typings stop satisfying a Flight type, which is the drift that would
+// otherwise force a cast at the web host boundary.
+describe('WgpuGpu', () => {
+  it('is satisfied by the browser WebGPU objects without a cast', () => {
+    const conform = (
+      gpu: GPU,
+      adapter: GPUAdapter,
+      device: GPUDevice,
+      queue: GPUQueue,
+      encoder: GPUCommandEncoder,
+      pass: GPURenderPassEncoder,
+      buffer: GPUBuffer,
+      texture: GPUTexture,
+      context: GPUCanvasContext,
+      format: GPUTextureFormat,
+    ): readonly unknown[] => {
+      const flightGpu: WgpuGpu = gpu;
+      const flightAdapter: WgpuAdapter = adapter;
+      const flightDevice: WgpuDevice = device;
+      const flightQueue: WgpuQueue = queue;
+      const flightEncoder: WgpuCommandEncoder = encoder;
+      const flightPass: WgpuRenderPassEncoder = pass;
+      const flightBuffer: WgpuBuffer = buffer;
+      const flightTexture: WgpuTexture = texture;
+      const flightContext: WgpuCanvasContext = context;
+      const flightFormat: WgpuTextureFormat = format;
+      return [
+        flightGpu,
+        flightAdapter,
+        flightDevice,
+        flightQueue,
+        flightEncoder,
+        flightPass,
+        flightBuffer,
+        flightTexture,
+        flightContext,
+        flightFormat,
+      ];
+    };
+    expect(typeof conform).toBe('function');
+  });
+});

package/src/types/WgpuRenderPipeline.test.ts

@@ -0,0 +1,12 @@
+import { describe, expect, it } from 'vitest';
+
+import { WgpuColorWrite } from './WgpuRenderPipeline.ts';
+
+describe('WgpuColorWrite', () => {
+  it('carries the WGPU color write bits, with ALL as their union', () => {
+    expect(WgpuColorWrite).toEqual({ ALL: 15, ALPHA: 8, BLUE: 4, GREEN: 2, RED: 1 });
+    expect(WgpuColorWrite.RED | WgpuColorWrite.GREEN | WgpuColorWrite.BLUE | WgpuColorWrite.ALPHA).toBe(
+      WgpuColorWrite.ALL,
+    );
+  });
+});

package/src/types/WgpuTexture.test.ts

@@ -0,0 +1,15 @@
+import { describe, expect, it } from 'vitest';
+
+import { WgpuTextureUsage } from './WgpuTexture.ts';
+
+describe('WgpuTextureUsage', () => {
+  it('carries the WGPU texture usage bits', () => {
+    expect(WgpuTextureUsage).toEqual({
+      COPY_DST: 2,
+      COPY_SRC: 1,
+      RENDER_ATTACHMENT: 16,
+      STORAGE_BINDING: 8,
+      TEXTURE_BINDING: 4,
+    });
+  });
+});

package/src/wgpuAdapterCapabilities.test.ts

@@ -1,10 +1,11 @@
-import { getWgpuAdapterCapabilities } from './wgpuAdapterCapabilities';
+import type { WgpuAdapter } from './contract.render-wgpu-types.ts';
+import { getWgpuAdapterCapabilities } from './wgpuAdapterCapabilities.ts';
 
-function makeAdapter(features: ReadonlyArray<string> = [], limits: Record<string, number> = {}): GPUAdapter {
+function makeAdapter(features: ReadonlyArray<string> = [], limits: Record<string, number> = {}): WgpuAdapter {
   return {
     features: new Set(features),
     limits: { maxTextureDimension2D: 8192, ...limits },
-  } as unknown as GPUAdapter;
+  } as unknown as WgpuAdapter;
 }
 
 describe('getWgpuAdapterCapabilities', () => {
@@ -37,7 +38,7 @@ describe('getWgpuAdapterCapabilities', () => {
     const adapter = {
       features: new Set(),
       limits: {},
-    } as unknown as GPUAdapter;
+    } as unknown as WgpuAdapter;
     const caps = getWgpuAdapterCapabilities(adapter);
     expect(caps.maxTextureDimension2D).toBe(8192);
   });

package/src/wgpuCompressedTexture.test.ts

@@ -1,6 +1,8 @@
-import type { CompressedImageResource, TextureContainer, WgpuCompressedTextureSupport } from '@flighthq/types/contract';
-import { CompressedImageTextureSourceKind, RegistryEntryState } from '@flighthq/types/contract';
+import type { CompressedImageResource } from '@flighthq/image/contract';
+import type { TextureContainer, TextureContainerFormat } from '@flighthq/texture-formats/contract';
+import { CompressedImageTextureSourceKind } from '@flighthq/texture/contract';
 
+import type { WgpuCompressedTextureSupport, WgpuFeatureName } from './contract.render-wgpu-types.ts';
 import {
   detectWgpuCompressedTextureSupport,
   getWgpuCompressedTextureFormat,
@@ -8,10 +10,10 @@ import {
   registerWgpuCompressedTextureDecoder,
   registerWgpuCompressedTextureUpload,
   uploadWgpuCompressedTextureContainer,
-} from './wgpuCompressedTexture';
-import { bindWgpuCompressedImageTexture } from './wgpuDraw';
-import { getWgpuRenderStateRuntime } from './wgpuRenderState';
-import { createWgpuRenderStateForTest, installWgpuMock } from './wgpuTestHelper';
+} from './wgpuCompressedTexture.ts';
+import { bindWgpuCompressedImageTexture } from './wgpuDraw.ts';
+import { getWgpuRenderStateRuntime } from './wgpuRenderState.ts';
+import { createWgpuRenderStateForTest, installWgpuMock } from './wgpuTestHelper.ts';
 
 beforeAll(() => installWgpuMock());
 
@@ -43,7 +45,7 @@ function compressedImage(): CompressedImageResource {
 describe('detectWgpuCompressedTextureSupport', () => {
   it('reads the three WebGPU compression features', async () => {
     const state = await createWgpuRenderStateForTest();
-    (state.device.features as Set<GPUFeatureName>).add('texture-compression-bc');
+    (state.device.features as Set<WgpuFeatureName>).add('texture-compression-bc');
     expect(detectWgpuCompressedTextureSupport(state.device)).toEqual({ astc: false, bc: true, etc2: false });
   });
 });
@@ -52,7 +54,7 @@ describe('getWgpuCompressedTextureFormat', () => {
   it('maps a format only when its family is enabled', async () => {
     const state = await createWgpuRenderStateForTest();
     expect(getWgpuCompressedTextureFormat(state.device, 'bc1')).toBeNull();
-    (state.device.features as Set<GPUFeatureName>).add('texture-compression-bc');
+    (state.device.features as Set<WgpuFeatureName>).add('texture-compression-bc');
     expect(getWgpuCompressedTextureFormat(state.device, 'bc1')).toBe('bc1-rgba-unorm');
     expect(getWgpuCompressedTextureFormat(state.device, 'rgba8unorm')).toBeNull();
   });
@@ -73,15 +75,12 @@ describe('registerWgpuCompressedTextureDecoder', () => {
     const state = await createWgpuRenderStateForTest();
     const runtime = getWgpuRenderStateRuntime(state);
     const before = runtime.registries.compressedTextureDecoder;
-    const decoder = vi.fn(() => new Uint8ClampedArray(64));
+    const decoder = vi.fn(() => new Uint8Array(64));
     registerWgpuCompressedTextureDecoder(state, decoder);
     expect(runtime.registries.compressedTextureDecoder).not.toBe(before);
-    expect(runtime.registries.compressedTextureDecoder.entry).toEqual({
-      state: RegistryEntryState.Bound,
-      value: decoder,
-    });
+    expect(runtime.registries.compressedTextureDecoder).toEqual(decoder);
     registerWgpuCompressedTextureDecoder(state, null);
-    expect(runtime.registries.compressedTextureDecoder.entry).toBeNull();
+    expect(runtime.registries.compressedTextureDecoder).toBeNull();
   });
 });
 
@@ -90,21 +89,18 @@ describe('registerWgpuCompressedTextureUpload', () => {
     const state = await createWgpuRenderStateForTest();
     const runtime = getWgpuRenderStateRuntime(state);
     const before = runtime.registries.compressedTextureUpload;
-    registerWgpuCompressedTextureUpload(state);
+    registerWgpuCompressedTextureUpload(state, true);
     expect(runtime.registries.compressedTextureUpload).not.toBe(before);
-    expect(runtime.registries.compressedTextureUpload.entry).toMatchObject({
-      state: RegistryEntryState.Bound,
-      value: expect.any(Function),
-    });
-    registerWgpuCompressedTextureUpload(state, null);
-    expect(runtime.registries.compressedTextureUpload.entry).toBeNull();
+    expect(runtime.registries.compressedTextureUpload).toMatchObject(expect.any(Function));
+    registerWgpuCompressedTextureUpload(state, false);
+    expect(runtime.registries.compressedTextureUpload).toBeNull();
   });
 
   it('lets the compressed-image binder consume its source', async () => {
     const state = await createWgpuRenderStateForTest();
-    registerWgpuCompressedTextureUpload(state);
-    registerWgpuCompressedTextureDecoder(state, (_format, width, height) => {
-      return new Uint8ClampedArray(width * height * 4);
+    registerWgpuCompressedTextureUpload(state, true);
+    registerWgpuCompressedTextureDecoder(state, (_format: TextureContainerFormat, width: number, height: number) => {
+      return new Uint8Array(width * height * 4);
     });
     const writeTexture = vi.spyOn(state.device.queue, 'writeTexture');
     expect(bindWgpuCompressedImageTexture(state, compressedImage())?.view).toBeDefined();
@@ -113,9 +109,9 @@ describe('registerWgpuCompressedTextureUpload', () => {
 
   it('premultiplies straight-alpha decoder output before the RGBA upload', async () => {
     const state = await createWgpuRenderStateForTest();
-    registerWgpuCompressedTextureUpload(state);
-    registerWgpuCompressedTextureDecoder(state, (_format, width, height) => {
-      const rgba = new Uint8ClampedArray(width * height * 4);
+    registerWgpuCompressedTextureUpload(state, true);
+    registerWgpuCompressedTextureDecoder(state, (_format: TextureContainerFormat, width: number, height: number) => {
+      const rgba = new Uint8Array(width * height * 4);
       for (let i = 0; i < rgba.length; i += 4) {
         rgba[i] = 255;
         rgba[i + 1] = 64;
@@ -128,13 +124,13 @@ describe('registerWgpuCompressedTextureUpload', () => {
     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]);
+    expect(Array.from(writeTexture.mock.calls[0][1] as Uint8Array).slice(0, 4)).toEqual([128, 32, 0, 128]);
   });
 
   it('marks native straight-alpha blocks for display-shader premultiplication', async () => {
     const state = await createWgpuRenderStateForTest();
-    (state.device.features as Set<GPUFeatureName>).add('texture-compression-bc');
-    registerWgpuCompressedTextureUpload(state);
+    (state.device.features as Set<WgpuFeatureName>).add('texture-compression-bc');
+    registerWgpuCompressedTextureUpload(state, true);
     expect(bindWgpuCompressedImageTexture(state, compressedImage())?.straightAlpha).toBe(true);
   });
 });
@@ -142,7 +138,7 @@ describe('registerWgpuCompressedTextureUpload', () => {
 describe('uploadWgpuCompressedTextureContainer', () => {
   it('uploads native blocks with their block-row layout', async () => {
     const state = await createWgpuRenderStateForTest();
-    (state.device.features as Set<GPUFeatureName>).add('texture-compression-bc');
+    (state.device.features as Set<WgpuFeatureName>).add('texture-compression-bc');
     const createTexture = vi.spyOn(state.device, 'createTexture');
     const writeTexture = vi.spyOn(state.device.queue, 'writeTexture');
     expect(uploadWgpuCompressedTextureContainer(state, container(), new Uint8Array(8))).not.toBeNull();
@@ -157,7 +153,7 @@ describe('uploadWgpuCompressedTextureContainer', () => {
 
   it('decodes plain 2D levels to RGBA when native support is absent', async () => {
     const state = await createWgpuRenderStateForTest();
-    const decoder = vi.fn(() => new Uint8ClampedArray(64));
+    const decoder = vi.fn(() => new Uint8Array(64));
     const createTexture = vi.spyOn(state.device, 'createTexture');
     expect(uploadWgpuCompressedTextureContainer(state, container(), new Uint8Array(8), decoder)).not.toBeNull();
     expect(decoder).toHaveBeenCalledWith('bc1', 4, 4, expect.any(Uint8Array));
@@ -171,10 +167,8 @@ describe('uploadWgpuCompressedTextureContainer', () => {
       { byteLength: 8, byteOffset: face * 40 + 32, height: 4, width: 4 },
     ]).flat();
     const cube = container({ faces: 6, height: 8, levels, mipLevels: 2, width: 8 });
-    expect(
-      uploadWgpuCompressedTextureContainer(state, cube, new Uint8Array(240), () => new Uint8ClampedArray(64)),
-    ).toBeNull();
-    (state.device.features as Set<GPUFeatureName>).add('texture-compression-bc');
+    expect(uploadWgpuCompressedTextureContainer(state, cube, new Uint8Array(240), () => new Uint8Array(64))).toBeNull();
+    (state.device.features as Set<WgpuFeatureName>).add('texture-compression-bc');
     const writeTexture = vi.spyOn(state.device.queue, 'writeTexture');
     expect(uploadWgpuCompressedTextureContainer(state, cube, new Uint8Array(240))).not.toBeNull();
     expect(writeTexture).toHaveBeenCalledTimes(12);
@@ -184,7 +178,7 @@ describe('uploadWgpuCompressedTextureContainer', () => {
 
   it('maps canonical multi-mip array entries to the right mip and layer slice', async () => {
     const state = await createWgpuRenderStateForTest();
-    (state.device.features as Set<GPUFeatureName>).add('texture-compression-bc');
+    (state.device.features as Set<WgpuFeatureName>).add('texture-compression-bc');
     const array = container({
       height: 8,
       layers: 2,