peachsim 0.1.1594 → 0.1.1619

package/README.md

@@ -12,7 +12,8 @@ drivers, and library exports; its only command, `npx peachsim`, runs that same
 installer from the copy of `install.sh` it ships.
 
 The executable updates itself with `peach upgrade`, which then restarts a running
-background daemon onto the new executable and runtime. Successful interactive human
+background daemon onto the new executable. A new runtime needs no restart: the
+next new sim opens on it while open sims keep theirs. Successful interactive human
 commands refresh a cached stable CLI version in a detached process at most once
 every 20 hours. A newer version produces one short notice on stderr, once per
 version and no more than weekly. CI, agents, JSON output, pipes, and
@@ -162,6 +163,11 @@ a local foreground bridge when no daemon is reachable, then opens a `WsBridge`
 `cli/commands/inspect/*` and are re-exported as the programmatic `peachsim/sdk`;
 the Maestro runner is `cli/bridge-flow-runner.ts`; the Detox compat driver
 is in `detox/`. Test and screenshot paths additionally use `cli/drivers/*`.
+Opening a simulator and waiting for reconnection share one app-tree readiness
+poller. Its nominal wait budget includes WebSocket handshakes, target lookup,
+evaluation and poll pauses; unanswered commands do not restart the deadline.
+A timeout reports the last node count, missing test hook or bridge error and
+elapsed time. Registering a simulator alone does not satisfy readiness.
 Browser sims launch in an isolated Playwright Chrome for Testing profile.
 An explicit `--base-url` keeps that shell's origin and uses its assets without
 installing an active runtime. A bridge started for that shell skips automatic
@@ -203,10 +209,12 @@ localhost. The `AgentHost` extension owns one FIFO reader per agent session and
 fans agent events out to every subscriber.
 
 `peach open` auto-installs a published runtime only when the runtime directory
-is empty. If runtime files exist without a selected runtime containing
-`index.html`, it refuses to open. Finish copying the runtime, then select it
-with `peach runtime use <version>`. Write the active marker after staging is
-complete when preparing an isolated home.
+is empty and no live bridge already owns the runtime. When a live bridge is
+performing its first download, `open` waits for that bridge's bootstrap state
+to finish, then uses its installed runtime. Without a live bridge, runtime
+files without a selected runtime containing `index.html` still cause a refusal.
+Finish copying the runtime, then select it with `peach runtime use <version>`.
+Write the active marker after staging is complete when preparing an isolated home.
 
 During source development, each Vite bridge owns one
 `~/.peach/dev-bridges/<port>.json` heartbeat record. CLI defaults select the
@@ -215,12 +223,13 @@ bridge, so concurrent worktrees cannot replace or delete one another's address.
 Each Vite shell also publishes its exact bridge at `/__sootsim/bridge`, so a
 launcher that reuses a shell from another isolated `PEACH_HOME` stays in that
 shell's bridge world without reading the other process's lockfile directory.
-An explicit `--port` also participates in `--sim` ownership discovery even
-without a local heartbeat record. The bridge must report that simulator as
-open; a port that names another simulator's world is rejected.
-SDK `connect({ sim })` and batched `do --then` actions use that same ownership
-discovery. An inferred default port does not override the named sim's world;
-an explicit SDK port or CLI `--port` retains the ownership check.
+An explicit CLI `--port` or SDK port connects directly to that bridge without
+scanning other worlds or requiring a local heartbeat record. That bridge handles
+the named sim and reports an error if it is absent.
+Without an explicit port, `--sim`, SDK `connect({ sim })`, and batched `do --then`
+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.
 
 **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
@@ -443,6 +452,7 @@ peach debug enable animated,layout
 peach debug trace shell on 240
 peach do tap-text "..." # interact
 peach do tap email --then type user@example.com --then tap submit
+peach shell window --x 120 --y 140 --scale fit # place/scale desktop sim window
 peach debug snapshot before
 peach debug snapshot after
 peach debug diff before after
