@invarn/cibuild 2.0.5 → 2.0.7

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

@@ -157,6 +157,34 @@ export interface RenderScriptInternals {
     generateProbeSwift(options: HarnessGeneratorOptions): string;
     generateScreenSwift(screen: string, options: HarnessGeneratorOptions): string;
 }
+/**
+ * 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.
+ */
+/**
+ * The CoreGraphics trim/align helper source, run via
+ * `swift <Trim.swift> <in> <out> <aligned> <ref>` (script-interpreter mode).
+ * Crops a PNG to its content bounding box (transparent or uniform-background
+ * margins), writes a reference-sized aligned copy, and prints a TRIMDIMS line.
+ *
+ * Exported so a real-toolchain test can exercise the pixel logic directly --
+ * the fake `swift` in the unit tests cannot, which is why a background-detection
+ * bug shipped twice undetected before a real-pixel guard existed.
+ */
+export declare const TRIM_HELPER_SWIFT_SOURCE: string;
 /**
  * Evaluates the embedded generator source and returns the real functions, so
  * unit tests exercise exactly the code that ships inside the runtime script.

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

@@ -1003,113 +1003,167 @@ function compileAssetCatalogs(packageDir, harnessDir) {
  * 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 pixels with non-zero alpha, in top-left image coordinates.',
-  'func alphaBoundingBox(_ 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))',
-  '    var minX = w, minY = h, maxX = -1, maxY = -1',
-  '    for y in 0..<h {',
-  '        let rowBase = y * bytesPerRow',
-  '        for x in 0..<w {',
-  '            if data[rowBase + x * 4 + 3] > 0 {',
-  '                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 = alphaBoundingBox(image) else {',
-  '    FileHandle.standardError.write(Data("image is fully transparent; nothing to trim".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 then reference px (0 0 when unavailable).',
-  'print("TRIMDIMS " + String(croppedWidth) + " " + String(croppedHeight) + " " + String(referenceWidth) + " " + String(referenceHeight))'
+/**
+ * The CoreGraphics trim/align helper source, run via
+ * `swift <Trim.swift> <in> <out> <aligned> <ref>` (script-interpreter mode).
+ * Crops a PNG to its content bounding box (transparent or uniform-background
+ * margins), writes a reference-sized aligned copy, and prints a TRIMDIMS line.
+ *
+ * Exported so a real-toolchain test can exercise the pixel logic directly --
+ * the fake `swift` in the unit tests cannot, which is why a background-detection
+ * bug shipped twice undetected before a real-pixel guard existed.
+ */
+export const TRIM_HELPER_SWIFT_SOURCE = [
+    '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. Two passes, because the renderer forces the view',
+    '// into a fixed device frame whose margins are transparent: (1) bound the',
+    '// non-transparent pixels, then (2) detect a uniform opaque background from the',
+    '// CORNERS OF THAT OPAQUE BOX -- not the raw frame, whose corners are the',
+    '// transparent device margin -- and bound everything that is not that',
+    '// background. A wrapper that fills the canvas with .background(.white) is thus',
+    '// trimmed to its real content. When the opaque 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]))',
+    '    }',
+    '    // Pass 1: bounding box of all non-transparent pixels.',
+    '    var aMinX = w, aMinY = h, aMaxX = -1, aMaxY = -1',
+    '    for y in 0..<h {',
+    '        let rowBase = y * bytesPerRow',
+    '        for x in 0..<w {',
+    '            if data[rowBase + x * 4 + 3] > 0 {',
+    '                if x < aMinX { aMinX = x }',
+    '                if x > aMaxX { aMaxX = x }',
+    '                if y < aMinY { aMinY = y }',
+    '                if y > aMaxY { aMaxY = y }',
+    '            }',
+    '        }',
+    '    }',
+    '    if aMaxX < 0 { return nil }',
+    '    let opaqueBox = CGRect(x: aMinX, y: aMinY, width: aMaxX - aMinX + 1, height: aMaxY - aMinY + 1)',
+    '    // Detect a uniform opaque background from the corners of the opaque box.',
+    '    let corners = [sample(aMinX, aMinY), sample(aMaxX, aMinY), sample(aMinX, aMaxY), sample(aMaxX, aMaxY)]',
+    '    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',
+    '            }',
+    '        }',
+    '    }',
+    '    // No uniform background: the opaque box is the content.',
+    '    guard let bg = background else { return opaqueBox }',
+    '    // Pass 2: within the opaque box, bound everything that is not the background.',
+    '    var minX = aMaxX + 1, minY = aMaxY + 1, maxX = aMinX - 1, maxY = aMinY - 1',
+    '    for y in aMinY...aMaxY {',
+    '        let rowBase = y * bytesPerRow',
+    '        for x in aMinX...aMaxX {',
+    '            let idx = rowBase + x * 4',
+    '            let a = Int(data[idx + 3])',
+    '            if a == 0 { continue }',
+    '            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 { continue }',
+    '            if x < minX { minX = x }',
+    '            if x > maxX { maxX = x }',
+    '            if y < minY { minY = y }',
+    '            if y > maxY { maxY = y }',
+    '        }',
+    '    }',
+    '    // All background, no distinct content: keep the opaque box, never crop to nothing.',
+    '    if maxX < minX { return opaqueBox }',
+    '    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';
-
+const RENDER_SCRIPT_TRIM_STAGE = '\n// ---- render trimming stage (package_source variants) ----\n' +
+    'var TRIM_HELPER_SWIFT = ' +
+    JSON.stringify(TRIM_HELPER_SWIFT_SOURCE) +
+    ';\n' +
+    String.raw `
 // Write the helper into the harness dir once (idempotent across screens).
 function ensureTrimHelper(harnessDir) {
   var helperPath = path.join(harnessDir, 'Trim.swift');
@@ -1124,15 +1178,23 @@ function roundTwo(value) {
   return Math.round(value * 100) / 100;
 }
 
-// Parse the helper's "TRIMDIMS <rW> <rH> <refW> <refH>" line (last one wins).
+// 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 >= 5) {
-      var nums = [Number(parts[1]), Number(parts[2]), Number(parts[3]), Number(parts[4])];
+    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]] };
+        return {
+          rendered: [nums[0], nums[1]],
+          reference: [nums[2], nums[3]],
+          source: [nums[4], nums[5]],
+        };
       }
     }
   }
@@ -1171,6 +1233,12 @@ function trimRenderedImage(entry, renderedPath, harnessDir) {
       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;

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

@@ -21,7 +21,7 @@ import { chmodSync, existsSync, mkdirSync, mkdtempSync, readdirSync, readFileSyn
 import { tmpdir } from 'node:os';
 import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { DEFAULT_RENDER_SIZE, DEFAULT_SCALE, UiFidelityRenderStepExecutor, generateRenderScript, getRenderScriptInternals, parseRenderSize, parseScale, } from './ui-fidelity-render.js';
+import { DEFAULT_RENDER_SIZE, DEFAULT_SCALE, UiFidelityRenderStepExecutor, generateRenderScript, getRenderScriptInternals, parseRenderSize, parseScale, TRIM_HELPER_SWIFT_SOURCE, } from './ui-fidelity-render.js';
 import { clearRegistry, getStepMetadata, hasStep } from './registry.js';
 import { initializeStepRegistry } from './index.js';
 import { testConfig } from './test-config.js';
@@ -116,7 +116,8 @@ const FAKE_SWIFT_LINES = [
     // 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). FAKE_TRIM_FAIL exercises warn-and-continue.
+    // 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\"",
@@ -125,7 +126,7 @@ const FAKE_SWIFT_LINES = [
     "      printf '\\x89PNG\\r\\n\\x1a\\n' > \"$aligned_png\"",
     '      printf \'aligned:%s\' "$(basename "$in_png")" >> "$aligned_png"',
     '    fi',
-    '    echo "TRIMDIMS 320 640 160 320"',
+    '    echo "TRIMDIMS 320 640 160 320 400 800"',
     '    exit 0 ;;',
     '  *)',
     '    exit 0 ;;',
@@ -1030,6 +1031,15 @@ describe('render output trimming (package_source variants)', () => {
             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');
@@ -1499,4 +1509,60 @@ describe('committed fixture package', () => {
         expectNoAbsolutePathLeaks(project, result);
     }, 600_000);
 });
+// The fake `swift` cannot exercise the trim helper's CoreGraphics pixel logic,
+// so the bounding-box behavior is guarded here with the real toolchain. This
+// is the regression test for the bug where a wrapper that fills the canvas with
+// an opaque .background(...) was not trimmed to its content: the renderer forces
+// the view into a fixed device frame whose margins are transparent, so the
+// helper must detect the solid background from the corners of the opaque region,
+// not the raw frame.
+describe('trim helper pixel logic (real toolchain)', () => {
+    const realSwiftTest = process.env.CIBUILD_UI_FIDELITY_REAL_SWIFT === '1' ? test : test.skip;
+    // PNG IHDR carries width/height as big-endian uint32 at byte offsets 16/20.
+    function pngSize(filePath) {
+        const buf = readFileSync(filePath);
+        return { width: buf.readUInt32BE(16), height: buf.readUInt32BE(20) };
+    }
+    // Swift program that writes a fixture mimicking a real render: a transparent
+    // device frame, an opaque white wrapper inset within it, and a distinct-color
+    // "content" rectangle inside the white. Crop should land on the content.
+    const MAKE_FIXTURE_SWIFT = [
+        'import Foundation',
+        'import ImageIO',
+        'import CoreGraphics',
+        'import UniformTypeIdentifiers',
+        'let w = 420, h = 320, cs = CGColorSpaceCreateDeviceRGB()',
+        'let c = CGContext(data: nil, width: w, height: h, bitsPerComponent: 8, bytesPerRow: 0, space: cs, bitmapInfo: CGImageAlphaInfo.premultipliedLast.rawValue)!',
+        'c.clear(CGRect(x: 0, y: 0, width: w, height: h))',
+        'c.setFillColor(red: 1, green: 1, blue: 1, alpha: 1)',
+        'c.fill(CGRect(x: 20, y: 40, width: 375, height: 200))',
+        'c.setFillColor(red: 1, green: 240.0/255, blue: 238.0/255, alpha: 1)',
+        'c.fill(CGRect(x: 36, y: 56, width: 343, height: 168))',
+        'let out = CommandLine.arguments[1]',
+        'let d = CGImageDestinationCreateWithURL(URL(fileURLWithPath: out) as CFURL, UTType.png.identifier as CFString, 1, nil)!',
+        'CGImageDestinationAddImage(d, c.makeImage()!, nil)',
+        '_ = CGImageDestinationFinalize(d)',
+    ].join('\n') + '\n';
+    realSwiftTest('crops an opaque-background wrapper inside a transparent frame to its content', () => {
+        const dir = mkdtempSync(join(tmpdir(), 'ui-fidelity-trim-real-'));
+        tempDirs.push(dir);
+        const makePath = join(dir, 'Make.swift');
+        const trimPath = join(dir, 'Trim.swift');
+        const inputPath = join(dir, 'input.png');
+        const outputPath = join(dir, 'out.png');
+        writeFileSync(makePath, MAKE_FIXTURE_SWIFT);
+        writeFileSync(trimPath, TRIM_HELPER_SWIFT_SOURCE);
+        const make = spawnSync('swift', [makePath, inputPath], { encoding: 'utf-8' });
+        expect(make.status).toBe(0);
+        // 420x320 transparent canvas, 375x200 white wrapper, 343x168 pink card.
+        expect(pngSize(inputPath)).toEqual({ width: 420, height: 320 });
+        const trim = spawnSync('swift', [trimPath, inputPath, outputPath], {
+            encoding: 'utf-8',
+        });
+        expect(trim.status).toBe(0);
+        // The crop lands on the content card, NOT the white wrapper (375x200) and
+        // NOT the raw canvas (420x320).
+        expect(pngSize(outputPath)).toEqual({ width: 343, height: 168 });
+    }, 600_000);
+});
 //# sourceMappingURL=ui-fidelity-render.test.js.map

package/package.json

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