peachsim 0.1.1635 → 0.1.1640

package/src/swift-host.ts

@@ -15,6 +15,8 @@ import { authHeaderValue, resolveCliAuth } from '../cli/auth'
 import { resolveContrastBackendOrigin } from './backend-origin'
 import { cacheDir } from './home-paths'
 import iosSdk from './ios-sdk-frameworks.json' with { type: 'json' }
+import { type NativeAppIdentity } from './native-app-identity'
+import { readNativeAppIdentityFromXcodeTarget } from './native-app-identity-project'
 import { swiftBinaryModules } from './swift-binary-modules'
 import {
   compileSwiftProjectUnit,
@@ -28,6 +30,7 @@ import {
 } from './swift-compile'
 import { designTimeValues } from './swift-design-time'
 import { swiftDistributionRoot, swiftModuleToolchain } from './swift-distribution'
+import { compileXcodeObjCImplementations } from './swift-objc-compile'
 import {
   swiftImplicitResourcePaths,
   swiftMetalSourceFiles,
@@ -267,7 +270,9 @@ export function openXcodeProject(
   moduleRoot: string | undefined,
   configuration?: string,
 ): string {
-  const app = readXcodeAppTarget(xcodeproj, target, configuration)
+  const app = readXcodeAppTarget(xcodeproj, target, configuration, {
+    prepareGeneratedSources: true,
+  })
   const root = app.rootDir
   xcodeProjects.set(root, {
     xcodeproj,
@@ -312,20 +317,20 @@ function swiftPackages(
   projectGaps: Map<string, string>
   binaries: SwiftPackageBinary[]
 } {
-  const stamp = (file: string | null) =>
-    file && fs.existsSync(file) ? fs.statSync(file).mtimeMs : 0
+  const stamp = (file: string) =>
+    fs.existsSync(file)
+      ? createHash('sha256').update(fs.readFileSync(file)).digest('hex')
+      : null
   const key = JSON.stringify([
     app.linkedProducts,
-    app.packageResolved,
-    stamp(app.packageResolved),
+    app.packageResolved.map((file) => [file, stamp(file)]),
     app.localPackageDirs.map((dir) => stamp(path.join(dir, 'Package.swift'))),
     app.linkedProducts.map(({ source }) =>
       source.kind === 'local' ? stamp(path.join(source.dir, 'Package.swift')) : 0,
     ),
   ])
-  // the package key is cheap stamps; the stand-in key covers the generation
-  // inputs the stamps cannot see (artifact contents, peach's modules, the
-  // emitter), so a changed input rebuilds instead of reusing stale output.
+  // resolution follows lock and manifest contents even when a checkout restores
+  // timestamps. the stand-in key also covers artifacts, peach modules and emitter.
   let cached = entry.packages
   if (cached?.key !== key) {
     const packages = resolveSwiftPackages({
@@ -345,6 +350,13 @@ function swiftPackages(
     }
     entry.packages = cached
   }
+  if (
+    entry.moduleRoot &&
+    [app, ...app.frameworks].some((target) =>
+      target.allSources.some((file) => /\.mm?$/.test(file)),
+    )
+  )
+    compileXcodeObjCImplementations(app, cached.binaries, entry.moduleRoot)
   // a reached binary target with stand-ins for every module it ships
   // resolves as provided, so what depends on it compiles; the rest keep
   // their reason with why no stand-in was built. surfaces peach already
@@ -450,11 +462,26 @@ function xcodeLayout(root: string): XcodeLayout | null {
     registered.xcodeproj,
     registered.target,
     registered.configuration,
+    { prepareGeneratedSources: true },
   )
+  const implementations = [app, ...app.frameworks].flatMap((target) =>
+    target.allSources
+      .filter((file) => /\.mm?$/i.test(file))
+      .map((file) => `${target.name}: ${path.relative(app.rootDir, file)}`),
+  )
+  if (implementations.length > 0 && !registered.moduleRoot)
+    throw new Error(
+      `Peach cannot compile Objective-C implementations in Xcode targets until the runtime and shared Swift object bridge are available:\n${implementations.map((file) => `  ${file}`).join('\n')}`,
+    )
   const appSources = app.allSources.filter(
     (file) => file.endsWith('.swift') || file.endsWith('.metal'),
   )
-  const files = new Set([...app.projectFiles, ...appSources, ...app.resources])
+  const files = new Set([
+    ...app.projectFiles,
+    ...app.packageResolved,
+    ...appSources,
+    ...app.resources,
+  ])
   if (app.infoPlistFile) files.add(app.infoPlistFile)
   const targetDirs = new Map(
     [...appSources, ...app.resources].map((file) => [file, XCODE_APP_DIR]),
@@ -605,10 +632,18 @@ function xcodeManifest(layout: XcodeLayout): string {
 
 // preflight the entire input tree before reading any source or resource bytes.
 // a nested package is a separate compile unit; ignored build trees never enter it.
-function packageFiles(root: string): string[] {
+function packageFiles(root: string, includeBuildInputs = true): string[] {
   const canonicalRoot = fs.realpathSync(root)
   const xcode = xcodeLayout(canonicalRoot)
-  return xcode ? xcode.files : sourceTreeFiles(canonicalRoot, canonicalRoot)
+  if (!xcode) return sourceTreeFiles(canonicalRoot, canonicalRoot)
+  if (includeBuildInputs) return xcode.files
+  const buildInputs = new Set(xcode.app.projectFiles)
+  return xcode.files.filter(
+    (file) =>
+      !buildInputs.has(file) ||
+      xcode.targetDirs.has(file) ||
+      xcode.packages.targets.some((target) => target.files.includes(file)),
+  )
 }
 
 // remote dependencies are enumerated from peach's checkout cache, while app
@@ -668,16 +703,18 @@ function isPackageSource(file: string): boolean {
 }
 
 export function sourceFiles(root: string): string[] {
-  return packageFiles(root).filter(isPackageSource)
+  return packageFiles(root, false).filter(isPackageSource)
 }
 
 // project files and the xcconfigs their settings read are build inputs, never resources
 function resourceCandidateFiles(root: string): string[] {
-  return packageFiles(root).filter(
+  return packageFiles(root, false).filter(
     (file) =>
       !isPackageSource(file) &&
       !file.endsWith('.xcconfig') &&
-      !['project.pbxproj', 'project.xcproj'].includes(path.basename(file)),
+      !['project.pbxproj', 'project.xcproj', 'Package.resolved'].includes(
+        path.basename(file),
+      ),
   )
 }
 
@@ -685,6 +722,7 @@ function resourceCandidateFiles(root: string): string[] {
 export function swiftProjectAppInfo(packagePath: string): {
   name: string
   icon: { bytes: Buffer; contentType: string } | null
+  identity: NativeAppIdentity | null
 } {
   const registered = xcodeProjects.get(packagePath)
   const app = registered
@@ -747,12 +785,17 @@ export function swiftProjectAppInfo(packagePath: string): {
     }
     break
   }
-  return { name: app?.name ?? path.basename(packagePath), icon }
+  return {
+    name: app?.name ?? path.basename(packagePath),
+    icon,
+    identity: app ? readNativeAppIdentityFromXcodeTarget(app) : null,
+  }
 }
 
 // the hosted compile service caps what a project sends it; a local compile
 // reads the author's own files, so nothing caps them there.
 const HOSTED_LIMITS = {
+  sourceBytes: MAX_SWIFT_COMPILE_SOURCE_BYTES,
   resources: MAX_SWIFT_COMPILE_RESOURCES,
   resourceBytes: MAX_SWIFT_COMPILE_RESOURCE_BYTES,
   resourceTotalBytes: MAX_SWIFT_COMPILE_RESOURCE_TOTAL_BYTES,
@@ -761,6 +804,7 @@ const HOSTED_LIMITS = {
   imageTotalBytes: MAX_SWIFT_COMPILE_IMAGE_TOTAL_BYTES,
 }
 const LOCAL_LIMITS: typeof HOSTED_LIMITS = {
+  sourceBytes: Infinity,
   resources: Infinity,
   resourceBytes: Infinity,
   resourceTotalBytes: Infinity,
@@ -969,7 +1013,7 @@ export function buildSwiftBundleFiles(
   const xcode = xcodeLayout(packagePath)
   const bundles =
     xcode?.resourceBundles ??
-    swiftResourceBundles(inputs ?? packageSources(packagePath), relative)
+    swiftResourceBundles(inputs ?? packageSources(packagePath, hosted), relative)
   const addFile = (key: string, bytes: Buffer) => {
     if (
       Object.keys(files).length >= limits.resources ||
@@ -1175,6 +1219,7 @@ export function standinLibraries(
 
 function packageSources(
   packagePath: string,
+  hosted = false,
   linked: ReadonlySet<SwiftStandin> = new Set(),
 ): Record<string, string> {
   const xcode = xcodeLayout(packagePath)
@@ -1184,13 +1229,14 @@ function packageSources(
     ),
   )
   const files: Record<string, string> = {}
+  const limits = inputLimits(hosted)
   for (const file of sourceFiles(packagePath)) {
     const relative = path.relative(packagePath, file).split(path.sep).join(path.posix.sep)
     if (manifests.has(file)) continue
     files[xcode ? xcodeInputKey(xcode, file, relative) : relative] = readPackageFile(
       packagePath,
       file,
-      MAX_SWIFT_COMPILE_SOURCE_BYTES,
+      limits.sourceBytes,
     ).toString('utf8')
   }
   if (xcode) {
@@ -1221,7 +1267,11 @@ function packageSnapshot(project: SwiftProject, entry: string): SwiftPackageSnap
   const linked = layout
     ? standinLibraries(layout.binaries, layout.standins, layout.app.rootDir)
     : new Map<string, SwiftStandin[]>()
-  const files = packageSources(project.packagePath, new Set([...linked.values()].flat()))
+  const files = packageSources(
+    project.packagePath,
+    Boolean(project.hosted),
+    new Set([...linked.values()].flat()),
+  )
   const native = nativeSourceDescriptor(project.packagePath)
   return {
     files,
@@ -1262,7 +1312,7 @@ function packageSnapshot(project: SwiftProject, entry: string): SwiftPackageSnap
           glue: readPackageFile(
             project.packagePath,
             path.join(project.packagePath, NATIVE_GLUE),
-            MAX_SWIFT_COMPILE_SOURCE_BYTES,
+            inputLimits(Boolean(project.hosted)).sourceBytes,
           ).toString('utf8'),
         }
       : {}),
@@ -1411,6 +1461,21 @@ const API_GAP_PATTERNS: [RegExp, (match: RegExpExecArray) => string][] = [
     (match) => `${match[1]}.${match[2]}`,
   ],
   [/^'([^']+)' is unavailable/, (match) => match[1]!],
+  // an instance api Peach declares static, or the reverse
+  [
+    /^(?:static|instance) member '([^']+)' cannot be used on (?:instance of )?type '([^']+)'/,
+    (match) => `${match[2]}.${match[1]}`,
+  ],
+  // an overridable api Peach declares in an extension
+  [
+    /^(?:non-@objc )?[\w ]+ '([^']+)' is declared in extension of '([^']+)' and cannot be overridden/,
+    (match) => `${match[2]}.${match[1]}`,
+  ],
+  // a form of a macro Peach's expansion does not accept
+  [
+    /^(@\w+) requires an initial value/,
+    (match) => `${match[1]} without an initial value`,
+  ],
   [/^no such module '([^']+)'/, (match) => `module ${match[1]}`],
 ]
 
@@ -1425,7 +1490,7 @@ export function swiftApiGapReport(output: string): string | null {
     const file = diagnostic[1]!
       .replace(new RegExp(`^(?:${XCODE_APP_DIR}|${XCODE_FRAMEWORKS_DIR}/[^/]+)/`), '')
       .replace(new RegExp(`^${XCODE_PACKAGES_DIR}/`), '')
-    const message = diagnostic[4]!
+    const message = diagnostic[4]!.trim()
     const rule = API_GAP_PATTERNS.find(([pattern]) => pattern.test(message))
     const key = rule ? rule[1](rule[0].exec(message)!) : message
     const table = rule ? gaps : other
@@ -1726,9 +1791,8 @@ export function swiftPackageWatchFiles(
   packagePath = fs.realpathSync(packagePath)
   return [
     ...(xcodeProjects.has(packagePath) ? [] : [path.join(packagePath, 'Package.swift')]),
-    ...sourceFiles(packagePath),
+    ...packageFiles(packagePath),
     ...nativeSourceFiles(packagePath),
-    ...resourceCandidateFiles(packagePath),
     ...(moduleRoot
       ? swiftModuleInputFiles(moduleRoot).map((file) => path.join(moduleRoot, file))
       : []),
@@ -1744,14 +1808,14 @@ export async function swiftPackageMetadata(
   signal?: AbortSignal,
 ): Promise<SwiftEntryModuleArgs> {
   packagePath = fs.realpathSync(packagePath)
+  const project = projectFor(packagePath, hosted, signal)
+  const limits = inputLimits(Boolean(project.hosted))
   const mains = sourceFiles(packagePath).filter(
     (file) =>
       file.endsWith('.swift') &&
       swiftApplicationEntry(
         file,
-        readPackageFile(packagePath, file, MAX_SWIFT_COMPILE_SOURCE_BYTES).toString(
-          'utf8',
-        ),
+        readPackageFile(packagePath, file, limits.sourceBytes).toString('utf8'),
       ),
   )
   const native = nativeSourceDescriptor(packagePath)
@@ -1760,7 +1824,6 @@ export async function swiftPackageMetadata(
       `swift package ${packageName} needs exactly one application entry source or generated native modules; found ${mains.length}`,
     )
   }
-  const project = projectFor(packagePath, hosted, signal)
   const entry =
     mains.length === 1
       ? path.relative(packagePath, mains[0]).split(path.sep).join(path.posix.sep)

package/src/swift-icu.ts

@@ -4,7 +4,7 @@ import { existsSync, readFileSync } from 'node:fs'
 import path from 'node:path'
 import { promisify } from 'node:util'
 import { gzip } from 'node:zlib'
-import { swiftSdkOptions } from './swift-toolchain.ts'
+import { swiftEnvironment, swiftSdkOptions } from './swift-toolchain.ts'
 
 /**
  * the icu common data a swift artifact reserves and its host fills
@@ -73,17 +73,23 @@ async function load(toolchainBin: string, sdk: string): Promise<Buffer> {
   // missing piece instead of shelling out to sdk configure.
   if (!existsSync(swift))
     throw new Error(`swift-icu: no swift at ${swift} for the ${sdk} SDK's icu data`)
-  const { stdout: listed } = await run(swift, ['sdk', 'list', ...swiftSdkOptions()])
+  const { stdout: listed } = await run(swift, ['sdk', 'list', ...swiftSdkOptions()], {
+    env: swiftEnvironment(),
+  })
   if (!listed.split('\n').some((line) => line.trim() === sdk))
     throw new Error(`swift-icu: ${sdk} is not installed for ${swift}`)
-  const { stdout } = await run(swift, [
-    'sdk',
-    'configure',
-    ...swiftSdkOptions(),
-    '--show-configuration',
-    sdk,
-    'wasm32-unknown-wasip1',
-  ])
+  const { stdout } = await run(
+    swift,
+    [
+      'sdk',
+      'configure',
+      ...swiftSdkOptions(),
+      '--show-configuration',
+      sdk,
+      'wasm32-unknown-wasip1',
+    ],
+    { env: swiftEnvironment() },
+  )
   const resources = /^swiftStaticResourcesPath: (.+)$/m.exec(stdout)?.[1]?.trim()
   if (!resources) throw new Error(`swift-icu: ${sdk} names no static resources`)
   // a copy, so the 42 MB archive it was sliced from can be collected

package/src/swift-objc-compile.ts

@@ -0,0 +1,355 @@
+import { spawnSync } from 'node:child_process'
+import { createHash } from 'node:crypto'
+import fs from 'node:fs'
+import path from 'node:path'
+import { cacheDir } from './home-paths'
+import { swiftSdkPaths, swiftModuleSdk } from './swift-compile'
+import { swiftModuleToolchain } from './swift-distribution'
+import { IOS_SDK_ID, materializeObjcSdk } from './swift-objc-standin'
+import { swiftTargetModuleName } from './swift-package'
+import { swiftPackageManifest, swiftTargetFiles } from './swift-package-manifest'
+import { remoteSwiftCheckouts, type SwiftPackageBinary } from './swift-packages'
+import { readPackageFile } from './swift-source-file'
+import { swiftEnvironment } from './swift-toolchain'
+import type { XcodeAppTarget } from './xcode-project'
+
+/** compile original implementations before any header-derived replacement can hide them.
+ * successful objects still require the canonical framework bridge before linking. */
+export function compileXcodeObjCImplementations(
+  app: XcodeAppTarget,
+  binaries: readonly SwiftPackageBinary[],
+  moduleRoot: string,
+): never {
+  const toolchain = swiftModuleToolchain(moduleRoot)
+  const sdk = swiftSdkPaths(moduleRoot, toolchain.toolchainBin)
+  const sources = new Map<string, Buffer>()
+  const links: Record<string, string> = {}
+  const checkouts = remoteSwiftCheckouts(app.rootDir)
+  const add = (file: string, header = false) => {
+    const resolved = header ? fs.realpathSync(file) : file
+    if (resolved !== file) links[file] = resolved
+    if (!sources.has(file))
+      sources.set(
+        file,
+        readPackageFile(
+          file.startsWith(`${checkouts}${path.sep}`) ? checkouts : app.rootDir,
+          resolved,
+          Infinity,
+        ),
+      )
+  }
+  const addHeaders = (directory: string): void => {
+    for (const entry of fs.readdirSync(directory, { withFileTypes: true })) {
+      const file = path.join(directory, entry.name)
+      if (entry.isDirectory()) addHeaders(file)
+      else if (/\.(h|hh|hpp|hxx|inc|inl|modulemap)$/.test(entry.name)) add(file, true)
+    }
+  }
+  const targets: {
+    name: string
+    deploymentTarget: string | null
+    files: string[]
+    includes: string[]
+    frameworks: string[]
+    flags: string[]
+    cxxFlags: string[]
+    prefix: string | null
+    fileFlags: Record<string, string[]>
+    publicHeaders?: string
+  }[] = []
+  const configuration = app.configuration === 'Debug' ? 'debug' : 'release'
+  for (const binary of binaries) {
+    if (!binary.reached || binary.publicHeaders === undefined) continue
+    const manifest = swiftPackageManifest(binary.dir)
+    const target = manifest.targets.get(binary.target)
+    if (!target)
+      throw new Error(`missing original implementation target ${binary.target}`)
+    const files = swiftTargetFiles(manifest, target)
+    for (const file of files) add(file)
+    addHeaders(path.join(target.dir, target.publicHeadersPath))
+    for (const dependency of binary.headerDependencies ?? [])
+      addHeaders(path.resolve(binary.dir, dependency.path))
+    const settings = target.nativeSettings.filter(
+      (setting) =>
+        setting.configuration === null || setting.configuration === configuration,
+    )
+    targets.push({
+      name: target.name,
+      deploymentTarget: app.iosDeploymentTarget,
+      files: files.filter((file) => /\.(c|cc|cpp|cxx|m|mm)$/.test(file)),
+      includes: [
+        path.join(target.dir, target.publicHeadersPath),
+        ...(binary.headerDependencies ?? []).map((dependency) =>
+          path.resolve(binary.dir, dependency.path),
+        ),
+      ],
+      frameworks: [],
+      // retain the source iOS package's ARC and module semantics on the wasm ABI.
+      flags: [
+        '-fobjc-arc',
+        '-fmodules',
+        '-DSWIFT_PACKAGE',
+        ...(configuration === 'debug' ? ['-DDEBUG'] : []),
+        ...settings
+          .filter((setting) => setting.tool === 'c')
+          .flatMap((setting) => setting.flags),
+      ],
+      cxxFlags: settings
+        .filter((setting) => setting.tool === 'cxx')
+        .flatMap((setting) => setting.flags),
+      prefix: null,
+      fileFlags: {},
+      publicHeaders: path.join(target.dir, target.publicHeadersPath),
+    })
+  }
+  for (const target of [...app.frameworks, app]) {
+    if (!target.objc) continue
+    const files = target.allSources.filter((file) => /\.(c|cc|cpp|cxx|m|mm)$/.test(file))
+    for (const file of files) add(file)
+    for (const file of [
+      ...target.objc.headers,
+      ...[target.objc.prefixHeader, target.objc.bridgingHeader].filter(
+        (file): file is string => file !== null,
+      ),
+    ])
+      add(file, true)
+    targets.push({
+      name: target.moduleName,
+      deploymentTarget: target.iosDeploymentTarget,
+      files,
+      includes: target.objc.headerSearchPaths,
+      frameworks: target.objc.frameworkSearchPaths,
+      flags: target.objc.flags,
+      cxxFlags: target.objc.cxxFlags,
+      prefix: target.objc.prefixHeader,
+      fileFlags: target.objc.fileFlags,
+    })
+  }
+  const digest = (bytes: Buffer | string) =>
+    createHash('sha256').update(bytes).digest('hex')
+  const inputs = Object.fromEntries(
+    [...sources].map(([file, bytes]) => [file, digest(bytes)]),
+  )
+  const identity = {
+    version: 1,
+    release: toolchain.release,
+    compiler: digest(fs.readFileSync(path.join(toolchain.toolchainBin, 'clang'))),
+    sdk: swiftModuleSdk(moduleRoot),
+    declarations: IOS_SDK_ID,
+    targets,
+    inputs,
+    links,
+  }
+  const parent = path.join(cacheDir(), 'swift-objc-implementations')
+  fs.mkdirSync(parent, { recursive: true })
+  const key = digest(JSON.stringify(identity))
+  const work = path.join(parent, key)
+  const resultFile = path.join(work, 'result.json')
+  const record = (value: unknown): value is Record<string, unknown> =>
+    value !== null && typeof value === 'object' && !Array.isArray(value)
+  if (fs.existsSync(work)) {
+    let message: string
+    try {
+      const result: unknown = JSON.parse(
+        readPackageFile(work, resultFile, Infinity).toString(),
+      )
+      if (
+        !record(result) ||
+        result.key !== key ||
+        typeof result.message !== 'string' ||
+        !result.message ||
+        !record(result.files) ||
+        Object.keys(result.files).length < sources.size + 1 ||
+        !('receipt.json' in result.files)
+      )
+        throw new Error('invalid completed receipt')
+      for (const [file, hash] of Object.entries(result.files)) {
+        if (
+          typeof hash !== 'string' ||
+          digest(readPackageFile(work, path.resolve(work, file), Infinity)) !== hash
+        )
+          throw new Error(`retained file changed: ${file}`)
+      }
+      message = result.message
+    } catch (cause) {
+      throw new Error(
+        `Objective-C implementation preparation has an incomplete or damaged receipt at ${work}`,
+        { cause },
+      )
+    }
+    throw new Error(message)
+  }
+  // exclusive creation prevents another caller from writing the same objects.
+  fs.mkdirSync(work)
+  const staged = (file: string): string => {
+    for (const { root, name } of [
+      { root: checkouts, name: 'packages' },
+      { root: app.rootDir, name: 'project' },
+    ]) {
+      const relative = path.relative(root, file)
+      if (
+        relative !== '..' &&
+        !relative.startsWith(`..${path.sep}`) &&
+        !path.isAbsolute(relative)
+      )
+        return path.join(work, name, relative)
+    }
+    // native SDK include paths select the wasm SDK, never host system headers.
+    if (file.startsWith('/usr/include/'))
+      return path.join(sdk.sysroot, 'include', file.slice('/usr/include/'.length))
+    throw new Error(
+      `Objective-C compiler input is outside the project and its pinned packages: ${file}`,
+    )
+  }
+  for (const [file, bytes] of sources) {
+    const output = staged(file)
+    fs.mkdirSync(path.dirname(output), { recursive: true })
+    fs.writeFileSync(output, bytes)
+  }
+  const headers = materializeObjcSdk(path.join(cacheDir(), 'swift-standins'))
+  const modulemaps = targets.flatMap((target, index) => {
+    if (!target.publicHeaders) return []
+    const custom = path.join(target.publicHeaders, 'module.modulemap')
+    if (sources.has(custom)) return [`-fmodule-map-file=${staged(custom)}`]
+    const output = path.join(work, `module-${index}.modulemap`)
+    fs.writeFileSync(
+      output,
+      `module ${swiftTargetModuleName(target.name)} {\n  umbrella ${JSON.stringify(staged(target.publicHeaders))}\n  export *\n}\n`,
+    )
+    return [`-fmodule-map-file=${output}`]
+  })
+  const commands: {
+    target: string
+    source: string
+    args: string[]
+    status: number | null
+    signal: string | null
+    object?: string
+  }[] = []
+  const receipt = path.join(work, 'receipt.json')
+  const save = (status: string) =>
+    fs.writeFileSync(
+      receipt,
+      JSON.stringify({ ...identity, work, status, commands }, null, 2),
+    )
+  const finish = (status: string, message: string): never => {
+    save(status)
+    const files = [
+      ...[...sources.keys()].map(staged),
+      ...modulemaps.map((flag) => flag.slice('-fmodule-map-file='.length)),
+      receipt,
+      ...commands.flatMap((command) => {
+        const output = command.args[command.args.lastIndexOf('-o') + 1]!
+        return [output.replace(/\.o$/, '.log'), ...(command.object ? [output] : [])]
+      }),
+    ]
+    const result = {
+      key,
+      message,
+      files: Object.fromEntries(
+        files.map((file) => [path.relative(work, file), digest(fs.readFileSync(file))]),
+      ),
+    }
+    fs.writeFileSync(`${resultFile}.pending`, JSON.stringify(result, null, 2))
+    fs.renameSync(`${resultFile}.pending`, resultFile)
+    throw new Error(message)
+  }
+  save('compiling')
+  for (const [index, target] of targets.entries()) {
+    const version = /^(\d{1,2})(?:\.(\d{1,2}))?(?:\.(\d{1,2}))?$/.exec(
+      target.deploymentTarget ?? '',
+    )
+    if (!version) {
+      return finish(
+        'unsupported-deployment-target',
+        `${target.name}: Objective-C compilation requires an explicit numeric IPHONEOS_DEPLOYMENT_TARGET; received ${JSON.stringify(target.deploymentTarget)}. Inputs: ${receipt}`,
+      )
+    }
+    const minimum =
+      Number(version[1]) * 10_000 +
+      Number(version[2] ?? 0) * 100 +
+      Number(version[3] ?? 0)
+    for (const [unit, file] of target.files.entries()) {
+      const output = path.join(work, `${index}-${unit}.o`)
+      const cxx = /\.(mm|cc|cpp|cxx)$/.test(file)
+      const objc = /\.mm?$/.test(file)
+      const flags = [
+        ...target.flags.filter(
+          (flag) =>
+            (!cxx || !flag.startsWith('-std=')) && (objc || flag !== '-fobjc-arc'),
+        ),
+        ...(cxx ? target.cxxFlags : []),
+        ...(target.fileFlags[file] ?? []),
+      ].map((flag, index, flags) => {
+        if (
+          ['-I', '-F', '-iquote', '-isystem', '-include'].includes(flags[index - 1] ?? '')
+        )
+          return staged(flag)
+        const include = /^(-I|-F)(\/.*)$/.exec(flag)
+        return include ? `${include[1]}${staged(include[2]!)}` : flag
+      })
+      const args = [
+        '--target=wasm32-unknown-wasip1',
+        `--sysroot=${sdk.sysroot}`,
+        '-fwasm-exceptions',
+        '-fexceptions',
+        '-D_WASI_EMULATED_SIGNAL',
+        '-D_WASI_EMULATED_MMAN',
+        `-D__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__=${minimum}`,
+        `-D__IPHONE_OS_VERSION_MIN_REQUIRED=${minimum}`,
+        ...(objc ? ['-fobjc-runtime=gnustep-2.2', '-fobjc-exceptions', '-fblocks'] : []),
+        '-F',
+        path.join(headers, 'System/Library/Frameworks'),
+        // installed libc and objc runtime headers own the target ABI.
+        '-idirafter',
+        path.join(headers, 'usr/include'),
+        ...target.includes.flatMap((include) => ['-I', staged(include)]),
+        ...target.frameworks.flatMap((framework) => ['-F', staged(framework)]),
+        ...modulemaps,
+        `-fmodule-name=${swiftTargetModuleName(target.name)}`,
+        `-fmodules-cache-path=${path.join(work, 'module-cache')}`,
+        ...flags,
+        ...(target.prefix ? ['-include', staged(target.prefix)] : []),
+        '-Os',
+        '-c',
+        staged(file),
+        '-o',
+        output,
+      ]
+      const result = spawnSync(
+        path.join(toolchain.toolchainBin, cxx ? 'clang++' : 'clang'),
+        args,
+        {
+          cwd: work,
+          encoding: 'utf8',
+          env: swiftEnvironment(),
+          timeout: 120_000,
+          maxBuffer: 16 * 1024 * 1024,
+        },
+      )
+      fs.writeFileSync(
+        path.join(work, `${index}-${unit}.log`),
+        `${result.stdout ?? ''}${result.stderr ?? ''}${result.error?.message ?? ''}`,
+      )
+      commands.push({
+        target: target.name,
+        source: file,
+        args,
+        status: result.status,
+        signal: result.signal,
+        ...(result.status === 0 ? { object: digest(fs.readFileSync(output)) } : {}),
+      })
+      if (result.error || result.status !== 0) {
+        return finish(
+          'compile-failed',
+          `Objective-C implementation compile failed in ${target.name}: ${file}\n${result.stderr || result.stdout || result.error?.message}\nOriginal inputs, compiler command and diagnostics: ${receipt}`,
+        )
+      }
+      save('compiling')
+    }
+  }
+  return finish(
+    'requires-framework-bridge',
+    `Objective-C implementations compiled, but linking their original method bodies requires the canonical Swift framework object bridge. No implementation was replaced. Inputs and objects: ${receipt}`,
+  )
+}