peachsim 0.1.1635 → 0.1.1641

package/src/swift-compile.ts

@@ -33,7 +33,8 @@ import {
   swiftTargetModuleName,
   type SwiftPackageTarget,
 } from './swift-package'
-import { swiftSdkOptions, type SwiftWasmSdk } from './swift-toolchain'
+import { withSwiftRootLock } from './swift-root-lock'
+import { swiftEnvironment, swiftSdkOptions, type SwiftWasmSdk } from './swift-toolchain'
 import { isSwiftResourceBundles } from './swiftContract'
 import type { SwiftImageUpload } from './swift-submit'
 import type { SwiftResourceBundle } from './swiftContract'
@@ -42,17 +43,21 @@ 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.
+// `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 },
-  stream = false,
+  stream: boolean | RegExp = false,
+  quiet?: RegExp,
 ): Promise<void> {
   const { signal } = options
   signal?.throwIfAborted()
   const child = spawn(command, args, {
     cwd: options.cwd,
-    env: options.env,
+    env: swiftEnvironment(options.env),
     detached: true,
     stdio: ['ignore', 'pipe', 'pipe'],
   })
@@ -63,6 +68,7 @@ async function runCompiler(
       let timeout: ReturnType<typeof setTimeout> | undefined
       const chunks: Record<'stdout' | 'stderr', Buffer[]> = { stdout: [], stderr: [] }
       const sizes = { stdout: 0, stderr: 0 }
+      const partial = { stdout: '', stderr: '' }
       const stop = () => {
         stopping ??= terminateProcessGroup(child)
         // close and cancellation share the same awaited cleanup below.
@@ -70,7 +76,13 @@ async function runCompiler(
       }
       for (const name of ['stdout', 'stderr'] as const) {
         child[name].on('data', (bytes: Buffer) => {
-          if (stream) process[name].write(bytes)
+          if (stream === true) process[name].write(bytes)
+          else if (stream) {
+            const lines = (partial[name] + bytes.toString()).split('\n')
+            partial[name] = lines.pop()!
+            for (const line of lines)
+              if (stream.test(line)) process[name].write(`${line}\n`)
+          }
           sizes[name] += bytes.length
           if (sizes[name] <= (options.maxBuffer ?? 1024 * 1024)) chunks[name].push(bytes)
           else {
@@ -102,7 +114,13 @@ async function runCompiler(
               },
             ),
           )
-        else resolve()
+        else {
+          if (quiet)
+            for (const name of ['stdout', 'stderr'] as const)
+              for (const line of Buffer.concat(chunks[name]).toString().split('\n'))
+                if (line && !quiet.test(line)) process[name].write(`${line}\n`)
+          resolve()
+        }
       })
       if (options.timeout)
         timeout = setTimeout(() => {
@@ -118,6 +136,14 @@ async function runCompiler(
 
 const WASM_TRIPLE = 'wasm32-unknown-wasip1'
 
+// swiftpm's step counter, echoed while a build runs; its diagnostics print
+// once, with the failure.
+const SWIFTPM_PROGRESS = /^\[\d+\/\d+\] /
+// lines that are not diagnostics: progress, already echoed, and the notice
+// that the native build system peach selects is deprecated.
+const SWIFTPM_NOISE =
+  /^(?:\[\d+\/\d+\] |Building for production\.\.\.$|warning: '--build-system native' has been deprecated)/
+
 // compiler jobs match the fixture builder's cap to fit a 16GiB Linux slot.
 const BUILD_JOBS = String(
   Math.min(4, Math.max(1, Math.floor(os.availableParallelism() / 2))),
@@ -153,6 +179,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 {
@@ -212,6 +240,10 @@ export function swiftModuleInputFiles(root: string): string[] {
     'scripts/contrast-app-Package.swift',
     'scripts/build-distribution.ts',
     'scripts/distribution-clang.ts',
+    'scripts/distribution-libxml2.ts',
+    'scripts/distribution-libxml2.json',
+    'Sources/libxml2/include/module.modulemap',
+    'Sources/libxml2/COPYING',
     'scripts/build-distribution-plugins.sh',
     'scripts/build-distribution-plugins-docker.sh',
     'scripts/build-preview-plugin.sh',
@@ -234,12 +266,8 @@ export function swiftModuleInputFiles(root: string): string[] {
   return files.sort()
 }
 
-// the host halves of the module's macros: the rnx plugin (#Preview, @Entry,
-// @Model) and #Predicate's FoundationMacros stand-in, which one script builds
-// side by side. manifest swiftSettings cannot load a plugin library (RAN: the
-// flag reaches the driver but the plugin never loads), so every build loads
-// both with -Xswiftc, as scripts/build.sh does for the fixtures. their
-// sources are under Sources/, which the artifact hash already covers.
+// the host macro plugins build side by side and load explicitly for every
+// app compile. their source inputs also participate in artifact identity.
 /** the host macro plugin libraries a module root compiles with, and whether a
  *  checkout's must be rebuilt (scripts/build-preview-plugin.sh) first. */
 export function swiftMacroPlugins(moduleRoot: string): {
@@ -262,11 +290,21 @@ export function swiftMacroPlugins(moduleRoot: string): {
   const plugins = [
     {
       library: path.join(dir, `libRnxPreviewMacros.${ext}`),
-      source: path.join(moduleRoot, 'Sources/RnxPreviewMacros/PreviewMacro.swift'),
+      sources: [path.join(moduleRoot, 'Sources/RnxPreviewMacros/PreviewMacro.swift')],
     },
     {
       library: path.join(dir, `libFoundationMacros.${ext}`),
-      source: path.join(moduleRoot, 'Sources/FoundationMacros/PredicateMacro.swift'),
+      sources: [
+        path.join(moduleRoot, 'Sources/FoundationMacros/PredicateMacro.swift'),
+        path.join(moduleRoot, 'Sources/SwiftMacroSupport/PredicateExpression.swift'),
+      ],
+    },
+    {
+      library: path.join(dir, `libTipKitMacros.${ext}`),
+      sources: [
+        path.join(moduleRoot, 'Sources/TipKitMacros/TipKitMacros.swift'),
+        path.join(moduleRoot, 'Sources/SwiftMacroSupport/PredicateExpression.swift'),
+      ],
     },
   ]
   return {
@@ -275,8 +313,9 @@ export function swiftMacroPlugins(moduleRoot: string): {
       !existsSync(compilerStamp) ||
       readFileSync(compilerStamp, 'utf8').trim() !== release ||
       plugins.some(
-        ({ library, source }) =>
-          !existsSync(library) || statSync(source).mtimeMs > statSync(library).mtimeMs,
+        ({ library, sources }) =>
+          !existsSync(library) ||
+          sources.some((source) => statSync(source).mtimeMs > statSync(library).mtimeMs),
       ),
   }
 }
@@ -342,6 +381,16 @@ export function swiftModuleDigest(root: string): Buffer {
   return digest
 }
 
+// optimized consumers can reference private symbols from an imported framework.
+// source revisions need separate object trees, while app edits keep one warm tree.
+export function swiftProjectBuildKey(moduleRoot: string, release: string): string {
+  return createHash('sha256')
+    .update(`${release}\0${swiftModuleSdk(moduleRoot).wasmSdkId}`)
+    .update(swiftModuleDigest(moduleRoot))
+    .digest('hex')
+    .slice(0, 32)
+}
+
 export function compileTargets(input: SwiftCompileInput): SwiftPackageTarget[] {
   const manifest = input.files['Package.swift']
   return manifest === undefined
@@ -384,11 +433,13 @@ const OPTIONAL_FRAMEWORK_DEPENDENCIES: Record<string, string[]> = {
   Accelerate: [],
   CryptoKit: [],
   CommonCrypto: [],
+  ImagePlayground: [],
+  QuickLookThumbnailing: [],
+  libxml2: [],
   CoreText: [],
   Compression: ['PeachCodec'],
   zlib: ['PeachCodec'],
   PeachCodec: [],
-  Security: ['CryptoKit'],
   TikTokBusinessSDK: [],
   nSure: [],
   Statsig: [],
@@ -569,7 +620,7 @@ export function swiftSdkPaths(
       sdk,
       'wasm32-unknown-wasip1',
     ],
-    { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] },
+    { encoding: 'utf8', env: swiftEnvironment(), stdio: ['ignore', 'pipe', 'pipe'] },
   )
   const field = (name: string) => {
     const value = new RegExp(`^${name}:\\s*(.+)$`, 'm').exec(configuration)?.[1]?.trim()
@@ -900,9 +951,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'))}`
       : ''
@@ -946,7 +998,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('')
         : ''
@@ -1636,25 +1688,32 @@ function objcRootedClasses(sources: string[]): Set<string> {
 // the header swift emits on iOS keeps an Objective-C class out of its C++
 // section. here its root is a swift class from a module with no C++ header,
 // so C++ that includes the header fails on the undeclared base. a top-level
-// class in `rooted` gains @_expose(!Cxx) in front of its declaration,
-// shifting that one line's columns. swift rejects the attribute in a local
+// class in `rooted` gains @_expose(!Cxx), keeping @main first so SwiftPM
+// recognizes the entry without changing source lines. swift rejects it in a local
 // scope, so a nested class keeps its exposure.
 function hideObjCClassesFromCxx(source: string, rooted: Set<string>): string {
   if (rooted.size === 0) return source
   const code = swiftCodeMask(source)
-  const starts: number[] = []
+  const insertions: { at: number; text: string }[] = []
   let depth = 0
   for (const match of code.matchAll(
     /[{}]|\bclass\s+(?!(?:func|var|let|subscript)\b)([A-Za-z_]\w*)/g,
   )) {
     if (match[0] === '{') depth++
     else if (match[0] === '}') depth--
-    else if (depth === 0 && rooted.has(match[1]!))
-      starts.push(declarationStart(code, match.index, 0))
+    else if (depth === 0 && rooted.has(match[1]!)) {
+      const start = declarationStart(code, match.index, 0)
+      const main = /@main\b/.exec(code.slice(start, match.index))
+      insertions.push(
+        main
+          ? { at: start + main.index + main[0].length, text: ' @_expose(!Cxx)' }
+          : { at: start, text: '@_expose(!Cxx) ' },
+      )
+    }
   }
   let out = source
-  for (const at of starts.reverse())
-    out = `${out.slice(0, at)}@_expose(!Cxx) ${out.slice(at)}`
+  for (const { at, text } of insertions.reverse())
+    out = `${out.slice(0, at)}${text}${out.slice(at)}`
   return out
 }
 
@@ -5952,6 +6011,7 @@ function projectDiagnostic(
   const prefix = `${base}${path.sep}`
   return designTimeDiagnostic(output, files)
     .split('\n')
+    .filter((line) => !SWIFTPM_NOISE.test(line))
     .map((line) => (line.startsWith(prefix) ? line.slice(prefix.length) : line))
     .join('\n')
     .trim()
@@ -6093,8 +6153,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,
@@ -6133,13 +6195,9 @@ export function compileSwiftProjectUnit(
             hash,
             release: options.release,
             timeoutMs: options.timeoutMs,
-            // the builder's swiftpm tree holds the sootsim-swift objects, which
-            // depend on the toolchain and sdk and not on the caller's checkout
-            // path, so every caller shares one warm tree per toolchain.
-            buildKey: createHash('sha256')
-              .update(`${options.release}\0${swiftModuleSdk(moduleRoot).wasmSdkId}`)
-              .digest('hex')
-              .slice(0, 32),
+            // framework sources and compiler inputs own the shared object tree;
+            // unrelated app edits reuse it without retaining stale private ABI.
+            buildKey: swiftProjectBuildKey(moduleRoot, options.release),
           }),
         )
         try {
@@ -6180,113 +6238,140 @@ 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, true)
-      } 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, true)
-          } catch (retryError) {
+        async () => {
+          // 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(
-              projectDiagnostic(outputOf(retryError), layout, input.files),
-              {
-                cause: retryError,
-              },
+              `swift-compile: no swift.org toolchain at ${options.toolchainBin}; install ${options.release} and its matching wasm sdk`,
             )
           }
-        } 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)
+          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,
+          }
+          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 })
+              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,
+              })
+            }
+          }
+          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-distribution.lock.json

