peachsim 0.1.2198 → 0.1.2200

package/src/kotlin-maven-sources.ts

@@ -0,0 +1,248 @@
+// a dependency outside Peach's pinned closure compiles from the sources jar
+// the app's Maven repositories publish for that coordinate
+import { createHash } from 'node:crypto'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { inflateRawSync } from 'node:zlib'
+
+const pending = new Map<string, Promise<string[]>>()
+
+function braceBlock(text: string, from: number): { body: string; end: number } | null {
+  const open = text.indexOf('{', from)
+  if (open < 0) return null
+  let depth = 0
+  for (let index = open; index < text.length; index++) {
+    const char = text[index]
+    if (char === '{') depth++
+    else if (char === '}') {
+      depth--
+      if (depth === 0) return { body: text.slice(open + 1, index), end: index }
+    }
+  }
+  return null
+}
+
+function repositoryRoot(value: string, where: string): string {
+  if (value.startsWith('https://')) return value.replace(/\/+$/, '')
+  if (value.startsWith('/')) return value.replace(/\/+$/, '')
+  if (value.startsWith('file:')) {
+    const pathname = new URL(value).pathname
+    if (!pathname.startsWith('/'))
+      throw new Error(`${where}: Maven repository ${value} is not a local path`)
+    return decodeURIComponent(pathname).replace(/\/+$/, '')
+  }
+  throw new Error(
+    `${where}: Maven repository ${value} is not an https URL or a local path`,
+  )
+}
+
+// google(), mavenCentral(), mavenLocal(), or one literal maven URL
+function withoutComments(text: string): string {
+  let out = ''
+  for (let index = 0; index < text.length; index++) {
+    const char = text[index]
+    const next = text[index + 1]
+    if (char === '"' || char === "'") {
+      const quote = char
+      out += char
+      index++
+      while (index < text.length && text[index] !== quote) {
+        out += text[index]
+        if (text[index] === '\\') {
+          index++
+          out += text[index] ?? ''
+        }
+        index++
+      }
+      out += text[index] ?? ''
+      continue
+    }
+    if (char === '/' && next === '/') {
+      while (index < text.length && text[index] !== '\n') index++
+      out += '\n'
+      continue
+    }
+    if (char === '/' && next === '*') {
+      index += 2
+      while (index < text.length && !(text[index] === '*' && text[index + 1] === '/'))
+        index++
+      index++
+      continue
+    }
+    out += char
+  }
+  return out
+}
+
+function repositories(body: string, where: string): string[] {
+  const stripped = withoutComments(body)
+  const roots: string[] = []
+  const leftover = stripped.replace(
+    /\b(google|mavenCentral|mavenLocal)\s*\(\s*\)|\bmaven\s*(?:\(\s*["']([^"']+)["']\s*\)|\{([^{}]*)\})/g,
+    (match, name: string, direct: string | undefined, block: string | undefined) => {
+      if (name === 'google') roots.push('https://dl.google.com/dl/android/maven2')
+      else if (name === 'mavenCentral') roots.push('https://repo1.maven.org/maven2')
+      else if (name === 'mavenLocal')
+        roots.push(path.join(os.homedir(), '.m2', 'repository'))
+      else {
+        const declared = direct ?? /["']([^"']+)["']/.exec(block ?? '')?.[1]
+        if (!declared)
+          throw new Error(`${where}: ${match.trim()} declares no repository URL`)
+        roots.push(repositoryRoot(declared, where))
+      }
+      return ''
+    },
+  )
+  if (leftover.replace(/[\s;]/g, ''))
+    throw new Error(`${where}: ${leftover.trim()} is not a literal Maven repository`)
+  return roots
+}
+
+function mavenRepositories(projectDir: string, where: string): string[] {
+  const file = ['settings.gradle.kts', 'settings.gradle']
+    .map((name) => path.join(projectDir, name))
+    .find((candidate) => fs.existsSync(candidate))
+  if (!file) throw new Error(`${where}: ${projectDir} has no settings.gradle`)
+  const text = fs.readFileSync(file, 'utf8')
+  const management = text.search(/\bdependencyResolutionManagement\b/)
+  if (management < 0)
+    throw new Error(`${where}: ${file} declares no dependency repositories`)
+  const managed = braceBlock(text, management)
+  if (!managed)
+    throw new Error(`${where}: ${file} dependencyResolutionManagement block never closes`)
+  const repositoriesAt = managed.body.search(/\brepositories\b/)
+  if (repositoriesAt < 0)
+    throw new Error(`${where}: ${file} declares no dependency repositories`)
+  const block = braceBlock(managed.body, repositoriesAt)
+  if (!block) throw new Error(`${where}: ${file} repositories block never closes`)
+  const roots = repositories(block.body, `${where}: ${file}`)
+  if (roots.length === 0)
+    throw new Error(`${where}: ${file} declares no dependency repositories`)
+  return roots
+}
+
+function zipSources(bytes: Buffer, where: string): { name: string; data: Buffer }[] {
+  let end = -1
+  const earliest = Math.max(0, bytes.length - 22 - 0xffff)
+  for (let index = bytes.length - 22; index >= earliest; index--) {
+    if (bytes.readUInt32LE(index) === 0x06054b50) {
+      end = index
+      break
+    }
+  }
+  if (end < 0) throw new Error(`${where}: sources jar is not a zip`)
+  const count = bytes.readUInt16LE(end + 8)
+  if (count !== bytes.readUInt16LE(end + 10))
+    throw new Error(`${where}: sources jar spans zip disks`)
+  let offset = bytes.readUInt32LE(end + 16)
+  if (offset === 0xffffffff) throw new Error(`${where}: sources jar is zip64`)
+  const entries: { name: string; data: Buffer }[] = []
+  for (let index = 0; index < count; index++) {
+    if (bytes.readUInt32LE(offset) !== 0x02014b50)
+      throw new Error(`${where}: sources jar has a broken central directory`)
+    const flags = bytes.readUInt16LE(offset + 8)
+    const method = bytes.readUInt16LE(offset + 10)
+    const compressed = bytes.readUInt32LE(offset + 20)
+    const nameLength = bytes.readUInt16LE(offset + 28)
+    const extraLength = bytes.readUInt16LE(offset + 30)
+    const commentLength = bytes.readUInt16LE(offset + 32)
+    const localOffset = bytes.readUInt32LE(offset + 42)
+    const name = bytes.toString('utf8', offset + 46, offset + 46 + nameLength)
+    offset += 46 + nameLength + extraLength + commentLength
+    if (name.endsWith('/')) continue
+    if (flags & 1) throw new Error(`${where}: ${name} is encrypted`)
+    if (name.startsWith('/') || name.split('/').includes('..'))
+      throw new Error(`${where}: ${name} escapes the sources jar`)
+    if (bytes.readUInt32LE(localOffset) !== 0x04034b50)
+      throw new Error(`${where}: ${name} has no local header`)
+    const localName = bytes.readUInt16LE(localOffset + 26)
+    const localExtra = bytes.readUInt16LE(localOffset + 28)
+    const start = localOffset + 30 + localName + localExtra
+    const payload = bytes.subarray(start, start + compressed)
+    const data =
+      method === 0 ? Buffer.from(payload) : method === 8 ? inflateRawSync(payload) : null
+    if (!data) throw new Error(`${where}: ${name} uses zip method ${method}`)
+    entries.push({ name, data })
+  }
+  return entries
+}
+
+function extract(bytes: Buffer, where: string): Promise<string[]> {
+  const key = createHash('sha256').update(bytes).digest('hex')
+  const cached = pending.get(key)
+  if (cached) return cached
+  const request = (async () => {
+    const dest = path.join(os.tmpdir(), 'peach-maven-sources', key)
+    const marker = path.join(dest, '.complete')
+    if (!fs.existsSync(marker)) {
+      const entries = zipSources(bytes, where)
+      const java = entries.find((entry) => entry.name.endsWith('.java'))
+      if (java) throw new Error(`${where}: ${java.name} is a Java source`)
+      const kotlin = entries.filter((entry) => entry.name.endsWith('.kt'))
+      if (kotlin.length === 0) throw new Error(`${where}: sources jar has no Kotlin`)
+      const staging = `${dest}.partial-${process.pid}`
+      fs.rmSync(staging, { recursive: true, force: true })
+      for (const entry of kotlin) {
+        const file = path.join(staging, entry.name)
+        fs.mkdirSync(path.dirname(file), { recursive: true })
+        fs.writeFileSync(file, entry.data)
+      }
+      fs.writeFileSync(path.join(staging, '.complete'), '')
+      try {
+        fs.renameSync(staging, dest)
+      } catch (error) {
+        fs.rmSync(staging, { recursive: true, force: true })
+        if (!fs.existsSync(marker)) throw error
+      }
+    }
+    return fs
+      .readdirSync(dest, { recursive: true })
+      .flatMap((entry) => {
+        const name = String(entry)
+        return name.endsWith('.kt') ? [path.join(dest, name)] : []
+      })
+      .sort()
+  })().catch((error: unknown) => {
+    pending.delete(key)
+    throw error
+  })
+  pending.set(key, request)
+  return request
+}
+
+async function sourcesJar(
+  root: string,
+  group: string,
+  artifact: string,
+  version: string,
+): Promise<Buffer | null> {
+  const parts = [
+    ...group.split('.'),
+    artifact,
+    version,
+    `${artifact}-${version}-sources.jar`,
+  ]
+  if (root.startsWith('https://')) {
+    const url = `${root}/${parts.join('/')}`
+    const response = await fetch(url)
+    if (response.status === 404) return null
+    if (!response.ok) throw new Error(`${url} answered ${response.status}`)
+    return Buffer.from(await response.arrayBuffer())
+  }
+  const file = path.join(root, ...parts)
+  return fs.existsSync(file) ? fs.readFileSync(file) : null
+}
+
+export async function mavenKotlinSources(
+  projectDir: string,
+  coordinate: { group: string; artifact: string; version: string },
+  where: string,
+): Promise<string[] | null> {
+  const { group, artifact, version } = coordinate
+  for (const root of mavenRepositories(projectDir, where)) {
+    const jar = await sourcesJar(root, group, artifact, version)
+    if (jar) return extract(jar, `${where}: ${group}:${artifact}:${version}`)
+  }
+  return null
+}

