@flighthq/scene2d-wgpu 0.3.0 → 0.3.1-next.1041.35b950c

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flighthq/scene2d-wgpu",
-  "version": "0.3.0",
+  "version": "0.3.1-next.1041.35b950c",
   "author": "Joshua Granick and other contributors",
   "license": "MIT",
   "repository": {
@@ -38,23 +38,27 @@
     "clean:dist": "tsx ../../scripts/clean-package-dist.ts"
   },
   "dependencies": {
-    "@flighthq/color": "0.3.0",
-    "@flighthq/scene2d": "0.3.0",
-    "@flighthq/scene2d-canvas": "0.3.0",
-    "@flighthq/geometry": "0.3.0",
-    "@flighthq/image": "0.3.0",
-    "@flighthq/log": "0.3.0",
-    "@flighthq/node": "0.3.0",
-    "@flighthq/path": "0.3.0",
-    "@flighthq/render": "0.3.0",
-    "@flighthq/render-wgpu": "0.3.0",
-    "@flighthq/shape": "0.3.0",
-    "@flighthq/text": "0.3.0",
-    "@flighthq/textinput": "0.3.0",
-    "@flighthq/textlayout": "0.3.0",
-    "@flighthq/texture": "0.3.0",
-    "@flighthq/types": "0.3.0",
-    "@flighthq/velocity": "0.3.0"
+    "@flighthq/color": "0.3.1-next.1041.35b950c",
+    "@flighthq/scene2d": "0.3.1-next.1041.35b950c",
+    "@flighthq/scene2d-canvas": "0.3.1-next.1041.35b950c",
+    "@flighthq/geometry": "0.3.1-next.1041.35b950c",
+    "@flighthq/image": "0.3.1-next.1041.35b950c",
+    "@flighthq/log": "0.3.1-next.1041.35b950c",
+    "@flighthq/node": "0.3.1-next.1041.35b950c",
+    "@flighthq/path": "0.3.1-next.1041.35b950c",
+    "@flighthq/registry": "0.3.1-next.1041.35b950c",
+    "@flighthq/render": "0.3.1-next.1041.35b950c",
+    "@flighthq/render-wgpu": "0.3.1-next.1041.35b950c",
+    "@flighthq/shape": "0.3.1-next.1041.35b950c",
+    "@flighthq/text": "0.3.1-next.1041.35b950c",
+    "@flighthq/textinput": "0.3.1-next.1041.35b950c",
+    "@flighthq/textlayout": "0.3.1-next.1041.35b950c",
+    "@flighthq/texture": "0.3.1-next.1041.35b950c",
+    "@flighthq/types": "0.3.1-next.1041.35b950c",
+    "@flighthq/velocity": "0.3.1-next.1041.35b950c"
+  },
+  "peerDependencies": {
+    "@webgpu/types": "^0.1.70"
   },
   "devDependencies": {
     "@flighthq/bitmaptext": "*",

package/src/enableWgpuColorAdjustmentGuards.test.ts

@@ -1,12 +1,14 @@
 import { addLogSink, createMemoryLogSink, getMemoryLogSinkEntries, removeLogSink } from '@flighthq/log/contract';
-import { getWgpuRenderStateRuntime } from '@flighthq/render-wgpu/contract';
 import { createWgpuRenderStateForTest, installWgpuMock } from '@flighthq/render-wgpu/contract';
+import { getWgpuRenderStateRuntime } from '@flighthq/render-wgpu/contract';
 import type { ColorScaleBias } from '@flighthq/types/contract';
+import { RegistryEntryState } from '@flighthq/types/contract';
 
 import {
   areWgpuColorAdjustmentGuardsEnabled,
   enableWgpuColorAdjustmentGuards,
 } from './enableWgpuColorAdjustmentGuards';
+import { registerWgpuColorAdjustmentMaterialFeature } from './wgpuColorAdjustmentMaterialFeature';
 import { recordWgpuQuadBatchColorScaleBias } from './wgpuQuadBatchWriter';
 
 beforeAll(() => {
@@ -32,6 +34,15 @@ describe('areWgpuColorAdjustmentGuardsEnabled', () => {
     expect(areWgpuColorAdjustmentGuardsEnabled(state)).toBe(false);
     enableWgpuColorAdjustmentGuards(state);
     expect(areWgpuColorAdjustmentGuardsEnabled(state)).toBe(true);
+    const table = getWgpuRenderStateRuntime(state).registries.colorAdjustmentFeatureGuard;
+    expect(table).toMatchObject({
+      entry: { state: RegistryEntryState.Bound },
+      onMiss: 'Disabled',
+      registry: 'WgpuColorAdjustmentFeatureGuard',
+      shape: 'slot',
+    });
+    enableWgpuColorAdjustmentGuards(state);
+    expect(getWgpuRenderStateRuntime(state).registries.colorAdjustmentFeatureGuard).toBe(table);
   });
 });
 
@@ -67,17 +78,11 @@ describe('enableWgpuColorAdjustmentGuards', () => {
 
   it('does not warn when the guard slot is present but color adjustment is also enabled', async () => {
     const state = await createWgpuRenderStateForTest();
-    const runtime = getWgpuRenderStateRuntime(state);
     const sink = createMemoryLogSink(8);
     addLogSink(sink.sink);
     try {
       enableWgpuColorAdjustmentGuards(state);
-      runtime.wgpuColorAdjustmentMaterialFeature = {
-        fragmentShaderChunk: '',
-        matrixFragmentShaderChunk: '',
-        record: () => {},
-        resolveFlush: () => null,
-      };
+      registerWgpuColorAdjustmentMaterialFeature(state);
       recordWgpuQuadBatchColorScaleBias(state, ct(), 0);
       expect(getMemoryLogSinkEntries(sink).length).toBe(0);
     } finally {

package/src/enableWgpuStrokePathTessellation.test.ts

@@ -4,6 +4,7 @@ import {
   getWgpuRenderStateRuntime,
   installWgpuMock,
 } from '@flighthq/render-wgpu/contract';
+import { RegistryEntryState } from '@flighthq/types/contract';
 
 import { enableWgpuStrokePathTessellation } from './enableWgpuStrokePathTessellation';
 
@@ -12,12 +13,18 @@ beforeAll(() => {
 });
 
 describe('enableWgpuStrokePathTessellation', () => {
-  it('installs the full stroke tessellator on the render state', async () => {
+  it('replaces the full stroke-tessellator policy slot', async () => {
     const state = await createWgpuRenderStateForTest();
-    expect(getWgpuRenderStateRuntime(state).strokeTessellator).toBeNull();
+    const runtime = getWgpuRenderStateRuntime(state);
+    const before = runtime.registries.strokeTessellator;
+    expect(before.entry).toBeNull();
 
     enableWgpuStrokePathTessellation(state);
 
-    expect(getWgpuRenderStateRuntime(state).strokeTessellator).toBe(tessellateStrokePath);
+    expect(runtime.registries.strokeTessellator).not.toBe(before);
+    expect(runtime.registries.strokeTessellator.entry).toEqual({
+      state: RegistryEntryState.Bound,
+      value: tessellateStrokePath,
+    });
   });
 });

package/src/wgpuCache.test.ts

@@ -1,9 +1,24 @@
 import { createMatrix } from '@flighthq/geometry/contract';
+import { getRegistryTableEntry } from '@flighthq/registry/contract';
 import type * as WgpuRenderWgpuModule from '@flighthq/render-wgpu/contract';
-import { createRenderCache, createRenderState, RenderCacheKind, useRenderCache } from '@flighthq/render/contract';
+import {
+  createRenderCache,
+  createRenderState,
+  enableColorAdjustmentGuards,
+  getColorAdjustmentUnsupportedGuard,
+  RenderCacheKind,
+  useRenderCache,
+} from '@flighthq/render/contract';
 import { createDisplayObject } from '@flighthq/scene2d/contract';
-import type { WgpuRenderState, WgpuRenderTarget } from '@flighthq/types/contract';
-import { EntityRuntimeKey } from '@flighthq/types/contract';
+import type {
+  WgpuColorAdjustmentMaterialFeature,
+  WgpuColorAdjustmentMaterialFeatureGuard,
+  WgpuMaterialRenderer,
+  WgpuRenderState,
+  RenderRootGuard,
+  WgpuRenderTarget,
+} from '@flighthq/types/contract';
+import { EntityRuntimeKey, RegistryEntryState } from '@flighthq/types/contract';
 
 import { scopeModuleMocks } from './moduleMockTestHelper';
 import type * as WgpuCacheModule from './wgpuCache';
@@ -28,6 +43,9 @@ let refreshWgpuRenderCache: typeof WgpuCacheModule.refreshWgpuRenderCache;
 let releaseWgpuRenderCache: typeof WgpuCacheModule.releaseWgpuRenderCache;
 let createWgpuRenderStateRuntime: typeof WgpuRenderWgpuModule.createWgpuRenderStateRuntime;
 let getWgpuRenderStateRuntime: typeof WgpuRenderWgpuModule.getWgpuRenderStateRuntime;
+let getWgpuMaterialRenderer: typeof WgpuRenderWgpuModule.getWgpuMaterialRenderer;
+let registerWgpuMaterialRenderer: typeof WgpuRenderWgpuModule.registerWgpuMaterialRenderer;
+let resolveWgpuApplyBlendMode: typeof WgpuRenderWgpuModule.resolveWgpuApplyBlendMode;
 let beginWgpuFrame: typeof WgpuRenderWgpuModule.beginWgpuFrame;
 let destroyWgpuRenderTarget: typeof WgpuRenderWgpuModule.destroyWgpuRenderTarget;
 let drawWgpuRenderTargetResult: typeof WgpuRenderWgpuModule.drawWgpuRenderTargetResult;
@@ -92,7 +110,10 @@ beforeAll(async () => {
     createWgpuRenderStateRuntime,
     destroyWgpuRenderTarget,
     drawWgpuRenderTargetResult,
+    getWgpuMaterialRenderer,
     getWgpuRenderStateRuntime,
+    registerWgpuMaterialRenderer,
+    resolveWgpuApplyBlendMode,
     submitWgpuRenderPass,
   } = await import('@flighthq/render-wgpu/contract'));
   ({ flushWgpuQuadBatchWriter } = await import('./wgpuQuadBatchWriter'));
@@ -124,18 +145,141 @@ function makeCacheNode(source: unknown): any {
 }
 
 describe('createWgpuCacheState', () => {
+  it('resolves late screen blend-mode wiring explicitly until locally overridden', () => {
+    const screen = fakeScreen();
+    screen.applyBlendMode = null;
+    const cacheState = createWgpuCacheState(screen);
+    const screenHook = vi.fn();
+    const laterScreenHook = vi.fn();
+    const cacheHook = vi.fn();
+
+    expect(cacheState.applyBlendMode).toBeNull();
+    expect(Object.getOwnPropertyDescriptor(cacheState, 'applyBlendMode')?.get).toBeUndefined();
+    expect(resolveWgpuApplyBlendMode(cacheState)).toBeNull();
+    screen.applyBlendMode = screenHook;
+    expect(cacheState.applyBlendMode).toBeNull();
+    expect(resolveWgpuApplyBlendMode(cacheState)).toBe(screenHook);
+
+    cacheState.applyBlendMode = cacheHook;
+    screen.applyBlendMode = laterScreenHook;
+    expect(resolveWgpuApplyBlendMode(cacheState)).toBe(cacheHook);
+  });
+
   it('copies renderers and shares the GPU device but keeps its own node map', () => {
     const screen = fakeScreen();
     const resolver = vi.fn();
-    getWgpuRenderStateRuntime(screen).colorAdjustmentResolver = resolver;
+    const colorAdjustmentFeature: WgpuColorAdjustmentMaterialFeature = {
+      fragmentShaderChunk: '',
+      matrixFragmentShaderChunk: '',
+      record: vi.fn(),
+      resolveFlush: vi.fn(() => null),
+    };
+    const colorAdjustmentFeatureGuard: WgpuColorAdjustmentMaterialFeatureGuard = vi.fn();
+    const renderRootGuard: RenderRootGuard = vi.fn();
+    const screenRuntime = getWgpuRenderStateRuntime(screen);
+    screenRuntime.registries.colorAdjustments = {
+      entry: { state: RegistryEntryState.Bound, value: resolver },
+      onMiss: 'Disabled',
+      registry: 'ColorAdjustments',
+      shape: 'slot',
+    };
+    screenRuntime.registries.colorAdjustmentFeature = {
+      entry: { state: RegistryEntryState.Bound, value: colorAdjustmentFeature },
+      onMiss: 'Disabled',
+      registry: 'WgpuColorAdjustmentFeature',
+      shape: 'slot',
+    };
+    screenRuntime.registries.colorAdjustmentFeatureGuard = {
+      entry: { state: RegistryEntryState.Bound, value: colorAdjustmentFeatureGuard },
+      onMiss: 'Disabled',
+      registry: 'WgpuColorAdjustmentFeatureGuard',
+      shape: 'slot',
+    };
+    screenRuntime.registries.renderRootGuard = {
+      entry: { state: RegistryEntryState.Bound, value: renderRootGuard },
+      onMiss: 'Disabled',
+      registry: 'RenderRootGuard',
+      shape: 'slot',
+    };
+    enableColorAdjustmentGuards(screen);
     enableWgpuRenderCache(screen);
     const cacheState = createWgpuCacheState(screen);
-    expect(getWgpuRenderStateRuntime(cacheState).rendererMap.get(RenderCacheKind)).toBe(defaultWgpuRenderCacheRenderer);
+    expect(getWgpuRenderStateRuntime(cacheState).registries.renderers.entries.get(RenderCacheKind)).toEqual({
+      state: 'bound',
+      value: defaultWgpuRenderCacheRenderer,
+    });
     expect((cacheState as any).device).toBe((screen as any).device);
     expect(getWgpuRenderStateRuntime(cacheState).renderProxyMap).not.toBe(
       getWgpuRenderStateRuntime(screen).renderProxyMap,
     );
-    expect(getWgpuRenderStateRuntime(cacheState).colorAdjustmentResolver).toBe(resolver);
+    expect(getWgpuRenderStateRuntime(cacheState).registries.colorAdjustments).toBe(
+      screenRuntime.registries.colorAdjustments,
+    );
+    expect(getWgpuRenderStateRuntime(cacheState).registries.colorAdjustmentFeature).toBe(
+      screenRuntime.registries.colorAdjustmentFeature,
+    );
+    const cacheRuntime = getWgpuRenderStateRuntime(cacheState);
+    expect(cacheRuntime.registries.colorAdjustmentFeatureGuard).toBe(
+      screenRuntime.registries.colorAdjustmentFeatureGuard,
+    );
+    const sharedColorFeatureGuard = cacheRuntime.registries.colorAdjustmentFeatureGuard;
+    screenRuntime.registries.colorAdjustmentFeatureGuard = undefined;
+    expect(cacheRuntime.registries.colorAdjustmentFeatureGuard).toBe(sharedColorFeatureGuard);
+    expect(cacheRuntime.registries.colorAdjustmentUnsupportedGuard).toBe(
+      screenRuntime.registries.colorAdjustmentUnsupportedGuard,
+    );
+    expect(getColorAdjustmentUnsupportedGuard(cacheState)).not.toBeNull();
+    const sharedUnsupportedGuard = cacheRuntime.registries.colorAdjustmentUnsupportedGuard;
+    screenRuntime.registries.colorAdjustmentUnsupportedGuard = undefined;
+    expect(getColorAdjustmentUnsupportedGuard(screen)).toBeNull();
+    expect(cacheRuntime.registries.colorAdjustmentUnsupportedGuard).toBe(sharedUnsupportedGuard);
+    expect(getColorAdjustmentUnsupportedGuard(cacheState)).not.toBeNull();
+    expect(cacheRuntime.registries.renderRootGuard).toBe(screenRuntime.registries.renderRootGuard);
+    expect(
+      getRegistryTableEntry(
+        cacheRuntime.registries.renderRootGuard!,
+        cacheRuntime.registries.renderRootGuard!.registry,
+      ),
+    ).toBe(renderRootGuard);
+    const sharedRootGuard = cacheRuntime.registries.renderRootGuard;
+    screenRuntime.registries.renderRootGuard = undefined;
+    expect(screenRuntime.registries.renderRootGuard).toBeUndefined();
+    expect(cacheRuntime.registries.renderRootGuard).toBe(sharedRootGuard);
+    expect(
+      getRegistryTableEntry(
+        cacheRuntime.registries.renderRootGuard!,
+        cacheRuntime.registries.renderRootGuard!.registry,
+      ),
+    ).toBe(renderRootGuard);
+  });
+
+  it('shares persistent registration snapshots through a distinct aggregate and then diverges', () => {
+    const screen = fakeScreen();
+    const first: WgpuMaterialRenderer = { instanceFloatCount: 0, getShaderModule: vi.fn() };
+    const replacement: WgpuMaterialRenderer = { instanceFloatCount: 0, getShaderModule: vi.fn() };
+    registerWgpuMaterialRenderer(screen, 'acme.Material', first);
+
+    const cacheState = createWgpuCacheState(screen);
+    const screenRuntime = getWgpuRenderStateRuntime(screen);
+    const cacheRuntime = getWgpuRenderStateRuntime(cacheState);
+    expect(cacheRuntime.registries).not.toBe(screenRuntime.registries);
+    expect(cacheRuntime.registries.colorAdjustments).toBe(screenRuntime.registries.colorAdjustments);
+    expect(cacheRuntime.registries.compressedTextureDecoder).toBe(screenRuntime.registries.compressedTextureDecoder);
+    expect(cacheRuntime.registries.compressedTextureUpload).toBe(screenRuntime.registries.compressedTextureUpload);
+    expect(cacheRuntime.registries.customMaterialShaders).toBe(screenRuntime.registries.customMaterialShaders);
+    expect(cacheRuntime.registries.materialRenderers).toBe(screenRuntime.registries.materialRenderers);
+    expect(cacheRuntime.registries.meshMaterialRenderers).toBe(screenRuntime.registries.meshMaterialRenderers);
+    expect(cacheRuntime.registries.renderEffects).toBe(screenRuntime.registries.renderEffects);
+    expect(cacheRuntime.registries.shapeRasterizer).toBe(screenRuntime.registries.shapeRasterizer);
+    expect(cacheRuntime.registries.strokeTessellator).toBe(screenRuntime.registries.strokeTessellator);
+    expect(cacheRuntime.registries.textureResolvers).toBe(screenRuntime.registries.textureResolvers);
+    expect(cacheRuntime.registries.velocityWriters).toBe(screenRuntime.registries.velocityWriters);
+    expect(getWgpuMaterialRenderer(cacheState, 'acme.Material')).toBe(first);
+
+    registerWgpuMaterialRenderer(screen, 'acme.Material', replacement);
+
+    expect(getWgpuMaterialRenderer(screen, 'acme.Material')).toBe(replacement);
+    expect(getWgpuMaterialRenderer(cacheState, 'acme.Material')).toBe(first);
   });
 });
 
@@ -177,7 +321,10 @@ describe('enableWgpuRenderCache', () => {
   it('registers the renderer for the render cache kind', () => {
     const state = fakeScreen();
     enableWgpuRenderCache(state);
-    expect(getWgpuRenderStateRuntime(state).rendererMap.get(RenderCacheKind)).toBe(defaultWgpuRenderCacheRenderer);
+    expect(getWgpuRenderStateRuntime(state).registries.renderers.entries.get(RenderCacheKind)).toEqual({
+      state: 'bound',
+      value: defaultWgpuRenderCacheRenderer,
+    });
   });
 });
 

package/src/wgpuColorAdjustmentMaterialFeature.test.ts

@@ -1,5 +1,5 @@
 import { renderWgpuBackground, submitWgpuRenderPass } from '@flighthq/render-wgpu/contract';
-import { getWgpuRenderStateRuntime } from '@flighthq/render-wgpu/contract';
+import { getWgpuColorAdjustmentMaterialFeature, getWgpuRenderStateRuntime } from '@flighthq/render-wgpu/contract';
 import { createWgpuRenderStateForTest, installWgpuMock } from '@flighthq/render-wgpu/contract';
 import { areColorAdjustmentsEnabled } from '@flighthq/render/contract';
 import type { ColorScaleBias } from '@flighthq/types/contract';
@@ -51,18 +51,19 @@ describe('registerWgpuColorAdjustmentMaterialFeature', () => {
     const runtime = getWgpuRenderStateRuntime(state);
     registerWgpuColorAdjustmentMaterialFeature(state);
     expect(areColorAdjustmentsEnabled(state)).toBe(true);
-    expect(runtime.wgpuColorAdjustmentMaterialFeature).toBeDefined();
-    expect(runtime.wgpuColorAdjustmentMaterialFeature).not.toBeNull();
-    expect(runtime.wgpuColorAdjustmentMaterialFeature?.drawShapeMeshes).toBeTypeOf('function');
+    expect(runtime.registries.colorAdjustmentFeature).toBeDefined();
+    expect(getWgpuColorAdjustmentMaterialFeature(state)?.drawShapeMeshes).toBeTypeOf('function');
   });
 
   it('is idempotent', async () => {
     const state = await createWgpuRenderStateForTest();
     const runtime = getWgpuRenderStateRuntime(state);
     registerWgpuColorAdjustmentMaterialFeature(state);
-    const fold = runtime.wgpuColorAdjustmentMaterialFeature;
+    const table = runtime.registries.colorAdjustmentFeature;
+    const fold = getWgpuColorAdjustmentMaterialFeature(state);
     registerWgpuColorAdjustmentMaterialFeature(state);
-    expect(runtime.wgpuColorAdjustmentMaterialFeature).toBe(fold);
+    expect(runtime.registries.colorAdjustmentFeature).toBe(table);
+    expect(getWgpuColorAdjustmentMaterialFeature(state)).toBe(fold);
   });
 
   it('stays untinted (mode NONE) when no instance carries a color adjustment', async () => {

package/src/wgpuParticleEmitter2D.test.ts

@@ -9,7 +9,7 @@ import { createWgpuRenderStateForTest, installWgpuMock } from '@flighthq/render-
 import { getRenderProxy2D, prepareScene2DRender } from '@flighthq/render/contract';
 import { createTexture } from '@flighthq/texture/contract';
 import type { CompressedImage, RenderProxy2D } from '@flighthq/types/contract';
-import { CompressedImageTextureSourceKind } from '@flighthq/types/contract';
+import { CompressedImageTextureSourceKind, RegistryEntryState } from '@flighthq/types/contract';
 
 import { defaultWgpuParticleEmitter2DRenderer, drawWgpuParticleEmitter2D } from './wgpuParticleEmitter2D';
 
@@ -53,19 +53,25 @@ describe('drawWgpuParticleEmitter2D', () => {
       version: 1,
       width: 4,
     } as unknown as CompressedImage;
-    runtime.compressedTextureUpload = () => {
-      const texture = state.device.createTexture({
-        size: [4, 4],
-        format: 'bc3-rgba-unorm',
-        usage: GPUTextureUsage.TEXTURE_BINDING,
-      });
-      const view = texture.createView();
-      return {
-        bindGroup: state.device.createBindGroup({ layout: runtime.textureBindGroupLayout, entries: [] }),
-        straightAlpha: true,
-        texture,
-        view,
-      };
+    runtime.registries.compressedTextureUpload = {
+      ...runtime.registries.compressedTextureUpload,
+      entry: {
+        state: RegistryEntryState.Bound,
+        value: () => {
+          const texture = state.device.createTexture({
+            size: [4, 4],
+            format: 'bc3-rgba-unorm',
+            usage: GPUTextureUsage.TEXTURE_BINDING,
+          });
+          const view = texture.createView();
+          return {
+            bindGroup: state.device.createBindGroup({ layout: runtime.textureBindGroupLayout, entries: [] }),
+            straightAlpha: true,
+            texture,
+            view,
+          };
+        },
+      },
     };
     const renderProxy = {
       alpha: 1,

package/src/wgpuShapeRasterizer.test.ts

@@ -1,4 +1,8 @@
-import { createWgpuRenderStateForTest, installWgpuMock } from '@flighthq/render-wgpu/contract';
+import {
+  createWgpuRenderStateForTest,
+  getWgpuRenderStateRuntime,
+  installWgpuMock,
+} from '@flighthq/render-wgpu/contract';
 import { createRenderState, enableRenderRegistryGuards, explainRenderRegistryMisses } from '@flighthq/render/contract';
 import { RenderRegistry } from '@flighthq/types/contract';
 
@@ -19,18 +23,24 @@ describe('registerWgpuShapeRasterizer', () => {
   it('installs the rasterizer the shape path draws non-solid fills through', async () => {
     const state = await createWgpuRenderStateForTest();
     const rasterizer = (): void => {};
+    const before = getWgpuRenderStateRuntime(state).registries.shapeRasterizer;
 
     registerWgpuShapeRasterizer(state, rasterizer);
 
     expect(getWgpuShapeRasterizer(state)).toBe(rasterizer);
+    expect(getWgpuRenderStateRuntime(state).registries.shapeRasterizer).not.toBe(before);
+    expect(before.entry).toBeNull();
   });
 
   it('removes one again, so a state can drop back to tessellation only', async () => {
     const state = await createWgpuRenderStateForTest();
     registerWgpuShapeRasterizer(state, (): void => {});
+    const before = getWgpuRenderStateRuntime(state).registries.shapeRasterizer;
 
     registerWgpuShapeRasterizer(state, null);
 
     expect(getWgpuShapeRasterizer(state)).toBeNull();
+    expect(getWgpuRenderStateRuntime(state).registries.shapeRasterizer).not.toBe(before);
+    expect(before.entry?.state).toBe('bound');
   });
 });

package/src/wgpuTextLabel.test.ts

@@ -24,14 +24,14 @@ beforeAll(async () => {
     const actual = (await importOriginal()) as Record<string, unknown>;
     return {
       ...actual,
-      computeTextLayout: vi.fn((result: { groups: object[] }) => {
+      computeTextLayout: vi.fn((result: { groups: object[] }, params: { formatRanges: Array<{ format: object }> }) => {
         result.groups.push({
           offsetX: 0,
           offsetY: 0,
           width: 50,
           ascent: 12,
           descent: 4,
-          format: {},
+          format: params.formatRanges[0]?.format ?? {},
           startIndex: 0,
           endIndex: 5,
         });
@@ -107,6 +107,22 @@ describe('drawWgpuTextLabel', () => {
     submitWgpuRenderPass(state);
   });
 
+  it('rasterizes packed run alpha into the canvas color', async () => {
+    const state = await createWgpuRenderStateForTest();
+    renderWgpuBackground(state);
+    registerWgpuStandardMaterial(state);
+    const data = makeTextData();
+    const proxy = makeTextProxy('hello', data);
+    (proxy.source as ReturnType<typeof createTextLabel>).data.textFormat = { color: 0xff000080 };
+    const styles: Array<string | CanvasGradient | CanvasPattern> = [];
+    vi.spyOn(data.ctx, 'fillText').mockImplementation(() => styles.push(data.ctx.fillStyle));
+
+    drawWgpuTextLabel(state, proxy);
+
+    expect(styles).toEqual(['rgba(255, 0, 0, 0.5019607843137255)']);
+    submitWgpuRenderPass(state);
+  });
+
   it('does not re-rasterize when only alpha changes (content version unchanged)', async () => {
     const state = await createWgpuRenderStateForTest();
     renderWgpuBackground(state);

package/src/wgpuVelocity.test.ts

@@ -1,6 +1,10 @@
 import { createParticleEmitter2D, reserveParticleEmitter2D } from '@flighthq/particleemitter/contract';
 import { createQuadBatch, getQuadBatchRuntime } from '@flighthq/quadbatch/contract';
-import { renderWgpuBackground } from '@flighthq/render-wgpu/contract';
+import {
+  createWgpuOffscreenRenderState,
+  getWgpuRenderStateRuntime,
+  renderWgpuBackground,
+} from '@flighthq/render-wgpu/contract';
 import { createWgpuRenderStateForTest, installWgpuMock } from '@flighthq/render-wgpu/contract';
 import { createDisplayObject } from '@flighthq/scene2d/contract';
 import type { QuadBatchRuntime, TextureAtlas, TextureAtlasRegion } from '@flighthq/types/contract';
@@ -119,6 +123,24 @@ describe('registerWgpuVelocityWriter', () => {
     registerWgpuVelocityWriter(state, root.kind, defaultWgpuNode2DVelocityWriter);
     expect(getWgpuVelocityWriter(state, root.kind)).toBe(defaultWgpuNode2DVelocityWriter);
   });
+
+  it('replaces persistent snapshots and preserves a derived pipeline snapshot', async () => {
+    const state = await createWgpuRenderStateForTest();
+    const kind = 'acme.Velocity';
+    const replacement = vi.fn();
+    const before = getWgpuRenderStateRuntime(state).registries.velocityWriters;
+
+    registerWgpuVelocityWriter(state, kind, defaultWgpuNode2DVelocityWriter);
+    const registered = getWgpuRenderStateRuntime(state).registries.velocityWriters;
+    const offscreen = createWgpuOffscreenRenderState(state);
+    registerWgpuVelocityWriter(state, kind, replacement);
+
+    expect(registered).not.toBe(before);
+    expect(before.entries.has(kind)).toBe(false);
+    expect(registered.entries.get(kind)).toEqual({ state: 'bound', value: defaultWgpuNode2DVelocityWriter });
+    expect(getWgpuVelocityWriter(state, kind)).toBe(replacement);
+    expect(getWgpuVelocityWriter(offscreen, kind)).toBe(defaultWgpuNode2DVelocityWriter);
+  });
 });
 
 describe('renderWgpuVelocity', () => {