peachsim 0.1.578 → 0.1.580

package/src/vite-plugin-swift.ts

@@ -16,22 +16,119 @@ 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 { compileSwiftProjectUnit, swiftModuleInputFiles } from './swift-compile'
-import type { SwiftCompileInput } from './swift-compile'
-import type { SwiftImageUpload } from './swift-submit'
+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'
 import type { Plugin, ViteDevServer } from 'vite'
 
 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.
@@ -74,14 +171,18 @@ 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('.') || entry.name === 'node_modules') continue
+      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')) found.push(full)
+      } else if (
+        entry.name.endsWith('.swift') &&
+        (entry.isFile() || (entry.isSymbolicLink() && fs.statSync(full).isFile()))
+      )
+        found.push(full)
     }
   }
   walk(root)
@@ -98,7 +199,7 @@ function resourceCandidateFiles(root: string): string[] {
     for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
       if (
         entry.name.startsWith('.') ||
-        entry.name === 'node_modules' ||
+        SKIP_SOURCE_DIRS.has(entry.name) ||
         entry.name === '.build'
       )
         continue
@@ -127,11 +228,14 @@ const RESOURCE_CONTENT_TYPES: Record<string, string> = {
 }
 
 export interface SwiftResourceTable {
-  /** bundle asset name to absolute serving url. */
-  table: Record<string, string>
+  /** 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>
-  /** project-relative image files this load's table covers (for watching). */
+  /** 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[]
 }
 
@@ -148,20 +252,25 @@ export function buildSwiftResourceTable(
     path.relative(project.packagePath, file).split(path.sep).join(path.posix.sep),
   )
   const byRelative = new Map(absolute.map((file, index) => [relative[index], file]))
-  const found = enumerateBundleImages(relative, (candidate) => {
+  const readContents = (candidate: string): string | null => {
     const file = byRelative.get(candidate)
-    if (!file || path.basename(file) !== 'Contents.json') return null
+    // 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 table: Record<string, string> = {}
+  }
+  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 } of found) {
+  for (const { name, file, scale } of found) {
     const disk = byRelative.get(file)
     if (!disk) continue
     let bytes: Buffer
@@ -172,7 +281,7 @@ export function buildSwiftResourceTable(
     }
     const hash = createHash('sha256').update(bytes).digest('hex').slice(0, 16)
     const ext = path.posix.extname(file).toLowerCase()
-    table[name] = `${baseUrl}${RESOURCE_PATH}${hash}${ext}`
+    table[name] = { uri: `${baseUrl}${RESOURCE_PATH}${hash}${ext}`, scale }
     images[name] = {
       file: path.posix.basename(file),
       data: bytes.toString('base64'),
@@ -184,22 +293,28 @@ export function buildSwiftResourceTable(
     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, watched }
+  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. caps are
-// INFERRED (no app in either rung is near them; landmarkData-scale json is
-// tens of KB): a file past them 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).
+// 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 = 2 * 1024 * 1024
+const BUNDLE_MAX_FILE_BYTES = 4 * 1024 * 1024
 const BUNDLE_MAX_TOTAL_BYTES = 8 * 1024 * 1024
 
 export interface SwiftBundlePack {
@@ -295,12 +410,13 @@ export function linkedModuleRoots(packagePath: string): string[] {
 // 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): string {
+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)),
     ),
@@ -312,15 +428,14 @@ export function sourceStamp(packagePath: string): string {
     hash.update(path.relative(packagePath, file))
     hash.update(String(fs.statSync(file).mtimeMs))
   }
-  const moduleRoot = linkedModuleRoots(packagePath).find((root) =>
-    fs.existsSync(path.join(root, 'toolchain.json')),
-  )
+  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),
-      'toolchain.json',
-    ].sort()) {
+    for (const relative of swiftModuleInputFiles(moduleRoot)) {
       hash.update(relative)
       hash.update(String(fs.statSync(path.join(moduleRoot, relative)).mtimeMs))
     }
@@ -353,7 +468,13 @@ function artifactUrl(project: SwiftProject, artifact: SwiftArtifact): string {
   return `${serverOrigin()}${ARTIFACT_PATH}${artifact.hash}.wasm`
 }
 
-function compileInput(packagePath: string, entry: string): SwiftCompileInput {
+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)
@@ -361,29 +482,37 @@ function compileInput(packagePath: string, entry: string): SwiftCompileInput {
   }
   const manifest = path.join(packagePath, 'Package.swift')
   if (fs.existsSync(manifest)) files['Package.swift'] = fs.readFileSync(manifest, 'utf8')
-  const resources = buildSwiftBundleFiles(packagePath).files
-  const images = buildSwiftResourceTable(projectFor(packagePath), '').images
-  return {
-    files,
-    resources,
-    images,
+  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 = linkedModuleRoots(packagePath).find((root) =>
-    fs.existsSync(path.join(root, 'toolchain.json')),
-  )
-  if (!moduleRoot) {
-    throw new Error(
-      `swift project ${packagePath} has no linked rnx SwiftUI package with toolchain.json`,
+  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'),
   )
@@ -395,9 +524,21 @@ async function compile(
     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'),
+      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(
@@ -408,8 +549,64 @@ async function compile(
   return { ...artifact, stamp }
 }
 
-function artifactFor(project: SwiftProject, entry: string): Promise<SwiftArtifact> {
-  const stamp = sourceStamp(project.packagePath)
+// 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
@@ -418,10 +615,10 @@ function artifactFor(project: SwiftProject, entry: string): Promise<SwiftArtifac
     // 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)
+    const again = () => artifactFor(project, entry, moduleRoot)
     return running.promise.then(again, again)
   }
-  const promise = compile(project.packagePath, entry, stamp).then(
+  const promise = compile(project.packagePath, entry, stamp, moduleRoot).then(
     (artifact) => {
       project.artifact = artifact
       project.building = null
@@ -436,6 +633,111 @@ function artifactFor(project: SwiftProject, entry: string): Promise<SwiftArtifac
   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
@@ -481,7 +783,20 @@ export function swiftPlugin(options: SwiftPluginOptions = {}): Plugin {
       if (!source.endsWith('.swift')) return null
       const resolved = await this.resolve(source, importer, { skipSelf: true })
       if (!resolved) throw new Error(`cannot resolve swift source ${source}`)
-      return VIRTUAL_PREFIX + resolved.id
+      // a symlinked source (the showcase app links the files Xcode builds)
+      // resolves to its target, and the package walk then finds the target's
+      // package instead of the importing one. keep the importer's own path
+      // when it names the same file, so the import's package owns the compile.
+      let id = resolved.id
+      if (importer && (source.startsWith('./') || source.startsWith('../'))) {
+        const raw = path.resolve(path.dirname(importer.split('?')[0] ?? importer), source)
+        try {
+          if (fs.realpathSync(raw) === fs.realpathSync(resolved.id)) id = raw
+        } catch {
+          // fall through with the resolver's answer
+        }
+      }
+      return VIRTUAL_PREFIX + id
     },
 
     async load(id) {
@@ -498,7 +813,11 @@ export function swiftPlugin(options: SwiftPluginOptions = {}): Plugin {
       // bundler watching this module learns about a `.swift` edit and re-runs
       // load. that is the whole hot reload: the new hash in the emitted module
       // is what tells the mount it is looking at a different app.
-      for (const source of sourceFiles(packagePath)) this.addWatchFile(source)
+      for (const source of [
+        ...sourceFiles(packagePath),
+        ...nativeSourceFiles(packagePath),
+      ])
+        this.addWatchFile(source)
       this.addWatchFile(path.join(packagePath, 'Package.swift'))
       // an edit to the linked SwiftUI module rebuilds the artifact without
       // touching the project's own sources, so those files gate the reload
@@ -523,10 +842,14 @@ export function swiftPlugin(options: SwiftPluginOptions = {}): Plugin {
       // 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, string> = {}
+      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)))
         }
@@ -559,12 +882,17 @@ export function swiftPlugin(options: SwiftPluginOptions = {}): Plugin {
       // 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
       // its package and source path so a hot reload finds the same instance.
+      const native = nativeSourceDescriptor(packagePath)
       return swiftEntryModuleEsm({
         url: artifactUrl(project, artifact),
         hash: artifact.hash,
+        icuUrl: icuUrl(serverOrigin(), artifact),
         rootId: entryRootId(packagePath, file),
         resources,
         bundleFiles,
+        colors,
+        symbols,
+        native: native ? swiftNativeEntry(native, entry) : undefined,
       })
     },
 
@@ -572,49 +900,7 @@ export function swiftPlugin(options: SwiftPluginOptions = {}): Plugin {
       devServer = server
 
       server.middlewares.use((req, res, next) => {
-        const url = (req.url ?? '').split('?')[0]
-        if (url.startsWith(RESOURCE_PATH)) {
-          // hash-addressed: the table this load emitted names these hashes,
-          // so a hit serves known bytes and anything else is a 404, never a
-          // neighboring file. the tenant worker is cross-origin like the
-          // artifact fetch, hence the same cors header.
-          for (const project of projects.values()) {
-            const served = serveSwiftResource(project, url.slice(RESOURCE_PATH.length))
-            if (served) {
-              res.setHeader('access-control-allow-origin', '*')
-              res.setHeader('content-type', served.contentType)
-              res.end(served.bytes)
-              return
-            }
-          }
-          res.statusCode = 404
-          res.end('swift resource is stale')
-          return
-        }
-        if (!url.startsWith(ARTIFACT_PATH)) {
-          next()
-          return
-        }
-        // the url names a content hash, not a package: the request is answered
-        // by whichever known project built it, so a React Native app whose
-        // swift package sits below its root serves the same path its imports
-        // compiled. served from what is already built, never rebuilt here: the
-        // page only knows a hash that `load` emitted, and `load` under a compile
-        // error emits the last good hash, whose bytes are still the project's
-        // artifact. rebuilding would fail that fetch with the compile error and
-        // fail every other project's artifact with it.
-        for (const project of projects.values()) {
-          const artifact = project.artifact
-          if (artifact && url === `${ARTIFACT_PATH}${artifact.hash}.wasm`) {
-            // the tenant worker's origin is the shell, never this dev server
-            res.setHeader('access-control-allow-origin', '*')
-            res.setHeader('content-type', 'application/wasm')
-            res.end(artifact.bytes)
-            return
-          }
-        }
-        res.statusCode = 404
-        res.end('swift artifact is stale')
+        if (!serveSwiftPackageAsset((req.url ?? '').split('?')[0], res)) next()
       })
     },
   }