@@ -551,6 +561,16 @@ peach detox            # auto-discovers e2e/ tests and launches a shell
 peach detox init       # scaffold a config + sample test
 ```
 
+`device.launchApp()` reuses a running guest by default. With a URL,
+`device.launchApp({ url })` and `device.openURL({ url })` deliver a Linking
+URL event to the running guest through the shell's deep-link bridge. Warm `launchApp` brings the guest forward; `openURL` retains its
+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
+existing work before dispatch and for navigation and painting afterward.
+
 See `../../docs/migrating-from-detox.md` for details.
 
 ## Coming from Maestro
@@ -604,6 +624,9 @@ the framed export inline without changing Maestro syntax:
 native content, a populated node tree, or a live-frame channel whose publish
 count advances across probes. Canvas-only GL, WebGPU, and video surfaces can
 therefore prove that they are painting without weakening the boot-card guard.
+A confirmed guest launch error ends readiness immediately, including waits longer
+than one bridge request. Loading and suppressed entry errors keep their existing
+readiness rules.
 
 ```yaml
 - takeScreenshot: hero

package/cli/app-catalog.ts

@@ -3,6 +3,7 @@ import path from 'node:path'
 import {
   enumerateBundleColors,
   enumerateBundleImages,
+  enumerateBundleSymbols,
 } from '../../sootsim-swift/src/bundleAssets'
 import type { AppCatalog } from 'peach-engine/engine/app-catalog-wire'
 
@@ -36,7 +37,7 @@ function catalogFiles(dir: string, found: string[]) {
   }
 }
 
-// the app's asset-catalog colors and images and its declared accent, read off
+// the app's asset-catalog colors, images, symbols and declared accent, read off
 // the ios project a prebuild or a bare app keeps on disk: the app target is
 // the folder holding the AppDelegate, the catalogs are its .xcassets, and the
 // accent is what its Info.plist or project build settings name. metro serves
@@ -65,9 +66,9 @@ export function discoverAppCatalog(
   const relative = files.map((file) =>
     path.relative(targetDir, file).split(path.sep).join(path.posix.sep),
   )
-  const readContents = (candidate: string) =>
-    candidate.endsWith('Contents.json') ? readText(path.join(targetDir, candidate)) : null
+  const readContents = (candidate: string) => readText(path.join(targetDir, candidate))
   const colors = enumerateBundleColors(relative, readContents)
+  const symbols = enumerateBundleSymbols(relative, readContents, () => '.')
   const served = path.relative(appDir, targetDir).split(path.sep).join(path.posix.sep)
   const images: AppCatalog['images'] = {}
   for (const { name, file, scale } of enumerateBundleImages(relative, readContents)) {
@@ -85,8 +86,9 @@ export function discoverAppCatalog(
   if (
     accentName === null &&
     Object.keys(colors).length === 0 &&
-    Object.keys(images).length === 0
+    Object.keys(images).length === 0 &&
+    Object.keys(symbols).length === 0
   )
     return null
-  return { colors, images, accentName }
+  return { colors, images, symbols, accentName }
 }

package/cli/app-config.ts

@@ -4,7 +4,7 @@ import * as peachConfigModule from '../src/config'
 import { isPeachConfig, type PeachConfig } from '../src/config'
 import { rnxPublicBrand } from '../src/public-brand'
 import { resolveAppProject, type ResolvedAppProject } from './app-project'
-import { resolveAppStubs, type AppStubs } from './app-stubs'
+import { resolveAppStubs, wireSlotMigration, type AppStubs } from './app-stubs'
 
 // `{ file }` entries are relative to the config file; the engine loads them by
 // absolute path from the runtime's replacement-module endpoint.
@@ -86,8 +86,12 @@ async function loadConfigFile(
     }
     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 },
+      })
       throw new Error(
-        `${wire.join(', ')} moved under packages, keyed by the package whose native side they answer: packages: { 'package-name': { modules: { Name: './stub.ts' }, views: { Name: './View.tsx' } } }`,
+        `${wire.join(', ')} moved under packages, keyed by the package whose native side they answer. replace them with:\n${migration}`,
       )
     }
     return resolveConfigReplacementFiles(loaded, project.configPath)

