peachsim 0.1.2224 → 0.1.2228

package/src/swift-guest-link.ts

@@ -504,7 +504,7 @@ export function linkGuestImages(
   fs.writeFileSync(irPath, ledger.llvmIR)
   execFileSync(
     clang,
-    ['--target=wasm32-unknown-wasip1', '-c', irPath, '-o', ledgerObject],
+    ['--target=wasm64-unknown-wasip1', '-c', irPath, '-o', ledgerObject],
     { stdio: 'pipe' },
   )
   linkedOwners.set(ledgerObject, options.ledgerDataImage)

package/src/swift-guest-linked-spans.ts

@@ -29,6 +29,9 @@ function number(bytes: Uint8Array, start: number): [number, number] {
   }
 }
 
+// the linked module places segments with i64.const and the lowered one with i32.const.
+const constant = (opcode: number | undefined) => opcode === 0x41 || opcode === 0x42
+
 function signedAddress(bytes: Uint8Array, start: number): [number, number] {
   const [value, end] = number(bytes, start)
   const bits = (end - start) * 7
@@ -84,7 +87,7 @@ function layout(bytes: Uint8Array): WasmLayout {
     }
     const limits = () => {
       const flags = read()
-      if (flags & ~3) throw new Error('unsupported wasm limits')
+      if (flags & ~7) throw new Error('unsupported wasm limits')
       const minimum = read()
       if (flags & 1) read()
       return minimum
@@ -123,7 +126,7 @@ function layout(bytes: Uint8Array): WasmLayout {
     if (read() !== 1 || memoryPages !== undefined)
       throw new Error('unsupported wasm memories')
     const flags = read()
-    if (flags & ~3) throw new Error('unsupported wasm memory limits')
+    if (flags & ~7) throw new Error('unsupported wasm memory limits')
     memoryPages = read()
     if (flags & 1) read()
     if (pos !== memory[1]) throw new Error('invalid wasm memory section')
@@ -160,7 +163,7 @@ function layout(bytes: Uint8Array): WasmLayout {
       if (flags !== 0 && flags !== 2)
         throw new Error(`unsupported wasm element segment ${flags}`)
       if (flags === 2 && read() !== 0) throw new Error('unsupported wasm table index')
-      if (bytes[pos++] !== 0x41) throw new Error('nonconstant wasm table offset')
+      if (!constant(bytes[pos++])) throw new Error('nonconstant wasm table offset')
       let base: number
       ;[base, pos] = signedAddress(bytes, pos)
       if (bytes[pos++] !== 0x0b) throw new Error('invalid wasm table offset')
@@ -191,7 +194,7 @@ function layout(bytes: Uint8Array): WasmLayout {
       if (flags !== 0 && flags !== 2)
         throw new Error(`unsupported wasm data segment ${flags}`)
       if (flags === 2 && read() !== 0) throw new Error('unsupported wasm memory index')
-      if (bytes[pos++] !== 0x41) throw new Error('nonconstant wasm data offset')
+      if (!constant(bytes[pos++])) throw new Error('nonconstant wasm data offset')
       let address: number
       ;[address, pos] = signedAddress(bytes, pos)
       if (bytes[pos++] !== 0x0b) throw new Error('invalid wasm data offset')

package/src/swift-guest-manifest.ts

@@ -90,8 +90,8 @@ export function createGuestImageManifest(
   image: GuestManifestImage,
 ): SwiftGuestImageManifest {
   const target = {
-    triple: 'wasm32-unknown-wasip1',
-    pointerWidth: 32,
+    triple: 'wasm64-unknown-wasip1',
+    pointerWidth: 64,
     byteOrder: 'little',
     cpuType: -1,
     cpuSubtype: 0,

package/src/swift-guest-source-inputs.ts

@@ -1,6 +1,6 @@
 import { execFileSync } from 'node:child_process'
 import { createHash } from 'node:crypto'
-import { readFileSync, realpathSync, writeFileSync } from 'node:fs'
+import { mkdirSync, readFileSync, realpathSync, writeFileSync } from 'node:fs'
 import path from 'node:path'
 import { libraryArchiveTarget, type GuestSourceArtifact } from './swift-guest-source-plan'
 import { frameworkRuntimeProductId } from './swift-runtime-products'
@@ -42,6 +42,10 @@ export function clangIrLinkOptions(ir: string): string[] {
   return result
 }
 
+// the C compiler a package build runs: the toolchain clang, named for the
+// target whose <target>.build directory receives the object
+export const CLANG_TARGET_MODULE_WRAPPER = '.peach-clang'
+
 /** Replay only selected source-owned Clang commands to retain their IR link options. */
 export function sourceGuestClangLinkOptions(options: {
   buildDirectory: string
@@ -97,15 +101,22 @@ export function sourceGuestClangLinkOptions(options: {
         throw new Error(`unsupported source object producer ${file}`)
       continue
     }
+    const compiler = command.args[0] ? realpathSync(command.args[0]) : ''
     if (
       command.tool !== 'clang' ||
-      !command.args.length ||
-      realpathSync(command.args[0]!) !==
-        realpathSync(path.join(options.toolchainBin, 'clang'))
+      (compiler !== realpathSync(path.join(options.toolchainBin, 'clang')) &&
+        compiler !==
+          realpathSync(path.join(options.buildDirectory, CLANG_TARGET_MODULE_WRAPPER)))
     )
       throw new Error(`unsupported source object producer ${file}`)
     const args = command.args.slice(1).filter((arg) => arg !== '-c')
-    const output = path.join(options.directory, `clang-link-${index}.ll`)
+    // the replay keeps the object's <target>.build directory name
+    const outputDirectory = path.join(
+      options.directory,
+      path.basename(path.dirname(file)),
+    )
+    mkdirSync(outputDirectory, { recursive: true })
+    const output = path.join(outputDirectory, `clang-link-${index}.ll`)
     for (const flag of ['-o', '-MF']) {
       const index = args.lastIndexOf(flag)
       if (index < 0 || index + 1 >= args.length)

package/src/swift-host.ts

@@ -1171,16 +1171,21 @@ async function buildXcodeLayout(root: string): Promise<XcodeLayout | null> {
         )
         .map((feature) => feature.name),
       // the flat build gives every module one package; swiftpm names each
-      // module for its own package, which `@retroactive` and `package` read
-      swiftFlags: ['-package-name', swiftPackageIdentity(target.packageDir)].concat(
-        target.packageSwiftFlags
+      // module for its own package, which `@retroactive` and `package` read.
+      // xcode and swiftpm build a debug package testable, so sources may
+      // `@testable import` it
+      swiftFlags: [
+        '-package-name',
+        swiftPackageIdentity(target.packageDir),
+        ...(packageConfiguration === 'debug' ? ['-enable-testing'] : []),
+        ...target.packageSwiftFlags
           .filter(
             (setting) =>
               setting.configuration === null ||
               setting.configuration === packageConfiguration,
           )
           .flatMap((setting) => setting.flags),
-      ),
+      ],
       linkedLibraries: target.packageLibraries
         .filter(
           (library) =>
@@ -1666,7 +1671,7 @@ function xcodeManifest(layout: XcodeLayout): string {
   return [
     '// swift-tools-version: 6.2',
     'import PackageDescription',
-    `let package = Package(name: "app", ${layout.app.iosDeploymentTarget ? `platforms: [.iOS(${JSON.stringify(layout.app.iosDeploymentTarget)})], ` : ''}dependencies: [${[...nativePaths].map(([name, directory]) => `.package(name: ${JSON.stringify(name)}, path: ${JSON.stringify(directory)})`).join(', ')}], targets: [`,
+    `let package = Package(name: "app", platforms: [.iOS(${JSON.stringify(layout.app.iosDeploymentTarget)})], dependencies: [${[...nativePaths].map(([name, directory]) => `.package(name: ${JSON.stringify(name)}, path: ${JSON.stringify(directory)})`).join(', ')}], targets: [`,
     `  .executableTarget(name: "${layout.app.moduleName}", dependencies: [${[...appProducts, ...layout.targets.map((target) => JSON.stringify(target.name)), ...sdkProducts].join(', ')}], path: "${XCODE_APP_DIR}", ${appSettings}),`,
     ...layout.targets.map((target) =>
       target.systemLibrary

package/src/swift-icu.ts

@@ -141,7 +141,7 @@ async function load(toolchainBin: string, sdk: string): Promise<Buffer> {
       ...swiftSdkOptions(),
       '--show-configuration',
       sdk,
-      'wasm32-unknown-wasip1',
+      'wasm64-unknown-wasip1',
     ],
     { env: swiftEnvironment() },
   )

package/src/swift-objc-compile.ts

@@ -5,7 +5,7 @@ import path from 'node:path'
 import { mapLimit } from '../../../src/helpers/mapLimit.ts'
 import { cacheDir } from './home-paths'
 import { isRecord } from './is-record'
-import { DOUBLE_CONVERSION_WASM32_BACKPORT } from './nitro-dependencies'
+import { DOUBLE_CONVERSION_WASM64_BACKPORT } from './nitro-dependencies'
 import {
   swiftBuildJobs,
   swiftSdkPaths,
@@ -320,7 +320,7 @@ function* xcodeObjCInputSteps(
     )
     // the pod's own double-conversion utils.h takes the approved backport by
     // its exact original bytes; the file on disk stays unchanged.
-    const backport = DOUBLE_CONVERSION_WASM32_BACKPORT
+    const backport = DOUBLE_CONVERSION_WASM64_BACKPORT
     if (
       path.basename(file) !== 'utils.h' ||
       createHash('sha256').update(bytes).digest('hex') !== backport.originalSha256
@@ -713,6 +713,11 @@ function* xcodeObjCInputSteps(
       }
       for (const reference of references) {
         if (++workCount % 64 === 0) yield
+        if (
+          path.isAbsolute(reference.name) &&
+          /\.sdk\/(?:System|Developer)\/Library\/Frameworks\//.test(reference.name)
+        )
+          continue
         // only the first quoted lookup depends on the including file. after a
         // local miss, every includer shares the target's ordered search paths.
         if (reference.quoted && !reference.next) {
@@ -1120,7 +1125,7 @@ export function prepareXcodeSwiftProducts(
           ? ['-merge-modules', '-emit-module']
           : ['-emit-object', '-whole-module-optimization', '-parse-as-library']),
         '-target',
-        'wasm32-unknown-wasip1',
+        'wasm64-unknown-wasip1',
         '-sdk',
         sdk.sysroot,
         '-resource-dir',
@@ -1547,7 +1552,7 @@ export async function prepareXcodeObjCImplementations(
           (!cxx ||
             flags.lastIndexOf('-fno-cxx-modules') <= flags.lastIndexOf('-fcxx-modules'))
         const args = [
-          '--target=wasm32-unknown-wasip1',
+          '--target=wasm64-unknown-wasip1',
           `--sysroot=${sdk.sysroot}`,
           '-fwasm-exceptions',
           '-fexceptions',

package/src/swift-objc-standin.ts

@@ -303,14 +303,11 @@ export function objcSdkIntakeFlags(
   return [
     ...swiftObjCPlatformFlags(toolchainBin, minimum),
     // AvailabilityInternal.h derives these through __is_target_os(ios), which
-    // is false for wasm32. the maximum is the sdk the headers come from, as
+    // is false for wasm64. the maximum is the sdk the headers come from, as
     // xcode defines it, so `#if __IPHONE_OS_VERSION_MAX_ALLOWED >= __IPHONE_26_0`
     // sources see the members the sdk declares instead of a 17.0 default.
     `-D__IPHONE_OS_VERSION_MIN_REQUIRED=${minimum}`,
     `-D__IPHONE_OS_VERSION_MAX_ALLOWED=__IPHONE_${NATIVE_GRAPH_SDK_VERSION.replace('.', '_')}`,
-    // apple's build setting for a 32-bit target to keep NSInteger and
-    // NSUInteger long, the nominal types they have on arm64.
-    '-DNS_BUILD_32_LIKE_64=1',
     // the installed libc's default feature set otherwise defines
     // _XOPEN_SOURCE, which darwin's sys/cdefs.h turns into a strict posix
     // level; iOS compiles at darwin's full level with neither defined.

package/src/swift-package-manifest.ts

@@ -513,7 +513,11 @@ export function swiftPackageManifest(
           ? '5'
           : (string(record(raw.toolsVersion)._version) ?? 'unknown')
     let mainActorIsolation = false
-    const defines: SwiftManifestSetting[] = []
+    // swiftpm defines each enabled trait as a condition in every swift target
+    const defines: SwiftManifestSetting[] = [...traits].map((name) => ({
+      name,
+      configuration: null,
+    }))
     const libraries: SwiftManifestSetting[] = []
     const frameworks: SwiftManifestSetting[] = []
     const experimentalFeatures: SwiftManifestSetting[] = []

package/src/swift-packages.ts

@@ -116,7 +116,7 @@ export interface SwiftPackageBinary {
   reached: boolean
   /** a source Objective-C target: public headers relative to dir. */
   publicHeaders?: string
-  /** sources, relative to the package, with no wasm32 lowering that keep a
+  /** sources, relative to the package, with no wasm lowering that keep a
    *  source target from compiling; its public headers stand in for it. */
   unloweredSources?: string[]
   /** dependency module public headers, relative to dir. */
@@ -693,7 +693,7 @@ export function resolveSwiftPackages(options: {
             : target.type !== 'regular' && target.type !== 'system'
               ? `${name} is a ${target.type} target`
               : unlowerable.length > 0
-                ? `${name} has native sources with no wasm32 lowering: ${unlowerable.map((file) => path.relative(pkg.manifest.dir, file)).join(', ')}${gap ? `; ${gap}` : ''}`
+                ? `${name} has native sources with no wasm 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

package/src/swift-shared-sdk.ts

@@ -277,7 +277,7 @@ export function swiftSharedSdkViewOptions(
       ...swiftSdkOptions(),
       '--show-configuration',
       sdk,
-      'wasm32-unknown-wasip1',
+      'wasm64-unknown-wasip1',
     ],
     { encoding: 'utf8', env: swiftEnvironment(), stdio: ['ignore', 'pipe', 'pipe'] },
   )

package/src/swift-standin-emit.ts

@@ -1529,6 +1529,7 @@ export function emitSwiftStandin(
                   ].includes(name)
                 ) &&
                 !(name === nsObjectProtocol && externalRoot(id) === nsObject) &&
+                !options.unconformed?.get(path)?.has(name.split(/::|\./).pop()!) &&
                 !options.unconformed?.get(path)?.has(name),
             ),
           ].filter((name, at, all) => all.indexOf(name) === at)
@@ -1703,8 +1704,7 @@ export function emitSwiftStandin(
                 synthesizedEquality(member, list))
             )
               continue
-            const header = values.get(member.identifier.precise)
-            const value = header === undefined ? undefined : atWidth(header, raw)
+            const value = values.get(member.identifier.precise)
             if (value !== undefined && member.kind.identifier === 'swift.type.property') {
               emit(
                 `${inner}public static let ${tick(leaf(member))} = ${shape.name}(rawValue: ${value})`,
@@ -1763,8 +1763,7 @@ export function emitSwiftStandin(
           )
           const seenValues = new Map<string, string>()
           for (const member of cases) {
-            const header = values.get(member.identifier.precise)
-            const value = header === undefined ? undefined : atWidth(header, raw)
+            const value = values.get(member.identifier.precise)
             // objective-c aliases a value under a second name; swift spells
             // the alias as a static member of the first case.
             if (value !== undefined && seenValues.has(value)) {
@@ -1976,18 +1975,6 @@ export function emitSwiftStandin(
     }
     return null
   }
-  // header values are clang's for 64-bit iOS. NSUIntegerMax, NSIntegerMax
-  // and NSIntegerMin are the platform-width type's own extremes, which on
-  // wasm32 are the 32-bit ones.
-  const atWidth = (value: string, raw: string | null) =>
-    (raw === 'UInt' || raw === 'Swift.UInt') && value === '18446744073709551615'
-      ? '4294967295'
-      : (raw === 'Int' || raw === 'Swift.Int') && value === '9223372036854775807'
-        ? '2147483647'
-        : (raw === 'Int' || raw === 'Swift.Int') && value === '-9223372036854775808'
-          ? '-2147483648'
-          : value
-
   const emitGlobal = scoped((symbol: GraphSymbol) => {
     const path = pathOf(symbol)
     const kind = symbol.kind.identifier

package/src/swift-standins.ts

@@ -13,12 +13,14 @@ import { execFileSync, spawn, spawnSync } from 'node:child_process'
 import { createHash } from 'node:crypto'
 import fs from 'node:fs'
 import path from 'node:path'
+import { PEACH_FORKED_SCRIPT_ENV } from './forked-script-contract'
 import { cacheDir as peachCacheDir } from './home-paths'
 import { isRecord } from './is-record'
 import { fetchNativeEntry, nativeEntryKey } from './native-prebuilt'
 import { nativeSliceEntry, NATIVE_SLICE_RECIPES } from './native-slices'
 import { nativeStaticLibrary, nativeStaticLibraryRecipe } from './native-static-libraries'
 import { nativeSwiftSlice } from './native-swift-slices'
+import { tryAcquireNumberedLock } from './numbered-lock'
 import { outputLockStdio } from './output-lock-stdio'
 import {
   FOUNDATION_IMPLICIT_MODULES,
@@ -35,6 +37,7 @@ import {
   swiftSdkPaths,
 } from './swift-compile'
 import { emitCxxStandin } from './swift-cxx-standin'
+import { swiftModuleToolchain } from './swift-distribution'
 import {
   iosSdkId,
   WASI_EMULATION,
@@ -74,7 +77,7 @@ import {
 } from './swift-toolchain'
 import { simulatorNativeLibrary } from './swift-xcframework'
 
-const TRIPLE = 'wasm32-unknown-wasip1'
+const TRIPLE = 'wasm64-unknown-wasip1'
 // every stand-in artifact and temporary workspace belongs to peach.
 const cacheDir = path.join(peachCacheDir(), 'swift-standins')
 export interface SwiftStandin {
@@ -1700,6 +1703,14 @@ function graphStandin(
         unconformed.set(owner, new Set([...(unconformed.get(owner) ?? []), conformance]))
         continue
       }
+      // a superclass another module declares already brings this conformance
+      const redundant = /^redundant conformance of '\w+' to protocol '(\w+)'$/.exec(
+        match[3]!,
+      )?.[1]
+      if (owner && redundant) {
+        unconformed.set(owner, new Set([...(unconformed.get(owner) ?? []), redundant]))
+        continue
+      }
       if (owner && swiftPaths.has(owner))
         throw new Error(
           `Swift declaration ${module}.${owner} does not typecheck: ${match[3]}`,
@@ -2175,7 +2186,7 @@ async function cxxStandin(
   }
 }
 
-export const RUST_TARGET = 'wasm32-wasip1'
+export const RUST_TARGET = 'wasm64-wasip1'
 // directories a crate search never enters: build output and installed deps
 const UNSEARCHED = new Set([
   'node_modules',
@@ -2233,9 +2244,7 @@ export function crateFor(root: string, name: string): string | null {
  */
 export const RUST_TOOLCHAIN = '1.94.0'
 
-// the directories a crate's build reads: the workspace that owns its Cargo.lock
-// plus every path dependency that lies outside it.
-function crateSourceRoots(manifest: string): string[] {
+function crateWorkspace(manifest: string): string {
   let workspace = path.dirname(manifest)
   while (!fs.existsSync(path.join(workspace, 'Cargo.lock'))) {
     const parent = path.dirname(workspace)
@@ -2243,7 +2252,15 @@ function crateSourceRoots(manifest: string): string[] {
       throw new Error(`${manifest} has no Cargo.lock; the build runs --locked`)
     workspace = parent
   }
-  const roots = [workspace]
+  return workspace
+}
+
+function crateSourceRoots(manifest: string, searchRoot: string): string[] {
+  const workspace = crateWorkspace(manifest)
+  const root = path.resolve(searchRoot)
+  const roots = path.relative(root, workspace).startsWith('..')
+    ? [root, workspace]
+    : [root]
   const inside = (dir: string) =>
     roots.some((root) => !path.relative(root, dir).startsWith('..'))
   const manifests = (dir: string): string[] =>
@@ -2269,7 +2286,7 @@ function crateSourceRoots(manifest: string): string[] {
 
 // a digest of every file under the roots a crate builds from, build output and
 // installed dependencies aside.
-function crateSourceDigest(manifest: string): string {
+function crateSourceDigest(manifest: string, searchRoot: string): string {
   const hash = createHash('sha256')
   const walk = (dir: string, root: string) => {
     for (const entry of fs
@@ -2285,7 +2302,7 @@ function crateSourceDigest(manifest: string): string {
       }
     }
   }
-  for (const root of crateSourceRoots(manifest)) {
+  for (const root of crateSourceRoots(manifest, searchRoot)) {
     hash.update(`root\0`)
     walk(root, root)
   }
@@ -2293,14 +2310,20 @@ function crateSourceDigest(manifest: string): string {
 }
 
 /** the registry entry a crate's static library lives under. */
-export function rustCrateEntry(manifest: string, library: string) {
+export function rustCrateEntry(
+  manifest: string,
+  library: string,
+  moduleRoot: string,
+  searchRoot: string,
+) {
   const inputs = {
     crate: library,
-    source: crateSourceDigest(manifest),
+    source: crateSourceDigest(manifest, searchRoot),
     target: RUST_TARGET,
-    build: 'release locked',
+    build: 'release locked panic=abort',
+    compiler: swiftModuleToolchain(moduleRoot).release,
+    sdk: swiftModuleSdk(moduleRoot).wasmSdkChecksum,
     rust: RUST_TOOLCHAIN,
-    rustflags: process.env.RUSTFLAGS ?? '',
   }
   return { name: library, inputs, key: nativeEntryKey(inputs) }
 }
@@ -2308,7 +2331,7 @@ export function rustCrateEntry(manifest: string, library: string) {
 /**
  * the WebAssembly static library a c stand-in links in place of its traps,
  * or null when it has none. a build the developer supplies in the
- * xcframework (`wasm32-wasip1/lib<name>.a`) wins; otherwise the crate under
+ * xcframework (`wasm64-wasip1/lib<name>.a`) wins; otherwise the crate under
  * `searchRoot` that builds the slice's library comes from the registry when
  * it holds that crate's source and toolchain, else compiles with the
  * developer's cargo with the registry's pinned toolchain. peach ships no rust compiler.
@@ -2353,10 +2376,11 @@ export function standinLibrary(
   }
   const manifest = crateFor(searchRoot, path.basename(library, '.a').replace(/^lib/, ''))
   if (!manifest) return null
-  const entry = rustCrateEntry(manifest, library)
+  if (!toolchain) throw new Error('Rust native libraries need the Swift SDK')
+  const entry = rustCrateEntry(manifest, library, toolchain.moduleRoot, searchRoot)
   const prebuilt = fetchNativeEntry('rust', entry.name, entry.key)
   if (prebuilt) return path.join(prebuilt, library)
-  return buildRustCrate(manifest, library, searchRoot)
+  return buildRustCrate(manifest, library, searchRoot, toolchain.moduleRoot, entry)
 }
 
 /** compiles a crate with the same rust standard library as registry archives. */
@@ -2364,87 +2388,95 @@ export function buildRustCrate(
   manifest: string,
   library: string,
   searchRoot: string,
+  moduleRoot: string,
+  entry = rustCrateEntry(manifest, library, moduleRoot, searchRoot),
 ): string {
-  const crate = path.relative(searchRoot, path.dirname(manifest))
-  // rustup installs the pinned toolchain and its wasm target, and is a no-op
-  // when both are present. a cargo without rustup has to carry them itself.
-  const rustup = spawnSync(
-    // runner-toolchain-platform: darwin
-    'rustup',
-    [
-      'toolchain',
-      'install',
-      RUST_TOOLCHAIN,
-      '--profile',
-      'minimal',
-      '--target',
-      RUST_TARGET,
-      '--no-self-update',
-    ],
-    { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] },
-  )
-  if (!rustup.error && rustup.status !== 0)
-    throw new Error(
-      `rustup could not install Rust ${RUST_TOOLCHAIN} with ${RUST_TARGET} for ${crate}: ${failure(rustup)}`,
+  const compiler = swiftModuleToolchain(moduleRoot)
+  const sdk = swiftModuleSdk(moduleRoot)
+  const sdkRoot = path.dirname(swiftSdkPaths(moduleRoot, compiler.toolchainBin).sysroot)
+  const runner = path.join(sdkRoot, 'rust/scripts/build-rust-wasm64.mjs')
+  const work = path.join(cacheDir, 'rust', entry.key)
+  const release = tryAcquireNumberedLock(work + '.lock', manifest)
+  if (!release) throw new Error('Rust native build already running: ' + manifest)
+  try {
+    const roots = crateSourceRoots(manifest, searchRoot)
+    let common = roots[0]!
+    while (
+      roots.some((root) => {
+        const relative = path.relative(common, root)
+        return relative === '..' || relative.startsWith('..' + path.sep)
+      })
     )
-  const result = spawnSync(
-    // runner-toolchain-platform: darwin
-    'cargo',
-    [
-      'build',
-      '--release',
-      '--locked',
-      '--target',
-      RUST_TARGET,
-      '--message-format=json-render-diagnostics',
-      '--manifest-path',
-      manifest,
-      '--target-dir',
-      path.join(cacheDir, 'cargo', key(manifest)),
-    ],
-    {
-      encoding: 'utf8',
-      env: {
-        ...process.env,
-        RUSTUP_TOOLCHAIN: RUST_TOOLCHAIN,
-        CARGO_HOME: path.join(cacheDir, 'cargo-home'),
-      },
-      maxBuffer: 256 * 1024 * 1024,
-      stdio: ['ignore', 'pipe', 'pipe'],
-    },
-  )
-  if (result.error)
-    throw new Error(
-      `${crate} is a rust crate and cargo is not installed; install rust (https://rustup.rs), then run again`,
+      common = path.dirname(common)
+    const source = path.join(work, 'source')
+    fs.rmSync(source, { recursive: true, force: true })
+    for (const root of roots)
+      fs.cpSync(root, path.join(source, path.relative(common, root)), {
+        recursive: true,
+        filter: (file) => !UNSEARCHED.has(path.basename(file)),
+      })
+    const privateManifest = path.join(source, path.relative(common, manifest))
+    const lock = path.join(
+      source,
+      path.relative(common, crateWorkspace(manifest)),
+      'Cargo.lock',
     )
-  if (result.status !== 0) {
-    if (
-      /target may not be installed|can't find crate for `(core|std)`/.test(result.stderr)
+    const result = spawnSync(
+      process.execPath,
+      [
+        runner,
+        '--bin',
+        compiler.toolchainBin,
+        '--sdk',
+        sdkRoot,
+        '--sdk-checksum',
+        sdk.wasmSdkChecksum,
+        '--work',
+        path.join(work, 'toolchain'),
+        '--manifest',
+        privateManifest,
+        '--lock',
+        lock,
+        '--panic',
+        'abort',
+        '--cargo-arg=--locked',
+        '--cargo-arg=--jobs',
+        '--cargo-arg=' + (process.env.TM_EXEC_CPU_CORES ?? '1'),
+      ],
+      {
+        encoding: 'utf8',
+        env: { ...swiftEnvironment(), [PEACH_FORKED_SCRIPT_ENV]: '1' },
+        maxBuffer: 256 * 1024 * 1024,
+        stdio: ['ignore', 'pipe', 'pipe'],
+      },
     )
+    if (result.error) throw result.error
+    if (result.status !== 0)
       throw new Error(
-        `${crate} builds for ${RUST_TARGET}, which Rust ${RUST_TOOLCHAIN} lacks; run \`rustup target add --toolchain ${RUST_TOOLCHAIN} ${RUST_TARGET}\`, then run again`,
+        `Rust wasm64 could not build ${path.relative(searchRoot, manifest)}: ${failure(result)}`,
       )
+    for (const line of result.stdout.split('\n')) {
+      if (!line.startsWith('{')) continue
+      const message: unknown = JSON.parse(line)
+      if (
+        !message ||
+        typeof message !== 'object' ||
+        !('filenames' in message) ||
+        !Array.isArray(message.filenames)
+      )
+        continue
+      const archive = message.filenames.find(
+        (file): file is string =>
+          typeof file === 'string' && path.basename(file) === library,
+      )
+      if (archive) return archive
+    }
     throw new Error(
-      `cargo could not build ${crate} for ${RUST_TARGET}: ${failure(result)}`,
-    )
-  }
-  for (const line of result.stdout.split('\n')) {
-    if (!line.startsWith('{')) continue
-    const message: unknown = JSON.parse(line)
-    if (
-      !message ||
-      typeof message !== 'object' ||
-      !('filenames' in message) ||
-      !Array.isArray(message.filenames)
+      `cargo built ${manifest} for ${RUST_TARGET} but reported no ${library}`,
     )
-      continue
-    const archive = message.filenames.find(
-      (file): file is string =>
-        typeof file === 'string' && path.basename(file) === library,
-    )
-    if (archive) return archive
+  } finally {
+    release()
   }
-  throw new Error(`cargo built ${crate} for ${RUST_TARGET} but reported no ${library}`)
 }
 
 // source preflight admits the complete closure once, including ignored local