@forgeax/engine-runtime 0.1.4 → 0.1.7

package/src/__tests__/video-loader-consumption.test.ts

@@ -0,0 +1,86 @@
+// feat-20260623-world-space-video-asset M2 / w3 — AC-02: VideoAsset
+// consumption-path type inference in a real unit test (not just test-d).
+//
+// AC-02 (requirements.md:76-78): `const v = await registry.loadByGuid<VideoAsset>(guid)`
+// must return a VideoAsset where `v.url` is inferable as `string` without
+// an `as` cast. `switch (asset.kind)` must narrow to VideoAsset on
+// `case 'video'` with TypeScript exhaustiveness.
+//
+// Pattern: host-custom-kind-contract.test.ts:38-75 (loadByGuid<P> + no as cast).
+// This is the TDD test for M2 — it verifies the consumption path works
+// with catalogued payloads (dev path). The prod (pack-index) path is
+// enabled by videoLoader in w4.
+//
+// Structural variant (b) from video-asset-union.test-d.ts moved into a real
+// unit so the consumption path is exercised with a concrete AssetRegistry,
+// not just a *.test-d.ts compile-only check.
+
+import { AssetRegistry } from '@forgeax/engine-assets-runtime';
+import { AssetGuid } from '@forgeax/engine-pack/guid';
+import type { Asset, VideoAsset } from '@forgeax/engine-types';
+import { describe, expect, it } from 'vitest';
+import { makeMockShaderRegistry } from './helpers/mock-shader-registry';
+
+function parseGuid(s: string): AssetGuid {
+  const r = AssetGuid.parse(s);
+  if (!r.ok) throw new Error(`invalid test GUID: ${s}`);
+  return r.value;
+}
+
+function makeRegistry(): AssetRegistry {
+  return new AssetRegistry(makeMockShaderRegistry());
+}
+
+describe('AC-02 — VideoAsset consumption path type inference (real unit)', () => {
+  it('loadByGuid<VideoAsset> returns payload with .url inferable as string, no as cast', async () => {
+    const reg = makeRegistry();
+
+    const guid = parseGuid('c0000000-0000-4000-a000-00000000a001');
+    const video: VideoAsset = { kind: 'video', url: 'test-clip.webm' };
+
+    reg.catalog(guid, video);
+
+    // loadByGuid<VideoAsset> returns Result<VideoAsset, ...>.
+    // v.url is inferable as string without any `as VideoAsset` cast.
+    const loadResult = await reg.loadByGuid<VideoAsset>(guid);
+    expect(loadResult.ok).toBe(true);
+    if (!loadResult.ok) throw new Error('unreachable');
+    const v = loadResult.value;
+    // Type inference: v.url is string; no `as` cast needed.
+    expect(v.url).toBe('test-clip.webm');
+    expect(v.kind).toBe('video');
+  });
+
+  it('switch(asset.kind) narrows to VideoAsset on case "video"', () => {
+    // The Asset union (15 members) includes VideoAsset per M1/w2.
+    // TS strict + exhaustive switch ensures this compiles only if
+    // 'video' is a recognised discriminant that narrows to VideoAsset.
+    const asset: Asset = { kind: 'video', url: 'switch-test.webm' };
+    switch (asset.kind) {
+      case 'video':
+        // Narrowed to VideoAsset — .url is string, no `as`.
+        expect(asset.url).toBe('switch-test.webm');
+        break;
+      default:
+        // TS exhaustiveness: the 14 other Asset.kind discriminants
+        // are covered by this branch; the switch would fail to compile
+        // if 'video' were absent from the union.
+        break;
+    }
+  });
+
+  it('registry.lookup<VideoAsset> returns catalogued payload with .url accessible', () => {
+    const reg = makeRegistry();
+
+    const guid = parseGuid('c0000000-0000-4000-a000-00000000a002');
+    const video: VideoAsset = { kind: 'video', url: 'lookup-test.webm' };
+
+    reg.catalog(guid, video);
+    const v = reg.lookup<VideoAsset>(guid);
+    expect(v).toBeDefined();
+    // biome-ignore lint/style/noNonNullAssertion: asserted above
+    expect(v!.url).toBe('lookup-test.webm');
+    // biome-ignore lint/style/noNonNullAssertion: asserted above
+    expect(v!.kind).toBe('video');
+  });
+});

