peachsim 0.1.1625 → 0.1.1640

package/dist-lib/swift-toolchain.cjs

@@ -1,4 +1,4 @@
-/*! peach v0.1.1625 | (c) 2026 Tamagui LLC | Proprietary; see LICENSE */
+/*! peach v0.1.1640 | (c) 2026 Tamagui LLC | Proprietary; see LICENSE */
 let __sootsim_import_meta_url = '', __sootsim_import_meta_dirname = ''; try { __sootsim_import_meta_url = require('url').pathToFileURL(__filename).href; __sootsim_import_meta_dirname = __dirname; } catch {}
 "use strict";
 var __create = Object.create;
@@ -32,18 +32,70 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/swift-toolchain.ts
 var swift_toolchain_exports = {};
 __export(swift_toolchain_exports, {
+  SWIFT_HOST_COMPILER_ID: () => SWIFT_HOST_COMPILER_ID,
+  SWIFT_HOST_COMPILER_RELEASE: () => SWIFT_HOST_COMPILER_RELEASE,
+  confineSwiftScratch: () => confineSwiftScratch,
+  installSwiftWasmSdk: () => installSwiftWasmSdk,
+  swiftCompiler: () => swiftCompiler,
+  swiftCompilerInstallSteps: () => swiftCompilerInstallSteps,
   swiftCompilerRelease: () => swiftCompilerRelease,
+  swiftEnvironment: () => swiftEnvironment,
+  swiftFileChecksum: () => swiftFileChecksum,
+  swiftHostCompilerArchive: () => swiftHostCompilerArchive,
   swiftInstallSteps: () => swiftInstallSteps,
+  swiftSdkInstallStep: () => swiftSdkInstallStep,
+  swiftSdkOptions: () => swiftSdkOptions,
   swiftToolchain: () => swiftToolchain,
-  swiftToolchainBin: () => swiftToolchainBin
+  swiftToolchainBin: () => swiftToolchainBin,
+  swiftUpstreamRelease: () => swiftUpstreamRelease,
+  verifySwiftHostCompiler: () => verifySwiftHostCompiler
 });
 module.exports = __toCommonJS(swift_toolchain_exports);
 var import_node_child_process = require("node:child_process");
+var import_node_crypto = require("node:crypto");
 var import_node_fs = __toESM(require("node:fs"), 1);
 var import_node_os = __toESM(require("node:os"), 1);
 var import_node_path = __toESM(require("node:path"), 1);
