peachsim 0.1.1641 → 0.1.1653

package/src/metro-project-root.ts

@@ -0,0 +1,68 @@
+import { resolveListeningPid, resolveProcessCwd } from '../scripts/dev-server-scanner'
+import { loopbackOriginOf } from './backend-origin'
+import { MANIFEST_PROBE_TIMEOUT_MS } from './dev-bundle-resolution'
+import { parseExpoManifestBody } from './expo-manifest-body'
+
+// resolve a metro dev server's project root. Expo's middleware advertises it
+// in X-React-Native-Project-Root, encoded with encodeURI. Older servers name it
+// in extra.expoClient._internal.projectRoot. The local peach open path runs from the
+// CLI's cwd, which almost never owns the bundle being opened (e.g.
+// `peach open 8081` run from ~/contrast against a 3pc metro), so scanning cwd for
+// font declarations finds nothing.
+//
+// a bare react-native packager serves no such manifest, so the same resolver
+// asks the OS for the listening process's cwd. that is still the development
+// server's project identity; the invoking CLI's cwd is never consulted.
+//
+// it waits on the same budget as the manifest resolution that found this dev
+// server. a cold Expo Metro answers /status in 2-4s while it builds a bundle,
+// and dropping the project there opens the app without its fonts, splash or
+// Firebase config. a server that stays silent past the budget fails the open.
+export async function resolveMetroProjectRoot(bundleUrl: string): Promise<string | null> {
+  const origin = loopbackOriginOf(bundleUrl)
+  if (!origin) return null
+  const controller = new AbortController()
+  const timer = setTimeout(() => controller.abort(), MANIFEST_PROBE_TIMEOUT_MS)
+  let servedManifest = false
+  let metroRunning = false
+  try {
+    const status = await fetch(`${origin}/status`, { signal: controller.signal })
+    const advertisedRoot = status.headers.get('X-React-Native-Project-Root')
+    if (status.ok && advertisedRoot) return decodeURI(advertisedRoot)
+    metroRunning = status.ok && (await status.text()).trim() === 'packager-status:running'
+    const res = await fetch(`${origin}/`, {
+      headers: { 'expo-platform': 'ios', Accept: 'application/json' },
+      signal: controller.signal,
+    })
+    if (res.ok) {
+      const manifest: unknown = parseExpoManifestBody(await res.text())
+      servedManifest = true
+      let root: unknown = manifest
+      for (const key of ['extra', 'expoClient', '_internal', 'projectRoot']) {
+        root =
+          typeof root === 'object' && root !== null ? Reflect.get(root, key) : undefined
+      }
+      if (typeof root === 'string' && root.length > 0) return root
+    }
+  } catch {
+    if (controller.signal.aborted)
+      throw new Error(
+        `Metro project root request timed out after ${MANIFEST_PROBE_TIMEOUT_MS / 1000}s: ${origin}. Wait for the dev server to finish starting or pass --project-root.`,
+      )
+  } finally {
+    clearTimeout(timer)
+  }
+
+  // a server that answered with a manifest has already told us everything it
+  // knows. if it did not name a project root there is none to learn, and asking
+  // the OS about the listening process would answer with whatever directory
+  // that process happens to sit in — which is the CLI's own cwd trap this
+  // function exists to avoid. only a server whose status identifies Metro
+  // and which served no manifest gets the process lookup.
+  if (servedManifest || !metroRunning) return null
+
+  const port = Number(new URL(origin).port)
+  if (!Number.isFinite(port) || port <= 0) return null
+  const pid = await resolveListeningPid(port)
+  return pid === null ? null : resolveProcessCwd(pid)
+}

package/src/native-app-identity-project.ts