package/src/native-prebuilt.ts

@@ -58,7 +58,7 @@ export function nativeEntryKey(inputs: Record<string, string>): string {
 export const nativeEntryPrefix = (kind: NativeEntryKind, name: string, key: string) =>
   `native/${kind}/${name}/${key}`
 
-const entryCache = (kind: NativeEntryKind, name: string, key: string) =>
+export const nativeEntryCache = (kind: NativeEntryKind, name: string, key: string) =>
   path.join(peachCacheDir(), 'native-prebuilt', kind, name, key)
 
 // one GET; a missing object is null. a network failure is a miss too, since a
@@ -111,7 +111,7 @@ export function fetchNativeEntry(
   name: string,
   key: string,
 ): string | null {
-  const dir = entryCache(kind, name, key)
+  const dir = nativeEntryCache(kind, name, key)
   const descriptorFile = path.join(dir, 'descriptor.json')
   if (fs.existsSync(descriptorFile)) return dir
   const base = `${NATIVE_PREBUILT_ORIGIN}/${nativeEntryPrefix(kind, name, key)}`
@@ -146,6 +146,40 @@ export function fetchNativeEntry(
   }
 }
 
+/**
+ * installs a locally produced entry directory (descriptor beside its files) as
+ * the cache's entry for its key, after the same checks a download gets.
+ * a private distribution has no registry entries, so its host produces them.
+ */
+export function installNativeEntry(
+  kind: NativeEntryKind,
+  name: string,
+  key: string,
+  source: string,
+): string {
+  const files = parseFiles(
+    fs.readFileSync(path.join(source, 'descriptor.json'), 'utf8'),
+    kind,
+    name,
+    key,
+  )
+  for (const file of files) {
+    const target = path.join(source, file.path)
+    if (fs.statSync(target).size !== file.size || sha256(target) !== file.sha256)
+      throw new Error(
+        `native prebuilt ${kind}/${name}/${key}: ${file.path} does not match its descriptor`,
+      )
+  }
+  const dir = entryCache(kind, name, key)
+  fs.mkdirSync(path.dirname(dir), { recursive: true })
+  const staging = `${dir}.${process.pid}.partial`
+  fs.rmSync(staging, { recursive: true, force: true })
+  fs.cpSync(source, staging, { recursive: true })
+  fs.rmSync(dir, { recursive: true, force: true })
+  fs.renameSync(staging, dir)
+  return dir
+}
+
 /** the descriptor for files a publisher is about to upload. */
 export function describeNativeEntry(
   kind: NativeEntryKind,

package/src/native-swift-slices.ts

@@ -1,12 +1,20 @@
+import { execFileSync } from 'node:child_process'
 import { createHash } from 'node:crypto'
 import fs from 'node:fs'
+import os from 'node:os'
 import path from 'node:path'
-import { fetchNativeEntry, nativeEntryKey } from './native-prebuilt'
+import {
+  fetchNativeEntry,
+  installNativeEntry,
+  nativeEntryKey,
+  nativeEntryPrefix,
+} from './native-prebuilt'
 import {
   swiftDistributionAt,
   swiftInterfaceDeclarations,
   withoutSwiftDeclarations,
 } from './swift-compile'
+import { privateSwiftDistributionRoot, sourceSwiftCheckout } from './swift-toolchain'
 import { simulatorNativeLibrary } from './swift-xcframework'
 import type { SwiftStandin } from './swift-standins'
 
@@ -44,6 +52,37 @@ export function nativeSwiftSliceEntry(
   return { name: SENTRY_SWIFT_SLICE.name, inputs, key: nativeEntryKey(inputs) }
 }
 
+// the registry holds entries only for the pinned distribution; a private one
+// (a canary or local candidate) has none, so its host produces the slice.
+function privateSentrySlice(
+  entry: ReturnType<typeof nativeSwiftSliceEntry>,
+  moduleRoot: string,
+): string | null {
+  const privateRoot = privateSwiftDistributionRoot()
+  if (!privateRoot || fs.realpathSync(privateRoot) !== fs.realpathSync(moduleRoot))
+    return null
+  const script = path.join(sourceSwiftCheckout(), 'scripts/build-sentry-wasi.ts')
+  if (!fs.existsSync(script))
+    throw new Error(
+      'the Sentry slice for a private Swift distribution builds from a Contrast source checkout',
+    )
+  const staging = fs.mkdtempSync(path.join(fs.realpathSync(os.tmpdir()), 'sentry-slice-'))
+  try {
+    process.stderr.write('peach: building the Sentry slice for a private distribution…\n')
+    execFileSync('bun', [script, '--output', staging, '--module-root', moduleRoot], {
+      stdio: ['ignore', 2, 2],
+    })
+    return installNativeEntry(
+      'slice',
+      entry.name,
+      entry.key,
+      path.join(staging, nativeEntryPrefix('slice', entry.name, entry.key)),
+    )
+  } finally {
+    fs.rmSync(staging, { recursive: true, force: true })
+  }
+}
+
 export function nativeSwiftSlice(
   standin: SwiftStandin,
   moduleRoot: string,
@@ -66,7 +105,9 @@ export function nativeSwiftSlice(
   const distribution = swiftDistributionAt(moduleRoot)
   if (!distribution) throw new Error('native Swift slices need a compiled distribution')
   const entry = nativeSwiftSliceEntry(distribution, generator)
-  const directory = fetchNativeEntry('slice', entry.name, entry.key)
+  const directory =
+    fetchNativeEntry('slice', entry.name, entry.key) ??
+    privateSentrySlice(entry, moduleRoot)
   if (!directory)
     throw new Error(
       `native Swift slice ${entry.name}/${entry.key} is not built for this compiler and SDK`,

package/src/react-native-bridge-modules.ts

@@ -477,7 +477,13 @@ export function collectBridgeModuleSources(
       if (swiftClass) {
         const bridgingHeader = target.objc?.bridgingHeader
         if (bridgingHeader && target.objc && app) {
-          nativeInputs ??= xcodeObjCInputs(app, [], null, undefined, projectRoot)
+          nativeInputs ??= xcodeObjCInputs(
+            app,
+            [],
+            null,
+            undefined,
+            installedWorkspace ? app.rootDir : projectRoot,
+          )
           const native = target.objc
           // an installed package a monorepo hoists above the project keeps its
           // absolute path under one reserved prefix.

package/src/react-native-core-build.ts

@@ -0,0 +1,176 @@
+import { execFileSync } from 'node:child_process'
+import fs from 'node:fs'
+import path from 'node:path'
+import { cacheDir } from './home-paths'
+import { describeNativeEntry, nativeEntryCache, nativeEntryKey } from './native-prebuilt'
+import {
+  reactNativeCoreEntry,
+  reactNativeCoreFloor,
+  type ReactNativeCoreMode,
+} from './react-native-core'
+import { compileSwiftProjectUnit } from './swift-compile'
+import { swiftModuleToolchain } from './swift-distribution'
+import { isSwiftNativeTranslationUnit, swiftManifestTargets } from './swift-package'
+import { withSwiftRootLock } from './swift-root-lock'
+import { collectTurboCompileInput } from './turbo-compile'
+import { collectTurboSources, prepareTurboSourceDependencies } from './turbo-source'
+
+/** builds the React Native core for an installed app into the local
+ *  native-prebuilt cache, the directory a published entry downloads into, and
+ *  returns that directory. an entry already in the cache is returned as is. */
+export async function buildReactNativeCore(
+  project: string,
+  reactNativeRoot: string,
+  mode: ReactNativeCoreMode,
+  moduleRoot: string,
+): Promise<string> {
+  const entry = reactNativeCoreEntry(reactNativeRoot, moduleRoot, mode)
+  const directory = nativeEntryCache('react-native', entry.name, entry.key)
+  const work = path.join(cacheDir(), 'react-native-core-build', entry.key)
+  return withSwiftRootLock(work, async () => {
+    if (fs.existsSync(path.join(directory, 'descriptor.json'))) return directory
+    const module = { root: moduleRoot, ...swiftModuleToolchain(moduleRoot) }
+    const floor = reactNativeCoreFloor(reactNativeRoot)
+    await prepareTurboSourceDependencies(reactNativeRoot)
+    const codegenDir = path.join(work, 'codegen')
+    fs.mkdirSync(work, { recursive: true })
+    fs.rmSync(codegenDir, { recursive: true, force: true })
+    const collection = await collectTurboSources({
+      appRoot: project,
+      projectRoot: project,
+      reactNativeRoot,
+      providers: [],
+      codegenDir,
+      ...(mode === 'turbo-cxx'
+        ? { reactNativeCore: true }
+        : { reactNativeProvider: true }),
+      ...(mode === 'turbo' ? { turboDispatch: true } : {}),
+    })
+    const producer = {
+      ...collection,
+      files: { ...collection.files },
+      targets: [...collection.targets],
+    }
+    if (mode === 'turbo') {
+      // only the producer executable supplies this host callback; it is absent from the archives.
+      producer.targets.push({
+        name: 'PeachCoreProducerHost',
+        path: 'Sources/PeachCoreProducerHost',
+        executable: false,
+        languageMode: 5,
+        mainActorIsolation: false,
+        resources: false,
+        clangSettings: [{ tool: 'c', flags: ['-fblocks'] }],
+      })
+      producer.files['Sources/PeachCoreProducerHost/include/PeachCoreProducerHost.h'] =
+        '#pragma once\n'
+      producer.files['Sources/PeachCoreProducerHost/Dispatch.m'] =
+        '#import <dispatch/dispatch.h>\nvoid peachTurboDispatchAsync(dispatch_block_t block) { dispatch_async(dispatch_get_main_queue(), block); }\n'
+    }
+    const input = collectTurboCompileInput(producer, null, floor)
+    const { compiler: _compiler, recipe: _recipe, ...nativeInputs } = entry.inputs
+    const buildRoot = path.join(
+      cacheDir(),
+      'react-native-core-products',
+      nativeEntryKey(nativeInputs),
+    )
+    await compileSwiftProjectUnit(input, {
+      ...module,
+      moduleRoot: module.root,
+      buildRoot,
+      intermediates: true,
+    })
+    const products = path.join(buildRoot, '.build/wasm32-unknown-wasip1/release')
+    const emitted = swiftManifestTargets(
+      fs.readFileSync(path.join(buildRoot, 'Package.swift'), 'utf8'),
+    )
+    const libraries: Record<string, string> = {}
+    const binaryModules: Record<string, string> = {}
+    for (const target of collection.targets) {
+      const objects = emitted
+        .filter((product) => !product.executable && product.path === target.path)
+        .flatMap((product) => {
+          const built = path.join(products, `${product.name}.build`)
+          return fs
+            .readdirSync(built, { recursive: true, encoding: 'utf8' })
+            .filter((file) => file.endsWith('.o'))
+            .map((file) => path.join(built, file))
+        })
+        .sort()
+      if (objects.length === 0)
+        throw new Error(`${target.name}: core build produced no objects`)
+      const members = path.join(work, 'members', target.name)
+      fs.rmSync(members, { recursive: true, force: true })
+      fs.mkdirSync(members, { recursive: true })
+      const stripped = objects.map((file, index) => {
+        const output = path.join(members, `${index}-${path.basename(file)}`)
+        execFileSync(path.join(module.toolchainBin, 'llvm-objcopy'), [
+          '--strip-debug',
+          file,
+          output,
+        ])
+        return output
+      })
+      const archive = path.join(work, `lib${target.name}.a`)
+      fs.rmSync(archive, { force: true })
+      execFileSync(path.join(module.toolchainBin, 'llvm-ar'), [
+        'rcsD',
+        archive,
+        ...stripped,
+      ])
+      libraries[target.name] = fs.readFileSync(archive).toString('base64')
+      const swiftModule = path.join(products, 'Modules', `${target.name}.swiftmodule`)
+      if (fs.existsSync(swiftModule)) {
+        binaryModules[target.name] = fs.readFileSync(swiftModule).toString('base64')
+        collection.files[
+          `Sources/TurboCore/include/${target.name}/${target.name}-Swift.h`
+        ] = fs.readFileSync(
+          path.join(buildRoot, '.build/peach-cxx-headers', `${target.name}-Swift.h`),
+          'utf8',
+        )
+      }
+      // keep textually included implementations available to the preprocessor.
+      target.exclude = [
+        ...new Set([
+          ...(target.exclude ?? []),
+          ...Object.keys(collection.files)
+            .filter(
+              (file) =>
+                file.startsWith(`${target.path}/`) &&
+                (isSwiftNativeTranslationUnit(file) || file.endsWith('.swift')),
+            )
+            .map((file) => file.slice(target.path.length + 1)),
+        ]),
+      ]
+      collection.files[`${target.path}/PeachPrebuiltCore.c`] = '\n'
+      collection.files[`${target.path}/include/PeachPrebuiltCore.h`] = '#pragma once\n'
+    }
+    const prebuilt = collectTurboCompileInput(collection, null, floor)
+    const core = {
+      files: prebuilt.files,
+      entry: prebuilt.entry,
+      libraries,
+      binaryModules,
+      staticClangTargets: prebuilt.staticClangTargets ?? [],
+      ...(prebuilt.headerAliases ? { headerAliases: prebuilt.headerAliases } : {}),
+      ...(prebuilt.nativeTargets ? { nativeTargets: prebuilt.nativeTargets } : {}),
+    }
+    // the descriptor lands last, by rename, so a reader never sees a partial entry.
+    const staging = `${directory}.${process.pid}.building`
+    fs.rmSync(staging, { recursive: true, force: true })
+    fs.mkdirSync(staging, { recursive: true })
+    const coreFile = path.join(staging, 'core.json')
+    fs.writeFileSync(coreFile, JSON.stringify(core))
+    const descriptor = describeNativeEntry('react-native', entry.name, entry.inputs, [
+      coreFile,
+    ])
+    fs.writeFileSync(path.join(staging, 'descriptor.json'), JSON.stringify(descriptor))
+    fs.mkdirSync(path.dirname(directory), { recursive: true })
+    fs.rmSync(directory, { recursive: true, force: true })
+    fs.renameSync(staging, directory)
+    console.error(
+      `[peach] React Native core ${entry.name}: built ${collection.targets.length} targets locally`,
+    )
+    return directory
+  })
+}

package/src/react-native-core-digest.ts

@@ -10,7 +10,7 @@ export const REACT_NATIVE_CORE_SOURCES = [
   'nitro-dependencies.ts',
   'nitroAdapterContract.ts',
   'podspec-sources.ts',
-  '../../../scripts/lib/react-native-core.ts',
+  'react-native-core-build.ts',
 ]
 
 export function reactNativeCoreDigest(directory: string): string {

package/src/react-native-core.ts

@@ -152,17 +152,34 @@ export function reactNativeCoreEntry(
   return { name, inputs, key: nativeEntryKey(inputs) }
 }
 
-export function prebuiltReactNativeCore(
+// the published core is a cache of this build: a cli whose compiler or a
+// runtime whose distribution has no published entry yet builds it once into the
+// same local cache instead of refusing the app.
+const building = new Map<string, Promise<string>>()
+
+export async function prebuiltReactNativeCore(
+  project: string,
   reactNativeRoot: string,
   moduleRoot: string,
   mode: ReactNativeCoreMode,
-): ReactNativeCoreInput {
+): Promise<ReactNativeCoreInput> {
   const entry = reactNativeCoreEntry(reactNativeRoot, moduleRoot, mode)
-  const dir = fetchNativeEntry('react-native', entry.name, entry.key)
-  if (!dir)
-    throw new Error(
-      `no prebuilt React Native ${entry.inputs['react-native']} ${mode} core for headers ${entry.inputs.headers}; publish ${NATIVE_PREBUILT_ORIGIN}/${nativeEntryPrefix('react-native', entry.name, entry.key)}/descriptor.json before opening this app`,
-    )
+  let dir = fetchNativeEntry('react-native', entry.name, entry.key)
+  if (!dir) {
+    let pending = building.get(entry.key)
+    if (!pending) {
+      console.error(
+        `[peach] no published React Native ${entry.name} core at ${NATIVE_PREBUILT_ORIGIN}/${nativeEntryPrefix('react-native', entry.name, entry.key)}; building it locally`,
+      )
+      pending = import('./react-native-core-build')
+        .then(({ buildReactNativeCore }) =>
+          buildReactNativeCore(project, reactNativeRoot, mode, moduleRoot),
+        )
+        .finally(() => building.delete(entry.key))
+      building.set(entry.key, pending)
+    }
+    dir = await pending
+  }
   const file = path.join(dir, 'core.json')
   const descriptor: unknown = JSON.parse(
     fs.readFileSync(path.join(dir, 'descriptor.json'), 'utf8'),

package/src/swift-packages.ts

@@ -778,6 +778,9 @@ export function resolveSwiftPackages(options: {
       )
     )
       return false
+    // an assembly target stands in from its public headers, so a stand-in
+    // peach built for it stays provided instead of compiling its sources
+    if (providedTargets.has(name) && assemblySources(files, target)) return false
     claimed.add(key)
     providedTargets.delete(name)
     for (const dependency of target.dependencies) {

package/src/swift-standin-emit.ts

@@ -1296,8 +1296,16 @@ export function emitSwiftStandin(
         [...superChain(owner.get(member.identifier.precise) ?? '')].some((at) =>
           options.requiredInits?.has(`${pathOf(byId.get(at)!)}.init()`),
         )
+      // clang imports an init a class takes from a protocol requirement as
+      // required, which a non-final class must declare to conform
+      const protocolInit =
+        member.kind.identifier === 'swift.init' &&
+        /^c:objc\(pl\)\w+\(im\).*::SYNTHESIZED::c:objc\(cs\)/.test(
+          member.identifier.precise,
+        )
       const required =
-        context.inClass && (flags.has('required') || requiredInit || restatesRequired)
+        context.inClass &&
+        (flags.has('required') || requiredInit || restatesRequired || protocolInit)
       const final = context.inClass && flags.has('final') ? 'final ' : ''
       const mutating = flags.has('mutating')
         ? 'mutating '

package/src/swift-standins.ts

@@ -659,9 +659,12 @@ function cxxOnly(surface: Surface): boolean {
   if (surface.kind !== 'c' && surface.kind !== 'objc') return false
   return files(surface.headers, (name) => name.endsWith('.h')).some((file) => {
     const guards: boolean[] = []
-    for (const line of fs
+    // documentation prose such as "class that conforms to" is not a declaration
+    const code = fs
       .readFileSync(path.join(surface.headers, file), 'utf8')
-      .split('\n')) {
+      .replace(/\/\*[\s\S]*?\*\//g, '')
+      .replace(/\/\/.*$/gm, '')
+    for (const line of code.split('\n')) {
       if (/^\s*#\s*if/.test(line))
         guards.push(/__cplusplus/.test(line) && !/!\s*defined|ifndef/.test(line))
       else if (/^\s*#\s*endif/.test(line)) guards.pop()