@forgeax/engine-runtime 0.1.4 → 0.1.6

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

@@ -58,46 +58,30 @@ import { readFileSync } from 'node:fs';
 import { resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { AnimationPlayer } from '@forgeax/engine-animation';
+import type { AssetRuntimeErrorCode } from '@forgeax/engine-assets-runtime';
+import { AssetRegistry } from '@forgeax/engine-assets-runtime';
 import type { EntityHandle, World as WorldType } from '@forgeax/engine-ecs';
 import { ENTITY_NULL_RAW, World } from '@forgeax/engine-ecs';
-import { componentDefinition, componentSchema } from '@forgeax/engine-ecs/internal';
-import { createPrimitiveMesh } from '@forgeax/engine-geometry';
+import { SpriteAnimationInvalidError } from '@forgeax/engine-ecs/projection';
 import { mat4, vec3 } from '@forgeax/engine-math';
-import type { Renderer as RendererType } from '@forgeax/engine-render';
-import {
-  SPRITE_PLAYBACK_MODE_CLAMP,
-  SPRITE_PLAYBACK_MODE_LOOP,
-  SpriteAnimation,
-  SpriteRegionOverride,
-} from '@forgeax/engine-render/authoring';
-import type { RenderAssetPort, RenderErrorCode } from '@forgeax/engine-render/internal';
+import type { RenderErrorCode, Renderer as RendererType } from '@forgeax/engine-render';
 import {
   ANTIALIAS_FXAA,
   ANTIALIAS_NONE,
-  antialiasFromF32,
   BLOOM_DISABLED,
   BLOOM_ENABLED,
-  bloomEnabledFromF32,
   CAMERA_PROJECTION_ORTHOGRAPHIC,
   CAMERA_PROJECTION_PERSPECTIVE,
   Camera,
-  cameraProjectionFromF32,
   MeshFilter,
   MeshRenderer,
-  SkinPaletteOverflowError,
   SkyboxBackground,
   Skylight,
-  selectSwapChainFormat,
-  VertexStorageBufferUnavailableError,
-} from '@forgeax/engine-render/internal';
+} from '@forgeax/engine-render';
 import type { BindGroupEntry, Buffer, Sampler, Texture, TextureView } from '@forgeax/engine-rhi';
 import { ok as rhiOk } from '@forgeax/engine-rhi';
 import { ChildOf, Name, propagateTransforms, Transform } from '@forgeax/engine-scene';
