peachsim 0.1.1640 → 0.1.1644

package/src/swift-objc-compile.ts

@@ -5,14 +5,25 @@ import path from 'node:path'
 import { cacheDir } from './home-paths'
 import { swiftSdkPaths, swiftModuleSdk } from './swift-compile'
 import { swiftModuleToolchain } from './swift-distribution'
+import {
+  compileObjcPeerMetadata,
+  ObjcPeerMetadataError,
+  validateObjcPeerClasses,
+} from './swift-objc-metadata'
 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 {
+  SwiftObjCImplementationPreparation,
+  SwiftObjCPeerClass,
+} from './swiftContract'
 import type { XcodeAppTarget } from './xcode-project'
 
+export class SwiftObjCCompilationError extends Error {}
+
 /** compile original implementations before any header-derived replacement can hide them.
  * successful objects still require the canonical framework bridge before linking. */
 export function compileXcodeObjCImplementations(
@@ -20,6 +31,33 @@ export function compileXcodeObjCImplementations(
   binaries: readonly SwiftPackageBinary[],
   moduleRoot: string,
 ): never {
+  const prepared = prepareXcodeObjCImplementations(app, binaries, moduleRoot)
+  throw new SwiftObjCCompilationError(
+    `Objective-C implementations compiled, but linking their original method bodies requires the canonical Swift framework object bridge. No implementation was replaced. Inputs and objects: ${prepared.receipt}`,
+  )
+}
+
+// a link's target, or null when the target is proven absent; other failures surface.
+function linkedStat(file: string): fs.Stats | null {
+  try {
+    return fs.statSync(file)
+  } catch (error) {
+    if (error instanceof Error && 'code' in error && error.code === 'ENOENT') return null
+    throw error
+  }
+}
+
+const isSdkInclude = (file: string): boolean =>
+  file === '/usr/include' || file.startsWith('/usr/include/')
+
+/** prepares genuine objects without authorizing unsupported framework linkage. */
+export function prepareXcodeObjCImplementations(
+  app: XcodeAppTarget,
+  binaries: readonly SwiftPackageBinary[],
+  moduleRoot: string,
+  peers?: readonly SwiftObjCPeerClass[],
+): SwiftObjCImplementationPreparation {
+  if (peers) validateObjcPeerClasses(peers)
   const toolchain = swiftModuleToolchain(moduleRoot)
   const sdk = swiftSdkPaths(moduleRoot, toolchain.toolchainBin)
   const sources = new Map<string, Buffer>()
@@ -38,12 +76,24 @@ export function compileXcodeObjCImplementations(
         ),
       )
   }
+  const walked = new Set<string>()
+  const ancestors = new Set<string>()
   const addHeaders = (directory: string): void => {
+    // a versioned framework links Headers to a real directory: stage each path it is reached by, once, never around a link cycle.
+    const real = fs.realpathSync(directory)
+    if (walked.has(directory) || ancestors.has(real)) return
+    walked.add(directory)
+    ancestors.add(real)
     for (const entry of fs.readdirSync(directory, { withFileTypes: true })) {
+      if (entry.name.startsWith('.') && !entry.isFile()) continue
       const file = path.join(directory, entry.name)
-      if (entry.isDirectory()) addHeaders(file)
+      // a link to nothing is never opened by the compiler: a header that is needed fails there as not found.
+      const linked = entry.isSymbolicLink() ? linkedStat(file) : null
+      if (entry.isSymbolicLink() && !linked) continue
+      if (entry.isDirectory() || linked?.isDirectory()) addHeaders(file)
       else if (/\.(h|hh|hpp|hxx|inc|inl|modulemap)$/.test(entry.name)) add(file, true)
     }
+    ancestors.delete(real)
   }
   const targets: {
     name: string
@@ -66,13 +116,26 @@ export function compileXcodeObjCImplementations(
       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))
+    // explicit sources select compile units, not the private headers they include.
+    addHeaders(target.dir)
     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,
     )
