peachsim 0.1.1641 → 0.1.1653

package/src/swift-compile.ts

@@ -1,4 +1,9 @@
-import { spawn, execFileSync, type ExecFileOptions } from 'node:child_process'
+import {
+  spawn,
+  execFileSync,
+  type ExecFileOptions,
+  type SpawnOptions,
+} from 'node:child_process'
 import { createHash } from 'node:crypto'
 import {
   cpSync,
@@ -15,8 +20,10 @@ import {
 } from 'node:fs'
 import os from 'node:os'
 import path from 'node:path'
+import yaml from 'yaml'
 import { admittedMacBuilderSlot } from './admitted-mac-build'
 import { rnxHomeDir, swiftPackageCacheOptions } from './home-paths'
+import { isRecord } from './is-record'
 import { terminateProcessGroup } from './process-group'
 import { swiftCompilerSourceDigest } from './swift-compiler-digest'
 import { designTimeDiagnostic, designTimeSource } from './swift-design-time'
@@ -26,16 +33,38 @@ import {
   type SwiftDistributionManifest,
 } from './swift-distribution-contract'
 import { swiftIcuAsset, type SwiftIcuAsset } from './swift-icu'
+import { swiftObjCExports } from './swift-objc-export'
+import { swiftObjCImports, swiftObjCPrivateImports } from './swift-objc-import'
+import { validateObjcPeerStartupLibraries } from './swift-objc-metadata'
+import { materializeObjcSdk, objcView } from './swift-objc-standin'
 import {
+  OBJC_RESOURCE_ACCESSOR_BODY,
+  OBJC_RESOURCE_ACCESSOR_HEADER,
   swiftManifestCxxLanguageStandard,
   swiftManifestTargets,
+  swiftObjCResourceAccessor,
+  swiftObjCResourceBundleName,
   swiftPackagePartition,
   swiftTargetModuleName,
   type SwiftPackageTarget,
 } from './swift-package'
-import { withSwiftRootLock } from './swift-root-lock'
-import { swiftEnvironment, swiftSdkOptions, type SwiftWasmSdk } from './swift-toolchain'
-import { isSwiftResourceBundles } from './swiftContract'
+import { withSwiftRootLock, type SwiftRootLease } from './swift-root-lock'
+import {
+  swiftEnvironment,
+  swiftSdkOptions,
+  swiftToolchain,
+  type SwiftWasmSdk,
+} from './swift-toolchain'
+import {
+  isSwiftNativeTargets,
+  isSwiftObjCPeerStartup,
+  isSwiftResourceBundles,
+  SWIFT_NATIVE_INPUT_ROOT,
+  SWIFT_NATIVE_SDK_INCLUDE,
+  type SwiftNativeTarget,
+  type SwiftObjCPeerStartup,
+  type SwiftProjectPreparation,
+} from './swiftContract'
 import type { SwiftImageUpload } from './swift-submit'
 import type { SwiftResourceBundle } from './swiftContract'
 
@@ -43,27 +72,32 @@ export { swiftIcuAsset, type SwiftIcuAsset }
 
 // compiler drivers own descendants such as admission and swiftpm workers.
 // cancellation waits for their pipes to close before releasing the build root.
+// a `lease` records the group under the root's lock, so the root stays held
+// while the compiler lives even if this process does not.
 // `stream` echoes the output as it arrives: all of it, or only matching lines.
 // a successful run then echoes the rest minus lines matching `quiet`, its
 // warnings; a failed run's output goes to the caller's one diagnostic.
 async function runCompiler(
   command: string,
   args: string[],
-  options: ExecFileOptions & { signal?: AbortSignal },
+  options: ExecFileOptions & { signal?: AbortSignal; lease?: SwiftRootLease },
   stream: boolean | RegExp = false,
   quiet?: RegExp,
-): Promise<void> {
+): Promise<string> {
   const { signal } = options
   signal?.throwIfAborted()
-  const child = spawn(command, args, {
+  const launch = {
     cwd: options.cwd,
     env: swiftEnvironment(options.env),
     detached: true,
-    stdio: ['ignore', 'pipe', 'pipe'],
-  })
+    stdio: ['ignore', 'pipe', 'pipe'] as ['ignore', 'pipe', 'pipe'],
+  } satisfies SpawnOptions
+  const child = options.lease
+    ? options.lease.spawn(command, args, launch)
+    : spawn(command, args, launch)
   let stopping: Promise<void> | undefined
   try {
-    await new Promise<void>((resolve, reject) => {
+    return await new Promise<string>((resolve, reject) => {
       let failure: Error | undefined
       let timeout: ReturnType<typeof setTimeout> | undefined
       const chunks: Record<'stdout' | 'stderr', Buffer[]> = { stdout: [], stderr: [] }
@@ -119,7 +153,7 @@ async function runCompiler(
             for (const name of ['stdout', 'stderr'] as const)
               for (const line of Buffer.concat(chunks[name]).toString().split('\n'))
                 if (line && !quiet.test(line)) process[name].write(`${line}\n`)
-          resolve()
+          resolve(Buffer.concat(chunks.stdout).toString())
         }
       })
       if (options.timeout)
@@ -134,7 +168,7 @@ async function runCompiler(
   }
 }
 
-const WASM_TRIPLE = 'wasm32-unknown-wasip1'
+export const WASM_TRIPLE = 'wasm32-unknown-wasip1'
 
 // swiftpm's step counter, echoed while a build runs; its diagnostics print
 // once, with the failure.
@@ -151,6 +185,8 @@ const BUILD_JOBS = String(
 
 export interface SwiftCompileInput {
   files: Record<string, string>
+  objcPeerStartup?: SwiftObjCPeerStartup
+  nativeTargets?: SwiftNativeTarget[]
   metalSources?: Record<string, string>
   resources?: Record<string, string>
   /** project-relative resource paths retained before the bundle namespace flattens. */
@@ -828,6 +864,8 @@ export function swiftArtifactHash(
       [...(input.resourceBundles ?? [])].sort((a, b) => a.target.localeCompare(b.target)),
     ),
   )
+  hash.update(JSON.stringify(input.nativeTargets ?? []))
+  hash.update(JSON.stringify(input.objcPeerStartup ?? null))
   for (const target of Object.keys(input.libraries ?? {}).sort()) {
     hash.update(`library\n${target}\n`)
     hash.update(
@@ -854,9 +892,13 @@ export function swiftArtifactHash(
 interface SwiftNativeTargetPlan {
   path: string
   includeDirectory: string
+  sources: string[]
   // units that consume a swift-generated header: excluded from the original
   // target and compiled by the downstream implementation target.
   lateSources: string[]
+  mixed?: boolean
+  exclude?: string[]
+  groups?: { name: string; sources: string[]; flags: string[]; cxxFlags: string[] }[]
   late?: { name: string; producers: string[] }
 }
 
@@ -865,6 +907,7 @@ export function emitSwiftPackageManifest(args: {
   cxxLanguageStandard?: string
   native?: Map<string, SwiftNativeTargetPlan>
   headerDirectory?: string
+  objcExports?: { modules: Set<string>; flags: string[] }
   siblings: Map<string, string[]>
   moduleRoot: string
   oneModule?: boolean
@@ -943,6 +986,9 @@ export function emitSwiftPackageManifest(args: {
       ? ' .defaultIsolation(MainActor.self),'
       : ''
     const interoperability = target.cxxInterop ? ' .interoperabilityMode(.Cxx),' : ''
+    const exports = args.objcExports?.modules.has(target.name)
+      ? ' .enableExperimentalFeature("Extern"),'
+      : ''
     const defines = (target.defines ?? [])
       .map((name) => ` .define(${JSON.stringify(name)}),`)
       .join('')
@@ -959,8 +1005,9 @@ export function emitSwiftPackageManifest(args: {
       ? `, "-I", ${JSON.stringify(path.join(moduleRoot, 'modules'))}`
       : ''
     const native = args.native?.get(target.name)
+    const clang = native && !native.mixed
     const nativeImports = (siblings.get(target.name) ?? [])
-      .filter((name) => args.native?.has(name))
+      .filter((name) => args.native?.has(name) && !args.native.get(name)?.mixed)
       .map(
         (name) =>
           `, "-Xfrontend", "-import-module", "-Xfrontend", ${JSON.stringify(swiftTargetModuleName(name))}`,
@@ -971,30 +1018,54 @@ export function emitSwiftPackageManifest(args: {
       [...(args.native?.values() ?? [])].some((value) =>
         value.late?.producers.includes(target.name),
       )
-        ? `, "-emit-objc-header-path", ${JSON.stringify(path.join(args.headerDirectory, `${target.name}-Swift.h`))}`
+        ? `, "-emit-objc-header-path", ${JSON.stringify(path.join(args.headerDirectory, `${target.name}-${args.objcExports?.modules.has(target.name) ? 'Cxx' : 'Swift'}.h`))}`
         : ''
-    const swiftSettings = `swiftSettings: [.swiftLanguageMode(.v${target.languageMode}),${isolation}${interoperability}${defines} .unsafeFlags(["-Osize", "-Xfrontend", "-enable-cross-import-overlays"${overlayFlags}${FOUNDATION_IMPLICIT_FLAGS}${oneModule ? ONE_IMPLICIT_FLAGS : ''}${imports}${nativeImports}${header}])]`
+    const swiftSettings = `swiftSettings: [.swiftLanguageMode(.v${target.languageMode}),${isolation}${interoperability}${defines}${exports} .unsafeFlags(["-Osize", "-Xfrontend", "-enable-cross-import-overlays"${overlayFlags}${FOUNDATION_IMPLICIT_FLAGS}${oneModule ? ONE_IMPLICIT_FLAGS : ''}${imports}${nativeImports}${header}])]`
     const deps = [
-      ...(target.executable
-        ? [...(args.native?.values() ?? [])].flatMap((value) =>
-            value.late ? [JSON.stringify(value.late.name)] : [],
+      ...new Set([
+        ...(target.executable
+          ? [
+              ...new Set([
+                ...(args.objcExports?.modules ?? []),
+                ...[...(args.native?.values() ?? [])].flatMap(
+                  (value) => value.late?.producers ?? [],
+                ),
+              ]),
+            ]
+              .filter((name) => name !== target.name)
+              .map((name) => JSON.stringify(name))
+          : []),
+        ...(target.executable && args.objcExports ? ['"PeachSwiftObjCExports"'] : []),
+        ...(target.executable
+          ? [...(args.native?.values() ?? [])].flatMap((value) =>
+              value.late
+                ? (value.groups ?? [{ name: value.late.name }]).map((group) =>
+                    JSON.stringify(group.name),
+                  )
+                : [],
+            )
+          : []),
+        ...(distribution || (clang && !target.executable)
+          ? []
+          : [
+              '.product(name: "SwiftUI", package: "sootsim-swift")',
+              ...(oneModule ? [ONE_PRODUCT] : []),
+              ...(spriteKit ? [SPRITEKIT_PRODUCT] : []),
+            ]),
+        ...(siblings.get(target.name) ?? []).flatMap((dependency) =>
+          clang &&
+          [...(args.native?.values() ?? [])].some((value) =>
+            value.late?.producers.includes(dependency),
           )
-        : []),
-      ...(distribution || (native && !target.executable)
-        ? []
-        : [
-            '.product(name: "SwiftUI", package: "sootsim-swift")',
-            ...(oneModule ? [ONE_PRODUCT] : []),
-            ...(spriteKit ? [SPRITEKIT_PRODUCT] : []),
-          ]),
-      ...(siblings.get(target.name) ?? []).flatMap((dependency) =>
-        OPTIONAL_FRAMEWORKS.has(dependency) &&
-        !targets.some((candidate) => candidate.name === dependency)
-          ? distribution
             ? []
-            : [`.product(name: "${dependency}", package: "sootsim-swift")`]
-          : [`"${dependency}"`],
-      ),
+            : OPTIONAL_FRAMEWORKS.has(dependency) &&
+                !targets.some((candidate) => candidate.name === dependency)
+              ? distribution
+                ? []
+                : [`.product(name: "${dependency}", package: "sootsim-swift")`]
+              : [`"${dependency}"`],
+        ),
+      ]),
     ].join(', ')
     const library =
       distribution && distributionLink
@@ -1017,7 +1088,7 @@ export function emitSwiftPackageManifest(args: {
       linkerSettings: [
         ${linkedLibraries.map((setting) => `${setting},`).join('\n        ')}
         .unsafeFlags([
-          ${REACTOR_FLAG}${EXECUTABLE_LINK_FLAGS}          "-Xlinker", "--export-if-defined=__main_argc_argv"${library},
+          ${REACTOR_FLAG}${EXECUTABLE_LINK_FLAGS}          "-Xlinker", "--export-if-defined=__main_argc_argv"${args.objcExports ? ', "-Xlinker", "--fatal-warnings"' : ''}${library},
         ]),
         .unsafeFlags(["-Xlinker", "--strip-all"], .when(configuration: .release)),
       ]`
@@ -1030,10 +1101,12 @@ export function emitSwiftPackageManifest(args: {
       `      name: "${target.name}",`,
       `      dependencies: [${deps}],`,
       `      path: "${target.path}",`,
-      ...(native ? [`      exclude: ${JSON.stringify(native.lateSources)},`] : []),
+      ...(native
+        ? [`      exclude: ${JSON.stringify(native.exclude ?? native.lateSources)},`]
+        : []),
       // the native backend supplies dependency module maps without their
       // compiled modules. textual c++ includes keep those dependencies usable.
-      `      ${native ? `cxxSettings: [${defines} .unsafeFlags(["-fno-cxx-modules"])]` : swiftSettings}${link}`,
+      `      ${clang ? `${args.objcExports ? `cSettings: [.unsafeFlags(${JSON.stringify(args.objcExports.flags)})], ` : ''}cxxSettings: [${defines} .unsafeFlags(["-fno-cxx-modules"])]` : swiftSettings}${link}`,
       `    ),`,
     ].join('\n')
   }
@@ -1050,16 +1123,40 @@ export function emitSwiftPackageManifest(args: {
     `  dependencies: [${distribution ? '' : `.package(path: "${moduleRoot}")`}],`,
     '  targets: [',
     ...targets.map(stanza),
+    ...(args.objcExports
+      ? [
+          '    .target(name: "PeachSwiftObjCExports",',
+          '      dependencies: [],',
+          '      path: "PeachObjCExports",',
+          `      sources: ${JSON.stringify(['root.m', ...[...args.objcExports.modules].map((name) => `${name}.m`)])},`,
+          '      publicHeadersPath: "include",',
+          `      cSettings: [.unsafeFlags(${JSON.stringify([...args.objcExports.flags.filter((flag) => flag !== '-fobjc-arc'), '-fno-objc-arc', '-Xclang', '-disable-objc-default-synthesize-properties'])})]),`,
+        ]
+      : []),
     ...[...(args.native?.entries() ?? [])].flatMap(([name, native]) =>
       native.late
-        ? [
-            `    .target(name: ${JSON.stringify(native.late.name)},`,
-            `      dependencies: ${JSON.stringify([name, ...native.late.producers])},`,
+        ? (
+            native.groups ?? [
+              {
+                name: native.late.name,
+                sources: native.lateSources,
+                flags: [],
+                cxxFlags: [],
+              },
+            ]
+          ).flatMap((group) => [
+            `    .target(name: ${JSON.stringify(group.name)},`,
+            `      dependencies: ${JSON.stringify(args.native?.get(name)?.mixed ? [] : [name])},`,
             `      path: ${JSON.stringify(native.path)},`,
-            `      sources: ${JSON.stringify(native.lateSources)},`,
+            `      sources: ${JSON.stringify(group.sources)},`,
             `      publicHeadersPath: "include",`,
-            `      cxxSettings: [.unsafeFlags(["-fno-cxx-modules", "-I", ${JSON.stringify(native.includeDirectory)}, "-I", ${JSON.stringify(args.headerDirectory)}])]),`,
-          ]
+            ...(args.objcExports
+              ? [
+                  `      cSettings: [.unsafeFlags(${JSON.stringify([...args.objcExports.flags, ...group.flags])})],`,
+                ]
+              : []),
+            `      cxxSettings: [.unsafeFlags(${JSON.stringify(['-fno-cxx-modules', '-I', native.includeDirectory, '-I', args.headerDirectory, ...group.cxxFlags])})]),`,
+          ])
         : [],
     ),
     args.cxxLanguageStandard
@@ -2304,6 +2401,68 @@ const SDK_OBJC_OPTIONAL: Record<
     ][]
   }
 > = {
+  UIAdaptivePresentationControllerDelegate: {
+    mainActor: true,
+    parents: [],
+    requirements: [
+      [
+        'presentationControllerShouldDismiss(_:)',
+        'presentationControllerShouldDismiss:',
+        'UIPresentationController->Bool',
+      ],
+      [
+        'presentationControllerWillDismiss(_:)',
+        'presentationControllerWillDismiss:',
+        'UIPresentationController->Void',
+      ],
+      [
+        'presentationControllerDidDismiss(_:)',
+        'presentationControllerDidDismiss:',
+        'UIPresentationController->Void',
+      ],
+      [
+        'presentationControllerDidAttemptToDismiss(_:)',
+        'presentationControllerDidAttemptToDismiss:',
+        'UIPresentationController->Void',
+      ],
+      [
+        'adaptivePresentationStyle(for:)',
+        'adaptivePresentationStyleForPresentationController:',
+        'UIPresentationController->UIModalPresentationStyle',
+      ],
+      [
+        'adaptivePresentationStyle(for:traitCollection:)',
+        'adaptivePresentationStyleForPresentationController:traitCollection:',
+        'UIPresentationController,UITraitCollection->UIModalPresentationStyle',
+      ],
+      [
+        'presentationController(_:willPresentWithAdaptiveStyle:transitionCoordinator:)',
+        'presentationController:willPresentWithAdaptiveStyle:transitionCoordinator:',
+        'UIPresentationController,UIModalPresentationStyle,(UIViewControllerTransitionCoordinator)?->Void',
+      ],
+    ],
+  },
+  UIPopoverPresentationControllerDelegate: {
+    mainActor: true,
+    parents: ['UIAdaptivePresentationControllerDelegate'],
+    requirements: [
+      [
+        'popoverPresentationControllerShouldDismissPopover(_:)',
+        'popoverPresentationControllerShouldDismissPopover:',
+        'UIPopoverPresentationController->Bool',
+      ],
+      [
+        'popoverPresentationControllerDidDismissPopover(_:)',
+        'popoverPresentationControllerDidDismissPopover:',
+        'UIPopoverPresentationController->Void',
+      ],
+      [
+        'prepareForPopoverPresentation(_:)',
+        'prepareForPopoverPresentation:',
+        'UIPopoverPresentationController->Void',
+      ],
+    ],
+  },
   WKWebExtensionWindow: {
     callers: true,
     mainActor: true,
@@ -5511,6 +5670,87 @@ export function swiftApplicationEntry(file: string, source: string): boolean {
   return false
 }
 
+// swift's executable entry runs after the reactor's _initialize has completed.
+// global swift values remain lazy; native application initializers need separate
+// object evidence and are refused here rather than running the registry early.
+function installObjcPeerStartup(
+  input: SwiftCompileInput,
+  targets: SwiftPackageTarget[],
+  compiled: Map<string, string>,
+): void {
+  const startup = input.objcPeerStartup
+  if (!startup) return
+  function fail(detail: string): never {
+    throw new Error(`Objective-C peer startup: ${detail}`)
+  }
+  if (
+    (input.nativeTargets?.length ?? 0) > 0 ||
+    Object.keys(input.files).some((file) => /\.(?:c|cc|cpp|cxx|m|mm)$/.test(file))
+  )
+    fail('original native source targets require constructor provenance before admission')
+  validateObjcPeerStartupLibraries(input.libraries ?? {})
+  const executables = targets.filter((target) => target.executable)
+  if (executables.length !== 1)
+    fail('requires one executable application entry; library startup is unqualified')
+  const target = executables[0]!
+  const prefix = target.path === '.' ? '' : `${target.path}/`
+  const belongs = (file: string): boolean =>
+    file.startsWith(prefix) &&
+    !targets.some(
+      (other) =>
+        other !== target &&
+        other.path !== '.' &&
+        other.path.startsWith(prefix) &&
+        file.startsWith(`${other.path}/`),
+    )
+  if (
+    !belongs(input.entry) ||
+    !belongs(startup.registration) ||
+    !compiled.has(startup.registration) ||
+    startup.registration === input.entry
+  )
+    fail('generated registration and entry must belong to the same executable target')
+  for (const [file, source] of compiled) {
+    if (/@_(?:section|used)\b/.test(swiftCodeMask(source)))
+      fail(`${file} contains unqualified pre-main Swift storage`)
+  }
+  const entries = [...compiled].filter(
+    ([file, source]) => belongs(file) && /@main\b/.test(swiftCodeMask(source)),
+  )
+  if (entries.length === 0) {
+    const source = compiled.get(input.entry)
+    if (path.basename(input.entry) !== 'main.swift' || source === undefined)
+      fail('requires main.swift or a supported @main App/UIApplicationDelegate entry')
+    compiled.set(input.entry, `_peachRegisterObjcPeers()\n${source}`)
+    return
+  }
+  if (entries.length !== 1 || entries[0]![0] !== input.entry)
+    fail('requires the exact single @main application entry')
+  const [file, source] = entries[0]!
+  const code = swiftCodeMask(source)
+  const attribute = /@main\b/.exec(code)!
+  const nominal = /\b(?:struct|class|enum)\s+([A-Za-z_]\w*)[^{}]*\{/.exec(
+    code.slice(attribute.index),
+  )
+  if (
+    !nominal ||
+    /\bstatic\s+func\s+main\s*\([^)]*\)[^{]*\b(?:async|throws|rethrows)\b/.test(code)
+  )
+    fail('generic, async or throwing application entries are unqualified')
+  if (/\b(?:struct|class|enum)\s+\w+\s*</.test(nominal[0]))
+    fail('generic application entries are unqualified')
+  const generated = `${prefix}PeachObjCPeerStartup.generated.swift`
+  if (compiled.has(generated)) fail('generated entry conflicts with application sources')
+  compiled.set(
+    file,
+    source.slice(0, attribute.index) + '     ' + source.slice(attribute.index + 5),
+  )
+  compiled.set(
+    generated,
+    `@main struct __PeachObjCPeerStartupEntry {\n  @MainActor static func main() {\n    _peachRegisterObjcPeers()\n    ${nominal[1]}.main()\n  }\n}\n`,
+  )
+}
+
 // the offsets of the lines that begin in code, and of every `@`, `#`,
 // `class`, `extension` and `override` keyword that stands in code (an interpolation's code included), from a scan of Swift's
 // lexical contexts: nested block comments, line comments, string literals (single and
@@ -5685,7 +5925,14 @@ export function writeSwiftProject(
   layout: SwiftProjectLayout,
   input: SwiftCompileInput,
   moduleRoot: string,
-): void {
+): SwiftProjectPreparation {
+  if (
+    input.objcPeerStartup !== undefined &&
+    !isSwiftObjCPeerStartup(input.objcPeerStartup)
+  )
+    throw new Error('swift compile input has invalid Objective-C peer startup metadata')
+  if (input.nativeTargets !== undefined && !isSwiftNativeTargets(input.nativeTargets))
+    throw new Error('swift compile input has invalid original clang target inputs')
   if (
     input.resourceBundles !== undefined &&
     !isSwiftResourceBundles(input.resourceBundles)
@@ -5713,7 +5960,54 @@ export function writeSwiftProject(
       : compileTargets(input)
   const files = new Map<string, string | Buffer>()
   const native = new Map<string, SwiftNativeTargetPlan>()
+  const bySourcePath = [...targets].sort(
+    (left, right) => right.path.length - left.path.length,
+  )
+  const swiftTargets = new Set<string>()
+  for (const file of Object.keys(input.files)) {
+    if (!file.endsWith('.swift')) continue
+    const target = bySourcePath.find(
+      (candidate) => candidate.path === '.' || file.startsWith(`${candidate.path}/`),
+    )
+    if (target) swiftTargets.add(target.name)
+  }
   const headerDirectory = path.join(layout.root, '.build', 'peach-cxx-headers')
+  const headerModuleDirectory = path.join(
+    layout.root,
+    '.build',
+    'peach-objc-export-modules',
+  )
+  const imports = new Map<
+    string,
+    {
+      view: ReturnType<typeof objcView>
+      classes: string[]
+      headers: string[]
+      foreignTypes: Map<string, string>
+    }
+  >()
+  // headers keep their original project paths. product headers additionally
+  // occupy the same Module/Header.h namespace that xcode publishes.
+  for (const settings of input.nativeTargets ?? []) {
+    for (const file of settings.headers) {
+      const contents = input.files[file]
+      if (contents === undefined)
+        throw new Error(`missing original Objective-C header ${file}`)
+      const destination = path.join(layout.root, file)
+      mkdirSync(path.dirname(destination), { recursive: true })
+      writeFileSync(destination, contents)
+      files.set(destination, contents)
+    }
+    for (const header of settings.publicHeaders) {
+      const destination = path.join(headerDirectory, settings.name, path.basename(header))
+      if (files.has(destination))
+        throw new Error(`duplicate product header ${destination}`)
+      const contents = `#import ${JSON.stringify(path.join(layout.root, header))}\n`
+      files.set(destination, contents)
+      mkdirSync(path.dirname(destination), { recursive: true })
+      writeFileSync(destination, contents)
+    }
+  }
   // declarations are imported before swift can emit the header that native
   // implementations consume. give those implementations a downstream target.
   for (const target of targets) {
@@ -5729,9 +6023,232 @@ export function writeSwiftProject(
             file.startsWith(`${candidate.path}/`),
         ),
     )
-    if (entries.some(([file]) => file.endsWith('.swift'))) continue
     const units = entries.filter(([file]) => /\.(?:c|cc|cpp|cxx|m|mm)$/.test(file))
     if (units.length === 0) continue
+    const settings = input.nativeTargets?.find((value) => value.name === target.name)
+    if (
+      entries.some(([file]) => file.endsWith('.swift')) ||
+      (settings && units.some(([file]) => /\.mm?$/.test(file)))
+    ) {
+      if (!settings)
+        throw new Error(
+          `mixed target ${target.name} requires its original native target settings; SwiftPM does not compile mixed source targets`,
+        )
+      const headers = settings.headers
+      const roots = settings.bridgingHeader
+        ? [settings.bridgingHeader]
+        : settings.publicHeaders
+      if (!roots.length)
+        throw new Error(`mixed target ${target.name} has no original declaration headers`)
+      for (const file of headers) {
+        const destination = path.join(layout.root, file)
+        mkdirSync(path.dirname(destination), { recursive: true })
+        writeFileSync(destination, input.files[file]!)
+      }
+      const search = [
+        ...new Set([
+          ...(settings?.headerSearchPaths ?? []),
+          ...headers.map((file) => path.posix.dirname(file)),
+        ]),
+      ].flatMap((dir) => ['-I', path.join(layout.root, dir)])
+      const pin: { release: string } =
+        distribution ??
+        JSON.parse(readFileSync(path.join(moduleRoot, 'toolchain.json'), 'utf8'))
+      const release = pin.release
+      const toolchainBin = swiftToolchain(release, swiftModuleSdk(moduleRoot))
+      const sdkHeaders = materializeObjcSdk(
+        path.join(layout.root, '.build', 'peach-objc-sdk'),
+      )
+      const stageFlags = (flags: readonly string[], sdkInclude: string) =>
+        flags.map((flag) =>
+          flag
+            .replaceAll(SWIFT_NATIVE_INPUT_ROOT, layout.root)
+            .replaceAll(SWIFT_NATIVE_SDK_INCLUDE, sdkInclude),
+        )
+      const originalFlags = [
+        ...(settings?.flags ?? []),
+        ...search,
+        ...(settings?.frameworkSearchPaths ?? []).flatMap((dir) => [
+          '-F',
+          path.join(layout.root, dir),
+        ]),
+        '-I',
+        headerDirectory,
+      ]
+      const flags = stageFlags(
+        originalFlags,
+        path.join(swiftSdkPaths(moduleRoot, toolchainBin).sysroot, 'include'),
+      )
+      const prefixHeader = settings?.prefixHeader
+        ? ['-include', path.join(layout.root, settings.prefixHeader)]
+        : []
+      // swiftpm gives a native resource target's units an accessor header and
+      // one more unit defining it. the swift accessor below stays for swift.
+      const bundleName = entries.some(([file]) => file.endsWith('.swift'))
+        ? undefined
+        : swiftObjCResourceBundleName({
+            target: target.name,
+            path: target.path,
+            resources:
+              resourceTargets.find((candidate) => candidate.name === target.name)
+                ?.resources ?? false,
+            usesBundleMacro: entries.some(
+              ([file, contents]) =>
+                /\.(?:c|cc|cpp|cxx|m|mm|h|hpp|hh|hxx)$/.test(file) &&
+                /\bSWIFTPM_MODULE_BUNDLE\b/.test(contents),
+            ),
+            bundles: input.resourceBundles,
+          })
+      const accessor =
+        bundleName === undefined ? undefined : swiftObjCResourceAccessor(bundleName)
+      const accessorHeader = path.join(
+        layout.root,
+        target.path,
+        OBJC_RESOURCE_ACCESSOR_HEADER,
+      )
+      const accessorUnit = `${prefix}${OBJC_RESOURCE_ACCESSOR_BODY}`
+      if (
+        accessor &&
+        (input.files[accessorUnit] !== undefined ||
+          input.files[`${prefix}${OBJC_RESOURCE_ACCESSOR_HEADER}`] !== undefined)
+      )
+        throw new Error(`target ${target.name} already contains its resource accessor`)
+      const nativeUnits: [string, string][] = accessor
+        ? [...units, [accessorUnit, accessor.body]]
+        : units
+      const accessorFlags = accessor ? ['-include', accessorHeader] : []
+      if (accessor) {
+        files.set(accessorHeader, accessor.header)
+        files.set(path.join(layout.root, accessorUnit), accessor.body)
+      }
+      const sourceHeaders = path.join(
+        layout.root,
+        '.build',
+        'peach-objc-originals',
+        target.name,
+      )
+      mkdirSync(sourceHeaders, { recursive: true })
+      const modulemap = path.join(sourceHeaders, 'module.modulemap')
+      writeFileSync(
+        modulemap,
+        `module ${swiftTargetModuleName(target.name)} {\n${roots.map((file) => `header ${JSON.stringify(path.join(layout.root, file))}`).join('\n')}\nexport *\n}\n`,
+      )
+      const view = objcView(
+        { module: swiftTargetModuleName(target.name), headers: sourceHeaders, modulemap },
+        toolchainBin,
+        path.join(moduleRoot, 'ios-simulator-stdlib'),
+        path.join(layout.root, '.build', 'peach-objc-sdk'),
+        path.join(layout.root, '.build', 'peach-objc-imports', target.name),
+        {
+          flags: stageFlags(originalFlags, path.join(sdkHeaders, 'usr/include')),
+          target: `arm64-apple-ios${settings?.deploymentTarget ?? '16.0'}-simulator`,
+        },
+      )
+      const defined = new Set<string>()
+      const declarations = (node: unknown): void => {
+        if (!node || typeof node !== 'object') return
+        const name: unknown = Reflect.get(node, 'name')
+        if (
+          Reflect.get(node, 'kind') === 'ObjCInterfaceDecl' &&
+          Reflect.get(node, 'super') &&
+          typeof name === 'string'
+        )
+          defined.add(name)
+        const children: unknown = Reflect.get(node, 'inner')
+        if (Array.isArray(children)) for (const child of children) declarations(child)
+      }
+      declarations(view.clangAST)
+      const foreignTypes = new Map<string, string>()
+      for (const graph of view.graphs)
+        for (const symbol of graph.symbols) {
+          const nativeName = /^c:objc\(cs\)(\w+)$/.exec(symbol.identifier.precise)?.[1]
+          if (nativeName && defined.has(nativeName))
+            foreignTypes.set(symbol.pathComponents[0]!, nativeName)
+        }
+      imports.set(target.name, {
+        view,
+        classes: [...foreignTypes.values()],
+        headers: roots.map((file) => path.join(layout.root, file)),
+        foreignTypes,
+      })
+      const thunk = 'PeachObjCImports.generated.m'
+      const groups = new Map<
+        string,
+        { name: string; sources: string[]; flags: string[]; cxxFlags: string[] }
+      >()
+      for (const [file] of nativeUnits) {
+        const origin = settings?.sourceDirectories[file]
+        if (origin) mkdirSync(path.join(layout.root, origin), { recursive: true })
+        const perFile = [
+          ...(origin ? ['-iquote', path.join(layout.root, origin)] : []),
+          ...stageFlags(
+            settings?.fileFlags[file] ?? [],
+            path.join(swiftSdkPaths(moduleRoot, toolchainBin).sysroot, 'include'),
+          ),
+        ]
+        const cxx = /\.(?:cc|cpp|cxx|mm)$/.test(file)
+        const identity = createHash('sha256')
+          .update(JSON.stringify([cxx, perFile]))
+          .digest('hex')
+          .slice(0, 12)
+        const group = groups.get(identity) ?? {
+          name: `${target.name}SwiftImplementation_${identity}`,
+          sources: [],
+          flags: [...flags, ...prefixHeader, ...accessorFlags, ...perFile],
+          cxxFlags: [
+            ...flags,
+            ...prefixHeader,
+            ...accessorFlags,
+            ...stageFlags(
+              cxx ? settings.cxxFlags : [],
+              path.join(swiftSdkPaths(moduleRoot, toolchainBin).sysroot, 'include'),
+            ),
+            ...perFile,
+          ],
+        }
+        group.sources.push(file.slice(prefix.length))
+        groups.set(identity, group)
+      }
+      groups.set('imports', {
+        name: `${target.name}ObjCImports`,
+        sources: [thunk],
+        flags: [...flags, '-fobjc-arc'],
+        cxxFlags: [...flags, '-fobjc-arc'],
+      })
+      const include = path.join(layout.root, target.path, 'include')
+      files.set(
+        path.join(include, 'module.modulemap'),
+        `module ${target.name}ImplementationDeclarations { export * }\n`,
+      )
+      native.set(target.name, {
+        mixed: true,
+        path: target.path,
+        includeDirectory: include,
+        sources: nativeUnits.map(([file]) => file.slice(prefix.length)),
+        lateSources: [...nativeUnits.map(([file]) => file.slice(prefix.length)), thunk],
+        exclude: [
+          ...entries
+            .filter(([file]) => !file.endsWith('.swift') && !file.endsWith('.metal'))
+            .map(([file]) => file.slice(prefix.length)),
+          ...(accessor
+            ? [OBJC_RESOURCE_ACCESSOR_HEADER, OBJC_RESOURCE_ACCESSOR_BODY]
+            : []),
+          thunk,
+          'include',
+        ],
+        groups: [...groups.values()],
+        late: {
+          name: `${target.name}SwiftImplementation`,
+          producers: [
+            target.name,
+            ...(target.dependencies ?? [])
+              .filter((dependency) => swiftTargets.has(dependency.name))
+              .map((dependency) => dependency.name),
+          ],
+        },
+      })
+      continue
+    }
     const includes = `${prefix}include/`
     const consumers = new Map<string, Set<string>>()
     const reverse = new Map<string, string[]>()
@@ -5739,7 +6256,9 @@ export function writeSwiftProject(
       const producers = new Set<string>()
       // a block-commented include is not an edge.
       const source = contents.replace(/\/\*[\s\S]*?\*\//g, '')
-      for (const match of source.matchAll(/^\s*#\s*include\s*[<"]([^>"]+)[>"]/gm)) {
+      for (const match of source.matchAll(
+        /^\s*#\s*(?:include|import)\s*[<"]([^>"]+)[>"]/gm,
+      )) {
         const include = match[1]!
         const producer = /(?:^|\/)([^/]+)-Swift\.h$/.exec(include)?.[1]
         if (producer && targets.some((value) => value.name === producer))
@@ -5768,6 +6287,7 @@ export function writeSwiftProject(
     native.set(target.name, {
       path: target.path,
       includeDirectory: path.join(layout.root, includes),
+      sources: units.map(([file]) => file.slice(prefix.length)),
       lateSources: late.map(([file]) => file.slice(prefix.length)),
       ...(late.length > 0
         ? {
@@ -5841,6 +6361,247 @@ export function writeSwiftProject(
     ),
     targets,
   )
+  installObjcPeerStartup(
+    input,
+    layout.multi ? targets : targets.map((target) => ({ ...target, path: '.' })),
+    compiled,
+  )
+  // an application's swift module must precede its native implementations.
+  // the tiny executable calls the original typed entry after both are linked.
+  for (const target of [...targets]) {
+    if (
+      !target.executable ||
+      ![...native.values()].some((value) => value.late?.producers.includes(target.name))
+    )
+      continue
+    const prefix = target.path === '.' ? '' : `${target.path}/`
+    const entries = [...compiled].filter(
+      ([file]) =>
+        file.startsWith(prefix) &&
+        !targets.some(
+          (candidate) =>
+            candidate.name !== target.name &&
+            candidate.path !== '.' &&
+            candidate.path.startsWith(prefix) &&
+            file.startsWith(`${candidate.path}/`),
+        ),
+    )
+    const mains = entries.flatMap(([file, source]) => {
+      const match = /@main\b[\s\S]*?\b(?:struct|class|enum)\s+([A-Za-z_]\w*)/.exec(
+        swiftCodeMask(source),
+      )
+      return match ? [{ file, source, match }] : []
+    })
+    if (mains.length !== 1)
+      throw new Error(
+        `mixed executable ${target.name} requires one typed Swift application entry`,
+      )
+    const main = mains[0]!
+    compiled.set(
+      main.file,
+      main.source.slice(0, main.match.index) +
+        '     ' +
+        main.source.slice(main.match.index + 5) +
+        `\n@MainActor public func __peachRunApplication() { ${main.match[1]}.main() }\n`,
+    )
+    const name = `${target.name}Executable`
+    if (targets.some((candidate) => candidate.name === name))
+      throw new Error(`mixed application executable target conflicts with ${name}`)
+    target.executable = false
+    targets.push({
+      ...target,
+      name,
+      path: `PeachApplication/${name}`,
+      executable: true,
+      resources: false,
+      dependencies: [{ kind: 'target', name: target.name }],
+      exclude: [],
+    })
+    files.set(
+      path.join(layout.root, `PeachApplication/${name}/Entry.swift`),
+      `import ${swiftTargetModuleName(target.name)}\n@main struct __PeachApplicationEntry { @MainActor static func main() { __peachRunApplication() } }\n`,
+    )
+  }
+  // genuine objective-c consumers receive declarations and implementations from
+  // one typed export plan. the swift compiler emits their C function prototypes.
+  const objcProducers = new Set<string>()
+  for (const name of imports.keys()) objcProducers.add(name)
+  for (const [name, plan] of native) {
+    if (!plan.late) continue
+    if (plan.lateSources.some((file) => /\.mm?$/.test(file)))
+      for (const producer of plan.late.producers) objcProducers.add(producer)
+  }
+  const objcModules = new Set<string>()
+  const registrations: string[] = []
+  const registeredClasses = new Set<string>(['NSObject'])
+  let rootOwner: string | undefined
+  for (const name of objcProducers) {
+    const target = targets.find((value) => value.name === name)!
+    const prefix = target.path === '.' ? '' : `${target.path}/`
+    const exported = swiftObjCExports({
+      module: swiftTargetModuleName(name),
+      sources: Object.entries(input.files).filter(
+        ([file]) =>
+          file.startsWith(prefix) &&
+          file.endsWith('.swift') &&
+          !targets.some(
+            (candidate) =>
+              candidate.name !== name &&
+              candidate.path !== '.' &&
+              candidate.path.startsWith(prefix) &&
+              file.startsWith(`${candidate.path}/`),
+          ) &&
+          !target.exclude?.some(
+            (excluded) =>
+              file.slice(prefix.length) === excluded ||
+              file.slice(prefix.length).startsWith(`${excluded}/`),
+          ),
+      ),
+      mask: swiftCodeMask,
+      declarationStart,
+      selector: objcSelectorName,
+      foreignTypes: imports.get(name)?.foreignTypes,
+    })
+    const original = imports.get(name)
+    if (!exported && !original) continue
+    objcModules.add(name)
+    rootOwner ??= exported
+      ? [...exported.swift.keys()][0]
+      : `${prefix}PeachObjCImports.generated.swift`
+    files.set(
+      path.join(headerDirectory, `${name}-Swift.h`),
+      exported?.header ?? '#pragma once\n',
+    )
+    files.set(
+      path.join(headerDirectory, name, `${name}-Swift.h`),
+      `#include "../${name}-Swift.h"\n`,
+    )
+    files.set(
+      path.join(headerModuleDirectory, name, 'module.modulemap'),
+      `module ${swiftTargetModuleName(name)} {\n${[
+        path.join(headerDirectory, `${name}-Swift.h`),
+        ...(
+          input.nativeTargets?.find((target) => target.name === name)?.publicHeaders ?? []
+        ).map((header) => path.join(layout.root, header)),
+      ]
+        .map((header) => `  header ${JSON.stringify(header)}`)
+        .join('\n')}\n  export *\n}\n`,
+    )
+    files.set(
+      path.join(layout.root, 'PeachObjCExports', `${name}.m`),
+      exported?.implementation ?? `#include "${name}-Cxx.h"\n`,
+    )
+    if (exported) registrations.push(exported.registration)
+    for (const type of exported?.types.values() ?? []) registeredClasses.add(type)
+    for (const type of original?.classes ?? []) registeredClasses.add(type)
+    for (const [file, text] of exported?.swift ?? [])
+      compiled.set(file, compiled.get(file)! + text)
+    if (original) {
+      const generated = swiftObjCImports(original.view.graphs, {
+        module: swiftTargetModuleName(name),
+        headers: original.headers,
+        classes: original.classes,
+        clangAST: original.view.clangAST,
+        peerTypes: exported?.types,
+      })
+      const register = `_peach_objc_imports_${swiftTargetModuleName(name)}`
+      files.set(
+        path.join(layout.root, target.path, 'PeachObjCImports.generated.swift'),
+        generated.swift +
+          generated.registration +
+          `\n@_cdecl("${register}") public func __peachRegisterOriginalObjC() { ${generated.registerFunction}() }\n`,
+      )
+      files.set(
+        path.join(layout.root, target.path, 'PeachObjCImports.generated.m'),
+        generated.objc,
+      )
+      registrations.push(`${register}();`)
+    }
+  }
+  let objcExports: { modules: Set<string>; flags: string[] } | undefined
+  if (rootOwner && input.objcPeerStartup)
+    throw new Error(
+      'Objective-C peer startup: joining framework metadata with source exports requires one qualified root registration',
+    )
+  if (rootOwner) {
+    if (
+      targets.some((target) => target.name === 'PeachSwiftObjCExports') ||
+      Object.keys(input.files).some((file) => file.startsWith('PeachObjCExports/'))
+    )
+      throw new Error(
+        'Swift Objective-C export target conflicts with application sources',
+      )
+    const ownerFile = path.join(layout.root, rootOwner)
+    const ownerSource = compiled.get(rootOwner) ?? files.get(ownerFile)
+    if (typeof ownerSource !== 'string')
+      throw new Error('Objective-C root registration has no owning Swift source')
+    files.set(
+      ownerFile,
+      ownerSource +
+        `
+@_extern(c, "_peach_objc_register_all_exports") private func __peachRegisterAllExports()
+private let __peachExportRegistration: Void = { __peachRegisterAllExports() }()
+@_cdecl("_peach_objc_ensure_exports")
+public func __peachEnsureExportRegistration() { _ = __peachExportRegistration }
+@_cdecl("_peach_objc_export_root")
+public func __peachObjcExportRoot() { _objcRegisterPeerClass(NSObject.self, nativeName: "NSObject") }
+`,
+    )
+    if (compiled.has(rootOwner)) compiled.set(rootOwner, files.get(ownerFile)!.toString())
+    files.set(
+      path.join(layout.root, 'PeachObjCExports', 'include', 'module.modulemap'),
+      'module PeachSwiftObjCExports { export * }\n',
+    )
+    files.set(
+      path.join(layout.root, 'PeachObjCExports', 'root.m'),
+      [
+        '#import <Foundation/Foundation.h>',
+        'extern void _peach_objc_ensure_exports(void);',
+        'extern void *_peach_objc_allocate_foreign(void *);',
+        '@implementation NSObject',
+        '+ (void)initialize { _peach_objc_ensure_exports(); }',
+        '+ (instancetype)alloc { return (__bridge id)_peach_objc_allocate_foreign((__bridge void *)self); }',
+        '+ (instancetype)new { return [[self alloc] init]; }',
+        '- (instancetype)init { return self; }',
+        '@end',
+        'extern void _peach_objc_export_root(void);',
+        ...registrations.flatMap((text) =>
+          [...text.matchAll(/(\w+)\(\);/g)].map(
+            (match) => `extern void ${match[1]}(void);`,
+          ),
+        ),
+        'extern void _peach_objc_register_private_implementations(void);',
+        'void _peach_objc_register_all_exports(void) {',
+        '_peach_objc_export_root();',
+        ...registrations,
+        '_peach_objc_register_private_implementations();',
+        '}',
+        '',
+      ].join('\n'),
+    )
+    const headers = materializeObjcSdk(path.join(layout.root, '.build', 'peach-objc-sdk'))
+    objcExports = {
+      modules: objcModules,
+      flags: [
+        '-fobjc-runtime=gnustep-2.2',
+        '-fobjc-exceptions',
+        '-fexceptions',
+        '-fwasm-exceptions',
+        '-fobjc-arc',
+        '-fblocks',
+        '-F',
+        path.join(headers, 'System/Library/Frameworks'),
+        '-idirafter',
+        path.join(headers, 'usr/include'),
+        '-I',
+        headerDirectory,
+        ...[...objcModules].map(
+          (name) =>
+            `-fmodule-map-file=${path.join(headerModuleDirectory, name, 'module.modulemap')}`,
+        ),
+      ],
+    }
+  }
   if (targets.length === 0) {
     for (const [file, contents] of Object.entries(input.files)) {
       if (file === 'Package.swift') continue
@@ -5912,6 +6673,7 @@ export function writeSwiftProject(
       emitSwiftPackageManifest({
         targets,
         native,
+        objcExports,
         headerDirectory: native.size > 0 ? headerDirectory : undefined,
         cxxLanguageStandard: swiftManifestCxxLanguageStandard(
           input.files['Package.swift'] ?? '',
@@ -5957,7 +6719,42 @@ export function writeSwiftProject(
       ].join('\n'),
     )
   }
+  for (const [file, source] of compiled)
+    if (!Object.hasOwn(input.files, file))
+      files.set(path.join(layout.multi ? layout.root : layout.sources, file), source)
   syncSwiftTree(layout.root, files)
+  const producers = [
+    ...new Set([
+      ...objcProducers,
+      ...[...native.values()].flatMap((value) => value.late?.producers ?? []),
+    ]),
+  ]
+  const dependencies = swiftTargetDependencies(input.files, targets)
+  const included = new Set<string>()
+  const include = (name: string): void => {
+    if (included.has(name)) return
+    included.add(name)
+    for (const dependency of dependencies.get(name) ?? []) include(dependency)
+  }
+  for (const producer of producers)
+    for (const dependency of dependencies.get(producer) ?? []) include(dependency)
+  // building a producer also emits its dependency producers' headers.
+  return {
+    headerProducers: producers.filter((name) => !included.has(name)),
+    ...(rootOwner && objcExports
+      ? {
+          objcImplementations: {
+            owner: path.join(layout.root, rootOwner),
+            registeredClasses: [...registeredClasses],
+            units: [...native.values()].flatMap((value) =>
+              value.sources
+                .filter((file) => /\.mm?$/.test(file))
+                .map((file) => path.join(layout.root, value.path, file)),
+            ),
+          },
+        }
+      : {}),
+  }
 }
 
 function streamText(value: unknown): string {
@@ -6242,7 +7039,7 @@ export function compileSwiftProjectUnit(
       // using it, so one process writes, builds and reads them at a time.
       return withSwiftRootLock(
         root,
-        async () => {
+        async (lease) => {
           // a process that held the root while this one waited may have built
           // this exact address.
           const built = readCompiledArtifact(path.join(sharedRoot, 'artifact'), hash)
@@ -6250,7 +7047,7 @@ export function compileSwiftProjectUnit(
             report('reusing verified disk artifact')
             return retain(root, built)
           }
-          writeSwiftProject(layout, input, moduleRoot)
+          const preparation = writeSwiftProject(layout, input, moduleRoot)
           const swift = path.join(options.toolchainBin, 'swift')
           if (!existsSync(swift)) {
             throw new Error(
@@ -6314,9 +7111,91 @@ export function compileSwiftProjectUnit(
             maxBuffer: 64 * 1024 * 1024,
             timeout: options.timeoutMs,
             signal: options.signal,
+            lease,
           }
           report('compiling and linking Swift modules')
           try {
+            // clang consumes the real emitted headers after swift finishes.
+            // swiftpm's transitive swift module maps are not C declarations:
+            // importing them would shadow SDK modules such as ObjectiveC.
+            for (const producer of preparation.headerProducers) {
+              await runCompiler(
+                swift,
+                [...buildArgs, '--target', producer],
+                buildOptions,
+                SWIFTPM_PROGRESS,
+                SWIFTPM_NOISE,
+              )
+            }
+            if (preparation.objcImplementations) {
+              const plan = preparation.objcImplementations
+              // the producer build writes the complete native build graph. use
+              // its exact per-unit clang argv, including swiftpm's settings.
+              const manifest: unknown = yaml.parse(
+                readFileSync(path.join(root, '.build', 'release.yaml'), 'utf8'),
+              )
+              if (!isRecord(manifest) || !isRecord(manifest.commands))
+                throw new Error('missing SwiftPM native compiler commands')
+              const commands = new Map<string, string[]>()
+              const selected = new Set(plan.units)
+              for (const command of Object.values(manifest.commands)) {
+                if (
+                  !isRecord(command) ||
+                  command.tool !== 'clang' ||
+                  !Array.isArray(command.inputs)
+                )
+                  continue
+                for (const file of command.inputs) {
+                  if (typeof file !== 'string' || !selected.has(file)) continue
+                  if (
+                    commands.has(file) ||
+                    !Array.isArray(command.args) ||
+                    !command.args.length ||
+                    !command.args.every((arg: unknown) => typeof arg === 'string')
+                  )
+                    throw new Error(`invalid SwiftPM compiler command for ${file}`)
+                  commands.set(file, command.args)
+                }
+              }
+              async function* implementationASTs(): AsyncGenerator<string> {
+                for (const file of plan.units) {
+                  const command = commands.get(file)
+                  if (!command)
+                    throw new Error(`missing SwiftPM compiler command for ${file}`)
+                  // change only the action and its output side effects. language,
+                  // SDK, defines, includes and original source identity stay exact.
+                  const args: string[] = []
+                  for (let index = 1; index < command.length; index++) {
+                    const arg = command[index]!
+                    if (
+                      ['-o', '-MF', '-MT', '-MQ', '-serialize-diagnostics'].includes(arg)
+                    )
+                      index++
+                    else if (!['-c', '-MD', '-MMD'].includes(arg)) args.push(arg)
+                  }
+                  try {
+                    yield await runCompiler(
+                      command[0]!,
+                      [...args, '-fsyntax-only', '-Xclang', '-ast-dump'],
+                      { ...buildOptions, cwd: root, maxBuffer: 256 * 1024 * 1024 },
+                    )
+                  } catch (error) {
+                    const diagnostic =
+                      error && typeof error === 'object'
+                        ? streamText(Reflect.get(error, 'stderr'))
+                        : ''
+                    throw new Error(
+                      `original Objective-C implementation AST failed for ${file}: ${diagnostic || String(error)}`,
+                    )
+                  }
+                }
+              }
+              const adapter = await swiftObjCPrivateImports(
+                implementationASTs(),
+                plan.registeredClasses,
+              )
+              writeFileSync(plan.owner, readFileSync(plan.owner, 'utf8') + adapter)
+            }
             await runCompiler(
               swift,
               buildArgs,