peachsim 0.1.577 → 0.1.579

package/dist-lib/swift-compile.cjs

@@ -1,4 +1,4 @@
-/*! rnx v0.1.577 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+/*! rnx v0.1.579 | (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;
@@ -38,15 +38,115 @@ __export(swift_compile_exports, {
   compileTargets: () => compileTargets,
   emitSwiftPackageManifest: () => emitSwiftPackageManifest,
   swiftArtifactHash: () => swiftArtifactHash,
+  swiftIcuAsset: () => swiftIcuAsset,
   swiftModuleInputFiles: () => swiftModuleInputFiles,
+  withNativeSourceGlue: () => withNativeSourceGlue,
   writeSwiftProject: () => writeSwiftProject
 });
 module.exports = __toCommonJS(swift_compile_exports);
+var import_node_child_process2 = require("node:child_process");
+var import_node_crypto2 = require("node:crypto");
+var import_node_fs2 = require("node:fs");
+var import_node_os = __toESM(require("node:os"), 1);
+var import_node_path2 = __toESM(require("node:path"), 1);
+var import_node_util2 = require("node:util");
+
+// src/swift-icu.ts
 var import_node_child_process = require("node:child_process");
 var import_node_crypto = require("node:crypto");
 var import_node_fs = require("node:fs");
 var import_node_path = __toESM(require("node:path"), 1);
 var import_node_util = require("node:util");
+var import_node_zlib = require("node:zlib");
+var run = (0, import_node_util.promisify)(import_node_child_process.execFile);
+var deflate = (0, import_node_util.promisify)(import_node_zlib.gzip);
+var ARCHIVE = "wasi/lib_FoundationICU.a";
+var MEMBER = "icu_packaged_data.cpp.obj";
+var raw = /* @__PURE__ */ new Map();
+var assets = /* @__PURE__ */ new Map();
+function memo(cache, key, load2) {
+  let pending = cache.get(key);
+  if (!pending) {
+    pending = load2();
+    pending.catch(() => cache.delete(key));
+    cache.set(key, pending);
+  }
+  return pending;
+}
+function swiftIcuData(toolchainBin, release) {
+  return memo(raw, `${toolchainBin}\0${release}`, () => load(toolchainBin, release));
+}
+function swiftIcuAsset(toolchainBin, release) {
+  return memo(assets, `${toolchainBin}\0${release}`, async () => {
+    const zipped = await deflate(await swiftIcuData(toolchainBin, release));
+    return { sha256: (0, import_node_crypto.createHash)("sha256").update(zipped).digest("hex"), gzip: zipped };
+  });
+}
+async function load(toolchainBin, release) {
+  const { stdout } = await run(import_node_path.default.join(toolchainBin, "swift"), [
+    "sdk",
+    "configure",
+    "--show-configuration",
+    `${release}_wasm`,
+    "wasm32-unknown-wasip1"
+  ]);
+  const resources = /^swiftStaticResourcesPath: (.+)$/m.exec(stdout)?.[1]?.trim();
+  if (!resources) throw new Error(`swift-icu: ${release}_wasm names no static resources`);
+  return Buffer.from(
+    icuSegment(archiveMember((0, import_node_fs.readFileSync)(import_node_path.default.join(resources, ARCHIVE)), MEMBER))
+  );
+}
+function archiveMember(archive, name) {
+  if (archive.toString("latin1", 0, 8) !== "!<arch>\n")
+    throw new Error("swift-icu: not an ar archive");
+  let names = "";
+  for (let at = 8; at + 60 <= archive.length; ) {
+    const raw2 = archive.toString("latin1", at, at + 16).trimEnd();
+    const size = Number(archive.toString("latin1", at + 48, at + 58).trim());
+    const body = archive.subarray(at + 60, at + 60 + size);
+    if (raw2 === "//") names = body.toString("latin1");
+    const member = /^\/\d+$/.test(raw2) ? names.slice(Number(raw2.slice(1)), names.indexOf("/\n", Number(raw2.slice(1)))) : raw2.replace(/\/$/, "");
+    if (member === name) return body;
+    at += 60 + size + size % 2;
+  }
+  throw new Error(`swift-icu: ${name} is not in the sdk's icu archive`);
+}
+function icuSegment(object) {
+  let at = 8;
+  const leb = () => {
+    let result = 0;
+    let shift = 0;
+    let byte;
+    do {
+      byte = object[at++];
+      result += (byte & 127) * 2 ** shift;
+      shift += 7;
+    } while (byte & 128);
+    return result;
+  };
+  const found = [];
+  while (at < object.length) {
+    const id = object[at++];
+    const size = leb();
+    const end = at + size;
+    if (id === 11) {
+      for (let count = leb(); count > 0; count--) {
+        if (leb() !== 0) throw new Error("swift-icu: unexpected data segment kind");
+        at++;
+        leb();
+        at++;
+        const length = leb();
+        const bytes = object.subarray(at, at + length);
+        if (bytes[2] === 218 && bytes[3] === 39) found.push(bytes);
+        at += length;
+      }
+    }
+    at = end;
+  }
+  if (found.length !== 1)
+    throw new Error(`swift-icu: expected one icu data segment, found ${found.length}`);
+  return found[0];
+}
 
 // src/swift-package.ts
 function swiftManifestTargets(manifest) {
@@ -57,7 +157,8 @@ function swiftManifestTargets(manifest) {
   while ((match = pattern.exec(code)) !== null) {
     const executable = match[1] === "executableTarget";
     let depth = 1;
-    let i = pattern.lastIndex;
+    const start = pattern.lastIndex;
+    let i = start;
     let inString = false;
     let escaped = false;
     let flat = "";
@@ -86,26 +187,67 @@ function swiftManifestTargets(manifest) {
     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 });
+    const call = code.slice(start, i);
+    const languageMode = Number(
+      /\.swiftLanguageMode\(\s*\.v(\d+)\s*\)/.exec(call)?.[1] ?? "5"
+    );
+    const mainActorIsolation = /\.defaultIsolation\(\s*MainActor\.self\s*\)/.test(call);
+    targets.push({ name, path: targetPath, executable, languageMode, mainActorIsolation });
   }
   return targets;
 }
