peachsim 0.1.577 → 0.1.579

package/dist-lib/swift-compile.mjs

@@ -1,20 +1,118 @@
-/*! rnx v0.1.577 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+/*! rnx v0.1.579 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
 
 // src/swift-compile.ts
-import { execFile } from "node:child_process";
-import { createHash } from "node:crypto";
+import { execFile as execFile2 } from "node:child_process";
+import { createHash as createHash2 } from "node:crypto";
 import {
   existsSync,
   mkdirSync,
-  readFileSync,
+  readFileSync as readFileSync2,
   readdirSync,
   realpathSync,
   rmSync,
   statSync,
   writeFileSync
 } from "node:fs";
+import os from "node:os";
+import path2 from "node:path";
+import { promisify as promisify2 } from "node:util";
+
+// src/swift-icu.ts
+import { execFile } from "node:child_process";
+import { createHash } from "node:crypto";
+import { readFileSync } from "node:fs";
 import path from "node:path";
 import { promisify } from "node:util";
+import { gzip } from "node:zlib";
+var run = promisify(execFile);
+var deflate = promisify(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: createHash("sha256").update(zipped).digest("hex"), gzip: zipped };
+  });
+}
+async function load(toolchainBin, release) {
+  const { stdout } = await run(path.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(readFileSync(path.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) {
@@ -25,7 +123,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 = "";
@@ -54,26 +153,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 = promisify(execFile);
+var run2 = promisify2(execFile2);
 var WASM_TRIPLE = "wasm32-unknown-wasip1";
+var cores = os.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 readdirSync(path.join(root, dir), { withFileTypes: true })) {
+    for (const entry of readdirSync(path2.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 = path2.join(moduleRoot, ".build/host/RnxPreviewMacros");
+  const ext = process.platform === "darwin" ? "dylib" : "so";
+  const plugins = [
+    {
+      library: path2.join(dir, `libRnxPreviewMacros.${ext}`),
+      source: path2.join(moduleRoot, "Sources/RnxPreviewMacros/PreviewMacro.swift")
+    },
+    {
+      library: path2.join(dir, `libFoundationMacros.${ext}`),
+      source: path2.join(moduleRoot, "Sources/FoundationMacros/PredicateMacro.swift")
+    }
+  ];
+  const stale = plugins.some(
+    ({ library, source }) => !existsSync(library) || statSync(source).mtimeMs > statSync(library).mtimeMs
+  );
+  if (stale) {
+    await run2("sh", [
+      path2.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();
@@ -81,9 +221,9 @@ function clearLinkedModuleDigests(root) {
 }
 function linkedModuleDigest(root) {
   const files = swiftModuleInputFiles(root);
-  const stampHash = createHash("sha256");
+  const stampHash = createHash2("sha256");
   for (const file of files) {
-    const stat = statSync(path.join(root, file), { bigint: true });
+    const stat = statSync(path2.join(root, file), { bigint: true });
     stampHash.update(file);
     stampHash.update(
       `${stat.dev}:${stat.ino}:${stat.size}:${stat.mtimeNs}:${stat.ctimeNs}
@@ -93,11 +233,11 @@ function linkedModuleDigest(root) {
   const stamp = stampHash.digest("hex");
   const cached = linkedModuleDigests.get(root);
   if (cached?.stamp === stamp) return cached.digest;
-  const hash = createHash("sha256");
+  const hash = createHash2("sha256");
   for (const file of files) {
-    hash.update(createHash("sha256").update(file).digest());
+    hash.update(createHash2("sha256").update(file).digest());
     hash.update(
-      createHash("sha256").update(readFileSync(path.join(root, file))).digest()
+      createHash2("sha256").update(readFileSync2(path2.join(root, file))).digest()
     );
   }
   const digest = hash.digest();
@@ -106,7 +246,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,
+      [path2.posix.join(targetPath, "OneNativeSource.generated.swift")]: glue
+    },
+    oneModule: true
+  };
 }
 function swiftSiblingDependencies(files, targets) {
   const names = new Set(targets.map((target) => target.name));
@@ -116,7 +271,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]);
       }
     }
@@ -124,29 +281,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 = createHash("sha256");
+  const hash = createHash2("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(createHash("sha256").update(file).digest());
-    hash.update(createHash("sha256").update(input.files[file]).digest());
+    hash.update(createHash2("sha256").update(file).digest());
+    hash.update(createHash2("sha256").update(input.files[file]).digest());
   }
   for (const base of Object.keys(input.resources ?? {}).sort()) {
-    hash.update(createHash("sha256").update(base).digest());
+    hash.update(createHash2("sha256").update(base).digest());
     hash.update(
-      createHash("sha256").update(input.resources?.[base] ?? "").digest()
+      createHash2("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(createHash("sha256").update(name).digest());
-    hash.update(createHash("sha256").update(image.file).digest());
-    hash.update(createHash("sha256").update(image.data).digest());
+    hash.update(createHash2("sha256").update(name).digest());
+    hash.update(createHash2("sha256").update(image.file).digest());
+    hash.update(createHash2("sha256").update(image.data).digest());
   }
   const targets = compileTargets(input);
   if (targets.length > 0) {
@@ -164,13 +324,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";
@@ -192,7 +354,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.",
@@ -207,42 +369,63 @@ function emitSwiftPackageManifest(args) {
     ""
   ].join("\n");
 }
+function syncSwiftTree(base, files) {
+  mkdirSync(base, { recursive: true });
+  const walk = (dir) => {
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+      const full = path2.join(dir, entry.name);
+      if (dir === base && entry.name === ".build") continue;
+      if (entry.isDirectory()) walk(full);
+      else if (!files.has(full)) rmSync(full, { force: true });
+    }
+  };
+  walk(base);
+  for (const [full, contents] of files) {
+    if (existsSync(full) && readFileSync2(full, "utf8") === contents) continue;
+    mkdirSync(path2.dirname(full), { recursive: true });
+    writeFileSync(full, contents, "utf8");
+  }
+}
 function writeSwiftProject(layout, input, moduleRoot) {
   const targets = compileTargets(input);
+  const files = /* @__PURE__ */ new Map();
   if (targets.length === 0) {
-    rmSync(layout.sources, { recursive: true, force: true });
     for (const [file, contents] of Object.entries(input.files)) {
-      const target = path.join(layout.sources, file);
-      mkdirSync(path.dirname(target), { recursive: true });
-      writeFileSync(target, contents, "utf8");
+      if (file === "Package.swift") continue;
+      files.set(path2.join(layout.sources, file), contents);
     }
-    const manifest = readFileSync(
-      path.join(moduleRoot, "scripts/contrast-app-Package.swift"),
+    let manifest = readFileSync2(
+      path2.join(moduleRoot, "scripts/contrast-app-Package.swift"),
       "utf8"
     ).replaceAll("__SOOTSIM_SWIFT_PACKAGE__", moduleRoot);
-    writeFileSync(path.join(layout.root, "Package.swift"), manifest, "utf8");
-    return;
-  }
-  mkdirSync(layout.root, { recursive: true });
-  for (const child of readdirSync(layout.root)) {
-    if (child === ".build") continue;
-    rmSync(path.join(layout.root, child), { recursive: true, force: true });
-  }
-  for (const [file, contents] of Object.entries(input.files)) {
-    if (file === "Package.swift") continue;
-    const target = path.join(layout.root, file);
-    mkdirSync(path.dirname(target), { recursive: true });
-    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(path2.join(layout.root, "Package.swift"), manifest);
+  } else {
+    for (const [file, contents] of Object.entries(input.files)) {
+      if (file === "Package.swift") continue;
+      files.set(path2.join(layout.root, file), contents);
+    }
+    files.set(
+      path2.join(layout.root, "Package.swift"),
+      emitSwiftPackageManifest({
+        targets,
+        siblings: swiftSiblingDependencies(input.files, targets),
+        moduleRoot,
+        oneModule: input.oneModule
+      })
+    );
   }
-  writeFileSync(
-    path.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();
@@ -260,18 +443,24 @@ function outputOf(error) {
   return error instanceof Error ? error.message : String(error);
 }
 function builtArtifact(layout) {
-  const binDir = path.join(layout.root, ".build", WASM_TRIPLE, "release");
-  const artifacts = existsSync(binDir) ? readdirSync(binDir).filter((name) => name.endsWith(".wasm")).sort() : [];
-  if (artifacts.length !== 1) {
+  const binDir = path2.join(layout.root, ".build", WASM_TRIPLE, "release");
+  const manifest = readFileSync2(path2.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 = path2.join(binDir, `${executable.name}.wasm`);
+  if (!existsSync(file)) {
+    const found = existsSync(binDir) ? 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 path.join(binDir, artifacts[0]);
+  return file;
 }
 function projectDiagnostic(output, layout) {
   const base = layout.multi ? layout.root : layout.sources;
-  const prefix = `${base}${path.sep}`;
+  const prefix = `${base}${path2.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");
@@ -290,26 +479,30 @@ function serialize(root, work) {
 function compileSwiftProjectUnit(input, options) {
   mkdirSync(options.buildRoot, { recursive: true });
   const root = realpathSync(options.buildRoot);
-  const moduleRoot = path.resolve(options.moduleRoot);
+  const moduleRoot = path2.resolve(options.moduleRoot);
   const layout = {
     root,
-    sources: path.join(root, "Sources", "App"),
+    sources: path2.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 = path.join(options.toolchainBin, "swift");
+    const swift = path2.join(options.toolchainBin, "swift");
     if (!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",
@@ -317,14 +510,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: readFileSync(builtArtifact(layout)) };
+    return {
+      hash,
+      bytes: readFileSync2(builtArtifact(layout)),
+      icu: await icu
+    };
   });
 }
 export {
@@ -334,6 +537,8 @@ export {
   compileTargets,
   emitSwiftPackageManifest,
   swiftArtifactHash,
+  swiftIcuAsset,
   swiftModuleInputFiles,
+  withNativeSourceGlue,
   writeSwiftProject
 };

package/dist-lib/swift-package.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 __defProp = Object.defineProperty;
@@ -23,7 +23,8 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var swift_package_exports = {};
 __export(swift_package_exports, {
   isSwiftManifestFile: () => isSwiftManifestFile,
-  swiftManifestTargets: () => swiftManifestTargets
+  swiftManifestTargets: () => swiftManifestTargets,
+  swiftPackagePartition: () => swiftPackagePartition
 });
 module.exports = __toCommonJS(swift_package_exports);
 function isSwiftManifestFile(file) {
@@ -38,7 +39,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 = "";
@@ -67,12 +69,22 @@ 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;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   isSwiftManifestFile,
-  swiftManifestTargets
+  swiftManifestTargets,
+  swiftPackagePartition
 });

package/dist-lib/swift-package.mjs

@@ -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 */
 
 // src/swift-package.ts
 function isSwiftManifestFile(file) {
@@ -13,7 +13,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 = "";
@@ -42,11 +43,21 @@ 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;
+}
 export {
   isSwiftManifestFile,
-  swiftManifestTargets
+  swiftManifestTargets,
+  swiftPackagePartition
 };