@@ -326,44 +326,8 @@ function readIosNativeAppIdentity(
   parseInfoPlist: (source: string) => unknown,
   iosTarget: string | undefined,
 ): NativeAppIdentity | null {
-  const iosRoot = path.join(projectRoot, 'ios')
-  if (!fs.existsSync(iosRoot)) return null
-  const projects = fs
-    .readdirSync(iosRoot, { withFileTypes: true })
-    .filter((entry) => entry.isDirectory() && entry.name.endsWith('.xcodeproj'))
-  if (projects.length === 0) return null
-  if (projects.length > 1 && !iosTarget) {
-    throw new NativeAppTargetSelectionError(
-      `native app identity requires a selected Xcode project; set withPeach's iosTarget to an app target in one of: ${projects.map((entry) => entry.name).join(', ')}`,
-    )
-  }
-  let project = projects[0]!
-  if (iosTarget && projects.length > 1) {
-    const matches = projects.filter((entry) =>
-      listXcodeAppTargets(path.join(iosRoot, entry.name), {
-        requireSources: false,
-      }).includes(iosTarget),
-    )
-    if (matches.length === 0) {
-      throw new Error(`native app identity has no application target ${iosTarget}`)
-    }
-    if (matches.length > 1) {
-      throw new Error(
-        `native app identity target ${iosTarget} is ambiguous across ${matches.map((entry) => entry.name).join(', ')}`,
-      )
-    }
-    project = matches[0]!
-  }
-  const xcodeproj = path.join(iosRoot, project.name)
-  const appTargets = listXcodeAppTargets(xcodeproj, { requireSources: false })
-  if (!iosTarget && appTargets.length > 1) {
-    throw new NativeAppTargetSelectionError(
-      `native app identity requires a selected app target; set withPeach's iosTarget to one of: ${appTargets.join(', ')}`,
-    )
-  }
-  const app = readXcodeAppTarget(xcodeproj, iosTarget ?? appTargets[0], 'Release', {
-    requireSources: false,
-  })
+  const app = readIosAppTarget(projectRoot, iosTarget)
+  if (!app) return null
   const identity = readNativeAppIdentityFromXcodeTarget(app, parseInfoPlist)
   const projectManifestPath = path.join(projectRoot, 'package.json')
   const projectRequire = createRequire(projectManifestPath)
@@ -422,3 +386,48 @@ function readIosNativeAppIdentity(
   }
   return { ...identity, reanimatedStaticFeatureFlags: flags }
 }
+
+// native identity and copied resources must select the same application target.
+export function readIosAppTarget(
+  projectRoot: string,
+  iosTarget?: string,
+): XcodeAppTarget | null {
+  const iosRoot = path.join(projectRoot, 'ios')
+  if (!fs.existsSync(iosRoot)) return null
+  const projects = fs
+    .readdirSync(iosRoot, { withFileTypes: true })
+    .filter((entry) => entry.isDirectory() && entry.name.endsWith('.xcodeproj'))
+  if (projects.length === 0) return null
+  if (projects.length > 1 && !iosTarget) {
+    throw new NativeAppTargetSelectionError(
+      `native app identity requires a selected Xcode project; set withPeach's iosTarget to an app target in one of: ${projects.map((entry) => entry.name).join(', ')}`,
+    )
+  }
+  let project = projects[0]!
+  if (iosTarget && projects.length > 1) {
+    const matches = projects.filter((entry) =>
+      listXcodeAppTargets(path.join(iosRoot, entry.name), {
+        requireSources: false,
+      }).includes(iosTarget),
+    )
+    if (matches.length === 0) {
+      throw new Error(`native app identity has no application target ${iosTarget}`)
+    }
+    if (matches.length > 1) {
+      throw new Error(
+        `native app identity target ${iosTarget} is ambiguous across ${matches.map((entry) => entry.name).join(', ')}`,
+      )
+    }
+    project = matches[0]!
+  }
+  const xcodeproj = path.join(iosRoot, project.name)
+  const appTargets = listXcodeAppTargets(xcodeproj, { requireSources: false })
+  if (!iosTarget && appTargets.length > 1) {
+    throw new NativeAppTargetSelectionError(
+      `native app identity requires a selected app target; set withPeach's iosTarget to one of: ${appTargets.join(', ')}`,
+    )
+  }
+  return readXcodeAppTarget(xcodeproj, iosTarget ?? appTargets[0], 'Release', {
+    requireSources: false,
+  })
+}

