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

package/src/wgpuRenderState.test.ts

@@ -1,48 +1,42 @@
-import { allocateEntity, finishEntity } from '@flighthq/entity/contract';
-import {
-  createKeyedTable,
-  getRegistryTableEntry,
-  hasRegistryTableEntry,
-  withRegistryTableEntry,
-} from '@flighthq/registry/contract';
+import { allocateEntity } from '@flighthq/entity/contract';
+import type { Entity } from '@flighthq/entity/contract';
+import { EntityRuntimeKey } from '@flighthq/entity/contract';
+import { withKindMapEntry } from '@flighthq/registry/contract';
 import {
   enableColorAdjustmentGuards,
   enableColorAdjustments,
   getColorAdjustmentUnsupportedGuard,
   getRenderStateRuntime,
   prepareScene2DRender,
-  registerRenderer,
+  registerNodeRenderer,
 } from '@flighthq/render/contract';
+import type { EffectPaddingResolver, RenderRootGuard, RenderState } from '@flighthq/render/contract';
 import { createDisplayObject } from '@flighthq/scene2d/contract';
+
 import type {
-  Entity,
-  RenderEffectPaddingResolver,
-  RenderRootGuard,
-  RenderState,
+  WgpuBindGroupLayout,
   WgpuColorAdjustmentMaterialFeature,
   WgpuColorAdjustmentMaterialFeatureGuard,
+  WgpuDevice,
+  WgpuSampler,
+  WgpuShaderModule,
+} from './contract.render-wgpu-types.ts';
+import type {
   WgpuHostAcquisition,
-  WgpuHostBackend,
-  WgpuPipeline,
-  WgpuPresentationRenderState,
-  WgpuPresentationSurface,
+  HostWgpuCapability,
   WgpuRenderOptions,
   WgpuRenderState,
-} from '@flighthq/types/contract';
-import { EntityRuntimeKey, RegistryEntryState } from '@flighthq/types/contract';
-
-import { getWgpuSurfaceRenderExtent } from './wgpuAntialias';
-import { beginWgpuFrame, withWgpuFrameBorrow } from './wgpuBackground';
-import { registerWgpuCompressedTextureDecoder, registerWgpuCompressedTextureUpload } from './wgpuCompressedTexture';
-import { setWgpuHostBackend } from './wgpuHost';
-import { registerWgpuMaterialRenderer } from './wgpuMaterialRegistry';
-import { createEmptyWgpuRegistries, createWgpuPipeline } from './wgpuPipeline';
+} from './contract.render-wgpu-types.ts';
+import { registerWgpuCompressedTextureDecoder, registerWgpuCompressedTextureUpload } from './wgpuCompressedTexture.ts';
+import { beginWgpuFrame, withWgpuFrameBorrow } from './wgpuFrame.ts';
+import { createTestWgpuSurface, testWgpuHost } from './wgpuHost.ts';
+import { registerWgpuQuadMaterialRenderer } from './wgpuQuadMaterialRegistry.ts';
 import {
-  createWgpuAcquisitionFromCanvasElement,
+  buildWgpuRenderRegistries,
+  createWgpuAcquisition,
   createWgpuDeviceState,
   createWgpuOffscreenRenderState as createDeviceOnlyWgpuRenderState,
   createWgpuRenderState as createWgpuRenderStateWithPipeline,
-  createWgpuRenderStateFromCanvasElement as createWgpuRenderStateFromCanvasElementWithPipeline,
   createWgpuRenderStateRuntime as createWgpuRenderStateRuntimeWithPipeline,
   destroyWgpuRenderState,
   getWgpuColorAdjustmentMaterialFeature,
@@ -60,9 +54,9 @@ import {
   registerWgpuRenderStateTeardown,
   releaseWgpuAcquisition,
   resolveWgpuApplyBlendMode,
-} from './wgpuRenderState';
-import { createWgpuRenderStateForTest, installWgpuMock } from './wgpuTestHelper';
-import { registerWgpuTextureResolver } from './wgpuTextureResolver';
+} from './wgpuRenderState.ts';
+import { createWgpuRenderStateForTest, installWgpuMock } from './wgpuTestHelper.ts';
+import { registerWgpuTextureResolver } from './wgpuTextureResolver.ts';
 
 function expectEntitySlot(slot: object & { readonly [EntityRuntimeKey]?: unknown }, fields: object): void {
   const { [EntityRuntimeKey]: entityRuntime, ...slotFields } = slot;
@@ -75,35 +69,28 @@ beforeAll(() => {
   installWgpuMock();
 });
 
-const _testPipeline = createWgpuPipeline(createEmptyWgpuRegistries());
-
-function createWgpuRenderState(acquisition: Readonly<WgpuHostAcquisition>, options: Readonly<WgpuRenderOptions> = {}) {
-  return createWgpuRenderStateWithPipeline(acquisition, _testPipeline, options);
-}
+const _testPipeline = {};
+const _webBackend = testWgpuHost;
 
-function createWgpuRenderStateFromCanvasElement(
-  canvas: HTMLCanvasElement,
-  options: Readonly<WgpuRenderOptions & { powerPreference?: GPUPowerPreference }> = {},
-) {
-  return createWgpuRenderStateFromCanvasElementWithPipeline(canvas, _testPipeline, options);
+function createWgpuRenderState(device: WgpuDevice, options: Readonly<WgpuRenderOptions> = {}) {
+  return createWgpuRenderStateWithPipeline(device, { ..._testPipeline, ...options });
 }
 
 function createWgpuRenderStateRuntime(deviceState: ReturnType<typeof createWgpuDeviceState>) {
-  return createWgpuRenderStateRuntimeWithPipeline(deviceState, _testPipeline);
+  return createWgpuRenderStateRuntimeWithPipeline(deviceState, { ..._testPipeline });
 }
 
-function entityHostBackend(fields: Omit<WgpuHostBackend, keyof Entity>): WgpuHostBackend {
+function entityHostBackend(fields: Omit<HostWgpuCapability, keyof Entity>): HostWgpuCapability {
   return (() => {
-    const out = allocateEntity<any>();
+    const out = allocateEntity<any>() as any;
     Object.assign(out, fields);
-    return finishEntity(out);
+    return out;
   })();
 }
 
 function createWgpuOffscreenRenderState(source: WgpuRenderState): WgpuRenderState {
-  const pipeline: WgpuPipeline = createWgpuPipeline(getWgpuRenderStateRuntime(source).registries);
-  const state = createDeviceOnlyWgpuRenderState(source.deviceState, pipeline, {
-    backgroundColor: source.backgroundColor,
+  const state = createDeviceOnlyWgpuRenderState(source.deviceState, {
+    ...getWgpuRenderStateRuntime(source).registries,
     format: source.format,
     imageSmoothingEnabled: source.allowSmoothing,
     pixelRatio: source.pixelRatio,
@@ -121,57 +108,84 @@ function createWgpuOffscreenRenderState(source: WgpuRenderState): WgpuRenderStat
   return state;
 }
 
-function getPaddingResolver(state: RenderState, kind: string): RenderEffectPaddingResolver | null {
+function getPaddingResolver(state: RenderState, kind: string): EffectPaddingResolver | null {
   const table = getRenderStateRuntime(state).registries.effectPaddingResolvers;
-  return table === undefined ? null : getRegistryTableEntry(table, kind);
+  return table === undefined ? null : (table.get(kind) ?? null);
 }
 
-function registerPaddingResolver(state: RenderState, kind: string, resolver: RenderEffectPaddingResolver): void {
+function registerPaddingResolver(state: RenderState, kind: string, resolver: EffectPaddingResolver): void {
   const runtime = getRenderStateRuntime(state);
-  runtime.registries.effectPaddingResolvers = withRegistryTableEntry(
-    runtime.registries.effectPaddingResolvers ??
-      createKeyedTable<RenderEffectPaddingResolver>('RenderEffectPaddingResolver', 'Zero'),
+  runtime.registries.effectPaddingResolvers = withKindMapEntry(
+    runtime.registries.effectPaddingResolvers ?? new Map(),
     kind,
     resolver,
   );
 }
 
-describe('createWgpuAcquisitionFromCanvasElement', () => {
+describe('buildWgpuRenderRegistries', () => {
+  it('returns all required fields with default values', () => {
+    const registries = buildWgpuRenderRegistries({});
+    expect(registries.nodeRenderers).toBeInstanceOf(Map);
+    expect(registries.nodeRenderers.size).toBe(0);
+    expect(registries.materialRenderers).toBeInstanceOf(Map);
+    expect(registries.modifierSnippets).toBeInstanceOf(Map);
+    expect(registries.textureResolvers).toBeInstanceOf(Map);
+    expect(registries.strokeTessellator).toBeNull();
+    expect(registries.gpuSkinning).toBeNull();
+  });
+
+  it('clones provided registry maps and pass arrays into an isolated live aggregate', () => {
+    const nodeRenderers = new Map();
+    const passes: never[] = [];
+    const registries = buildWgpuRenderRegistries({ nodeRenderers, passes });
+    expect(registries.nodeRenderers).not.toBe(nodeRenderers);
+    expect(registries.passes).not.toBe(passes);
+
+    nodeRenderers.set('acme.Late', {});
+    expect(registries.nodeRenderers.has('acme.Late')).toBe(false);
+  });
+});
+
+describe('createWgpuAcquisition', () => {
   it('hands back handles the CALLER owns, so no state teardown can release them', async () => {
-    const acquisition = await createWgpuAcquisitionFromCanvasElement(document.createElement('canvas'));
+    const acquisition = await createWgpuAcquisition(
+      _webBackend,
+      createTestWgpuSurface(document.createElement('canvas')),
+    );
 
     expect(acquisition).not.toBeNull();
     expect(acquisition!.ownership).toBe('caller');
     expect(acquisition!.surface).toBeDefined();
-    releaseWgpuAcquisition(acquisition!);
+    releaseWgpuAcquisition(_webBackend, acquisition!);
   });
 
   // ★ NULL, NOT THROW. "This environment cannot give me WebGPU" is an expected outcome, not API misuse, so
   // it reports through the return value like every other expected failure in this SDK.
   it('returns null when the host cannot acquire, rather than rejecting', async () => {
-    setWgpuHostBackend(
-      entityHostBackend({
-        acquire: vi.fn(async () => {
-          throw new Error('no adapter');
-        }),
-        isSupported: vi.fn(() => false),
-        release: vi.fn(),
+    const failingBackend = entityHostBackend({
+      acquire: vi.fn(async () => {
+        throw new Error('no adapter');
       }),
-    );
+      attachSurface: vi.fn(() => null),
+      create: vi.fn(() => null),
+      isSupported: vi.fn(() => false),
+      release: vi.fn(),
+    });
 
-    await expect(createWgpuAcquisitionFromCanvasElement(document.createElement('canvas'))).resolves.toBeNull();
-    setWgpuHostBackend(null);
+    await expect(
+      createWgpuAcquisition(failingBackend, createTestWgpuSurface(document.createElement('canvas'))),
+    ).resolves.toBeNull();
   });
 });
 
 describe('createWgpuDeviceState', () => {
   it('allocates distinct owners for repeated calls with the same raw device', () => {
-    const device = {} as GPUDevice;
+    const device = {} as WgpuDevice;
     expect(createWgpuDeviceState(device)).not.toBe(createWgpuDeviceState(device));
   });
 
   it('rejects a plain literal at the Entity boundary: EntityRuntimeKey is absent without allocateEntity', () => {
-    const device = {} as GPUDevice;
+    const device = {} as WgpuDevice;
     const literal = { device };
     expect(EntityRuntimeKey in literal).toBe(false);
 
@@ -180,29 +194,21 @@ describe('createWgpuDeviceState', () => {
   });
 
   it('returns a state that shares the device tier across derived runtimes', () => {
-    const device = {} as GPUDevice;
+    const device = {} as WgpuDevice;
     const deviceState = createWgpuDeviceState(device);
     const runtimeA = createWgpuRenderStateRuntime(deviceState);
     const runtimeB = createWgpuRenderStateRuntime(deviceState);
-    runtimeA.context.standardMaterialModule = {} as GPUShaderModule;
+    runtimeA.context.standardMaterialModule = {} as WgpuShaderModule;
     expect(runtimeB.context.standardMaterialModule).toBe(runtimeA.context.standardMaterialModule);
   });
 
   it('represents device-native resources as absent before the first render state initializes them', () => {
-    const runtime = getWgpuDeviceRuntime(createWgpuDeviceState({} as GPUDevice));
+    const runtime = getWgpuDeviceRuntime(createWgpuDeviceState({} as WgpuDevice));
     expect(runtime.resources).toBeNull();
   });
 });
 
 describe('createWgpuOffscreenRenderState', () => {
-  it('rejects a device-only state at presentation boundaries', () => {
-    const deviceOnlyState = null as WgpuRenderState | null;
-    if (deviceOnlyState === null) return;
-
-    // @ts-expect-error — a device-only state has no presentation surface or canvas context.
-    beginWgpuFrame(deviceOnlyState);
-  });
-
   it('resolves late screen blend-mode wiring explicitly until locally overridden', async () => {
     const screen = await createWgpuRenderStateForTest();
     const offscreen = createWgpuOffscreenRenderState(screen);
@@ -245,32 +251,17 @@ describe('createWgpuOffscreenRenderState', () => {
     };
     const colorAdjustmentFeatureGuard: WgpuColorAdjustmentMaterialFeatureGuard = vi.fn();
     const renderRootGuard: RenderRootGuard = vi.fn();
-    registerRenderer(screen, 'acme.Node', renderer);
-    registerWgpuMaterialRenderer(screen, 'acme.Material', materialRenderer);
+    registerNodeRenderer(screen, 'acme.Node', renderer);
+    registerWgpuQuadMaterialRenderer(screen, 'acme.Material', materialRenderer);
     registerWgpuTextureResolver(screen, 'acme.Texture', textureResolver);
     enableColorAdjustments(screen);
-    enableColorAdjustmentGuards(screen);
+    enableColorAdjustmentGuards(screen, null);
     registerPaddingResolver(screen, 'acme.Effect', paddingResolver);
-    getWgpuRenderStateRuntime(screen).registries.colorAdjustmentFeature = {
-      entry: { state: RegistryEntryState.Bound, value: colorAdjustmentFeature },
-      onMiss: 'Disabled',
-      registry: 'WgpuColorAdjustmentFeature',
-      shape: 'slot',
-    };
-    getWgpuRenderStateRuntime(screen).registries.colorAdjustmentFeatureGuard = {
-      entry: { state: RegistryEntryState.Bound, value: colorAdjustmentFeatureGuard },
-      onMiss: 'Disabled',
-      registry: 'WgpuColorAdjustmentFeatureGuard',
-      shape: 'slot',
-    };
-    getWgpuRenderStateRuntime(screen).registries.renderRootGuard = {
-      entry: { state: RegistryEntryState.Bound, value: renderRootGuard },
-      onMiss: 'Disabled',
-      registry: 'RenderRootGuard',
-      shape: 'slot',
-    };
-    getWgpuRenderStateRuntime(screen).registries.renderEffects = withRegistryTableEntry(
-      getWgpuRenderStateRuntime(screen).registries.renderEffects,
+    getWgpuRenderStateRuntime(screen).registries.colorAdjustmentFeature = colorAdjustmentFeature;
+    getWgpuRenderStateRuntime(screen).registries.colorAdjustmentFeatureGuard = colorAdjustmentFeatureGuard;
+    getWgpuRenderStateRuntime(screen).registries.renderRootGuard = renderRootGuard;
+    getWgpuRenderStateRuntime(screen).registries.effects = withKindMapEntry(
+      getWgpuRenderStateRuntime(screen).registries.effects,
       'acme.Effect',
       { runner: effectRunner },
     );
@@ -284,7 +275,7 @@ describe('createWgpuOffscreenRenderState', () => {
     expect('surface' in offscreen).toBe(false);
     expect(offscreenRuntime.context).toBe(screenRuntime.context);
     expect(offscreenRuntime.uniformBuffer).not.toBe(screenRuntime.uniformBuffer);
-    expect(offscreenRuntime.registries.renderers).toBe(screenRuntime.registries.renderers);
+    expect(offscreenRuntime.registries.nodeRenderers).not.toBe(screenRuntime.registries.nodeRenderers);
     expect(offscreenRuntime.registries).not.toBe(screenRuntime.registries);
     expect(offscreenRuntime.registries.colorAdjustmentFeature).toBe(screenRuntime.registries.colorAdjustmentFeature);
     expect(getWgpuColorAdjustmentMaterialFeature(offscreen)).toBe(colorAdjustmentFeature);
@@ -313,41 +304,32 @@ describe('createWgpuOffscreenRenderState', () => {
     expect(offscreenRuntime.registries.colorAdjustmentUnsupportedGuard).toBe(sharedUnsupportedGuard);
     expect(getColorAdjustmentUnsupportedGuard(offscreen)).not.toBeNull();
     expect(offscreenRuntime.registries.renderRootGuard).toBe(screenRuntime.registries.renderRootGuard);
-    expect(offscreenRuntime.registries.renderRootGuard?.entry).toEqual({
-      state: RegistryEntryState.Bound,
-      value: renderRootGuard,
-    });
+    expect(offscreenRuntime.registries.renderRootGuard).toEqual(renderRootGuard);
     const sharedRenderRootGuard = offscreenRuntime.registries.renderRootGuard;
     screenRuntime.registries.renderRootGuard = undefined;
     expect(screenRuntime.registries.renderRootGuard).toBeUndefined();
     expect(offscreenRuntime.registries.renderRootGuard).toBe(sharedRenderRootGuard);
-    expect(
-      getRegistryTableEntry(
-        offscreenRuntime.registries.renderRootGuard!,
-        offscreenRuntime.registries.renderRootGuard!.registry,
-      ),
-    ).toBe(renderRootGuard);
+    expect(offscreenRuntime.registries.renderRootGuard).toBe(renderRootGuard);
     expect(offscreenRuntime.registries.compressedTextureDecoder).toBe(
       screenRuntime.registries.compressedTextureDecoder,
     );
     expect(offscreenRuntime.registries.compressedTextureUpload).toBe(screenRuntime.registries.compressedTextureUpload);
-    expect(offscreenRuntime.registries.customMaterialShaders).toBe(screenRuntime.registries.customMaterialShaders);
-    expect(offscreenRuntime.registries.materialRenderers).toBe(screenRuntime.registries.materialRenderers);
-    expect(offscreenRuntime.registries.meshMaterialRenderers).toBe(screenRuntime.registries.meshMaterialRenderers);
-    expect(offscreenRuntime.registries.modifierSnippets).toBe(screenRuntime.registries.modifierSnippets);
-    expect(offscreenRuntime.registries.modifierSnippetRevision).toBe(screenRuntime.registries.modifierSnippetRevision);
-    expect(offscreenRuntime.registries.renderEffects).toBe(screenRuntime.registries.renderEffects);
+    expect(offscreenRuntime.registries.customMaterialShaders).not.toBe(screenRuntime.registries.customMaterialShaders);
+    expect(offscreenRuntime.registries.materialRenderers).not.toBe(screenRuntime.registries.materialRenderers);
+    expect(offscreenRuntime.registries.modifierSnippets).not.toBe(screenRuntime.registries.modifierSnippets);
+    expect(offscreenRuntime.modifierSnippetRevision).toBe(screenRuntime.modifierSnippetRevision);
+    expect(offscreenRuntime.registries.effects).not.toBe(screenRuntime.registries.effects);
     expect(offscreenRuntime.registries.shapeRasterizer).toBe(screenRuntime.registries.shapeRasterizer);
     expect(offscreenRuntime.registries.strokeTessellator).toBe(screenRuntime.registries.strokeTessellator);
-    expect(offscreenRuntime.registries.textureResolvers).toBe(screenRuntime.registries.textureResolvers);
-    expect(offscreenRuntime.registries.velocityWriters).toBe(screenRuntime.registries.velocityWriters);
-    expect(offscreenRuntime.registries.effectPaddingResolvers).toBe(screenRuntime.registries.effectPaddingResolvers);
-    expect(getRegistryTableEntry(offscreenRuntime.registries.renderers, 'acme.Node')).toBe(renderer);
-    expect(getRegistryTableEntry(offscreenRuntime.registries.materialRenderers, 'acme.Material')).toBe(
-      materialRenderer,
+    expect(offscreenRuntime.registries.textureResolvers).not.toBe(screenRuntime.registries.textureResolvers);
+    expect(offscreenRuntime.registries.velocityWriters).not.toBe(screenRuntime.registries.velocityWriters);
+    expect(offscreenRuntime.registries.effectPaddingResolvers).not.toBe(
+      screenRuntime.registries.effectPaddingResolvers,
     );
-    expect(getRegistryTableEntry(offscreenRuntime.registries.textureResolvers, 'acme.Texture')).toBe(textureResolver);
-    expect(getRegistryTableEntry(offscreenRuntime.registries.renderEffects, 'acme.Effect')).toEqual({
+    expect(offscreenRuntime.registries.nodeRenderers.get('acme.Node') ?? null).toBe(renderer);
+    expect(offscreenRuntime.registries.materialRenderers.get('acme.Material') ?? null).toBe(materialRenderer);
+    expect(offscreenRuntime.registries.textureResolvers.get('acme.Texture') ?? null).toBe(textureResolver);
+    expect(offscreenRuntime.registries.effects.get('acme.Effect') ?? null).toEqual({
       runner: effectRunner,
     });
     expect(getPaddingResolver(offscreen, 'acme.Effect')).toBe(paddingResolver);
@@ -357,7 +339,7 @@ describe('createWgpuOffscreenRenderState', () => {
     const screen = await createWgpuRenderStateForTest();
     const offscreen = createWgpuOffscreenRenderState(screen);
     const root = createDisplayObject();
-    registerRenderer(offscreen, root.kind, { createData: () => finishEntity(allocateEntity()), submit: vi.fn() });
+    registerNodeRenderer(offscreen, root.kind, { createData: () => allocateEntity(), submit: vi.fn() });
     prepareScene2DRender(offscreen, root);
     beginWgpuFrame(screen);
 
@@ -382,7 +364,6 @@ describe('createWgpuOffscreenRenderState', () => {
 
     withWgpuFrameBorrow(screen, offscreen, () => {
       expect(offscreenRuntime.commandEncoder).toBe(encoder);
-      expect(getWgpuSurfaceRenderExtent(offscreen)).toEqual({ height: 600, width: 800 });
       offscreenRuntime.uniformOffset = offscreenRuntime.uniformStride;
     });
 
@@ -403,7 +384,6 @@ describe('createWgpuOffscreenRenderState', () => {
       expect.anything(),
     );
     expect(submit).not.toHaveBeenCalled();
-    expect(() => getWgpuSurfaceRenderExtent(offscreen)).toThrow(/outside an explicit frame borrow/);
   });
 
   it('submits a standalone borrow and restores both states when the callback throws', async () => {
@@ -421,7 +401,6 @@ describe('createWgpuOffscreenRenderState', () => {
     expect(submit).toHaveBeenCalledOnce();
     expect(getWgpuRenderStateRuntime(screen).commandEncoder).toBeNull();
     expect(getWgpuRenderStateRuntime(offscreen).commandEncoder).toBeNull();
-    expect(() => getWgpuSurfaceRenderExtent(offscreen)).toThrow(/outside an explicit frame borrow/);
   });
 
   it('rejects nested borrowing by the same offscreen state', async () => {
@@ -437,8 +416,8 @@ describe('createWgpuOffscreenRenderState', () => {
     const screen = await createWgpuRenderStateForTest();
     const root = createDisplayObject();
     const destroyData = vi.fn();
-    registerRenderer(screen, root.kind, {
-      createData: () => finishEntity(allocateEntity()),
+    registerNodeRenderer(screen, root.kind, {
+      createData: () => allocateEntity(),
       destroyData,
       submit: vi.fn(),
     });
@@ -459,88 +438,36 @@ describe('createWgpuOffscreenRenderState', () => {
     const offscreen = createWgpuOffscreenRenderState(screen);
     const renderer = { createData: () => null, submit: vi.fn() };
     const paddingResolver = vi.fn(() => ({ bottom: 2, left: 2, right: 2, top: 2 }));
-    registerRenderer(screen, 'acme.LateNode', renderer);
+    registerNodeRenderer(screen, 'acme.LateNode', renderer);
     registerPaddingResolver(screen, 'acme.LateEffect', paddingResolver);
 
-    expect(hasRegistryTableEntry(getRenderStateRuntime(offscreen).registries.renderers, 'acme.LateNode')).toBe(false);
+    expect(getRenderStateRuntime(offscreen).registries.nodeRenderers.has('acme.LateNode')).toBe(false);
     expect(getPaddingResolver(offscreen, 'acme.LateEffect')).toBeNull();
 
     const refreshed = createWgpuOffscreenRenderState(screen);
-    expect(getRegistryTableEntry(getRenderStateRuntime(refreshed).registries.renderers, 'acme.LateNode')).toBe(
-      renderer,
-    );
+    expect(getRenderStateRuntime(refreshed).registries.nodeRenderers.get('acme.LateNode') ?? null).toBe(renderer);
     expect(getPaddingResolver(refreshed, 'acme.LateEffect')).toBe(paddingResolver);
   });
 });
 
 describe('createWgpuRenderState', () => {
-  it('keeps exact caller-owned handles usable through every shared-state teardown', async () => {
-    const owner = await createWgpuRenderStateForTest();
-    const canvas = document.createElement('canvas');
-    const _acqOut = allocateEntity<WgpuHostAcquisition>();
-    _acqOut.context = owner.context;
-    _acqOut.device = owner.device;
-    _acqOut.format = owner.format;
-    _acqOut.ownership = 'caller' as const;
-    _acqOut.surface = owner.surface;
-    const acquisition = finishEntity(_acqOut);
-    let contextUsable = true;
-    let deviceUsable = true;
-    const originalCreateBuffer = acquisition.device.createBuffer.bind(acquisition.device);
-    const originalGetCurrentTexture = acquisition.context.getCurrentTexture.bind(acquisition.context);
-    const createBuffer = vi.spyOn(acquisition.device, 'createBuffer').mockImplementation((descriptor) => {
-      if (!deviceUsable) throw new Error('caller device was destroyed');
-      return originalCreateBuffer(descriptor);
-    });
-    const getCurrentTexture = vi.spyOn(acquisition.context, 'getCurrentTexture').mockImplementation(() => {
-      if (!contextUsable) throw new Error('caller context was unconfigured');
-      return originalGetCurrentTexture();
-    });
-    const unconfigure = vi.spyOn(acquisition.context, 'unconfigure').mockImplementation(() => {
-      contextUsable = false;
-    });
-    const destroy = vi.spyOn(acquisition.device, 'destroy').mockImplementation(() => {
-      deviceUsable = false;
-    });
-    Object.defineProperty(globalThis.navigator, 'gpu', {
-      configurable: true,
-      get(): never {
-        throw new Error('host getter failed');
-      },
-    });
+  it('takes the device alone: no surface, no context, nothing that belongs to a screen', async () => {
+    // The state is "how to talk to the GPU" and the screen target is "which surface a frame lands on".
+    // Keeping them apart is what lets one state render to several windows, and lets an offscreen state
+    // exist without inventing a canvas for it.
+    const acquisition = await createWgpuAcquisition(
+      _webBackend,
+      createTestWgpuSurface(document.createElement('canvas')),
+    );
+    const state = createWgpuRenderState(acquisition!.device, { format: acquisition!.format });
 
-    try {
-      const state = createWgpuRenderState(acquisition);
-      const offscreen = createWgpuOffscreenRenderState(state);
-      expect(state.context).toBe(acquisition.context);
-      expect(state.device).toBe(acquisition.device);
-      expect(state.format).toBe(acquisition.format);
-      expect('context' in offscreen).toBe(false);
-      expect(offscreen.device).toBe(acquisition.device);
-      expect(offscreen.format).toBe(acquisition.format);
-      const createBufferCallsBeforeTeardown = createBuffer.mock.calls.length;
-      const getCurrentTextureCallsBeforeTeardown = getCurrentTexture.mock.calls.length;
-      destroyWgpuRenderState(state);
-      destroyWgpuRenderState(offscreen);
-      expect(unconfigure).not.toHaveBeenCalled();
-      expect(destroy).not.toHaveBeenCalled();
-
-      const buffer = acquisition.device.createBuffer({ size: 4, usage: GPUBufferUsage.COPY_DST });
-      expect(buffer.size).toBe(4);
-      expect(acquisition.context.getCurrentTexture().createView()).toBeDefined();
-      expect(createBuffer).toHaveBeenCalledTimes(createBufferCallsBeforeTeardown + 1);
-      expect(getCurrentTexture).toHaveBeenCalledTimes(getCurrentTextureCallsBeforeTeardown + 1);
-      buffer.destroy();
-    } finally {
-      installWgpuMock();
-      destroyWgpuRenderState(owner);
-    }
-  });
+    expect(state.device).toBe(acquisition!.device);
+    expect(state.format).toBe(acquisition!.format);
+    expect('context' in state).toBe(false);
+    expect('surface' in state).toBe(false);
 
-  it('returns a render state with device and context', async () => {
-    const state = await createWgpuRenderStateForTest();
-    expect(state.device).toBeDefined();
-    expect(state.context).toBeDefined();
+    destroyWgpuRenderState(state);
+    releaseWgpuAcquisition(_webBackend, acquisition!);
   });
 
   it('sets allowSmoothing to true by default', async () => {
@@ -556,169 +483,87 @@ describe('createWgpuRenderState', () => {
     expect(runtime.uniformOffset).toBe(0);
   });
 
-  // C5: the state exposes the surface as SIZE ONLY. Asserting `instanceof HTMLCanvasElement` here would
-  // re-impose the DOM dependency the surface type exists to remove — that the web backend's surface happens
-  // to be a canvas is a property of that backend, pinned in wgpuHost.test.ts, not of the state contract.
-  it('exposes the presentation surface as live size, carrying no DOM member', async () => {
+  it('does not mutate a frozen preset when used as options input', async () => {
+    const preset = Object.freeze({
+      ...buildWgpuRenderRegistries({}),
+      nodeRenderers: new Map(),
+    });
+    const state = await createWgpuRenderStateForTest({ ...preset });
+    registerNodeRenderer(state, 'acme.Test', { createData: () => null, submit: () => {} });
+    expect(preset.nodeRenderers.size).toBe(0);
+    expect(getWgpuRenderStateRuntime(state).registries.nodeRenderers.size).toBe(1);
+  });
+
+  it('keeps revision counters on the runtime, not in registries', async () => {
     const state = await createWgpuRenderStateForTest();
-    expect(typeof state.surface.width).toBe('number');
-    expect(typeof state.surface.height).toBe('number');
-    expect(Object.keys(state.surface as object).filter((key) => key !== 'width' && key !== 'height')).toEqual([]);
+    const runtime = getWgpuRenderStateRuntime(state);
+    expect(runtime.modifierSnippetRevision).toBe(0);
+    expect('modifierSnippetRevision' in runtime.registries).toBe(false);
   });
 
-  it('starts with null renderPass and commandEncoder', async () => {
+  it('starts with no open frame, pass, or target', async () => {
     const state = await createWgpuRenderStateForTest();
     const runtime = getWgpuRenderStateRuntime(state);
     expect(runtime.renderPass).toBeNull();
     expect(runtime.commandEncoder).toBeNull();
-  });
-});
-
-describe('createWgpuRenderStateFromCanvasElement', () => {
-  it('acquires flight-owned handles and releases them when the state is destroyed', async () => {
-    const owner = await createWgpuRenderStateForTest();
-    const acquisition = { ...ownerAcquisition(owner), ownership: 'flight' } as const;
-    const released: Readonly<WgpuHostAcquisition>[] = [];
-    setWgpuHostBackend(
-      entityHostBackend({
-        acquire: vi.fn(async () => acquisition),
-        isSupported: vi.fn(() => true),
-        release: vi.fn((held: Readonly<WgpuHostAcquisition>) => released.push(held)),
-      }),
-    );
-
-    const state = await createWgpuRenderStateFromCanvasElement(document.createElement('canvas'));
-    destroyWgpuRenderState(state);
-
-    expect(released).toEqual([acquisition]);
-    setWgpuHostBackend(null);
-    destroyWgpuRenderState(owner);
-  });
-
-  it('forwards the acquisition options, which the render options no longer carry', async () => {
-    const owner = await createWgpuRenderStateForTest();
-    const acquire = vi.fn(async () => ({ ...ownerAcquisition(owner), ownership: 'flight' }) as const);
-    setWgpuHostBackend(entityHostBackend({ acquire, isSupported: vi.fn(() => true), release: vi.fn() }));
-    const canvas = document.createElement('canvas');
-
-    const state = await createWgpuRenderStateFromCanvasElement(canvas, {
-      format: 'rgba8unorm',
-      powerPreference: 'low-power',
-    });
-
-    expect(acquire).toHaveBeenCalledWith(canvas, { format: 'rgba8unorm', powerPreference: 'low-power' });
-    destroyWgpuRenderState(state);
-    setWgpuHostBackend(null);
-    destroyWgpuRenderState(owner);
+    expect(runtime.passStack).toEqual([]);
+    expect(runtime.currentRenderTarget).toBeNull();
   });
 });
 
 describe('createWgpuRenderStateRuntime', () => {
   it('returns a runtime with the base binding slot and empty named registration tables', () => {
-    const runtime = createWgpuRenderStateRuntime(createWgpuDeviceState({} as GPUDevice));
+    const runtime = createWgpuRenderStateRuntime(createWgpuDeviceState({} as WgpuDevice));
     expect(runtime.binding).toBeNull();
-    expect(runtime.registries.customMaterialShaders).toMatchObject({
-      onMiss: 'Unregistered',
-      registry: 'WgpuCustomMaterialShader',
-      shape: 'keyed',
-    });
-    expect(runtime.registries.customMaterialShaders.entries.size).toBe(0);
-    expect(runtime.registries.materialRenderers).toMatchObject({
-      onMiss: 'StandardMaterial',
-      registry: 'WgpuMaterialRenderer',
-      shape: 'keyed',
-    });
-    expect(runtime.registries.materialRenderers.entries.size).toBe(0);
-    expect(runtime.registries.meshMaterialRenderers).toMatchObject({
-      onMiss: 'StandardMaterial',
-      registry: 'WgpuMeshMaterialRenderer',
-      shape: 'keyed',
-    });
-    expect(runtime.registries.meshMaterialRenderers.entries.size).toBe(0);
-    expect(runtime.registries.modifierSnippets).toMatchObject({
-      onMiss: 'Unregistered',
-      registry: 'WgpuModifierSnippet',
-      shape: 'keyed',
-    });
-    expect(runtime.registries.modifierSnippets.entries.size).toBe(0);
-    expect(runtime.registries.modifierSnippetRevision).toBe(0);
-    expect(runtime.registries.renderEffects).toMatchObject({
-      onMiss: 'Unregistered',
-      registry: 'WgpuRenderEffect',
-      shape: 'keyed',
-    });
-    expectEntitySlot(runtime.registries.compressedTextureDecoder, {
-      entry: null,
-      onMiss: 'Unregistered',
-      registry: 'WgpuCompressedTextureDecoder',
-      shape: 'slot',
-    });
+    expect(runtime.registries.customMaterialShaders.size).toBe(0);
+    expect(runtime.registries.materialRenderers.size).toBe(0);
+    expect(runtime.registries.modifierSnippets.size).toBe(0);
+    expect(runtime.modifierSnippetRevision).toBe(0);
+    expect(runtime.registries.effects.size).toBe(0);
+    expect(runtime.registries.compressedTextureDecoder).toBeNull();
     expect(runtime.registries.colorAdjustments).toBeUndefined();
-    expectEntitySlot(runtime.registries.compressedTextureUpload, {
-      entry: null,
-      onMiss: 'Unregistered',
-      registry: 'WgpuCompressedTextureUpload',
-      shape: 'slot',
-    });
-    expectEntitySlot(runtime.registries.shapeRasterizer, {
-      entry: null,
-      onMiss: 'Unregistered',
-      registry: 'WgpuShapeRasterizer',
-      shape: 'slot',
-    });
-    expectEntitySlot(runtime.registries.strokeTessellator, {
-      entry: null,
-      onMiss: 'Rasterize',
-      registry: 'StrokeTessellator',
-      shape: 'slot',
-    });
-    expect(runtime.registries.velocityWriters).toMatchObject({
-      onMiss: 'Unregistered',
-      registry: 'WgpuVelocityWriter',
-      shape: 'keyed',
-    });
-    expect(runtime.registries.velocityWriters.entries.size).toBe(0);
+    expect(runtime.registries.compressedTextureUpload).toBeNull();
+    expect(runtime.registries.shapeRasterizer).toBeNull();
+    expect(runtime.registries.strokeTessellator).toBeNull();
+    expect(runtime.registries.velocityWriters.size).toBe(0);
   });
 
   it('shares the device tier when two runtimes are built from the same WgpuDeviceState', () => {
-    const deviceState = createWgpuDeviceState({} as GPUDevice);
+    const deviceState = createWgpuDeviceState({} as WgpuDevice);
     const runtimeA = createWgpuRenderStateRuntime(deviceState);
     const runtimeB = createWgpuRenderStateRuntime(deviceState);
 
     const resources = {
-      linearSampler: {} as GPUSampler,
-      nearestSampler: {} as GPUSampler,
-      textureBindGroupLayout: {} as GPUBindGroupLayout,
-      uniformBindGroupLayout: {} as GPUBindGroupLayout,
+      linearSampler: {} as WgpuSampler,
+      nearestSampler: {} as WgpuSampler,
+      textureBindGroupLayout: {} as WgpuBindGroupLayout,
+      uniformBindGroupLayout: {} as WgpuBindGroupLayout,
     };
     runtimeA.context.resources = resources;
     expect(runtimeB.context.resources).toBe(resources);
   });
 
   it('keeps separate device tiers when two runtimes are built from different WgpuDeviceStates', () => {
-    const runtimeA = createWgpuRenderStateRuntime(createWgpuDeviceState({} as GPUDevice));
-    const runtimeB = createWgpuRenderStateRuntime(createWgpuDeviceState({} as GPUDevice));
+    const runtimeA = createWgpuRenderStateRuntime(createWgpuDeviceState({} as WgpuDevice));
+    const runtimeB = createWgpuRenderStateRuntime(createWgpuDeviceState({} as WgpuDevice));
 
     expect(runtimeA.context).not.toBe(runtimeB.context);
   });
 });
 
 describe('destroyWgpuRenderState', () => {
-  it('releases a Flight-owned acquisition once after its last derived state', async () => {
+  it('never destroys the device, however many of its states are torn down', async () => {
+    // The device came from the caller and outlives every state built on it — including the last one.
     const state = await createWgpuRenderStateForTest();
     const offscreen = createWgpuOffscreenRenderState(state);
-    const unconfigure = vi.spyOn(state.context, 'unconfigure');
     const destroy = vi.spyOn(state.device, 'destroy');
 
     destroyWgpuRenderState(state);
     destroyWgpuRenderState(state);
-    expect(unconfigure).not.toHaveBeenCalled();
-    expect(destroy).not.toHaveBeenCalled();
-
     destroyWgpuRenderState(offscreen);
     destroyWgpuRenderState(offscreen);
-    expect(unconfigure).toHaveBeenCalledOnce();
-    expect(destroy).toHaveBeenCalledOnce();
+
+    expect(destroy).not.toHaveBeenCalled();
   });
 
   it('destroys the state-owned uniform buffer', async () => {
@@ -798,17 +643,9 @@ describe('getWgpuColorAdjustmentMaterialFeature', () => {
     const runtime = getWgpuRenderStateRuntime(state);
 
     expect(getWgpuColorAdjustmentMaterialFeature(state)).toBeNull();
-    runtime.registries.colorAdjustmentFeature = {
-      entry: { state: RegistryEntryState.Bound, value: feature },
-      onMiss: 'Disabled',
-      registry: 'WgpuColorAdjustmentFeature',
-      shape: 'slot',
-    };
+    runtime.registries.colorAdjustmentFeature = feature;
     expect(getWgpuColorAdjustmentMaterialFeature(state)).toBe(feature);
-    runtime.registries.colorAdjustmentFeature = {
-      ...runtime.registries.colorAdjustmentFeature,
-      entry: { state: RegistryEntryState.Tombstoned },
-    };
+    runtime.registries.colorAdjustmentFeature = null;
     expect(getWgpuColorAdjustmentMaterialFeature(state)).toBeNull();
   });
 });
@@ -820,24 +657,16 @@ describe('getWgpuColorAdjustmentMaterialFeatureGuard', () => {
     const runtime = getWgpuRenderStateRuntime(state);
 
     expect(getWgpuColorAdjustmentMaterialFeatureGuard(state)).toBeNull();
-    runtime.registries.colorAdjustmentFeatureGuard = {
-      entry: { state: RegistryEntryState.Bound, value: guard },
-      onMiss: 'Disabled',
-      registry: 'WgpuColorAdjustmentFeatureGuard',
-      shape: 'slot',
-    };
+    runtime.registries.colorAdjustmentFeatureGuard = guard;
     expect(getWgpuColorAdjustmentMaterialFeatureGuard(state)).toBe(guard);
-    runtime.registries.colorAdjustmentFeatureGuard = {
-      ...runtime.registries.colorAdjustmentFeatureGuard,
-      entry: { state: RegistryEntryState.Tombstoned },
-    };
+    runtime.registries.colorAdjustmentFeatureGuard = null;
     expect(getWgpuColorAdjustmentMaterialFeatureGuard(state)).toBeNull();
   });
 });
 
 describe('getWgpuDeviceRuntime', () => {
   it('returns the device runtime attached by createWgpuDeviceState', () => {
-    const device = {} as GPUDevice;
+    const device = {} as WgpuDevice;
     const deviceState = createWgpuDeviceState(device);
     const runtime = getWgpuDeviceRuntime(deviceState);
     expect(runtime).toBeDefined();
@@ -846,7 +675,7 @@ describe('getWgpuDeviceRuntime', () => {
   });
 
   it('resolves the same runtime object on repeated calls', () => {
-    const deviceState = createWgpuDeviceState({} as GPUDevice);
+    const deviceState = createWgpuDeviceState({} as WgpuDevice);
     expect(getWgpuDeviceRuntime(deviceState)).toBe(getWgpuDeviceRuntime(deviceState));
   });
 });
@@ -963,7 +792,7 @@ describe('initializeWgpuOffscreenRenderStateOkResult', () => {
 
 describe('isWgpuSupported', () => {
   it('returns true when navigator.gpu is present', () => {
-    expect(isWgpuSupported()).toBe(true);
+    expect(isWgpuSupported(_webBackend)).toBe(true);
   });
 
   it('returns false when navigator.gpu throws', () => {
@@ -974,7 +803,8 @@ describe('isWgpuSupported', () => {
       },
     });
     try {
-      expect(isWgpuSupported()).toBe(false);
+      const unsupportedBackend = testWgpuHost;
+      expect(isWgpuSupported(unsupportedBackend)).toBe(false);
     } finally {
       installWgpuMock();
     }
@@ -992,15 +822,6 @@ describe('registerWgpuDeviceTeardown', () => {
   });
 });
 
-function ownerAcquisition(owner: WgpuPresentationRenderState): Omit<WgpuHostAcquisition, 'ownership'> {
-  const out = allocateEntity<any>();
-  out.context = owner.context;
-  out.device = owner.device;
-  out.format = owner.format;
-  out.surface = owner.surface;
-  return finishEntity(out);
-}
-
 describe('registerWgpuRenderStateTeardown', () => {
   it('runs a state-owned callback exactly once on teardown', async () => {
     const state = await createWgpuRenderStateForTest();
@@ -1019,24 +840,23 @@ describe('releaseWgpuAcquisition', () => {
   // Unconditional on purpose: this is the CALLER asking. Flight's own paths refuse to release caller-owned
   // handles, so if this verb deferred to the same policy the caller would have no way to end their life.
   it('releases caller-owned handles, which Flight itself never does', async () => {
-    const owner = await createWgpuRenderStateForTest();
-    const acquisition = { ...ownerAcquisition(owner), ownership: 'caller' } as const;
+    const acquired = await createWgpuAcquisition(_webBackend, createTestWgpuSurface(document.createElement('canvas')));
+    const acquisition = acquired!;
     const released: Readonly<WgpuHostAcquisition>[] = [];
-    setWgpuHostBackend(
-      entityHostBackend({
-        acquire: vi.fn(async () => acquisition),
-        isSupported: vi.fn(() => true),
-        release: vi.fn((held: Readonly<WgpuHostAcquisition>) => released.push(held)),
-      }),
-    );
+    const recordingBackend = entityHostBackend({
+      acquire: vi.fn(async () => acquisition),
+      attachSurface: vi.fn(() => null),
+      create: vi.fn(() => null),
+      isSupported: vi.fn(() => true),
+      release: vi.fn((held: Readonly<WgpuHostAcquisition>) => released.push(held)),
+    });
 
-    releaseWgpuAcquisition(acquisition);
+    releaseWgpuAcquisition(recordingBackend, acquisition);
 
     expect(released).toEqual([acquisition]);
-    setWgpuHostBackend(null);
-    destroyWgpuRenderState(owner);
   });
 });
+
 describe('resolveWgpuApplyBlendMode', () => {
   it('returns a hook installed directly on the state', async () => {
     const state = await createWgpuRenderStateForTest();
@@ -1046,157 +866,50 @@ describe('resolveWgpuApplyBlendMode', () => {
   });
 });
 
-// ★ OWNERSHIP LIFECYCLE. Flight decides whether an acquisition is released; the backend only carries out
-// the teardown. Each backend here would really destroy the handles if asked, so "not released" is a fact
-// about Flight's decision rather than about a spy that could not have destroyed anything.
-describe('wgpu acquisition lifecycle', () => {
-  const destroyingBackend = (
-    acquisition: Readonly<WgpuHostAcquisition>,
-  ): { backend: WgpuHostBackend; released: Readonly<WgpuHostAcquisition>[] } => {
-    const released: Readonly<WgpuHostAcquisition>[] = [];
-    return {
-      backend: entityHostBackend({
-        acquire: vi.fn(async () => acquisition),
-        isSupported: vi.fn(() => true),
-        release: vi.fn((held: Readonly<WgpuHostAcquisition>) => {
-          released.push(held);
-          held.device.destroy();
-        }),
-      }),
-      released,
-    };
-  };
-
-  it('L1: releases a flight-owned acquisition exactly once, after the last sharer, in either order', async () => {
-    for (const destroyOffscreenFirst of [false, true]) {
-      const owner = await createWgpuRenderStateForTest();
-      const acquisition = { ...ownerAcquisition(owner), ownership: 'flight' } as const;
-      const { backend, released } = destroyingBackend(acquisition);
-      setWgpuHostBackend(backend);
-
-      const state = createWgpuRenderState(acquisition);
-      const offscreen = createWgpuOffscreenRenderState(state);
-      const first = destroyOffscreenFirst ? offscreen : state;
-      const second = destroyOffscreenFirst ? state : offscreen;
-
-      destroyWgpuRenderState(first);
-      expect(released, 'released before the last sharer was destroyed').toEqual([]);
-      destroyWgpuRenderState(second);
-      expect(released).toEqual([acquisition]);
-
-      setWgpuHostBackend(null);
-      destroyWgpuRenderState(owner);
-    }
-  });
-
-  it('L2: never releases a caller-owned acquisition, in either destroy order', async () => {
-    for (const destroyOffscreenFirst of [false, true]) {
-      const owner = await createWgpuRenderStateForTest();
-      const acquisition = { ...ownerAcquisition(owner), ownership: 'caller' } as const;
-      const { backend, released } = destroyingBackend(acquisition);
-      setWgpuHostBackend(backend);
-
-      const state = createWgpuRenderState(acquisition);
-      const offscreen = createWgpuOffscreenRenderState(state);
-      destroyWgpuRenderState(destroyOffscreenFirst ? offscreen : state);
-      destroyWgpuRenderState(destroyOffscreenFirst ? state : offscreen);
-
-      expect(released).toEqual([]);
-      // L5: the handles still work, which is what the caller actually depends on.
-      expect(acquisition.device.createBuffer({ size: 4, usage: GPUBufferUsage.COPY_DST }).size).toBe(4);
-
-      setWgpuHostBackend(null);
-      destroyWgpuRenderState(owner);
-    }
-  });
-
-  it('L3: destroying the same state twice releases once', async () => {
-    const owner = await createWgpuRenderStateForTest();
-    const acquisition = { ...ownerAcquisition(owner), ownership: 'flight' } as const;
-    const { backend, released } = destroyingBackend(acquisition);
-    setWgpuHostBackend(backend);
-
-    const state = createWgpuRenderState(acquisition);
-    destroyWgpuRenderState(state);
-    destroyWgpuRenderState(state);
-
-    expect(released).toEqual([acquisition]);
-    setWgpuHostBackend(null);
-    destroyWgpuRenderState(owner);
-  });
-
-  it('L4: routes release to the backend that acquired, not whichever is installed at destroy time', async () => {
-    const owner = await createWgpuRenderStateForTest();
-    const acquisition = { ...ownerAcquisition(owner), ownership: 'flight' } as const;
-    const acquiring = destroyingBackend(acquisition);
-    const replacement = destroyingBackend(acquisition);
-    setWgpuHostBackend(acquiring.backend);
-
-    const state = createWgpuRenderState(acquisition);
-    setWgpuHostBackend(replacement.backend);
-    destroyWgpuRenderState(state);
-
-    expect(acquiring.released).toEqual([acquisition]);
-    expect(replacement.released, 'released through the backend installed later').toEqual([]);
-
-    setWgpuHostBackend(null);
-    destroyWgpuRenderState(owner);
-  });
-});
-
-describe('WgpuPipeline snapshots', () => {
+describe('WgpuRenderRegistries snapshots', () => {
   it('captures late Wgpu registrations only when an explicit pipeline is created', async () => {
     const screen = await createWgpuRenderStateForTest();
     const materialRenderer = { instanceFloatCount: 0, getShaderModule: vi.fn() } as never;
     const offscreenMaterialRenderer = { instanceFloatCount: 0, getShaderModule: vi.fn() } as never;
-    const decoder = vi.fn(() => new Uint8ClampedArray(4));
+    const decoder = vi.fn(() => new Uint8Array(4));
     const resolver = vi.fn(() => null);
     registerWgpuCompressedTextureDecoder(screen, decoder);
-    registerWgpuCompressedTextureUpload(screen);
-    registerWgpuMaterialRenderer(screen, 'acme.LateMaterial', materialRenderer);
+    registerWgpuCompressedTextureUpload(screen, true);
+    registerWgpuQuadMaterialRenderer(screen, 'acme.LateMaterial', materialRenderer);
     registerWgpuTextureResolver(screen, 'acme.LateTexture', resolver);
     const offscreen = createWgpuOffscreenRenderState(screen);
 
-    expect(
-      getRegistryTableEntry(getWgpuRenderStateRuntime(offscreen).registries.materialRenderers, 'acme.LateMaterial'),
-    ).toBe(materialRenderer);
-    expect(
-      getRegistryTableEntry(getWgpuRenderStateRuntime(offscreen).registries.textureResolvers, 'acme.LateTexture'),
-    ).toBe(resolver);
+    expect(getWgpuRenderStateRuntime(offscreen).registries.materialRenderers.get('acme.LateMaterial') ?? null).toBe(
+      materialRenderer,
+    );
+    expect(getWgpuRenderStateRuntime(offscreen).registries.textureResolvers.get('acme.LateTexture') ?? null).toBe(
+      resolver,
+    );
     expect(getWgpuRenderStateRuntime(offscreen).registries.compressedTextureDecoder).toBe(
       getWgpuRenderStateRuntime(screen).registries.compressedTextureDecoder,
     );
-    expect(getWgpuRenderStateRuntime(offscreen).registries.compressedTextureDecoder.entry).toEqual({
-      state: RegistryEntryState.Bound,
-      value: decoder,
-    });
+    expect(getWgpuRenderStateRuntime(offscreen).registries.compressedTextureDecoder).toEqual(decoder);
     expect(getWgpuRenderStateRuntime(offscreen).registries.compressedTextureUpload).toBe(
       getWgpuRenderStateRuntime(screen).registries.compressedTextureUpload,
     );
-    registerWgpuMaterialRenderer(offscreen, 'acme.LateMaterial', offscreenMaterialRenderer);
+    registerWgpuQuadMaterialRenderer(offscreen, 'acme.LateMaterial', offscreenMaterialRenderer);
     registerWgpuCompressedTextureDecoder(offscreen, null);
-    registerWgpuCompressedTextureUpload(offscreen, null);
+    registerWgpuCompressedTextureUpload(offscreen, false);
     registerWgpuTextureResolver(offscreen, 'acme.LateTexture', null);
-    expect(
-      getRegistryTableEntry(getWgpuRenderStateRuntime(offscreen).registries.materialRenderers, 'acme.LateMaterial'),
-    ).toBe(offscreenMaterialRenderer);
-    expect(
-      getRegistryTableEntry(getWgpuRenderStateRuntime(screen).registries.materialRenderers, 'acme.LateMaterial'),
-    ).toBe(materialRenderer);
-    expect(
-      hasRegistryTableEntry(getWgpuRenderStateRuntime(offscreen).registries.textureResolvers, 'acme.LateTexture'),
-    ).toBe(false);
-    expect(
-      getRegistryTableEntry(getWgpuRenderStateRuntime(screen).registries.textureResolvers, 'acme.LateTexture'),
-    ).toBe(resolver);
-    expect(getWgpuRenderStateRuntime(offscreen).registries.compressedTextureDecoder.entry).toBeNull();
-    expect(getWgpuRenderStateRuntime(screen).registries.compressedTextureDecoder.entry?.state).toBe(
-      RegistryEntryState.Bound,
+    expect(getWgpuRenderStateRuntime(offscreen).registries.materialRenderers.get('acme.LateMaterial') ?? null).toBe(
+      offscreenMaterialRenderer,
     );
-    expect(getWgpuRenderStateRuntime(offscreen).registries.compressedTextureUpload.entry).toBeNull();
-    expect(getWgpuRenderStateRuntime(screen).registries.compressedTextureUpload.entry?.state).toBe(
-      RegistryEntryState.Bound,
+    expect(getWgpuRenderStateRuntime(screen).registries.materialRenderers.get('acme.LateMaterial') ?? null).toBe(
+      materialRenderer,
+    );
+    expect(getWgpuRenderStateRuntime(offscreen).registries.textureResolvers.has('acme.LateTexture')).toBe(false);
+    expect(getWgpuRenderStateRuntime(screen).registries.textureResolvers.get('acme.LateTexture') ?? null).toBe(
+      resolver,
     );
+    expect(getWgpuRenderStateRuntime(offscreen).registries.compressedTextureDecoder).toBeNull();
+    expect(getWgpuRenderStateRuntime(screen).registries.compressedTextureDecoder).not.toBeNull();
+    expect(getWgpuRenderStateRuntime(offscreen).registries.compressedTextureUpload).toBeNull();
+    expect(getWgpuRenderStateRuntime(screen).registries.compressedTextureUpload).not.toBeNull();
   });
 });
 
@@ -1205,51 +918,3 @@ describe('WgpuPipeline snapshots', () => {
 // would satisfy every construction-time assertion in this repo and fail only on a resize, so liveness is
 // tested here through a NON-DOM provider whose values change behind getters — which also proves the second
 // half of the contract, that nothing on the path reads a DOM member.
-describe('WgpuPresentationSurface', () => {
-  it('C1/C2: drives every size consumer from a live, non-DOM, size-only provider', async () => {
-    const owner = await createWgpuRenderStateForTest();
-    let width = 800;
-    let height = 600;
-    const surface: WgpuPresentationSurface = {
-      get height() {
-        return height;
-      },
-      get width() {
-        return width;
-      },
-    };
-    const acquisition = (() => {
-      const out = allocateEntity<any>();
-      out.context = owner.context;
-      out.device = owner.device;
-      out.format = owner.format;
-      out.ownership = 'caller' as const;
-      out.surface = surface;
-      return finishEntity(out);
-    })();
-    const canvas = document.createElement('canvas');
-
-    const state = createWgpuRenderState(acquisition);
-    expect(getWgpuSurfaceRenderExtent(state)).toEqual({ width: 800, height: 600 });
-
-    width = 320;
-    height = 240;
-
-    // Every consumer re-reads: a captured `{ width, height }` would still answer 800x600 here.
-    expect(state.surface.width).toBe(320);
-    expect(state.surface.height).toBe(240);
-    expect(getWgpuSurfaceRenderExtent(state)).toEqual({ width: 320, height: 240 });
-
-    destroyWgpuRenderState(state);
-    destroyWgpuRenderState(owner);
-  });
-
-  it('C4: accepts an HTMLCanvasElement structurally, so the web path needs no wrapper', () => {
-    const canvas = document.createElement('canvas');
-    canvas.width = 128;
-    canvas.height = 64;
-    const surface: WgpuPresentationSurface = canvas;
-    expect(surface.width).toBe(128);
-    expect(surface.height).toBe(64);
-  });
-});