package/src/__tests__/video-loader-smoke.dawn.test.ts

@@ -0,0 +1,60 @@
+// feat-20260623-world-space-video-asset M2 / w5 — AC-03: dawn structural
+// smoke for the VideoAsset register + loadByGuid link.
+//
+// AC-03 (requirements.md): register a VideoAsset { url } via catalog,
+// loadByGuid<VideoAsset> returns the payload successfully, process exit
+// code 0. Structural-only — dawn-node has no HTMLVideoElement, so no
+// pixel verification (plan-strategy S5.2).
+//
+// The default loader set (wireDefaultLoaders) already includes videoLoader
+// (w4), so the AssetRegistry's built-in loaders field dispatches 'video'
+// kind through videoLoader without manual registration.
+
+import { AssetRegistry } from '@forgeax/engine-assets-runtime';
+import { AssetGuid } from '@forgeax/engine-pack/guid';
+import type { VideoAsset } from '@forgeax/engine-types';
+import { describe, expect, it } from 'vitest';
+import { makeMockShaderRegistry } from './helpers/mock-shader-registry';
+
+const GUID_SMOKE_A = '00000000-0000-7000-8000-00000000a010';
+
+function parseGuid(s: string): AssetGuid {
+  const r = AssetGuid.parse(s);
+  if (!r.ok) throw new Error(`invalid test GUID: ${s}`);
+  return r.value;
+}
+
+describe('AC-03 — VideoAsset register + loadByGuid dawn structural smoke', () => {
+  it('catalog + loadByGuid<VideoAsset> round-trips payload in dawn context', async () => {
+    const reg = new AssetRegistry(makeMockShaderRegistry());
+
+    const guid = parseGuid(GUID_SMOKE_A);
+    const video: VideoAsset = { kind: 'video', url: 'test-clip.webm' };
+
+    reg.catalog(guid, video);
+
+    const result = await reg.loadByGuid<VideoAsset>(guid);
+    expect(result.ok).toBe(true);
+    if (!result.ok) throw new Error('expected ok');
+    expect(result.value.url).toBe('test-clip.webm');
+    expect(result.value.kind).toBe('video');
+  });
+
+  it('loadByGuid succeeds when videoLoader dispatches through default loader set', async () => {
+    // The AssetRegistry constructor wires the default loader set via
+    // createDefaultLoaderRegistry(), which includes videoLoader (w4).
+    // This test verifies the dispatch path works without manual
+    // registry.loaders.register(videoLoader).
+    const reg = new AssetRegistry(makeMockShaderRegistry());
+
+    // Confirm 'video' is in the registered kinds.
+    expect(reg.loaders.registeredKinds()).toContain('video');
+    expect(reg.loaders.get('video')).toBeDefined();
+
+    const guid = parseGuid('00000000-0000-7000-8000-00000000a011');
+    reg.catalog(guid, { kind: 'video', url: 'loader-dispatch.webm' } as VideoAsset);
+
+    const result = await reg.loadByGuid<VideoAsset>(guid);
+    expect(result.ok).toBe(true);
+  });
+});

package/src/__tests__/view-ubo-layout.browser.test.ts

@@ -31,10 +31,6 @@
 // (w15, AC-12 / AC-14); this gate locks the byte layout itself.
 
 import { describe, expect, it } from 'vitest';
-// @ts-expect-error Vite provides raw text imports to the browser test runner.
-import viewUboSource from '../../../render/src/record/view-ubo.ts?raw';
-// @ts-expect-error Vite provides raw text imports to the browser test runner.
-import commonViewSource from '../../../shader/src/common.wgsl?raw';
 
 const browserReady = typeof navigator !== 'undefined' && navigator.gpu !== undefined;
 
@@ -163,21 +159,3 @@ describe('w4 view UBO 240 B std140 layout (AC-06, browser)', () => {
     },
   );
 });
