peachsim 0.1.1635 → 0.1.1640

package/src/swift-standins.ts

@@ -15,16 +15,27 @@ import fs from 'node:fs'
 import path from 'node:path'
 import { getCliVersion } from './cli-version'
 import { cacheDir as peachCacheDir, swiftPackageCacheOptions } from './home-paths'
+import { isRecord } from './is-record'
+import { outputLockStdio } from './output-lock-stdio'
 import { parsePlistSource } from './plist'
 import {
   swiftDistributionAt,
+  swiftImportNames,
   swiftMacroPlugins,
   swiftModuleDigest,
   swiftModuleSdk,
   swiftPeachModules,
   swiftSdkPaths,
 } from './swift-compile'
-import { IOS_SDK_ID, objcView, type ObjcSurface } from './swift-objc-standin'
+import {
+  IOS_SDK_ID,
+  NATIVE_GRAPH_ID,
+  OBJC_IMPORT_VERSION,
+  nativeInterfaceView,
+  objcView,
+  type ObjcSurface,
+} from './swift-objc-standin'
+import { swiftTargetModuleName } from './swift-package'
 import {
   STANDIN_EMIT_VERSION,
   STANDIN_IMPORTS,
@@ -33,10 +44,11 @@ import {
   type SwiftStandinBehaviors,
   type StandinBehavior,
 } from './swift-standin-emit'
-import { swiftSdkOptions } from './swift-toolchain'
+import { swiftEnvironment, swiftSdkOptions } from './swift-toolchain'
 import type { SwiftPackageBinary } from './swift-packages'
 
 const TRIPLE = 'wasm32-unknown-wasip1'
+const WASI_EMULATION = ['_WASI_EMULATED_SIGNAL', '_WASI_EMULATED_MMAN']
 // every stand-in artifact and temporary workspace belongs to peach.
 const cacheDir = path.join(peachCacheDir(), 'swift-standins')
 // each binary stand-in is a target under its module's directory here.
@@ -68,10 +80,16 @@ interface Toolchain {
   standinModules?: string
 }
 
+interface NativeFrameworkInputs {
+  dirs: string[]
+  digest: string
+}
+
 function exec(file: string, args: string[], cwd?: string): string {
   return execFileSync(file, args, {
     cwd,
     encoding: 'utf8',
+    env: swiftEnvironment(),
     maxBuffer: 256 * 1024 * 1024,
     stdio: ['ignore', 'pipe', 'pipe'],
   })
@@ -99,14 +117,20 @@ const digests = new Map<string, { stamp: string; digest: string }>()
 
 function treeDigest(root: string): string {
   const names: string[] = []
+  const ancestors = new Set<string>()
   const walk = (dir: string) => {
+    const resolved = fs.realpathSync(dir)
+    if (ancestors.has(resolved)) throw new Error(`cyclic header directory: ${dir}`)
+    ancestors.add(resolved)
     for (const entry of fs
       .readdirSync(dir, { withFileTypes: true })
       .sort((left, right) => (left.name < right.name ? -1 : 1))) {
       const full = path.join(dir, entry.name)
-      if (entry.isDirectory()) walk(full)
-      else if (entry.isFile()) names.push(path.relative(root, full))
+      const stat = entry.isSymbolicLink() ? fs.statSync(full) : entry
+      if (stat.isDirectory()) walk(full)
+      else if (stat.isFile()) names.push(path.relative(root, full))
     }
+    ancestors.delete(resolved)
   }
   walk(root)
   const stamp = names
@@ -222,6 +246,7 @@ const files = (dir: string, test: (name: string) => boolean): string[] =>
 /** the module surfaces an iOS simulator slice describes. */
 type Surface =
   | { kind: 'swift'; module: string; interface: string }
+  | (ObjcSurface & { kind: 'mixed'; interface: string })
   | { kind: 'c'; module: string; modulemap: string; headers: string }
   | (ObjcSurface & { kind: 'objc' })
 
@@ -262,15 +287,27 @@ function surfaces(xcframeworkDir: string): Surface[] {
     )
     const chosen =
       interfaces.find((name) => name.startsWith('arm64-')) ?? interfaces[0] ?? null
+    const modulemap = path.join(framework, 'Modules', 'module.modulemap')
     if (chosen) {
-      found.push({
-        kind: 'swift',
-        module,
-        interface: path.join(swiftmodule, chosen),
-      })
+      const file = path.join(swiftmodule, chosen)
+      const underlying = [
+        ...fs
+          .readFileSync(file, 'utf8')
+          .matchAll(/^(?:@_exported[ \t]+)?import[ \t]+(\w+)[ \t]*$/gm),
+      ].some((match) => match[1] === module)
+      if (underlying) {
+        if (!fs.existsSync(modulemap))
+          throw new Error(`${module} imports its underlying module without a modulemap`)
+        found.push({
+          kind: 'mixed',
+          module,
+          interface: file,
+          modulemap,
+          headers: path.join(framework, 'Headers'),
+        })
+      } else found.push({ kind: 'swift', module, interface: file })
       continue
     }
-    const modulemap = path.join(framework, 'Modules', 'module.modulemap')
     if (fs.existsSync(modulemap))
       found.push(headerSurface(module, modulemap, path.join(framework, 'Headers')))
   }
@@ -286,6 +323,14 @@ function surfaces(xcframeworkDir: string): Surface[] {
   return found
 }
 
+export function standinsNeedNativeSdk(binaries: readonly SwiftPackageBinary[]): boolean {
+  return binaries.some(
+    (binary) =>
+      binary.publicHeaders === undefined &&
+      surfaces(xcframework(binary).dir).some((surface) => surface.kind === 'mixed'),
+  )
+}
+
 // the peach modules an interface imports, compiled for wasm: a distribution
 // ships them; a checkout builds the ones named into its own build directory,
 // with the flags scripts/build.sh uses, so the two share one build.
@@ -366,11 +411,14 @@ export function swiftInterfaceForWasm(text: string): string {
       ? rooted.replace(/^(?=import[ \t])/m, 'import Foundation\n')
       : rooted
   return foundation
-    .replace(/^(\/\/ swift-module-flags:.*)$/m, (flags) =>
-      flags
-        .replace(/-target \S+/, `-target ${TRIPLE}`)
-        .replace(/\s-enable-objc-interop\b/, '')
-        .replace(/\s-target-variant \S+/, ''),
+    .replace(
+      /^(\/\/ swift-module-flags:.*)$/m,
+      (flags) =>
+        flags
+          .replace(/-target \S+/, `-target ${TRIPLE}`)
+          .replace(/\s-enable-objc-interop\b/, '')
+          .replace(/\s-target-variant \S+/, '') +
+        ` ${WASI_EMULATION.map((name) => `-Xcc -D${name}`).join(' ')}`,
     )
     .replace(
       /@(?:objc(?:\s*\([^()]*\))?|objcMembers|nonobjc|IBOutlet|IBAction|IBInspectable|IBDesignable|_objcRuntimeName\([^()]*\))(?![\w(])/g,
@@ -384,17 +432,14 @@ function swiftStandin(
   toolchain: Toolchain,
   work: string,
   behavior: ReadonlyMap<string, StandinBehavior>,
+  siblings: ReadonlySet<string>,
 ): SwiftStandin {
   const text = swiftInterfaceForWasm(fs.readFileSync(surface.interface, 'utf8'))
   const search = path.join(work, 'interfaces')
   const moduleDir = path.join(search, `${surface.module}.swiftmodule`)
   fs.mkdirSync(moduleDir, { recursive: true })
   fs.writeFileSync(path.join(moduleDir, `${TRIPLE}.swiftinterface`), text)
-  const imports = [
-    ...text.matchAll(
-      /^(?:@_exported[ \t]+)?import[ \t]+(?:(?:struct|class|enum|protocol|typealias|func|var|let)[ \t]+)?(\w+)/gm,
-    ),
-  ].map((match) => match[1]!)
+  const imports = swiftImportNames(text)
   const wasm = wasmFlags(toolchain, imports)
   const out = path.join(work, 'graphs')
   fs.mkdirSync(out, { recursive: true })
@@ -425,6 +470,37 @@ function swiftStandin(
     toolchain,
     work,
     behavior,
+    [...new Set(imports)].filter((module) => siblings.has(module)),
+  )
+}
+
+function mixedStandin(
+  surface: Extract<Surface, { kind: 'mixed' }>,
+  binary: SwiftPackageBinary,
+  toolchain: Toolchain,
+  work: string,
+  behavior: ReadonlyMap<string, StandinBehavior>,
+  frameworkDirs: readonly string[],
+  siblings: ReadonlySet<string>,
+): SwiftStandin {
+  const view = nativeInterfaceView(surface, frameworkDirs, work)
+  const provided = new Set(swiftPeachModules(toolchain.moduleRoot))
+  const imports = [
+    ...new Set(swiftImportNames(fs.readFileSync(surface.interface, 'utf8'))),
+  ].filter(
+    (module) =>
+      module !== surface.module && (provided.has(module) || siblings.has(module)),
+  )
+  return graphStandin(
+    surface.module,
+    view.graphs,
+    view.values,
+    wasmFlags(toolchain, imports),
+    binary,
+    toolchain,
+    work,
+    behavior,
+    imports,
   )
 }
 
@@ -442,10 +518,7 @@ function wasmFlags(toolchain: Toolchain, imports: string[]): string[] {
     '-resource-dir',
     resources,
     // the sdk toolset's emulation defines, which raw swiftc does not read
-    '-Xcc',
-    '-D_WASI_EMULATED_SIGNAL',
-    '-Xcc',
-    '-D_WASI_EMULATED_MMAN',
+    ...WASI_EMULATION.flatMap((name) => ['-Xcc', `-D${name}`]),
     ...peachModuleDirs(toolchain, imports).flatMap((dir) => ['-I', dir]),
     ...(toolchain.standinModules ? ['-I', toolchain.standinModules] : []),
   ]
@@ -475,7 +548,9 @@ function objcStandin(
     toolchain,
     work,
     behavior,
-    binary.headerDependencies?.map((dependency) => dependency.module),
+    binary.headerDependencies?.map((dependency) =>
+      swiftTargetModuleName(dependency.module),
+    ),
   )
 }
 
@@ -528,17 +603,21 @@ function graphStandin(
     fs.writeFileSync(file, source)
     const check = spawnSync(
       path.join(toolchain.toolchainBin, 'swiftc'),
+      // emitting the module runs the diagnostics a typecheck skips, such as
+      // literal overflow, which the app's build of the stand-in reaches
       [
-        '-typecheck',
+        '-emit-module',
         '-parse-as-library',
         '-swift-version',
         '5',
         '-module-name',
         module,
         ...wasm,
+        '-emit-module-path',
+        path.join(work, `${module}.swiftmodule`),
         file,
       ],
-      { encoding: 'utf8', maxBuffer: 256 * 1024 * 1024 },
+      { encoding: 'utf8', env: swiftEnvironment(), maxBuffer: 256 * 1024 * 1024 },
     )
     if (check.status === 0)
       return {
@@ -993,51 +1072,91 @@ export function standinLibrary(
   throw new Error(`cargo built ${crate} for ${RUST_TARGET} but reported no ${library}`)
 }
 
-// source preflight shares project compilation's portable builder admission.
-// the complete resolved artifact travels as an input, including ignored local frameworks.
-function sourceBinaryStandins(
-  binary: SwiftPackageBinary,
+// source preflight admits the complete closure once, including ignored local
+// frameworks. target generation and prerequisite modules stay in that one job.
+function sourceStandins(
+  binaries: readonly SwiftPackageBinary[],
   toolchain: Toolchain,
   provided: ReadonlySet<string>,
   behavior: SwiftStandinBehaviors,
-): SwiftStandin[] | string {
+): SwiftStandins {
   const repo = path.resolve(toolchain.moduleRoot, '../..')
   fs.mkdirSync(cacheDir, { recursive: true })
+  const generation = standinGenerationInputs(binaries, toolchain, behavior)
+  const cached = path.join(
+    cacheDir,
+    'closures',
+    `${key(generation, JSON.stringify([...provided].sort()))}.json`,
+  )
+  const targets = new Set(binaries.map((binary) => binary.target))
+  if (fs.existsSync(cached))
+    return readStandinResults(
+      JSON.parse(fs.readFileSync(cached, 'utf8')),
+      generation,
+      targets,
+    )
   const work = fs.mkdtempSync(path.join(cacheDir, 'request-'))
   try {
-    const artifact =
-      binary.publicHeaders !== undefined
-        ? { dir: path.join(work, 'headers') }
-        : xcframework(binary)
-    const local = { ...binary, dir: artifact.dir, url: null, checksum: null }
-    if (binary.publicHeaders !== undefined) {
-      const dependencies = binary.headerDependencies ?? []
-      for (const header of [
-        { module: binary.target, path: binary.publicHeaders },
-        ...dependencies,
-      ])
-        fs.cpSync(
-          path.join(binary.dir, header.path),
-          path.join(artifact.dir, header.module),
-          { recursive: true },
-        )
-      local.publicHeaders = binary.target
-      local.headerDependencies = dependencies.map(({ module }) => ({
-        module,
-        path: module,
-      }))
+    const artifact = path.join(work, 'artifacts')
+    fs.mkdirSync(artifact)
+    const local: SwiftPackageBinary[] = []
+    const gaps = new Map<string, string>()
+    const headers = new Map<string, string>()
+    for (const [index, binary] of binaries.entries()) {
+      try {
+        if (binary.publicHeaders !== undefined) {
+          const copyHeader = (relative: string) => {
+            const source = fs.realpathSync(path.join(binary.dir, relative))
+            let destination = headers.get(source)
+            if (destination === undefined) {
+              destination = `headers/${headers.size}`
+              fs.cpSync(source, path.join(artifact, destination), {
+                recursive: true,
+                dereference: true,
+              })
+              headers.set(source, destination)
+            }
+            return destination
+          }
+          local.push({
+            ...binary,
+            dir: artifact,
+            url: null,
+            checksum: null,
+            publicHeaders: copyHeader(binary.publicHeaders),
+            headerDependencies: (binary.headerDependencies ?? []).map((dependency) => ({
+              module: dependency.module,
+              path: copyHeader(dependency.path),
+            })),
+          })
+        } else {
+          const resolved = xcframework(binary)
+          const dir = path.join(artifact, String(index), path.basename(resolved.dir))
+          fs.cpSync(resolved.dir, dir, { recursive: true, dereference: true })
+          local.push({ ...binary, dir, url: null, checksum: null })
+        }
+      } catch (error) {
+        gaps.set(binary.target, error instanceof Error ? error.message : String(error))
+      }
     }
-    const generation = standinGenerationInputs([local], toolchain, behavior)
+    if (local.length === 0) return { standins: [], gaps }
+    const preparedGeneration = standinGenerationInputs(local, toolchain, behavior)
+    if (generation !== standinGenerationInputs(binaries, toolchain, behavior))
+      throw new Error('Swift stand-in inputs changed during preparation')
     const request = path.join(work, 'request.json')
     const delivery = path.join(work, 'delivery')
     fs.writeFileSync(
       request,
       JSON.stringify({
-        binary: local,
+        binaries: local.map((binary) => ({
+          ...binary,
+          dir: path.relative(artifact, binary.dir) || '.',
+        })),
         provided: [...provided],
         behavior,
-        generation,
+        generation: preparedGeneration,
         release: toolchain.release,
+        native: standinsNeedNativeSdk(local),
       }),
     )
     const build = spawnSync(
@@ -1047,56 +1166,104 @@ function sourceBinaryStandins(
         '--request',
         request,
         '--artifact',
-        artifact.dir,
+        artifact,
         '--delivery-dir',
         delivery,
       ],
-      { cwd: repo, encoding: 'utf8', maxBuffer: 8 * 1024 * 1024 },
+      {
+        cwd: repo,
+        encoding: 'utf8',
+        maxBuffer: 8 * 1024 * 1024,
+        stdio: outputLockStdio(['ignore', 'pipe', 'pipe']),
+      },
     )
     if (build.stdout) process.stdout.write(build.stdout)
     if (build.stderr) process.stderr.write(build.stderr)
     if (build.error || build.status !== 0)
       throw new Error(
-        `source stand-in build for ${binary.target} failed (${build.error?.message ?? build.signal ?? `exit ${build.status}`}): ${build.stderr?.trim().slice(-4000) || build.stdout?.trim().slice(-4000) || 'builder returned no diagnostic'}`,
+        `source stand-in build for ${local.map((binary) => binary.target).join(', ')} failed (${build.error?.message ?? build.signal ?? `exit ${build.status}`}): ${build.stderr?.trim().slice(-4000) || build.stdout?.trim().slice(-4000) || 'builder returned no diagnostic'}`,
       )
     const output = path.join(delivery, 'standins.json')
     if (!fs.existsSync(output))
-      throw new Error(
-        `source stand-in builder returned no standins.json for ${binary.target}`,
-      )
+      throw new Error('source stand-in builder returned no standins.json')
     const receipt: unknown = JSON.parse(fs.readFileSync(output, 'utf8'))
-    if (
-      !receipt ||
-      typeof receipt !== 'object' ||
-      !('generation' in receipt) ||
-      receipt.generation !== generation ||
-      !('result' in receipt)
-    )
-      throw new Error('Swift stand-in builder source differs from the caller')
-    const result = receipt.result
-    if (typeof result === 'string') throw new Error(result)
-    if (
-      !Array.isArray(result) ||
-      !result.every(
-        (item) =>
-          item &&
-          typeof item === 'object' &&
-          typeof item.module === 'string' &&
-          typeof item.target === 'string' &&
-          item.target === binary.target &&
-          item.files &&
-          typeof item.files === 'object' &&
-          !Array.isArray(item.files) &&
-          Object.values(item.files).every((text) => typeof text === 'string'),
-      )
+    const result = readStandinResults(
+      receipt,
+      preparedGeneration,
+      new Set(local.map((binary) => binary.target)),
     )
-      throw new Error('invalid Swift stand-in builder result')
+    if (generation !== standinGenerationInputs(binaries, toolchain, behavior))
+      throw new Error('Swift stand-in inputs changed during generation')
+    for (const [target, reason] of gaps) result.gaps.set(target, reason)
+    // failures retry against the per-target generation cache on the builder.
+    // only a complete successful closure skips the next admission entirely.
+    if (result.gaps.size === 0 && isRecord(receipt)) {
+      fs.mkdirSync(path.dirname(cached), { recursive: true })
+      const pending = `${cached}.${process.pid}.tmp`
+      fs.writeFileSync(pending, JSON.stringify({ ...receipt, generation }))
+      fs.renameSync(pending, cached)
+    }
     return result
   } finally {
     fs.rmSync(work, { recursive: true, force: true })
   }
 }
 
+function readStandinResults(
+  receipt: unknown,
+  generation: string,
+  targets: ReadonlySet<string>,
+): SwiftStandins {
+  if (!isRecord(receipt) || receipt.generation !== generation)
+    throw new Error('Swift stand-in builder source differs from the caller')
+  if (!Array.isArray(receipt.results) || receipt.results.length !== targets.size)
+    throw new Error('invalid Swift stand-in builder results')
+  const standins: SwiftStandin[] = []
+  const gaps = new Map<string, string>()
+  const seen = new Set<string>()
+  for (const entry of receipt.results) {
+    if (
+      !isRecord(entry) ||
+      typeof entry.target !== 'string' ||
+      !targets.has(entry.target) ||
+      seen.has(entry.target)
+    )
+      throw new Error('invalid Swift stand-in builder target')
+    seen.add(entry.target)
+    if (typeof entry.result === 'string') {
+      gaps.set(entry.target, entry.result)
+      continue
+    }
+    if (!Array.isArray(entry.result))
+      throw new Error('invalid Swift stand-in builder result')
+    for (const item of entry.result) {
+      if (
+        !isRecord(item) ||
+        typeof item.module !== 'string' ||
+        item.target !== entry.target ||
+        !isRecord(item.files) ||
+        !Object.values(item.files).every((text) => typeof text === 'string') ||
+        (item.dependencies !== undefined &&
+          (!Array.isArray(item.dependencies) ||
+            !item.dependencies.every((name) => typeof name === 'string')))
+      )
+        throw new Error('invalid Swift stand-in builder result')
+      const files: Record<string, string> = {}
+      for (const [name, text] of Object.entries(item.files)) {
+        if (typeof text !== 'string') throw new Error('invalid Swift stand-in file')
+        files[name] = text
+      }
+      standins.push({
+        module: item.module,
+        target: entry.target,
+        files,
+        ...(item.dependencies === undefined ? {} : { dependencies: item.dependencies }),
+      })
+    }
+  }
+  return { standins, gaps }
+}
+
 const built = new Map<string, SwiftStandin[] | string>()
 
 /** what stand-ins are generated from besides the surfaces' files: the
@@ -1111,13 +1278,14 @@ export function standinGenerationInputs(
   const { moduleRoot, release } = toolchain
   const sdk = swiftModuleSdk(moduleRoot)
   const parts = [
-    'standin/v6',
+    'standin/v9',
     release,
     sdk.wasmSdkId,
     sdk.wasmSdkChecksum,
     swiftModuleDigest(moduleRoot).toString('hex'),
     `emit/${STANDIN_EMIT_VERSION}`,
     `ios-sdk/${IOS_SDK_ID}`,
+    `objc-import/${OBJC_IMPORT_VERSION}`,
     // a released cli can change the emitter without anyone bumping the constant
     `cli/${getCliVersion()}`,
   ]
@@ -1125,7 +1293,7 @@ export function standinGenerationInputs(
     binaries.flatMap((binary) => {
       try {
         return binary.publicHeaders !== undefined
-          ? [binary.target]
+          ? [swiftTargetModuleName(binary.target)]
           : surfaces(xcframework(binary).dir).map((surface) => surface.module)
       } catch {
         return []
@@ -1147,7 +1315,22 @@ export function standinGenerationInputs(
       ),
     )
   for (const binary of binaries) {
+    if (
+      binary.publicHeaders !== undefined &&
+      swiftTargetModuleName(binary.target) !== binary.target
+    )
+      parts.push(`module/${swiftTargetModuleName(binary.target)}`)
     try {
+      if (
+        binary.publicHeaders === undefined &&
+        surfaces(xcframework(binary).dir).some((surface) => surface.kind === 'swift')
+      )
+        parts.push(`interface-emulation/${WASI_EMULATION.join(',')}`)
+      if (
+        binary.publicHeaders === undefined &&
+        surfaces(xcframework(binary).dir).some((surface) => surface.kind === 'mixed')
+      )
+        parts.push(`native-graph/${NATIVE_GRAPH_ID}`)
       parts.push(
         binary.target,
         binary.source,
@@ -1158,7 +1341,7 @@ export function standinGenerationInputs(
               treeDigest(path.join(binary.dir, binary.publicHeaders)),
               ...(binary.headerDependencies ?? []).map(
                 (dependency) =>
-                  `${dependency.module}\0${treeDigest(path.join(binary.dir, dependency.path))}`,
+                  `${swiftTargetModuleName(dependency.module)}\0${treeDigest(path.join(binary.dir, dependency.path))}`,
               ),
             ].join('\0')
           : xcframework(binary).digest,
@@ -1187,6 +1370,8 @@ function binaryStandins(
   toolchain: Toolchain,
   provided: ReadonlySet<string>,
   behavior: SwiftStandinBehaviors,
+  frameworks: NativeFrameworkInputs,
+  siblings: ReadonlySet<string>,
 ): SwiftStandin[] | string {
   if (provided.has(binary.target)) return []
   // a local artifact a script downloads or builds is absent from a fresh
@@ -1201,6 +1386,7 @@ function binaryStandins(
   try {
     if (binary.publicHeaders !== undefined) {
       const headers = path.join(binary.dir, binary.publicHeaders)
+      const module = swiftTargetModuleName(binary.target)
       const modulemap = path.join(work, 'module.modulemap')
       const supplied = path.join(headers, 'module.modulemap')
       const roots = files(headers, (name) => name.endsWith('.h'))
@@ -1210,16 +1396,16 @@ function binaryStandins(
         modulemap,
         fs.existsSync(supplied)
           ? fs.readFileSync(supplied, 'utf8')
-          : `module ${binary.target} {\n${roots.map((file) => `  header "${file}"`).join('\n')}\n  export *\n}\n`,
+          : `module ${module} {\n${roots.map((file) => `  header "${file}"`).join('\n')}\n  export *\n}\n`,
       )
       all = [
         {
           kind: 'objc',
-          module: binary.target,
+          module,
           modulemap,
           headers,
           dependencies: binary.headerDependencies?.map((dependency) => ({
-            module: dependency.module,
+            module: swiftTargetModuleName(dependency.module),
             headers: path.join(binary.dir, dependency.path),
           })),
         },
@@ -1228,7 +1414,7 @@ function binaryStandins(
         treeDigest(headers),
         ...(binary.headerDependencies ?? []).map(
           (dependency) =>
-            `${dependency.module}\0${treeDigest(path.join(binary.dir, dependency.path))}`,
+            `${swiftTargetModuleName(dependency.module)}\0${treeDigest(path.join(binary.dir, dependency.path))}`,
         ),
       ].join('\0')
     } else {
@@ -1252,11 +1438,14 @@ function binaryStandins(
     standinGenerationInputs([binary], toolchain, behavior),
   )
   hash.update(digest)
+  hash.update([...siblings].sort().join('\0'))
+  if (found.some((surface) => surface.kind === 'mixed')) hash.update(frameworks.digest)
   for (const surface of found) {
     hash.update(`${surface.kind}\0${surface.module}\0`)
     for (const file of surface.kind === 'swift'
       ? [surface.interface]
       : [
+          ...(surface.kind === 'mixed' ? [surface.interface] : []),
           surface.modulemap,
           ...files(surface.headers, (name) => name.endsWith('.h')).map((file) =>
             path.join(surface.headers, file),
@@ -1279,44 +1468,47 @@ function binaryStandins(
   }
   let result: SwiftStandin[] | string
   try {
-    result =
-      process.platform === 'darwin' &&
-      process.env.TM_EXEC_BUILD_PLATFORM !== 'mac' &&
-      process.env.TM_SESSION &&
-      process.env.CI !== 'true' &&
-      toolchain.moduleRoot === path.resolve(import.meta.dirname, '../../sootsim-swift') &&
-      !swiftDistributionAt(toolchain.moduleRoot)
-        ? sourceBinaryStandins(binary, toolchain, provided, behavior)
-        : found.map((surface) => {
-            const dir = path.join(work, surface.module)
-            try {
-              if (surface.kind === 'c' && configured.has(surface.module))
-                throw new Error(
-                  "Configured behavior requires the framework's Swift declarations",
-                )
-              return surface.kind === 'swift'
-                ? swiftStandin(
-                    surface,
-                    binary,
-                    toolchain,
-                    dir,
-                    new Map(Object.entries(configured.get(surface.module) ?? {})),
-                  )
-                : surface.kind === 'objc'
-                  ? objcStandin(
-                      surface,
-                      binary,
-                      toolchain,
-                      dir,
-                      new Map(Object.entries(configured.get(surface.module) ?? {})),
-                    )
-                  : cStandin(surface, binary, toolchain, dir)
-            } catch (error) {
-              throw new Error(
-                `no stand-in for ${surface.module}: ${error instanceof Error && !('stderr' in error) ? error.message : failure(error)}`,
+    result = found.map((surface) => {
+      const dir = path.join(work, surface.module)
+      try {
+        if (surface.kind === 'c' && configured.has(surface.module))
+          throw new Error(
+            "Configured behavior requires the framework's Swift declarations",
+          )
+        return surface.kind === 'mixed'
+          ? mixedStandin(
+              surface,
+              binary,
+              toolchain,
+              dir,
+              new Map(Object.entries(configured.get(surface.module) ?? {})),
+              frameworks.dirs,
+              siblings,
+            )
+          : surface.kind === 'swift'
+            ? swiftStandin(
+                surface,
+                binary,
+                toolchain,
+                dir,
+                new Map(Object.entries(configured.get(surface.module) ?? {})),
+                siblings,
               )
-            }
-          })
+            : surface.kind === 'objc'
+              ? objcStandin(
+                  surface,
+                  binary,
+                  toolchain,
+                  dir,
+                  new Map(Object.entries(configured.get(surface.module) ?? {})),
+                )
+              : cStandin(surface, binary, toolchain, dir)
+      } catch (error) {
+        throw new Error(
+          `no stand-in for ${surface.module}: ${error instanceof Error && !('stderr' in error) ? error.message : failure(error)}`,
+        )
+      }
+    })
     if (typeof result === 'string') throw new Error(result)
     fs.mkdirSync(path.dirname(cached), { recursive: true })
     // publish a complete entry so concurrent workspaces never read partial json.
@@ -1352,26 +1544,100 @@ export function swiftStandins(
   provided: ReadonlySet<string> = new Set(),
   behavior: SwiftStandinBehaviors = {},
 ): SwiftStandins {
+  const requested = binaries.filter((binary) => !provided.has(binary.target))
+  if (requested.length === 0) return { standins: [], gaps: new Map() }
+  if (
+    process.platform === 'darwin' &&
+    process.env.TM_EXEC_BUILD_PLATFORM !== 'mac' &&
+    process.env.TM_SESSION &&
+    process.env.CI !== 'true' &&
+    toolchain.moduleRoot === path.resolve(import.meta.dirname, '../../sootsim-swift') &&
+    !swiftDistributionAt(toolchain.moduleRoot)
+  )
+    return sourceStandins(requested, toolchain, provided, behavior)
   const standins: SwiftStandin[] = []
   const gaps = new Map<string, string>()
   fs.mkdirSync(cacheDir, { recursive: true })
   const modules = fs.mkdtempSync(path.join(cacheDir, 'modules-'))
+  const frameworkDirs = new Set<string>()
+  const frameworkInputs: string[] = []
+  const byModule = new Map(
+    binaries.map((binary) => [swiftTargetModuleName(binary.target), binary]),
+  )
+  // the modules each binary's swift interfaces import
+  const interfaceImports = new Map<SwiftPackageBinary, Set<string>>()
+  for (const binary of binaries) {
+    if (binary.publicHeaders !== undefined) continue
+    try {
+      const artifact = xcframework(binary)
+      frameworkInputs.push(`${binary.target}\0${artifact.digest}`)
+      const imports = new Set<string>()
+      interfaceImports.set(binary, imports)
+      for (const surface of surfaces(artifact.dir)) {
+        byModule.set(surface.module, binary)
+        if (surface.kind === 'swift' || surface.kind === 'mixed')
+          for (const module of swiftImportNames(
+            fs.readFileSync(surface.interface, 'utf8'),
+          ))
+            imports.add(module)
+        if (surface.kind === 'c') continue
+        frameworkDirs.add(
+          surface.kind === 'swift'
+            ? path.resolve(surface.interface, '../../../..')
+            : path.resolve(surface.modulemap, '../../..'),
+        )
+      }
+    } catch {
+      // the target reports its artifact gap when visited below.
+    }
+  }
   const generatedToolchain = { ...toolchain, standinModules: modules }
-  const byTarget = new Map(binaries.map((binary) => [binary.target, binary]))
+  const frameworks: NativeFrameworkInputs = {
+    dirs: [...frameworkDirs].sort(),
+    digest: createHash('sha256').update(frameworkInputs.sort().join('\0')).digest('hex'),
+  }
+  // another binary's module a swift interface imports: its stand-in is built
+  // first and imported, as the vendor framework imports the other framework
+  const siblings = new Map(
+    binaries.map((binary) => [
+      binary,
+      new Set(
+        [...(interfaceImports.get(binary) ?? [])].filter((module) => {
+          const owner = byModule.get(module)
+          return owner !== undefined && owner !== binary && !provided.has(module)
+        }),
+      ),
+    ]),
+  )
   const prerequisites = new Set(
-    binaries.flatMap((binary) =>
-      (binary.headerDependencies ?? []).map((dependency) => dependency.module),
-    ),
+    binaries.flatMap((binary) => [
+      ...(binary.headerDependencies ?? []).map((dependency) =>
+        swiftTargetModuleName(dependency.module),
+      ),
+      ...siblings.get(binary)!,
+    ]),
   )
   const visited = new Set<string>()
   const visit = (binary: SwiftPackageBinary) => {
     if (visited.has(binary.target)) return
     visited.add(binary.target)
-    for (const dependency of binary.headerDependencies ?? []) {
-      const target = byTarget.get(dependency.module)
+    for (const module of [
+      ...(binary.headerDependencies ?? []).map((dependency) =>
+        swiftTargetModuleName(dependency.module),
+      ),
+      ...siblings.get(binary)!,
+    ]) {
+      const target = byModule.get(module)
       if (target) visit(target)
     }
-    const result = binaryStandins(binary, generatedToolchain, provided, behavior)
+    const result = binaryStandins(
+      binary,
+      generatedToolchain,
+      provided,
+      behavior,
+      frameworks,
+      siblings.get(binary)!,
+    )
     if (typeof result === 'string') {
       gaps.set(binary.target, result)
       return