peachsim 0.1.939 → 0.1.1399

package/src/swift-compile.ts

@@ -22,12 +22,15 @@ import {
 } from './swift-distribution-contract'
 import { swiftIcuAsset, type SwiftIcuAsset } from './swift-icu'
 import {
+  swiftManifestCxxLanguageStandard,
   swiftManifestTargets,
   swiftPackagePartition,
   type SwiftPackageTarget,
 } from './swift-package'
+import { isSwiftResourceBundles } from './swiftContract'
 import type { SwiftImageUpload } from './swift-submit'
 import type { SwiftWasmSdk } from './swift-toolchain'
+import type { SwiftResourceBundle } from './swiftContract'
 
 export { swiftIcuAsset, type SwiftIcuAsset }
 
@@ -47,17 +50,25 @@ const BUILD_JOBS = String(Math.min(4, Math.max(1, Math.floor(cores / 2))))
 
 export interface SwiftCompileInput {
   files: Record<string, string>
+  metalSources?: Record<string, string>
   resources?: Record<string, string>
   /** project-relative resource paths retained before the bundle namespace flattens. */
   resourcePaths?: string[]
+  resourceBundles?: SwiftResourceBundle[]
   images?: Record<string, SwiftImageUpload>
   entry: string
   /**
    * the sources are a One swift package. One's pod compiles every file with
-   * `-import-module One`, so `RNXModule`, `RNXPackage` and `JSON` resolve
+   * `-import-module One`, so `PeachModule`, `PeachPackage` and `JSON` resolve
    * without an import; the compile links Peach's `One` module the same way.
    */
   oneModule?: boolean
+  /**
+   * WebAssembly static libraries a local compile links, base64 by the target
+   * they link into: a vendored c framework's own wasm build, whose functions
+   * replace the stand-in's traps.
+   */
+  libraries?: Record<string, string>
 }
 
 export interface SwiftCompileOptions {
@@ -124,6 +135,7 @@ export function swiftModuleInputFiles(root: string): string[] {
     'Package.swift',
     'scripts/contrast-app-Package.swift',
     'scripts/build-distribution.ts',
+    'scripts/distribution-clang.ts',
     'scripts/build-distribution-plugins.sh',
     'scripts/build-preview-plugin.sh',
     'toolchain.json',
@@ -160,6 +172,10 @@ export function swiftMacroPlugins(moduleRoot: string): {
       stale: false,
     }
   const dir = path.join(moduleRoot, '.build/host/RnxPreviewMacros')
+  const release = JSON.parse(
+    readFileSync(path.join(moduleRoot, 'toolchain.json'), 'utf8'),
+  ).release
+  const compilerStamp = path.join(dir, 'compiler-release')
   // linux names a plugin's module from lib<Module>.so
   const ext = process.platform === 'darwin' ? 'dylib' : 'so'
   const plugins = [
@@ -174,16 +190,20 @@ export function swiftMacroPlugins(moduleRoot: string): {
   ]
   return {
     libraries: plugins.map(({ library }) => library),
-    stale: plugins.some(
-      ({ library, source }) =>
-        !existsSync(library) || statSync(source).mtimeMs > statSync(library).mtimeMs,
-    ),
+    stale:
+      !existsSync(compilerStamp) ||
+      readFileSync(compilerStamp, 'utf8').trim() !== release ||
+      plugins.some(
+        ({ library, source }) =>
+          !existsSync(library) || statSync(source).mtimeMs > statSync(library).mtimeMs,
+      ),
   }
 }
 
 async function ensureMacroPlugins(
   moduleRoot: string,
   toolchainBin: string,
+  release: string,
 ): Promise<string[]> {
   const { libraries, stale } = swiftMacroPlugins(moduleRoot)
   if (stale) {
@@ -192,6 +212,10 @@ async function ensureMacroPlugins(
       toolchainBin,
       libraries[0],
     ])
+    writeFileSync(
+      path.join(path.dirname(libraries[0]!), 'compiler-release'),
+      `${release}\n`,
+    )
   }
   return libraries
 }
@@ -279,6 +303,7 @@ const OPTIONAL_FRAMEWORK_DEPENDENCIES: Record<string, string[]> = {
   TikTokBusinessSDK: [],
   nSure: [],
   Statsig: [],
+  TOCropViewController: [],
   RiveRuntime: ['MetalKit'],
   MetalKit: [],
   DatadogCore: [],
@@ -293,6 +318,7 @@ const OPTIONAL_FRAMEWORK_DEPENDENCIES: Record<string, string[]> = {
   Intercom: [],
   FirebaseCore: [],
   FirebaseSharedSwift: ['FirebaseCore'],
+  FirebaseRemoteConfig: ['FirebaseCore', 'FirebaseSharedSwift'],
   FirebaseFirestoreInternal: ['FirebaseCore'],
   FirebaseAnalytics: ['FirebaseCore'],
   FirebaseAppCheck: ['FirebaseCore'],
@@ -300,6 +326,7 @@ const OPTIONAL_FRAMEWORK_DEPENDENCIES: Record<string, string[]> = {
   FirebaseCrashlytics: ['FirebaseCore'],
   FirebaseFirestore: ['FirebaseCore', 'FirebaseSharedSwift', 'FirebaseFirestoreInternal'],
   FirebaseStorage: ['FirebaseCore'],
+  GoogleMobileAds: [],
   FBAudienceNetwork: [],
 }
 const OPTIONAL_FRAMEWORKS = new Set(Object.keys(OPTIONAL_FRAMEWORK_DEPENDENCIES))
@@ -514,13 +541,21 @@ export function missingSwiftModules(
 
 export function swiftTargetDependencies(
   files: Record<string, string>,
-  targets: Pick<SwiftPackageTarget, 'name' | 'path'>[],
+  targets: Pick<SwiftPackageTarget, 'name' | 'path' | 'dependencies'>[],
 ): Map<string, string[]> {
   const names = new Set([...OPTIONAL_FRAMEWORKS, ...targets.map((target) => target.name)])
   const siblings = new Map<string, string[]>()
   for (const target of targets) {
     const prefix = target.path === '.' ? '' : `${target.path}/`
-    const deps = new Set<string>()
+    const deps = new Set(
+      (target.dependencies ?? []).flatMap((dependency) =>
+        dependency.kind === 'target' &&
+        dependency.name !== target.name &&
+        names.has(dependency.name)
+          ? [dependency.name]
+          : [],
+      ),
+    )
     for (const [file, contents] of Object.entries(files)) {
       if (file === 'Package.swift' || !file.startsWith(prefix)) continue
       if (
@@ -554,23 +589,22 @@ const importsSpriteKit = (files: Record<string, string>): boolean =>
 // every iOS source sees through Foundation what darwin's Foundation exports:
 // PeachObjC supplies the ObjectiveC module's selectors, Dispatch Foundation's
 // Darwin queue exports, and FoundationNetworking (re-exporting PeachFoundation)
-// URLSession, NotificationCenter, OperationQueue and the CoreFoundation types.
-// WASILibc is the platform libc the way Darwin's headers are on iOS: its
-// math.h answers the free round Kingfisher's SizeExtensions reaches, and its
-// pthread mutexes are what a Foundation-only source reaches there
-// (SwiftSoup's Mutex). pthread.h is not in the overlay's module: the sdk's
-// wasi-libc.modulemap (swift_static/wasi/wasm32) carries it as the separate
-// top-level module wasi_pthread, which nothing re-exports, so the flags name
-// both. these modules export only names iOS has, WASILibc's wasi-only names
-// aside; Peach's host plumbing is `package` or lives in PeachJSON, which none
-// of them re-exports. scripts/contrast-app-Package.swift and
+// URLSession, NotificationCenter, OperationQueue and the CoreFoundation types,
+// and PeachFoundationCombine the ObservableObject and Published aliases.
+// Darwin is the platform libc and Mach, as Foundation re-exports it on iOS:
+// it re-exports WASILibc, whose math.h answers the free round Kingfisher's
+// SizeExtensions reaches, and the sdk's separate pthread module wasi_pthread,
+// whose mutexes a Foundation-only source reaches (SwiftSoup's Mutex). these
+// modules export only names iOS has, WASILibc's wasi-only names aside;
+// Peach's host plumbing is `package` or lives in PeachJSON, which none of
+// them re-exports. scripts/contrast-app-Package.swift and
 // example/Package.swift carry the same flags.
 export const FOUNDATION_IMPLICIT_MODULES = [
   'PeachObjC',
   'Dispatch',
   'FoundationNetworking',
-  'WASILibc',
-  'wasi_pthread',
+  'PeachFoundationCombine',
+  'Darwin',
 ]
 const FOUNDATION_IMPLICIT_FLAGS = FOUNDATION_IMPLICIT_MODULES.map(
   (module) => `, "-Xfrontend", "-import-module", "-Xfrontend", "${module}"`,
@@ -578,7 +612,7 @@ const FOUNDATION_IMPLICIT_FLAGS = FOUNDATION_IMPLICIT_MODULES.map(
 const ONE_IMPLICIT_FLAGS = ', "-Xfrontend", "-import-module", "-Xfrontend", "One"'
 
 /** bump with any change to the emitted multi-target manifest text. */
-export const MULTI_MANIFEST_VERSION = 12
+export const MULTI_MANIFEST_VERSION = 18
 
 export function swiftArtifactHash(
   input: SwiftCompileInput,
@@ -586,6 +620,8 @@ export function swiftArtifactHash(
   moduleRoot: string,
 ): string {
   const hash = createHash('sha256')
+  // v22: Foundation sources see Darwin, which carries the libc and Mach
+  // v21: Foundation sources see the ObservableObject and Published aliases
   // v20: supplied table editing and swipe methods preserve objective-c selectors
   // v18: NSValue(time:) constructs NSStructBox through NSValue.boxedTime
   // v17: AVAsset(url:) constructs AVURLAsset for the class cluster
@@ -602,13 +638,22 @@ export function swiftArtifactHash(
   // v6: app and scene delegate classes compile final
   // (v5: a target declaring resources gets SwiftPM's Bundle.module accessor;
   // v4: sources compile through swiftSourceAsIOS)
-  hash.update(`swift-compile/v20\n${release}\n`)
+  hash.update(`swift-compile/v23\n${release}\n`)
   if (input.oneModule) hash.update('one-module\n')
   hash.update(swiftModuleDigest(moduleRoot))
   for (const file of Object.keys(input.files).sort()) {
     hash.update(createHash('sha256').update(file).digest())
     hash.update(createHash('sha256').update(input.files[file]).digest())
   }
+  for (const file of Object.keys(input.metalSources ?? {}).sort()) {
+    hash.update('metal-source\n')
+    hash.update(createHash('sha256').update(file).digest())
+    hash.update(
+      createHash('sha256')
+        .update(input.metalSources?.[file] ?? '')
+        .digest(),
+    )
+  }
   for (const base of Object.keys(input.resources ?? {}).sort()) {
     hash.update(createHash('sha256').update(base).digest())
     hash.update(
@@ -628,6 +673,19 @@ export function swiftArtifactHash(
     hash.update('resource-path\n')
     hash.update(createHash('sha256').update(file).digest())
   }
+  hash.update(
+    JSON.stringify(
+      [...(input.resourceBundles ?? [])].sort((a, b) => a.target.localeCompare(b.target)),
+    ),
+  )
+  for (const target of Object.keys(input.libraries ?? {}).sort()) {
+    hash.update(`library\n${target}\n`)
+    hash.update(
+      createHash('sha256')
+        .update(input.libraries?.[target] ?? '')
+        .digest(),
+    )
+  }
   const targets = compileTargets(input)
   if (targets.length > 0) {
     hash.update(`swift-multi/v${MULTI_MANIFEST_VERSION}\n`)
@@ -643,14 +701,28 @@ export function swiftArtifactHash(
   return hash.digest('hex')
 }
 
+interface SwiftNativeTargetPlan {
+  path: string
+  includeDirectory: string
+  // units that consume a swift-generated header: excluded from the original
+  // target and compiled by the downstream implementation target.
+  lateSources: string[]
+  late: { name: string; producers: string[] }
+}
+
 export function emitSwiftPackageManifest(args: {
   targets: SwiftPackageTarget[]
+  cxxLanguageStandard?: string
+  native?: Map<string, SwiftNativeTargetPlan>
+  headerDirectory?: string
   siblings: Map<string, string[]>
   moduleRoot: string
   oneModule?: boolean
   spriteKit?: boolean
   /** link the prebuilt distribution at moduleRoot instead of its sources. */
   distribution?: SwiftDistributionManifest
+  /** the static library each target links, by target name. */
+  libraries?: Map<string, string>
 }): string {
   const { targets, siblings, moduleRoot, oneModule, spriteKit, distribution } = args
   const reachedFrameworks = new Set(
@@ -682,6 +754,10 @@ export function emitSwiftPackageManifest(args: {
     const isolation = target.mainActorIsolation
       ? ' .defaultIsolation(MainActor.self),'
       : ''
+    const interoperability = target.cxxInterop ? ' .interoperabilityMode(.Cxx),' : ''
+    const defines = (target.defines ?? [])
+      .map((name) => ` .define(${JSON.stringify(name)}),`)
+      .join('')
     // a distribution's modules import from its modules/ directory, and its
     // objects link as inputs, exactly as a source build links every object it
     // compiled: whole, and ahead of the sdk libraries, so PeachICU's
@@ -693,9 +769,29 @@ export function emitSwiftPackageManifest(args: {
     const imports = distribution
       ? `, "-I", ${JSON.stringify(path.join(moduleRoot, 'modules'))}`
       : ''
-    const swiftSettings = `swiftSettings: [.swiftLanguageMode(.v${target.languageMode}),${isolation} .unsafeFlags(["-Osize"${FOUNDATION_IMPLICIT_FLAGS}${oneModule ? ONE_IMPLICIT_FLAGS : ''}${imports}])]`
+    const native = args.native?.get(target.name)
+    const nativeImports = (siblings.get(target.name) ?? [])
+      .filter((name) => args.native?.has(name))
+      .map(
+        (name) =>
+          `, "-Xfrontend", "-import-module", "-Xfrontend", ${JSON.stringify(name)}`,
+      )
+      .join('')
+    const header =
+      args.headerDirectory &&
+      [...(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`))}`
+        : ''
+    const swiftSettings = `swiftSettings: [.swiftLanguageMode(.v${target.languageMode}),${isolation}${interoperability}${defines} .unsafeFlags(["-Osize"${FOUNDATION_IMPLICIT_FLAGS}${oneModule ? ONE_IMPLICIT_FLAGS : ''}${imports}${nativeImports}${header}])]`
     const deps = [
-      ...(distribution
+      ...(target.executable
+        ? [...(args.native?.values() ?? [])].map((value) =>
+            JSON.stringify(value.late.name),
+          )
+        : []),
+      ...(distribution || native
         ? []
         : [
             '.product(name: "SwiftUI", package: "sootsim-swift")',
@@ -729,13 +825,17 @@ export function emitSwiftPackageManifest(args: {
         ]),
         .unsafeFlags(["-Xlinker", "--strip-all"], .when(configuration: .release)),
       ]`
-      : ''
+      : args.libraries?.has(target.name)
+        ? `,
+      linkerSettings: [.unsafeFlags([${JSON.stringify(args.libraries.get(target.name))}])]`
+        : ''
     return [
       `    ${kind}(`,
       `      name: "${target.name}",`,
       `      dependencies: [${deps}],`,
       `      path: "${target.path}",`,
-      `      ${swiftSettings}${link}`,
+      ...(native ? [`      exclude: ${JSON.stringify(native.lateSources)},`] : []),
+      `      ${native ? 'cxxSettings: []' : swiftSettings}${link}`,
       `    ),`,
     ].join('\n')
   }
@@ -752,7 +852,17 @@ export function emitSwiftPackageManifest(args: {
     `  dependencies: [${distribution ? '' : `.package(path: "${moduleRoot}")`}],`,
     '  targets: [',
     ...targets.map(stanza),
-    '  ]',
+    ...[...(args.native?.entries() ?? [])].flatMap(([name, native]) => [
+      `    .target(name: ${JSON.stringify(native.late.name)},`,
+      `      dependencies: ${JSON.stringify([name, ...native.late.producers])},`,
+      `      path: ${JSON.stringify(native.path)},`,
+      `      sources: ${JSON.stringify(native.lateSources)},`,
+      `      publicHeadersPath: "include",`,
+      `      cxxSettings: [.unsafeFlags(["-fno-cxx-modules", "-I", ${JSON.stringify(native.includeDirectory)}, "-I", ${JSON.stringify(args.headerDirectory)}])]),`,
+    ]),
+    args.cxxLanguageStandard
+      ? `  ],\n  cxxLanguageStandard: .${args.cxxLanguageStandard}`
+      : '  ]',
     ')',
     '',
   ].join('\n')
@@ -761,7 +871,7 @@ export function emitSwiftPackageManifest(args: {
 // the build tree mirrors the input: a file is written only when its text
 // changed and a file the input dropped is removed, so an unchanged source
 // keeps its mtime and swiftpm rebuilds only what moved. `.build` stays.
-export function syncSwiftTree(base: string, files: Map<string, string>): void {
+export function syncSwiftTree(base: string, files: Map<string, string | Buffer>): void {
   mkdirSync(base, { recursive: true })
   const walk = (dir: string): void => {
     for (const entry of readdirSync(dir, { withFileTypes: true })) {
@@ -773,9 +883,15 @@ export function syncSwiftTree(base: string, files: Map<string, string>): void {
   }
   walk(base)
   for (const [full, contents] of files) {
-    if (existsSync(full) && readFileSync(full, 'utf8') === contents) continue
+    if (
+      existsSync(full) &&
+      (typeof contents === 'string'
+        ? readFileSync(full, 'utf8') === contents
+        : readFileSync(full).equals(contents))
+    )
+      continue
     mkdirSync(path.dirname(full), { recursive: true })
-    writeFileSync(full, contents, 'utf8')
+    writeFileSync(full, contents)
   }
 }
 
@@ -1009,7 +1125,12 @@ function liftExtensionOverrides(
     nameAt: number
     edits: [number, number, string][]
   }[] = []
-  const overrides: { type: string; member: string; at: number; nameAt: number }[] = []
+  const overrides: {
+    type: string
+    member: string
+    at: number
+    nameAt: number
+  }[] = []
   // the offset just past the brace that closes the one at `open`
   const closing = (open: number): number => closingBrace(source, tokens, open)
   for (const at of tokens) {
@@ -2203,6 +2324,11 @@ export function writeSwiftProject(
   input: SwiftCompileInput,
   moduleRoot: string,
 ): void {
+  if (
+    input.resourceBundles !== undefined &&
+    !isSwiftResourceBundles(input.resourceBundles)
+  )
+    throw new Error('swift compile input has invalid target bundle assignments')
   const resourceTargets = swiftManifestTargets(
     input.files['Package.swift'] ?? '',
     input.resourcePaths,
@@ -2223,7 +2349,96 @@ export function writeSwiftProject(
           },
         ]
       : compileTargets(input)
-  const files = new Map<string, string>()
+  const files = new Map<string, string | Buffer>()
+  const native = new Map<string, SwiftNativeTargetPlan>()
+  const headerDirectory = path.join(layout.root, '.build', 'peach-cxx-headers')
+  // declarations are imported before swift can emit the header that native
+  // implementations consume. give those implementations a downstream target.
+  for (const target of targets) {
+    const prefix = target.path === '.' ? '' : `${target.path}/`
+    const entries = Object.entries(input.files).filter(
+      ([file]) =>
+        file.startsWith(prefix) &&
+        !targets.some(
+          (candidate) =>
+            candidate.name !== target.name &&
+            candidate.path !== '.' &&
+            candidate.path.startsWith(prefix) &&
+            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 includes = `${prefix}include/`
+    const consumers = new Map<string, Set<string>>()
+    const reverse = new Map<string, string[]>()
+    for (const [file, contents] of entries) {
+      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)) {
+        const include = match[1]!
+        const producer = /(?:^|\/)([^/]+)-Swift\.h$/.exec(include)?.[1]
+        if (producer && targets.some((value) => value.name === producer))
+          producers.add(producer)
+        const local = [
+          path.posix.join(path.posix.dirname(file), include),
+          `${includes}${include}`,
+        ].find((candidate) => input.files[candidate] !== undefined)
+        if (local) {
+          reverse.set(local, [...(reverse.get(local) ?? []), file])
+        }
+      }
+      consumers.set(file, producers)
+    }
+    const queue = [...consumers.keys()].filter((file) => consumers.get(file)!.size > 0)
+    for (let index = 0; index < queue.length; index++) {
+      const file = queue[index]!
+      for (const parent of reverse.get(file) ?? []) {
+        const inherited = consumers.get(parent)!
+        const before = inherited.size
+        for (const producer of consumers.get(file)!) inherited.add(producer)
+        if (before !== inherited.size) queue.push(parent)
+      }
+    }
+    const late = units.filter(([file]) => consumers.get(file)!.size > 0)
+    if (late.length === 0) continue
+    native.set(target.name, {
+      path: target.path,
+      includeDirectory: path.join(layout.root, includes),
+      lateSources: late.map(([file]) => file.slice(prefix.length)),
+      late: {
+        name: `${target.name}SwiftImplementation`,
+        producers: [
+          ...new Set(late.flatMap(([file]) => [...consumers.get(file)!])),
+        ].sort(),
+      },
+    })
+    // only declaration roots belong to the imported clang module. headers
+    // consuming swift's generated output belong to its implementation target.
+    // a package that ships its own module map keeps it.
+    if (input.files[`${includes}module.modulemap`] !== undefined) continue
+    const roots = entries.filter(
+      ([file]) =>
+        file.startsWith(includes) &&
+        /\.(?:h|hpp|hh|hxx)$/.test(file) &&
+        consumers.get(file)!.size === 0,
+    )
+    files.set(
+      path.join(layout.root, includes, 'module.modulemap'),
+      [
+        `module ${target.name} {`,
+        ...roots.map(
+          ([file]) => `  header ${JSON.stringify(file.slice(includes.length))}`,
+        ),
+        '  export *',
+        '}',
+        '',
+      ].join('\n'),
+    )
+  }
+  if (native.size > 0) mkdirSync(headerDirectory, { recursive: true })
   // swiftpm plans a build root's build once and reuses the plan until a
   // manifest changes, so a file added to the module would never compile
   // there (RAN: a broken new UIKitCore file built "complete" in 0.1s). the
@@ -2239,7 +2454,11 @@ export function writeSwiftProject(
       JSON.stringify(
         resourceTargets
           .filter((target) => target.resources)
-          .map((target) => [target.name, target.path]),
+          .map((target) => [
+            target.name,
+            target.path,
+            input.resourceBundles?.find((bundle) => bundle.target === target.name)?.path,
+          ]),
       ),
     )
     .digest('hex')
@@ -2305,6 +2524,12 @@ export function writeSwiftProject(
     files.set(path.join(layout.root, 'Package.swift'), manifest + moduleFiles)
   } else {
     const base = layout.multi ? layout.root : layout.sources
+    const libraries = new Map<string, string>()
+    for (const [target, data] of Object.entries(input.libraries ?? {})) {
+      const file = path.join(layout.root, '.peach-libraries', `lib${target}.a`)
+      files.set(file, Buffer.from(data, 'base64'))
+      libraries.set(target, file)
+    }
     for (const [file, contents] of Object.entries(input.files)) {
       if (file === 'Package.swift') continue
       files.set(
@@ -2316,6 +2541,11 @@ export function writeSwiftProject(
       path.join(layout.root, 'Package.swift'),
       emitSwiftPackageManifest({
         targets,
+        native,
+        headerDirectory: native.size > 0 ? headerDirectory : undefined,
+        cxxLanguageStandard: swiftManifestCxxLanguageStandard(
+          input.files['Package.swift'] ?? '',
+        ),
         siblings: swiftTargetDependencies(
           input.files,
           layout.multi ? targets : targets.map((target) => ({ ...target, path: '.' })),
@@ -2324,13 +2554,20 @@ export function writeSwiftProject(
         oneModule: input.oneModule,
         spriteKit: importsSpriteKit(input.files),
         distribution: distribution ?? undefined,
+        libraries,
       }) + moduleFiles,
     )
   }
-  // peach serves all target resources from the mount's flat /res bundle.
-  // retain target ownership of the accessor even though its bytes share that bundle.
+  // resource accessors and the /res pack share the original target assignment.
   for (const target of resourceTargets) {
     if (!target.resources) continue
+    const bundle = input.resourceBundles?.find(
+      (candidate) => candidate.target === target.name,
+    )
+    if (!bundle || bundle.sourcePath !== target.path)
+      throw new Error(
+        `swift resource target ${target.name} has no matching bundle assignment`,
+      )
     const directory = layout.multi ? path.join(layout.root, target.path) : layout.sources
     files.set(
       path.join(directory, 'ResourceBundleAccessor.generated.swift'),
@@ -2338,7 +2575,9 @@ export function writeSwiftProject(
         'import Foundation',
         '',
         'extension Foundation.Bundle {',
-        '  static let module: Bundle = Bundle.main',
+        bundle.path === '.'
+          ? '  static let module: Bundle = Bundle.main'
+          : `  static let module: Bundle = {\n    let url = Bundle.main.bundleURL.appendingPathComponent(${JSON.stringify(bundle.path)})\n    guard let bundle = Bundle(url: url) else { fatalError("resource bundle is missing: ${bundle.target}") }\n    return bundle\n  }()`,
         '}',
         '',
       ].join('\n'),
@@ -2434,7 +2673,6 @@ export function compileSwiftProjectUnit(
       process.platform === 'darwin' &&
       process.env.TM_SESSION &&
       process.env.CI !== 'true' &&
-      process.env.CONTRAST_HEAVY_ADMITTED !== '1' &&
       moduleRoot === path.resolve(import.meta.dirname, '../../sootsim-swift') &&
       !swiftDistributionAt(moduleRoot)
     ) {
@@ -2462,7 +2700,11 @@ export function compileSwiftProjectUnit(
             '--output',
             output,
           ],
-          { cwd: repo, timeout: options.timeoutMs, maxBuffer: 64 * 1024 * 1024 },
+          {
+            cwd: repo,
+            timeout: options.timeoutMs,
+            maxBuffer: 64 * 1024 * 1024,
+          },
         )
         pending.child.stdout?.on('data', (bytes: Buffer) => process.stdout.write(bytes))
         pending.child.stderr?.on('data', (bytes: Buffer) => process.stderr.write(bytes))
@@ -2508,7 +2750,11 @@ export function compileSwiftProjectUnit(
         `swift-compile: no swift.org toolchain at ${options.toolchainBin}; install ${options.release} and its matching wasm sdk`,
       )
     }
-    const macroPlugins = await ensureMacroPlugins(moduleRoot, options.toolchainBin)
+    const macroPlugins = await ensureMacroPlugins(
+      moduleRoot,
+      options.toolchainBin,
+      options.release,
+    )
     // memoized per toolchain, so only a process's first build waits on it,
     // and that one reads and gzips it while swift builds
     const sdk = swiftModuleSdk(moduleRoot).wasmSdkId
@@ -2518,6 +2764,8 @@ export function compileSwiftProjectUnit(
         swift,
         [
           'build',
+          '--build-system',
+          'native',
           '-j',
           BUILD_JOBS,
           '--package-path',

package/src/swift-distribution-contract.ts

@@ -52,6 +52,8 @@ export interface SwiftDistributionLock extends SwiftWasmSdk {
   release: string
   /** the commit the module sources were built from. */
   source: string
+  /** the Package.swift targets it was built from (swiftPeachModules). */
+  targets: string[]
   hosts: Record<SwiftDistributionHost, { sha256: string; size: number }>
 }
 
@@ -107,6 +109,7 @@ export function parseSwiftDistributionLock(value: unknown): SwiftDistributionLoc
     typeof value.wasmSdkUrl !== 'string' ||
     typeof value.wasmSdkChecksum !== 'string' ||
     typeof value.source !== 'string' ||
+    !isStrings(value.targets) ||
     !isRecord(value.hosts)
   ) {
     throw new Error('invalid Swift distribution lock')
@@ -131,6 +134,7 @@ export function parseSwiftDistributionLock(value: unknown): SwiftDistributionLoc
     wasmSdkUrl: value.wasmSdkUrl,
     wasmSdkChecksum: value.wasmSdkChecksum,
     source: value.source,
+    targets: value.targets,
     hosts: {
       'darwin-arm64': entry('darwin-arm64'),
       'linux-x64': entry('linux-x64'),