@invarn/cibuild 2.0.6 → 2.0.8

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

@@ -1003,142 +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 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))'
+/**
+ * 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');

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';
@@ -1509,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.6",
+  "version": "2.0.8",
   "description": "CI Build CLI — local pipeline orchestration and validation",
   "type": "module",
   "main": "dist/cli.cjs",