peachsim 0.1.2208 → 0.1.2210

package/src/swift-compile.ts

@@ -62,6 +62,7 @@ import {
   SWIFT_OBJC_INTEROP_FLAGS,
   swiftClangImporterFlags,
   swiftObjCModuleMap,
+  swiftSubmoduleImports,
 } from './swift-objc-import'
 import { swiftObjCRuntimeFlags } from './swift-objc-runtime'
 import { iosDeploymentMinimum, objcSdkIntakeFlags } from './swift-objc-standin'
@@ -1373,6 +1374,104 @@ export function swiftSystemLibraryExclusions(
   )
 }
 
+// EXUpdates publicly imports these C targets. The distribution links their
+// objects and ships no clang module, so a later `import EXUpdates` fails
+// with missing required modules EXStructuredHeaders and EXUpdatesBSPatch.
+// Headers match packages/sootsim-swift/Sources for those targets.
+const DISTRIBUTION_CLANG_MODULES: {
+  name: string
+  header: string
+  source: string
+}[] = [
+  {
+    name: 'EXStructuredHeaders',
+    header: 'EXStructuredHeaders/EXStructuredHeadersParser.h',
+    source: `//  Copyright © 2021 650 Industries. All rights reserved.
+
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+typedef NS_ENUM(NSInteger, EXStructuredHeadersParserFieldType) {
+  EXStructuredHeadersParserFieldTypeDictionary,
+  EXStructuredHeadersParserFieldTypeList,
+  EXStructuredHeadersParserFieldTypeItem
+};
+
+@interface EXStructuredHeadersParser : NSObject
+
+- (instancetype)initWithRawInput:(NSString *)raw
+                       fieldType:(EXStructuredHeadersParserFieldType)fieldType;
+
+- (instancetype)initWithRawInput:(NSString *)raw
+                       fieldType:(EXStructuredHeadersParserFieldType)fieldType
+              ignoringParameters:(BOOL)shouldIgnoreParameters;
+
+- (nullable id)parseStructuredFieldsWithError:(NSError ** _Nullable)error;
+
+@end
+
+NS_ASSUME_NONNULL_END
+`,
+  },
+  {
+    name: 'EXUpdatesBSPatch',
+    header: 'EXUpdatesBSPatch.h',
+    source: `// Copyright 2015-present 650 Industries. All rights reserved.
+
+#pragma once
+
+#import <Foundation/Foundation.h>
+
+int EXUpdatesApplyBSDiffPatch(const char * _Nonnull oldFilePath,
+                              const char * _Nonnull newFilePath,
+                              const char * _Nonnull patchFilePath);
+`,
+  },
+]
+
+function distributionClangModulePresent(modules: string, name: string): boolean {
+  return (
+    existsSync(path.join(modules, `${name}.swiftmodule`)) ||
+    existsSync(path.join(modules, name, 'module.modulemap'))
+  )
+}
+
+/** module map for distribution C targets the archive omitted, or null when
+ *  the archive already provides them. */
+function distributionClangModuleMap(root: string, modules: string): string | null {
+  const missing = DISTRIBUTION_CLANG_MODULES.filter(
+    (mod) => !distributionClangModulePresent(modules, mod.name),
+  )
+  if (missing.length === 0) return null
+  const key = createHash('sha256')
+    .update(modules)
+    .update(missing.map((mod) => `${mod.name}\0${mod.source}`).join('\0'))
+    .digest('hex')
+    .slice(0, 16)
+  const directory = path.join(root, `.peach-clang-modules-${key}`)
+  const mapPath = path.join(directory, 'module.modulemap')
+  if (!existsSync(mapPath)) {
+    mkdirSync(directory, { recursive: true })
+    const parts: string[] = []
+    for (const mod of missing) {
+      const destination = path.join(directory, mod.header)
+      mkdirSync(path.dirname(destination), { recursive: true })
+      writeFileSync(destination, mod.source)
+      parts.push(
+        `module ${mod.name} {\n  requires objc\n  header "${mod.header}"\n  export *\n}\n`,
+      )
+    }
+    writeFileSync(mapPath, parts.join('\n'))
+  }
+  return mapPath
+}
+
+function distributionClangModuleOptions(root: string, modules: string): string[] {
+  const map = distributionClangModuleMap(root, modules)
+  return map === null ? [] : ['-Xcc', `-fmodule-map-file=${map}`]
+}
+
 /** prebuilt modules without interfaces owned by the compiling source graph. */
 function providedModulesPath(
   root: string,
@@ -2038,7 +2137,9 @@ export function emitSwiftPackageManifest(args: {
               path.join(moduleRoot, 'modules'),
               args.moduleExcludes,
             ),
-          )}`
+          )}${distributionClangModuleOptions(args.root, path.join(moduleRoot, 'modules'))
+            .map((flag) => `, ${JSON.stringify(flag)}`)
+            .join('')}`
         : prebuilt
           ? `, "-Isystem", ${JSON.stringify(providedModulesPath(args.root, prebuilt.modules, args.moduleExcludes))}${prebuilt.moduleMaps
               .map((map) => `, "-Xcc", ${JSON.stringify(`-fmodule-map-file=${map}`)}`)
@@ -2351,6 +2452,9 @@ export function syncSwiftTree(base: string, files: Map<string, string | Buffer>)
         dir === base &&
         (entry.name === '.build' ||
           entry.name.startsWith('.peach-modules-') ||
+          // distribution clang maps are written beside the project and named
+          // from the compiler flags, so a sync must not remove them.
+          entry.name.startsWith('.peach-clang-modules-') ||
           entry.name === SWIFT_LINK_STAMP)
       )
         continue
@@ -3729,6 +3833,25 @@ function stripCCode(source: string): string {
   return code
 }
 
+// whether the unit's code under wasm32 takes its own return address, which
+// the WebAssembly backend rejects ("hasn't implemented __builtin_return_address"):
+// native machine code the target has no lowering for, like assembly. branches
+// the native architecture macros guard are not wasm code.
+const wasmMacroEnvironment: SwiftCMacroEnvironment = {
+  ...emptyMacroEnvironment,
+  defines: new Map([
+    ['__wasm__', '1'],
+    ['__wasm32__', '1'],
+    ['__wasi__', '1'],
+  ]),
+}
+export function swiftCTakesReturnAddress(source: string): boolean {
+  if (!source.includes('__builtin_return_address')) return false
+  return /\b__builtin_return_address\s*\(/.test(
+    cActiveCode(stripCCode(source), wasmMacroEnvironment),
+  )
+}
+
 // every name the given sources define. order and conditions are not
 // evaluated: a name defined anywhere makes its guards undecided.
 export function swiftCDefinedNames(sources: Iterable<string>): Set<string> {
@@ -4257,6 +4380,11 @@ export function writeSwiftProject(
         clangImportedModules.add(name)
       }
   }
+  const submoduleImports = swiftSubmoduleImports(
+    Object.entries(input.files).flatMap(([file, contents]) =>
+      file.endsWith('.swift') ? [contents] : [],
+    ),
+  )
   const headerDirectory = path.join(layout.root, '.build', 'peach-cxx-headers')
   const flattenedHeaders = new Set<string>()
   // product header aliases belong to this input. keep emitted Swift headers,
@@ -4803,6 +4931,7 @@ export function writeSwiftProject(
             swiftObjCModuleMap(
               swiftTargetModuleName(target.name),
               roots.map((file) => path.join(layout.root, file)),
+              submoduleImports.get(swiftTargetModuleName(target.name)),
             ))
         if (moduleContents === undefined)
           throw new Error('missing original module map ' + modulemap)
@@ -5192,26 +5321,38 @@ export function writeSwiftProject(
       modulemap,
       originalMap
         ? `extern module ${moduleName} ${JSON.stringify(path.join(layout.root, originalMap))}\nmodule ${moduleName}.Swift {\n  header ${JSON.stringify(path.join(headerDirectory, name + '-Swift.h'))}\n  requires objc\n}\n`
-        : swiftObjCModuleMap(moduleName, [
-            ...(
-              input.nativeTargets?.find((target) => target.name === name)
-                ?.publicHeaders ?? []
-            ).map((header) => path.join(layout.root, header)),
-            path.join(headerDirectory, name + '-Swift.h'),
-          ]),
+        : swiftObjCModuleMap(
+            moduleName,
+            [
+              ...(
+                input.nativeTargets?.find((target) => target.name === name)
+                  ?.publicHeaders ?? []
+              ).map((header) => path.join(layout.root, header)),
+              path.join(headerDirectory, name + '-Swift.h'),
+            ],
+            submoduleImports.get(moduleName),
+          ),
     )
     nativeHeaderFlags.push('-fmodule-map-file=' + modulemap)
   }
   // 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
-  // module's file list and package flags replan when either changes.
+  // module's file list, the package flags, and the app package's swift
+  // names replan when any changes. names only, so an edit of a file already
+  // in the plan still incremental-compiles.
   const modulePlan = createHash('sha256').update(
     swiftModuleInputFiles(moduleRoot).join('\n'),
   )
   if (!distribution) {
     modulePlan.update(readFileSync(path.join(moduleRoot, 'Package.swift')))
   }
+  modulePlan.update(
+    Object.keys(input.files)
+      .filter((file) => file.endsWith('.swift'))
+      .sort()
+      .join('\n'),
+  )
   const resourcePlan = createHash('sha256')
     .update(
       JSON.stringify(
@@ -5744,6 +5885,12 @@ export function writeSwiftProject(
               : prebuilt
                 ? providedModulesPath(layout.root, prebuilt.modules, moduleExcludes)
                 : path.join(layout.root, '.build', WASM_TRIPLE, 'release', 'Modules'),
+            ...(distribution
+              ? distributionClangModuleOptions(
+                  layout.root,
+                  path.join(moduleRoot, 'modules'),
+                )
+              : []),
             ...(prebuilt?.moduleMaps.flatMap((map) => [
               '-Xcc',
               `-fmodule-map-file=${map}`,
@@ -6471,8 +6618,15 @@ async function buildFrameworkProducts(
   const linked = frameworkLinkClosure(scratch, linkedTargets.targets)
   const objects = linked.objects
   if (linked.modules.has('UniformTypeIdentifiers')) {
-    const object = path.join(scratch, 'UniformTypeIdentifiers-NativeConstants.o')
-    if (!existsSync(object)) {
+    const constantsDir = path.join(scratch, 'uniform-type-constants')
+    const constantsStamp = path.join(constantsDir, '.complete')
+    const object = path.join(constantsDir, 'UniformTypeIdentifiers-NativeConstants.o')
+    if (
+      !existsSync(constantsStamp) ||
+      readFileSync(constantsStamp, 'utf8') !== args.frameworkKey
+    ) {
+      rmSync(constantsDir, { recursive: true, force: true })
+      mkdirSync(constantsDir)
       const sdkPaths = swiftSdkPaths(args.moduleRoot, args.toolchainBin)
       compileUniformTypeConstants({
         bin: args.toolchainBin,
@@ -6480,8 +6634,9 @@ async function buildFrameworkProducts(
         darwin: sdkPaths.darwin,
         packageRoot: args.moduleRoot,
         minimum: darwinRecordsMinimum(),
-        out: scratch,
+        out: constantsDir,
       })
+      writeFileSync(constantsStamp, args.frameworkKey)
     }
     objects.push(object)
     linked.owners.set(object, 'UniformTypeIdentifiers')
@@ -6886,6 +7041,7 @@ function compileSwiftProjectOnce(
       if (
         !options.intermediates &&
         process.platform === 'darwin' &&
+        !options.intermediates &&
         process.env.TM_SESSION &&
         !windowAdmission() &&
         process.env.CI !== 'true' &&

package/src/swift-distribution.lock.json

@@ -1,10 +1,10 @@
 {
-  "id": "87fc4d2ff9d5d588",
+  "id": "e7ae8fdb51086f73",
   "release": "swift-6.4.0-RELEASE-custom-11345d60dca47496",
   "wasmSdkId": "swift-6.4.0-RELEASE_wasm-peach-19471d4b",
   "wasmSdkUrl": "https://r2.sootsim.com/swift-wasm-sdk/swift-6.4.0-RELEASE_wasm-peach-19471d4b.artifactbundle.tar.gz",
   "wasmSdkChecksum": "764c16e7e34156bf90d6c3372a2b77b98b9d8c3470235520d0f9619f90f33456",
-  "source": "08519cc5f11db43a2f85f28c47ec6c8930843f93",
+  "source": "dbcdd2998c7a523cb5136f3731f6850cfe0bd154",
   "targets": [
     "ImagePlayground",
     "QuickLookThumbnailing",
@@ -244,16 +244,16 @@
   },
   "hosts": {
     "darwin-arm64": {
-      "sha256": "7444ad87688bb551601a49fee6b48d15978fcd877982a25a944280f553f439b5",
-      "size": 103297800
+      "sha256": "8680805789e5212d83e374bea9e4af3e3c7a86011e8ebf4921e76a8eba092761",
+      "size": 103496854
     },
     "linux-x64": {
-      "sha256": "03edd8359c024c592bb53b8917d9efc59f9b76871966b41189838deb2b9c27f2",
-      "size": 106017072
+      "sha256": "9d82820dfdbc857d5127c489b9c704c9e9336fe8b010256cd5b1d24ba956f454",
+      "size": 106214710
     },
     "linux-arm64": {
-      "sha256": "00a89f46a581f73ea6b0343f21fa330bbe1ae444a1d29ad7251e87a86e4bc91b",
-      "size": 105508093
+      "sha256": "a8e5084e14867ca9245428e51cb9435bc5b34505914fa5855950951d01b6b990",
+      "size": 105708986
     }
   }
 }

package/src/swift-host.ts

@@ -83,7 +83,8 @@ import {
   type SwiftPackageGap,
   type SwiftPackages,
 } from './swift-packages'
-import { rasterizePdfFile } from './swift-pdf-raster'
+import { rasterizePdfFile, rasterizeSvgFile } from './swift-pdf-raster'
+import { shippedBinaryDiffers } from './swift-shipped-binaries'
 import {
   packageInputPath,
   readPackageFile as readSwiftSourceFile,
@@ -596,7 +597,7 @@ async function swiftPackages(
   // compiling, or a placeholder package's swift target: each stands in from
   // its public surface.
   const standinArtifact = (binary: SwiftPackageBinary) =>
-    binary.publicHeaders === undefined || binary.assemblySources !== undefined
+    binary.publicHeaders === undefined || binary.unloweredSources !== undefined
   const artifacts = reached.filter(standinArtifact)
   if (entry.moduleRoot && entry.provided && artifacts.length > 0) {
     const resolved = swiftModuleToolchain(entry.moduleRoot)
@@ -618,10 +619,16 @@ async function swiftPackages(
     const cxxArtifacts = reached.filter(standinArtifact)
     const generation = standinGenerationInputs(cxxArtifacts, toolchain, entry.behavior)
     if (cached.standinKey !== generation) {
+      // an archive other than the one peach ships a module for stands in itself
+      const replaced = new Set(
+        cxxArtifacts
+          .filter((binary) => shippedBinaryDiffers(binary.target, binary.checksum))
+          .map((binary) => binary.target),
+      )
       const built = await swiftStandins(
         cxxArtifacts,
         toolchain,
-        entry.provided,
+        new Set([...entry.provided].filter((name) => !replaced.has(name))),
         entry.behavior,
       )
       cached.packages = await resolveSwiftPackagesAsync({
@@ -637,6 +644,9 @@ async function swiftPackages(
             .map((binary) => binary.target)
             .filter((target) => !built.gaps.has(target)),
         ]),
+        standinTargets: new Set(
+          [...replaced].filter((target) => !built.gaps.has(target)),
+        ),
         binaryGaps: built.gaps,
         owners,
       })
@@ -1941,6 +1951,15 @@ export function buildSwiftResourceTable(
         throw new Error('swift image pack exceeds the compile service caps')
       }
       bytes = readPackageFile(project.packagePath, disk, limits.imageBytes)
+      const svg =
+        ext === '.svg'
+          ? rasterizeSvgFile(disk, createHash('sha256').update(bytes).digest('hex'))
+          : null
+      if (svg) {
+        bytes = svg.bytes
+        ext = '.png'
+        uploadName = `${path.posix.basename(file, path.posix.extname(file))}.png`
+      }
     }
     if (imageBytes + bytes.length > limits.imageTotalBytes) {
       throw new Error('swift image pack exceeds the compile service caps')

package/src/swift-objc-compile.ts

@@ -432,7 +432,7 @@ function* xcodeObjCInputSteps(
     if (
       !binary.reached ||
       binary.publicHeaders === undefined ||
-      binary.assemblySources !== undefined
+      binary.unloweredSources !== undefined
     )
       continue
     const manifest = swiftPackageManifest(binary.dir)

package/src/swift-objc-import.ts

@@ -24,12 +24,42 @@ export function swiftClangImporterFlags(flags: readonly string[]): string[] {
   )
 }
 
+// swift names a header's submodule as `import Module.Header`, which xcode
+// infers for every header of a framework. a header an app source imports that
+// way becomes its own submodule, visible with the module; the rest stay in it.
+const SWIFT_SUBMODULE_IMPORT =
+  /^[ \t]*(?:@\w+(?:\([^)]*\))?[ \t]+)*import[ \t]+([A-Za-z_]\w*)\.([A-Za-z_]\w*)[ \t]*(?:\/\/.*)?$/gm
+
+export function swiftSubmoduleImports(
+  sources: Iterable<string>,
+): Map<string, Set<string>> {
+  const imports = new Map<string, Set<string>>()
+  for (const source of sources)
+    for (const [, module, submodule] of source.matchAll(SWIFT_SUBMODULE_IMPORT)) {
+      const names = imports.get(module!) ?? new Set<string>()
+      names.add(submodule!)
+      imports.set(module!, names)
+    }
+  return imports
+}
+
 // swiftpm synthesizes a module map for public headers when the package provides
 // none. original xcode and package module maps retain their own contents.
-export function swiftObjCModuleMap(module: string, headers: readonly string[]): string {
+export function swiftObjCModuleMap(
+  module: string,
+  headers: readonly string[],
+  submodules: ReadonlySet<string> = new Set(),
+): string {
+  const header = (file: string) => `header ${JSON.stringify(file)}`
+  const stem = (file: string) =>
+    file.slice(file.lastIndexOf('/') + 1).replace(/\.[^.]*$/, '')
   return [
     `module ${module} {`,
-    ...headers.map((header) => `  header ${JSON.stringify(header)}`),
+    ...headers.map((file) =>
+      submodules.has(stem(file))
+        ? `  module ${stem(file)} { ${header(file)} export * }`
+        : `  ${header(file)}`,
+    ),
     '  export *',
     '}',
     '',

package/src/swift-objc-standin.ts

@@ -348,7 +348,7 @@ export function iosDeploymentMinimum(version: string | null): number | undefined
 const headerFiles = (dir: string): string[] =>
   fs
     .readdirSync(dir, { recursive: true, encoding: 'utf8' })
-    .filter((file) => file.endsWith('.h'))
+    .filter((file) => file.endsWith('.h') || file.endsWith('.hh'))
     .sort()
 
 /**
@@ -571,11 +571,18 @@ export function objcView(
       recursive: true,
     })
     // the swift overlay owns what the generated -Swift.h header re-imports
-    // under swift_name, so a mixed framework's intake map drops that submodule
+    // under swift_name, so a mixed framework's intake map drops that submodule.
+    // an enum the objective-c headers only forward-declare is completed by that
+    // header, and without it every member naming the enum leaves the import.
     const modulemap = fs.readFileSync(surface.modulemap, 'utf8')
+    const forwardEnum = [...originals.values()].some((text) =>
+      /typedef\s+NS_(?:CLOSED_)?(?:ENUM|OPTIONS)\s*\(\s*\w+\s*,\s*\w+\s*\)\s*;/.test(
+        text,
+      ),
+    )
     fs.writeFileSync(
       path.join(frameworks, `${surface.module}.framework`, 'Modules', 'module.modulemap'),
-      surface.interface
+      surface.interface && !forwardEnum
         ? modulemap.replace(
             new RegExp(`\\n\\s*module\\s+${surface.module}\\.Swift\\s*\\{[^}]*\\}`),
             '',

package/src/swift-packages.ts

@@ -19,6 +19,7 @@ import { cacheDir } from './home-paths'
 import { requireNativeGit } from './native-git'
 import { tryAcquireNumberedLock } from './numbered-lock'
 import { preparedSwiftCheckouts, preparedSwiftPin } from './prepared-xcode-phases'
+import { swiftCTakesReturnAddress } from './swift-compile'
 import {
   isSwiftNativeTranslationUnit,
   swiftImplicitResourcePaths,
@@ -36,6 +37,7 @@ import {
   type SwiftManifestTarget,
   type SwiftPackageManifest,
 } from './swift-package-manifest'
+import { shippedBinaryDiffers } from './swift-shipped-binaries'
 import type { SwiftSourceLinkGraph } from './swiftContract'
 
 // which machine a package target is built for
@@ -114,9 +116,9 @@ export interface SwiftPackageBinary {
   reached: boolean
   /** a source Objective-C target: public headers relative to dir. */
   publicHeaders?: string
-  /** assembly sources, relative to the package, that keep a source target from
-   *  compiling; its public headers stand in for it. */
-  assemblySources?: string[]
+  /** sources, relative to the package, with no wasm32 lowering that keep a
+   *  source target from compiling; its public headers stand in for it. */
+  unloweredSources?: string[]
   /** dependency module public headers, relative to dir. */
   headerDependencies?: { module: string; path: string }[]
   /** xcode modules whose linked package products reach this clang target. */
@@ -159,29 +161,42 @@ export function remoteSwiftCheckouts(root: string): string {
 // assembly requires its own target lowering; objective-c keeps its original bodies.
 const UNSUPPORTED_NATIVE = /\.(s|S)$/
 
-// a clang source target whose sources include assembly cannot lower to wasm,
-// unless upstream declares wasi-conditioned c settings for it: that is the
-// package's own supported portable path (boringssl's guarded assembly with
-// OPENSSL_NO_ASM), which compiles with those flags exactly as swiftpm builds
-// it. without that signal the target keeps the refusal below. when a refused
-// target also ships public headers, those headers stand in for it and every
-// declaration they spell traps by name. this is the assembly rule above,
-// widened only where the target has a header surface to stand in from.
-function assemblySources(
+// a clang source target whose sources include assembly, or take their own
+// return address, cannot lower to wasm, unless upstream declares
+// wasi-conditioned c settings for it: that is the package's own supported
+// portable path (boringssl's guarded assembly with OPENSSL_NO_ASM), which
+// compiles with those flags exactly as swiftpm builds it. without that signal
+// the target keeps the refusal below. when a refused target also ships public
+// headers, those headers stand in for it and every declaration they spell
+// traps by name. this is the assembly rule above, widened only where the
+// target has a header surface to stand in from.
+function unlowerableSources(
+  files: readonly string[],
+  target: SwiftManifestTarget,
+): string[] {
+  if (target.declaresWasiNativeSettings) return []
+  return [
+    ...files.filter((file) => UNSUPPORTED_NATIVE.test(file)),
+    ...files
+      .filter(isSwiftNativeTranslationUnit)
+      .filter((file) => swiftCTakesReturnAddress(fs.readFileSync(file, 'utf8'))),
+  ]
+}
+
+function unloweredSources(
   files: readonly string[],
   target: SwiftManifestTarget,
 ): string[] | null {
   if (target.type !== 'regular') return null
-  if (target.declaresWasiNativeSettings) return null
-  const assembly = files.filter((file) => UNSUPPORTED_NATIVE.test(file))
-  if (assembly.length === 0) return null
   if (!files.some(isSwiftNativeTranslationUnit)) return null
+  const unlowered = unlowerableSources(files, target)
+  if (unlowered.length === 0) return null
   const headers = path.resolve(target.dir, target.publicHeadersPath)
   if (
     !files.some((file) => file.startsWith(`${headers}${path.sep}`) && file.endsWith('.h'))
   )
     return null
-  return assembly
+  return unlowered
 }
 
 const BINARY = 'is a binary framework'
@@ -514,6 +529,8 @@ export function resolveSwiftPackages(options: {
   /** local package directories the workspace or a project references. */
   localDirs: readonly string[]
   provided: ReadonlySet<string> | null
+  /** binary targets whose stand-in is built; one pinning another archive than peach's shipped module compiles through it. */
+  standinTargets?: ReadonlySet<string>
   /** why a binary target has no stand-in, added to its reason. */
   binaryGaps?: ReadonlyMap<string, string>
   /**
@@ -657,9 +674,7 @@ export function resolveSwiftPackages(options: {
           ? swiftTargetFiles(pkg.manifest, target)
           : []
       const gap = options.binaryGaps?.get(name)
-      const assembly = target.declaresWasiNativeSettings
-        ? []
-        : files.filter((file) => UNSUPPORTED_NATIVE.test(file))
+      const unlowerable = unlowerableSources(files, target)
       const placeholder = placeholderPackage(pkg)
       const ownReason =
         target.type === 'binary'
@@ -668,8 +683,8 @@ export function resolveSwiftPackages(options: {
             ? `${name} stands in as a placeholder (${placeholder}), and ${gap}`
             : target.type !== 'regular' && target.type !== 'system'
               ? `${name} is a ${target.type} target`
-              : assembly.length > 0
-                ? `${name} is an assembly target with no wasm32 lowering: ${assembly.map((file) => path.relative(pkg.manifest.dir, file)).join(', ')}${gap ? `; ${gap}` : ''}`
+              : unlowerable.length > 0
+                ? `${name} has native sources with no wasm32 lowering: ${unlowerable.map((file) => path.relative(pkg.manifest.dir, file)).join(', ')}${gap ? `; ${gap}` : ''}`
                 : null
       // every dependency resolves, so a failing one never hides the rest
       // of the closure from the compile or from the report
@@ -778,9 +793,8 @@ export function resolveSwiftPackages(options: {
       )
     )
       return false
-    // an assembly target stands in from its public headers, so a stand-in
-    // peach built for it stays provided instead of compiling its sources
-    if (providedTargets.has(name) && assemblySources(files, target)) return false
+    // a target whose headers stand in for its unlowered sources stays with the stand-in
+    if (unloweredSources(files, target)) return false
     claimed.add(key)
     providedTargets.delete(name)
     for (const dependency of target.dependencies) {
@@ -794,6 +808,17 @@ export function resolveSwiftPackages(options: {
   }
   const claimProduct = (pkg: LoadedPackage, product: string): void => {
     const roots = pkg.manifest.products.get(product)?.targets ?? []
+    for (const root of roots) {
+      const target = pkg.manifest.targets.get(root)
+      if (
+        target?.type === 'binary' &&
+        !options.standinTargets?.has(root) &&
+        shippedBinaryDiffers(root, target.checksum)
+      ) {
+        providedTargets.delete(root)
+        providedProducts.delete(product)
+      }
+    }
     if (roots.map((name) => claimTarget(pkg, name)).some(Boolean))
       providedProducts.delete(product)
   }
@@ -840,7 +865,7 @@ export function resolveSwiftPackages(options: {
           : []
       const objc =
         target.type === 'regular' && files.some((file) => /\.(m|mm)$/.test(file))
-      const assembly = assemblySources(files, target)
+      const unlowered = unloweredSources(files, target)
       const gap = placeholderPackage(pkg)
       const sources = files.filter((file) => file.endsWith('.swift'))
       // swiftpm's release settings, as xcode builds a package for any
@@ -873,7 +898,7 @@ export function resolveSwiftPackages(options: {
             ],
           },
         })
-      else if (target.type === 'binary' || objc || assembly)
+      else if (target.type === 'binary' || objc || unlowered)
         result.binaries.push({
           target: name,
           source: pkg.source,
@@ -889,9 +914,9 @@ export function resolveSwiftPackages(options: {
                   path.join(target.dir, target.publicHeadersPath),
                 ),
               }),
-          ...(assembly
+          ...(unlowered
             ? {
-                assemblySources: assembly.map((file) =>
+                unloweredSources: unlowered.map((file) =>
                   path.relative(pkg.manifest.dir, file),
                 ),
               }