@@ -1,11 +1,15 @@
 {
-  "id": "4fdcd218fa180b52",
-  "release": "swift-6.4.0-RELEASE-custom-91504a66b3f012ac",
-  "wasmSdkId": "swift-6.4.0-RELEASE_wasm-peach-7fd9a101",
-  "wasmSdkUrl": "https://r2.sootsim.com/swift-wasm-sdk/swift-6.4.0-RELEASE_wasm-peach-7fd9a101.artifactbundle.tar.gz",
-  "wasmSdkChecksum": "72f7fec1d090d142d26148d6cc0cd5b1ce78da70bb97bd577dc1482eaf0299b2",
-  "source": "80c26dea3c4bbf0e29458c33a3a0e856b0942564",
+  "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": "693296741f3865605388c21ee7e220cb0b6ccaa3",
   "targets": [
+    "ImagePlayground",
+    "QuickLookThumbnailing",
+    "libxml2",
+    "CarPlay",
     "System",
     "_LocationEssentials",
     "GeoToolbox",
@@ -42,6 +46,7 @@
     "Darwin",
     "MachO",
     "ObjectiveC",
+    "PeachObjCRuntime",
     "PeachObjC",
     "UIUtilities",
     "UIKitCore",
@@ -56,6 +61,7 @@
     "DeviceCheck",
     "PassKit",
     "Translation",
+    "TipKit",
     "CoreSpotlight",
     "CoreVideo",
     "CoreMedia",
@@ -139,7 +145,12 @@
     "FoundationModels",
     "CoreTransferable",
     "AudioToolbox",
+    "CoreAudioTypes",
+    "AudioUnit",
     "Intents",
+    "IntentsUI",
+    "WatchConnectivity",
+    "CoreServices",
     "MobileCoreServices",
     "ImageIO",
     "CoreLocationEnums",
@@ -181,16 +192,16 @@
   },
   "hosts": {
     "darwin-arm64": {
-      "sha256": "2b6768539f39bbdc2d77447fc91b00e9a7ee2d9ed732ea10e67a7b05c1c854ea",
-      "size": 69899802
+      "sha256": "0e06928cd63077f30226a27b2a3e92e89bdcaaf2fcd57fcac6a38a8465ee6865",
+      "size": 71438614
     },
     "linux-x64": {
-      "sha256": "2d357dc6c24559b1e4f792c4142de2608e2dd91a2b322c74013af31a9346ad6e",
-      "size": 69902826
+      "sha256": "baae9a89308dfde3cc47366ab4163369ac8537274361d10381004f006a965afa",
+      "size": 71444190
     },
     "linux-arm64": {
-      "sha256": "fdbdc2b25d102db38da6c00e74c6d198b87537aefe74365ef65793ec6feb3faa",
-      "size": 69900830
+      "sha256": "422e2fbd6f65a8aebe0456e9becc2a6a28505825457c9758e8275f35e2fe63f1",
+      "size": 71442522
     }
   }
 }