peachsim 0.1.1620 → 0.1.1635

package/LICENSE

@@ -8,7 +8,7 @@ the Peach Software License Agreement: https://peachsim.com/legal/license
 In summary (the agreement governs): Seed is free for individuals and companies
 under 10 people and under $1M yearly revenue, including commercial desktop and
 local use. A company at or above either limit needs Team while it has under
-100 people and under $10M yearly revenue, or Enterprise at or above either of
+25 people and under $3M yearly revenue, or Enterprise at or above either of
 those limits. Members, agents, API keys and local simulators are unlimited.
 Company size is self-reported and enforced through the license terms only.
 Embedding or redistributing the software requires a separate written agreement

package/README.md

@@ -231,6 +231,11 @@ actions discover the sim's owning world. Each world probe has one two-second
 wall deadline covering both connection and response. An inferred default port
 does not override the named sim's world.
 
+Bridge sockets use TCP keepalive so a governor-stopped browser can resume an
+in-flight render without losing its connection to an unanswered application
+ping. Command deadlines still bound stalled work; idle leases and abandoned
+sim cleanup remain separate from transport liveness.
+
 **The sim** is a browser/Electron *page* launched by a CLI driver. Inside that
 page run three workers: the **shell worker** owns device and native state, the
 **compositor worker** paints every visible CanvasKit surface, and the **tenant
@@ -279,7 +284,7 @@ therefore runs before assertions in each flow.
 | runtime delivery + Peach home | Versioned engine runtime management. The shared machinery owns manifest fetch, sha256 verification, channels, and auto-update. Peach binds it to `https://contrast.dev` and `~/.peach/runtimes/<version>`. A repo can select `runtimeVersion` without changing the machine default. | `src/runtime-delivery.ts`, `packages/contrast-runtime-delivery/`, `src/home-paths.ts`, `src/runtime-assets.ts` |
 | standalone CLI delivery | Cached stable-version checks, bounded interactive notices, and verified atomic executable replacement. | `cli/cli-update.ts`, `cli/commands/upgrade.ts`, `cli/commands/version.ts`, `src/cli-version.ts` |
 | `peachsim/vite` + `peachsim/metro` (runtime serving) | Published bundler plugins. Both serve the installed engine runtime at `/__peachsim/` from `~/.peach/runtimes/<version>` so an app's own dev server can host the sim shell; the Vite plugin can opt into a named Electron window. | `src/vite-plugin-one.ts`, `src/metro-plugin.ts`, `src/runtime-assets.ts` |
-| `sootsim()` vite resolver plugin (internal) | The large RN-resolution / native-stub vite plugin: aliases `react-native` to the engine shim, native packages to `@sootsim/compat` stubs, applies worklets/babel transforms, and instantiates `SootSimBridgeHost` in its dev server. Distinct from the published `peachsim/vite` export. | `src/vite-plugin.ts`, `src/worklets-babel.ts`, `packages/peach-compat/src/stub-manifest.ts` |
+| `sootsim()` vite resolver plugin (internal) | The large RN-resolution / native-stub vite plugin: aliases `react-native` to the engine shim, native packages to `@sootsim/compat` stubs, and applies worklets/babel transforms. Distinct from the published `peachsim/vite` export. | `src/vite-plugin.ts`, `src/worklets-babel.ts`, `packages/peach-compat/src/stub-manifest.ts` |
 | skills registry | Peach agent skills (`peach-setup`, `peach-debug`, `peach-test`, `peach-visual`, and the generated `contrast` index) installable with `peach skill`. | `skills/*.md`, `src/skills/registry.ts`, `src/skills/types.ts` |
 
 ## Getting started
