@forgeax/engine-runtime 0.1.19 → 0.1.20

package/src/__tests__/lights.unit.test.ts

@@ -1295,11 +1295,12 @@ function spawnValidatedLight(
       });
     });
 
-    describe('packSpotLight - std430 64B layout (feat-20260625 M2 w6)', () => {
+    describe('packSpotLight - std430 80B layout (feat-20260625 M2 w6)', () => {
       // feat-20260625-spot-light-shadow-mapping M2 w6 (D-4): SpotLight std430
-      // stride 48 -> 64 (12 -> 16 floats). Slots 0..11 keep the prior layout;
-      // slots 12..14 are vec4-alignment padding; slot 15 is shadowAtlasTile i32
-      // (sentinel -1 = unassigned/clipped) written via an Int32Array view.
+      // stride 64 -> 80 (16 -> 20 floats). Slots 0..11 keep the prior layout;
+      // slots 12..14 carry receiver controls, slot 15 is shadowAtlasTile i32
+      // (sentinel -1 = unassigned/clipped), slot 16 carries shadowIntensity,
+      // and slots 17..19 are the std430 tail pad.
       function makeSnap(shadowAtlasTile: number): SpotLightSnapshot {
         return {
           kind: 'spot',
@@ -1319,11 +1320,11 @@ function spawnValidatedLight(
         };
       }
 
-      it('emits 16 floats / 64 bytes; slots 0..11 unchanged from the 48B layout', () => {
+      it('emits 20 floats / 80 bytes; slots 0..11 unchanged from the 48B layout', () => {
         const out = packSpotLight(makeSnap(0));
         expect(out).toBeInstanceOf(Float32Array);
-        expect(out.length).toBe(16);
-        expect(out.byteLength).toBe(64);
+        expect(out.length).toBe(20);
+        expect(out.byteLength).toBe(80);
         // Slot 0..2: position vec3.
         expect(out[0]).toBeCloseTo(3.0, 6);
         expect(out[1]).toBeCloseTo(4.0, 6);
@@ -1342,10 +1343,16 @@ function spawnValidatedLight(
         expect(out[10]).toBeCloseTo(0.0, 6);
         // Slot 11: cosOuter (packed into direction.w lane).
         expect(out[11]).toBeCloseTo(0.866, 6);
-        // Slot 12..14: vec4-alignment padding, zero-initialised.
-        expect(out[12]).toBe(0);
-        expect(out[13]).toBe(0);
-        expect(out[14]).toBe(0);
+        // Slot 12..14: shared receiver controls.
+        expect(out[12]).toBeCloseTo(0.005, 6);
+        expect(out[13]).toBeCloseTo(0.05, 6);
+        expect(out[14]).toBe(3);
+        // Slot 16 carries the authored shadow visibility factor; the tail is
+        // explicit zero padding for the 80-byte std430 array stride.
+        expect(out[16]).toBe(1);
+        expect(out[17]).toBe(0);
+        expect(out[18]).toBe(0);
+        expect(out[19]).toBe(0);
       });
 
       it('slot 15 carries shadowAtlasTile as i32 (tile=0)', () => {
@@ -2308,13 +2315,20 @@ function spawnValidatedLight(
       });
     });
 
-    describe('sampler reuse (binding 4) — spot adds no new sampler (D-5)', () => {
-      it('keeps binding 4 as the single comparison sampler (shared by directional/point/spot)', () => {
+    describe('sampler reuse (binding 4) plus optional projector filtering sampler', () => {
+      it('keeps binding 4 as the comparison sampler and binding 12 as the projector filtering sampler', () => {
         const entries = buildPbrViewBglEntries({ storageBuffer: true });
         const samplers = entries.filter((e) => e.sampler !== undefined);
-        expect(samplers).toHaveLength(1);
-        expect(samplers[0]?.binding).toBe(4);
-        expect(samplers[0]?.sampler?.type).toBe('comparison');
+        expect(samplers).toHaveLength(2);
+        expect(samplers.find((entry) => entry.binding === 4)?.sampler?.type).toBe('comparison');
+        expect(samplers.find((entry) => entry.binding === 12)?.sampler?.type).toBe('filtering');
+      });
+
+      it('omits the projector filtering sampler on the 16-texture capability path', () => {
+        const entries = buildPbrViewBglEntries({ storageBuffer: true, projectorAvailable: false });
+        expect(entries.find((entry) => entry.binding === 11)).toBeUndefined();
+        expect(entries.find((entry) => entry.binding === 12)).toBeUndefined();
+        expect(entries.find((entry) => entry.binding === 4)?.sampler?.type).toBe('comparison');
       });
     });
 
@@ -2353,10 +2367,17 @@ function spawnValidatedLight(
     });
 
     describe('full binding roster reserves 9 for Points/Lines at 10', () => {
-      it('exposes bindings 0..8 plus binding 10, with binding 9 reserved', () => {
+      it('exposes bindings 0..8 plus optional projector 11+12 and binding 10', () => {
         const bindings = buildPbrViewBglEntries({ storageBuffer: true })
           .map((e) => e.binding)
           .sort((a, b) => a - b);
+        expect(bindings).toEqual([0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 11, 12]);
+      });
+
+      it('drops only optional projector bindings on the low sampled-texture path', () => {
+        const bindings = buildPbrViewBglEntries({ storageBuffer: true, projectorAvailable: false })
+          .map((e) => e.binding)
+          .sort((a, b) => a - b);
         expect(bindings).toEqual([0, 1, 2, 3, 4, 5, 6, 7, 8, 10]);
       });
     });

package/src/__tests__/loadbyguid-texture-intern.unit.test.ts

@@ -64,13 +64,12 @@ function registerQuadMesh(world: World): Handle<'MeshAsset', 'shared'> {
 function textureAsset(red = 255): TextureAsset {
   return {
     kind: 'texture',
-    width: 1,
-    height: 1,
+    shape: { viewDimension: '2d', extent: { width: 1, height: 1 } },
     format: 'rgba8unorm',
     data: new Uint8Array([red, 255, 255, 255]),
     colorSpace: 'linear',
-    mipmap: false,
-  } as unknown as TextureAsset;
+    mips: { kind: 'none' },
+  };
 }
 
 // Build a loadByGuid-shaped scene: the material's baseColorTexture paramValue is

package/src/__tests__/loader-name-survival.test.ts

@@ -77,11 +77,10 @@ function makeSharedPack(): unknown {
 
 const TEX_METADATA = {
   kind: 'texture',
-  width: 1,
-  height: 1,
+  shape: { viewDimension: '2d', extent: { width: 1, height: 1 } },
   format: 'rgba8unorm',
   colorSpace: 'srgb',
-  mipmap: false,
+  mips: { kind: 'none' },
 };
 
 // `includeNames=false` is the FALSIFY variant (entry.name stripped).

package/src/__tests__/material-texture-dimension-mismatch.unit.test.ts

@@ -0,0 +1,18 @@
+import { derive } from '@forgeax/engine-types';
+import { describe, expect, it } from 'vitest';
+
+describe('material texture dimension mismatch contract', () => {
+  it('carries the authored array view dimension into the material binding interface', () => {
+    const derived = derive([{ name: 'layers', type: 'texture2d_array' }]);
+
+    expect(derived.coordinateRecords[0]?.parameter).toBe('layers');
+    expect(derived.bglEntries[2]?.texture?.viewDimension).toBe('2d-array');
+  });
+
+  it('carries the authored volume view dimension without changing the submit boundary', () => {
+    const derived = derive([{ name: 'volume', type: 'texture3d' }]);
+
+    expect(derived.bglEntries[2]?.texture?.viewDimension).toBe('3d');
+    expect(derived.resourceBindings).toHaveLength(2);
+  });
+});

package/src/__tests__/material-texture-uv-scale.unit.test.ts

@@ -10,7 +10,10 @@ import {
 
 describe('material texture UV scale [w37]', () => {
   it('maps a non-aligned BC7 logical edge below padded physical storage', () => {
-    const scale = materialTextureUvScale({ width: 2085, height: 1573, format: 'bc7-rgba-unorm' });
+    const scale = materialTextureUvScale({
+      shape: { viewDimension: '2d', extent: { width: 2085, height: 1573 } },
+      format: 'bc7-rgba-unorm',
+    });
     expect(scale).toEqual([2085 / 2088, 1573 / 1576]);
     expect(scale[0]).toBeLessThan(1);
     expect(scale[1]).toBeLessThan(1);
@@ -18,7 +21,12 @@ describe('material texture UV scale [w37]', () => {
 
   it('uses identity scale for uncompressed and fallback texture bindings', () => {
     expect(materialTextureUvScale(undefined)).toEqual([1, 1]);
-    expect(materialTextureUvScale({ width: 17, height: 9, format: 'rgba8unorm' })).toEqual([1, 1]);
+    expect(
+      materialTextureUvScale({
+        shape: { viewDimension: '2d', extent: { width: 17, height: 9 } },
+        format: 'rgba8unorm',
+      }),
+    ).toEqual([1, 1]);
   });
 
   it('keeps compatibility param schemas compact when they have no textures', () => {

package/src/__tests__/mip-gate.unit.test.ts

@@ -27,19 +27,20 @@ import { deriveRenderDataTexture } from '../../../render/src/render-data';
 function tex(overrides: Partial<TextureAsset>): TextureAsset {
   return {
     kind: 'texture',
-    width: 8,
-    height: 8,
+    shape: { viewDimension: '2d', extent: { width: 8, height: 8 } },
     format: 'rgba8unorm',
     data: new Uint8Array(8 * 8 * 4),
     colorSpace: 'linear',
-    mipmap: false,
+    mips: { kind: 'none' },
     ...overrides,
   };
 }
 
 describe('deriveRenderDataTexture -- mip gate on compressed formats (w30, AC-09)', () => {
   it('compressed format + mipmap:true (runtime mip-gen requested) -> error', () => {
-    const res = deriveRenderDataTexture(tex({ format: 'bc7-rgba-unorm', mipmap: true }));
+    const res = deriveRenderDataTexture(
+      tex({ format: 'bc7-rgba-unorm', mips: { kind: 'generate' } }),
+    );
     expect(res.ok).toBe(false);
     if (!res.ok) {
       expect(res.error.code).toBe('mipgen-unsupported-compressed-format');
@@ -50,7 +51,9 @@ describe('deriveRenderDataTexture -- mip gate on compressed formats (w30, AC-09)
   });
 
   it('mip-gate error fires for an ETC2 compressed format too', () => {
-    const res = deriveRenderDataTexture(tex({ format: 'etc2-rgba8unorm', mipmap: true }));
+    const res = deriveRenderDataTexture(
+      tex({ format: 'etc2-rgba8unorm', mips: { kind: 'generate' } }),
+    );
     expect(res.ok).toBe(false);
     if (!res.ok) expect(res.error.code).toBe('mipgen-unsupported-compressed-format');
   });
@@ -59,20 +62,20 @@ describe('deriveRenderDataTexture -- mip gate on compressed formats (w30, AC-09)
     // The KTX2 loader baked the mip chain offline; this is the normal
     // compressed-upload path and must NOT trip the runtime-mip-gen gate.
     const res = deriveRenderDataTexture(
-      tex({ format: 'bc7-rgba-unorm', mipmap: true, mipLevelCount: 4 }),
+      tex({ format: 'bc7-rgba-unorm', mips: { kind: 'packed', levelCount: 4 } }),
     );
     expect(res.ok).toBe(true);
     if (res.ok) expect(res.value.mipLevelCount).toBe(4);
   });
 
   it('compressed format + mipmap:false -> ok (single level)', () => {
-    const res = deriveRenderDataTexture(tex({ format: 'bc7-rgba-unorm', mipmap: false }));
+    const res = deriveRenderDataTexture(tex({ format: 'bc7-rgba-unorm', mips: { kind: 'none' } }));
     expect(res.ok).toBe(true);
     if (res.ok) expect(res.value.mipLevelCount).toBe(1);
   });
 
   it('uncompressed format + mipmap:true -> ok (existing runtime mip-gen path unchanged)', () => {
-    const res = deriveRenderDataTexture(tex({ format: 'rgba8unorm', mipmap: true }));
+    const res = deriveRenderDataTexture(tex({ format: 'rgba8unorm', mips: { kind: 'generate' } }));
     expect(res.ok).toBe(true);
     if (res.ok) expect(res.value.mipLevelCount).toBeGreaterThan(1);
   });

package/src/__tests__/msaa-sprite-pixel-diff.dawn.test.ts

@@ -260,12 +260,11 @@ describe('feat-20260604-msaa M2 w9 [F-1]: LDR sprite + MSAA split sub-pass cover
     const synth = buildSyntheticRgba();
     const synthPod = {
       kind: 'texture' as const,
-      width: synth.width,
-      height: synth.height,
+      shape: { viewDimension: '2d' as const, extent: { width: synth.width, height: synth.height } },
       format: 'rgba8unorm-srgb' as const,
       data: synth.data,
       colorSpace: 'srgb' as const,
-      mipmap: false,
+      mips: { kind: 'none' as const },
     };
     const TEX_GUID = '00000000-0000-7000-8000-0000000005a1';
     const SAMPLER_GUID = '00000000-0000-7000-8000-0000000005a2';

package/src/__tests__/new-kind-refs-contract.test.ts

@@ -62,12 +62,11 @@ describe('AC-07 — a new reference appears in the load graph via envelope.refs'
     // new reference field whose GUID it dropped into refs[]".
     reg.catalog(parseGuid(EXTRA_REF_GUID), {
       kind: 'texture',
-      width: 1,
-      height: 1,
+      shape: { viewDimension: '2d', extent: { width: 1, height: 1 } },
       format: 'rgba8unorm',
       data: new Uint8Array(4),
       colorSpace: 'srgb',
-      mipmap: false,
+      mips: { kind: 'none' },
     });
 
     const packIndex = [

package/src/__tests__/pbr-pipeline.unit.test.ts

@@ -44,7 +44,7 @@ function makeSpec(): PipelineSpec {
 
 describe('buildBindGroupLayoutDescriptor — pbr-pipeline 6 sites byte-equiv', () => {
   describe('pbr-view', () => {
-    it('storageBuffer=true: 10 entries with read-only-storage on bindings 1+2', () => {
+    it('storageBuffer=true: 12 entries with read-only-storage on bindings 1+2 and projector bindings 11+12', () => {
       const spec = makeSpec();
       const out = buildBindGroupLayoutDescriptor(spec, {
         kind: 'pbr-view',
@@ -60,11 +60,15 @@ describe('buildBindGroupLayoutDescriptor — pbr-pipeline 6 sites byte-equiv', (
       // Points/Lines viewport UBO occupies binding 10, while w25 (scope-amend
       // webkit-fallback) folded the former binding 9 spotLightViewProj matrices
       // UBO into the View UBO (`view.spotLightViewProj`), so the BGL stays at 9
-      // entries (bindings 0..8 plus binding 10) — keeping the WebGL2 fallback fragment uniform-
-      // buffer count <= 11 (GLES 3.0).
-      expect(out.entries.length).toBe(10);
+      // entries (bindings 0..8 plus optional projector 11+12 and binding 10)
+      // — keeping the WebGL2 fallback fragment uniform-buffer count <= 11
+      // (GLES 3.0), while the projector remains available on the default
+      // WebGPU path.
+      expect(out.entries.length).toBe(12);
       expect(out.entries.find((entry) => entry.binding === 9)).toBeUndefined();
       expect(out.entries.find((entry) => entry.binding === 10)?.buffer?.type).toBe('uniform');
+      expect(out.entries.find((entry) => entry.binding === 11)?.texture?.viewDimension).toBe('2d');
+      expect(out.entries.find((entry) => entry.binding === 12)?.sampler?.type).toBe('filtering');
     });
 
     it('storageBuffer=false: bindings 1+2 fall back to uniform', () => {
@@ -79,6 +83,21 @@ describe('buildBindGroupLayoutDescriptor — pbr-pipeline 6 sites byte-equiv', (
       };
       expect(out).toEqual(expected);
     });
+
+    it('projectorAvailable=false: omits optional projector bindings for the 16-texture limit', () => {
+      const spec = makeSpec();
+      const out = buildBindGroupLayoutDescriptor(spec, {
+        kind: 'pbr-view',
+        caps: { storageBuffer: true, projectorAvailable: false },
+      });
+      expect(out).toEqual({
+        label: 'pbr-view-bgl',
+        entries: buildPbrViewBglEntries({ storageBuffer: true, projectorAvailable: false }),
+      });
+      expect(out.entries.find((entry) => entry.binding === 11)).toBeUndefined();
+      expect(out.entries.find((entry) => entry.binding === 12)).toBeUndefined();
+      expect(out.entries.find((entry) => entry.binding === 10)?.buffer?.type).toBe('uniform');
+    });
   });
 
   describe('pbr-material-merged', () => {

package/src/__tests__/pipeline.unit.test.ts

@@ -4466,12 +4466,11 @@ vi.mock('@forgeax/engine-rhi-wgpu', () => {
   function texturePod(mipmap: boolean, format: GPUTextureFormat = 'rgba8unorm-srgb'): TextureAsset {
     return {
       kind: 'texture',
-      width: 2,
-      height: 2,
+      shape: { viewDimension: '2d', extent: { width: 2, height: 2 } },
       format,
       data: new Uint8Array(2 * 2 * 4).fill(188),
       colorSpace: format.endsWith('-srgb') ? 'srgb' : 'linear',
-      mipmap,
+      mips: { kind: mipmap ? 'generate' : 'none' },
     };
   }
 
@@ -4549,12 +4548,11 @@ vi.mock('@forgeax/engine-rhi-wgpu', () => {
   ): TextureAsset {
     return {
       kind: 'texture',
-      width,
-      height,
+      shape: { viewDimension: '2d', extent: { width, height } },
       format,
       data: new Uint8Array(width * height * 4).fill(170),
       colorSpace: format.endsWith('-srgb') ? 'srgb' : 'linear',
-      mipmap,
+      mips: { kind: mipmap ? 'generate' : 'none' },
     };
   }
 
@@ -4566,12 +4564,11 @@ vi.mock('@forgeax/engine-rhi-wgpu', () => {
   ): TextureAsset {
     return {
       kind: 'texture',
-      width,
-      height,
+      shape: { viewDimension: '2d', extent: { width, height } },
       format,
       data: new Uint8Array(width * height * 8),
       colorSpace,
-      mipmap: false,
+      mips: { kind: 'none' },
     };
   }
 
@@ -4658,33 +4655,35 @@ vi.mock('@forgeax/engine-rhi-wgpu', () => {
       const source = texturePod(false, 'rgba16float');
       const res = deriveRenderDataTexture({
         ...source,
-        data: new Uint8Array(source.width * source.height * 8),
+        data: new Uint8Array(source.shape.extent.width * source.shape.extent.height * 8),
       });
       expect(res.ok).toBe(true);
       if (!res.ok) return;
-      expect(res.value.bytesPerRow).toBe(source.width * 8);
+      expect(res.value.bytesPerRow).toBe(source.shape.extent.width * 8);
     });
 
     it('derives row pitch from format when an rgba8 decoder retains trailing bytes', () => {
       const source = texturePod(false, 'rgba8unorm');
       const res = deriveRenderDataTexture({
         ...source,
-        data: new Uint8Array(source.width * source.height * 4 + source.width),
+        data: new Uint8Array(
+          source.shape.extent.width * source.shape.extent.height * 4 + source.shape.extent.width,
+        ),
       });
       expect(res.ok).toBe(true);
       if (!res.ok) return;
-      expect(res.value.bytesPerRow).toBe(source.width * 4);
+      expect(res.value.bytesPerRow).toBe(source.shape.extent.width * 4);
     });
 
     it('derives the row pitch from an rgba32float source payload', () => {
       const source = texturePod(false, 'rgba32float');
       const res = deriveRenderDataTexture({
         ...source,
-        data: new Uint8Array(source.width * source.height * 16),
+        data: new Uint8Array(source.shape.extent.width * source.shape.extent.height * 16),
       });
       expect(res.ok).toBe(true);
       if (!res.ok) return;
-      expect(res.value.bytesPerRow).toBe(source.width * 16);
+      expect(res.value.bytesPerRow).toBe(source.shape.extent.width * 16);
     });
 
     it('rejects an uncompressed payload shorter than its base mip', () => {
@@ -5091,14 +5090,14 @@ vi.mock('@forgeax/engine-rhi-wgpu', () => {
       expect(LIGHT_ARRAY_MAX_SLOTS).toBe(4);
     });
 
-    it('POINT_LIGHT_STD430_BYTES and SPOT_LIGHT_STD430_BYTES still match URP specs', async () => {
+    it('POINT_LIGHT_STD430_BYTES and SPOT_LIGHT_STD430_BYTES match the current URP payloads', async () => {
       const { POINT_LIGHT_STD430_BYTES, SPOT_LIGHT_STD430_BYTES } = await import(
         '../../../render/src/light-buffer-layout'
       );
       expect(POINT_LIGHT_STD430_BYTES).toBe(32);
-      // feat-20260625-spot-light-shadow-mapping M2 / w8 (D-4): SpotLight grew
-      // 48 -> 64 for the shadowAtlasTile i32 clip-signal lane (4th vec4 column).
-      expect(SPOT_LIGHT_STD430_BYTES).toBe(64);
+      // SpotLight's projector receiver controls and shadow intensity occupy
+      // the appended fifth vec4 column; point-light layout remains unchanged.
+      expect(SPOT_LIGHT_STD430_BYTES).toBe(80);
     });
   });
 }

package/src/__tests__/point-light-shadow.unit.test.ts

@@ -577,7 +577,7 @@ function spawnValidatedPointShadow(
         expect(withShadow[15]).toBe(25);
       });
 
-      it('AC-13: spot light packLightSlot leaves pad lanes at sentinel (-1, 0, 0)', () => {
+      it('AC-13: spot light packLightSlot writes its shadow defaults into the tail lanes', () => {
         const spotSnap = {
           kind: 'spot' as const,
           entity: 0,
@@ -595,8 +595,9 @@ function spawnValidatedPointShadow(
           farPlane: 50,
           shadowAtlasTile: -1,
         };
-        // Even when shadow info is passed, spot lights ignore the lanes
-        // (only point lights with shadow ride the pad lanes).
+        // SpotLight uses the former pad lanes for the shadow intensity and
+        // PCF-kernel defaults. The atlas tile remains the -1 sentinel while
+        // projector/shadow consumers read the appended payload fields.
         const packed = packLightSlot(spotSnap, {
           shadowAtlasLayer: 0,
           near: 0.1,
@@ -604,8 +605,8 @@ function spawnValidatedPointShadow(
         });
         const i32 = new Int32Array(packed.buffer);
         expect(i32[13]).toBe(-1); // sentinel; spot lights stay shadowless
-        expect(packed[14]).toBe(0);
-        expect(packed[15]).toBe(0);
+        expect(packed[14]).toBeCloseTo(1, 5);
+        expect(packed[15]).toBeCloseTo(3, 5);
       });
 
       it('AC-05: LIGHTSLOT_LAYOUT byteSize unchanged at 64 (no-regression for standard)', () => {

package/src/__tests__/render-error-exhaustive.test-d.ts

@@ -114,6 +114,16 @@ function exhaustiveSwitchOnRenderCode(code: RenderErrorCode): string {
       return code;
     case 'points-lines-prepare-failed':
       return code;
+    case 'projector-binding-failed':
+      return code;
+    case 'volume-owner-conflict':
+      return code;
+    case 'volume-density-shape-mismatch':
+      return code;
+    case 'volume-invalid-bounds':
+      return code;
+    case 'volume-invalid-parameters':
+      return code;
     default: {
       const exhaustive: never = code;
       return exhaustive;
@@ -333,6 +343,25 @@ function narrowRenderError(err: RenderError): void {
       void err.detail.capability;
       void err.detail.stage;
       break;
+    case 'projector-binding-failed':
+      void err.detail.guid;
+      void err.detail.status;
+      break;
+    case 'volume-owner-conflict':
+      void err.detail.ownerCount;
+      break;
+    case 'volume-density-shape-mismatch':
+      void err.detail.guid;
+      void err.detail.viewDimension;
+      break;
+    case 'volume-invalid-bounds':
+      void err.detail.min;
+      void err.detail.max;
+      break;
+    case 'volume-invalid-parameters':
+      void err.detail.field;
+      void err.detail.value;
+      break;
     default: {
       const exhaustive: never = err;
       void exhaustive;

package/src/__tests__/render-system-extract.test.ts

@@ -1193,12 +1193,11 @@ import { makeMockShaderRegistry } from './helpers/mock-shader-registry';
       'TextureAsset',
       {
         kind: 'texture',
-        width: 1,
-        height: 1,
+        shape: { viewDimension: '2d', extent: { width: 1, height: 1 } },
         format: 'rgba8unorm',
         data: new Uint8Array([255, 255, 255, 255]),
         colorSpace: 'linear',
-        mipmap: false,
+        mips: { kind: 'none' },
       },
     );
   }
@@ -1211,12 +1210,11 @@ import { makeMockShaderRegistry } from './helpers/mock-shader-registry';
       const textureGuid = AssetGuid.random();
       assets.catalog(textureGuid, {
         kind: 'texture',
-        width: 1,
-        height: 1,
+        shape: { viewDimension: '2d', extent: { width: 1, height: 1 } },
         format: 'rgba8unorm',
         data: new Uint8Array([255, 255, 255, 255]),
         colorSpace: 'linear',
-        mipmap: false,
+        mips: { kind: 'none' },
       } satisfies TextureAsset);
       const matHandle = world.allocSharedRef<'MaterialAsset', MaterialAsset>('MaterialAsset', {
         kind: 'material',

package/src/__tests__/render-system-record-multi-material-textureview.test.ts

@@ -323,8 +323,7 @@ function makeChequerTexture(): TextureAsset {
   // textureView sentinel.
   return {
     kind: 'texture',
-    width: 2,
-    height: 2,
+    shape: { viewDimension: '2d', extent: { width: 2, height: 2 } },
     // colorSpace=linear+rgba8unorm to satisfy the runtime's
     // srgb-format consistency validator (layer 7c-1: srgb requires
     // rgba8unorm-srgb). The test only cares that each texture's
@@ -332,7 +331,7 @@ function makeChequerTexture(): TextureAsset {
     format: 'rgba8unorm',
     data: new Uint8Array(2 * 2 * 4),
     colorSpace: 'linear',
-    mipmap: false,
+    mips: { kind: 'none' },
   } as unknown as TextureAsset;
 }
 
@@ -586,12 +585,11 @@ async function spawnPbrMissingTextureScene(): Promise<unknown> {
   // existing debug-pink fallback.
   const unresidentTexture = {
     kind: 'texture',
-    width: 2,
-    height: 2,
+    shape: { viewDimension: '2d', extent: { width: 2, height: 2 } },
     format: 'rgba8unorm-srgb',
     data: new Uint8Array(2 * 2 * 4),
     colorSpace: 'srgb',
-    mipmap: false,
+    mips: { kind: 'none' },
   } as unknown as TextureAsset;
   const badTexHandle = world.allocSharedRef('TextureAsset', unresidentTexture) as unknown as Handle<
     'TextureAsset',

package/src/__tests__/render-system-record-per-submesh-transparency.test.ts

@@ -256,12 +256,11 @@ function cameraTransform() {
 function makeTex(): TextureAsset {
   return {
     kind: 'texture',
-    width: 2,
-    height: 2,
+    shape: { viewDimension: '2d', extent: { width: 2, height: 2 } },
     format: 'rgba8unorm',
     data: new Uint8Array(2 * 2 * 4),
     colorSpace: 'linear',
-    mipmap: false,
+    mips: { kind: 'none' },
   } as unknown as TextureAsset;
 }