package/src/nitro-adapter.lock.json

@@ -0,0 +1,26 @@
+{
+  "schema": 1,
+  "platform": "ios",
+  "target": "wasm32-unknown-wasip1",
+  "recipe": "93ec12de28e70ccd6a0ff72c91fe59add61930da9b9f0c981c35b8ff64abdf8e",
+  "adapter": {
+    "sha256": "051a6905f1194aa18075d68e0444d30e69b4e52dc6017f3e70815a2403e3c306"
+  },
+  "headers": {
+    "reactNativeJsi": "96db4e758dd53e9320cef7cad485e00aa06e7a982cefd920f17007de8a5bd9f9",
+    "nitroModules": "372b6f69fc063a0b316792eec9b26f36063868dc206f169acbb5d993c6572f65"
+  },
+  "compiler": "swift-6.4.0-RELEASE-custom-0d775d32d7c74eae",
+  "sdk": {
+    "id": "swift-6.4.0-RELEASE_wasm-peach-f02bd198",
+    "checksum": "1e19ea768fd4e821aae34b8966c4ddcee45615c4b3cf018979b061aee2fb5504"
+  },
+  "framework": {
+    "distribution": "e3bdd3d8fa4f9993",
+    "wireAbi": "ed0b01fcc0a79236d88ef9ac7950ac30932dfc19c19112c69d1d6a039a489292"
+  },
+  "archive": {
+    "sha256": "1cf000ee821aaf65b04a3d6702c7d4341e450371cfd199e5887c6056f80af899",
+    "size": 31175
+  }
+}

package/src/nitro-adapter.ts