@@ -318,7 +323,16 @@ resolve` re-pins it, and the CLI release publishes any bundle the bucket lacks.
 On Mac, headless launches attach an installed compatible native host. With no
 host, they render in the browser without downloading or placing the app. The
 browser logo menu offers the app; `peach desktop install --native` remains the
-explicit CLI installer. Linux still acquires its standalone host under `~/.peach`.
+explicit CLI installer. Linux x64 headless opens acquire the native standalone
+host under `~/.peach` by default. To choose plain Chromium for an open, use
+`peach open <target> --driver playwright --headless --chromium`.
+Pin the native host for reproducible Linux runs with
+`PEACH_DESKTOP_VERSION=<build>.<attempt> peach open <target> --headless`.
+A cached pin is used directly, even if another build is active; a missing pin
+is downloaded exactly, and an unavailable or incompatible pin fails the open.
+`peach list --drivers` shows installed hosts and each running sim's renderer
+and native executable path. Renderer choices select a matching sim or launch
+one; they never change a running sim's renderer.
 
 Headed launches on Linux use full Chromium, whose extra libraries the bundle
 also carries. Later opens reuse that sim and
@@ -510,8 +524,8 @@ a supported input; pass Peach the JavaScript bundle produced before Hermes
 compilation.
 
 If an app has unusual dependencies or fingerprint inference fails, you can
-optionally wrap your Metro configuration with `withPeach(config)`. It takes no
-options and enables two integrations:
+optionally wrap your Metro configuration with `withPeach(config)`. It enables
+two integrations:
 
 1. **Deterministic module identity:** appends Metro's exact module identity map
    as a trailing `globalThis.__sootsimModulePaths = { ... }` footer to every
@@ -521,6 +535,23 @@ options and enables two integrations:
 2. **In-browser dev shell:** serves the Peach simulator shell at `/__peachsim/` on
    the Metro dev server.
 
+Native app identity also travels in the bundle. Android permissions come only
+from a completed app manifest merger output. A sole output under
+`android/<module>/build/intermediates/merged_manifests/` is selected automatically;
+select one explicitly when multiple variants exist:
+
+```js
+module.exports = withPeach(config, {
+  androidMergedManifest:
+    'android/app/build/intermediates/merged_manifests/debug/processDebugManifest/AndroidManifest.xml',
+})
+```
+
+Without resolved merged output, Android permissions contain only the explicit
+Expo `android.permissions` set minus `android.blockedPermissions`. Defaults,
+plugins and linked library additions require completed merged output. See the
+[native identity contract](../../specs/sootsim-engine/native-app-identity.md).
+
 The URL helpers request ordinary Metro graphs: `dev=false&minify=true` for
 production and `dev=true&minify=false` for development.
 
@@ -571,6 +602,12 @@ and video recording create a new browser context; cold launches still use the
 supplied shell URL. When synchronization is enabled, URL delivery waits for
 existing work before dispatch and for navigation and painting afterward.
 
+Element taps finish viewport measurement before resolving the selected node's
+current center, visible frame, and relative offset in the browser task that
+sends the physical tap. Stillness samples do not supply later tap coordinates:
+startup layout can change while other bridge reads finish. A removed node
+rejects the action instead of reusing its old geometry.
+
 See `../../docs/migrating-from-detox.md` for details.
 
 ## Coming from Maestro
@@ -751,8 +788,10 @@ fails instead of loading empty native configuration. Bare Metro, which has no
 Expo manifest project root, uses
 the listening development process's cwd inside that same resolver. The invoking
 CLI's cwd is never an asset/config fallback. Asset wires stay on each opened
-project URL, so one daemon can serve several attached projects without sharing
-font or splash state between them.
+project URL. Font catalogs use content-addressed bridge asset references, so
+the navigation request stays bounded as the number of fonts grows. Recordings
+resolve these references before capturing the catalog and its assets. One daemon
+can serve several attached projects without sharing font or splash state.
 
 Bare iOS projects carry default Firebase options from their selected app
 target's Google services build resource when the app delegate initializes

package/cli/app-config.ts

@@ -1,3 +1,4 @@
+import { readFileSync } from 'node:fs'
 import path from 'node:path'
 import { createJiti } from 'jiti'
 import * as peachConfigModule from '../src/config'
@@ -80,7 +81,9 @@ async function loadConfigFile(
         [`${rnxPublicBrand.packageName}/config`]: peachConfigModule,
       },
     })
-    const loaded: unknown = await jiti.import(project.configPath, { default: true })
+    const loaded: unknown = project.configPath.endsWith('.json')
+      ? JSON.parse(readFileSync(project.configPath, 'utf8'))
+      : await jiti.import(project.configPath, { default: true })
     if (!isPeachConfig(loaded)) {
       throw new Error('the default export must be a peach config object')
     }

package/cli/app-fonts.ts

@@ -4,9 +4,9 @@ import { createRequire } from 'node:module'
 import path from 'node:path'
 import {
   encodeAppFontsWire,
+  resolveAppFontsWire,
   expoFontPathsFromPlugins,
   nativeLinkedFontSpecsFromPaths,
-  metroFontSpecsFromPaths,
   appFontAssetUrlsFromWire,
   type ConfigPluginFontSpec,
   type FontPlatform,
@@ -14,8 +14,10 @@ import {
 import { resolveListeningPid, resolveProcessCwd } from '../scripts/dev-server-scanner'
 import { loopbackOriginOf } from '../src/backend-origin'
 import { MANIFEST_PROBE_TIMEOUT_MS } from '../src/dev-bundle-resolution'
+import { parseExpoManifestBody } from '../src/expo-manifest-body'
 import { stageHostFile } from '../src/host/staged-host-files'
 import { parsePlistSource } from '../src/plist.ts'
+import { listXcodeAppTargets, readXcodeAppTarget } from '../src/xcode-project'
 import { resolveAppProject } from './app-project'
 import {
   materialSymbolFontPaths,
@@ -30,24 +32,22 @@ export type DiscoveredAppFontSpec = ConfigPluginFontSpec
 
 type ExpoConfigGetter = (dir: string, opts: Record<string, unknown>) => { exp?: unknown }
 
-// every font file is found on disk, so the asset urls are decided here and
-// never by asking the dev server: metro's asset endpoint resolves a path
-// against its config.projectRoot, which is the root it advertises and the one
-// projectDir names. a reachability request would make the result depend on how
-// busy the dev server is, and a cold build answers late enough to drop fonts.
+// every font file is found on disk, so its bytes are staged as host files and
+// never fetched from the dev server: only metro serves project files at
+// `/assets/<path>`, and a reachability request would make the result depend on
+// how busy the dev server is, so a cold build could answer late and drop fonts.
 export function discoverNativeLinkedAppFonts(opts: {
-  bundleUrl: string
   projectDir: string
   platform?: string
   nativeAssetOrigin: string
 }): DiscoveredAppFontSpec[] {
-  const metroOrigin = loopbackOriginOf(opts.bundleUrl)
-  if (!metroOrigin) return []
   const { paths, materialSymbols } = discoverNativeLinkedAppFontAssets(opts)
-  const specs = metroFontSpecsFromPaths(
+  const realProjectRoot = fs.realpathSync(opts.projectDir)
+  const specs = nativeLinkedFontSpecsFromPaths(
     projectRelativeFontPaths(opts.projectDir, paths),
-    metroOrigin,
     nativeFontPlatform(opts.platform),
+    (fontPath) =>
+      stageHostFile(path.resolve(realProjectRoot, fontPath), opts.nativeAssetOrigin),
   )
   attachMaterialSymbolMetadata(specs, materialSymbols, (asset) =>
     stageHostFile(asset, opts.nativeAssetOrigin),
@@ -285,6 +285,23 @@ function discoverNativeLinkedAppFontAssets(opts: {
             !entry.name.startsWith('.'),
         )
         .slice(0, 64)
+      // a bare filename in UIAppFonts names a file the target copies into
+      // its bundle, wherever the project keeps it: resolve it by the target's
+      // resource build phase before trying paths beside the plist.
+      const bundledByName = new Map<string, string>()
+      for (const entry of fs.readdirSync(iosDir, { withFileTypes: true })) {
+        if (!entry.isDirectory() || !entry.name.endsWith('.xcodeproj')) continue
+        const xcodeproj = path.join(iosDir, entry.name)
+        for (const target of listXcodeAppTargets(xcodeproj, { requireSources: false })) {
+          const members = readXcodeAppTarget(xcodeproj, target, undefined, {
+            requireSources: false,
+          })
+          for (const file of members.resources) {
+            if (!bundledByName.has(path.basename(file)))
+              bundledByName.set(path.basename(file), file)
+          }
+        }
+      }
       const plistPaths = [path.join(iosDir, 'Info.plist')]
       for (const entry of targetDirs) {
         plistPaths.push(path.join(iosDir, entry.name, 'Info.plist'))
@@ -301,15 +318,19 @@ function discoverNativeLinkedAppFontAssets(opts: {
         if (!Array.isArray(declaredFonts)) continue
         for (const declaredFont of declaredFonts) {
           if (typeof declaredFont !== 'string') continue
+          // a file the target copies into its bundle is linked wherever it
+          // lives, including a workspace package's folder outside the app.
+          const bundled = bundledByName.get(declaredFont)
           const candidates = [
             path.resolve(path.dirname(plistPath), declaredFont),
             path.resolve(iosDir, declaredFont),
           ]
-          const fontPath = candidates.find((candidate) => {
-            const relative = path.relative(selectedAppDir, candidate)
-            if (relative.startsWith('..') || path.isAbsolute(relative)) return false
-            return isFile(candidate)
-          })
+          const fontPath =
+            candidates.find((candidate) => {
+              const relative = path.relative(selectedAppDir, candidate)
+              if (relative.startsWith('..') || path.isAbsolute(relative)) return false
+              return isFile(candidate)
+            }) ?? (bundled && isFile(bundled) ? bundled : undefined)
           if (fontPath) fontPaths.push(fontPath)
         }
       }
@@ -382,7 +403,7 @@ export async function resolveMetroProjectRoot(bundleUrl: string): Promise<string
       signal: controller.signal,
     })
     if (res.ok) {
-      const manifest = (await res.json()) as {
+      const manifest = parseExpoManifestBody(await res.text()) as {
         extra?: { expoClient?: { _internal?: { projectRoot?: unknown } } }
       }
       servedManifest = true
@@ -448,7 +469,7 @@ export async function fetchAppFontFiles(
 ): Promise<FetchedAppFont[]> {
   const out: FetchedAppFont[] = []
   const seen = new Set<string>()
-  for (const url of appFontAssetUrlsFromWire(wire)) {
+  for (const url of appFontAssetUrlsFromWire(await resolveAppFontsWire(wire, fetch))) {
     const urlhash = createHash('sha256').update(url).digest('hex')
     if (seen.has(urlhash)) continue
     seen.add(urlhash)

package/cli/app-stubs.ts

@@ -3,7 +3,14 @@
 // packages, and a library's own `peach` field, lowered into the engine's
 // nativeModules / nativeViews wire slots.
 
-import { existsSync, readdirSync, readFileSync, realpathSync, statSync } from 'node:fs'
+import {
+  existsSync,
+  lstatSync,
+  readdirSync,
+  readFileSync,
+  realpathSync,
+  statSync,
+} from 'node:fs'
 import { dirname, join, relative, resolve } from 'node:path'
 import { resolveCompatVersionRange } from '@peach/compat/version-range'
 import { parseSync, type Expression } from 'oxc-parser'
@@ -19,7 +26,14 @@ import {
 } from '../src/config'
 import { isRecord } from '../src/is-record'
 import { visitParsedProgram } from '../src/visit-parsed-program'
-import { readProjectManifest, scanRepository } from './commands/detect'
+import {
+  readProjectManifest,
+  scanRepository,
+  metadataValue,
+  readProjectJson,
+} from './commands/detect'
+import type { ProjectManifest } from './commands/projectReportContract'
+import type { ScanResult } from '@peach/compat/web'
 
 // who answers a package, in rising precedence
 export type StubOrigin = 'library' | 'stub-package' | 'config'
@@ -125,7 +139,25 @@ export function resolveAppStubs(
       baseDir: dir,
     })
   }
-  for (const [target, stubs] of Object.entries(config?.packages ?? {})) {
+  const configuredPackages = Object.entries(config?.packages ?? {})
+  const packageNames = new Set<string>()
+  if (typeof manifest?.name === 'string') packageNames.add(manifest.name)
+  for (const [target] of configuredPackages) {
+    const dir = installedPackageDir(appDir, target)
+    if (dir && readPackageJson(dir)?.name === target) packageNames.add(target)
+  }
+  if (manifest && configuredPackages.some(([target]) => !packageNames.has(target))) {
+    for (const root of [appDir, ...workspacePackageDirs(appDir, manifest)])
+      for (const dir of scanRepository(root).directories) {
+        const name = readPackageJson(dir)?.name
+        if (typeof name === 'string') packageNames.add(name)
+      }
+  }
+  for (const [target, stubs] of configuredPackages) {
+    if (manifest && !packageNames.has(target))
+      throw new Error(
+        `packages[${JSON.stringify(target)}]: no installed or local package has this name; use the name from the package's package.json`,
+      )
     sources.push({
       target,
       origin: 'config',
@@ -368,12 +400,17 @@ export function wireSlotMigration(
       if (!owners.has(`${request.kind}:${request.name}`))
         owners.set(`${request.kind}:${request.name}`, name)
   }
-  // the app's own native code answers under its package name
-  if (typeof manifest?.name === 'string')
-    for (const request of packageNativeRequests(appDir))
+  if (manifest)
+    for (const request of scanLocalNative(
+      appDir,
+      manifest,
+      { module: new Set(), view: new Set() },
+      undefined,
+      new Set(),
+      true,
+    ))
       if (!owners.has(`${request.kind}:${request.name}`))
-        owners.set(`${request.kind}:${request.name}`, manifest.name)
-  const unknownOwner = '<package that asks for it>'
+        owners.set(`${request.kind}:${request.name}`, request.package)
   const blocks = new Map<string, { modules: string[]; views: string[] }>()
   const manual: string[] = []
   for (const [kind, entries] of [
@@ -395,7 +432,13 @@ export function wireSlotMigration(
         )
         continue
       }
-      const owner = owners.get(`${kind}:${name}`) ?? unknownOwner
+      const owner = owners.get(`${kind}:${name}`)
+      if (!owner) {
+        manual.push(
+          `${name}: no requesting package was found; find the package that requests this ${kind} before adding its packages entry`,
+        )
+        continue
+      }
       const block = blocks.get(owner) ?? { modules: [], views: [] }
       block[kind === 'module' ? 'modules' : 'views'].push(
         `[${JSON.stringify(name)}]: ${stub}`,
@@ -431,3 +474,175 @@ export function readSmallFile(file: string): string | null {
     return null
   }
 }
+
+export 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"')
+}
+
+// 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)$/
+export type AnsweredNames = Record<LocalNative['kind'], Set<string>>
+
+export function scanLocalNative(
+  appDir: string,
+  pkg: ProjectManifest,
+  answered: AnsweredNames,
+  platform: ScanResult['scoreSummary']['platform'] | undefined,
+  knownPackages: ReadonlySet<string> = new Set(),
+  includeLegacy = false,
+): LocalNative[] {
+  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 (platform && !hasNativeCode(dir, 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 = readPackageJson(dir)?.name
+    const parent = dirname(dir)
+    const result =
+      typeof name === 'string'
+        ? 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, includeLegacy))
+      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]
+}