expo-modules-macros 0.16.0 → 0.17.0

package/apple/Sources/ExpoModulesMacros/ViewPropsMacro.swift

@@ -1,4 +1,3 @@
-import Foundation
 import SwiftDiagnostics
 import SwiftSyntax
 import SwiftSyntaxBuilder
@@ -248,10 +247,22 @@ private struct ViewProp {
   /// The name with any escaping backticks removed: the JS-visible key, so the enum's raw value and
   /// `_eventNames` both read `"default"`, never `` "`default`" ``.
   var wireName: String {
-    return name.trimmingCharacters(in: CharacterSet(charactersIn: "`"))
+    return withoutBackticks(name)
   }
 }
 
+/// `name` without the backticks that escape it: `` `default` `` becomes `default`.
+private func withoutBackticks(_ name: String) -> String {
+  var name = Substring(name)
+  while name.first == "`" {
+    name.removeFirst()
+  }
+  while name.last == "`" {
+    name.removeLast()
+  }
+  return String(name)
+}
+
 private struct ViewPropsModel {
   /// Value props, in declaration order. The order is the bit order, so it is part of the ABI
   /// between a compiled view and the runtime that fills the mask.
@@ -344,7 +355,7 @@ private func validatedViewProps(of declaration: some DeclGroupSyntax) throws ->
       // `PropSet` stores its mask in `rawValue`, so a value prop of that name would emit a static
       // member shadowing it and the option set would not compile ("circular reference"). The error
       // would point at generated code, so catch it here and name the property.
-      if !isEvent && name.trimmingCharacters(in: CharacterSet(charactersIn: "`")) == "rawValue" {
+      if !isEvent && withoutBackticks(name) == "rawValue" {
         throw MacroExpansionErrorMessage(
           "'rawValue' can't be used as a prop name — it collides with the synthesized PropSet's storage. Rename the property"
         )

package/apple/Sources/ExpoModulesScanner/CLI.swift

@@ -1,5 +1,3 @@
-import Foundation
-
 /// Command-line front end for the scanner: parses the subcommand and paths, then delegates to the
 /// matching `Scanner` entry (which runs the scan and writes its JSON output). Lives in the library
 /// so the macro plugin executable can dispatch into it: the compiler always launches that executable
@@ -16,12 +14,12 @@ public enum ScannerCLI {
   public static func run(arguments: [String]) -> Int32 {
     // `-h`/`--help` anywhere is treated as a help request: print usage to stdout and exit 0.
     if arguments.contains(where: { $0 == "-h" || $0 == "--help" }) {
-      printUsage(to: .standardOutput)
+      writeToStandardOutput(usageText)
       return 0
     }
 
     guard let subcommand = arguments.first else {
-      printUsage()
+      writeToStandardError(usageText)
       return 2
     }
 
@@ -79,7 +77,11 @@ public enum ScannerCLI {
 /// The invoked executable's basename, so the usage text matches however the tool was launched
 /// (the `ExpoModulesMacros` shipped in the package, or a locally built `ExpoModulesMacros-tool`).
 private var toolName: String {
-  return (CommandLine.arguments.first as NSString?)?.lastPathComponent ?? "ExpoModulesScanner"
+  guard let path = CommandLine.arguments.first else {
+    return "ExpoModulesScanner"
+  }
+  // Windows paths may use either separator.
+  return String(path.split(whereSeparator: { $0 == "/" || $0 == "\\" }).last ?? Substring(path))
 }
 
 private var usageText: String {
@@ -100,15 +102,8 @@ private var usageText: String {
   """
 }
 
-/// Prints the usage text to the given handle. Goes to stdout when help was explicitly requested
-/// (a successful action), stderr when it accompanies a usage error.
-private func printUsage(to handle: FileHandle = .standardError) {
-  handle.write(Data(usageText.utf8))
-}
-
 /// Reports a usage error on stderr, followed by the usage text, and returns the usage exit code.
 private func usageError(_ message: String) -> Int32 {
-  FileHandle.standardError.write(Data("error: \(message)\n".utf8))
-  printUsage()
+  writeToStandardError("error: \(message)\n" + usageText)
   return 2
 }

package/apple/Sources/ExpoModulesScanner/Core/Detection.swift

@@ -1,5 +1,3 @@
-import Foundation
-
 /// Which Expo macro was found on a declaration. The scanner recognizes the entry-point macros that
 /// mark a type or member as part of a module's JS surface, plus `@Record` for convertible types.
 enum DetectedMacro: String, Codable, CaseIterable {

package/apple/Sources/ExpoModulesScanner/Core/ScanBuildConfiguration.swift

@@ -23,6 +23,11 @@ struct ScanBuildConfiguration: BuildConfiguration {
     return name.lowercased() == platform.lowercased()
   }
 
+  /// The scan evaluates only Apple OSes, which all produce Mach-O, as `objectFormat(...)` spells it.
+  func isActiveTargetObjectFormat(name: String) throws -> Bool {
+    return name == "MachO"
+  }
+
   // MARK: - Unanswerable conditions
 
   // These vary within a single platform's build (device vs simulator, arm64 vs x86_64) or depend

package/apple/Sources/ExpoModulesScanner/Core/SourceScan.swift

@@ -1,4 +1,8 @@
+#if canImport(FoundationEssentials)
+import FoundationEssentials
+#else
 import Foundation
+#endif
 import SwiftParser
 import SwiftSyntax
 
@@ -21,12 +25,12 @@ func scanFiles(
   var filesScanned = 0
   var filesParsed = 0
 
-  // Compile the pre-filter regex once per run, not once per file.
-  let prefilter = macroAttributeRegex(for: macros, conformances: conformances)
+  // Build the pre-filter once per run, not once per file.
+  let prefilter = MacroPrefilter(macros: macros, conformances: conformances)
 
   for file in swiftFiles(in: paths) {
     guard let source = try? String(contentsOfFile: file, encoding: .utf8) else {
-      FileHandle.standardError.write(Data("warning: could not read \(file)\n".utf8))
+      writeToStandardError("warning: could not read \(file)\n")
       continue
     }
     filesScanned += 1
@@ -81,27 +85,57 @@ func detect(
 
 // MARK: - Pre-filter
 
-/// Builds the pre-filter regex for a macro set, e.g. `@(ExpoModule)` for a `modules` scan or
-/// `@(ExpoModule|JS|Record|SharedObject)` for an `exports` scan. A precompiled `NSRegularExpression`
-/// benchmarked ~20x faster over a large source tree than calling `String.contains` once per macro
-/// name, because it scans each file in a single pass. Compiled once per run and reused per file.
+/// The spelled forms whose presence makes a file worth parsing: each macro's attribute right after an
+/// `@` (`@ExpoModule`, `@JS`, …), plus bare names for the types recognized by a conformance rather than
+/// an attribute (`Enumerable` for `scan-exports`). A bare name matches more loosely than an
+/// `@`-prefixed one, which costs a wasted parse and never a miss.
 ///
-/// `conformances` adds bare (unprefixed) alternatives for types recognized by conformance rather than
-/// by an attribute (`Enumerable` for `scan-exports`). They join the same alternation so the scan stays
-/// one pass; a bare name matches more loosely than an `@`-prefixed one, which costs a wasted parse and
-/// never a miss.
-func macroAttributeRegex(
-  for macros: Set<DetectedMacro>,
-  conformances: Set<String> = []
-) -> NSRegularExpression {
-  // Sort for a stable pattern regardless of the set's iteration order.
-  let attributes = macros.map(\.rawValue).sorted().joined(separator: "|")
-  var alternatives: [String] = []
-  if !attributes.isEmpty {
-    alternatives.append("@(\(attributes))")
+/// Matching is a single pass over the UTF-8 bytes, checking the names only where an `@` or a bare
+/// name's first byte occurs, rather than one search per name. It runs on every file a whole-tree scan
+/// reads, far more than it parses, so it has to stay cheap. Built once per run and reused per file.
+struct MacroPrefilter {
+  /// The attribute names matched right after an `@`, as UTF-8.
+  private let attributes: [[UInt8]]
+
+  /// The names matched anywhere, as UTF-8.
+  private let bareNames: [[UInt8]]
+
+  init(macros: Set<DetectedMacro>, conformances: Set<String> = []) {
+    attributes = macros.map { Array($0.rawValue.utf8) }
+    bareNames = conformances.map { Array($0.utf8) }
+  }
+
+  /// True if `source` contains one of the attributes after an `@`, or one of the bare names.
+  func matches(_ source: String) -> Bool {
+    var source = source
+    return source.withUTF8 { bytes in
+      for index in bytes.indices {
+        let byte = bytes[index]
+        if byte == UInt8(ascii: "@") {
+          for name in attributes where bytes.hasBytes(name, at: index + 1) {
+            return true
+          }
+        }
+        for name in bareNames where name.first == byte && bytes.hasBytes(name, at: index) {
+          return true
+        }
+      }
+      return false
+    }
+  }
+}
+
+extension UnsafeBufferPointer<UInt8> {
+  /// True if the bytes starting at `index` begin with `prefix`.
+  fileprivate func hasBytes(_ prefix: [UInt8], at index: Int) -> Bool {
+    guard index + prefix.count <= count else {
+      return false
+    }
+    for offset in prefix.indices where self[index + offset] != prefix[offset] {
+      return false
+    }
+    return true
   }
-  alternatives.append(contentsOf: conformances.sorted())
-  return try! NSRegularExpression(pattern: alternatives.joined(separator: "|"))
 }
 
 /// True if the source text contains one of the pre-filter's spelled macro attributes, so it's worth
@@ -109,9 +143,8 @@ func macroAttributeRegex(
 /// in which case the file is parsed and correctly yields no detections — a wasted parse, never a
 /// missed module. It assumes the attribute is written with no space after `@` (`@ExpoModule`, not
 /// `@ ExpoModule`), which is universal in practice; the rare spaced form would be skipped.
-func mightContainMacro(in source: String, prefilter: NSRegularExpression) -> Bool {
-  let range = NSRange(source.startIndex..., in: source)
-  return prefilter.firstMatch(in: source, range: range) != nil
+func mightContainMacro(in source: String, prefilter: MacroPrefilter) -> Bool {
+  return prefilter.matches(source)
 }
 
 // MARK: - File discovery
@@ -144,13 +177,12 @@ func swiftFiles(in paths: [String]) -> [String] {
   var result: [String] = []
 
   for path in paths {
-    var isDirectory: ObjCBool = false
-    guard fileManager.fileExists(atPath: path, isDirectory: &isDirectory) else {
-      FileHandle.standardError.write(Data("warning: no such path \(path)\n".utf8))
+    guard let isDirectory = isDirectory(atPath: path, fileManager: fileManager) else {
+      writeToStandardError("warning: no such path \(path)\n")
       continue
     }
 
-    if isDirectory.boolValue {
+    if isDirectory {
       result.append(contentsOf: swiftFiles(inDirectory: URL(fileURLWithPath: path), fileManager: fileManager))
     } else if path.hasSuffix(".swift") {
       // A directory walk already yields absolute paths; resolve a directly-passed file the same way
@@ -162,6 +194,54 @@ func swiftFiles(in paths: [String]) -> [String] {
   return result.sorted()
 }
 
+/// Whether `path` is a directory (following symbolic links), or `nil` if nothing exists there.
+private func isDirectory(atPath path: String, fileManager: FileManager) -> Bool? {
+  #if canImport(FoundationEssentials)
+  var isDirectory = false
+  #else
+  var isDirectory: ObjCBool = false
+  #endif
+  guard fileManager.fileExists(atPath: path, isDirectory: &isDirectory) else {
+    return nil
+  }
+  #if canImport(FoundationEssentials)
+  return isDirectory
+  #else
+  return isDirectory.boolValue
+  #endif
+}
+
+#if canImport(FoundationEssentials)
+/// Recursively lists the `.swift` files under a directory, without descending into pruned directories.
+/// `FoundationEssentials`, used outside Apple platforms, has no directory enumerator, so each directory
+/// is listed on its own and the walk recurses into the subdirectories that aren't pruned. Like the
+/// enumerator walk on Apple platforms, it skips names starting with a dot and doesn't follow symbolic
+/// links to directories.
+private func swiftFiles(inDirectory directory: URL, fileManager: FileManager) -> [String] {
+  return swiftFiles(inDirectoryAtPath: directory.path, fileManager: fileManager)
+}
+
+private func swiftFiles(inDirectoryAtPath directory: String, fileManager: FileManager) -> [String] {
+  guard let names = try? fileManager.contentsOfDirectory(atPath: directory) else {
+    return []
+  }
+
+  var result: [String] = []
+  for name in names where !name.hasPrefix(".") {
+    let path = directory + "/" + name
+    // `attributesOfItem` doesn't follow a symbolic link, so a link reads as `.typeSymbolicLink`.
+    let type = (try? fileManager.attributesOfItem(atPath: path))?[.type] as? FileAttributeType
+    if type == .typeDirectory {
+      if !prunedDirectoryNames.contains(name) {
+        result.append(contentsOf: swiftFiles(inDirectoryAtPath: path, fileManager: fileManager))
+      }
+    } else if name.hasSuffix(".swift") {
+      result.append(path)
+    }
+  }
+  return result
+}
+#else
 /// Recursively enumerates `.swift` files under a directory, calling `skipDescendants()` on any
 /// pruned directory so its subtree is never read. Uses the URL enumerator (rather than the
 /// path-based one) precisely because it supports skipping a subtree mid-walk.
@@ -191,3 +271,4 @@ private func swiftFiles(inDirectory directory: URL, fileManager: FileManager) ->
   }
   return result
 }
+#endif

package/apple/Sources/ExpoModulesScanner/Core/StandardStreams.swift

@@ -0,0 +1,45 @@
+#if canImport(Darwin)
+import Darwin
+#elseif canImport(Glibc)
+import Glibc
+#elseif os(Windows)
+import CRT
+#endif
+
+// Output goes straight to the file descriptors rather than through Foundation's `FileHandle`, which
+// `FoundationEssentials` doesn't have. Outside Apple platforms the scanner uses only
+// `FoundationEssentials`, so the binary doesn't link full Foundation and its ICU data.
+
+/// Writes `text` to stdout as is, without adding a newline.
+func writeToStandardOutput(_ text: String) {
+  writeAll(text, toFileDescriptor: 1)
+}
+
+/// Writes `text` to stderr as is, without adding a newline.
+func writeToStandardError(_ text: String) {
+  writeAll(text, toFileDescriptor: 2)
+}
+
+/// Writes the UTF-8 bytes of `text` to `descriptor`, repeating the write until every byte is out. Retries
+/// a write that a signal interrupted, and stops early if one fails otherwise, since there is nowhere
+/// left to report that.
+private func writeAll(_ text: String, toFileDescriptor descriptor: Int32) {
+  var text = text
+  text.withUTF8 { bytes in
+    var remaining = UnsafeRawBufferPointer(bytes)
+    while !remaining.isEmpty {
+      #if os(Windows)
+      let written = Int(_write(descriptor, remaining.baseAddress, CUnsignedInt(remaining.count)))
+      #else
+      let written = write(descriptor, remaining.baseAddress, remaining.count)
+      #endif
+      if written < 0 && errno == EINTR {
+        continue
+      }
+      guard written > 0 else {
+        return
+      }
+      remaining = UnsafeRawBufferPointer(rebasing: remaining[written...])
+    }
+  }
+}

package/apple/Sources/ExpoModulesScanner/Exports/ExportedSurface.swift

@@ -1,5 +1,3 @@
-import Foundation
-
 /// The deep-scan surface: the full JS-exported shape of every `@ExpoModule`, `@SharedObject`, and
 /// `@Record` type, with the per-member detail a TypeScript type generator needs. Read syntactically
 /// (like the macros): each boundary type becomes a structured `TypeNode` tree so the consumer walks a

package/apple/Sources/ExpoModulesScanner/Exports/ResolveRefs.swift

@@ -1,5 +1,3 @@
-import Foundation
-
 /// Fills in each `.ref`'s `refKind` once the whole scan is done.
 ///
 /// A `TypeNode` is parsed from one `TypeSyntax` in isolation, so at parse time a name like `Status` is

package/apple/Sources/ExpoModulesScanner/Exports/ScanExports.swift

@@ -1,4 +1,8 @@
+#if canImport(FoundationEssentials)
+import FoundationEssentials
+#else
 import Foundation
+#endif
 import SwiftParser
 import SwiftSyntax
 
@@ -12,11 +16,10 @@ extension Scanner {
       let encoder = JSONEncoder()
       encoder.outputFormatting = [.prettyPrinted, .sortedKeys]
       let data = try encoder.encode(result)
-      FileHandle.standardOutput.write(data)
-      FileHandle.standardOutput.write(Data("\n".utf8))
+      writeToStandardOutput(String(decoding: data, as: UTF8.self) + "\n")
       return 0
     } catch {
-      FileHandle.standardError.write(Data("error: failed to encode results: \(error)\n".utf8))
+      writeToStandardError("error: failed to encode results: \(error)\n")
       return 1
     }
   }

package/apple/Sources/ExpoModulesScanner/Modules/ScanModules.swift

@@ -1,4 +1,8 @@
+#if canImport(FoundationEssentials)
+import FoundationEssentials
+#else
 import Foundation
+#endif
 import SwiftParser
 
 /// The scanner's public entry point. Argument parsing, subcommand dispatch, and usage text live in
@@ -20,11 +24,10 @@ public enum Scanner {
       let encoder = JSONEncoder()
       encoder.outputFormatting = [.prettyPrinted, .sortedKeys]
       let data = try encoder.encode(result)
-      FileHandle.standardOutput.write(data)
-      FileHandle.standardOutput.write(Data("\n".utf8))
+      writeToStandardOutput(String(decoding: data, as: UTF8.self) + "\n")
       return 0
     } catch {
-      FileHandle.standardError.write(Data("error: failed to encode results: \(error)\n".utf8))
+      writeToStandardError("error: failed to encode results: \(error)\n")
       return 1
     }
   }

package/build/index.d.ts

@@ -29,8 +29,17 @@ export declare class ScannerSchemaVersionError extends Error {
     constructor(command: string, found: number, expected: number);
 }
 /**
- * Absolute path to the scanner binary shipped with this package. It doubles as the macro plugin
- * executable, so it lives next to the Swift package rather than in a `bin` directory.
+ * Absolute path to the scanner binary for the current platform. It doubles as the macro plugin
+ * executable.
+ *
+ * - macOS: the universal binary shipped in this package, next to the Swift package rather than in a
+ *   `bin` directory.
+ * - Windows: `ExpoModulesMacros.exe` from the package for the current architecture (see
+ *   `windowsBinaryPackageName`). When that package isn't installed, for example in this repository,
+ *   it falls back to the executable that `npm run build` writes to `platforms/win32-<arch>`.
+ *
+ * The path isn't checked here; running a missing binary fails with a `ScannerError` that says how to
+ * get it.
  */
 export declare function getScannerBinaryPath(): string;
 /**

package/build/index.js

@@ -51,11 +51,47 @@ class ScannerSchemaVersionError extends Error {
 }
 exports.ScannerSchemaVersionError = ScannerSchemaVersionError;
 /**
- * Absolute path to the scanner binary shipped with this package. It doubles as the macro plugin
- * executable, so it lives next to the Swift package rather than in a `bin` directory.
+ * The package with the Windows binary for the current architecture, for example
+ * `@expo/modules-macros-win32-x64`. It is an optional dependency of this package, and its `os` and
+ * `cpu` fields make package managers install it only on a matching Windows machine.
+ */
+function windowsBinaryPackageName() {
+    return `@expo/modules-macros-win32-${process.arch}`;
+}
+/**
+ * Absolute path to the scanner binary for the current platform. It doubles as the macro plugin
+ * executable.
+ *
+ * - macOS: the universal binary shipped in this package, next to the Swift package rather than in a
+ *   `bin` directory.
+ * - Windows: `ExpoModulesMacros.exe` from the package for the current architecture (see
+ *   `windowsBinaryPackageName`). When that package isn't installed, for example in this repository,
+ *   it falls back to the executable that `npm run build` writes to `platforms/win32-<arch>`.
+ *
+ * The path isn't checked here; running a missing binary fails with a `ScannerError` that says how to
+ * get it.
  */
 function getScannerBinaryPath() {
-    return node_path_1.default.join(__dirname, '..', 'apple', 'ExpoModulesMacros');
+    if (process.platform !== 'win32') {
+        return node_path_1.default.join(__dirname, '..', 'apple', 'ExpoModulesMacros');
+    }
+    try {
+        const packageJson = require.resolve(`${windowsBinaryPackageName()}/package.json`);
+        return node_path_1.default.join(node_path_1.default.dirname(packageJson), 'ExpoModulesMacros.exe');
+    }
+    catch {
+        return node_path_1.default.join(__dirname, '..', 'platforms', `win32-${process.arch}`, 'ExpoModulesMacros.exe');
+    }
+}
+/** The message for a scanner binary that doesn't exist at `binaryPath`. */
+function missingBinaryMessage(binaryPath) {
+    if (process.platform === 'win32') {
+        return (`The scanner binary is missing at ${binaryPath}. On Windows it comes from the optional package ` +
+            `${windowsBinaryPackageName()}, which your package manager installs only on Windows x64 and arm64. ` +
+            'Reinstall dependencies without skipping optional ones (for example without `--omit=optional`), ' +
+            'or run `npm run build` in this package to build it locally.');
+    }
+    return `The scanner binary is missing at ${binaryPath}. Run \`npm run build\` in this package to build it.`;
 }
 /**
  * Runs a scanner subcommand and parses its JSON report.
@@ -92,7 +128,7 @@ function runScanner(binaryPath, args) {
                 // number. Only the latter is an exit status.
                 const exitCode = typeof error.code === 'number' ? error.code : null;
                 if (error.code === 'ENOENT') {
-                    reject(new ScannerError(`The scanner binary is missing at ${binaryPath}. Run \`npm run build\` in this package to build it.`, null, stderr));
+                    reject(new ScannerError(missingBinaryMessage(binaryPath), null, stderr));
                     return;
                 }
                 reject(new ScannerError(`\`${node_path_1.default.basename(binaryPath)} ${args.join(' ')}\` failed: ${stderr.trim() || error.message}`, exitCode, stderr));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-modules-macros",
-  "version": "0.16.0",
+  "version": "0.17.0",
   "description": "Swift macro plugin for Expo modules",
   "main": "build/index.js",
   "types": "build/index.d.ts",
@@ -12,7 +12,7 @@
     "url": "git+https://github.com/expo/expo-modules-macros.git"
   },
   "scripts": {
-    "build": "node apple/build.js",
+    "build": "node scripts/build.js",
     "build:ts": "tsc -p tsconfig.json",
     "clean": "rm -rf build",
     "typecheck": "tsc -p tsconfig.json --noEmit",
@@ -21,5 +21,9 @@
   "devDependencies": {
     "@types/node": "^20.11.0",
     "typescript": "^5.4.0"
+  },
+  "optionalDependencies": {
+    "@expo/modules-macros-win32-arm64": "0.17.0",
+    "@expo/modules-macros-win32-x64": "0.17.0"
   }
 }

package/apple/build.js

@@ -1,138 +0,0 @@
-#!/usr/bin/env node
-
-const childProcess = require('node:child_process');
-const fs = require('node:fs/promises');
-const os = require('node:os');
-const path = require('node:path');
-const { promisify } = require('node:util');
-
-const execFile = promisify(childProcess.execFile);
-
-/**
- * Runs a command and resolves when it exits successfully.
- */
-function spawnAsync(command, args, options = {}) {
-  return new Promise((resolve, reject) => {
-    const child = childProcess.spawn(command, args, { stdio: 'inherit', ...options });
-    child.once('error', reject);
-    child.once('close', (code, signal) => {
-      if (code === 0) {
-        resolve();
-      } else {
-        reject(new Error(`\`${command} ${args.join(' ')}\` exited with ${signal ?? `code ${code}`}`));
-      }
-    });
-  });
-}
-
-/**
- * Builds the macro plugin for the given architecture and returns the path to the built binary.
- * SwiftPM always builds macro tools for the host architecture, so the x86_64 slice
- * is built by running the whole toolchain under Rosetta with `arch -${arch}`.
- */
-async function buildForArch(arch) {
-  const buildArgs = ['build', '-c', 'release'];
-  if (arch === os.machine()) {
-    await spawnAsync('swift', buildArgs, { cwd: __dirname });
-  } else {
-    await spawnAsync('arch', [`-${arch}`, 'swift', ...buildArgs], { cwd: __dirname });
-  }
-
-  const binPath = path.join(__dirname, `.build/${arch}-apple-macosx/release/ExpoModulesMacros-tool`);
-  try {
-    await fs.access(binPath);
-  } catch {
-    throw new Error(`Could not find the built ExpoModulesMacros-tool at ${binPath}`);
-  }
-  return binPath;
-}
-
-/**
- * Checks whether the Swift toolchain actually runs for the given architecture by
- * verifying the host target triple it reports, e.g. `Target: x86_64-apple-macosx26.0`
- * under Rosetta. Exit status alone is not enough: if `arch` ever fell back to the
- * native architecture, the probe would pass but the build would produce a wrong slice.
- */
-async function canRunSwiftForArch(arch) {
-  try {
-    const { stdout } = await execFile('arch', [`-${arch}`, 'swift', '--version']);
-    return stdout.includes(`${arch}-apple`);
-  } catch {
-    return false;
-  }
-}
-
-/**
- * Checks whether the toolchain can build for the given architecture.
- * Building x86_64 on Apple Silicon requires Rosetta, so when it is missing,
- * try to install it before giving up.
- */
-async function canBuildForArch(arch) {
-  if (arch === os.machine()) {
-    return true;
-  }
-  if (await canRunSwiftForArch(arch)) {
-    return true;
-  }
-  if (arch === 'x86_64' && os.machine() === 'arm64') {
-    try {
-      console.log('Installing Rosetta to build the x86_64 slice...');
-      await spawnAsync('sudo', ['softwareupdate', '--install-rosetta', '--agree-to-license']);
-      return await canRunSwiftForArch(arch);
-    } catch {
-      // No sudo access or the install failed - fall through to the unsupported arch warning.
-    }
-  }
-  return false;
-}
-
-/**
- * Asserts that the built binary contains a slice for each of the given architectures.
- */
-async function verifyArchs(binaryPath, archs) {
-  const { stdout } = await execFile('lipo', ['-archs', binaryPath]);
-  const builtArchs = stdout.trim().split(/\s+/);
-  for (const arch of archs) {
-    if (!builtArchs.includes(arch)) {
-      throw new Error(`The built binary at ${binaryPath} is missing the ${arch} slice`);
-    }
-  }
-}
-
-async function main() {
-  const outputPath = path.join(__dirname, 'ExpoModulesMacros');
-
-  const archs = [];
-  for (const arch of ['arm64', 'x86_64']) {
-    if (await canBuildForArch(arch)) {
-      archs.push(arch);
-    } else {
-      console.warn(`The Swift toolchain cannot run for ${arch} - the built binary will not support ${arch} Macs.`);
-    }
-  }
-  if (archs.length === 0) {
-    throw new Error('The Swift toolchain is not available for any supported architecture');
-  }
-
-  // Builds run sequentially as SwiftPM locks the shared .build directory.
-  const binPaths = [];
-  for (const arch of archs) {
-    binPaths.push(await buildForArch(arch));
-  }
-
-  await fs.rm(outputPath, { force: true });
-  if (binPaths.length > 1) {
-    await spawnAsync('lipo', ['-create', ...binPaths, '-output', outputPath]);
-  } else {
-    await fs.copyFile(binPaths[0], outputPath);
-  }
-
-  await spawnAsync('strip', [outputPath]);
-  await verifyArchs(outputPath, archs);
-  await spawnAsync('lipo', ['-info', outputPath]);
-}
-
-main().catch((error) => {
-  console.error('Build failed:', error.message);
-  process.exit(1);
-});