@invarn/cibuild 2.0.4 → 2.0.6

package/dist/src/yaml/steps/ui-fidelity-render.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ui-fidelity-render.d.ts","sourceRoot":"","sources":["../../../../src/yaml/steps/ui-fidelity-render.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"ui-fidelity-render.d.ts","sourceRoot":"","sources":["../../../../src/yaml/steps/ui-fidelity-render.ts"],"names":[],"mappings":"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"}

package/dist/src/yaml/steps/ui-fidelity-render.js

@@ -986,6 +986,240 @@ function compileAssetCatalogs(packageDir, harnessDir) {
   }
 }
 `;
+/**
+ * Runtime support for trimming the rendered output (package_source variants).
+ *
+ * The render entry forces the view into a fixed device-sized frame, so a
+ * component smaller than the canvas renders with transparent margins. After a
+ * screen renders, crop the PNG in place to the bounding box of its
+ * non-transparent pixels, so the rendered artifact is the component itself,
+ * tight -- no canvas, no background ambiguity for the human comparing screens.
+ *
+ * The crop is done by a small CoreGraphics helper run in Swift's
+ * script-interpreter mode (so it needs no extra harness target and reuses the
+ * one `swift` the runner already has). Best-effort: a trim failure is logged
+ * (warn-and-continue) and the untrimmed render is kept -- a cosmetic post-step
+ * never fails an otherwise good render. This is prep, not scoring: it produces
+ * a tighter image for the human's judgment and computes nothing about
+ * fidelity.
+ */
+const RENDER_SCRIPT_TRIM_STAGE = String.raw `
+// ---- render trimming stage (package_source variants) ----
+
+// CoreGraphics helper, run via 'swift <Trim.swift> <in.png> <out.png>'
+// (script-interpreter mode). Crops a PNG to the bounding box of its
+// non-transparent pixels and writes it to the output path, which may equal the
+// input path (in-place trim).
+var TRIM_HELPER_SWIFT = [
+  'import Foundation',
+  'import ImageIO',
+  'import CoreGraphics',
+  'import UniformTypeIdentifiers',
+  '',
+  'func loadCGImage(_ path: String) -> CGImage? {',
+  '    guard let src = CGImageSourceCreateWithURL(URL(fileURLWithPath: path) as CFURL, nil),',
+  '          let img = CGImageSourceCreateImageAtIndex(src, 0, nil) else { return nil }',
+  '    return img',
+  '}',
+  '',
+  'func writePNG(_ image: CGImage, to path: String) -> Bool {',
+  '    guard let dest = CGImageDestinationCreateWithURL(URL(fileURLWithPath: path) as CFURL, UTType.png.identifier as CFString, 1, nil) else { return false }',
+  '    CGImageDestinationAddImage(dest, image, nil)',
+  '    return CGImageDestinationFinalize(dest)',
+  '}',
+  '',
+  '// Redraw an image at an exact pixel size (used to match the reference).',
+  'func resize(_ image: CGImage, toWidth w: Int, height h: Int) -> CGImage? {',
+  '    if w <= 0 || h <= 0 { return nil }',
+  '    let bytesPerRow = w * 4',
+  '    let space = CGColorSpaceCreateDeviceRGB()',
+  '    guard let ctx = CGContext(data: nil, width: w, height: h, bitsPerComponent: 8, bytesPerRow: bytesPerRow, space: space, bitmapInfo: CGImageAlphaInfo.premultipliedLast.rawValue) else { return nil }',
+  '    ctx.interpolationQuality = .high',
+  '    ctx.draw(image, in: CGRect(x: 0, y: 0, width: w, height: h))',
+  '    return ctx.makeImage()',
+  '}',
+  '',
+  '// Bounding box of content: pixels that are neither transparent nor part of a',
+  '// uniform solid background. The background is detected from the four corners',
+  '// (opaque and agreeing within a tight tolerance); when the corners disagree,',
+  '// only transparency is trimmed. Top-left image coordinates.',
+  'func contentBoundingBox(_ image: CGImage) -> CGRect? {',
+  '    let w = image.width, h = image.height',
+  '    if w == 0 || h == 0 { return nil }',
+  '    let bytesPerRow = w * 4',
+  '    var data = [UInt8](repeating: 0, count: bytesPerRow * h)',
+  '    let space = CGColorSpaceCreateDeviceRGB()',
+  '    guard let ctx = CGContext(data: &data, width: w, height: h, bitsPerComponent: 8, bytesPerRow: bytesPerRow, space: space, bitmapInfo: CGImageAlphaInfo.premultipliedLast.rawValue) else { return nil }',
+  '    ctx.draw(image, in: CGRect(x: 0, y: 0, width: w, height: h))',
+  '    // Tight tolerance: exact solid fills match, near-colored content does not.',
+  '    let tolerance = 4',
+  '    func sample(_ x: Int, _ y: Int) -> (Int, Int, Int, Int) {',
+  '        let i = y * bytesPerRow + x * 4',
+  '        return (Int(data[i]), Int(data[i + 1]), Int(data[i + 2]), Int(data[i + 3]))',
+  '    }',
+  '    // Detect a uniform opaque background shared by all four corners.',
+  '    let corners = [sample(0, 0), sample(w - 1, 0), sample(0, h - 1), sample(w - 1, h - 1)]',
+  '    var background: (Int, Int, Int, Int)? = corners[0]',
+  '    for c in corners {',
+  '        if let bg = background {',
+  '            if c.3 == 0 || abs(c.0 - bg.0) > tolerance || abs(c.1 - bg.1) > tolerance || abs(c.2 - bg.2) > tolerance || abs(c.3 - bg.3) > tolerance {',
+  '                background = nil',
+  '            }',
+  '        }',
+  '    }',
+  '    var minX = w, minY = h, maxX = -1, maxY = -1',
+  '    for y in 0..<h {',
+  '        let rowBase = y * bytesPerRow',
+  '        for x in 0..<w {',
+  '            let idx = rowBase + x * 4',
+  '            let a = Int(data[idx + 3])',
+  '            var isMargin = a == 0',
+  '            if !isMargin, let bg = background {',
+  '                let r = Int(data[idx]), g = Int(data[idx + 1]), b = Int(data[idx + 2])',
+  '                if abs(r - bg.0) <= tolerance && abs(g - bg.1) <= tolerance && abs(b - bg.2) <= tolerance && abs(a - bg.3) <= tolerance {',
+  '                    isMargin = true',
+  '                }',
+  '            }',
+  '            if !isMargin {',
+  '                if x < minX { minX = x }',
+  '                if x > maxX { maxX = x }',
+  '                if y < minY { minY = y }',
+  '                if y > maxY { maxY = y }',
+  '            }',
+  '        }',
+  '    }',
+  '    if maxX < 0 { return nil }',
+  '    return CGRect(x: minX, y: minY, width: maxX - minX + 1, height: maxY - minY + 1)',
+  '}',
+  '',
+  'let arguments = CommandLine.arguments',
+  'guard arguments.count >= 3 else {',
+  '    FileHandle.standardError.write(Data("usage: Trim <in.png> <out.png>".utf8))',
+  '    exit(64)',
+  '}',
+  'let inputPath = arguments[1]',
+  'let outputPath = arguments[2]',
+  'guard let image = loadCGImage(inputPath) else {',
+  '    FileHandle.standardError.write(Data(("could not read image at " + inputPath).utf8))',
+  '    exit(65)',
+  '}',
+  'guard let box = contentBoundingBox(image) else {',
+  '    FileHandle.standardError.write(Data("no content to trim (image is uniform)".utf8))',
+  '    exit(66)',
+  '}',
+  'guard let cropped = image.cropping(to: box) else {',
+  '    FileHandle.standardError.write(Data("could not crop image".utf8))',
+  '    exit(67)',
+  '}',
+  'let croppedWidth = cropped.width',
+  'let croppedHeight = cropped.height',
+  'guard writePNG(cropped, to: outputPath) else {',
+  '    FileHandle.standardError.write(Data(("could not write trimmed PNG to " + outputPath).utf8))',
+  '    exit(68)',
+  '}',
+  '',
+  '// Optional aligned output: the trimmed image resized to the reference pixel',
+  '// size, a 1:1 overlay pair. Best-effort; dimensions are reported either way.',
+  'var referenceWidth = 0',
+  'var referenceHeight = 0',
+  'if arguments.count >= 5 {',
+  '    let alignedPath = arguments[3]',
+  '    let referencePath = arguments[4]',
+  '    if let reference = loadCGImage(referencePath) {',
+  '        referenceWidth = reference.width',
+  '        referenceHeight = reference.height',
+  '        if let aligned = resize(cropped, toWidth: referenceWidth, height: referenceHeight) {',
+  '            _ = writePNG(aligned, to: alignedPath)',
+  '        }',
+  '    }',
+  '}',
+  '',
+  '// Report: rendered (trimmed) px, reference px (0 0 when unavailable), then',
+  '// the pre-trim source px so the caller can log how much margin was removed.',
+  'print("TRIMDIMS " + String(croppedWidth) + " " + String(croppedHeight) + " " + String(referenceWidth) + " " + String(referenceHeight) + " " + String(image.width) + " " + String(image.height))'
+].join('\n') + '\n';
+
+// Write the helper into the harness dir once (idempotent across screens).
+function ensureTrimHelper(harnessDir) {
+  var helperPath = path.join(harnessDir, 'Trim.swift');
+  if (!fs.existsSync(helperPath)) {
+    fs.writeFileSync(helperPath, TRIM_HELPER_SWIFT);
+  }
+  return helperPath;
+}
+
+// Round to two decimals, keeping the value a plain number.
+function roundTwo(value) {
+  return Math.round(value * 100) / 100;
+}
+
+// Parse the helper's "TRIMDIMS <rW> <rH> <refW> <refH> <srcW> <srcH>" line
+// (rendered/reference/source px; last one wins).
+function parseTrimDims(stdout) {
+  var lines = String(stdout || '').split('\n');
+  for (var i = lines.length - 1; i >= 0; i--) {
+    var parts = lines[i].trim().split(/\s+/);
+    if (parts[0] === 'TRIMDIMS' && parts.length >= 7) {
+      var nums = [
+        Number(parts[1]), Number(parts[2]), Number(parts[3]),
+        Number(parts[4]), Number(parts[5]), Number(parts[6]),
+      ];
+      if (nums.every(function (n) { return Number.isFinite(n); })) {
+        return {
+          rendered: [nums[0], nums[1]],
+          reference: [nums[2], nums[3]],
+          source: [nums[4], nums[5]],
+        };
+      }
+    }
+  }
+  return null;
+}
+
+// Crop the rendered PNG in place to its content bounding box, write an aligned
+// copy resized to the reference, and record the dimensions on the entry.
+// Best-effort: a failure is logged and the untrimmed render is kept.
+function trimRenderedImage(entry, renderedPath, harnessDir) {
+  var helperPath = ensureTrimHelper(harnessDir);
+  var alignedRelative = 'ui-fidelity/aligned/' + entry.screen + '.png';
+  var alignedPath = path.resolve(artifactsDir, alignedRelative);
+  var referencePath =
+    entry.reference_image_path === null
+      ? ''
+      : path.resolve(artifactsDir, entry.reference_image_path);
+  try {
+    fs.mkdirSync(path.dirname(alignedPath), { recursive: true });
+  } catch (mkdirError) {
+    // best effort -- the helper reports a missing output dir itself
+  }
+  var result = runSwift([helperPath, renderedPath, renderedPath, alignedPath, referencePath]);
+  if (result.status !== 0) {
+    logError(
+      'trim failed for ' + renderedPath +
+        ' (continuing with the untrimmed render): ' + sanitizeMessage(outputTail(result))
+    );
+    return;
+  }
+  var dims = parseTrimDims(result.stdout);
+  if (dims !== null) {
+    var scale = CONFIG.scale;
+    entry.dimensions = {
+      rendered_px: dims.rendered,
+      logical_pt: [roundTwo(dims.rendered[0] / scale), roundTwo(dims.rendered[1] / scale)],
+      reference_px: dims.reference[0] > 0 && dims.reference[1] > 0 ? dims.reference : null,
+    };
+    // Surface how much margin was removed -- a no-op (source == rendered) means
+    // the view fills an opaque canvas with no transparent or uniform margin.
+    log(
+      'trimmed ' + entry.screen + ': ' + dims.source[0] + 'x' + dims.source[1] +
+        ' -> ' + dims.rendered[0] + 'x' + dims.rendered[1]
+    );
+  }
+  if (fs.existsSync(alignedPath)) {
+    entry.aligned_image_path = alignedRelative;
+  }
+}
+`;
 /**
  * Replaces exactly one occurrence of `anchor` in `source`. Throws when the
  * anchor is missing or ambiguous, so any drift between the v1 runtime text
@@ -1093,6 +1327,21 @@ function buildPackageSourceMain() {
     main = replaceOnce(main, 'function renderWithHarness(renderable, packagePath) {', RENDER_SCRIPT_ASSET_CATALOG_STAGE + '\nfunction renderWithHarness(renderable, packagePath) {');
     main = replaceOnce(main, '    renderable.forEach(function (entry) {', '    compileAssetCatalogs(packagePath, harnessDir);\n\n' +
         '    renderable.forEach(function (entry) {');
+    // Render-trimming stage: define the helpers ahead of renderWithHarness, then
+    // crop each rendered PNG to its content bounding box right after it renders.
+    main = replaceOnce(main, 'function renderWithHarness(renderable, packagePath) {', RENDER_SCRIPT_TRIM_STAGE + '\nfunction renderWithHarness(renderable, packagePath) {');
+    main = replaceOnce(main, "      log('rendered ' + entry.screen + ' -> ' + relative);", "      log('rendered ' + entry.screen + ' -> ' + relative);\n" +
+        '      trimRenderedImage(entry, outputPath, harnessDir);');
+    // Per-screen result entries gain the trimmed-render fields: the aligned
+    // (reference-sized) image and the rendered/logical/reference dimensions.
+    // They stay null until a screen renders and is trimmed.
+    main = replaceOnce(main, '      reference_image_path: null,\n' +
+        '      rendered_image_path: null,\n' +
+        '    };', '      reference_image_path: null,\n' +
+        '      rendered_image_path: null,\n' +
+        '      aligned_image_path: null,\n' +
+        '      dimensions: null,\n' +
+        '    };');
     return main;
 }
 const RENDER_SCRIPT_MAIN_WITH_PACKAGE_SOURCE = buildPackageSourceMain();

package/dist/src/yaml/steps/ui-fidelity-render.test.js

@@ -111,6 +111,23 @@ const FAKE_SWIFT_LINES = [
     "    printf '\\x89PNG\\r\\n\\x1a\\n' > \"$out\"",
     '    printf \'fake-render:%s\' "$screen" >> "$out"',
     '    exit 0 ;;',
+    '  *.swift)',
+    // Script-interpreter mode (swift <Trim.swift> <in> <out> <aligned> <ref>):
+    // stands in for the CoreGraphics trim helper. Overwrites <out> with a PNG
+    // marked "trimmed:<in basename>" and writes an "aligned:<in basename>" PNG so
+    // tests can prove both outputs. Emits a fixed TRIMDIMS line (rendered
+    // 320x640, reference 160x320, source 400x800). FAKE_TRIM_FAIL exercises
+    // warn-and-continue.
+    '    if [ -n "$FAKE_TRIM_FAIL" ]; then echo "trim: simulated failure" >&2; exit 1; fi',
+    '    in_png="$1"; out_png="$2"; aligned_png="$3"',
+    "    printf '\\x89PNG\\r\\n\\x1a\\n' > \"$out_png\"",
+    '    printf \'trimmed:%s\' "$(basename "$in_png")" >> "$out_png"',
+    '    if [ -n "$aligned_png" ]; then',
+    "      printf '\\x89PNG\\r\\n\\x1a\\n' > \"$aligned_png\"",
+    '      printf \'aligned:%s\' "$(basename "$in_png")" >> "$aligned_png"',
+    '    fi',
+    '    echo "TRIMDIMS 320 640 160 320 400 800"',
+    '    exit 0 ;;',
     '  *)',
     '    exit 0 ;;',
     'esac',
@@ -896,6 +913,12 @@ describe('render script runtime (package_source: repo)', () => {
                     error: null,
                     reference_image_path: 'ui-fidelity/references/HomeView.png',
                     rendered_image_path: 'ui-fidelity/rendered/HomeView.png',
+                    aligned_image_path: 'ui-fidelity/aligned/HomeView.png',
+                    dimensions: {
+                        rendered_px: [320, 640],
+                        logical_pt: [160, 320],
+                        reference_px: [160, 320],
+                    },
                 },
             ],
         });
@@ -965,6 +988,82 @@ describe('render script runtime (package_source: repo)', () => {
         expect(run.stderr).toContain('asset-catalog compile failed');
     });
 });
+describe('render output trimming (package_source variants)', () => {
+    // The renderer forces the view into a fixed device-sized frame, so a small
+    // component lands in a large canvas with transparent margins. After each
+    // screen renders, the trim helper crops the PNG in place to its content
+    // bounding box so the rendered artifact IS the component, tight.
+    function readArtifact(project, relative) {
+        return readFileSync(artifact(project, relative), 'utf-8');
+    }
+    test('trims the rendered PNG in place via the Swift helper', async () => {
+        const project = makeProject({ screens: { HomeView: 'home.png' } });
+        writeReference(project, 'home.png');
+        const script = await buildScript(project, { package_source: 'repo' });
+        const logPath = join(project.dir, 'swift-invocations.log');
+        const run = runScript(project, script, { FAKE_SWIFT_LOG: logPath });
+        expect(run.status).toBe(0);
+        // The helper is invoked in script mode with the rendered PNG as in and out
+        // (in-place overwrite), after the render run.
+        const invocations = readFileSync(logPath, 'utf-8').trim().split('\n');
+        const trimCall = invocations.find((c) => c.includes('Trim.swift'));
+        expect(trimCall).toBeTruthy();
+        expect(trimCall).toContain('ui-fidelity/rendered/HomeView.png');
+        // The rendered file now holds the trim helper's output, not the raw render.
+        expect(isPng(artifact(project, 'ui-fidelity/rendered/HomeView.png'))).toBe(true);
+        expect(readArtifact(project, 'ui-fidelity/rendered/HomeView.png')).toContain('trimmed:HomeView.png');
+    });
+    test('writes an aligned image and records rendered/logical/reference dimensions', async () => {
+        const project = makeProject({ screens: { HomeView: 'home.png' } });
+        writeReference(project, 'home.png');
+        const run = runScript(project, await buildScript(project, { package_source: 'repo' }));
+        expect(run.status).toBe(0);
+        // The aligned (reference-sized) image is a separate artifact.
+        expect(isPng(artifact(project, 'ui-fidelity/aligned/HomeView.png'))).toBe(true);
+        expect(readArtifact(project, 'ui-fidelity/aligned/HomeView.png')).toContain('aligned:HomeView.png');
+        // Dimensions are explicit: rendered px from the helper, logical points
+        // derived from the scale (320/2, 640/2), reference px from the helper.
+        const screen = readResult(project).screens[0];
+        expect(screen.aligned_image_path).toBe('ui-fidelity/aligned/HomeView.png');
+        expect(screen.dimensions).toEqual({
+            rendered_px: [320, 640],
+            logical_pt: [160, 320],
+            reference_px: [160, 320],
+        });
+    });
+    test('logs how much margin the trim removed (source -> rendered)', async () => {
+        const project = makeProject({ screens: { HomeView: 'home.png' } });
+        writeReference(project, 'home.png');
+        const run = runScript(project, await buildScript(project, { package_source: 'repo' }));
+        expect(run.status).toBe(0);
+        // The pre-trim source size and the trimmed size are both surfaced, so a
+        // no-op trim (an opaque-canvas wrapper) is visible in the build log.
+        expect(run.stdout).toContain('trimmed HomeView: 400x800 -> 320x640');
+    });
+    test('a failing trim warns but still renders (warn-and-continue)', async () => {
+        const project = makeProject({ screens: { HomeView: 'home.png' } });
+        writeReference(project, 'home.png');
+        const script = await buildScript(project, { package_source: 'repo' });
+        const run = runScript(project, script, { FAKE_TRIM_FAIL: '1' });
+        // A trim failure never fails the step: the untrimmed render survives, with
+        // no aligned image and no dimensions.
+        expect(run.status).toBe(0);
+        expect(isPng(artifact(project, 'ui-fidelity/rendered/HomeView.png'))).toBe(true);
+        const screen = readResult(project).screens[0];
+        expect(screen.status).toBe('rendered');
+        expect(screen.aligned_image_path).toBeNull();
+        expect(screen.dimensions).toBeNull();
+        expect(run.stderr).toContain('trim failed');
+    });
+    test('trims renders shipped via package_source: inputs too', async () => {
+        const project = makeProject({ screens: { HomeView: 'home.png' } });
+        writeReference(project, 'home.png');
+        stageArchive(project, shippedPackageEntries('pkg'));
+        const run = runScript(project, await buildInputsScript({ target: 'FixtureViews' }));
+        expect(run.status).toBe(0);
+        expect(readArtifact(project, 'ui-fidelity/rendered/HomeView.png')).toContain('trimmed:HomeView.png');
+    });
+});
 describe('render script runtime (package_source: inputs)', () => {
     test('renders every screen from a shipped archive with a single package root', async () => {
         const project = makeProject({
@@ -993,6 +1092,12 @@ describe('render script runtime (package_source: inputs)', () => {
                     error: null,
                     reference_image_path: 'ui-fidelity/references/HomeView.png',
                     rendered_image_path: 'ui-fidelity/rendered/HomeView.png',
+                    aligned_image_path: 'ui-fidelity/aligned/HomeView.png',
+                    dimensions: {
+                        rendered_px: [320, 640],
+                        logical_pt: [160, 320],
+                        reference_px: [160, 320],
+                    },
                 },
                 {
                     screen: 'SettingsView',
@@ -1000,6 +1105,12 @@ describe('render script runtime (package_source: inputs)', () => {
                     error: null,
                     reference_image_path: 'ui-fidelity/references/SettingsView.png',
                     rendered_image_path: 'ui-fidelity/rendered/SettingsView.png',
+                    aligned_image_path: 'ui-fidelity/aligned/SettingsView.png',
+                    dimensions: {
+                        rendered_px: [320, 640],
+                        logical_pt: [160, 320],
+                        reference_px: [160, 320],
+                    },
                 },
             ],
         });

package/package.json

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