-
-describe('Fog View ABI transport (M2)', () => {
-  it('host payload grows beyond the stale 784 B prefix and carries Fog facts', async () => {
-    const source = await viewUboSource;
-    expect(source).toContain('VIEW_PAYLOAD_FLOATS = 240');
-    expect(source).toContain('heightFalloff');
-    expect(source).toContain('maxOpacity');
-    expect(source).not.toContain('VIEW_PAYLOAD_FLOATS = 196');
-  });
-
-  it('shader View carries Fog in the existing uniform binding', async () => {
-    const [viewSource, commonSource] = await Promise.all([viewUboSource, commonViewSource]);
-    expect(viewSource).toContain('viewPayload[232]');
-    expect(commonSource).toContain('fog                 : FogViewParams');
-    expect(commonSource).toContain('@group(0) @binding(0) var<uniform> view : View;');
-    expect(commonSource).not.toContain('@group(0) @binding(10)');
-  });
-});

package/src/__tests__/world-entity-key.test.ts

@@ -14,8 +14,8 @@
 //   plan-strategy D-1/D-9
 //   requirements AC-03
 
-import { worldEntityKey } from '@forgeax/engine-render/internal';
 import { describe, expect, it } from 'vitest';
+import { worldEntityKey } from '../../../render/src/record/frame-snapshot';
 
 describe('worldEntityKey', () => {
   // ── Identity: worldId=0 ──────────────────────────────────────────────────

package/src/__tests__/world-scene-despawn.test.ts

@@ -10,7 +10,7 @@
 //   - opts.keepDetached preserves members marked via detachSceneMember.
 
 import { World } from '@forgeax/engine-ecs';
-import { SceneInstance } from '@forgeax/engine-render/internal';
+import { SceneInstance } from '@forgeax/engine-render';
 import {
   ChildOf,
   Transform,

package/src/__tests__/world-scene-instantiate.test.ts

@@ -19,10 +19,9 @@
 // w23: perf — 100 entities x 5 components instantiates < 50ms (plan §5.4).
 
 import { defineComponent, World } from '@forgeax/engine-ecs';
-import { SceneInstance } from '@forgeax/engine-render/internal';
+import { SceneInstance } from '@forgeax/engine-render';
 import {
   ChildOf,
-  Children,
   Transform,
   worldGetSceneAssetForInstance,
   worldInstantiateScene,
@@ -35,7 +34,7 @@ function registerSceneAsset(
   asset: SceneAsset,
   extraComponents: readonly Parameters<World['components']['register']>[0][] = [],
 ): Handle<'SceneAsset', 'shared'> {
-  for (const component of [SceneInstance, ChildOf, Children, Transform, ...extraComponents]) {
+  for (const component of [SceneInstance, ChildOf, Transform, ...extraComponents]) {
     world.components.register(component).unwrap();
   }
   return world.allocSharedRef('SceneAsset', asset);
@@ -193,36 +192,3 @@ describe('world.instantiateScene perf (w23) — 100 entities x 5 components', ()
     expect(dt).toBeLessThan(50);
   });
 });
-
-describe('M2 direct Scene owner contract', () => {
-  it('keeps successful member materialization and diagnostics on the real World path', () => {
-    const world = new World();
-    const asset: SceneAsset = {
-      kind: 'scene',
-      entities: [{ localId: 0 as never, components: { Transform: {} } }],
-    };
-    const result = worldInstantiateScene(world, registerSceneAsset(world, asset));
-
-    expect(result.ok).toBe(true);
-    if (!result.ok) return;
-    expect(result.value.diagnostics).toEqual([]);
-    const instance = world.get(result.value.root, SceneInstance);
-    expect(instance.ok).toBe(true);
-    if (instance.ok) expect(instance.value.mapping.length).toBe(1);
-  });
-
-  it('rolls back a failed component lookup without a partial SceneInstance root', () => {
-    const world = new World();
-    const result = worldInstantiateScene(
-      world,
-      registerSceneAsset(world, {
-        kind: 'scene',
-        entities: [{ localId: 0 as never, components: { M2MissingComponent: { value: 3 } } }],
-      } as SceneAsset),
-    );
-
-    expect(result.ok).toBe(false);
-    const query = world.query({ read: [SceneInstance] });
-    expect(query.ok ? Array.from(query.value) : []).toHaveLength(0);
-  });
-});

package/src/__tests__/world-scene-nested.test.ts

@@ -16,7 +16,7 @@ import * as SceneOwner from '@forgeax/engine-scene';
 //     do not leak across mount instances)
 
 import { defineComponent, World } from '@forgeax/engine-ecs';
-import { SceneInstance } from '@forgeax/engine-render/internal';
+import { SceneInstance } from '@forgeax/engine-render';
 import { ChildOf } from '@forgeax/engine-scene';
 import type { Handle, SceneAsset } from '@forgeax/engine-types';
 import { err, ok } from '@forgeax/engine-types';

package/src/__tests__/world-scene-override.test.ts

@@ -16,7 +16,7 @@ import * as SceneOwner from '@forgeax/engine-scene';
 //     with detail.{ comp, field, expectedType, actualType }.
 
 import { defineComponent, World } from '@forgeax/engine-ecs';
-import { SceneInstance } from '@forgeax/engine-render/internal';
+import { SceneInstance } from '@forgeax/engine-render';
 import { Transform } from '@forgeax/engine-scene';
 import type { Handle, SceneAsset } from '@forgeax/engine-types';
 import { ok } from '@forgeax/engine-types';

package/src/backend-selection.ts

@@ -0,0 +1,69 @@
+import type { RendererOptions } from '@forgeax/engine-render';
+import type { RhiBackendPack } from '@forgeax/engine-render/internal/construct-renderer';
+import { err, ok, RhiError } from '@forgeax/engine-rhi';
+import * as rhiWebgpu from '@forgeax/engine-rhi-webgpu';
+
+export function loadRhiPack(
+  mod: Record<string, unknown>,
+  instrumentation?: RhiBackendPack['instrumentation'],
+): RhiBackendPack {
+  const rhi = mod.rhi as unknown as RhiBackendPack['rhi'];
+  const createShaderModule = mod.createShaderModule as
+    | RhiBackendPack['createShaderModule']
+    | undefined;
+  const translateErrorEventToRhiError = mod.translateErrorEventToRhiError as
+    | RhiBackendPack['translateErrorEventToRhiError']
+    | undefined;
+  const rawDeviceAccessor = mod._internal_getRawDevice as unknown as
+    | RhiBackendPack['_internal_getRawDevice']
+    | undefined;
+  const backendInstrumentation = mod.instrumentation as
+    | RhiBackendPack['instrumentation']
+    | undefined;
+  const pack: RhiBackendPack = {
+    rhi,
+    ...(createShaderModule === undefined ? {} : { createShaderModule }),
+    ...(translateErrorEventToRhiError === undefined ? {} : { translateErrorEventToRhiError }),
+    ...(rawDeviceAccessor === undefined ? {} : { _internal_getRawDevice: rawDeviceAccessor }),
+  };
+  const resolvedInstrumentation = instrumentation ?? backendInstrumentation;
+  return resolvedInstrumentation === undefined
+    ? pack
+    : { ...pack, instrumentation: resolvedInstrumentation };
+}
+
+/** Selects one backend pack; render receives only this typed owner contract. */
+export async function loadBackendPack(
+  options: RendererOptions | undefined,
+  preferWgpu = false,
+): Promise<
+  | { readonly ok: true; readonly value: RhiBackendPack }
+  | { readonly ok: false; readonly error: RhiError }
+> {
+  const explicit = options?.rhi;
+  if (explicit !== undefined && explicit !== null) {
+    return ok(loadRhiPack({ rhi: explicit, ...(explicit as object) }, options?.rhiInstrumentation));
+  }
+  const nav =
+    typeof globalThis === 'undefined'
+      ? undefined
+      : (globalThis as { navigator?: { gpu?: unknown } }).navigator;
+  if (!preferWgpu && nav?.gpu !== undefined && nav.gpu !== null) {
+    return ok(
+      loadRhiPack(rhiWebgpu as unknown as Record<string, unknown>, options?.rhiInstrumentation),
+    );
+  }
+  try {
+    const mod = (await import('@forgeax/engine-rhi-wgpu')) as Record<string, unknown>;
+    await (mod.ensureReady as () => Promise<unknown>)();
+    return ok(loadRhiPack(mod, options?.rhiInstrumentation));
+  } catch (cause) {
+    return err(
+      new RhiError({
+        code: 'rhi-not-available',
+        expected: 'a usable RHI backend is available',
+        hint: `failed to load wgpu backend: ${String(cause)}`,
+      }),
+    );
+  }
+}

package/src/collect-scene-asset.ts

@@ -24,7 +24,7 @@
 //   ── serialize mounts (M3) ──
 //   serializeSceneAssetToPack maps in-memory mounts[].source GUID strings to
 //   refs[] indices, memberFirst/memberCount/localId/parent numeric pass-through.
-//   the scene asset loader carries mounts through the reload
+//   _resolveSceneGuids (asset-registry.ts) carries mounts through the reload
 //   chain: recursively resolves child scene GUIDs, registers child copies in
 //   the origin reverse-index (D-7), and protects against mount-source cycles
 //   (R-9).  registry.instantiate wires an identity resolver so resolved mount
@@ -32,7 +32,7 @@
 //
 //   ── round-trip closure ──
 //   The round-trip instantiate -> collect (rootsToSceneAsset) -> serialize
-//   (serializeSceneAssetToPack) -> reload through the typed scene port
+//   (serializeSceneAssetToPack) -> reload (loadByGuid + registry.instantiate)
 //   -> instantiate produces a structurally equivalent live subtree (AC-04).
 //   The equivalence benchmark is a second collect (fixed-point): after the
 //   first reload, the second collect output equals the first (D-9 normalization
@@ -44,6 +44,12 @@
 //   proven to be a mount entity, components is left undefined (one-time
 //   normalization on first reload; fixed-point from second collect onward).
 
+import {
+  builtinMeshGuid,
+  resolveAssetHandle,
+  SceneCollectAssetGuidUnresolvedError,
+  SceneCollectEntityRefOutOfClosureError,
+} from '@forgeax/engine-assets-runtime';
 import {
   componentDefinition,
   type Component as EcsComponent,
@@ -52,9 +58,10 @@ import {
 } from '@forgeax/engine-ecs';
 import { classifyEntityField } from '@forgeax/engine-ecs/externalization';
 import { componentSchema } from '@forgeax/engine-ecs/internal';
-import { collectSubtree, SceneInstance } from '@forgeax/engine-render/internal';
+import { SceneInstance } from '@forgeax/engine-render';
 import { err, ok, type Result } from '@forgeax/engine-rhi';
 import {
+  collectSubtree,
   externalizeSceneAsset,
   SCENE_COLLECT_PROFILE,
   worldGetSceneAssetForInstance,
@@ -69,13 +76,13 @@ import type {
   SceneEntity,
   SceneInstanceMount,
 } from '@forgeax/engine-types';
-import type { SceneAssetPort } from './scene-asset-port';
-import {
-  SceneCollectAssetGuidUnresolvedError,
-  SceneCollectEntityRefOutOfClosureError,
-} from './scene-collect-errors';
 import { foldMountOverrides } from './scene-utils/mount-override-fold';
 
+/** The collector needs identity lookup, not an authoring registry implementation. */
+export interface SceneAssetGuidLookup {
+  guidOf(asset: Asset): string | undefined;
+}
+
 // Shared helpers
 function _isArrayLike(value: unknown): value is ArrayLike<unknown> {
   // SceneAsset values are ordinary JSON arrays at the boundary. Use the
@@ -114,14 +121,16 @@ function classifyFieldSchema(fieldType: string | undefined): SchemaFieldClass |
 // lives in exactly one place; `field` names the failing field in the error.
 function _handleToGuid(
   world: World,
-  assets: SceneAssetPort,
+  registry: SceneAssetGuidLookup,
   handle: number,
   field: string,
 ): Result<string | undefined, SceneCollectAssetGuidUnresolvedError> {
   if (handle === 0) return ok(undefined); // NULL sentinel
-  const assetRes = assets.resolve(world, handle as unknown as Handle<string, 'shared'>);
+  const builtinGuid = builtinMeshGuid(handle as unknown as Handle<string, 'shared'>);
+  if (builtinGuid !== undefined) return ok(builtinGuid);
+  const assetRes = resolveAssetHandle(world, handle as unknown as Handle<string, 'shared'>);
   if (!assetRes.ok) return err(new SceneCollectAssetGuidUnresolvedError(field, handle));
-  const guid = assets.guidOf(assetRes.value as Asset);
+  const guid = registry.guidOf(assetRes.value as Asset);
   if (guid === undefined) return err(new SceneCollectAssetGuidUnresolvedError(field, handle));
   return ok(guid);
 }
@@ -133,14 +142,14 @@ function _handleToGuid(
 // values pass through untouched.
 function _serializeSharedFieldValue(
   world: World,
-  assets: SceneAssetPort,
+  registry: SceneAssetGuidLookup,
   classification: SchemaFieldClass,
   value: unknown,
   field: string,
 ): Result<unknown, SceneCollectAssetGuidUnresolvedError> {
   if (classification.scalar) {
     if (typeof value !== 'number') return ok(value);
-    return _handleToGuid(world, assets, value, field); // undefined -> caller omits
+    return _handleToGuid(world, registry, value, field); // undefined -> caller omits
   }
   if (!Array.isArray(value)) return ok(value);
   const mapped: Array<string | number> = [];
@@ -149,7 +158,7 @@ function _serializeSharedFieldValue(
       mapped.push(elem as number);
       continue;
     }
-    const g = _handleToGuid(world, assets, elem, field);
+    const g = _handleToGuid(world, registry, elem, field);
     if (!g.ok) return g;
     mapped.push(g.value ?? 0); // NULL sentinel keeps positional 0
   }
@@ -164,7 +173,7 @@ function _serializeSharedFieldValue(
 // override IS that field so it cannot be omitted). Non-shared fields pass through.
 function _serializeOverrideValueHandles(
   world: World,
-  assets: SceneAssetPort,
+  registry: SceneAssetGuidLookup,
   ov: MountOverride,
 ): Result<unknown, SceneCollectAssetGuidUnresolvedError> {
   const comp = world.components.resolve(ov.comp);
@@ -172,7 +181,7 @@ function _serializeOverrideValueHandles(
   if (ov.field !== undefined) {
     const classification = schema ? classifyFieldSchema(schema[ov.field]) : undefined;
     if (!classification || classification.kind !== 'shared') return ok(ov.value);
-    const conv = _serializeSharedFieldValue(world, assets, classification, ov.value, ov.field);
+    const conv = _serializeSharedFieldValue(world, registry, classification, ov.value, ov.field);
     if (!conv.ok) return conv;
     // Field-patch: keep the field even at NULL sentinel (the override IS the
     // field); undefined only arises for a scalar handle 0 -> emit 0.
@@ -192,7 +201,7 @@ function _serializeOverrideValueHandles(
     }
     const conv = _serializeSharedFieldValue(
       world,
-      assets,
+      registry,
       classification,
       src[fieldName],
       fieldName,
@@ -251,7 +260,7 @@ export function serializeSceneAssetToPack(
  * filter (not subtree pruning): graft entities under members survive as owned.
  */
 export function rootsToSceneAsset(
-  assets: SceneAssetPort,
+  registry: SceneAssetGuidLookup,
   world: World,
   roots: EntityHandle[],
 ): Result<
@@ -402,7 +411,10 @@ export function rootsToSceneAsset(
           sh.error as unknown as number,
         ),
       );
-    const pr = assets.resolve<SceneAsset>(world, sh.value as unknown as Handle<string, 'shared'>);
+    const pr = resolveAssetHandle<SceneAsset>(
+      world,
+      sh.value as unknown as Handle<string, 'shared'>,
+    );
     if (!pr.ok)
       return err(
         new SceneCollectAssetGuidUnresolvedError(
@@ -410,7 +422,7 @@ export function rootsToSceneAsset(
           sh.value as unknown as number,
         ),
       );
-    const g = assets.guidOf(pr.value as Asset);
+    const g = registry.guidOf(pr.value as Asset);
     if (g === undefined)
       return err(
         new SceneCollectAssetGuidUnresolvedError(
@@ -482,11 +494,11 @@ export function rootsToSceneAsset(
     let mountOverrides: MountOverride[] | undefined;
     const foldStateRes = worldGetSceneInstanceState(world, a.entityRaw as EntityHandle);
     if (foldStateRes.ok) {
-      const rawOverrides = foldMountOverrides(world, assets, foldStateRes.value);
+      const rawOverrides = foldMountOverrides(world, foldStateRes.value);
       if (rawOverrides.length > 0) {
         mountOverrides = [];
         for (const ov of rawOverrides) {
-          const convRes = _serializeOverrideValueHandles(world, assets, ov);
+          const convRes = _serializeOverrideValueHandles(world, registry, ov);
           if (!convRes.ok) return convRes;
           mountOverrides.push({
             ...ov,
@@ -664,7 +676,7 @@ export function rootsToSceneAsset(
           }
           const conv = _serializeSharedFieldValue(
             world,
-            assets,
+            registry,
             sharedClass,
             normalized,
             fieldName,

package/src/components/__tests__/camera.test-d.ts

@@ -7,8 +7,8 @@
 // Charter P3: required-field omission must produce compile-time error,
 // not runtime silent fallback.
 
-import { orthographic, perspective } from '@forgeax/engine-render/internal';
 import { describe, expectTypeOf, it } from 'vitest';
+import { orthographic, perspective } from '../../../../render/src/components/camera';
 
 describe('perspective factory type-level', () => {
   it('perspective({ fov: 60, aspect: 4/3 }) type-checks OK', () => {

package/src/components/__tests__/camera.test.ts

@@ -14,8 +14,8 @@
 // exercises the world.get path.
 
 import { World } from '@forgeax/engine-ecs';
-import { Camera, perspective } from '@forgeax/engine-render/internal';
 import { describe, expect, expectTypeOf, it } from 'vitest';
+import { Camera, perspective } from '../../../../render/src/components/camera';
 
 describe('camera.ts autoAspect bool column (w8)', () => {
   it('world.get(cam, Camera).autoAspect reads a JS boolean, not a number', () => {

package/src/components/__tests__/sprite-animation.test-d.ts

@@ -45,11 +45,11 @@
 
 import type { Component, SchemaOf, ShapeOf } from '@forgeax/engine-ecs';
 import type { SpriteAnimation } from '@forgeax/engine-render/authoring';
+import { describe, expectTypeOf, it } from 'vitest';
 import {
   SPRITE_PLAYBACK_MODE_CLAMP,
   SPRITE_PLAYBACK_MODE_LOOP,
-} from '@forgeax/engine-render/authoring';
-import { describe, expectTypeOf, it } from 'vitest';
+} from '../../../../render/src/components/sprite-playback-mode';
 
 describe('SpriteAnimation — Component token shape (AC-02 schema lock)', () => {
   it("name literal type is 'SpriteAnimation'", () => {

package/src/components/__tests__/tile-layer.test-d.ts

@@ -5,9 +5,9 @@
 // AGENTS.md §Component naming.
 
 import type { EcsError, EntityHandle, SchemaOf, World } from '@forgeax/engine-ecs';
-import { markTileLayerDirty, type TileLayer } from '@forgeax/engine-render/authoring';
 import type { Result } from '@forgeax/engine-types';
 import { describe, expectTypeOf, it } from 'vitest';
+import { markTileLayerDirty, type TileLayer } from '../../../../render/src/components/tile-layer';
 
 describe('TileLayer component schema (M0 baseline)', () => {
   it('type-level: schema fields remain owner-defined and typed', () => {

package/src/components/__tests__/tile-layer.unit.test.ts

@@ -26,13 +26,13 @@
 // P1 (progressive disclosure — `'layer'` / `'per-cell'` reads directly).
 
 import { World } from '@forgeax/engine-ecs';
+import { describe, expect, expectTypeOf, it } from 'vitest';
 import {
   decodeSortScope,
   encodeSortScope,
   type SortScope,
   TileLayer,
-} from '@forgeax/engine-render/authoring';
-import { describe, expect, expectTypeOf, it } from 'vitest';
+} from '../../../../render/src/components';
 
 describe('TileLayer.sortScope union lock (w5, round-2 production)', () => {
   it("'layer' is assignable to SortScope", () => {