expo-modules-macros 0.0.1 → 0.15.0

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

@@ -0,0 +1,284 @@
+import SwiftSyntax
+
+/// A boundary type parsed into a structured, JS-oriented tree, so the consumer walks a tagged tree
+/// instead of re-parsing Swift type syntax. The single Swift type parser lives here. Encoded as a
+/// `kind` discriminator plus per-kind fields and a `typeof` on every node, e.g.
+/// `{ "kind": "array", "typeof": "object", "element": { "kind": "primitive", "name": "Int",
+/// "typeof": "number" } }`. An unmodeled spelling becomes `.unknown` (verbatim text, no `typeof`),
+/// never silently dropped.
+
+/// The runtime category mirroring JavaScript's `typeof`. A coarse companion to `TypeNode.kind`: every
+/// structured object kind (array, dictionary, promise, ref) reports `object`. `bigint`/`symbol` are
+/// included for completeness; the scanner doesn't produce them.
+enum JSType: String, Encodable {
+  case undefined
+  case object
+  case boolean
+  case number
+  case bigint
+  case string
+  case symbol
+  case function
+}
+
+/// Which of the scanned kinds declares the name a `.ref` points at.
+///
+/// Resolution happens after the whole scan (`ExportedSurface.resolvingRefs()`), not while parsing a
+/// type: a `TypeNode` is built from one `TypeSyntax` in isolation, long before the scanner knows what
+/// else exists. A ref the scan can't place carries no `refKind` at all rather than a value meaning "none",
+/// matching how the rest of the surface signals "nothing to say" (`returns` for `Void`, `rawType` for
+/// a bare conformance). That is not an error: it covers a platform or built-in convertible (`CGPoint`,
+/// `URL`) and a type from another module, which the consumer resolves against its own catalog.
+enum RefKind: String, Encodable {
+  case record
+  case sharedObject
+  case `enum`
+  case union
+}
+
+indirect enum TypeNode: Equatable {
+  /// `Bool`, `Int`, `Double`, `String`: the types core fast-decodes. `name` is the Swift spelling;
+  /// `jsType` is `boolean`/`number`/`string`.
+  case primitive(name: String, jsType: JSType)
+
+  /// `T?` / `T!` / `Optional<T>`.
+  case optional(wrapped: TypeNode)
+
+  /// `[T]` / `Array<T>`.
+  case array(element: TypeNode)
+
+  /// `[K: V]` / `Dictionary<K, V>`.
+  case dictionary(key: TypeNode, value: TypeNode)
+
+  /// `Promise<T>`.
+  case promise(value: TypeNode)
+
+  /// A closure `(A, B) async throws -> R`. `returns` is `nil` for `Void`; `isAsync`/`isThrowing` carry
+  /// the effects (encoded `async`/`throws`).
+  case function(parameters: [TypeNode], returns: TypeNode?, isAsync: Bool, isThrowing: Bool)
+
+  /// Any other named type (record, shared object, enum, union, …). `name` is the possibly-qualified
+  /// spelling.
+  ///
+  /// `refKind` says which scanned kind declares that name, filled in after the scan by
+  /// `ExportedSurface.resolvingRefs()`; it is `nil` until then, and stays `nil` for a name the scan
+  /// never declared (a platform type like `CGPoint`, or one from another module).
+  ///
+  /// `jsTypeOverride` carries the category a resolved ref actually crosses as, when that isn't
+  /// `object`: a raw-value enum reaches JS as its raw value, so `Status: String` is a `string`. Only
+  /// resolution can know this, since the category comes from the *declaration's* `rawType`, which a
+  /// node parsed at a use site has never seen.
+  case ref(name: String, refKind: RefKind? = nil, jsTypeOverride: JSType? = nil)
+
+  /// A spelling the parser doesn't model (generic parameter, tuple, metatype, …), kept verbatim so
+  /// nothing is lost. Has no `typeof`.
+  case unknown(text: String)
+
+  /// The `typeof` category, or `nil` for `.unknown`. An optional reports its *present* value's
+  /// category; the absent (`undefined`) case is carried by the `.optional` wrapper itself.
+  var jsType: JSType? {
+    switch self {
+    case .primitive(_, let jsType):
+      return jsType
+    case .array, .dictionary, .promise:
+      return .object
+    case .ref(_, _, let jsTypeOverride):
+      // An unresolved ref, and every resolved one but an enum, is an object.
+      return jsTypeOverride ?? .object
+    case .function:
+      return .function
+    case .optional(let wrapped):
+      return wrapped.jsType
+    case .unknown:
+      return nil
+    }
+  }
+}
+
+extension TypeNode: Encodable {
+  private enum CodingKeys: String, CodingKey {
+    case refKind
+    case kind
+    case name
+    // The `typeof` category. Spelled `typeof` in JSON (what the consumer reads); the Swift property is
+    // `jsType` since it's the cleaner Swift name.
+    case jsType = "typeof"
+    case wrapped, element, key, value, parameters, returns, text
+    // A closure type's effects, matching `ExportedFunction`'s TS-keyword spellings.
+    case isAsync = "async"
+    case isThrowing = "throws"
+  }
+
+  func encode(to encoder: Encoder) throws {
+    var container = encoder.container(keyedBy: CodingKeys.self)
+    // Every node carries its `typeof` category (except `.unknown`, whose `jsType` is nil). Encoded up
+    // front so it sits beside `kind` on each node.
+    try container.encodeIfPresent(jsType, forKey: .jsType)
+    switch self {
+    case .primitive(let name, _):
+      try container.encode("primitive", forKey: .kind)
+      try container.encode(name, forKey: .name)
+    case .optional(let wrapped):
+      try container.encode("optional", forKey: .kind)
+      try container.encode(wrapped, forKey: .wrapped)
+    case .array(let element):
+      try container.encode("array", forKey: .kind)
+      try container.encode(element, forKey: .element)
+    case .dictionary(let key, let value):
+      try container.encode("dictionary", forKey: .kind)
+      try container.encode(key, forKey: .key)
+      try container.encode(value, forKey: .value)
+    case .promise(let value):
+      try container.encode("promise", forKey: .kind)
+      try container.encode(value, forKey: .value)
+    case .function(let parameters, let returns, let isAsync, let isThrowing):
+      try container.encode("function", forKey: .kind)
+      try container.encode(parameters, forKey: .parameters)
+      try container.encodeIfPresent(returns, forKey: .returns)
+      try container.encode(isAsync, forKey: .isAsync)
+      try container.encode(isThrowing, forKey: .isThrowing)
+    case .ref(let name, let refKind, _):
+      try container.encode("ref", forKey: .kind)
+      try container.encode(name, forKey: .name)
+      try container.encodeIfPresent(refKind, forKey: .refKind)
+    case .unknown(let text):
+      try container.encode("unknown", forKey: .kind)
+      try container.encode(text, forKey: .text)
+    }
+  }
+}
+
+/// The primitive Swift types with a dedicated JS mapping (the set core fast-decodes), each paired with
+/// its JS primitive. A bare name here is a `.primitive`; anything else is a `.ref`.
+private let primitiveJSTypes: [String: JSType] = [
+  "Bool": .boolean,
+  "Int": .number,
+  "Double": .number,
+  "String": .string,
+]
+
+/// Parses a `TypeSyntax` into a `TypeNode`: the single place Swift type syntax is interpreted.
+func typeNode(from type: TypeSyntax) -> TypeNode {
+  // `T?` sugar.
+  if let optional = type.as(OptionalTypeSyntax.self) {
+    return .optional(wrapped: typeNode(from: optional.wrappedType))
+  }
+  // `T!`, JS treats it the same as `T?`.
+  if let iuo = type.as(ImplicitlyUnwrappedOptionalTypeSyntax.self) {
+    return .optional(wrapped: typeNode(from: iuo.wrappedType))
+  }
+  // `[T]` sugar.
+  if let arrayType = type.as(ArrayTypeSyntax.self) {
+    return .array(element: typeNode(from: arrayType.element))
+  }
+  // `[K: V]` sugar.
+  if let dictionaryType = type.as(DictionaryTypeSyntax.self) {
+    return .dictionary(key: typeNode(from: dictionaryType.key), value: typeNode(from: dictionaryType.value))
+  }
+  // `(A, B) -> R`.
+  if let functionType = type.as(FunctionTypeSyntax.self) {
+    return functionNode(from: functionType)
+  }
+  // `@escaping (…) -> …`, `@Sendable …`, etc.: strip the attributes and parse the underlying type.
+  if let attributed = type.as(AttributedTypeSyntax.self) {
+    return typeNode(from: attributed.baseType)
+  }
+  // A nominal type, possibly generic: `Int`, `Point`, `Optional<T>`, `Array<T>`, `Promise<T>`.
+  if let identifier = type.as(IdentifierTypeSyntax.self) {
+    return nominalNode(name: identifier.name.text, generics: identifier.genericArgumentClause)
+  }
+  // A qualified nominal type: `Foo.Bar`. Kept as a ref under its full spelling.
+  if let member = type.as(MemberTypeSyntax.self) {
+    return .ref(name: member.trimmedDescription)
+  }
+  // Tuples, metatypes, some/any types, etc.: not modeled, preserve the verbatim spelling.
+  return .unknown(text: type.trimmedDescription)
+}
+
+/// A nominal type's node. The standard generic wrappers normalize to their sugared node
+/// (`Optional<T>`/`Array<T>`/`Dictionary<K,V>`/`Promise<T>`); a bare name is a primitive when known,
+/// else a ref; any other generic is a ref under its full spelling.
+private func nominalNode(name: String, generics: GenericArgumentClauseSyntax?) -> TypeNode {
+  guard let generics else {
+    if let jsType = primitiveJSTypes[name] {
+      return .primitive(name: name, jsType: jsType)
+    }
+    return .ref(name: name)
+  }
+
+  let arguments = genericArguments(generics)
+  switch (name, arguments.count) {
+  case ("Optional", 1):
+    return .optional(wrapped: arguments[0])
+  case ("Array", 1):
+    return .array(element: arguments[0])
+  case ("Dictionary", 2):
+    return .dictionary(key: arguments[0], value: arguments[1])
+  case ("Promise", 1):
+    return .promise(value: arguments[0])
+  default:
+    // An unmodeled generic (`Set<Int>`, `Either<A, B>`, …). Keep the whole spelling as a ref so the
+    // name and its arguments survive for the generator to interpret or flag.
+    return .ref(name: "\(name)<\(arguments.map { $0.spelling }.joined(separator: ", "))>")
+  }
+}
+
+/// The argument types of a generic clause, each parsed into a node.
+private func genericArguments(_ clause: GenericArgumentClauseSyntax) -> [TypeNode] {
+  clause.arguments.compactMap { argument in
+    guard case .type(let type) = argument.argument else {
+      return nil
+    }
+    return typeNode(from: type)
+  }
+}
+
+/// A closure node: each parameter parsed, the result (`Void`/`()` collapsed to `nil`, matching how a
+/// function's own return is reported), and the closure's `async`/`throws` effects.
+private func functionNode(from type: FunctionTypeSyntax) -> TypeNode {
+  let parameters = type.parameters.map { typeNode(from: $0.type) }
+  let returnType = type.returnClause.type
+  let returns = isVoidType(returnType) ? nil : typeNode(from: returnType)
+  let effects = type.effectSpecifiers
+  return .function(
+    parameters: parameters,
+    returns: returns,
+    isAsync: effects?.asyncSpecifier != nil,
+    isThrowing: effects?.throwsClause?.throwsSpecifier != nil
+  )
+}
+
+/// True when a return clause is absent or written `Void` / `()`, so the surface reports `nil`. Shared
+/// by the function-return read and the closure-type parser.
+func isVoidType(_ type: TypeSyntax?) -> Bool {
+  guard let type else {
+    return true
+  }
+  let text = type.trimmedDescription
+  return text == "Void" || text == "()"
+}
+
+extension TypeNode {
+  /// A best-effort source-like spelling, used only to re-compose an unmodeled generic ref's name.
+  /// Not a round-trip of arbitrary Swift; the structured node is the source of truth.
+  fileprivate var spelling: String {
+    switch self {
+    case .primitive(let name, _):
+      return name
+    case .ref(let name, _, _):
+      return name
+    case .optional(let wrapped):
+      return "\(wrapped.spelling)?"
+    case .array(let element):
+      return "[\(element.spelling)]"
+    case .dictionary(let key, let value):
+      return "[\(key.spelling): \(value.spelling)]"
+    case .promise(let value):
+      return "Promise<\(value.spelling)>"
+    case .function(let parameters, let returns, _, _):
+      return "(\(parameters.map { $0.spelling }.joined(separator: ", "))) -> \(returns?.spelling ?? "Void")"
+    case .unknown(let text):
+      return text
+    }
+  }
+}

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

