peachsim 0.1.1625 → 0.1.1640

package/cli/commands/doctor.ts

@@ -4,8 +4,7 @@
 // native code Peach does not know with how to stub it, and a no-login report.
 
 import { createHash } from 'node:crypto'
-import { existsSync, lstatSync, realpathSync } from 'node:fs'
-import { dirname, join, relative, resolve } from 'node:path'
+import { relative, resolve } from 'node:path'
 import { PURE_JS_PACKAGES } from '@peach/compat/pure-js-whitelist'
 import { resolveCompatVersionRange } from '@peach/compat/version-range'
 import {
@@ -20,11 +19,11 @@ import { rnxPublicBrand } from '../../src/public-brand'
 import { resolveRNXAppConfig } from '../app-config'
 import {
   installedPackageDir,
-  listDir,
+  hasNativeCode,
+  scanLocalNative,
+  type LocalNative,
+  type AnsweredNames,
   packageNativeRequests,
-  sourceNativeRequests,
-  readSmallFile,
-  SOURCE_FILE,
   type AppStubs,
   type AppliedStubs,
   type NativeRequest as PackageNativeRequest,
@@ -33,11 +32,8 @@ import { readRuntimeCompatibility } from '../runtime-compat'
 import { accent, bold, failure, muted, success, warning } from '../ui'
 import {
   findProjectRoot,
-  scanRepository,
   scanWorkspace,
   installedManifest,
-  metadataValue,
-  readProjectJson,
   readProjectManifest,
 } from './detect'
 import { sanitizeProjectReportName, sanitizeProjectReportVersion } from './project-report'
@@ -129,7 +125,18 @@ export async function runDoctor(args: string[]): Promise<number> {
     versions: checkVersions(target.installed, runtime.appSupport),
     scan: target.scan,
     unknownNative: findUnknownNative(target.dir, target.scan, answered),
-    local: scanLocalNative(target.dir, target.manifest, answered, target.scan),
+    local: scanLocalNative(
+      target.dir,
+      target.manifest,
+      answered,
+      target.scan.scoreSummary.platform,
+      new Set([
+        ...PURE_JS_PACKAGES,
+        ...target.scan.packages
+          .filter((item) => item.rnx.source !== 'untracked')
+          .map((item) => item.name),
+      ]),
+    ),
   }
 
   if (json) printJson(findings)
@@ -469,7 +476,10 @@ function packageRow(
     return {
       rank: RANK.unknown,
       glyph: accent('?'),
-      detail: 'native code Peach does not know; stub it below',
+      // fonts and assets, or names built at runtime, leave nothing to stub by name
+      detail: unknownNative.requests.length
+        ? 'native code Peach does not know; stub it below'
+        : 'native code; names no native module',
       tone: muted,
     }
   // a stub answers ahead of Peach's own support for the package
@@ -553,19 +563,24 @@ function printNativeGuidance(
     )
   }
   // the open names grouped by the package they belong to, the key `packages` takes
-  const open = new Map<string, NativeRequest[]>()
+  const open = new Map<string, Map<string, NativeRequest>>()
   for (const [owner, requests] of [
     ...unknownNative.map((item) => [item.name, item.requests] as const),
     ...local.map((item) => [item.package, [item]] as const),
   ]) {
-    const unanswered = requests.filter((request) => !request.answered)
-    if (unanswered.length) open.set(owner, [...(open.get(owner) ?? []), ...unanswered])
+    for (const request of requests) {
+      if (request.answered) continue
+      const names = open.get(owner) ?? new Map<string, NativeRequest>()
+      names.set(`${request.kind}:${request.name}`, request)
+      open.set(owner, names)
+    }
   }
   if (open.size) {
     console.log(`\n  stub them in peach.config.ts, by package:\n`)
     console.log(muted(`    export default defineConfig({`))
     console.log(muted(`      packages: {`))
-    for (const [owner, requests] of open) {
+    for (const [owner, requestsByName] of open) {
+      const requests = [...requestsByName.values()]
       console.log(muted(`        '${owner}': {`))
       for (const kind of ['module', 'view'] as const) {
         const names = requests.filter((request) => request.kind === kind)
@@ -817,23 +832,6 @@ function findUnknownNative(
     })
 }
 
-function hasNativeCode(
-  dir: string,
-  platform: ScanResult['scoreSummary']['platform'],
-): boolean {
-  const expoConfig = join(dir, 'expo-module.config.json')
-  const platforms = metadataValue(readProjectJson(expoConfig), 'platforms')
-  if (Array.isArray(platforms))
-    return (
-      platforms.includes(platform) || (platform === 'ios' && platforms.includes('apple'))
-    )
-  if ([platform, 'expo-module.config.json'].some((entry) => existsSync(join(dir, entry))))
-    return true
-  if (listDir(dir).some((name) => name.endsWith('.podspec'))) return true
-  const manifest = readSmallFile(join(dir, 'package.json'))
-  return manifest !== null && manifest.includes('"codegenConfig"')
-}
-
 function reportLocalNative(local: readonly LocalNative[]): void {
   for (const item of local) {
     const where = item.expoModule
@@ -845,26 +843,6 @@ function reportLocalNative(local: readonly LocalNative[]): void {
   }
 }
 
-// an app's own native code, found from the names its JavaScript asks the native
-// side for and from local Expo modules (a directory with expo-module.config.json).
-// each name is a key under its package in peach.config.ts `packages`.
-export interface LocalNative {
-  kind: 'module' | 'view'
-  name: string
-  // the package the name belongs to: the nearest package.json with a name
-  package: string
-  // first place the name appears, relative to the app, as file:line
-  path: string
-  // the local Expo module directory the name belongs to, relative to the app
-  expoModule: string | null
-  swift: boolean
-  // a stub already answers it
-  answered: boolean
-}
-
-const NATIVE_SOURCE_FILE = /\.(?:swift|kt)$/
-type AnsweredNames = Record<LocalNative['kind'], Set<string>>
-
 function answeredNames(
   config: Awaited<ReturnType<typeof resolveRNXAppConfig>>['config'],
 ): AnsweredNames {
@@ -878,143 +856,6 @@ function answeredNames(
   }
 }
 
-function scanLocalNative(
-  appDir: string,
-  pkg: ProjectManifest,
-  answered: AnsweredNames,
-  scan: ScanResult,
-): LocalNative[] {
-  // linking a known dependency into a workspace does not make it app-owned native code.
-  const knownPackages = new Set([
-    ...PURE_JS_PACKAGES,
-    ...scan.packages
-      .filter((item) => item.rnx.source !== 'untracked')
-      .map((item) => item.name),
-  ])
-  const expoModuleDirs: string[] = []
-  const excludedModuleDirs: string[] = []
-  const sourceFiles: string[] = []
-  for (const root of [appDir, ...workspacePackageDirs(appDir, pkg)]) {
-    for (const dir of scanRepository(root).directories) {
-      if (
-        excludedModuleDirs.some(
-          (excluded) => dir === excluded || dir.startsWith(`${excluded}/`),
-        )
-      )
-        continue
-      if (existsSync(join(dir, 'expo-module.config.json'))) {
-        if (!hasNativeCode(dir, scan.scoreSummary.platform)) {
-          excludedModuleDirs.push(dir)
-          continue
-        }
-        expoModuleDirs.push(dir)
-      }
-      for (const name of listDir(dir)) {
-        if (SOURCE_FILE.test(name) && !name.endsWith('.d.ts'))
-          sourceFiles.push(join(dir, name))
-      }
-    }
-  }
-  const nativeFilesByModule = new Map(
-    expoModuleDirs.map((dir) => [
-      dir,
-      scanRepository(dir).directories.flatMap((sub) =>
-        listDir(sub)
-          .filter((name) => NATIVE_SOURCE_FILE.test(name))
-          .map((name) => join(sub, name)),
-      ),
-    ]),
-  )
-
-  const owners = new Map<string, string>()
-  const owner = (dir: string): string => {
-    const known = owners.get(dir)
-    if (known) return known
-    const name = readSmallFile(join(dir, 'package.json'))?.match(
-      /"name"\s*:\s*"([^"]+)"/,
-    )?.[1]
-    const parent = dirname(dir)
-    const result = name ?? (parent === dir ? (pkg.name ?? 'app') : owner(parent))
-    owners.set(dir, result)
-    return result
-  }
-  const found = new Map<string, LocalNative>()
-  const add = (kind: LocalNative['kind'], name: string, file: string, line: number) => {
-    const packageName = owner(dirname(file))
-    if (knownPackages.has(packageName)) return
-    const key = `${kind}:${name}`
-    if (found.has(key)) return
-    const moduleDir = expoModuleDirs.find((dir) => file.startsWith(`${dir}/`)) ?? null
-    found.set(key, {
-      kind,
-      name,
-      package: packageName,
-      path: `${relative(appDir, file)}:${line}`,
-      expoModule: moduleDir ? relative(appDir, moduleDir) || '.' : null,
-      swift: moduleDir
-        ? (nativeFilesByModule.get(moduleDir) ?? []).some((path) =>
-            path.endsWith('.swift'),
-          )
-        : false,
-      answered: answered[kind].has(name),
-    })
-  }
-  for (const file of sourceFiles) {
-    const text = readSmallFile(file)
-    if (!text) continue
-    for (const { kind, name, line } of sourceNativeRequests(file, text))
-      add(kind, name, file, line)
-  }
-  // a local expo module declares its name in its native definition, Name("X"),
-  // whether or not the app's javascript spells it out. swift first, so a
-  // module the report marks Swift points at its swift definition.
-  for (const [, files] of nativeFilesByModule) {
-    const swiftFirst = [...files].sort(
-      (a, b) => Number(b.endsWith('.swift')) - Number(a.endsWith('.swift')),
-    )
-    for (const file of swiftFirst) {
-      const text = readSmallFile(file)
-      if (!text) continue
-      for (const match of text.matchAll(/\bName\(\s*"(\w+)"\s*\)/g)) {
-        if (match[1])
-          add('module', match[1], file, text.slice(0, match.index).split('\n').length)
-      }
-    }
-  }
-  return [...found.values()].sort(
-    (a, b) => a.kind.localeCompare(b.kind) || a.name.localeCompare(b.name),
-  )
-}
-
-// dependencies installed as links to source outside any node_modules are the
-// app's own workspace packages, which hold its native code as often as the app
-// directory does.
-function workspacePackageDirs(appDir: string, pkg: ProjectManifest): string[] {
-  const dirs = new Set<string>()
-  for (const name of Object.keys({ ...pkg.dependencies, ...pkg.devDependencies })) {
-    let current = appDir
-    while (true) {
-      const link = join(current, 'node_modules', name)
-      if (existsSync(link)) {
-        if (lstatSync(link).isSymbolicLink()) {
-          const target = realpathSync(link)
-          if (
-            !target.split('/').includes('node_modules') &&
-            !target.startsWith(`${appDir}/`)
-          ) {
-            dirs.add(target)
-          }
-        }
-        break
-      }
-      const parent = dirname(current)
-      if (parent === current) break
-      current = parent
-    }
-  }
-  return [...dirs]
-}
-
 function scanOnePackage(
   appDir: string,
   pkg: ProjectManifest,

package/cli/commands/flow.ts

@@ -434,20 +434,20 @@ flow extension:
   const remapArgs = args.flatMap((arg, index) =>
     args[index - 1] === '--remap' ? ['--remap', arg] : [],
   )
-  // --preview implies --record: the preview page layers the mp4 over
-  // the canvas during scrub so the viewer sees smooth motion while the
-  // real app is catching up. upload chains the video in automatically.
-  const record = args.includes('--record') || preview
+  // CI previews export video from the saved scene after the take. desktop
+  // previews can also record live video; explicit --record always requests it.
+  const record =
+    args.includes('--record') || (preview && process.env.GITHUB_ACTIONS !== 'true')
   // hold the final UI state in the recording so viewers see the result
   // of the flow, not just a frame mid-transition. short flows otherwise
   // cut off ~600ms in. caller can override with --tail-wait <ms>.
   const tailWaitMs = args.includes('--tail-wait')
     ? Math.max(0, +(getFlag('--tail-wait') || '2000'))
-    : record
-      ? preview
-        ? 6000
-        : 2000
-      : 0
+    : preview
+      ? 6000
+      : record
+        ? 2000
+        : 0
 
   // parse flow file (frontmatter + steps). `${...}` templates stay verbatim
   // here — the runner interpolates per step at execution time.
@@ -730,6 +730,9 @@ flow extension:
     let videoPath: string | null = null
     let videoDurationMs: number | null = null
     let capturedEvents: Array<Record<string, any>> | null = null
+    let sceneRecording = false
+    let scenePath: string | null = null
+    let previewRecordingStartedAtMs: number | null = null
     let previewScreenshotPath: string | null = null
     let failureBundleDir: string | null = null
     let exitCode = 0
@@ -799,14 +802,17 @@ flow extension:
           simId: driver.simId,
           code: `(() => {
           const r = window.SootSim?.bridges?.eventRecorder ?? window.__sootsimEventRecorder
-          return r?.start?.() ?? false
+          const startedAtMs = Date.now()
+          return r?.start?.(startedAtMs) ? startedAtMs : null
         })()`,
         })
+        if (typeof started === 'number') previewRecordingStartedAtMs = started
         if (!started) {
           console.warn(
             '  warn: eventRecorder.start() returned false — preview will upload bundle without replay events',
           )
         }
+        sceneRecording = await startPreviewSceneRecording(bridge, driver.simId)
       }
       await hooks.beforeSteps?.()
       if (hooks.runSteps) await hooks.runSteps(driver, steps)
@@ -830,6 +836,10 @@ flow extension:
         })()`,
         })) as Array<Record<string, any>>
         console.log(`  captured ${capturedEvents.length} replay events`)
+        if (sceneRecording) {
+          sceneRecording = false
+          scenePath = await stopPreviewSceneRecording(bridge, driver.simId)
+        }
         previewScreenshotPath = path.join(screenshotDir, 'preview-final.png')
         await driver.captureScreenshot(previewScreenshotPath)
         console.log(`  final screenshot: ${previewScreenshotPath}`)
@@ -887,6 +897,10 @@ flow extension:
           )
         }
       }
+      if (sceneRecording) {
+        sceneRecording = false
+        scenePath = await stopPreviewSceneRecording(bridge, driver.simId)
+      }
       lastFlowError = err.message
       console.error(`\n  x failed: ${err.message}\n`)
       if (profileResult) {
@@ -959,6 +973,7 @@ flow extension:
         // canvas during scrub for smooth motion while the real app
         // catches up.
         if (videoPath) uploadArgs.push('--video', videoPath)
+        if (scenePath) uploadArgs.push('--scene', scenePath, '--live-bundle')
         if (previewScreenshotPath) {
           uploadArgs.push('--screenshot', previewScreenshotPath)
         }
@@ -966,7 +981,8 @@ flow extension:
           uploadArgs.push('--video-duration-ms', String(Math.round(videoDurationMs)))
           uploadArgs.push('--recorded-duration-ms', String(Math.round(videoDurationMs)))
         }
-        const recordingStartedAtMs = driver.getLastRecordingStartedAtMs()
+        const recordingStartedAtMs =
+          driver.getLastRecordingStartedAtMs() ?? previewRecordingStartedAtMs
         if (recordingStartedAtMs && Number.isFinite(recordingStartedAtMs)) {
           uploadArgs.push(
             '--recording-started-at-ms',
@@ -1151,6 +1167,58 @@ async function prepareEventsFile(events: Array<Record<string, any>>): Promise<st
   return outPath
 }
 
+// the tab's scene stream rides the preview share. a tab with no app on screen
+// has none to record, and the share keeps its events and video.
+async function startPreviewSceneRecording(
+  bridge: ReturnType<typeof createBridge>,
+  simId: string | undefined,
+): Promise<boolean> {
+  try {
+    await bridge.send({
+      type: 'evaluate',
+      simId,
+      code: `window.SootSim.bridges.sceneStream.run({ action: 'recordStart' })`,
+    })
+    return true
+  } catch (err) {
+    console.warn(
+      `  warn: scene stream not recorded: ${err instanceof Error ? err.message : String(err)}`,
+    )
+    return false
+  }
+}
+
+// write the recorded scene stream to a temp file for the upload command.
+async function stopPreviewSceneRecording(
+  bridge: ReturnType<typeof createBridge>,
+  simId: string | undefined,
+): Promise<string | null> {
+  try {
+    const encoded = await bridge.send({
+      type: 'evaluate',
+      simId,
+      code: `(async () => {
+        const { bytes } = await window.SootSim.bridges.sceneStream.run({ action: 'recordStop' })
+        let text = ''
+        for (let i = 0; i < bytes.length; i += 0x8000)
+          text += String.fromCharCode(...bytes.subarray(i, i + 0x8000))
+        return btoa(text)
+      })()`,
+    })
+    if (typeof encoded !== 'string') throw new Error('the tab returned no scene stream')
+    const bytes = Buffer.from(encoded, 'base64')
+    const outPath = path.join(tmpdir(), `peach-scene-${Date.now()}.psr.gz`)
+    fs.writeFileSync(outPath, bytes)
+    console.log(`  scene stream: ${outPath} (${bytes.length} bytes gz)`)
+    return outPath
+  } catch (err) {
+    console.warn(
+      `  warn: scene stream stop failed: ${err instanceof Error ? err.message : String(err)}`,
+    )
+    return null
+  }
+}
+
 async function prepareFlowStepTimelineFile(
   steps: SootSimFlowTraceStep[],
 ): Promise<string> {

package/cli/commands/inspect/core.ts

@@ -13,17 +13,14 @@
 
 import {
   HEADLESS_TENANT_FETCH_HUNG_MARKER,
+  readyProbeContentBasis,
   readyProbeIsReady,
   type SemanticWaitCondition,
   type SemanticWaitResult,
   type WsBridgeCommand,
 } from '../../../src/bridge-contract'
 import { SEMANTIC_WAIT_MAX_TIMEOUT_MS } from '../../../src/bridge-contract-input'
-export {
-  readyProbeHasContent,
-  readyProbeHasTargetContent,
-  readyProbeIsReady,
-} from '../../../src/bridge-contract'
+export { readyProbeHasContent, readyProbeIsReady } from '../../../src/bridge-contract'
 import type {
   SimSemanticNode,
   SimSemanticQueryResult,
@@ -1175,6 +1172,11 @@ export interface WaitReadyStatus {
   externalError: string
   suppressedEntryError: string
   errors: number
+  // the probe fields that decide readiness, so a ready result shows why it
+  // returned: which content condition held and what painted.
+  paintedAppContent: boolean
+  treeQuietMs: number
+  readyBasis: string
   // non-empty when the probe itself stopped reaching the sim (tab closed,
   // sim never connected) — the wait failed on the bridge, not on the app.
   bridgeError: string
@@ -1422,6 +1424,9 @@ function waitReadyStatus(result: SemanticWaitResult, ready: boolean): WaitReadyS
     suppressedEntryError: probe?.suppressedEntryError ?? '',
     errors: probe?.errors ?? 0,
     bridgeError: result.error ?? '',
+    paintedAppContent: probe?.paintedAppContent ?? false,
+    treeQuietMs: probe?.treeQuietMs ?? 0,
+    readyBasis: probe ? readyProbeContentBasis(probe) : '',
   }
 }
 

package/cli/commands/inspect/settling.ts

@@ -422,9 +422,15 @@ export async function waitForSootsimIdle({
               webViewStarting = true
               webViewBlocker = 'preview progress element displayed'
             } else {
-              const unreadyWebView = document.querySelector(
+              // a loading document with no area (an app's hidden worker or
+              // executor frame) paints nothing, and a screenshot on device
+              // does not wait for it.
+              const unreadyWebView = [...document.querySelectorAll(
                 '[data-sootsim-webview-loading="true"], [data-sootsim-webview-mode="placeholder"]'
-              )
+              )].find((view) => {
+                const frame = view.querySelector('iframe')
+                return !frame || frame.clientWidth > 0 || frame.clientHeight > 0
+              })
               if (unreadyWebView) {
                 webViewStarting = true
                 webViewBlocker = 'webView document still loading'
@@ -691,6 +697,9 @@ export type SettledWaitReady = {
   // the last readiness read: the settled tree once the app went idle,
   // otherwise the read that ended the wait.
   status: WaitReadyStatus
+  // the first read that counted as ready, before the settle: the probe the
+  // wait accepted. null when the app never became ready.
+  accepted: WaitReadyStatus | null
   // the last settle; null when the app never became ready.
   idle: WaitForSootsimIdleResult | null
   elapsedMs: number
@@ -709,8 +718,10 @@ export async function waitReadyAndSettle(
 ): Promise<SettledWaitReady> {
   const start = Date.now()
   const remaining = () => Math.max(0, start + timeoutMs - Date.now())
+  let accepted: WaitReadyStatus | null = null
   const result = (status: WaitReadyStatus, idle: WaitForSootsimIdleResult | null) => ({
     status,
+    accepted,
     idle,
     elapsedMs: Date.now() - start,
   })
@@ -719,6 +730,7 @@ export async function waitReadyAndSettle(
     idle = null
     const ready = await inspectWaitReady(bridge, remaining(), options)
     if (!ready.ready) return result(ready, idle)
+    accepted = ready
     idle = await waitForSootsimIdle({
       bridge,
       simId: options.simId,

package/cli/commands/inspect/shared.ts

@@ -92,10 +92,15 @@ export async function maybeWaitForStartedScreenTransitions(
 ) {
   if (bridge.plane === 'cloud') return
   try {
-    const result = await callTestBridge<SootSimScreenTransitionWaitResult>(
-      bridge,
-      'waitForScreenTransitions',
-      SCREEN_TRANSITION_PREFLIGHT,
+    // the sim bounds this wait itself, so the round trip gets a short budget of
+    // its own; under the command budget a wedged sim cost every read twice
+    const result: SootSimScreenTransitionWaitResult | undefined = await bridge.send(
+      {
+        type: 'call',
+        path: '__sootsimTest.waitForScreenTransitions',
+        args: [SCREEN_TRANSITION_PREFLIGHT],
+      },
+      { timeoutMs: SCREEN_TRANSITION_PREFLIGHT.timeoutMs + 1200 },
     )
     if (!opts.verbose || !result?.started) return
     if (result.timedOut) {

package/cli/commands/inspect/wait-ready.ts

@@ -26,10 +26,12 @@ export async function runWaitReadySubcommand(opts: {
   if (bridge.plane === 'cloud') {
     const status = await inspectWaitReady(bridge, timeoutMs)
     if (!status.ready) timedOut(status, status.elapsedMs)
+    printAcceptedProbe(status)
     printReady(status, status.elapsedMs)
     return
   }
   let status: Awaited<ReturnType<typeof waitReadyAndSettle>>['status']
+  let accepted: Awaited<ReturnType<typeof waitReadyAndSettle>>['accepted']
   let idle: Awaited<ReturnType<typeof waitReadyAndSettle>>['idle']
   let elapsedMs: number
   try {
@@ -41,6 +43,7 @@ export async function runWaitReadySubcommand(opts: {
       },
     })
     status = settledWait.status
+    accepted = settledWait.accepted
     idle = settledWait.idle
     elapsedMs = settledWait.elapsedMs
   } catch (error) {
@@ -51,6 +54,7 @@ export async function runWaitReadySubcommand(opts: {
     throw error
   }
   if (!idle) timedOut(status, elapsedMs)
+  if (accepted) printAcceptedProbe(accepted)
   if (!idle.settled) {
     console.error(
       `  ⚠ wait ready timed out after ${elapsedMs}ms — app mounted but did not settle: ${idle.blockedBy} (nodes: ${status.nodes}, targets: ${status.targets})`,
@@ -66,6 +70,14 @@ export async function runWaitReadySubcommand(opts: {
   printReady(status, elapsedMs)
 }
 
+// the probe the wait accepted, kept so a ready that later proves wrong can be
+// read from the command's own output.
+function printAcceptedProbe(status: WaitReadyStatus): void {
+  console.error(
+    `  accepted probe at ${Math.round(status.elapsedMs)}ms: basis ${status.readyBasis}, flag ${String(status.flag)}, ${status.nodes} nodes (quiet ${Math.round(status.treeQuietMs)}ms), ${status.targets} targets, painted ${status.paintedAppContent}, live frame ${status.liveFrameActive} (${status.liveFrameChannels} channels, ${status.liveFramePublishes} publishes), browser surfaces ${status.browserSurfaceCount}`,
+  )
+}
+
 function printReady(status: WaitReadyStatus, elapsedMs: number): void {
   console.log(
     `  ready in ${elapsedMs}ms: ${status.nodes} nodes, ${status.targets} targets${status.liveFrameActive ? `, ${status.liveFrameChannels} live surfaces` : ''}${status.browserSurfaceCount ? `, ${status.browserSurfaceCount} browser surfaces` : ''}`,