peachsim 0.1.638 → 0.1.640

package/src/vite-plugin-swift.ts

@@ -1,459 +1,42 @@
-// `.swift` handling for a vite dev server: send the project source set through
-// the same project-unit compiler as `/api/swift-compile`, serve the resulting
-// artifact at a content-hashed url, and answer every `.swift` import with the
-// module that mounts it.
-//
-// two hosts use this. the bundler that builds the app's native bundle runs
-// resolveId/load, and the dev server runs the middleware that serves the
-// artifact. both share the build below, so the artifact is compiled once.
-//
-// the hash covers the same source/module/toolchain inputs as the remote
-// service, so a new hash means a genuinely different app: createSwiftEntry
-// moves the @State store across it instead of remounting.
-
-import { createHash } from 'node:crypto'
+// vite adapts the common Swift package host to native source imports.
 import fs from 'node:fs'
-import os from 'node:os'
 import path from 'node:path'
-import {
-  enumerateBundleColors,
-  enumerateBundleSymbols,
-  enumerateBundleImages,
-  enumerateBundleJson,
-  type SwiftImageSource,
-} from '../../sootsim-swift/src/bundleAssets'
 import { swiftEntryModuleEsm } from '../../sootsim-swift/src/entryModule'
-import { authHeaderValue, resolveCliAuth } from '../cli/auth'
-import { resolveContrastBackendOrigin } from './backend-origin'
 import {
-  compileSwiftProjectUnit,
-  withNativeSourceGlue,
-  swiftModuleInputFiles,
-} from './swift-compile'
-import {
-  compileSwiftProject,
-  httpSwiftCompileSubmit,
-  swiftNativeEntry,
-  type SwiftImageUpload,
-  type SwiftNativeModules,
-} from './swift-submit'
-import type { SwiftEntryModuleArgs } from '../../sootsim-swift/src/entryModule'
-import type { SwiftCompileInput, SwiftIcuAsset } from './swift-compile'
-import type { ServerResponse } from 'node:http'
-import type { SfSymbolVector } from 'peach-engine/ios/sf-symbol-catalog'
-import type { AppCatalogColor } from 'peach-engine/react-native/platform-colors'
+  artifactFor,
+  entryRootId,
+  icuUrl,
+  linkedModuleRoots,
+  nativeSourceDescriptor,
+  nativeSourceFiles,
+  projectFor,
+  serveSwiftPackageAsset,
+  sourceFiles,
+  type SwiftArtifact,
+  type SwiftProject,
+} from './swift-host'
+import { swiftNativeEntry } from './swift-submit'
 import type { Plugin, ViteDevServer } from 'vite'
 
+export {
+  buildSwiftBundleFiles,
+  buildSwiftResourceTable,
+  compileInput,
+  entryRootId,
+  linkedModuleRoots,
+  serveSwiftPackageAsset,
+  serveSwiftResource,
+  sourceStamp,
+  swiftPackageMetadata,
+  swiftPackageWatchFiles,
+  type SwiftBundlePack,
+  type SwiftResourceTable,
+} from './swift-host'
+
 const ARTIFACT_PATH = '/__peach/swift/'
-const RESOURCE_PATH = '/__peach/swift-res/'
-const ICU_PATH = '/__peach/swift-icu/'
 const VIRTUAL_PREFIX = '\0peach-swift:'
-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')
-}
-
-function nativeSourceDescriptor(packagePath: string): SwiftNativeModules | null {
-  const file = path.join(packagePath, NATIVE_DESCRIPTOR)
-  if (!fs.existsSync(file)) return null
-  const value: unknown = JSON.parse(fs.readFileSync(file, '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()
-  }
-  const packageId = Reflect.get(value, 'packageId')
-  const hash = Reflect.get(value, 'hash')
-  const rawFiles: unknown = Reflect.get(value, 'files')
-  const rawModules: unknown = Reflect.get(value, 'modules')
-  const rawDefaults: unknown = Reflect.get(value, 'defaultViewFiles')
-  if (
-    typeof packageId !== 'string' ||
-    typeof hash !== 'string' ||
-    !rawFiles ||
-    typeof rawFiles !== 'object' ||
-    !rawModules ||
-    typeof rawModules !== 'object' ||
-    !Array.isArray(rawDefaults) ||
-    !rawDefaults.every((name) => typeof name === 'string')
-  ) {
-    throw invalid()
-  }
-  const files: Record<string, string[]> = {}
-  const modules: Record<string, string[]> = {}
-  for (const [key, names] of Object.entries(rawFiles)) {
-    if (!Array.isArray(names) || !names.every((name) => typeof name === 'string'))
-      throw invalid()
-    files[key] = names
-  }
-  for (const [key, names] of Object.entries(rawModules)) {
-    if (!Array.isArray(names) || !names.every((name) => typeof name === 'string'))
-      throw invalid()
-    modules[key] = names
-  }
-  if (packageId !== swiftPackageId(packagePath)) {
-    throw new Error(`${file}: invalid One native source descriptor; run one typegen`)
-  }
-  return { packageId, hash, files, modules, defaultViewFiles: rawDefaults }
-}
-
-function nativeSourceFiles(packagePath: string): string[] {
-  return [NATIVE_DESCRIPTOR, NATIVE_GLUE]
-    .map((name) => path.join(packagePath, name))
-    .filter((file) => fs.existsSync(file))
-}
-
-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
-}
-
-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
-  // content hash to absolute path for this load's bundle images: the served
-  // urls name a hash, never a path, so there is nothing to traverse.
-  resourceFiles: Map<string, string>
-}
-
-// 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>()
 let devServer: ViteDevServer | undefined
 
