fix: add comments and test

Author: VladaHarbour

packages/layout-engine/layout-bridge/src/cache.ts

@@ -142,6 +142,9 @@ const hashRuns = (block: FlowBlock): string => {
 
         for (const cellBlock of cellBlocks) {
           if (cellBlock?.kind === 'table') {
+            // Intentional split with renderer.ts: cache.ts hashes nested tables only,
+            // while renderer.ts also hashes non-paragraph cell blocks. Keep both
+            // in sync when adjusting nested-block invalidation behavior.
             // Nested tables inside table cells must contribute to the parent
             // table cache key, otherwise edits can be missed until a later
             // broader invalidation.

packages/layout-engine/layout-bridge/test/cache.test.ts

@@ -334,6 +334,78 @@ describe('MeasureCache', () => {
       expect(cache.get(table2, 800, 600)).toEqual({ totalHeight: 120 });
     });
 
+    it('invalidates when nested table content changes inside a cell block', () => {
+      const nestedTable = (id: string, text: string): TableBlock => ({
+        kind: 'table',
+        id,
+        rows: [
+          {
+            id: `${id}-row-0`,
+            cells: [
+              {
+                id: `${id}-cell-0-0`,
+                blocks: [
+                  {
+                    kind: 'paragraph',
+                    id: `${id}-para-0`,
+                    runs: [{ text, fontFamily: 'Arial', fontSize: 12 }],
+                  },
+                ],
+              },
+            ],
+          },
+        ],
+      });
+
+      const parentTable1: TableBlock = {
+        kind: 'table',
+        id: 'parent-table',
+        rows: [
+          {
+            id: 'parent-row-0',
+            cells: [
+              {
+                id: 'parent-cell-0-0',
+                blocks: [
+                  {
+                    kind: 'paragraph',
+                    id: 'parent-cell-0-0-para',
+                    runs: [{ text: 'Host', fontFamily: 'Arial', fontSize: 12 }],
+                  },
+                  nestedTable('nested-table', 'Nested A'),
+                ],
+              },
+            ],
+          },
+        ],
+      };
+
+      const parentTable2: TableBlock = {
+        ...parentTable1,
+        rows: [
+          {
+            ...parentTable1.rows[0],
+            cells: [
+              {
+                ...parentTable1.rows[0].cells[0],
+                blocks: [
+                  {
+                    kind: 'paragraph',
+                    id: 'parent-cell-0-0-para',
+                    runs: [{ text: 'Host', fontFamily: 'Arial', fontSize: 12 }],
+                  },
+                  nestedTable('nested-table', 'Nested B'),
+                ],
+              },
+            ],
+          },
+        ],
+      };
+
+      cache.set(parentTable1, 800, 600, { totalHeight: 130 });
+      expect(cache.get(parentTable2, 800, 600)).toBeUndefined();
+    });
+
     it('handles legacy single paragraph cells', () => {
       const table1 = tableBlock(
         'table-1',

packages/layout-engine/painters/dom/src/renderer.ts

@@ -7413,6 +7413,9 @@ const deriveBlockVersion = (block: FlowBlock): string => {
               hash = hashNumber(hash, getRunNumberProp(run, 'baselineShift'));
             }
           } else if (cellBlock?.kind) {
+            // Keep this broader than layout-bridge cache.ts on purpose:
+            // renderer hashes any non-paragraph cell block, while cache.ts hashes
+            // nested tables only. If you tighten one side, review the other.
             // Include nested non-paragraph blocks (notably nested tables inside
             // table cells) so edits there invalidate this parent table version.
             hash = hashString(hash, deriveBlockVersion(cellBlock as FlowBlock));