+var import_node_url = require("node:url");
+function swiftSdkOptions() {
+  const directory = process.env.PEACH_SWIFT_SDKS_PATH;
+  return directory ? ["--swift-sdks-path", import_node_path.default.resolve(directory)] : [];
+}
+var SWIFT_HOST_COMPILER_RELEASE = "swift-6.4.0-RELEASE-custom-0d775d32d7c74eae";
+var SWIFT_HOST_COMPILER_ID = "0d775d32d7c74eae";
+var compilerArchives = {
+  "darwin-arm64": {
+    checksum: "957e85486f92327ee5cf8d3c5bb9336d17ab80145c87645c637c49130a50477a",
+    manifest: "c63e2f81694e8d8ad046d10c71d0638dbae4e5a36601294ed670988d1cb5b6f1"
+  },
+  "linux-x64": {
+    checksum: "6302230fb126b79c9af5fc2bc0208a936bb573c343da7ae949c5c1687e761cd2",
+    manifest: "31b507a6a8648a2266a187b9fed092e29a63cae99d57c5defdf2e82a7cbbc113"
+  },
+  "linux-arm64": {
+    checksum: "9b40d39ea5ba82fd9a417868f0a449f5e98e37cf83acaac9cedd3a8b8d91a218",
+    manifest: "fe07a29d4f4374cad47b29de70e90aa2e3b7664e08c8b53d304585e65637da24"
+  }
+};
+function swiftHostCompilerArchive(release, host = `${process.platform}-${process.arch}`) {
+  if (release !== SWIFT_HOST_COMPILER_RELEASE)
+    throw new Error(`unqualified host compiler ${release}`);
+  const archive = compilerArchives[host];
+  if (!archive) throw new Error(`unsupported Swift compiler host ${host}`);
+  return {
+    ...archive,
+    identity: SWIFT_HOST_COMPILER_ID,
+    url: `https://r2.sootsim.com/swift-host-compiler/${SWIFT_HOST_COMPILER_ID}/${release}-${host}.tar.gz`
+  };
+}
+function swiftUpstreamRelease(release) {
+  return release.replace(/-custom-[a-f0-9]{16}$/, "");
+}
 function swiftCompilerRelease(release) {
-  return release.replace(/^swift-(\d+\.\d+)\.0-RELEASE$/, "swift-$1-RELEASE");
+  return swiftUpstreamRelease(release).replace(
+    /^swift-(\d+\.\d+)\.0-RELEASE$/,
+    "swift-$1-RELEASE"
+  );
 }
 function swiftToolchainBin(release) {
   if (process.platform === "darwin") {
@@ -57,64 +109,402 @@ function swiftToolchainBin(release) {
   }
   const image = import_node_path.default.join("/opt/swift", release, "usr/bin");
   if (import_node_fs.default.existsSync(import_node_path.default.join(image, "swift"))) return image;
+  if (release.includes("-custom-"))
+    return import_node_path.default.join(peachHome(), "swift", "toolchains", release, "usr/bin");
   return (process.env.PATH ?? "").split(import_node_path.default.delimiter).find((dir) => dir && import_node_fs.default.existsSync(import_node_path.default.join(dir, "swift"))) ?? image;
 }
-var verified = /* @__PURE__ */ new Map();
+function peachHome() {
+  const override = process.env.PEACH_HOME;
+  return override ? import_node_path.default.resolve(override) : import_node_path.default.join(import_node_os.default.homedir(), ".peach");
+}
+var scratch;
+var swiftHome;
+function confineSwiftScratch(root) {
+  if (scratch) return;
+  import_node_fs.default.mkdirSync(root, { recursive: true });
+  for (const name of import_node_fs.default.readdirSync(root)) {
+    const pid = Number(name);
+    if (Number.isInteger(pid) && pid > 0 && !processRuns(pid))
+      import_node_fs.default.rmSync(import_node_path.default.join(root, name), { recursive: true, force: true });
+  }
+  const dir = import_node_path.default.join(root, String(process.pid));
+  import_node_fs.default.mkdirSync(dir, { recursive: true });
+  scratch = dir;
+  if (process.platform === "linux") {
+    swiftHome = import_node_path.default.join(root, "home");
+    import_node_fs.default.mkdirSync(swiftHome, { recursive: true });
+  }
+  const seeded = import_node_path.default.join(import_node_os.default.homedir(), ".swiftpm");
+  const dirAbsentBefore = lstatIfKnown(seeded) === null;
+  const absentBefore = swiftpmSeeds.filter(
+    (name) => lstatIfKnown(import_node_path.default.join(seeded, name)) === null
+  );
+  process.once("exit", () => {
+    import_node_fs.default.rmSync(dir, { recursive: true, force: true });
+    for (const name of absentBefore) removeSwiftpmSeed(import_node_path.default.join(seeded, name), name);
+    if (dirAbsentBefore && lstatIfKnown(seeded)?.isDirectory())
+      try {
+        import_node_fs.default.rmdirSync(seeded);
+      } catch {
+      }
+  });
+}
+var swiftpmSeeds = ["cache", "configuration", "security"];
+function lstatIfKnown(entry) {
+  try {
+    return import_node_fs.default.lstatSync(entry);
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") return null;
+    return void 0;
+  }
+}
+function removeSwiftpmSeed(entry, name) {
+  const stat = lstatIfKnown(entry);
+  if (!stat) return;
+  try {
+    if (name === "cache") {
+      if (stat.isSymbolicLink() && import_node_fs.default.readlinkSync(entry).endsWith("/.cache/org.swift.swiftpm"))
+        import_node_fs.default.unlinkSync(entry);
+    } else if (stat.isDirectory()) {
+      import_node_fs.default.rmdirSync(entry);
+    }
+  } catch {
+  }
+}
+function processRuns(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error instanceof Error && "code" in error && error.code === "EPERM";
+  }
+}
+function swiftEnvironment(base = process.env) {
+  if (!scratch) return base;
+  return swiftHome ? { ...base, TMPDIR: scratch, HOME: swiftHome } : { ...base, TMPDIR: scratch };
+}
 function swiftToolchain(release, sdk) {
-  const cached = verified.get(`${release}\0${sdk.wasmSdkId}`);
-  if (cached) return cached;
-  const bin = swiftToolchainBin(release);
-  const swift = import_node_path.default.join(bin, "swift");
-  const version = import_node_fs.default.existsSync(swift) ? (0, import_node_child_process.execFileSync)(swift, ["--version"], {
-    encoding: "utf8",
-    stdio: ["ignore", "pipe", "pipe"]
-  }) : "";
-  if (!version.includes(`(${swiftCompilerRelease(release)})`)) {
-    const found = version ? `found ${version.split("\n")[0]?.trim()} at ${swift}` : process.platform === "darwin" ? `found no ${release}.xctoolchain in ~/Library/Developer/Toolchains or /Library/Developer/Toolchains` : "found no swift on PATH";
+  validateSwiftSdkIdentity(sdk);
+  let bin;
+  try {
+    bin = swiftCompiler(release);
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
     throw new Error(
-      `peach compiles Swift with the swift.org toolchain ${release} and its wasm SDK; ${found}.
+      `Swift compiler ${release} is unavailable or differs from its pin: ${reason}
 ${swiftInstallSteps(release, sdk)}`
     );
   }
-  const sdks = (0, import_node_child_process.execFileSync)(swift, ["sdk", "list"], {
+  const swift = import_node_path.default.join(bin, "swift");
+  const sdks = (0, import_node_child_process.execFileSync)(swift, ["sdk", "list", ...swiftSdkOptions()], {
     encoding: "utf8",
+    env: swiftEnvironment(),
     stdio: ["ignore", "pipe", "pipe"]
   });
   if (!sdks.split("\n").some((line) => line.trim() === sdk.wasmSdkId)) {
     throw new Error(
       `peach compiles Swift with the ${sdk.wasmSdkId} SDK, which ${swift} does not have.
-${swiftInstallSteps(release, sdk)}`
+${swiftSdkInstallStep(release, sdk)}`
+    );
+  }
+  try {
+    verifySwiftSdk(swift, sdk);
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    throw new Error(`${reason}
+${swiftSdkInstallStep(release, sdk)}`);
+  }
+  return bin;
+}
+function validateSwiftSdkIdentity(sdk) {
+  if (!/^[a-zA-Z0-9._-]+$/.test(sdk.wasmSdkId) || !/^[a-f0-9]{64}$/.test(sdk.wasmSdkChecksum))
+    throw new Error("invalid Swift SDK identity or checksum");
+}
+function swiftSdkBundle(swift, id, options) {
+  const configuration = (0, import_node_child_process.execFileSync)(
+    swift,
+    ["sdk", "configure", ...options, "--show-configuration", id, "wasm32-unknown-wasip1"],
+    { encoding: "utf8", env: swiftEnvironment(), stdio: ["ignore", "pipe", "pipe"] }
+  );
+  const sysroot = /^sdkRootPath: (.+)$/m.exec(configuration)?.[1]?.trim();
+  if (!sysroot || !import_node_path.default.isAbsolute(sysroot))
+    throw new Error(`Swift SDK ${id} reports no absolute sdkRootPath`);
+  let bundle = sysroot;
+  while (!bundle.endsWith(".artifactbundle")) {
+    const parent = import_node_path.default.dirname(bundle);
+    if (parent === bundle)
+      throw new Error(`Swift SDK ${id} is outside an artifact bundle`);
+    bundle = parent;
+  }
+  return import_node_fs.default.realpathSync(bundle);
+}
+var sdkFileHashes = /* @__PURE__ */ new Map();
+function swiftSdkPayloadChecksum(bundle) {
+  const hash = (0, import_node_crypto.createHash)("sha256");
+  function visit(relative) {
+    const file = import_node_path.default.join(bundle, relative);
+    const stat = import_node_fs.default.lstatSync(file, { bigint: true });
+    if (stat.isSymbolicLink()) {
+      const resolved = import_node_path.default.relative(bundle, import_node_fs.default.realpathSync(file));
+      if (resolved === ".." || resolved.startsWith(`..${import_node_path.default.sep}`) || import_node_path.default.isAbsolute(resolved))
+        throw new Error(`Swift SDK symlink escapes its bundle: ${relative}`);
+      hash.update(JSON.stringify([relative, "link", import_node_fs.default.readlinkSync(file)]) + "\n");
+    } else if (stat.isDirectory()) {
+      hash.update(JSON.stringify([relative, "directory"]) + "\n");
+      for (const name of import_node_fs.default.readdirSync(file).sort()) visit(import_node_path.default.join(relative, name));
+    } else if (stat.isFile()) {
+      const stamp = [stat.dev, stat.ino, stat.size, stat.mtimeNs, stat.ctimeNs].join(":");
+      let cached = sdkFileHashes.get(file);
+      if (cached?.stamp !== stamp) {
+        cached = { stamp, checksum: swiftFileChecksum(file) };
+        sdkFileHashes.set(file, cached);
+      }
+      hash.update(
+        JSON.stringify([relative, "file", Number(stat.mode & 0o111n), cached.checksum]) + "\n"
+      );
+    } else throw new Error(`unsupported Swift SDK payload entry: ${relative}`);
+  }
+  visit("");
+  return hash.digest("hex");
+}
+function swiftSdkVerificationFile(bundle, sdk) {
+  return import_node_path.default.join(
+    import_node_path.default.dirname(bundle),
+    ".peach-sdk-checksums",
+    `${sdk.wasmSdkId}-${sdk.wasmSdkChecksum}.json`
+  );
+}
+function verifySwiftSdk(swift, sdk) {
+  const bundle = swiftSdkBundle(swift, sdk.wasmSdkId, swiftSdkOptions());
+  const file = swiftSdkVerificationFile(bundle, sdk);
+  if (!import_node_fs.default.existsSync(file))
+    throw new Error(
+      `Swift SDK ${sdk.wasmSdkId} has no verified archive binding for ${sdk.wasmSdkChecksum}. Hydrate it with installSwiftWasmSdk before compiling.`
+    );
+  const receipt = JSON.parse(import_node_fs.default.readFileSync(file, "utf8"));
+  if (!receipt || typeof receipt !== "object" || !("wasmSdkId" in receipt) || receipt.wasmSdkId !== sdk.wasmSdkId || !("wasmSdkChecksum" in receipt) || receipt.wasmSdkChecksum !== sdk.wasmSdkChecksum || !("payloadChecksum" in receipt) || receipt.payloadChecksum !== swiftSdkPayloadChecksum(bundle))
+    throw new Error(
+      `Swift SDK ${sdk.wasmSdkId} installed payload differs from its verified archive ${sdk.wasmSdkChecksum}`
     );
+}
+function installSwiftSdkArchive(swift, sdk, archive) {
+  validateSwiftSdkIdentity(sdk);
+  const staging = import_node_fs.default.realpathSync(
+    import_node_fs.default.mkdtempSync(import_node_path.default.join(scratch ?? import_node_os.default.tmpdir(), "peach-sdk-verification-"))
+  );
+  try {
+    if (swiftFileChecksum(archive) !== sdk.wasmSdkChecksum)
+      throw new Error("declared Swift SDK archive checksum mismatch");
+    const store = import_node_path.default.join(staging, "sdks");
+    import_node_fs.default.mkdirSync(store);
+    (0, import_node_child_process.execFileSync)(
+      swift,
+      [
+        "sdk",
+        "install",
+        archive,
+        "--checksum",
+        sdk.wasmSdkChecksum,
+        "--swift-sdks-path",
+        store
+      ],
+      { env: swiftEnvironment(), stdio: "inherit" }
+    );
+    const stagedBundle = swiftSdkBundle(swift, sdk.wasmSdkId, [
+      "--swift-sdks-path",
+      store
+    ]);
+    const expected = swiftSdkPayloadChecksum(stagedBundle);
+    const directory = process.env.PEACH_SWIFT_SDKS_PATH;
+    const locks = directory ? import_node_path.default.join(import_node_path.default.resolve(directory), ".peach-locks") : import_node_path.default.join(import_node_os.default.homedir(), ".swiftpm", "builder-locks");
+    import_node_fs.default.mkdirSync(locks, { recursive: true });
+    (0, import_node_child_process.execFileSync)(
+      "perl",
+      [
+        "-e",
+        'use Fcntl qw(:flock); my ($lock, $id, $bundle, $swift, @options) = @ARGV; open(my $fd, ">>", $lock) or die $!; flock($fd, LOCK_EX) or die $!; open(my $list, "-|", $swift, "sdk", "list", @options) or die $!; my $found = 0; while (<$list>) { s/^\\s+|\\s+$//g; $found = 1 if $_ eq $id; } close($list) or die "swift sdk list failed"; unless ($found) { system($swift, "sdk", "install", $bundle, @options); exit(($? & 127) ? 128 + ($? & 127) : $? >> 8); }',
+        import_node_path.default.join(locks, "wasm-sdk.lock"),
+        sdk.wasmSdkId,
+        stagedBundle,
+        swift,
+        ...swiftSdkOptions()
+      ],
+      { env: swiftEnvironment(), stdio: "inherit" }
+    );
+    const bundle = swiftSdkBundle(swift, sdk.wasmSdkId, swiftSdkOptions());
+    if (swiftSdkPayloadChecksum(bundle) !== expected)
+      throw new Error(
+        `Swift SDK ${sdk.wasmSdkId} already exists with different payload bytes; select a separate --swift-sdks-path. No installed SDK was replaced.`
+      );
+    const file = swiftSdkVerificationFile(bundle, sdk);
+    import_node_fs.default.mkdirSync(import_node_path.default.dirname(file), { recursive: true });
+    const temporary = `${file}.${process.pid}.tmp`;
+    try {
+      import_node_fs.default.writeFileSync(
+        temporary,
+        JSON.stringify({
+          wasmSdkId: sdk.wasmSdkId,
+          wasmSdkChecksum: sdk.wasmSdkChecksum,
+          payloadChecksum: expected
+        }) + "\n"
+      );
+      import_node_fs.default.renameSync(temporary, file);
+    } finally {
+      import_node_fs.default.rmSync(temporary, { force: true });
+    }
+  } finally {
+    import_node_fs.default.rmSync(staging, { recursive: true, force: true });
+    for (const file of sdkFileHashes.keys())
+      if (file.startsWith(staging + import_node_path.default.sep)) sdkFileHashes.delete(file);
   }
-  verified.set(`${release}\0${sdk.wasmSdkId}`, bin);
+}
+function installSwiftWasmSdk(release, sdk) {
+  validateSwiftSdkIdentity(sdk);
+  try {
+    swiftToolchain(release, sdk);
+    return;
+  } catch {
+  }
+  const swift = import_node_path.default.join(swiftCompiler(release), "swift");
+  const staging = import_node_fs.default.mkdtempSync(import_node_path.default.join(scratch ?? import_node_os.default.tmpdir(), "builder-swift-sdk-"));
+  const archive = import_node_path.default.join(staging, "sdk.artifactbundle.tar.gz");
+  try {
+    if (sdk.wasmSdkUrl.startsWith("file:"))
+      import_node_fs.default.copyFileSync((0, import_node_url.fileURLToPath)(sdk.wasmSdkUrl), archive);
+    else
+      (0, import_node_child_process.execFileSync)("curl", ["-fsSL", sdk.wasmSdkUrl, "-o", archive], { stdio: "inherit" });
+    installSwiftSdkArchive(swift, sdk, archive);
+    swiftToolchain(release, sdk);
+  } finally {
+    import_node_fs.default.rmSync(staging, { recursive: true, force: true });
+  }
+}
+function swiftFileChecksum(file) {
+  const hash = (0, import_node_crypto.createHash)("sha256");
+  const fd = import_node_fs.default.openSync(file, "r");
+  const buffer = Buffer.allocUnsafe(1024 * 1024);
+  try {
+    let size = import_node_fs.default.readSync(fd, buffer, 0, buffer.length, null);
+    while (size > 0) {
+      hash.update(buffer.subarray(0, size));
+      size = import_node_fs.default.readSync(fd, buffer, 0, buffer.length, null);
+    }
+  } finally {
+    import_node_fs.default.closeSync(fd);
+  }
+  return hash.digest("hex");
+}
+function verifySwiftHostCompiler(release, root) {
+  const pin = swiftHostCompilerArchive(release);
+  const file = import_node_path.default.join(root, "compiler.json");
+  if (swiftFileChecksum(file) !== pin.manifest)
+    throw new Error(`Swift compiler manifest mismatch at ${root}`);
+  const manifest = JSON.parse(import_node_fs.default.readFileSync(file, "utf8"));
+  if (!manifest || typeof manifest !== "object" || !("identity" in manifest) || manifest.identity !== pin.identity || !("host" in manifest) || manifest.host !== `${process.platform}-${process.arch}` || !("files" in manifest) || !manifest.files || typeof manifest.files !== "object") {
+    throw new Error(`Swift compiler identity mismatch at ${root}`);
+  }
+  const files = Object.entries(manifest.files);
+  if (files.length !== 16) throw new Error("incomplete Swift compiler manifest");
+  for (const [relative, checksum] of files) {
+    if (relative.startsWith("/") || relative.split("/").includes("..") || typeof checksum !== "string" || swiftFileChecksum(import_node_path.default.join(root, relative)) !== checksum) {
+      throw new Error(`Swift compiler binary mismatch: ${relative}`);
+    }
+  }
+}
+var verifiedCompilers = /* @__PURE__ */ new Map();
+function swiftCompiler(release) {
+  const cached = verifiedCompilers.get(release);
+  if (cached) return cached;
+  const bin = swiftToolchainBin(release);
+  if (release.includes("-custom-"))
+    verifySwiftHostCompiler(release, import_node_path.default.resolve(bin, "../.."));
+  const version = (0, import_node_child_process.execFileSync)(import_node_path.default.join(bin, "swift"), ["--version"], {
+    encoding: "utf8",
+    env: swiftEnvironment(),
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  if (!version.includes(`(${swiftCompilerRelease(release)})`))
+    throw new Error(`compiler release mismatch at ${bin}`);
+  verifiedCompilers.set(release, bin);
   return bin;
 }
+function swiftSdkInstallStep(release, wasmSdk) {
+  return `install the pinned SDK:
+  ${swiftSdkInstallCommand(release, wasmSdk)}`;
+}
+function swiftSdkInstallCommand(release, wasmSdk) {
+  const { wasmSdkId, wasmSdkUrl, wasmSdkChecksum } = wasmSdk;
+  const program = `import { installSwiftWasmSdk } from "peachsim/swift-toolchain"; installSwiftWasmSdk(${JSON.stringify(release)}, ${JSON.stringify({ wasmSdkId, wasmSdkUrl, wasmSdkChecksum })})`;
+  const directory = process.env.PEACH_SWIFT_SDKS_PATH;
+  const environment = directory ? `PEACH_SWIFT_SDKS_PATH='${import_node_path.default.resolve(directory).replaceAll("'", "'\\''")}' ` : "";
+  return `${environment}node --input-type=module -e '${program.replaceAll("'", "'\\''")}'`;
+}
 function swiftInstallSteps(release, wasmSdk) {
+  const { note, commands } = swiftCompilerInstall(release);
+  return [
+    `install the pinned compiler and SDK${note}:`,
+    ...[...commands, swiftSdkInstallCommand(release, wasmSdk)].map((line) => `  ${line}`)
+  ].join("\n");
+}
+function swiftCompilerInstallSteps(release) {
+  const { note, commands } = swiftCompilerInstall(release);
+  return [
+    `install the pinned compiler${note}:`,
+    ...commands.map((line) => `  ${line}`)
+  ].join("\n");
+}
+function swiftCompilerInstall(release) {
+  if (release.includes("-custom-")) {
+    const archive = swiftHostCompilerArchive(release);
+    const directory = import_node_path.default.resolve(swiftToolchainBin(release), "../..");
+    return {
+      note: "",
+      commands: [
+        `curl -fsSL ${archive.url} -o compiler.tar.gz`,
+        `echo '${archive.checksum}  compiler.tar.gz' | shasum -a 256 -c -`,
+        `mkdir -p '${directory}'`,
+        `tar -xzf compiler.tar.gz --strip-components=1 -C '${directory}'`
+      ]
+    };
+  }
   const version = release.replace(/^swift-/, "").toLowerCase();
   const downloads = `https://download.swift.org/swift-${version}`;
-  const sdk = `swift sdk install ${wasmSdk.wasmSdkUrl} --checksum ${wasmSdk.wasmSdkChecksum}`;
   if (process.platform === "darwin") {
-    const swift = `~/Library/Developer/Toolchains/${release}.xctoolchain/usr/bin/swift`;
-    return [
-      "install it:",
-      `  curl -fsSLO ${downloads}/xcode/${release}/${release}-osx.pkg`,
-      `  installer -pkg ${release}-osx.pkg -target CurrentUserHomeDirectory`,
-      `  ${swift} ${sdk.replace(/^swift /, "")}`
-    ].join("\n");
+    return {
+      note: "",
+      commands: [
+        `curl -fsSLO ${downloads}/xcode/${release}/${release}-osx.pkg`,
+        `installer -pkg ${release}-osx.pkg -target CurrentUserHomeDirectory`
+      ]
+    };
   }
   const platform = `debian12${process.arch === "arm64" ? "-aarch64" : ""}`;
   const name = `${release}-${platform}`;
-  return [
-    "install it (Debian 12 shown; other distributions: https://www.swift.org/install/linux/):",
-    `  curl -fsSL ${downloads}/${platform}/${release}/${name}.tar.gz | tar -xz -C /opt`,
-    `  export PATH=/opt/${name}/usr/bin:$PATH`,
-    `  ${sdk}`
-  ].join("\n");
+  return {
+    note: " (Debian 12 shown; other distributions: https://www.swift.org/install/linux/)",
+    commands: [
+      `curl -fsSL ${downloads}/${platform}/${release}/${name}.tar.gz | tar -xz -C /opt`,
+      `export PATH=/opt/${name}/usr/bin:$PATH`
+    ]
+  };
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  SWIFT_HOST_COMPILER_ID,
+  SWIFT_HOST_COMPILER_RELEASE,
+  confineSwiftScratch,
+  installSwiftWasmSdk,
+  swiftCompiler,
+  swiftCompilerInstallSteps,
   swiftCompilerRelease,
+  swiftEnvironment,
+  swiftFileChecksum,
+  swiftHostCompilerArchive,
   swiftInstallSteps,
+  swiftSdkInstallStep,
+  swiftSdkOptions,
   swiftToolchain,
-  swiftToolchainBin
+  swiftToolchainBin,
+  swiftUpstreamRelease,
+  verifySwiftHostCompiler
 });

package/dist-lib/swift.cjs

@@ -1,4 +1,4 @@
-/*! peach v0.1.1625 | (c) 2026 Tamagui LLC | Proprietary; see LICENSE */
+/*! peach v0.1.1640 | (c) 2026 Tamagui LLC | Proprietary; see LICENSE */
 let __sootsim_import_meta_url = '', __sootsim_import_meta_dirname = ''; try { __sootsim_import_meta_url = require('url').pathToFileURL(__filename).href; __sootsim_import_meta_dirname = __dirname; } catch {}
 "use strict";
 var __defProp = Object.defineProperty;