peachsim 0.1.638 → 0.1.640

package/src/swift-host.ts

@@ -0,0 +1,900 @@
+// the node host for every Swift preview: package inputs, one compile and
+// immutable artifact addresses. vite and the foreground CLI adapt this host.
+
+import { createHash } from 'node:crypto'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import {
+  enumerateBundleColors,
+  enumerateBundleSymbols,
+  enumerateBundleImages,
+  enumerateBundleJson,
+} from '../../sootsim-swift/src/bundleAssets'
+import { authHeaderValue, resolveCliAuth } from '../cli/auth'
+import { resolveContrastBackendOrigin } from './backend-origin'
+import {
+  compileSwiftProjectUnit,
+  withNativeSourceGlue,
+  swiftModuleInputFiles,
+} from './swift-compile'
+import {
+  MAX_SWIFT_COMPILE_FILES,
+  MAX_SWIFT_COMPILE_SOURCE_BYTES,
+  MAX_SWIFT_COMPILE_RESOURCES,
+  MAX_SWIFT_COMPILE_RESOURCE_BYTES,
+  MAX_SWIFT_COMPILE_RESOURCE_TOTAL_BYTES,
+  MAX_SWIFT_COMPILE_IMAGES,
+  MAX_SWIFT_COMPILE_IMAGE_BYTES,
+  MAX_SWIFT_COMPILE_IMAGE_TOTAL_BYTES,
+  isSwiftNativeModules,
+  compileSwiftProject,
+  httpSwiftCompileSubmit,
+  swiftNativeEntry,
+  type SwiftImageUpload,
+  type SwiftNativeModules,
+} from './swift-submit'
+import type { SwiftEntryModuleArgs } from '../../sootsim-swift/src/entryModule'
+import type {
+  AppCatalogColor,
+  SfSymbolVector,
+  SwiftImageSource,
+} from './assetCatalogContract'
+import type { SwiftCompileInput, SwiftIcuAsset } from './swift-compile'
+import type { ServerResponse } from 'node:http'
+
+const ARTIFACT_PATH = '/__peach/swift/'
+const RESOURCE_PATH = '/__peach/swift-res/'
+const ICU_PATH = '/__peach/swift-icu/'
+const SKIP_SOURCE_DIRS = new Set([
+  'node_modules',
+  'ios',
+  'android',
+  'dist',
+  'types',
+  'build',
+])
+const NATIVE_DESCRIPTOR = '.one-native-source.json'
+const NATIVE_GLUE = '.one-native-source.swift.txt'
+
+// vxrn's `swiftPackageId`: the id One's device registry and typegen name a
+// package by.
+function swiftPackageId(packagePath: string): string {
+  return path
+    .basename(packagePath)
+    .replace(/[^A-Za-z0-9_]/g, '_')
+    .replace(/^(\d)/, '_$1')
+}
+
+export function nativeSourceDescriptor(packagePath: string): SwiftNativeModules | null {
+  packagePath = fs.realpathSync(packagePath)
+  const file = path.join(packagePath, NATIVE_DESCRIPTOR)
+  if (!fs.existsSync(file)) return null
+  const value: unknown = JSON.parse(
+    readPackageFile(packagePath, file, MAX_SWIFT_COMPILE_SOURCE_BYTES).toString('utf8'),
+  )
+  const invalid = () =>
+    new Error(`${file}: invalid One native source descriptor; run one typegen`)
+  if (
+    !value ||
+    typeof value !== 'object' ||
+    Reflect.get(value, 'generatedBy') !== 'one typegen' ||
+    !fs.existsSync(path.join(packagePath, NATIVE_GLUE))
+  ) {
+    throw invalid()
+  }
+  if (!isSwiftNativeModules(value) || value.packageId !== swiftPackageId(packagePath)) {
+    throw invalid()
+  }
+  return value
+}
+
+export function nativeSourceFiles(packagePath: string): string[] {
+  packagePath = fs.realpathSync(packagePath)
+  return [NATIVE_DESCRIPTOR, NATIVE_GLUE]
+    .map((name) => path.join(packagePath, name))
+    .filter((file) => fs.existsSync(file))
+}
+
+export interface SwiftArtifact {
+  hash: string
+  bytes: Buffer
+  // the icu common data the artifact reserves: built here and served from
+  // this server, or already published by the Contrast compile that built it
+  icu: SwiftIcuAsset | { url: string }
+  // the sources this artifact was built from. a watcher event and a `load`
+  // reach the project in either order, so freshness is read from the sources
+  // rather than from whichever of them ran first.
+  stamp: string
+  package: {
+    resources: Omit<SwiftResourceTable, 'images'>
+    bundleFiles: SwiftBundlePack
+    native: SwiftNativeModules | null
+  }
+}
+
+export interface SwiftProject {
+  packagePath: string
+  artifact: SwiftArtifact | null
+  // the build in flight and the sources it was started from
+  building: { stamp: string; promise: Promise<SwiftArtifact> } | null
+  // two bounded generations of immutable bytes cover in-flight asset reads.
+  resourceFiles: Map<string, { bytes: Buffer; contentType: string }>
+  resourcesPrevious: Map<string, { bytes: Buffer; contentType: string }>
+  artifacts: SwiftArtifact[]
+  hosted?: SwiftHostedCompileOptions
+}
+
+// a project is its swiftpm package: the build, the artifact, and the dev
+// server that serves it are shared by every plugin instance in this process.
+const projects = new Map<string, SwiftProject>()
+
+export interface SwiftHostedCompileOptions {
+  origin: string
+  authorization: string
+  signal: AbortSignal
+}
+
+export function projectFor(
+  packagePath: string,
+  hosted?: SwiftHostedCompileOptions,
+): SwiftProject {
+  packagePath = fs.realpathSync(packagePath)
+  const existing = projects.get(packagePath)
+  if (existing) {
+    if (hosted && !existing.hosted) {
+      throw new Error('a Swift package cannot share local and hosted compile ownership')
+    }
+    return existing
+  }
+  const created: SwiftProject = {
+    packagePath,
+    artifact: null,
+    building: null,
+    resourceFiles: new Map(),
+    resourcesPrevious: new Map(),
+    artifacts: [],
+    hosted,
+  }
+  projects.set(packagePath, created)
+  return created
+}
+
+// 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[] {
+  const canonicalRoot = fs.realpathSync(root)
+  const found: string[] = []
+  const walk = (dir: string): void => {
+    for (const entry of fs
+      .readdirSync(dir, { withFileTypes: true })
+      .sort((left, right) => left.name.localeCompare(right.name))) {
+      if (
+        (entry.name.startsWith('.') &&
+          entry.name !== NATIVE_DESCRIPTOR &&
+          entry.name !== NATIVE_GLUE) ||
+        SKIP_SOURCE_DIRS.has(entry.name)
+      )
+        continue
+      const full = path.join(dir, entry.name)
+      if (entry.isSymbolicLink()) throw new Error(`swift input is a symlink: ${full}`)
+      const real = fs.realpathSync(full)
+      const relative = path.relative(canonicalRoot, real)
+      if (
+        relative.startsWith(`..${path.sep}`) ||
+        relative === '..' ||
+        path.isAbsolute(relative)
+      ) {
+        throw new Error(`swift input escapes the selected package: ${full}`)
+      }
+      if (entry.isDirectory()) {
+        if (fs.existsSync(path.join(full, 'Package.swift'))) continue
+        walk(full)
+      } else if (entry.isFile()) {
+        found.push(full)
+        if (found.length > 4096) throw new Error('swift package exceeds 4096 input files')
+      }
+    }
+  }
+  walk(canonicalRoot)
+  return found
+}
+
+function readPackageFile(root: string, file: string, maxBytes: number): Buffer {
+  const canonicalRoot = fs.realpathSync(root)
+  const relative = path.relative(canonicalRoot, fs.realpathSync(file))
+  if (
+    relative === '..' ||
+    relative.startsWith(`..${path.sep}`) ||
+    path.isAbsolute(relative)
+  ) {
+    throw new Error(`swift input escapes the selected package: ${file}`)
+  }
+  let ancestor = path.resolve(file)
+  while (ancestor !== canonicalRoot) {
+    if (fs.lstatSync(ancestor).isSymbolicLink()) {
+      throw new Error(`swift input is a symlink: ${ancestor}`)
+    }
+    const parent = path.dirname(ancestor)
+    if (parent === ancestor)
+      throw new Error(`swift input escapes the selected package: ${file}`)
+    ancestor = parent
+  }
+  const expected = fs.statSync(file)
+  const fd = fs.openSync(file, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW)
+  try {
+    const stat = fs.fstatSync(fd)
+    if (stat.dev !== expected.dev || stat.ino !== expected.ino) {
+      throw new Error(`swift input changed while opening: ${file}`)
+    }
+    if (!stat.isFile() || stat.size > maxBytes) {
+      throw new Error(`swift input exceeds ${maxBytes} bytes: ${file}`)
+    }
+    const bytes = Buffer.alloc(stat.size + 1)
+    let offset = 0
+    while (offset < bytes.length) {
+      const count = fs.readSync(fd, bytes, offset, bytes.length - offset, null)
+      if (count === 0) break
+      offset += count
+    }
+    if (offset !== stat.size || fs.fstatSync(fd).size !== stat.size) {
+      throw new Error(`swift input changed while reading: ${file}`)
+    }
+    return bytes.subarray(0, offset)
+  } finally {
+    fs.closeSync(fd)
+  }
+}
+
+export function sourceFiles(root: string): string[] {
+  const files = packageFiles(root).filter((file) => file.endsWith('.swift'))
+  if (
+    files.length > MAX_SWIFT_COMPILE_FILES ||
+    files.reduce((total, file) => total + fs.statSync(file).size, 0) >
+      MAX_SWIFT_COMPILE_SOURCE_BYTES
+  ) {
+    throw new Error('swift sources exceed the compile service caps')
+  }
+  return files
+}
+
+function resourceCandidateFiles(root: string): string[] {
+  return packageFiles(root).filter((file) => !file.endsWith('.swift'))
+}
+
+const RESOURCE_CONTENT_TYPES: Record<string, string> = {
+  '.avif': 'image/avif',
+  '.bmp': 'image/bmp',
+  '.gif': 'image/gif',
+  '.ico': 'image/x-icon',
+  '.jpeg': 'image/jpeg',
+  '.jpg': 'image/jpeg',
+  '.png': 'image/png',
+  '.webp': 'image/webp',
+}
+
+export interface SwiftResourceTable {
+  /** bundle asset name to its absolute serving url and scale. */
+  table: Record<string, SwiftImageSource>
+  /** the same rasters as compile-address inputs. */
+  images: Record<string, SwiftImageUpload>
+  /** asset-catalog color name to its value. */
+  colors: Record<string, AppCatalogColor>
+  symbols: Record<string, SfSymbolVector>
+  /** project-relative image and color files this load's table covers (for watching). */
+  watched: string[]
+}
+
+// the producer for the local vehicle: enumerate the package's bundle images
+// through the shared rule both hosts use, hash each raster's bytes into its
+// url (an edited photo moves its url, so no stale paint survives a reload),
+// and retain immutable bytes for the serving middleware below.
+export function buildSwiftResourceTable(
+  project: SwiftProject,
+  baseUrl: string,
+): SwiftResourceTable {
+  const absolute = resourceCandidateFiles(project.packagePath)
+  const relative = absolute.map((file) =>
+    path.relative(project.packagePath, file).split(path.sep).join(path.posix.sep),
+  )
+  const byRelative = new Map(absolute.map((file, index) => [relative[index], file]))
+  const readContents = (candidate: string): string | null => {
+    const file = byRelative.get(candidate)
+    // catalog json, and the glyph template a symbolset names
+    if (!file || !/(^|\/)Contents\.json$|\.symbolset\/[^/]+\.svg$/.test(candidate))
+      return null
+    return readPackageFile(
+      project.packagePath,
+      file,
+      MAX_SWIFT_COMPILE_RESOURCE_BYTES,
+    ).toString('utf8')
+  }
+  const found = enumerateBundleImages(relative, readContents)
+  const colors = enumerateBundleColors(relative, readContents)
+  const symbols = enumerateBundleSymbols(relative, readContents)
+  const table: Record<string, SwiftImageSource> = {}
+  const images: Record<string, SwiftImageUpload> = {}
+  const watched: string[] = []
+  const registered = new Map<string, { bytes: Buffer; contentType: string }>()
+  let imageBytes = 0
+  for (const { name, file, scale } of found) {
+    const disk = byRelative.get(file)
+    if (!disk) continue
+    if (
+      Object.keys(images).length >= MAX_SWIFT_COMPILE_IMAGES ||
+      imageBytes + fs.statSync(disk).size > MAX_SWIFT_COMPILE_IMAGE_TOTAL_BYTES
+    ) {
+      throw new Error('swift image pack exceeds the compile service caps')
+    }
+    const bytes = readPackageFile(
+      project.packagePath,
+      disk,
+      MAX_SWIFT_COMPILE_IMAGE_BYTES,
+    )
+    imageBytes += bytes.length
+    const hash = createHash('sha256').update(bytes).digest('hex').slice(0, 16)
+    const ext = path.posix.extname(file).toLowerCase()
+    table[name] = { uri: `${baseUrl}${RESOURCE_PATH}${hash}${ext}`, scale }
+    images[name] = {
+      file: path.posix.basename(file),
+      data: bytes.toString('base64'),
+    }
+    watched.push(file)
+    // a Contents.json edit (scale swap, file rename) re-resolves the same
+    // way a raster edit does, so the catalog rides the watcher too.
+    const contents = file.replace(/\/[^/]+$/, '/Contents.json')
+    if (byRelative.has(contents)) watched.push(contents)
+    registered.set(`${hash}${ext}`, {
+      bytes,
+      contentType: RESOURCE_CONTENT_TYPES[ext] ?? 'application/octet-stream',
+    })
+  }
+  // a colorset or symbolset edit re-resolves like an imageset edit.
+  for (const file of relative) {
+    if (file.endsWith('.colorset/Contents.json') || file.includes('.symbolset/'))
+      watched.push(file)
+  }
+  if (
+    registered.size !== project.resourceFiles.size ||
+    [...registered].some(
+      ([key, value]) => !project.resourceFiles.get(key)?.bytes.equals(value.bytes),
+    )
+  ) {
+    project.resourcesPrevious = project.resourceFiles
+    project.resourceFiles = registered
+  }
+  return { table, images, colors, symbols, watched }
+}
+
+// the /res pack: every Resources/ json in the package, basename-keyed and
+// base64, riding the entry module so the mount serves it without a fetch.
+// the namespace is flat like the bundle the wasm side reads: shallower
+// paths pack first (the Resources root is the bundle root) with a lexical
+// tiebreak, and the first spelling of a basename wins a collision. data json
+// bundle caps match the hosted compiler; oversized input refuses before reading.
+const BUNDLE_MAX_FILES = MAX_SWIFT_COMPILE_RESOURCES
+const BUNDLE_MAX_FILE_BYTES = MAX_SWIFT_COMPILE_RESOURCE_BYTES
+const BUNDLE_MAX_TOTAL_BYTES = MAX_SWIFT_COMPILE_RESOURCE_TOTAL_BYTES
+
+export interface SwiftBundlePack {
+  /** basename to base64 bytes for the mount's /res. */
+  files: Record<string, string>
+  /** project-relative json files this load's pack covers (for watching). */
+  watched: string[]
+}
+
+export function buildSwiftBundleFiles(packagePath: string): SwiftBundlePack {
+  packagePath = fs.realpathSync(packagePath)
+  // resourceCandidateFiles walks every non-ignored file with the nested
+  // package exclusion; the shared enumeration decides namespace, order and
+  // collisions, identically for every host that packs.
+  const relative = resourceCandidateFiles(packagePath).map((file) =>
+    path.relative(packagePath, file).split(path.sep).join(path.posix.sep),
+  )
+  const files: Record<string, string> = {}
+  const watched: string[] = []
+  let total = 0
+  for (const { base, file } of enumerateBundleJson(relative)) {
+    watched.push(file)
+    const disk = path.join(packagePath, ...file.split('/'))
+    if (
+      Object.keys(files).length >= BUNDLE_MAX_FILES ||
+      total + fs.statSync(disk).size > BUNDLE_MAX_TOTAL_BYTES
+    ) {
+      throw new Error(
+        `swift bundle pack exceeds ${BUNDLE_MAX_FILES} files / ${BUNDLE_MAX_TOTAL_BYTES} bytes`,
+      )
+    }
+    const bytes = readPackageFile(packagePath, disk, BUNDLE_MAX_FILE_BYTES)
+    files[base] = bytes.toString('base64')
+    total += bytes.length
+  }
+  return { files, watched }
+}
+
+// the middleware's lookup, exported for the producer's own proof: a hit is
+// known bytes for a known hash, anything else is null, never a file.
+export function serveSwiftResource(
+  project: SwiftProject,
+  key: string,
+): { bytes: Buffer; contentType: string } | null {
+  return project.resourceFiles.get(key) ?? project.resourcesPrevious.get(key) ?? null
+}
+
+// the SwiftUI module the project links: its manifest names it as a path
+// dependency, and `swift build` compiles it with the project, so an edit
+// there changes the artifact without moving any of the project's own mtimes.
+export function linkedModuleRoots(packagePath: string): string[] {
+  packagePath = fs.realpathSync(packagePath)
+  let manifest: string
+  try {
+    manifest = readPackageFile(
+      packagePath,
+      path.join(packagePath, 'Package.swift'),
+      MAX_SWIFT_COMPILE_SOURCE_BYTES,
+    ).toString('utf8')
+  } catch {
+    return []
+  }
+  const roots = new Set<string>()
+  const dependency = /\.package\(\s*path:\s*"([^"]+)"\s*\)/g
+  for (const match of manifest.replace(/^\s*\/\/.*$/gm, '').matchAll(dependency)) {
+    const root = path.resolve(packagePath, match[1])
+    if (fs.existsSync(path.join(root, 'Package.swift'))) roots.add(root)
+  }
+  return [...roots].sort()
+}
+
+// the stamp covers every file that contributes to compileInput plus the
+// linked module and toolchain release that the shared artifact hash names. a
+// running dev server rebuilds only when this moves, so its input closure must
+// stay identical to the artifact address's even though this cheap watcher
+// signal hashes mtimes while that stable address hashes content. a checkout
+// restoring byte-identical files rebuilds here and reuses the same address
+// there, by design.
+export function sourceStamp(
+  packagePath: string,
+  moduleRootOverride?: string,
+  hosted = false,
+): string {
+  const hash = createHash('sha256')
+  hash.update(packagePath)
+  const projectInputs = new Set(packageFiles(packagePath))
+  for (const file of [...projectInputs].sort()) {
+    hash.update(path.relative(packagePath, file))
+    const stat = fs.statSync(file)
+    hash.update(`${stat.mtimeMs}/${stat.ctimeMs}/${stat.size}`)
+  }
+  const moduleRoot = hosted
+    ? undefined
+    : (moduleRootOverride ??
+      linkedModuleRoots(packagePath).find((root) =>
+        fs.existsSync(path.join(root, 'toolchain.json')),
+      ))
+  if (moduleRoot) {
+    hash.update(moduleRoot)
+    for (const relative of swiftModuleInputFiles(moduleRoot)) {
+      hash.update(relative)
+      hash.update(String(fs.statSync(path.join(moduleRoot, relative)).mtimeMs))
+    }
+  }
+  return hash.digest('hex').slice(0, 16)
+}
+
+// the registry slot for an entry: the owning package's own name plus the
+// source within it. two packages in one app can hold the same filename, and
+// a bare relative path would share one slot, one instance, and its state.
+// the name travels instead of the path so identical source in two checkouts
+// emits the identical module; two same-named packages sharing one app still
+// collide, and take the rootId override for that.
+export function entryRootId(packagePath: string, file: string): string {
+  const relative = path.relative(packagePath, file).split(path.sep).join(path.posix.sep)
+  return `${path.basename(packagePath)}${path.posix.sep}${relative}`
+}
+
+export function icuUrl(origin: string, artifact: SwiftArtifact): string {
+  return 'url' in artifact.icu
+    ? artifact.icu.url
+    : `${origin}${ICU_PATH}${artifact.icu.sha256}`
+}
+
+function packageSources(packagePath: string): Record<string, string> {
+  const sources = sourceFiles(packagePath)
+  if (sources.length > MAX_SWIFT_COMPILE_FILES)
+    throw new Error('swift source file cap exceeded')
+  let total = 0
+  for (const file of sources) total += fs.statSync(file).size
+  if (total > MAX_SWIFT_COMPILE_SOURCE_BYTES)
+    throw new Error('swift source byte cap exceeded')
+  const files: Record<string, string> = {}
+  for (const file of sources) {
+    const relative = path.relative(packagePath, file).split(path.sep).join(path.posix.sep)
+    files[relative] = readPackageFile(
+      packagePath,
+      file,
+      MAX_SWIFT_COMPILE_SOURCE_BYTES,
+    ).toString('utf8')
+  }
+  return files
+}
+
+interface SwiftPackageSnapshot {
+  files: Record<string, string>
+  resources: SwiftResourceTable
+  bundleFiles: SwiftBundlePack
+  native: SwiftNativeModules | null
+  glue?: string
+}
+
+function packageSnapshot(project: SwiftProject): SwiftPackageSnapshot {
+  const files = packageSources(project.packagePath)
+  const native = nativeSourceDescriptor(project.packagePath)
+  return {
+    files,
+    resources: buildSwiftResourceTable(project, ''),
+    bundleFiles: buildSwiftBundleFiles(project.packagePath),
+    native,
+    ...(native
+      ? {
+          glue: readPackageFile(
+            project.packagePath,
+            path.join(project.packagePath, NATIVE_GLUE),
+            MAX_SWIFT_COMPILE_SOURCE_BYTES,
+          ).toString('utf8'),
+        }
+      : {}),
+  }
+}
+
+function snapshotCompileInput(
+  snapshot: SwiftPackageSnapshot,
+  entry: string,
+): SwiftCompileInput {
+  const input: SwiftCompileInput = {
+    files: snapshot.files,
+    resources: snapshot.bundleFiles.files,
+    images: snapshot.resources.images,
+    entry,
+    oneModule: true,
+  }
+  return snapshot.glue ? withNativeSourceGlue(input, snapshot.glue) : input
+}
+
+export function compileInput(packagePath: string, entry: string): SwiftCompileInput {
+  return snapshotCompileInput(packageSnapshot(projectFor(packagePath)), entry)
+}
+
+async function compile(
+  packagePath: string,
+  entry: string,
+  stamp: string,
+  moduleRootOverride: string | undefined,
+  hosted: SwiftHostedCompileOptions | undefined,
+  snapshot: SwiftPackageSnapshot,
+): Promise<SwiftArtifact> {
+  const resources = {
+    table: snapshot.resources.table,
+    colors: snapshot.resources.colors,
+    symbols: snapshot.resources.symbols,
+    watched: snapshot.resources.watched,
+  }
+  const content = {
+    resources,
+    bundleFiles: snapshot.bundleFiles,
+    native: snapshot.native,
+  }
+  if (hosted)
+    return {
+      ...(await compileRemote(packagePath, entry, snapshot, hosted)),
+      stamp,
+      package: content,
+    }
+  const moduleRoot =
+    moduleRootOverride ??
+    linkedModuleRoots(packagePath).find((root) =>
+      fs.existsSync(path.join(root, 'toolchain.json')),
+    )
+  if (!moduleRoot)
+    return {
+      ...(await compileRemote(packagePath, entry, snapshot)),
+      stamp,
+      package: content,
+    }
+  const toolchain: unknown = JSON.parse(
+    fs.readFileSync(path.join(moduleRoot, 'toolchain.json'), 'utf8'),
+  )
+  const release =
+    toolchain && typeof toolchain === 'object'
+      ? Reflect.get(toolchain, 'release')
+      : undefined
+  if (typeof release !== 'string') {
+    throw new Error(`swift toolchain manifest at ${moduleRoot} has no release`)
+  }
+  const artifact = await compileSwiftProjectUnit(snapshotCompileInput(snapshot, entry), {
+    // 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.
+    buildRoot:
+      process.env.CONTRAST_SWIFT_BUILD_ROOT ??
+      path.join(
+        os.tmpdir(),
+        'contrast-swift-build',
+        createHash('sha256')
+          .update(`${moduleRoot}\0${path.resolve(packagePath)}`)
+          .digest('hex')
+          .slice(0, 16),
+      ),
+    moduleRoot,
+    release,
+    toolchainBin: path.join(
+      os.homedir(),
+      `Library/Developer/Toolchains/${release}.xctoolchain/usr/bin`,
+    ),
+  })
+  return { ...artifact, stamp, package: content }
+}
+
+// an npm-installed peachsim ships neither the SwiftUI module nor a toolchain,
+// so the package compiles where a Contrast project's does: Contrast's compile
+// route, authorized by `peach login` or PEACH_API_KEY. the service renders the
+// native dispatch glue itself under the package's id and answers the wasm at a
+// public content address, which is fetched once and served from this dev
+// server like a local build. resource bytes share the compile snapshot and
+// immutable local asset addresses.
+async function compileRemote(
+  packagePath: string,
+  entry: string,
+  snapshot: SwiftPackageSnapshot,
+  hosted?: SwiftHostedCompileOptions,
+): Promise<Omit<SwiftArtifact, 'stamp' | 'package'>> {
+  const auth = hosted ? null : resolveCliAuth()
+  if (!hosted && (!auth || auth.kind === 'github')) {
+    throw new Error(
+      `compiling ${path.basename(packagePath)} for Peach needs \`peach login\` or PEACH_API_KEY: this peachsim has no local SwiftUI module, so Contrast compiles it`,
+    )
+  }
+  const origin =
+    hosted?.origin ??
+    resolveContrastBackendOrigin(auth?.kind === 'session' ? auth.origin : null)
+  const authorization =
+    hosted?.authorization ?? (auth ? authHeaderValue(auth) : undefined)
+  const signal = AbortSignal.any([
+    ...(hosted ? [hosted.signal] : []),
+    AbortSignal.timeout(5 * 60_000),
+  ])
+  const submit = httpSwiftCompileSubmit({
+    endpoint: origin,
+    authorization,
+    signal,
+  })
+  if (!submit) throw new Error('swift compile: no credential to submit with')
+  const descriptor = snapshot.native
+  const address = await compileSwiftProject(
+    submit,
+    {
+      files: snapshot.files,
+      resources: snapshot.bundleFiles.files,
+      images: snapshot.resources.images,
+      entry,
+      packageId: descriptor?.packageId ?? swiftPackageId(packagePath),
+    },
+    origin,
+    signal,
+  )
+  // 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.
+  if (descriptor && address.native?.hash !== descriptor.hash) {
+    throw new Error(
+      `${path.basename(packagePath)}: Contrast compiled native contract ${address.native?.hash ?? 'none'} but one typegen wrote ${descriptor.hash}; the app's One and the compile host's differ, or the compile host is older than this peachsim`,
+    )
+  }
+  const response = await fetch(address.url, { signal })
+  if (!response.ok) {
+    throw new Error(`swift compile: ${address.url} answered ${response.status}`)
+  }
+  const maxArtifactBytes = 64 * 1024 * 1024
+  if (
+    Number(response.headers.get('content-length')) > maxArtifactBytes ||
+    !response.body
+  ) {
+    throw new Error('swift compile: artifact exceeds 64 MiB or has no body')
+  }
+  const reader = response.body.getReader()
+  const chunks: Uint8Array[] = []
+  let total = 0
+  for (;;) {
+    signal.throwIfAborted()
+    const next = await reader.read()
+    if (next.done) break
+    total += next.value.byteLength
+    if (total > maxArtifactBytes) {
+      await reader.cancel()
+      throw new Error('swift compile: artifact exceeds 64 MiB')
+    }
+    chunks.push(next.value)
+  }
+  return {
+    hash: address.hash,
+    bytes: Buffer.concat(chunks),
+    icu: { url: address.icuUrl },
+  }
+}
+
+export function artifactFor(
+  project: SwiftProject,
+  entry: string,
+  moduleRoot?: string,
+): Promise<SwiftArtifact> {
+  const stamp = sourceStamp(project.packagePath, moduleRoot, Boolean(project.hosted))
+  if (project.artifact?.stamp === stamp) return Promise.resolve(project.artifact)
+  if (project.building) {
+    // a second edit during a build: the build in flight was started from
+    // older sources, so its artifact is not the answer for these. wait it out
+    // and ask again, which starts the build these sources need; joining it
+    // would emit the older artifact and nothing would trigger another load.
+    const running = project.building
+    if (running.stamp === stamp) return running.promise
+    const again = () => artifactFor(project, entry, moduleRoot)
+    return running.promise.then(again, again)
+  }
+  const snapshot = packageSnapshot(project)
+  if (sourceStamp(project.packagePath, moduleRoot, Boolean(project.hosted)) !== stamp) {
+    return artifactFor(project, entry, moduleRoot)
+  }
+  const promise = compile(
+    project.packagePath,
+    entry,
+    stamp,
+    moduleRoot,
+    project.hosted,
+    snapshot,
+  ).then(
+    (artifact) => {
+      project.artifact = artifact
+      project.artifacts = [
+        artifact,
+        ...project.artifacts.filter((old) => old.hash !== artifact.hash),
+      ].slice(0, 2)
+      project.building = null
+      return artifact
+    },
+    (error: unknown) => {
+      project.building = null
+      throw error
+    },
+  )
+  const fresh = promise.then((artifact) =>
+    sourceStamp(project.packagePath, moduleRoot, Boolean(project.hosted)) ===
+    artifact.stamp
+      ? artifact
+      : artifactFor(project, entry, moduleRoot),
+  )
+  project.building = { stamp, promise: fresh }
+  return fresh
+}
+
+export function swiftPackageWatchFiles(
+  packagePath: string,
+  moduleRoot: string | undefined,
+): string[] {
+  packagePath = fs.realpathSync(packagePath)
+  return [
+    path.join(packagePath, 'Package.swift'),
+    ...sourceFiles(packagePath),
+    ...nativeSourceFiles(packagePath),
+    ...resourceCandidateFiles(packagePath),
+    ...(moduleRoot
+      ? swiftModuleInputFiles(moduleRoot).map((file) => path.join(moduleRoot, file))
+      : []),
+  ]
+}
+
+export async function swiftPackageMetadata(
+  packagePath: string,
+  packageName: string,
+  moduleRoot: string | undefined,
+  origin: string,
+  hosted?: SwiftHostedCompileOptions,
+): Promise<SwiftEntryModuleArgs> {
+  packagePath = fs.realpathSync(packagePath)
+  const mains = sourceFiles(packagePath).filter((file) =>
+    /@main\s+(?:public\s+)?struct\s+\w+\s*:/.test(
+      readPackageFile(packagePath, file, MAX_SWIFT_COMPILE_SOURCE_BYTES).toString('utf8'),
+    ),
+  )
+  const native = nativeSourceDescriptor(packagePath)
+  if (mains.length > 1 || (mains.length === 0 && !native)) {
+    throw new Error(
+      `swift package ${packageName} needs exactly one @main source or generated native modules; found ${mains.length}`,
+    )
+  }
+  const project = projectFor(packagePath, hosted)
+  const entry =
+    mains.length === 1
+      ? path.relative(packagePath, mains[0]).split(path.sep).join(path.posix.sep)
+      : Object.entries(native?.files ?? {}).find(
+          ([_file, names]) => names.length > 0,
+        )?.[0]
+  if (!entry) throw new Error(`swift package ${packageName} has no native module source`)
+  const artifact = await artifactFor(project, entry, moduleRoot)
+  const resources = artifact.package.resources
+  const bundleFiles = artifact.package.bundleFiles
+  return {
+    url: `${origin}${ARTIFACT_PATH}${artifact.hash}.wasm`,
+    hash: artifact.hash,
+    icuUrl: icuUrl(origin, artifact),
+    rootId: `${packageName}/${entry}`,
+    resources: Object.fromEntries(
+      Object.entries(resources.table).map(([name, image]) => [
+        name,
+        { ...image, uri: `${origin}${image.uri}` },
+      ]),
+    ),
+    bundleFiles: bundleFiles.files,
+    colors: resources.colors,
+    symbols: resources.symbols,
+    native: artifact.package.native
+      ? {
+          packageId: artifact.package.native.packageId,
+          contractHash: artifact.package.native.hash,
+          modules: artifact.package.native.modules,
+          defaultView: mains.length === 1,
+        }
+      : undefined,
+  }
+}
+
+export function serveSwiftPackageAsset(pathname: string, res: ServerResponse): boolean {
+  if (pathname.startsWith(RESOURCE_PATH)) {
+    for (const project of projects.values()) {
+      const served = serveSwiftResource(project, pathname.slice(RESOURCE_PATH.length))
+      if (!served) continue
+      res.setHeader('access-control-allow-origin', '*')
+      res.setHeader('content-type', served.contentType)
+      res.end(served.bytes)
+      return true
+    }
+    res.statusCode = 404
+    res.end('swift resource is stale')
+    return true
+  }
+  if (pathname.startsWith(ICU_PATH)) {
+    for (const project of projects.values()) {
+      const icu = project.artifacts.find(
+        (artifact) =>
+          'sha256' in artifact.icu && pathname === `${ICU_PATH}${artifact.icu.sha256}`,
+      )?.icu
+      if (!icu || 'url' in icu || pathname !== `${ICU_PATH}${icu.sha256}`) continue
+      // the address is the content, so the browser keeps it across reloads,
+      // restarts and every app built with this toolchain
+      res.setHeader('access-control-allow-origin', '*')
+      res.setHeader('content-type', 'application/gzip')
+      res.setHeader('cache-control', 'public, max-age=31536000, immutable')
+      res.end(icu.gzip)
+      return true
+    }
+    res.statusCode = 404
+    res.end('swift icu data is stale')
+    return true
+  }
+  if (!pathname.startsWith(ARTIFACT_PATH)) return false
+  for (const project of projects.values()) {
+    const artifact = project.artifacts.find(
+      (artifact) => pathname === `${ARTIFACT_PATH}${artifact.hash}.wasm`,
+    )
+    if (!artifact || pathname !== `${ARTIFACT_PATH}${artifact.hash}.wasm`) continue
+    res.setHeader('access-control-allow-origin', '*')
+    res.setHeader('content-type', 'application/wasm')
+    res.end(artifact.bytes)
+    return true
+  }
+  res.statusCode = 404
+  res.end('swift artifact is stale')
+  return true
+}
+
+export function disposeSwiftProject(packagePath: string): void {
+  projects.delete(fs.realpathSync(packagePath))
+}