-function projectFor(packagePath: string): SwiftProject {
-  const existing = projects.get(packagePath)
-  if (existing) return existing
-  const created: SwiftProject = {
-    packagePath,
-    artifact: null,
-    building: null,
-    resourceFiles: new Map(),
-  }
-  projects.set(packagePath, created)
-  return created
-}
-
-// the compile unit is the whole package: `swift build` compiles every source
-// in it, so one file's edit can change the artifact for all of them. also
-// used for a linked module below, whose own nested packages are separate
-// units by the same rule.
-function sourceFiles(root: string): string[] {
-  const found: string[] = []
-  const walk = (dir: string): void => {
-    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
-      if (entry.name.startsWith('.') || SKIP_SOURCE_DIRS.has(entry.name)) continue
-      const full = path.join(dir, entry.name)
-      // a nested Package.swift is a separate package with its own compile:
-      // its sources belong to that unit's stamp, not this one's
-      if (entry.isDirectory()) {
-        if (full !== root && fs.existsSync(path.join(full, 'Package.swift'))) continue
-        walk(full)
-      } else if (
-        entry.name.endsWith('.swift') &&
-        (entry.isFile() || (entry.isSymbolicLink() && fs.statSync(full).isFile()))
-      )
-        found.push(full)
-    }
-  }
-  walk(root)
-  return found
-}
-
-// every file that can carry bundle content: catalogs and flat Resources
-// rasters anywhere under the package. `.build` is skipped where sourceFiles
-// does not need to: a release tree holds tens of thousands of files and no
-// bundle content, and walking it per import would tax every hot reload.
-function resourceCandidateFiles(root: string): string[] {
-  const found: string[] = []
-  const walk = (dir: string): void => {
-    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
-      if (
-        entry.name.startsWith('.') ||
-        SKIP_SOURCE_DIRS.has(entry.name) ||
-        entry.name === '.build'
-      )
-        continue
-      const full = path.join(dir, entry.name)
-      if (entry.isDirectory()) {
-        if (full !== root && fs.existsSync(path.join(full, 'Package.swift'))) continue
-        walk(full)
-      } else {
-        found.push(full)
-      }
-    }
-  }
-  walk(root)
-  return found
-}
-
-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 register hash to path 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
-    try {
-      return fs.readFileSync(file, 'utf8')
-    } catch {
-      return null
-    }
-  }
-  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, string>()
-  for (const { name, file, scale } of found) {
-    const disk = byRelative.get(file)
-    if (!disk) continue
-    let bytes: Buffer
-    try {
-      bytes = fs.readFileSync(disk)
-    } catch {
-      continue
-    }
-    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}`, disk)
-  }
-  // 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)
-  }
-  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
-// runs tens of KB, but a string catalog carries every language it ships (a
-// 19-language app catalog measured 2.2MB), which sets the per-file cap: a
-// file past a cap is skipped and named in `skipped` so the load warns
-// instead of silently serving a partial bundle. binary bytes travel the same
-// map when a port reaches past json; the worker half packs text only until
-// then (see the gaps ledger).
-const BUNDLE_MAX_FILES = 128
-const BUNDLE_MAX_FILE_BYTES = 4 * 1024 * 1024
-const BUNDLE_MAX_TOTAL_BYTES = 8 * 1024 * 1024
-
-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[]
-  /** project-relative files skipped by a cap, for the load warning. */
-  skipped: string[]
-}
-
-export function buildSwiftBundleFiles(packagePath: string): SwiftBundlePack {
-  // 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[] = []
-  const skipped: string[] = []
-  let total = 0
-  for (const { base, file } of enumerateBundleJson(relative)) {
-    watched.push(file)
-    let bytes: Buffer
-    try {
-      bytes = fs.readFileSync(path.join(packagePath, ...file.split('/')))
-    } catch {
-      continue
-    }
-    if (bytes.length > BUNDLE_MAX_FILE_BYTES) {
-      skipped.push(`${file} (${bytes.length} bytes past the per-file cap)`)
-      continue
-    }
-    if (
-      Object.keys(files).length >= BUNDLE_MAX_FILES ||
-      total + bytes.length > BUNDLE_MAX_TOTAL_BYTES
-    ) {
-      skipped.push(
-        `${file} (pack caps: ${BUNDLE_MAX_FILES} files / ${BUNDLE_MAX_TOTAL_BYTES} bytes)`,
-      )
-      continue
-    }
-    files[base] = bytes.toString('base64')
-    total += bytes.length
-  }
-  return { files, watched, skipped }
-}
-
-// 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 {
-  const disk = project.resourceFiles.get(key)
-  if (!disk) return null
-  try {
-    return {
-      bytes: fs.readFileSync(disk),
-      contentType:
-        RESOURCE_CONTENT_TYPES[path.extname(disk).toLowerCase()] ??
-        'application/octet-stream',
-    }
-  } catch {
-    return 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[] {
-  let manifest: string
-  try {
-    manifest = fs.readFileSync(path.join(packagePath, 'Package.swift'), '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): string {
-  const hash = createHash('sha256')
-  hash.update(packagePath)
-  const projectInputs = new Set([
-    path.join(packagePath, 'Package.swift'),
-    ...sourceFiles(packagePath),
-    ...nativeSourceFiles(packagePath),
-    ...buildSwiftBundleFiles(packagePath).watched.map((file) =>
-      path.join(packagePath, ...file.split(path.posix.sep)),
-    ),
-    ...buildSwiftResourceTable(projectFor(packagePath), '').watched.map((file) =>
-      path.join(packagePath, ...file.split(path.posix.sep)),
-    ),
-  ])
-  for (const file of [...projectInputs].sort()) {
-    hash.update(path.relative(packagePath, file))
-    hash.update(String(fs.statSync(file).mtimeMs))
-  }
-  const moduleRoot =
-    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}`
-}
-
 // the app fetches from a worker whose origin is the shell, so urls have to
 // name this dev server rather than resolve relative to the shell.
 function serverOrigin(): string {
@@ -468,276 +51,6 @@ function artifactUrl(project: SwiftProject, artifact: SwiftArtifact): string {
   return `${serverOrigin()}${ARTIFACT_PATH}${artifact.hash}.wasm`
 }
 
-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 files: Record<string, string> = {}
-  for (const file of sourceFiles(packagePath)) {
-    const relative = path.relative(packagePath, file).split(path.sep).join(path.posix.sep)
-    files[relative] = fs.readFileSync(file, 'utf8')
-  }
-  const manifest = path.join(packagePath, 'Package.swift')
-  if (fs.existsSync(manifest)) files['Package.swift'] = fs.readFileSync(manifest, 'utf8')
-  return files
-}
-
-export function compileInput(packagePath: string, entry: string): SwiftCompileInput {
-  const input: SwiftCompileInput = {
-    files: packageSources(packagePath),
-    resources: buildSwiftBundleFiles(packagePath).files,
-    images: buildSwiftResourceTable(projectFor(packagePath), '').images,
-    entry,
-    oneModule: true,
-  }
-  return nativeSourceDescriptor(packagePath)
-    ? withNativeSourceGlue(
-        input,
-        fs.readFileSync(path.join(packagePath, NATIVE_GLUE), 'utf8'),
-      )
-    : input
-}
-
-async function compile(
-  packagePath: string,
-  entry: string,
-  stamp: string,
-  moduleRootOverride?: string,
-): Promise<SwiftArtifact> {
-  const moduleRoot =
-    moduleRootOverride ??
-    linkedModuleRoots(packagePath).find((root) =>
-      fs.existsSync(path.join(root, 'toolchain.json')),
-    )
-  if (!moduleRoot) return { ...(await compileRemote(packagePath, entry)), stamp }
-  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(compileInput(packagePath, 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 }
-}
-
-// 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. bundle images, colors and json stay local.
-async function compileRemote(
-  packagePath: string,
-  entry: string,
-): Promise<Omit<SwiftArtifact, 'stamp'>> {
-  const auth = resolveCliAuth()
-  if (!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 = resolveContrastBackendOrigin(
-    auth.kind === 'session' ? auth.origin : null,
-  )
-  const submit = httpSwiftCompileSubmit({
-    endpoint: origin,
-    authorization: authHeaderValue(auth),
-  })
-  if (!submit) throw new Error('swift compile: no credential to submit with')
-  const descriptor = nativeSourceDescriptor(packagePath)
-  const address = await compileSwiftProject(
-    submit,
-    {
-      files: packageSources(packagePath),
-      entry,
-      packageId: descriptor?.packageId ?? swiftPackageId(packagePath),
-    },
-    origin,
-  )
-  // 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)
-  if (!response.ok) {
-    throw new Error(`swift compile: ${address.url} answered ${response.status}`)
-  }
-  return {
-    hash: address.hash,
-    bytes: Buffer.from(await response.arrayBuffer()),
-    icu: { url: address.icuUrl },
-  }
-}
-
-function artifactFor(
-  project: SwiftProject,
-  entry: string,
-  moduleRoot?: string,
-): Promise<SwiftArtifact> {
-  const stamp = sourceStamp(project.packagePath, moduleRoot)
-  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 promise = compile(project.packagePath, entry, stamp, moduleRoot).then(
-    (artifact) => {
-      project.artifact = artifact
-      project.building = null
-      return artifact
-    },
-    (error: unknown) => {
-      project.building = null
-      throw error
-    },
-  )
-  project.building = { stamp, promise }
-  return promise
-}
-
-export function swiftPackageWatchFiles(
-  packagePath: string,
-  moduleRoot: string | undefined,
-): string[] {
-  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,
-): Promise<SwiftEntryModuleArgs> {
-  const mains = sourceFiles(packagePath).filter((file) =>
-    /@main\s+(?:public\s+)?struct\s+\w+\s*:/.test(fs.readFileSync(file, '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)
-  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 = buildSwiftResourceTable(project, origin)
-  const bundleFiles = buildSwiftBundleFiles(packagePath)
-  return {
-    url: `${origin}${ARTIFACT_PATH}${artifact.hash}.wasm`,
-    hash: artifact.hash,
-    icuUrl: icuUrl(origin, artifact),
-    rootId: `${packageName}/${entry}`,
-    resources: resources.table,
-    bundleFiles: bundleFiles.files,
-    colors: resources.colors,
-    symbols: resources.symbols,
-    native: native
-      ? {
-          packageId: native.packageId,
-          contractHash: native.hash,
-          modules: 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.artifact?.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.artifact
-    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
-}
-
 // the swiftpm package that owns an imported file: the nearest directory at
 // or above the file that holds a Package.swift, stopping at the vite root
 // once the dev server has named it. a swift-only project keeps its sources at
@@ -839,45 +152,20 @@ export function swiftPlugin(options: SwiftPluginOptions = {}): Plugin {
         this.warn(error instanceof Error ? error.message : String(error))
         artifact = project.artifact
       }
-      // the bundle image table rides the same module: a photo edit moves
-      // its urls without rebuilding the artifact, and the watched files
-      // re-run this load so the mount sees the new table on hot reload.
-      let resources: Record<string, SwiftImageSource> = {}
-      let colors: Record<string, AppCatalogColor> = {}
-      let symbols: Record<string, SfSymbolVector> = {}
-      try {
-        const built = buildSwiftResourceTable(project, serverOrigin())
-        resources = built.table
-        colors = built.colors
-        symbols = built.symbols
-        for (const watched of built.watched) {
-          this.addWatchFile(path.join(packagePath, ...watched.split(path.posix.sep)))
-        }
-      } catch (error) {
-        this.warn(
-          `swift resources for ${packagePath}: ${error instanceof Error ? error.message : String(error)}`,
-        )
-      }
-      // the /res pack rides the same module as bytes: a json edit moves the
-      // pack, the watched files re-run this load, and the mount's
-      // bundleFiles compare treats it as a new app and remounts through it.
-      let bundleFiles: Record<string, string> = {}
-      try {
-        const packed = buildSwiftBundleFiles(packagePath)
-        bundleFiles = packed.files
-        for (const watched of packed.watched) {
-          this.addWatchFile(path.join(packagePath, ...watched.split(path.posix.sep)))
-        }
-        if (packed.skipped.length > 0) {
-          this.warn(
-            `swift bundle files skipped for ${packagePath}: ${packed.skipped.join('; ')}`,
-          )
-        }
-      } catch (error) {
-        this.warn(
-          `swift bundle files for ${packagePath}: ${error instanceof Error ? error.message : String(error)}`,
-        )
-      }
+      const resources = Object.fromEntries(
+        Object.entries(artifact.package.resources.table).map(([name, image]) => [
+          name,
+          { ...image, uri: `${serverOrigin()}${image.uri}` },
+        ]),
+      )
+      for (const watched of [
+        ...artifact.package.resources.watched,
+        ...artifact.package.bundleFiles.watched,
+      ])
+        this.addWatchFile(path.join(packagePath, ...watched.split(path.posix.sep)))
+      const colors = artifact.package.resources.colors
+      const symbols = artifact.package.resources.symbols
+      const bundleFiles = artifact.package.bundleFiles.files
       // every import mounts through the one entry: the artifact answers
       // whether it is a view or an app root at runtime, so the transform
       // never re-derives the conformance from source. the entry is rooted by