@invarn/cibuild 2.0.7 → 2.0.9

package/dist/src/lib.d.ts

@@ -19,6 +19,10 @@ export { loadYAMLPipeline, getWorkflowNames, hasWorkflow, YAMLParseError, YAMLVa
 export { convertYAMLToPipelineDef, getAvailableWorkflows, YAMLConversionError, } from './yaml/converter.js';
 export type { ConversionResult } from './yaml/converter.js';
 export { pipeline } from './pipeline.js';
+export { renderUiFidelityPreview } from './yaml/steps/ui-fidelity-preview.js';
+export type { UiFidelityPreviewOptions, UiFidelityPreviewScreen, UiFidelityPreviewResult, UiFidelityPreviewScreenResult, UiFidelityPreviewDimensions, } from './yaml/steps/ui-fidelity-preview.js';
+export { renderUiFidelityPreviewAndroid, ANDROID_TOOLCHAIN_MISSING, } from './yaml/steps/ui-fidelity-preview-android.js';
+export type { UiFidelityPreviewAndroidOptions } from './yaml/steps/ui-fidelity-preview-android.js';
 export { getStepExecutor, hasStep, getAvailableSteps, registerStep, getStepMetadata, } from './yaml/steps/registry.js';
 export type { StepDef, PipelineDef, CIConfig, PipelineFactory, PipelineContext, StepBuilders, } from './types.js';
 export type { StepExecutor, StepMetadata, StepPlatform, StepExecutionContext, } from './yaml/steps/base.js';

package/dist/src/lib.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lib.d.ts","sourceRoot":"","sources":["../../src/lib.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAIH,OAAO,uBAAuB,CAAC;AAI/B,OAAO,EAAE,cAAc,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAIjE,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAIzC,OAAO,EACL,gBAAgB,EAChB,gBAAgB,EAChB,WAAW,EACX,cAAc,EACd,mBAAmB,GACpB,MAAM,kBAAkB,CAAC;AAI1B,OAAO,EACL,wBAAwB,EACxB,qBAAqB,EACrB,mBAAmB,GACpB,MAAM,qBAAqB,CAAC;AAC7B,YAAY,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAI5D,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAIzC,OAAO,EACL,eAAe,EACf,OAAO,EACP,iBAAiB,EACjB,YAAY,EACZ,eAAe,GAChB,MAAM,0BAA0B,CAAC;AAIlC,YAAY,EACV,OAAO,EACP,WAAW,EACX,QAAQ,EACR,eAAe,EACf,eAAe,EACf,YAAY,GACb,MAAM,YAAY,CAAC;AAIpB,YAAY,EACV,YAAY,EACZ,YAAY,EACZ,YAAY,EACZ,oBAAoB,GACrB,MAAM,sBAAsB,CAAC;AAI9B,YAAY,EACV,YAAY,EACZ,YAAY,EACZ,QAAQ,EACR,cAAc,EACd,UAAU,EACV,OAAO,EACP,QAAQ,EACR,UAAU,EACV,YAAY,EACZ,QAAQ,EACR,WAAW,GACZ,MAAM,iBAAiB,CAAC;AAIzB,OAAO,EAAE,+BAA+B,EAAE,MAAM,wBAAwB,CAAC"}
+{"version":3,"file":"lib.d.ts","sourceRoot":"","sources":["../../src/lib.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAIH,OAAO,uBAAuB,CAAC;AAI/B,OAAO,EAAE,cAAc,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAIjE,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAIzC,OAAO,EACL,gBAAgB,EAChB,gBAAgB,EAChB,WAAW,EACX,cAAc,EACd,mBAAmB,GACpB,MAAM,kBAAkB,CAAC;AAI1B,OAAO,EACL,wBAAwB,EACxB,qBAAqB,EACrB,mBAAmB,GACpB,MAAM,qBAAqB,CAAC;AAC7B,YAAY,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAI5D,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAIzC,OAAO,EAAE,uBAAuB,EAAE,MAAM,qCAAqC,CAAC;AAC9E,YAAY,EACV,wBAAwB,EACxB,uBAAuB,EACvB,uBAAuB,EACvB,6BAA6B,EAC7B,2BAA2B,GAC5B,MAAM,qCAAqC,CAAC;AAC7C,OAAO,EACL,8BAA8B,EAC9B,yBAAyB,GAC1B,MAAM,6CAA6C,CAAC;AACrD,YAAY,EAAE,+BAA+B,EAAE,MAAM,6CAA6C,CAAC;AAInG,OAAO,EACL,eAAe,EACf,OAAO,EACP,iBAAiB,EACjB,YAAY,EACZ,eAAe,GAChB,MAAM,0BAA0B,CAAC;AAIlC,YAAY,EACV,OAAO,EACP,WAAW,EACX,QAAQ,EACR,eAAe,EACf,eAAe,EACf,YAAY,GACb,MAAM,YAAY,CAAC;AAIpB,YAAY,EACV,YAAY,EACZ,YAAY,EACZ,YAAY,EACZ,oBAAoB,GACrB,MAAM,sBAAsB,CAAC;AAI9B,YAAY,EACV,YAAY,EACZ,YAAY,EACZ,QAAQ,EACR,cAAc,EACd,UAAU,EACV,OAAO,EACP,QAAQ,EACR,UAAU,EACV,YAAY,EACZ,QAAQ,EACR,WAAW,GACZ,MAAM,iBAAiB,CAAC;AAIzB,OAAO,EAAE,+BAA+B,EAAE,MAAM,wBAAwB,CAAC"}

package/dist/src/lib.js

@@ -25,6 +25,9 @@ export { loadYAMLPipeline, getWorkflowNames, hasWorkflow, YAMLParseError, YAMLVa
 export { convertYAMLToPipelineDef, getAvailableWorkflows, YAMLConversionError, } from './yaml/converter.js';
 // ─── Pipeline DSL factory ───────────────────────────────────────────────
 export { pipeline } from './pipeline.js';
+// ─── UI fidelity local preview ──────────────────────────────────────────
+export { renderUiFidelityPreview } from './yaml/steps/ui-fidelity-preview.js';
+export { renderUiFidelityPreviewAndroid, ANDROID_TOOLCHAIN_MISSING, } from './yaml/steps/ui-fidelity-preview-android.js';
 // ─── Step registry ──────────────────────────────────────────────────────
 export { getStepExecutor, hasStep, getAvailableSteps, registerStep, getStepMetadata, } from './yaml/steps/registry.js';
 // ─── Error types ────────────────────────────────────────────────────────

package/dist/src/yaml/steps/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/yaml/steps/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAqCH;;;GAGG;AACH,wBAAgB,sBAAsB,IAAI,IAAI,CA63C7C"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/yaml/steps/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAyCH;;;GAGG;AACH,wBAAgB,sBAAsB,IAAI,IAAI,CAs5C7C"}

package/dist/src/yaml/steps/index.js

@@ -25,6 +25,7 @@ import { BitriseApkInfoStepExecutor } from './bitrise-apk-info.js';
 import { GooglePlayDeployStepExecutor } from './google-play-deploy.js';
 import { AppStoreDeployStepExecutor } from './app-store-deploy.js';
 import { UiFidelityRenderStepExecutor, DEFAULT_RENDER_SIZE, DEFAULT_SCALE, DEFAULT_PACKAGE_SOURCE, } from './ui-fidelity-render.js';
+import { UiFidelityRenderAndroidStepExecutor, DEFAULT_GRADLE_TASK, } from './ui-fidelity-render-android.js';
 /**
  * Initializes the step registry with all available steps
  * This function should be called once at application startup
@@ -795,6 +796,27 @@ export function initializeStepRegistry() {
             },
         },
     });
+    // UI fidelity — render Jetpack Compose wrappers to PNGs via Roborazzi +
+    // Robolectric on the JVM (no device/emulator), on a macOS runner
+    registerStep('ui-fidelity-render-android', new UiFidelityRenderAndroidStepExecutor(), {
+        name: 'ui-fidelity-render-android',
+        description: 'Render parameterless Jetpack Compose wrappers from a shipped Gradle project to PNGs ' +
+            'via Roborazzi + Robolectric on the JVM (no device, no emulator)',
+        platform: 'android',
+        inputs: {
+            scale: {
+                description: 'Display scale factor used when reporting logical points; must match the ' +
+                    'density qualifier the render test pins (xhdpi = 2)',
+                required: false,
+                default: DEFAULT_SCALE,
+            },
+            gradle_task: {
+                description: 'Gradle task that records the Roborazzi PNGs, run from the project root',
+                required: false,
+                default: DEFAULT_GRADLE_TASK,
+            },
+        },
+    });
     // Export xcarchive
     registerStep('export-xcarchive', new ExportXcarchiveStepExecutor(), {
         name: 'export-xcarchive',

package/dist/src/yaml/steps/render-post-processor.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Shared render-output post-processor.
+ *
+ * The single source of truth for turning a freshly rendered PNG into the
+ * artifacts the fidelity loop compares: a content-trimmed image, a
+ * reference-sized aligned copy, and the reported dimensions (rendered px /
+ * logical pt / reference px). It operates on PNGs regardless of how they were
+ * produced -- a SwiftUI `ImageRenderer` render or a Compose/Roborazzi render --
+ * so crop/align/dimension behavior cannot drift between platforms. Both render
+ * paths run on the macOS runner fleet, so the pixel work is one CoreGraphics
+ * helper invoked in Swift's script-interpreter mode; the surrounding JS
+ * orchestration is spliced into each platform's generated runtime script.
+ *
+ * This module is consumed by `ui-fidelity-render.ts` (iOS) and, once it lands,
+ * the Android render step. The iOS step embeds these exact strings, so its
+ * generated script -- and therefore its rendered output -- stays byte-identical
+ * to before this extraction.
+ */
+/**
+ * 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;
+export declare const RENDER_SCRIPT_TRIM_STAGE: string;
+/** A rendered/reference/source dimension pair in pixels, as TRIMDIMS reports. */
+export type TrimDimsPair = [number, number];
+/** Parsed TRIMDIMS line: rendered (trimmed) / reference / pre-trim source px. */
+export interface TrimDims {
+    rendered: TrimDimsPair;
+    reference: TrimDimsPair;
+    source: TrimDimsPair;
+}
+/**
+ * The pure, platform-neutral dimension-reporting helpers embedded in the
+ * trim-stage script. `parseTrimDims` reads the helper's TRIMDIMS stdout line;
+ * `roundTwo` is the logical-pt rounding primitive.
+ */
+export interface PostProcessorInternals {
+    parseTrimDims(stdout: string): TrimDims | null;
+    roundTwo(value: number): number;
+}
+/**
+ * Evaluates the embedded trim-stage source and returns its pure helpers, so
+ * unit tests exercise exactly the code that ships inside the runtime script
+ * (mirrors getRenderScriptInternals in ui-fidelity-render.ts). The other
+ * trim-stage functions reference runtime globals (fs, path, runSwift, ...)
+ * only when called, so defining them here is harmless.
+ */
+export declare function getPostProcessorInternals(): PostProcessorInternals;
+//# sourceMappingURL=render-post-processor.d.ts.map

package/dist/src/yaml/steps/render-post-processor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"render-post-processor.d.ts","sourceRoot":"","sources":["../../../../src/yaml/steps/render-post-processor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH;;;;;;;;;;;;;;;;GAgBG;AACH;;;;;;;;;GASG;AACH,eAAO,MAAM,wBAAwB,EAAE,MAiJpB,CAAC;AAEpB,eAAO,MAAM,wBAAwB,EAAE,MAsFtC,CAAC;AAEF,iFAAiF;AACjF,MAAM,MAAM,YAAY,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AAE5C,iFAAiF;AACjF,MAAM,WAAW,QAAQ;IACvB,QAAQ,EAAE,YAAY,CAAC;IACvB,SAAS,EAAE,YAAY,CAAC;IACxB,MAAM,EAAE,YAAY,CAAC;CACtB;AAED;;;;GAIG;AACH,MAAM,WAAW,sBAAsB;IACrC,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,QAAQ,GAAG,IAAI,CAAC;IAC/C,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC;CACjC;AAED;;;;;;GAMG;AACH,wBAAgB,yBAAyB,IAAI,sBAAsB,CAMlE"}

package/dist/src/yaml/steps/render-post-processor.js

@@ -0,0 +1,290 @@
+/**
+ * Shared render-output post-processor.
+ *
+ * The single source of truth for turning a freshly rendered PNG into the
+ * artifacts the fidelity loop compares: a content-trimmed image, a
+ * reference-sized aligned copy, and the reported dimensions (rendered px /
+ * logical pt / reference px). It operates on PNGs regardless of how they were
+ * produced -- a SwiftUI `ImageRenderer` render or a Compose/Roborazzi render --
+ * so crop/align/dimension behavior cannot drift between platforms. Both render
+ * paths run on the macOS runner fleet, so the pixel work is one CoreGraphics
+ * helper invoked in Swift's script-interpreter mode; the surrounding JS
+ * orchestration is spliced into each platform's generated runtime script.
+ *
+ * This module is consumed by `ui-fidelity-render.ts` (iOS) and, once it lands,
+ * the Android render step. The iOS step embeds these exact strings, so its
+ * generated script -- and therefore its rendered output -- stays byte-identical
+ * to before this extraction.
+ */
+/**
+ * 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';
+export 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;
+  }
+}
+`;
+/**
+ * Evaluates the embedded trim-stage source and returns its pure helpers, so
+ * unit tests exercise exactly the code that ships inside the runtime script
+ * (mirrors getRenderScriptInternals in ui-fidelity-render.ts). The other
+ * trim-stage functions reference runtime globals (fs, path, runSwift, ...)
+ * only when called, so defining them here is harmless.
+ */
+export function getPostProcessorInternals() {
+    const factory = new Function(RENDER_SCRIPT_TRIM_STAGE +
+        '\nreturn { parseTrimDims: parseTrimDims, roundTwo: roundTwo };');
+    return factory();
+}
+//# sourceMappingURL=render-post-processor.js.map

package/dist/src/yaml/steps/render-post-processor.test.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Direct tests for the shared render-output post-processor.
+ *
+ * Two layers, matching how the module is built:
+ *  - The platform-neutral dimension-reporting logic (TRIMDIMS parsing, the
+ *    logical-pt rounding primitive) is pure JS embedded in the trim-stage
+ *    script. It is evaluated out of the shipped string via
+ *    getPostProcessorInternals() and tested directly, so these run in every
+ *    CI pass.
+ *  - The CoreGraphics pixel logic (content trim, uniform-background crop, the
+ *    transparent-frame fallback, align-to-reference) cannot run under a fake
+ *    `swift`, so it is exercised over crafted PNGs with the real toolchain,
+ *    gated behind CIBUILD_UI_FIDELITY_REAL_SWIFT=1 (the same gate iOS uses).
+ */
+export {};
+//# sourceMappingURL=render-post-processor.test.d.ts.map

package/dist/src/yaml/steps/render-post-processor.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"render-post-processor.test.d.ts","sourceRoot":"","sources":["../../../../src/yaml/steps/render-post-processor.test.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG"}

package/dist/src/yaml/steps/render-post-processor.test.js

@@ -0,0 +1,194 @@
+/**
+ * Direct tests for the shared render-output post-processor.
+ *
+ * Two layers, matching how the module is built:
+ *  - The platform-neutral dimension-reporting logic (TRIMDIMS parsing, the
+ *    logical-pt rounding primitive) is pure JS embedded in the trim-stage
+ *    script. It is evaluated out of the shipped string via
+ *    getPostProcessorInternals() and tested directly, so these run in every
+ *    CI pass.
+ *  - The CoreGraphics pixel logic (content trim, uniform-background crop, the
+ *    transparent-frame fallback, align-to-reference) cannot run under a fake
+ *    `swift`, so it is exercised over crafted PNGs with the real toolchain,
+ *    gated behind CIBUILD_UI_FIDELITY_REAL_SWIFT=1 (the same gate iOS uses).
+ */
+import { spawnSync } from 'node:child_process';
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { getPostProcessorInternals, TRIM_HELPER_SWIFT_SOURCE, } from './render-post-processor.js';
+describe('dimension reporting (TRIMDIMS parsing)', () => {
+    const { parseTrimDims } = getPostProcessorInternals();
+    test('parses a well-formed TRIMDIMS line into rendered/reference/source px', () => {
+        const dims = parseTrimDims('TRIMDIMS 320 640 160 320 400 800\n');
+        expect(dims).toEqual({
+            rendered: [320, 640],
+            reference: [160, 320],
+            source: [400, 800],
+        });
+    });
+    test('returns null when no TRIMDIMS line is present', () => {
+        expect(parseTrimDims('rendered HomeView\nsome other log line\n')).toBeNull();
+        expect(parseTrimDims('')).toBeNull();
+    });
+    test('takes the last TRIMDIMS line and ignores surrounding log noise', () => {
+        const stdout = [
+            'TRIMDIMS 10 10 10 10 10 10',
+            'helper: warming up',
+            'TRIMDIMS 320 640 160 320 400 800',
+            'helper: done',
+        ].join('\n');
+        expect(parseTrimDims(stdout)).toEqual({
+            rendered: [320, 640],
+            reference: [160, 320],
+            source: [400, 800],
+        });
+    });
+    test('returns null for a truncated or non-numeric TRIMDIMS line', () => {
+        expect(parseTrimDims('TRIMDIMS 320 640 160 320\n')).toBeNull();
+        expect(parseTrimDims('TRIMDIMS 320 x 160 320 400 800\n')).toBeNull();
+    });
+    test('reports a zero reference pair when no reference was available', () => {
+        // The helper prints "0 0" for the reference when it cannot load one; the
+        // render step maps that to a null reference_px when reporting dimensions.
+        const dims = parseTrimDims('TRIMDIMS 320 640 0 0 400 800\n');
+        expect(dims?.reference).toEqual([0, 0]);
+    });
+});
+describe('logical-pt rounding (roundTwo)', () => {
+    const { roundTwo } = getPostProcessorInternals();
+    test('rounds a logical-point value to two decimals', () => {
+        expect(roundTwo(360 / 2)).toBe(180);
+        expect(roundTwo(343 / 2)).toBe(171.5);
+        expect(roundTwo(100 / 3)).toBe(33.33);
+    });
+});
+// The CoreGraphics bounding-box/resize logic cannot run under a fake `swift`,
+// so it is exercised over crafted PNGs with the real toolchain. This is the
+// regression guard for the bug where a wrapper that fills its 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 a 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;
+    const { parseTrimDims } = getPostProcessorInternals();
+    const dirs = [];
+    afterAll(() => {
+        for (const dir of dirs) {
+            try {
+                rmSync(dir, { recursive: true, force: true });
+            }
+            catch {
+                // best effort
+            }
+        }
+    });
+    // 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) };
+    }
+    // A parameterized fixture maker: paints opaque rectangles (colors in 0..1)
+    // onto an otherwise transparent canvas, so a single Swift program can craft
+    // every input shape the bounding-box logic must handle.
+    const MAKE_FIXTURE_SWIFT = [
+        'import Foundation',
+        'import ImageIO',
+        'import CoreGraphics',
+        'import UniformTypeIdentifiers',
+        'let out = CommandLine.arguments[1]',
+        'let spec = try! JSONSerialization.jsonObject(with: CommandLine.arguments[2].data(using: .utf8)!) as! [String: Any]',
+        'let w = spec["w"] as! Int, h = spec["h"] as! Int',
+        'let 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))',
+        'func num(_ v: Any) -> Double { return Double("\\(v)")! }',
+        'for r in spec["rects"] as! [[String: Any]] {',
+        '    c.setFillColor(red: num(r["r"]!), green: num(r["g"]!), blue: num(r["b"]!), alpha: num(r["a"]!))',
+        '    c.fill(CGRect(x: num(r["x"]!), y: num(r["y"]!), width: num(r["w"]!), height: num(r["h"]!)))',
+        '}',
+        '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';
+    const RED = { r: 1, g: 0, b: 0, a: 1 };
+    const BLUE = { r: 0, g: 0, b: 1, a: 1 };
+    const WHITE = { r: 1, g: 1, b: 1, a: 1 };
+    const PINK = { r: 1, g: 240 / 255, b: 238 / 255, a: 1 };
+    function scene() {
+        const dir = mkdtempSync(join(tmpdir(), 'ui-fidelity-postproc-'));
+        dirs.push(dir);
+        writeFileSync(join(dir, 'Make.swift'), MAKE_FIXTURE_SWIFT);
+        writeFileSync(join(dir, 'Trim.swift'), TRIM_HELPER_SWIFT_SOURCE);
+        return dir;
+    }
+    function craft(dir, name, w, h, rects) {
+        const out = join(dir, name);
+        const make = spawnSync('swift', [join(dir, 'Make.swift'), out, JSON.stringify({ w, h, rects })], { encoding: 'utf-8' });
+        expect(make.stderr + '').toBe('');
+        expect(make.status).toBe(0);
+        return out;
+    }
+    function trim(dir, input, output, aligned, reference) {
+        const args = [join(dir, 'Trim.swift'), input, output];
+        if (aligned && reference)
+            args.push(aligned, reference);
+        const result = spawnSync('swift', args, { encoding: 'utf-8' });
+        expect(result.status).toBe(0);
+        return result;
+    }
+    realSwiftTest('trims a transparent frame down to its single content rectangle', () => {
+        const dir = scene();
+        const input = craft(dir, 'in.png', 200, 200, [{ x: 30, y: 50, w: 60, h: 40, ...RED }]);
+        const out = join(dir, 'out.png');
+        trim(dir, input, out);
+        expect(pngSize(out)).toEqual({ width: 60, height: 40 });
+    }, 600_000);
+    realSwiftTest('crops an opaque uniform-background wrapper to its content card', () => {
+        const dir = scene();
+        // 420x320 transparent canvas, 375x200 white wrapper, 343x168 pink card.
+        const input = craft(dir, 'in.png', 420, 320, [
+            { x: 20, y: 40, w: 375, h: 200, ...WHITE },
+            { x: 36, y: 56, w: 343, h: 168, ...PINK },
+        ]);
+        const out = join(dir, 'out.png');
+        trim(dir, input, out);
+        // Lands on the content card, NOT the white wrapper (375x200) or the raw
+        // canvas (420x320).
+        expect(pngSize(out)).toEqual({ width: 343, height: 168 });
+    }, 600_000);
+    realSwiftTest('trims only transparency when the opaque corners disagree (fallback)', () => {
+        const dir = scene();
+        // Two differently-colored halves: the opaque bounding box is 80x80 but its
+        // corners are not one uniform color, so no background is detected and only
+        // the transparent margin is removed.
+        const input = craft(dir, 'in.png', 120, 120, [
+            { x: 20, y: 20, w: 40, h: 80, ...RED },
+            { x: 60, y: 20, w: 40, h: 80, ...BLUE },
+        ]);
+        const out = join(dir, 'out.png');
+        trim(dir, input, out);
+        expect(pngSize(out)).toEqual({ width: 80, height: 80 });
+    }, 600_000);
+    realSwiftTest('writes a reference-sized aligned image and reports all three dimensions', () => {
+        const dir = scene();
+        const input = craft(dir, 'in.png', 200, 200, [{ x: 30, y: 50, w: 60, h: 40, ...RED }]);
+        const reference = craft(dir, 'ref.png', 100, 50, [{ x: 0, y: 0, w: 100, h: 50, ...BLUE }]);
+        const out = join(dir, 'out.png');
+        const aligned = join(dir, 'aligned.png');
+        const result = trim(dir, input, out, aligned, reference);
+        // The trimmed render is the content; the aligned copy is resized to the
+        // reference pixel size for a 1:1 overlay.
+        expect(pngSize(out)).toEqual({ width: 60, height: 40 });
+        expect(pngSize(aligned)).toEqual({ width: 100, height: 50 });
+        // The TRIMDIMS line reports rendered (trimmed) / reference / pre-trim
+        // source px, parsed by the same helper the runtime uses.
+        expect(parseTrimDims(result.stdout)).toEqual({
+            rendered: [60, 40],
+            reference: [100, 50],
+            source: [200, 200],
+        });
+    }, 600_000);
+});
+//# sourceMappingURL=render-post-processor.test.js.map