auto-git:

[change] tests/domain/build-runtime-scene.test.ts
 [change] tests/domain/scene-document-validation.test.ts
 [change] tests/serialization/scene-document-json.test.ts
 [change] tests/unit/entity-instances.test.ts
 [change] tests/unit/viewport-focus.test.ts

tests/domain/build-runtime-scene.test.ts

@@ -13,6 +13,8 @@ import { createDefaultProjectTimeSettings } from "../../src/document/project-tim
 import { createTerrain } from "../../src/document/terrains";
 import { createEmptySceneDocument } from "../../src/document/scene-document";
 import {
+  createCameraRigEntity,
+  createCameraRigEntityTargetRef,
   DEFAULT_PLAYER_START_MOVE_SPEED,
   DEFAULT_PLAYER_START_MOVEMENT_CAPABILITIES,
   createNpcEntity,
@@ -42,6 +44,86 @@ import { createFixtureLoadedModelAssetFromGeometry } from "../helpers/model-coll
 const defaultMovementTemplate = createPlayerStartMovementTemplate();
 
 describe("buildRuntimeSceneFromDocument", () => {
+  it("builds enabled fixed camera rigs into runtime entities", () => {
+    const interactable = createInteractableEntity({
+      id: "entity-interactable-camera-anchor",
+      position: {
+        x: 4,
+        y: 1,
+        z: -2
+      },
+      prompt: "Anchor"
+    });
+    const cameraRig = createCameraRigEntity({
+      id: "entity-camera-rig-overlook",
+      position: {
+        x: 8,
+        y: 3,
+        z: -6
+      },
+      priority: 7,
+      defaultActive: false,
+      target: createCameraRigEntityTargetRef(interactable.id),
+      targetOffset: {
+        x: 0,
+        y: 1.5,
+        z: 0
+      },
+      transitionMode: "blend",
+      transitionDurationSeconds: 0.6,
+      lookAround: {
+        enabled: true,
+        yawLimitDegrees: 10,
+        pitchLimitDegrees: 6,
+        recenterSpeed: 5
+      }
+    });
+    const disabledCameraRig = createCameraRigEntity({
+      id: "entity-camera-rig-disabled",
+      enabled: false
+    });
+
+    const runtimeScene = buildRuntimeSceneFromDocument({
+      ...createEmptySceneDocument({ name: "Camera Rig Runtime Scene" }),
+      entities: {
+        [interactable.id]: interactable,
+        [cameraRig.id]: cameraRig,
+        [disabledCameraRig.id]: disabledCameraRig
+      }
+    });
+
+    expect(runtimeScene.entities.cameraRigs).toEqual([
+      {
+        entityId: cameraRig.id,
+        rigType: "fixed",
+        priority: 7,
+        defaultActive: false,
+        position: {
+          x: 8,
+          y: 3,
+          z: -6
+        },
+        target: {
+          kind: "entity",
+          entityId: interactable.id
+        },
+        targetOffset: {
+          x: 0,
+          y: 1.5,
+          z: 0
+        },
+        transitionMode: "blend",
+        transitionDurationSeconds: 0.6,
+        lookAround: {
+          enabled: true,
+          yawLimitDegrees: 10,
+          pitchLimitDegrees: 6,
+          recenterSpeed: 5
+        }
+      }
+    ]);
+  });
+
   it("builds runtime brush data, colliders, and an authored player spawn from the document", () => {
     const brush = createBoxBrush({
       id: "brush-room-floor",

tests/domain/scene-document-validation.test.ts

@@ -17,6 +17,9 @@ import { createScenePath } from "../../src/document/paths";
 import { createEmptySceneDocument } from "../../src/document/scene-document";
 import { validateSceneDocument } from "../../src/document/scene-document-validation";
 import {
+  createCameraRigActorTargetRef,
+  createCameraRigEntity,
+  createCameraRigEntityTargetRef,
   createPointLightEntity,
   createInteractableEntity,
   createNpcEntity,
@@ -753,6 +756,81 @@ describe("validateSceneDocument", () => {
     );
   });
 
+  it("validates fixed camera rig targets and authored settings", () => {
+    const otherCameraRig = createCameraRigEntity({
+      id: "entity-camera-rig-other"
+    });
+    const missingActorRig = createCameraRigEntity({
+      id: "entity-camera-rig-missing-actor",
+      target: createCameraRigActorTargetRef("actor-missing")
+    });
+    const missingEntityRig = createCameraRigEntity({
+      id: "entity-camera-rig-missing-entity",
+      target: createCameraRigEntityTargetRef("entity-missing")
+    });
+    const selfTargetRig = createCameraRigEntity({
+      id: "entity-camera-rig-self"
+    });
+    const cameraTargetRig = createCameraRigEntity({
+      id: "entity-camera-rig-camera-target",
+      target: createCameraRigEntityTargetRef(otherCameraRig.id)
+    });
+    const invalidRig = createCameraRigEntity({
+      id: "entity-camera-rig-invalid"
+    });
+
+    selfTargetRig.target = createCameraRigEntityTargetRef(selfTargetRig.id);
+    invalidRig.priority = Number.NaN;
+    invalidRig.targetOffset = {
+      x: Number.POSITIVE_INFINITY,
+      y: 0,
+      z: 0
+    };
+    invalidRig.lookAround.enabled = "yes" as unknown as boolean;
+    invalidRig.lookAround.pitchLimitDegrees = Number.NaN;
+
+    const validation = validateSceneDocument({
+      ...createEmptySceneDocument(),
+      entities: {
+        [otherCameraRig.id]: otherCameraRig,
+        [missingActorRig.id]: missingActorRig,
+        [missingEntityRig.id]: missingEntityRig,
+        [selfTargetRig.id]: selfTargetRig,
+        [cameraTargetRig.id]: cameraTargetRig,
+        [invalidRig.id]: invalidRig
+      }
+    });
+
+    expect(validation.errors).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          code: "missing-camera-rig-target-actor"
+        }),
+        expect.objectContaining({
+          code: "missing-camera-rig-target-entity"
+        }),
+        expect.objectContaining({
+          code: "camera-rig-self-target"
+        }),
+        expect.objectContaining({
+          code: "invalid-camera-rig-target-entity-kind"
+        }),
+        expect.objectContaining({
+          code: "invalid-camera-rig-priority"
+        }),
+        expect.objectContaining({
+          code: "invalid-camera-rig-target-offset"
+        }),
+        expect.objectContaining({
+          code: "invalid-camera-rig-look-around-enabled"
+        }),
+        expect.objectContaining({
+          code: "invalid-camera-rig-look-around-pitch-limit"
+        })
+      ])
+    );
+  });
+
   it("detects missing and invalid audio asset references on Sound Emitters", () => {
     const audioAsset = {
       id: "asset-audio-main",