peachsim 0.1.939 → 0.1.1399

package/src/cloud.ts

@@ -28,7 +28,7 @@ import {
 import { isRecord } from './is-record'
 import { rnxPublicBrand } from './public-brand'
 import { sleep } from './sleep'
-import type { SimStateOptions } from './bridge-contract'
+import type { SemanticWaitCondition, SimStateOptions } from './bridge-contract'
 
 export {
   isRnxCloudCommandScope,
@@ -407,7 +407,10 @@ export class RemoteSimulator {
       do: (command) => this.sendCommand(command),
       wait: (condition, options) => {
         const timeoutMs = options?.maxMs ?? DEFAULT_WAIT_READY_MS
-        const waitCondition = condition === 'ready' ? { type: 'ready' } : condition
+        const waitCondition: SemanticWaitCondition =
+          condition === 'ready'
+            ? { type: 'ready' }
+            : { type: 'present', selector: { testID: condition.selector } }
         return this.sendCommand(
           {
             type: 'waitFor',

package/src/config.ts

@@ -8,6 +8,14 @@ import { isValidRuntimeVersion } from '@contrast/runtime-delivery/version'
 import { isRecord } from './is-record'
 import type { RevenueCatTestStoreConfig } from '@peach/compat/revenuecat-test-store'
 
+export type NativeRenderer = 'paper' | 'fabric'
+
+export function readNativeRenderer(value: unknown): NativeRenderer | undefined {
+  if (value === undefined) return undefined
+  if (value === 'paper' || value === 'fabric') return value
+  throw new Error('nativeRenderer must be paper or fabric')
+}
+
 export type ModuleResolution =
   // an empty module under `modules`; under `nativeModules` / `turboModules` a
   // present-but-inert native module whose every method call is a no-op.
@@ -28,6 +36,8 @@ export type NativeViewResolution = 'noop' | { file: string }
 export interface PeachConfig<Settings extends Record<string, any> = Record<string, any>> {
   // host-only engine selection. omitted means the current stable runtime.
   runtimeVersion?: string
+  // native host identity. omission preserves the Fabric default.
+  nativeRenderer?: NativeRenderer
   modules?: Record<string, ModuleResolution>
   turboModules?: Record<string, NativeModuleResolution>
   nativeModules?: Record<string, NativeModuleResolution>
@@ -71,9 +81,14 @@ export function collectConfiguredFileModules(config?: PeachConfig): string[] {
   ]
 }
 
-export function isPeachConfig(value: unknown): value is PeachConfig {
+export function isPeachConfig<Settings extends Record<string, any> = Record<string, any>>(
+  value: unknown,
+): value is PeachConfig<Settings> {
   if (!isRecord(value)) return false
   return (
+    (value.nativeRenderer === undefined ||
+      value.nativeRenderer === 'paper' ||
+      value.nativeRenderer === 'fabric') &&
     (value.runtimeVersion === undefined ||
       (typeof value.runtimeVersion === 'string' &&
         value.runtimeVersion === value.runtimeVersion.trim() &&
@@ -169,6 +184,7 @@ export function hasPeachConfig<
 >(config?: PeachConfig<Settings> | null): config is PeachConfig<Settings> {
   if (!config) return false
   return (
+    config.nativeRenderer !== undefined ||
     (typeof config.runtimeVersion === 'string' && config.runtimeVersion.length > 0) ||
     hasOwnKeys(config.modules as Record<string, unknown> | undefined) ||
     hasOwnKeys(config.turboModules as Record<string, unknown> | undefined) ||
@@ -193,6 +209,7 @@ export function mergePeachConfig<
 
   return {
     runtimeVersion: override.runtimeVersion ?? base.runtimeVersion,
+    nativeRenderer: override.nativeRenderer ?? base.nativeRenderer,
     modules: { ...(base.modules || {}), ...(override.modules || {}) },
     turboModules: { ...(base.turboModules || {}), ...(override.turboModules || {}) },
     nativeModules: {
@@ -217,14 +234,16 @@ export function readPeachConfigFromSearchParams<
 >(searchParams: URLSearchParams): PeachConfig<Settings> | undefined {
   const raw = searchParams.get(PEACH_CONFIG_QUERY_PARAM)
   if (!raw) return undefined
+  let parsed: unknown
   try {
-    const parsed = JSON.parse(raw) as PeachConfig<Settings>
-    return hasPeachConfig(parsed) ? parsed : undefined
+    parsed = JSON.parse(raw)
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error)
     console.warn(`[peach] invalid ${PEACH_CONFIG_QUERY_PARAM}: ${message}`)
     return undefined
   }
+  if (isRecord(parsed)) readNativeRenderer(parsed.nativeRenderer)
+  return isPeachConfig<Settings>(parsed) && hasPeachConfig(parsed) ? parsed : undefined
 }
 
 export function applyPeachConfigToUrl<

package/src/configured-bundle-producer.ts

@@ -90,7 +90,7 @@ export async function produceConfiguredBundle(
     const compact = await minify(code, {
       compress: false,
       mangle: false,
-      format: { comments: false, beautify: false },
+      format: { comments: false },
     })
     if (!compact.code || /[\n\r]/.test(compact.code))
       throw new Error('configured bundle prefix must preserve the guest source lines')

package/src/desktop-host-delivery.ts

@@ -79,6 +79,88 @@ export function isNativeHostBundle(app: string): boolean {
   )
 }
 
+/** a default production install owns the scheme until uninstall or home purge. */
+export function registerNativeDesktopLinks(): void {
+  if (
+    desktopHostPlatform() !== 'mac-arm64' ||
+    !isNativeHostBundle(MAC_HOST_APP) ||
+    bundleValue(MAC_HOST_APP, 'PeachUpdateChannel') !== 'production'
+  )
+    return
+  const receipt = path.join(desktopHostsDir(), 'url-handler.json')
+  fs.mkdirSync(desktopHostsDir(), { recursive: true })
+  const script = `
+ObjC.import('CoreServices');
+ObjC.import('Foundation');
+ObjC.bindFunction('LSCopyDefaultHandlerForURLScheme', ['id', ['id']]);
+ObjC.bindFunction('LSSetDefaultHandlerForURLScheme', ['int', ['id', 'id']]);
+ObjC.bindFunction('LSCopyAllHandlersForURLScheme', ['id', ['id']]);
+const current = ObjC.unwrap($.LSCopyDefaultHandlerForURLScheme('peach')) || null;
+const handlers = ObjC.deepUnwrap($.LSCopyAllHandlersForURLScheme('peach')) || [];
+const previous = current === ${JSON.stringify(HOST_BUNDLE_ID)}
+  ? handlers.find(handler => handler !== ${JSON.stringify(HOST_BUNDLE_ID)}) || null : current;
+if (current !== ${JSON.stringify(HOST_BUNDLE_ID)} || ${!fs.existsSync(receipt)}) {
+  const data = $.NSString.stringWithString(JSON.stringify({ previous })).dataUsingEncoding($.NSUTF8StringEncoding);
+  if (!data.writeToFileAtomically(${JSON.stringify(receipt)}, true))
+    throw new Error('native URL handler receipt write failed');
+}
+const registered = $.LSRegisterURL($.NSURL.fileURLWithPath(${JSON.stringify(MAC_HOST_APP)}), true);
+if (registered !== 0) throw new Error('native URL registration failed: ' + registered);
+const selected = $.LSSetDefaultHandlerForURLScheme('peach', ${JSON.stringify(HOST_BUNDLE_ID)});
+if (selected !== 0) throw new Error('native URL handler selection failed: ' + selected);
+if (ObjC.unwrap($.LSCopyDefaultHandlerForURLScheme('peach')) !== ${JSON.stringify(HOST_BUNDLE_ID)})
+  throw new Error('native URL handler readback failed');
+`
+  // runner-toolchain-platform: darwin
+  const result = spawnSync('/usr/bin/osascript', ['-l', 'JavaScript', '-e', script], {
+    encoding: 'utf8',
+  })
+  if (result.status !== 0)
+    throw new Error(`native deep-link registration failed: ${result.stderr.trim()}`)
+}
+
+/** restore the captured handler only while this install still owns the scheme. */
+export function unregisterNativeDesktopLinks(): void {
+  if (desktopHostPlatform() !== 'mac-arm64') return
+  const receipt = path.join(desktopHostsDir(), 'url-handler.json')
+  if (!fs.existsSync(receipt)) return
+  const state: unknown = JSON.parse(fs.readFileSync(receipt, 'utf8'))
+  if (
+    typeof state !== 'object' ||
+    state === null ||
+    !('previous' in state) ||
+    (state.previous !== null && typeof state.previous !== 'string')
+  )
+    throw new Error('invalid native URL registration receipt')
+  const script = `
+ObjC.import('CoreServices');
+ObjC.bindFunction('LSCopyDefaultHandlerForURLScheme', ['id', ['id']]);
+ObjC.bindFunction('LSSetDefaultHandlerForURLScheme', ['int', ['id', 'id']]);
+const current = ObjC.unwrap($.LSCopyDefaultHandlerForURLScheme('peach'));
+const previous = ${JSON.stringify(state.previous)};
+if (current === ${JSON.stringify(HOST_BUNDLE_ID)} && previous) {
+  const status = $.LSSetDefaultHandlerForURLScheme('peach', previous);
+  if (status !== 0 || ObjC.unwrap($.LSCopyDefaultHandlerForURLScheme('peach')) !== previous)
+    throw new Error('native URL handler restore failed: ' + status);
+}
+`
+  // runner-toolchain-platform: darwin
+  run('/usr/bin/osascript', ['-l', 'JavaScript', '-e', script])
+  // runner-toolchain-platform: darwin
+  run(
+    '/System/Library/Frameworks/CoreServices.framework/Frameworks/LaunchServices.framework/Support/lsregister',
+    ['-u', MAC_HOST_APP],
+  )
+  fs.unlinkSync(receipt)
+}
+
+export function uninstallNativeDesktopHost(): void {
+  unregisterNativeDesktopLinks()
+  if (desktopHostPlatform() === 'mac-arm64' && isNativeHostBundle(MAC_HOST_APP))
+    fs.rmSync(MAC_HOST_APP, { recursive: true, force: true })
+  fs.rmSync(desktopHostsDir(), { recursive: true, force: true })
+}
+
 function placedHostVersion(): string | null {
   if (desktopHostPlatform() === 'linux-x64') {
     try {
@@ -105,7 +187,19 @@ export function activeDesktopHostApp(): string | null {
 
 /** the installed standalone host command; the driver appends its connection arguments. */
 export function headlessHostCommand(): string[] | null {
-  if (desktopHostPlatform() !== 'linux-x64') return null
+  const platform = desktopHostPlatform()
+  if (!platform) return null
+  if (platform === 'mac-arm64') {
+    const app = process.env.PEACH_DESKTOP_APP
+      ? path.resolve(process.env.PEACH_DESKTOP_APP)
+      : activeDesktopHostApp()
+    if (!app) return null
+    const launcher = path.join(app, 'Contents/Frameworks/node')
+    const host = path.join(app, 'Contents/Resources/node/host.mjs')
+    // releases before the bundled launcher have no headless host
+    if (!fs.existsSync(launcher) || !fs.existsSync(host)) return null
+    return [launcher, '--experimental-vm-modules', host]
+  }
   const version = placedHostVersion()
   if (!version) return null
   const dir = desktopHostDir(version)

package/src/expo-kotlin-bundle.ts

@@ -0,0 +1,29 @@
+// release publishers use the same app compiler as local Android launches, then
+// carry its immutable Kotlin/Wasm module beside the javascript bundle.
+import { compileExpoKotlinModules } from './expo-kotlin-host'
+import type { ExpoKotlinCompilationResult } from './expoKotlinContract'
+
+export interface ExpoKotlinBundle {
+  // module.url is relative to the release's asset base
+  metadata: ExpoKotlinCompilationResult
+  assets: { path: string; bytes: Buffer; contentType: string }[]
+}
+
+export async function buildExpoKotlinBundle(
+  appRoot: string,
+): Promise<ExpoKotlinBundle | null> {
+  const metadata = await compileExpoKotlinModules(appRoot, '')
+  if (!metadata) return null
+  const { module } = metadata
+  if (!module) return { metadata, assets: [] }
+  const { kotlinArtifactFiles } = await import('./kotlin-host')
+  const dir = `__peach/kotlin/${module.hash}`
+  return {
+    metadata: { ...metadata, module: { ...module, url: `${dir}/app.mjs` } },
+    assets: kotlinArtifactFiles(module.hash).map((file) => ({
+      path: `${dir}/${file.name}`,
+      bytes: file.bytes,
+      contentType: file.contentType,
+    })),
+  }
+}

package/src/expo-kotlin-host.ts

@@ -0,0 +1,201 @@
+// local Expo modules on an Android device: expo's own autolinker selects the
+// app-owned Android modules, as its gradle plugin does, and their Kotlin
+// compiles into one Kotlin/Wasm process with the expo-modules-core DSL port.
+import { execFile } from 'node:child_process'
+import fs from 'node:fs'
+import { createRequire } from 'node:module'
+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 { isRecord } from './is-record'
+import type { ExpoKotlinCompilationResult } from './expoKotlinContract'
+import type { IncomingMessage, ServerResponse } from 'node:http'
+
+const run = promisify(execFile)
+// the compiled CLI's execPath is peach itself, which runs a forked `.js` as a
+// script only with this set; node and bun ignore it.
+const scriptEnv = { ...process.env, [RNX_FORKED_SCRIPT_ENV]: '1' }
+export const EXPO_KOTLIN_ROUTE = '/__peach/expo-kotlin'
+const MODULE_ROOT = path.resolve(import.meta.dirname, '../kotlin')
+
+export interface ExpoKotlinModules {
+  // the registration names Android's ExpoModulesPackageList passes, in order
+  modules: { classifier: string; name: string | null }[]
+  sources: string[]
+}
+
+export async function collectExpoKotlinModules(
+  appRoot: string,
+): Promise<ExpoKotlinModules | null> {
+  appRoot = fs.realpathSync(appRoot)
+  let autolinker: string
+  try {
+    autolinker = createRequire(path.join(appRoot, 'package.json')).resolve(
+      'expo-modules-autolinking/package.json',
+    )
+  } catch (error) {
+    if (isRecord(error) && error.code === 'MODULE_NOT_FOUND') return null
+    throw error
+  }
+  const { stdout } = await run(
+    process.execPath,
+    [
+      path.join(path.dirname(autolinker), 'bin/expo-modules-autolinking.js'),
+      'resolve',
+      '--platform',
+      'android',
+      '--project-root',
+      appRoot,
+      '--json',
+    ],
+    { timeout: 30_000, maxBuffer: 8 * 1024 * 1024, env: scriptEnv },
+  )
+  const resolved: unknown = JSON.parse(stdout)
+  if (!isRecord(resolved) || !Array.isArray(resolved.modules))
+    throw new Error('invalid Expo Android resolution')
+  const result: ExpoKotlinModules = { modules: [], sources: [] }
+  for (const entry of resolved.modules) {
+    if (!isRecord(entry) || !Array.isArray(entry.projects))
+      throw new Error('invalid Expo Android module entry')
+    for (const project of entry.projects) {
+      if (
+        !isRecord(project) ||
+        typeof project.sourceDir !== 'string' ||
+        !Array.isArray(project.modules)
+      )
+        throw new Error('invalid Expo Android project')
+      const sourceDir = fs.realpathSync(project.sourceDir)
+      // installed dependency implementations remain with their native seams.
+      if (sourceDir.split(path.sep).includes('node_modules')) continue
+      if (project.modules.length === 0) continue
+      for (const module of project.modules) {
+        if (
+          !isRecord(module) ||
+          typeof module.classifier !== 'string' ||
+          !/^[A-Za-z_][A-Za-z0-9_]*(\.[A-Za-z_][A-Za-z0-9_]*)+$/.test(
+            module.classifier,
+          ) ||
+          (module.name !== null && typeof module.name !== 'string')
+        )
+          throw new Error(`${sourceDir}: invalid Expo Android module descriptor`)
+        result.modules.push({ classifier: module.classifier, name: module.name })
+      }
+      const walk = (dir: string) => {
+        if (!fs.existsSync(dir)) return
+        for (const child of fs
+          .readdirSync(dir, { withFileTypes: true })
+          .sort((a, b) => a.name.localeCompare(b.name))) {
+          const file = path.join(dir, child.name)
+          if (child.isSymbolicLink())
+            throw new Error(`Expo Kotlin source is a symlink: ${file}`)
+          if (child.isDirectory()) walk(file)
+          else if (child.name.endsWith('.java'))
+            throw new Error(`${file}: Java sources in Expo modules are not supported yet`)
+          else if (child.name.endsWith('.kt')) result.sources.push(file)
+        }
+      }
+      // the gradle android plugin's default main source sets
+      walk(path.join(sourceDir, 'src', 'main', 'java'))
+      walk(path.join(sourceDir, 'src', 'main', 'kotlin'))
+    }
+  }
+  return result.modules.length === 0 ? null : result
+}
+
+export async function compileExpoKotlinModules(
+  root: string,
+  origin: string,
+): Promise<ExpoKotlinCompilationResult | null> {
+  const found = await collectExpoKotlinModules(root)
+  if (!found) return null
+  const namespaces = found.modules.map(
+    (module) => module.name ?? module.classifier.split('.').pop()!,
+  )
+  const { expoKotlinArtifact } = await import('./kotlin-host')
+  try {
+    const artifact = await expoKotlinArtifact(root, MODULE_ROOT, origin, found)
+    return { namespaces, module: artifact, failures: [] }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error)
+    // kotlinc names each failing source line; anything else is the host's
+    const errors = message.match(/^.+\.kt:\d+:\d+: error:.*$/gm)
+    if (!errors) throw error
+    return {
+      namespaces,
+      module: null,
+      failures: namespaces.map((namespace) => ({
+        namespace,
+        diagnostic: errors.join('\n'),
+      })),
+    }
+  }
+}
+
+const compiling = new Map<string, Promise<ExpoKotlinCompilationResult | null>>()
+
+export async function handleExpoKotlinRequest(
+  req: IncomingMessage,
+  res: ServerResponse,
+): Promise<boolean> {
+  const url = new URL(req.url ?? '/', 'http://localhost')
+  if (
+    !url.pathname.startsWith('/__peach/kotlin-artifact/') &&
+    url.pathname !== EXPO_KOTLIN_ROUTE
+  )
+    return false
+  const remote = req.socket.remoteAddress?.replace(/^::ffff:/, '')
+  const requestOrigin = req.headers.origin
+  if (
+    !remote ||
+    !isLoopbackHost(remote) ||
+    (requestOrigin && !isLoopbackHost(new URL(requestOrigin).hostname))
+  ) {
+    res.writeHead(403)
+    res.end('Expo Kotlin artifacts require a loopback client')
+    return true
+  }
+  res.setHeader('Access-Control-Allow-Origin', requestOrigin ?? '*')
+  res.setHeader('Vary', 'Origin')
+  res.setHeader('Cross-Origin-Resource-Policy', 'cross-origin')
+  if (url.pathname !== EXPO_KOTLIN_ROUTE) {
+    const { serveKotlinArtifact } = await import('./kotlin-host')
+    return serveKotlinArtifact(url.pathname, res)
+  }
+  if (req.method !== 'GET') {
+    res.writeHead(405)
+    res.end('GET required')
+    return true
+  }
+  const root = url.searchParams.get('root')
+  if (!root || !path.isAbsolute(root)) {
+    res.writeHead(400)
+    res.end('missing absolute app root')
+    return true
+  }
+  const host = req.headers.host
+  if (!host) {
+    res.writeHead(400)
+    res.end('Expo Kotlin request has no host')
+    return true
+  }
+  try {
+    let pending = compiling.get(root)
+    if (!pending) {
+      pending = compileExpoKotlinModules(root, `http://${host}`)
+      compiling.set(root, pending)
+    }
+    const metadata = await pending
+    res.writeHead(200, {
+      'Content-Type': 'application/json',
+      'Cache-Control': 'no-store',
+    })
+    res.end(JSON.stringify(metadata))
+  } catch (error) {
+    res.writeHead(500, { 'Content-Type': 'text/plain' })
+    res.end(error instanceof Error ? error.message : String(error))
+  } finally {
+    compiling.delete(root)
+  }
+  return true
+}

package/src/expo-swift-host.ts

@@ -1,5 +1,5 @@
 // expo's own autolinker selects app-owned Swift modules; the common Swift host
-// validates namespaces independently and links successful registrations together.
+// links their registrations together and isolates namespaces only when that fails.
 import { execFile } from 'node:child_process'
 import { createHash } from 'node:crypto'
 import fs from 'node:fs'
@@ -232,7 +232,7 @@ export async function collectExpoSwiftSources(
 }
 
 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: RNXPackage {\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`
+  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`
 }
 
 const compiling = new Map<string, Promise<unknown>>()
@@ -246,7 +246,8 @@ export async function compileExpoSwiftModules(
 ): Promise<ExpoSwiftCompilationResult | null> {
   const units = await collectExpoSwiftSources(root)
   if (!units) return null
-  // source checks isolate failures; successful modules share one linked app.
+  // every candidate links into one app first; only a failed link compiles each
+  // namespace alone to isolate the failures, so a framework change costs one build.
   const module = await resolveSwiftModule()
   if (!module && publishArtifact)
     throw new Error('No local Swift toolchain or distribution is available')
@@ -255,81 +256,42 @@ export async function compileExpoSwiftModules(
     modules: [],
     failures: [],
   }
-  const key = createHash('sha256').update(fs.realpathSync(root)).digest('hex')
-  const linked: ExpoSwiftSourceUnit[] = []
-  for (const unit of units) {
-    if (!module) {
+  if (!module) {
+    for (const unit of units)
       result.failures.push({
         namespace: unit.moduleId,
         diagnostic: 'No local Swift toolchain or distribution is available',
       })
-      continue
-    }
+    return result
+  }
+  const key = createHash('sha256').update(fs.realpathSync(root)).digest('hex')
+  const failures = new Map<string, string>()
+  const candidates: ExpoSwiftSourceUnit[] = []
+  const stamps = new Map<ExpoSwiftSourceUnit, string>()
+  for (const unit of units) {
     const packagePath = path.join(os.tmpdir(), 'peach-expo-swift', key, unit.moduleId)
-    let stamp: string | undefined
-    try {
-      // preserve the compiler's input stamp across unchanged reloads.
-      // only this adapter's build copy is synchronized; app sources are read only.
-      syncSwiftTree(
-        packagePath,
-        new Map(
-          Object.entries(unit.files).map(([name, source]) => [
-            path.join(packagePath, name),
-            source,
-          ]),
-        ),
-      )
-      stamp = sourceStamp(packagePath, module.root)
-      const failed = failedCompilations.get(packagePath)
-      if (failed?.stamp === stamp) {
-        result.failures.push({
-          namespace: unit.moduleId,
-          diagnostic: failed.diagnostic,
-        })
-        continue
-      }
-      failedCompilations.delete(packagePath)
-      await artifactFor(projectFor(packagePath), EXPO_SWIFT_ENTRY, module.root)
-      linked.push(unit)
-    } catch (error) {
-      const diagnostic = error instanceof Error ? error.message : String(error)
-      const appPaths = Object.values(unit.files).flatMap((source) => {
-        const match = /^#sourceLocation\(file: (".*"), line: 1\)$/m.exec(source)
-        if (!match) return []
-        const file: unknown = JSON.parse(match[1]!)
-        return typeof file === 'string' ? [file] : []
-      })
-      const errors = diagnostic.match(/^.+:\d+(?::\d+)?: error:.*$/gm) ?? []
-      const sourceErrors = errors.filter(
-        (line) =>
-          appPaths.some((file) => line.startsWith(`${file}:`)) &&
-          !/external macro implementation type|failed to load library plugin/.test(line),
-      )
-      if (
-        publishArtifact &&
-        (sourceErrors.length === 0 || sourceErrors.length !== errors.length) &&
-        !(error instanceof SwiftMissingModulesError)
-      )
-        throw error
-      if (
-        sourceErrors.length &&
-        sourceErrors.length === errors.length &&
-        module &&
-        stamp &&
-        sourceStamp(packagePath, module.root) === stamp
-      ) {
-        failedCompilations.set(packagePath, {
-          stamp,
-          diagnostic: sourceErrors.join('\n'),
-        })
-      }
-      result.failures.push({
-        namespace: unit.moduleId,
-        diagnostic: sourceErrors.length ? sourceErrors.join('\n') : diagnostic,
-      })
+    // preserve the compiler's input stamp across unchanged reloads.
+    // only this adapter's build copy is synchronized; app sources are read only.
+    syncSwiftTree(
+      packagePath,
+      new Map(
+        Object.entries(unit.files).map(([name, source]) => [
+          path.join(packagePath, name),
+          source,
+        ]),
+      ),
+    )
+    const stamp = sourceStamp(packagePath, module.root)
+    const failed = failedCompilations.get(packagePath)
+    if (failed?.stamp === stamp) {
+      failures.set(unit.moduleId, failed.diagnostic)
+      continue
     }
+    failedCompilations.delete(packagePath)
+    stamps.set(unit, stamp)
+    candidates.push(unit)
   }
-  if (module && linked.length) {
+  const link = async (linked: ExpoSwiftSourceUnit[]) => {
     const files: Record<string, string> = Object.assign(
       {},
       ...linked.map((unit) => unit.files),
@@ -355,11 +317,69 @@ export async function compileExpoSwiftModules(
         ]),
       ),
     )
-    const artifact = await artifactFor(
-      projectFor(packagePath),
-      EXPO_SWIFT_ENTRY,
-      module.root,
-    )
+    return artifactFor(projectFor(packagePath), EXPO_SWIFT_ENTRY, module.root)
+  }
+  let linked = candidates
+  let artifact: import('./swift-host').SwiftArtifact | undefined
+  if (linked.length) {
+    try {
+      artifact = await link(linked)
+    } catch (linkError) {
+      linked = []
+      for (const unit of candidates) {
+        const packagePath = path.join(os.tmpdir(), 'peach-expo-swift', key, unit.moduleId)
+        try {
+          await artifactFor(projectFor(packagePath), EXPO_SWIFT_ENTRY, module.root)
+          linked.push(unit)
+        } catch (error) {
+          const diagnostic = error instanceof Error ? error.message : String(error)
+          const appPaths = Object.values(unit.files).flatMap((source) => {
+            const match = /^#sourceLocation\(file: (".*"), line: 1\)$/m.exec(source)
+            if (!match) return []
+            const file: unknown = JSON.parse(match[1]!)
+            return typeof file === 'string' ? [file] : []
+          })
+          const errors = diagnostic.match(/^.+:\d+(?::\d+)?: error:.*$/gm) ?? []
+          const sourceErrors = errors.filter(
+            (line) =>
+              appPaths.some((file) => line.startsWith(`${file}:`)) &&
+              !/external macro implementation type|failed to load library plugin/.test(
+                line,
+              ),
+          )
+          if (
+            publishArtifact &&
+            (sourceErrors.length === 0 || sourceErrors.length !== errors.length) &&
+            !(error instanceof SwiftMissingModulesError)
+          )
+            throw error
+          if (
+            sourceErrors.length &&
+            sourceErrors.length === errors.length &&
+            sourceStamp(packagePath, module.root) === stamps.get(unit)
+          ) {
+            failedCompilations.set(packagePath, {
+              stamp: stamps.get(unit)!,
+              diagnostic: sourceErrors.join('\n'),
+            })
+          }
+          failures.set(
+            unit.moduleId,
+            sourceErrors.length ? sourceErrors.join('\n') : diagnostic,
+          )
+        }
+      }
+      // 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)
+    }
+  }
+  for (const unit of units) {
+    const diagnostic = failures.get(unit.moduleId)
+    if (diagnostic !== undefined)
+      result.failures.push({ namespace: unit.moduleId, diagnostic })
+  }
+  if (artifact) {
     await publishArtifact?.(artifact)
     result.modules.push({
       namespaces: linked.map((unit) => unit.moduleId),