rnxsim 0.1.521 → 0.1.523

package/src/vite-plugin-swift.ts

@@ -7,7 +7,7 @@
 // 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: createSwiftModule moves the @State store across it instead of
+// different app: createSwiftEntry moves the @State store across it instead of
 // remounting.
 
 import { execFile } from 'node:child_process'
@@ -47,7 +47,8 @@ interface SwiftArtifact {
 interface SwiftProject {
   packagePath: string
   artifact: SwiftArtifact | null
-  building: Promise<SwiftArtifact> | null
+  // the build in flight and the sources it was started from
+  building: { stamp: string; promise: Promise<SwiftArtifact> } | null
 }
 
 // a project is its swiftpm package: the build, the artifact, and the dev
@@ -107,8 +108,12 @@ export function linkedModuleRoots(packagePath: string): string[] {
 // 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. mirrors the compile
-// service's artifact hash, which names the same closure.
+// 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.
 export function sourceStamp(packagePath: string): string {
   const hash = createHash('sha256')
   for (const root of [packagePath, ...linkedModuleRoots(packagePath)]) {
@@ -121,11 +126,15 @@ export function sourceStamp(packagePath: string): string {
   return hash.digest('hex').slice(0, 16)
 }
 
-// the registry slot for a view: the owning package 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.
-export function viewRootId(packagePath: string, file: string): string {
-  return path.join(packagePath, path.relative(packagePath, file))
+// 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 the artifact from a worker whose origin is the shell, so the
@@ -156,6 +165,12 @@ function builtArtifact(packagePath: string): string {
   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)) {
@@ -180,9 +195,24 @@ async function compile(packagePath: string, stamp: string): Promise<SwiftArtifac
       { maxBuffer: 64 * 1024 * 1024 },
     )
   } catch (error) {
-    throw new Error(
-      `swift build failed for ${packagePath}\n${error instanceof Error ? error.message : String(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 {
@@ -195,7 +225,17 @@ async function compile(packagePath: string, stamp: string): Promise<SwiftArtifac
 function artifactFor(project: SwiftProject): Promise<SwiftArtifact> {
   const stamp = sourceStamp(project.packagePath)
   if (project.artifact?.stamp === stamp) return Promise.resolve(project.artifact)
-  project.building ??= compile(project.packagePath, stamp).then(
+  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)
+    return running.promise.then(again, again)
+  }
+  const promise = compile(project.packagePath, stamp).then(
     (artifact) => {
       project.artifact = artifact
       project.building = null
@@ -206,7 +246,8 @@ function artifactFor(project: SwiftProject): Promise<SwiftArtifact> {
       throw error
     },
   )
-  return project.building
+  project.building = { stamp, promise }
+  return promise
 }
 
 // the swiftpm package that owns an imported file: the nearest directory at
@@ -228,20 +269,6 @@ function packageFor(file: string): string {
   )
 }
 
-// whether the package mounts as a view: its @main type conforms to
-// RNXPackage instead of to App. the symbol graph is the exact read once the
-// transform emits one; until then the conformance on the @main declaration is
-// unambiguous, comments aside.
-function isViewPackage(packagePath: string): boolean {
-  const main =
-    /@main\s+(?:\w+\s+)*(?:struct|class|enum|actor)\s+\w+[^{]*:\s*[^{]*\bRNXPackage\b/
-  for (const file of sourceFiles(packagePath)) {
-    const text = fs.readFileSync(file, 'utf8').replace(/^\s*\/\/.*$/gm, '')
-    if (main.test(text)) return true
-  }
-  return false
-}
-
 export interface SwiftPluginOptions {
   // swiftpm package that owns the project's .swift sources. defaults to the
   // nearest Package.swift above each imported file, which is the vite root
@@ -274,6 +301,10 @@ export function swiftPlugin(options: SwiftPluginOptions = {}): Plugin {
     async load(id) {
       if (!id.startsWith(VIRTUAL_PREFIX)) return null
       const file = id.slice(VIRTUAL_PREFIX.length)
+      // the module is the whole package's artifact, so an import of a file
+      // that was deleted would keep answering with it. a deleted .tsx fails
+      // its importer; so does a deleted .swift.
+      if (!fs.existsSync(file)) throw new Error(`swift source ${file} no longer exists`)
       const packagePath = options.packagePath ?? packageFor(file)
       const project = projectFor(packagePath)
       // every source in the package is a dependency of this module, so a
@@ -301,21 +332,13 @@ export function swiftPlugin(options: SwiftPluginOptions = {}): Plugin {
         this.warn(error instanceof Error ? error.message : String(error))
         artifact = project.artifact
       }
-      // a view package mounts into its importer: the default export is the
-      // view component, rooted by its package and source path so a hot reload
-      // finds the same instance. an app package keeps the root component it
-      // always had.
-      if (isViewPackage(packagePath)) {
-        const rootId = viewRootId(packagePath, file)
-        return [
-          `import { createSwiftView } from 'rnxsim/swift'`,
-          `export default createSwiftView({ url: ${JSON.stringify(artifactUrl(project, artifact))}, hash: ${JSON.stringify(artifact.hash)}, rootId: ${JSON.stringify(rootId)} })`,
-          '',
-        ].join('\n')
-      }
+      // 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
+      // its package and source path so a hot reload finds the same instance.
       return [
-        `import { createSwiftModule } from 'rnxsim/swift'`,
-        `export default createSwiftModule({ url: ${JSON.stringify(artifactUrl(project, artifact))}, hash: ${JSON.stringify(artifact.hash)} })`,
+        `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))} })`,
         '',
       ].join('\n')
     },
@@ -332,24 +355,23 @@ export function swiftPlugin(options: SwiftPluginOptions = {}): Plugin {
         // 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.
-        void (async () => {
-          for (const project of projects.values()) {
-            const artifact = await artifactFor(project)
-            if (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
-            }
+        // 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')
-        })().catch((error: unknown) => {
-          res.statusCode = 500
-          res.end(error instanceof Error ? error.message : String(error))
-        })
+        }
+        res.statusCode = 404
+        res.end('swift artifact is stale')
       })
     },
   }