peachsim 0.1.1625 → 0.1.1640

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

@@ -323,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
@@ -590,7 +599,11 @@ foreground or background state. Both retain its browser session and app state.
 `sourceApp` does not add fields to React Native's `{ url }` event. A
 stopped guest rejects URL delivery. Explicit `newInstance: true`, deletion,
 and video recording create a new browser context; cold launches still use the
-supplied shell URL. When synchronization is enabled, URL delivery waits for
+supplied shell URL. Process termination and `newInstance: true` preserve
+cookies, local storage and IndexedDB for the next launch. `delete: true` and
+driver cleanup clear that retained storage. Relaunch creates a fresh runtime,
+so input focus and other in-memory component state do not survive termination.
+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

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,18 +81,29 @@ 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')
     }
     const wire = WIRE_SLOTS.filter((slot) => loaded[slot] !== undefined)
     if (wire.length > 0) {
-      const migration = wireSlotMigration(project.appDir, {
-        modules: { ...loaded.turboModules, ...loaded.nativeModules },
-        views: { ...loaded.nativeViews },
-      })
+      const slots: readonly string[] = WIRE_SLOTS
+      const kept = Object.entries(loaded)
+        .filter(([key, value]) => !slots.includes(key) && value !== undefined)
+        .map(([key]) => key)
+      const migration = wireSlotMigration(
+        project.appDir,
+        project.configPath,
+        {
+          modules: { ...loaded.turboModules, ...loaded.nativeModules },
+          views: { ...loaded.nativeViews },
+        },
+        kept,
+      )
       throw new Error(
-        `${wire.join(', ')} moved under packages, keyed by the package whose native side they answer. replace them with:\n${migration}`,
+        `${wire.join(', ')} moved under packages, keyed by the package whose native side they answer. ${kept.length ? 'remove them and add' : 'replace the config with'}:\n${migration}`,
       )
     }
     return resolveConfigReplacementFiles(loaded, project.configPath)

package/cli/app-fonts.ts

@@ -7,7 +7,6 @@ import {
   resolveAppFontsWire,
   expoFontPathsFromPlugins,
   nativeLinkedFontSpecsFromPaths,
-  metroFontSpecsFromPaths,
   appFontAssetUrlsFromWire,
   type ConfigPluginFontSpec,
   type FontPlatform,
@@ -15,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,
@@ -31,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),
@@ -286,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'))
@@ -302,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)
         }
       }
@@ -383,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

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'
@@ -18,8 +25,16 @@ import {
   type PeachConfig,
 } from '../src/config'
 import { isRecord } from '../src/is-record'
+import { rnxPublicBrand } from '../src/public-brand'
 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 +140,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',
@@ -348,32 +381,73 @@ export function packageNativeRequests(dir: string): NativeRequest[] {
   )
 }
 
-// the `packages` block that replaces a config's old top-level wire slots: each
-// name keyed by the direct dependency whose JavaScript asks for it. `packages`
-// takes only 'noop' or a file path, so any other old value is named for a hand
-// move instead of guessed.
-export function wireSlotMigration(
+// the native names each installed dependency's own JavaScript asks for, keyed
+// `kind:name`. links to source outside node_modules are the app's own packages
+// and are scanned as app code instead.
+function dependencyNativeOwners(
   appDir: string,
-  wire: { modules: Record<string, unknown>; views: Record<string, unknown> },
-): string {
+  manifest: ProjectManifest | null,
+): Map<string, string> {
   const owners = new Map<string, string>()
-  const manifest = readProjectManifest(appDir)
   for (const name of Object.keys({
     ...manifest?.devDependencies,
     ...manifest?.dependencies,
   })) {
     const dir = installedPackageDir(appDir, name)
-    if (!dir) continue
+    if (!dir || !dir.split('/').includes('node_modules')) continue
     for (const request of packageNativeRequests(dir))
       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))
+  return owners
+}
+
+// a complete config module in the form the app's config file already uses, so
+// the printed text pastes over it
+function configModule(configPath: string | null, packages: string[]): string {
+  const body = ['  packages: {', ...packages, '  },']
+  if (
+    configPath &&
+    (configPath.endsWith('.cjs') ||
+      (configPath.endsWith('.js') &&
+        /\bmodule\.exports\b/.test(readSmallFile(configPath) ?? '')))
+  )
+    return ['module.exports = {', ...body, '}'].join('\n')
+  return [
+    `import { defineConfig } from '${rnxPublicBrand.packageName}/config'`,
+    '',
+    'export default defineConfig({',
+    ...body,
+    '})',
+  ].join('\n')
+}
+
+// what replaces a config's old top-level wire slots: each name keyed by the
+// package whose JavaScript asks for it. a config holding only those slots gets
+// a complete module; one with other settings (`kept`) gets just the packages
+// entries, since a whole module would drop them. `packages` takes only 'noop'
+// or a file path, so any other old value is named for a hand move instead of
+// guessed.
+export function wireSlotMigration(
+  appDir: string,
+  configPath: string | null,
+  wire: { modules: Record<string, unknown>; views: Record<string, unknown> },
+  kept: readonly string[] = [],
+): string {
+  const manifest = readProjectManifest(appDir)
+  const owners = dependencyNativeOwners(appDir, manifest)
+  if (manifest)
+    for (const request of scanLocalNative(
+      appDir,
+      manifest,
+      { module: new Set(), view: new Set() },
+      undefined,
+      new Set(),
+      true,
+      owners,
+    ))
       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 +469,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}`,
@@ -410,9 +490,17 @@ export function wireSlotMigration(
     ].filter(Boolean)
     return `    [${JSON.stringify(owner)}]: { ${parts.join(', ')} },`
   })
+  if (lines.length && kept.length)
+    return [
+      ...manual.map((line) => `// ${line}`),
+      `// keep ${kept.join(', ')}; merge these into packages`,
+      '  packages: {',
+      ...lines,
+      '  },',
+    ].join('\n')
   return [
-    ...(lines.length ? ['  packages: {', ...lines, '  },'] : []),
-    ...manual.map((line) => `  // ${line}`),
+    ...manual.map((line) => `// ${line}`),
+    ...(lines.length ? [configModule(configPath, lines)] : []),
   ].join('\n')
 }
 
@@ -431,3 +519,179 @@ 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,
+  providers?: ReadonlyMap<string, string>,
+): 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>()
+  // a name an installed dependency asks for belongs to that dependency, whoever
+  // in the app spells it out
+  const add = (kind: LocalNative['kind'], name: string, file: string, line: number) => {
+    const key = `${kind}:${name}`
+    if (found.has(key)) return
+    providers ??= dependencyNativeOwners(appDir, pkg)
+    const packageName = providers.get(key) ?? owner(dirname(file))
+    if (knownPackages.has(packageName)) 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]
+}