rnxsim 0.1.506 → 0.1.508

package/dist-lib/vite.cjs

@@ -1,4 +1,4 @@
-/*! rnx v0.1.506 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+/*! rnx v0.1.508 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
 let __sootsim_import_meta_url = ''; try { __sootsim_import_meta_url = require('url').pathToFileURL(__filename).href; } catch {}
 "use strict";
 var __create = Object.create;
@@ -34,11 +34,12 @@ var vite_plugin_one_exports = {};
 __export(vite_plugin_one_exports, {
   default: () => vite_plugin_one_default,
   rnxPlugin: () => rnxPlugin,
-  sootsimPlugin: () => sootsimPlugin
+  sootsimPlugin: () => sootsimPlugin,
+  swiftPlugin: () => swiftPlugin
 });
 module.exports = __toCommonJS(vite_plugin_one_exports);
 var import_fs2 = __toESM(require("fs"), 1);
-var import_node_crypto2 = require("node:crypto");
+var import_node_crypto3 = require("node:crypto");
 var import_path2 = __toESM(require("path"), 1);
 
 // src/bridge-constants.ts
@@ -748,6 +749,184 @@ function serveRuntimeFile(req, res, fullPath) {
   import_fs.default.createReadStream(fullPath).pipe(res);
 }
 
+// src/vite-plugin-swift.ts
+var import_node_child_process2 = require("node:child_process");
+var import_node_crypto2 = require("node:crypto");
+var import_node_fs3 = __toESM(require("node:fs"), 1);
+var import_node_os2 = __toESM(require("node:os"), 1);
+var import_node_path4 = __toESM(require("node:path"), 1);
+var import_node_util = require("node:util");
+var run = (0, import_node_util.promisify)(import_node_child_process2.execFile);
+var TOOLCHAIN_BIN = import_node_path4.default.join(
+  import_node_os2.default.homedir(),
+  "Library/Developer/Toolchains/swift-6.2-RELEASE.xctoolchain/usr/bin"
+);
+var WASM_SDK = "swift-6.2-RELEASE_wasm";
+var WASM_TRIPLE = "wasm32-unknown-wasip1";
+var ARTIFACT_PATH = "/__rnx/swift/";
+var VIRTUAL_PREFIX = "\0rnx-swift:";
+var projects = /* @__PURE__ */ new Map();
+var devServer;
+function projectFor(packagePath) {
+  const existing = projects.get(packagePath);
+  if (existing) return existing;
+  const created = { packagePath, artifact: null, building: null };
+  projects.set(packagePath, created);
+  return created;
+}
+function rootFor(file) {
+  return devServer?.config.root ?? import_node_path4.default.dirname(file);
+}
+function sourceFiles(packagePath) {
+  const found = [];
+  const walk = (dir) => {
+    for (const entry of import_node_fs3.default.readdirSync(dir, { withFileTypes: true })) {
+      if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
+      const full = import_node_path4.default.join(dir, entry.name);
+      if (entry.isDirectory()) walk(full);
+      else if (entry.name.endsWith(".swift")) found.push(full);
+    }
+  };
+  walk(packagePath);
+  return found;
+}
+function sourceStamp(packagePath) {
+  const hash = (0, import_node_crypto2.createHash)("sha256");
+  for (const file of sourceFiles(packagePath).sort()) {
+    hash.update(import_node_path4.default.relative(packagePath, file));
+    hash.update(String(import_node_fs3.default.statSync(file).mtimeMs));
+  }
+  return hash.digest("hex").slice(0, 16);
+}
+function artifactUrl(project, artifact) {
+  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`;
+}
+function builtArtifact(packagePath) {
+  const binDir = import_node_path4.default.join(packagePath, ".build", WASM_TRIPLE, "release");
+  const artifacts = import_node_fs3.default.existsSync(binDir) ? import_node_fs3.default.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`
+    );
+  }
+  return import_node_path4.default.join(binDir, artifacts[0]);
+}
+async function compile(packagePath, stamp) {
+  const swift = import_node_path4.default.join(TOOLCHAIN_BIN, "swift");
+  if (!import_node_fs3.default.existsSync(swift)) {
+    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 }
+    );
+  } catch (error) {
+    throw new Error(
+      `swift build failed for ${packagePath}
+${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  const bytes = import_node_fs3.default.readFileSync(builtArtifact(packagePath));
+  return {
+    hash: (0, import_node_crypto2.createHash)("sha256").update(bytes).digest("hex").slice(0, 16),
+    bytes,
+    stamp
+  };
+}
+function artifactFor(project) {
+  const stamp = sourceStamp(project.packagePath);
+  if (project.artifact?.stamp === stamp) return Promise.resolve(project.artifact);
+  project.building ??= compile(project.packagePath, stamp).then(
+    (artifact) => {
+      project.artifact = artifact;
+      project.building = null;
+      return artifact;
+    },
+    (error) => {
+      project.building = null;
+      throw error;
+    }
+  );
+  return project.building;
+}
+function swiftPlugin(options = {}) {
+  const packagePathFor = (file) => options.packagePath ?? rootFor(file);
+  return {
+    name: "rnx-swift",
+    enforce: "pre",
+    async resolveId(source, importer) {
+      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;
+    },
+    async load(id) {
+      if (!id.startsWith(VIRTUAL_PREFIX)) return null;
+      const packagePath = packagePathFor(id.slice(VIRTUAL_PREFIX.length));
+      const project = projectFor(packagePath);
+      for (const source of sourceFiles(packagePath)) this.addWatchFile(source);
+      let artifact;
+      try {
+        artifact = await artifactFor(project);
+      } catch (error) {
+        if (!project.artifact) throw error;
+        this.warn(error instanceof Error ? error.message : String(error));
+        artifact = project.artifact;
+      }
+      return [
+        `import { createSwiftModule } from 'rnxsim/swift'`,
+        `export default createSwiftModule({ url: ${JSON.stringify(artifactUrl(project, artifact))}, hash: ${JSON.stringify(artifact.hash)} })`,
+        ""
+      ].join("\n");
+    },
+    configureServer(server) {
+      devServer = server;
+      const packagePath = packagePathFor("");
+      server.middlewares.use((req, res, next) => {
+        const url = (req.url ?? "").split("?")[0];
+        if (!url.startsWith(ARTIFACT_PATH)) {
+          next();
+          return;
+        }
+        const project = projectFor(packagePath);
+        void artifactFor(project).then(
+          (artifact) => {
+            if (url !== `${ARTIFACT_PATH}${artifact.hash}.wasm`) {
+              res.statusCode = 404;
+              res.end("swift artifact is stale");
+              return;
+            }
+            res.setHeader("access-control-allow-origin", "*");
+            res.setHeader("content-type", "application/wasm");
+            res.end(artifact.bytes);
+          },
+          (error) => {
+            res.statusCode = 500;
+            res.end(error instanceof Error ? error.message : String(error));
+          }
+        );
+      });
+    }
+  };
+}
+
 // src/vite-plugin-one.ts
 function rnxPlugin(options = {}) {
   const prefix = options.prefix || "/__soot";
@@ -757,7 +936,7 @@ function rnxPlugin(options = {}) {
       if (options.enabled === false) return;
       const bundleUrl = options.bundleUrl || "/node_modules/one/metro-entry.bundle?platform=ios&dev=true&minify=false";
       const appName = resolveRnxDesktopAppName(options.open, server.config.root);
-      const replacementToken = (0, import_node_crypto2.randomUUID)();
+      const replacementToken = (0, import_node_crypto3.randomUUID)();
       const configuredPort = server.config.server.port || 8081;
       const listeningPort = () => {
         const address = server.httpServer?.address();
@@ -883,5 +1062,6 @@ var vite_plugin_one_default = rnxPlugin;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   rnxPlugin,
-  sootsimPlugin
+  sootsimPlugin,
+  swiftPlugin
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rnxsim",
-  "version": "0.1.506",
+  "version": "0.1.508",
   "description": "Vite and Metro plugins, testing drivers, and SDK exports for rnx.",
   "author": "Tamagui LLC",
   "license": "SEE LICENSE IN LICENSE",
@@ -34,6 +34,11 @@
       "source": "./src/vite-plugin-one.ts",
       "default": "./dist-lib/vite.cjs"
     },
+    "./swift": {
+      "types": "./src/swift.ts",
+      "source": "./src/swift.ts",
+      "default": "./dist-lib/swift.cjs"
+    },
     "./metro": {
       "source": "./src/metro-plugin.ts",
       "default": "./dist-lib/metro.cjs"

package/src/swift.ts

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

package/src/vite-plugin-one.ts

@@ -235,3 +235,11 @@ export function rnxPlugin(options: RnxPluginOptions = {}): Plugin {
 
 export const sootsimPlugin = rnxPlugin
 export default rnxPlugin
+
+// the `.swift` transform is opt-in per project: an app that never imports a
+// `.swift` file has no reason to watch for one, and an app that ships a native
+// ios/ tree (every swift file in it is a pod or an xcode target, not app
+// source) would otherwise rebuild the wrong package on every edit. a swift app
+// registers it in both the bundler that builds its native bundle and the main
+// dev server that serves the artifact.
+export { swiftPlugin, type SwiftPluginOptions } from './vite-plugin-swift.ts'

package/src/vite-plugin-swift.ts

@@ -0,0 +1,254 @@
+// `.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.
+//
+// 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: createSwiftModule 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 type { Plugin, ViteDevServer } from 'vite'
+
+const run = promisify(execFile)
+
+// the toolchain layout scripts/build.sh pins. xcode's swift has no wasm
+// backend, so the swift.org toolchain and its matching wasm sdk are the only
+// ones that can build this target.
+const TOOLCHAIN_BIN = path.join(
+  os.homedir(),
+  'Library/Developer/Toolchains/swift-6.2-RELEASE.xctoolchain/usr/bin',
+)
+const WASM_SDK = 'swift-6.2-RELEASE_wasm'
+const WASM_TRIPLE = 'wasm32-unknown-wasip1'
+
+const ARTIFACT_PATH = '/__rnx/swift/'
+const VIRTUAL_PREFIX = '\0rnx-swift:'
+
+interface SwiftArtifact {
+  hash: string
+  bytes: Buffer
+  // 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.
+  stamp: string
+}
+
+interface SwiftProject {
+  packagePath: string
+  artifact: SwiftArtifact | null
+  building: Promise<SwiftArtifact> | null
+}
+
+// a project is its swiftpm package: the build, the artifact, and the dev
+// server that serves it are shared by every plugin instance in this process.
+const projects = new Map<string, SwiftProject>()
+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 }
+  projects.set(packagePath, created)
+  return created
+}
+
+function rootFor(file: string): string {
+  return devServer?.config.root ?? path.dirname(file)
+}
+
+// the compile unit is the whole package: `swift build` compiles every source
+// in it, so one file's edit can change the artifact for all of them.
+function sourceFiles(packagePath: 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
+      const full = path.join(dir, entry.name)
+      if (entry.isDirectory()) walk(full)
+      else if (entry.name.endsWith('.swift')) found.push(full)
+    }
+  }
+  walk(packagePath)
+  return found
+}
+
+function sourceStamp(packagePath: string): string {
+  const hash = createHash('sha256')
+  for (const file of sourceFiles(packagePath).sort()) {
+    hash.update(path.relative(packagePath, file))
+    hash.update(String(fs.statSync(file).mtimeMs))
+  }
+  return hash.digest('hex').slice(0, 16)
+}
+
+// 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 {
+  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`
+}
+
+// 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`,
+    )
+  }
+  return path.join(binDir, artifacts[0])
+}
+
+async function compile(packagePath: string, stamp: string): Promise<SwiftArtifact> {
+  const swift = path.join(TOOLCHAIN_BIN, 'swift')
+  if (!fs.existsSync(swift)) {
+    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 },
+    )
+  } catch (error) {
+    throw new Error(
+      `swift build failed for ${packagePath}\n${error instanceof Error ? error.message : String(error)}`,
+    )
+  }
+  const bytes = fs.readFileSync(builtArtifact(packagePath))
+  return {
+    hash: createHash('sha256').update(bytes).digest('hex').slice(0, 16),
+    bytes,
+    stamp,
+  }
+}
+
+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(
+    (artifact) => {
+      project.artifact = artifact
+      project.building = null
+      return artifact
+    },
+    (error: unknown) => {
+      project.building = null
+      throw error
+    },
+  )
+  return project.building
+}
+
+export interface SwiftPluginOptions {
+  // swiftpm package that owns the project's .swift sources. defaults to the
+  // vite root, which is the layout a swift-only project uses.
+  packagePath?: string
+}
+
+export function swiftPlugin(options: SwiftPluginOptions = {}): Plugin {
+  const packagePathFor = (file: string): string => options.packagePath ?? rootFor(file)
+
+  return {
+    name: 'rnx-swift',
+    enforce: 'pre',
+
+    async resolveId(source, importer) {
+      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
+    },
+
+    async load(id) {
+      if (!id.startsWith(VIRTUAL_PREFIX)) return null
+      const packagePath = packagePathFor(id.slice(VIRTUAL_PREFIX.length))
+      const project = projectFor(packagePath)
+      // 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)
+      let artifact: SwiftArtifact
+      try {
+        artifact = await artifactFor(project)
+      } 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
+        // never rebuild it and the app would sit on a stale frame until the
+        // dev server restarted. the previous artifact keeps rendering, and the
+        // error is reported here instead.
+        if (!project.artifact) throw error
+        this.warn(error instanceof Error ? error.message : String(error))
+        artifact = project.artifact
+      }
+      return [
+        `import { createSwiftModule } from 'rnxsim/swift'`,
+        `export default createSwiftModule({ url: ${JSON.stringify(artifactUrl(project, artifact))}, hash: ${JSON.stringify(artifact.hash)} })`,
+        '',
+      ].join('\n')
+    },
+
+    configureServer(server) {
+      devServer = server
+      const packagePath = packagePathFor('')
+
+      server.middlewares.use((req, res, next) => {
+        const url = (req.url ?? '').split('?')[0]
+        if (!url.startsWith(ARTIFACT_PATH)) {
+          next()
+          return
+        }
+        const project = projectFor(packagePath)
+        void artifactFor(project).then(
+          (artifact) => {
+            if (url !== `${ARTIFACT_PATH}${artifact.hash}.wasm`) {
+              res.statusCode = 404
+              res.end('swift artifact is stale')
+              return
+            }
+            // 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)
+          },
+          (error: unknown) => {
+            res.statusCode = 500
+            res.end(error instanceof Error ? error.message : String(error))
+          },
+        )
+      })
+    },
+  }
+}