peachsim 0.1.1625 → 0.1.1640

package/cli/commands/inspect.ts

@@ -1,6 +1,7 @@
 // peach inspect — dump node tree, accessibility info, query nodes
 // connects to the peach WS bridge (no Playwright)
 
+import { Script } from 'node:vm'
 import { getCliInspectVerbMeta } from '@peach/skills/cli'
 import { renderCliCommandHelp, renderCliGroupHelp } from '@peach/skills/cli/renderers'
 import { DEFAULT_SOOTSIM_BRIDGE_PORT } from '../../src/bridge-constants'
@@ -34,6 +35,7 @@ import {
   parseBridgeCliArgs,
   printBridgeWorldNotice,
   type WsBridge,
+  type BridgeSimInfo,
 } from '../ws-bridge'
 import {
   isTapSuccess,
@@ -193,6 +195,8 @@ async function performSingleStep(
   }
 }
 
+// runs after a command already spent its whole budget, so an explicit --timeout
+// must not make the liveness check wait that long a second time
 async function probeSimResponsive(bridge: WsBridge): Promise<boolean> {
   try {
     await bridge.send({ type: 'evaluate', code: '1' }, { timeoutMs: 3000 })
@@ -209,6 +213,18 @@ async function reportMissingTarget(
   verb: 'tap' | 'double-tap' | 'long-press',
   target: { mode: 'testid' | 'text'; value: string },
 ): Promise<void> {
+  if (target.mode === 'testid') {
+    // the tree can hold the id while the engine has no point to press: the node
+    // is not painted yet, or was replaced since the query. say so, so the
+    // suggestion list never names the id that was just reported missing.
+    const exact = await inspectFind(bridge, { testId: target.value }).catch(() => null)
+    if (exact?.result) {
+      console.error(
+        `  found ${target.value} in the tree but it has no tap target yet; it may be unpainted, hidden or covered: wait for it with peach wait selector ${target.value}`,
+      )
+      return
+    }
+  }
   console.error(`  not found: ${target.value}`)
   if (target.mode !== 'testid') return
   const byText = await inspectFind(bridge, { text: target.value }).catch(() => null)
@@ -596,13 +612,13 @@ export function printShellPerfReport(result: Record<string, any>) {
     console.log(``)
     console.log(`    cadence (frame delivery, ${cadence.vsyncTicks} vsync ticks):`)
     console.log(
-      `      display clock:  ${cadence.displayHz}hz · host rAF interval p50 ${cadence.hostIntervalP50} / p95 ${cadence.hostIntervalP95} / max ${cadence.hostIntervalMax} ms${cadence.hostGaps ? ` · ${cadence.hostGaps} gaps >1.5x (host rAF starved)` : ''}`,
+      `      display clock:  ${cadence.displayHz}hz · host rAF interval p50 ${cadence.hostIntervalP50} / p95 ${cadence.hostIntervalP95} / max ${cadence.hostIntervalMax} ms${cadence.hostGaps ? ` · ${cadence.hostGaps} gaps >1.5x (host rAF starved)` : ''}${cadence.idleBreaks ? ` · ${cadence.idleBreaks} host idle breaks excluded` : ''}`,
     )
     console.log(
       `      delivery lag:   p50 ${cadence.deliveryLagP50} / p95 ${cadence.deliveryLagP95} / max ${cadence.deliveryLagMax} ms (vsync postMessage → shell receipt)`,
     )
     console.log(
-      `      paint interval: p50 ${cadence.paintIntervalP50} / p95 ${cadence.paintIntervalP95} / max ${cadence.paintIntervalMax} ms${cadence.idleBreaks ? ` · ${cadence.idleBreaks} idle breaks excluded` : ''}`,
+      `      present interval: p50 ${cadence.paintIntervalP50} / p95 ${cadence.paintIntervalP95} / max ${cadence.paintIntervalMax} ms (during motion, ${cadence.paintIntervals} intervals, including native frames)`,
     )
   }
   const compositorCadence = result.compositorCadence
@@ -857,11 +873,10 @@ async function waitForKeyboardVisible(
 }
 
 /**
- * keys for a CPU simulator. it has no keyboard bridge to probe and refuses the
- * `keyboard` command, so its `perform` presses each character against
- * whatever holds focus and fails the batch when nothing does.
+ * dispatch through the shared input executor, which checks the requested
+ * node identity before targeted typing and carries refusals out of the CLI.
  */
-async function performCloudKeys(
+async function performKeys(
   bridge: WsBridge,
   steps: Array<Extract<PerformStep, { type: 'type' | 'typeInto' | 'key' }>>,
   actionLabel: string,
@@ -1247,7 +1262,7 @@ export async function runInspect(args: string[], opts: InspectOptions) {
     return
   }
 
-  // `peach list --drivers` — pure local registry view, no bridge needed.
+  // driver discovery works offline; a live bridge also reports each running renderer.
   // short-circuit here so users can discover drivers even when no peach
   // session is running.
   if (
@@ -1256,6 +1271,19 @@ export async function runInspect(args: string[], opts: InspectOptions) {
   ) {
     const { buildDriverListRows } = await import('../drivers')
     const rows = buildDriverListRows()
+    const bridge = (opts.createBridge ?? createBridgeFromParsed)(parsed)
+    let sims: BridgeSimInfo[] = []
+    try {
+      sims = await bridge.listSims()
+    } catch {
+      // local availability remains useful when no bridge is running.
+    } finally {
+      bridge.close()
+    }
+    if (wantsJson(effectiveArgs)) {
+      printJson({ drivers: rows, sims })
+      return
+    }
     console.log(`  available drivers (${rows.length}):\n`)
     const idWidth = Math.max(...rows.map((r) => r.id.length), 6)
     const kindWidth = Math.max(...rows.map((r) => r.kind.length), 4)
@@ -1270,6 +1298,15 @@ export async function runInspect(args: string[], opts: InspectOptions) {
         console.log(`    unavailable: ${row.reason}`)
       }
     }
+    for (const sim of sims) {
+      const renderer = sim.meta?.peachRenderer
+      const executable = sim.meta?.peachHostExecutable
+      if (sim.readyState === 'open' && typeof renderer === 'string') {
+        console.log(
+          `  in use: ${sim.id} · ${String(sim.meta?.sootsimHostDriver)} · ${renderer}${typeof executable === 'string' ? ` @ ${executable}` : ''}`,
+        )
+      }
+    }
     return
   }
 
@@ -2439,7 +2476,7 @@ export async function runInspect(args: string[], opts: InspectOptions) {
             console.error('  type-into requires a resolved text input node identity')
             peachExit(1)
           }
-          const typed = await performCloudKeys(
+          const typed = await performKeys(
             bridge,
             [{ type: 'typeInto', text, nodeId }],
             'type-into',
@@ -2477,6 +2514,7 @@ export async function runInspect(args: string[], opts: InspectOptions) {
             return {
               cx: n.absolutePosition.x + (n.layout.width || 0) / 2,
               cy: n.absolutePosition.y + (n.layout.height || 0) / 2,
+              nodeId: n.nodeId,
               id: n.id,
               testID: n.testID,
               type: n.type,
@@ -2491,7 +2529,13 @@ export async function runInspect(args: string[], opts: InspectOptions) {
           peachExit(1)
         }
         if (!tiPayload.isTextInput) {
-          console.error(`  warning: ${targetId} is not a text input (isTextInput: false)`)
+          console.error(`  ${targetId} is not a text input (isTextInput: false)`)
+          peachExit(1)
+        }
+        const nodeId: unknown = tiPayload.nodeId
+        if (typeof nodeId !== 'number' || !Number.isSafeInteger(nodeId) || nodeId === 0) {
+          console.error('  type-into requires a resolved text input node identity')
+          peachExit(1)
         }
         // step 2: tap to focus
         const tapResult = await bridge.send({
@@ -2499,12 +2543,17 @@ export async function runInspect(args: string[], opts: InspectOptions) {
           x: tiPayload.cx,
           y: tiPayload.cy,
           target: {
+            nodeId,
             id: tiPayload.id ?? targetId,
             testID: tiPayload.testID ?? targetId,
             text: null,
             type: tiPayload.type ?? null,
           },
         })
+        if (!isTapSuccess(tapResult)) {
+          console.error(`  type-into could not tap ${targetId}`)
+          peachExit(1)
+        }
         const targetSecureTextEntry = tiPayload.secureTextEntry === true
         const keyboardState = await waitForKeyboardVisible(bridge, 1000, {
           targetId,
@@ -2535,38 +2584,26 @@ export async function runInspect(args: string[], opts: InspectOptions) {
             peachExit(1)
           }
         }
-        // step 3: clear existing text then type through the visible keyboard.
-        // count the field's value, masked while secure. the node's described
-        // text is its placeholder while empty, and the keyboard spec's text
-        // follows only predictive candidates.
-        const drawnCharacters = async () => {
-          const count: unknown = await bridge.send({
-            type: 'evaluate',
-            code: `(async () => {
-              const text = await window.__sootsimTest?.getTextInputValue(${tiArg})
-              return text ? [...new Intl.Segmenter().segment(text)].length : 0
-            })()`,
-          })
-          if (typeof count !== 'number') {
-            console.error(`  could not read the current text of ${targetId}`)
-            peachExit(1)
-          }
-          return count
-        }
-        const existingCharacters = await drawnCharacters()
-        for (let i = 0; i < existingCharacters; i++) {
-          await bridge.send({ type: 'keyboard', action: 'press', text: 'delete' })
-        }
-        // backspace clears only what precedes the caret the tap placed
-        if (existingCharacters > 0 && (await drawnCharacters()) > 0) {
-          console.error(
-            `  type-into could not clear ${targetId}: text remains after the caret the tap placed`,
-          )
+        // type at the live selection through the same guarded operation as
+        // chained and cloud typing; clearing first changes controlled values.
+        const typed = await performKeys(
+          bridge,
+          [{ type: 'typeInto', text, nodeId }],
+          'type-into',
+        )
+        const receipt: unknown = typed.steps[0]?.value
+        if (
+          !receipt ||
+          typeof receipt !== 'object' ||
+          typeof Reflect.get(receipt, 'secureTextEntry') !== 'boolean'
+        ) {
+          console.error('  type-into did not return its matched input secure state')
           peachExit(1)
         }
-        await bridge.send({ type: 'keyboard', action: 'type', text })
         const secureTextEntry =
-          targetSecureTextEntry || isSecureKeyboardState(keyboardState as any)
+          targetSecureTextEntry ||
+          Reflect.get(receipt, 'secureTextEntry') === true ||
+          isSecureKeyboardState(keyboardState as any)
         const outputText = secureTextEntry
           ? SECURE_TEXT_REDACTION
           : redactTextForKeyboardState(text, keyboardState as any)
@@ -2606,7 +2643,7 @@ export async function runInspect(args: string[], opts: InspectOptions) {
           peachExit(1)
         }
         if (bridge.plane === 'cloud') {
-          await performCloudKeys(bridge, [{ type: 'type', text }], 'type')
+          await performKeys(bridge, [{ type: 'type', text }], 'type')
           await recordInspectAction(
             'inspect type',
             { inputText: text },
@@ -2640,7 +2677,7 @@ export async function runInspect(args: string[], opts: InspectOptions) {
           peachExit(1)
         }
         if (bridge.plane === 'cloud') {
-          await performCloudKeys(bridge, [{ type: 'key', key: name }], 'key')
+          await performKeys(bridge, [{ type: 'key', key: name }], 'key')
         } else {
           await requireVisualKeyboard(bridge, 'key')
           await bridge.send({ type: 'keyboard', action: 'press', text: name })
@@ -2657,7 +2694,7 @@ export async function runInspect(args: string[], opts: InspectOptions) {
           peachExit(1)
         }
         if (bridge.plane === 'cloud') {
-          await performCloudKeys(
+          await performKeys(
             bridge,
             keys.map((key) => ({ type: 'key' as const, key })),
             'key-sequence',
@@ -3694,13 +3731,17 @@ export async function runInspect(args: string[], opts: InspectOptions) {
         // wrap in async to support await in worker mode. no identifier
         // rewriting — the snippet runs verbatim so tokens like `root`,
         // `debug`, `test` refer to whatever the user actually typed.
-        // multi-statement snippets need a block body: the bare expression
-        // form terminates at the first `;` (Unexpected token).
+        // compile without executing to distinguish expressions from statements;
+        // punctuation inside callbacks, literals and comments is not a separator.
         let expandedCode = code
         if (!expandedCode.startsWith('(async')) {
-          expandedCode = /[;\n]/.test(expandedCode)
-            ? `(async () => { ${expandedCode} })()`
-            : `(async () => ${expandedCode})()`
+          expandedCode = `(async () => (\n${code}\n))()`
+          try {
+            new Script(expandedCode)
+          } catch (error) {
+            if (!(error instanceof SyntaxError)) throw error
+            expandedCode = `(async () => {\n${code}\n})()`
+          }
         }
         const result = await bridge.send({ type: 'evaluate', code: expandedCode })
         printJson(result)
@@ -3936,11 +3977,11 @@ export async function runInspect(args: string[], opts: InspectOptions) {
           case 'start': {
             const result = await bridge.send({
               type: 'evaluate',
-              code: `(() => {
+              code: `(async () => {
                 if (!window.__sootsimShellPerf) {
                   return { error: 'shell frame profile unavailable (__sootsimShellPerf missing on the page)' }
                 }
-                window.__sootsimShellPerf.start()
+                await window.__sootsimShellPerf.start()
                 return { started: true }
               })()`,
             })
@@ -4015,7 +4056,7 @@ export async function runInspect(args: string[], opts: InspectOptions) {
                 if (!window.__sootsimShellPerf) {
                   return { error: 'shell frame profile unavailable (__sootsimShellPerf missing on the page)' }
                 }
-                window.__sootsimShellPerf.start()
+                await window.__sootsimShellPerf.start()
                 // give a frame for profiling to engage before the event
                 await new Promise(r => requestAnimationFrame(() => r(undefined)))
                 window.dispatchEvent(new Event('${eventName}'))
@@ -4603,7 +4644,7 @@ export async function runInspect(args: string[], opts: InspectOptions) {
     // re-incurs the full per-command timeout. three sequential probes turn a
     // single 15s timeout into ~60s of apparent hang (QA F19-1). there is
     // nothing useful to fetch from a sim that just timed out, so skip them.
-    const timedOut = /^command timed out after (\d+)s$/.exec(message)
+    const timedOut = /^command timed out after (\d+(?:\.\d+)?)s$/.exec(message)
     // a disconnected bridge is genuinely gone; recover is right and probing
     // it would just re-incur a full timeout. no bridge at all means there is
     // no sim to recover, only one to open.

package/cli/commands/install-desktop.ts

@@ -126,6 +126,7 @@ async function installLinuxDeb(packagePath: string): Promise<string> {
 async function installWindowsExe(exePath: string): Promise<string> {
   // nsis installer prompts and self-elevates; run it and let it take over.
   await new Promise<void>((resolvePromise, rejectPromise) => {
+    // runner-toolchain-platform: win32
     const child = spawn('cmd', ['/c', 'start', '""', '/wait', exePath], {
       stdio: 'inherit',
     })

package/cli/commands/maestro-compare.ts

@@ -8,6 +8,7 @@ import * as fs from 'fs'
 import * as os from 'os'
 import * as path from 'path'
 import { devices } from 'peach-engine/settings/devices'
+import { PNG } from 'pngjs'
 import { rnxHomeDir } from '../../src/home-paths'
 import { parseFlowFile } from '../flow-file'
 import {
@@ -17,7 +18,8 @@ import {
   comparePassed,
   instrumentFlowSource,
   nativeStepsFromCommandsJson,
-  nativeFlowFailureFromLog,
+  nativeFlowVerdictsFromJunit,
+  junitFlowKey,
   peachStepsFromCommandsJson,
   screensOverThreshold,
   type CompareCapture,
@@ -161,12 +163,44 @@ function statusBarPx(png: Buffer): number {
   const height = png.readUInt32BE(20)
   const spec = Object.values(devices).find(
     (d) =>
-      Math.round(d.width * d.scale) === width &&
-      Math.round(d.height * d.scale) === height,
+      // maestro can truncate fractional point bounds one pixel below simctl.
+      Math.abs(Math.round(d.width * d.scale) - width) <= 1 &&
+      Math.abs(Math.round(d.height * d.scale) - height) <= 1,
   )
   return spec ? spec.statusBarHeight * spec.scale : 0
 }
 
+// maestro's xctest shot on an ios 27 simulator drops the rightmost column of
+// an odd framebuffer (1179 becomes 1178). diffing at that short width
+// resamples peach off the pixel grid, so restore the column first.
+function alignNativeCapture(png: Buffer): Buffer {
+  const width = png.readUInt32BE(16)
+  const height = png.readUInt32BE(20)
+  const spec = Object.values(devices).find(
+    (d) =>
+      Math.abs(Math.round(d.width * d.scale) - width) <= 1 &&
+      Math.abs(Math.round(d.height * d.scale) - height) <= 1,
+  )
+  if (!spec) return png
+  const expectedW = Math.round(spec.width * spec.scale)
+  const expectedH = Math.round(spec.height * spec.scale)
+  if (expectedH !== height || expectedW !== width + 1) return png
+  const src = PNG.sync.read(png)
+  const dst = new PNG({ width: expectedW, height })
+  for (let y = 0; y < height; y++) {
+    const srow = y * src.width * 4
+    const drow = y * expectedW * 4
+    src.data.copy(dst.data, drow, srow, srow + src.width * 4)
+    const last = srow + (src.width - 1) * 4
+    const o = drow + src.width * 4
+    dst.data[o] = src.data[last] ?? 0
+    dst.data[o + 1] = src.data[last + 1] ?? 0
+    dst.data[o + 2] = src.data[last + 2] ?? 0
+    dst.data[o + 3] = 255
+  }
+  return PNG.sync.write(dst)
+}
+
 // the flow as its author would name it: relative inside the working
 // directory, home-relative or absolute outside it.
 function displayPath(cwd: string, file: string): string {
@@ -201,22 +235,6 @@ function formatFailedRequest(entry: unknown): string {
   return `request failed: ${e.method ?? 'GET'} ${e.url ?? '?'} ${e.status ?? e.error ?? ''}`.trim()
 }
 
-// peach names each flow's output dir after the file stem, suffixing repeats
-// in run order (commands/maestro.ts uniqueFlowDir).
-function peachFlowDirs(root: string, files: string[]): string[] {
-  const seen = new Map<string, number>()
-  return files.map((file) => {
-    const slug =
-      path
-        .basename(file)
-        .replace(/\.(ya?ml)$/i, '')
-        .replace(/[^A-Za-z0-9._-]+/g, '_') || 'flow'
-    const n = (seen.get(slug) ?? 0) + 1
-    seen.set(slug, n)
-    return path.join(root, n === 1 ? slug : `${slug}-${n}`)
-  })
-}
-
 // the flow's appId as maestro resolves it: its `${...}` templates evaluate
 // against --env values (in process.env) and the flow's own env block.
 function resolveFlowAppId(frontmatter: Record<string, unknown>): string | undefined {
@@ -424,6 +442,10 @@ export async function runMaestroCompare(
         '--test-output-dir',
         nativeOut,
         '--no-ansi',
+        '--format',
+        'junit',
+        '--output',
+        path.join(out, 'ios-report.xml'),
         ...shared,
         ...envPairs,
       ],
@@ -433,18 +455,23 @@ export async function runMaestroCompare(
     spawnSync('xcrun', ['simctl', 'status_bar', udid, 'clear'], { stdio: 'ignore' })
   }
   console.log(`\n  ios │ maestro exited ${nativeExit}\n`)
-  const nativeLog = fs.readFileSync(path.join(out, 'ios.log'), 'utf8')
+  const nativeVerdicts = nativeFlowVerdictsFromJunit(
+    fs.readFileSync(path.join(out, 'ios-report.xml'), 'utf8'),
+  )
 
   // 2. peach, same instrumented flows (its --env already applied above)
   const peachOut = path.join(out, 'peach')
-  const peachResults = new Map<string, { exit: number; playbackFailure: string }>()
+  const peachResults = new Map<
+    string,
+    { exit: number; playbackFailure: string; outputDir: string | null }
+  >()
   await runMaestro(
     ['test', runTarget, '--test-output-dir', peachOut, ...shared, ...peachArgs],
     {
       ...opts,
       captureConsole: true,
-      onFlowResult: ({ file, exit, playbackFailure }) => {
-        peachResults.set(path.resolve(file), { exit, playbackFailure })
+      onFlowResult: ({ file, exit, playbackFailure, outputDir }) => {
+        peachResults.set(path.resolve(file), { exit, playbackFailure, outputDir })
       },
     },
   )
@@ -458,26 +485,56 @@ export async function runMaestroCompare(
         .sort()
         .pop()
     : undefined
-  const peachDirs = peachFlowDirs(
-    peachOut,
-    instrumented.map((f) => f.copy),
-  )
+  const nativeOutputs = new Map<string, Array<{ dir: string; commands: unknown }>>()
+  for (const entry of nativeRun
+    ? fs.readdirSync(nativeRun, { withFileTypes: true })
+    : []) {
+    if (!entry.isDirectory()) continue
+    const dir = path.join(nativeRun!, entry.name)
+    const commands = readJson(path.join(dir, 'commands.json'))
+    if (!Array.isArray(commands)) continue
+    // display names are not paths: maestro replaces slashes and suffixes collisions.
+    // the top-level bookkeeping retains the original flow identity.
+    let name: string | undefined
+    let fileStem: string | undefined
+    for (const command of commands) {
+      if (command?.metadata?.depth !== 0) continue
+      const config = command?.command?.applyConfigurationCommand?.config
+      if (typeof config?.name === 'string') name ??= config.name
+      const env = command?.command?.defineVariablesCommand?.env
+      if (typeof env?.MAESTRO_FILENAME === 'string') fileStem ??= env.MAESTRO_FILENAME
+    }
+    if (fileStem === undefined) continue
+    const key = JSON.stringify([name ?? fileStem, fileStem])
+    const outputs = nativeOutputs.get(key) ?? []
+    outputs.push({ dir, commands })
+    nativeOutputs.set(key, outputs)
+  }
   const imagesDir = path.join(out, 'images')
   const flows: CompareFlow[] = []
   for (const [i, flow] of instrumented.entries()) {
-    const nativeDir = nativeRun ? path.join(nativeRun, flow.name) : null
-    const peachDir = peachDirs[i]!
-    const nativeRan = Boolean(nativeDir && fs.existsSync(nativeDir))
+    const fileStem = path.basename(flow.copy).replace(/\.(ya?ml)$/i, '')
+    const nativeOutput = nativeOutputs.get(JSON.stringify([flow.name, fileStem]))?.shift()
+    const nativeDir = nativeOutput?.dir
+    const nativeRan = Boolean(nativeOutput)
     const peachResult = peachResults.get(path.resolve(flow.copy))
-    const nativeFailure = nativeFlowFailureFromLog(nativeLog, flow.name)
-    const peachRan = fs.existsSync(path.join(peachDir, 'commands.json'))
+    const peachDir = peachResult?.outputDir
+    const verdicts = nativeVerdicts.get(junitFlowKey(flow.name, fileStem))
+    const nativeFailure = verdicts?.length
+      ? verdicts.shift()
+      : 'no native verdict in ios-report.xml'
+    const peachRan = Boolean(
+      peachDir && fs.existsSync(path.join(peachDir, 'commands.json')),
+    )
     const nativeSteps = nativeRan
-      ? nativeStepsFromCommandsJson(readJson(path.join(nativeDir!, 'commands.json')))
+      ? nativeStepsFromCommandsJson(nativeOutput?.commands)
       : []
     const peachSteps = peachRan
-      ? peachStepsFromCommandsJson(readJson(path.join(peachDir, 'commands.json')))
+      ? peachStepsFromCommandsJson(readJson(path.join(peachDir!, 'commands.json')))
       : []
-    const consoleJson = readJson(path.join(peachDir, 'logs', 'console.json')) as {
+    const consoleJson = (
+      peachDir ? readJson(path.join(peachDir, 'logs', 'console.json')) : null
+    ) as {
       errors?: unknown[]
       requests?: unknown[]
     } | null
@@ -492,15 +549,17 @@ export async function runMaestroCompare(
       const nativePng = nativeDir
         ? path.join(nativeDir, 'takeScreenshot', `${capture.name}.png`)
         : ''
-      const peachPng = path.join(peachDir, 'screenshots', `${capture.name}.png`)
+      const peachPng = peachDir
+        ? path.join(peachDir, 'screenshots', `${capture.name}.png`)
+        : ''
       const hasNative = Boolean(nativePng) && fs.existsSync(nativePng)
-      const hasPeach = fs.existsSync(peachPng)
+      const hasPeach = Boolean(peachPng) && fs.existsSync(peachPng)
       const imageRel = path.join(
         'images',
         `${i + 1}-${capture.name.split('/').pop()}.png`,
       )
       if (hasNative && hasPeach) {
-        const nativeBytes = fs.readFileSync(nativePng)
+        const nativeBytes = alignNativeCapture(fs.readFileSync(nativePng))
         const { diff, triptych } = compareScreens(
           nativeBytes,
           fs.readFileSync(peachPng),

package/cli/commands/maestro.ts

@@ -51,7 +51,12 @@ export interface RunMaestroOptions {
   // (maestro compare reads it for the errors Peach saw)
   captureConsole?: boolean
   // each flow's final verdict, including a failure before any step ran
-  onFlowResult?: (result: { file: string; exit: number; playbackFailure: string }) => void
+  onFlowResult?: (result: {
+    file: string
+    exit: number
+    playbackFailure: string
+    outputDir: string | null
+  }) => void
 }
 
 const MAESTRO_DIRS = ['.maestro', 'maestro']
@@ -518,6 +523,7 @@ export async function runMaestro(
   let worstExit = 0
   const results: Array<{
     file: string
+    outputDir: string | null
     exit: number
     durationMs: number
     steps: ReturnType<typeof getLastFlowTraceSteps>
@@ -537,6 +543,7 @@ export async function runMaestro(
         console.error(`  error: ${playbackFailure}`)
         results.push({
           file,
+          outputDir: flowTestDir,
           exit: 1,
           durationMs: 0,
           steps: [],
@@ -610,6 +617,7 @@ export async function runMaestro(
     }
     const result = {
       file,
+      outputDir: flowTestDir,
       exit,
       durationMs,
       steps: traceSteps,

package/cli/commands/preview.ts

@@ -88,7 +88,7 @@ export async function runPreview(args: string[]): Promise<number> {
       bundleSizeBytes: artifact.bytes.byteLength,
       bundleContentType: 'application/javascript',
       bundleEncoding: 'br',
-      bundleMinified: true,
+      bundleMinified: artifact.minified,
       bundleOrigin: null,
       entry: null,
       isTransformed: false,