peachsim 0.1.570 → 0.1.571

package/dist-lib/vite.cjs

@@ -1,4 +1,4 @@
-/*! rnx v0.1.570 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+/*! rnx v0.1.571 | (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;
@@ -40,7 +40,7 @@ __export(vite_plugin_one_exports, {
 });
 module.exports = __toCommonJS(vite_plugin_one_exports);
 var import_fs2 = __toESM(require("fs"), 1);
-var import_node_crypto3 = require("node:crypto");
+var import_node_crypto4 = require("node:crypto");
 var import_path2 = __toESM(require("path"), 1);
 
 // src/bridge-constants.ts
@@ -713,10 +713,10 @@ function resolveRuntimeRootForHostname(hostname) {
   const version = runtimeVersionFromHostname(hostname);
   return version ? resolveInstalledRuntimeRoot(version) : null;
 }
-function resolveRuntimeRootForRequestHost(host) {
-  if (!host) return resolveActiveRuntimeRoot();
+function resolveRuntimeRootForRequestHost(host2) {
+  if (!host2) return resolveActiveRuntimeRoot();
   try {
-    return resolveRuntimeRootForHostname(new URL(`http://${host}`).hostname);
+    return resolveRuntimeRootForHostname(new URL(`http://${host2}`).hostname);
   } catch {
     return null;
   }
@@ -757,12 +757,10 @@ function serveRuntimeFile(req, res, fullPath) {
 }
 
 // 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_crypto3 = require("node:crypto");
+var import_node_fs4 = __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 import_node_path5 = __toESM(require("node:path"), 1);
 
 // ../sootsim-swift/src/bundleAssets.ts
 var RASTER_EXTENSIONS = /* @__PURE__ */ new Set([
@@ -797,13 +795,13 @@ function imagesetName(contentsPath) {
   if (!leaf.endsWith(".imageset")) return null;
   return leaf.slice(0, -".imageset".length) || null;
 }
-function isFlatResourceImage(path8) {
-  return path8.split("/").includes("Resources") && RASTER_EXTENSIONS.has(extOf(path8));
+function isFlatResourceImage(path9) {
+  return path9.split("/").includes("Resources") && RASTER_EXTENSIONS.has(extOf(path9));
 }
 function enumerateBundleImages(paths, readText) {
   const table = [];
   const seen = /* @__PURE__ */ new Set();
-  const catalogs = paths.filter((path8) => baseOf(path8) === "Contents.json");
+  const catalogs = paths.filter((path9) => baseOf(path9) === "Contents.json");
   for (const contentsPath of catalogs) {
     const name = imagesetName(contentsPath);
     if (name === null || seen.has(name)) continue;
@@ -823,12 +821,12 @@ function enumerateBundleImages(paths, readText) {
     seen.add(name);
     table.push({ name, file: `${dir}/${file}` });
   }
-  for (const path8 of paths) {
-    if (!isFlatResourceImage(path8)) continue;
-    const name = baseOf(path8).slice(0, -extOf(path8).length);
+  for (const path9 of paths) {
+    if (!isFlatResourceImage(path9)) continue;
+    const name = baseOf(path9).slice(0, -extOf(path9).length);
     if (name === "" || seen.has(name)) continue;
     seen.add(name);
-    table.push({ name, file: path8 });
+    table.push({ name, file: path9 });
   }
   return table;
 }
@@ -836,7 +834,7 @@ function enumerateBundleJson(paths) {
   const found = [];
   const seen = /* @__PURE__ */ new Set();
   const ordered = [...paths].filter(
-    (path8) => path8.split("/").includes("Resources") && path8.split("/").every((segment) => segment !== "" && segment !== "..") && extOf(path8) === ".json"
+    (path9) => path9.split("/").includes("Resources") && path9.split("/").every((segment) => segment !== "" && segment !== "..") && extOf(path9) === ".json"
   ).sort((a, b) => {
     const aDepth = a.split("/").length;
     const bDepth = b.split("/").length;
@@ -860,20 +858,322 @@ function swiftEntryModuleEsm(args) {
   ].join("\n");
 }
 
-// ../sootsim-swift/toolchain.json
-var toolchain_default = {
-  release: "swift-6.3-RELEASE",
-  wasmSdkChecksum: "9fa4016ee632c7e9e906608ec3b55cf13dfc4dff44e47574c5af58064dc33fd9"
-};
+// src/swift-compile.ts
+var import_node_child_process2 = require("node:child_process");
+var import_node_crypto2 = require("node:crypto");
+var import_node_fs3 = require("node:fs");
+var import_node_path4 = __toESM(require("node:path"), 1);
+var import_node_util = require("node:util");
 
-// src/vite-plugin-swift.ts
+// src/swift-package.ts
+function swiftManifestTargets(manifest) {
+  const code = manifest.replace(/\/\*[\s\S]*?\*\//g, "").replace(/\/\/[^\n]*/g, "");
+  const targets = [];
+  const pattern = /\.(executableTarget|target)\s*\(/g;
+  let match;
+  while ((match = pattern.exec(code)) !== null) {
+    const executable = match[1] === "executableTarget";
+    let depth = 1;
+    let i = pattern.lastIndex;
+    let inString = false;
+    let escaped = false;
+    let flat = "";
+    while (i < code.length && depth > 0) {
+      const ch = code[i];
+      if (inString) {
+        if (escaped) escaped = false;
+        else if (ch === "\\") escaped = true;
+        else if (ch === '"') inString = false;
+        if (depth === 1) flat += ch;
+      } else if (ch === '"') {
+        inString = true;
+        if (depth === 1) flat += ch;
+      } else if (ch === "(") {
+        depth++;
+        if (depth === 1) flat += ch;
+      } else if (ch === ")") {
+        depth--;
+        if (depth >= 1) flat += ch;
+      } else if (depth === 1) {
+        flat += ch;
+      }
+      i++;
+    }
+    const name = /\bname\s*:\s*"([^"]+)"/.exec(flat)?.[1];
+    if (!name) continue;
+    const rawPath = /\bpath\s*:\s*"([^"]*)"/.exec(flat)?.[1];
+    const targetPath = rawPath == null || rawPath === "" ? `Sources/${name}` : rawPath.replace(/^\.\//, "").replace(/\/+$/, "");
+    targets.push({ name, path: targetPath, executable });
+  }
+  return targets;
+}
+
+// src/swift-compile.ts
 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/${toolchain_default.release}.xctoolchain/usr/bin`
-);
-var WASM_SDK = `${toolchain_default.release}_wasm`;
 var WASM_TRIPLE = "wasm32-unknown-wasip1";
+function swiftModuleInputFiles(root) {
+  const files = ["Package.swift", "scripts/contrast-app-Package.swift"];
+  const walk = (dir) => {
+    for (const entry of (0, import_node_fs3.readdirSync)(import_node_path4.default.join(root, dir), { withFileTypes: true })) {
+      const relative2 = `${dir}/${entry.name}`;
+      if (entry.isDirectory()) walk(relative2);
+      else if (entry.name.endsWith(".swift")) files.push(relative2);
+    }
+  };
+  walk("Sources");
+  return files.sort();
+}
+var linkedModuleDigests = /* @__PURE__ */ new Map();
+function linkedModuleDigest(root) {
+  const files = swiftModuleInputFiles(root);
+  const stampHash = (0, import_node_crypto2.createHash)("sha256");
+  for (const file of files) {
+    const stat = (0, import_node_fs3.statSync)(import_node_path4.default.join(root, file), { bigint: true });
+    stampHash.update(file);
+    stampHash.update(
+      `${stat.dev}:${stat.ino}:${stat.size}:${stat.mtimeNs}:${stat.ctimeNs}
+`
+    );
+  }
+  const stamp = stampHash.digest("hex");
+  const cached = linkedModuleDigests.get(root);
+  if (cached?.stamp === stamp) return cached.digest;
+  const hash = (0, import_node_crypto2.createHash)("sha256");
+  for (const file of files) {
+    hash.update((0, import_node_crypto2.createHash)("sha256").update(file).digest());
+    hash.update(
+      (0, import_node_crypto2.createHash)("sha256").update((0, import_node_fs3.readFileSync)(import_node_path4.default.join(root, file))).digest()
+    );
+  }
+  const digest = hash.digest();
+  linkedModuleDigests.set(root, { stamp, digest });
+  return digest;
+}
+function compileTargets(input) {
+  const manifest = input.files["Package.swift"];
+  return manifest === void 0 ? [] : swiftManifestTargets(manifest);
+}
+function swiftSiblingDependencies(files, targets) {
+  const names = new Set(targets.map((target) => target.name));
+  const siblings = /* @__PURE__ */ new Map();
+  for (const target of targets) {
+    const prefix = `${target.path}/`;
+    const deps = /* @__PURE__ */ new Set();
+    for (const [file, contents] of Object.entries(files)) {
+      if (file === "Package.swift" || !file.startsWith(prefix)) continue;
+      for (const match of contents.matchAll(/^\s*import\s+([A-Za-z_][A-Za-z0-9_]*)/gm)) {
+        if (names.has(match[1]) && match[1] !== target.name) deps.add(match[1]);
+      }
+    }
+    siblings.set(target.name, [...deps].sort());
+  }
+  return siblings;
+}
+var MULTI_MANIFEST_VERSION = 1;
+function swiftArtifactHash(input, release, moduleRoot) {
+  const hash = (0, import_node_crypto2.createHash)("sha256");
+  hash.update(`swift-compile/v1
+${release}
+`);
+  hash.update(linkedModuleDigest(moduleRoot));
+  for (const file of Object.keys(input.files).sort()) {
+    hash.update((0, import_node_crypto2.createHash)("sha256").update(file).digest());
+    hash.update((0, import_node_crypto2.createHash)("sha256").update(input.files[file]).digest());
+  }
+  for (const base of Object.keys(input.resources ?? {}).sort()) {
+    hash.update((0, import_node_crypto2.createHash)("sha256").update(base).digest());
+    hash.update(
+      (0, import_node_crypto2.createHash)("sha256").update(input.resources?.[base] ?? "").digest()
+    );
+  }
+  for (const name of Object.keys(input.images ?? {}).sort()) {
+    const image = input.images?.[name];
+    if (!image) continue;
+    hash.update((0, import_node_crypto2.createHash)("sha256").update(name).digest());
+    hash.update((0, import_node_crypto2.createHash)("sha256").update(image.file).digest());
+    hash.update((0, import_node_crypto2.createHash)("sha256").update(image.data).digest());
+  }
+  const targets = compileTargets(input);
+  if (targets.length > 0) {
+    hash.update(`swift-multi/v${MULTI_MANIFEST_VERSION}
+`);
+    hash.update(
+      JSON.stringify({
+        targets,
+        siblings: [...swiftSiblingDependencies(input.files, targets)].sort(
+          (a, b) => String(a) < String(b) ? -1 : String(a) > String(b) ? 1 : 0
+        )
+      })
+    );
+  }
+  return hash.digest("hex");
+}
+function emitSwiftPackageManifest(args) {
+  const { targets, siblings, moduleRoot } = args;
+  const executable = targets.find((target) => target.executable);
+  if (!executable) throw new Error("swift-compile: no executable target to emit");
+  const swiftSettings = 'swiftSettings: [.swiftLanguageMode(.v5), .unsafeFlags(["-Osize"])]';
+  const stanza = (target) => {
+    const deps = [
+      '.product(name: "SwiftUI", package: "sootsim-swift")',
+      ...(siblings.get(target.name) ?? []).map((sibling) => `"${sibling}"`)
+    ].join(", ");
+    const kind = target.executable ? ".executableTarget" : ".target";
+    const link = target.executable ? `,
+      linkerSettings: [
+        .unsafeFlags([
+          "-Xclang-linker", "-mexec-model=reactor",
+          "-Xlinker", "--export-if-defined=__main_argc_argv",
+        ]),
+        .unsafeFlags(["-Xlinker", "--strip-all"], .when(configuration: .release)),
+      ]` : "";
+    return [
+      `    ${kind}(`,
+      `      name: "${target.name}",`,
+      `      dependencies: [${deps}],`,
+      `      path: "${target.path}",`,
+      `      ${swiftSettings}${link}`,
+      `    ),`
+    ].join("\n");
+  };
+  return [
+    "// swift-tools-version: 6.0",
+    "import PackageDescription",
+    "",
+    "// generated by swift-compile from the project package partition.",
+    "let package = Package(",
+    '  name: "app",',
+    `  products: [.executable(name: "${executable.name}", targets: ["${executable.name}"])],`,
+    `  dependencies: [.package(path: "${moduleRoot}")],`,
+    "  targets: [",
+    ...targets.map(stanza),
+    "  ]",
+    ")",
+    ""
+  ].join("\n");
+}
+function writeSwiftProject(layout, input, moduleRoot) {
+  const targets = compileTargets(input);
+  if (targets.length === 0) {
+    (0, import_node_fs3.rmSync)(layout.sources, { recursive: true, force: true });
+    for (const [file, contents] of Object.entries(input.files)) {
+      const target = import_node_path4.default.join(layout.sources, file);
+      (0, import_node_fs3.mkdirSync)(import_node_path4.default.dirname(target), { recursive: true });
+      (0, import_node_fs3.writeFileSync)(target, contents, "utf8");
+    }
+    const manifest = (0, import_node_fs3.readFileSync)(
+      import_node_path4.default.join(moduleRoot, "scripts/contrast-app-Package.swift"),
+      "utf8"
+    ).replaceAll("__SOOTSIM_SWIFT_PACKAGE__", moduleRoot);
+    (0, import_node_fs3.writeFileSync)(import_node_path4.default.join(layout.root, "Package.swift"), manifest, "utf8");
+    return;
+  }
+  (0, import_node_fs3.mkdirSync)(layout.root, { recursive: true });
+  for (const child of (0, import_node_fs3.readdirSync)(layout.root)) {
+    if (child === ".build") continue;
+    (0, import_node_fs3.rmSync)(import_node_path4.default.join(layout.root, child), { recursive: true, force: true });
+  }
+  for (const [file, contents] of Object.entries(input.files)) {
+    if (file === "Package.swift") continue;
+    const target = import_node_path4.default.join(layout.root, file);
+    (0, import_node_fs3.mkdirSync)(import_node_path4.default.dirname(target), { recursive: true });
+    (0, import_node_fs3.writeFileSync)(target, contents, "utf8");
+  }
+  (0, import_node_fs3.writeFileSync)(
+    import_node_path4.default.join(layout.root, "Package.swift"),
+    emitSwiftPackageManifest({
+      targets,
+      siblings: swiftSiblingDependencies(input.files, targets),
+      moduleRoot
+    }),
+    "utf8"
+  );
+}
+function streamText(value) {
+  if (typeof value === "string") return value.trim();
+  if (Buffer.isBuffer(value)) return value.toString("utf8").trim();
+  return "";
+}
+function outputOf(error) {
+  if (error && typeof error === "object") {
+    const streams = [
+      streamText(Reflect.get(error, "stdout")),
+      streamText(Reflect.get(error, "stderr"))
+    ].filter(Boolean);
+    if (streams.length > 0) return streams.join("\n");
+  }
+  return error instanceof Error ? error.message : String(error);
+}
+function builtArtifact(layout) {
+  const binDir = import_node_path4.default.join(layout.root, ".build", WASM_TRIPLE, "release");
+  const artifacts = (0, import_node_fs3.existsSync)(binDir) ? (0, import_node_fs3.readdirSync)(binDir).filter((name) => name.endsWith(".wasm")).sort() : [];
+  if (artifacts.length !== 1) {
+    throw new Error(
+      `swift-compile: the build produced ${artifacts.length} wasm artifacts; exactly one executable is the app`
+    );
+  }
+  return import_node_path4.default.join(binDir, artifacts[0]);
+}
+function projectDiagnostic(output, layout) {
+  const base = layout.multi ? layout.root : layout.sources;
+  const prefix = `${base}${import_node_path4.default.sep}`;
+  return output.split("\n").map((line) => line.startsWith(prefix) ? line.slice(prefix.length) : line).join("\n").trim();
+}
+var ROOT_LOCKS = Symbol.for("peachsim.swiftCompile.rootLocks");
+var host = globalThis;
+var rootLocks = host[ROOT_LOCKS] ??= /* @__PURE__ */ new Map();
+function serialize(root, work) {
+  const current = rootLocks.get(root) ?? Promise.resolve();
+  const next = current.then(work, work);
+  rootLocks.set(
+    root,
+    next.catch(() => {
+    })
+  );
+  return next;
+}
+function compileSwiftProjectUnit(input, options) {
+  (0, import_node_fs3.mkdirSync)(options.buildRoot, { recursive: true });
+  const root = (0, import_node_fs3.realpathSync)(options.buildRoot);
+  const moduleRoot = import_node_path4.default.resolve(options.moduleRoot);
+  const layout = {
+    root,
+    sources: import_node_path4.default.join(root, "Sources", "App"),
+    multi: compileTargets(input).length > 0
+  };
+  const hash = swiftArtifactHash(input, options.release, moduleRoot);
+  return serialize(root, async () => {
+    writeSwiftProject(layout, input, moduleRoot);
+    const swift = import_node_path4.default.join(options.toolchainBin, "swift");
+    if (!(0, import_node_fs3.existsSync)(swift)) {
+      throw new Error(
+        `swift-compile: no swift.org toolchain at ${options.toolchainBin}; install ${options.release} and its matching wasm sdk`
+      );
+    }
+    try {
+      await run(
+        swift,
+        [
+          "build",
+          "--package-path",
+          root,
+          "--swift-sdk",
+          `${options.release}_wasm`,
+          "-c",
+          "release",
+          "-Xswiftc",
+          "-Osize"
+        ],
+        { maxBuffer: 64 * 1024 * 1024, timeout: options.timeoutMs }
+      );
+    } catch (error) {
+      throw new Error(projectDiagnostic(outputOf(error), layout), { cause: error });
+    }
+    return { hash, bytes: (0, import_node_fs3.readFileSync)(builtArtifact(layout)) };
+  });
+}
+
+// src/vite-plugin-swift.ts
 var ARTIFACT_PATH = "/__rnx/swift/";
 var RESOURCE_PATH = "/__rnx/swift-res/";
 var VIRTUAL_PREFIX = "\0rnx-swift:";
@@ -894,11 +1194,11 @@ function projectFor(packagePath) {
 function sourceFiles(root) {
   const found = [];
   const walk = (dir) => {
-    for (const entry of import_node_fs3.default.readdirSync(dir, { withFileTypes: true })) {
+    for (const entry of import_node_fs4.default.readdirSync(dir, { withFileTypes: true })) {
       if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
-      const full = import_node_path4.default.join(dir, entry.name);
+      const full = import_node_path5.default.join(dir, entry.name);
       if (entry.isDirectory()) {
-        if (full !== root && import_node_fs3.default.existsSync(import_node_path4.default.join(full, "Package.swift"))) continue;
+        if (full !== root && import_node_fs4.default.existsSync(import_node_path5.default.join(full, "Package.swift"))) continue;
         walk(full);
       } else if (entry.name.endsWith(".swift")) found.push(full);
     }
@@ -909,12 +1209,12 @@ function sourceFiles(root) {
 function resourceCandidateFiles(root) {
   const found = [];
   const walk = (dir) => {
-    for (const entry of import_node_fs3.default.readdirSync(dir, { withFileTypes: true })) {
+    for (const entry of import_node_fs4.default.readdirSync(dir, { withFileTypes: true })) {
       if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.name === ".build")
         continue;
-      const full = import_node_path4.default.join(dir, entry.name);
+      const full = import_node_path5.default.join(dir, entry.name);
       if (entry.isDirectory()) {
-        if (full !== root && import_node_fs3.default.existsSync(import_node_path4.default.join(full, "Package.swift"))) continue;
+        if (full !== root && import_node_fs4.default.existsSync(import_node_path5.default.join(full, "Package.swift"))) continue;
         walk(full);
       } else {
         found.push(full);
@@ -937,19 +1237,20 @@ var RESOURCE_CONTENT_TYPES = {
 function buildSwiftResourceTable(project, baseUrl) {
   const absolute = resourceCandidateFiles(project.packagePath);
   const relative2 = absolute.map(
-    (file) => import_node_path4.default.relative(project.packagePath, file).split(import_node_path4.default.sep).join(import_node_path4.default.posix.sep)
+    (file) => import_node_path5.default.relative(project.packagePath, file).split(import_node_path5.default.sep).join(import_node_path5.default.posix.sep)
   );
   const byRelative = new Map(absolute.map((file, index) => [relative2[index], file]));
   const found = enumerateBundleImages(relative2, (candidate) => {
     const file = byRelative.get(candidate);
-    if (!file || import_node_path4.default.basename(file) !== "Contents.json") return null;
+    if (!file || import_node_path5.default.basename(file) !== "Contents.json") return null;
     try {
-      return import_node_fs3.default.readFileSync(file, "utf8");
+      return import_node_fs4.default.readFileSync(file, "utf8");
     } catch {
       return null;
     }
   });
   const table = {};
+  const images = {};
   const watched = [];
   const registered = /* @__PURE__ */ new Map();
   for (const { name, file } of found) {
@@ -957,27 +1258,31 @@ function buildSwiftResourceTable(project, baseUrl) {
     if (!disk) continue;
     let bytes;
     try {
-      bytes = import_node_fs3.default.readFileSync(disk);
+      bytes = import_node_fs4.default.readFileSync(disk);
     } catch {
       continue;
     }
-    const hash = (0, import_node_crypto2.createHash)("sha256").update(bytes).digest("hex").slice(0, 16);
-    const ext = import_node_path4.default.posix.extname(file).toLowerCase();
+    const hash = (0, import_node_crypto3.createHash)("sha256").update(bytes).digest("hex").slice(0, 16);
+    const ext = import_node_path5.default.posix.extname(file).toLowerCase();
     table[name] = `${baseUrl}${RESOURCE_PATH}${hash}${ext}`;
+    images[name] = {
+      file: import_node_path5.default.posix.basename(file),
+      data: bytes.toString("base64")
+    };
     watched.push(file);
     const contents = file.replace(/\/[^/]+$/, "/Contents.json");
     if (byRelative.has(contents)) watched.push(contents);
     registered.set(`${hash}${ext}`, disk);
   }
   project.resourceFiles = registered;
-  return { table, watched };
+  return { table, images, watched };
 }
 var BUNDLE_MAX_FILES = 128;
 var BUNDLE_MAX_FILE_BYTES = 2 * 1024 * 1024;
 var BUNDLE_MAX_TOTAL_BYTES = 8 * 1024 * 1024;
 function buildSwiftBundleFiles(packagePath) {
   const relative2 = resourceCandidateFiles(packagePath).map(
-    (file) => import_node_path4.default.relative(packagePath, file).split(import_node_path4.default.sep).join(import_node_path4.default.posix.sep)
+    (file) => import_node_path5.default.relative(packagePath, file).split(import_node_path5.default.sep).join(import_node_path5.default.posix.sep)
   );
   const files = {};
   const watched = [];
@@ -987,7 +1292,7 @@ function buildSwiftBundleFiles(packagePath) {
     watched.push(file);
     let bytes;
     try {
-      bytes = import_node_fs3.default.readFileSync(import_node_path4.default.join(packagePath, ...file.split("/")));
+      bytes = import_node_fs4.default.readFileSync(import_node_path5.default.join(packagePath, ...file.split("/")));
     } catch {
       continue;
     }
@@ -1011,8 +1316,8 @@ function serveSwiftResource(project, key) {
   if (!disk) return null;
   try {
     return {
-      bytes: import_node_fs3.default.readFileSync(disk),
-      contentType: RESOURCE_CONTENT_TYPES[import_node_path4.default.extname(disk).toLowerCase()] ?? "application/octet-stream"
+      bytes: import_node_fs4.default.readFileSync(disk),
+      contentType: RESOURCE_CONTENT_TYPES[import_node_path5.default.extname(disk).toLowerCase()] ?? "application/octet-stream"
     };
   } catch {
     return null;
@@ -1021,32 +1326,53 @@ function serveSwiftResource(project, key) {
 function linkedModuleRoots(packagePath) {
   let manifest;
   try {
-    manifest = import_node_fs3.default.readFileSync(import_node_path4.default.join(packagePath, "Package.swift"), "utf8");
+    manifest = import_node_fs4.default.readFileSync(import_node_path5.default.join(packagePath, "Package.swift"), "utf8");
   } catch {
     return [];
   }
   const roots = /* @__PURE__ */ new Set();
   const dependency = /\.package\(\s*path:\s*"([^"]+)"\s*\)/g;
   for (const match of manifest.replace(/^\s*\/\/.*$/gm, "").matchAll(dependency)) {
-    const root = import_node_path4.default.resolve(packagePath, match[1]);
-    if (import_node_fs3.default.existsSync(import_node_path4.default.join(root, "Package.swift"))) roots.add(root);
+    const root = import_node_path5.default.resolve(packagePath, match[1]);
+    if (import_node_fs4.default.existsSync(import_node_path5.default.join(root, "Package.swift"))) roots.add(root);
   }
   return [...roots].sort();
 }
 function sourceStamp(packagePath) {
-  const hash = (0, import_node_crypto2.createHash)("sha256");
-  for (const root of [packagePath, ...linkedModuleRoots(packagePath)]) {
-    hash.update(root);
-    for (const file of sourceFiles(root).sort()) {
-      hash.update(import_node_path4.default.relative(root, file));
-      hash.update(String(import_node_fs3.default.statSync(file).mtimeMs));
+  const hash = (0, import_node_crypto3.createHash)("sha256");
+  hash.update(packagePath);
+  const projectInputs = /* @__PURE__ */ new Set([
+    import_node_path5.default.join(packagePath, "Package.swift"),
+    ...sourceFiles(packagePath),
+    ...buildSwiftBundleFiles(packagePath).watched.map(
+      (file) => import_node_path5.default.join(packagePath, ...file.split(import_node_path5.default.posix.sep))
+    ),
+    ...buildSwiftResourceTable(projectFor(packagePath), "").watched.map(
+      (file) => import_node_path5.default.join(packagePath, ...file.split(import_node_path5.default.posix.sep))
+    )
+  ]);
+  for (const file of [...projectInputs].sort()) {
+    hash.update(import_node_path5.default.relative(packagePath, file));
+    hash.update(String(import_node_fs4.default.statSync(file).mtimeMs));
+  }
+  const moduleRoot = linkedModuleRoots(packagePath).find(
+    (root) => import_node_fs4.default.existsSync(import_node_path5.default.join(root, "toolchain.json"))
+  );
+  if (moduleRoot) {
+    hash.update(moduleRoot);
+    for (const relative2 of [
+      ...swiftModuleInputFiles(moduleRoot),
+      "toolchain.json"
+    ].sort()) {
+      hash.update(relative2);
+      hash.update(String(import_node_fs4.default.statSync(import_node_path5.default.join(moduleRoot, relative2)).mtimeMs));
     }
   }
   return hash.digest("hex").slice(0, 16);
 }
 function entryRootId(packagePath, file) {
-  const relative2 = import_node_path4.default.relative(packagePath, file).split(import_node_path4.default.sep).join(import_node_path4.default.posix.sep);
-  return `${import_node_path4.default.basename(packagePath)}${import_node_path4.default.posix.sep}${relative2}`;
+  const relative2 = import_node_path5.default.relative(packagePath, file).split(import_node_path5.default.sep).join(import_node_path5.default.posix.sep);
+  return `${import_node_path5.default.basename(packagePath)}${import_node_path5.default.posix.sep}${relative2}`;
 }
 function serverOrigin() {
   const address = devServer?.httpServer?.address();
@@ -1057,70 +1383,60 @@ function serverOrigin() {
 function artifactUrl(project, artifact) {
   return `${serverOrigin()}${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`
-    );
+function compileInput(packagePath, entry) {
+  const files = {};
+  for (const file of sourceFiles(packagePath)) {
+    const relative2 = import_node_path5.default.relative(packagePath, file).split(import_node_path5.default.sep).join(import_node_path5.default.posix.sep);
+    files[relative2] = import_node_fs4.default.readFileSync(file, "utf8");
   }
-  return import_node_path4.default.join(binDir, artifacts[0]);
-}
-function streamText(value) {
-  if (typeof value === "string") return value.trim();
-  if (Buffer.isBuffer(value)) return value.toString("utf8").trim();
-  return "";
+  const manifest = import_node_path5.default.join(packagePath, "Package.swift");
+  if (import_node_fs4.default.existsSync(manifest)) files["Package.swift"] = import_node_fs4.default.readFileSync(manifest, "utf8");
+  const resources = buildSwiftBundleFiles(packagePath).files;
+  const images = buildSwiftResourceTable(projectFor(packagePath), "").images;
+  return {
+    files,
+    resources,
+    images,
+    entry
+  };
 }
-async function compile(packagePath, stamp) {
-  const swift = import_node_path4.default.join(TOOLCHAIN_BIN, "swift");
-  if (!import_node_fs3.default.existsSync(swift)) {
+async function compile(packagePath, entry, stamp) {
+  const moduleRoot = linkedModuleRoots(packagePath).find(
+    (root) => import_node_fs4.default.existsSync(import_node_path5.default.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) {
-    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}
-${detail}`);
+  const toolchain = JSON.parse(
+    import_node_fs4.default.readFileSync(import_node_path5.default.join(moduleRoot, "toolchain.json"), "utf8")
+  );
+  const release = toolchain && typeof toolchain === "object" ? Reflect.get(toolchain, "release") : void 0;
+  if (typeof release !== "string") {
+    throw new Error(`swift toolchain manifest at ${moduleRoot} has no release`);
   }
-  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
-  };
+  const artifact = await compileSwiftProjectUnit(compileInput(packagePath, entry), {
+    buildRoot: process.env.CONTRAST_SWIFT_BUILD_ROOT ?? import_node_path5.default.join(import_node_os2.default.tmpdir(), "contrast-swift-build"),
+    moduleRoot,
+    release,
+    toolchainBin: import_node_path5.default.join(
+      import_node_os2.default.homedir(),
+      `Library/Developer/Toolchains/${release}.xctoolchain/usr/bin`
+    )
+  });
+  return { ...artifact, stamp };
 }
-function artifactFor(project) {
+function artifactFor(project, entry) {
   const stamp = sourceStamp(project.packagePath);
   if (project.artifact?.stamp === stamp) return Promise.resolve(project.artifact);
   if (project.building) {
     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;
@@ -1135,12 +1451,12 @@ function artifactFor(project) {
   return promise;
 }
 function packageFor(file) {
-  let dir = import_node_path4.default.dirname(file);
+  let dir = import_node_path5.default.dirname(file);
   const stop = devServer?.config.root;
   for (; ; ) {
-    if (import_node_fs3.default.existsSync(import_node_path4.default.join(dir, "Package.swift"))) return dir;
-    if (stop !== void 0 && dir === stop || import_node_path4.default.dirname(dir) === dir) break;
-    dir = import_node_path4.default.dirname(dir);
+    if (import_node_fs4.default.existsSync(import_node_path5.default.join(dir, "Package.swift"))) return dir;
+    if (stop !== void 0 && dir === stop || import_node_path5.default.dirname(dir) === dir) break;
+    dir = import_node_path5.default.dirname(dir);
   }
   throw new Error(
     `no Package.swift above ${file}${stop === void 0 ? "" : ` (searched up to ${stop})`}; a .swift import needs a swiftpm package like the one in packages/sootsim-swift/example`
@@ -1164,16 +1480,18 @@ function swiftPlugin(options = {}) {
     async load(id) {
       if (!id.startsWith(VIRTUAL_PREFIX)) return null;
       const file = id.slice(VIRTUAL_PREFIX.length);
-      if (!import_node_fs3.default.existsSync(file)) throw new Error(`swift source ${file} no longer exists`);
+      if (!import_node_fs4.default.existsSync(file)) throw new Error(`swift source ${file} no longer exists`);
       const packagePath = options.packagePath ?? packageFor(file);
       const project = projectFor(packagePath);
+      const entry = import_node_path5.default.relative(packagePath, file).split(import_node_path5.default.sep).join(import_node_path5.default.posix.sep);
       for (const source of sourceFiles(packagePath)) this.addWatchFile(source);
+      this.addWatchFile(import_node_path5.default.join(packagePath, "Package.swift"));
       for (const root of linkedModuleRoots(packagePath)) {
         for (const source of sourceFiles(root)) this.addWatchFile(source);
       }
       let artifact;
       try {
-        artifact = await artifactFor(project);
+        artifact = await artifactFor(project, entry);
       } catch (error) {
         if (!project.artifact) throw error;
         this.warn(error instanceof Error ? error.message : String(error));
@@ -1184,7 +1502,7 @@ function swiftPlugin(options = {}) {
         const built = buildSwiftResourceTable(project, serverOrigin());
         resources = built.table;
         for (const watched of built.watched) {
-          this.addWatchFile(import_node_path4.default.join(packagePath, ...watched.split(import_node_path4.default.posix.sep)));
+          this.addWatchFile(import_node_path5.default.join(packagePath, ...watched.split(import_node_path5.default.posix.sep)));
         }
       } catch (error) {
         this.warn(
@@ -1196,7 +1514,7 @@ function swiftPlugin(options = {}) {
         const packed = buildSwiftBundleFiles(packagePath);
         bundleFiles = packed.files;
         for (const watched of packed.watched) {
-          this.addWatchFile(import_node_path4.default.join(packagePath, ...watched.split(import_node_path4.default.posix.sep)));
+          this.addWatchFile(import_node_path5.default.join(packagePath, ...watched.split(import_node_path5.default.posix.sep)));
         }
         if (packed.skipped.length > 0) {
           this.warn(
@@ -1255,8 +1573,8 @@ function swiftPlugin(options = {}) {
 }
 
 // src/rolldown-plugin-swift.ts
-var import_node_fs4 = __toESM(require("node:fs"), 1);
-var import_node_path5 = __toESM(require("node:path"), 1);
+var import_node_fs5 = __toESM(require("node:fs"), 1);
+var import_node_path6 = __toESM(require("node:path"), 1);
 
 // src/swift-submit.ts
 var SWIFT_COMPILE_PATH = "/api/swift-compile";
@@ -1330,15 +1648,15 @@ function projectFor2(packagePath) {
 function packageFiles(root) {
   const found = [];
   const walk = (dir) => {
-    for (const entry of import_node_fs4.default.readdirSync(dir, { withFileTypes: true })) {
+    for (const entry of import_node_fs5.default.readdirSync(dir, { withFileTypes: true })) {
       if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.name === ".build")
         continue;
-      const full = import_node_path5.default.join(dir, entry.name);
+      const full = import_node_path6.default.join(dir, entry.name);
       if (entry.isDirectory()) {
-        if (full !== root && import_node_fs4.default.existsSync(import_node_path5.default.join(full, "Package.swift"))) continue;
+        if (full !== root && import_node_fs5.default.existsSync(import_node_path6.default.join(full, "Package.swift"))) continue;
         walk(full);
       } else {
-        found.push(import_node_path5.default.relative(root, full).split(import_node_path5.default.sep).join(import_node_path5.default.posix.sep));
+        found.push(import_node_path6.default.relative(root, full).split(import_node_path6.default.sep).join(import_node_path6.default.posix.sep));
       }
     }
   };
@@ -1349,8 +1667,8 @@ function sourceFiles2(packagePath) {
   const files = {};
   for (const relative2 of packageFiles(packagePath)) {
     if (!relative2.endsWith(".swift")) continue;
-    files[relative2] = import_node_fs4.default.readFileSync(
-      import_node_path5.default.join(packagePath, ...relative2.split("/")),
+    files[relative2] = import_node_fs5.default.readFileSync(
+      import_node_path6.default.join(packagePath, ...relative2.split("/")),
       "utf8"
     );
   }
@@ -1358,20 +1676,20 @@ function sourceFiles2(packagePath) {
 }
 function bundlePack(packagePath) {
   const relative2 = packageFiles(packagePath);
-  const disk = (file) => import_node_path5.default.join(packagePath, ...file.split("/"));
+  const disk = (file) => import_node_path6.default.join(packagePath, ...file.split("/"));
   const resources = {};
   const watched = [];
   for (const { base, file } of enumerateBundleJson(relative2)) {
-    resources[base] = import_node_fs4.default.readFileSync(disk(file)).toString("base64");
+    resources[base] = import_node_fs5.default.readFileSync(disk(file)).toString("base64");
     watched.push(file);
   }
   const images = {};
   const byRelative = new Map(relative2.map((file) => [file, disk(file)]));
   for (const { name, file } of enumerateBundleImages(relative2, (candidate) => {
     const absolute = byRelative.get(candidate);
-    if (!absolute || import_node_path5.default.basename(absolute) !== "Contents.json") return null;
+    if (!absolute || import_node_path6.default.basename(absolute) !== "Contents.json") return null;
     try {
-      return import_node_fs4.default.readFileSync(absolute, "utf8");
+      return import_node_fs5.default.readFileSync(absolute, "utf8");
     } catch {
       return null;
     }
@@ -1379,19 +1697,19 @@ function bundlePack(packagePath) {
     const absolute = byRelative.get(file);
     if (!absolute) continue;
     images[name] = {
-      file: import_node_path5.default.posix.basename(file),
-      data: import_node_fs4.default.readFileSync(absolute).toString("base64")
+      file: import_node_path6.default.posix.basename(file),
+      data: import_node_fs5.default.readFileSync(absolute).toString("base64")
     };
     watched.push(file);
   }
   return { resources, images, watched };
 }
 function packageFor2(file, stop) {
-  let dir = import_node_path5.default.dirname(file);
+  let dir = import_node_path6.default.dirname(file);
   for (; ; ) {
-    if (import_node_fs4.default.existsSync(import_node_path5.default.join(dir, "Package.swift"))) return dir;
-    if (stop !== void 0 && dir === stop || import_node_path5.default.dirname(dir) === dir) break;
-    dir = import_node_path5.default.dirname(dir);
+    if (import_node_fs5.default.existsSync(import_node_path6.default.join(dir, "Package.swift"))) return dir;
+    if (stop !== void 0 && dir === stop || import_node_path6.default.dirname(dir) === dir) break;
+    dir = import_node_path6.default.dirname(dir);
   }
   throw new Error(
     `no Package.swift above ${file}; a .swift import needs a swiftpm package like the one in packages/sootsim-swift/example`
@@ -1420,17 +1738,17 @@ function swiftRemotePlugin(options) {
     async load(id) {
       if (!id.startsWith(VIRTUAL_PREFIX2)) return null;
       const file = id.slice(VIRTUAL_PREFIX2.length);
-      if (!import_node_fs4.default.existsSync(file)) throw new Error(`swift source ${file} no longer exists`);
+      if (!import_node_fs5.default.existsSync(file)) throw new Error(`swift source ${file} no longer exists`);
       const packagePath = options.packagePath ?? packageFor2(file);
       const project = projectFor2(packagePath);
       const files = sourceFiles2(packagePath);
-      const entry = import_node_path5.default.relative(packagePath, file).split(import_node_path5.default.sep).join(import_node_path5.default.posix.sep);
+      const entry = import_node_path6.default.relative(packagePath, file).split(import_node_path6.default.sep).join(import_node_path6.default.posix.sep);
       for (const source of Object.keys(files)) {
-        this.addWatchFile(import_node_path5.default.join(packagePath, ...source.split("/")));
+        this.addWatchFile(import_node_path6.default.join(packagePath, ...source.split("/")));
       }
       const pack = bundlePack(packagePath);
       for (const watched of pack.watched) {
-        this.addWatchFile(import_node_path5.default.join(packagePath, ...watched.split("/")));
+        this.addWatchFile(import_node_path6.default.join(packagePath, ...watched.split("/")));
       }
       try {
         project.address = await compileSwiftProject(
@@ -1474,7 +1792,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_crypto3.randomUUID)();
+      const replacementToken = (0, import_node_crypto4.randomUUID)();
       const configuredPort = server.config.server.port || 8081;
       const listeningPort = () => {
         const address = server.httpServer?.address();