Include camera state in RenderCommandBuffer (#835)

* feat(renderer-contract): include camera in RCB (#814)

* test(renderer-debug): cover render validation edge cases

* refactor(renderer): reduce cognitive complexity

* chore(dist): rebuild renderer outputs

Author: hansjm10

docs/coverage/index.md

@@ -10,21 +10,21 @@ Run `pnpm coverage:md` from the repository root to regenerate this page after mo
 ## Overall Coverage
 | Metric | Covered | Total | % |
 | --- | --- | --- | --- |
-| Statements | 40442 | 44945 | 89.98% |
-| Branches | 8295 | 9731 | 85.24% |
-| Functions | 2128 | 2280 | 93.33% |
-| Lines | 40442 | 44945 | 89.98% |
+| Statements | 40594 | 45024 | 90.16% |
+| Branches | 8384 | 9815 | 85.42% |
+| Functions | 2128 | 2281 | 93.29% |
+| Lines | 40594 | 45024 | 90.16% |
 
 ## Coverage by Package
 | Package | Statements | Branches | Functions | Lines |
 | --- | --- | --- | --- | --- |
-| @idle-engine/content-compiler | 1374 / 1525 (90.10%) | 238 / 301 (79.07%) | 88 / 92 (95.65%) | 1374 / 1525 (90.10%) |
+| @idle-engine/content-compiler | 1374 / 1525 (90.10%) | 237 / 300 (79.00%) | 88 / 92 (95.65%) | 1374 / 1525 (90.10%) |
 | @idle-engine/content-sample | 17 / 21 (80.95%) | 2 / 3 (66.67%) | 0 / 0 (0.00%) | 17 / 21 (80.95%) |
 | @idle-engine/content-schema | 8645 / 9715 (88.99%) | 1231 / 1446 (85.13%) | 307 / 337 (91.10%) | 8645 / 9715 (88.99%) |
 | @idle-engine/content-validation-cli | 1608 / 2200 (73.09%) | 276 / 374 (73.80%) | 80 / 99 (80.81%) | 1608 / 2200 (73.09%) |
 | @idle-engine/controls | 228 / 230 (99.13%) | 67 / 69 (97.10%) | 14 / 14 (100.00%) | 228 / 230 (99.13%) |
-| @idle-engine/core | 24710 / 27308 (90.49%) | 5446 / 6460 (84.30%) | 1435 / 1534 (93.55%) | 24710 / 27308 (90.49%) |
-| @idle-engine/renderer-contract | 500 / 507 (98.62%) | 131 / 135 (97.04%) | 27 / 27 (100.00%) | 500 / 507 (98.62%) |
-| @idle-engine/renderer-debug | 686 / 763 (89.91%) | 186 / 223 (83.41%) | 38 / 38 (100.00%) | 686 / 763 (89.91%) |
-| @idle-engine/renderer-webgpu | 1817 / 1819 (99.89%) | 493 / 495 (99.60%) | 95 / 95 (100.00%) | 1817 / 1819 (99.89%) |
-| @idle-engine/shell-desktop | 857 / 857 (100.00%) | 225 / 225 (100.00%) | 44 / 44 (100.00%) | 857 / 857 (100.00%) |
+| @idle-engine/core | 24720 / 27308 (90.52%) | 5450 / 6463 (84.33%) | 1435 / 1534 (93.55%) | 24720 / 27308 (90.52%) |
+| @idle-engine/renderer-contract | 516 / 523 (98.66%) | 134 / 138 (97.10%) | 27 / 27 (100.00%) | 516 / 523 (98.66%) |
+| @idle-engine/renderer-debug | 794 / 796 (99.75%) | 263 / 290 (90.69%) | 38 / 38 (100.00%) | 794 / 796 (99.75%) |
+| @idle-engine/renderer-webgpu | 1829 / 1843 (99.24%) | 498 / 505 (98.61%) | 95 / 96 (98.96%) | 1829 / 1843 (99.24%) |
+| @idle-engine/shell-desktop | 863 / 863 (100.00%) | 226 / 227 (99.56%) | 44 / 44 (100.00%) | 863 / 863 (100.00%) |

docs/issue-814-design.md

@@ -93,6 +93,9 @@ describe('visual replay', () => {
       renderFrame: options.renderFrame,
       contentHash: options.contentHash,
     },
+    scene: {
+      camera: { x: 0, y: 0, zoom: 1 },
+    },
     passes: [{ id: 'world' }, { id: 'ui' }],
     draws: [
       {
@@ -273,6 +276,58 @@ describe('visual replay', () => {
     ).rejects.toThrow(/"event":"visual_replay_mismatch"/);
   });
 
+  it('reports a diffable mismatch summary when the RCB camera differs', async () => {
+    resetRNG();
+    setRNGSeed(4242);
+
+    const content = createGoldContentPack();
+    const wiring = createGameRuntime({ content, stepSizeMs: 100 });
+    const stepSizeMs = wiring.runtime.getStepSizeMs();
+
+    const recorder = new SimReplayRecorder({ content, wiring, recordedAt: 0, capturedAt: 0 });
+
+    wiring.runtime.tick(stepSizeMs);
+
+    const step = wiring.runtime.getCurrentStep() - 1;
+    const simTimeMs = step * stepSizeMs;
+    const goldAmount = getGoldAmount(wiring);
+    const contentHash = content.digest.hash;
+
+    const recordedRcb = buildRcb({ step, simTimeMs, renderFrame: step, contentHash, goldAmount });
+    const replay = recorder.export({ capturedAt: 0 });
+    const replayWithFrames = {
+      ...replay,
+      frames: {
+        viewModels: [],
+        rcbs: [
+          {
+            renderFrame: step,
+            step,
+            hash: await hashRenderCommandBuffer(recordedRcb),
+            rcb: recordedRcb,
+          },
+        ],
+      },
+    };
+
+    const decoded = decodeSimReplayJsonLines(encodeSimReplayJsonLines(replayWithFrames));
+
+    await expect(
+      runCombinedReplay({
+        content,
+        replay: decoded,
+        buildRenderCommandBuffers: () => [
+          {
+            ...recordedRcb,
+            scene: {
+              camera: { x: 1, y: 0, zoom: 1 },
+            },
+          },
+        ],
+      }),
+    ).rejects.toThrow(/"stream":"rcb"/);
+  });
+
   it('replays schemaVersion 1 streams without visual builders', async () => {
     resetRNG();
     setRNGSeed(4242);

packages/core/src/replay/visual-replay.test.ts

@@ -1,4 +1,4 @@
-export declare const RENDERER_CONTRACT_SCHEMA_VERSION: 3;
+export declare const RENDERER_CONTRACT_SCHEMA_VERSION: 4;
 export type RendererContractSchemaVersion = typeof RENDERER_CONTRACT_SCHEMA_VERSION;
 export type Sha256Hex = string;
 export type AssetId = string & {
@@ -142,6 +142,9 @@ export interface ScissorPopDraw {
 export type RenderDraw = ClearDraw | RectDraw | ImageDraw | TextDraw | ScissorPushDraw | ScissorPopDraw;
 export interface RenderCommandBuffer {
     readonly frame: FrameHeader;
+    readonly scene: {
+        readonly camera: Camera2D;
+    };
     readonly passes: readonly RenderPass[];
     readonly draws: readonly RenderDraw[];
 }

packages/renderer-contract/dist/render-compiler.d.ts.map

@@ -313,6 +313,9 @@ describe('hashing', () => {
         simTimeMs: 32,
         contentHash: 'content:abc',
       },
+      scene: {
+        camera: { x: 0, y: 0, zoom: 1 },
+      },
       passes: [
         { id: 'world' },
         { id: 'ui' },
@@ -340,6 +343,9 @@ describe('hashing', () => {
         { id: 'world' },
         { id: 'ui' },
       ],
+      scene: {
+        camera: { x: 0, y: 0, zoom: 1 },
+      },
       frame: {
         contentHash: 'content:abc',
         simTimeMs: 32,
@@ -352,4 +358,30 @@ describe('hashing', () => {
       await hashRenderCommandBuffer(b),
     );
   });
+
+  it('includes scene.camera in RenderCommandBuffer hashes', async () => {
+    const base: RenderCommandBuffer = {
+      frame: {
+        schemaVersion: RENDERER_CONTRACT_SCHEMA_VERSION,
+        step: 1,
+        simTimeMs: 16,
+        contentHash: 'content:test',
+      },
+      scene: {
+        camera: { x: 0, y: 0, zoom: 1 },
+      },
+      passes: [{ id: 'world' }],
+      draws: [],
+    };
+
+    const hashA = await hashRenderCommandBuffer(base);
+    const hashB = await hashRenderCommandBuffer({
+      ...base,
+      scene: {
+        camera: { x: 0, y: 0, zoom: 2 },
+      },
+    });
+
+    expect(hashA).not.toEqual(hashB);
+  });
 });