peachsim 0.1.1635 → 0.1.1641

package/cli/commands/doctor.ts

@@ -373,9 +373,8 @@ function printVersions(findings: DoctorFindings): void {
   }
 }
 
-// one line per package, worst first, with the published implementation
-// percent. packages that run from the bundle with no native code sit last on
-// one line: there is nothing to check in them.
+// packages appear worst first with the published implementation percent and
+// complete capability details. javascript-only packages sit last on one line.
 function printPackages(
   packages: readonly PackageResult[],
   verbose: boolean,
@@ -411,10 +410,26 @@ function printPackages(
   const columns = process.stdout.columns || 120
   for (const row of rows) {
     const percent = percentLabel(row.item)
-    const detail = fit(row.detail, Math.max(40, columns - nameWidth - versionWidth - 13))
+    const detail = row.detail
     console.log(
       `    ${row.glyph} ${row.item.name.padEnd(nameWidth)}${muted(row.item.version.padEnd(versionWidth))}${percent.padStart(5)}${detail ? `  ${row.tone(detail)}` : ''}`,
     )
+    if (!answering.has(row.item.name)) {
+      for (const [label, text] of [
+        ['working', row.item.rnx.working],
+        ['missing', row.item.rnx.missing],
+      ]) {
+        if (!text) continue
+        let line = `${label}:`
+        for (const word of text.split(/\s+/)) {
+          if (line.length + word.length + 1 > columns - 6) {
+            console.log(`      ${muted(line)}`)
+            line = word
+          } else line += ` ${word}`
+        }
+        console.log(`      ${muted(line)}`)
+      }
+    }
     if (verbose && row.item.note) console.log(`      ${muted(row.item.note)}`)
   }
   if (javascriptOnly.length > 0) {
@@ -476,7 +491,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
@@ -514,22 +532,12 @@ function packageRow(
     return {
       rank: RANK.partial,
       glyph: warning('◐'),
-      detail: pkg.rnx.missing ? `missing: ${firstClause(pkg.rnx.missing)}` : '',
+      detail: '',
       tone: muted,
     }
   return { rank: RANK.supported, glyph: success('✓'), detail: '', tone: muted }
 }
 
-function firstClause(text: string): string {
-  const end = text.search(/[.;,](\s|$)/)
-  return end > 0 ? text.slice(0, end) : text
-}
-
-// a detail ends at the terminal edge rather than wrapping under the columns
-function fit(text: string, width: number): string {
-  return text.length > width ? `${text.slice(0, Math.max(0, width - 1))}…` : text
-}
-
 function printNativeGuidance(
   unknownNative: readonly UnknownNativePackage[],
   local: readonly LocalNative[],
@@ -560,19 +568,28 @@ 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(`    import { defineConfig } from '${rnxPublicBrand.packageName}/config'`),
+    )
+    console.log()
     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)

package/cli/commands/flow.ts

@@ -973,7 +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)
+        if (scenePath) uploadArgs.push('--scene', scenePath, '--live-bundle')
         if (previewScreenshotPath) {
           uploadArgs.push('--screenshot', previewScreenshotPath)
         }

package/cli/commands/inspect/actions.ts

@@ -380,9 +380,10 @@ async function resolveTextTapTarget(
   query: string,
   options: TapTextOptions = {},
 ) {
+  const needle = options.exact ? query : query.trim().toLowerCase()
+  if (!needle) return { matched: 0, total: 0 }
   const { tree } = await inspectTree(bridge, 50)
   if (!Array.isArray(tree)) return { matched: 0, total: 0 }
-  const needle = options.exact ? query : query.toLowerCase()
   let candidates = collectTextCandidates(tree).filter(
     ({ node, ancestorTestIDs, role }) => {
       const text = nodeText(node)
@@ -411,7 +412,7 @@ async function resolveTextTapTarget(
     if (actionable.length > 0) candidates = actionable
     if (!options.exact) {
       const whole = candidates.filter(
-        ({ node }) => nodeText(node).trim().toLowerCase() === needle.trim(),
+        ({ node }) => nodeText(node).trim().toLowerCase() === needle,
       )
       if (whole.length > 0) candidates = whole
     }

package/cli/commands/inspect/core.ts

@@ -556,12 +556,6 @@ export interface LayoutElement {
   ellipsisActive?: boolean
 }
 
-export interface LayoutResult {
-  preview: 'web' | 'native'
-  count: number
-  elements: LayoutElement[]
-}
-
 // in-page extractor for the native preview. mirrors the visibility + device
 // sizing the a11y / wait-ready kernels use so "what's on screen" agrees across
 // the inspect surface. returns LayoutElement[] (or [] when the bridge is cold).
@@ -2013,8 +2007,6 @@ export const DEBUG_CHANNELS = [
   'yoga',
 ] as const
 
-export type DebugChannel = (typeof DEBUG_CHANNELS)[number]
-
 // `debug status` — which debug channels are currently enabled + their counts.
 export async function inspectDebugStatus(bridge: InspectBridge): Promise<unknown> {
   return bridge.send({ type: 'evaluate', code: 'window.__sootsimDebug.status()' })

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.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'
@@ -194,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 })
@@ -210,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)
@@ -858,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,
@@ -957,20 +971,6 @@ function keyCodeToVisualKey(code: string) {
   return null
 }
 
-function getInspectCommandName(subcommand: string, directSubcommand: string | null) {
-  if (directSubcommand === subcommand) return `peach ${subcommand}`
-  const group = getCliInspectVerbMeta(subcommand)?.group
-  return group ? `peach ${group} ${subcommand}` : `peach ${subcommand}`
-}
-
-function getInspectUsage(
-  subcommand: string,
-  tail: string,
-  directSubcommand: string | null,
-) {
-  return `  usage: ${getInspectCommandName(subcommand, directSubcommand)}${tail ? ` ${tail}` : ''}`
-}
-
 function normalizeRecordedText(value: unknown) {
   if (typeof value !== 'string') return null
   const text = value.replace(/\s+/g, ' ').trim()
@@ -2462,7 +2462,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',
@@ -2500,6 +2500,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,
@@ -2514,7 +2515,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({
@@ -2522,12 +2529,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,
@@ -2558,38 +2570,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)
@@ -2629,7 +2629,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 },
@@ -2663,7 +2663,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 })
@@ -2680,7 +2680,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',
@@ -3717,13 +3717,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)
@@ -3959,11 +3963,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 }
               })()`,
             })
@@ -4038,7 +4042,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}'))
@@ -4626,7 +4630,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/platform.ts

@@ -528,7 +528,7 @@ async function runRemoteBox(
   } else if (existingSession) {
     await closeCloudSession(existingSession)
   }
-  const created = await box.createPrebuiltBundleBox({
+  const { box: created, appFontsWireSha256 } = await box.createPrebuiltBundleBox({
     bundle: new Uint8Array(artifact.bytes),
     nativeProjectDir: input.nativeProjectDir,
     device: selectedDevice,
@@ -546,6 +546,7 @@ async function runRemoteBox(
     apiOrigin: endpoint,
     platform,
     device: selectedDevice,
+    appFontsWireSha256,
     artifact: {
       sha256: artifactSha256,
       bytes: artifact.bytes.length,

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,