peachsim 0.1.527 → 0.1.571

package/src/vite-plugin-swift.ts

@@ -1,41 +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 toolchain from '../../sootsim-swift/toolchain.json'
+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 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:'
@@ -140,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[]
 }
@@ -167,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) {
@@ -181,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.
@@ -189,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
@@ -292,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)
@@ -338,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`,
-    )
-  }
-  try {
-    await run(
-      swift,
-      [
-        'build',
-        '--package-path',
-        packagePath,
-        '--swift-sdk',
-        WASM_SDK,
-        '-c',
-        'release',
-        '-Xswiftc',
-        '-Osize',
-      ],
-      { maxBuffer: 64 * 1024 * 1024 },
+      `swift project ${packagePath} has no linked rnx SwiftUI package with toolchain.json`,
     )
-  } 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) {
@@ -423,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
@@ -498,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
@@ -512,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
@@ -530,7 +527,9 @@ export function swiftPlugin(options: SwiftPluginOptions = {}): Plugin {
       try {
         const built = buildSwiftResourceTable(project, serverOrigin())
         resources = built.table
-        for (const watched of built.watched) this.addWatchFile(watched)
+        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)}`,
@@ -560,11 +559,13 @@ 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.
-      return [
-        `import { createSwiftEntry } from 'rnxsim/swift'`,
-        `export default createSwiftEntry({ url: ${JSON.stringify(artifactUrl(project, artifact))}, hash: ${JSON.stringify(artifact.hash)}, rootId: ${JSON.stringify(entryRootId(packagePath, file))}, resources: ${JSON.stringify(resources)}, bundleFiles: ${JSON.stringify(bundleFiles)} })`,
-        '',
-      ].join('\n')
+      return swiftEntryModuleEsm({
+        url: artifactUrl(project, artifact),
+        hash: artifact.hash,
+        rootId: entryRootId(packagePath, file),
+        resources,
+        bundleFiles,
+      })
     },
 
     configureServer(server) {

package/src/vite-plugin.ts

@@ -13,7 +13,7 @@ import { createRequire } from 'module'
 import path from 'path'
 import { fileURLToPath } from 'url'
 import { type Plugin, transformWithOxc } from 'vite'
-import { resolveExportsHiddenSubpath } from '../../compat/src/resolve-hidden-subpath.ts'
+import { resolveExportsHiddenSubpath } from '../../peach-compat/src/resolve-hidden-subpath.ts'
 import {
   SOOTSIM_COMPAT_PUBLISHED_BROWSER_ENTRIES,
   SOOTSIM_COMPAT_WRAPPER_REAL_PACKAGES,
@@ -21,7 +21,7 @@ import {
   SOOTSIM_HAPTIC_FEEDBACK_TOUCHABLE_SPECIFIER,
   compatStubsForBuildResolver,
   reactNativeDeepStubsForBuildResolver,
-} from '../../compat/src/stub-manifest.ts'
+} from '../../peach-compat/src/stub-manifest.ts'
 import { resolveSootsimBridgePort } from './bridge-constants.ts'
 import {
   SHELL_BRIDGE_IDENTITY_PATH,
@@ -50,19 +50,32 @@ const sootsimRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '
 const workspaceRoot = path.resolve(sootsimRoot, '..', '..')
 const workspaceNodeModules = path.resolve(workspaceRoot, 'node_modules')
 const workspaceTamaguiDir = path.resolve(workspaceNodeModules, '@tamagui')
-// stubs and the mutable React bridge live in @sootsim/compat.
-const compatRoot = path.resolve(sootsimRoot, '..', 'compat')
+// stubs and the mutable React bridge live in @peach/compat.
+const compatRoot = path.resolve(sootsimRoot, '..', 'peach-compat')
 
 // the rendering engine and its shims live in the private sootsim-engine
 // workspace package. resolve via workspace root rather than relative hops so
 // renames of either package don't break things.
-const engineRoot = path.resolve(workspaceRoot, 'packages/sootsim-engine')
+const engineRoot = path.resolve(workspaceRoot, 'packages/peach-engine')
 const rnShimPath = path.resolve(engineRoot, 'src/react-native/index.ts')
 const reactBridgePath = path.resolve(
   workspaceRoot,
   'packages/contrast-kit/src/react-bridge.ts',
 )
 const sootsimBrowserSourceAliases = [
+  {
+    find: 'peachsim/backend-origin',
+    replacement: path.resolve(sootsimRoot, 'src/backend-origin.ts'),
+  },
+  {
+    find: 'peachsim/bridge-constants',
+    replacement: path.resolve(sootsimRoot, 'src/bridge-constants.ts'),
+  },
+  {
+    find: 'peachsim/dev-bundle-resolution',
+    replacement: path.resolve(sootsimRoot, 'src/dev-bundle-resolution.ts'),
+  },
+  // old specifiers for user code still on rnxsim; remove with packages/sootsim.
   {
     find: 'rnxsim/backend-origin',
     replacement: path.resolve(sootsimRoot, 'src/backend-origin.ts'),
@@ -475,13 +488,13 @@ function rnghUpstreamInternalResolvePlugin(): Plugin {
 export function recordingPluginWorkerRedirect(): Plugin {
   const workerTarget = path.resolve(
     workspaceRoot,
-    'packages/rnx-plugin-recording/src/worker.ts',
+    'packages/peach-plugin-recording/src/worker.ts',
   )
   return {
     name: 'sootsim-recording-plugin-worker-redirect',
     enforce: 'pre',
     resolveId(source) {
-      if (source === '@rnx/plugin-recording') {
+      if (source === '@peach/plugin-recording') {
         return workerTarget
       }
       return null
@@ -542,7 +555,7 @@ const ENGINE_WORKER_BOOT_CLOSURES: WorkerBootClosure[] = [
   // statically instead of require()ing the whole react-native namespace into
   // the boot file.
   { entry: 'src/render-worker/shell-worker-entry.ts', maxBytes: 3_451_000 },
-  { entry: 'src/render-worker/compositor-worker-entry.ts', maxBytes: 1_080_000 },
+  { entry: 'src/render-worker/compositor-worker-entry.ts', maxBytes: 1_085_000 },
   { entry: 'src/render-worker/compositor-worker-ganesh-entry.ts', maxBytes: 1_820_000 },
 ]
 
@@ -670,7 +683,7 @@ export function keyboardControllerBindingsRedirect(): Plugin {
 //
 // per the project policy of not shimming pure-JS libs, we let upstream resolve
 // from node_modules and redirect ONLY the native seam to our compat stub
-// (one file at packages/compat/src/stubs/react-native-reanimated.ts that
+// (one file at packages/peach-compat/src/stubs/react-native-reanimated.ts that
 // exports the right shape — default = turbomodule, named = platform fns).
 //
 // upstream's `assertWorkletsVersion` (DEV-only) imports a build-time script
@@ -1274,11 +1287,11 @@ function reactBridgePlugin(): Plugin {
         // skip during dep scanning / SSR — only active in browser serve mode
         if ((options as { scan?: boolean })?.scan || options?.ssr) return null
 
-        // only redirect imports from sootsim, sootsim-engine, compat, and react-reconciler
+        // only redirect imports from peachsim, peach-engine, peach-compat, and react-reconciler
         const shouldRedirect =
-          importer.includes('/sootsim/src/') ||
-          importer.includes('/sootsim-engine/src/') ||
-          importer.includes('/compat/src/') ||
+          importer.includes('/peachsim/src/') ||
+          importer.includes('/peach-engine/src/') ||
+          importer.includes('/peach-compat/src/') ||
           importer.includes('/contrast-kit/src/') ||
           importer.includes('react-reconciler')
 
@@ -1326,16 +1339,16 @@ export function workerReactBridgePlugin(): Plugin {
         // stub-registry needs the real React (with __CLIENT_INTERNALS) for bundle stubs
         if (importer.includes('stub-registry')) return null
 
-        // redirect react imports from sootsim, sootsim-engine, compat, react-reconciler,
+        // redirect react imports from peachsim, peach-engine, peach-compat, react-reconciler,
         // and any pure-JS RN-ecosystem package the bundle pulls in. without this
         // redirect, packages like react-native-drawer-layout / use-latest-callback
         // call into a separate React instance than the renderer/bridge does, so
         // their useRef/useEffect refs collide with the engine's hooks state and
         // we hit "Maximum update depth exceeded" infinite-loop renders.
         const shouldRedirect =
-          importer.includes('/sootsim/src/') ||
-          importer.includes('/sootsim-engine/src/') ||
-          importer.includes('/compat/src/') ||
+          importer.includes('/peachsim/src/') ||
+          importer.includes('/peach-engine/src/') ||
+          importer.includes('/peach-compat/src/') ||
           importer.includes('/contrast-kit/src/') ||
           importer.includes('react-reconciler') ||
           importer.includes('/node_modules/')

package/src/worklets-babel.ts

@@ -41,8 +41,8 @@ export const REANIMATED_WORKLETIZATION_REGEX = new RegExp(
 // content-gated so most of node_modules skips for free.
 const REANIMATED_IGNORED_PATHS_REGEX =
   /node_modules\/(react|react-dom|react-native|react-native-web)\//
-const SOOTSIM_ENGINE_SRC_PATH = '/packages/sootsim-engine/src/'
-const SOOTSIM_ENGINE_TEST_FIXTURE_PATH = '/packages/sootsim-engine/src/test-fixtures/'
+const SOOTSIM_ENGINE_SRC_PATH = '/packages/peach-engine/src/'
+const SOOTSIM_ENGINE_TEST_FIXTURE_PATH = '/packages/peach-engine/src/test-fixtures/'
 const REANIMATED_IMPORT_REGEX =
   /(?:from\s+['"]react-native-reanimated(?:\/[^'"]*)?['"]|require\(\s*['"]react-native-reanimated(?:\/[^'"]*)?['"]\s*\))/