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

package/src/explainWgpuScene3DCoverage.test.ts

@@ -6,12 +6,14 @@ import { createTexture } from '@flighthq/texture/contract';
 import type {
   ImageResourceReference,
   Scene3DKindUsage,
+  SceneCoverageCatalog,
   SceneCoverageEntry,
   WgpuRenderState,
 } from '@flighthq/types/contract';
 import {
   ImageResourceReferenceKind,
   RenderRegistry,
+  RequirementFacet,
   ResourceResolutionState,
   SceneCoverage,
   StandardMaterialKind,
@@ -22,8 +24,27 @@ import { explainWgpuScene3DCoverage, hasWgpuScene3DCoverage } from './explainWgp
 import { registerWgpuMeshMaterialRenderer } from './wgpuMeshMaterialRegistry';
 import { makeWgpuScene3DState } from './wgpuScene3DTestHelper';
 
+const coverageCatalog: SceneCoverageCatalog = [
+  {
+    kind: 'ShadedMaterial',
+    registrations: [{ module: '@flighthq/scene3d-wgpu', registrar: 'registerWgpuShadedMaterial' }],
+    registry: RenderRegistry.MaterialRenderer,
+  },
+  {
+    kind: 'image',
+    registrations: [{ module: '@flighthq/scene3d-wgpu', registrar: 'registerWgpuImageTextureResolver' }],
+    registry: RenderRegistry.TextureResolver,
+  },
+  {
+    kind: 'RimModifier',
+    registrations: [{ module: '@flighthq/scene3d-wgpu', registrar: 'registerWgpuRimModifier' }],
+    registry: RenderRegistry.ModifierSnippet,
+  },
+];
+
 function shadedUsage(withModifier = false): Scene3DKindUsage {
   const ref: ImageResourceReference = {
+    alphaType: 'straight',
     bytes: new Uint8Array([1, 2, 3]),
     failure: null,
     kind: ImageResourceReferenceKind.Embedded,
@@ -42,23 +63,29 @@ function shadedUsage(withModifier = false): Scene3DKindUsage {
 
 function entries(state: WgpuRenderState, withModifier = false): SceneCoverageEntry[] {
   const out: SceneCoverageEntry[] = [];
-  explainWgpuScene3DCoverage(out, state, shadedUsage(withModifier));
+  explainWgpuScene3DCoverage(out, state, shadedUsage(withModifier), coverageCatalog);
   return out;
 }
 
 const renderer = { bind() {}, draw() {} } as never;
 
 describe('explainWgpuScene3DCoverage', () => {
-  it('reports a bare state as missing both the material renderer and the texture resolver', () => {
+  it('reports a bare state with remedies for both unregistered requirements', () => {
     const found = entries(makeWgpuScene3DState().state);
     expect(found).toContainEqual({
-      coverage: SceneCoverage.Missing,
+      coverage: SceneCoverage.Unregistered,
+      facet: RequirementFacet.SceneMaterialKind,
       kind: 'ShadedMaterial',
+      module: '@flighthq/scene3d-wgpu',
+      registrar: 'registerWgpuShadedMaterial',
       registry: RenderRegistry.MaterialRenderer,
     });
     expect(found).toContainEqual({
-      coverage: SceneCoverage.Missing,
+      coverage: SceneCoverage.Unregistered,
+      facet: RequirementFacet.SceneTextureSourceKind,
       kind: 'image',
+      module: '@flighthq/scene3d-wgpu',
+      registrar: 'registerWgpuImageTextureResolver',
       registry: RenderRegistry.TextureResolver,
     });
   });
@@ -67,8 +94,11 @@ describe('explainWgpuScene3DCoverage', () => {
     const { state } = makeWgpuScene3DState();
     registerWgpuMeshMaterialRenderer(state, StandardMaterialKind, renderer);
     expect(entries(state)).toContainEqual({
-      coverage: SceneCoverage.Fallback,
+      coverage: SceneCoverage.FallbackRemediable,
+      facet: RequirementFacet.SceneMaterialKind,
       kind: 'ShadedMaterial',
+      module: '@flighthq/scene3d-wgpu',
+      registrar: 'registerWgpuShadedMaterial',
       registry: RenderRegistry.MaterialRenderer,
     });
   });
@@ -78,17 +108,21 @@ describe('explainWgpuScene3DCoverage', () => {
     registerWgpuMeshMaterialRenderer(state, 'ShadedMaterial', renderer);
     expect(entries(state)).toContainEqual({
       coverage: SceneCoverage.Satisfied,
+      facet: RequirementFacet.SceneMaterialKind,
       kind: 'ShadedMaterial',
       registry: RenderRegistry.MaterialRenderer,
     });
   });
 
-  it('reports an unregistered modifier snippet as Missing, never a fallback', () => {
+  it('reports an unregistered modifier snippet as actionable, never a fallback', () => {
     // The shaded compiler assembles base + modifiers into one program, so an absent snippet fails the
     // whole material rather than degrading it.
     expect(entries(makeWgpuScene3DState().state, true)).toContainEqual({
-      coverage: SceneCoverage.Missing,
+      coverage: SceneCoverage.Unregistered,
+      facet: RequirementFacet.SceneModifierKind,
       kind: 'RimModifier',
+      module: '@flighthq/scene3d-wgpu',
+      registrar: 'registerWgpuRimModifier',
       registry: RenderRegistry.ModifierSnippet,
     });
   });
@@ -101,9 +135,9 @@ describe('explainWgpuScene3DCoverage', () => {
     const { state } = makeWgpuScene3DState();
     const usage = shadedUsage();
     const out: SceneCoverageEntry[] = [];
-    explainWgpuScene3DCoverage(out, state, usage);
+    explainWgpuScene3DCoverage(out, state, usage, coverageCatalog);
     const first = out.length;
-    explainWgpuScene3DCoverage(out, state, usage);
+    explainWgpuScene3DCoverage(out, state, usage, coverageCatalog);
     expect(out).toHaveLength(first);
   });
 });
@@ -124,7 +158,7 @@ describe('hasWgpuScene3DCoverage', () => {
     registerWgpuMeshMaterialRenderer(state, 'ShadedMaterial', renderer);
     const usage = shadedUsage();
     const out: SceneCoverageEntry[] = [];
-    explainWgpuScene3DCoverage(out, state, usage);
+    explainWgpuScene3DCoverage(out, state, usage, coverageCatalog);
     const gaps = out.filter((e) => e.coverage !== SceneCoverage.Satisfied);
     expect(hasWgpuScene3DCoverage(state, usage)).toBe(gaps.length === 0);
   });

package/src/wgpuMeshMaterialRegistry.test.ts

@@ -1,4 +1,6 @@
 import { createStandardPbrMaterial } from '@flighthq/materials/contract';
+import { getRegistryTableEntry } from '@flighthq/registry/contract';
+import { copyWgpuRenderStateRegistrations, getWgpuRenderStateRuntime } from '@flighthq/render-wgpu/contract';
 import type { WgpuMeshMaterialRenderer } from '@flighthq/types/contract';
 import { StandardMaterialKind, StandardPbrMaterialKind } from '@flighthq/types/contract';
 
@@ -7,6 +9,7 @@ import {
   registerWgpuMeshMaterialRenderer,
   resolveWgpuMeshMaterialRenderer,
 } from './wgpuMeshMaterialRegistry';
+import { getWgpuScene3DRuntime } from './wgpuScene3DRuntime';
 import { makeWgpuScene3DState } from './wgpuScene3DTestHelper';
 
 function makeRenderer(): WgpuMeshMaterialRenderer {
@@ -30,6 +33,25 @@ describe('registerWgpuMeshMaterialRenderer', () => {
     registerWgpuMeshMaterialRenderer(state, StandardPbrMaterialKind, renderer);
     expect(getWgpuMeshMaterialRenderer(state, StandardPbrMaterialKind)).toBe(renderer);
   });
+
+  it('replaces the persistent table while an explicitly copied state retains its snapshot', () => {
+    const { state: screen } = makeWgpuScene3DState();
+    const { state: derived } = makeWgpuScene3DState();
+    const renderer = makeRenderer();
+    const replacement = makeRenderer();
+    registerWgpuMeshMaterialRenderer(screen, StandardPbrMaterialKind, renderer);
+    const snapshot = getWgpuRenderStateRuntime(screen).registries.meshMaterialRenderers;
+
+    copyWgpuRenderStateRegistrations(derived, screen);
+    getWgpuScene3DRuntime(derived);
+    registerWgpuMeshMaterialRenderer(screen, StandardPbrMaterialKind, replacement);
+
+    expect(getWgpuRenderStateRuntime(derived).registries.meshMaterialRenderers).toBe(snapshot);
+    expect(getWgpuRenderStateRuntime(screen).registries.meshMaterialRenderers).not.toBe(snapshot);
+    expect(getRegistryTableEntry(snapshot, StandardPbrMaterialKind)).toBe(renderer);
+    expect(getWgpuMeshMaterialRenderer(derived, StandardPbrMaterialKind)).toBe(renderer);
+    expect(getWgpuMeshMaterialRenderer(screen, StandardPbrMaterialKind)).toBe(replacement);
+  });
 });
 
 describe('resolveWgpuMeshMaterialRenderer', () => {

package/src/wgpuMeshPipeline.test.ts

@@ -1,7 +1,7 @@
 import { createCamera3D } from '@flighthq/camera/contract';
 import { createMatrix3, createMatrix4 } from '@flighthq/geometry/contract';
 import { createStandardPbrMaterial } from '@flighthq/materials/contract';
-import { createBoxMeshGeometry } from '@flighthq/mesh/contract';
+import { createBoxMeshGeometry, createMeshGeometry } from '@flighthq/mesh/contract';
 import { getWgpuRenderStateRuntime } from '@flighthq/render-wgpu/contract';
 import { createTexture, setTextureUvOffset, setTextureUvScale } from '@flighthq/texture/contract';
 import type {
@@ -277,6 +277,39 @@ describe('drawWgpuMeshSubset', () => {
     expect(draw!.args[0]).toBe(proxy.subset.indexCount);
   });
 
+  // The defect this covers: non-indexed geometry issued NO draw call at all, so a valid imported mesh
+  // rendered nothing and reported nothing. A backend that silently drops geometry is worse than one
+  // that draws it wrong, because nothing announces the loss.
+  it('issues a non-indexed draw for geometry without indices', () => {
+    const { fake, state } = makeWgpuScene3DState();
+    ensureWgpuFrameBindGroup(state);
+    beginWgpuMeshDraw(state, makePipeline(state));
+    const geometry = createMeshGeometry({
+      indices: null,
+      layout: {
+        attributes: [{ byteOffset: 0, format: 'float32x3', semantic: 'position' }],
+        stride: 12,
+      },
+      vertices: new Float32Array(9),
+    });
+    const proxy: Scene3DRenderProxy = {
+      material: createStandardPbrMaterial(),
+      normalMatrix: createMatrix3(),
+      subset: geometry.subsets[0],
+      worldMatrix: createMatrix4(),
+    };
+
+    drawWgpuMeshSubset(state, proxy, geometry);
+
+    const draw = fake.calls.find((c) => c.name === 'draw');
+    expect(draw).toBeDefined();
+    expect(draw!.args[0]).toBe(proxy.subset.indexCount);
+    expect(draw!.args[2]).toBe(proxy.subset.indexOffset);
+    // It must not try to bind an index buffer it does not have.
+    expect(fake.calls.some((c) => c.name === 'setIndexBuffer')).toBe(false);
+    expect(fake.calls.some((c) => c.name === 'drawIndexed')).toBe(false);
+  });
+
   it('is a no-op when no pipeline is active', () => {
     const { fake, state } = makeWgpuScene3DState();
     drawWgpuMeshSubset(state, makeProxy(), createBoxMeshGeometry());

package/src/wgpuMeshUpload.test.ts

@@ -44,6 +44,28 @@ describe('ensureWgpuMeshUpload', () => {
     expect(fake.calls.filter((c) => c.name === 'writeBuffer').length).toBeGreaterThanOrEqual(2);
   });
 
+  it('pads an odd-length Uint16 index upload to four-byte alignment without changing the index count', () => {
+    const { fake, state } = makeWgpuScene3DState();
+    const geometry = createMeshGeometry({
+      indices: new Uint16Array([0, 1, 2]),
+      layout: POSITION_LAYOUT,
+      vertices: new Float32Array(9),
+    });
+
+    const upload = ensureWgpuMeshUpload(state, geometry);
+    const writes = fake.calls.filter((call) => call.name === 'writeBuffer');
+    const indexWrite = writes[writes.length - 1]!;
+    const uploadedIndices = new Uint16Array(
+      indexWrite.args[2] as ArrayBuffer,
+      indexWrite.args[3] as number,
+      (indexWrite.args[4] as number) / Uint16Array.BYTES_PER_ELEMENT,
+    );
+
+    expect(indexWrite.args[4]).toBe(8);
+    expect(Array.from(uploadedIndices.subarray(0, 3))).toEqual([0, 1, 2]);
+    expect(upload.indexCount).toBe(3);
+  });
+
   it('returns the cached upload without re-uploading when version is unchanged', () => {
     const { fake, state } = makeWgpuScene3DState();
     const geometry = createBoxMeshGeometry();
@@ -80,6 +102,8 @@ describe('ensureWgpuMeshUpload', () => {
       positions: new Float32Array([1, 2, 3]),
       skinnedNormals: new Float32Array(3),
       skinnedPositions: new Float32Array(3),
+      skinnedTangents: new Float32Array(0),
+      tangents: new Float32Array(0),
       weights: new Float32Array([1, 0, 0, 0]),
     });
 
@@ -135,6 +159,8 @@ describe('ensureWgpuMeshUpload', () => {
       positions: new Float32Array([1, 0, 0]),
       skinnedNormals: new Float32Array(3),
       skinnedPositions: new Float32Array(3),
+      skinnedTangents: new Float32Array(0),
+      tangents: new Float32Array(0),
       weights: new Float32Array([1, 0, 0, 0]),
     });
     const morph: MeshMorph = {
@@ -162,7 +188,32 @@ describe('ensureWgpuMeshUpload', () => {
     expect(meshRuntime.webgpuData as unknown).toBe(upload);
   });
 
-  it('returns null for non-indexed geometry', () => {
+  // glTF primitives may legitimately omit indices and the importer preserves that, so refusing to
+  // upload them made valid meshes vanish on this backend with nothing rendered and nothing thrown.
+  // The GL sibling has always uploaded them; this mirrors it.
+  it('uploads non-indexed geometry with the vertex count in indexCount', () => {
+    const { state } = makeWgpuScene3DState();
+    const geometry = createMeshGeometry({
+      indices: null,
+      layout: {
+        attributes: [{ byteOffset: 0, format: 'float32x3', semantic: 'position' }],
+        stride: 12,
+      },
+      vertices: new Float32Array(9),
+    });
+
+    const upload = ensureWgpuMeshUpload(state, geometry);
+
+    expect(upload.vertexBuffer).toBeDefined();
+    expect(upload.indexBuffer).toBeNull();
+    // 9 floats / 3 per vertex = 3 vertices, the count a non-indexed draw needs.
+    expect(upload.indexCount).toBe(3);
+    expect(getWgpuScene3DRuntime(state).uploadCache.get(geometry)).toBe(upload);
+  });
+
+  // No index buffer exists, so no element format describes one. Null says that; a stand-in 'uint16'
+  // would read as a fact about a buffer that is not there.
+  it('reports a null index format for non-indexed geometry', () => {
     const { state } = makeWgpuScene3DState();
     const geometry = createMeshGeometry({
       indices: null,
@@ -172,7 +223,18 @@ describe('ensureWgpuMeshUpload', () => {
       },
       vertices: new Float32Array(9),
     });
-    expect(ensureWgpuMeshUpload(state, geometry)).toBeNull();
-    expect(getWgpuScene3DRuntime(state).uploadCache.get(geometry)).toBeUndefined();
+
+    expect(ensureWgpuMeshUpload(state, geometry).indexFormat).toBeNull();
+  });
+
+  it('reports zero vertices when the layout has no stride to divide by', () => {
+    const { state } = makeWgpuScene3DState();
+    const geometry = createMeshGeometry({
+      indices: null,
+      layout: { attributes: [], stride: 0 },
+      vertices: new Float32Array(9),
+    });
+
+    expect(ensureWgpuMeshUpload(state, geometry).indexCount).toBe(0);
   });
 });

package/src/wgpuParticleEmitter3D.test.ts

@@ -157,6 +157,29 @@ describe('drawWgpuScene3DParticleEmitter3Ds', () => {
     expect(pipelineDescriptors(fake.calls).some((d) => hasTextureConstant(d) === 1)).toBe(true);
   });
 
+  it('copies atlas pixels with straight alpha for post-decode shader premultiplication', () => {
+    const { state, fake } = makeAtlasWgpuScene3DState();
+    const scene = createNode3D(Node3DKind);
+    addNodeChild(scene, makeAtlasEmitter(64, 64));
+    drawWgpuScene3DParticleEmitter3Ds(state, scene, makeCamera(), makeLights());
+    const copy = fake.calls.find((c) => c.name === 'copyExternalImageToTexture');
+    expect(copy).toBeDefined();
+    expect((copy!.args[1] as { premultipliedAlpha?: boolean }).premultipliedAlpha).toBe(false);
+  });
+
+  it('premultiplies sampled atlas color after decode in the fragment shader', () => {
+    const { state, fake } = makeAtlasWgpuScene3DState();
+    const scene = createNode3D(Node3DKind);
+    addNodeChild(scene, makeAtlasEmitter(64, 64));
+    drawWgpuScene3DParticleEmitter3Ds(state, scene, makeCamera(), makeLights());
+    const shaderSource = fake.calls
+      .filter((c) => c.name === 'createShaderModule')
+      .map((c) => String((c.args[0] as { code: string }).code))
+      .find((source) => source.includes('@fragment fn fs_main'));
+    expect(shaderSource).toContain('let alpha = tex.a * in.color.a;');
+    expect(shaderSource).toContain('vec4f(tex.rgb * in.color.rgb * alpha, alpha)');
+  });
+
   it('compiles the untextured pipeline variant for an atlas-less emitter', () => {
     const { state, fake } = makeWgpuScene3DState();
     const scene = createNode3D(Node3DKind);

package/src/wgpuScene3DRuntime.test.ts

@@ -11,17 +11,21 @@ describe('getWgpuScene3DRuntime', () => {
     const a = getWgpuScene3DRuntime(state);
     const b = getWgpuScene3DRuntime(state);
     expect(a).toBe(b);
-    expect(a.materialRegistry).toBeInstanceOf(Map);
     expect(a.pipelineCache).toBeInstanceOf(Map);
     expect(a.activeBlendMode).toBeNull();
     expect(a.activeMeshPipeline).toBeNull();
   });
 
-  it('surfaces the registry and upload cache through the header runtime slots', () => {
+  it('surfaces its upload cache without replacing persistent material dispatch policy', () => {
     const { state } = makeWgpuScene3DState();
-    const scene = getWgpuScene3DRuntime(state);
     const stateRuntime = state[EntityRuntimeKey] as WgpuRenderStateRuntime;
-    expect(stateRuntime.sceneMeshMaterialRegistry).toBe(scene.materialRegistry);
+    const materials = stateRuntime.registries.meshMaterialRenderers;
+    const modifierSnippets = stateRuntime.registries.modifierSnippets;
+    const modifierSnippetRevision = stateRuntime.registries.modifierSnippetRevision;
+    const scene = getWgpuScene3DRuntime(state);
+    expect(stateRuntime.registries.meshMaterialRenderers).toBe(materials);
+    expect(stateRuntime.registries.modifierSnippets).toBe(modifierSnippets);
+    expect(stateRuntime.registries.modifierSnippetRevision).toBe(modifierSnippetRevision);
     expect(stateRuntime.sceneMeshUploadCache).toBe(scene.uploadCache);
   });
 });

package/src/wgpuScene3DTestHelper.test.ts

@@ -0,0 +1,84 @@
+import { getWgpuRenderStateRuntime } from '@flighthq/render-wgpu/contract';
+
+import { makeWgpuScene3DState } from './wgpuScene3DTestHelper';
+
+describe('makeWgpuScene3DState', () => {
+  it('records aligned writeBuffer data using typed-array element units', () => {
+    const { fake, state } = makeWgpuScene3DState();
+
+    state.device.queue.writeBuffer({} as GPUBuffer, 0, new Uint16Array([0, 1, 2]), 0, 2);
+
+    expect(fake.calls.filter((call) => call.name === 'writeBuffer')).toHaveLength(1);
+  });
+
+  it('rejects a writeBuffer ArrayBuffer byte size that is not a multiple of four', () => {
+    const { fake, state } = makeWgpuScene3DState();
+    const data = new Uint16Array([0, 1, 2]);
+
+    expect(() =>
+      state.device.queue.writeBuffer({} as GPUBuffer, 0, data.buffer, data.byteOffset, data.byteLength),
+    ).toThrow(expect.objectContaining({ name: 'OperationError' }));
+    expect(fake.calls.some((call) => call.name === 'writeBuffer')).toBe(false);
+  });
+
+  it('rejects a writeBuffer typed-array element count whose bytes are not a multiple of four', () => {
+    const { state } = makeWgpuScene3DState();
+
+    expect(() => state.device.queue.writeBuffer({} as GPUBuffer, 0, new Uint16Array([0, 1, 2]))).toThrow(
+      expect.objectContaining({ name: 'OperationError' }),
+    );
+  });
+
+  it('rejects a writeBuffer destination offset that is not aligned to four bytes', () => {
+    const { state } = makeWgpuScene3DState();
+
+    expect(() => state.device.queue.writeBuffer({} as GPUBuffer, 2, new Uint32Array([0]))).toThrow(
+      /destination offset must be aligned to 4 bytes/,
+    );
+  });
+
+  it('rejects misaligned or out-of-range index buffer bindings', () => {
+    const { fake, state } = makeWgpuScene3DState();
+    const buffer = state.device.createBuffer({ size: 8, usage: GPUBufferUsage.INDEX });
+    const pass = getWgpuRenderStateRuntime(state).renderPass!;
+
+    expect(() => pass.setIndexBuffer(buffer, 'uint16', -2)).toThrow(/offset and size must be non-negative/);
+    expect(() => pass.setIndexBuffer(buffer, 'uint32', 2)).toThrow(/offset must be aligned to 4 bytes/);
+    expect(() => pass.setIndexBuffer(buffer, 'uint16', 6, 4)).toThrow(/range exceeds the buffer size/);
+    expect(fake.calls.some((call) => call.name === 'setIndexBuffer')).toBe(false);
+
+    pass.setIndexBuffer(buffer, 'uint16', 2, 4);
+    expect(fake.calls.filter((call) => call.name === 'setIndexBuffer')).toHaveLength(1);
+  });
+
+  it('rejects misaligned or out-of-range vertex buffer bindings', () => {
+    const { fake, state } = makeWgpuScene3DState();
+    const buffer = state.device.createBuffer({ size: 8, usage: GPUBufferUsage.VERTEX });
+    const pass = getWgpuRenderStateRuntime(state).renderPass!;
+
+    expect(() => pass.setVertexBuffer(0, buffer, 0, -4)).toThrow(/offset and size must be non-negative/);
+    expect(() => pass.setVertexBuffer(0, buffer, 2)).toThrow(/offset must be aligned to 4 bytes/);
+    expect(() => pass.setVertexBuffer(0, buffer, 4, 8)).toThrow(/range exceeds the buffer size/);
+    expect(fake.calls.some((call) => call.name === 'setVertexBuffer')).toBe(false);
+
+    pass.setVertexBuffer(0, buffer, 4, 4);
+    expect(fake.calls.filter((call) => call.name === 'setVertexBuffer')).toHaveLength(1);
+  });
+
+  it('rejects writeTexture data smaller than an rgba8 copy requires', () => {
+    const { fake, state } = makeWgpuScene3DState();
+    const texture = state.device.createTexture({
+      size: [2, 2, 1],
+      format: 'rgba8unorm',
+      usage: GPUTextureUsage.COPY_DST,
+    });
+
+    expect(() =>
+      state.device.queue.writeTexture({ texture }, new Uint8Array(15), { bytesPerRow: 8, rowsPerImage: 2 }, [2, 2, 1]),
+    ).toThrow(expect.objectContaining({ name: 'OperationError' }));
+    expect(fake.calls.some((call) => call.name === 'writeTexture')).toBe(false);
+
+    state.device.queue.writeTexture({ texture }, new Uint8Array(16), { bytesPerRow: 8, rowsPerImage: 2 }, [2, 2, 1]);
+    expect(fake.calls.filter((call) => call.name === 'writeTexture')).toHaveLength(1);
+  });
+});

package/src/wgpuShadedModifierSnippet.test.ts

@@ -15,13 +15,25 @@ function makeSnippet(overrides?: Partial<WgpuModifierSnippet>): WgpuModifierSnip
 }
 
 describe('registerWgpuModifierSnippet', () => {
-  it('lazily allocates a state-scoped registry and is last-write-wins', () => {
-    const { state } = makeWgpuScene3DState();
-    expect(getWgpuScene3DRuntime(state).modifierSnippetRegistry).toBeNull();
-    registerWgpuModifierSnippet(state, makeSnippet());
+  it('replaces the table while an explicitly copied state retains its snapshot through lazy scene init', () => {
+    const { state: screen } = makeWgpuScene3DState();
+    const { state: derived } = makeWgpuScene3DState();
+    const initial = makeSnippet();
     const override = makeSnippet({ contribution: () => ({ source: '// override' }) });
-    registerWgpuModifierSnippet(state, override);
-    expect(resolveWgpuModifierSnippet(state, 'acme.Test')).toBe(override);
+    registerWgpuModifierSnippet(screen, initial);
+    const snapshot = getWgpuRenderStateRuntime(screen).registries.modifierSnippets;
+
+    copyWgpuRenderStateRegistrations(derived, screen);
+    getWgpuScene3DRuntime(derived);
+    registerWgpuModifierSnippet(screen, override);
+
+    expect(getWgpuRenderStateRuntime(derived).registries.modifierSnippets).toBe(snapshot);
+    expect(getWgpuRenderStateRuntime(derived).registries.modifierSnippetRevision).toBe(1);
+    expect(getWgpuRenderStateRuntime(screen).registries.modifierSnippets).not.toBe(snapshot);
+    expect(getWgpuRenderStateRuntime(screen).registries.modifierSnippetRevision).toBe(2);
+    expect(getRegistryTableEntry(snapshot, 'acme.Test')).toBe(initial);
+    expect(resolveWgpuModifierSnippet(derived, 'acme.Test')).toBe(initial);
+    expect(resolveWgpuModifierSnippet(screen, 'acme.Test')).toBe(override);
   });
 });
 
@@ -31,3 +43,5 @@ describe('resolveWgpuModifierSnippet', () => {
     expect(resolveWgpuModifierSnippet(state, 'acme.Missing')).toBeNull();
   });
 });
+import { getRegistryTableEntry } from '@flighthq/registry/contract';
+import { copyWgpuRenderStateRegistrations, getWgpuRenderStateRuntime } from '@flighthq/render-wgpu/contract';

package/src/wgpuShadedPrelude.test.ts

@@ -1,4 +1,4 @@
-import { registerWgpuImageTextureResolver } from '@flighthq/render-wgpu/contract';
+import { getWgpuRenderStateRuntime, registerWgpuImageTextureResolver } from '@flighthq/render-wgpu/contract';
 import {
   createAnimatedNormalModifier,
   createDissolveModifier,
@@ -173,7 +173,7 @@ describe('getWgpuShadedModuleSource', () => {
         createToonModifier({ steps: 3 }),
       ],
     });
-    const source = getWgpuShadedModuleSource(material, getWgpuScene3DRuntime(state).modifierSnippetRegistry!);
+    const source = getWgpuShadedModuleSource(material, getWgpuRenderStateRuntime(state).registries.modifierSnippets);
     expect(source).toContain('animatedNormal');
     expect(source).toContain('emissiveTerm');
     expect(source).toContain('rimFactor');
@@ -195,7 +195,7 @@ describe('getWgpuShadedModuleSource', () => {
         }),
       ],
     });
-    const source = getWgpuShadedModuleSource(material, getWgpuScene3DRuntime(state).modifierSnippetRegistry!);
+    const source = getWgpuShadedModuleSource(material, getWgpuRenderStateRuntime(state).registries.modifierSnippets);
     expect(source.indexOf('localPosition = vec4f(localPosition.xyz')).toBeLessThan(
       source.indexOf('let world = draw.world * localPosition'),
     );
@@ -212,7 +212,7 @@ describe('getWgpuShadedModuleSource', () => {
     const registered = { kind: 'acme.Glow', slot: ModifierSlot.Effect } as Modifier;
     const missing = { kind: 'acme.Missing', slot: ModifierSlot.Effect } as Modifier;
     const material = createShadedMaterial({ modifiers: [registered, missing] });
-    const registry = getWgpuScene3DRuntime(state).modifierSnippetRegistry!;
+    const registry = getWgpuRenderStateRuntime(state).registries.modifierSnippets;
     const source = getWgpuShadedModuleSource(material, registry);
     expect(source).toContain('radiance = radiance + vec3f(0.125)');
     expect(buildWgpuShadedCacheKey(material, registry)).toContain('acme.Missing');
@@ -249,7 +249,7 @@ describe('getWgpuShadedModuleSource', () => {
       });
       modifiers.push({ kind, slot: slots[i] });
     }
-    const registry = getWgpuScene3DRuntime(state).modifierSnippetRegistry!;
+    const registry = getWgpuRenderStateRuntime(state).registries.modifierSnippets;
     const source = getWgpuShadedModuleSource(createShadedMaterial({ modifiers }), registry);
     for (let i = 0; i < slots.length; i++) expect(source).toContain(`slot_marker_${i}`);
     expect(source).toMatch(/\/\/ slot_marker_1\s+diffuse = diffuse;\s+if \(ALPHA_MASK/);
@@ -277,7 +277,7 @@ describe('getWgpuShadedModuleSource', () => {
         { kind: 'acme.DeclarationB', slot: ModifierSlot.Effect },
       ],
     });
-    const source = getWgpuShadedModuleSource(material, getWgpuScene3DRuntime(state).modifierSnippetRegistry!);
+    const source = getWgpuShadedModuleSource(material, getWgpuRenderStateRuntime(state).registries.modifierSnippets);
     expect(source.match(/fn shadedValueNoise/g)).toHaveLength(1);
     expect(source).toContain('fn vendorA() {}\nfn vendorB() {}');
   });

package/src/wgpuShadowMap.test.ts

@@ -214,6 +214,36 @@ describe('drawWgpuScene3DShadowMap', () => {
     expect(fake.calls.filter((call) => call.name === 'beginRenderPass')).toHaveLength(passCount);
   });
 
+  // The sibling of the forward-pass defect: the shadow pass also bound an index buffer and issued
+  // drawIndexed unconditionally, so a non-indexed caster rendered (once the forward path was fixed)
+  // but cast no shadow. glShadowMap has always branched to drawArrays for this case.
+  it('issues a non-indexed draw for a caster without indices', () => {
+    const { fake, state } = makeWgpuScene3DState();
+    const scene = createNode3D(Node3DKind);
+    addNodeChild(
+      scene,
+      createMesh(
+        createMeshGeometry({
+          indices: null,
+          layout: {
+            attributes: [{ byteOffset: 0, format: 'float32x3', semantic: 'position' }],
+            stride: 12,
+          },
+          vertices: new Float32Array(9),
+        }),
+        [],
+      ),
+    );
+
+    drawWgpuScene3DShadowMap(state, scene, makeShadowCamera(), SHADOW_LIGHT);
+
+    const draw = fake.calls.find((c) => c.name === 'draw');
+    expect(draw).toBeDefined();
+    expect(draw!.args[0]).toBe(3);
+    expect(fake.calls.some((c) => c.name === 'drawIndexed')).toBe(false);
+    expect(fake.calls.some((c) => c.name === 'setIndexBuffer')).toBe(false);
+  });
+
   it('opens a depth-only pass and renders each caster mesh depth', () => {
     const { fake, state } = makeWgpuScene3DState();
     drawWgpuScene3DShadowMap(state, makeShadowScene3D(), makeShadowCamera(), SHADOW_LIGHT);