rnxsim 0.1.522 → 0.1.524

package/src/swift.ts

@@ -1,8 +1,7 @@
 // the runtime the `.swift` vite transform emits its module against. the
 // implementation lives beside the toolchain it drives, in sootsim-swift.
 export {
-  createSwiftModule,
-  createSwiftView,
+  createSwiftEntry,
+  type SwiftEntryOptions,
   type SwiftModuleOptions,
-  type SwiftViewOptions,
 } from '../../sootsim-swift/src/mount.tsx'

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'
@@ -16,6 +16,7 @@ import fs from 'node:fs'
 import os from 'node:os'
 import path from 'node:path'
 import { promisify } from 'node:util'
+import { enumerateBundleImages } from '../../sootsim-swift/src/bundleAssets'
 import toolchain from '../../sootsim-swift/toolchain.json'
 import type { Plugin, ViteDevServer } from 'vite'
 
@@ -33,6 +34,7 @@ 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:'
 
 interface SwiftArtifact {
@@ -49,6 +51,9 @@ interface SwiftProject {
   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
@@ -59,7 +64,12 @@ 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 }
+  const created: SwiftProject = {
+    packagePath,
+    artifact: null,
+    building: null,
+    resourceFiles: new Map(),
+  }
   projects.set(packagePath, created)
   return created
 }
@@ -86,6 +96,119 @@ function sourceFiles(root: string): string[] {
   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('.') ||
+        entry.name === 'node_modules' ||
+        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 absolute serving url. */
+  table: Record<string, string>
+  /** project-relative image 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 found = enumerateBundleImages(relative, (candidate) => {
+    const file = byRelative.get(candidate)
+    if (!file || path.basename(file) !== 'Contents.json') return null
+    try {
+      return fs.readFileSync(file, 'utf8')
+    } catch {
+      return null
+    }
+  })
+  const table: Record<string, string> = {}
+  const watched: string[] = []
+  const registered = new Map<string, string>()
+  for (const { name, file } 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] = `${baseUrl}${RESOURCE_PATH}${hash}${ext}`
+    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)
+  }
+  project.resourceFiles = registered
+  return { table, watched }
+}
+
+// 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.
@@ -108,8 +231,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)]) {
@@ -122,21 +249,29 @@ 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
-// url has to name this dev server rather than resolve relative to the shell.
-function artifactUrl(project: SwiftProject, artifact: SwiftArtifact): string {
+// 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 {
   const address = devServer?.httpServer?.address()
   const port =
     address && typeof address === 'object' ? address.port : devServer?.config.server.port
-  if (!port) throw new Error('the swift artifact url needs the dev server port')
-  return `http://localhost:${port}${ARTIFACT_PATH}${artifact.hash}.wasm`
+  if (!port) throw new Error('the swift urls need the dev server port')
+  return `http://localhost:${port}`
+}
+
+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
@@ -261,20 +396,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
@@ -338,21 +459,26 @@ 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')
+      // 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> = {}
+      try {
+        const built = buildSwiftResourceTable(project, serverOrigin())
+        resources = built.table
+        for (const watched of built.watched) this.addWatchFile(watched)
+      } catch (error) {
+        this.warn(
+          `swift resources for ${packagePath}: ${error instanceof Error ? error.message : String(error)}`,
+        )
       }
+      // 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))}, resources: ${JSON.stringify(resources)} })`,
         '',
       ].join('\n')
     },
@@ -362,6 +488,24 @@ export function swiftPlugin(options: SwiftPluginOptions = {}): Plugin {
 
       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