@@ -0,0 +1,103 @@
+// the private Nitro adapter archive an installed peach links into every Nitro
+// compile: downloaded from PEACH_SWIFT_ENDPOINT, verified against the lock this
+// build carries, then checked against the app's own original headers and the
+// compiler, SDK and framework the module root compiles with
+// (docs/swift-distribution.md). the adapter source never reaches this machine.
+import fs from 'node:fs'
+import path from 'node:path'
+import { installVerifiedTarball } from '@contrast/runtime-delivery'
+import { rnxHomeDir } from './home-paths'
+import lockJson from './nitro-adapter.lock.json' with { type: 'json' }
+import {
+  headerDigests,
+  NITRO_ADAPTER_MANIFEST,
+  nitroAdapterArchiveKey,
+  parseNitroAdapterLock,
+  verifyInstalledNitroAdapter,
+  type NitroAdapterLock,
+  type NitroAdapterManifest,
+} from './nitroAdapterContract'
+import { NITRO_GUEST_PLATFORM } from './nitroContract'
+import { swiftDistributionAt, swiftModuleSdk, WASM_TRIPLE } from './swift-compile'
+import { SWIFT_ENDPOINT_ENV } from './swift-distribution'
+import type { NitroSourceCollection } from './nitro-source'
+
+/** the verified adapter this build ships, the only lock normal compiles use. */
+export const committedNitroAdapterLock = parseNitroAdapterLock(lockJson)
+
+export interface NitroAdapterArchive {
+  manifest: NitroAdapterManifest
+  /** the static archive, base64, as SwiftCompileInput.libraries carries it. */
+  base64: string
+}
+
+/** rejects a lock built for other guest platform, target, headers, compiler,
+ *  SDK or framework than this app's original headers and the module root
+ *  compiling it. the committed lock is the trust root and pins the whole
+ *  manifest. its wire ABI digest is producer provenance the reviewed lock
+ *  fixes; the consumer cannot recompute it and the framework distribution id
+ *  does not independently bind it. */
+function verifyIdentity(
+  lock: NitroAdapterLock,
+  collection: NitroSourceCollection,
+  moduleRoot: string,
+) {
+  const { nitro, reactNative } = collection
+  const distribution = swiftDistributionAt(moduleRoot)
+  if (!distribution) throw new Error(`${moduleRoot} holds no Swift distribution`)
+  const sdk = swiftModuleSdk(moduleRoot)
+  const headers = headerDigests({
+    nitroModules: nitro.root,
+    reactNative: reactNative.root,
+  })
+  const mismatched = [
+    lock.platform !== NITRO_GUEST_PLATFORM && 'guest platform',
+    lock.target !== WASM_TRIPLE && 'target',
+    lock.headers.reactNativeJsi !== headers.reactNativeJsi && 'React Native JSI headers',
+    lock.headers.nitroModules !== headers.nitroModules && 'Nitro Modules headers',
+    lock.compiler !== distribution.release && 'compiler',
+    (lock.sdk.id !== sdk.wasmSdkId || lock.sdk.checksum !== sdk.wasmSdkChecksum) &&
+      'Swift SDK',
+    lock.framework.distribution !== distribution.id && 'Swift distribution',
+  ].filter((name) => name !== false)
+  if (mismatched.length > 0)
+    throw new Error(
+      `Nitro adapter archive does not match this app and toolchain: ${mismatched.join(', ')}`,
+    )
+}
+
+/** the verified adapter archive for a collection: identity first, then the
+ *  download, whose tarball and unpacked bytes the lock pins. */
+export async function resolveNitroAdapter(
+  collection: NitroSourceCollection,
+  moduleRoot: string,
+  lock: NitroAdapterLock,
+  signal?: AbortSignal,
+): Promise<NitroAdapterArchive> {
+  verifyIdentity(lock, collection, moduleRoot)
+  const endpoint = process.env[SWIFT_ENDPOINT_ENV]?.trim().replace(/\/+$/, '')
+  if (!endpoint)
+    throw new Error(
+      `Nitro compilation needs ${SWIFT_ENDPOINT_ENV} for its adapter archive`,
+    )
+  const dir = path.join(rnxHomeDir(), 'swift', `nitro-adapter-${lock.archive.sha256}`)
+  if (!fs.existsSync(path.join(dir, NITRO_ADAPTER_MANIFEST))) {
+    process.stderr.write(`peach: downloading Nitro adapter ${lock.archive.sha256}…\n`)
+    await installVerifiedTarball({
+      signal,
+      url: `${endpoint}/${nitroAdapterArchiveKey(lock)}`,
+      digest: { algorithm: 'sha256', encoding: 'hex', value: lock.archive.sha256 },
+      destDir: dir,
+      installedMarker: NITRO_ADAPTER_MANIFEST,
+      label: 'Nitro adapter archive',
+      verify: (installed) => {
+        verifyInstalledNitroAdapter(installed, lock)
+      },
+    })
+  }
+  const manifest = verifyInstalledNitroAdapter(dir, lock)
+  return {
+    manifest,
+    base64: fs.readFileSync(path.join(dir, manifest.archive.path)).toString('base64'),
+  }
+}

package/src/nitro-bundle.ts

@@ -1,6 +1,7 @@
 import { compileNitroModule } from './nitro-compile'
+import { discoverNitroProviders } from './nitro-source'
+import { SWIFT_ENDPOINT_ENV, swiftDistributionRoot } from './swift-distribution'
 import { icuUrl } from './swift-host'
