@invarn/cibuild 2.5.2 → 2.5.4

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

@@ -8,7 +8,7 @@
  * 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, ciede2000, hexToLab, diffKeyGeometry, buildStructuralBlock, buildReviewScaffold, appearanceReferenceFromPreviousRender, buildAppearanceReferenceFromParams, getStructuralFactsStageInternals, getGeometryStageInternals, } from './structural-facts.js';
+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', () => {
@@ -419,7 +419,9 @@ describe('buildStructuralBlock — facts only (no reference geometry)', () => {
             elements: [
                 { id: 'banner', rendered: { w: 360, h: 96, x: 0, y: 0 } },
                 { id: 'voucher', rendered: { w: 96, h: 96, x: 248, y: 0 } },
-                { id: 'copy', rendered: { w: 296, h: 47, x: 32, y: 12 } },
+                // 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 } },
             ],
         });
     });
@@ -532,7 +534,8 @@ describe('buildStructuralBlock — with reference geometry (Signal B)', () => {
         // 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');
-        expect(copy).toEqual({ id: 'copy', rendered: { w: 296, h: 47, x: 32, y: 12 } });
+        // 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 });
     });
@@ -1029,6 +1032,69 @@ describe('deriveLineFacts — declared line split vs rendered laid-out lines', (
         ]);
     });
 });
+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 } });
@@ -2909,4 +2975,65 @@ describe('deriveBorderFacts — the design stroke vs the rendered border', () =>
         ]);
     });
 });
+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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@invarn/cibuild",
-  "version": "2.5.2",
+  "version": "2.5.4",
   "description": "CI Build CLI — local pipeline orchestration and validation",
   "type": "module",
   "main": "dist/cli.cjs",