@@ -0,0 +1,161 @@
+import Foundation
+import SwiftParser
+
+/// The scanner's public entry point. Argument parsing, subcommand dispatch, and usage text live in
+/// the CLI target; this just runs a command and writes its JSON report to stdout.
+///
+/// The detection model (`Detection`, `DetectionVisitor`, …) stays `internal`: tests reach it via
+/// `@testable import`, and the CLI only needs these entries, so nothing else is exposed.
+public enum Scanner {
+  /// Runs the `scan-modules` command over `paths`, prints the JSON report to stdout, and returns a
+  /// process exit code: `0` on success, `1` if encoding fails. (The deep `scan-exports` command has
+  /// its own `runExports` entry returning its own result type.)
+  ///
+  /// `defines` (the `--define` options) asserts conditional compilation flags; see `scanModules`
+  /// for how they and platforms shape each module's `platforms` list.
+  public static func runModules(paths: [String], defines: [String] = []) -> Int32 {
+    let result = scanModules(paths: paths, defines: Set(defines))
+
+    do {
+      let encoder = JSONEncoder()
+      encoder.outputFormatting = [.prettyPrinted, .sortedKeys]
+      let data = try encoder.encode(result)
+      FileHandle.standardOutput.write(data)
+      FileHandle.standardOutput.write(Data("\n".utf8))
+      return 0
+    } catch {
+      FileHandle.standardError.write(Data("error: failed to encode results: \(error)\n".utf8))
+      return 1
+    }
+  }
+}
+
+/// One module in the `scan-modules` output. Trimmed to what `expo-modules-autolinking` needs to
+/// register a module: the Swift class name, the JS name it registers under, the platforms that
+/// include it, and the file it's in. The richer fields the visitor captures (declaration kind, raw
+/// macro arguments, line/column) are dropped here — they're redundant for this command (the macro
+/// is always `@ExpoModule` on a class) and the deep `scan-exports` surface carries the richer
+/// per-member detail instead.
+struct ScannedModule: Codable, Equatable {
+  /// The Swift class name the module is declared as.
+  let name: String
+
+  /// The fully-resolved JS module name: the `@ExpoModule("Foo")` override when present, otherwise the
+  /// class name. Resolved here (rather than left `nil`) so it matches how the macro derives the name
+  /// and the consumer never has to apply the fallback itself.
+  let jsName: String
+
+  /// The class's spelled access modifier (`open`, `public`, `package`, `fileprivate`, `private`),
+  /// or `internal` when none is written. The generated modules provider references the class from
+  /// the app target, which requires `public`/`open`, so the consumer uses this to skip inaccessible
+  /// classes with a diagnostic instead of emitting a provider that fails to compile.
+  let accessLevel: String
+
+  /// The Apple OSes whose builds include this class, spelled as `os(...)` spells them and compared
+  /// case-sensitively. An unconditional module lists every OS. Empty means no build is known to
+  /// include it, because the enclosing conditions depend on flags not asserted with `--define` or
+  /// on conditions a static scan cannot answer (those are reported in `warnings`). The consumer
+  /// must not assume such a class exists.
+  let platforms: [String]
+
+  /// Source file the module was found in, relative to the path the scanner was invoked with.
+  let file: String
+}
+
+/// Version of the `scan-modules` output shape. Bumped on any breaking change to the envelope or to
+/// `ScannedModule`, so `expo-modules-autolinking` can verify it understands the output before
+/// trusting it (and fall back to config-declared modules when it doesn't). Version 2 added the
+/// per-module `platforms` list and made the module list platform-agnostic.
+let scanModulesSchemaVersion = 2
+
+/// The `scan-modules` result: the detected modules plus the stats describing the run. Encoded as the
+/// command's JSON output. (`scan-exports` returns its own `ScanExportsResult` shape; the two commands
+/// serve different consumers and don't share an envelope.)
+struct ScanModulesResult: Codable, Equatable {
+  let schemaVersion: Int
+  let modules: [ScannedModule]
+
+  /// Warnings for `#if` conditions the scan couldn't answer statically (see `ScanWarning`). Carried
+  /// in the report rather than on stderr so the consumer can attach them to its own output.
+  let warnings: [ScanWarning]
+
+  let stats: ScanStats
+}
+
+/// The Apple OSes a scan attributes modules to. `condition` is what `os(...)` matches; `reported`
+/// is what the JSON carries. They are identical today, but stated separately so the output
+/// contract cannot drift if the matcher's spelling changes.
+private let platformUniverse: [(condition: String, reported: String)] = [
+  (condition: "iOS", reported: "iOS"),
+  (condition: "macOS", reported: "macOS"),
+  (condition: "tvOS", reported: "tvOS"),
+  (condition: "watchOS", reported: "watchOS"),
+  (condition: "visionOS", reported: "visionOS"),
+]
+
+/// Scans the given paths for top-level `@ExpoModule` types and returns every module found in any
+/// `#if` branch (in file then source order), each with the platforms whose builds include it, plus
+/// the stats for the run — the `scan-modules` command. Kept separate from the public entry (and
+/// `internal`) so tests can drive it without going through argv/stdout.
+///
+/// Each file is parsed once and walked once per platform (plus once unconditionally to enumerate
+/// every module): a module's `platforms` are the OSes whose evaluated walk reached it, given the
+/// asserted `defines`. The scanner reports the facts; filtering to the platform being linked is the
+/// consumer's call.
+func scanModules(paths: [String], defines: Set<String> = []) -> ScanModulesResult {
+  var modules: [ScannedModule] = []
+  var warnings: [ScanWarning] = []
+  var seenWarnings = Set<ScanWarning>()
+
+  let stats = scanFiles(paths: paths, macros: [.expoModule]) { source, file in
+    let tree = Parser.parse(source: source)
+
+    // The unconditional walk enumerates every module in the file, in source order.
+    let allModules = DetectionVisitor(file: file, tree: tree, detectedMacros: [.expoModule], configuration: nil)
+    allModules.walk(tree)
+
+    // One evaluated walk per OS attributes each module to the platforms that include it. The walks
+    // are cheap relative to the parse, which is shared.
+    var platformsByDetection: [String: [String]] = [:]
+    for platform in platformUniverse {
+      let configuration = ScanBuildConfiguration(platform: platform.condition, defines: defines)
+      let visitor = DetectionVisitor(file: file, tree: tree, detectedMacros: [.expoModule], configuration: configuration)
+      visitor.walk(tree)
+      for detection in visitor.detections {
+        platformsByDetection[detectionKey(detection), default: []].append(platform.reported)
+      }
+      // The same unanswerable condition diagnoses identically in every per-platform walk; report
+      // it once.
+      for warning in visitor.warnings where seenWarnings.insert(warning).inserted {
+        warnings.append(warning)
+      }
+    }
+
+    for detection in allModules.detections {
+      // Resolve the JS name the way the macro does: explicit `@ExpoModule("Foo")` override, else
+      // the class name.
+      modules.append(
+        ScannedModule(
+          name: detection.name,
+          jsName: detection.jsName ?? detection.name,
+          accessLevel: detection.accessLevel,
+          platforms: platformsByDetection[detectionKey(detection)] ?? [],
+          file: detection.file
+        )
+      )
+    }
+  }
+
+  return ScanModulesResult(
+    schemaVersion: scanModulesSchemaVersion,
+    modules: modules,
+    warnings: warnings,
+    stats: stats
+  )
+}
+
+/// Identifies one declaration across the per-platform walks of the same tree: the source position
+/// is unique within a file, and the name guards against any position ambiguity.
+private func detectionKey(_ detection: Detection) -> String {
+  return "\(detection.line):\(detection.column):\(detection.name)"
+}