+function swiftPackagePartition(manifest) {
+  const targets = swiftManifestTargets(manifest);
+  return targets.length === 1 && targets[0].executable && targets[0].path === "." ? [] : targets;
+}
 
 // src/swift-compile.ts
-var run = (0, import_node_util.promisify)(import_node_child_process.execFile);
+var run2 = (0, import_node_util2.promisify)(import_node_child_process2.execFile);
 var WASM_TRIPLE = "wasm32-unknown-wasip1";
+var cores = import_node_os.default.availableParallelism();
+var BUILD_ENV = { ...process.env, BINARYEN_CORES: String(Math.min(4, cores)) };
+var BUILD_JOBS = String(Math.max(1, Math.floor(cores / 2)));
 function swiftModuleInputFiles(root) {
-  const files = ["Package.swift", "scripts/contrast-app-Package.swift"];
+  const files = [
+    "Package.swift",
+    "scripts/contrast-app-Package.swift",
+    "toolchain.json"
+  ];
   const walk = (dir) => {
-    for (const entry of (0, import_node_fs.readdirSync)(import_node_path.default.join(root, dir), { withFileTypes: true })) {
+    for (const entry of (0, import_node_fs2.readdirSync)(import_node_path2.default.join(root, dir), { withFileTypes: true })) {
       const relative = `${dir}/${entry.name}`;
       if (entry.isDirectory()) walk(relative);
-      else if (entry.name.endsWith(".swift")) files.push(relative);
+      else if (/\.(swift|c|h)$/.test(entry.name)) files.push(relative);
     }
   };
   walk("Sources");
   return files.sort();
 }
+async function ensureMacroPlugins(moduleRoot, toolchainBin) {
+  const dir = import_node_path2.default.join(moduleRoot, ".build/host/RnxPreviewMacros");
+  const ext = process.platform === "darwin" ? "dylib" : "so";
+  const plugins = [
+    {
+      library: import_node_path2.default.join(dir, `libRnxPreviewMacros.${ext}`),
+      source: import_node_path2.default.join(moduleRoot, "Sources/RnxPreviewMacros/PreviewMacro.swift")
+    },
+    {
+      library: import_node_path2.default.join(dir, `libFoundationMacros.${ext}`),
+      source: import_node_path2.default.join(moduleRoot, "Sources/FoundationMacros/PredicateMacro.swift")
+    }
+  ];
+  const stale = plugins.some(
+    ({ library, source }) => !(0, import_node_fs2.existsSync)(library) || (0, import_node_fs2.statSync)(source).mtimeMs > (0, import_node_fs2.statSync)(library).mtimeMs
+  );
+  if (stale) {
+    await run2("sh", [
+      import_node_path2.default.join(moduleRoot, "scripts/build-preview-plugin.sh"),
+      toolchainBin,
+      plugins[0].library
+    ]);
+  }
+  return plugins.map(({ library }) => library);
+}
 var linkedModuleDigests = /* @__PURE__ */ new Map();
 function clearLinkedModuleDigests(root) {
   if (root === void 0) linkedModuleDigests.clear();
@@ -113,9 +255,9 @@ function clearLinkedModuleDigests(root) {
 }
 function linkedModuleDigest(root) {
   const files = swiftModuleInputFiles(root);
-  const stampHash = (0, import_node_crypto.createHash)("sha256");
+  const stampHash = (0, import_node_crypto2.createHash)("sha256");
   for (const file of files) {
-    const stat = (0, import_node_fs.statSync)(import_node_path.default.join(root, file), { bigint: true });
+    const stat = (0, import_node_fs2.statSync)(import_node_path2.default.join(root, file), { bigint: true });
     stampHash.update(file);
     stampHash.update(
       `${stat.dev}:${stat.ino}:${stat.size}:${stat.mtimeNs}:${stat.ctimeNs}
@@ -125,11 +267,11 @@ function linkedModuleDigest(root) {
   const stamp = stampHash.digest("hex");
   const cached = linkedModuleDigests.get(root);
   if (cached?.stamp === stamp) return cached.digest;
-  const hash = (0, import_node_crypto.createHash)("sha256");
+  const hash = (0, import_node_crypto2.createHash)("sha256");
   for (const file of files) {
-    hash.update((0, import_node_crypto.createHash)("sha256").update(file).digest());
+    hash.update((0, import_node_crypto2.createHash)("sha256").update(file).digest());
     hash.update(
-      (0, import_node_crypto.createHash)("sha256").update((0, import_node_fs.readFileSync)(import_node_path.default.join(root, file))).digest()
+      (0, import_node_crypto2.createHash)("sha256").update((0, import_node_fs2.readFileSync)(import_node_path2.default.join(root, file))).digest()
     );
   }
   const digest = hash.digest();
@@ -138,7 +280,22 @@ function linkedModuleDigest(root) {
 }
 function compileTargets(input) {
   const manifest = input.files["Package.swift"];
-  return manifest === void 0 ? [] : swiftManifestTargets(manifest);
+  return manifest === void 0 ? [] : swiftPackagePartition(manifest);
+}
+function withNativeSourceGlue(input, glue) {
+  const targets = compileTargets(input);
+  if (targets.length > 1) {
+    throw new Error("swift native modules need one SwiftPM target");
+  }
+  const targetPath = targets[0]?.path === "." ? "" : targets[0]?.path ?? "";
+  return {
+    ...input,
+    files: {
+      ...input.files,
+      [import_node_path2.default.posix.join(targetPath, "OneNativeSource.generated.swift")]: glue
+    },
+    oneModule: true
+  };
 }
 function swiftSiblingDependencies(files, targets) {
   const names = new Set(targets.map((target) => target.name));
@@ -148,7 +305,9 @@ function swiftSiblingDependencies(files, targets) {
     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)) {
+      for (const match of contents.matchAll(
+        /^\s*(?:@\w+(?:\([^)]*\))?\s+)*import\s+(?:(?:typealias|struct|class|enum|protocol|let|var|func)\s+)?([A-Za-z_][A-Za-z0-9_]*)/gm
+      )) {
         if (names.has(match[1]) && match[1] !== target.name) deps.add(match[1]);
       }
     }
@@ -156,29 +315,32 @@ function swiftSiblingDependencies(files, targets) {
   }
   return siblings;
 }
-var MULTI_MANIFEST_VERSION = 1;
+var ONE_PRODUCT = '.product(name: "One", package: "sootsim-swift")';
+var ONE_IMPLICIT_FLAGS = ', "-Xfrontend", "-import-module", "-Xfrontend", "One"';
+var MULTI_MANIFEST_VERSION = 5;
 function swiftArtifactHash(input, release, moduleRoot) {
-  const hash = (0, import_node_crypto.createHash)("sha256");
+  const hash = (0, import_node_crypto2.createHash)("sha256");
   hash.update(`swift-compile/v1
 ${release}
 `);
+  if (input.oneModule) hash.update("one-module\n");
   hash.update(linkedModuleDigest(moduleRoot));
   for (const file of Object.keys(input.files).sort()) {
-    hash.update((0, import_node_crypto.createHash)("sha256").update(file).digest());
-    hash.update((0, import_node_crypto.createHash)("sha256").update(input.files[file]).digest());
+    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_crypto.createHash)("sha256").update(base).digest());
+    hash.update((0, import_node_crypto2.createHash)("sha256").update(base).digest());
     hash.update(
-      (0, import_node_crypto.createHash)("sha256").update(input.resources?.[base] ?? "").digest()
+      (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_crypto.createHash)("sha256").update(name).digest());
-    hash.update((0, import_node_crypto.createHash)("sha256").update(image.file).digest());
-    hash.update((0, import_node_crypto.createHash)("sha256").update(image.data).digest());
+    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) {
@@ -196,13 +358,15 @@ ${release}
   return hash.digest("hex");
 }
 function emitSwiftPackageManifest(args) {
-  const { targets, siblings, moduleRoot } = args;
+  const { targets, siblings, moduleRoot, oneModule } = 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 isolation = target.mainActorIsolation ? " .defaultIsolation(MainActor.self)," : "";
+    const swiftSettings = `swiftSettings: [.swiftLanguageMode(.v${target.languageMode}),${isolation} .unsafeFlags(["-Osize"${oneModule ? ONE_IMPLICIT_FLAGS : ""}])]`;
     const deps = [
       '.product(name: "SwiftUI", package: "sootsim-swift")',
+      ...oneModule ? [ONE_PRODUCT] : [],
       ...(siblings.get(target.name) ?? []).map((sibling) => `"${sibling}"`)
     ].join(", ");
     const kind = target.executable ? ".executableTarget" : ".target";
@@ -224,7 +388,7 @@ function emitSwiftPackageManifest(args) {
     ].join("\n");
   };
   return [
-    "// swift-tools-version: 6.0",
+    "// swift-tools-version: 6.2",
     "import PackageDescription",
     "",
     "// generated by swift-compile from the project package partition.",
@@ -239,42 +403,63 @@ function emitSwiftPackageManifest(args) {
     ""
   ].join("\n");
 }
+function syncSwiftTree(base, files) {
+  (0, import_node_fs2.mkdirSync)(base, { recursive: true });
+  const walk = (dir) => {
+    for (const entry of (0, import_node_fs2.readdirSync)(dir, { withFileTypes: true })) {
+      const full = import_node_path2.default.join(dir, entry.name);
+      if (dir === base && entry.name === ".build") continue;
+      if (entry.isDirectory()) walk(full);
+      else if (!files.has(full)) (0, import_node_fs2.rmSync)(full, { force: true });
+    }
+  };
+  walk(base);
+  for (const [full, contents] of files) {
+    if ((0, import_node_fs2.existsSync)(full) && (0, import_node_fs2.readFileSync)(full, "utf8") === contents) continue;
+    (0, import_node_fs2.mkdirSync)(import_node_path2.default.dirname(full), { recursive: true });
+    (0, import_node_fs2.writeFileSync)(full, contents, "utf8");
+  }
+}
 function writeSwiftProject(layout, input, moduleRoot) {
   const targets = compileTargets(input);
+  const files = /* @__PURE__ */ new Map();
   if (targets.length === 0) {
-    (0, import_node_fs.rmSync)(layout.sources, { recursive: true, force: true });
     for (const [file, contents] of Object.entries(input.files)) {
-      const target = import_node_path.default.join(layout.sources, file);
-      (0, import_node_fs.mkdirSync)(import_node_path.default.dirname(target), { recursive: true });
-      (0, import_node_fs.writeFileSync)(target, contents, "utf8");
+      if (file === "Package.swift") continue;
+      files.set(import_node_path2.default.join(layout.sources, file), contents);
     }
-    const manifest = (0, import_node_fs.readFileSync)(
-      import_node_path.default.join(moduleRoot, "scripts/contrast-app-Package.swift"),
+    let manifest = (0, import_node_fs2.readFileSync)(
+      import_node_path2.default.join(moduleRoot, "scripts/contrast-app-Package.swift"),
       "utf8"
     ).replaceAll("__SOOTSIM_SWIFT_PACKAGE__", moduleRoot);
-    (0, import_node_fs.writeFileSync)(import_node_path.default.join(layout.root, "Package.swift"), manifest, "utf8");
-    return;
-  }
-  (0, import_node_fs.mkdirSync)(layout.root, { recursive: true });
-  for (const child of (0, import_node_fs.readdirSync)(layout.root)) {
-    if (child === ".build") continue;
-    (0, import_node_fs.rmSync)(import_node_path.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_path.default.join(layout.root, file);
-    (0, import_node_fs.mkdirSync)(import_node_path.default.dirname(target), { recursive: true });
-    (0, import_node_fs.writeFileSync)(target, contents, "utf8");
+    if (input.oneModule) {
+      const product = '.product(name: "CoreLocation", package: "sootsim-swift"),';
+      const flags = '"-Osize"';
+      if (!manifest.includes(product) || !manifest.includes(flags)) {
+        throw new Error(
+          "scripts/contrast-app-Package.swift lost the lines the One module links at"
+        );
+      }
+      manifest = manifest.replace(product, `${product}
+        ${ONE_PRODUCT},`).replace(flags, `${flags}${ONE_IMPLICIT_FLAGS}`);
+    }
+    files.set(import_node_path2.default.join(layout.root, "Package.swift"), manifest);
+  } else {
+    for (const [file, contents] of Object.entries(input.files)) {
+      if (file === "Package.swift") continue;
+      files.set(import_node_path2.default.join(layout.root, file), contents);
+    }
+    files.set(
+      import_node_path2.default.join(layout.root, "Package.swift"),
+      emitSwiftPackageManifest({
+        targets,
+        siblings: swiftSiblingDependencies(input.files, targets),
+        moduleRoot,
+        oneModule: input.oneModule
+      })
+    );
   }
-  (0, import_node_fs.writeFileSync)(
-    import_node_path.default.join(layout.root, "Package.swift"),
-    emitSwiftPackageManifest({
-      targets,
-      siblings: swiftSiblingDependencies(input.files, targets),
-      moduleRoot
-    }),
-    "utf8"
-  );
+  syncSwiftTree(layout.root, files);
 }
 function streamText(value) {
   if (typeof value === "string") return value.trim();
@@ -292,18 +477,24 @@ function outputOf(error) {
   return error instanceof Error ? error.message : String(error);
 }
 function builtArtifact(layout) {
-  const binDir = import_node_path.default.join(layout.root, ".build", WASM_TRIPLE, "release");
-  const artifacts = (0, import_node_fs.existsSync)(binDir) ? (0, import_node_fs.readdirSync)(binDir).filter((name) => name.endsWith(".wasm")).sort() : [];
-  if (artifacts.length !== 1) {
+  const binDir = import_node_path2.default.join(layout.root, ".build", WASM_TRIPLE, "release");
+  const manifest = (0, import_node_fs2.readFileSync)(import_node_path2.default.join(layout.root, "Package.swift"), "utf8");
+  const executable = swiftManifestTargets(manifest).find((target) => target.executable);
+  if (executable === void 0) {
+    throw new Error("swift-compile: the written manifest names no executable target");
+  }
+  const file = import_node_path2.default.join(binDir, `${executable.name}.wasm`);
+  if (!(0, import_node_fs2.existsSync)(file)) {
+    const found = (0, import_node_fs2.existsSync)(binDir) ? (0, import_node_fs2.readdirSync)(binDir).filter((name) => name.endsWith(".wasm")).sort() : [];
     throw new Error(
-      `swift-compile: the build produced ${artifacts.length} wasm artifacts; exactly one executable is the app`
+      `swift-compile: the build produced no ${executable.name}.wasm (found: ${found.join(", ") || "none"})`
     );
   }
-  return import_node_path.default.join(binDir, artifacts[0]);
+  return file;
 }
 function projectDiagnostic(output, layout) {
   const base = layout.multi ? layout.root : layout.sources;
-  const prefix = `${base}${import_node_path.default.sep}`;
+  const prefix = `${base}${import_node_path2.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");
@@ -320,28 +511,32 @@ function serialize(root, work) {
   return next;
 }
 function compileSwiftProjectUnit(input, options) {
-  (0, import_node_fs.mkdirSync)(options.buildRoot, { recursive: true });
-  const root = (0, import_node_fs.realpathSync)(options.buildRoot);
-  const moduleRoot = import_node_path.default.resolve(options.moduleRoot);
+  (0, import_node_fs2.mkdirSync)(options.buildRoot, { recursive: true });
+  const root = (0, import_node_fs2.realpathSync)(options.buildRoot);
+  const moduleRoot = import_node_path2.default.resolve(options.moduleRoot);
   const layout = {
     root,
-    sources: import_node_path.default.join(root, "Sources", "App"),
+    sources: import_node_path2.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_path.default.join(options.toolchainBin, "swift");
-    if (!(0, import_node_fs.existsSync)(swift)) {
+    const swift = import_node_path2.default.join(options.toolchainBin, "swift");
+    if (!(0, import_node_fs2.existsSync)(swift)) {
       throw new Error(
         `swift-compile: no swift.org toolchain at ${options.toolchainBin}; install ${options.release} and its matching wasm sdk`
       );
     }
+    const macroPlugins = await ensureMacroPlugins(moduleRoot, options.toolchainBin);
+    const icu = swiftIcuAsset(options.toolchainBin, options.release);
     try {
-      await run(
+      await run2(
         swift,
         [
           "build",
+          "-j",
+          BUILD_JOBS,
           "--package-path",
           root,
           "--swift-sdk",
@@ -349,14 +544,24 @@ function compileSwiftProjectUnit(input, options) {
           "-c",
           "release",
           "-Xswiftc",
-          "-Osize"
+          "-Osize",
+          ...macroPlugins.flatMap((plugin) => [
+            "-Xswiftc",
+            "-load-plugin-library",
+            "-Xswiftc",
+            plugin
+          ])
         ],
-        { maxBuffer: 64 * 1024 * 1024, timeout: options.timeoutMs }
+        { env: BUILD_ENV, maxBuffer: 64 * 1024 * 1024, timeout: options.timeoutMs }
       );
     } catch (error) {
       throw new Error(projectDiagnostic(outputOf(error), layout), { cause: error });
     }
-    return { hash, bytes: (0, import_node_fs.readFileSync)(builtArtifact(layout)) };
+    return {
+      hash,
+      bytes: (0, import_node_fs2.readFileSync)(builtArtifact(layout)),
+      icu: await icu
+    };
   });
 }
 // Annotate the CommonJS export names for ESM import in node:
@@ -367,6 +572,8 @@ function compileSwiftProjectUnit(input, options) {
   compileTargets,
   emitSwiftPackageManifest,
   swiftArtifactHash,
+  swiftIcuAsset,
   swiftModuleInputFiles,
+  withNativeSourceGlue,
   writeSwiftProject
 });