+    const nativeFlags = settings.flatMap((setting) => setting.flags)
+    for (const [index, flag] of nativeFlags.entries()) {
+      const directory = ['-I', '-iquote', '-isystem'].includes(
+        nativeFlags[index - 1] ?? '',
+      )
+        ? flag
+        : /^-I(.+)$/.exec(flag)?.[1]
+      if (directory) {
+        const include = path.resolve(target.dir, directory)
+        if (fs.existsSync(include)) addHeaders(include)
+      }
+    }
     targets.push({
       name: target.name,
       deploymentTarget: app.iosDeploymentTarget,
@@ -113,6 +176,12 @@ export function compileXcodeObjCImplementations(
       ),
     ])
       add(file, true)
+    // search paths name directories of headers the target includes; /usr/include maps to the wasm sysroot.
+    for (const directory of [
+      ...target.objc.headerSearchPaths,
+      ...target.objc.frameworkSearchPaths,
+    ])
+      if (!isSdkInclude(directory) && fs.existsSync(directory)) addHeaders(directory)
     targets.push({
       name: target.moduleName,
       deploymentTarget: target.iosDeploymentTarget,
@@ -131,7 +200,9 @@ export function compileXcodeObjCImplementations(
     [...sources].map(([file, bytes]) => [file, digest(bytes)]),
   )
   const identity = {
-    version: 1,
+    version: 8,
+    peers,
+    metadataDeploymentTarget: peers ? app.iosDeploymentTarget : undefined,
     release: toolchain.release,
     compiler: digest(fs.readFileSync(path.join(toolchain.toolchainBin, 'clang'))),
     sdk: swiftModuleSdk(moduleRoot),
@@ -144,212 +215,363 @@ export function compileXcodeObjCImplementations(
   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)
+  const descriptor = fs.openSync(`${work}.lock`, 'a')
+  try {
+    // the inherited descriptor keeps the kernel lock after perl exits.
+    const locked = spawnSync(
+      'perl',
+      ['-e', 'open(my $f, ">&=", 3) or die $!; flock($f, 2) or die $!'],
+      { stdio: ['ignore', 'pipe', 'pipe', descriptor], encoding: 'utf8' },
+    )
+    if (locked.error || locked.status !== 0)
+      throw new Error(
+        `Could not lock Objective-C implementation inputs: ${locked.error?.message ?? locked.stderr}`,
       )
-        throw new Error('invalid completed receipt')
-      for (const [file, hash] of Object.entries(result.files)) {
+    const resultFile = path.join(work, 'result.json')
+    const preparation = (): SwiftObjCImplementationPreparation => ({
+      receipt: path.join(work, 'receipt.json'),
+      objects: targets.flatMap((target, index) =>
+        target.files.map((source, unit) => ({
+          target: target.name,
+          source,
+          file: path.join(work, `${index}-${unit}.o`),
+        })),
+      ),
+      ...(peers
+        ? {
+            metadata: path.join(work, 'peer-metadata.o'),
+            registration: path.join(work, 'peer-registration.swift'),
+          }
+        : {}),
+    })
+    const record = (value: unknown): value is Record<string, unknown> =>
+      value !== null && typeof value === 'object' && !Array.isArray(value)
+    if (fs.existsSync(work)) {
+      let message: string | undefined
+      let interrupted = false
+      let prepared = false
+      try {
+        const result: unknown = JSON.parse(
+          readPackageFile(work, resultFile, Infinity).toString(),
+        )
+        if (
+          !record(result) ||
+          result.key !== key ||
+          typeof result.reusable !== 'boolean' ||
+          typeof result.prepared !== 'boolean' ||
+          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}`)
+        }
+        if (result.prepared) {
+          for (const file of [
+            ...preparation().objects.map((object) => object.file),
+            ...(peers
+              ? [
+                  'peer-metadata.o',
+                  'peer-metadata.m',
+                  'peer-metadata.log',
+                  'peer-metadata.json',
+                  'peer-registration.swift',
+                ].map((file) => path.join(work, file))
+              : []),
+          ])
+            if (!(path.relative(work, file) in result.files))
+              throw new Error(`missing prepared object or metadata input: ${file}`)
+          prepared = true
+        } else if (result.reusable) message = result.message
+        else interrupted = true
+      } catch {
+        // no writer can remain under this kernel lock; rebuild invalid proof.
+        fs.rmSync(work, { recursive: true })
+      }
+      if (prepared) return preparation()
+      if (message !== undefined) throw new SwiftObjCCompilationError(message)
+      // retain the first and latest complete interruptions for this input identity.
+      if (interrupted) {
+        const first = `${work}-interrupted-first`
+        const destination = fs.existsSync(first) ? `${work}-interrupted-latest` : first
+        fs.rmSync(destination, { recursive: true, force: true })
+        fs.renameSync(work, destination)
+      }
+    }
+    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 (
-          typeof hash !== 'string' ||
-          digest(readPackageFile(work, path.resolve(work, file), Infinity)) !== hash
+          relative !== '..' &&
+          !relative.startsWith(`..${path.sep}`) &&
+          !path.isAbsolute(relative)
         )
-          throw new Error(`retained file changed: ${file}`)
+          return path.join(work, name, relative)
       }
-      message = result.message
-    } catch (cause) {
+      // native SDK include paths select the wasm SDK, never host system headers.
+      if (isSdkInclude(file))
+        return path.join(sdk.sysroot, 'include', file.slice('/usr/include'.length))
       throw new Error(
-        `Objective-C implementation preparation has an incomplete or damaged receipt at ${work}`,
-        { cause },
+        `Objective-C compiler input is outside the project and its pinned packages: ${file}`,
       )
     }
-    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)
+    for (const [file, bytes] of sources) {
+      const output = staged(file)
+      fs.mkdirSync(path.dirname(output), { recursive: true })
+      fs.writeFileSync(output, bytes)
     }
-    // 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',
+    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,
-      ]
-      const result = spawnSync(
-        path.join(toolchain.toolchainBin, cxx ? 'clang++' : 'clang'),
-        args,
-        {
-          cwd: work,
-          encoding: 'utf8',
-          env: swiftEnvironment(),
-          timeout: 120_000,
-          maxBuffer: 16 * 1024 * 1024,
-        },
+        `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
+      error?: string
+      object?: string
+    }[] = []
+    const receipt = path.join(work, 'receipt.json')
+    const save = (status: string) =>
       fs.writeFileSync(
-        path.join(work, `${index}-${unit}.log`),
-        `${result.stdout ?? ''}${result.stderr ?? ''}${result.error?.message ?? ''}`,
+        receipt,
+        JSON.stringify({ ...identity, work, status, commands }, null, 2),
+      )
+    let metadataFiles: string[] = []
+    const complete = (
+      status: string,
+      message: string,
+      reusable = true,
+      additionalFiles: string[] = [],
+    ): void => {
+      save(status)
+      const files = [
+        ...[...sources.keys()].map(staged),
+        ...modulemaps.map((flag) => flag.slice('-fmodule-map-file='.length)),
+        receipt,
+        ...metadataFiles,
+        ...additionalFiles,
+        ...commands.flatMap((command) => {
+          const output = command.args[command.args.lastIndexOf('-o') + 1]!
+          return [output.replace(/\.o$/, '.log'), ...(command.object ? [output] : [])]
+        }),
+      ]
+      const result = {
+        key,
+        message,
+        reusable,
+        prepared: status === 'prepared',
+        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)
+    }
+    const finish = (
+      status: string,
+      message: string,
+      reusable = true,
+      metadataFiles: string[] = [],
+    ): never => {
+      complete(status, message, reusable, metadataFiles)
+      throw new SwiftObjCCompilationError(message)
+    }
+    save('compiling')
+    const minimumFor = (target: {
+      name: string
+      deploymentTarget: string | null
+    }): number => {
+      const version = /^(\d{1,2})(?:\.(\d{1,2}))?(?:\.(\d{1,2}))?$/.exec(
+        target.deploymentTarget ?? '',
       )
-      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) {
+      if (!version) {
         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}`,
+          '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)
+      return minimum
+    }
+    if (targets.length === 0)
+      return finish(
+        'missing-target',
+        'Objective-C preparation requires an original implementation target',
+      )
+    const minimums = targets.map(minimumFor)
+    if (peers) {
+      try {
+        metadataFiles = compileObjcPeerMetadata({
+          classes: peers,
+          work,
+          headerCache: path.join(cacheDir(), 'swift-standins'),
+          toolchainBin: toolchain.toolchainBin,
+          sysroot: sdk.sysroot,
+          minimum: minimumFor({
+            name: app.moduleName,
+            deploymentTarget: app.iosDeploymentTarget,
+          }),
+          descriptor,
+        }).files
+      } catch (error) {
+        if (error instanceof ObjcPeerMetadataError)
+          return finish(
+            error.reusable ? 'metadata-failed' : 'metadata-interrupted',
+            error.message,
+            error.reusable,
+            error.files,
+          )
+        throw error
+      }
+    }
+    const failures: string[] = []
+    let interrupted = false
+    compile: for (const [index, target] of targets.entries()) {
+      const minimum = minimums[index]!
+      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',
+            stdio: ['ignore', 'pipe', 'pipe', descriptor],
+            env: swiftEnvironment(),
+            timeout: 120_000,
+            maxBuffer: 16 * 1024 * 1024,
+          },
         )
+        const diagnostics = `${result.stdout ?? ''}${result.stderr ?? ''}${result.error ? `\n${result.error.message}` : ''}${result.signal ? `\nClang terminated by ${result.signal}` : ''}`
+        fs.writeFileSync(path.join(work, `${index}-${unit}.log`), diagnostics)
+        commands.push({
+          target: target.name,
+          source: file,
+          args,
+          status: result.status,
+          signal: result.signal,
+          ...(result.error ? { error: result.error.message } : {}),
+          ...(!result.error && !result.signal && result.status === 0
+            ? { object: digest(fs.readFileSync(output)) }
+            : {}),
+        })
+        if (result.error || result.signal || result.status !== 0) {
+          failures.push(
+            `${target.name}: ${file}\n${diagnostics.trimEnd() || `Clang exited with status ${result.status}`}`,
+          )
+          // clang's driver also returns 1 when its frontend crashes or cannot write.
+          if (
+            result.error ||
+            result.signal ||
+            result.status !== 1 ||
+            /^(?:PLEASE submit a bug report|LLVM ERROR:|(?:clang(?:\+\+)?(?:-\d+)?: )?(?:fatal )?error: (?:error in backend:|unable to (?:execute command|open output file|make temporary file)|.*command failed))/m.test(
+              result.stderr ?? '',
+            )
+          ) {
+            interrupted = true
+            break compile
+          }
+        }
+        save('compiling')
       }
-      save('compiling')
     }
+    if (failures.length > 0) {
+      const selected = targets.reduce((count, target) => count + target.files.length, 0)
+      const successes = commands.filter((command) => command.object !== undefined).length
+      return finish(
+        interrupted ? 'compile-interrupted' : 'compile-failed',
+        [
+          interrupted
+            ? `Objective-C implementation compilation interrupted after ${commands.length} of ${selected} translation units; this attempt will not be reused.`
+            : `Objective-C implementation compilation failed in ${failures.length} of ${selected} translation units.`,
+          `${successes} successful object${successes === 1 ? '' : 's'} retained.`,
+          ...failures,
+          `Original inputs, compiler commands and diagnostics: ${receipt}`,
+        ].join('\n\n'),
+        !interrupted,
+      )
+    }
+    complete(
+      'prepared',
+      'Original Objective-C objects prepared; framework linkage remains unqualified.',
+      true,
+    )
+    return preparation()
+  } finally {
+    fs.closeSync(descriptor)
   }
-  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}`,
-  )
 }