@invarn/cibuild 2.9.4 → 2.9.7

package/dist/src/yaml/steps/structural-facts.test.js

@@ -1,3039 +0,0 @@
-/**
- * Pure unit tests for the structural-facts deriver (UI-fidelity structural
- * pass, Signal A). Fixture-driven, no toolchain — the deriver turns a
- * per-node layout dump into intent-agnostic geometric facts the fidelity
- * judge checks instead of eyeballing.
- *
- * The canonical regression fixture is the motivating miss: a card clips an
- * overflowing voucher tag; the deriver must surface the bottom clip as a
- * fact so it is never again skipped by eye.
- */
-import { deriveStructuralFacts, derivePresenceFacts, deriveCopyFacts, deriveSpanFacts, deriveLineFacts, deriveColorFacts, deriveBorderFacts, deriveTypefaceFacts, deriveTypeMetricFacts, ciede2000, hexToLab, diffKeyGeometry, buildStructuralBlock, buildReviewScaffold, appearanceReferenceFromPreviousRender, buildAppearanceReferenceFromParams, getStructuralFactsStageInternals, getGeometryStageInternals, } from './structural-facts.js';
-// 200x400 canvas in px for all fixtures unless noted.
-const CANVAS = { left: 0, top: 0, right: 200, bottom: 400 };
-describe('deriveStructuralFacts — containment', () => {
-    test('a fully-contained child produces no clip/overflow fact', () => {
-        const dump = {
-            canvas: CANVAS,
-            nodes: [
-                { id: 'card', bounds: { left: 20, top: 20, right: 180, bottom: 200 }, parentId: null, clipsChildren: true },
-                { id: 'label', bounds: { left: 30, top: 30, right: 170, bottom: 60 }, parentId: 'card', clipsChildren: false },
-            ],
-        };
-        expect(deriveStructuralFacts(dump)).toEqual([]);
-    });
-});
-describe('deriveStructuralFacts — overflow vs clip', () => {
-    test('child overflowing a NON-clipping parent is reported as overflow, not clipped', () => {
-        const dump = {
-            canvas: CANVAS,
-            nodes: [
-                { id: 'row', bounds: { left: 20, top: 20, right: 180, bottom: 100 }, parentId: null, clipsChildren: false },
-                // sticks out 15px past the row's right edge
-                { id: 'chip', bounds: { left: 150, top: 30, right: 195, bottom: 80 }, parentId: 'row', clipsChildren: false },
-            ],
-        };
-        const facts = deriveStructuralFacts(dump);
-        expect(facts).toHaveLength(1);
-        expect(facts[0]).toMatchObject({
-            kind: 'overflow',
-            nodeId: 'chip',
-            parentId: 'row',
-            edges: ['right'],
-            overflowPx: { right: 15 },
-        });
-    });
-    test('child overflowing a CLIPPING parent is reported as clipped-by-parent with the clipped extent', () => {
-        const dump = {
-            canvas: CANVAS,
-            nodes: [
-                { id: 'card', bounds: { left: 20, top: 20, right: 180, bottom: 200 }, parentId: null, clipsChildren: true },
-                // overflows the card's bottom by 24px → that extent is clipped away
-                { id: 'tag', bounds: { left: 60, top: 150, right: 140, bottom: 224 }, parentId: 'card', clipsChildren: false },
-            ],
-        };
-        const facts = deriveStructuralFacts(dump);
-        expect(facts).toHaveLength(1);
-        expect(facts[0]).toMatchObject({
-            kind: 'clipped_by_parent',
-            nodeId: 'tag',
-            clipperId: 'card',
-            edges: ['bottom'],
-            clippedPx: { bottom: 24 },
-        });
-    });
-});
-describe('deriveStructuralFacts — unclippedBounds path (real clamping renders)', () => {
-    // A real clipping parent CLAMPS the child's boundsInRoot to its own edge, so
-    // the clipped `bounds` show no excess — the overflow lives only in
-    // `unclippedBounds`. This is the case bounds-only v1 went blind on.
-    test('a clamped child is reported clipped-by-parent, recovered from unclippedBounds', () => {
-        const dump = {
-            canvas: { left: 0, top: 0, right: 360, bottom: 720 },
-            nodes: [
-                {
-                    id: 'HomeOfferBanner',
-                    bounds: { left: 16, top: 100, right: 344, bottom: 262 },
-                    unclippedBounds: { left: 16, top: 100, right: 344, bottom: 262 },
-                    parentId: null,
-                    clipsChildren: false,
-                },
-                {
-                    // visible bounds CLAMPED to the card bottom (262); the true extent runs
-                    // 18px past it → 18px cut away. The current emitter writes clipsChildren
-                    // false, so only unclippedBounds can reveal this.
-                    id: 'voucherTag',
-                    bounds: { left: 250, top: 210, right: 330, bottom: 262 },
-                    unclippedBounds: { left: 250, top: 210, right: 330, bottom: 280 },
-                    parentId: 'HomeOfferBanner',
-                    clipsChildren: false,
-                },
-            ],
-        };
-        const facts = deriveStructuralFacts(dump);
-        expect(facts).toHaveLength(1);
-        expect(facts[0]).toMatchObject({
-            kind: 'clipped_by_parent',
-            nodeId: 'voucherTag',
-            clipperId: 'HomeOfferBanner',
-            edges: ['bottom'],
-            clippedPx: { bottom: 18 },
-        });
-    });
-    test('a child sticking out of a non-clipping parent (bounds == unclippedBounds) is overflow', () => {
-        const dump = {
-            canvas: CANVAS,
-            nodes: [
-                {
-                    id: 'row',
-                    bounds: { left: 20, top: 20, right: 180, bottom: 100 },
-                    unclippedBounds: { left: 20, top: 20, right: 180, bottom: 100 },
-                    parentId: null,
-                    clipsChildren: false,
-                },
-                {
-                    // not clamped (bounds == unclipped) → the 15px excess is visible.
-                    id: 'chip',
-                    bounds: { left: 150, top: 30, right: 195, bottom: 80 },
-                    unclippedBounds: { left: 150, top: 30, right: 195, bottom: 80 },
-                    parentId: 'row',
-                    clipsChildren: false,
-                },
-            ],
-        };
-        const facts = deriveStructuralFacts(dump);
-        expect(facts).toHaveLength(1);
-        expect(facts[0]).toMatchObject({
-            kind: 'overflow',
-            nodeId: 'chip',
-            parentId: 'row',
-            edges: ['right'],
-            overflowPx: { right: 15 },
-        });
-    });
-});
-describe('deriveStructuralFacts — off-screen', () => {
-    test('a node extending past the canvas is reported off-screen on those edges', () => {
-        const dump = {
-            canvas: CANVAS,
-            nodes: [
-                { id: 'root', bounds: { left: 0, top: 0, right: 200, bottom: 400 }, parentId: null, clipsChildren: false },
-                // bottom edge 30px below the canvas
-                { id: 'sheet', bounds: { left: 0, top: 360, right: 200, bottom: 430 }, parentId: 'root', clipsChildren: false },
-            ],
-        };
-        const facts = deriveStructuralFacts(dump);
-        const offscreen = facts.filter((f) => f.kind === 'off_screen');
-        expect(offscreen).toHaveLength(1);
-        expect(offscreen[0]).toMatchObject({
-            kind: 'off_screen',
-            nodeId: 'sheet',
-            edges: ['bottom'],
-            offscreenPx: { bottom: 30 },
-        });
-    });
-});
-describe('deriveStructuralFacts — overlap', () => {
-    test('two significantly overlapping siblings are reported as an overlap', () => {
-        const dump = {
-            canvas: CANVAS,
-            nodes: [
-                { id: 'root', bounds: { left: 0, top: 0, right: 200, bottom: 400 }, parentId: null, clipsChildren: false },
-                { id: 'a', bounds: { left: 20, top: 20, right: 120, bottom: 120 }, parentId: 'root', clipsChildren: false },
-                { id: 'b', bounds: { left: 80, top: 60, right: 180, bottom: 160 }, parentId: 'root', clipsChildren: false },
-            ],
-        };
-        const overlap = deriveStructuralFacts(dump).filter((f) => f.kind === 'overlap');
-        expect(overlap).toHaveLength(1);
-        expect(overlap[0]).toMatchObject({ kind: 'overlap', nodeIds: ['a', 'b'] });
-    });
-    // --- judged on INK, not the container (icon-ink-ratio 02 Half B) ---
-    //
-    // The live case in render px at density 2: the funnel is an Icon(24.dp) whose
-    // drawable paints only 20x14 of its 24x24 viewport, offset 2 in and 5 down; the
-    // green badge is a plain Box, so its box IS its ink.
-    //
-    //   vector container  48..96 x, 268..316 y     vector INK  52..92 x, 278..306 y
-    //   badge             80..96 x, 268..284 y
-    //
-    // Against the container the badge is entirely inside (ratio 1). Against the ink
-    // it clips one corner: 12 x 6 px.
-    const INK = { kind: 'vector', viewport: { w: 24, h: 24 }, ink: { w: 20, h: 14, x: 2, y: 5 } };
-    const funnelDump = (paintedInk) => ({
-        canvas: { left: 0, top: 0, right: 750, bottom: 356 },
-        nodes: [
-            { id: 'row', bounds: { left: 0, top: 0, right: 750, bottom: 356 }, parentId: null, clipsChildren: false },
-            { id: 'vector', bounds: { left: 48, top: 268, right: 96, bottom: 316 }, parentId: 'row', clipsChildren: false, ...(paintedInk ? { paintedInk } : {}) },
-            { id: 'badge', bounds: { left: 80, top: 268, right: 96, bottom: 284 }, parentId: 'row', clipsChildren: false },
-        ],
-    });
-    test('intersects the painted ink when the node declares where its ink sits', () => {
-        const overlap = deriveStructuralFacts(funnelDump(INK)).filter((f) => f.kind === 'overlap');
-        expect(overlap).toHaveLength(1);
-        expect(overlap[0]).toMatchObject({ nodeIds: ['badge', 'vector'], overlapPx: { width: 12, height: 6 } });
-        // Ratio against the smaller PAINTED area (badge 16x16 = 256), not the container.
-        expect(overlap[0].ratio).toBeCloseTo((12 * 6) / 256, 10);
-    });
-    test('falls back to the container when the ink is unmeasurable', () => {
-        const overlap = deriveStructuralFacts(funnelDump({ kind: 'unmeasurable', why: 'the drawable rotates' })).filter((f) => f.kind === 'overlap');
-        expect(overlap[0]).toMatchObject({ overlapPx: { width: 16, height: 16 } });
-    });
-    test('falls back to the container when the ink declares an extent but no ORIGIN', () => {
-        // Every dump written before the origin was captured. The extent alone cannot
-        // place the ink, and assuming it centred would be a guess.
-        const overlap = deriveStructuralFacts(funnelDump({ kind: 'vector', viewport: { w: 24, h: 24 }, ink: { w: 20, h: 14 } })).filter((f) => f.kind === 'overlap');
-        expect(overlap[0]).toMatchObject({ overlapPx: { width: 16, height: 16 } });
-    });
-    test('drops the overlap entirely when the ink clears the other element', () => {
-        // The false positive Half B exists to kill: the badge sits in the container's
-        // corner, which the ink never reaches.
-        const dump = funnelDump(INK);
-        dump.nodes[2].bounds = { left: 92, top: 268, right: 108, bottom: 278 };
-        expect(deriveStructuralFacts(dump).filter((f) => f.kind === 'overlap')).toEqual([]);
-    });
-    test('barely-touching siblings within tolerance are not an overlap', () => {
-        const dump = {
-            canvas: CANVAS,
-            nodes: [
-                { id: 'root', bounds: { left: 0, top: 0, right: 200, bottom: 400 }, parentId: null, clipsChildren: false },
-                { id: 'a', bounds: { left: 20, top: 20, right: 100, bottom: 100 }, parentId: 'root', clipsChildren: false },
-                { id: 'b', bounds: { left: 100, top: 20, right: 180, bottom: 100 }, parentId: 'root', clipsChildren: false },
-            ],
-        };
-        expect(deriveStructuralFacts(dump).filter((f) => f.kind === 'overlap')).toEqual([]);
-    });
-});
-describe('embedded render-side stage parity', () => {
-    // The render script ships a JS-source port of the deriver. It must produce
-    // byte-identical facts to the canonical typed module, or render-side facts
-    // would silently diverge from what the tests guarantee.
-    const { deriveStructuralFacts: embedded } = getStructuralFactsStageInternals();
-    const fixtures = {
-        clip: {
-            canvas: CANVAS,
-            nodes: [
-                { id: 'card', bounds: { left: 20, top: 20, right: 180, bottom: 200 }, parentId: null, clipsChildren: true },
-                { id: 'tag', bounds: { left: 60, top: 150, right: 140, bottom: 224 }, parentId: 'card', clipsChildren: false },
-            ],
-        },
-        overflow: {
-            canvas: CANVAS,
-            nodes: [
-                { id: 'row', bounds: { left: 20, top: 20, right: 180, bottom: 100 }, parentId: null, clipsChildren: false },
-                { id: 'chip', bounds: { left: 150, top: 30, right: 195, bottom: 80 }, parentId: 'row', clipsChildren: false },
-            ],
-        },
-        overlap: {
-            canvas: CANVAS,
-            nodes: [
-                { id: 'root', bounds: { left: 0, top: 0, right: 200, bottom: 400 }, parentId: null, clipsChildren: false },
-                { id: 'a', bounds: { left: 20, top: 20, right: 120, bottom: 120 }, parentId: 'root', clipsChildren: false },
-                { id: 'b', bounds: { left: 80, top: 60, right: 180, bottom: 160 }, parentId: 'root', clipsChildren: false },
-            ],
-        },
-        // Painted ink with an ORIGIN: the embedded port must map viewport units onto
-        // the layout box exactly as the module does, or production overlaps would be
-        // measured on containers while the tests guarantee ink.
-        overlapInk: {
-            canvas: { left: 0, top: 0, right: 750, bottom: 356 },
-            nodes: [
-                { id: 'row', bounds: { left: 0, top: 0, right: 750, bottom: 356 }, parentId: null, clipsChildren: false },
-                { id: 'vector', bounds: { left: 48, top: 268, right: 96, bottom: 316 }, parentId: 'row', clipsChildren: false, paintedInk: { kind: 'vector', viewport: { w: 24, h: 24 }, ink: { w: 20, h: 14, x: 2, y: 5 } } },
-                { id: 'badge', bounds: { left: 80, top: 268, right: 96, bottom: 284 }, parentId: 'row', clipsChildren: false },
-            ],
-        },
-        // The same ink WITHOUT an origin — the pre-origin fallback must agree too.
-        overlapInkNoOrigin: {
-            canvas: { left: 0, top: 0, right: 750, bottom: 356 },
-            nodes: [
-                { id: 'row', bounds: { left: 0, top: 0, right: 750, bottom: 356 }, parentId: null, clipsChildren: false },
-                { id: 'vector', bounds: { left: 48, top: 268, right: 96, bottom: 316 }, parentId: 'row', clipsChildren: false, paintedInk: { kind: 'vector', viewport: { w: 24, h: 24 }, ink: { w: 20, h: 14 } } },
-                { id: 'badge', bounds: { left: 80, top: 268, right: 96, bottom: 284 }, parentId: 'row', clipsChildren: false },
-            ],
-        },
-        // New unclippedBounds path: a clamped child (clip) and a visible-excess child
-        // (overflow) — exercises the embedded port's new branch, not just the legacy one.
-        clipReal: {
-            canvas: CANVAS,
-            nodes: [
-                { id: 'card', bounds: { left: 20, top: 20, right: 180, bottom: 200 }, unclippedBounds: { left: 20, top: 20, right: 180, bottom: 200 }, parentId: null, clipsChildren: false },
-                { id: 'tag', bounds: { left: 60, top: 150, right: 140, bottom: 200 }, unclippedBounds: { left: 60, top: 150, right: 140, bottom: 224 }, parentId: 'card', clipsChildren: false },
-            ],
-        },
-        overflowReal: {
-            canvas: CANVAS,
-            nodes: [
-                { id: 'row', bounds: { left: 20, top: 20, right: 180, bottom: 100 }, unclippedBounds: { left: 20, top: 20, right: 180, bottom: 100 }, parentId: null, clipsChildren: false },
-                { id: 'chip', bounds: { left: 150, top: 30, right: 195, bottom: 80 }, unclippedBounds: { left: 150, top: 30, right: 195, bottom: 80 }, parentId: 'row', clipsChildren: false },
-            ],
-        },
-        // A duplicated testTag: the collision guard must withhold the child's
-        // (mispairable) overflow and emit the duplicate_tag fact identically.
-        duplicateTag: {
-            canvas: CANVAS,
-            nodes: [
-                { id: 'list', bounds: { left: 0, top: 0, right: 200, bottom: 400 }, parentId: null, clipsChildren: false },
-                { id: 'copy_button', bounds: { left: 20, top: 20, right: 180, bottom: 60 }, parentId: 'list', clipsChildren: false },
-                { id: 'copy_button', bounds: { left: 20, top: 80, right: 180, bottom: 120 }, parentId: 'list', clipsChildren: false },
-                { id: 'copy_button', bounds: { left: 20, top: 140, right: 180, bottom: 180 }, parentId: 'list', clipsChildren: false },
-                { id: 'copy_label', bounds: { left: 30, top: 30, right: 120, bottom: 50 }, parentId: 'copy_button', clipsChildren: false },
-            ],
-        },
-    };
-    for (const [name, dump] of Object.entries(fixtures)) {
-        test(`embedded port matches the module for the ${name} fixture`, () => {
-            expect(embedded(dump)).toEqual(deriveStructuralFacts(dump));
-        });
-    }
-});
-describe('deriveStructuralFacts — motivating regression (voucher tag bottom-clip)', () => {
-    // The render-side layout dump for the HomeOfferBanner-style case: a card
-    // clips children, and the voucher tag (with its euro coin) overflows the
-    // card's bottom. The deriver MUST surface the bottom clip so the verdict
-    // can compare its extent to the design and never miss it by eye again.
-    test('reports the voucher tag as clipped by the card at the bottom, with the clipped px', () => {
-        const dump = {
-            canvas: { left: 0, top: 0, right: 360, bottom: 720 },
-            nodes: [
-                { id: 'HomeOfferBanner', bounds: { left: 16, top: 100, right: 344, bottom: 262 }, parentId: null, clipsChildren: true },
-                { id: 'promoText', bounds: { left: 32, top: 116, right: 240, bottom: 180 }, parentId: 'HomeOfferBanner', clipsChildren: false },
-                // voucher tag overflows the card bottom (262) down to 280 → 18px clipped
-                { id: 'voucherTag', bounds: { left: 250, top: 210, right: 330, bottom: 280 }, parentId: 'HomeOfferBanner', clipsChildren: false },
-            ],
-        };
-        const facts = deriveStructuralFacts(dump);
-        const clip = facts.find((f) => f.kind === 'clipped_by_parent' && f.nodeId === 'voucherTag');
-        expect(clip).toMatchObject({
-            kind: 'clipped_by_parent',
-            nodeId: 'voucherTag',
-            clipperId: 'HomeOfferBanner',
-            edges: ['bottom'],
-            clippedPx: { bottom: 18 },
-        });
-    });
-});
-describe('deriveStructuralFacts — duplicate testTag collision guard', () => {
-    // Repeated rows tagging their pill with one shared testTag: parent lookups
-    // resolve through a last-wins id map, so overflow/clip derived through the
-    // duplicated tag compares arbitrary instances (a child of the first row
-    // measured against the last row's box reads as a huge spurious overflow).
-    // The deriver must refuse to guess — name the collision as a fact and
-    // withhold the pairing-derived facts for that tag.
-    test('three nodes sharing one testTag yield a duplicate_tag fact and no overflow/clip facts through that tag', () => {
-        const dump = {
-            canvas: CANVAS,
-            nodes: [
-                { id: 'list', bounds: { left: 0, top: 0, right: 200, bottom: 400 }, parentId: null, clipsChildren: false },
-                { id: 'copy_button', bounds: { left: 20, top: 20, right: 180, bottom: 60 }, parentId: 'list', clipsChildren: false },
-                { id: 'copy_button', bounds: { left: 20, top: 80, right: 180, bottom: 120 }, parentId: 'list', clipsChildren: false },
-                { id: 'copy_button', bounds: { left: 20, top: 140, right: 180, bottom: 180 }, parentId: 'list', clipsChildren: false },
-                // Sits inside the FIRST pill; paired against the last-wins instance
-                // (top 140) it would read as a spurious 110px top overflow.
-                { id: 'copy_label', bounds: { left: 30, top: 30, right: 120, bottom: 50 }, parentId: 'copy_button', clipsChildren: false },
-            ],
-        };
-        expect(deriveStructuralFacts(dump)).toEqual([
-            { kind: 'duplicate_tag', tag: 'copy_button', instanceCount: 3 },
-        ]);
-    });
-    test('a duplicated node overflowing its unique parent is withheld too — attribution is ambiguous', () => {
-        const dump = {
-            canvas: CANVAS,
-            nodes: [
-                { id: 'row', bounds: { left: 20, top: 20, right: 180, bottom: 100 }, parentId: null, clipsChildren: false },
-                // The first instance sticks out 15px past the row; the second is contained.
-                { id: 'chip', bounds: { left: 150, top: 30, right: 195, bottom: 80 }, parentId: 'row', clipsChildren: false },
-                { id: 'chip', bounds: { left: 30, top: 30, right: 60, bottom: 60 }, parentId: 'row', clipsChildren: false },
-            ],
-        };
-        expect(deriveStructuralFacts(dump)).toEqual([
-            { kind: 'duplicate_tag', tag: 'chip', instanceCount: 2 },
-        ]);
-    });
-});
-// ---- Signal B: key-geometry diff + inline structural-block assembly ----
-describe('diffKeyGeometry — dimensional gaps', () => {
-    test('reports a size delta on the right element beyond tolerance', () => {
-        const generated = { card: { width: 328, height: 81 }, chip: { width: 64, height: 24 } };
-        const reference = { card: { width: 328, height: 72 }, chip: { width: 64, height: 24 } };
-        expect(diffKeyGeometry(generated, reference)).toEqual([
-            { elementId: 'card', deltas: [{ dimension: 'height', generated: 81, reference: 72, delta: 9 }] },
-        ]);
-    });
-    test('degrades cleanly to no deltas when there is no reference geometry', () => {
-        const generated = { card: { width: 100, height: 50 } };
-        expect(diffKeyGeometry(generated, null)).toEqual([]);
-        expect(diffKeyGeometry(generated, {})).toEqual([]);
-    });
-});
-// The golden hub promo banner (xhdpi, density 2): banner fills the 720px canvas,
-// voucher 96x96dp vs Figma 81x81, banner 96dp tall vs Figma 72, copy<->voucher
-// overlap. Identical fixture + expectations to Invarn's fidelity-structural test,
-// so preview (Invarn) and run (cibuild) assemble byte-identical blocks.
-const HUB_PROMO_DUMP = {
-    canvas: { left: 0, top: 0, right: 720, bottom: 192 },
-    nodes: [
-        { id: 'node-1', bounds: { left: 0, top: 0, right: 720, bottom: 192 }, unclippedBounds: { left: 0, top: 0, right: 720, bottom: 192 }, parentId: null, clipsChildren: false },
-        { id: 'banner', bounds: { left: 0, top: 0, right: 720, bottom: 192 }, unclippedBounds: { left: 0, top: 0, right: 720, bottom: 192 }, parentId: 'node-1', clipsChildren: false },
-        { id: 'voucher', bounds: { left: 496, top: 0, right: 688, bottom: 192 }, unclippedBounds: { left: 496, top: 0, right: 688, bottom: 192 }, parentId: 'banner', clipsChildren: false },
-        { id: 'copy', bounds: { left: 64, top: 24, right: 656, bottom: 117 }, unclippedBounds: { left: 64, top: 24, right: 656, bottom: 117 }, parentId: 'banner', clipsChildren: false },
-    ],
-};
-const HUB_PROMO_REFERENCE = { voucher: { w: 81, h: 81 }, banner: { w: 343, h: 72 } };
-describe('buildStructuralBlock — facts only (no reference geometry)', () => {
-    test('surfaces facts + summary; geometry describes what rasterized (rendered-only boxes)', () => {
-        const block = buildStructuralBlock(HUB_PROMO_DUMP, null, 2);
-        expect(block.facts).toEqual([
-            { kind: 'overlap', nodeIds: ['copy', 'voucher'], overlapPx: { width: 160, height: 93 }, ratio: 0.4036458333333333 },
-        ]);
-        // Summary is byte-identical to the pre-description era: max deltas stay
-        // null (no comparison ran), clean is fact-driven only.
-        expect(block.summary).toEqual({ clean: false, factCount: 1, maxSizeDeltaDp: null, maxClipDeltaDp: null });
-        // Description vs comparison: rendered boxes persist for every authored-tag
-        // node even without a reference. No design/deltas/sizeFlag — those exist
-        // only where a reference declares the element. The synthetic root
-        // (node-1) is not fact-named, so it does not persist.
-        expect(block.geometry).toEqual({
-            unit: 'dp',
-            density: 2,
-            elements: [
-                { id: 'banner', rendered: { w: 360, h: 96, x: 0, y: 0 } },
-                { id: 'voucher', rendered: { w: 96, h: 96, x: 248, y: 0 } },
-                // copy's honest height is 93px ÷ 2 = 46.5 — the box persists at
-                // 2-decimal precision; 47 was the whole-dp era's quantization.
-                { id: 'copy', rendered: { w: 296, h: 46.5, x: 32, y: 12 } },
-            ],
-        });
-    });
-    test('a fact-named synthetic node persists its box; unnamed synthetics never do', () => {
-        // An untagged sibling (node-7) overlaps the tagged chip: the deriver names
-        // it in the overlap fact, so the collision scene needs its box. The
-        // untagged root (node-1) participates in no fact and stays out.
-        const dump = {
-            canvas: { left: 0, top: 0, right: 200, bottom: 400 },
-            nodes: [
-                { id: 'node-1', bounds: { left: 0, top: 0, right: 200, bottom: 400 }, parentId: null, clipsChildren: false },
-                { id: 'chip', bounds: { left: 0, top: 0, right: 100, bottom: 40 }, parentId: 'node-1', clipsChildren: false },
-                { id: 'node-7', bounds: { left: 40, top: 0, right: 140, bottom: 40 }, parentId: 'node-1', clipsChildren: false },
-            ],
-        };
-        const block = buildStructuralBlock(dump, null, 2);
-        expect(block.facts).toEqual([
-            expect.objectContaining({ kind: 'overlap', nodeIds: ['chip', 'node-7'] }),
-        ]);
-        expect(block.geometry?.elements).toEqual([
-            { id: 'chip', rendered: { w: 50, h: 20, x: 0, y: 0 } },
-            { id: 'node-7', rendered: { w: 50, h: 20, x: 20, y: 0 } },
-        ]);
-    });
-    test('a duplicated testTag persists no box (last-wins geometry is ambiguous)', () => {
-        const dump = {
-            canvas: { left: 0, top: 0, right: 200, bottom: 400 },
-            nodes: [
-                { id: 'node-1', bounds: { left: 0, top: 0, right: 200, bottom: 400 }, parentId: null, clipsChildren: false },
-                { id: 'chip', bounds: { left: 0, top: 0, right: 40, bottom: 20 }, parentId: 'node-1', clipsChildren: false },
-                { id: 'chip', bounds: { left: 60, top: 0, right: 100, bottom: 20 }, parentId: 'node-1', clipsChildren: false },
-                { id: 'label', bounds: { left: 0, top: 40, right: 40, bottom: 60 }, parentId: 'node-1', clipsChildren: false },
-            ],
-        };
-        const block = buildStructuralBlock(dump, null, 2);
-        // The duplicate_tag fact carries the collision; a box for an arbitrary
-        // instance would be misleading, so only the unambiguous tag persists.
-        expect(block.geometry?.elements).toEqual([
-            { id: 'label', rendered: { w: 20, h: 10, x: 0, y: 20 } },
-        ]);
-    });
-});
-describe('buildStructuralBlock — with reference geometry (Signal B)', () => {
-    test('reports the golden size deltas and a not-clean summary', () => {
-        const block = buildStructuralBlock(HUB_PROMO_DUMP, HUB_PROMO_REFERENCE, 2);
-        expect(block.summary).toEqual({ clean: false, factCount: 1, maxSizeDeltaDp: 24, maxClipDeltaDp: 0 });
-        expect(block.geometry?.unit).toBe('dp');
-        expect(block.geometry?.density).toBe(2);
-        const voucher = block.geometry?.elements.find((e) => e.id === 'voucher');
-        expect(voucher).toEqual({
-            id: 'voucher',
-            // rendered now carries x/y (dp) for the clip reference; design stays
-            // w/h-only here (the reference declared no x/y).
-            rendered: { w: 96, h: 96, x: 248, y: 0 },
-            design: { w: 81, h: 81 },
-            deltas: [{ dimension: 'w', delta: 15 }, { dimension: 'h', delta: 15 }],
-            sizeFlag: true,
-            // The render ancestry (icon-ink-ratio 05): `voucher` sits inside `banner`,
-            // which sits at the root. This assertion is exhaustive on purpose — it is
-            // what noticed the new field, and it is what will notice the next one.
-            ancestors: ['banner', 'node-1'],
-        });
-        const banner = block.geometry?.elements.find((e) => e.id === 'banner');
-        expect(banner?.sizeFlag).toBe(true);
-        expect(banner?.deltas).toContainEqual({ dimension: 'h', delta: 24 });
-    });
-    test('a declared tag absent from the render persists its design box alone', () => {
-        // The absence itself is reported by the presence channel (element_missing);
-        // this is the BOX that lets that report's evidence point at the region the
-        // design reserved. Design-only: no rendered half, no comparison fields
-        // (there is nothing to compare), no ancestry (there is no node to chain
-        // from). Exhaustive on purpose, like the voucher assertion above.
-        const reference = { ...HUB_PROMO_REFERENCE, cta: { w: 112, h: 36, x: 16, y: 200 } };
-        const block = buildStructuralBlock(HUB_PROMO_DUMP, reference, 2);
-        expect(block.geometry?.elements.find((e) => e.id === 'cta')).toEqual({
-            id: 'cta',
-            design: { w: 112, h: 36, x: 16, y: 200 },
-        });
-        // The summary must not move: the deltas and flags that drive it exist only
-        // on compared elements, and an element that rendered nothing compares to
-        // nothing. Byte-identical to the same dump judged without the absent tag.
-        expect(block.summary).toEqual(buildStructuralBlock(HUB_PROMO_DUMP, HUB_PROMO_REFERENCE, 2).summary);
-    });
-    test('a w/h-only declared tag absent from the render stays w/h — x/y are never invented', () => {
-        const reference = { ...HUB_PROMO_REFERENCE, chip: { w: 40, h: 20 } };
-        const block = buildStructuralBlock(HUB_PROMO_DUMP, reference, 2);
-        expect(block.geometry?.elements.find((e) => e.id === 'chip')).toEqual({
-            id: 'chip',
-            design: { w: 40, h: 20 },
-        });
-    });
-    test('a duplicated declared tag emits nothing — it rendered (twice); last-wins is ambiguous', () => {
-        const dump = {
-            canvas: { left: 0, top: 0, right: 200, bottom: 400 },
-            nodes: [
-                { id: 'node-1', bounds: { left: 0, top: 0, right: 200, bottom: 400 }, parentId: null, clipsChildren: false },
-                { id: 'chip', bounds: { left: 0, top: 0, right: 40, bottom: 20 }, parentId: 'node-1', clipsChildren: false },
-                { id: 'chip', bounds: { left: 60, top: 0, right: 100, bottom: 20 }, parentId: 'node-1', clipsChildren: false },
-            ],
-        };
-        const block = buildStructuralBlock(dump, { chip: { w: 20, h: 10, x: 0, y: 0 } }, 2);
-        // Not a pair, and not a design-only entry either: the tag DID render, so
-        // "absent" would be a lie; the duplicate_tag fact carries the collision.
-        expect(block.geometry?.elements.find((e) => e.id === 'chip')).toBeUndefined();
-    });
-    test('authored elements outside the reference ride along as rendered-only boxes', () => {
-        const block = buildStructuralBlock(HUB_PROMO_DUMP, HUB_PROMO_REFERENCE, 2);
-        // The reference declares voucher+banner; `copy` is authored but undeclared,
-        // so it persists as a description (rendered only, no comparison fields),
-        // appended after the compared elements.
-        expect(block.geometry?.elements.map((e) => e.id)).toEqual(['voucher', 'banner', 'copy']);
-        const copy = block.geometry?.elements.find((e) => e.id === 'copy');
-        // 93px ÷ 2 = 46.5 — 2-decimal persistence; 47 was the quantization.
-        expect(copy).toEqual({ id: 'copy', rendered: { w: 296, h: 46.5, x: 32, y: 12 } });
-        // The summary still reflects the comparison only.
-        expect(block.summary).toEqual({ clean: false, factCount: 1, maxSizeDeltaDp: 24, maxClipDeltaDp: 0 });
-    });
-});
-// ---- Signal B v2: per-edge overhang (clip) diff ----
-//
-// The euro-coin miss: a voucher tag meant to overflow-and-clip on the bottom-right
-// reproduced at the wrong size, so its bottom clip came out wrong even though its
-// width matched. Signal B v1 (raw w/h) is blind here — the load-bearing invariant
-// for a clipping element is its per-edge OVERHANG (= the clip), not its raw size.
-// These two fixtures are the field validation numbers (px @ density 2): the
-// logged-in state MUST flag (bottom Δ−9), the guest state MUST NOT (bottom Δ+2,
-// within tolerance). Same fixtures + expectations as Invarn's preview copy.
-// Logged-in: rendered voucher unclipped 289..370 × 16..86.5dp, frame card 343×70.5dp.
-// right overhang 27=27 (match); bottom overhang 16 vs design 25 → Δ−9 (FLAG).
-const OVERHANG_LOGGED_IN_DUMP = {
-    canvas: { left: 0, top: 0, right: 760, bottom: 200 },
-    nodes: [
-        { id: 'node-1', bounds: { left: 0, top: 0, right: 760, bottom: 200 }, unclippedBounds: { left: 0, top: 0, right: 760, bottom: 200 }, parentId: null, clipsChildren: false },
-        { id: 'banner', bounds: { left: 0, top: 0, right: 686, bottom: 141 }, unclippedBounds: { left: 0, top: 0, right: 686, bottom: 141 }, parentId: 'node-1', clipsChildren: false },
-        { id: 'voucher', bounds: { left: 578, top: 32, right: 740, bottom: 173 }, unclippedBounds: { left: 578, top: 32, right: 740, bottom: 173 }, parentId: 'banner', clipsChildren: false },
-    ],
-};
-const OVERHANG_LOGGED_IN_REF = { banner: { x: 0, y: 0, w: 343, h: 72 }, voucher: { x: 289, y: 16, w: 81, h: 81 } };
-// Guest: rendered voucher unclipped 272..381 × 19..127.5dp, frame card 343×108.5dp.
-// right overhang 38=38 (match); bottom overhang 19 vs design 17 → Δ+2 (within tol, PASS).
-const OVERHANG_GUEST_DUMP = {
-    canvas: { left: 0, top: 0, right: 800, bottom: 280 },
-    nodes: [
-        { id: 'node-1', bounds: { left: 0, top: 0, right: 800, bottom: 280 }, unclippedBounds: { left: 0, top: 0, right: 800, bottom: 280 }, parentId: null, clipsChildren: false },
-        { id: 'banner', bounds: { left: 0, top: 0, right: 686, bottom: 217 }, unclippedBounds: { left: 0, top: 0, right: 686, bottom: 217 }, parentId: 'node-1', clipsChildren: false },
-        { id: 'voucher', bounds: { left: 544, top: 38, right: 762, bottom: 255 }, unclippedBounds: { left: 544, top: 38, right: 762, bottom: 255 }, parentId: 'banner', clipsChildren: false },
-    ],
-};
-const OVERHANG_GUEST_REF = { banner: { x: 0, y: 0, w: 343, h: 111 }, voucher: { x: 272, y: 19, w: 109, h: 109 } };
-// Voucher is the correct 81×81 size but sits 5dp too high (y 11 vs design 16),
-// so the bottom clip is 5dp short (overhang 20 vs 25) for a POSITION reason.
-const OVERHANG_POSITION_DUMP = {
-    canvas: { left: 0, top: 0, right: 800, bottom: 200 },
-    nodes: [
-        { id: 'node-1', bounds: { left: 0, top: 0, right: 800, bottom: 200 }, unclippedBounds: { left: 0, top: 0, right: 800, bottom: 200 }, parentId: null, clipsChildren: false },
-        { id: 'card', bounds: { left: 0, top: 0, right: 686, bottom: 144 }, unclippedBounds: { left: 0, top: 0, right: 686, bottom: 144 }, parentId: 'node-1', clipsChildren: false },
-        { id: 'voucher', bounds: { left: 578, top: 22, right: 740, bottom: 184 }, unclippedBounds: { left: 578, top: 22, right: 740, bottom: 184 }, parentId: 'card', clipsChildren: false },
-    ],
-};
-const OVERHANG_POSITION_REF = { card: { x: 0, y: 0, w: 343, h: 72 }, voucher: { x: 289, y: 16, w: 81, h: 81 } };
-// MISSING clip: the voucher is squashed + sits tangent to the card edges, so the
-// render does NOT overflow at all (no clip), while the design overflows-and-clips
-// (right 27 / bottom 25). Signal B v1 was SILENT here (no rendered overflow → no
-// overhang). The symmetric (design-side) candidate rule must flag it.
-const OVERHANG_MISSING_DUMP = {
-    canvas: { left: 0, top: 0, right: 800, bottom: 200 },
-    nodes: [
-        { id: 'node-1', bounds: { left: 0, top: 0, right: 800, bottom: 200 }, unclippedBounds: { left: 0, top: 0, right: 800, bottom: 200 }, parentId: null, clipsChildren: false },
-        { id: 'card', bounds: { left: 0, top: 0, right: 686, bottom: 142 }, unclippedBounds: { left: 0, top: 0, right: 686, bottom: 142 }, parentId: 'node-1', clipsChildren: false },
-        { id: 'voucher', bounds: { left: 524, top: 0, right: 686, bottom: 142 }, unclippedBounds: { left: 524, top: 0, right: 686, bottom: 142 }, parentId: 'card', clipsChildren: false },
-    ],
-};
-const OVERHANG_MISSING_REF = { card: { x: 0, y: 0, w: 343, h: 72 }, voucher: { x: 289, y: 16, w: 81, h: 81 } };
-describe('buildStructuralBlock — per-edge overhang (Signal B v2)', () => {
-    test('logged-in voucher: flags the bottom clip (Δ−9), not the matching right edge', () => {
-        const block = buildStructuralBlock(OVERHANG_LOGGED_IN_DUMP, OVERHANG_LOGGED_IN_REF, 2);
-        const voucher = block.geometry?.elements.find((e) => e.id === 'voucher');
-        expect(voucher?.overhang).toEqual({
-            unit: 'dp',
-            rendered: { right: 27, bottom: 16 },
-            design: { right: 27, bottom: 25 },
-            deltas: [{ edge: 'bottom', delta: -9 }],
-            clipFlag: true,
-            // the clip is explained by the voucher's own height (71 vs 81dp) tracking
-            // the frame (the fillMaxHeight tell) — a sizing defect, not an intended clip.
-            sizeDriven: true,
-            frameRelative: true,
-            positionDriven: false,
-        });
-        expect(block.summary.clean).toBe(false);
-        expect(block.summary.maxClipDeltaDp).toBe(9);
-    });
-    test('guest voucher: matching right edge, bottom within tolerance → no clipFlag', () => {
-        const block = buildStructuralBlock(OVERHANG_GUEST_DUMP, OVERHANG_GUEST_REF, 2);
-        const voucher = block.geometry?.elements.find((e) => e.id === 'voucher');
-        expect(voucher?.overhang).toEqual({
-            unit: 'dp',
-            rendered: { right: 38, bottom: 19 },
-            design: { right: 38, bottom: 17 },
-            deltas: [],
-            clipFlag: false,
-            sizeDriven: false,
-            frameRelative: false,
-            positionDriven: false,
-        });
-    });
-    test('a fully-contained element gets no overhang block', () => {
-        const block = buildStructuralBlock(HUB_PROMO_DUMP, HUB_PROMO_REFERENCE, 2);
-        const voucher = block.geometry?.elements.find((e) => e.id === 'voucher');
-        expect(voucher?.overhang).toBeUndefined();
-        expect(block.summary.maxClipDeltaDp).toBe(0);
-    });
-    // Correct SIZE (81×81) but positioned 5dp too high → the bottom clip comes out
-    // short (20 vs 25) for a POSITION reason, not a size one. This is the residual
-    // that got waved off as "sub-pixel rounding": positionDriven must flag it.
-    test('a correctly-sized element clipped wrong by its position is positionDriven, not sizeDriven', () => {
-        const block = buildStructuralBlock(OVERHANG_POSITION_DUMP, OVERHANG_POSITION_REF, 2);
-        const voucher = block.geometry?.elements.find((e) => e.id === 'voucher');
-        expect(voucher?.overhang).toEqual({
-            unit: 'dp',
-            rendered: { right: 27, bottom: 20 },
-            design: { right: 27, bottom: 25 },
-            deltas: [{ edge: 'bottom', delta: -5 }],
-            clipFlag: true,
-            sizeDriven: false,
-            frameRelative: false,
-            positionDriven: true,
-        });
-        const review = buildReviewScaffold(block);
-        const clipRow = review.rows.find((r) => r.element === 'voucher' && r.fact.startsWith('clip'));
-        expect(clipRow?.fact).toBe('clip bottom 20dp vs design 25dp (-5) — driven by the element\'s position relative to the frame; reposition to the design offset');
-    });
-    test('a MISSING clip (design overflows, render contained/tangent) flags via the design-side candidate', () => {
-        const block = buildStructuralBlock(OVERHANG_MISSING_DUMP, OVERHANG_MISSING_REF, 2);
-        const voucher = block.geometry?.elements.find((e) => e.id === 'voucher');
-        expect(voucher?.overhang).toEqual({
-            unit: 'dp',
-            rendered: { right: 0, bottom: 0 },
-            design: { right: 27, bottom: 25 },
-            deltas: [
-                { edge: 'right', delta: -27 },
-                { edge: 'bottom', delta: -25 },
-            ],
-            clipFlag: true,
-            sizeDriven: true,
-            frameRelative: true,
-            positionDriven: true,
-        });
-        expect(block.summary.clean).toBe(false);
-        expect(block.summary.maxClipDeltaDp).toBe(27);
-        const review = buildReviewScaffold(block);
-        const clipRow = review.rows.find((r) => r.element === 'voucher' && r.fact.startsWith('clip'));
-        expect(clipRow?.fact).toContain('right 0dp vs design 27dp (-27)');
-        expect(clipRow?.fact).toContain('reposition to the design offset');
-    });
-});
-describe('buildReviewScaffold — run-only verdict obligation', () => {
-    test('forces a verdict per flagged element + fact, with the golden mustExplain', () => {
-        const block = buildStructuralBlock(HUB_PROMO_DUMP, HUB_PROMO_REFERENCE, 2);
-        const review = buildReviewScaffold(block);
-        expect(review.verdict).toBeNull();
-        expect(review.mustExplain).toEqual(['voucher', 'banner', 'copy↔voucher']);
-        expect(review.rows.every((r) => r.verdict === null)).toBe(true);
-        expect(review.rows.find((r) => r.element === 'voucher')).toEqual({
-            element: 'voucher',
-            rendered: '96×96dp',
-            design: '81×81dp',
-            fact: 'size +15×+15',
-            verdict: null,
-        });
-        expect(review.rows.find((r) => r.element === 'copy↔voucher')?.fact).toBe('overlap 160×93px (ratio 0.40)');
-    });
-    test('a clipFlag element forces a verdict row describing the overhang mismatch', () => {
-        const block = buildStructuralBlock(OVERHANG_LOGGED_IN_DUMP, OVERHANG_LOGGED_IN_REF, 2);
-        const review = buildReviewScaffold(block);
-        expect(review.mustExplain).toContain('voucher');
-        const clipRow = review.rows.find((r) => r.element === 'voucher' && r.fact.startsWith('clip'));
-        expect(clipRow).toEqual({
-            element: 'voucher',
-            rendered: 'bottom 16dp',
-            design: 'bottom 25dp',
-            fact: "clip bottom 16dp vs design 25dp (-9) — driven by the element's own size (h 71 vs 81dp) tracking the frame (parent-relative); reproduce at the fixed design size",
-            verdict: null,
-        });
-    });
-});
-// ---- Signal C: element-presence facts (appearance container) ----
-describe('derivePresenceFacts — set difference over element ids', () => {
-    test('equal element sets produce no facts', () => {
-        expect(derivePresenceFacts(['a', 'b', 'c'], ['a', 'b', 'c'])).toEqual([]);
-    });
-    test('an id only in the reference yields element_missing', () => {
-        // rendered lacks `voucher`, which the reference declares.
-        expect(derivePresenceFacts(['banner'], ['banner', 'voucher'])).toEqual([
-            { kind: 'element_missing', elementId: 'voucher' },
-        ]);
-    });
-    test('an id only in the render yields element_extra', () => {
-        // rendered has an extra `debugOverlay` the reference does not declare.
-        expect(derivePresenceFacts(['banner', 'debugOverlay'], ['banner'])).toEqual([
-            { kind: 'element_extra', elementId: 'debugOverlay' },
-        ]);
-    });
-    test('reports both a missing and an extra id, missing before extra', () => {
-        expect(derivePresenceFacts(['banner', 'extra'], ['banner', 'gone'])).toEqual([
-            { kind: 'element_missing', elementId: 'gone' },
-            { kind: 'element_extra', elementId: 'extra' },
-        ]);
-    });
-    test('result is order-independent — same sets in any input order give the same facts', () => {
-        const a = derivePresenceFacts(['a', 'b', 'c'], ['b', 'd', 'a']);
-        const b = derivePresenceFacts(['c', 'b', 'a'], ['d', 'a', 'b']);
-        expect(a).toEqual(b);
-        // d missing, c extra — independent of how the ids were ordered or duplicated.
-        expect(derivePresenceFacts(['c', 'c', 'b', 'a'], ['a', 'b', 'd', 'd'])).toEqual([
-            { kind: 'element_missing', elementId: 'd' },
-            { kind: 'element_extra', elementId: 'c' },
-        ]);
-    });
-});
-describe('ciede2000 — CIEDE2000 ΔE against the Sharma supplementary test data', () => {
-    // Canonical test vectors from Sharma, Wu & Dalal, "The CIEDE2000 Color-
-    // Difference Formula: Implementation Notes, Supplementary Test Data, and
-    // Mathematical Observations" (2005). Each row: Lab1, Lab2, expected ΔE00.
-    // These exercise the hue-discontinuity and high-chroma edge cases an
-    // incorrect implementation gets wrong.
-    const SHARMA = [
-        [[50, 2.6772, -79.7751], [50, 0, -82.7485], 2.0425],
-        [[50, 3.1571, -77.2803], [50, 0, -82.7485], 2.8615],
-        [[50, 2.8361, -74.02], [50, 0, -82.7485], 3.4412],
-        [[50, -1.3802, -84.2814], [50, 0, -82.7485], 1.0],
-        [[50, -1.1848, -84.8006], [50, 0, -82.7485], 1.0],
-        [[50, 0, 0], [50, -1, 2], 2.3669],
-        [[50, 2.49, -0.001], [50, -2.49, 0.0009], 7.1792],
-        [[50, 2.49, -0.001], [50, -2.49, 0.0011], 7.2195],
-        [[50, -0.001, 2.49], [50, 0.0009, -2.49], 4.8045],
-        [[50, 2.5, 0], [50, 0, -2.5], 4.3065],
-        [[50, 2.5, 0], [73, 25, -18], 27.1492],
-        [[50, 2.5, 0], [50, 3.1736, 0.5854], 1.0],
-        [[60.2574, -34.0099, 36.2677], [60.4626, -34.1751, 39.4387], 1.2644],
-        [[63.0109, -31.0961, -5.8663], [62.8187, -29.7946, -4.0864], 1.263],
-        [[22.7233, 20.0904, -46.694], [23.0331, 14.973, -42.5619], 2.0373],
-        [[90.8027, -2.0831, 1.441], [91.1528, -1.6435, 0.0447], 1.4441],
-        [[2.0776, 0.0795, -1.135], [0.9033, -0.0636, -0.5514], 0.9082],
-    ];
-    for (const [lab1, lab2, expected] of SHARMA) {
-        test(`ΔE(${lab1.join(',')} ; ${lab2.join(',')}) ≈ ${expected}`, () => {
-            expect(ciede2000(lab1, lab2)).toBeCloseTo(expected, 4);
-        });
-    }
-    test('identical colors have ΔE 0 and the metric is symmetric', () => {
-        expect(ciede2000([42, 7, -13], [42, 7, -13])).toBe(0);
-        expect(ciede2000([50, 2.5, 0], [73, 25, -18])).toBeCloseTo(ciede2000([73, 25, -18], [50, 2.5, 0]), 10);
-    });
-});
-describe('hexToLab — sRGB hex → CIELAB (D65)', () => {
-    test('white maps to L≈100, a≈0, b≈0', () => {
-        const [L, a, b] = hexToLab('#ffffff');
-        expect(L).toBeCloseTo(100, 3);
-        expect(a).toBeCloseTo(0, 3);
-        expect(b).toBeCloseTo(0, 3);
-    });
-    test('black maps to L≈0', () => {
-        const [L] = hexToLab('#000000');
-        expect(L).toBeCloseTo(0, 3);
-    });
-    test('accepts hex with or without a leading # and is case-insensitive', () => {
-        expect(hexToLab('FFFFFF')).toEqual(hexToLab('#ffffff'));
-    });
-});
-describe('deriveColorFacts — rendered vs reference color per element/channel', () => {
-    test('matching colors produce no fact', () => {
-        expect(deriveColorFacts({ card: { fill: '#ff0000', text: '#000000' } }, { card: { fill: '#ff0000', text: '#000000' } })).toEqual([]);
-        // case-insensitive match
-        expect(deriveColorFacts({ card: { fill: '#FF0000' } }, { card: { fill: '#ff0000' } })).toEqual([]);
-    });
-    // Opacity parity with the Invarn CLI twin (issue 14b). The design's Apply CTA
-    // was painted at 30% (disabled) and the render at 100% (enabled); both hexes
-    // were #3ca000, so ΔE was 0 and nothing ever flagged.
-    test('a design translucency the render paints opaque yields one color_alpha fact', () => {
-        const facts = deriveColorFacts({ 'button-cta': { fill: '#3ca000' } }, { 'button-cta': { fill: '#3ca000', fillAlpha: 0.3 } });
-        expect(facts).toHaveLength(1);
-        expect(facts[0]).toMatchObject({
-            kind: 'color_alpha', elementId: 'button-cta', channel: 'fill', rendered: 1, reference: 0.3,
-        });
-    });
-    test('a render matching the design translucency produces no fact', () => {
-        expect(deriveColorFacts({ 'button-cta': { fill: '#3ca000', fillAlpha: 0.3 } }, { 'button-cta': { fill: '#3ca000', fillAlpha: 0.3 } })).toEqual([]);
-    });
-    test('an opaque design says nothing about alpha, so a translucent render is not graded', () => {
-        expect(deriveColorFacts({ 'button-cta': { fill: '#3ca000', fillAlpha: 0.3 } }, { 'button-cta': { fill: '#3ca000' } })).toEqual([]);
-    });
-    test('a rounding-step alpha difference is ignored', () => {
-        expect(deriveColorFacts({ 'button-cta': { fill: '#3ca000', fillAlpha: 0.2999 } }, { 'button-cta': { fill: '#3ca000', fillAlpha: 0.3 } })).toEqual([]);
-    });
-    test('a fill divergence yields one fill-channel fact with the correct ΔE', () => {
-        const facts = deriveColorFacts({ card: { fill: '#ff0000' } }, { card: { fill: '#00ff00' } });
-        expect(facts).toHaveLength(1);
-        expect(facts[0]).toMatchObject({ kind: 'color', elementId: 'card', channel: 'fill', rendered: '#ff0000', reference: '#00ff00' });
-        expect(facts[0].deltaE).toBeCloseTo(ciede2000(hexToLab('#ff0000'), hexToLab('#00ff00')), 10);
-    });
-    test('fill and text are distinct channels — a wrong text color does not collapse with a correct fill', () => {
-        const facts = deriveColorFacts({ card: { fill: '#ffffff', text: '#111111' } }, { card: { fill: '#ffffff', text: '#000000' } });
-        expect(facts).toHaveLength(1);
-        expect(facts[0]).toMatchObject({ kind: 'color', elementId: 'card', channel: 'text', rendered: '#111111', reference: '#000000' });
-    });
-    test('both channels diverging yield two facts, fill before text', () => {
-        const facts = deriveColorFacts({ card: { fill: '#ff0000', text: '#111111' } }, { card: { fill: '#00ff00', text: '#000000' } });
-        expect(facts.map((f) => f.channel)).toEqual(['fill', 'text']);
-    });
-    test('an element/channel with no color signal produces no fact', () => {
-        // reference declares a fill the render never exposes → no signal → no fact
-        expect(deriveColorFacts({ card: {} }, { card: { fill: '#ff0000' } })).toEqual([]);
-        // render has a color the reference never declared → no reference signal → no fact
-        expect(deriveColorFacts({ card: { text: '#abcdef' } }, { card: { fill: '#ff0000' } })).toEqual([]);
-        // element absent from the reference entirely → no fact
-        expect(deriveColorFacts({ extra: { fill: '#ff0000' } }, {})).toEqual([]);
-    });
-    test('result is order-independent and deterministic (sorted by element id)', () => {
-        const a = deriveColorFacts({ b: { fill: '#ff0000' }, a: { fill: '#000000' } }, { a: { fill: '#ffffff' }, b: { fill: '#ff0000' } });
-        const b = deriveColorFacts({ a: { fill: '#000000' }, b: { fill: '#ff0000' } }, { b: { fill: '#ff0000' }, a: { fill: '#ffffff' } });
-        expect(a).toEqual(b);
-        expect(a.map((f) => f.elementId)).toEqual(['a']);
-    });
-});
-describe('deriveCopyFacts — rendered vs reference text per element', () => {
-    test('identical text produces no fact', () => {
-        expect(deriveCopyFacts({ title: '5 EUR off' }, { title: '5 EUR off' })).toEqual([]);
-    });
-    test('differing text yields text_mismatch with both strings', () => {
-        expect(deriveCopyFacts({ title: '5 EUR' }, { title: '5 EUR off' })).toEqual([{ kind: 'text_mismatch', elementId: 'title', rendered: '5 EUR', reference: '5 EUR off' }]);
-    });
-    test('reference text with empty/absent render yields text_missing', () => {
-        // absent render entry
-        expect(deriveCopyFacts({}, { cta: 'Shop now' })).toEqual([
-            { kind: 'text_missing', elementId: 'cta', reference: 'Shop now' },
-        ]);
-        // empty-string render entry counts as no rendered text
-        expect(deriveCopyFacts({ cta: '' }, { cta: 'Shop now' })).toEqual([
-            { kind: 'text_missing', elementId: 'cta', reference: 'Shop now' },
-        ]);
-    });
-    test('an element with no reference text produces no fact (absence of signal is not a divergence)', () => {
-        // render has text the reference never declared → no fact (no reference signal)
-        expect(deriveCopyFacts({ debugLabel: 'x' }, {})).toEqual([]);
-        // reference declares an empty string → no signal → no fact regardless of render
-        expect(deriveCopyFacts({ note: 'hi' }, { note: '' })).toEqual([]);
-    });
-    test('result is order-independent and deterministic (sorted by element id)', () => {
-        const a = deriveCopyFacts({ b: 'r', a: 'wrong' }, { a: 'right', b: 'r', c: 'gone' });
-        const b = deriveCopyFacts({ a: 'wrong', b: 'r' }, { c: 'gone', b: 'r', a: 'right' });
-        expect(a).toEqual(b);
-        expect(a).toEqual([
-            { kind: 'text_mismatch', elementId: 'a', rendered: 'wrong', reference: 'right' },
-            { kind: 'text_missing', elementId: 'c', reference: 'gone' },
-        ]);
-    });
-});
-describe('deriveSpanFacts — declared highlight extents vs rendered background spans', () => {
-    test('a rendered span matching the declared extent produces no fact', () => {
-        expect(deriveSpanFacts({ discountText: [{ start: 4, end: 13, text: '5 EUR off', background: '#ffe45e' }] }, { discountText: { text: '5 EUR off' } })).toEqual([]);
-    });
-    test('a rendered span chipping the wrong extent yields span_mismatch with both strings', () => {
-        // The motivating case: the design chips the full phrase, the wrapper
-        // highlighted only the amount.
-        expect(deriveSpanFacts({ discountText: [{ start: 4, end: 9, text: '5 EUR', background: '#ffe45e' }] }, { discountText: { text: '5 EUR off' } })).toEqual([
-            { kind: 'span_mismatch', elementId: 'discountText', rendered: '5 EUR', reference: '5 EUR off' },
-        ]);
-    });
-    test('a node that emitted no spans produces no fact (old packages degrade gracefully)', () => {
-        // An older committed package's dump has no textSpans field at all — the
-        // declared expectation must stay silent, not fire a false missing-span.
-        expect(deriveSpanFacts({}, { discountText: { text: '5 EUR off' } })).toEqual([]);
-    });
-    test('any one of several rendered spans matching the declared extent passes', () => {
-        expect(deriveSpanFacts({
-            discountText: [
-                { start: 0, end: 3, text: 'Get', background: '#eeeeee' },
-                { start: 4, end: 13, text: '5 EUR off', background: '#ffe45e' },
-            ],
-        }, { discountText: { text: '5 EUR off' } })).toEqual([]);
-    });
-    test('several wrong spans report all their extents in one fact', () => {
-        expect(deriveSpanFacts({
-            discountText: [
-                { start: 0, end: 3, text: 'Get', background: '#eeeeee' },
-                { start: 4, end: 9, text: '5 EUR', background: '#ffe45e' },
-            ],
-        }, { discountText: { text: '5 EUR off' } })).toEqual([
-            { kind: 'span_mismatch', elementId: 'discountText', rendered: 'Get, 5 EUR', reference: '5 EUR off' },
-        ]);
-    });
-    test('no declared entry / empty declared text produces no fact (absence of signal is not a divergence)', () => {
-        expect(deriveSpanFacts({ discountText: [{ start: 0, end: 3, text: 'Get' }] }, {})).toEqual([]);
-        expect(deriveSpanFacts({ discountText: [{ start: 0, end: 3, text: 'Get' }] }, { discountText: { text: '' } })).toEqual([]);
-    });
-    test('result is order-independent and deterministic (sorted by element id)', () => {
-        const rendered = {
-            b: [{ start: 0, end: 1, text: 'x' }],
-            a: [{ start: 0, end: 1, text: 'y' }],
-        };
-        const a = deriveSpanFacts(rendered, { a: { text: 'right' }, b: { text: 'x' } });
-        const b = deriveSpanFacts(rendered, { b: { text: 'x' }, a: { text: 'right' } });
-        expect(a).toEqual(b);
-        expect(a).toEqual([
-            { kind: 'span_mismatch', elementId: 'a', rendered: 'y', reference: 'right' },
-        ]);
-    });
-    // ── Foreground-color spans (partial-color emphasis), capability-gated. ──
-    test('a color span with the right extent but the wrong color yields span_color_mismatch', () => {
-        expect(deriveSpanFacts({ pillText: [{ start: 19, end: 30, text: 'special offer', color: '#ffffff' }] }, { pillText: { text: 'special offer', color: '#ffdc23' } }, true)).toEqual([
-            {
-                kind: 'span_color_mismatch',
-                elementId: 'pillText',
-                extent: 'special offer',
-                rendered: '#ffffff',
-                reference: '#ffdc23',
-            },
-        ]);
-    });
-    test('a color span matching extent AND color (case-insensitive) produces no fact', () => {
-        expect(deriveSpanFacts({ pillText: [{ start: 19, end: 30, text: 'special offer', color: '#FFDC23' }] }, { pillText: { text: 'special offer', color: '#ffdc23' } }, true)).toEqual([]);
-    });
-    test('a capable dump rendering NO span at all fails a color declaration (dropped emphasis)', () => {
-        expect(deriveSpanFacts({}, { pillText: { text: 'special offer', color: '#ffdc23' } }, true)).toEqual([
-            { kind: 'span_mismatch', elementId: 'pillText', rendered: '', reference: 'special offer' },
-        ]);
-    });
-    test('a color declaration against a color-blind dump stays silent (capability gate)', () => {
-        // Old emitter: no spanChannels marker → colorCapable false. Its silence
-        // is "cannot see", never "no color span rendered".
-        expect(deriveSpanFacts({}, { pillText: { text: 'special offer', color: '#ffdc23' } }, false)).toEqual([]);
-        expect(deriveSpanFacts({}, { pillText: { text: 'special offer', color: '#ffdc23' } })).toEqual([]);
-    });
-    test('a color-only rendered span never satisfies a BACKGROUND declaration (channel-scoped)', () => {
-        expect(deriveSpanFacts({ pillText: [{ start: 0, end: 5, text: 'offer', color: '#ffdc23' }] }, { pillText: { text: 'offer', background: '#ffe45e' } }, true)).toEqual([
-            { kind: 'span_mismatch', elementId: 'pillText', rendered: '', reference: 'offer' },
-        ]);
-    });
-    test('a declaration carrying BOTH channels needs both satisfied', () => {
-        const rendered = {
-            pillText: [{ start: 0, end: 5, text: 'offer', background: '#ffe45e', color: '#ffdc23' }],
-        };
-        expect(deriveSpanFacts(rendered, { pillText: { text: 'offer', background: '#ffe45e', color: '#ffdc23' } }, true)).toEqual([]);
-        expect(deriveSpanFacts(rendered, { pillText: { text: 'offer', background: '#ffe45e', color: '#1b1b1b' } }, true)).toEqual([
-            {
-                kind: 'span_color_mismatch',
-                elementId: 'pillText',
-                extent: 'offer',
-                rendered: '#ffdc23',
-                reference: '#1b1b1b',
-            },
-        ]);
-    });
-});
-describe('deriveLineFacts — declared line split vs rendered laid-out lines', () => {
-    test('rendered lines matching the declared split produce no fact', () => {
-        expect(deriveLineFacts({
-            promoCopy: [
-                { start: 0, end: 28, text: 'Get 5 EUR off your first order' },
-                { start: 29, end: 50, text: 'placed by tomorrow.' },
-            ],
-        }, { promoCopy: ['Get 5 EUR off your first order', 'placed by tomorrow.'] })).toEqual([]);
-    });
-    test('a break on the wrong word yields line_break_mismatch with both splits', () => {
-        expect(deriveLineFacts({
-            promoCopy: [
-                { start: 0, end: 31, text: 'Get 5 EUR off your first order placed' },
-                { start: 32, end: 45, text: 'by tomorrow.' },
-            ],
-        }, { promoCopy: ['Get 5 EUR off your first order', 'placed by tomorrow.'] })).toEqual([
-            {
-                kind: 'line_break_mismatch',
-                elementId: 'promoCopy',
-                rendered: 'Get 5 EUR off your first order placed\nby tomorrow.',
-                reference: 'Get 5 EUR off your first order\nplaced by tomorrow.',
-            },
-        ]);
-    });
-    test('a dropped break (single rendered line vs a declared two-line split) is a fact', () => {
-        expect(deriveLineFacts({ promoCopy: [{ start: 0, end: 50, text: 'Get 5 EUR off your first order placed by tomorrow.' }] }, { promoCopy: ['Get 5 EUR off your first order', 'placed by tomorrow.'] })).toEqual([
-            {
-                kind: 'line_break_mismatch',
-                elementId: 'promoCopy',
-                rendered: 'Get 5 EUR off your first order placed by tomorrow.',
-                reference: 'Get 5 EUR off your first order\nplaced by tomorrow.',
-            },
-        ]);
-    });
-    test('a node that emitted no lines produces no fact (old packages degrade gracefully)', () => {
-        expect(deriveLineFacts({}, { promoCopy: ['Get 5 EUR off', 'placed by tomorrow.'] })).toEqual([]);
-    });
-    test('no declared entry / an empty declared split produces no fact (absence of signal is not a divergence)', () => {
-        expect(deriveLineFacts({ promoCopy: [{ start: 0, end: 3, text: 'Get' }] }, {})).toEqual([]);
-        expect(deriveLineFacts({ promoCopy: [{ start: 0, end: 3, text: 'Get' }] }, { promoCopy: [] })).toEqual([]);
-        expect(deriveLineFacts({ promoCopy: [{ start: 0, end: 3, text: 'Get' }] }, { promoCopy: ['', ''] })).toEqual([]);
-    });
-    test('result is order-independent and deterministic (sorted by element id)', () => {
-        const rendered = {
-            b: [{ start: 0, end: 1, text: 'x' }],
-            a: [{ start: 0, end: 1, text: 'y' }],
-        };
-        const one = deriveLineFacts(rendered, { a: ['right'], b: ['x'] });
-        const two = deriveLineFacts(rendered, { b: ['x'], a: ['right'] });
-        expect(one).toEqual(two);
-        expect(one).toEqual([
-            { kind: 'line_break_mismatch', elementId: 'a', rendered: 'y', reference: 'right' },
-        ]);
-    });
-});
-describe('deriveTypeMetricFacts — laid-out size/tracking/leading vs design', () => {
-    // The blind spot: with family and weight matching, the typeface comparison
-    // finds nothing, so a wrong font size can only surface as the text box
-    // measuring small — filed as structure, with a hint naming a fix site that
-    // does not exist. The live case survived two autofix passes and was
-    // recommended for dismissal as unfixable.
-    test('the motivating case: 18sp design against a 16sp wrapper yields a font-size fact', () => {
-        const facts = deriveTypeMetricFacts({ 'button-16': { fontSize: 16, lineHeight: 24 } }, { 'button-16': { family: 'Poppins', weight: 600, fontSize: 18, lineHeight: 24 } });
-        expect(facts).toEqual([
-            {
-                kind: 'type_metric',
-                elementId: 'button-16',
-                channel: 'text',
-                metric: 'fontSize',
-                rendered: 16,
-                reference: 18,
-            },
-        ]);
-    });
-    test('two metrics diverging on one element yield TWO facts, size first', () => {
-        // Folding them into one fact would collapse downstream into a single
-        // finding (identity is screen+element+category) and silently drop the
-        // other — and the motivating element diverged in BOTH at once.
-        const facts = deriveTypeMetricFacts({ 'button-16': { fontSize: 16, letterSpacing: 0 } }, { 'button-16': { family: 'Poppins', fontSize: 18, letterSpacing: -0.6 } });
-        expect(facts.map((f) => f.metric)).toEqual(['fontSize', 'letterSpacing']);
-    });
-    test('a metric declared on only ONE side is no signal, never a divergence', () => {
-        // A design that declares no tracking is not asserting 0, and a style that
-        // leaves leading Unspecified has not chosen a value to be wrong about.
-        expect(deriveTypeMetricFacts({ label: { fontSize: 14, letterSpacing: 0.5 } }, { label: { family: 'Poppins', fontSize: 14 } })).toEqual([]);
-        expect(deriveTypeMetricFacts({ label: { fontSize: 14 } }, { label: { family: 'Poppins', lineHeight: 20 } })).toEqual([]);
-    });
-    test('a sub-unit difference does not flap', () => {
-        // 15.999 against 16 is the same type; a fact for it would recur on every
-        // render forever. No design system steps type by a tenth of a point.
-        expect(deriveTypeMetricFacts({ label: { fontSize: 15.999, lineHeight: 20.2 } }, { label: { family: 'Poppins', fontSize: 16, lineHeight: 20 } })).toEqual([]);
-    });
-    test('a real one-point difference is reported', () => {
-        const facts = deriveTypeMetricFacts({ label: { fontSize: 15 } }, { label: { family: 'Poppins', fontSize: 16 } });
-        expect(facts).toHaveLength(1);
-    });
-    test('an element the render measured no metrics for yields nothing', () => {
-        expect(deriveTypeMetricFacts({}, { label: { family: 'Poppins', fontSize: 16 } })).toEqual([]);
-    });
-    test('a non-finite measurement is no measurement, not a zero', () => {
-        expect(deriveTypeMetricFacts({ label: { fontSize: Number.NaN } }, { label: { family: 'Poppins', fontSize: 16 } })).toEqual([]);
-    });
-    test('deterministic: output sorted by element id', () => {
-        const facts = deriveTypeMetricFacts({ b: { fontSize: 10 }, a: { fontSize: 10 } }, { b: { family: 'P', fontSize: 16 }, a: { family: 'P', fontSize: 16 } });
-        expect(facts.map((f) => f.elementId)).toEqual(['a', 'b']);
-    });
-    test('the embedded render-side port agrees with the module', () => {
-        // The runner executes the JS twin, not this module. A twin that drifted
-        // would emit different facts from the ones these tests guarantee.
-        const { deriveTypeMetricFacts: embedded } = getGeometryStageInternals();
-        const rendered = { 'button-16': { fontSize: 16, letterSpacing: 0, lineHeight: 24 } };
-        const reference = {
-            'button-16': { family: 'Poppins', weight: 600, fontSize: 18, letterSpacing: -0.6, lineHeight: 24 },
-        };
-        expect(embedded(rendered, reference)).toEqual(deriveTypeMetricFacts(rendered, reference));
-        expect(embedded(rendered, reference)).toHaveLength(2);
-    });
-});
-describe('deriveTypefaceFacts — resolved vs design typeface per element', () => {
-    test('a family mismatch yields one typeface fact carrying both fonts', () => {
-        const facts = deriveTypefaceFacts({ code: { family: 'Roboto', weight: 400 } }, { code: { family: 'Poppins', weight: 600 } });
-        expect(facts).toEqual([
-            {
-                kind: 'typeface',
-                elementId: 'code',
-                channel: 'text',
-                rendered: { family: 'Roboto', weight: 400 },
-                reference: { family: 'Poppins', weight: 600 },
-            },
-        ]);
-    });
-    test('a weight mismatch on the same family yields a typeface fact', () => {
-        const facts = deriveTypefaceFacts({ code: { family: 'Poppins', weight: 400 } }, { code: { family: 'Poppins', weight: 600 } });
-        expect(facts).toHaveLength(1);
-        expect(facts[0]).toMatchObject({ kind: 'typeface', elementId: 'code', channel: 'text' });
-    });
-    test('an exact family+weight match produces no fact', () => {
-        expect(deriveTypefaceFacts({ code: { family: 'Poppins', weight: 600 } }, { code: { family: 'Poppins', weight: 600 } })).toEqual([]);
-    });
-    test('a normalization-equivalent pair produces no fact (suffix-encoded weight vs numeric, case, separators)', () => {
-        // design names "Poppins-SemiBold"; render resolved "Poppins" weight 600 — same font.
-        expect(deriveTypefaceFacts({ code: { family: 'Poppins', weight: 600 } }, { code: { family: 'Poppins-SemiBold' } })).toEqual([]);
-        // resource-name encoding "fira_sans_medium" vs design "Fira Sans" weight 500.
-        expect(deriveTypefaceFacts({ code: { family: 'fira_sans_medium' } }, { code: { family: 'Fira Sans', weight: 500 } })).toEqual([]);
-        // pure case difference on the family.
-        expect(deriveTypefaceFacts({ code: { family: 'POPPINS', weight: 600 } }, { code: { family: 'poppins', weight: 600 } })).toEqual([]);
-    });
-    test('a suffix-encoded family that disagrees on weight still flags', () => {
-        // design "Poppins-SemiBold" (→600) vs resolved "Poppins" Regular (400) — a real
-        // weight fallback the suffix normalization must NOT mask.
-        const facts = deriveTypefaceFacts({ code: { family: 'Poppins', weight: 400 } }, { code: { family: 'Poppins-SemiBold' } });
-        expect(facts).toHaveLength(1);
-        expect(facts[0]).toMatchObject({ kind: 'typeface', elementId: 'code' });
-    });
-    test('a missing rendered or reference font produces no fact (graceful, no false positive)', () => {
-        // reference declares a font the render never resolved → no signal → no fact
-        expect(deriveTypefaceFacts({ code: undefined }, { code: { family: 'Poppins', weight: 600 } })).toEqual([]);
-        expect(deriveTypefaceFacts({ code: { family: '' } }, { code: { family: 'Poppins', weight: 600 } })).toEqual([]);
-        // render resolved a font the reference never declared → no reference signal → no fact
-        expect(deriveTypefaceFacts({ code: { family: 'Roboto', weight: 400 } }, {})).toEqual([]);
-        expect(deriveTypefaceFacts({ code: { family: 'Roboto', weight: 400 } }, { code: { family: '' } })).toEqual([]);
-    });
-    test('result is order-independent and deterministic (sorted by element id)', () => {
-        const a = deriveTypefaceFacts({ b: { family: 'Roboto', weight: 400 }, a: { family: 'Arial', weight: 400 } }, { a: { family: 'Poppins', weight: 600 }, b: { family: 'Roboto', weight: 400 } });
-        const b = deriveTypefaceFacts({ a: { family: 'Arial', weight: 400 }, b: { family: 'Roboto', weight: 400 } }, { b: { family: 'Roboto', weight: 400 }, a: { family: 'Poppins', weight: 600 } });
-        expect(a).toEqual(b);
-        expect(a.map((f) => f.elementId)).toEqual(['a']);
-    });
-});
-describe('buildStructuralBlock — appearance container (Signal C, additive)', () => {
-    test('no appearanceReference → no appearance container; facts + geometry unchanged', () => {
-        const withC = buildStructuralBlock(HUB_PROMO_DUMP, HUB_PROMO_REFERENCE, 2);
-        const without = buildStructuralBlock(HUB_PROMO_DUMP, HUB_PROMO_REFERENCE, 2, undefined, null);
-        expect(withC.appearance).toBeUndefined();
-        // Signal A facts and Signal B geometry are byte-identical whether or not the
-        // appearance arg is threaded.
-        expect(without).toEqual(withC);
-    });
-    test('with a figma appearanceReference → container rides along, Signal A/B untouched (issue 04: no presence noise)', () => {
-        // dump node ids: node-1, banner, voucher, copy; reference declares banner+voucher.
-        // element_extra is gated to the previous_render baseline (see the issue-04 test
-        // below), so the figma path no longer flags copy/node-1 as element_extra; both
-        // declared ids rendered, so no element_missing either (issue 03).
-        const block = buildStructuralBlock(HUB_PROMO_DUMP, HUB_PROMO_REFERENCE, 2, undefined, {
-            baseline: 'figma',
-            elementIds: ['banner', 'voucher'],
-        });
-        expect(block.appearance).toEqual({
-            baseline: 'figma',
-            facts: [],
-            rendered: { elementIds: ['banner', 'copy', 'node-1', 'voucher'] },
-        });
-        // Additive: the existing Signal A facts and Signal B geometry are untouched.
-        expect(block.facts).toEqual(buildStructuralBlock(HUB_PROMO_DUMP, HUB_PROMO_REFERENCE, 2).facts);
-        expect(block.geometry).toEqual(buildStructuralBlock(HUB_PROMO_DUMP, HUB_PROMO_REFERENCE, 2).geometry);
-    });
-    test('a figma appearanceReference emits NO element_extra — reference_geometry is a partial annotation, not the element inventory (issue 04)', () => {
-        // The figma baseline's ids come from reference_geometry (only the load-bearing
-        // tagged elements). Deriving element_extra against that partial set falsely
-        // flags every untagged rendered element (the e2e noise: copy, node-1).
-        // element_extra requires the COMPLETE inventory, which figma lacks here.
-        const block = buildStructuralBlock(HUB_PROMO_DUMP, HUB_PROMO_REFERENCE, 2, undefined, {
-            baseline: 'figma',
-            elementIds: ['banner', 'voucher'],
-        });
-        expect(block.appearance?.baseline).toBe('figma');
-        expect(block.appearance?.facts).toEqual([]);
-        // The container still rode along (Signal C ran) with the render's snapshot.
-        expect(block.appearance?.rendered?.elementIds).toEqual(['banner', 'copy', 'node-1', 'voucher']);
-    });
-    test('a figma appearanceReference emits element_missing for a declared id with no rendered node (coverage-gaps issue 03)', () => {
-        // Declared-side presence is noise-free: every reference id is a deliberate,
-        // named, load-bearing element — a declared id matching NO rendered node is a
-        // real absence, not annotation noise. The render-side direction stays gated
-        // (copy/node-1 rendered-but-undeclared → still no element_extra).
-        const block = buildStructuralBlock(HUB_PROMO_DUMP, HUB_PROMO_REFERENCE, 2, undefined, {
-            baseline: 'figma',
-            elementIds: ['banner', 'voucher', 'removedButton'],
-        });
-        expect(block.appearance?.facts).toEqual([
-            { kind: 'element_missing', elementId: 'removedButton' },
-        ]);
-    });
-    // ---- Painted ink (icon-ink-ratio 01) ----
-    // `Icon(N.dp)` paints `N x (path bounds / viewport)`, not N, while a design
-    // reference's key for an icon is its vector PATH box. The emitter measures the
-    // ink; this block is the only thing between it and the judge, so a dropped
-    // field here silently restores the container-vs-ink comparison that produced a
-    // false positive, a false negative and an inverted sign, all live at once.
-    //
-    // TWO copies build this element — the module below and the embedded render
-    // script that actually runs on the runner — so both are asserted, and the
-    // parity test guards them against drifting apart later.
-    const INK_DUMP = {
-        canvas: CANVAS,
-        nodes: [
-            {
-                id: 'intersect',
-                bounds: { left: 32, top: 32, right: 64, bottom: 64 },
-                unclippedBounds: { left: 32, top: 32, right: 64, bottom: 64 },
-                parentId: null,
-                clipsChildren: false,
-                paintedInk: { kind: 'vector', viewport: { w: 24, h: 24 }, ink: { w: 15, h: 15 } },
-            },
-            {
-                id: 'label',
-                bounds: { left: 0, top: 80, right: 200, bottom: 120 },
-                unclippedBounds: { left: 0, top: 80, right: 200, bottom: 120 },
-                parentId: null,
-                clipsChildren: false,
-            },
-        ],
-    };
-    const INK_REFERENCE = { intersect: { w: 14, h: 14 }, label: { w: 100, h: 20 } };
-    test('carries a measured ink onto the element, and omits it where nothing paints', () => {
-        const block = buildStructuralBlock(INK_DUMP, INK_REFERENCE, 2);
-        const intersect = block.geometry?.elements.find((e) => e.id === 'intersect');
-        expect(intersect?.paintedInk).toEqual({
-            kind: 'vector',
-            viewport: { w: 24, h: 24 },
-            ink: { w: 15, h: 15 },
-        });
-        // A text label paints no painter: its layout box IS the measurement, and a
-        // caveat here would land on every non-icon element in the product.
-        const label = block.geometry?.elements.find((e) => e.id === 'label');
-        expect(label && 'paintedInk' in label).toBe(false);
-    });
-    test('embedded stage matches the module for painted ink (parity, icon-ink-ratio 01)', () => {
-        const embedded = getGeometryStageInternals();
-        expect(embedded.buildStructuralBlock(INK_DUMP, INK_REFERENCE, 2)).toEqual(buildStructuralBlock(INK_DUMP, INK_REFERENCE, 2));
-    });
-    // ---- Render ancestry (icon-ink-ratio 05) ----
-    // The dump carries `parentId` per node and the deriver consumes it for sibling
-    // grouping, then drops it. Without it the judge cannot see the render's tree at
-    // all, so an element the wrapper nested in the wrong container has no finding of
-    // its own — it surfaces only as a side effect of whatever collision it happens
-    // to cause.
-    //
-    // The CHAIN, not the parent link. Compose's semantics tree omits untagged layout
-    // nodes, so a declared key routinely sits several levels below the parent it
-    // should be compared against; measured against three gated screens, an immediate
-    // parent alone produces 21 false rows where the chain produces 2 (see the issue).
-    //
-    // Same three copies as `paintedInk`: this module, the embedded render script that
-    // actually runs on the runner, and Invarn's vendored twin.
-    const NESTED_DUMP = {
-        canvas: CANVAS,
-        nodes: [
-            {
-                id: 'root',
-                bounds: { left: 0, top: 0, right: 200, bottom: 200 },
-                unclippedBounds: { left: 0, top: 0, right: 200, bottom: 200 },
-                parentId: null,
-                clipsChildren: false,
-            },
-            // An UNTAGGED intermediate: the case the chain exists for.
-            {
-                id: 'node-7',
-                bounds: { left: 0, top: 0, right: 200, bottom: 200 },
-                unclippedBounds: { left: 0, top: 0, right: 200, bottom: 200 },
-                parentId: 'root',
-                clipsChildren: false,
-            },
-            {
-                id: 'badge',
-                bounds: { left: 32, top: 32, right: 48, bottom: 48 },
-                unclippedBounds: { left: 32, top: 32, right: 48, bottom: 48 },
-                parentId: 'node-7',
-                clipsChildren: false,
-            },
-        ],
-    };
-    const NESTED_REFERENCE = { root: { w: 100, h: 100 }, badge: { w: 8, h: 8 } };
-    test('carries the render ancestor chain onto the element, immediate parent first (icon-ink-ratio 05)', () => {
-        const block = buildStructuralBlock(NESTED_DUMP, NESTED_REFERENCE, 2);
-        const badge = block.geometry?.elements.find((e) => e.id === 'badge');
-        // Through the untagged `node-7` and on to the root — the untagged link is the
-        // whole reason a single `parentId` is not enough.
-        expect(badge?.ancestors).toEqual(['node-7', 'root']);
-        // A root node's chain is empty, not absent: "measured, no ancestors" is a
-        // statement, and it is what tells the judge this render carries ancestry at
-        // all (every render made before this shipped carries none).
-        const root = block.geometry?.elements.find((e) => e.id === 'root');
-        expect(root?.ancestors).toEqual([]);
-    });
-    test('embedded stage matches the module for render ancestry (parity, icon-ink-ratio 05)', () => {
-        const embedded = getGeometryStageInternals();
-        expect(embedded.buildStructuralBlock(NESTED_DUMP, NESTED_REFERENCE, 2)).toEqual(buildStructuralBlock(NESTED_DUMP, NESTED_REFERENCE, 2));
-    });
-    test('embedded stage matches the module for a declared tag absent from the render (parity)', () => {
-        const embedded = getGeometryStageInternals();
-        const reference = { ...HUB_PROMO_REFERENCE, cta: { w: 112, h: 36, x: 16, y: 200 } };
-        expect(embedded.buildStructuralBlock(HUB_PROMO_DUMP, reference, 2)).toEqual(buildStructuralBlock(HUB_PROMO_DUMP, reference, 2));
-    });
-    test('embedded stage matches the module for the figma missing-element case (parity, issue 03)', () => {
-        const embedded = getGeometryStageInternals();
-        const reference = {
-            baseline: 'figma',
-            elementIds: ['banner', 'voucher', 'removedButton'],
-        };
-        expect(embedded.buildStructuralBlock(HUB_PROMO_DUMP, HUB_PROMO_REFERENCE, 2, undefined, reference)).toEqual(buildStructuralBlock(HUB_PROMO_DUMP, HUB_PROMO_REFERENCE, 2, undefined, reference));
-    });
-    test('a previous_render appearanceReference still emits presence facts keyed on the previous render id set (issue 04)', () => {
-        // The previous_render baseline carries the COMPLETE prior-render inventory, so
-        // missing/extra are meaningful: `legacyBadge` was in the prior render and is
-        // gone (missing); `copy`/`node-1` are in the prior render too (not extra).
-        const block = buildStructuralBlock(HUB_PROMO_DUMP, null, 2, undefined, {
-            baseline: 'previous_render',
-            elementIds: ['banner', 'voucher', 'copy', 'node-1', 'legacyBadge'],
-        });
-        expect(block.appearance?.facts).toEqual([
-            { kind: 'element_missing', elementId: 'legacyBadge' },
-        ]);
-    });
-    test('an appearanceReference matching the render → ran-and-clean (baseline, zero facts)', () => {
-        const block = buildStructuralBlock(HUB_PROMO_DUMP, null, 2, undefined, {
-            baseline: 'figma',
-            elementIds: ['node-1', 'banner', 'voucher', 'copy'],
-        });
-        expect(block.appearance).toEqual({
-            baseline: 'figma',
-            facts: [],
-            rendered: { elementIds: ['banner', 'copy', 'node-1', 'voucher'] },
-        });
-    });
-    // A dump whose per-node `text` (Signal C render-side enrichment) drives the
-    // copy-fact comparison: `title` renders the wrong string, `cta` renders no
-    // text, and `debugOverlay` is an extra element absent from the reference.
-    const COPY_DUMP = {
-        canvas: { left: 0, top: 0, right: 200, bottom: 400 },
-        nodes: [
-            { id: 'title', bounds: { left: 0, top: 0, right: 100, bottom: 20 }, parentId: null, clipsChildren: false, text: '5 EUR' },
-            { id: 'cta', bounds: { left: 0, top: 30, right: 100, bottom: 50 }, parentId: null, clipsChildren: false },
-            { id: 'debugOverlay', bounds: { left: 0, top: 60, right: 100, bottom: 80 }, parentId: null, clipsChildren: false },
-        ],
-    };
-    test('with reference text → copy facts derive on the figma path (no presence noise, issue 04)', () => {
-        // Copy facts still fire on the figma baseline (reference text present); only
-        // presence is gated off, so `debugOverlay` (rendered, not in the reference) is
-        // no longer flagged element_extra — just the genuine copy drift remains.
-        const block = buildStructuralBlock(COPY_DUMP, null, 2, undefined, {
-            baseline: 'figma',
-            elementIds: ['title', 'cta'],
-            text: { title: '5 EUR off', cta: 'Shop now' },
-        });
-        expect(block.appearance).toEqual({
-            baseline: 'figma',
-            facts: [
-                // copy only (sorted by id: cta missing, title mismatched)
-                { kind: 'text_missing', elementId: 'cta', reference: 'Shop now' },
-                { kind: 'text_mismatch', elementId: 'title', rendered: '5 EUR', reference: '5 EUR off' },
-            ],
-            rendered: { elementIds: ['cta', 'debugOverlay', 'title'], text: { title: '5 EUR' } },
-        });
-    });
-    test('an appearanceReference without text → presence only (issue-01 behavior unchanged)', () => {
-        const block = buildStructuralBlock(COPY_DUMP, null, 2, undefined, {
-            baseline: 'figma',
-            elementIds: ['title', 'cta', 'debugOverlay'],
-        });
-        expect(block.appearance).toEqual({
-            baseline: 'figma',
-            facts: [],
-            rendered: { elementIds: ['cta', 'debugOverlay', 'title'], text: { title: '5 EUR' } },
-        });
-    });
-    // A dump whose per-node fill/text colors (Signal C render-side enrichment)
-    // drive the color-fact comparison: `card` renders the wrong fill, correct text.
-    const COLOR_DUMP = {
-        canvas: { left: 0, top: 0, right: 200, bottom: 400 },
-        nodes: [
-            { id: 'card', bounds: { left: 0, top: 0, right: 100, bottom: 40 }, parentId: null, clipsChildren: false, fillColor: '#ff0000', textColor: '#000000' },
-        ],
-    };
-    test('with reference color → color facts are appended after presence/copy facts', () => {
-        const block = buildStructuralBlock(COLOR_DUMP, null, 2, undefined, {
-            baseline: 'figma',
-            elementIds: ['card'],
-            color: { card: { fill: '#00ff00', text: '#000000' } },
-        });
-        expect(block.appearance?.baseline).toBe('figma');
-        expect(block.appearance?.facts).toEqual([
-            {
-                kind: 'color',
-                elementId: 'card',
-                channel: 'fill',
-                rendered: '#ff0000',
-                reference: '#00ff00',
-                deltaE: ciede2000(hexToLab('#ff0000'), hexToLab('#00ff00')),
-            },
-        ]);
-    });
-    test('with reference text color → a text-channel color fact (issue 02)', () => {
-        // COLOR_DUMP renders `card` text #000000; the reference declares #ffffff for
-        // the text channel and the matching fill — so exactly one fact, channel:'text'.
-        const block = buildStructuralBlock(COLOR_DUMP, null, 2, undefined, {
-            baseline: 'figma',
-            elementIds: ['card'],
-            color: { card: { fill: '#ff0000', text: '#ffffff' } },
-        });
-        expect(block.appearance?.facts).toEqual([
-            {
-                kind: 'color',
-                elementId: 'card',
-                channel: 'text',
-                rendered: '#000000',
-                reference: '#ffffff',
-                deltaE: ciede2000(hexToLab('#000000'), hexToLab('#ffffff')),
-            },
-        ]);
-    });
-    test('an identical text color → no text fact (issue 02)', () => {
-        const block = buildStructuralBlock(COLOR_DUMP, null, 2, undefined, {
-            baseline: 'figma',
-            elementIds: ['card'],
-            color: { card: { fill: '#ff0000', text: '#000000' } },
-        });
-        expect(block.appearance?.facts).toEqual([]);
-    });
-    test('an appearanceReference without color → no color facts (presence only)', () => {
-        const block = buildStructuralBlock(COLOR_DUMP, null, 2, undefined, {
-            baseline: 'figma',
-            elementIds: ['card'],
-        });
-        expect(block.appearance).toEqual({
-            baseline: 'figma',
-            facts: [],
-            rendered: { elementIds: ['card'], color: { card: { fill: '#ff0000', text: '#000000' } } },
-        });
-    });
-    // ---- Signal C no-Figma baseline (issue 04) ----
-    test('the appearance container persists a rendered snapshot (the baseline source for the next render)', () => {
-        // The snapshot captures THIS render's own element ids + text + colors so a
-        // later no-Figma render can diff against it. Text/color are present only for
-        // the nodes that expose them.
-        const block = buildStructuralBlock(COPY_DUMP, null, 2, undefined, {
-            baseline: 'figma',
-            elementIds: ['title', 'cta'],
-        });
-        expect(block.appearance?.rendered).toEqual({
-            elementIds: ['cta', 'debugOverlay', 'title'],
-            text: { title: '5 EUR' },
-        });
-    });
-    test('a previous_render baseline marks the facts as regressions (drift), derivers unchanged', () => {
-        // The same derivers run; only the reference source + baseline marking differ.
-        // Reference here is the *previous render*'s ids/text/color.
-        const block = buildStructuralBlock(COLOR_DUMP, null, 2, undefined, {
-            baseline: 'previous_render',
-            elementIds: ['card'],
-            color: { card: { fill: '#00ff00' } },
-        });
-        expect(block.appearance?.baseline).toBe('previous_render');
-        expect(block.appearance?.facts).toEqual([
-            {
-                kind: 'color',
-                elementId: 'card',
-                channel: 'fill',
-                rendered: '#ff0000',
-                reference: '#00ff00',
-                deltaE: ciede2000(hexToLab('#ff0000'), hexToLab('#00ff00')),
-            },
-        ]);
-    });
-    test('a previous_render baseline diffs presence against the previous element-id set', () => {
-        // COLOR_DUMP renders only `card`; the previous render had `card` + `legacyBadge`.
-        const block = buildStructuralBlock(COLOR_DUMP, null, 2, undefined, {
-            baseline: 'previous_render',
-            elementIds: ['card', 'legacyBadge'],
-        });
-        expect(block.appearance).toMatchObject({
-            baseline: 'previous_render',
-            facts: [{ kind: 'element_missing', elementId: 'legacyBadge' }],
-        });
-    });
-    test('no appearanceReference (neither Figma nor previous render) → no container, no rendered snapshot', () => {
-        const block = buildStructuralBlock(COLOR_DUMP, null, 2);
-        expect(block.appearance).toBeUndefined();
-    });
-    // ---- Signal C typeface facts (resolved vs design font, issue 03) ----
-    // A dump whose text node carries the resolved-typeface enrichment (issue 03):
-    // the font that ACTUALLY painted, post-fallback — here a Roboto fallback where
-    // the design wants Poppins SemiBold. The dump also declares the render SDK the
-    // proof ran at (TextRunShaper, the capture seam, is API 31+).
-    const TYPEFACE_DUMP = {
-        canvas: { left: 0, top: 0, right: 200, bottom: 400 },
-        renderSdk: 34,
-        nodes: [
-            {
-                id: 'code',
-                bounds: { left: 0, top: 0, right: 100, bottom: 20 },
-                parentId: null,
-                clipsChildren: false,
-                text: 'INV-50',
-                resolvedTypeface: { family: 'Roboto', weight: 400 },
-            },
-        ],
-    };
-    test('with a reference typeface → a typeface fact fires on divergence and the resolved font is persisted (issue 03)', () => {
-        const block = buildStructuralBlock(TYPEFACE_DUMP, null, 2, undefined, {
-            baseline: 'figma',
-            elementIds: ['code'],
-            typeface: { code: { family: 'Poppins', weight: 600 } },
-        });
-        expect(block.appearance?.facts).toEqual([
-            {
-                kind: 'typeface',
-                elementId: 'code',
-                channel: 'text',
-                rendered: { family: 'Roboto', weight: 400 },
-                reference: { family: 'Poppins', weight: 600 },
-            },
-        ]);
-        expect(block.appearance?.rendered?.typeface).toEqual({ code: { family: 'Roboto', weight: 400 } });
-    });
-    test('a matching resolved typeface → no fact; the snapshot still persists the resolved font (issue 03)', () => {
-        const block = buildStructuralBlock(TYPEFACE_DUMP, null, 2, undefined, {
-            baseline: 'figma',
-            elementIds: ['code'],
-            typeface: { code: { family: 'Roboto', weight: 400 } },
-        });
-        expect(block.appearance?.facts).toEqual([]);
-        expect(block.appearance?.rendered?.typeface).toEqual({ code: { family: 'Roboto', weight: 400 } });
-    });
-    test('a node without the enrichment yields no typeface signal and no snapshot entry (old packages degrade gracefully)', () => {
-        const block = buildStructuralBlock(COPY_DUMP, null, 2, undefined, {
-            baseline: 'figma',
-            elementIds: ['title'],
-            typeface: { title: { family: 'Poppins', weight: 600 } },
-        });
-        expect(block.appearance?.facts).toEqual([]);
-        expect(block.appearance?.rendered?.typeface).toBeUndefined();
-    });
-    test('a render SDK below 31 omits typeface facts AND carries the advisory — never a silent pass (issue 03)', () => {
-        const oldSdkDump = {
-            canvas: { left: 0, top: 0, right: 200, bottom: 400 },
-            renderSdk: 28,
-            nodes: [
-                { id: 'code', bounds: { left: 0, top: 0, right: 100, bottom: 20 }, parentId: null, clipsChildren: false, text: 'INV-50' },
-            ],
-        };
-        const block = buildStructuralBlock(oldSdkDump, null, 2, undefined, {
-            baseline: 'figma',
-            elementIds: ['code'],
-            typeface: { code: { family: 'Poppins', weight: 600 } },
-        });
-        expect(block.appearance?.facts).toEqual([]);
-        expect(block.appearance?.advisories).toEqual([
-            'typeface check requires render SDK >= 31; this proof rendered at SDK 28 — typeface facts were not derived (not checked, not passing)',
-        ]);
-    });
-    test('a render SDK below 31 without a typeface reference carries no advisory (nothing was checkable)', () => {
-        const oldSdkDump = {
-            canvas: { left: 0, top: 0, right: 200, bottom: 400 },
-            renderSdk: 28,
-            nodes: [
-                { id: 'code', bounds: { left: 0, top: 0, right: 100, bottom: 20 }, parentId: null, clipsChildren: false },
-            ],
-        };
-        const block = buildStructuralBlock(oldSdkDump, null, 2, undefined, {
-            baseline: 'figma',
-            elementIds: ['code'],
-        });
-        expect(block.appearance?.advisories).toBeUndefined();
-    });
-    test('a render SDK >= 31 carries no advisory; facts derive normally', () => {
-        const modern = buildStructuralBlock(TYPEFACE_DUMP, null, 2, undefined, {
-            baseline: 'figma',
-            elementIds: ['code'],
-            typeface: { code: { family: 'Poppins', weight: 600 } },
-        });
-        expect(modern.appearance?.advisories).toBeUndefined();
-        expect(modern.appearance?.facts).toHaveLength(1);
-    });
-    test('an ABSENT render SDK carries the advisory too — a Roboto fallback on an old package must not read as checked (coverage-gaps issue 04)', () => {
-        // The emitter stamps renderSdk in the same generation that captures
-        // resolvedTypeface, so an absent renderSdk means the dump CANNOT carry
-        // resolved typefaces: the check did not run, and "not run" is an
-        // advisory, never a silent pass.
-        const undeclared = {
-            canvas: { left: 0, top: 0, right: 200, bottom: 400 },
-            nodes: [
-                { id: 'code', bounds: { left: 0, top: 0, right: 100, bottom: 20 }, parentId: null, clipsChildren: false },
-            ],
-        };
-        const block = buildStructuralBlock(undeclared, null, 2, undefined, {
-            baseline: 'figma',
-            elementIds: ['code'],
-            typeface: { code: { family: 'Poppins', weight: 600 } },
-        });
-        expect(block.appearance?.facts).toEqual([]);
-        expect(block.appearance?.advisories).toEqual([
-            'typeface check requires render SDK >= 31; this proof declared no render SDK (an older package) — typeface facts were not derived (not checked, not passing)',
-        ]);
-    });
-});
-// ---- Signal C: previous-render → AppearanceReference mapper (issue 01) ----
-//
-// The no-Figma drift path: a previous catalog render persisted its own
-// appearance snapshot (`appearance.rendered`: element ids + per-element colors).
-// This pure mapper turns that snapshot into the `previous_render`
-// AppearanceReference the next render diffs against — the colors/ids to compare,
-// marked as drift (regression vs the last render), not a design divergence. It is
-// the testable core the thin catalog-fetch adapter wraps; no I/O here.
-describe('appearanceReferenceFromPreviousRender — previous render snapshot → reference', () => {
-    test('a previous render with per-element fill colors → a previous_render reference carrying color + ids', () => {
-        const previous = {
-            elementIds: ['banner', 'voucher'],
-            color: { banner: { fill: '#fff0ee' } },
-        };
-        expect(appearanceReferenceFromPreviousRender(previous)).toEqual({
-            baseline: 'previous_render',
-            elementIds: ['banner', 'voucher'],
-            color: { banner: { fill: '#fff0ee' } },
-        });
-    });
-    test('a previous render with per-element text colors → the text channel rides through into the reference (issue 02)', () => {
-        // The mapper carries the whole previous color map, so the foreground (text)
-        // channel reaches the reference exactly as the fill channel does — channel
-        // genericity, not a fill-only carry.
-        const previous = {
-            elementIds: ['banner', 'copy'],
-            color: { banner: { fill: '#fff0ee' }, copy: { text: '#1b1b1b' } },
-        };
-        expect(appearanceReferenceFromPreviousRender(previous)).toEqual({
-            baseline: 'previous_render',
-            elementIds: ['banner', 'copy'],
-            color: { banner: { fill: '#fff0ee' }, copy: { text: '#1b1b1b' } },
-        });
-    });
-    test("a previous render with per-element text → the mapper carries text into the reference (issue 03)", () => {
-        // The previous render's accessible text content (copy) becomes the reference
-        // the next render's text is diffed against — drift, not design divergence.
-        const previous = {
-            elementIds: ['banner', 'copy'],
-            text: { copy: 'Get 5 € off your first order placed by 1 lug 2026.' },
-        };
-        expect(appearanceReferenceFromPreviousRender(previous)).toEqual({
-            baseline: 'previous_render',
-            elementIds: ['banner', 'copy'],
-            text: { copy: 'Get 5 € off your first order placed by 1 lug 2026.' },
-        });
-    });
-    test('a previous render with per-element resolved typefaces → the mapper carries typeface into the reference (typeface issue 05)', () => {
-        // The previous render's RESOLVED font becomes the drift reference: a
-        // previously-correct element that silently falls back on a later build then
-        // diverges from its own prior snapshot and is flagged.
-        const previous = {
-            elementIds: ['banner', 'code'],
-            typeface: { code: { family: 'poppins_semibold', weight: 600 } },
-        };
-        expect(appearanceReferenceFromPreviousRender(previous)).toEqual({
-            baseline: 'previous_render',
-            elementIds: ['banner', 'code'],
-            typeface: { code: { family: 'poppins_semibold', weight: 600 } },
-        });
-        // An empty typeface map is no signal on that axis — not carried.
-        expect(appearanceReferenceFromPreviousRender({ elementIds: ['banner'], typeface: {} })).toEqual({ baseline: 'previous_render', elementIds: ['banner'] });
-    });
-    test('fed into buildStructuralBlock, a typeface that drifts from the previous render yields a previous_render typeface fact (typeface issue 05)', () => {
-        const dump = {
-            canvas: { left: 0, top: 0, right: 343, bottom: 72 },
-            renderSdk: 34,
-            nodes: [
-                { id: 'code', bounds: { left: 0, top: 0, right: 343, bottom: 40 }, parentId: null, clipsChildren: false, text: 'INV-50', resolvedTypeface: { family: 'Roboto-Regular', weight: 400 } },
-            ],
-        };
-        const previous = {
-            elementIds: ['code'],
-            typeface: { code: { family: 'poppins_semibold' } },
-        };
-        const block = buildStructuralBlock(dump, null, 2, undefined, appearanceReferenceFromPreviousRender(previous));
-        expect(block.appearance?.baseline).toBe('previous_render');
-        const typefaceFacts = (block.appearance?.facts ?? []).filter((f) => f.kind === 'typeface');
-        expect(typefaceFacts).toEqual([
-            {
-                kind: 'typeface',
-                elementId: 'code',
-                channel: 'text',
-                rendered: { family: 'Roboto-Regular', weight: 400 },
-                reference: { family: 'poppins_semibold' },
-            },
-        ]);
-    });
-    test('a previous render with both color and text → the reference carries both maps (issue 03)', () => {
-        const previous = {
-            elementIds: ['banner', 'copy'],
-            color: { banner: { fill: '#fff0ee' }, copy: { text: '#1b1b1b' } },
-            text: { copy: 'Get 5 € off' },
-        };
-        expect(appearanceReferenceFromPreviousRender(previous)).toEqual({
-            baseline: 'previous_render',
-            elementIds: ['banner', 'copy'],
-            color: { banner: { fill: '#fff0ee' }, copy: { text: '#1b1b1b' } },
-            text: { copy: 'Get 5 € off' },
-        });
-    });
-    test('an empty text map is treated as no text signal (presence-only on the text axis) (issue 03)', () => {
-        const previous = { elementIds: ['copy'], text: {} };
-        expect(appearanceReferenceFromPreviousRender(previous)).toEqual({
-            baseline: 'previous_render',
-            elementIds: ['copy'],
-        });
-    });
-    test('a previous render with no extractable color → a presence-only reference (ids, no color)', () => {
-        const previous = { elementIds: ['banner', 'voucher'] };
-        expect(appearanceReferenceFromPreviousRender(previous)).toEqual({
-            baseline: 'previous_render',
-            elementIds: ['banner', 'voucher'],
-        });
-    });
-    test('an empty color map is treated as no color signal (presence-only)', () => {
-        const previous = { elementIds: ['banner'], color: {} };
-        expect(appearanceReferenceFromPreviousRender(previous)).toEqual({
-            baseline: 'previous_render',
-            elementIds: ['banner'],
-        });
-    });
-    test('a genuinely absent previous render → null (no appearance container downstream)', () => {
-        expect(appearanceReferenceFromPreviousRender(null)).toBeNull();
-        expect(appearanceReferenceFromPreviousRender(undefined)).toBeNull();
-        expect(appearanceReferenceFromPreviousRender({})).toBeNull();
-    });
-    test('fed into buildStructuralBlock, a drifted fill produces a previous_render color fact (the tracer)', () => {
-        // The render now paints the banner the wrong fill (#1e88e5); the previous
-        // render painted #fff0ee. The mapper turns that previous snapshot into the
-        // drift reference, and the assembled block carries one fill color fact with a
-        // large positive ΔE — exactly the blue-banner divergence, proven through the
-        // public interface (the e2e proves the same on a real render).
-        const driftedDump = {
-            canvas: { left: 0, top: 0, right: 686, bottom: 282 },
-            nodes: [
-                { id: 'banner', bounds: { left: 0, top: 0, right: 686, bottom: 282 }, parentId: null, clipsChildren: false, fillColor: '#1e88e5' },
-            ],
-        };
-        const previous = { elementIds: ['banner'], color: { banner: { fill: '#fff0ee' } } };
-        const reference = appearanceReferenceFromPreviousRender(previous);
-        const block = buildStructuralBlock(driftedDump, null, 2, undefined, reference);
-        expect(block.appearance?.baseline).toBe('previous_render');
-        const colorFacts = (block.appearance?.facts ?? []).filter((f) => f.kind === 'color');
-        expect(colorFacts).toEqual([
-            {
-                kind: 'color',
-                elementId: 'banner',
-                channel: 'fill',
-                rendered: '#1e88e5',
-                reference: '#fff0ee',
-                deltaE: ciede2000(hexToLab('#1e88e5'), hexToLab('#fff0ee')),
-            },
-        ]);
-        expect(colorFacts[0].kind === 'color' && colorFacts[0].deltaE).toBeGreaterThan(10);
-    });
-    test('fed into buildStructuralBlock, a drifted text color produces a previous_render text-channel fact (issue 02)', () => {
-        // The render paints `copy` the wrong foreground color (#1e88e5); the previous
-        // render painted #1b1b1b. The mapper carries the text channel through, and the
-        // assembled block carries one text color fact with a large positive ΔE —
-        // distinct from fill, proven through the public interface.
-        const driftedDump = {
-            canvas: { left: 0, top: 0, right: 686, bottom: 282 },
-            nodes: [
-                { id: 'copy', bounds: { left: 0, top: 0, right: 343, bottom: 40 }, parentId: null, clipsChildren: false, textColor: '#1e88e5' },
-            ],
-        };
-        const previous = { elementIds: ['copy'], color: { copy: { text: '#1b1b1b' } } };
-        const reference = appearanceReferenceFromPreviousRender(previous);
-        const block = buildStructuralBlock(driftedDump, null, 2, undefined, reference);
-        expect(block.appearance?.baseline).toBe('previous_render');
-        const colorFacts = (block.appearance?.facts ?? []).filter((f) => f.kind === 'color');
-        expect(colorFacts).toEqual([
-            {
-                kind: 'color',
-                elementId: 'copy',
-                channel: 'text',
-                rendered: '#1e88e5',
-                reference: '#1b1b1b',
-                deltaE: ciede2000(hexToLab('#1e88e5'), hexToLab('#1b1b1b')),
-            },
-        ]);
-        expect(colorFacts[0].kind === 'color' && colorFacts[0].deltaE).toBeGreaterThan(10);
-    });
-    test('a correct fill with a wrong text color yields a text-channel fact only — the two never collapse (issue 02)', () => {
-        // One element carries both channels: fill matches the previous render, text
-        // drifts. Exactly one fact, channel:'text' — the correct fill produces none.
-        const dump = {
-            canvas: { left: 0, top: 0, right: 343, bottom: 72 },
-            nodes: [
-                { id: 'banner', bounds: { left: 0, top: 0, right: 343, bottom: 72 }, parentId: null, clipsChildren: false, fillColor: '#fff0ee', textColor: '#1e88e5' },
-            ],
-        };
-        const previous = {
-            elementIds: ['banner'],
-            color: { banner: { fill: '#fff0ee', text: '#1b1b1b' } },
-        };
-        const block = buildStructuralBlock(dump, null, 2, undefined, appearanceReferenceFromPreviousRender(previous));
-        const colorFacts = (block.appearance?.facts ?? []).filter((f) => f.kind === 'color');
-        expect(colorFacts).toEqual([
-            {
-                kind: 'color',
-                elementId: 'banner',
-                channel: 'text',
-                rendered: '#1e88e5',
-                reference: '#1b1b1b',
-                deltaE: ciede2000(hexToLab('#1e88e5'), hexToLab('#1b1b1b')),
-            },
-        ]);
-    });
-    test('fed into buildStructuralBlock, drifted copy produces a previous_render text_mismatch fact (issue 03)', () => {
-        // The render paints `copy` a different string than the previous render; the
-        // mapper carries the previous text through, and the assembled block carries
-        // one text_mismatch with both strings — drift, proven through the public API.
-        const dump = {
-            canvas: { left: 0, top: 0, right: 343, bottom: 72 },
-            nodes: [
-                { id: 'copy', bounds: { left: 0, top: 0, right: 343, bottom: 40 }, parentId: null, clipsChildren: false, text: 'Get 10 € off your first order placed by 1 lug 2026.' },
-            ],
-        };
-        const previous = {
-            elementIds: ['copy'],
-            text: { copy: 'Get 5 € off your first order placed by 1 lug 2026.' },
-        };
-        const block = buildStructuralBlock(dump, null, 2, undefined, appearanceReferenceFromPreviousRender(previous));
-        expect(block.appearance?.baseline).toBe('previous_render');
-        expect(block.appearance?.facts).toEqual([
-            {
-                kind: 'text_mismatch',
-                elementId: 'copy',
-                rendered: 'Get 10 € off your first order placed by 1 lug 2026.',
-                reference: 'Get 5 € off your first order placed by 1 lug 2026.',
-            },
-        ]);
-    });
-    test('a reference with text the render no longer carries → a previous_render text_missing fact (issue 03)', () => {
-        const dump = {
-            canvas: { left: 0, top: 0, right: 343, bottom: 72 },
-            nodes: [
-                { id: 'copy', bounds: { left: 0, top: 0, right: 343, bottom: 40 }, parentId: null, clipsChildren: false },
-            ],
-        };
-        const previous = {
-            elementIds: ['copy'],
-            text: { copy: 'Get 5 € off' },
-        };
-        const block = buildStructuralBlock(dump, null, 2, undefined, appearanceReferenceFromPreviousRender(previous));
-        expect(block.appearance?.facts).toEqual([
-            { kind: 'text_missing', elementId: 'copy', reference: 'Get 5 € off' },
-        ]);
-    });
-    test('identical copy vs the previous render → no text fact (issue 03)', () => {
-        const dump = {
-            canvas: { left: 0, top: 0, right: 343, bottom: 72 },
-            nodes: [
-                { id: 'copy', bounds: { left: 0, top: 0, right: 343, bottom: 40 }, parentId: null, clipsChildren: false, text: 'Get 5 € off' },
-            ],
-        };
-        const previous = { elementIds: ['copy'], text: { copy: 'Get 5 € off' } };
-        const block = buildStructuralBlock(dump, null, 2, undefined, appearanceReferenceFromPreviousRender(previous));
-        expect(block.appearance?.facts).toEqual([]);
-    });
-});
-// ---- Signal C: build the appearance reference from run params (issue 05) ----
-//
-// The runner builds the appearanceReference from the per-screen reference_geometry
-// / reference_text / reference_color params. Issue 05 decouples the container from
-// reference_geometry: it is assembled when ANY of the three is present, with
-// elementIds = the UNION of their keys, so a run with reference_color but no
-// reference_geometry still emits color facts.
-describe('buildAppearanceReferenceFromParams — union of geometry/text/color ids', () => {
-    test('color only (no geometry) → a reference carrying color, ids from the color keys', () => {
-        const ref = buildAppearanceReferenceFromParams({
-            refColor: { banner: { fill: '#fff0ee' } },
-            baseline: 'previous_render',
-        });
-        expect(ref).toEqual({
-            baseline: 'previous_render',
-            elementIds: ['banner'],
-            color: { banner: { fill: '#fff0ee' } },
-        });
-    });
-    test('geometry only → ids from the geometry keys, no text/color attached', () => {
-        const ref = buildAppearanceReferenceFromParams({
-            refGeom: { banner: { w: 343, h: 96 }, voucher: { w: 81, h: 81 } },
-            baseline: 'figma',
-        });
-        expect(ref).toEqual({ baseline: 'figma', elementIds: ['banner', 'voucher'] });
-    });
-    test('geometry + color (color ids ⊆ geometry ids) → ids unchanged (additive, no regression)', () => {
-        const ref = buildAppearanceReferenceFromParams({
-            refGeom: { banner: { w: 343, h: 96 }, voucher: { w: 81, h: 81 } },
-            refColor: { banner: { fill: '#fff0ee' } },
-            baseline: 'figma',
-        });
-        expect(ref).toEqual({
-            baseline: 'figma',
-            elementIds: ['banner', 'voucher'],
-            color: { banner: { fill: '#fff0ee' } },
-        });
-    });
-    test('text + color, no geometry → union ids, both attached', () => {
-        const ref = buildAppearanceReferenceFromParams({
-            refText: { copy: 'Get 5 € off' },
-            refColor: { banner: { fill: '#fff0ee' } },
-            baseline: 'previous_render',
-        });
-        expect(ref).toEqual({
-            baseline: 'previous_render',
-            elementIds: ['copy', 'banner'],
-            text: { copy: 'Get 5 € off' },
-            color: { banner: { fill: '#fff0ee' } },
-        });
-    });
-    test('spans only (no geometry/text/color) → a reference carrying spans, ids from the span keys (issue 16)', () => {
-        const ref = buildAppearanceReferenceFromParams({
-            refSpans: { discountText: { text: '5 EUR off', background: '#ffe45e' } },
-            baseline: 'figma',
-        });
-        expect(ref).toEqual({
-            baseline: 'figma',
-            elementIds: ['discountText'],
-            spans: { discountText: { text: '5 EUR off', background: '#ffe45e' } },
-        });
-    });
-    test('lines only (no geometry/text/color/spans) → a reference carrying lines, ids from the line keys (issue 18)', () => {
-        const ref = buildAppearanceReferenceFromParams({
-            refLines: { promoCopy: ['Get 5 EUR off', 'placed by tomorrow.'] },
-            baseline: 'figma',
-        });
-        expect(ref).toEqual({
-            baseline: 'figma',
-            elementIds: ['promoCopy'],
-            lines: { promoCopy: ['Get 5 EUR off', 'placed by tomorrow.'] },
-        });
-    });
-    test('typeface only (no geometry/text/color) → a reference carrying typeface, ids from the typeface keys (typeface issue 04)', () => {
-        const ref = buildAppearanceReferenceFromParams({
-            refTypeface: { code: { family: 'Poppins', weight: 600 } },
-            baseline: 'figma',
-        });
-        expect(ref).toEqual({
-            baseline: 'figma',
-            elementIds: ['code'],
-            typeface: { code: { family: 'Poppins', weight: 600 } },
-        });
-    });
-    test('none present → null (no appearance container)', () => {
-        expect(buildAppearanceReferenceFromParams({ baseline: 'figma' })).toBeNull();
-        expect(buildAppearanceReferenceFromParams({ baseline: 'figma', refGeom: {}, refColor: {}, refText: {}, refSpans: {}, refLines: {}, refTypeface: {} })).toBeNull();
-    });
-    test('fed into buildStructuralBlock, a typeface reference flags a diverging resolved font and stays silent on a matching or unresolvable one (typeface issue 04)', () => {
-        // The design (Figma) declares Poppins 600 on `code` and Fira Sans 500 on
-        // `label`. The render resolved a Roboto fallback on `code` (→ one fact) and
-        // the correct font on `label` (→ none); `legacyText` has a declared font but
-        // no resolved enrichment (old package) → no signal, no fact.
-        const dump = {
-            canvas: { left: 0, top: 0, right: 686, bottom: 282 },
-            renderSdk: 34,
-            nodes: [
-                { id: 'code', bounds: { left: 0, top: 0, right: 300, bottom: 40 }, parentId: null, clipsChildren: false, text: 'INV-50', resolvedTypeface: { family: 'Roboto-Regular', weight: 400 } },
-                { id: 'label', bounds: { left: 0, top: 50, right: 300, bottom: 90 }, parentId: null, clipsChildren: false, text: 'Your code', resolvedTypeface: { family: 'fira_sans_medium' } },
-                { id: 'legacyText', bounds: { left: 0, top: 100, right: 300, bottom: 140 }, parentId: null, clipsChildren: false, text: 'Old' },
-            ],
-        };
-        const ref = buildAppearanceReferenceFromParams({
-            refTypeface: {
-                code: { family: 'Poppins', weight: 600 },
-                label: { family: 'Fira Sans', weight: 500 },
-                legacyText: { family: 'Poppins', weight: 400 },
-            },
-            baseline: 'figma',
-        });
-        const block = buildStructuralBlock(dump, null, 2, undefined, ref);
-        const typefaceFacts = (block.appearance?.facts ?? []).filter((f) => f.kind === 'typeface');
-        expect(typefaceFacts).toEqual([
-            {
-                kind: 'typeface',
-                elementId: 'code',
-                channel: 'text',
-                rendered: { family: 'Roboto-Regular', weight: 400 },
-                reference: { family: 'Poppins', weight: 600 },
-            },
-        ]);
-    });
-    test('fed into buildStructuralBlock, a spans-only reference emits exactly one span_mismatch for the wrong extent (issue 16)', () => {
-        const dump = {
-            canvas: { left: 0, top: 0, right: 686, bottom: 282 },
-            nodes: [
-                {
-                    id: 'discountText',
-                    bounds: { left: 0, top: 0, right: 300, bottom: 40 },
-                    parentId: null,
-                    clipsChildren: false,
-                    text: 'Get 5 EUR off',
-                    textSpans: [{ start: 4, end: 9, text: '5 EUR', background: '#ffe45e' }],
-                },
-                // A node that never emitted spans (old package) — the declared
-                // expectation for it must stay silent.
-                { id: 'legacyText', bounds: { left: 0, top: 50, right: 300, bottom: 90 }, parentId: null, clipsChildren: false, text: 'Free delivery' },
-            ],
-        };
-        const ref = buildAppearanceReferenceFromParams({
-            refSpans: {
-                discountText: { text: '5 EUR off', background: '#ffe45e' },
-                legacyText: { text: 'Free' },
-            },
-            baseline: 'figma',
-        });
-        const block = buildStructuralBlock(dump, null, 2, undefined, ref);
-        expect(block.appearance?.facts).toEqual([
-            { kind: 'span_mismatch', elementId: 'discountText', rendered: '5 EUR', reference: '5 EUR off' },
-        ]);
-    });
-    test('a matching extent yields a container with zero facts (the fixed wrapper is clean)', () => {
-        const dump = {
-            canvas: { left: 0, top: 0, right: 686, bottom: 282 },
-            nodes: [
-                {
-                    id: 'discountText',
-                    bounds: { left: 0, top: 0, right: 300, bottom: 40 },
-                    parentId: null,
-                    clipsChildren: false,
-                    text: 'Get 5 EUR off',
-                    textSpans: [{ start: 4, end: 13, text: '5 EUR off', background: '#ffe45e' }],
-                },
-            ],
-        };
-        const ref = buildAppearanceReferenceFromParams({
-            refSpans: { discountText: { text: '5 EUR off' } },
-            baseline: 'figma',
-        });
-        const block = buildStructuralBlock(dump, null, 2, undefined, ref);
-        expect(block.appearance?.facts).toEqual([]);
-    });
-    test('fed into buildStructuralBlock, a lines-only reference emits exactly one line_break_mismatch for a dropped break (issue 18)', () => {
-        const dump = {
-            canvas: { left: 0, top: 0, right: 686, bottom: 282 },
-            nodes: [
-                {
-                    id: 'promoCopy',
-                    bounds: { left: 0, top: 0, right: 600, bottom: 40 },
-                    parentId: null,
-                    clipsChildren: false,
-                    text: 'Get 5 EUR off placed by tomorrow.',
-                    textLines: [{ start: 0, end: 33, text: 'Get 5 EUR off placed by tomorrow.' }],
-                },
-                // Emitted no lines (old package) — the declared split stays silent.
-                { id: 'legacyText', bounds: { left: 0, top: 50, right: 600, bottom: 90 }, parentId: null, clipsChildren: false, text: 'Free delivery' },
-            ],
-        };
-        const ref = buildAppearanceReferenceFromParams({
-            refLines: {
-                promoCopy: ['Get 5 EUR off', 'placed by tomorrow.'],
-                legacyText: ['Free', 'delivery'],
-            },
-            baseline: 'figma',
-        });
-        const block = buildStructuralBlock(dump, null, 2, undefined, ref);
-        expect(block.appearance?.facts).toEqual([
-            {
-                kind: 'line_break_mismatch',
-                elementId: 'promoCopy',
-                rendered: 'Get 5 EUR off placed by tomorrow.',
-                reference: 'Get 5 EUR off\nplaced by tomorrow.',
-            },
-        ]);
-    });
-    test('a matching line split yields a container with zero facts', () => {
-        const dump = {
-            canvas: { left: 0, top: 0, right: 686, bottom: 282 },
-            nodes: [
-                {
-                    id: 'promoCopy',
-                    bounds: { left: 0, top: 0, right: 600, bottom: 40 },
-                    parentId: null,
-                    clipsChildren: false,
-                    text: 'Get 5 EUR off\nplaced by tomorrow.',
-                    textLines: [
-                        { start: 0, end: 13, text: 'Get 5 EUR off' },
-                        { start: 14, end: 33, text: 'placed by tomorrow.' },
-                    ],
-                },
-            ],
-        };
-        const ref = buildAppearanceReferenceFromParams({
-            refLines: { promoCopy: ['Get 5 EUR off', 'placed by tomorrow.'] },
-            baseline: 'figma',
-        });
-        const block = buildStructuralBlock(dump, null, 2, undefined, ref);
-        expect(block.appearance?.facts).toEqual([]);
-    });
-    test('fed into buildStructuralBlock, a color-only reference still emits the color fact', () => {
-        const dump = {
-            canvas: { left: 0, top: 0, right: 686, bottom: 282 },
-            nodes: [
-                { id: 'banner', bounds: { left: 0, top: 0, right: 686, bottom: 282 }, parentId: null, clipsChildren: false, fillColor: '#1e88e5' },
-            ],
-        };
-        const ref = buildAppearanceReferenceFromParams({
-            refColor: { banner: { fill: '#fff0ee' } },
-            baseline: 'previous_render',
-        });
-        const block = buildStructuralBlock(dump, null, 2, undefined, ref);
-        expect(block.appearance?.facts).toEqual([
-            {
-                kind: 'color',
-                elementId: 'banner',
-                channel: 'fill',
-                rendered: '#1e88e5',
-                reference: '#fff0ee',
-                deltaE: ciede2000(hexToLab('#1e88e5'), hexToLab('#fff0ee')),
-            },
-        ]);
-    });
-});
-describe('buildStructuralBlock — design-frame anchor (composition runs)', () => {
-    // 686x384px at density 2 → a 343×192dp captured root.
-    const FRAME_DUMP = {
-        canvas: { left: 0, top: 0, right: 686, bottom: 384 },
-        nodes: [
-            { id: 'voucher', bounds: { left: 32, top: 48, right: 194, bottom: 210 }, parentId: null, clipsChildren: false },
-        ],
-    };
-    const GEOM = { voucher: { w: 81, h: 81, x: 16, y: 24 } };
-    test('root ≈ declared frame → no mismatch fact, placement is not withheld', () => {
-        const block = buildStructuralBlock(FRAME_DUMP, GEOM, 2, undefined, undefined, { w: 343, h: 192 });
-        expect(block.facts.filter((f) => f.kind === 'frame_mismatch')).toEqual([]);
-        expect(block.placement).toEqual({ withheld: false, facts: [] });
-    });
-    test('sub-tolerance drift (≤1dp) does not read as a mismatch', () => {
-        const block = buildStructuralBlock(FRAME_DUMP, GEOM, 2, undefined, undefined, { w: 342.5, h: 192.5 });
-        expect(block.facts.filter((f) => f.kind === 'frame_mismatch')).toEqual([]);
-        expect(block.placement).toEqual({ withheld: false, facts: [] });
-    });
-    test('a mis-sized root → frame_mismatch fact with declared/captured dims, placement withheld', () => {
-        const block = buildStructuralBlock(FRAME_DUMP, GEOM, 2, undefined, undefined, { w: 343, h: 100 });
-        const mismatches = block.facts.filter((f) => f.kind === 'frame_mismatch');
-        expect(mismatches).toEqual([
-            {
-                kind: 'frame_mismatch',
-                declared: { w: 343, h: 100 },
-                captured: { w: 343, h: 192 },
-                deltas: [{ dimension: 'h', delta: 92 }],
-            },
-        ]);
-        expect(block.placement).toEqual({ withheld: true, reason: 'frame_mismatch' });
-        // A mis-sized wrapper root is not a clean render.
-        expect(block.summary.clean).toBe(false);
-    });
-    test('the mismatch review row reads as a mis-sized wrapper root, never a screen defect', () => {
-        const block = buildStructuralBlock(FRAME_DUMP, GEOM, 2, undefined, undefined, { w: 343, h: 100 });
-        const scaffold = buildReviewScaffold(block);
-        const row = scaffold.rows.find((r) => r.fact.includes('wrapper root'));
-        expect(row).toBeDefined();
-        expect(row.fact).toContain('343×192');
-        expect(row.fact).toContain('343×100');
-        expect(row.fact.toLowerCase()).toContain('size the wrapper root');
-    });
-    test('no declared frame → no placement container, block unchanged from today', () => {
-        const withoutFrame = buildStructuralBlock(FRAME_DUMP, GEOM, 2);
-        expect(withoutFrame.placement).toBeUndefined();
-        expect(buildStructuralBlock(FRAME_DUMP, GEOM, 2, undefined, undefined, null)).toEqual(withoutFrame);
-    });
-    test('embedded stage matches the module for match and mismatch alike (parity)', () => {
-        const embedded = getGeometryStageInternals();
-        for (const frame of [{ w: 343, h: 192 }, { w: 343, h: 100 }, null]) {
-            expect(embedded.buildStructuralBlock(FRAME_DUMP, GEOM, 2, undefined, undefined, frame)).toEqual(buildStructuralBlock(FRAME_DUMP, GEOM, 2, undefined, undefined, frame));
-        }
-    });
-});
-describe('buildStructuralBlock — placement facts (composition runs)', () => {
-    // 686x384px at density 2 → a 343×192dp captured root; frame matches.
-    const FRAME = { w: 343, h: 192 };
-    // voucher: design places it at (16, 24); rendered root-space (unclipped)
-    // bounds put it at (16, 24) → in place, or shifted for the drift cases.
-    function dumpWithVoucherAt(leftPx, topPx) {
-        return {
-            canvas: { left: 0, top: 0, right: 686, bottom: 384 },
-            nodes: [
-                {
-                    id: 'voucher',
-                    bounds: { left: leftPx, top: topPx, right: leftPx + 162, bottom: topPx + 162 },
-                    unclippedBounds: { left: leftPx, top: topPx, right: leftPx + 162, bottom: topPx + 162 },
-                    parentId: null,
-                    clipsChildren: false,
-                },
-            ],
-        };
-    }
-    const GEOM = { voucher: { w: 81, h: 81, x: 16, y: 24 } };
-    test('a member root shifted beyond tolerance → a placement fact with expected/actual/delta', () => {
-        // Rendered at (20, 100)dp = (40, 200)px — design says (16, 24)dp.
-        const block = buildStructuralBlock(dumpWithVoucherAt(40, 200), GEOM, 2, undefined, undefined, FRAME);
-        expect(block.placement).toEqual({
-            withheld: false,
-            facts: [
-                {
-                    elementId: 'voucher',
-                    expected: { x: 16, y: 24 },
-                    actual: { x: 20, y: 100 },
-                    deltas: [
-                        { dimension: 'x', delta: 4 },
-                        { dimension: 'y', delta: 76 },
-                    ],
-                },
-            ],
-        });
-        // Placement drift is load-bearing on a composition State — not clean.
-        expect(block.summary.clean).toBe(false);
-    });
-    test('within tolerance (≤2dp) → measured but no fact, still clean', () => {
-        // Rendered at (17, 25)dp = (34, 50)px — 1dp off design (16, 24).
-        const block = buildStructuralBlock(dumpWithVoucherAt(34, 50), GEOM, 2, undefined, undefined, FRAME);
-        expect(block.placement).toEqual({ withheld: false, facts: [] });
-        expect(block.summary.clean).toBe(true);
-    });
-    test('an element without design x/y contributes no placement fact', () => {
-        const geomNoXY = { voucher: { w: 81, h: 81 } };
-        const block = buildStructuralBlock(dumpWithVoucherAt(40, 200), geomNoXY, 2, undefined, undefined, FRAME);
-        expect(block.placement).toEqual({ withheld: false, facts: [] });
-    });
-    test('frame mismatch → placement facts withheld with the reason, none computed', () => {
-        const block = buildStructuralBlock(dumpWithVoucherAt(40, 200), GEOM, 2, undefined, undefined, { w: 343, h: 100 });
-        expect(block.placement).toEqual({ withheld: true, reason: 'frame_mismatch' });
-        expect(block.placement && 'facts' in block.placement).toBe(false);
-    });
-    test('no declared frame (component runs) → no placement facts, identical deltas stay advisory', () => {
-        const block = buildStructuralBlock(dumpWithVoucherAt(40, 200), GEOM, 2);
-        expect(block.placement).toBeUndefined();
-        // x/y deltas still reported (advisory) on the geometry element, unflagged.
-        const el = block.geometry.elements.find((e) => e.id === 'voucher');
-        expect(el.deltas.some((d) => d.dimension === 'x' || d.dimension === 'y')).toBe(true);
-        expect(el.sizeFlag).toBe(false);
-        expect(block.summary.clean).toBe(true);
-    });
-    test('embedded stage matches the module for drift, clean, and withheld (parity)', () => {
-        const embedded = getGeometryStageInternals();
-        const cases = [
-            [dumpWithVoucherAt(40, 200), FRAME],
-            [dumpWithVoucherAt(34, 50), FRAME],
-            [dumpWithVoucherAt(40, 200), { w: 343, h: 100 }],
-            [dumpWithVoucherAt(40, 200), null],
-        ];
-        for (const [dump, frame] of cases) {
-            expect(embedded.buildStructuralBlock(dump, GEOM, 2, undefined, undefined, frame)).toEqual(buildStructuralBlock(dump, GEOM, 2, undefined, undefined, frame));
-        }
-    });
-});
-describe('buildStructuralBlock — frame-anchored component runs (coverage-gaps issue 01)', () => {
-    // Same fixtures as the composition placement suite: 686x384px at density 2 →
-    // a 343×192dp captured root that MATCHES the design frame — but here the run
-    // is a COMPONENT run (no composition referenceFrame); the frame arrives as
-    // the ANCHOR PROBE instead. ADR-0004's canvas-width-artifact rationale for
-    // advisory x/y provably does not apply to a design-frame-sized root, so an
-    // anchored component run earns the same placement check a composition run
-    // gets. A root that does not match keeps today's advisory behavior exactly.
-    const FRAME = { w: 343, h: 192 };
-    function dumpWithVoucherAt(leftPx, topPx) {
-        return {
-            canvas: { left: 0, top: 0, right: 686, bottom: 384 },
-            nodes: [
-                {
-                    id: 'voucher',
-                    bounds: { left: leftPx, top: topPx, right: leftPx + 162, bottom: topPx + 162 },
-                    unclippedBounds: { left: leftPx, top: topPx, right: leftPx + 162, bottom: topPx + 162 },
-                    parentId: null,
-                    clipsChildren: false,
-                },
-            ],
-        };
-    }
-    const GEOM = { voucher: { w: 81, h: 81, x: 16, y: 24 } };
-    test('an anchored root with an element shifted beyond tolerance → placement facts flag (the −50dp button)', () => {
-        const block = buildStructuralBlock(dumpWithVoucherAt(40, 200), GEOM, 2, undefined, undefined, null, FRAME);
-        expect(block.placement).toEqual({
-            withheld: false,
-            facts: [
-                {
-                    elementId: 'voucher',
-                    expected: { x: 16, y: 24 },
-                    actual: { x: 20, y: 100 },
-                    deltas: [
-                        { dimension: 'x', delta: 4 },
-                        { dimension: 'y', delta: 76 },
-                    ],
-                },
-            ],
-        });
-        expect(block.summary.clean).toBe(false);
-    });
-    test('an anchored root with everything in place → placement rides with zero facts, clean', () => {
-        // Rendered at (16, 24)dp = (32, 48)px — exactly the design position.
-        const block = buildStructuralBlock(dumpWithVoucherAt(32, 48), GEOM, 2, undefined, undefined, null, FRAME);
-        expect(block.placement).toEqual({ withheld: false, facts: [] });
-        expect(block.summary.clean).toBe(true);
-    });
-    test('a content-sized root (anchor does not match) keeps today\'s behavior byte-identically', () => {
-        // 400x200px @2 → a 200x100dp root, nowhere near the 343×192 frame: no
-        // frame_mismatch fact, no placement container, x/y stays advisory — the
-        // probe must never start an invalidation storm for legacy wrappers.
-        const dump = {
-            canvas: { left: 0, top: 0, right: 400, bottom: 200 },
-            nodes: [
-                {
-                    id: 'voucher',
-                    bounds: { left: 40, top: 20, right: 202, bottom: 182 },
-                    unclippedBounds: { left: 40, top: 20, right: 202, bottom: 182 },
-                    parentId: null,
-                    clipsChildren: false,
-                },
-            ],
-        };
-        const probed = buildStructuralBlock(dump, GEOM, 2, undefined, undefined, null, FRAME);
-        const without = buildStructuralBlock(dump, GEOM, 2);
-        expect(probed).toEqual(without);
-        expect(probed.placement).toBeUndefined();
-        expect(probed.facts.some((f) => f.kind === 'frame_mismatch')).toBe(false);
-    });
-    test('a composition referenceFrame takes precedence over the probe (never both asserted)', () => {
-        const withBoth = buildStructuralBlock(dumpWithVoucherAt(40, 200), GEOM, 2, undefined, undefined, FRAME, FRAME);
-        const compositionOnly = buildStructuralBlock(dumpWithVoucherAt(40, 200), GEOM, 2, undefined, undefined, FRAME);
-        expect(withBoth).toEqual(compositionOnly);
-    });
-    test('embedded stage matches the module for anchored, unanchored, and in-place (parity)', () => {
-        const embedded = getGeometryStageInternals();
-        const cases = [
-            [dumpWithVoucherAt(40, 200)],
-            [dumpWithVoucherAt(32, 48)],
-        ];
-        for (const [dump] of cases) {
-            expect(embedded.buildStructuralBlock(dump, GEOM, 2, undefined, undefined, null, FRAME)).toEqual(buildStructuralBlock(dump, GEOM, 2, undefined, undefined, null, FRAME));
-        }
-    });
-});
-describe('buildStructuralBlock — duplicate testTag withhold (geometry / overhang / placement)', () => {
-    // A duplicated tag's entry in the generated-geometry map is last-wins, so its
-    // size diff, any overhang computed against it as a frame, and its placement
-    // drift would all compare an arbitrary instance. Each is withheld; the
-    // deriver's duplicate_tag fact carries the collision.
-    test('a duplicated tag gets no geometry element — no size/clip facts for it', () => {
-        const dump = {
-            canvas: { left: 0, top: 0, right: 360, bottom: 200 },
-            nodes: [
-                { id: 'card', bounds: { left: 0, top: 0, right: 360, bottom: 200 }, parentId: null, clipsChildren: false },
-                // 64×33 rendered vs 60×36 declared — would sizeFlag if compared.
-                { id: 'pill', bounds: { left: 10, top: 10, right: 74, bottom: 43 }, parentId: 'card', clipsChildren: false },
-                { id: 'pill', bounds: { left: 10, top: 60, right: 74, bottom: 93 }, parentId: 'card', clipsChildren: false },
-            ],
-        };
-        const block = buildStructuralBlock(dump, { card: { w: 360, h: 200 }, pill: { w: 60, h: 36 } }, 1);
-        expect(block.facts).toContainEqual({ kind: 'duplicate_tag', tag: 'pill', instanceCount: 2 });
-        expect(block.geometry.elements.map((e) => e.id)).toEqual(['card']);
-        expect(block.summary.clean).toBe(false);
-    });
-    test('no overhang is computed against a duplicated frame — the pairing would be arbitrary', () => {
-        const dump = {
-            canvas: { left: 0, top: 0, right: 360, bottom: 400 },
-            nodes: [
-                { id: 'banner', bounds: { left: 0, top: 0, right: 343, bottom: 72 }, parentId: null, clipsChildren: false },
-                { id: 'banner', bounds: { left: 0, top: 100, right: 343, bottom: 172 }, parentId: null, clipsChildren: false },
-                // Child of the duplicated banner: vs the last-wins instance it would
-                // read a spurious 100dp top clip.
-                { id: 'coin', bounds: { left: 300, top: 40, right: 340, bottom: 90 }, parentId: 'banner', clipsChildren: false },
-            ],
-        };
-        const block = buildStructuralBlock(dump, { banner: { x: 0, y: 0, w: 343, h: 72 }, coin: { x: 300, y: 40, w: 40, h: 50 } }, 1);
-        const coin = block.geometry.elements.find((e) => e.id === 'coin');
-        expect(coin).toBeDefined();
-        expect(coin.overhang).toBeUndefined();
-    });
-    test('placement facts skip a duplicated member tag (composition runs)', () => {
-        const dump = {
-            canvas: { left: 0, top: 0, right: 360, bottom: 640 },
-            nodes: [
-                { id: 'root', bounds: { left: 0, top: 0, right: 360, bottom: 640 }, parentId: null, clipsChildren: false },
-                { id: 'member', bounds: { left: 0, top: 0, right: 360, bottom: 100 }, parentId: 'root', clipsChildren: false },
-                { id: 'member', bounds: { left: 0, top: 200, right: 360, bottom: 300 }, parentId: 'root', clipsChildren: false },
-                // Genuinely misplaced: rendered y 500 vs design y 540.
-                { id: 'footer', bounds: { left: 0, top: 500, right: 360, bottom: 640 }, parentId: 'root', clipsChildren: false },
-            ],
-        };
-        const block = buildStructuralBlock(dump, { member: { x: 0, y: 0, w: 360, h: 100 }, footer: { x: 0, y: 540, w: 360, h: 140 } }, 1, undefined, undefined, { w: 360, h: 640 });
-        expect(block.placement.withheld).toBe(false);
-        expect(block.placement.facts.map((f) => f.elementId)).toEqual(['footer']);
-    });
-    test('the review scaffold rows the collision under the tag with the re-tag remediation', () => {
-        const scaffold = buildReviewScaffold({
-            facts: [{ kind: 'duplicate_tag', tag: 'copy_button', instanceCount: 3 }],
-        });
-        expect(scaffold.mustExplain).toEqual(['copy_button']);
-        expect(scaffold.rows).toHaveLength(1);
-        expect(scaffold.rows[0].element).toBe('copy_button');
-        expect(scaffold.rows[0].fact).toContain('3 nodes');
-        expect(scaffold.rows[0].fact).toContain('unique testTag');
-    });
-});
-describe('buildStructuralBlock — text-aware size tolerance (line-box residue)', () => {
-    // JVM (Robolectric) text metrics differ a few dp from Figma's nominal line
-    // boxes, so a text-driven element legitimately renders ±~2dp per laid-out
-    // line. The significance flag (sizeFlag) gets that band — min(8, 2 + 2·L)dp
-    // over the element's subtree line count — while the MEASUREMENT (deltas)
-    // stays exact and non-text elements keep the strict 1dp band (ADR-0004:
-    // strict, not loosen). Fixtures pin the July log cases.
-    const CANVAS_640 = { left: 0, top: 0, right: 360, bottom: 640 };
-    test('the 1-line pill (64×33 rendered vs 60×36 design) records the deltas but does not size-flag', () => {
-        const dump = {
-            canvas: CANVAS_640,
-            nodes: [
-                { id: 'root', bounds: { left: 0, top: 0, right: 360, bottom: 640 }, parentId: null, clipsChildren: false },
-                { id: 'pill', bounds: { left: 16, top: 16, right: 80, bottom: 49 }, parentId: 'root', clipsChildren: false },
-                {
-                    id: 'pill_label',
-                    bounds: { left: 24, top: 24, right: 72, bottom: 41 },
-                    parentId: 'pill',
-                    clipsChildren: false,
-                    text: 'Copy code',
-                    textLines: [{ start: 0, end: 9, text: 'Copy code' }],
-                },
-            ],
-        };
-        const block = buildStructuralBlock(dump, { pill: { w: 60, h: 36 } }, 1);
-        const pill = block.geometry.elements.find((e) => e.id === 'pill');
-        // Measurement integrity: the deltas are still recorded, exactly.
-        expect(pill.deltas).toEqual([
-            { dimension: 'w', delta: 4 },
-            { dimension: 'h', delta: -3 },
-        ]);
-        // Significance: within the 1-line text band (±4dp) — not a size divergence.
-        expect(pill.sizeFlag).toBe(false);
-        expect(block.summary.clean).toBe(true);
-    });
-    test('the 3-line card (65dp rendered vs 72 design) is within the line-scaled band', () => {
-        const dump = {
-            canvas: CANVAS_640,
-            nodes: [
-                { id: 'root', bounds: { left: 0, top: 0, right: 360, bottom: 640 }, parentId: null, clipsChildren: false },
-                { id: 'card', bounds: { left: 16, top: 16, right: 359, bottom: 81 }, parentId: 'root', clipsChildren: false },
-                {
-                    id: 'title',
-                    bounds: { left: 24, top: 24, right: 351, bottom: 45 },
-                    parentId: 'card',
-                    clipsChildren: false,
-                    text: 'Fresh picks',
-                    textLines: [{ start: 0, end: 11, text: 'Fresh picks' }],
-                },
-                {
-                    id: 'subtitle',
-                    bounds: { left: 24, top: 49, right: 351, bottom: 73 },
-                    parentId: 'card',
-                    clipsChildren: false,
-                    text: 'Two lines of helper copy wrap here',
-                    textLines: [
-                        { start: 0, end: 17, text: 'Two lines of help' },
-                        { start: 18, end: 34, text: 'er copy wrap here' },
-                    ],
-                },
-            ],
-        };
-        const block = buildStructuralBlock(dump, { card: { w: 343, h: 72 } }, 1);
-        const card = block.geometry.elements.find((e) => e.id === 'card');
-        expect(card.deltas).toEqual([{ dimension: 'h', delta: -7 }]);
-        // 3 laid-out lines in the subtree → band min(8, 2 + 2·3) = 8dp ≥ 7.
-        expect(card.sizeFlag).toBe(false);
-    });
-    test('a −2dp helper text node stays unflagged (its own line makes it text-driven)', () => {
-        const dump = {
-            canvas: CANVAS_640,
-            nodes: [
-                { id: 'root', bounds: { left: 0, top: 0, right: 360, bottom: 640 }, parentId: null, clipsChildren: false },
-                {
-                    id: 'helper',
-                    bounds: { left: 16, top: 100, right: 136, bottom: 118 },
-                    parentId: 'root',
-                    clipsChildren: false,
-                    text: 'Terms apply',
-                    textLines: [{ start: 0, end: 11, text: 'Terms apply' }],
-                },
-            ],
-        };
-        const block = buildStructuralBlock(dump, { helper: { w: 120, h: 20 } }, 1);
-        const helper = block.geometry.elements.find((e) => e.id === 'helper');
-        expect(helper.deltas).toEqual([{ dimension: 'h', delta: -2 }]);
-        expect(helper.sizeFlag).toBe(false);
-    });
-    test('the 328 vs 343dp button class still fails — 15dp is no line-box residue', () => {
-        const dump = {
-            canvas: CANVAS_640,
-            nodes: [
-                { id: 'root', bounds: { left: 0, top: 0, right: 360, bottom: 640 }, parentId: null, clipsChildren: false },
-                { id: 'button', bounds: { left: 16, top: 500, right: 344, bottom: 548 }, parentId: 'root', clipsChildren: false },
-                {
-                    id: 'button_label',
-                    bounds: { left: 100, top: 514, right: 260, bottom: 534 },
-                    parentId: 'button',
-                    clipsChildren: false,
-                    text: 'Continue',
-                    textLines: [{ start: 0, end: 8, text: 'Continue' }],
-                },
-            ],
-        };
-        const block = buildStructuralBlock(dump, { button: { w: 343, h: 48 } }, 1);
-        const button = block.geometry.elements.find((e) => e.id === 'button');
-        expect(button.sizeFlag).toBe(true);
-        expect(block.summary.clean).toBe(false);
-    });
-    test('the text band is capped at 8dp — a 10dp delta on a 5-line block still fails', () => {
-        const dump = {
-            canvas: CANVAS_640,
-            nodes: [
-                { id: 'root', bounds: { left: 0, top: 0, right: 360, bottom: 640 }, parentId: null, clipsChildren: false },
-                {
-                    id: 'paragraph',
-                    bounds: { left: 16, top: 16, right: 344, bottom: 126 },
-                    parentId: 'root',
-                    clipsChildren: false,
-                    text: 'five lines of copy wrap',
-                    textLines: [
-                        { start: 0, end: 4, text: 'five' },
-                        { start: 5, end: 10, text: 'lines' },
-                        { start: 11, end: 13, text: 'of' },
-                        { start: 14, end: 18, text: 'copy' },
-                        { start: 19, end: 23, text: 'wrap' },
-                    ],
-                },
-            ],
-        };
-        const block = buildStructuralBlock(dump, { paragraph: { w: 328, h: 120 } }, 1);
-        const paragraph = block.geometry.elements.find((e) => e.id === 'paragraph');
-        // min(8, 2 + 2·5) = 8dp < 10dp — the cap keeps large stacks honest.
-        expect(paragraph.sizeFlag).toBe(true);
-    });
-    test('a non-text element keeps the strict band — a 3dp delta still flags', () => {
-        const dump = {
-            canvas: CANVAS_640,
-            nodes: [
-                { id: 'root', bounds: { left: 0, top: 0, right: 360, bottom: 640 }, parentId: null, clipsChildren: false },
-                { id: 'thumbnail', bounds: { left: 16, top: 16, right: 119, bottom: 116 }, parentId: 'root', clipsChildren: false },
-            ],
-        };
-        const block = buildStructuralBlock(dump, { thumbnail: { w: 100, h: 100 } }, 1);
-        const thumbnail = block.geometry.elements.find((e) => e.id === 'thumbnail');
-        expect(thumbnail.deltas).toEqual([{ dimension: 'w', delta: 3 }]);
-        expect(thumbnail.sizeFlag).toBe(true);
-    });
-    test('an old package (text but no textLines) still counts one line per text node', () => {
-        const dump = {
-            canvas: CANVAS_640,
-            nodes: [
-                { id: 'root', bounds: { left: 0, top: 0, right: 360, bottom: 640 }, parentId: null, clipsChildren: false },
-                { id: 'pill', bounds: { left: 16, top: 16, right: 80, bottom: 49 }, parentId: 'root', clipsChildren: false },
-                {
-                    id: 'pill_label',
-                    bounds: { left: 24, top: 24, right: 72, bottom: 41 },
-                    parentId: 'pill',
-                    clipsChildren: false,
-                    text: 'Copy code',
-                },
-            ],
-        };
-        const block = buildStructuralBlock(dump, { pill: { w: 60, h: 36 } }, 1);
-        expect(block.geometry.elements.find((e) => e.id === 'pill').sizeFlag).toBe(false);
-    });
-});
-describe('embedded geometry stage parity', () => {
-    // The render ships a JS-source port of the differ + assembler. It must produce
-    // byte-identical blocks to the canonical typed module, or run-side structural
-    // would diverge from preview-side (Invarn) and from the tests.
-    const embedded = getGeometryStageInternals();
-    test('embedded diffKeyGeometry matches the module', () => {
-        const generated = { card: { width: 328, height: 81 } };
-        const reference = { card: { width: 328, height: 72 } };
-        expect(embedded.diffKeyGeometry(generated, reference)).toEqual(diffKeyGeometry(generated, reference));
-    });
-    test('embedded derivePresenceFacts matches the module (Signal C)', () => {
-        const cases = [
-            [['a', 'b', 'c'], ['a', 'b', 'c']],
-            [['banner'], ['banner', 'voucher']],
-            [['banner', 'debugOverlay'], ['banner']],
-            [['c', 'b', 'a'], ['d', 'a', 'b']],
-            [[], ['x', 'y']],
-            [['x', 'y'], []],
-        ];
-        for (const [rendered, reference] of cases) {
-            expect(embedded.derivePresenceFacts(rendered, reference)).toEqual(derivePresenceFacts(rendered, reference));
-        }
-    });
-    test('embedded buildStructuralBlock matches the module with an appearanceReference', () => {
-        const appearanceReference = { baseline: 'figma', elementIds: ['banner', 'voucher'] };
-        expect(embedded.buildStructuralBlock(HUB_PROMO_DUMP, HUB_PROMO_REFERENCE, 2, undefined, appearanceReference)).toEqual(buildStructuralBlock(HUB_PROMO_DUMP, HUB_PROMO_REFERENCE, 2, undefined, appearanceReference));
-    });
-    test('embedded buildStructuralBlock matches the module for rendered-only geometry (no reference)', () => {
-        // The description path: authored tags + a fact-named synthetic node, no
-        // reference geometry at all. Both copies must select the same ids and emit
-        // identical rendered-only boxes.
-        const dump = {
-            canvas: { left: 0, top: 0, right: 200, bottom: 400 },
-            nodes: [
-                { id: 'node-1', bounds: { left: 0, top: 0, right: 200, bottom: 400 }, parentId: null, clipsChildren: false },
-                { id: 'chip', bounds: { left: 0, top: 0, right: 100, bottom: 40 }, parentId: 'node-1', clipsChildren: false },
-                { id: 'node-7', bounds: { left: 40, top: 0, right: 140, bottom: 40 }, parentId: 'node-1', clipsChildren: false },
-            ],
-        };
-        expect(embedded.buildStructuralBlock(dump, null, 2)).toEqual(buildStructuralBlock(dump, null, 2));
-        expect(embedded.buildStructuralBlock(HUB_PROMO_DUMP, null, 2)).toEqual(buildStructuralBlock(HUB_PROMO_DUMP, null, 2));
-    });
-    test('embedded deriveSpanFacts matches the module (Signal C, issue 16)', () => {
-        const cases = [
-            [{ discountText: [{ start: 4, end: 13, text: '5 EUR off' }] }, { discountText: { text: '5 EUR off' } }],
-            [{ discountText: [{ start: 4, end: 9, text: '5 EUR' }] }, { discountText: { text: '5 EUR off' } }],
-            [{}, { discountText: { text: '5 EUR off' } }],
-            [{ discountText: [{ start: 0, end: 3, text: 'Get' }, { start: 4, end: 9, text: '5 EUR' }] }, { discountText: { text: '5 EUR off' } }],
-            [{ b: [{ start: 0, end: 1, text: 'x' }], a: [{ start: 0, end: 1, text: 'y' }] }, { a: { text: 'right' }, b: { text: 'x' } }],
-            [{ discountText: [{ start: 0, end: 3, text: 'Get' }] }, { discountText: { text: '' } }],
-        ];
-        for (const [rendered, reference] of cases) {
-            expect(embedded.deriveSpanFacts(rendered, reference)).toEqual(deriveSpanFacts(rendered, reference));
-        }
-    });
-    test('embedded buildStructuralBlock matches the module with an appearanceReference carrying spans (issue 16)', () => {
-        const dumpWithSpans = {
-            canvas: { left: 0, top: 0, right: 200, bottom: 400 },
-            nodes: [
-                {
-                    id: 'discountText',
-                    bounds: { left: 0, top: 0, right: 100, bottom: 20 },
-                    parentId: null,
-                    clipsChildren: false,
-                    text: 'Get 5 EUR off',
-                    textSpans: [{ start: 4, end: 9, text: '5 EUR', background: '#ffe45e' }],
-                },
-            ],
-        };
-        const appearanceReference = {
-            baseline: 'figma',
-            elementIds: ['discountText'],
-            spans: { discountText: { text: '5 EUR off', background: '#ffe45e' } },
-        };
-        expect(embedded.buildStructuralBlock(dumpWithSpans, null, 2, undefined, appearanceReference)).toEqual(buildStructuralBlock(dumpWithSpans, null, 2, undefined, appearanceReference));
-    });
-    test('embedded buildAppearanceReferenceFromParams matches the module for a spans declaration (issue 16)', () => {
-        const params = {
-            refSpans: { discountText: { text: '5 EUR off', background: '#ffe45e' } },
-            baseline: 'figma',
-        };
-        expect(embedded.buildAppearanceReferenceFromParams(params)).toEqual(buildAppearanceReferenceFromParams(params));
-    });
-    test('embedded buildAppearanceReferenceFromParams matches the module for a typeface declaration (typeface issue 04)', () => {
-        const cases = [
-            { refTypeface: { code: { family: 'Poppins', weight: 600 } }, baseline: 'figma' },
-            {
-                refGeom: { code: { w: 100, h: 20 } },
-                refTypeface: { code: { family: 'Poppins', weight: 600 }, label: { family: 'Fira Sans' } },
-                baseline: 'figma',
-            },
-            { refTypeface: {}, baseline: 'figma' },
-        ];
-        for (const params of cases) {
-            expect(embedded.buildAppearanceReferenceFromParams(params)).toEqual(buildAppearanceReferenceFromParams(params));
-        }
-    });
-    test('embedded deriveLineFacts matches the module (Signal C, issue 18)', () => {
-        const cases = [
-            [
-                { promoCopy: [{ start: 0, end: 13, text: 'Get 5 EUR off' }, { start: 14, end: 33, text: 'placed by tomorrow.' }] },
-                { promoCopy: ['Get 5 EUR off', 'placed by tomorrow.'] },
-            ],
-            [
-                { promoCopy: [{ start: 0, end: 33, text: 'Get 5 EUR off placed by tomorrow.' }] },
-                { promoCopy: ['Get 5 EUR off', 'placed by tomorrow.'] },
-            ],
-            [{}, { promoCopy: ['Get 5 EUR off', 'placed by tomorrow.'] }],
-            [{ promoCopy: [{ start: 0, end: 3, text: 'Get' }] }, { promoCopy: [] }],
-            [
-                { b: [{ start: 0, end: 1, text: 'x' }], a: [{ start: 0, end: 1, text: 'y' }] },
-                { a: ['right'], b: ['x'] },
-            ],
-        ];
-        for (const [rendered, reference] of cases) {
-            expect(embedded.deriveLineFacts(rendered, reference)).toEqual(deriveLineFacts(rendered, reference));
-        }
-    });
-    test('embedded buildStructuralBlock matches the module with an appearanceReference carrying lines (issue 18)', () => {
-        const dumpWithLines = {
-            canvas: { left: 0, top: 0, right: 200, bottom: 400 },
-            nodes: [
-                {
-                    id: 'promoCopy',
-                    bounds: { left: 0, top: 0, right: 100, bottom: 20 },
-                    parentId: null,
-                    clipsChildren: false,
-                    text: 'Get 5 EUR off placed by tomorrow.',
-                    textLines: [{ start: 0, end: 33, text: 'Get 5 EUR off placed by tomorrow.' }],
-                },
-            ],
-        };
-        const appearanceReference = {
-            baseline: 'figma',
-            elementIds: ['promoCopy'],
-            lines: { promoCopy: ['Get 5 EUR off', 'placed by tomorrow.'] },
-        };
-        expect(embedded.buildStructuralBlock(dumpWithLines, null, 2, undefined, appearanceReference)).toEqual(buildStructuralBlock(dumpWithLines, null, 2, undefined, appearanceReference));
-    });
-    test('embedded deriveTypefaceFacts matches the module (Signal C, issue 03)', () => {
-        const cases = [
-            [{ code: { family: 'Roboto', weight: 400 } }, { code: { family: 'Poppins', weight: 600 } }],
-            [{ code: { family: 'Poppins', weight: 600 } }, { code: { family: 'Poppins', weight: 600 } }],
-            [{ code: { family: 'Poppins', weight: 600 } }, { code: { family: 'Poppins-SemiBold' } }],
-            [{ code: { family: 'fira_sans_medium' } }, { code: { family: 'Fira Sans', weight: 500 } }],
-            [{ code: { family: 'Poppins', weight: 400 } }, { code: { family: 'Poppins-SemiBold' } }],
-            [{}, { code: { family: 'Poppins', weight: 600 } }],
-            [{ code: { family: 'Roboto', weight: 400 } }, {}],
-            [
-                { b: { family: 'Roboto', weight: 400 }, a: { family: 'Arial', weight: 400 } },
-                { a: { family: 'Poppins', weight: 600 }, b: { family: 'Roboto', weight: 400 } },
-            ],
-        ];
-        for (const [rendered, reference] of cases) {
-            expect(embedded.deriveTypefaceFacts(rendered, reference)).toEqual(deriveTypefaceFacts(rendered, reference));
-        }
-    });
-    test('embedded buildStructuralBlock matches the module with a typeface reference + the render-SDK gate (issue 03)', () => {
-        const dumps = [
-            {
-                canvas: { left: 0, top: 0, right: 200, bottom: 400 },
-                renderSdk: 34,
-                nodes: [
-                    { id: 'code', bounds: { left: 0, top: 0, right: 100, bottom: 20 }, parentId: null, clipsChildren: false, text: 'INV-50', resolvedTypeface: { family: 'Roboto', weight: 400 } },
-                ],
-            },
-            {
-                canvas: { left: 0, top: 0, right: 200, bottom: 400 },
-                renderSdk: 28,
-                nodes: [
-                    { id: 'code', bounds: { left: 0, top: 0, right: 100, bottom: 20 }, parentId: null, clipsChildren: false, text: 'INV-50' },
-                ],
-            },
-            {
-                canvas: { left: 0, top: 0, right: 200, bottom: 400 },
-                nodes: [
-                    { id: 'code', bounds: { left: 0, top: 0, right: 100, bottom: 20 }, parentId: null, clipsChildren: false },
-                ],
-            },
-        ];
-        const appearanceReference = {
-            baseline: 'figma',
-            elementIds: ['code'],
-            typeface: { code: { family: 'Poppins', weight: 600 } },
-        };
-        for (const dump of dumps) {
-            expect(embedded.buildStructuralBlock(dump, null, 2, undefined, appearanceReference)).toEqual(buildStructuralBlock(dump, null, 2, undefined, appearanceReference));
-        }
-    });
-    test('embedded deriveCopyFacts matches the module (Signal C)', () => {
-        const cases = [
-            [{ title: 'a' }, { title: 'a' }],
-            [{ title: 'a' }, { title: 'b' }],
-            [{}, { cta: 'Shop now' }],
-            [{ cta: '' }, { cta: 'Shop now' }],
-            [{ debugLabel: 'x' }, {}],
-            [{ note: 'hi' }, { note: '' }],
-            [{ b: 'r', a: 'wrong' }, { a: 'right', b: 'r', c: 'gone' }],
-        ];
-        for (const [rendered, reference] of cases) {
-            expect(embedded.deriveCopyFacts(rendered, reference)).toEqual(deriveCopyFacts(rendered, reference));
-        }
-    });
-    test('embedded buildStructuralBlock matches the module with an appearanceReference carrying text', () => {
-        const dumpWithText = {
-            canvas: { left: 0, top: 0, right: 200, bottom: 400 },
-            nodes: [
-                { id: 'title', bounds: { left: 0, top: 0, right: 100, bottom: 20 }, parentId: null, clipsChildren: false, text: '5 EUR' },
-                { id: 'cta', bounds: { left: 0, top: 30, right: 100, bottom: 50 }, parentId: null, clipsChildren: false },
-            ],
-        };
-        const appearanceReference = {
-            baseline: 'figma',
-            elementIds: ['title', 'cta'],
-            text: { title: '5 EUR off', cta: 'Shop now' },
-        };
-        expect(embedded.buildStructuralBlock(dumpWithText, null, 2, undefined, appearanceReference)).toEqual(buildStructuralBlock(dumpWithText, null, 2, undefined, appearanceReference));
-    });
-    test('embedded ciede2000 + hexToLab match the module (Signal C)', () => {
-        const labCases = [
-            [[50, 2.6772, -79.7751], [50, 0, -82.7485]],
-            [[50, 2.5, 0], [73, 25, -18]],
-            [[60.2574, -34.0099, 36.2677], [60.4626, -34.1751, 39.4387]],
-        ];
-        for (const [a, b] of labCases) {
-            expect(embedded.ciede2000(a, b)).toBeCloseTo(ciede2000(a, b), 12);
-        }
-        for (const hex of ['#ffffff', '#000000', '#ff0000', '#3a7bd5', 'abcdef']) {
-            expect(embedded.hexToLab(hex)).toEqual(hexToLab(hex));
-        }
-    });
-    test('embedded buildAppearanceReferenceFromParams matches the module (Signal C, issue 05)', () => {
-        const cases = [
-            { refColor: { banner: { fill: '#fff0ee' } }, baseline: 'previous_render' },
-            { refGeom: { banner: { w: 343, h: 96 }, voucher: { w: 81, h: 81 } }, baseline: 'figma' },
-            { refGeom: { banner: { w: 343 } }, refColor: { banner: { fill: '#fff0ee' } }, baseline: 'figma' },
-            { refText: { copy: 'Get 5 € off' }, refColor: { banner: { fill: '#fff0ee' } }, baseline: 'previous_render' },
-            { refGeom: { banner: { w: 1 } }, refText: { copy: 'x' }, refColor: { logo: { fill: '#000000' } }, baseline: 'figma' },
-            { baseline: 'figma' },
-            { refGeom: {}, refText: {}, refColor: {}, baseline: 'figma' },
-        ];
-        for (const c of cases) {
-            expect(embedded.buildAppearanceReferenceFromParams(c)).toEqual(buildAppearanceReferenceFromParams(c));
-        }
-    });
-    test('embedded deriveColorFacts matches the module (Signal C)', () => {
-        const cases = [
-            [{ card: { fill: '#ff0000' } }, { card: { fill: '#ff0000' } }],
-            [{ card: { fill: '#ff0000' } }, { card: { fill: '#00ff00' } }],
-            [{ card: { fill: '#ffffff', text: '#111111' } }, { card: { fill: '#ffffff', text: '#000000' } }],
-            [{ card: {} }, { card: { fill: '#ff0000' } }],
-            [{ extra: { fill: '#ff0000' } }, {}],
-        ];
-        for (const [rendered, reference] of cases) {
-            expect(embedded.deriveColorFacts(rendered, reference)).toEqual(deriveColorFacts(rendered, reference));
-        }
-    });
-    test('embedded buildStructuralBlock matches the module with an appearanceReference carrying color', () => {
-        const dumpWithColor = {
-            canvas: { left: 0, top: 0, right: 200, bottom: 400 },
-            nodes: [
-                { id: 'card', bounds: { left: 0, top: 0, right: 100, bottom: 40 }, parentId: null, clipsChildren: false, fillColor: '#ff0000', textColor: '#000000' },
-            ],
-        };
-        const appearanceReference = {
-            baseline: 'figma',
-            elementIds: ['card'],
-            color: { card: { fill: '#00ff00', text: '#000000' } },
-        };
-        expect(embedded.buildStructuralBlock(dumpWithColor, null, 2, undefined, appearanceReference)).toEqual(buildStructuralBlock(dumpWithColor, null, 2, undefined, appearanceReference));
-    });
-    test('embedded buildStructuralBlock matches the module for a text-only color drift (issue 02)', () => {
-        // Correct fill + wrong text: the embedded port must emit the same single
-        // text-channel fact (no collapse), matching the typed module exactly.
-        const dumpWithText = {
-            canvas: { left: 0, top: 0, right: 343, bottom: 72 },
-            nodes: [
-                { id: 'banner', bounds: { left: 0, top: 0, right: 343, bottom: 72 }, parentId: null, clipsChildren: false, fillColor: '#fff0ee', textColor: '#1e88e5' },
-            ],
-        };
-        const appearanceReference = {
-            baseline: 'previous_render',
-            elementIds: ['banner'],
-            color: { banner: { fill: '#fff0ee', text: '#1b1b1b' } },
-        };
-        expect(embedded.buildStructuralBlock(dumpWithText, null, 2, undefined, appearanceReference)).toEqual(buildStructuralBlock(dumpWithText, null, 2, undefined, appearanceReference));
-    });
-    // Duplicated banner tag + a child declared in the reference: exercises the
-    // collision guard end-to-end (duplicate_tag fact, geometry skip, overhang
-    // withheld against the duplicated frame, scaffold row).
-    const DUPLICATE_TAG_DUMP = {
-        canvas: { left: 0, top: 0, right: 720, bottom: 800 },
-        nodes: [
-            { id: 'banner', bounds: { left: 0, top: 0, right: 686, bottom: 144 }, parentId: null, clipsChildren: false },
-            { id: 'banner', bounds: { left: 0, top: 200, right: 686, bottom: 344 }, parentId: null, clipsChildren: false },
-            { id: 'coin', bounds: { left: 600, top: 80, right: 680, bottom: 180 }, parentId: 'banner', clipsChildren: false },
-        ],
-    };
-    const DUPLICATE_TAG_REF = {
-        banner: { x: 0, y: 0, w: 343, h: 72 },
-        coin: { x: 300, y: 40, w: 40, h: 50 },
-    };
-    // A text-driven pill inside the band (density 2: px are 2× the dp numbers)
-    // plus a non-text sibling outside it — exercises the text-aware size band.
-    const TEXT_BAND_DUMP = {
-        canvas: { left: 0, top: 0, right: 720, bottom: 400 },
-        nodes: [
-            { id: 'root', bounds: { left: 0, top: 0, right: 720, bottom: 400 }, parentId: null, clipsChildren: false },
-            { id: 'pill', bounds: { left: 32, top: 32, right: 160, bottom: 98 }, parentId: 'root', clipsChildren: false },
-            {
-                id: 'pill_label',
-                bounds: { left: 48, top: 48, right: 144, bottom: 82 },
-                parentId: 'pill',
-                clipsChildren: false,
-                text: 'Copy code',
-                textLines: [{ start: 0, end: 9, text: 'Copy code' }],
-            },
-            { id: 'thumbnail', bounds: { left: 200, top: 32, right: 406, bottom: 232 }, parentId: 'root', clipsChildren: false },
-        ],
-    };
-    const TEXT_BAND_REF = { pill: { w: 60, h: 36 }, thumbnail: { w: 100, h: 100 } };
-    const parityCases = [
-        { name: 'factsOnly', dump: HUB_PROMO_DUMP, ref: null },
-        { name: 'withGeometry', dump: HUB_PROMO_DUMP, ref: HUB_PROMO_REFERENCE },
-        { name: 'overhangLoggedIn', dump: OVERHANG_LOGGED_IN_DUMP, ref: OVERHANG_LOGGED_IN_REF },
-        { name: 'overhangGuest', dump: OVERHANG_GUEST_DUMP, ref: OVERHANG_GUEST_REF },
-        { name: 'overhangPosition', dump: OVERHANG_POSITION_DUMP, ref: OVERHANG_POSITION_REF },
-        { name: 'overhangMissing', dump: OVERHANG_MISSING_DUMP, ref: OVERHANG_MISSING_REF },
-        { name: 'duplicateTag', dump: DUPLICATE_TAG_DUMP, ref: DUPLICATE_TAG_REF },
-        { name: 'textSizeBand', dump: TEXT_BAND_DUMP, ref: TEXT_BAND_REF },
-    ];
-    for (const { name, dump, ref } of parityCases) {
-        test(`embedded buildStructuralBlock matches the module (${name})`, () => {
-            expect(embedded.buildStructuralBlock(dump, ref, 2)).toEqual(buildStructuralBlock(dump, ref, 2));
-        });
-        test(`embedded buildReviewScaffold matches the module (${name})`, () => {
-            const block = buildStructuralBlock(dump, ref, 2);
-            expect(embedded.buildReviewScaffold(block)).toEqual(buildReviewScaffold(block));
-        });
-    }
-    test('embedded buildStructuralBlock matches the module for a duplicated member tag under a declared frame', () => {
-        const dump = {
-            canvas: { left: 0, top: 0, right: 360, bottom: 640 },
-            nodes: [
-                { id: 'root', bounds: { left: 0, top: 0, right: 360, bottom: 640 }, parentId: null, clipsChildren: false },
-                { id: 'member', bounds: { left: 0, top: 0, right: 360, bottom: 100 }, parentId: 'root', clipsChildren: false },
-                { id: 'member', bounds: { left: 0, top: 200, right: 360, bottom: 300 }, parentId: 'root', clipsChildren: false },
-                { id: 'footer', bounds: { left: 0, top: 500, right: 360, bottom: 640 }, parentId: 'root', clipsChildren: false },
-            ],
-        };
-        const ref = { member: { x: 0, y: 0, w: 360, h: 100 }, footer: { x: 0, y: 540, w: 360, h: 140 } };
-        const frame = { w: 360, h: 640 };
-        expect(embedded.buildStructuralBlock(dump, ref, 1, undefined, undefined, frame)).toEqual(buildStructuralBlock(dump, ref, 1, undefined, undefined, frame));
-    });
-});
-// ─── Border facts (property-recognizer 01) ───────────────────────────────────
-// The runner half of the comparison that finally makes a missing ring visible.
-// These lock the TYPED copy; the ES5 runner twin is exercised through the
-// generated-script tests, and the two must not drift — patching one only is a
-// silent asymmetry between the local preview and the real gate.
-describe('deriveBorderFacts — the design stroke vs the rendered border', () => {
-    const REF = { badge: { fill: '#3ca000', stroke: '#ffffff', strokeWeight: 4 } };
-    test('THE motivating case: a declared ring the render never drew', () => {
-        expect(deriveBorderFacts({ badge: { fill: '#3ca000' } }, REF, true)).toEqual([
-            { kind: 'border_missing', elementId: 'badge', reference: '#ffffff', referenceWidth: 4 },
-        ]);
-    });
-    test('a border-blind dump states NOTHING — silence is "cannot see", not "absent"', () => {
-        // Without this gate every stroked design in the catalogue gains a finding on
-        // the strength of a blindness. The caller raises a not-checked advisory.
-        expect(deriveBorderFacts({ badge: { fill: '#3ca000' } }, REF, false)).toEqual([]);
-    });
-    test('a ring in the wrong colour is a border fact', () => {
-        expect(deriveBorderFacts({ badge: { stroke: '#cccccc', strokeWeight: 4 } }, REF, true)).toEqual([{ kind: 'border', elementId: 'badge', rendered: '#cccccc', reference: '#ffffff' }]);
-    });
-    test('a ring of the right colour and the wrong thickness is its own fact', () => {
-        expect(deriveBorderFacts({ badge: { stroke: '#ffffff', strokeWeight: 1 } }, REF, true)).toEqual([{ kind: 'border_width', elementId: 'badge', rendered: 1, reference: 4 }]);
-    });
-    test('hex case never matters, and a matching ring yields nothing', () => {
-        expect(deriveBorderFacts({ badge: { stroke: '#FFFFFF', strokeWeight: 4 } }, REF, true)).toEqual([]);
-    });
-    test('sub-half-dp width differences are the same ring', () => {
-        expect(deriveBorderFacts({ badge: { stroke: '#ffffff', strokeWeight: 4.4 } }, REF, true)).toEqual([]);
-    });
-    test('a design with no declared stroke says nothing about a rendered ring', () => {
-        // The design is the only side that can raise the question — the same
-        // asymmetry alpha uses. A wrapper adding an unasked-for ring is not a defect
-        // this comparison can name.
-        expect(deriveBorderFacts({ badge: { stroke: '#ffffff', strokeWeight: 4 } }, { badge: { fill: '#3ca000' } }, true)).toEqual([]);
-    });
-    test('an undeclared design WIDTH grades colour only, never thickness', () => {
-        expect(deriveBorderFacts({ badge: { stroke: '#ffffff', strokeWeight: 9 } }, { badge: { stroke: '#ffffff' } }, true)).toEqual([]);
-        // ...and a missing ring still states the colour, without inventing a width.
-        expect(deriveBorderFacts({}, { badge: { stroke: '#ffffff' } }, true)).toEqual([
-            { kind: 'border_missing', elementId: 'badge', reference: '#ffffff' },
-        ]);
-    });
-});
-describe('buildStructuralBlock — sub-dp rendered boxes', () => {
-    // The rendered box persists at 2-decimal precision instead of whole dp: the
-    // paint is sub-dp, and quantizing the box moved it up to half a dp off the
-    // pixels it describes — visibly mis-wrapped once evidence is magnified. The
-    // COMPARISON layer does not move: deltas were always computed from raw
-    // values and persisted integer-rounded, and the flag bands read raw deltas.
-    const FRACTIONAL_DUMP = {
-        canvas: { left: 0, top: 0, right: 1125, bottom: 2436 },
-        nodes: [
-            {
-                id: 'node-1',
-                bounds: { left: 0, top: 0, right: 1125, bottom: 2436 },
-                unclippedBounds: { left: 0, top: 0, right: 1125, bottom: 2436 },
-                parentId: null,
-                clipsChildren: false,
-            },
-            // ÷3 density: repeating decimals, so the 2-decimal clamp is load-bearing
-            // (133.666… must persist as 133.67, never 133.66666666666666).
-            {
-                id: 'dot',
-                bounds: { left: 401, top: 641, right: 426, bottom: 666 },
-                unclippedBounds: { left: 401, top: 641, right: 426, bottom: 666 },
-                parentId: 'node-1',
-                clipsChildren: false,
-            },
-            {
-                id: 'halo',
-                bounds: { left: 300, top: 500, right: 400, bottom: 600 },
-                unclippedBounds: { left: 300, top: 500, right: 400, bottom: 600 },
-                parentId: 'node-1',
-                clipsChildren: false,
-            },
-        ],
-    };
-    const FRACTIONAL_REFERENCE = { dot: { w: 8, h: 8 } };
-    test('persists the compared box at 2 decimals while deltas and flags stay whole-dp', () => {
-        const block = buildStructuralBlock(FRACTIONAL_DUMP, FRACTIONAL_REFERENCE, 3);
-        expect(block.geometry?.elements.find((e) => e.id === 'dot')).toEqual({
-            id: 'dot',
-            rendered: { w: 8.33, h: 8.33, x: 133.67, y: 213.67 },
-            design: { w: 8, h: 8 },
-            // The raw 0.33dp delta rounds to 0 — no delta emitted, no flag, exactly
-            // as the whole-dp era persisted it.
-            deltas: [],
-            sizeFlag: false,
-            ancestors: ['node-1'],
-        });
-        expect(block.summary.clean).toBe(true);
-    });
-    test('persists described-only (rendered-only) boxes at the same precision', () => {
-        const block = buildStructuralBlock(FRACTIONAL_DUMP, FRACTIONAL_REFERENCE, 3);
-        expect(block.geometry?.elements.find((e) => e.id === 'halo')).toEqual({
-            id: 'halo',
-            rendered: { w: 33.33, h: 33.33, x: 100, y: 166.67 },
-        });
-    });
-    test('embedded stage matches the module for sub-dp rendered boxes (parity)', () => {
-        const embedded = getGeometryStageInternals();
-        expect(embedded.buildStructuralBlock(FRACTIONAL_DUMP, FRACTIONAL_REFERENCE, 3)).toEqual(buildStructuralBlock(FRACTIONAL_DUMP, FRACTIONAL_REFERENCE, 3));
-    });
-});
-//# sourceMappingURL=structural-facts.test.js.map