peachsim 0.1.1640 → 0.1.1644

package/src/swift-compile.ts

@@ -1,4 +1,9 @@
-import { spawn, execFileSync, type ExecFileOptions } from 'node:child_process'
+import {
+  spawn,
+  execFileSync,
+  type ExecFileOptions,
+  type SpawnOptions,
+} from 'node:child_process'
 import { createHash } from 'node:crypto'
 import {
   cpSync,
@@ -33,6 +38,7 @@ import {
   swiftTargetModuleName,
   type SwiftPackageTarget,
 } from './swift-package'
+import { withSwiftRootLock, type SwiftRootLease } from './swift-root-lock'
 import { swiftEnvironment, swiftSdkOptions, type SwiftWasmSdk } from './swift-toolchain'
 import { isSwiftResourceBundles } from './swiftContract'
 import type { SwiftImageUpload } from './swift-submit'
@@ -42,24 +48,29 @@ export { swiftIcuAsset, type SwiftIcuAsset }
 
 // compiler drivers own descendants such as admission and swiftpm workers.
 // cancellation waits for their pipes to close before releasing the build root.
+// a `lease` records the group under the root's lock, so the root stays held
+// while the compiler lives even if this process does not.
 // `stream` echoes the output as it arrives: all of it, or only matching lines.
 // a successful run then echoes the rest minus lines matching `quiet`, its
 // warnings; a failed run's output goes to the caller's one diagnostic.
 async function runCompiler(
   command: string,
   args: string[],
-  options: ExecFileOptions & { signal?: AbortSignal },
+  options: ExecFileOptions & { signal?: AbortSignal; lease?: SwiftRootLease },
   stream: boolean | RegExp = false,
   quiet?: RegExp,
 ): Promise<void> {
   const { signal } = options
   signal?.throwIfAborted()
-  const child = spawn(command, args, {
+  const launch = {
     cwd: options.cwd,
     env: swiftEnvironment(options.env),
     detached: true,
-    stdio: ['ignore', 'pipe', 'pipe'],
-  })
+    stdio: ['ignore', 'pipe', 'pipe'] as ['ignore', 'pipe', 'pipe'],
+  } satisfies SpawnOptions
+  const child = options.lease
+    ? options.lease.spawn(command, args, launch)
+    : spawn(command, args, launch)
   let stopping: Promise<void> | undefined
   try {
     await new Promise<void>((resolve, reject) => {
@@ -178,6 +189,8 @@ export interface SwiftCompileOptions {
   toolchainBin: string
   timeoutMs?: number
   signal?: AbortSignal
+  /** called as the compile reaches each stage, in addition to the stderr line. */
+  onStage?: (stage: string) => void
 }
 
 export interface SwiftCompileArtifact {
@@ -948,9 +961,10 @@ export function emitSwiftPackageManifest(args: {
     // compiled: whole, and ahead of the sdk libraries, so PeachICU's
     // reservation keeps icu's data member out. merged into one relocatable
     // object (wasm-ld -r) or linked from an archive, a protocol conformance
-    // goes unfound at runtime or icu links twice (RAN, the Expo fixture). the
-    // libraries the objects autolink follow, since the driver reads autolink
-    // entries only from objects it compiled.
+    // goes unfound at runtime or icu links twice (RAN, the Expo fixture).
+    // clang loads configuration inputs before command-line libraries. forward
+    // the file opaquely so swift neither expands it nor scans every framework
+    // object for autolinks; distribution.link supplies those libraries.
     const imports = distribution
       ? `, "-I", ${JSON.stringify(path.join(moduleRoot, 'modules'))}`
       : ''
@@ -994,7 +1008,7 @@ export function emitSwiftPackageManifest(args: {
     ].join(', ')
     const library =
       distribution && distributionLink
-        ? ['-Xlinker', `@${distributionLink.path}`, ...distribution.link]
+        ? ['-Xclang-linker', `--config=${distributionLink.path}`, ...distribution.link]
             .map((flag) => `, ${JSON.stringify(flag)}`)
             .join('')
         : ''
@@ -6149,8 +6163,10 @@ export function compileSwiftProjectUnit(
   }
   const hash = swiftArtifactHash(input, options.release, moduleRoot)
   const sharedRoot = path.join(rnxHomeDir(), 'cache', 'swift-projects', hash)
-  const report = (message: string) =>
+  const report = (message: string) => {
     console.error(`[swift-project ${hash.slice(0, 16)}] ${message}`)
+    options.onStage?.(message)
+  }
   report('checking verified artifacts')
   return serialize(
     root,
@@ -6232,88 +6248,85 @@ export function compileSwiftProjectUnit(
           rmSync(requestRoot, { recursive: true, force: true })
         }
       }
-      writeSwiftProject(layout, input, moduleRoot)
-      const swift = path.join(options.toolchainBin, 'swift')
-      if (!existsSync(swift)) {
-        throw new Error(
-          `swift-compile: no swift.org toolchain at ${options.toolchainBin}; install ${options.release} and its matching wasm sdk`,
-        )
-      }
-      report('preparing compiler plugins')
-      const macroPlugins = await ensureMacroPlugins(
-        moduleRoot,
-        options.toolchainBin,
-        options.release,
-        options.signal,
-      )
-      // 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
-      const icu = swiftIcuAsset(options.toolchainBin, sdk)
-      const buildArgs = [
-        'build',
-        ...swiftPackageCacheOptions(),
-        '--build-system',
-        'native',
-        '-j',
-        BUILD_JOBS,
-        '--package-path',
+      // the root's sources, manifest and executable are shared by every process
+      // using it, so one process writes, builds and reads them at a time.
+      return withSwiftRootLock(
         root,
-        ...swiftSdkOptions(),
-        '--swift-sdk',
-        sdk,
-        '-c',
-        'release',
-        '-Xswiftc',
-        '-Osize',
-        '-Xswiftc',
-        '-num-threads',
-        '-Xswiftc',
-        BUILD_JOBS,
-        ...macroPlugins.flatMap((plugin) => [
-          '-Xswiftc',
-          '-load-plugin-library',
-          '-Xswiftc',
-          plugin,
-        ]),
-      ]
-      const buildOptions = {
-        env: {
-          ...process.env,
-          // shipped host plugins resolve against the selected compiler's runtime.
-          ...(process.platform === 'linux'
-            ? {
-                LD_LIBRARY_PATH: [
-                  path.resolve(options.toolchainBin, '../lib/swift/linux'),
-                  path.resolve(options.toolchainBin, '../lib/swift/host'),
-                  process.env.LD_LIBRARY_PATH,
-                ]
-                  .filter(Boolean)
-                  .join(':'),
-              }
-            : {}),
-        },
-        maxBuffer: 64 * 1024 * 1024,
-        timeout: options.timeoutMs,
-        signal: options.signal,
-      }
-      report('compiling and linking Swift modules')
-      try {
-        await runCompiler(swift, buildArgs, buildOptions, SWIFTPM_PROGRESS, SWIFTPM_NOISE)
-      } catch (error) {
-        const output = outputOf(error)
-        const moduleCache = path.join(
-          root,
-          '.build',
-          WASM_TRIPLE,
-          'release',
-          'ModuleCache',
-        )
-        if (
-          output.includes('was compiled with module cache path') &&
-          existsSync(moduleCache)
-        ) {
-          rmSync(moduleCache, { recursive: true, force: true })
+        async (lease) => {
+          // a process that held the root while this one waited may have built
+          // this exact address.
+          const built = readCompiledArtifact(path.join(sharedRoot, 'artifact'), hash)
+          if (built) {
+            report('reusing verified disk artifact')
+            return retain(root, built)
+          }
+          writeSwiftProject(layout, input, moduleRoot)
+          const swift = path.join(options.toolchainBin, 'swift')
+          if (!existsSync(swift)) {
+            throw new Error(
+              `swift-compile: no swift.org toolchain at ${options.toolchainBin}; install ${options.release} and its matching wasm sdk`,
+            )
+          }
+          report('preparing compiler plugins')
+          const macroPlugins = await ensureMacroPlugins(
+            moduleRoot,
+            options.toolchainBin,
+            options.release,
+            options.signal,
+          )
+          // 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
+          const icu = swiftIcuAsset(options.toolchainBin, sdk)
+          const buildArgs = [
+            'build',
+            ...swiftPackageCacheOptions(),
+            '--build-system',
+            'native',
+            '-j',
+            BUILD_JOBS,
+            '--package-path',
+            root,
+            ...swiftSdkOptions(),
+            '--swift-sdk',
+            sdk,
+            '-c',
+            'release',
+            '-Xswiftc',
+            '-Osize',
+            '-Xswiftc',
+            '-num-threads',
+            '-Xswiftc',
+            BUILD_JOBS,
+            ...macroPlugins.flatMap((plugin) => [
+              '-Xswiftc',
+              '-load-plugin-library',
+              '-Xswiftc',
+              plugin,
+            ]),
+          ]
+          const buildOptions = {
+            env: {
+              ...process.env,
+              // shipped host plugins resolve against the selected compiler's runtime.
+              ...(process.platform === 'linux'
+                ? {
+                    LD_LIBRARY_PATH: [
+                      path.resolve(options.toolchainBin, '../lib/swift/linux'),
+                      path.resolve(options.toolchainBin, '../lib/swift/host'),
+                      process.env.LD_LIBRARY_PATH,
+                    ]
+                      .filter(Boolean)
+                      .join(':'),
+                  }
+                : {}),
+            },
+            maxBuffer: 64 * 1024 * 1024,
+            timeout: options.timeoutMs,
+            signal: options.signal,
+            lease,
+          }
+          report('compiling and linking Swift modules')
           try {
             await runCompiler(
               swift,
@@ -6322,29 +6335,54 @@ export function compileSwiftProjectUnit(
               SWIFTPM_PROGRESS,
               SWIFTPM_NOISE,
             )
-          } catch (retryError) {
-            throw new Error(
-              projectDiagnostic(outputOf(retryError), layout, input.files),
-              {
-                cause: retryError,
-              },
+          } catch (error) {
+            const output = outputOf(error)
+            const moduleCache = path.join(
+              root,
+              '.build',
+              WASM_TRIPLE,
+              'release',
+              'ModuleCache',
             )
+            if (
+              output.includes('was compiled with module cache path') &&
+              existsSync(moduleCache)
+            ) {
+              rmSync(moduleCache, { recursive: true, force: true })
+              try {
+                await runCompiler(
+                  swift,
+                  buildArgs,
+                  buildOptions,
+                  SWIFTPM_PROGRESS,
+                  SWIFTPM_NOISE,
+                )
+              } catch (retryError) {
+                throw new Error(
+                  projectDiagnostic(outputOf(retryError), layout, input.files),
+                  {
+                    cause: retryError,
+                  },
+                )
+              }
+            } else {
+              throw new Error(projectDiagnostic(output, layout, input.files), {
+                cause: error,
+              })
+            }
           }
-        } else {
-          throw new Error(projectDiagnostic(output, layout, input.files), {
-            cause: error,
-          })
-        }
-      }
-      const artifact = {
-        hash,
-        bytes: readFileSync(builtArtifact(layout)),
-        icu: await icu,
-      }
-      saveCompiledArtifact(root, artifact)
-      saveCompiledArtifact(sharedRoot, artifact)
-      report('compiled artifact verified')
-      return retain(root, artifact)
+          const artifact = {
+            hash,
+            bytes: readFileSync(builtArtifact(layout)),
+            icu: await icu,
+          }
+          saveCompiledArtifact(root, artifact)
+          saveCompiledArtifact(sharedRoot, artifact)
+          report('compiled artifact verified')
+          return retain(root, artifact)
+        },
+        options.signal,
+      )
     },
     options.signal,
   )

package/src/swift-compiler-digest.ts

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

package/src/swift-distribution.lock.json

@@ -1,10 +1,10 @@
 {
-  "id": "77123740e6b79652",
+  "id": "e8dd3a9ff9c4dc74",
   "release": "swift-6.4.0-RELEASE-custom-0d775d32d7c74eae",
   "wasmSdkId": "swift-6.4.0-RELEASE_wasm-peach-21f60db0",
   "wasmSdkUrl": "https://r2.sootsim.com/swift-wasm-sdk/swift-6.4.0-RELEASE_wasm-peach-21f60db0.artifactbundle.tar.gz",
   "wasmSdkChecksum": "7b7573fd23120549fc928581a42968676f5f00f9ef63e5618032a6928a724e16",
-  "source": "7625fb75d15f047f1e8c0b14b73407c50263f0c4",
+  "source": "693296741f3865605388c21ee7e220cb0b6ccaa3",
   "targets": [
     "ImagePlayground",
     "QuickLookThumbnailing",
@@ -46,6 +46,7 @@
     "Darwin",
     "MachO",
     "ObjectiveC",
+    "PeachObjCRuntime",
     "PeachObjC",
     "UIUtilities",
     "UIKitCore",
@@ -191,16 +192,16 @@
   },
   "hosts": {
     "darwin-arm64": {
-      "sha256": "cc4a8f39ea9e3f12864196793a248bea28c05917ef4e7220ad516447da88d582",
-      "size": 71374056
+      "sha256": "0e06928cd63077f30226a27b2a3e92e89bdcaaf2fcd57fcac6a38a8465ee6865",
+      "size": 71438614
     },
     "linux-x64": {
-      "sha256": "c3938547ce5a453c63dc261e98753be6420ee8f2501b64d3622ef16f63d8bd1f",
-      "size": 71380196
+      "sha256": "baae9a89308dfde3cc47366ab4163369ac8537274361d10381004f006a965afa",
+      "size": 71444190
     },
     "linux-arm64": {
-      "sha256": "0b32aaf29f8ad7a1ca021a42f889bc4da28d239680c4cff82ca96a803c3d31e1",
-      "size": 71378226
+      "sha256": "422e2fbd6f65a8aebe0456e9becc2a6a28505825457c9758e8275f35e2fe63f1",
+      "size": 71442522
     }
   }
 }

package/src/swift-host.ts

@@ -1401,10 +1401,11 @@ async function compile(
     throw new SwiftMissingModulesError(await missingModulesMessage(packagePath, missing))
   const artifact = await compileSwiftProjectUnit(input, {
     // the compile rewrites Sources/App in its root before swiftpm builds, and
-    // its lock orders one process only: two vites on one root (a lane's dev
-    // server and a capture, or two checkouts) build each other's sources. so
-    // each app and module checkout gets its own root, which keeps the same
-    // app's incremental build across restarts.
+    // a root lock orders every process using it, so two vites on one root
+    // (a lane's dev server and a capture, or two checkouts) queue instead of
+    // building each other's sources. each app and module checkout still gets
+    // its own root, so they do not queue and the same app keeps its
+    // incremental build across restarts.
     buildRoot: (() => {
       if (process.env.CONTRAST_SWIFT_BUILD_ROOT)
         return process.env.CONTRAST_SWIFT_BUILD_ROOT
@@ -1656,6 +1657,7 @@ async function compileRemote(
     },
     origin,
     signal,
+    (stage) => console.error(`Peach: compiling ${path.basename(packagePath)}: ${stage}`),
   )
   // the app's JS calls with the hash its own `one typegen` wrote; glue the
   // service rendered from another One would reject every call as stale.