peachsim 0.1.570 → 0.1.571

package/src/vite-plugin-swift.ts

@@ -1,42 +1,30 @@
-// `.swift` handling for a vite dev server: compile the project's swift sources
-// with the swift.org toolchain, serve the artifact at a content-hashed url,
-// and answer every `.swift` import with the module that mounts it.
+// `.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 is the hash of the built wasm, so a new hash means a genuinely
-// different app: createSwiftEntry moves the @State store across it instead of
-// remounting.
+// 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 { execFile } from 'node:child_process'
 import { createHash } from 'node:crypto'
 import fs from 'node:fs'
 import os from 'node:os'
 import path from 'node:path'
-import { promisify } from 'node:util'
 import {
   enumerateBundleImages,
   enumerateBundleJson,
 } from '../../sootsim-swift/src/bundleAssets'
 import { swiftEntryModuleEsm } from '../../sootsim-swift/src/entryModule'
-import toolchain from '../../sootsim-swift/toolchain.json'
+import { compileSwiftProjectUnit, swiftModuleInputFiles } from './swift-compile'
+import type { SwiftCompileInput } from './swift-compile'
+import type { SwiftImageUpload } from './swift-submit'
 import type { Plugin, ViteDevServer } from 'vite'
 
-const run = promisify(execFile)
-
-// the swift.org release scripts/build.sh builds with, from the one place it is
-// named: the toolchain is <release>.xctoolchain and its matching wasm sdk is
-// <release>_wasm. xcode's swift has no wasm backend, so this toolchain is the
-// only one that can build the target.
-const TOOLCHAIN_BIN = path.join(
-  os.homedir(),
-  `Library/Developer/Toolchains/${toolchain.release}.xctoolchain/usr/bin`,
-)
-const WASM_SDK = `${toolchain.release}_wasm`
-const WASM_TRIPLE = 'wasm32-unknown-wasip1'
-
 const ARTIFACT_PATH = '/__rnx/swift/'
 const RESOURCE_PATH = '/__rnx/swift-res/'
 const VIRTUAL_PREFIX = '\0rnx-swift:'
@@ -141,6 +129,8 @@ const RESOURCE_CONTENT_TYPES: Record<string, string> = {
 export interface SwiftResourceTable {
   /** bundle asset name to absolute serving url. */
   table: Record<string, string>
+  /** the same rasters as compile-address inputs. */
+  images: Record<string, SwiftImageUpload>
   /** project-relative image files this load's table covers (for watching). */
   watched: string[]
 }
@@ -168,6 +158,7 @@ export function buildSwiftResourceTable(
     }
   })
   const table: Record<string, string> = {}
