peachsim 0.1.1625 → 0.1.1640

package/src/swift-host.ts

@@ -2,7 +2,6 @@ import { createHash } from 'node:crypto'
 // the node host for every Swift preview: package inputs, one compile and
 // immutable artifact addresses. vite and the foreground CLI adapt this host.
 import fs from 'node:fs'
-import os from 'node:os'
 import path from 'node:path'
 import {
   enumerateBundleColors,
@@ -11,9 +10,13 @@ import {
   enumerateBundleResources,
   resolveSwiftImageResourceUrls,
 } from '../../sootsim-swift/src/bundleAssets'
+import { compileStringCatalog } from '../../sootsim-swift/src/stringCatalog'
 import { authHeaderValue, resolveCliAuth } from '../cli/auth'
 import { resolveContrastBackendOrigin } from './backend-origin'
+import { cacheDir } from './home-paths'
 import iosSdk from './ios-sdk-frameworks.json' with { type: 'json' }
+import { type NativeAppIdentity } from './native-app-identity'
+import { readNativeAppIdentityFromXcodeTarget } from './native-app-identity-project'
 import { swiftBinaryModules } from './swift-binary-modules'
 import {
   compileSwiftProjectUnit,
@@ -27,6 +30,7 @@ import {
 } from './swift-compile'
 import { designTimeValues } from './swift-design-time'
 import { swiftDistributionRoot, swiftModuleToolchain } from './swift-distribution'
+import { compileXcodeObjCImplementations } from './swift-objc-compile'
 import {
   swiftImplicitResourcePaths,
   swiftMetalSourceFiles,
@@ -39,13 +43,13 @@ import {
 } from './swift-package'
 import { swiftPackageManifest } from './swift-package-manifest'
 import {
-  REMOTE_CHECKOUTS,
+  remoteSwiftCheckouts,
   resolveSwiftPackages,
   type SwiftPackageBinary,
   type SwiftPackageGap,
   type SwiftPackages,
 } from './swift-packages'
-import { readPackageFile } from './swift-source-file'
+import { readPackageFile as readSwiftSourceFile } from './swift-source-file'
 import { readSwiftStandinBehavior } from './swift-standin-config'
 import {
   standinGenerationInputs,
@@ -68,6 +72,7 @@ import {
   MAX_SWIFT_COMPILE_IMAGE_TOTAL_BYTES,
   isSwiftNativeModules,
   compileSwiftProject,
+  DEFAULT_SWIFT_COMPILE_BUILD_MS,
   httpSwiftCompileSubmit,
   swiftNativeEntry,
   type SwiftImageUpload,
@@ -242,6 +247,8 @@ interface XcodeProjectEntry {
   packages?: {
     key: string
     standinKey: string
+    /** generation always uses the original closure, before stand-ins replace targets. */
+    binaries: SwiftPackageBinary[]
     packages: SwiftPackages
     standins: SwiftStandin[]
     /** why a framework the project vendors got no stand-in, by name. */
@@ -263,7 +270,9 @@ export function openXcodeProject(
   moduleRoot: string | undefined,
   configuration?: string,
 ): string {
-  const app = readXcodeAppTarget(xcodeproj, target, configuration)
+  const app = readXcodeAppTarget(xcodeproj, target, configuration, {
+    prepareGeneratedSources: true,
+  })
   const root = app.rootDir
   xcodeProjects.set(root, {
     xcodeproj,
@@ -308,37 +317,46 @@ function swiftPackages(
   projectGaps: Map<string, string>
   binaries: SwiftPackageBinary[]
 } {
-  const stamp = (file: string | null) =>
-    file && fs.existsSync(file) ? fs.statSync(file).mtimeMs : 0
+  const stamp = (file: string) =>
+    fs.existsSync(file)
+      ? createHash('sha256').update(fs.readFileSync(file)).digest('hex')
+      : null
   const key = JSON.stringify([
     app.linkedProducts,
-    app.packageResolved,
-    stamp(app.packageResolved),
+    app.packageResolved.map((file) => [file, stamp(file)]),
     app.localPackageDirs.map((dir) => stamp(path.join(dir, 'Package.swift'))),
     app.linkedProducts.map(({ source }) =>
       source.kind === 'local' ? stamp(path.join(source.dir, 'Package.swift')) : 0,
     ),
   ])
-  // the package key is cheap stamps; the stand-in key covers the generation
-  // inputs the stamps cannot see (artifact contents, peach's modules, the
-  // emitter), so a changed input rebuilds instead of reusing stale output.
+  // resolution follows lock and manifest contents even when a checkout restores
+  // timestamps. the stand-in key also covers artifacts, peach modules and emitter.
   let cached = entry.packages
   if (cached?.key !== key) {
+    const packages = resolveSwiftPackages({
+      rootDir: app.rootDir,
+      resolved: app.packageResolved,
+      products: app.linkedProducts,
+      localDirs: app.localPackageDirs,
+      provided: entry.provided,
+    })
     cached = {
       key,
       standinKey: '',
-      packages: resolveSwiftPackages({
-        rootDir: app.rootDir,
-        resolved: app.packageResolved,
-        products: app.linkedProducts,
-        localDirs: app.localPackageDirs,
-        provided: entry.provided,
-      }),
+      packages,
+      binaries: packages.binaries,
       standins: [],
       projectGaps: new Map(),
     }
     entry.packages = cached
   }
+  if (
+    entry.moduleRoot &&
+    [app, ...app.frameworks].some((target) =>
+      target.allSources.some((file) => /\.mm?$/.test(file)),
+    )
+  )
+    compileXcodeObjCImplementations(app, cached.binaries, entry.moduleRoot)
   // a reached binary target with stand-ins for every module it ships
   // resolves as provided, so what depends on it compiles; the rest keep
   // their reason with why no stand-in was built. surfaces peach already
@@ -360,10 +378,7 @@ function swiftPackages(
         ]
       : [],
   )
-  const reached = [
-    ...cached.packages.binaries.filter((binary) => binary.reached),
-    ...vendored,
-  ]
+  const reached = [...cached.binaries.filter((binary) => binary.reached), ...vendored]
   if (entry.moduleRoot && entry.provided && reached.length > 0) {
     const resolved = swiftModuleToolchain(entry.moduleRoot)
     const toolchain = {
@@ -385,6 +400,8 @@ function swiftPackages(
         ]),
         binaryGaps: built.gaps,
       })
+      for (const target of new Set(built.standins.map((standin) => standin.target)))
+        console.error(`Peach: target ${target} was replaced with a stand-in`)
       cached.standins = built.standins
       cached.projectGaps = new Map(
         vendored.flatMap(({ target }) => {
@@ -408,14 +425,17 @@ const XCODE_FRAMEWORKS_DIR = '__frameworks__'
 // remote package checkouts compile here: swiftpm owns `.build` in the
 // compile's package root as its scratch directory.
 const XCODE_PACKAGES_DIR = '__packages__'
-const CHECKOUTS_PREFIX = `${REMOTE_CHECKOUTS.split(path.sep).join(path.posix.sep)}/`
 
 // the compile input key of a root-relative path in an xcode layout.
 function xcodeInputKey(layout: XcodeLayout, file: string, relative: string): string {
   const owner = layout.targetDirs.get(file)
   if (owner) return path.posix.join(owner, relative)
-  return relative.startsWith(CHECKOUTS_PREFIX)
-    ? path.posix.join(XCODE_PACKAGES_DIR, relative.slice(CHECKOUTS_PREFIX.length))
+  const checkouts = remoteSwiftCheckouts(layout.app.rootDir)
+  return file.startsWith(`${checkouts}${path.sep}`)
+    ? path.posix.join(
+        XCODE_PACKAGES_DIR,
+        path.relative(checkouts, file).split(path.sep).join('/'),
+      )
     : relative
 }
 
@@ -442,11 +462,26 @@ function xcodeLayout(root: string): XcodeLayout | null {
     registered.xcodeproj,
     registered.target,
     registered.configuration,
+    { prepareGeneratedSources: true },
+  )
+  const implementations = [app, ...app.frameworks].flatMap((target) =>
+    target.allSources
+      .filter((file) => /\.mm?$/i.test(file))
+      .map((file) => `${target.name}: ${path.relative(app.rootDir, file)}`),
   )
+  if (implementations.length > 0 && !registered.moduleRoot)
+    throw new Error(
+      `Peach cannot compile Objective-C implementations in Xcode targets until the runtime and shared Swift object bridge are available:\n${implementations.map((file) => `  ${file}`).join('\n')}`,
+    )
   const appSources = app.allSources.filter(
     (file) => file.endsWith('.swift') || file.endsWith('.metal'),
   )
-  const files = new Set([...app.projectFiles, ...appSources, ...app.resources])
+  const files = new Set([
+    ...app.projectFiles,
+    ...app.packageResolved,
+    ...appSources,
+    ...app.resources,
+  ])
   if (app.infoPlistFile) files.add(app.infoPlistFile)
   const targetDirs = new Map(
     [...appSources, ...app.resources].map((file) => [file, XCODE_APP_DIR]),
@@ -489,6 +524,7 @@ function xcodeLayout(root: string): XcodeLayout | null {
     targets.push({
       name: standin.module,
       path: path.posix.join(SWIFT_STANDINS_DIR, standin.module),
+      dependencies: standin.dependencies?.map((name) => ({ kind: 'target', name })),
       executable: false,
       resources: false,
       exclude: [],
@@ -500,7 +536,7 @@ function xcodeLayout(root: string): XcodeLayout | null {
   const packageConfiguration = app.configuration === 'Debug' ? 'debug' : 'release'
   for (const target of packages.targets) {
     const relative = path.relative(
-      target.remote ? path.join(root, REMOTE_CHECKOUTS) : root,
+      target.remote ? remoteSwiftCheckouts(root) : root,
       target.dir,
     )
     if (
@@ -524,6 +560,13 @@ function xcodeLayout(root: string): XcodeLayout | null {
           )
           .map((define) => define.name),
       ],
+      linkedLibraries: target.packageLibraries
+        .filter(
+          (library) =>
+            library.configuration === null ||
+            library.configuration === packageConfiguration,
+        )
+        .map((library) => library.name),
     })
     if (target.resources) {
       resourceBundles.push({
@@ -568,14 +611,19 @@ function xcodeManifest(layout: XcodeLayout): string {
       ...(target.mainActorIsolation ? ['.defaultIsolation(MainActor.self)'] : []),
       ...(target.defines ?? []).map((name) => `.define(${JSON.stringify(name)})`),
     ].join(', ')}]`
+  const libraries = (target: SwiftPackageTarget) =>
+    target.linkedLibraries?.length
+      ? `, linkerSettings: [${target.linkedLibraries.map((name) => `.linkedLibrary(${JSON.stringify(name)})`).join(', ')}]`
+      : ''
   return [
     '// swift-tools-version: 6.2',
     'import PackageDescription',
     'let package = Package(name: "app", targets: [',
     `  .executableTarget(name: "${layout.app.moduleName}", path: "${XCODE_APP_DIR}", ${settings(layout.app)}),`,
-    ...layout.targets.map(
-      (target) =>
-        `  .target(name: "${target.name}", dependencies: ${JSON.stringify((target.dependencies ?? []).map((dependency) => dependency.name))}, path: "${target.path}", ${target.exclude.length > 0 ? `exclude: ${JSON.stringify(target.exclude)}, ` : ''}${target.resources ? 'resources: [], ' : ''}${settings(target)}),`,
+    ...layout.targets.map((target) =>
+      target.systemLibrary
+        ? `  .systemLibrary(name: "${target.name}", path: "${target.path}"),`
+        : `  .target(name: "${target.name}", dependencies: ${JSON.stringify((target.dependencies ?? []).map((dependency) => dependency.name))}, path: "${target.path}", ${target.exclude.length > 0 ? `exclude: ${JSON.stringify(target.exclude)}, ` : ''}${target.resources ? 'resources: [], ' : ''}${settings(target)}${libraries(target)}),`,
     ),
     '])',
     '',
@@ -584,10 +632,29 @@ function xcodeManifest(layout: XcodeLayout): string {
 
 // preflight the entire input tree before reading any source or resource bytes.
 // a nested package is a separate compile unit; ignored build trees never enter it.
-function packageFiles(root: string): string[] {
+function packageFiles(root: string, includeBuildInputs = true): string[] {
   const canonicalRoot = fs.realpathSync(root)
   const xcode = xcodeLayout(canonicalRoot)
-  return xcode ? xcode.files : sourceTreeFiles(canonicalRoot, canonicalRoot)
+  if (!xcode) return sourceTreeFiles(canonicalRoot, canonicalRoot)
+  if (includeBuildInputs) return xcode.files
+  const buildInputs = new Set(xcode.app.projectFiles)
+  return xcode.files.filter(
+    (file) =>
+      !buildInputs.has(file) ||
+      xcode.targetDirs.has(file) ||
+      xcode.packages.targets.some((target) => target.files.includes(file)),
+  )
+}
+
+// remote dependencies are enumerated from peach's checkout cache, while app
+// inputs retain their selected-project boundary and all symlink checks.
+function readPackageFile(root: string, file: string, maxBytes: number): Buffer {
+  if (xcodeProjects.has(root)) {
+    const checkouts = remoteSwiftCheckouts(root)
+    if (file.startsWith(`${checkouts}${path.sep}`))
+      return readSwiftSourceFile(checkouts, file, maxBytes)
+  }
+  return readSwiftSourceFile(root, file, maxBytes)
 }
 
 // every input file under `dir`, which must stay inside `canonicalRoot`.
@@ -636,16 +703,18 @@ function isPackageSource(file: string): boolean {
 }
 
 export function sourceFiles(root: string): string[] {
-  return packageFiles(root).filter(isPackageSource)
+  return packageFiles(root, false).filter(isPackageSource)
 }
 
 // project files and the xcconfigs their settings read are build inputs, never resources
 function resourceCandidateFiles(root: string): string[] {
-  return packageFiles(root).filter(
+  return packageFiles(root, false).filter(
     (file) =>
       !isPackageSource(file) &&
       !file.endsWith('.xcconfig') &&
-      !['project.pbxproj', 'project.xcproj'].includes(path.basename(file)),
+      !['project.pbxproj', 'project.xcproj', 'Package.resolved'].includes(
+        path.basename(file),
+      ),
   )
 }
 
@@ -653,6 +722,7 @@ function resourceCandidateFiles(root: string): string[] {
 export function swiftProjectAppInfo(packagePath: string): {
   name: string
   icon: { bytes: Buffer; contentType: string } | null
+  identity: NativeAppIdentity | null
 } {
   const registered = xcodeProjects.get(packagePath)
   const app = registered
@@ -715,12 +785,17 @@ export function swiftProjectAppInfo(packagePath: string): {
     }
     break
   }
-  return { name: app?.name ?? path.basename(packagePath), icon }
+  return {
+    name: app?.name ?? path.basename(packagePath),
+    icon,
+    identity: app ? readNativeAppIdentityFromXcodeTarget(app) : null,
+  }
 }
 
 // the hosted compile service caps what a project sends it; a local compile
 // reads the author's own files, so nothing caps them there.
 const HOSTED_LIMITS = {
+  sourceBytes: MAX_SWIFT_COMPILE_SOURCE_BYTES,
   resources: MAX_SWIFT_COMPILE_RESOURCES,
   resourceBytes: MAX_SWIFT_COMPILE_RESOURCE_BYTES,
   resourceTotalBytes: MAX_SWIFT_COMPILE_RESOURCE_TOTAL_BYTES,
@@ -729,6 +804,7 @@ const HOSTED_LIMITS = {
   imageTotalBytes: MAX_SWIFT_COMPILE_IMAGE_TOTAL_BYTES,
 }
 const LOCAL_LIMITS: typeof HOSTED_LIMITS = {
+  sourceBytes: Infinity,
   resources: Infinity,
   resourceBytes: Infinity,
   resourceTotalBytes: Infinity,
@@ -937,7 +1013,7 @@ export function buildSwiftBundleFiles(
   const xcode = xcodeLayout(packagePath)
   const bundles =
     xcode?.resourceBundles ??
-    swiftResourceBundles(inputs ?? packageSources(packagePath), relative)
+    swiftResourceBundles(inputs ?? packageSources(packagePath, hosted), relative)
   const addFile = (key: string, bytes: Buffer) => {
     if (
       Object.keys(files).length >= limits.resources ||
@@ -983,6 +1059,13 @@ export function buildSwiftBundleFiles(
       const disk = path.join(packagePath, ...file.split('/'))
       const bytes = readPackageFile(packagePath, disk, limits.resourceBytes)
       addFile(bundlePath === '.' ? base : `${bundlePath}/${base}`, bytes)
+      if (base.endsWith('.xcstrings')) {
+        for (const [name, table] of Object.entries(
+          compileStringCatalog(bytes.toString('utf8'), base.slice(0, -10)),
+        )) {
+          addFile(bundlePath === '.' ? name : `${bundlePath}/${name}`, Buffer.from(table))
+        }
+      }
     }
   }
   return { files, bundles, watched }
@@ -1048,6 +1131,24 @@ export function sourceStamp(
   return hash.digest('hex').slice(0, 16)
 }
 
+// sourceStamp's inputs read by content and relative to the package, so
+// another process's build copy of the same sources stamps the same.
+export function sourceContentStamp(
+  packagePath: string,
+  moduleRootOverride?: string,
+): string {
+  const hash = createHash('sha256')
+  hash.update(JSON.stringify(xcodeProjects.get(packagePath)?.behavior ?? {}))
+  const libraries = projects.get(packagePath)?.libraries
+  if (libraries) hash.update(JSON.stringify(libraries))
+  for (const file of [...new Set(packageFiles(packagePath))].sort()) {
+    hash.update(path.relative(packagePath, file))
+    hash.update(fs.readFileSync(file))
+  }
+  hash.update(moduleStamp(packagePath, moduleRootOverride, false))
+  return hash.digest('hex').slice(0, 16)
+}
+
 // the linked module's part of the source stamp
 function moduleStamp(
   packagePath: string,
@@ -1118,6 +1219,7 @@ export function standinLibraries(
 
 function packageSources(
   packagePath: string,
+  hosted = false,
   linked: ReadonlySet<SwiftStandin> = new Set(),
 ): Record<string, string> {
   const xcode = xcodeLayout(packagePath)
@@ -1127,13 +1229,14 @@ function packageSources(
     ),
   )
   const files: Record<string, string> = {}
+  const limits = inputLimits(hosted)
   for (const file of sourceFiles(packagePath)) {
     const relative = path.relative(packagePath, file).split(path.sep).join(path.posix.sep)
     if (manifests.has(file)) continue
     files[xcode ? xcodeInputKey(xcode, file, relative) : relative] = readPackageFile(
       packagePath,
       file,
-      MAX_SWIFT_COMPILE_SOURCE_BYTES,
+      limits.sourceBytes,
     ).toString('utf8')
   }
   if (xcode) {
@@ -1164,7 +1267,11 @@ function packageSnapshot(project: SwiftProject, entry: string): SwiftPackageSnap
   const linked = layout
     ? standinLibraries(layout.binaries, layout.standins, layout.app.rootDir)
     : new Map<string, SwiftStandin[]>()
-  const files = packageSources(project.packagePath, new Set([...linked.values()].flat()))
+  const files = packageSources(
+    project.packagePath,
+    Boolean(project.hosted),
+    new Set([...linked.values()].flat()),
+  )
   const native = nativeSourceDescriptor(project.packagePath)
   return {
     files,
@@ -1177,9 +1284,7 @@ function packageSnapshot(project: SwiftProject, entry: string): SwiftPackageSnap
           .relative(project.packagePath, file)
           .split(path.sep)
           .join(path.posix.sep)
-        return layout && file.endsWith('.metal')
-          ? xcodeInputKey(layout, file, relative)
-          : relative
+        return layout ? xcodeInputKey(layout, file, relative) : relative
       }),
     ),
     resources: buildSwiftResourceTable(project, '', files),
@@ -1207,7 +1312,7 @@ function packageSnapshot(project: SwiftProject, entry: string): SwiftPackageSnap
           glue: readPackageFile(
             project.packagePath,
             path.join(project.packagePath, NATIVE_GLUE),
-            MAX_SWIFT_COMPILE_SOURCE_BYTES,
+            inputLimits(Boolean(project.hosted)).sourceBytes,
           ).toString('utf8'),
         }
       : {}),
@@ -1304,13 +1409,20 @@ async function compile(
       if (process.env.CONTRAST_SWIFT_BUILD_ROOT)
         return process.env.CONTRAST_SWIFT_BUILD_ROOT
       const resolvedPath = path.resolve(packagePath)
+      // units of one app share a root so the module cache stays warm.
+      // peach-expo-swift/<app>/<scope>/<package> shares <app>/<scope>, and
+      // the older <app>/<package> layout shares <app>. the scope is this
+      // process, so two servers do not compile into one tree.
+      const parts = resolvedPath.split(path.sep)
+      const expoAt = parts.lastIndexOf('peach-expo-swift')
+      const scoped = expoAt >= 0 && parts.length >= expoAt + 4
       const buildKeyPath =
-        path.basename(path.dirname(path.dirname(resolvedPath))) === 'peach-expo-swift'
-          ? path.dirname(resolvedPath)
+        expoAt >= 0 && parts.length >= expoAt + 3
+          ? parts.slice(0, scoped ? expoAt + 3 : expoAt + 2).join(path.sep)
           : resolvedPath
       return path.join(
-        os.tmpdir(),
-        'contrast-swift-build',
+        cacheDir(),
+        'swift-builds',
         createHash('sha256')
           .update(`${moduleRoot}\0${buildKeyPath}`)
           .digest('hex')
@@ -1349,6 +1461,21 @@ const API_GAP_PATTERNS: [RegExp, (match: RegExpExecArray) => string][] = [
     (match) => `${match[1]}.${match[2]}`,
   ],
   [/^'([^']+)' is unavailable/, (match) => match[1]!],
+  // an instance api Peach declares static, or the reverse
+  [
+    /^(?:static|instance) member '([^']+)' cannot be used on (?:instance of )?type '([^']+)'/,
+    (match) => `${match[2]}.${match[1]}`,
+  ],
+  // an overridable api Peach declares in an extension
+  [
+    /^(?:non-@objc )?[\w ]+ '([^']+)' is declared in extension of '([^']+)' and cannot be overridden/,
+    (match) => `${match[2]}.${match[1]}`,
+  ],
+  // a form of a macro Peach's expansion does not accept
+  [
+    /^(@\w+) requires an initial value/,
+    (match) => `${match[1]} without an initial value`,
+  ],
   [/^no such module '([^']+)'/, (match) => `module ${match[1]}`],
 ]
 
@@ -1363,7 +1490,7 @@ export function swiftApiGapReport(output: string): string | null {
     const file = diagnostic[1]!
       .replace(new RegExp(`^(?:${XCODE_APP_DIR}|${XCODE_FRAMEWORKS_DIR}/[^/]+)/`), '')
       .replace(new RegExp(`^${XCODE_PACKAGES_DIR}/`), '')
-    const message = diagnostic[4]!
+    const message = diagnostic[4]!.trim()
     const rule = API_GAP_PATTERNS.find(([pattern]) => pattern.test(message))
     const key = rule ? rule[1](rule[0].exec(message)!) : message
     const table = rule ? gaps : other
@@ -1496,7 +1623,7 @@ async function compileRemote(
     hosted?.authorization ?? (auth ? authHeaderValue(auth) : undefined)
   const signal = AbortSignal.any([
     ...(ownerSignal ? [ownerSignal] : []),
-    AbortSignal.timeout(5 * 60_000),
+    AbortSignal.timeout(DEFAULT_SWIFT_COMPILE_BUILD_MS + 60_000),
   ])
   const submit = httpSwiftCompileSubmit({
     endpoint: origin,
@@ -1664,9 +1791,8 @@ export function swiftPackageWatchFiles(
   packagePath = fs.realpathSync(packagePath)
   return [
     ...(xcodeProjects.has(packagePath) ? [] : [path.join(packagePath, 'Package.swift')]),
-    ...sourceFiles(packagePath),
+    ...packageFiles(packagePath),
     ...nativeSourceFiles(packagePath),
-    ...resourceCandidateFiles(packagePath),
     ...(moduleRoot
       ? swiftModuleInputFiles(moduleRoot).map((file) => path.join(moduleRoot, file))
       : []),
@@ -1682,14 +1808,14 @@ export async function swiftPackageMetadata(
   signal?: AbortSignal,
 ): Promise<SwiftEntryModuleArgs> {
   packagePath = fs.realpathSync(packagePath)
+  const project = projectFor(packagePath, hosted, signal)
+  const limits = inputLimits(Boolean(project.hosted))
   const mains = sourceFiles(packagePath).filter(
     (file) =>
       file.endsWith('.swift') &&
       swiftApplicationEntry(
         file,
-        readPackageFile(packagePath, file, MAX_SWIFT_COMPILE_SOURCE_BYTES).toString(
-          'utf8',
-        ),
+        readPackageFile(packagePath, file, limits.sourceBytes).toString('utf8'),
       ),
   )
   const native = nativeSourceDescriptor(packagePath)
@@ -1698,7 +1824,6 @@ export async function swiftPackageMetadata(
       `swift package ${packageName} needs exactly one application entry source or generated native modules; found ${mains.length}`,
     )
   }
-  const project = projectFor(packagePath, hosted, signal)
   const entry =
     mains.length === 1
       ? path.relative(packagePath, mains[0]).split(path.sep).join(path.posix.sep)

package/src/swift-icu.ts

@@ -4,6 +4,7 @@ import { existsSync, readFileSync } from 'node:fs'
 import path from 'node:path'
 import { promisify } from 'node:util'
 import { gzip } from 'node:zlib'
+import { swiftEnvironment, swiftSdkOptions } from './swift-toolchain.ts'
 
 /**
  * the icu common data a swift artifact reserves and its host fills
@@ -49,15 +50,21 @@ function memo<T>(
 
 /** the raw blob, for a harness that fills an artifact in node. */
 export function swiftIcuData(toolchainBin: string, sdk: string): Promise<Buffer> {
-  return memo(raw, `${toolchainBin}\0${sdk}`, () => load(toolchainBin, sdk))
+  return memo(raw, JSON.stringify([toolchainBin, sdk, swiftSdkOptions()]), () =>
+    load(toolchainBin, sdk),
+  )
 }
 
 /** the served form: gzipped and content-addressed. */
 export function swiftIcuAsset(toolchainBin: string, sdk: string): Promise<SwiftIcuAsset> {
-  return memo(assets, `${toolchainBin}\0${sdk}`, async () => {
-    const zipped = await deflate(await swiftIcuData(toolchainBin, sdk))
-    return { sha256: createHash('sha256').update(zipped).digest('hex'), gzip: zipped }
-  })
+  return memo(
+    assets,
+    JSON.stringify([toolchainBin, sdk, swiftSdkOptions()]),
+    async () => {
+      const zipped = await deflate(await swiftIcuData(toolchainBin, sdk))
+      return { sha256: createHash('sha256').update(zipped).digest('hex'), gzip: zipped }
+    },
+  )
 }
 
 async function load(toolchainBin: string, sdk: string): Promise<Buffer> {
@@ -66,16 +73,23 @@ async function load(toolchainBin: string, sdk: string): Promise<Buffer> {
   // missing piece instead of shelling out to sdk configure.
   if (!existsSync(swift))
     throw new Error(`swift-icu: no swift at ${swift} for the ${sdk} SDK's icu data`)
-  const { stdout: listed } = await run(swift, ['sdk', 'list'])
+  const { stdout: listed } = await run(swift, ['sdk', 'list', ...swiftSdkOptions()], {
+    env: swiftEnvironment(),
+  })
   if (!listed.split('\n').some((line) => line.trim() === sdk))
     throw new Error(`swift-icu: ${sdk} is not installed for ${swift}`)
-  const { stdout } = await run(swift, [
-    'sdk',
-    'configure',
-    '--show-configuration',
-    sdk,
-    'wasm32-unknown-wasip1',
-  ])
+  const { stdout } = await run(
+    swift,
+    [
+      'sdk',
+      'configure',
+      ...swiftSdkOptions(),
+      '--show-configuration',
+      sdk,
+      'wasm32-unknown-wasip1',
+    ],
+    { env: swiftEnvironment() },
+  )
   const resources = /^swiftStaticResourcesPath: (.+)$/m.exec(stdout)?.[1]?.trim()
   if (!resources) throw new Error(`swift-icu: ${sdk} names no static resources`)
   // a copy, so the 42 MB archive it was sliced from can be collected