-import type { NitroSourceOptions } from './nitro-source'
 import type { NitroCompiledModule } from './nitroContract'
 
 export interface NitroBundle {
@@ -8,14 +9,28 @@ export interface NitroBundle {
   assets: { path: string; bytes: Buffer; contentType: string }[]
 }
 
-// the selected installed package uses the same compiler and asset addresses
-// as local native loads. package javascript is carried verbatim by its bundler.
+// every installed iOS Nitro provider the app declares compiles into one
+// executable with the same compiler and asset addresses as local native loads.
+// package javascript is carried verbatim by its bundler.
 export async function buildNitroBundle(
-  options: NitroSourceOptions & { moduleRoot: string },
-): Promise<NitroBundle> {
-  const { artifact, collection } = await compileNitroModule(options)
-  const implementation = collection.packages[0]
-  if (!implementation) throw new Error('Nitro compilation has no installed package')
+  appRoot: string,
+  moduleRoot?: string,
+): Promise<NitroBundle | null> {
+  const packageRoots = discoverNitroProviders(appRoot)
+  if (packageRoots.length === 0) return null
+  // the adapter archive is built against the published distribution, so Nitro
+  // compiles against it even in a source checkout; the checkout framework has
+  // no manifest for the adapter identity check to bind.
+  const module = moduleRoot ?? (await swiftDistributionRoot())
+  if (!module)
+    throw new Error(
+      `Nitro compilation needs ${SWIFT_ENDPOINT_ENV} for the Swift distribution`,
+    )
+  const { artifact, collection } = await compileNitroModule({
+    appRoot,
+    packageRoots,
+    moduleRoot: module,
+  })
   const assets: NitroBundle['assets'] = [
     {
       path: `__peach/swift/${artifact.hash}.wasm`,
@@ -32,8 +47,7 @@ export async function buildNitroBundle(
   return {
     metadata: {
       platform: 'ios',
-      packageName: implementation.name,
-      packageVersion: implementation.version,
+      packages: collection.providers.map(({ name, version }) => ({ name, version })),
       url: `/__peach/swift/${artifact.hash}.wasm`,
       hash: artifact.hash,
       icuUrl: icuUrl('', artifact),

package/src/nitro-compile.ts

@@ -2,6 +2,11 @@ import { createHash } from 'node:crypto'
 import fs from 'node:fs'
 import os from 'node:os'
 import path from 'node:path'
+import {
+  committedNitroAdapterLock,
+  resolveNitroAdapter,
+  type NitroAdapterArchive,
+} from './nitro-adapter'
 import {
   collectNitroSources,
   type NitroSourceCollection,
@@ -9,59 +14,31 @@ import {
 } from './nitro-source'
 import { syncSwiftTree } from './swift-compile'
 import { artifactFor, projectFor, type SwiftArtifact } from './swift-host'
-import { readPackageFile } from './swift-source-file'
-import { MAX_SWIFT_COMPILE_SOURCE_BYTES } from './swift-submit'
 import type { SwiftCompileInput } from './swift-compile'
 
-// installed implementations, generated registration and the real runtime form
-// one executable. the common Swift compiler owns linking and artifact reuse.
+// every selected installed implementation, its generated registration and the
+// verified adapter archive form one executable. the archive carries the private
+// adapter objects and links into NitroCore; the common Swift compiler owns
+// linking and reuse.
 export function collectNitroCompileInput(
-  options: NitroSourceOptions & { moduleRoot: string },
-): { input: SwiftCompileInput; collection: NitroSourceCollection } {
-  const collection = collectNitroSources(options)
+  collection: NitroSourceCollection,
+  adapter: NitroAdapterArchive,
+): SwiftCompileInput {
   const files = { ...collection.files }
-  const platform = path.join(options.moduleRoot, 'platform/react-native-nitro-modules')
-  const read = (file: string) =>
-    readPackageFile(
-      platform,
-      path.join(platform, file),
-      MAX_SWIFT_COMPILE_SOURCE_BYTES,
-    ).toString('utf8')
-  for (const file of [
-    'platform/ThreadUtils.cpp',
-    'platform/NitroLogger.cpp',
-    'threading/UIThreadDispatcher.cpp',
-    'threading/UIThreadDispatcher.hpp',
-  ]) {
-    files[`Sources/NitroCore/peach/${file}`] = read(file)
-  }
-  files['Sources/NitroCore/include/UIThreadDispatcher.hpp'] =
-    '#include "../peach/threading/UIThreadDispatcher.hpp"\n'
-
-  const runtime = 'PeachNitroRuntime'
-  for (const file of [
-    'ProxyRuntime.cpp',
-    'RuntimeEntry.cpp',
-    'HostImports.hpp',
-    'ProxyRuntime.hpp',
-    'RuntimeEntry.hpp',
-  ]) {
-    const relative = file.endsWith('.hpp') ? `include/${file}` : file
-    files[`Sources/${runtime}/${relative}`] = read(`jsi/${file}`)
-  }
-  files[`Sources/${runtime}/include/PeachNitroEntry.hpp`] =
+  // the archive has no module, so NitroCore's module map declares its entry.
+  files['Sources/NitroCore/include/PeachNitroEntry.hpp'] =
     '#pragma once\nextern "C" void peachNitroInitialize();\n'
-  files[`Sources/${runtime}/include/module.modulemap`] =
-    `module ${runtime} { header "PeachNitroEntry.hpp" export * }\n`
+  const core = files['Sources/NitroCore/include/module.modulemap']
+  if (!core?.endsWith(' export * }\n'))
+    throw new Error('Nitro collection has no NitroCore module map')
+  files['Sources/NitroCore/include/module.modulemap'] =
+    `${core.slice(0, -' export * }\n'.length)} header "PeachNitroEntry.hpp" export * }\n`
 
-  const implementation = collection.targets.find((target) =>
-    collection.registration.header.startsWith(`${target.path}/`),
-  )
-  if (!implementation) throw new Error('Nitro registration has no package target')
   const entry = 'Sources/PeachNitroApp/main.swift'
+  // every provider registers before the one runtime serves guest evaluation.
   files[entry] =
-    `import ${runtime}\nimport ${implementation.name}\n` +
-    `peachNitroInitialize()\n${collection.registration.symbol}()\n`
+    `import NitroCore\n${collection.registrations.map(({ target }) => `import ${target}\n`).join('')}` +
+    `peachNitroInitialize()\n${collection.registrations.map(({ symbol }) => `${symbol}()\n`).join('')}`
   files['Package.swift'] = [
     '// swift-tools-version: 6.2',
     'import PackageDescription',
@@ -70,20 +47,23 @@ export function collectNitroCompileInput(
       (target) =>
         `.target(name: ${JSON.stringify(target.name)}, dependencies: ${JSON.stringify(target.dependencies?.map((dependency) => dependency.name) ?? [])}, path: ${JSON.stringify(target.path)}, ${target.cxxInterop ? 'swiftSettings: [.interoperabilityMode(.Cxx)]' : 'cxxSettings: [.define("DEBUG")]'}),`,
     ),
-    `.target(name: "${runtime}", dependencies: ["JsiBridge", "NitroCore"], cxxSettings: [.define("DEBUG")]),`,
-    `.executableTarget(name: "PeachNitroApp", dependencies: ["${runtime}", "${implementation.name}"], swiftSettings: [.interoperabilityMode(.Cxx)]),`,
+    `.executableTarget(name: "PeachNitroApp", dependencies: ${JSON.stringify(collection.registrations.map(({ target }) => target))}, swiftSettings: [.interoperabilityMode(.Cxx)]),`,
     '], cxxLanguageStandard: .cxx20)',
     '',
   ].join('\n')
-  return { input: { files, entry }, collection }
+  return { files, entry, libraries: { NitroCore: adapter.base64 } }
 }
 
 export async function compileNitroModule(
   options: NitroSourceOptions & { moduleRoot: string },
 ): Promise<{ artifact: SwiftArtifact; collection: NitroSourceCollection }> {
-  const { input, collection } = collectNitroCompileInput(options)
+  const collection = collectNitroSources(options)
+  const input = collectNitroCompileInput(
+    collection,
+    await resolveNitroAdapter(collection, options.moduleRoot, committedNitroAdapterLock),
+  )
   const key = createHash('sha256')
-    .update(fs.realpathSync(options.packageRoot))
+    .update(collection.providers.map(({ root }) => root).join('\0'))
     .update('\0')
     .update(fs.realpathSync(options.moduleRoot))
     .digest('hex')
@@ -97,8 +77,10 @@ export async function compileNitroModule(
       ]),
     ),
   )
+  const project = projectFor(packagePath)
+  project.libraries = input.libraries
   return {
-    artifact: await artifactFor(projectFor(packagePath), input.entry, options.moduleRoot),
+    artifact: await artifactFor(project, input.entry, options.moduleRoot),
     collection,
   }
 }