package/apple/build.js

@@ -0,0 +1,138 @@
+#!/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);
+});

package/build/index.d.ts

@@ -0,0 +1,51 @@
+import { ScanExportsResult, ScanModulesResult } from './types';
+export * from './types';
+/** Options accepted by `scanModules`, mirroring the CLI's `scan-modules` flags. */
+export interface ScanModulesOptions {
+    /** Conditional compilation flags to treat as set, e.g. `['DEBUG']`. */
+    defines?: string[];
+    /** Overrides the scanner binary path. Defaults to the one shipped with this package. */
+    binaryPath?: string;
+}
+/** Options accepted by `scanExports`. The deep scan doesn't evaluate `#if`, so it takes no flags. */
+export interface ScanExportsOptions {
+    /** Overrides the scanner binary path. Defaults to the one shipped with this package. */
+    binaryPath?: string;
+}
+/**
+ * Thrown when the scanner exits non-zero. Exit code 2 is a usage error (bad subcommand or flags) and
+ * 1 means the report couldn't be encoded; both put a message on stderr, carried here as `stderr`.
+ */
+export declare class ScannerError extends Error {
+    readonly exitCode: number | null;
+    readonly stderr: string;
+    constructor(message: string, exitCode: number | null, stderr: string);
+}
+/** Thrown when the binary's output schema doesn't match what these types were written against. */
+export declare class ScannerSchemaVersionError extends Error {
+    readonly command: string;
+    readonly found: number;
+    readonly expected: number;
+    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.
+ */
+export declare function getScannerBinaryPath(): string;
+/**
+ * Fast scan for top-level `@ExpoModule` types, for autolinking. Each path is a `.swift` file or a
+ * directory, scanned recursively.
+ *
+ * Conditions the scan can't answer statically come back in `warnings` rather than throwing, so the
+ * caller can surface them alongside its own diagnostics.
+ */
+export declare function scanModules(paths: string[], options?: ScanModulesOptions): Promise<ScanModulesResult>;
+/**
+ * Deep scan of the full JS-exported surface, for TypeScript type generation. Each path is a `.swift`
+ * file or a directory, scanned recursively.
+ *
+ * Unlike `scanModules`, this doesn't evaluate `#if` blocks, so it takes no define option:
+ * conditional declarations are reported as if their conditions held.
+ */
+export declare function scanExports(paths: string[], options?: ScanExportsOptions): Promise<ScanExportsResult>;