+  const images: Record<string, SwiftImageUpload> = {}
   const watched: string[] = []
   const registered = new Map<string, string>()
   for (const { name, file } of found) {
@@ -182,6 +173,10 @@ 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}`
+    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.
@@ -190,7 +185,7 @@ export function buildSwiftResourceTable(
     registered.set(`${hash}${ext}`, disk)
   }
   project.resourceFiles = registered
-  return { table, watched }
+  return { table, images, watched }
 }
 
 // the /res pack: every Resources/ json in the package, basename-keyed and
@@ -293,22 +288,41 @@ export function linkedModuleRoots(packagePath: string): string[] {
   return [...roots].sort()
 }
 
-// the stamp covers the project plus the modules it links: a running dev
-// server rebuilds only when this moves, so leaving the linked sources out
-// would keep serving the artifact built before a SwiftUI module edit for as
-// long as the project's own sources stayed the same. it names the same
-// closure the compile service's artifact hash names, but it is not the same
-// function: the stamp hashes mtimes, which is the cheap rebuild signal for a
-// watcher, while the artifact address hashes content, which is what stays
-// stable when a checkout restores byte-identical files. a restore rebuilds
-// here and reuses the stored artifact there, by design.
+// 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): string {
   const hash = createHash('sha256')
-  for (const root of [packagePath, ...linkedModuleRoots(packagePath)]) {
-    hash.update(root)
-    for (const file of sourceFiles(root).sort()) {
-      hash.update(path.relative(root, file))
-      hash.update(String(fs.statSync(file).mtimeMs))
+  hash.update(packagePath)
+  const projectInputs = new Set([
+    path.join(packagePath, 'Package.swift'),
+    ...sourceFiles(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 = 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()) {
+      hash.update(relative)
+      hash.update(String(fs.statSync(path.join(moduleRoot, relative)).mtimeMs))
     }
   }
   return hash.digest('hex').slice(0, 16)
@@ -339,82 +353,62 @@ function artifactUrl(project: SwiftProject, artifact: SwiftArtifact): string {
   return `${serverOrigin()}${ARTIFACT_PATH}${artifact.hash}.wasm`
 }
 
-// one executable is the app. a package with several is ambiguous: the host
-// cannot know which one the page is, so it says so instead of guessing.
-function builtArtifact(packagePath: string): string {
-  const binDir = path.join(packagePath, '.build', WASM_TRIPLE, 'release')
-  const artifacts = fs.existsSync(binDir)
-    ? fs
-        .readdirSync(binDir)
-        .filter((name) => name.endsWith('.wasm'))
-        .sort()
-    : []
-  if (artifacts.length !== 1) {
-    throw new Error(
-      `swift project ${packagePath} built ${artifacts.length} wasm artifacts; exactly one executable is the app`,
-    )
+function compileInput(packagePath: string, entry: string): SwiftCompileInput {
+  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')
+  const resources = buildSwiftBundleFiles(packagePath).files
+  const images = buildSwiftResourceTable(projectFor(packagePath), '').images
+  return {
+    files,
+    resources,
+    images,
+    entry,
   }
-  return path.join(binDir, artifacts[0])
-}
-
-function streamText(value: unknown): string {
-  if (typeof value === 'string') return value.trim()
-  if (Buffer.isBuffer(value)) return value.toString('utf8').trim()
-  return ''
 }
 
-async function compile(packagePath: string, stamp: string): Promise<SwiftArtifact> {
-  const swift = path.join(TOOLCHAIN_BIN, 'swift')
-  if (!fs.existsSync(swift)) {
+async function compile(
+  packagePath: string,
+  entry: string,
+  stamp: string,
+): Promise<SwiftArtifact> {
+  const moduleRoot = linkedModuleRoots(packagePath).find((root) =>
+    fs.existsSync(path.join(root, 'toolchain.json')),
+  )
+  if (!moduleRoot) {
     throw new Error(
-      `no swift.org toolchain at ${TOOLCHAIN_BIN}. install it and the ${WASM_SDK} sdk; see packages/sootsim-swift/README.md`,
+      `swift project ${packagePath} has no linked rnx SwiftUI package with toolchain.json`,
     )
   }
-  try {
-    await run(
-      swift,
-      [
-        'build',
-        '--package-path',
-        packagePath,
-        '--swift-sdk',
-        WASM_SDK,
-        '-c',
-        'release',
-        '-Xswiftc',
-        '-Osize',
-      ],
-      { maxBuffer: 64 * 1024 * 1024 },
-    )
-  } catch (error) {
-    // `swift build` prints the compiler's diagnostics on stdout and swiftpm's
-    // own on stderr; the failure's message holds only the command line, so
-    // both streams are what names the line that broke. stdout leads because
-    // compiler diagnostics are what the editor needs to show.
-    const streams =
-      error && typeof error === 'object'
-        ? [
-            streamText(Reflect.get(error, 'stdout')),
-            streamText(Reflect.get(error, 'stderr')),
-          ].filter(Boolean)
-        : []
-    const detail =
-      streams.length > 0
-        ? streams.join('\n')
-        : error instanceof Error
-          ? error.message
-          : String(error)
-    throw new Error(`swift build failed for ${packagePath}\n${detail}`)
-  }
-  const bytes = fs.readFileSync(builtArtifact(packagePath))
-  return {
-    hash: createHash('sha256').update(bytes).digest('hex').slice(0, 16),
-    bytes,
-    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), {
+    buildRoot:
+      process.env.CONTRAST_SWIFT_BUILD_ROOT ??
+      path.join(os.tmpdir(), 'contrast-swift-build'),
+    moduleRoot,
+    release,
+    toolchainBin: path.join(
+      os.homedir(),
+      `Library/Developer/Toolchains/${release}.xctoolchain/usr/bin`,
+    ),
+  })
+  return { ...artifact, stamp }
 }
 
-function artifactFor(project: SwiftProject): Promise<SwiftArtifact> {
+function artifactFor(project: SwiftProject, entry: string): Promise<SwiftArtifact> {
   const stamp = sourceStamp(project.packagePath)
   if (project.artifact?.stamp === stamp) return Promise.resolve(project.artifact)
   if (project.building) {
@@ -424,10 +418,10 @@ function artifactFor(project: SwiftProject): Promise<SwiftArtifact> {
     // 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)
+    const again = () => artifactFor(project, entry)
     return running.promise.then(again, again)
   }
-  const promise = compile(project.packagePath, stamp).then(
+  const promise = compile(project.packagePath, entry, stamp).then(
     (artifact) => {
       project.artifact = artifact
       project.building = null
@@ -499,11 +493,13 @@ export function swiftPlugin(options: SwiftPluginOptions = {}): Plugin {
       if (!fs.existsSync(file)) throw new Error(`swift source ${file} no longer exists`)
       const packagePath = options.packagePath ?? packageFor(file)
       const project = projectFor(packagePath)
+      const entry = path.relative(packagePath, file).split(path.sep).join(path.posix.sep)
       // every source in the package is a dependency of this module, so a
       // 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)
+      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
       // too: the new hash in the emitted module is what tells the mount it
@@ -513,7 +509,7 @@ export function swiftPlugin(options: SwiftPluginOptions = {}): Plugin {
       }
       let artifact: SwiftArtifact
       try {
-        artifact = await artifactFor(project)
+        artifact = await artifactFor(project, entry)
       } catch (error) {
         // a compile error must not fail this module. a module whose load threw
         // leaves the graph unwatched, so the edit that fixes the error would