@invarn/cibuild 2.0.8 → 2.1.0

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

@@ -49,6 +49,7 @@
  *     document is { renderer, package_source, error, screens }.
  */
 import { BaseStepExecutor } from './base.js';
+import { RENDER_SCRIPT_TRIM_STAGE } from './render-post-processor.js';
 /**
  * Default render size in device points. 393x852 is the iPhone-class portrait
  * canvas shared by the iPhone 14 Pro / 15 / 16 — the most common modern
@@ -986,265 +987,6 @@ 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.
- */
-/**
- * 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');
-  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

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, TRIM_HELPER_SWIFT_SOURCE, } from './ui-fidelity-render.js';
+import { DEFAULT_RENDER_SIZE, DEFAULT_SCALE, UiFidelityRenderStepExecutor, generateRenderScript, getRenderScriptInternals, parseRenderSize, parseScale, } from './ui-fidelity-render.js';
 import { clearRegistry, getStepMetadata, hasStep } from './registry.js';
 import { initializeStepRegistry } from './index.js';
 import { testConfig } from './test-config.js';
@@ -1509,60 +1509,4 @@ 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.8",
+  "version": "2.1.0",
   "description": "CI Build CLI — local pipeline orchestration and validation",
   "type": "module",
   "main": "dist/cli.cjs",