peachsim 0.1.1641 → 0.1.1653

package/src/swift-compiler-digest.ts

@@ -3,11 +3,25 @@ import { readFileSync } from 'node:fs'
 import path from 'node:path'
 
 // the lowering and manifest code in swift-compile.ts and its design-time lowering
-// decide the emitted output, so their text addresses every swift artifact. bundled
-// builds cannot read these files at runtime, so build-cli injects this digest.
+// decide the emitted output, and the root lock decides whose sources and
+// executable an address names, so their text addresses every swift artifact.
+// bundled builds cannot read these files at runtime, so build-cli injects this
+// digest.
+export const SWIFT_DIGEST_SOURCES = [
+  'swift-compile.ts',
+  'swift-design-time.ts',
+  'swift-root-lock.ts',
+  'swift-objc-export.ts',
+  'swift-objc-import.ts',
+  'swift-objc-metadata.ts',
+  'swiftContract.ts',
+  'swift-objc-standin.ts',
+  'swift-objc-sdk.ts',
+]
+
 export function swiftCompilerSourceDigest(srcDir: string): string {
   const hash = createHash('sha256')
-  for (const file of ['swift-compile.ts', 'swift-design-time.ts']) {
+  for (const file of SWIFT_DIGEST_SOURCES) {
     hash.update(readFileSync(path.join(srcDir, file)))
   }
   return hash.digest('hex')

package/src/swift-distribution.lock.json

@@ -1,10 +1,10 @@
 {
-  "id": "e8dd3a9ff9c4dc74",
+  "id": "e3bdd3d8fa4f9993",
   "release": "swift-6.4.0-RELEASE-custom-0d775d32d7c74eae",
-  "wasmSdkId": "swift-6.4.0-RELEASE_wasm-peach-21f60db0",
-  "wasmSdkUrl": "https://r2.sootsim.com/swift-wasm-sdk/swift-6.4.0-RELEASE_wasm-peach-21f60db0.artifactbundle.tar.gz",
-  "wasmSdkChecksum": "7b7573fd23120549fc928581a42968676f5f00f9ef63e5618032a6928a724e16",
-  "source": "693296741f3865605388c21ee7e220cb0b6ccaa3",
+  "wasmSdkId": "swift-6.4.0-RELEASE_wasm-peach-f02bd198",
+  "wasmSdkUrl": "https://r2.sootsim.com/swift-wasm-sdk/swift-6.4.0-RELEASE_wasm-peach-f02bd198.artifactbundle.tar.gz",
+  "wasmSdkChecksum": "1e19ea768fd4e821aae34b8966c4ddcee45615c4b3cf018979b061aee2fb5504",
+  "source": "5791eeff9ca9c054514aeb4a6599e1de8e1e4711",
   "targets": [
     "ImagePlayground",
     "QuickLookThumbnailing",
@@ -164,14 +164,33 @@
     "PeachBox2D"
   ],
   "systemEnvironment": {
-    "scenePhase": ["string:active", "string:inactive", "string:background"],
-    "deviceModel": ["string"],
-    "systemName": ["string"],
-    "systemVersion": ["string"],
-    "colorScheme": ["string:light", "string:dark"],
-    "semanticColors": ["object"],
-    "imageAssets": ["object"],
-    "locale": ["string"],
+    "scenePhase": [
+      "string:active",
+      "string:inactive",
+      "string:background"
+    ],
+    "deviceModel": [
+      "string"
+    ],
+    "systemName": [
+      "string"
+    ],
+    "systemVersion": [
+      "string"
+    ],
+    "colorScheme": [
+      "string:light",
+      "string:dark"
+    ],
+    "semanticColors": [
+      "object"
+    ],
+    "imageAssets": [
+      "object"
+    ],
+    "locale": [
+      "string"
+    ],
     "dynamicTypeSize": [
       "string:xSmall",
       "string:small",
@@ -186,22 +205,30 @@
       "string:accessibility4",
       "string:accessibility5"
     ],
-    "horizontalSizeClass": ["string:compact", "string:regular"],
-    "verticalSizeClass": ["string:compact", "string:regular"],
-    "accessibilityReduceMotion": ["bool"]
+    "horizontalSizeClass": [
+      "string:compact",
+      "string:regular"
+    ],
+    "verticalSizeClass": [
+      "string:compact",
+      "string:regular"
+    ],
+    "accessibilityReduceMotion": [
+      "bool"
+    ]
   },
   "hosts": {
     "darwin-arm64": {
-      "sha256": "0e06928cd63077f30226a27b2a3e92e89bdcaaf2fcd57fcac6a38a8465ee6865",
-      "size": 71438614
+      "sha256": "278cf5301795dd1e9f0f044bdb4e079b45ab4eb72a6e72331b06916115e34902",
+      "size": 71532233
     },
     "linux-x64": {
-      "sha256": "baae9a89308dfde3cc47366ab4163369ac8537274361d10381004f006a965afa",
-      "size": 71444190
+      "sha256": "920c6fe08ba45930880fee133a3cb85b310d713a4d60404f29d03555d3df879c",
+      "size": 71538725
     },
     "linux-arm64": {
-      "sha256": "422e2fbd6f65a8aebe0456e9becc2a6a28505825457c9758e8275f35e2fe63f1",
-      "size": 71442522
+      "sha256": "d3a3421e0c80cc698869bc39dd538d42b0e053db02526d3f5f22acf8e7c6dca9",
+      "size": 71536749
     }
   }
 }

package/src/swift-host.ts

@@ -30,7 +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 { xcodeObjCInputs } from './swift-objc-compile'
 import {
   swiftImplicitResourcePaths,
   swiftMetalSourceFiles,
@@ -78,6 +78,7 @@ import {
   type SwiftImageUpload,
   type SwiftNativeModules,
 } from './swift-submit'
+import { SWIFT_NATIVE_INPUT_ROOT, SWIFT_NATIVE_SDK_INCLUDE } from './swiftContract'
 import {
   enclosingXcodeWorkspace,
   readXcodeAppTarget,
@@ -92,20 +93,17 @@ import type {
 import type { PeachConfig } from './config'
 import type { SwiftCompileInput, SwiftIcuAsset } from './swift-compile'
 import type { SwiftStandinBehaviors } from './swift-standin-emit'
-import type { SwiftMetalLibrarySource, SwiftResourceBundle } from './swiftContract'
+import type {
+  SwiftMetalLibrarySource,
+  SwiftNativeTarget,
+  SwiftResourceBundle,
+} from './swiftContract'
 import type { ServerResponse } from 'node:http'
 
 const ARTIFACT_PATH = '/__peach/swift/'
 const RESOURCE_PATH = '/__peach/swift-res/'
 const ICU_PATH = '/__peach/swift-icu/'
-const SKIP_SOURCE_DIRS = new Set([
-  'node_modules',
-  'ios',
-  'android',
-  'dist',
-  'types',
-  'build',
-])
+const SKIP_SOURCE_DIRS = new Set(['node_modules', 'dist', 'types', 'build'])
 const NATIVE_DESCRIPTOR = '.one-native-source.json'
 const NATIVE_GLUE = '.one-native-source.swift.txt'
 
@@ -350,13 +348,6 @@ 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
@@ -364,31 +355,33 @@ function swiftPackages(
   // module.
   // a framework the project vendors links straight into its target, so it
   // stands in the same way a package's binary target does.
-  const vendored = app.binaryFrameworks.flatMap(({ name, path: dir }) =>
-    dir
-      ? [
-          {
-            target: name,
-            source: 'the project',
-            url: null,
-            checksum: null,
-            dir,
-            reached: true,
-          } satisfies SwiftPackageBinary,
-        ]
-      : [],
+  const vendored: SwiftPackageBinary[] = app.binaryFrameworks.flatMap(
+    ({ name, path: dir }) =>
+      dir
+        ? [
+            {
+              target: name,
+              source: 'the project',
+              url: null,
+              checksum: null,
+              dir,
+              reached: true,
+            } satisfies SwiftPackageBinary,
+          ]
+        : [],
   )
   const reached = [...cached.binaries.filter((binary) => binary.reached), ...vendored]
-  if (entry.moduleRoot && entry.provided && reached.length > 0) {
+  const artifacts = reached.filter((binary) => binary.publicHeaders === undefined)
+  if (entry.moduleRoot && entry.provided && artifacts.length > 0) {
     const resolved = swiftModuleToolchain(entry.moduleRoot)
     const toolchain = {
       moduleRoot: entry.moduleRoot,
       toolchainBin: resolved.toolchainBin,
       release: resolved.release,
     }
-    const generation = standinGenerationInputs(reached, toolchain, entry.behavior)
+    const generation = standinGenerationInputs(artifacts, toolchain, entry.behavior)
     if (cached.standinKey !== generation) {
-      const built = swiftStandins(reached, toolchain, entry.provided, entry.behavior)
+      const built = swiftStandins(artifacts, toolchain, entry.provided, entry.behavior)
       cached.packages = resolveSwiftPackages({
         rootDir: app.rootDir,
         resolved: app.packageResolved,
@@ -427,7 +420,11 @@ const XCODE_FRAMEWORKS_DIR = '__frameworks__'
 const XCODE_PACKAGES_DIR = '__packages__'
 
 // the compile input key of a root-relative path in an xcode layout.
-function xcodeInputKey(layout: XcodeLayout, file: string, relative: string): string {
+function xcodeInputKey(
+  layout: Pick<XcodeLayout, 'app' | 'targetDirs'>,
+  file: string,
+  relative: string,
+): string {
   const owner = layout.targetDirs.get(file)
   if (owner) return path.posix.join(owner, relative)
   const checkouts = remoteSwiftCheckouts(layout.app.rootDir)
@@ -452,6 +449,8 @@ interface XcodeLayout {
   /** the input directory each app and framework source compiles under. */
   targetDirs: Map<string, string>
   resourceBundles: SwiftResourceBundle[]
+  nativeTargets: SwiftNativeTarget[]
+  nativeFiles: Map<string, Buffer>
   files: string[]
 }
 
@@ -464,18 +463,7 @@ function xcodeLayout(root: string): XcodeLayout | null {
     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 appSources = app.allSources
   const files = new Set([
     ...app.projectFiles,
     ...app.packageResolved,
@@ -498,7 +486,6 @@ function xcodeLayout(root: string): XcodeLayout | null {
       path: `Frameworks/${framework.moduleName}.framework`,
     })
     for (const file of framework.allSources) {
-      if (!file.endsWith('.swift') && !file.endsWith('.metal')) continue
       if (targetDirs.has(file)) continue
       targetDirs.set(file, dir)
       files.add(file)
@@ -585,6 +572,118 @@ function xcodeLayout(root: string): XcodeLayout | null {
       .filter((other) => other.path.startsWith(`${target.path}/`))
       .map((other) => other.path.slice(target.path.length + 1))
   }
+  const relative = (file: string) =>
+    xcodeInputKey(
+      { app, targetDirs },
+      file,
+      path.relative(app.rootDir, file).split(path.sep).join('/') || '.',
+    )
+  const nativeInputs = xcodeObjCInputs(app, binaries)
+  const nativeFiles = nativeInputs.sources
+  for (const file of nativeFiles.keys()) files.add(file)
+  const nativeHeaders = [...nativeFiles.keys()].filter((file) =>
+    /\.(?:h|hh|hpp|hxx|pch|inc|inl|modulemap)$/.test(file),
+  )
+  const nativePath = (file: string, directory = app.rootDir) => {
+    const absolute = path.resolve(directory, file)
+    return absolute === '/usr/include' || absolute.startsWith('/usr/include/')
+      ? SWIFT_NATIVE_SDK_INCLUDE + absolute.slice('/usr/include'.length)
+      : `${SWIFT_NATIVE_INPUT_ROOT}/${relative(absolute)}`
+  }
+  const nativeFlags = (flags: string[], directory = app.rootDir) =>
+    flags.map((flag, index) => {
+      if (
+        [
+          '-I',
+          '-F',
+          '-iquote',
+          '-isystem',
+          '-include',
+          '-imacros',
+          '-iframework',
+        ].includes(flags[index - 1] ?? '')
+      )
+        return nativePath(flag, directory)
+      const joined = /^(-I|-F|-iquote|-isystem|-iframework)(.+)$/.exec(flag)
+      return joined ? `${joined[1]}${nativePath(joined[2]!, directory)}` : flag
+    })
+  const nativeTargets = [app, ...app.frameworks].flatMap(
+    (target): SwiftNativeTarget[] => {
+      if (!target.objc) return []
+      const settings = target.objc
+      for (const file of [
+        ...settings.headers,
+        settings.bridgingHeader,
+        settings.prefixHeader,
+      ])
+        if (file) files.add(file)
+      return [
+        {
+          name: target.moduleName,
+          deploymentTarget: target.iosDeploymentTarget,
+          headers: [...new Set([...settings.headers, ...nativeHeaders])].map(relative),
+          publicHeaders: settings.publicHeaders.map(relative),
+          bridgingHeader: settings.bridgingHeader
+            ? relative(settings.bridgingHeader)
+            : null,
+          prefixHeader: settings.prefixHeader ? relative(settings.prefixHeader) : null,
+          headerSearchPaths: settings.headerSearchPaths
+            .filter(
+              (file) => file !== '/usr/include' && !file.startsWith('/usr/include/'),
+            )
+            .map(relative),
+          frameworkSearchPaths: settings.frameworkSearchPaths.map(relative),
+          flags: [
+            ...nativeFlags(settings.flags),
+            ...settings.headerSearchPaths
+              .filter(
+                (file) => file === '/usr/include' || file.startsWith('/usr/include/'),
+              )
+              .flatMap((file) => ['-I', nativePath(file)]),
+          ],
+          cxxFlags: nativeFlags(settings.cxxFlags),
+          fileFlags: Object.fromEntries(
+            Object.entries(settings.fileFlags).map(([file, flags]) => [
+              relative(file),
+              nativeFlags(flags),
+            ]),
+          ),
+          sourceDirectories: Object.fromEntries(
+            target.allSources
+              .filter((file) => /\.(?:c|cc|cpp|cxx|m|mm)$/.test(file))
+              .map((file) => [relative(file), relative(path.dirname(file))]),
+          ),
+        },
+      ]
+    },
+  )
+  for (const settings of nativeInputs.targets) {
+    if (!settings.publicHeaders) continue
+    const target = packages.targets.find((value) => value.name === settings.name)
+    if (!target) continue
+    nativeTargets.push({
+      name: target.name,
+      deploymentTarget: settings.deploymentTarget,
+      headers: nativeHeaders.map(relative),
+      publicHeaders: nativeHeaders
+        .filter(
+          (file) =>
+            file.startsWith(`${settings.publicHeaders}${path.sep}`) &&
+            /\.(h|hh|hpp|hxx)$/.test(file),
+        )
+        .map(relative),
+      bridgingHeader: null,
+      prefixHeader: null,
+      headerSearchPaths: settings.includes.map(relative),
+      frameworkSearchPaths: [],
+      flags: nativeFlags(settings.flags, target.dir),
+      cxxFlags: nativeFlags(settings.cxxFlags, target.dir),
+      fileFlags: {},
+      sourceDirectories: Object.fromEntries(
+        settings.files.map((file) => [relative(file), relative(path.dirname(file))]),
+      ),
+    })
+  }
   return {
     app,
     targets,
@@ -594,6 +693,8 @@ function xcodeLayout(root: string): XcodeLayout | null {
     projectGaps,
     targetDirs,
     resourceBundles,
+    nativeTargets,
+    nativeFiles,
     files: [...files].sort(),
   }
 }
@@ -668,7 +769,10 @@ function sourceTreeFiles(dir: string, canonicalRoot: string): string[] {
         (entry.name.startsWith('.') &&
           entry.name !== NATIVE_DESCRIPTOR &&
           entry.name !== NATIVE_GLUE) ||
-        SKIP_SOURCE_DIRS.has(entry.name)
+        SKIP_SOURCE_DIRS.has(entry.name) ||
+        // platform project wrappers are excluded only at the package root;
+        // native target sources can contain upstream ios/android directories.
+        (dir === canonicalRoot && (entry.name === 'ios' || entry.name === 'android'))
       )
         continue
       const full = path.join(dir, entry.name)
@@ -1233,13 +1337,20 @@ function packageSources(
   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,
-      limits.sourceBytes,
+    files[xcode ? xcodeInputKey(xcode, file, relative) : relative] = (
+      xcode?.nativeFiles.get(file) ??
+      readPackageFile(packagePath, file, limits.sourceBytes)
     ).toString('utf8')
   }
   if (xcode) {
+    for (const [file, contents] of xcode.nativeFiles)
+      files[
+        xcodeInputKey(
+          xcode,
+          file,
+          path.relative(packagePath, file).split(path.sep).join('/'),
+        )
+      ] = contents.toString('utf8')
     files['Package.swift'] = xcodeManifest(xcode)
     for (const standin of xcode.standins)
       for (const [file, text] of Object.entries(standin.files))
@@ -1253,6 +1364,7 @@ function packageSources(
 
 interface SwiftPackageSnapshot {
   files: Record<string, string>
+  nativeTargets?: SwiftNativeTarget[]
   entry: string
   resourcePaths: string[]
   resources: SwiftResourceTable
@@ -1275,6 +1387,7 @@ function packageSnapshot(project: SwiftProject, entry: string): SwiftPackageSnap
   const native = nativeSourceDescriptor(project.packagePath)
   return {
     files,
+    ...(layout?.nativeTargets.length ? { nativeTargets: layout.nativeTargets } : {}),
     entry: layout
       ? xcodeInputKey(layout, path.resolve(project.packagePath, entry), entry)
       : entry,
@@ -1322,6 +1435,7 @@ function packageSnapshot(project: SwiftProject, entry: string): SwiftPackageSnap
 function snapshotCompileInput(snapshot: SwiftPackageSnapshot): SwiftCompileInput {
   const input: SwiftCompileInput = {
     files: snapshot.files,
+    ...(snapshot.nativeTargets ? { nativeTargets: snapshot.nativeTargets } : {}),
     metalSources: snapshot.resources.metalUploads,
     resourcePaths: snapshot.resourcePaths,
     resourceBundles: snapshot.bundleFiles.bundles,
@@ -1647,6 +1761,7 @@ async function compileRemote(
     submit,
     {
       files: snapshot.files,
+      ...(snapshot.nativeTargets ? { nativeTargets: snapshot.nativeTargets } : {}),
       metalSources: snapshot.resources.metalUploads,
       resourcePaths: snapshot.resourcePaths,
       resourceBundles: snapshot.bundleFiles.bundles,

package/src/swift-objc-compile.ts

@@ -3,14 +3,14 @@ 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 { swiftSdkPaths, swiftModuleDigest, 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 { IOS_SDK_ID, materializeObjcSdk, OBJC_IMPORT_VERSION } from './swift-objc-standin'
 import { swiftTargetModuleName } from './swift-package'
 import { swiftPackageManifest, swiftTargetFiles } from './swift-package-manifest'
 import { remoteSwiftCheckouts, type SwiftPackageBinary } from './swift-packages'
@@ -24,29 +24,24 @@ 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(
-  app: XcodeAppTarget,
-  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
+  }
 }
 
-/** prepares genuine objects without authorizing unsupported framework linkage. */
-export function prepareXcodeObjCImplementations(
+const isSdkInclude = (file: string): boolean =>
+  file === '/usr/include' || file.startsWith('/usr/include/')
+
+/** one original source snapshot serves declaration import and implementation compile. */
+export function xcodeObjCInputs(
   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>()
   const links: Record<string, string> = {}
   const checkouts = remoteSwiftCheckouts(app.rootDir)
@@ -63,13 +58,24 @@ export function prepareXcodeObjCImplementations(
         ),
       )
   }
+  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.isDirectory() && entry.name.startsWith('.')) continue
+      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
@@ -152,6 +158,30 @@ export function prepareXcodeObjCImplementations(
       ),
     ])
       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)
+    const flags = [
+      ...target.objc.flags,
+      ...target.objc.cxxFlags,
+      ...Object.values(target.objc.fileFlags).flat(),
+    ]
+    for (const [index, flag] of flags.entries()) {
+      const directory = ['-I', '-F', '-iquote', '-isystem', '-iframework'].includes(
+        flags[index - 1] ?? '',
+      )
+        ? flag
+        : /^(-I|-F|-iquote|-isystem|-iframework)(.+)$/.exec(flag)?.[2]
+      if (directory) {
+        const absolute = path.resolve(app.rootDir, directory)
+        if (!isSdkInclude(absolute) && fs.existsSync(absolute)) addHeaders(absolute)
+      }
+      if (['-include', '-imacros'].includes(flags[index - 1] ?? ''))
+        add(path.resolve(app.rootDir, flag), true)
+    }
     targets.push({
       name: target.moduleName,
       deploymentTarget: target.iosDeploymentTarget,
@@ -164,17 +194,43 @@ export function prepareXcodeObjCImplementations(
       fileFlags: target.objc.fileFlags,
     })
   }
+  return { sources, links, targets }
+}
+
+/** 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, links, targets } = xcodeObjCInputs(app, binaries)
+  const checkouts = remoteSwiftCheckouts(app.rootDir)
   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: 8,
+    version: 10,
+    importer: OBJC_IMPORT_VERSION,
     peers,
     metadataDeploymentTarget: peers ? app.iosDeploymentTarget : undefined,
     release: toolchain.release,
     compiler: digest(fs.readFileSync(path.join(toolchain.toolchainBin, 'clang'))),
+    ...(peers
+      ? {
+          extractor: digest(
+            fs.readFileSync(
+              path.join(toolchain.toolchainBin, 'swift-symbolgraph-extract'),
+            ),
+          ),
+          modules: swiftModuleDigest(moduleRoot).toString('hex'),
+        }
+      : {}),
     sdk: swiftModuleSdk(moduleRoot),
     declarations: IOS_SDK_ID,
     targets,
@@ -290,8 +346,8 @@ export function prepareXcodeObjCImplementations(
           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))
+      if (isSdkInclude(file))
+        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}`,
       )
@@ -402,6 +458,7 @@ export function prepareXcodeObjCImplementations(
           headerCache: path.join(cacheDir(), 'swift-standins'),
           toolchainBin: toolchain.toolchainBin,
           sysroot: sdk.sysroot,
+          stdlib: path.join(moduleRoot, 'ios-simulator-stdlib'),
           minimum: minimumFor({
             name: app.moduleName,
             deploymentTarget: app.iosDeploymentTarget,
@@ -458,6 +515,9 @@ export function prepareXcodeObjCImplementations(
             : []),
           '-F',
           path.join(headers, 'System/Library/Frameworks'),
+          // the extension headers include the installed libc before adding darwin declarations.
+          '-isystem',
+          path.join(headers, 'wasm/include'),
           // installed libc and objc runtime headers own the target ABI.
           '-idirafter',
           path.join(headers, 'usr/include'),