@invarn/cibuild 2.0.8 → 2.1.0

package/dist/src/lib.d.ts

@@ -21,6 +21,8 @@ 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,EAAE,uBAAuB,EAAE,MAAM,qCAAqC,CAAC;AAC9E,YAAY,EACV,wBAAwB,EACxB,uBAAuB,EACvB,uBAAuB,EACvB,6BAA6B,EAC7B,2BAA2B,GAC5B,MAAM,qCAAqC,CAAC;AAI7C,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

@@ -27,6 +27,7 @@ export { convertYAMLToPipelineDef, getAvailableWorkflows, YAMLConversionError, }
 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,MA8JpB,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,303 @@
+/**
+ * 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)',
+    '}',
+    '',
+    '// Draw `image` centered on a transparent reference-sized canvas, scaled to fit',
+    '// while PRESERVING its aspect ratio. Unlike `resize` (which stretches to exact',
+    '// dimensions and distorts proportions when the aspect ratios differ), this',
+    '// keeps the rendered shape honest: an aspect mismatch shows as transparent',
+    '// letterbox/pillarbox padding rather than a squished image, while the canvas',
+    '// stays exactly reference-sized so the pair still overlays 1:1.',
+    'func fitPad(_ 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.clear(CGRect(x: 0, y: 0, width: w, height: h))',
+    '    ctx.interpolationQuality = .high',
+    '    let scale = min(Double(w) / Double(image.width), Double(h) / Double(image.height))',
+    '    let drawW = Double(image.width) * scale',
+    '    let drawH = Double(image.height) * scale',
+    '    let originX = (Double(w) - drawW) / 2.0',
+    '    let originY = (Double(h) - drawH) / 2.0',
+    '    ctx.draw(image, in: CGRect(x: originX, y: originY, width: drawW, height: drawH))',
+    '    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 fit onto a reference-sized',
+    '// canvas, preserving aspect ratio (transparent letterbox/pillarbox padding',
+    '// when aspect ratios differ). A reference-sized, undistorted 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 = fitPad(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"}