peachsim 0.1.1625 → 0.1.1635

package/src/expo-swift-host.ts

@@ -9,6 +9,7 @@ import path from 'node:path'
 import { promisify } from 'node:util'
 import { RNX_FORKED_SCRIPT_ENV } from '../cli/internal-child'
 import { isLoopbackHost } from './backend-origin'
+import { collectBridgeModuleSources } from './react-native-bridge-modules'
 import { swiftBinaryModules } from './swift-binary-modules'
 import {
   swiftAvailableModules,
@@ -24,7 +25,7 @@ import {
   icuUrl,
   projectFor,
   serveSwiftPackageAsset,
-  sourceStamp,
+  sourceContentStamp,
   standinLibraries,
   SwiftMissingModulesError,
 } from './swift-host'
@@ -48,6 +49,37 @@ const run = promisify(execFile)
 const scriptEnv = { ...process.env, [RNX_FORKED_SCRIPT_ENV]: '1' }
 export const EXPO_SWIFT_ROUTE = '/__peach/expo-swift'
 export const EXPO_SWIFT_ENTRY = 'Sources/PeachExpoApp/PeachExpoEntry.swift'
+// a connected caller (the conformance waiter) waits this long. the old 10
+// minute cap aborted a compile that caller was still holding.
+const EXPO_SWIFT_REQUEST_TIMEOUT_MS = 30 * 60_000
+// bun drops an unanswered fetch at six minutes and the waiter retries. aborting
+// in that gap restarts the compile. a reconnect inside this window rejoins it.
+const EXPO_SWIFT_CLIENT_GAP_MS = 5_000
+
+// the autolinker's command line changed across Expo releases: before 1.8.0 it
+// takes the project from its working directory, before 1.10.3 the Apple
+// platform is named `ios`.
+function autolinkerAppleFlags(autolinkerManifest: string, appRoot: string) {
+  const manifest: unknown = JSON.parse(fs.readFileSync(autolinkerManifest, 'utf8'))
+  const version =
+    manifest && typeof manifest === 'object' && Reflect.get(manifest, 'version')
+  const parts =
+    typeof version === 'string'
+      ? version.split('.').map((part) => Number.parseInt(part, 10))
+      : []
+  const [major, minor, patch] = parts
+  if (!Number.isInteger(major) || !Number.isInteger(minor) || !Number.isInteger(patch))
+    throw new Error(
+      `unreadable expo-modules-autolinking version in ${autolinkerManifest}`,
+    )
+  const atLeast = (m: number, n: number, p: number) =>
+    major !== m ? major > m : minor !== n ? minor > n : patch >= p
+  if (atLeast(1, 10, 3))
+    return { args: ['--platform', 'apple', '--project-root', appRoot], cwd: undefined }
+  if (atLeast(1, 8, 0))
+    return { args: ['--platform', 'ios', '--project-root', appRoot], cwd: undefined }
+  return { args: ['--platform', 'ios'], cwd: appRoot }
+}
 
 export async function collectExpoSwiftSources(
   appRoot: string,
@@ -68,23 +100,25 @@ export async function collectExpoSwiftSources(
       return null
     throw error
   }
+  // autolinkers before 1.0 predate app-owned Swift modules and `--project-root`.
+  const autolinkerVersion: unknown = JSON.parse(
+    fs.readFileSync(autolinker, 'utf8'),
+  ).version
+  if (typeof autolinkerVersion === 'string' && Number.parseInt(autolinkerVersion, 10) < 1)
+    return null
+  const cli = path.join(path.dirname(autolinker), 'bin/expo-modules-autolinking.js')
+  const flags = autolinkerAppleFlags(autolinker, appRoot)
   // both upstream commands discover their inputs independently. settle both
   // before propagating errors so a failed request leaves no child running.
   const [searched, resolvedModules] = await Promise.allSettled(
     ['search', 'resolve'].map((command) =>
-      run(
-        process.execPath,
-        [
-          path.join(path.dirname(autolinker), 'bin/expo-modules-autolinking.js'),
-          command,
-          '--platform',
-          'apple',
-          '--project-root',
-          appRoot,
-          '--json',
-        ],
-        { timeout: 30_000, maxBuffer: 8 * 1024 * 1024, env: scriptEnv, signal },
-      ),
+      run(process.execPath, [cli, command, ...flags.args, '--json'], {
+        timeout: 120_000,
+        maxBuffer: 8 * 1024 * 1024,
+        env: scriptEnv,
+        cwd: flags.cwd,
+        signal,
+      }),
     ),
   )
   if (searched.status === 'rejected') throw searched.reason
@@ -226,10 +260,11 @@ export async function collectExpoSwiftSources(
     }
     walk(ios)
     for (const module of classes) {
-      const unit = {
+      const unit: ExpoSwiftSourceUnit = {
         namespace,
         moduleId: `${namespace}.${module.name}`,
         classes: [module.registration],
+        bridgeModules: [],
         files: swiftSourceClosure(files, [module.name]),
         frameworks: [...frameworks],
       }
@@ -282,7 +317,12 @@ export async function collectExpoSwiftSources(
   return units
 }
 
-function expoManifest(files: Record<string, string>, generation = ''): string {
+// an app target's Swift compiles in its own language mode; Expo packages in the default
+function expoManifest(
+  files: Record<string, string>,
+  generation = '',
+  modes: Map<string, number> = new Map(),
+): string {
   const targets = new Map<string, string>()
   for (const file of Object.keys(files)) {
     const match = /^(Sources|__standins__)\/([^/]+)\//.exec(file)
@@ -292,11 +332,29 @@ function expoManifest(files: Record<string, string>, generation = ''): string {
       throw new Error(`duplicate Expo Swift compile target ${match[2]}`)
     targets.set(match[2]!, dir)
   }
-  return `// swift-tools-version: 6.0\nimport PackageDescription\nlet package = Package(name: "PeachExpo", targets: [${[...targets].map(([name, dir]) => `.target(name: ${JSON.stringify(name)}, path: ${JSON.stringify(dir)}${dir.startsWith(`${SWIFT_STANDINS_DIR}/`) ? ', swiftSettings: [.swiftLanguageMode(.v5)]' : ''})`).join(', ')}, .executableTarget(name: "PeachExpoApp", path: "Sources/PeachExpoApp")])\n// stand-in inputs: ${generation}\n`
+  return `// swift-tools-version: 6.0\nimport PackageDescription\nlet package = Package(name: "PeachExpo", targets: [${[...targets].map(([name, dir]) => `.target(name: ${JSON.stringify(name)}, path: ${JSON.stringify(dir)}${dir.startsWith(`${SWIFT_STANDINS_DIR}/`) ? ', swiftSettings: [.swiftLanguageMode(.v5)]' : modes.has(name) ? `, swiftSettings: [.swiftLanguageMode(.v${modes.get(name)})]` : ''})`).join(', ')}, .executableTarget(name: "PeachExpoApp", path: "Sources/PeachExpoApp")])\n// stand-in inputs: ${generation}\n`
+}
+
+function languageModes(units: ExpoSwiftSourceUnit[]): Map<string, number> {
+  return new Map(
+    units.flatMap((unit) =>
+      unit.swiftLanguageMode === undefined
+        ? []
+        : [[unit.namespace, unit.swiftLanguageMode]],
+    ),
+  )
 }
 
 function expoEntry(units: ExpoSwiftSourceUnit[]): string {
-  return `import SwiftUI\nimport ExpoModulesCore\n${[...new Set(units.map((unit) => unit.namespace))].map((namespace) => `import ${namespace}`).join('\n')}\n\n@main struct PeachExpoApp: PeachPackage {\n  init() { MainActor.assumeIsolated { PeachExpoRuntime.register([${units.flatMap((unit) => unit.classes).join(', ')}]) } }\n  func view(props: JSON) -> PeachExpoNativeView { PeachExpoNativeView(props: props) }\n}\n\n@_expose(wasm, "peach_expo_call")\n@_cdecl("peach_expo_call")\n@MainActor public func peachExpoCall(_ payload: UnsafePointer<UInt8>?, _ length: Int32) -> UnsafeMutablePointer<UInt8>? {\n  PeachExpoRuntime.dispatch(payload, length)\n}\n`
+  // an Objective-C bridge module registers with no Swift of its own
+  const namespaces = [...new Set(units.map((unit) => unit.namespace))].filter(
+    (namespace) =>
+      units.some((unit) =>
+        Object.keys(unit.files).some((file) => file.startsWith(`Sources/${namespace}/`)),
+      ),
+  )
+  const bridgeModules = units.flatMap((unit) => unit.bridgeModules)
+  return `import SwiftUI\nimport ExpoModulesCore\n${bridgeModules.length ? 'import React\n' : ''}${namespaces.map((namespace) => `import ${namespace}`).join('\n')}\n\n@main struct PeachExpoApp: PeachPackage {\n  init() { MainActor.assumeIsolated { PeachExpoRuntime.register([${units.flatMap((unit) => unit.classes).join(', ')}])${bridgeModules.length ? `; RCTModuleHost.register([${bridgeModules.join(', ')}])` : ''} } }\n  func view(props: JSON) -> PeachExpoNativeView { PeachExpoNativeView(props: props) }\n}\n\n@_expose(wasm, "peach_expo_call")\n@_cdecl("peach_expo_call")\n@MainActor public func peachExpoCall(_ payload: UnsafePointer<UInt8>?, _ length: Int32) -> UnsafeMutablePointer<UInt8>? {\n  PeachExpoRuntime.dispatch(payload, length)\n}\n`
 }
 
 const compiling = new Map<
@@ -307,12 +365,41 @@ const compiling = new Map<
     clients: number
   }
 >()
+// identical sources already produced a wasm that is still registered on its
+// project. a second caller otherwise relinks namespaces whose failure records
+// did not stick, and that link blows the flow's ready bound.
+const preparedExpoSwift = new Map<string, ExpoSwiftCompilationResult>()
+
+function expoSwiftPreparedKey(base: string, units: ExpoSwiftSourceUnit[]): string {
+  const hash = createHash('sha256')
+  hash.update(base)
+  for (const unit of units) {
+    hash.update('\0')
+    hash.update(unit.moduleId)
+    for (const name of Object.keys(unit.files).sort()) {
+      hash.update('\0')
+      hash.update(name)
+      hash.update('\0')
+      hash.update(unit.files[name] ?? '')
+    }
+  }
+  return hash.digest('hex')
+}
+
+// this process's copy of the app's expo sources. the build key covers the
+// same directory, so another server compiling the app keeps its own tree.
+function expoSwiftPackage(appKey: string, name: string): string {
+  return path.join(os.tmpdir(), 'peach-expo-swift', appKey, `p${process.pid}`, name)
+}
+
 class ExpoSwiftLinkRefusal extends Error {}
 // a failed compiler result is valid only for the exact app and framework inputs.
-// it is kept beside the namespace's build tree, so a restarted dev server skips
-// the namespace instead of relinking every namespace and isolating each again.
+// it is kept at the app level, above each process's build copy, so a restarted
+// dev server skips the namespace instead of relinking every namespace and
+// isolating each again.
 function failureRecordPath(packagePath: string) {
-  return `${packagePath}.failed.json`
+  const app = path.dirname(path.dirname(packagePath))
+  return path.join(app, `${path.basename(packagePath)}.failed.json`)
 }
 
 function readFailedCompilation(packagePath: string) {
@@ -350,7 +437,9 @@ export async function compileExpoSwiftModules(
   ) => Promise<void>,
   options: ExpoSwiftPreparationOptions = {},
 ): Promise<ExpoSwiftCompilationResult | null> {
-  const timeoutMs = options.timeoutMs ?? 600_000
+  // a cold isolation compiles the sdk once per module. one module ran past
+  // six minutes, and the readiness wait allows thirty, so the compile does too.
+  const timeoutMs = options.timeoutMs ?? 30 * 60_000
   if (!Number.isSafeInteger(timeoutMs) || timeoutMs <= 0 || timeoutMs > 2_147_483_647)
     throw new Error('Expo Swift preparation timeout must be between 1 and 2147483647ms')
   const controller = new AbortController()
@@ -367,9 +456,20 @@ export async function compileExpoSwiftModules(
   try {
     signal.throwIfAborted()
     report(`discovering app-owned modules (budget ${timeoutMs}ms): ${root}`)
-    const units = await collectExpoSwiftSources(root, signal)
+    const expoUnits = await collectExpoSwiftSources(root, signal)
     signal.throwIfAborted()
-    if (!units) return null
+    const bridge = collectBridgeModuleSources(fs.realpathSync(root), signal)
+    for (const unit of bridge?.units ?? []) {
+      if (expoUnits?.some((expo) => expo.namespace === unit.namespace))
+        throw new Error(
+          `app target ${unit.namespace} shares its Swift module name with a local Expo module`,
+        )
+      unit.files[EXPO_SWIFT_ENTRY] = expoEntry([unit])
+      unit.files['Package.swift'] = expoManifest(unit.files, '', languageModes([unit]))
+    }
+    const units = [...(expoUnits ?? []), ...(bridge?.units ?? [])]
+    const bridgeFailures = bridge?.failures ?? []
+    if (units.length === 0 && bridgeFailures.length === 0) return null
     report(
       `preparing ${units.length} modules: ${units.map((unit) => unit.moduleId).join(', ')}`,
     )
@@ -380,9 +480,16 @@ export async function compileExpoSwiftModules(
     if (!module && publishArtifact)
       throw new Error('No local Swift toolchain or distribution is available')
     const result: ExpoSwiftCompilationResult = {
-      namespaces: units.map((unit) => unit.moduleId),
+      namespaces: [
+        ...units.map((unit) => unit.moduleId),
+        ...bridgeFailures.map((failure) => failure.namespace),
+      ],
+      bridgeModules: [
+        ...(bridge?.units ?? []).map((unit) => unit.moduleId),
+        ...bridgeFailures.map((failure) => failure.namespace),
+      ],
       modules: [],
-      failures: [],
+      failures: [...bridgeFailures],
     }
     if (!module) {
       for (const unit of units)
@@ -475,10 +582,14 @@ export async function compileExpoSwiftModules(
             unit,
             [...built.gaps].map(([name, reason]) => `${name}: no stand-in: ${reason}`),
           )
-          unit.files['Package.swift'] = expoManifest(unit.files, generation)
+          unit.files['Package.swift'] = expoManifest(
+            unit.files,
+            generation,
+            languageModes([unit]),
+          )
         }
       }
-      const packagePath = path.join(os.tmpdir(), 'peach-expo-swift', key, unit.moduleId)
+      const packagePath = expoSwiftPackage(key, unit.moduleId)
       // preserve the compiler's input stamp across unchanged reloads.
       // only this adapter's build copy is synchronized; app sources are read only.
       syncSwiftTree(
@@ -491,7 +602,7 @@ export async function compileExpoSwiftModules(
         ),
       )
       projectFor(packagePath).libraries = libraries.get(unit)
-      const stamp = sourceStamp(packagePath, module.root)
+      const stamp = sourceContentStamp(packagePath, module.root)
       const failed = readFailedCompilation(packagePath)
       if (failed?.stamp === stamp) {
         failures.set(unit.moduleId, failed.diagnostic)
@@ -501,6 +612,14 @@ export async function compileExpoSwiftModules(
       stamps.set(unit, stamp)
       candidates.push(unit)
     }
+    const preparedKey = expoSwiftPreparedKey(base, units)
+    if (!publishArtifact) {
+      const prepared = preparedExpoSwift.get(preparedKey)
+      if (prepared) {
+        report('reusing prepared expo swift artifact')
+        return prepared
+      }
+    }
     const link = async (linked: ExpoSwiftSourceUnit[]) => {
       const files: Record<string, string> = {}
       for (const unit of linked)
@@ -517,8 +636,9 @@ export async function compileExpoSwiftModules(
       files['Package.swift'] = expoManifest(
         files,
         linked.map((unit) => generations.get(unit) ?? '').join(','),
+        languageModes(linked),
       )
-      const packagePath = path.join(os.tmpdir(), 'peach-expo-swift', key, 'linked-app')
+      const packagePath = expoSwiftPackage(key, 'linked-app')
       syncSwiftTree(
         packagePath,
         new Map(
@@ -538,7 +658,7 @@ export async function compileExpoSwiftModules(
       projectFor(packagePath).libraries =
         linkedLibraries.size > 0 ? Object.fromEntries(linkedLibraries) : undefined
       signal.throwIfAborted()
-      const stamp = sourceStamp(packagePath, module.root)
+      const stamp = sourceContentStamp(packagePath, module.root)
       const refused = readFailedCompilation(packagePath)
       if (refused?.stamp === stamp) {
         report('reusing recent link refusal')
@@ -563,7 +683,7 @@ export async function compileExpoSwiftModules(
           throw error
         // admission and interrupted builds say nothing about individual modules.
         // share their result briefly, including across dev server restarts.
-        if (sourceStamp(packagePath, module.root) === stamp)
+        if (sourceContentStamp(packagePath, module.root) === stamp)
           failureRecords.set(packagePath, {
             stamp,
             diagnostic,
@@ -587,12 +707,7 @@ export async function compileExpoSwiftModules(
           report('linked build failed; isolating module diagnostics')
           linked = []
           for (const unit of candidates) {
-            const packagePath = path.join(
-              os.tmpdir(),
-              'peach-expo-swift',
-              key,
-              unit.moduleId,
-            )
+            const packagePath = expoSwiftPackage(key, unit.moduleId)
             try {
               signal.throwIfAborted()
               report(`checking ${unit.moduleId}`)
@@ -630,13 +745,14 @@ export async function compileExpoSwiftModules(
               )
                 throw error
               // a source error or a module peach does not provide holds until the
-              // stamp changes; retrying either relinks every namespace and rewrites
-              // the linked package, so no reload would ever reuse its artifact.
+              // stamp changes. the compiler also reports the same error at the
+              // build copy, so the app lines are enough to hold it. retrying
+              // either relinks every namespace and rewrites the linked package,
+              // so no reload would ever reuse its artifact.
               const missing = error instanceof SwiftMissingModulesError
               if (
-                ((sourceErrors.length && sourceErrors.length === errors.length) ||
-                  missing) &&
-                sourceStamp(packagePath, module.root) === stamps.get(unit)
+                (missing || sourceErrors.length > 0) &&
+                sourceContentStamp(packagePath, module.root) === stamps.get(unit)
               ) {
                 failureRecords.set(packagePath, {
                   stamp: stamps.get(unit)!,
@@ -651,7 +767,29 @@ export async function compileExpoSwiftModules(
           }
           // every namespace compiles alone, so the link itself is what failed.
           if (linked.length === candidates.length) throw linkError
-          if (linked.length) artifact = await link(linked)
+          if (linked.length) {
+            try {
+              artifact = await link(linked)
+            } catch (error) {
+              signal.throwIfAborted()
+              if (!(error instanceof SwiftMissingModulesError)) throw error
+              // the merged sources import a module none of the pieces needed
+              // alone. drop the pieces that import it and link the rest; a
+              // miss that none of them import is still a failed link.
+              const missing = new Set(
+                [...error.message.matchAll(/^  (\S+)/gm)].map((match) => match[1]),
+              )
+              const dropped = linked.filter((unit) =>
+                Object.values(unit.files).some((source) =>
+                  swiftImportNames(source).some((name) => missing.has(name)),
+                ),
+              )
+              if (dropped.length === 0) throw error
+              for (const unit of dropped) failures.set(unit.moduleId, error.message)
+              linked = linked.filter((unit) => !dropped.includes(unit))
+              if (linked.length) artifact = await link(linked)
+            }
+          }
         }
       }
     }
@@ -677,6 +815,7 @@ export async function compileExpoSwiftModules(
     report(
       `ready: ${result.modules.length} artifact, ${result.failures.length} unavailable modules`,
     )
+    if (!publishArtifact) preparedExpoSwift.set(preparedKey, result)
     return result
   } catch (error) {
     const failure: unknown = signal.aborted ? signal.reason : error
@@ -746,6 +885,7 @@ export async function handleExpoSwiftRequest(
     const controller = new AbortController()
     const promise = compileExpoSwiftModules(key, `http://${host}`, undefined, {
       signal: controller.signal,
+      timeoutMs: EXPO_SWIFT_REQUEST_TIMEOUT_MS,
     }).finally(() => {
       if (compiling.get(flightKey)?.controller === controller) compiling.delete(flightKey)
     })
@@ -758,9 +898,13 @@ export async function handleExpoSwiftRequest(
   const release = () => {
     if (released) return
     released = true
-    if (--current.clients === 0) {
-      current.controller.abort(new Error('Expo Swift preparation client disconnected'))
-    }
+    if (--current.clients > 0) return
+    const flight = current
+    setTimeout(() => {
+      if (flight.clients > 0 || flight.controller.signal.aborted) return
+      if (compiling.get(flightKey)?.controller !== flight.controller) return
+      flight.controller.abort(new Error('Expo Swift preparation client disconnected'))
+    }, EXPO_SWIFT_CLIENT_GAP_MS)
   }
   res.once('close', release)
   try {

package/src/expo-swift-ready.ts

@@ -0,0 +1,78 @@
+// an app with local Expo Swift modules only renders once the bridge compiles
+// them, and a cold /__peach/expo-swift artifact compiles for minutes (a linked
+// build plus per-namespace isolation builds in sequence) while a flow waits
+// 120s for its first tree. so `peach open` GETs the same endpoint the engine
+// will fetch and returns only once it answers; the bridge shares one compile
+// per root, so the engine's own fetch then finds it done. a warm artifact
+// answers in ~1s and an app without local modules answers null fast.
+export const EXPO_SWIFT_READY_TIMEOUT_MS = 30 * 60_000
+const EXPO_SWIFT_READY_PROGRESS_MS = 30_000
+
+export type ExpoSwiftReadyOptions = {
+  timeoutMs?: number
+  progressMs?: number
+  signal?: AbortSignal
+  onProgress?: (elapsedMs: number) => void
+}
+
+export async function awaitExpoSwiftReady(
+  endpointUrl: string,
+  options: ExpoSwiftReadyOptions = {},
+): Promise<void> {
+  const timeoutMs = options.timeoutMs ?? EXPO_SWIFT_READY_TIMEOUT_MS
+  const progressMs = options.progressMs ?? EXPO_SWIFT_READY_PROGRESS_MS
+  const start = Date.now()
+  const report =
+    options.onProgress ??
+    ((elapsedMs: number) => {
+      console.log(
+        `  still waiting on ${endpointUrl} after ${Math.round(elapsedMs / 1000)}s — expo swift compile in progress`,
+      )
+    })
+  const progress = setInterval(() => report(Date.now() - start), progressMs)
+  try {
+    options.signal?.throwIfAborted()
+    const timeout = AbortSignal.timeout(timeoutMs)
+    const signal = options.signal ? AbortSignal.any([options.signal, timeout]) : timeout
+    let res: Response | undefined
+    while (!res) {
+      try {
+        // bun ends an unanswered fetch at six minutes. that close is the last
+        // client, so the bridge aborts the shared compile and the retry starts
+        // over. hold the socket for the caller's bound instead.
+        const init: RequestInit = { signal }
+        Object.assign(init, { timeout: false })
+        res = await fetch(endpointUrl, init)
+      } catch (error) {
+        if (options.signal?.aborted) throw error
+        if (timeout.aborted) {
+          throw new Error(
+            `timed out after ${timeoutMs}ms waiting for ${endpointUrl} — the expo swift compile did not answer within the bound`,
+          )
+        }
+        // a dropped socket still rejoins the same compile when the bridge has
+        // another client. retry only that case.
+        if (error instanceof Error && error.name === 'TimeoutError') continue
+        throw new Error(`could not reach ${endpointUrl}`, { cause: error })
+      }
+    }
+    if (!res.ok) {
+      const body = (await res.text()).trim().slice(0, 500)
+      throw new Error(`${endpointUrl} answered ${res.status}${body ? `: ${body}` : ''}`)
+    }
+    await res.text()
+    console.log(
+      `  expo swift modules ready in ${((Date.now() - start) / 1000).toFixed(1)}s`,
+    )
+  } finally {
+    clearInterval(progress)
+  }
+}
+
+// the expoSwift endpoint a built shell url carries, or null for an app with no
+// project root
+export async function awaitStampedExpoSwiftReady(shellUrl: string): Promise<void> {
+  const endpoint = new URL(shellUrl).searchParams.get('expoSwift')
+  if (!endpoint) return
+  await awaitExpoSwiftReady(endpoint)
+}

package/src/expoSwiftContract.ts

@@ -9,8 +9,12 @@ export interface ExpoSwiftSourceUnit {
   namespace: string
   moduleId: string
   classes: string[]
+  // legacy bridge module registrations (react-native-bridge-modules.ts)
+  bridgeModules: string[]
   files: Record<string, string>
   frameworks: string[]
+  // the app target's Swift language mode; Expo packages compile in the default
+  swiftLanguageMode?: number
 }
 
 export interface ExpoSwiftCompiledModule {
@@ -23,6 +27,8 @@ export interface ExpoSwiftCompiledModule {
 
 export interface ExpoSwiftCompilationResult {
   namespaces: string[]
+  // the namespaces that are legacy bridge modules rather than Expo modules
+  bridgeModules?: string[]
   modules: ExpoSwiftCompiledModule[]
   failures: { namespace: string; diagnostic: string }[]
 }
@@ -47,6 +53,13 @@ export function isExpoSwiftCompilationResult(
     return false
   const remaining = new Set(value.namespaces)
   if (remaining.size !== value.namespaces.length) return false
+  // bundles published before legacy bridge modules carry no list
+  if (
+    value.bridgeModules !== undefined &&
+    (!strings(value.bridgeModules) ||
+      !value.bridgeModules.every((name) => remaining.has(name)))
+  )
+    return false
   for (const artifact of value.modules) {
     if (
       !record(artifact) ||

package/src/home-paths.ts

@@ -185,6 +185,15 @@ export function cacheDir(): string {
   return path.join(rnxHomeDir(), 'cache')
 }
 
+// swiftpm otherwise uses shared caches and configuration outside PEACH_HOME.
+export function swiftPackageCacheOptions(): string[] {
+  const root = path.join(cacheDir(), 'swiftpm')
+  return ['cache', 'config', 'security'].flatMap((name) => [
+    `--${name}-path`,
+    path.join(root, name),
+  ])
+}
+
 export function daemonLockfilePath(): string {
   return path.join(rnxHomeDir(), DAEMON_LOCKFILE)
 }
@@ -261,7 +270,10 @@ export function writeSharedConfig(patch: Partial<SharedConfig>): SharedConfig {
   return next
 }
 
-const CURRENT_ONBOARDING_VERSION = 1
+// version 2 made the native app the default simulator window. version 1 setup
+// saved the browser without asking on a Mac lacking the app, so its saved
+// driver is not read back and those machines run setup again.
+const CURRENT_ONBOARDING_VERSION = 2
 
 export type SimulatorDriverPreference = DriverId
 
@@ -270,7 +282,9 @@ export function isOnboardingComplete(): boolean {
 }
 
 export function readSimulatorDriverPreference(): SimulatorDriverPreference | null {
-  const driver = readSharedConfig().simulatorDriver
+  const config = readSharedConfig()
+  if (config.onboardingVersion !== CURRENT_ONBOARDING_VERSION) return null
+  const driver = config.simulatorDriver
   return driver === 'desktop' || driver === 'electron' || driver === 'playwright'
     ? driver
     : null
@@ -634,6 +648,38 @@ export function isDevBridgeLockfileFresh(
   }
 }
 
+function hostBridgePortNumber(value: number | null | undefined): number | null {
+  if (typeof value !== 'number' || !Number.isInteger(value) || value < 1 || value > 65535)
+    return null
+  return value
+}
+
+/** port a desktop host's page should register on.
+ *
+ *  the launch url's wsPort pin wins. an ambient PEACH_BRIDGE_PORT wins only
+ *  when this home has no fresh daemon, the daemon already bound that port, or
+ *  a fresh dev-bridge lockfile in this home claims it. otherwise the fresh
+ *  daemon lock wins, so a second PEACH_HOME is not pulled onto another world's
+ *  bridge. the mac user script and the native seed use the same rule. */
+export function desktopHostBridgePort(input: {
+  pinnedPort?: number | null
+  daemonPort?: number | null
+  envPort?: number | null
+  devBridgePorts?: readonly number[]
+}): number | null {
+  const pinned = hostBridgePortNumber(input.pinnedPort)
+  if (pinned != null) return pinned
+  const daemon = hostBridgePortNumber(input.daemonPort)
+  const env = hostBridgePortNumber(input.envPort)
+  const claimed = new Set(
+    (input.devBridgePorts ?? [])
+      .map((port) => hostBridgePortNumber(port))
+      .filter((port): port is number => port != null),
+  )
+  if (env != null && (daemon == null || env === daemon || claimed.has(env))) return env
+  return daemon
+}
+
 export function readLiveRuntimeVersions(): string[] {
   const versions = new Set<string>()
   const daemon = readDaemonLockfile()

package/src/host/bridge-host.ts

@@ -543,10 +543,13 @@ export class SootSimBridgeHost {
     if (this.httpServer || this.wss) return this.effectivePort
 
     // an installed runtime can serve while the startup update runs. only a
-    // machine without usable assets needs to wait for that download.
+    // machine without usable assets needs to wait for that download. only the
+    // daemon's runtime updater ever clears the flag, so a dev bridge (which
+    // serves the checkout build and runs no updater) never sets it.
     const bootRuntimeDir = this.getActiveRuntime().runtimeDir
     this.bootstrapping =
-      !bootRuntimeDir || !fs.existsSync(path.join(bootRuntimeDir, 'index.html'))
+      this.shouldWriteLockfile &&
+      (!bootRuntimeDir || !fs.existsSync(path.join(bootRuntimeDir, 'index.html')))
 
     for (let attempt = 0; attempt < this.portFallbackCount; attempt++) {
       const candidate = this.preferredPort === 0 ? 0 : this.preferredPort + attempt