-import {
-  DEFAULT_STANDARD_PBR_PARAM_SCHEMA,
-  DEFAULT_UNLIT_PARAM_SCHEMA,
-  TONEMAP_LUMINANCE_EPSILON,
-} from '@forgeax/engine-shader';
+import { TONEMAP_LUMINANCE_EPSILON } from '@forgeax/engine-shader';
 import type { SkinErrorCode } from '@forgeax/engine-skinning';
 import {
   Skin,
@@ -107,8 +91,6 @@ import {
   SkinJointPathUnresolvedError,
 } from '@forgeax/engine-skinning';
 import type {
-  AssetErrorCode,
-  EquirectAsset,
   Handle,
   MaterialAsset,
   MeshAsset,
@@ -117,20 +99,95 @@ import type {
 } from '@forgeax/engine-types';
 import { toShared } from '@forgeax/engine-types';
 import { afterEach, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest';
+import { worldInternal } from '../../../ecs/src/world-internal';
+import {
+  SPRITE_PLAYBACK_MODE_CLAMP,
+  SPRITE_PLAYBACK_MODE_LOOP,
+  SpriteAnimation,
+  SpriteRegionOverride,
+} from '../../../render/src/components';
+import {
+  type CameraProjection,
+  cameraProjectionFromF32,
+} from '../../../render/src/components/camera';
+import {
+  assembleMaterialWithSkylightEntries,
+  createSkylightFallback,
+  mergeSkylightIntoMaterialBgl,
+} from '../../../render/src/ibl/skylight-bind-group';
+import { buildPbrPipelineLayouts, buildUnlitMaterialBgl } from '../../../render/src/pbr-pipeline';
+import { INSTANCE_STORAGE_STRIDE_FLOATS } from '../../../render/src/record/mesh-ssbo';
+import { selectSwapChainFormat } from '../../../render/src/render-system';
+import { createSkinPaletteAllocator } from '../../../render/src/systems/skin-palette-allocator';
+import type { TransparentEntry } from '../../../render/src/systems/transparent-sort-config';
+import { drawWithOwners } from './renderer-test-utils';
+
+function componentFieldType(component: { fields: Record<string, { type: string }> }, name: string) {
+  return component.fields[name]?.type;
+}
 
-function canonicalTestMeshAttributes(vertexCount: number) {
-  return {
-    position: new Float32Array(vertexCount * 3),
-    normal: new Float32Array(vertexCount * 3),
-    uv: new Float32Array(vertexCount * 2),
-    tangent: new Float32Array(vertexCount * 4),
-  };
+function componentFieldDefault(
+  component: { fields: Record<string, { default?: unknown }> },
+  name: string,
+) {
+  return component.fields[name]?.default;
+}
+
+function componentSchemaTypes(component: { fields: Record<string, { type: string }> }) {
+  return Object.fromEntries(
+    Object.entries(component.fields).map(([name, field]) => [name, field.type]),
+  );
+}
+
+afterEach(() => vi.restoreAllMocks());
+
+type RendererErrorObservation = {
+  readonly code: string;
+  readonly detail?: unknown;
+  readonly hint?: string;
+};
+
+function unwrapRendererError(value: unknown): RendererErrorObservation {
+  let current = value as RendererErrorObservation;
+  while (
+    current.detail !== undefined &&
+    typeof current.detail === 'object' &&
+    current.detail !== null
+  ) {
+    const cause = (current.detail as { cause?: unknown }).cause;
+    if (
+      cause === undefined ||
+      typeof cause !== 'object' ||
+      cause === null ||
+      typeof (cause as { code?: unknown }).code !== 'string'
+    ) {
+      break;
+    }
+    current = cause as RendererErrorObservation;
+  }
+  return current;
+}
+
+function subscribeRendererErrors(
+  renderer: RendererType,
+  listener: (error: RendererErrorObservation) => void,
+): () => void {
+  return renderer.subscribe((event) => {
+    if (event.kind === 'error') listener(unwrapRendererError(event.error));
+  });
+}
+
+function drawPublished(renderer: RendererType, world: WorldType) {
+  const attached = renderer.attach(world);
+  if (!attached.ok) throw attached.error;
+  world.update().unwrap();
+  return drawWithOwners(renderer, world);
 }
 
 // feat-20260704-runtime-tier1-decomposition M2 / w12: reconstitute the
 // eliminated top-level RuntimeErrorCode aggregate union (D-3) as a test-local
 // alias so the exhaustive-switch bodies below stay byte-identical (AC-09).
-type RuntimeLayerErrorCode = RenderErrorCode | AssetErrorCode | SkinErrorCode;
+type RuntimeLayerErrorCode = RenderErrorCode | AssetRuntimeErrorCode | SkinErrorCode;
 
 import {
   AnimationTargetId,
@@ -138,113 +195,42 @@ import {
   advanceAnimationPlayer as canonicalAdvanceAnimationPlayer,
 } from '@forgeax/engine-animation';
 import { deriveAnimationTargetId } from '@forgeax/engine-animation/target-id';
-import type {
-  CameraSnapshot,
-  ExtractedLights,
-  InstanceBufferCacheEntry,
-} from '@forgeax/engine-render/internal';
-// (moved from import body)
+import { DeviceScope } from '../../../render/src/device/device-scope';
+import { GpuBuffer } from '../../../render/src/gpu-resource';
+import { getOrCreateIblCache, hasIblCache } from '../../../render/src/ibl/IblPipelineCache';
 import {
-  assembleMaterialWithSkylightEntries,
-  buildPbrPipelineLayouts,
-  buildUnlitMaterialBgl,
-  createSkinPaletteAllocator,
-  createSkylightFallback,
+  disposeInstanceBuffers,
+  type InstanceBufferCacheEntry,
+} from '../../../render/src/instance-buffer-cache';
+import { standardPipeline as urpPipeline } from '../../../render/src/pipeline/standard-pipeline';
+import { ZERO_CAMERA_CLEAR_FALLBACK } from '../../../render/src/record/frame-snapshot';
+import {
+  warnMultiLightDirectional,
+  warnMultiLightPoint,
+  warnMultiLightSpot,
+} from '../../../render/src/record/helpers';
+import type { CameraSnapshot } from '../../../render/src/render-contract';
+import {
+  type ExtractedLights,
   extractFrame,
   extractFrames,
-  GpuResourceStore,
-  getOrCreateIblCache,
-  getTransparentSortConfig,
-  hasIblCache,
-  mergeSkylightIntoMaterialBgl,
   prepareExtractContext,
+} from '../../../render/src/render-system-extract';
+import {
+  getTransparentSortConfig,
   setTransparentSortConfig,
   TRANSPARENT_SORT_CONFIG_KEY,
   TRANSPARENT_SORT_MODE_LAYER_Y,
   TRANSPARENT_SORT_MODE_LAYER_YZ,
   TRANSPARENT_SORT_MODE_LAYER_Z,
-  urpPipeline,
-  warnMultiLightDirectional,
-  warnMultiLightPoint,
-  warnMultiLightSpot,
-  ZERO_CAMERA_CLEAR_FALLBACK,
-} from '@forgeax/engine-render/internal';
-import { SpriteAnimationInvalidError } from '../errors/sprite-animation';
+} from '../../../render/src/systems/transparent-sort-config';
 import { spriteAnimationTickSystem } from '../systems/sprite-animation-tick';
 import { REC709_LUMA_WEIGHTS, tonemapReinhardLuminance } from '../systems/tonemap';
 import { transparentSortEntries } from '../systems/transparent-sort';
 import { makeMockShaderRegistry } from './helpers/mock-shader-registry';
 
-function canonicalMaterialParamSchema(identifier: string): string {
-  if (identifier === 'forgeax::default-standard-pbr') {
-    return JSON.stringify(DEFAULT_STANDARD_PBR_PARAM_SCHEMA);
-  }
-  if (identifier === 'forgeax::default-unlit') {
-    return JSON.stringify(DEFAULT_UNLIT_PARAM_SCHEMA);
-  }
-  return '[]';
-}
-
-const EMPTY_EXTRACTED_ENVIRONMENT = {
-  kind: 'none',
-  worldId: 0,
-  skylightCount: 0,
-  skyboxCount: 0,
-} as const;
-const EMPTY_POST_PROCESS_PARAMS = new Map<string, Uint8Array>();
-
-function makeEnvironmentGenerationState() {
-  return {
-    deviceGeneration: 0,
-    retired: [],
-    status: 'idle' as const,
-    generation: 0,
-    desired: undefined,
-    candidate: undefined,
-    active: undefined,
-    lastKnownGood: undefined,
-    failureStage: undefined,
-    bytes: 0,
-    peakBytes: 0,
-    rebuildCost: 0,
-    publishCount: 0,
-  };
-}
-
 {
   // --- from antialias-from-f32.test.ts ---
-
-  describe('antialiasFromF32', () => {
-    it('0 maps to none', () => {
-      expect(antialiasFromF32(0)).toBe('none');
-    });
-
-    it('1 maps to fxaa', () => {
-      expect(antialiasFromF32(1)).toBe('fxaa');
-    });
-
-    it('2 maps to msaa', () => {
-      expect(antialiasFromF32(2)).toBe('msaa');
-    });
-
-    it('invalid value 99 throws RangeError with text containing the max valid value 2', () => {
-      expect(() => antialiasFromF32(99)).toThrow(RangeError);
-      expect(() => antialiasFromF32(99)).toThrow(/2/);
-    });
-
-    it('negative value throws RangeError with text containing 2', () => {
-      expect(() => antialiasFromF32(-1)).toThrow(RangeError);
-    });
-
-    // Regression: verify constants match the mapping
-    it('ANTIALIAS_NONE matches mapping', () => {
-      expect(antialiasFromF32(ANTIALIAS_NONE)).toBe('none');
-    });
-
-    it('ANTIALIAS_FXAA matches mapping', () => {
-      expect(antialiasFromF32(ANTIALIAS_FXAA)).toBe('fxaa');
-    });
-  });
 }
 
 {
@@ -332,11 +318,11 @@ function makeEnvironmentGenerationState() {
 
   describe('Camera antialias schema', () => {
     it('Camera schema includes antialias: f32 field', () => {
-      expect(componentSchema(Camera).antialias).toBe('f32');
+      expect(componentFieldType(Camera, 'antialias')).toBe('f32');
     });
 
     it('Camera defaults antialias to 0 (ANTIALIAS_NONE)', () => {
-      expect(componentDefinition(Camera).defaults?.antialias).toBe(0);
+      expect(componentFieldDefault(Camera, 'antialias')).toBe(0);
     });
   });
 
@@ -349,46 +335,6 @@ function makeEnvironmentGenerationState() {
       expect(ANTIALIAS_FXAA).toBe(1);
     });
   });
-
-  describe('antialiasFromF32 mapping', () => {
-    it('0 -> none', () => {
-      expect(antialiasFromF32(0)).toBe('none');
-    });
-
-    it('1 -> fxaa', () => {
-      expect(antialiasFromF32(1)).toBe('fxaa');
-    });
-
-    it('99 -> throws RangeError (fail-fast P3)', () => {
-      expect(() => antialiasFromF32(99)).toThrow(RangeError);
-    });
-
-    it('-1 -> throws RangeError (fail-fast P3)', () => {
-      expect(() => antialiasFromF32(-1)).toThrow(RangeError);
-    });
-
-    it('undefined-like NaN -> throws RangeError (fail-fast P3)', () => {
-      expect(() => antialiasFromF32(Number.NaN)).toThrow(RangeError);
-    });
-  });
-
-  describe('Antialias type union', () => {
-    it('antialiasFromF32 return type is assignable to Antialias', () => {
-      // Compile-time check: the return type annotation guarantees this.
-      const result: Antialias = antialiasFromF32(0);
-      expect(result).toBe('none');
-    });
-
-    it('antialiasFromF32(1) is assignable to Antialias', () => {
-      const result: Antialias = antialiasFromF32(1);
-      expect(result).toBe('fxaa');
-    });
-
-    it('antialiasFromF32(2) maps to msaa', () => {
-      const result: Antialias = antialiasFromF32(2);
-      expect(result).toBe('msaa');
-    });
-  });
 }
 
 {
@@ -396,35 +342,35 @@ function makeEnvironmentGenerationState() {
 
   describe('Camera bloom schema', () => {
     it('Camera schema includes bloom: f32 field', () => {
-      expect(componentSchema(Camera).bloom).toBe('f32');
+      expect(componentFieldType(Camera, 'bloom')).toBe('f32');
     });
 
     it('Camera schema includes bloomThreshold: f32 field', () => {
-      expect(componentSchema(Camera).bloomThreshold).toBe('f32');
+      expect(componentFieldType(Camera, 'bloomThreshold')).toBe('f32');
     });
 
     it('Camera schema includes bloomIntensity: f32 field', () => {
-      expect(componentSchema(Camera).bloomIntensity).toBe('f32');
+      expect(componentFieldType(Camera, 'bloomIntensity')).toBe('f32');
     });
 
     it('Camera schema includes bloomBlurRadius: f32 field', () => {
-      expect(componentSchema(Camera).bloomBlurRadius).toBe('f32');
+      expect(componentFieldType(Camera, 'bloomBlurRadius')).toBe('f32');
     });
 
     it('Camera defaults bloom to 0 (BLOOM_DISABLED)', () => {
-      expect(componentDefinition(Camera).defaults?.bloom).toBe(0);
+      expect(componentFieldDefault(Camera, 'bloom')).toBe(0);
     });
 
     it('Camera defaults bloomThreshold to 1.0', () => {
-      expect(componentDefinition(Camera).defaults?.bloomThreshold).toBe(1.0);
+      expect(componentFieldDefault(Camera, 'bloomThreshold')).toBe(1.0);
     });
 
     it('Camera defaults bloomIntensity to 1.0', () => {
-      expect(componentDefinition(Camera).defaults?.bloomIntensity).toBe(1.0);
+      expect(componentFieldDefault(Camera, 'bloomIntensity')).toBe(1.0);
     });
 
     it('Camera defaults bloomBlurRadius to 4.0', () => {
-      expect(componentDefinition(Camera).defaults?.bloomBlurRadius).toBe(4.0);
+      expect(componentFieldDefault(Camera, 'bloomBlurRadius')).toBe(4.0);
     });
   });
 
@@ -437,40 +383,6 @@ function makeEnvironmentGenerationState() {
       expect(BLOOM_ENABLED).toBe(1);
     });
   });
-
-  describe('bloomEnabledFromF32 mapping', () => {
-    it('0 -> off', () => {
-      expect(bloomEnabledFromF32(0)).toBe('off');
-    });
-
-    it('1 -> on', () => {
-      expect(bloomEnabledFromF32(1)).toBe('on');
-    });
-
-    it('99 -> throws RangeError (fail-fast P3)', () => {
-      expect(() => bloomEnabledFromF32(99)).toThrow(RangeError);
-    });
-
-    it('-1 -> throws RangeError (fail-fast P3)', () => {
-      expect(() => bloomEnabledFromF32(-1)).toThrow(RangeError);
-    });
-
-    it('undefined-like NaN -> throws RangeError (fail-fast P3)', () => {
-      expect(() => bloomEnabledFromF32(Number.NaN)).toThrow(RangeError);
-    });
-  });
-
-  describe('BloomEnabled type union', () => {
-    it('bloomEnabledFromF32 return type is assignable to BloomEnabled', () => {
-      const result: 'on' | 'off' = bloomEnabledFromF32(0);
-      expect(result).toBe('off');
-    });
-
-    it('bloomEnabledFromF32(1) is assignable to BloomEnabled', () => {
-      const result: 'on' | 'off' = bloomEnabledFromF32(1);
-      expect(result).toBe('on');
-    });
-  });
 }
 
 {
@@ -478,18 +390,18 @@ function makeEnvironmentGenerationState() {
 
   describe('Camera clear-color schema (feat-20260709 M3: array<f32,4>)', () => {
     it('Camera schema includes clearColor: array<f32,4> field', () => {
-      expect(componentSchema(Camera).clearColor).toBe('array<f32, 4>');
+      expect(componentFieldType(Camera, 'clearColor')).toBe('array<f32, 4>');
     });
 
     it('per-axis clear scalars are gone (collapsed into clearColor)', () => {
-      expect('clearR' in componentSchema(Camera)).toBe(false);
-      expect('clearG' in componentSchema(Camera)).toBe(false);
-      expect('clearB' in componentSchema(Camera)).toBe(false);
-      expect('clearA' in componentSchema(Camera)).toBe(false);
+      expect('clearR' in Camera.fields).toBe(false);
+      expect('clearG' in Camera.fields).toBe(false);
+      expect('clearB' in Camera.fields).toBe(false);
+      expect('clearA' in Camera.fields).toBe(false);
     });
 
     it('Camera defaults clearColor to transparent black [0,0,0,0]', () => {
-      expect(Array.from(componentDefinition(Camera).defaults?.clearColor as Float32Array)).toEqual([
+      expect(Array.from(componentFieldDefault(Camera, 'clearColor') as Float32Array)).toEqual([
         0, 0, 0, 0,
       ]);
     });
@@ -534,34 +446,34 @@ function makeEnvironmentGenerationState() {
     ];
   }
 
-  describe('Camera schema (20 fields including temporal historyVersion)', () => {
-    it('componentSchema(Camera) has 20 fields with historyVersion as the temporal reset authority', () => {
-      expect(Object.keys(componentSchema(Camera)).length).toBe(20);
-      expect(componentSchema(Camera).fov).toBe('f32');
-      expect(componentSchema(Camera).aspect).toBe('f32');
-      expect(componentSchema(Camera).near).toBe('f32');
-      expect(componentSchema(Camera).far).toBe('f32');
-      expect(componentSchema(Camera).projection).toBe('f32');
-      expect(componentSchema(Camera).left).toBe('f32');
-      expect(componentSchema(Camera).right).toBe('f32');
-      expect(componentSchema(Camera).bottom).toBe('f32');
-      expect(componentSchema(Camera).top).toBe('f32');
-      expect(componentSchema(Camera).historyVersion).toBe('u32');
+  describe('Camera schema (19 fields: 17 f32 + clearColor array + autoAspect bool after w9 + tonemap-mvp + fxaa + bloom + clearColor + aspect-sync extensions)', () => {
+    it('Camera.schema has 19 fields (17 f32 + clearColor array + autoAspect bool: perspective quartet + projection + ortho quartet + tonemap trio + antialias + bloom quartet + clearColor + autoAspect)', () => {
+      expect(Object.keys(Camera.fields).length).toBe(20);
+      expect(componentFieldType(Camera, 'fov')).toBe('f32');
+      expect(componentFieldType(Camera, 'aspect')).toBe('f32');
+      expect(componentFieldType(Camera, 'near')).toBe('f32');
+      expect(componentFieldType(Camera, 'far')).toBe('f32');
+      expect(componentFieldType(Camera, 'projection')).toBe('f32');
+      expect(componentFieldType(Camera, 'left')).toBe('f32');
+      expect(componentFieldType(Camera, 'right')).toBe('f32');
+      expect(componentFieldType(Camera, 'bottom')).toBe('f32');
+      expect(componentFieldType(Camera, 'top')).toBe('f32');
       // feat-20260519-tonemap-reinhard-mvp / M1 / T-M1.2 (AC-01 + D-1).
-      expect(componentSchema(Camera).tonemap).toBe('f32');
-      expect(componentSchema(Camera).exposure).toBe('f32');
-      expect(componentSchema(Camera).whitePoint).toBe('f32');
-      expect(componentSchema(Camera).antialias).toBe('f32');
+      expect(componentFieldType(Camera, 'tonemap')).toBe('f32');
+      expect(componentFieldType(Camera, 'exposure')).toBe('f32');
+      expect(componentFieldType(Camera, 'whitePoint')).toBe('f32');
+      expect(componentFieldType(Camera, 'antialias')).toBe('f32');
+      expect(componentFieldType(Camera, 'historyVersion')).toBe('u32');
       // feat-20260531-bloom-first-declarative-render-graph-pass / w2.
-      expect(componentSchema(Camera).bloom).toBe('f32');
-      expect(componentSchema(Camera).bloomThreshold).toBe('f32');
-      expect(componentSchema(Camera).bloomIntensity).toBe('f32');
-      expect(componentSchema(Camera).bloomBlurRadius).toBe('f32');
+      expect(componentFieldType(Camera, 'bloom')).toBe('f32');
+      expect(componentFieldType(Camera, 'bloomThreshold')).toBe('f32');
+      expect(componentFieldType(Camera, 'bloomIntensity')).toBe('f32');
+      expect(componentFieldType(Camera, 'bloomBlurRadius')).toBe('f32');
       // feat-20260709 M3 / D-3: clear-color collapsed into one array<f32,4>.
-      expect(componentSchema(Camera).clearColor).toBe('array<f32, 4>');
+      expect(componentFieldType(Camera, 'clearColor')).toBe('array<f32, 4>');
       // feat-20260617-host-engine-contract-and-video-cutscene / M3: aspect-sync
       // opt-out flag (bool column tier).
-      expect(componentSchema(Camera).autoAspect).toBe('bool');
+      expect(componentFieldType(Camera, 'autoAspect')).toBe('bool');
     });
   });
 
@@ -772,15 +684,7 @@ function makeEnvironmentGenerationState() {
       unlitPipeline: { __label: 'unlit' },
       standardPipeline: { __label: 'standard' },
       unlitPipelineHdr: null,
-      standardPipelineHdr: null,
       shadowFallbackTextureView: { __label: 'shadow-fallback-view' },
-      shadowProbePipeline: null,
-      shadowProbeBindGroupLayout: null,
-      shadowProbeLsmUbo: null,
-      shadowProbeInputBuf: null,
-      shadowProbeOutputTex: null,
-      shadowProbeOutputView: null,
-      shadowProbeStagingBuf: null,
       skylightFallback: null,
       pointLightsBuffer: { __label: 'point-lights-buf' },
       spotLightsBuffer: { __label: 'spot-lights-buf' },
@@ -847,7 +751,7 @@ function makeEnvironmentGenerationState() {
       const { internals } = makeRecorderInternals(log);
       const ps = makePipelineState();
       (internals as { getPipelineState: () => unknown }).getPipelineState = () => ps;
-      const { recordFrame } = await import('@forgeax/engine-render/internal');
+      const { recordFrame } = await import('../../../render/src/record/frame');
       recordFrame(
         internals as never,
         new World() as never,
@@ -857,7 +761,6 @@ function makeEnvironmentGenerationState() {
         [],
         {
           frameNumber: 0,
-          environmentGeneration: makeEnvironmentGenerationState(),
           compiledFrameGraph: null,
           compiledFrameGraphTopologyKey: null,
           retiredCompiledFrameGraphs: new Set(),
@@ -885,8 +788,10 @@ function makeEnvironmentGenerationState() {
         },
         { unlit: 0 },
         { createBindGroup: 0, keys: [] },
-        EMPTY_EXTRACTED_ENVIRONMENT,
-        EMPTY_POST_PROCESS_PARAMS,
+        undefined,
+        0,
+        undefined,
+        0,
       );
 
       // No FXAA intermediate texture should be allocated when antialias='none'.
@@ -901,7 +806,7 @@ function makeEnvironmentGenerationState() {
       const { internals } = makeRecorderInternals(log);
       const ps = makePipelineState();
       (internals as { getPipelineState: () => unknown }).getPipelineState = () => ps;
-      const { recordFrame } = await import('@forgeax/engine-render/internal');
+      const { recordFrame } = await import('../../../render/src/record/frame');
       recordFrame(
         internals as never,
         new World() as never,
@@ -911,7 +816,6 @@ function makeEnvironmentGenerationState() {
         [],
         {
           frameNumber: 0,
-          environmentGeneration: makeEnvironmentGenerationState(),
           compiledFrameGraph: null,
           compiledFrameGraphTopologyKey: null,
           retiredCompiledFrameGraphs: new Set(),
@@ -939,8 +843,10 @@ function makeEnvironmentGenerationState() {
         },
         { unlit: 0 },
         { createBindGroup: 0, keys: [] },
-        EMPTY_EXTRACTED_ENVIRONMENT,
-        EMPTY_POST_PROCESS_PARAMS,
+        undefined,
+        0,
+        undefined,
+        0,
       );
 
       // TODO (feat-20260608-ci-time-cut): row 2/3/4 placeholders pruned -- they
@@ -1200,29 +1106,29 @@ function makeEnvironmentGenerationState() {
   // --- from ibl-pipeline-cache.test.ts ---
 
   describe('t11 - IblPipelineCache counter invariant + deferred-replay', () => {
-    // (a) IblPipelineCache initializes per-device WeakMap
-    it('IblPipelineCache maintains per-device WeakMap via getOrCreateIblCache', () => {
-      const mockDevice1 = {};
-      const mockDevice2 = {};
+    // (a) IblPipelineCache initializes one cache per DeviceScope generation
+    it('IblPipelineCache maintains per-scope ownership via getOrCreateIblCache', () => {
+      const scope1 = DeviceScope.create(1, 'systems-test-1');
+      const scope2 = DeviceScope.create(2, 'systems-test-2');
 
-      const cache1 = getOrCreateIblCache(mockDevice1);
-      const cache2 = getOrCreateIblCache(mockDevice2);
+      const cache1 = getOrCreateIblCache(scope1);
+      const cache2 = getOrCreateIblCache(scope2);
 
       // Different devices get different cache instances.
       expect(cache1).not.toBe(cache2);
 
       // Same device returns same instance.
-      expect(getOrCreateIblCache(mockDevice1)).toBe(cache1);
+      expect(getOrCreateIblCache(scope1)).toBe(cache1);
 
       // hasIblCache confirms registration.
-      expect(hasIblCache(mockDevice1)).toBe(true);
-      expect(hasIblCache(mockDevice2)).toBe(true);
-      expect(hasIblCache({})).toBe(false);
+      expect(hasIblCache(scope1)).toBe(true);
+      expect(hasIblCache(scope2)).toBe(true);
+      expect(hasIblCache(DeviceScope.create(3, 'systems-test-3'))).toBe(false);
     });
 
     // (d) counters initialized at 0
     it('counters are initialized at 0 before any pass execution', () => {
-      const cache = getOrCreateIblCache({});
+      const cache = getOrCreateIblCache(DeviceScope.create(4, 'systems-test-4'));
       expect(cache.irradianceBakeCount).toBe(0);
       expect(cache.prefilterBakeCount).toBe(0);
       expect(cache.brdfLutBakeCount).toBe(0);
@@ -1233,7 +1139,7 @@ function makeEnvironmentGenerationState() {
     // The actual GPU pass execution that sets these counters is wired in
     // uploadCubemapFromEquirect (t20 in asset-registry.ts).
     it('iblPrepass counters can be incremented post-execution', () => {
-      const cache = getOrCreateIblCache({});
+      const cache = getOrCreateIblCache(DeviceScope.create(5, 'systems-test-5'));
       cache.irradianceBakeCount += 1;
       cache.prefilterBakeCount += 1;
       cache.brdfLutBakeCount += 1;
@@ -1243,10 +1149,10 @@ function makeEnvironmentGenerationState() {
     });
 
     it('iblPrepass counters stay independent across devices', () => {
-      const deviceA = {};
-      const deviceB = {};
-      const cacheA = getOrCreateIblCache(deviceA);
-      const cacheB = getOrCreateIblCache(deviceB);
+      const scopeA = DeviceScope.create(6, 'systems-test-6');
+      const scopeB = DeviceScope.create(7, 'systems-test-7');
+      const cacheA = getOrCreateIblCache(scopeA);
+      const cacheB = getOrCreateIblCache(scopeB);
 
       cacheA.irradianceBakeCount += 1;
       cacheB.prefilterBakeCount += 1;
@@ -1266,7 +1172,7 @@ function makeEnvironmentGenerationState() {
 {
   // --- from ibl-runtime-probe.test.ts ---
 
-  const mockCaps = {
+  const _mockCaps = {
     backendKind: 'webgpu' as const,
     compute: true,
     timestampQuery: false,
@@ -1287,8 +1193,8 @@ function makeEnvironmentGenerationState() {
     float32Filterable: false,
   };
 
-  // feat-20260601-gpu-resource-store-extraction M1: uploadCubemapFromEquirect
-  // moved to GpuResourceStore (D-3 register-relay injected at configureGpuDevice,
+  // feat-20260601-device/gpu-residency-extraction M1: uploadCubemapFromEquirect
+  // moved to GpuResidencyCache (D-3 register-relay injected at configureGpuDevice,
   // source POD passed to the call; store holds no registry reference).
 
   interface MockEncoder {
@@ -1320,7 +1226,7 @@ function makeEnvironmentGenerationState() {
   }
 
   // biome-ignore lint/suspicious/noExplicitAny: opaque mock GPU device surface
-  function makeMockDevice(probe: MockSubmitProbe): any {
+  function _makeMockDevice(probe: MockSubmitProbe): any {
     const mockShader = { __mock: 'shader' };
     const mockPipeline = { __mock: 'pipeline' };
     const mockBgl = { __mock: 'bgl' };
@@ -1372,7 +1278,7 @@ function makeEnvironmentGenerationState() {
     };
   }
 
-  function makeEquirect(): {
+  function _makeEquirect(): {
     kind: 'equirect';
     width: number;
     height: number;
@@ -1389,128 +1295,6 @@ function makeEnvironmentGenerationState() {
       colorSpace: 'linear',
     };
   }
-
-  describe('t50 (M3.5) -- AC-20 runtime probe via mock device', () => {
-    it('(a) uploadCubemapFromEquirect calls queue.submit >= 1', async () => {
-      const probe: MockSubmitProbe = {
-        submitCalls: 0,
-        encoders: [],
-        shouldThrowOnSubmit: false,
-      };
-      const device = makeMockDevice(probe);
-
-      const equirect = makeEquirect();
-      const store = new GpuResourceStore();
-      const world = new World();
-      const equirectHandle = world.allocSharedRef('EquirectAsset', equirect);
-
-      store.configureGpuDevice(
-        device,
-        async (_d, desc) =>
-          // biome-ignore lint/suspicious/noExplicitAny: mock shader module
-          rhiOk({ __mock: 'shader', label: desc.label ?? '' }) as any,
-        (w: World, pod: EquirectAsset) => rhiOk(w.allocSharedRef('EquirectAsset', pod)),
-        mockCaps,
-      );
-
-      // biome-ignore lint/suspicious/noExplicitAny: package-internal method reached via store cast
-      const result = await (store as any)._uploadCubemapFromEquirect(
-        world,
-        equirectHandle,
-        equirect,
-      );
-      expect(result.ok).toBe(true);
-      expect(probe.submitCalls).toBeGreaterThanOrEqual(1);
-    });
-
-    it('(b) encoder contains 4 beginRenderPass calls (equirect / irradiance / prefilter / brdf-lut)', async () => {
-      const probe: MockSubmitProbe = {
-        submitCalls: 0,
-        encoders: [],
-        shouldThrowOnSubmit: false,
-      };
-      const device = makeMockDevice(probe);
-
-      const equirect = makeEquirect();
-      const store = new GpuResourceStore();
-      const world = new World();
-      const equirectHandle = world.allocSharedRef('EquirectAsset', equirect);
-
-      store.configureGpuDevice(
-        device,
-        async (_d, desc) =>
-          // biome-ignore lint/suspicious/noExplicitAny: mock shader module
-          rhiOk({ __mock: 'shader', label: desc.label ?? '' }) as any,
-        (w: World, pod: EquirectAsset) => rhiOk(w.allocSharedRef('EquirectAsset', pod)),
-        mockCaps,
-      );
-
-      // biome-ignore lint/suspicious/noExplicitAny: package-internal method reached via store cast
-      await (store as any)._uploadCubemapFromEquirect(world, equirectHandle, equirect);
-
-      const totalBeginPass = probe.encoders.reduce((s, e) => s + e.beginRenderPassCount, 0);
-      // 4 distinct pass families; each cube-face family unfolds to 6 sub-passes
-      // (24 for equirect+irradiance), prefilter to 30 (5 mip x 6 face),
-      // brdf-lut 1. Total ~ 55. We assert minimum 4 distinct pass labels.
-      const labels = new Set(
-        probe.encoders
-          .flatMap((e) => e.passes.map((p) => p.label ?? ''))
-          .map((l) => {
-            // strip face / mip suffix for family grouping
-            return l.replace(/-face\d+/, '').replace(/-mip\d+/, '');
-          }),
-      );
-      expect(totalBeginPass).toBeGreaterThanOrEqual(4);
-      expect(labels.has('ibl-equirect-to-cube')).toBe(true);
-      expect(labels.has('ibl-irradiance')).toBe(true);
-      expect(labels.has('ibl-prefilter')).toBe(true);
-      expect(labels.has('ibl-brdf-lut')).toBe(true);
-    });
-
-    it('(c) AC-20 critical: counters stay at 0 when queue.submit throws', async () => {
-      const probe: MockSubmitProbe = {
-        submitCalls: 0,
-        encoders: [],
-        shouldThrowOnSubmit: true,
-      };
-      const device = makeMockDevice(probe);
-
-      const equirect = makeEquirect();
-      const store = new GpuResourceStore();
-      const world = new World();
-      const equirectHandle = world.allocSharedRef('EquirectAsset', equirect);
-
-      store.configureGpuDevice(
-        device,
-        async (_d, desc) =>
-          // biome-ignore lint/suspicious/noExplicitAny: mock shader module
-          rhiOk({ __mock: 'shader', label: desc.label ?? '' }) as any,
-        (w: World, pod: EquirectAsset) => rhiOk(w.allocSharedRef('EquirectAsset', pod)),
-        mockCaps,
-      );
-
-      // biome-ignore lint/suspicious/noExplicitAny: package-internal method reached via store cast
-      const result = await (store as any)._uploadCubemapFromEquirect(
-        world,
-        equirectHandle,
-        equirect,
-      );
-
-      // Whether result.ok is true or false depends on impl error propagation;
-      // the critical assertion is the counter invariant -- counters must NOT
-      // increment when submit fails. counter += 1 placed BEFORE submit is the
-      // round-1 anti-pattern; this assertion fails in that case.
-      const cache = getOrCreateIblCache(device);
-      expect(cache.irradianceBakeCount).toBe(0);
-      expect(cache.prefilterBakeCount).toBe(0);
-      expect(cache.brdfLutBakeCount).toBe(0);
-
-      // If the impl chose to surface submit failure structurally, result.ok
-      // is false. We allow either outcome here -- the load-bearing fact is
-      // counter == 0.
-      void result;
-    });
-  });
 }
 
 {
@@ -1806,6 +1590,7 @@ function makeEnvironmentGenerationState() {
       limits: {},
       queue: {
         submit: () => undefined,
+        onSubmittedWorkDone: () => Promise.resolve(undefined),
         writeBuffer: () => undefined,
         writeTexture: () => undefined,
       },
@@ -1859,7 +1644,7 @@ function makeEnvironmentGenerationState() {
       identifier,
       sourcePath: `${identifier}.wgsl`,
       composedWgsl,
-      paramSchema: canonicalMaterialParamSchema(identifier),
+      paramSchema: '[]',
       variants: [],
     });
     const manifest = {
@@ -1886,15 +1671,10 @@ function makeEnvironmentGenerationState() {
     return `data:application/json,${encodeURIComponent(JSON.stringify(manifest))}`;
   }
 
-  interface RendererLike {
-    ready: Promise<void>;
-    draw: (worlds: unknown, opts: { cameraOwner: number; resourceOwner: number }) => void;
-    onError: (cb: (err: { code: string }) => void) => () => void;
-    assets: { register: (asset: unknown) => { ok: boolean; value: unknown } };
-  }
+  type RendererLike = RendererType;
 
   async function importEngine(): Promise<{
-    createRenderer: (canvas: unknown, opts?: unknown, bundler?: unknown) => Promise<RendererLike>;
+    createRenderer: (...args: unknown[]) => Promise<{ unwrap(): RendererLike }>;
   }> {
     return (await import(ENGINE)) as never;
   }
@@ -1913,7 +1693,7 @@ function makeEnvironmentGenerationState() {
     DirectionalLight: unknown;
   }> {
     return {
-      ...(await import('@forgeax/engine-render/internal')),
+      ...(await import('@forgeax/engine-render')),
       ...(await import('@forgeax/engine-scene')),
     } as never;
   }
@@ -1939,13 +1719,14 @@ function makeEnvironmentGenerationState() {
       kind: 'mesh',
       vertices: new Float32Array(3 * 12),
       indices: new Uint16Array([0, 1, 2]),
-      attributes: canonicalTestMeshAttributes(3),
+      attributes: { position: new Float32Array([0, 0, 0, 1, 0, 0, 0, 1, 0]) },
+      aabb: new Float32Array([-1, -1, -1, 1, 1, 1]),
       materialSlots: [{ slotName: 'Default' }],
       submeshes: [
         {
           indexOffset: 0,
           indexCount: 3,
-          vertexCount: 0,
+          vertexCount: 3,
           materialSlot: 0,
           topology: 'triangle-list',
         },
@@ -1958,13 +1739,14 @@ function makeEnvironmentGenerationState() {
       kind: 'mesh',
       vertices: new Float32Array(2 * 12),
       indices: new Uint16Array([0, 1]),
-      attributes: canonicalTestMeshAttributes(2),
+      attributes: { position: new Float32Array([0, 0, 0, 1, 0, 0]) },
+      aabb: new Float32Array([-1, -1, -1, 1, 1, 1]),
       materialSlots: [{ slotName: 'Default' }],
       submeshes: [
         {
           indexOffset: 0,
           indexCount: 2,
-          vertexCount: 0,
+          vertexCount: 2,
           materialSlot: 0,
           topology: 'line-list',
         },
@@ -1979,12 +1761,9 @@ function makeEnvironmentGenerationState() {
     const { device } = makeMockGPUDevice(shadow, main);
     vi.stubGlobal('navigator', { ...baseNavigator, gpu: makeMockGPU(device) });
     const { createRenderer } = await importEngine();
-    const renderer = await createRenderer(
-      makeMockCanvas(),
-      {},
-      { shaderManifestUrl: buildManifestDataUrl() },
-    );
-    await renderer.ready;
+    const renderer = (
+      await createRenderer(makeMockCanvas(), {}, { shaderManifestUrl: buildManifestDataUrl() })
+    ).unwrap();
     return { renderer };
   }
 
@@ -2002,26 +1781,11 @@ function makeEnvironmentGenerationState() {
       const main = makePassSpies();
       const { renderer } = await setupRenderer(shadow, main);
       const errors: string[] = [];
-      renderer.onError((e) => errors.push(e.code));
+      subscribeRendererErrors(renderer, (e) => errors.push(e.code));
 
       const { World } = await importEcs();
       const C = await importComponents();
       const world = new World();
-      for (const component of [
-        C.Camera,
-        C.DirectionalLight,
-        C.Transform,
-        C.MeshRenderer,
-        C.MeshFilter,
-      ]) {
-        (
-          world as unknown as {
-            components: { register: (component: unknown) => { unwrap: () => unknown } };
-          }
-        ).components
-          .register(component)
-          .unwrap();
-      }
 
       const triHandle = world.allocSharedRef('MeshAsset', indexedTriangleMesh()) as Handle<
         'MeshAsset',
@@ -2052,7 +1816,7 @@ function makeEnvironmentGenerationState() {
       world.spawn(
         {
           component: C.DirectionalLight,
-          data: { direction: [-0.5, -1, -0.3], mapSize: 512, cascadeCount: 1 },
+          data: { direction: [0, -1, 0], mapSize: 512, cascadeCount: 1 },
         },
         { component: C.Transform, data: cameraTransform() },
       );
@@ -2067,27 +1831,22 @@ function makeEnvironmentGenerationState() {
         { component: C.Transform, data: originTransform() },
       );
 
-      // Two frames: the first frame records the lazy shadow pass once the
-      // resources are available; the second frame reuses the directional cache.
-      // feat-20260609 M4 / T-010: yield so async shader-module creation
-      // (getMaterialShaderPipeline's 1-frame-warmup path) resolves before
-      // frame 2; the shadow PSO is now obtained via lazy cache lookup instead
-      // of the hardcoded perPassResources.shadowCasterPipeline field.
-      if (!(renderer as unknown as RendererType).attachWorld(world as WorldType).ok) {
-        throw new Error('World attachment failed');
-      }
-      (world as WorldType).update().unwrap();
-      renderer.draw([world], { cameraOwner: 0, resourceOwner: 0 });
+      // The first frame exercises the real shadow pass. A second frame proves
+      // the persistent directional-shadow cache can reuse that result without
+      // re-recording the depth draws. Yield so any async shader-module
+      // creation settles before the cached frame.
+      drawPublished(renderer, world as WorldType);
+      const firstShadowDrawCalls =
+        shadow.drawIndexed.mock.calls.length + shadow.draw.mock.calls.length;
       await new Promise((r) => setTimeout(r, 0));
-      if (!(renderer as unknown as RendererType).attachWorld(world as WorldType).ok) {
-        throw new Error('World attachment failed');
-      }
-      (world as WorldType).update().unwrap();
-      renderer.draw([world], { cameraOwner: 0, resourceOwner: 0 });
+      shadow.drawIndexed.mockClear();
+      shadow.draw.mockClear();
+      drawPublished(renderer, world as WorldType);
 
       // Shadow pass drew exactly once (the triangle mesh), never the line mesh.
       const shadowDrawCalls = shadow.drawIndexed.mock.calls.length + shadow.draw.mock.calls.length;
-      expect(shadowDrawCalls).toBe(1);
+      expect(firstShadowDrawCalls).toBe(1);
+      expect(shadowDrawCalls).toBe(0);
       expect(errors).toEqual([]);
     });
   });
@@ -2154,8 +1913,6 @@ function makeEnvironmentGenerationState() {
             return 'mesh-ssbo-capacity';
           case 'mesh-ssbo-ceiling-reached':
             return 'mesh-ssbo-ceiling';
-          case 'hdrp-caps-insufficient':
-            return 'hdrp-caps';
           case 'hdrp-light-budget-exceeded':
             return 'hdrp-budget';
           case 'hdrp-index-list-overflow':
@@ -2203,22 +1960,6 @@ function makeEnvironmentGenerationState() {
       expect(e.detail).toEqual({ entity: 99 });
     });
 
-    it('VertexStorageBufferUnavailableError has .code .expected .hint', () => {
-      const e = new VertexStorageBufferUnavailableError();
-      expect(e.code).toBe('vertex-storage-buffer-unavailable');
-      expect(e.expected).toContain('maxStorageBuffersPerShaderStage');
-      expect(e.hint.length).toBeGreaterThan(0);
-    });
-
-    it('SkinPaletteOverflowError has .code .expected .hint .detail', () => {
-      const e = new SkinPaletteOverflowError(10000, 128 * 1024 * 1024);
-      expect(e.code).toBe('skin-palette-overflow');
-      expect(e.expected).toContain('maxStorageBufferBindingSize');
-      expect(e.hint.length).toBeGreaterThan(0);
-      expect(e.detail.requestedBytes).toBe(10000);
-      expect(e.detail.limit).toBe(128 * 1024 * 1024);
-    });
-
     it('all 6 skin-animation error codes are in the RuntimeErrorCode union (type-level)', () => {
       const codes: RuntimeLayerErrorCode[] = [
         'skin-joint-count-exceeded',
@@ -2244,20 +1985,20 @@ function makeEnvironmentGenerationState() {
 
   describe('equirect-projection-failed error class shape', () => {
     it('has .code === equirect-projection-failed', async () => {
-      const { EquirectProjectionFailedError } = await import('@forgeax/engine-render/internal');
+      const { EquirectProjectionFailedError } = await import('../../../render/src/errors/render');
       const err = new EquirectProjectionFailedError(42);
       expect(err.code).toBe('equirect-projection-failed');
     });
 
     it('exposes .detail.handle === the constructor argument', async () => {
-      const { EquirectProjectionFailedError } = await import('@forgeax/engine-render/internal');
+      const { EquirectProjectionFailedError } = await import('../../../render/src/errors/render');
       const err = new EquirectProjectionFailedError(42);
       expect(err.detail).toBeDefined();
       expect(err.detail.handle).toBe(42);
     });
 
     it('exposes non-empty .hint with actionable guidance', async () => {
-      const { EquirectProjectionFailedError } = await import('@forgeax/engine-render/internal');
+      const { EquirectProjectionFailedError } = await import('../../../render/src/errors/render');
       const err = new EquirectProjectionFailedError(42);
       expect(err.hint).toBeDefined();
       expect(typeof err.hint).toBe('string');
@@ -2265,7 +2006,7 @@ function makeEnvironmentGenerationState() {
     });
 
     it('exposes .expected describing expected state', async () => {
-      const { EquirectProjectionFailedError } = await import('@forgeax/engine-render/internal');
+      const { EquirectProjectionFailedError } = await import('../../../render/src/errors/render');
       const err = new EquirectProjectionFailedError(42);
       expect(err.expected).toBeDefined();
       expect(typeof err.expected).toBe('string');
@@ -2273,7 +2014,7 @@ function makeEnvironmentGenerationState() {
     });
 
     it('extends Error so it can be thrown and caught', async () => {
-      const { EquirectProjectionFailedError } = await import('@forgeax/engine-render/internal');
+      const { EquirectProjectionFailedError } = await import('../../../render/src/errors/render');
       const err = new EquirectProjectionFailedError(42);
       expect(err).toBeInstanceOf(Error);
       expect(err.name).toBe('EquirectProjectionFailedError');
@@ -2285,7 +2026,7 @@ function makeEnvironmentGenerationState() {
       // The actual TS union membership is verified by typecheck: if
       // 'equirect-projection-failed' is not in RuntimeErrorCode, no expression
       // can assign err.code to a RuntimeErrorCode-typed variable.
-      const { EquirectProjectionFailedError } = await import('@forgeax/engine-render/internal');
+      const { EquirectProjectionFailedError } = await import('../../../render/src/errors/render');
       const err = new EquirectProjectionFailedError(42);
       expect(err.code).toBe('equirect-projection-failed');
     });
@@ -2297,7 +2038,7 @@ function makeEnvironmentGenerationState() {
       // the equirect handle, it binds the white-cube fallback and fires this
       // structured error ONCE (it does not retry; R-2/AC-09). The record-stage
       // integration is covered by the M3 lazy-projection tests + smoke gate.
-      const { EquirectProjectionFailedError } = await import('@forgeax/engine-render/internal');
+      const { EquirectProjectionFailedError } = await import('../../../render/src/errors/render');
       const err = new EquirectProjectionFailedError(42);
       expect(err.code).toBe('equirect-projection-failed');
       expect(err.detail.handle).toBe(42);
@@ -2339,9 +2080,7 @@ function makeEnvironmentGenerationState() {
     });
 
     it('imports View from forgeax_view::common', () => {
-      expect(source).toEqual(
-        expect.stringContaining('#import forgeax_view::common::{View, FogViewParams, FogRay}'),
-      );
+      expect(source).toEqual(expect.stringContaining('#import forgeax_view::common::{View'));
     });
 
     it('imports fullscreen_triangle from forgeax_view::common', () => {
@@ -2899,11 +2638,11 @@ function makeEnvironmentGenerationState() {
     });
   });
 
-  // ─── (e) unlit material BG follows the reflected schema ─────────────────────
+  // ─── (e) unlit material BG stays 7 entries ──────────────────────────────────
 
   describe('t58 (M4 round-4) -- unlit material BG isolation', () => {
     it('(e) buildUnlitMaterialBindGroupEntries returns 7 entries (no Skylight contamination)', async () => {
-      const mod = await import('@forgeax/engine-render/internal');
+      const mod = await import('../../../render/src/pbr-pipeline');
       const buildFn = (mod as { buildUnlitMaterialBindGroupEntries?: unknown })
         .buildUnlitMaterialBindGroupEntries;
       expect(typeof buildFn).toBe('function');
@@ -3015,24 +2754,24 @@ function makeEnvironmentGenerationState() {
       expect(layout?.label).toBe('pbr-pl');
     });
 
-    it('(b) PBR material BGL entry count === 20 (user region 0..12 + Skylight 13..19)', () => {
+    it('(b) PBR material BGL entry count === 24 (user region 0..12 + Skylight 13..19 + lightmap 20..23)', () => {
       const device = makeMockDevice();
       // biome-ignore lint/suspicious/noExplicitAny: structural mock
       buildPbrPipelineLayouts(device as any, STORAGE_CAPS);
       const materialBgl = device.capturedBgls.find((b) => b.label === 'pbr-material-skylight-bgl');
       expect(materialBgl).toBeDefined();
-      expect(materialBgl?.entries).toHaveLength(20);
+      expect(materialBgl?.entries).toHaveLength(24);
     });
 
-    it('(c) binding indices 0..19 in order; 13..19 resource types in D-5 round-4 order', () => {
+    it('(c) binding indices 0..23 in order; 13..19 resource types in D-5 round-4 order; 20..23 lightmap', () => {
       const device = makeMockDevice();
       // biome-ignore lint/suspicious/noExplicitAny: structural mock
       buildPbrPipelineLayouts(device as any, STORAGE_CAPS);
       const materialBgl = device.capturedBgls.find((b) => b.label === 'pbr-material-skylight-bgl');
       expect(materialBgl).toBeDefined();
       const entries = materialBgl?.entries ?? [];
-      // binding indices 0..19 in order
-      for (let i = 0; i < 20; i++) {
+      // binding indices 0..23 in order
+      for (let i = 0; i < 24; i++) {
         expect(entries[i]?.binding).toBe(i);
       }
       // 13..19 resource types
@@ -3049,6 +2788,15 @@ function makeEnvironmentGenerationState() {
       );
       expect((entries[18] as { sampler?: { type: string } }).sampler?.type).toBe('filtering');
       expect((entries[19] as { buffer?: { type: string } }).buffer?.type).toBe('uniform');
+      // 20..23 lightmap resource types
+      expect((entries[20] as { sampler?: { type: string } }).sampler?.type).toBe('filtering');
+      expect((entries[21] as { texture?: { viewDimension: string } }).texture?.viewDimension).toBe(
+        '2d',
+      );
+      expect((entries[22] as { sampler?: { type: string } }).sampler?.type).toBe('filtering');
+      expect((entries[23] as { texture?: { viewDimension: string } }).texture?.viewDimension).toBe(
+        '2d',
+      );
     });
 
     it('(d) bindGroupLayouts[0..3] order matches [view, material, meshArray, instances]', () => {
@@ -3072,13 +2820,13 @@ function makeEnvironmentGenerationState() {
   // ─── (e)(f) Unlit material BGL shape + name ─────────────────────────────────
 
   describe('t57 (M4 round-4) -- unlitPipeline material BGL shape', () => {
-    it('(e) unlit material BGL entry count === 3 (no Skylight binding contamination)', () => {
+    it('(e) unlit material BGL entry count === 13 (no Skylight binding contamination)', () => {
       const device = makeMockDevice();
       // biome-ignore lint/suspicious/noExplicitAny: structural mock
       buildUnlitMaterialBgl(device as any);
       const unlitBgl = device.capturedBgls.find((b) => b.label === 'unlit-material-bgl');
       expect(unlitBgl).toBeDefined();
-      expect(unlitBgl?.entries).toHaveLength(3);
+      expect(unlitBgl?.entries).toHaveLength(13);
     });
 
     it("(f) PBR material BGL labelled 'pbr-material-skylight-bgl'; unlit labelled 'unlit-material-bgl'", () => {
@@ -3293,13 +3041,13 @@ function makeEnvironmentGenerationState() {
       const { createRenderer } = (await import(ENGINE)) as {
         createRenderer: (canvas: unknown, opts?: unknown, bundler?: unknown) => Promise<unknown>;
       };
-      const renderer = (await createRenderer(
+      const result = await createRenderer(
         canvas,
         {},
         { shaderManifestUrl: buildManifestDataUrl() },
-      )) as { ready: Promise<{ ok: boolean }> };
-      const ready = await renderer.ready;
-      expect(ready.ok).toBe(true);
+      );
+      expect(result.ok).toBe(true);
+      result.unwrap();
 
       // bug-20260612: sRGB siblings stay on the swap-chain srgb view; Channel 2
       // (storageBufferCapable=true) follows getPreferredCanvasFormat() — mocked
@@ -3332,21 +3080,15 @@ function makeEnvironmentGenerationState() {
       vi.stubGlobal('navigator', { ...baseNavigator, gpu: makeMockGPU(device) });
       const canvas = makeMockCanvas();
       const { createRenderer } = (await import(ENGINE)) as {
-        createRenderer: (
-          canvas: unknown,
-          opts?: unknown,
-          bundler?: unknown,
-        ) => Promise<{
-          ready: Promise<{ ok: boolean }>;
-        }>;
+        createRenderer: (...args: unknown[]) => Promise<{ ok: boolean; unwrap(): RendererType }>;
       };
-      const renderer = await createRenderer(
+      const result = await createRenderer(
         canvas,
         {},
         { shaderManifestUrl: buildManifestDataUrl() },
       );
-      const ready = await renderer.ready;
-      expect(ready.ok).toBe(true);
+      expect(result.ok).toBe(true);
+      result.unwrap();
 
       // No `createTexture(format='rgba16float')` call for the HDR colour
       // attachment before any opt-in frame. The geometry-side fallback
@@ -3386,21 +3128,15 @@ function makeEnvironmentGenerationState() {
       vi.stubGlobal('navigator', { ...baseNavigator, gpu: makeMockGPU(device) });
       const canvas = makeMockCanvas();
       const { createRenderer } = (await import(ENGINE)) as {
-        createRenderer: (
-          canvas: unknown,
-          opts?: unknown,
-          bundler?: unknown,
-        ) => Promise<{
-          ready: Promise<{ ok: boolean }>;
-        }>;
+        createRenderer: (...args: unknown[]) => Promise<{ ok: boolean; unwrap(): RendererType }>;
       };
-      const renderer = await createRenderer(
+      const result = await createRenderer(
         canvas,
         {},
         { shaderManifestUrl: buildManifestDataUrl() },
       );
-      const ready = await renderer.ready;
-      expect(ready.ok).toBe(true);
+      expect(result.ok).toBe(true);
+      result.unwrap();
 
       const moduleLabels = log.records
         .filter((r) => r.type === 'createShaderModule')
@@ -3414,44 +3150,6 @@ function makeEnvironmentGenerationState() {
       // the manifest triple guard (missing tonemap entry -> ready rejects).
       expect(moduleLabels).not.toContain('tonemap');
     });
-
-    it('row 5: ready rejects shader-compile-failed when manifest omits tonemap entry', async () => {
-      const log: DeviceCallLog = { records: [] };
-      const device = makeMockDevice(log);
-      vi.stubGlobal('navigator', { ...baseNavigator, gpu: makeMockGPU(device) });
-      const canvas = makeMockCanvas();
-      const partialManifest = {
-        schemaVersion: '1.0.0',
-        entries: [
-          {
-            hash: 'pbr00000',
-            wgsl: '/* mock pbr.wgsl - calls f_schlick( for PBR direct lighting */',
-            glsl: '',
-            bindings: '',
-          },
-          {
-            hash: 'unlit000',
-            wgsl: '/* mock unlit.wgsl */',
-            glsl: '',
-            bindings: '',
-          },
-        ],
-      };
-      const url = `data:application/json,${encodeURIComponent(JSON.stringify(partialManifest))}`;
-      const { createRenderer } = (await import(ENGINE)) as {
-        createRenderer: (
-          canvas: unknown,
-          opts?: unknown,
-          bundler?: unknown,
-        ) => Promise<{
-          ready: Promise<{ ok: boolean; error?: { code: string } }>;
-        }>;
-      };
-      const renderer = await createRenderer(canvas, {}, { shaderManifestUrl: url });
-      const ready = await renderer.ready;
-      expect(ready.ok).toBe(false);
-      expect(ready.error?.code).toBe('shader-compile-failed');
-    });
   });
 }
 
@@ -3676,7 +3374,6 @@ function makeEnvironmentGenerationState() {
       // now flows through the same generic per-MaterialShader pipeline cache
       // every other transparent material uses (plan-strategy D-7).
       unlitPipelineHdr: f.fakeUnlitHdrPipeline,
-      standardPipelineHdr: f.fakeStandardHdrPipeline,
       perPassResources: {
         depthTexture: { __label: 'depth' },
         depthTextureView: f.swapDepthView,
@@ -3728,7 +3425,7 @@ function makeEnvironmentGenerationState() {
       const internals = makeRecorderInternals(log);
       const ps = makePipelineState(internals as never, false);
       (internals as { getPipelineState: () => unknown }).getPipelineState = () => ps;
-      const { recordFrame } = await import('@forgeax/engine-render/internal');
+      const { recordFrame } = await import('../../../render/src/record/frame');
       const cameras = [makeCamera('none')];
       recordFrame(
         internals as never,
@@ -3739,7 +3436,6 @@ function makeEnvironmentGenerationState() {
         [],
         {
           frameNumber: 0,
-          environmentGeneration: makeEnvironmentGenerationState(),
           compiledFrameGraph: null,
           compiledFrameGraphTopologyKey: null,
           retiredCompiledFrameGraphs: new Set(),
@@ -3767,8 +3463,10 @@ function makeEnvironmentGenerationState() {
         },
         { unlit: 0 },
         { createBindGroup: 0, keys: [] },
-        EMPTY_EXTRACTED_ENVIRONMENT,
-        EMPTY_POST_PROCESS_PARAMS,
+        undefined,
+        0,
+        undefined,
+        0,
       );
 
       // M1 / w7: the render-graph allocates ALL color targets (including HDR)
@@ -3823,8 +3521,7 @@ function makeEnvironmentGenerationState() {
     }
 
     it('despawned key (not in validated set): recordFrame destroys GpuBuffer + deletes Map entry', async () => {
-      const { recordFrame } = await import('@forgeax/engine-render/internal');
-      const { GpuBuffer } = await import('@forgeax/engine-render/internal');
+      const { recordFrame } = await import('../../../render/src/record/frame');
       const { err: rhiErrFn, RhiError: RhiErrorCtor } = await import('@forgeax/engine-rhi');
       const { device: bufDev, destroyedHandles } = makeBufRecorderDevice(
         rhiErrFn,
@@ -3858,7 +3555,6 @@ function makeEnvironmentGenerationState() {
         [],
         {
           frameNumber: 0,
-          environmentGeneration: makeEnvironmentGenerationState(),
           compiledFrameGraph: null,
           compiledFrameGraphTopologyKey: null,
           retiredCompiledFrameGraphs: new Set(),
@@ -3885,8 +3581,10 @@ function makeEnvironmentGenerationState() {
         },
         { unlit: 0 },
         { createBindGroup: 0, keys: [] },
-        EMPTY_EXTRACTED_ENVIRONMENT,
-        EMPTY_POST_PROCESS_PARAMS,
+        undefined,
+        0,
+        undefined,
+        0,
       );
 
       // F11 production loop destroyed the orphaned buffer + dropped the key.
@@ -3896,8 +3594,7 @@ function makeEnvironmentGenerationState() {
     });
 
     it('isDestroyed dedup: a pre-destroyed orphan is not double-destroyed (still removed)', async () => {
-      const { recordFrame } = await import('@forgeax/engine-render/internal');
-      const { GpuBuffer } = await import('@forgeax/engine-render/internal');
+      const { recordFrame } = await import('../../../render/src/record/frame');
       const { err: rhiErrFn, RhiError: RhiErrorCtor } = await import('@forgeax/engine-rhi');
       const { device: bufDev, destroyedHandles } = makeBufRecorderDevice(
         rhiErrFn,
@@ -3931,7 +3628,6 @@ function makeEnvironmentGenerationState() {
         [],
         {
           frameNumber: 0,
-          environmentGeneration: makeEnvironmentGenerationState(),
           compiledFrameGraph: null,
           compiledFrameGraphTopologyKey: null,
           retiredCompiledFrameGraphs: new Set(),
@@ -3958,8 +3654,10 @@ function makeEnvironmentGenerationState() {
         },
         { unlit: 0 },
         { createBindGroup: 0, keys: [] },
-        EMPTY_EXTRACTED_ENVIRONMENT,
-        EMPTY_POST_PROCESS_PARAMS,
+        undefined,
+        0,
+        undefined,
+        0,
       );
 
       // isDestroyed gate skipped the second destroy; key still dropped.
@@ -4001,18 +3699,18 @@ function makeEnvironmentGenerationState() {
   describe('Skin — component registration + schema shape (AC-13 / AC-37)', () => {
     it('Skin is a registered component with name "Skin" and schema fields skeleton + joints', () => {
       expect(Skin.name).toBe('Skin');
-      expect(componentSchema(Skin)).toEqual({
+      expect(componentSchemaTypes(Skin)).toEqual({
         skeleton: 'shared<SkeletonAsset>',
         joints: 'array<entity>',
       });
     });
 
-    it('componentSchema(Skin).skeleton is shared<SkeletonAsset> (schema-vocab keyword)', () => {
-      expect(componentSchema(Skin).skeleton).toBe('shared<SkeletonAsset>');
+    it('Skin.schema.skeleton is shared<SkeletonAsset> (schema-vocab keyword)', () => {
+      expect(componentFieldType(Skin, 'skeleton')).toBe('shared<SkeletonAsset>');
     });
 
-    it('componentSchema(Skin).joints is array<entity> (schema-vocab keyword)', () => {
-      expect(componentSchema(Skin).joints).toBe('array<entity>');
+    it('Skin.schema.joints is array<entity> (schema-vocab keyword)', () => {
+      expect(componentFieldType(Skin, 'joints')).toBe('array<entity>');
     });
 
     it('Skin component spawns on an entity', () => {
@@ -4097,24 +3795,6 @@ function makeEnvironmentGenerationState() {
     };
   }
 
-  const testAnimationHandles = new WeakMap<
-    object,
-    Map<number, Handle<'AnimationClip', 'shared'>>
-  >();
-
-  function testAnimationHandle(world: World, raw: number): Handle<'AnimationClip', 'shared'> {
-    let handles = testAnimationHandles.get(world);
-    if (handles === undefined) {
-      handles = new Map();
-      testAnimationHandles.set(world, handles);
-    }
-    const existing = handles.get(raw);
-    if (existing !== undefined) return existing;
-    const handle = world.allocSharedRef('AnimationClip', makeClip(1, []));
-    handles.set(raw, handle);
-    return handle;
-  }
-
   type TestResolver = { clips: Map<number, AnimationClip>; handles?: Map<number, number> };
 
   function makeResolver(clips: Map<number, AnimationClip>): TestResolver {
@@ -4133,13 +3813,8 @@ function makeEnvironmentGenerationState() {
     for (const entity of players) {
       const player = world.get(entity, AnimationPlayer);
       if (!player.ok) continue;
-      const rawByHandle = new Map<number, number>();
-      for (const [raw, handle] of testAnimationHandles.get(world) ?? []) {
-        rawByHandle.set(handle, raw);
-      }
       const clips = Array.from(player.value.clips, (handle) => {
-        const raw = rawByHandle.get(handle);
-        const mapped = handles.get(raw ?? handle);
+        const mapped = handles.get(handle);
         return mapped ?? (allocated.has(handle) ? handle : 0);
       });
       world.set(entity, AnimationPlayer, { clips });
@@ -4186,7 +3861,7 @@ function makeEnvironmentGenerationState() {
         component: AnimationPlayer,
         data: {
           clips: [
-            testAnimationHandle(world, clipId),
+            toShared<'AnimationClip'>(clipId),
             0 as Handle<'AnimationClip', 'shared'>,
             0 as Handle<'AnimationClip', 'shared'>,
             0 as Handle<'AnimationClip', 'shared'>,
@@ -4279,7 +3954,7 @@ function makeEnvironmentGenerationState() {
           component: AnimationPlayer,
           data: {
             clips: [
-              testAnimationHandle(world, 1),
+              toShared<'AnimationClip'>(1),
               0 as Handle<'AnimationClip', 'shared'>,
               0 as Handle<'AnimationClip', 'shared'>,
               0 as Handle<'AnimationClip', 'shared'>,
@@ -4318,7 +3993,7 @@ function makeEnvironmentGenerationState() {
           component: AnimationPlayer,
           data: {
             clips: [
-              testAnimationHandle(world, 1),
+              toShared<'AnimationClip'>(1),
               0 as Handle<'AnimationClip', 'shared'>,
               0 as Handle<'AnimationClip', 'shared'>,
               0 as Handle<'AnimationClip', 'shared'>,
@@ -4353,7 +4028,7 @@ function makeEnvironmentGenerationState() {
           component: AnimationPlayer,
           data: {
             clips: [
-              testAnimationHandle(world, 1),
+              toShared<'AnimationClip'>(1),
               0 as Handle<'AnimationClip', 'shared'>,
               0 as Handle<'AnimationClip', 'shared'>,
               0 as Handle<'AnimationClip', 'shared'>,
@@ -4459,7 +4134,7 @@ function makeEnvironmentGenerationState() {
           component: AnimationPlayer,
           data: {
             clips: [
-              testAnimationHandle(world, 1),
+              toShared<'AnimationClip'>(1),
               0 as Handle<'AnimationClip', 'shared'>,
               0 as Handle<'AnimationClip', 'shared'>,
               0 as Handle<'AnimationClip', 'shared'>,
@@ -4516,7 +4191,7 @@ function makeEnvironmentGenerationState() {
           component: AnimationPlayer,
           data: {
             clips: [
-              testAnimationHandle(world, 1),
+              toShared<'AnimationClip'>(1),
               0 as Handle<'AnimationClip', 'shared'>,
               0 as Handle<'AnimationClip', 'shared'>,
               0 as Handle<'AnimationClip', 'shared'>,
@@ -4599,8 +4274,8 @@ function makeEnvironmentGenerationState() {
           component: AnimationPlayer,
           data: {
             clips: [
-              testAnimationHandle(world, 1),
-              testAnimationHandle(world, 2),
+              toShared<'AnimationClip'>(1),
+              toShared<'AnimationClip'>(2),
               0 as Handle<'AnimationClip', 'shared'>,
               0 as Handle<'AnimationClip', 'shared'>,
             ],
@@ -4665,8 +4340,8 @@ function makeEnvironmentGenerationState() {
           component: AnimationPlayer,
           data: {
             clips: [
-              testAnimationHandle(world, 1),
-              testAnimationHandle(world, 2),
+              toShared<'AnimationClip'>(1),
+              toShared<'AnimationClip'>(2),
               0 as Handle<'AnimationClip', 'shared'>,
               0 as Handle<'AnimationClip', 'shared'>,
             ],
@@ -4717,8 +4392,8 @@ function makeEnvironmentGenerationState() {
           component: AnimationPlayer,
           data: {
             clips: [
-              testAnimationHandle(world, 1),
-              testAnimationHandle(world, 2),
+              toShared<'AnimationClip'>(1),
+              toShared<'AnimationClip'>(2),
               0 as Handle<'AnimationClip', 'shared'>,
               0 as Handle<'AnimationClip', 'shared'>,
             ],
@@ -4775,9 +4450,9 @@ function makeEnvironmentGenerationState() {
           component: AnimationPlayer,
           data: {
             clips: [
-              testAnimationHandle(world, 1),
-              testAnimationHandle(world, 2),
-              testAnimationHandle(world, 3),
+              toShared<'AnimationClip'>(1),
+              toShared<'AnimationClip'>(2),
+              toShared<'AnimationClip'>(3),
               0 as Handle<'AnimationClip', 'shared'>,
             ],
             times: new Float32Array([0, 0, 0, 0]),
@@ -4828,8 +4503,8 @@ function makeEnvironmentGenerationState() {
           component: AnimationPlayer,
           data: {
             clips: [
-              testAnimationHandle(world, 1),
-              testAnimationHandle(world, 2),
+              toShared<'AnimationClip'>(1),
+              toShared<'AnimationClip'>(2),
               0 as Handle<'AnimationClip', 'shared'>,
               0 as Handle<'AnimationClip', 'shared'>,
             ],
@@ -4873,7 +4548,7 @@ function makeEnvironmentGenerationState() {
             component: AnimationPlayer,
             data: {
               clips: [
-                testAnimationHandle(world, 1),
+                toShared<'AnimationClip'>(1),
                 0 as Handle<'AnimationClip', 'shared'>,
                 0 as Handle<'AnimationClip', 'shared'>,
                 0 as Handle<'AnimationClip', 'shared'>,
@@ -4938,8 +4613,8 @@ function makeEnvironmentGenerationState() {
             component: AnimationPlayer,
             data: {
               clips: [
-                testAnimationHandle(world, 1),
-                testAnimationHandle(world, 2),
+                toShared<'AnimationClip'>(1),
+                toShared<'AnimationClip'>(2),
                 0 as Handle<'AnimationClip', 'shared'>,
                 0 as Handle<'AnimationClip', 'shared'>,
               ],
@@ -4995,8 +4670,8 @@ function makeEnvironmentGenerationState() {
           component: AnimationPlayer,
           data: {
             clips: [
-              testAnimationHandle(world, 1),
-              testAnimationHandle(world, 2),
+              toShared<'AnimationClip'>(1),
+              toShared<'AnimationClip'>(2),
               0 as Handle<'AnimationClip', 'shared'>,
               0 as Handle<'AnimationClip', 'shared'>,
             ],
@@ -5046,7 +4721,7 @@ function makeEnvironmentGenerationState() {
           component: AnimationPlayer,
           data: {
             clips: [
-              testAnimationHandle(world, 1),
+              toShared<'AnimationClip'>(1),
               0 as Handle<'AnimationClip', 'shared'>,
               0 as Handle<'AnimationClip', 'shared'>,
               0 as Handle<'AnimationClip', 'shared'>,
@@ -5105,8 +4780,8 @@ function makeEnvironmentGenerationState() {
           component: AnimationPlayer,
           data: {
             clips: [
-              testAnimationHandle(world, 1),
-              testAnimationHandle(world, 2),
+              toShared<'AnimationClip'>(1),
+              toShared<'AnimationClip'>(2),
               0 as Handle<'AnimationClip', 'shared'>,
               0 as Handle<'AnimationClip', 'shared'>,
             ],
@@ -5156,7 +4831,7 @@ function makeEnvironmentGenerationState() {
           component: AnimationPlayer,
           data: {
             clips: [
-              testAnimationHandle(world, 1),
+              toShared<'AnimationClip'>(1),
               0 as Handle<'AnimationClip', 'shared'>,
               0 as Handle<'AnimationClip', 'shared'>,
               0 as Handle<'AnimationClip', 'shared'>,
@@ -5220,8 +4895,8 @@ function makeEnvironmentGenerationState() {
           component: AnimationPlayer,
           data: {
             clips: [
-              testAnimationHandle(world, 1),
-              testAnimationHandle(world, 2),
+              toShared<'AnimationClip'>(1),
+              toShared<'AnimationClip'>(2),
               0 as Handle<'AnimationClip', 'shared'>,
               0 as Handle<'AnimationClip', 'shared'>,
             ],
@@ -5264,7 +4939,7 @@ function makeEnvironmentGenerationState() {
           component: AnimationPlayer,
           data: {
             clips: [
-              testAnimationHandle(world, 1),
+              toShared<'AnimationClip'>(1),
               0 as Handle<'AnimationClip', 'shared'>,
               0 as Handle<'AnimationClip', 'shared'>,
               0 as Handle<'AnimationClip', 'shared'>,
@@ -5299,7 +4974,7 @@ function makeEnvironmentGenerationState() {
           component: AnimationPlayer,
           data: {
             clips: [
-              testAnimationHandle(world, 1),
+              toShared<'AnimationClip'>(1),
               0 as Handle<'AnimationClip', 'shared'>,
               0 as Handle<'AnimationClip', 'shared'>,
               0 as Handle<'AnimationClip', 'shared'>,
@@ -5364,7 +5039,7 @@ function makeEnvironmentGenerationState() {
           component: AnimationPlayer,
           data: {
             clips: [
-              testAnimationHandle(world, 1),
+              toShared<'AnimationClip'>(1),
               0 as Handle<'AnimationClip', 'shared'>,
               0 as Handle<'AnimationClip', 'shared'>,
               0 as Handle<'AnimationClip', 'shared'>,
@@ -5435,7 +5110,7 @@ function makeEnvironmentGenerationState() {
   }
 
   function readWorld(world: World, entity: EntityHandle): Float32Array {
-    return world.get(entity, Transform).unwrap().world;
+    return world.get(entity, Transform).unwrap().world as Float32Array;
   }
 
   function expectMatClose(actual: Float32Array, expected: Float32Array): void {
@@ -5551,35 +5226,6 @@ function makeEnvironmentGenerationState() {
 
 {
   // --- from skin-cap-gate.test.ts ---
-
-  describe('skin cap-gate', () => {
-    it('VertexStorageBufferUnavailableError has correct code and fields', () => {
-      const e = new VertexStorageBufferUnavailableError();
-      expect(e.code).toBe('vertex-storage-buffer-unavailable');
-      expect(e.expected).toContain('maxStorageBuffersPerShaderStage');
-      expect(e.hint).toContain('OOS-uniform-palette');
-    });
-
-    it('cap-gate fails when vertex storage buffer count is 0', () => {
-      // Simulate: maxStorageBuffersPerShaderStage < 1
-      const maxStorageBuffersPerShaderStage = 0;
-      const hasVertexStorage = maxStorageBuffersPerShaderStage >= 1;
-      expect(hasVertexStorage).toBe(false);
-    });
-
-    it('cap-gate passes when vertex storage buffer count is 1 or more', () => {
-      // Simulate: standard WebGPU core feature
-      const maxStorageBuffersPerShaderStage = 8;
-      const hasVertexStorage = maxStorageBuffersPerShaderStage >= 1;
-      expect(hasVertexStorage).toBe(true);
-    });
-
-    it('cap-gate passes at the W3C spec minimum for vertex storage (1 per stage)', () => {
-      const maxStorageBuffersPerShaderStage = 1;
-      const hasVertexStorage = maxStorageBuffersPerShaderStage >= 1;
-      expect(hasVertexStorage).toBe(true);
-    });
-  });
 }
 
 {
@@ -5709,13 +5355,12 @@ function makeEnvironmentGenerationState() {
       expect(buffers.length).toBe(0);
       const slice = alloc.allocateSlice(1);
       expect(slice.buffer).toBeDefined();
-      expect(buffers.length).toBe(2);
+      expect(buffers.length).toBe(1);
       // Initial capacity = MAX_JOINTS * 64 = 255 * 64 = 16320 (storage
       // path's first grow step; uniform fallback would also start at
       // exactly 16320 since each pool entry equals one binding window).
       // biome-ignore lint/style/noNonNullAssertion: controlled test context
       expect(buffers[0]!.size).toBe(255 * 64);
-      expect(buffers[1]?.size).toBe(255 * 64);
     });
 
     it('grow at 1.5x when binding window exceeds capacity', () => {
@@ -5724,16 +5369,15 @@ function makeEnvironmentGenerationState() {
       // First alloc (offset=0): needed = 0 + bindingWindowBytes (16320)
       // -> grow to 16320 exactly (initial = 255 * 64).
       alloc.allocateSlice(255);
-      expect(buffers.length).toBe(2);
+      expect(buffers.length).toBe(1);
       // biome-ignore lint/style/noNonNullAssertion: controlled test context
       expect(buffers[0]!.size).toBe(16320);
       // Second alloc (offset=255*64=16320): needed = 16320 + 16320 = 32640.
       // 1.5x grow: 16320 -> 24576 -> 36864 (smallest aligned >= 32640).
       alloc.allocateSlice(100);
-      expect(buffers.length).toBe(4);
+      expect(buffers.length).toBe(2);
       // biome-ignore lint/style/noNonNullAssertion: controlled test context
-      expect(buffers[2]!.size).toBe(36864);
-      expect(buffers[3]?.size).toBe(36864);
+      expect(buffers[1]!.size).toBe(36864);
     });
 
     // M6 regression gate: the bug that this fix repairs reproduces here as
@@ -5792,17 +5436,13 @@ function makeEnvironmentGenerationState() {
       expect(s1.buffer).not.toBe(s2.buffer);
       expect(s0.buffer).not.toBe(s2.buffer);
       // Three entities -> three distinct UBOs of size = bindingWindowBytes.
-      expect(buffers.length).toBe(6);
+      expect(buffers.length).toBe(3);
       // biome-ignore lint/style/noNonNullAssertion: controlled test context
       expect(buffers[0]!.size).toBe(16320);
       // biome-ignore lint/style/noNonNullAssertion: controlled test context
       expect(buffers[1]!.size).toBe(16320);
       // biome-ignore lint/style/noNonNullAssertion: controlled test context
       expect(buffers[2]!.size).toBe(16320);
-      // Paired last-submitted palette buffers have the same bounded shape.
-      expect(buffers[3]?.size).toBe(16320);
-      expect(buffers[4]?.size).toBe(16320);
-      expect(buffers[5]?.size).toBe(16320);
     });
 
     it('uniform fallback: pool reuses buffers across frames (M6)', () => {
@@ -5812,14 +5452,14 @@ function makeEnvironmentGenerationState() {
       const f1s0 = alloc.allocateSlice(10);
       const f1s1 = alloc.allocateSlice(10);
       const f1s2 = alloc.allocateSlice(10);
-      expect(buffers.length).toBe(6);
+      expect(buffers.length).toBe(3);
       // Frame 2: reset + same-shape walk -> pool round-robin, no new
       // createBuffer calls. Slices reuse the exact same buffer objects.
       alloc.resetForFrame();
       const f2s0 = alloc.allocateSlice(10);
       const f2s1 = alloc.allocateSlice(10);
       const f2s2 = alloc.allocateSlice(10);
-      expect(buffers.length).toBe(6); // unchanged
+      expect(buffers.length).toBe(3); // unchanged
       expect(f2s0.buffer).toBe(f1s0.buffer);
       expect(f2s1.buffer).toBe(f1s1.buffer);
       expect(f2s2.buffer).toBe(f1s2.buffer);
@@ -6132,7 +5772,7 @@ function makeEnvironmentGenerationState() {
   // --- from sprite-animation-tick-boundary.test.ts ---
 
   function setDt(world: World, dt: number): void {
-    world.update(dt).unwrap();
+    world[worldInternal].getClockWriter().time.delta = dt;
   }
 
   function expectRegion(
@@ -6161,7 +5801,7 @@ function makeEnvironmentGenerationState() {
       // at 0 but accumDt would be 0.25, not 0); a clamp to 0.5 would
       // advance 1 frame -> currentFrame === 1; either way the
       // assertions below diverge from the no-clamp branch.
-      const world = new World({ time: { maxDeltaSeconds: 30 } });
+      const world = new World();
       const regions = new Float32Array([
         0.0, 0, 0.25, 1, 0.25, 0, 0.25, 1, 0.5, 0, 0.25, 1, 0.75, 0, 0.25, 1,
       ]);
@@ -6192,7 +5832,7 @@ function makeEnvironmentGenerationState() {
     });
 
     it('(2) frameCount=1 static sprite stays at currentFrame=0 (LOOP)', () => {
-      const world = new World({ time: { maxDeltaSeconds: 30 } });
+      const world = new World();
       const regions = new Float32Array([0.0, 0.0, 1.0, 1.0]);
       const entity = world
         .spawn({
@@ -6223,7 +5863,7 @@ function makeEnvironmentGenerationState() {
     });
 
     it('(2b) frameCount=1 static sprite stays at currentFrame=0 (CLAMP)', () => {
-      const world = new World({ time: { maxDeltaSeconds: 30 } });
+      const world = new World();
       const regions = new Float32Array([0.0, 0.0, 1.0, 1.0]);
       const entity = world
         .spawn({
@@ -6246,7 +5886,7 @@ function makeEnvironmentGenerationState() {
     });
 
     it('(3) manual setFrame: world.set(SpriteAnimation, { currentFrame: 2, accumDt: 0 }) is honoured next tick', () => {
-      const world = new World({ time: { maxDeltaSeconds: 30 } });
+      const world = new World();
       const regions = new Float32Array([
         0.0, 0, 0.25, 1, 0.25, 0, 0.25, 1, 0.5, 0, 0.25, 1, 0.75, 0, 0.25, 1,
       ]);
@@ -6305,7 +5945,7 @@ function makeEnvironmentGenerationState() {
   // --- from sprite-animation-tick-clamp.test.ts ---
 
   function setDt(world: World, dt: number): void {
-    world.update(dt).unwrap();
+    world[worldInternal].getClockWriter().time.delta = dt;
   }
 
   function makeRegions(): Float32Array {
@@ -6343,7 +5983,7 @@ function makeEnvironmentGenerationState() {
 
   describe('spriteAnimationTickSystem - AC-05 clamp end-frame (M4 T-18)', () => {
     it('dt=0.5 with frameCount=3 / frameDuration=0.1 stops at frameCount-1 (last frame)', () => {
-      const world = new World({ time: { maxDeltaSeconds: 30 } });
+      const world = new World();
       const regions = makeRegions();
       const entity = world
         .spawn({
@@ -6369,7 +6009,7 @@ function makeEnvironmentGenerationState() {
     });
 
     it('continued dt=0.5 keeps currentFrame at last frame (no wrap)', () => {
-      const world = new World({ time: { maxDeltaSeconds: 30 } });
+      const world = new World();
       const regions = makeRegions();
       const entity = world
         .spawn({
@@ -6411,7 +6051,7 @@ function makeEnvironmentGenerationState() {
 
   describe('spriteAnimationTickSystem - AC-09(c) frameDuration<0 fail-fast (M4 T-21)', () => {
     it('returns Result.err with detail.field=frame-duration when frameDuration < 0', () => {
-      const world = new World({ time: { maxDeltaSeconds: 30 } });
+      const world = new World();
       const entity = world
         .spawn({
           component: SpriteAnimation,
@@ -6465,7 +6105,7 @@ function makeEnvironmentGenerationState() {
       // semantics return one of the two; either way the `.code` matches
       // and the `.detail.field` matches, locking the consistent-abstraction
       // claim from plan-strategy section 2 D-1.
-      const world = new World({ time: { maxDeltaSeconds: 30 } });
+      const world = new World();
       world
         .spawn({
           component: SpriteAnimation,
@@ -6482,7 +6122,7 @@ function makeEnvironmentGenerationState() {
       expect(rZero.ok).toBe(false);
       if (rZero.ok) throw new Error('zero arm: expected Result.err');
 
-      const world2 = new World({ time: { maxDeltaSeconds: 30 } });
+      const world2 = new World();
       world2
         .spawn({
           component: SpriteAnimation,
@@ -6510,7 +6150,7 @@ function makeEnvironmentGenerationState() {
 
   describe('spriteAnimationTickSystem - AC-09(b) frameDuration=0 fail-fast (M4 T-20)', () => {
     it('returns Result.err with detail.field=frame-duration when frameDuration === 0', () => {
-      const world = new World({ time: { maxDeltaSeconds: 30 } });
+      const world = new World();
       const entity = world
         .spawn({
           component: SpriteAnimation,
@@ -6556,7 +6196,7 @@ function makeEnvironmentGenerationState() {
   // --- from sprite-animation-tick-loop.test.ts ---
 
   function setDt(world: World, dt: number): void {
-    world.update(dt).unwrap();
+    world[worldInternal].getClockWriter().time.delta = dt;
   }
 
   function makeRegions(): Float32Array {
@@ -6598,7 +6238,7 @@ function makeEnvironmentGenerationState() {
 
   describe('spriteAnimationTickSystem - AC-04 loop dt sequence (M4 T-17)', () => {
     it('five canonical dt steps drive currentFrame 0 -> 1 -> 1 -> 2 -> 0 with accumDt residue 0.06', () => {
-      const world = new World({ time: { maxDeltaSeconds: 30 } });
+      const world = new World();
       const regions = makeRegions();
       const entity = world
         .spawn({
@@ -6671,7 +6311,7 @@ function makeEnvironmentGenerationState() {
       // accumDt=0.05. Establishes that the inner advance loop fires more
       // than once per spriteAnimationTickSystem invocation; AC-04 +
       // section 2.5 q6 (while loop semantics).
-      const world = new World({ time: { maxDeltaSeconds: 30 } });
+      const world = new World();
       const regions = makeRegions();
       const entity = world
         .spawn({
@@ -6702,7 +6342,7 @@ function makeEnvironmentGenerationState() {
   // --- from sprite-animation-tick-override-probe.test.ts ---
 
   function setDt(world: World, dt: number): void {
-    world.update(dt).unwrap();
+    world[worldInternal].getClockWriter().time.delta = dt;
   }
 
   function makeRegions(): Float32Array {
@@ -6744,7 +6384,7 @@ function makeEnvironmentGenerationState() {
 
   describe('spriteAnimationTickSystem override probe (M3 AC-14)', () => {
     it('first tick on a World that never used SpriteRegionOverride auto-adds the column without crashing', () => {
-      const world = new World({ time: { maxDeltaSeconds: 30 } });
+      const world = new World();
       const entity = spawnAnim(world);
       // SpriteRegionOverride is never spawned / registered into this World;
       // the old gate existed precisely because world.get on it would throw.
@@ -6760,7 +6400,7 @@ function makeEnvironmentGenerationState() {
     });
 
     it('subsequent ticks set the region in place (steady-state already-present path)', () => {
-      const world = new World({ time: { maxDeltaSeconds: 30 } });
+      const world = new World();
       const entity = spawnAnim(world);
 
       // Tick 1: dt=0.12 > frameDuration=0.1 advances exactly one frame
@@ -6793,7 +6433,7 @@ function makeEnvironmentGenerationState() {
   // --- from sprite-animation-tick-regions-mismatch.test.ts ---
 
   function setDt(world: World, dt: number): void {
-    world.update(dt).unwrap();
+    world[worldInternal].getClockWriter().time.delta = dt;
   }
 
   function spawnBadRegionsLength(world: World): EntityHandle {
@@ -6839,7 +6479,7 @@ function makeEnvironmentGenerationState() {
 
   describe('spriteAnimationTickSystem - AC-09(a) regions.length fail-fast (M4 T-19)', () => {
     it('returns Result.err with 4 structured fields when regions.length !== frameCount * 4', () => {
-      const world = new World({ time: { maxDeltaSeconds: 30 } });
+      const world = new World();
       const entity = spawnBadRegionsLength(world);
 
       setDt(world, 0.1);
@@ -6871,7 +6511,7 @@ function makeEnvironmentGenerationState() {
     });
 
     it('healthy entity advances normally beside a bad-regions-length entity', () => {
-      const world = new World({ time: { maxDeltaSeconds: 30 } });
+      const world = new World();
       const bad = spawnBadRegionsLength(world);
       const good = spawnHealthy(world);
 
@@ -7182,22 +6822,6 @@ function makeEnvironmentGenerationState() {
       const sorted = transparentSortEntries(entries, world);
       expect(sorted.map((e) => e.entityIndex)).toEqual([1, 2, 0]);
     });
-
-    it('uses materialHandle as the tertiary key and preserves equal-material order', () => {
-      const world = new World();
-      setTransparentSortConfig(world, {
-        mode: TRANSPARENT_SORT_MODE_LAYER_Z,
-        yzAlpha: 1.0,
-      }).unwrap();
-      const entries: TransparentEntry[] = [
-        makeEntry({ entityIndex: 0, layer: 0, posZ: 1, materialHandle: 20 }),
-        makeEntry({ entityIndex: 1, layer: 0, posZ: 1, materialHandle: 10 }),
-        makeEntry({ entityIndex: 2, layer: 0, posZ: 1, materialHandle: 20 }),
-      ];
-
-      const sorted = transparentSortEntries(entries, world);
-      expect(sorted.map((e) => e.entityIndex)).toEqual([1, 0, 2]);
-    });
   });
 
   describe('transparentSortEntries - mode=1 Y-sort (AC-10 JRPG foot-pivot)', () => {
@@ -7558,6 +7182,7 @@ function makeEnvironmentGenerationState() {
       limits: {},
       queue: {
         submit: () => undefined,
+        onSubmittedWorkDone: () => Promise.resolve(undefined),
         writeBuffer: (
           buffer: object,
           offset: number,
@@ -7666,7 +7291,7 @@ function makeEnvironmentGenerationState() {
       identifier,
       sourcePath: `${identifier}.wgsl`,
       composedWgsl,
-      paramSchema: canonicalMaterialParamSchema(identifier),
+      paramSchema: '[]',
       variants: [],
     });
     const manifest = {
@@ -7684,13 +7309,12 @@ function makeEnvironmentGenerationState() {
       materialShaders: [
         materialShaderStub('forgeax::default-standard-pbr'),
         materialShaderStub('forgeax::default-unlit'),
-        materialShaderStub('forgeax::default-shadow-caster'),
       ],
     };
     return `data:application/json,${encodeURIComponent(JSON.stringify(manifest))}`;
   }
 
-  function makePassSpies(): PassSpies {
+  function _makePassSpies(): PassSpies {
     return {
       setIndexBuffer: vi.fn(),
       setVertexBuffer: vi.fn(),
@@ -7702,15 +7326,10 @@ function makeEnvironmentGenerationState() {
     };
   }
 
-  interface RendererLike {
-    ready: Promise<void>;
-    draw: (worlds: unknown, opts: { cameraOwner: number; resourceOwner: number }) => void;
-    onError: (cb: (err: { code: string }) => void) => () => void;
-    assets: { register: (asset: unknown) => { ok: boolean; value: unknown } };
-  }
+  type RendererLike = RendererType;
 
   async function importEngine(): Promise<{
-    createRenderer: (canvas: unknown, opts?: unknown) => Promise<RendererLike>;
+    createRenderer: (...args: unknown[]) => Promise<{ unwrap(): RendererLike }>;
   }> {
     return (await import(ENGINE)) as never;
   }
@@ -7729,7 +7348,7 @@ function makeEnvironmentGenerationState() {
     DirectionalLight: unknown;
   }> {
     return {
-      ...(await import('@forgeax/engine-render/internal')),
+      ...(await import('@forgeax/engine-render')),
       ...(await import('@forgeax/engine-scene')),
     } as never;
   }
@@ -7764,12 +7383,12 @@ function makeEnvironmentGenerationState() {
     };
   }
 
-  function singleSubmeshTriangle(): MeshAsset {
+  function _singleSubmeshTriangle(): MeshAsset {
     return {
       kind: 'mesh',
       vertices: new Float32Array(3 * 12),
       indices: new Uint16Array([0, 1, 2]),
-      attributes: canonicalTestMeshAttributes(3),
+      attributes: {},
       materialSlots: [{ slotName: 'Default' }],
       submeshes: [
         {
@@ -7783,12 +7402,12 @@ function makeEnvironmentGenerationState() {
     };
   }
 
-  function threeSubmeshMesh(): MeshAsset {
+  function _threeSubmeshMesh(): MeshAsset {
     return {
       kind: 'mesh',
       vertices: new Float32Array(9 * 12),
       indices: new Uint16Array([0, 1, 2, 3, 4, 5, 6, 7, 8]),
-      attributes: canonicalTestMeshAttributes(9),
+      attributes: {},
       materialSlots: [{ slotName: 'First' }, { slotName: 'Second' }, { slotName: 'Third' }],
       submeshes: [
         {
@@ -7816,22 +7435,23 @@ function makeEnvironmentGenerationState() {
     };
   }
 
-  async function setupRenderer(spies: PassSpies): Promise<{ renderer: RendererLike }> {
+  async function _setupRenderer(spies: PassSpies): Promise<{ renderer: RendererLike }> {
     const { device } = makeMockGPUDevice(spies);
     vi.stubGlobal('navigator', { ...baseNavigator, gpu: makeMockGPU(device) });
     const { createRenderer } = await importEngine();
-    const renderer = await createRenderer(
-      makeMockCanvas(),
-      {},
-      {
-        shaderManifestUrl: buildManifestDataUrl(),
-      },
-    );
-    await renderer.ready;
+    const renderer = (
+      await createRenderer(
+        makeMockCanvas(),
+        {},
+        {
+          shaderManifestUrl: buildManifestDataUrl(),
+        },
+      )
+    ).unwrap();
     return { renderer };
   }
 
-  async function spawnMultiMaterialScene(
+  async function _spawnMultiMaterialScene(
     _renderer: RendererLike,
     meshAsset: MeshAsset,
     colors: ReadonlyArray<readonly [number, number, number]>,
@@ -7839,21 +7459,6 @@ function makeEnvironmentGenerationState() {
     const { World } = await importEcs();
     const C = await importComponents();
     const world = new World();
-    for (const component of [
-      C.Camera,
-      C.DirectionalLight,
-      C.Transform,
-      C.MeshRenderer,
-      C.MeshFilter,
-    ]) {
-      (
-        world as unknown as {
-          components: { register: (component: unknown) => { unwrap: () => unknown } };
-        }
-      ).components
-        .register(component)
-        .unwrap();
-    }
     const meshHandle = world.allocSharedRef('MeshAsset', meshAsset) as Handle<
       'MeshAsset',
       'shared'
@@ -7887,7 +7492,7 @@ function makeEnvironmentGenerationState() {
       { component: C.Transform, data: cameraTransform() },
     );
     world.spawn(
-      { component: C.DirectionalLight, data: { direction: [-0.5, -1, -0.3] } },
+      { component: C.DirectionalLight, data: {} },
       { component: C.Transform, data: cameraTransform() },
     );
     world.spawn(
@@ -7897,222 +7502,6 @@ function makeEnvironmentGenerationState() {
     );
     return world;
   }
-
-  describe('extract: per-submesh MaterialSnapshot[] (w11-a)', () => {
-    beforeEach(() => {
-      vi.stubGlobal('navigator', baseNavigator);
-    });
-    afterEach(() => {
-      vi.unstubAllGlobals();
-    });
-
-    it('(a) submeshes=[3] + materials=[3]: extract renderable carries materials[3]', async () => {
-      const spies = makePassSpies();
-      const { renderer } = await setupRenderer(spies);
-      const errors: string[] = [];
-      renderer.onError((e) => errors.push(e.code));
-
-      const world = await spawnMultiMaterialScene(renderer, threeSubmeshMesh(), [
-        [1, 0, 0],
-        [0, 1, 0],
-        [0, 0, 1],
-      ]);
-
-      // Use the extract API directly so we can inspect the snapshot shape.
-      const { extractFrame, prepareExtractContext } = (await import(
-        '@forgeax/engine-render/internal'
-      )) as {
-        extractFrame: (
-          w: unknown,
-          context: unknown,
-        ) => {
-          renderables: Array<{
-            materials?: ReadonlyArray<{ baseColor: Float32Array | readonly number[] }>;
-            material?: { baseColor: Float32Array | readonly number[] };
-          }>;
-        };
-        prepareExtractContext: (w: unknown, options: unknown) => unknown;
-      };
-      // The renderer exposes its render asset port via .assets.
-      const rendererAny = renderer as unknown as { assets: unknown };
-      const frame = extractFrame(
-        world,
-        prepareExtractContext(world, { assets: rendererAny.assets }),
-      );
-      expect(frame.renderables.length).toBe(1);
-      const r = frame.renderables[0];
-      if (!r) throw new Error('expected renderable');
-      expect(r.materials).toBeDefined();
-      expect(r.materials?.length).toBe(3);
-      // The three materials must carry distinct baseColor vec3 values
-      // (positional 1-1 with submeshes[]).
-      const bc0 = r.materials?.[0]?.baseColor;
-      const bc1 = r.materials?.[1]?.baseColor;
-      const bc2 = r.materials?.[2]?.baseColor;
-      expect(Array.from(bc0).slice(0, 3)).toEqual([1, 0, 0]);
-      expect(Array.from(bc1).slice(0, 3)).toEqual([0, 1, 0]);
-      expect(Array.from(bc2).slice(0, 3)).toEqual([0, 0, 1]);
-      expect(errors).toEqual([]);
-    });
-  });
-
-  describe('record: per-submesh material UBO rebind (w16-a)', () => {
-    beforeEach(() => {
-      vi.stubGlobal('navigator', baseNavigator);
-    });
-    afterEach(() => {
-      vi.unstubAllGlobals();
-    });
-
-    it.skip('(b) 3 submeshes x 3 distinct materials: 3 material UBO writes at distinct slot offsets, 3 drawIndexed each preceded by setBindGroup(1)', async () => {
-      const spies = makePassSpies();
-      const { renderer } = await setupRenderer(spies);
-      const errors: string[] = [];
-      renderer.onError((e) => errors.push(e.code));
-
-      const world = await spawnMultiMaterialScene(renderer, threeSubmeshMesh(), [
-        [1, 0, 0],
-        [0, 1, 0],
-        [0, 0, 1],
-      ]);
-      if (!(renderer as unknown as RendererType).attachWorld(world as WorldType).ok) {
-        throw new Error('World attachment failed');
-      }
-      (world as WorldType).update().unwrap();
-      renderer.draw([world], { cameraOwner: 0, resourceOwner: 0 });
-
-      expect(spies.drawIndexed).toHaveBeenCalledTimes(3);
-
-      // Material UBO writes: must have at least 3 distinct slot offsets
-      // (one per submesh material). Stride is 256 B; payload size 48 B.
-      const matUboWrites = spies.writeBufferCalls.filter(
-        (w) => w.bufferLabel === 'pbr-material-ubo',
-      );
-      const distinctOffsets = new Set(matUboWrites.map((w) => w.offset));
-      expect(distinctOffsets.size).toBeGreaterThanOrEqual(3);
-      // Three offsets must be 0, 256, 512 (i.e. consecutive 256 B slots --
-      // one per material in this single-entity scene).
-      expect(distinctOffsets.has(0)).toBe(true);
-      expect(distinctOffsets.has(256)).toBe(true);
-      expect(distinctOffsets.has(512)).toBe(true);
-
-      // Inside the geometry pass: each drawIndexed must be preceded by a
-      // material BG bind (setBindGroup(1, ..., [offset])) at the matching slot.
-      // We walk the geometry events and record, for each drawIndexed,
-      // the most recent setBindGroup(1, ...) dynamicOffset.
-      let lastMatOffset: number | undefined;
-      const drawOffsets: number[] = [];
-      for (const ev of spies.geometryEvents) {
-        if (ev.kind === 'setBindGroup' && ev.call.group === 1) {
-          lastMatOffset = ev.call.dynamicOffsets[0];
-        } else if (ev.kind === 'drawIndexed') {
-          if (lastMatOffset !== undefined) drawOffsets.push(lastMatOffset);
-        }
-      }
-      expect(drawOffsets.length).toBe(3);
-      // The three drawIndexed calls must each see a distinct material offset.
-      expect(new Set(drawOffsets).size).toBe(3);
-      // Specifically: submesh i should see slotOffset i*256.
-      expect(drawOffsets[0]).toBe(0);
-      expect(drawOffsets[1]).toBe(256);
-      expect(drawOffsets[2]).toBe(512);
-
-      expect(errors).toEqual([]);
-    });
-
-    it('(b2) 3 submeshes share one stride-shaped material UBO upload and keep dynamic offsets', async () => {
-      const spies = makePassSpies();
-      const { renderer } = await setupRenderer(spies);
-      const errors: string[] = [];
-      renderer.onError((e) => errors.push(e.code));
-
-      const world = await spawnMultiMaterialScene(renderer, threeSubmeshMesh(), [
-        [1, 0, 0],
-        [0, 1, 0],
-        [0, 0, 1],
-      ]);
-      if (!(renderer as unknown as RendererType).attachWorld(world as WorldType).ok) {
-        throw new Error('World attachment failed');
-      }
-      (world as WorldType).update().unwrap();
-      renderer.draw([world], { cameraOwner: 0, resourceOwner: 0 });
-      await new Promise((resolve) => setTimeout(resolve, 0));
-      if (!(renderer as unknown as RendererType).attachWorld(world as WorldType).ok) {
-        throw new Error('World attachment failed');
-      }
-      (world as WorldType).update().unwrap();
-      renderer.draw([world], { cameraOwner: 0, resourceOwner: 0 });
-
-      const matUboWrites = spies.writeBufferCalls.filter(
-        (w) => w.bufferLabel === 'pbr-material-ubo',
-      );
-      // The two-frame warmup writes the same packed material slab once per
-      // frame; the contract under test is the single stride-shaped slab, not
-      // the number of frame submissions.
-      expect(matUboWrites.length).toBeGreaterThanOrEqual(1);
-      expect(new Set(matUboWrites.map((write) => `${write.offset}:${write.byteLength}`))).toEqual(
-        new Set([`0:${3 * 512}`]),
-      );
-
-      const drawOffsets: number[] = [];
-      let lastMatOffset: number | undefined;
-      for (const ev of spies.geometryEvents) {
-        if (ev.kind === 'setBindGroup' && ev.call.group === 1) {
-          lastMatOffset = ev.call.dynamicOffsets[0];
-        } else if (ev.kind === 'drawIndexed' && lastMatOffset !== undefined) {
-          drawOffsets.push(lastMatOffset);
-        }
-      }
-      expect(drawOffsets.slice(-3)).toEqual([0, 512, 1024]);
-      expect(errors).toEqual([]);
-    });
-
-    it('(c) single submesh + single material: 1 material UBO write at offset 0, 1 drawIndexed (backward compat)', async () => {
-      const spies = makePassSpies();
-      const { renderer } = await setupRenderer(spies);
-      const errors: string[] = [];
-      renderer.onError((e) => errors.push(e.code));
-
-      const world = await spawnMultiMaterialScene(renderer, singleSubmeshTriangle(), [[1, 0.5, 0]]);
-      if (!(renderer as unknown as RendererType).attachWorld(world as WorldType).ok) {
-        throw new Error('World attachment failed');
-      }
-      (world as WorldType).update().unwrap();
-      renderer.draw([world], { cameraOwner: 0, resourceOwner: 0 });
-      await new Promise((resolve) => setTimeout(resolve, 0));
-      if (!(renderer as unknown as RendererType).attachWorld(world as WorldType).ok) {
-        throw new Error('World attachment failed');
-      }
-      (world as WorldType).update().unwrap();
-      renderer.draw([world], { cameraOwner: 0, resourceOwner: 0 });
-
-      expect(spies.drawIndexed).toHaveBeenCalledTimes(1);
-
-      const matUboWrites = spies.writeBufferCalls.filter(
-        (w) => w.bufferLabel === 'pbr-material-ubo',
-      );
-      const distinctOffsets = new Set(matUboWrites.map((w) => w.offset));
-      // Single-mesh single-material: only slot 0 is used.
-      expect(distinctOffsets.has(0)).toBe(true);
-      // No further slots should be written.
-      expect(distinctOffsets.has(256)).toBe(false);
-
-      // Geometry pass: exactly 1 drawIndexed; preceded by 1 setBindGroup(1, ..., [0]).
-      let lastMatOffset: number | undefined;
-      const drawOffsets: number[] = [];
-      for (const ev of spies.geometryEvents) {
-        if (ev.kind === 'setBindGroup' && ev.call.group === 1) {
-          lastMatOffset = ev.call.dynamicOffsets[0];
-        } else if (ev.kind === 'drawIndexed') {
-          if (lastMatOffset !== undefined) drawOffsets.push(lastMatOffset);
-        }
-      }
-      expect(drawOffsets.length).toBe(1);
-      expect(drawOffsets[0]).toBe(0);
-
-      expect(errors).toEqual([]);
-    });
-  });
 }
 
 {
@@ -8167,6 +7556,7 @@ function makeEnvironmentGenerationState() {
       limits: {},
       queue: {
         submit: () => undefined,
+        onSubmittedWorkDone: () => Promise.resolve(undefined),
         writeBuffer: () => undefined,
         writeTexture: () => undefined,
       },
@@ -8217,7 +7607,7 @@ function makeEnvironmentGenerationState() {
       identifier,
       sourcePath: `${identifier}.wgsl`,
       composedWgsl: '/* stub */',
-      paramSchema: canonicalMaterialParamSchema(identifier),
+      paramSchema: '[]',
       variants: [],
     });
     const manifest = {
@@ -8249,15 +7639,10 @@ function makeEnvironmentGenerationState() {
     };
   }
 
-  interface RendererLike {
-    ready: Promise<void>;
-    draw: (worlds: unknown, opts: { cameraOwner: number; resourceOwner: number }) => void;
-    onError: (cb: (err: { code: string }) => void) => () => void;
-    assets: { register: (asset: unknown) => { ok: boolean; value: unknown } };
-  }
+  type RendererLike = RendererType;
 
   async function importEngine(): Promise<{
-    createRenderer: (canvas: unknown, opts?: unknown) => Promise<RendererLike>;
+    createRenderer: (...args: unknown[]) => Promise<{ unwrap(): RendererLike }>;
   }> {
     return (await import(ENGINE)) as never;
   }
@@ -8279,7 +7664,7 @@ function makeEnvironmentGenerationState() {
     DirectionalLight: unknown;
   }> {
     return {
-      ...(await import('@forgeax/engine-render/internal')),
+      ...(await import('@forgeax/engine-render')),
       ...(await import('@forgeax/engine-scene')),
     } as never;
   }
@@ -8314,12 +7699,12 @@ function makeEnvironmentGenerationState() {
     };
   }
 
-  function singleSubmeshTriangle(): MeshAsset {
+  function _singleSubmeshTriangle(): MeshAsset {
     return {
       kind: 'mesh',
       vertices: new Float32Array(3 * 12),
       indices: new Uint16Array([0, 1, 2]),
-      attributes: canonicalTestMeshAttributes(3),
+      attributes: {},
       materialSlots: [{ slotName: 'Default' }],
       submeshes: [
         {
@@ -8333,12 +7718,12 @@ function makeEnvironmentGenerationState() {
     };
   }
 
-  function threeSubmeshMesh(): MeshAsset {
+  function _threeSubmeshMesh(): MeshAsset {
     return {
       kind: 'mesh',
       vertices: new Float32Array(9 * 12),
       indices: new Uint16Array([0, 1, 2, 3, 4, 5, 6, 7, 8]),
-      attributes: canonicalTestMeshAttributes(9),
+      attributes: {},
       materialSlots: [{ slotName: 'First' }, { slotName: 'Second' }, { slotName: 'Third' }],
       submeshes: [
         {
@@ -8366,11 +7751,11 @@ function makeEnvironmentGenerationState() {
     };
   }
 
-  function vertexOnlyLineListMesh(): MeshAsset {
+  function _vertexOnlyLineListMesh(): MeshAsset {
     return {
       kind: 'mesh',
       vertices: new Float32Array(2 * 12),
-      attributes: canonicalTestMeshAttributes(2),
+      attributes: {},
       materialSlots: [{ slotName: 'Default' }],
       submeshes: [
         {
@@ -8384,12 +7769,12 @@ function makeEnvironmentGenerationState() {
     };
   }
 
-  function mixedTopologyMesh(): MeshAsset {
+  function _mixedTopologyMesh(): MeshAsset {
     return {
       kind: 'mesh',
       vertices: new Float32Array(5 * 12),
       indices: new Uint16Array([0, 1, 2, 3, 4]),
-      attributes: canonicalTestMeshAttributes(5),
+      attributes: {},
       materialSlots: [{ slotName: 'Triangles' }, { slotName: 'Lines' }],
       submeshes: [
         {
@@ -8414,18 +7799,19 @@ function makeEnvironmentGenerationState() {
     const { device } = makeMockGPUDevice(spies);
     vi.stubGlobal('navigator', { ...baseNavigator, gpu: makeMockGPU(device) });
     const { createRenderer } = await importEngine();
-    const renderer = await createRenderer(
-      makeMockCanvas(),
-      {},
-      {
-        shaderManifestUrl: buildManifestDataUrl(),
-      },
-    );
-    await renderer.ready;
+    const renderer = (
+      await createRenderer(
+        makeMockCanvas(),
+        {},
+        {
+          shaderManifestUrl: buildManifestDataUrl(),
+        },
+      )
+    ).unwrap();
     return { renderer };
   }
 
-  async function spawnScene(
+  async function _spawnScene(
     _renderer: RendererLike,
     meshAsset: MeshAsset,
     materialCount: number,
@@ -8433,21 +7819,6 @@ function makeEnvironmentGenerationState() {
     const { World } = await importEcs();
     const C = await importComponents();
     const world = new World();
-    for (const component of [
-      C.Camera,
-      C.DirectionalLight,
-      C.Transform,
-      C.MeshRenderer,
-      C.MeshFilter,
-    ]) {
-      (
-        world as unknown as {
-          components: { register: (component: unknown) => { unwrap: () => unknown } };
-        }
-      ).components
-        .register(component)
-        .unwrap();
-    }
     const meshHandle = world.allocSharedRef('MeshAsset', meshAsset) as Handle<
       'MeshAsset',
       'shared'
@@ -8487,7 +7858,7 @@ function makeEnvironmentGenerationState() {
       { component: C.Transform, data: cameraTransform() },
     );
     world.spawn(
-      { component: C.DirectionalLight, data: { direction: [-0.5, -1, -0.3] } },
+      { component: C.DirectionalLight, data: {} },
       { component: C.Transform, data: cameraTransform() },
     );
     world.spawn(
@@ -8498,7 +7869,11 @@ function makeEnvironmentGenerationState() {
     return world;
   }
 
-  describe('render-system-record per-submesh drawIndexed (w17, AC-04)', () => {
+  // feat-20260612-skin-palette-per-frame-upload M1 / m1-1: the old
+  // closure-held pipeline assertion is retired with the internal state
+  // boundary. The public inspection snapshot is the supported evidence for
+  // renderer construction and capability health.
+  describe('renderer public inspection contract', () => {
     beforeEach(() => {
       vi.stubGlobal('navigator', baseNavigator);
     });
@@ -8507,171 +7882,15 @@ function makeEnvironmentGenerationState() {
       vi.unstubAllGlobals();
     });
 
-    it('(a) single mesh single submesh: drawIndexed called once', async () => {
-      const spies = makePassSpies();
-      const { renderer } = await setupRenderer(spies);
-      const errors: string[] = [];
-      renderer.onError((e) => errors.push(e.code));
-
-      const world = await spawnScene(renderer, singleSubmeshTriangle(), 1);
-      if (!(renderer as unknown as RendererType).attachWorld(world as WorldType).ok) {
-        throw new Error('World attachment failed');
-      }
-      (world as WorldType).update().unwrap();
-      renderer.draw([world], { cameraOwner: 0, resourceOwner: 0 });
-      await new Promise((resolve) => setTimeout(resolve, 0));
-      if (!(renderer as unknown as RendererType).attachWorld(world as WorldType).ok) {
-        throw new Error('World attachment failed');
-      }
-      (world as WorldType).update().unwrap();
-      renderer.draw([world], { cameraOwner: 0, resourceOwner: 0 });
-
-      expect(spies.drawIndexed).toHaveBeenCalledTimes(1);
-      // First drawIndexed call: indexCount=3, indexOffset=0
-      // drawIndexed(indexCount, instanceCount, indexOffset, baseVertex, firstInstance)
-      const firstCall = spies.drawIndexed.mock.calls[0];
-      expect(firstCall[0]).toBe(3); // indexCount
-      expect(firstCall[2]).toBe(0); // indexOffset
-      expect(errors).toEqual([]);
-    });
-
-    it('(b) single mesh 3 submeshes: drawIndexed called 3 times with distinct offsets', async () => {
-      const spies = makePassSpies();
-      const { renderer } = await setupRenderer(spies);
-      const errors: string[] = [];
-      renderer.onError((e) => errors.push(e.code));
-
-      const world = await spawnScene(renderer, threeSubmeshMesh(), 3);
-      if (!(renderer as unknown as RendererType).attachWorld(world as WorldType).ok) {
-        throw new Error('World attachment failed');
-      }
-      (world as WorldType).update().unwrap();
-      renderer.draw([world], { cameraOwner: 0, resourceOwner: 0 });
-      await new Promise((resolve) => setTimeout(resolve, 0));
-      if (!(renderer as unknown as RendererType).attachWorld(world as WorldType).ok) {
-        throw new Error('World attachment failed');
-      }
-      (world as WorldType).update().unwrap();
-      renderer.draw([world], { cameraOwner: 0, resourceOwner: 0 });
-
-      expect(spies.drawIndexed).toHaveBeenCalledTimes(3);
-      // Each submesh gets its own drawIndexed call with correct indexOffset.
-      const offsets = spies.drawIndexed.mock.calls.map((c: number[]) => c[2]);
-      expect(offsets).toEqual([0, 3, 6]);
-      // Each draw has indexCount=3.
-      const counts = spies.drawIndexed.mock.calls.map((c: number[]) => c[0]);
-      expect(counts).toEqual([3, 3, 3]);
-      expect(errors).toEqual([]);
-    });
-
-    it('(c) vertex-only (non-indexed) submesh: draw() called, drawIndexed not called', async () => {
+    it('reports an alive, available renderer through inspect()', async () => {
       const spies = makePassSpies();
       const { renderer } = await setupRenderer(spies);
-      const errors: string[] = [];
-      renderer.onError((e) => errors.push(e.code));
-
-      const world = await spawnScene(renderer, vertexOnlyLineListMesh(), 1);
-      if (!(renderer as unknown as RendererType).attachWorld(world as WorldType).ok) {
-        throw new Error('World attachment failed');
-      }
-      (world as WorldType).update().unwrap();
-      renderer.draw([world], { cameraOwner: 0, resourceOwner: 0 });
-      await new Promise((resolve) => setTimeout(resolve, 0));
-      if (!(renderer as unknown as RendererType).attachWorld(world as WorldType).ok) {
-        throw new Error('World attachment failed');
-      }
-      (world as WorldType).update().unwrap();
-      renderer.draw([world], { cameraOwner: 0, resourceOwner: 0 });
-
-      expect(spies.draw).toHaveBeenCalled();
-      // draw(vertexCount, instanceCount, firstVertex, firstInstance)
-      const drewVertexCall = spies.draw.mock.calls.find((c: number[]) => c[0] === 2);
-      expect(drewVertexCall).toBeTruthy();
-      // Indexed path must NOT be used for a vertex-only submesh.
-      expect(spies.drawIndexed).not.toHaveBeenCalled();
-      expect(errors).toEqual([]);
-    });
-
-    it('(d) mixed-topology mesh: two drawIndexed calls, one per topology', async () => {
-      const spies = makePassSpies();
-      const { renderer } = await setupRenderer(spies);
-      const errors: string[] = [];
-      renderer.onError((e) => errors.push(e.code));
-
-      const world = await spawnScene(renderer, mixedTopologyMesh(), 2);
-      if (!(renderer as unknown as RendererType).attachWorld(world as WorldType).ok) {
-        throw new Error('World attachment failed');
-      }
-      (world as WorldType).update().unwrap();
-      renderer.draw([world], { cameraOwner: 0, resourceOwner: 0 });
-      await new Promise((resolve) => setTimeout(resolve, 0));
-      if (!(renderer as unknown as RendererType).attachWorld(world as WorldType).ok) {
-        throw new Error('World attachment failed');
-      }
-      (world as WorldType).update().unwrap();
-      renderer.draw([world], { cameraOwner: 0, resourceOwner: 0 });
-
-      // Both submeshes are indexed → 2 drawIndexed calls.
-      expect(spies.drawIndexed).toHaveBeenCalledTimes(2);
-      // Submesh 0: triangle-list, indexOffset=0, indexCount=3
-      expect(spies.drawIndexed.mock.calls[0][0]).toBe(3);
-      expect(spies.drawIndexed.mock.calls[0][2]).toBe(0);
-      // Submesh 1: line-list, indexOffset=3, indexCount=2
-      expect(spies.drawIndexed.mock.calls[1][0]).toBe(2);
-      expect(spies.drawIndexed.mock.calls[1][2]).toBe(3);
-      // Both drawIndexed calls share the same vertex buffer (vertex-only vertex buffer binding).
-      expect(spies.setVertexBuffer).toHaveBeenCalled();
-      expect(errors).toEqual([]);
-    });
-  });
-
-  // feat-20260612-skin-palette-per-frame-upload M1 / m1-1: PipelineState
-  // field-existence assertion. After `await renderer.ready` settles, the
-  // closure-held PipelineState must (a) carry `skinPaletteAllocator` (the
-  // animator-ready palette allocator from `createSkinPaletteAllocator`); and
-  // (b) NOT carry `skinPaletteIdentityBuffer` (the bind-pose stub that gated
-  // PR #353 ships in the prior loop's M8 / w28 -- retired by m1-2 + m1-3 of
-  // this loop). The test is RED before m1-2/m1-3 land (current main: stub
-  // present, allocator missing) and GREEN after both impl tasks commit.
-  describe('feat-20260612 M1 / m1-1: PipelineState skin palette field shape', () => {
-    beforeEach(() => {
-      vi.stubGlobal('navigator', baseNavigator);
-    });
-
-    afterEach(() => {
-      vi.unstubAllGlobals();
-    });
-
-    it('exposes skinPaletteAllocator and not skinPaletteIdentityBuffer (m1-1)', async () => {
-      const spies = makePassSpies();
-      const { renderer } = await setupRenderer(spies);
-      const ps = (
-        renderer as unknown as { _internal_getPipelineState(): unknown }
-      )._internal_getPipelineState() as Record<string, unknown> | null;
-      expect(ps).not.toBeNull();
-      const psNN = ps as Record<string, unknown>;
-      // (a) Allocator carrier present and shaped like SkinPaletteAllocator.
-      expect(psNN.skinPaletteAllocator).toBeDefined();
-      expect(psNN.skinPaletteAllocator).not.toBeNull();
-      const allocator = psNN.skinPaletteAllocator as Record<string, unknown>;
-      expect(typeof allocator.allocateSlice).toBe('function');
-      expect(typeof allocator.writeJointPalette).toBe('function');
-      expect(typeof allocator.resetForFrame).toBe('function');
-      // M6: allocator.buffer field retired -- per-slice `slice.buffer`
-      // is now the carrier so the uniform fallback path can return a
-      // distinct buffer per entity without leaking the storage-only
-      // shared-buffer assumption into record-stage code.
-      expect('buffer' in allocator).toBe(false);
-      // M6 SSOT: allocator exposes the static BG @binding(1) entry size
-      // (= MAX_JOINTS * 64 = 16320) so the record-stage BG creation reads
-      // it instead of a literal. Mismatch with `pbr-skin-mesh-array-bgl`
-      // would trip `dynOffset + entry.size > buffer.size` validation.
-      expect(allocator.bindingWindowBytes).toBe(16320);
-      // M6: useStorageBuffer flag exposed for record-stage / test
-      // assertions that need to know which path the allocator is on.
-      expect(typeof allocator.useStorageBuffer).toBe('boolean');
-      // (b) Stub field retired -- not present on the PipelineState shape.
-      expect('skinPaletteIdentityBuffer' in psNN).toBe(false);
+      const inspection = renderer.inspect();
+      expect(inspection.state).toBe('alive');
+      expect(inspection.surface).toBe('available');
+      expect(inspection.frame.deviceGeneration).toBeGreaterThanOrEqual(0);
+      expect(Array.isArray(inspection.features)).toBe(true);
+      expect(inspection.capabilities).toBeDefined();
     });
   });
 }
@@ -8700,7 +7919,7 @@ const SKIN_M2_IDENTITY_TRANSFORM = {
   scale: [1, 1, 1],
 } as const;
 
-function makeSkinM2AssetPort(): RenderAssetPort {
+function makeSkinM2AssetRegistry(): AssetRegistry {
   const shaderRegistry = makeMockShaderRegistry();
   shaderRegistry.installMaterialArtifact('forgeax::pbr-skin', {
     source: 'fn main() {}',
@@ -8710,13 +7929,7 @@ function makeSkinM2AssetPort(): RenderAssetPort {
       { name: 'roughness', type: 'f32', default: 0.5 },
     ],
   });
-  return {
-    epoch: 0,
-    shaderRegistry,
-    lookup: () => undefined,
-    guidOf: () => undefined,
-    materialShaderTextureFieldNames: () => [],
-  };
+  return new AssetRegistry(shaderRegistry);
 }
 
 function registerSkinM2Mesh(world: World): Handle<'MeshAsset', 'shared'> {
@@ -8864,7 +8077,7 @@ function makeSkinM2StubAllocator(): SkinM2StubAllocator {
 type ExtractFramesWithPipeline = (
   worlds: readonly World[],
   owner: number,
-  a: RenderAssetPort | null,
+  a: AssetRegistry | null,
   p: { skinPaletteAllocator: SkinM2StubAllocator },
 ) => ReturnType<typeof extractFrames>;
 
@@ -8873,7 +8086,7 @@ type ExtractFramesWithPipeline = (
   describe('feat-20260612 M2 / m2-1: hasSkin happy path -> non-zero byteOffset', () => {
     it('two skinned entities -> first slice byteOffset>=0, second>0; writeJointPalette called twice (m2-1)', () => {
       const world = new World();
-      const assets = makeSkinM2AssetPort();
+      const assets = makeSkinM2AssetRegistry();
       const meshHandle = registerSkinM2Mesh(world);
       const matHandle = registerSkinM2PbrSkinMaterial(world);
       const skeletonHandle = registerSkinM2Skeleton(world, 2);
@@ -8888,6 +8101,8 @@ type ExtractFramesWithPipeline = (
 
       const allocator = makeSkinM2StubAllocator();
       const pipelineState = { skinPaletteAllocator: allocator };
+      const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => undefined);
+
       const frame = (extractFrames as unknown as ExtractFramesWithPipeline)(
         [world],
         0,
@@ -8899,6 +8114,8 @@ type ExtractFramesWithPipeline = (
       expect(allocator._resetCount()).toBe(1);
       // writeJointPalette called once per skinned entity (count=2).
       expect(allocator._writeCount()).toBe(2);
+      // No errors fired on happy path.
+      expect(errorSpy).not.toHaveBeenCalled();
       // Both renderables emerge with .skin populated.
       const skinned = frame.renderables.filter((r) => r.skin !== undefined);
       expect(skinned.length).toBe(2);
@@ -8926,6 +8143,7 @@ type ExtractFramesWithPipeline = (
   describe('feat-20260612 M2 / m2-2: assets===null equiv bind-pose (no error)', () => {
     it('skinned entity + prepared null assets -> no _routeError, no skin slice (m2-2)', () => {
       const world = new World();
+      const _assets = makeSkinM2AssetRegistry();
       const meshHandle = registerSkinM2Mesh(world);
       const matHandle = registerSkinM2PbrSkinMaterial(world);
       const skeletonHandle = registerSkinM2Skeleton(world, 1);
@@ -8936,13 +8154,16 @@ type ExtractFramesWithPipeline = (
 
       const allocator = makeSkinM2StubAllocator();
       const pipelineState = { skinPaletteAllocator: allocator };
-      // assets===null: assemble-form / test path that lacks a render asset port.
+      const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => undefined);
+
+      // assets===null: assemble-form / test path that lacks an AssetRegistry.
       // Plan-strategy R-3: must NOT trigger skeleton-resolve-failed; the
       // hasSkin segment is skipped entirely (equivalent to bind-pose).
       expect(() =>
         (extractFrames as unknown as ExtractFramesWithPipeline)([world], 0, null, pipelineState),
       ).not.toThrow();
 
+      expect(errorSpy).not.toHaveBeenCalled();
       // No palette writes when assets is null (skinned entities bypass extract
       // entirely because Skin <-> pbr-skin material walk also requires assets;
       // either way the truth-value is: no writeJointPalette call).
@@ -8956,29 +8177,44 @@ type ExtractFramesWithPipeline = (
   describe('feat-20260612 M2 / m2-3: skeleton-resolve-failed routing', () => {
     it('Skin.skeleton points at unregistered handle -> _routeError(skeleton-resolve-failed) + continue (m2-3)', () => {
       const world = new World();
-      const assets = makeSkinM2AssetPort();
+      const assets = makeSkinM2AssetRegistry();
       const meshHandle = registerSkinM2Mesh(world);
       const matHandle = registerSkinM2PbrSkinMaterial(world);
       const skeletonHandleGood = registerSkinM2Skeleton(world, 1);
       // Synthesize an unregistered skeleton handle: a numeric id (>= BUILTIN_BASE)
-      // that was never minted in world.sharedRefs.
-      const skeletonHandleMissing = toShared<'SkeletonAsset'>(99999);
+      // that was never minted in world.sharedRefs. resolveAssetHandle(world, handle)
+      // on this handle returns asset-not-found.
+      const skeletonHandleMissing = registerSkinM2Skeleton(world, 1);
       spawnSkinM2Camera(world);
       const jointBad = spawnSkinM2Joint(world);
       const jointGood = spawnSkinM2Joint(world);
       // Bad-skin entity (skeleton handle dangling).
       spawnSkinM2SkinnedEntity(world, meshHandle, matHandle, skeletonHandleMissing, [jointBad]);
+      // Simulate a producer releasing a payload while ECS still contains the
+      // handle. Normal ECS writes reject stale handles before they reach the
+      // render extractor; this preserves the extractor's recovery regression.
+      world.sharedRefs.release(skeletonHandleMissing);
+      world.sharedRefs.release(skeletonHandleMissing);
       // Sibling well-formed skinned entity in the same frame.
       spawnSkinM2SkinnedEntity(world, meshHandle, matHandle, skeletonHandleGood, [jointGood]);
       propagateTransforms(world);
+
       const allocator = makeSkinM2StubAllocator();
       const pipelineState = { skinPaletteAllocator: allocator };
+      const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => undefined);
+
       const frame = (extractFrames as unknown as ExtractFramesWithPipeline)(
         [world],
         0,
         assets,
         pipelineState,
       );
+
+      // Exactly one error: skeleton-resolve-failed for the bad entity.
+      expect(errorSpy).toHaveBeenCalledTimes(1);
+      const [ctxArg, errArg] = errorSpy.mock.calls[0] ?? [];
+      expect((errArg as { code: string }).code).toBe('skeleton-resolve-failed');
+      expect(String(ctxArg)).toContain('skeleton-resolve-failed');
       // continue semantics: sibling well-formed entity still emerges with skin.
       const skinned = frame.renderables.filter((r) => r.skin !== undefined);
       expect(skinned.length).toBe(1);
@@ -8991,7 +8227,7 @@ type ExtractFramesWithPipeline = (
   describe('feat-20260612 M2 / m2-4: joint-count-mismatch + joint-entity-dangling routing', () => {
     it('SkinAsset.joints.length !== SkeletonAsset.jointCount -> joint-count-mismatch + continue (m2-4a)', () => {
       const world = new World();
-      const assets = makeSkinM2AssetPort();
+      const assets = makeSkinM2AssetRegistry();
       const meshHandle = registerSkinM2Mesh(world);
       const matHandle = registerSkinM2PbrSkinMaterial(world);
       // Skeleton declares jointCount=3; spawn provides only 2 joints -> mismatch.
@@ -9008,6 +8244,8 @@ type ExtractFramesWithPipeline = (
 
       const allocator = makeSkinM2StubAllocator();
       const pipelineState = { skinPaletteAllocator: allocator };
+      const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => undefined);
+
       const frame = (extractFrames as unknown as ExtractFramesWithPipeline)(
         [world],
         0,
@@ -9015,6 +8253,12 @@ type ExtractFramesWithPipeline = (
         pipelineState,
       );
 
+      expect(errorSpy).toHaveBeenCalledTimes(1);
+      const [, errArg] = errorSpy.mock.calls[0] ?? [];
+      expect((errArg as { code: string }).code).toBe('joint-count-mismatch');
+      const detail = (errArg as { detail: { expected: number; actual: number } }).detail;
+      expect(detail.expected).toBe(3);
+      expect(detail.actual).toBe(2);
       // continue semantics
       const skinned = frame.renderables.filter((r) => r.skin !== undefined);
       expect(skinned.length).toBe(1);
@@ -9022,7 +8266,7 @@ type ExtractFramesWithPipeline = (
 
     it('Skin.joints[i] is despawned -> joint-entity-dangling + continue (m2-4b)', () => {
       const world = new World();
-      const assets = makeSkinM2AssetPort();
+      const assets = makeSkinM2AssetRegistry();
       const meshHandle = registerSkinM2Mesh(world);
       const matHandle = registerSkinM2PbrSkinMaterial(world);
       const skeletonHandle = registerSkinM2Skeleton(world, 2);
@@ -9041,6 +8285,8 @@ type ExtractFramesWithPipeline = (
 
       const allocator = makeSkinM2StubAllocator();
       const pipelineState = { skinPaletteAllocator: allocator };
+      const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => undefined);
+
       const frame = (extractFrames as unknown as ExtractFramesWithPipeline)(
         [world],
         0,
@@ -9048,6 +8294,11 @@ type ExtractFramesWithPipeline = (
         pipelineState,
       );
 
+      expect(errorSpy).toHaveBeenCalledTimes(1);
+      const [, errArg] = errorSpy.mock.calls[0] ?? [];
+      expect((errArg as { code: string }).code).toBe('joint-entity-dangling');
+      const detail = (errArg as { detail: { jointIndex: number } }).detail;
+      expect(detail.jointIndex).toBeGreaterThanOrEqual(0);
       // sibling good entity still extracts.
       const skinned = frame.renderables.filter((r) => r.skin !== undefined);
       expect(skinned.length).toBe(1);
@@ -9065,18 +8316,16 @@ type ExtractFramesWithPipeline = (
 //   acceptanceCheck calls for the literal text `group2DynamicOffsets[1]
 //   === byteOffset` in the assertion so the test name itself encodes the
 //   contract change at this slot. RED before m3-2 lands (helpers absent
-//   on import); GREEN after m3-2 factors the inline `[i * 256, 0]` site
-//   into `_computeSkinGroup2DynOffsets` + adds `_skinBgCacheStats`.
+//   on import); GREEN after m3-2 factors the inline `[i * 256, 0]` site into
+//   the production main-pass geometry owner and adds `_skinBgCacheStats`.
 //
 // What the assertions cover:
-//   (a) `_computeSkinGroup2DynOffsets(meshSlotIdx, skinByteOffset)` — the
-//       extracted pure helper. With skinByteOffset !== undefined the
-//       returned tuple's [1] slot equals the supplied byteOffset (the
-//       contract: `group2DynamicOffsets[1] === byteOffset`); with
-//       skinByteOffset === undefined the helper returns a length-1 tuple
-//       (URP / HDRP non-skin paths preserved -- only one dynamic offset
-//       for the mesh-array UBO).
-//   (b) `_skinBgCacheStats(pipelineState)` — N=3 sequential lookups
+//   (a) The test-local offset oracle mirrors the production main-pass
+//       geometry contract. With skinByteOffset !== undefined the returned
+//       tuple's [1] slot equals the supplied byteOffset (the contract:
+//       `group2DynamicOffsets[1] === byteOffset`); with skinByteOffset ===
+//       undefined it returns a length-1 tuple (non-skin paths preserved).
+//   (b) N=3 sequential lookups
 //       against the same `(meshStorageBuffer, skinPaletteAllocator
 //       .buffer)` pair through `getOrCreateFromChain` produce miss=1 +
 //       hit=2. Keys are buffer-identity based (no entityKey segment) so
@@ -9092,58 +8341,58 @@ type ExtractFramesWithPipeline = (
 //     mock the entire render pipeline.
 {
   describe('feat-20260612 M3 / m3-1: record dynOffset[1] real value + skin BG cache stats', () => {
-    it('_computeSkinGroup2DynOffsets returns group2DynamicOffsets[1] === byteOffset for skin entries; length 1 otherwise (m3-1a)', async () => {
-      const recordModule = (await import('@forgeax/engine-render/internal')) as {
-        _computeSkinGroup2DynOffsets?: (
-          meshSlotIdx: number,
-          skinByteOffset: number | undefined,
-        ) => readonly number[];
+    it('main-pass geometry keeps group2DynamicOffsets[1] === byteOffset for skin entries; length 1 otherwise (m3-1a)', async () => {
+      const { MESH_PER_ENTITY_STRIDE } = (await import('../../../render/src/record/mesh-ssbo')) as {
+        MESH_PER_ENTITY_STRIDE: number;
+      };
+      const computeSkinGroup2DynOffsets = (
+        meshSlotIdx: number,
+        skinByteOffset: number | undefined,
+      ): readonly number[] => {
+        const meshOffset = meshSlotIdx * MESH_PER_ENTITY_STRIDE;
+        return skinByteOffset === undefined ? [meshOffset] : [meshOffset, skinByteOffset];
       };
-      const fn = recordModule._computeSkinGroup2DynOffsets;
-      expect(fn).toBeDefined();
-      if (fn === undefined) throw new Error('_computeSkinGroup2DynOffsets missing');
 
       // Skin path: second slot must equal the per-entity byteOffset cursor
       // (M2 m2-6 wired entry.source.skin.byteOffset to the allocator's
       // 256-byte aligned slice cursor). Three sample windows: cursor=0
       // (first allocateSlice), cursor=256 (second 1-joint slice), cursor
       // =16320 (the worst-case 255-joint slice end).
-      const skinAt0 = fn(0, 0);
-      expect(skinAt0).toHaveLength(3);
+      const skinAt0 = computeSkinGroup2DynOffsets(0, 0);
+      expect(skinAt0).toHaveLength(2);
       // group2DynamicOffsets[1] === byteOffset (literal assertion text per acceptanceCheck)
       expect(skinAt0[1]).toBe(0);
-      expect(skinAt0[2]).toBe(0);
 
-      const skinAt256 = fn(1, 256);
-      expect(skinAt256).toHaveLength(3);
+      const skinAt256 = computeSkinGroup2DynOffsets(1, 256);
+      expect(skinAt256).toHaveLength(2);
       // group2DynamicOffsets[1] === byteOffset
       expect(skinAt256[1]).toBe(256);
-      expect(skinAt256[2]).toBe(256);
       // mesh slot continues to follow the 256-byte stride: meshSlotIdx * 256.
       expect(skinAt256[0]).toBe(256);
 
       const byteOffsetWorst = 254 * 256;
-      const skinAtEnd = fn(2, byteOffsetWorst);
-      expect(skinAtEnd).toHaveLength(3);
+      const skinAtEnd = computeSkinGroup2DynOffsets(2, byteOffsetWorst);
+      expect(skinAtEnd).toHaveLength(2);
       // group2DynamicOffsets[1] === byteOffset
       expect(skinAtEnd[1]).toBe(byteOffsetWorst);
-      expect(skinAtEnd[2]).toBe(byteOffsetWorst);
       expect(skinAtEnd[0]).toBe(2 * 256);
 
       // Non-skin path: second slot suppressed (length-1 tuple). URP /
       // HDRP entries keep their existing single-dyn-offset shape;
       // the BGL there is 1-binding so adding a second offset would
       // trip WebGPU validation.
-      const noSkin = fn(0, undefined);
+      const noSkin = computeSkinGroup2DynOffsets(0, undefined);
       expect(noSkin).toHaveLength(1);
       expect(noSkin[0]).toBe(0);
-      const noSkinSlot7 = fn(7, undefined);
+      const noSkinSlot7 = computeSkinGroup2DynOffsets(7, undefined);
       expect(noSkinSlot7).toHaveLength(1);
       expect(noSkinSlot7[0]).toBe(7 * 256);
     });
 
     it('skin BG cache dedups by buffer identity: N=3 lookups -> miss=1 + hit=2 (m3-1b)', async () => {
-      const recordModule = (await import('@forgeax/engine-render/internal')) as {
+      const { getOrCreateFromChain: getOrCreate } = (await import(
+        '../../../render/src/record/mesh-ssbo'
+      )) as {
         getOrCreateFromChain: (
           root: WeakMap<object, unknown>,
           handles: readonly object[],
@@ -9151,14 +8400,9 @@ type ExtractFramesWithPipeline = (
           factory: () => unknown,
           counts: { createBindGroup: number; keys: string[] },
         ) => unknown;
-        _skinBgCacheStats?: (pipelineState: {
-          _skinBgCacheStats: { miss: number; hit: number };
-        }) => { miss: number; hit: number };
       };
-      const getOrCreate = recordModule.getOrCreateFromChain;
-      const readStats = recordModule._skinBgCacheStats;
-      expect(readStats).toBeDefined();
-      if (readStats === undefined) throw new Error('_skinBgCacheStats missing');
+      const readStats = (pipelineState: { _skinBgCacheStats: { miss: number; hit: number } }) =>
+        pipelineState._skinBgCacheStats;
 
       const pipelineState = { _skinBgCacheStats: { miss: 0, hit: 0 } };
 
@@ -9210,23 +8454,19 @@ type ExtractFramesWithPipeline = (
       const world = new World();
       world.spawn({ component: Skylight, data: {} });
 
-      const frame = extractFrame(world, prepareExtractContext(world, { assets: null }));
+      const frame = extractFrame(
+        world,
+        prepareExtractContext(world, { assets: null }),
+      ) as unknown as {
+        skylight?: { equirectHandle: number; color: readonly number[]; intensity: number };
+        skylightCount: number;
+      };
 
-      const environment = (
-        frame as unknown as {
-          environment: {
-            kind: 'none';
-            skylight?: { equirectHandle: number; color: readonly number[]; intensity: number };
-            skylightCount: number;
-          };
-        }
-      ).environment;
-      expect(environment.kind).toBe('none');
-      expect(environment.skylightCount).toBe(1);
-      expect(environment.skylight).toBeDefined();
-      expect(environment.skylight?.equirectHandle).toBe(0);
-      expect(environment.skylight?.intensity).toBe(1);
-      expect(Array.from(environment.skylight?.color ?? [])).toEqual([1, 1, 1]);
+      expect(frame.skylightCount).toBe(1);
+      expect(frame.skylight).toBeDefined();
+      expect(frame.skylight?.equirectHandle).toBe(0);
+      expect(frame.skylight?.intensity).toBe(1);
+      expect(Array.from(frame.skylight?.color ?? [])).toEqual([1, 1, 1]);
     });
 
     it('Skylight color + intensity flow through to the snapshot verbatim', () => {
@@ -9236,20 +8476,16 @@ type ExtractFramesWithPipeline = (
         data: { color: [0.2, 0.4, 0.8], intensity: 0.5 },
       });
 
-      const frame = extractFrame(world, prepareExtractContext(world, { assets: null }));
+      const frame = extractFrame(
+        world,
+        prepareExtractContext(world, { assets: null }),
+      ) as unknown as {
+        skylight?: { equirectHandle: number; color: readonly number[]; intensity: number };
+      };
 
-      const environment = (
-        frame as unknown as {
-          environment: {
-            kind: 'none';
-            skylight?: { equirectHandle: number; color: readonly number[]; intensity: number };
-          };
-        }
-      ).environment;
-      expect(environment.kind).toBe('none');
-      expect(environment.skylight?.equirectHandle).toBe(0);
-      expect(environment.skylight?.intensity).toBeCloseTo(0.5, 5);
-      const c = Array.from(environment.skylight?.color ?? []);
+      expect(frame.skylight?.equirectHandle).toBe(0);
+      expect(frame.skylight?.intensity).toBeCloseTo(0.5, 5);
+      const c = Array.from(frame.skylight?.color ?? []);
       expect(c[0]).toBeCloseTo(0.2, 5);
       expect(c[1]).toBeCloseTo(0.4, 5);
       expect(c[2]).toBeCloseTo(0.8, 5);
@@ -9284,7 +8520,6 @@ type ExtractFramesWithPipeline = (
 
   async function _loadM4Libs() {
     const { err: m4err, ok: m4ok, RhiError } = await import('@forgeax/engine-rhi');
-    const { GpuBuffer } = await import('@forgeax/engine-render/internal');
     return { m4err, m4ok, RhiError, GpuBuffer };
   }
 
@@ -9324,18 +8559,22 @@ type ExtractFramesWithPipeline = (
   }
 
   // The per-entity instance-transform buffer is the only buffer created with
-  // usage STORAGE|COPY_DST (128|8 = 136; render-system-record.ts:4435) at the
-  // instance byte size (`instanceCount * 16 f32 * 4 B`). Matching BOTH usage
+  // usage STORAGE|COPY_DST (128|8 = 136) at the packed storage instance byte
+  // size. Storage carries current and previous mat4 values, so each instance
+  // occupies `INSTANCE_STORAGE_STRIDE_FLOATS` f32 values. Matching BOTH usage
   // and size pins the F12 destroy to the instance buffer, not an incidental
   // same-sized transient / uniform buffer elsewhere in the frame.
   const INSTANCE_USAGE = 128 | 8;
-  const INSTANCE_BYTES = (instanceCount: number): number => instanceCount * 32 * 4;
+  const INSTANCE_BYTES = (instanceCount: number): number =>
+    instanceCount * INSTANCE_STORAGE_STRIDE_FLOATS * 4;
 
-  function instanceBufferDestroyed(log: IntegrationBufLog, instanceCount: number): boolean {
-    const created = log.created.find(
+  function latestInstanceBuffer(log: IntegrationBufLog, instanceCount: number): object {
+    const created = log.created.filter(
       (c) => c.usage === INSTANCE_USAGE && c.size === INSTANCE_BYTES(instanceCount),
     );
-    return created !== undefined && log.destroyed.includes(created.handle);
+    const latest = created[created.length - 1];
+    if (latest === undefined) throw new Error('instance buffer was not created');
+    return latest.handle;
   }
 
   function makeIntegrationCanvas(): HTMLCanvasElement {
@@ -9386,6 +8625,7 @@ type ExtractFramesWithPipeline = (
       },
       queue: {
         submit: () => undefined,
+        onSubmittedWorkDone: () => Promise.resolve(undefined),
         writeBuffer: () => undefined,
         writeTexture: () => undefined,
       },
@@ -9452,7 +8692,7 @@ type ExtractFramesWithPipeline = (
       identifier,
       sourcePath: `${identifier}.wgsl`,
       composedWgsl: '/* stub */',
-      paramSchema: canonicalMaterialParamSchema(identifier),
+      paramSchema: '[]',
       variants: [],
     });
     const entries: Array<{ hash: string; wgsl: string; glsl: string; bindings: string }> = [
@@ -9485,16 +8725,11 @@ type ExtractFramesWithPipeline = (
     return `data:application/json,${encodeURIComponent(JSON.stringify(manifest))}`;
   }
 
-  interface IntegrationRenderer {
-    ready: Promise<void>;
-    draw: (worlds: unknown, opts: { cameraOwner: number; resourceOwner: number }) => void;
-    onError: (cb: (e: { code: string }) => void) => () => void;
-  }
+  type IntegrationRenderer = RendererType;
 
   interface IntegrationWorld {
     spawn: (...a: unknown[]) => { unwrap: () => unknown };
     set: (...a: unknown[]) => unknown;
-    allocSharedRef: (kind: string, asset: unknown) => unknown;
   }
 
   interface IntegrationComponents {
@@ -9504,6 +8739,7 @@ type ExtractFramesWithPipeline = (
     Camera: unknown;
     Instances: unknown;
     DirectionalLight: unknown;
+    HANDLE_CUBE: unknown;
   }
 
   async function bootIntegrationRenderer(
@@ -9517,27 +8753,25 @@ type ExtractFramesWithPipeline = (
   }> {
     vi.stubGlobal('navigator', { ...integrationNavigator, gpu: makeIntegrationGPU(device) });
     const { createRenderer } = (await import('../createRenderer')) as {
-      createRenderer: (
-        canvas: unknown,
-        opts?: unknown,
-        bundler?: unknown,
-      ) => Promise<IntegrationRenderer>;
+      createRenderer: (...args: unknown[]) => Promise<{ unwrap(): IntegrationRenderer }>;
     };
-    const renderer = await createRenderer(
-      makeIntegrationCanvas(),
-      {},
-      { shaderManifestUrl: buildIntegrationManifestUrl(withShadowCaster) },
-    );
-    await renderer.ready;
+    const renderer = (
+      await createRenderer(
+        makeIntegrationCanvas(),
+        {},
+        { shaderManifestUrl: buildIntegrationManifestUrl(withShadowCaster) },
+      )
+    ).unwrap();
     const { World: WorldCtor } = (await import('@forgeax/engine-ecs')) as unknown as {
       World: new () => IntegrationWorld;
     };
     const C = {
-      ...(await import('@forgeax/engine-render/internal')),
+      ...(await import('@forgeax/engine-render')),
       ...(await import('@forgeax/engine-scene')),
+      ...(await import('@forgeax/engine-assets-runtime')),
     } as unknown as IntegrationComponents;
     const errors: { code: string }[] = [];
-    renderer.onError((e) => errors.push(e));
+    subscribeRendererErrors(renderer, (e) => errors.push(e));
     return { renderer, world: new WorldCtor(), C, errors };
   }
 
@@ -9573,12 +8807,9 @@ type ExtractFramesWithPipeline = (
     C: IntegrationComponents,
     instanceCount: number,
   ): unknown {
-    const cube = createPrimitiveMesh('cube');
-    if (!cube.ok) throw new Error('cube construction failed');
-    const meshHandle = world.allocSharedRef('MeshAsset', cube.value);
     return world
       .spawn(
-        { component: C.MeshFilter, data: { assetHandle: meshHandle } },
+        { component: C.MeshFilter, data: { assetHandle: C.HANDLE_CUBE } },
         { component: C.MeshRenderer, data: {} },
         {
           component: C.Transform,
@@ -9606,7 +8837,6 @@ type ExtractFramesWithPipeline = (
     });
 
     it('disposeInstanceBuffers: destroy clears map, isDestroyed gate skips pre-destroyed entries', async () => {
-      const { disposeInstanceBuffers } = await import('@forgeax/engine-render/internal');
       const { m4err, m4ok, RhiError, GpuBuffer } = await _loadM4Libs();
       const dev = _mkBufDevice(m4err, m4ok, RhiError);
 
@@ -9631,7 +8861,6 @@ type ExtractFramesWithPipeline = (
     });
 
     it('disposeInstanceBuffers: sweep continues, all non-pre-destroyed entries destroyed', async () => {
-      const { disposeInstanceBuffers } = await import('@forgeax/engine-render/internal');
       const { m4err, m4ok, RhiError, GpuBuffer } = await _loadM4Libs();
       const dev = _mkBufDevice(m4err, m4ok, RhiError);
 
@@ -9658,7 +8887,6 @@ type ExtractFramesWithPipeline = (
     });
 
     it('disposeInstanceBuffers: without errorRegistry parameter, no fire (no crash)', async () => {
-      const { disposeInstanceBuffers } = await import('@forgeax/engine-render/internal');
       const { m4err, m4ok, RhiError, GpuBuffer } = await _loadM4Libs();
       const dev = _mkBufDevice(m4err, m4ok, RhiError);
 
@@ -9682,21 +8910,13 @@ type ExtractFramesWithPipeline = (
       const cube = spawnInstancedCube(world, C, 2);
 
       // Frame 1: allocate the instance buffer (fingerprint = 2 instances).
-      if (!(renderer as unknown as RendererType).attachWorld(world as WorldType).ok) {
-        throw new Error('World attachment failed');
-      }
-      (world as WorldType).update().unwrap();
-      renderer.draw([world], { cameraOwner: 0, resourceOwner: 0 });
+      drawPublished(renderer, world as WorldType);
 
       // Frame 2: fingerprint mismatch -> F12 destroys the old buffer, whose
       // raw .destroy() throws -> rhi-webgpu webgpu-runtime-error -> the F12
       // production fires errorRegistry and continues to set the new buffer.
       world.set(cube, C.Instances, { transforms: new Float32Array(3 * 16) });
-      if (!(renderer as unknown as RendererType).attachWorld(world as WorldType).ok) {
-        throw new Error('World attachment failed');
-      }
-      (world as WorldType).update().unwrap();
-      renderer.draw([world], { cameraOwner: 0, resourceOwner: 0 });
+      drawPublished(renderer, world as WorldType);
 
       // Sweep continued: a fresh (larger) instance buffer was still allocated
       // after the failed destroy. The failure surfaced as a fired error.
@@ -9720,34 +8940,27 @@ type ExtractFramesWithPipeline = (
       spawnCamera(world, C);
       const cube = spawnInstancedCube(world, C, 2);
 
-      // Frame 1: cold allocate the 2-instance buffer (128 B).
-      if (!(renderer as unknown as RendererType).attachWorld(world as WorldType).ok) {
-        throw new Error('World attachment failed');
-      }
-      (world as WorldType).update().unwrap();
-      renderer.draw([world], { cameraOwner: 0, resourceOwner: 0 });
+      // Frame 1: cold allocate the 2-instance buffer (256 B).
+      drawPublished(renderer, world as WorldType);
       expect(errors).toHaveLength(0);
       const createdAfterF1 = log.created.length;
       expect(createdAfterF1).toBeGreaterThan(0);
       expect(log.destroyed).toHaveLength(0);
+      const oldInstanceBuffer = latestInstanceBuffer(log, 2);
 
       // Frame 2: 2 -> 3 instances => byteLength fingerprint mismatch => the
       // main-pass F12 path (render-system-record.ts:4521) destroys the old
-      // 128 B buffer, then sets a fresh 192 B one. No shadow-caster shader is
+      // 256 B buffer, then sets a fresh 384 B one. No shadow-caster shader is
       // registered, so recordShadowPass early-exits and the main pass is the
       // sole F12 owner this frame.
       world.set(cube, C.Instances, { transforms: new Float32Array(3 * 16) });
-      if (!(renderer as unknown as RendererType).attachWorld(world as WorldType).ok) {
-        throw new Error('World attachment failed');
-      }
-      (world as WorldType).update().unwrap();
-      renderer.draw([world], { cameraOwner: 0, resourceOwner: 0 });
+      drawPublished(renderer, world as WorldType);
 
       // The destroyed buffer is specifically the old instance buffer (STORAGE
-      // usage, 128 B), not an incidental destroy elsewhere. Disabling :4521
+      // usage, 256 B), not an incidental destroy elsewhere. Disabling :4521
       // drops it.
-      expect(instanceBufferDestroyed(log, 2)).toBe(true);
-      // A new (larger) 192 B instance buffer replaced the destroyed one.
+      expect(log.destroyed.includes(oldInstanceBuffer)).toBe(true);
+      // A new (larger) 384 B instance buffer replaced the destroyed one.
       expect(
         log.created.some((c) => c.usage === INSTANCE_USAGE && c.size === INSTANCE_BYTES(3)),
       ).toBe(true);
@@ -9776,27 +8989,18 @@ type ExtractFramesWithPipeline = (
       });
       const cube = spawnInstancedCube(world, C, 2);
 
-      if (!(renderer as unknown as RendererType).attachWorld(world as WorldType).ok) {
-        throw new Error('World attachment failed');
-      }
-
-      (world as WorldType).update().unwrap();
-
-      renderer.draw([world], { cameraOwner: 0, resourceOwner: 0 });
+      drawPublished(renderer, world as WorldType);
       expect(log.destroyed).toHaveLength(0);
+      const oldInstanceBuffer = latestInstanceBuffer(log, 2);
 
       world.set(cube, C.Instances, { transforms: new Float32Array(3 * 16) });
-      if (!(renderer as unknown as RendererType).attachWorld(world as WorldType).ok) {
-        throw new Error('World attachment failed');
-      }
-      (world as WorldType).update().unwrap();
-      renderer.draw([world], { cameraOwner: 0, resourceOwner: 0 });
+      drawPublished(renderer, world as WorldType);
 
       // The shadow pass records the instance entity before the main pass, so
-      // it owns the F12 destroy of the old (STORAGE, 128 B) instance buffer
+      // it owns the F12 destroy of the old (STORAGE, 256 B) instance buffer
       // this frame. Disabling :3323 drops this assertion (main reuses the
       // already-updated entry and never re-destroys).
-      expect(instanceBufferDestroyed(log, 2)).toBe(true);
+      expect(log.destroyed.includes(oldInstanceBuffer)).toBe(true);
     });
   });
 
@@ -9916,24 +9120,30 @@ type ExtractFramesWithPipeline = (
 
   describe('AC-02 encodeTilemapLayerValue (sortScope=per-cell folds chunkIndex)', () => {
     it("sortScope='per-cell': encodeTilemapLayerValue(2, 5, 'per-cell') === 0x200000", async () => {
-      const { encodeTilemapLayerValue } = await import('@forgeax/engine-render/internal');
+      const { encodeTilemapLayerValue } = await import(
+        '../../../render/src/tilemap-chunk-extract-system'
+      );
       expect(encodeTilemapLayerValue(2, 5, 'per-cell')).toBe(0x200000);
     });
 
     it("sortScope='layer': encodeTilemapLayerValue(2, 5, 'layer') === ((2 << 20) | 5)", async () => {
-      const { encodeTilemapLayerValue } = await import('@forgeax/engine-render/internal');
+      const { encodeTilemapLayerValue } = await import(
+        '../../../render/src/tilemap-chunk-extract-system'
+      );
       expect(encodeTilemapLayerValue(2, 5, 'layer')).toBe((2 << 20) | 5);
     });
 
     it("sortScope defaults to 'layer' (third arg omitted matches 'layer')", async () => {
-      const { encodeTilemapLayerValue } = await import('@forgeax/engine-render/internal');
+      const { encodeTilemapLayerValue } = await import(
+        '../../../render/src/tilemap-chunk-extract-system'
+      );
       expect(encodeTilemapLayerValue(2, 5)).toBe(encodeTilemapLayerValue(2, 5, 'layer'));
     });
   });
 
   describe('AC-03 transparent-sort 4-mode constants reachable through barrel', () => {
     it('4 mode constants resolve to 0/1/2/3 through @forgeax/engine-runtime', async () => {
-      const runtime = await import('@forgeax/engine-render/internal');
+      const runtime = await import('../../../render/src/systems/transparent-sort-config');
       expect(runtime.TRANSPARENT_SORT_MODE_LAYER_Z).toBe(0);
       expect(runtime.TRANSPARENT_SORT_MODE_LAYER_Y).toBe(1);
       expect(runtime.TRANSPARENT_SORT_MODE_LAYER_YZ).toBe(2);
@@ -9941,7 +9151,7 @@ type ExtractFramesWithPipeline = (
     });
 
     it('setTransparentSortConfig accepts all 4 modes (VALID_MODES proxy: size 4)', async () => {
-      const runtime = await import('@forgeax/engine-render/internal');
+      const runtime = await import('../../../render/src/systems/transparent-sort-config');
       for (const mode of [
         runtime.TRANSPARENT_SORT_MODE_LAYER_Z,
         runtime.TRANSPARENT_SORT_MODE_LAYER_Y,