@forgeax/engine-runtime 0.1.28 → 0.1.29

package/src/__tests__/collect-scene-mount-collapse.test.ts

@@ -66,14 +66,16 @@ describe('m2-t1 — Form 2: root itself is SceneInstance', () => {
     const w = new World();
     const child: SceneAsset = {
       kind: 'scene',
-      entities: [{ localId: 0 as never, components: { Transform: {} } }],
+      entities: { 'entity-0': { components: { Transform: {} } } },
     };
     reg.catalog(pg(G1), child as Asset);
 
     const parent: SceneAsset = {
       kind: 'scene',
-      entities: [{ localId: 0 as never, components: { Transform: { pos: [10, 0, 0] } } }],
-      mounts: [{ localId: 1 as never, source: 0, memberFirst: 2 as never, memberCount: 1 }],
+      entities: {
+        'entity-0': { components: { Transform: { pos: [10, 0, 0] } } },
+        child: { components: {}, instance: { source: G1 } },
+      },
     };
     const ch = rs(w, child);
     const ph = rs(w, parent);
@@ -91,16 +93,15 @@ describe('m2-t1 — Form 2: root itself is SceneInstance', () => {
     // Root is SceneInstance → root's own entities are owned.
     // Child's member entities are excluded.
     const s = res.value;
-    expect(s.entities.length).toBeGreaterThanOrEqual(1); // parent's own entity
-    for (const e of s.entities) {
+    expect(Object.keys(s.entities).length).toBeGreaterThanOrEqual(1); // parent's own entity
+    for (const e of Object.values(s.entities)) {
       expect(
         (e.components as Record<string, Record<string, unknown>>).SceneInstance,
       ).toBeUndefined();
     }
     // Child anchor produces a mount.
-    expect(s.mounts).toBeDefined();
-    expect(s.mounts?.length).toBe(1);
-    expect(s.mounts?.[0]?.source).toBe(G1);
+    const childInstance = Object.values(s.entities).find((entity) => entity.instance);
+    expect(childInstance?.instance?.source).toBe(G1);
   });
 });
 
@@ -111,10 +112,10 @@ describe('m2-t2 — Form 1: deep anchor with ChildOf parent', () => {
     const w = new World();
     const child: SceneAsset = {
       kind: 'scene',
-      entities: [
-        { localId: 0 as never, components: { Transform: { pos: [1, 0, 0] } } },
-        { localId: 1 as never, components: { Transform: { pos: [2, 0, 0] } } },
-      ],
+      entities: {
+        'entity-0': { components: { Transform: { pos: [1, 0, 0] } } },
+        'entity-1': { components: { Transform: { pos: [2, 0, 0] } } },
+      },
     };
     reg.catalog(pg(G1), child as Asset);
     const ch = rs(w, child);
@@ -144,10 +145,9 @@ describe('m2-t2 — Form 1: deep anchor with ChildOf parent', () => {
 
     // Outer root is NOT SceneInstance → no mount for it.
     // Child anchor produces a mount; its member entities excluded from owned.
-    expect(res.value.mounts).toBeDefined();
-    expect(res.value.mounts?.length).toBe(1);
-    expect(res.value.mounts?.[0]?.source).toBe(G1);
-    for (const e of res.value.entities) {
+    const childInstance = Object.values(res.value.entities).find((entity) => entity.instance);
+    expect(childInstance?.instance?.source).toBe(G1);
+    for (const e of Object.values(res.value.entities)) {
       expect(
         (e.components as Record<string, Record<string, unknown>>).SceneInstance,
       ).toBeUndefined();
@@ -162,15 +162,17 @@ describe('m2-t3 — AC-03 window invariants', () => {
     const w = new World();
     const ca: SceneAsset = {
       kind: 'scene',
-      entities: [{ localId: 0 as never, components: { Transform: {} } }],
+      entities: { 'entity-0': { components: { Transform: {} } } },
     };
     reg.catalog(pg(G1), ca as Asset);
     const ch = rs(w, ca);
 
     const pa: SceneAsset = {
       kind: 'scene',
-      entities: [{ localId: 0 as never, components: { Transform: {} } }],
-      mounts: [{ localId: 1 as never, source: 0, memberFirst: 2 as never, memberCount: 1 }],
+      entities: {
+        'entity-0': { components: { Transform: {} } },
+        child: { components: {}, instance: { source: G1 } },
+      },
     };
     const ph = rs(w, pa);
     wr(w, ph, ch);
@@ -182,7 +184,7 @@ describe('m2-t3 — AC-03 window invariants', () => {
     const res = rootsToSceneAsset(reg, w, [inst.value.root]);
     expect(res.ok).toBe(true);
     if (!res.ok) return;
-    expect(res.value.mounts?.[0]?.memberCount).toBe(1);
+    expect(Object.values(res.value.entities).filter((entity) => entity.instance)).toHaveLength(1);
   });
 
   it('sparse localId does not shrink window', () => {
@@ -190,18 +192,20 @@ describe('m2-t3 — AC-03 window invariants', () => {
     const w = new World();
     const ca: SceneAsset = {
       kind: 'scene',
-      entities: [
-        { localId: 0 as never, components: { Transform: { pos: [1, 0, 0] } } },
-        { localId: 1 as never, components: { Transform: { pos: [2, 0, 0] } } },
-      ],
+      entities: {
+        'entity-0': { components: { Transform: { pos: [1, 0, 0] } } },
+        'entity-1': { components: { Transform: { pos: [2, 0, 0] } } },
+      },
     };
     reg.catalog(pg(G1), ca as Asset);
     const ch = rs(w, ca);
 
     const pa: SceneAsset = {
       kind: 'scene',
-      entities: [{ localId: 0 as never, components: { Transform: {} } }],
-      mounts: [{ localId: 1 as never, source: 0, memberFirst: 2 as never, memberCount: 2 }],
+      entities: {
+        'entity-0': { components: { Transform: {} } },
+        child: { components: {}, instance: { source: G1 } },
+      },
     };
     const ph = rs(w, pa);
     wr(w, ph, ch);
@@ -220,7 +224,7 @@ describe('m2-t3 — AC-03 window invariants', () => {
     const res = rootsToSceneAsset(reg, w, [inst.value.root]);
     expect(res.ok).toBe(true);
     if (!res.ok) return;
-    expect(res.value.mounts?.[0]?.memberCount).toBe(2); // totalSlots, not live count
+    expect(Object.values(res.value.entities).filter((entity) => entity.instance)).toHaveLength(1); // keyed instance survives sparse members
   });
 
   it('multiple child mounts have non-overlapping windows', () => {
@@ -228,14 +232,14 @@ describe('m2-t3 — AC-03 window invariants', () => {
     const w = new World();
     const cA: SceneAsset = {
       kind: 'scene',
-      entities: [{ localId: 0 as never, components: { Transform: {} } }],
+      entities: { 'entity-0': { components: { Transform: {} } } },
     };
     const cB: SceneAsset = {
       kind: 'scene',
-      entities: [
-        { localId: 0 as never, components: { Transform: {} } },
-        { localId: 1 as never, components: { Transform: {} } },
-      ],
+      entities: {
+        'entity-0': { components: { Transform: {} } },
+        'entity-1': { components: { Transform: {} } },
+      },
     };
     reg.catalog(pg(G1), cA as Asset);
     reg.catalog(pg(G2), cB as Asset);
@@ -244,20 +248,19 @@ describe('m2-t3 — AC-03 window invariants', () => {
 
     const pa: SceneAsset = {
       kind: 'scene',
-      entities: [{ localId: 0 as never, components: { Transform: {} } }],
-      mounts: [
-        { localId: 1 as never, source: 0, memberFirst: 3 as never, memberCount: 1 },
-        { localId: 2 as never, source: 1, memberFirst: 4 as never, memberCount: 2 },
-      ],
+      entities: {
+        'entity-0': { components: { Transform: {} } },
+        childA: { components: {}, instance: { source: G1 } },
+        childB: { components: {}, instance: { source: G2 } },
+      },
     };
     const ph = rs(w, pa);
-    SceneOwner.worldSetSceneAssetResolver(w, (sIdx, pH) =>
-      (pH as unknown as number) !== (ph as unknown as number)
-        ? err({ code: 'asset-not-found' })
-        : sIdx === 0
-          ? ok(hA)
-          : ok(hB),
-    );
+    SceneOwner.worldSetSceneAssetResolver(w, (sIdx, pH) => {
+      if ((pH as unknown as number) !== (ph as unknown as number))
+        return err({ code: 'asset-not-found' });
+      if (typeof sIdx === 'number') return ok(sIdx as unknown as Handle<'SceneAsset', 'shared'>);
+      return String(sIdx).toLowerCase() === G1 ? ok(hA) : ok(hB);
+    });
 
     const inst = SceneOwner.worldInstantiateScene(w, ph);
     expect(inst.ok).toBe(true);
@@ -268,27 +271,18 @@ describe('m2-t3 — AC-03 window invariants', () => {
       if (!s.ok) continue;
       const c = resolveAssetHandle<SceneAsset>(w, s.value as unknown as Handle<string, 'shared'>);
       if (!c.ok) continue;
-      soi(reg, c.value as SceneAsset, c.value.entities.length === 1 ? G1 : G2);
+      soi(reg, c.value as SceneAsset, Object.keys(c.value.entities).length === 1 ? G1 : G2);
     }
 
     const res = rootsToSceneAsset(reg, w, [inst.value.root]);
     expect(res.ok).toBe(true);
     if (!res.ok) return;
 
-    const ms = res.value.mounts ?? [];
-    expect(ms.length).toBe(2);
-    const W = ms
-      .map((m) => ({ f: m.memberFirst as number, c: m.memberCount }))
-      .sort((a, b) => a.f - b.f);
-    for (let i = 0; i < W.length - 1; i++) {
-      const cur = W[i];
-      const next = W[i + 1];
-      if (!cur || !next) throw new Error('window index out of range');
-      expect(cur.f + cur.c).toBeLessThanOrEqual(next.f);
-    }
-    const owned = new Set(res.value.entities.map((e) => e.localId as unknown as number));
-    for (const w of W)
-      for (let lid = w.f; lid < w.f + w.c; lid++) expect(owned.has(lid)).toBe(false);
+    const instances = Object.values(res.value.entities).flatMap((entity) =>
+      entity.instance ? [entity.instance] : [],
+    );
+    expect(instances).toHaveLength(2);
+    expect(new Set(instances.map((instance) => instance.source))).toEqual(new Set([G1, G2]));
   });
 });
 
@@ -299,15 +293,17 @@ describe('m2-t4 — graft preservation', () => {
     const w = new World();
     const ca: SceneAsset = {
       kind: 'scene',
-      entities: [{ localId: 0 as never, components: { Transform: {} } }],
+      entities: { 'entity-0': { components: { Transform: {} } } },
     };
     reg.catalog(pg(G1), ca as Asset);
     const ch = rs(w, ca);
 
     const pa: SceneAsset = {
       kind: 'scene',
-      entities: [{ localId: 0 as never, components: { Transform: {} } }],
-      mounts: [{ localId: 1 as never, source: 0, memberFirst: 2 as never, memberCount: 1 }],
+      entities: {
+        'entity-0': { components: { Transform: {} } },
+        child: { components: {}, instance: { source: G1 } },
+      },
     };
     const ph = rs(w, pa);
     wr(w, ph, ch);
@@ -337,7 +333,7 @@ describe('m2-t4 — graft preservation', () => {
 
     // Prop should survive as owned entity (not eaten by mount).
     let propFound = false;
-    for (const e of res.value.entities) {
+    for (const e of Object.values(res.value.entities)) {
       if ((e.components as Record<string, Record<string, unknown>>).ChildOf) {
         propFound = true;
         break;
@@ -351,15 +347,17 @@ describe('m2-t4 — graft preservation', () => {
     const w = new World();
     const ca: SceneAsset = {
       kind: 'scene',
-      entities: [{ localId: 0 as never, components: { Transform: {} } }],
+      entities: { 'entity-0': { components: { Transform: {} } } },
     };
     reg.catalog(pg(G1), ca as Asset);
     const ch = rs(w, ca);
 
     const pa: SceneAsset = {
       kind: 'scene',
-      entities: [{ localId: 0 as never, components: { Transform: {} } }],
-      mounts: [{ localId: 1 as never, source: 0, memberFirst: 2 as never, memberCount: 1 }],
+      entities: {
+        'entity-0': { components: { Transform: {} } },
+        child: { components: {}, instance: { source: G1 } },
+      },
     };
     const ph = rs(w, pa);
     wr(w, ph, ch);

package/src/__tests__/collect-transient-children-absent.test.ts

@@ -25,7 +25,7 @@ function makeRegistry(): AssetRegistry {
   return new AssetRegistry(makeMockShaderRegistry());
 }
 
-function localId(n: number): LocalEntityId {
+function _localId(n: number): LocalEntityId {
   return n as LocalEntityId;
 }
 
@@ -37,10 +37,7 @@ describe('m1t3 — Children absent from collect (AC-04)', () => {
   it('2-level hierarchy: no entity has Children in collect output', () => {
     const asset: SceneAsset = {
       kind: 'scene',
-      entities: [
-        { localId: localId(0), components: {} },
-        { localId: localId(1), components: {} },
-      ],
+      entities: { 'entity-0': { components: {} }, 'entity-1': { components: {} } },
     };
 
     const world = new World();
@@ -59,12 +56,12 @@ describe('m1t3 — Children absent from collect (AC-04)', () => {
     if (!collected.ok) return;
 
     // Verify: no entity in the collected scene has 'Children' component.
-    for (const ent of collected.value.entities) {
+    for (const ent of Object.values(collected.value.entities)) {
       expect(hasComp(ent, 'Children')).toBe(false);
     }
 
     // Also verify no entity has 'SceneInstance'.
-    for (const ent of collected.value.entities) {
+    for (const ent of Object.values(collected.value.entities)) {
       expect(hasComp(ent, 'SceneInstance')).toBe(false);
     }
   });
@@ -76,18 +73,15 @@ describe('m1t3 — Children absent from collect (AC-04)', () => {
     // Level 3: leaf scene instantiated under mid scene entity.
     const leafAsset: SceneAsset = {
       kind: 'scene',
-      entities: [{ localId: localId(0), components: {} }],
+      entities: { 'entity-0': { components: {} } },
     };
     const midAsset: SceneAsset = {
       kind: 'scene',
-      entities: [{ localId: localId(0), components: {} }],
+      entities: { 'entity-0': { components: {} } },
     };
     const outerAsset: SceneAsset = {
       kind: 'scene',
-      entities: [
-        { localId: localId(0), components: {} },
-        { localId: localId(1), components: {} },
-      ],
+      entities: { 'entity-0': { components: {} }, 'entity-1': { components: {} } },
     };
 
     const world = new World();
@@ -131,10 +125,10 @@ describe('m1t3 — Children absent from collect (AC-04)', () => {
 
     // Hierarchy: outer root + (2 outer children) + mid root + (1 mid child) + leaf root + (1 leaf child) >= 7 entities.
     // But the exact count depends on mount-collapse logic — focus on the Children assertion.
-    expect(collected.value.entities.length).toBeGreaterThan(0);
+    expect(Object.keys(collected.value.entities).length).toBeGreaterThan(0);
 
     // No entity has Children or SceneInstance.
-    for (const ent of collected.value.entities) {
+    for (const ent of Object.values(collected.value.entities)) {
       expect(hasComp(ent, 'Children')).toBe(false);
       expect(hasComp(ent, 'SceneInstance')).toBe(false);
     }
@@ -143,7 +137,7 @@ describe('m1t3 — Children absent from collect (AC-04)', () => {
   it('degenerate: zero-hierarchy scene has no Children', () => {
     const asset: SceneAsset = {
       kind: 'scene',
-      entities: [{ localId: localId(0), components: {} }],
+      entities: { 'entity-0': { components: {} } },
     };
 
     const world = new World();
@@ -161,7 +155,7 @@ describe('m1t3 — Children absent from collect (AC-04)', () => {
     expect(collected.ok).toBe(true);
     if (!collected.ok) return;
 
-    for (const ent of collected.value.entities) {
+    for (const ent of Object.values(collected.value.entities)) {
       expect(hasComp(ent, 'Children')).toBe(false);
     }
   });

package/src/__tests__/collect-transient-roundtrip.test.ts

@@ -39,7 +39,7 @@ function makeRegistry(): AssetRegistry {
   return new AssetRegistry(makeMockShaderRegistry());
 }
 
-function localId(n: number): LocalEntityId {
+function _localId(n: number): LocalEntityId {
   return n as LocalEntityId;
 }
 
@@ -55,11 +55,11 @@ describe('m1t4 — AC-05 roundtrip regression (red-first)', () => {
     // After instantiateScene, the synthetic root has Children populated by mirror hook.
     const asset: SceneAsset = {
       kind: 'scene',
-      entities: [
-        { localId: localId(0), components: {} },
-        { localId: localId(1), components: {} },
-        { localId: localId(2), components: {} },
-      ],
+      entities: {
+        'entity-0': { components: {} },
+        'entity-1': { components: {} },
+        'entity-2': { components: {} },
+      },
     };
 
     const world = new World();
@@ -128,7 +128,7 @@ describe('m1t4 — AC-05 roundtrip regression (red-first)', () => {
   it('(c) degenerate: zero parent-child scene round-trips', () => {
     const asset: SceneAsset = {
       kind: 'scene',
-      entities: [{ localId: localId(0), components: {} }],
+      entities: { 'entity-0': { components: {} } },
     };
 
     const world = new World();
@@ -172,7 +172,7 @@ describe('m1t4 — AC-05 roundtrip regression (red-first)', () => {
 // world produced. The transient world column is reconstructed by propagate from
 // the persisted local TRS -- proving skipping it loses nothing.
 describe('w1 — AC-04 transient world roundtrip numeric equivalence', () => {
-  function localId2(n: number): LocalEntityId {
+  function _localId2(n: number): LocalEntityId {
     return n as LocalEntityId;
   }
 
@@ -180,9 +180,8 @@ describe('w1 — AC-04 transient world roundtrip numeric equivalence', () => {
     // Non-identity local TRS so the world mat4 is a real, distinguishable value.
     const asset: SceneAsset = {
       kind: 'scene',
-      entities: [
-        {
-          localId: localId2(0),
+      entities: {
+        'entity-0': {
           components: {
             Transform: {
               pos: [3, 4, 5],
@@ -191,7 +190,7 @@ describe('w1 — AC-04 transient world roundtrip numeric equivalence', () => {
             },
           },
         },
-      ],
+      },
     };
 
     const world = new World();
@@ -213,7 +212,7 @@ describe('w1 — AC-04 transient world roundtrip numeric equivalence', () => {
     if (!collected.ok) return;
 
     // Serialized output must not carry world (transient).
-    for (const ent of collected.value.entities) {
+    for (const ent of Object.values(collected.value.entities)) {
       const t = (ent.components as Record<string, Record<string, unknown>>).Transform;
       if (t !== undefined) expect('world' in t).toBe(false);
       expect((ent.components as Record<string, unknown>).GlobalTransform).toBeUndefined();

package/src/__tests__/collect-transient-skip.test.ts

@@ -24,7 +24,7 @@ function makeRegistry(): AssetRegistry {
   return new AssetRegistry(makeMockShaderRegistry());
 }
 
-function localId(n: number): LocalEntityId {
+function _localId(n: number): LocalEntityId {
   return n as LocalEntityId;
 }
 
@@ -41,7 +41,7 @@ describe('m1t2 — collect transient skip (AC-02 + AC-03)', () => {
   it('(a) SceneInstance absent from collect output', () => {
     const asset: SceneAsset = {
       kind: 'scene',
-      entities: [{ localId: localId(0), components: {} }],
+      entities: { 'entity-0': { components: {} } },
     };
 
     const world = new World();
@@ -58,7 +58,7 @@ describe('m1t2 — collect transient skip (AC-02 + AC-03)', () => {
     expect(collected.ok).toBe(true);
     if (!collected.ok) return;
 
-    for (const ent of collected.value.entities) {
+    for (const ent of Object.values(collected.value.entities)) {
       expect(hasComp(ent, 'SceneInstance')).toBe(false);
     }
   });
@@ -68,10 +68,7 @@ describe('m1t2 — collect transient skip (AC-02 + AC-03)', () => {
     // (instance-level isRoot && ChildOf skip is independent of transient).
     const asset: SceneAsset = {
       kind: 'scene',
-      entities: [
-        { localId: localId(0), components: {} },
-        { localId: localId(1), components: {} },
-      ],
+      entities: { 'entity-0': { components: {} }, 'entity-1': { components: {} } },
     };
 
     const world = new World();
@@ -88,34 +85,27 @@ describe('m1t2 — collect transient skip (AC-02 + AC-03)', () => {
     expect(collected.ok).toBe(true);
     if (!collected.ok) return;
 
-    // root + 2 children = 3 entities.
-    // Children (non-root) should have ChildOf. Root should NOT have ChildOf.
-    const rootWithChildOf = false;
+    // Both entities are authored roots. Their runtime ChildOf edges point to
+    // the transient synthetic root and are therefore omitted on collect.
     let childrenWithChildOf = 0;
 
-    for (const ent of collected.value.entities) {
+    for (const ent of Object.values(collected.value.entities)) {
       if (hasComp(ent, 'ChildOf')) {
         childrenWithChildOf++;
       }
     }
 
-    // At least one non-root entity has ChildOf.
-    // Root ChildOf is skipped by isRoot && ChildOf instance-level check.
-    expect(childrenWithChildOf).toBeGreaterThan(0);
-    // No root entity should have ChildOf (the only root is the synthetic scene root).
-    // We verify by counting: all entities with ChildOf are children, root has none.
-    // The sum indicates root coverage is correct.
-    expect(rootWithChildOf).toBe(false);
+    expect(childrenWithChildOf).toBe(0);
   });
 
   it('(c) non-root entities retain ChildOf', () => {
     // Non-root entities (instantiated from SceneAsset localIds) must carry ChildOf.
     const asset: SceneAsset = {
       kind: 'scene',
-      entities: [
-        { localId: localId(0), components: {} },
-        { localId: localId(1), components: {} },
-      ],
+      entities: {
+        'entity-0': { components: {} },
+        'entity-1': { components: { ChildOf: { parent: 'entity-0' } } },
+      },
     };
 
     const world = new World();
@@ -132,9 +122,12 @@ describe('m1t2 — collect transient skip (AC-02 + AC-03)', () => {
     expect(collected.ok).toBe(true);
     if (!collected.ok) return;
 
-    // root + 2 children = 3 entities. 2 children have ChildOf.
-    const childOfEntities = collected.value.entities.filter((e) => hasComp(e, 'ChildOf'));
-    expect(childOfEntities.length).toBe(2);
+    // The explicit authored edge survives; the implicit synthetic-root edges
+    // are omitted by the collector.
+    const childOfEntities = Object.values(collected.value.entities).filter((e) =>
+      hasComp(e, 'ChildOf'),
+    );
+    expect(childOfEntities.length).toBe(1);
 
     // Each child ChildOf.parent should point to root handle.
     for (const c of childOfEntities) {
@@ -149,7 +142,7 @@ describe('m1t2 — collect transient skip (AC-02 + AC-03)', () => {
 
     const asset: SceneAsset = {
       kind: 'scene',
-      entities: [{ localId: localId(0), components: { M1T2_Ctrl: { val: 42, label: 'hello' } } }],
+      entities: { 'entity-0': { components: { M1T2_Ctrl: { val: 42, label: 'hello' } } } },
     };
 
     const world = new World();
@@ -166,7 +159,7 @@ describe('m1t2 — collect transient skip (AC-02 + AC-03)', () => {
     expect(collected.ok).toBe(true);
     if (!collected.ok) return;
 
-    const found = collected.value.entities.find((e) => hasComp(e, 'M1T2_Ctrl'));
+    const found = Object.values(collected.value.entities).find((e) => hasComp(e, 'M1T2_Ctrl'));
     expect(found).toBeDefined();
     const c = (found?.components as Record<string, Record<string, unknown>>).M1T2_Ctrl;
     expect(c).toBeDefined();

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

@@ -69,7 +69,7 @@ describe('w7 type-level - 5 component schemas yield exact data shapes via ShapeO
     expectTypeOf<{ materials: readonly [0] }>().not.toMatchTypeOf<SpawnData>();
   });
 
-  it('Camera data shape has 21 fields (18 number + clearColor array + autoAspect boolean + target)', () => {
+  it('Camera data shape includes output exposure and color-grading fields', () => {
     type Data = ShapeOf<SchemaOf<typeof Camera>>;
     expectTypeOf<keyof Data>().toEqualTypeOf<
       | 'fov'
@@ -83,7 +83,15 @@ describe('w7 type-level - 5 component schemas yield exact data shapes via ShapeO
       | 'top'
       | 'tonemap'
       | 'exposure'
+      | 'exposureMode'
+      | 'compensationEv'
+      | 'rangeEv'
+      | 'rates'
       | 'whitePoint'
+      | 'temperature'
+      | 'tint'
+      | 'colorLut'
+      | 'colorLutStrength'
       | 'antialias'
       | 'historyVersion'
       | 'bloom'
@@ -102,7 +110,15 @@ describe('w7 type-level - 5 component schemas yield exact data shapes via ShapeO
     // plan-strategy section 2.3 D-1 (f32 enum encoding).
     expectTypeOf<Data['tonemap']>().toEqualTypeOf<number>();
     expectTypeOf<Data['exposure']>().toEqualTypeOf<number>();
+    expectTypeOf<Data['exposureMode']>().toEqualTypeOf<number>();
+    expectTypeOf<Data['compensationEv']>().toEqualTypeOf<number>();
+    expectTypeOf<Data['rangeEv']>().toEqualTypeOf<Float32Array>();
+    expectTypeOf<Data['rates']>().toEqualTypeOf<Float32Array>();
     expectTypeOf<Data['whitePoint']>().toEqualTypeOf<number>();
+    expectTypeOf<Data['temperature']>().toEqualTypeOf<number>();
+    expectTypeOf<Data['tint']>().toEqualTypeOf<number>();
+    expectTypeOf<Data['colorLut']>().toEqualTypeOf<Handle<'TextureAsset', 'shared'>>();
+    expectTypeOf<Data['colorLutStrength']>().toEqualTypeOf<number>();
     expectTypeOf<Data['historyVersion']>().toEqualTypeOf<number>();
     // feat-20260709 M3: clear-color quartet collapsed into one inline
     // array<f32,4> column; read side resolves to Float32Array (mirrors the