package/cli/app-fonts.ts

@@ -7,14 +7,20 @@ import {
   expoFontPathsFromPlugins,
   nativeLinkedFontSpecsFromPaths,
   metroFontSpecsFromPaths,
+  appFontAssetUrlsFromWire,
   type ConfigPluginFontSpec,
   type FontPlatform,
 } from 'peach-engine/engine/config-plugin-fonts'
 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 { stageHostFile } from '../src/host/staged-host-files'
 import { parsePlistSource } from '../src/plist.ts'
 import { resolveAppProject } from './app-project'
+import {
+  materialSymbolFontPaths,
+  materialSymbolFontAssets,
+} from './material-symbol-fonts'
 
 const require = createRequire(import.meta.url)
 
@@ -33,14 +39,20 @@ export function discoverNativeLinkedAppFonts(opts: {
   bundleUrl: string
   projectDir: string
   platform?: string
+  nativeAssetOrigin: string
 }): DiscoveredAppFontSpec[] {
   const metroOrigin = loopbackOriginOf(opts.bundleUrl)
   if (!metroOrigin) return []
-  return metroFontSpecsFromPaths(
-    projectRelativeFontPaths(opts.projectDir, discoverNativeLinkedAppFontPaths(opts)),
+  const { paths, materialSymbols } = discoverNativeLinkedAppFontAssets(opts)
+  const specs = metroFontSpecsFromPaths(
+    projectRelativeFontPaths(opts.projectDir, paths),
     metroOrigin,
     nativeFontPlatform(opts.platform),
   )
+  attachMaterialSymbolMetadata(specs, materialSymbols, (asset) =>
+    stageHostFile(asset, opts.nativeAssetOrigin),
+  )
+  return specs
 }
 
 function nativeFontPlatform(platform: string | undefined): FontPlatform {
@@ -49,10 +61,40 @@ function nativeFontPlatform(platform: string | undefined): FontPlatform {
     : 'ios'
 }
 
-function projectRelativeFontPaths(projectDir: string, fontPaths: string[]): string[] {
-  return fontPaths.map((fontPath) =>
-    path.relative(path.resolve(projectDir), fontPath).split(path.sep).join('/'),
+function attachMaterialSymbolMetadata(
+  specs: ConfigPluginFontSpec[],
+  files: ReturnType<typeof materialSymbolFontAssets>,
+  assetUrl: (filePath: string) => string,
+): void {
+  const first = specs.find(
+    (spec) =>
+      spec.family !== undefined &&
+      /^MaterialSymbols(?:Outlined|Rounded|Sharp)_/.test(spec.family),
   )
+  if (first && files)
+    first.materialSymbols = {
+      hash: files.hash,
+      codepointsUrl: assetUrl(files.codepointsPath),
+      mirroredUrl: assetUrl(files.mirroredPath),
+    }
+}
+
+function projectRelativeFontPaths(projectDir: string, fontPaths: string[]): string[] {
+  // metro resolves an asset path lexically against its project root and reads
+  // through symlinks, so a font declared inside the project keeps its declared
+  // path even when node_modules is a symlink to a shared install. a font that
+  // node resolved outside the project (a hoisted workspace or pnpm store) is
+  // named through its real location, in the namespace of the real project root.
+  const projectRoot = path.resolve(projectDir)
+  const realProjectRoot = fs.realpathSync(projectDir)
+  return fontPaths.map((fontPath) => {
+    const lexical = path.relative(projectRoot, fontPath)
+    const relative =
+      lexical.startsWith('..') || path.isAbsolute(lexical)
+        ? path.relative(realProjectRoot, fs.realpathSync(fontPath))
+        : lexical
+    return relative.split(path.sep).join('/')
+  })
 }
 
 function isFile(filePath: string): boolean {
@@ -64,13 +106,13 @@ function isFile(filePath: string): boolean {
 }
 
 // absolute paths of every existing font file the native app links.
-function discoverNativeLinkedAppFontPaths(opts: {
+function discoverNativeLinkedAppFontAssets(opts: {
   projectDir: string
   platform?: string
-}): string[] {
+}): { paths: string[]; materialSymbols?: ReturnType<typeof materialSymbolFontAssets> } {
   const project = resolveAppProject(opts.projectDir)
   const selectedAppDir = project?.appDir ?? null
-  if (!selectedAppDir) return []
+  if (!selectedAppDir) return { paths: [] }
 
   const platform = nativeFontPlatform(opts.platform)
 
@@ -105,6 +147,9 @@ function discoverNativeLinkedAppFontPaths(opts: {
     .slice(0, 256)
     .map((fontPath) => path.resolve(selectedAppDir, fontPath))
     .filter(isFile)
+  const materialFonts =
+    platform === 'android' ? materialSymbolFontPaths(selectedAppDir) : []
+  fontPaths.push(...materialFonts)
   // the walk is bounded by WORK, not by a clock: at most 64 readdirs, at most 64
   // queued dirs, 4 levels deep, 256 paths. those ceilings are what keep a stray
   // node_modules from being crawled, and no machine can blow through them. a
@@ -271,7 +316,10 @@ function discoverNativeLinkedAppFontPaths(opts: {
     } catch {}
   }
 
-  return [...new Set(fontPaths)]
+  return {
+    paths: [...new Set(fontPaths)],
+    materialSymbols: materialSymbolFontAssets(materialFonts),
+  }
 }
 
 // prebuilt guests cannot discover files linked into their native binary.
@@ -283,16 +331,23 @@ export function readNativeLinkedAppFontsWire(opts: {
   if (!resolveAppProject(opts.projectDir)) {
     throw new Error(`native font project is unavailable: ${opts.projectDir}`)
   }
-  return encodeAppFontsWire(
-    nativeLinkedFontSpecsFromPaths(
-      projectRelativeFontPaths(opts.projectDir, discoverNativeLinkedAppFontPaths(opts)),
-      nativeFontPlatform(opts.platform),
-      (fontPath) => {
-        const bytes = fs.readFileSync(path.resolve(opts.projectDir, fontPath))
-        return `data:${fontContentType(fontPath)};base64,${bytes.toString('base64')}`
-      },
-    ),
+  const projectDir = fs.realpathSync(opts.projectDir)
+  const { paths, materialSymbols } = discoverNativeLinkedAppFontAssets(opts)
+  const specs = nativeLinkedFontSpecsFromPaths(
+    projectRelativeFontPaths(projectDir, paths),
+    nativeFontPlatform(opts.platform),
+    (fontPath) => {
+      const bytes = fs.readFileSync(path.resolve(projectDir, fontPath))
+      return `data:${fontContentType(fontPath)};base64,${bytes.toString('base64')}`
+    },
+  )
+  attachMaterialSymbolMetadata(
+    specs,
+    materialSymbols,
+    (filePath) =>
+      `data:application/octet-stream;base64,${fs.readFileSync(filePath).toString('base64')}`,
   )
+  return encodeAppFontsWire(specs)
 }
 
 // resolve a metro dev server's project root. Expo's middleware advertises it
@@ -357,22 +412,6 @@ export async function resolveMetroProjectRoot(bundleUrl: string): Promise<string
   return pid === null ? null : resolveProcessCwd(pid)
 }
 
-export function parseAppFontUrls(wire: string): string[] {
-  const urls: string[] = []
-  for (const entry of wire.split(',')) {
-    const trimmed = entry.trim()
-    if (!trimmed) continue
-    const sep = trimmed.indexOf('::')
-    const urlPart = sep === -1 ? trimmed : trimmed.slice(0, sep)
-    try {
-      urls.push(decodeURIComponent(urlPart))
-    } catch {
-      urls.push(urlPart)
-    }
-  }
-  return urls.filter(Boolean)
-}
-
 // content type for a config-plugin font url, by extension. config fonts only
 // ever ship as ttf/otf/woff(2); fall back to octet-stream for anything else
 // so R2 still serves bytes the engine can register.
@@ -409,7 +448,7 @@ export async function fetchAppFontFiles(
 ): Promise<FetchedAppFont[]> {
   const out: FetchedAppFont[] = []
   const seen = new Set<string>()
-  for (const url of parseAppFontUrls(wire)) {
+  for (const url of appFontAssetUrlsFromWire(wire)) {
     const urlhash = createHash('sha256').update(url).digest('hex')
     if (seen.has(urlhash)) continue
     seen.add(urlhash)

package/cli/app-stubs.ts

@@ -6,15 +6,19 @@
 import { existsSync, 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'
+import { transform } from 'sucrase'
 import {
   isPackageStubs,
   type NativeModuleResolution,
   type NativeStub,
   type NativeViewResolution,
+  type NativeViewSource,
   type PackageStubs,
   type PeachConfig,
 } from '../src/config'
 import { isRecord } from '../src/is-record'
+import { visitParsedProgram } from '../src/visit-parsed-program'
 import { readProjectManifest, scanRepository } from './commands/detect'
 
 // who answers a package, in rising precedence
@@ -28,6 +32,7 @@ export interface AppliedStubs {
   providerVersion: string | null
   modules: string[]
   views: string[]
+  viewSources?: Record<string, NativeViewSource>
 }
 
 // a published stub whose `versions` range excludes the installed target
@@ -141,7 +146,8 @@ export function resolveAppStubs(
     for (const [name, stub] of Object.entries(modules))
       nativeModules[name] = lowerStub(stub, source.baseDir)
     for (const [name, stub] of Object.entries(views))
-      nativeViews[name] = lowerStub(stub, source.baseDir)
+      nativeViews[name] =
+        typeof stub === 'string' ? lowerStub(stub, source.baseDir) : stub
     applied.push({
       target: source.target,
       origin: source.origin,
@@ -149,6 +155,16 @@ export function resolveAppStubs(
       providerVersion: source.providerVersion,
       modules: Object.keys(modules),
       views: Object.keys(views),
+      ...(Object.values(views).some((value) => typeof value !== 'string')
+        ? {
+            viewSources: Object.fromEntries(
+              Object.entries(views).filter(
+                (entry): entry is [string, NativeViewSource] =>
+                  typeof entry[1] !== 'string',
+              ),
+            ),
+          }
+        : {}),
     })
   }
   const stubs = { applied, skipped }
@@ -162,7 +178,10 @@ export function resolveAppStubs(
 function expandStubs(
   appDir: string,
   source: StubSource,
-): { modules: Record<string, NativeStub>; views: Record<string, NativeStub> } {
+): {
+  modules: Record<string, NativeStub>
+  views: Record<string, NativeStub | NativeViewSource>
+} {
   if (source.stubs !== 'noop')
     return { modules: source.stubs.modules ?? {}, views: source.stubs.views ?? {} }
   const dir = installedPackageDir(appDir, source.target)
@@ -212,34 +231,85 @@ export interface NativeRequest {
 }
 
 export const SOURCE_FILE = /\.[cm]?[jt]sx?$/
-export const NATIVE_LOOKUP = /requireNative|TurboModuleRegistry|codegenNativeComponent/
-// a requireNativeView(module, view) name is `module_view`, the key the engine
-// registers expo views under.
-export const LOOKUPS: { kind: NativeRequest['kind']; pattern: RegExp }[] = [
-  {
-    kind: 'view',
-    pattern: /\brequireNativeComponent\s*(?:<[^;]{0,200}?>)?\(\s*['"]([\w$.-]+)['"]/g,
-  },
-  {
-    kind: 'view',
-    pattern:
-      /\brequireNativeView(?:Manager)?\s*(?:<[^;]{0,200}?>)?\(\s*['"](\w+)['"]\s*(?:,\s*['"](\w+)['"])?/g,
-  },
-  {
-    kind: 'view',
-    pattern: /\bcodegenNativeComponent\s*(?:<[^;]{0,200}?>)?\(\s*['"](\w+)['"]/g,
-  },
-  {
-    kind: 'module',
-    pattern:
-      /\brequire(?:Optional)?NativeModule\s*(?:<[^;]{0,200}?>)?\(\s*['"](\w+)['"]/g,
-  },
-  {
-    kind: 'module',
-    pattern:
-      /\bTurboModuleRegistry\.get(?:Enforcing)?\s*(?:<[^;]{0,200}?>)?\(\s*['"](\w+)['"]/g,
-  },
-]
+const NATIVE_LOOKUP =
+  /requireNative|requireOptionalNative|TurboModuleRegistry|codegenNativeComponent|NativeModules/
+
+function nativeLookupName(node: Expression): string | null {
+  if (node.type === 'Identifier') return node.name
+  if (
+    node.type === 'MemberExpression' &&
+    !node.computed &&
+    node.property.type === 'Identifier'
+  )
+    return node.property.name
+  return null
+}
+
+// sucrase removes flow and typescript types while retaining source lines. oxc
+// then visits executable syntax, including expressions inside template literals,
+// without interpreting comments, fixture strings or type queries as requests.
+export function sourceNativeRequests(
+  file: string,
+  text: string,
+  includeLegacy = false,
+): (NativeRequest & { line: number })[] {
+  if (!NATIVE_LOOKUP.test(text)) return []
+  let code: string
+  try {
+    code = transform(text, {
+      transforms: [/\.[cm]?tsx?$/.test(file) ? 'typescript' : 'flow', 'jsx'],
+      disableESTransforms: true,
+    }).code
+  } catch {
+    return []
+  }
+  const { program, errors } = parseSync(file, code, { lang: 'jsx' })
+  if (errors.length) return []
+  const found: (NativeRequest & { line: number })[] = []
+  const add = (kind: NativeRequest['kind'], name: string, at: number) => {
+    found.push({ kind, name, line: code.slice(0, at).split('\n').length })
+  }
+  visitParsedProgram(program, {
+    CallExpression(node) {
+      const first = node.arguments[0]
+      if (first?.type !== 'Literal' || typeof first.value !== 'string') return
+      const callee = node.callee
+      const lookup = nativeLookupName(callee)
+      if (
+        callee.type === 'MemberExpression' &&
+        !callee.computed &&
+        nativeLookupName(callee.object) === 'TurboModuleRegistry' &&
+        (lookup === 'get' || lookup === 'getEnforcing')
+      ) {
+        add('module', first.value, node.start)
+      } else if (lookup) {
+        if (['requireNativeModule', 'requireOptionalNativeModule'].includes(lookup))
+          add('module', first.value, node.start)
+        else if (['requireNativeComponent', 'codegenNativeComponent'].includes(lookup))
+          add('view', first.value, node.start)
+        else if (['requireNativeView', 'requireNativeViewManager'].includes(lookup)) {
+          const second = node.arguments[1]
+          // expo registers a named view under the module_view key.
+          const name =
+            second?.type === 'Literal' && typeof second.value === 'string'
+              ? `${first.value}_${second.value}`
+              : first.value
+          add('view', name, node.start)
+        }
+      }
+    },
+    MemberExpression(node) {
+      if (
+        includeLegacy &&
+        !node.computed &&
+        nativeLookupName(node.object) === 'NativeModules' &&
+        node.property.type === 'Identifier'
+      )
+        add('module', node.property.name, node.start)
+    },
+  })
+  return found
+}
 
 // the native names a package's own JavaScript asks for, outside its native
 // sources (top-level ios and android; src/ios is JavaScript), tests and examples
@@ -251,7 +321,6 @@ const PACKAGE_SKIP_DIRS = new Set([
   '__mocks__',
   'docs',
 ])
-const LEGACY_NATIVE_MODULE = /\bNativeModules\s*\.\s*(\w+)/g
 
 export function packageNativeRequests(dir: string): NativeRequest[] {
   const found = new Map<string, NativeRequest>()
@@ -267,17 +336,11 @@ export function packageNativeRequests(dir: string): NativeRequest[] {
     for (const name of listDir(sub)) {
       if (!SOURCE_FILE.test(name) || name.endsWith('.d.ts') || files >= 2_000) continue
       files++
-      const text = readSmallFile(join(sub, name))
-      if (!text || !(NATIVE_LOOKUP.test(text) || text.includes('NativeModules'))) continue
-      for (const { kind, pattern } of [
-        ...LOOKUPS,
-        { kind: 'module' as const, pattern: LEGACY_NATIVE_MODULE },
-      ]) {
-        for (const match of text.matchAll(pattern)) {
-          const request = match[2] ? `${match[1]}_${match[2]}` : match[1]
-          if (request) found.set(`${kind}:${request}`, { kind, name: request })
-        }
-      }
+      const file = join(sub, name)
+      const text = readSmallFile(file)
+      if (!text) continue
+      for (const { kind, name } of sourceNativeRequests(file, text, true))
+        found.set(`${kind}:${name}`, { kind, name })
     }
   }
   return [...found.values()].sort(
@@ -285,6 +348,74 @@ 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(
+  appDir: string,
+  wire: { modules: Record<string, unknown>; views: Record<string, unknown> },
+): 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
+    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))
+      if (!owners.has(`${request.kind}:${request.name}`))
+        owners.set(`${request.kind}:${request.name}`, manifest.name)
+  const unknownOwner = '<package that asks for it>'
+  const blocks = new Map<string, { modules: string[]; views: string[] }>()
+  const manual: string[] = []
+  for (const [kind, entries] of [
+    ['module', wire.modules],
+    ['view', wire.views],
+  ] as const) {
+    for (const [name, value] of Object.entries(entries)) {
+      const stub =
+        value === 'noop'
+          ? JSON.stringify(value)
+          : isRecord(value) &&
+              typeof value.file === 'string' &&
+              Object.keys(value).length === 1
+            ? JSON.stringify(value.file)
+            : null
+      if (!stub) {
+        manual.push(
+          `${name}: packages takes 'noop' or a file path; move this ${kind} into a file that default-exports it and name that file`,
+        )
+        continue
+      }
+      const owner = owners.get(`${kind}:${name}`) ?? unknownOwner
+      const block = blocks.get(owner) ?? { modules: [], views: [] }
+      block[kind === 'module' ? 'modules' : 'views'].push(
+        `[${JSON.stringify(name)}]: ${stub}`,
+      )
+      blocks.set(owner, block)
+    }
+  }
+  const lines = [...blocks].map(([owner, { modules, views }]) => {
+    const parts = [
+      modules.length ? `modules: { ${modules.join(', ')} }` : '',
+      views.length ? `views: { ${views.join(', ')} }` : '',
+    ].filter(Boolean)
+    return `    [${JSON.stringify(owner)}]: { ${parts.join(', ')} },`
+  })
+  return [
+    ...(lines.length ? ['  packages: {', ...lines, '  },'] : []),
+    ...manual.map((line) => `  // ${line}`),
+  ].join('\n')
+}
+
 export function listDir(dir: string): string[] {
   try {
     return readdirSync(dir)

package/cli/bin.ts

@@ -13,6 +13,15 @@
 import { exitWithFlushedOutput } from '../src/process-output'
 import { RNX_FORKED_SCRIPT_ENV, RNX_INTERNAL_COMMAND } from './internal-child'
 
+// a consumer such as head may close its pipe before the command finishes.
+// exit directly: reporting this through stderr can fail on the same pipe.
+for (const stream of [process.stdout, process.stderr]) {
+  stream.on('error', (error: NodeJS.ErrnoException) => {
+    if (error.code === 'EPIPE') process.exit(1)
+    throw error
+  })
+}
+
 if (process.argv[2] === '__shell-init') {
   const { renderRnxShellInit } = await import('./shell-init')
   try {