@expo/expo-modules-macros-plugin 0.5.1 → 0.6.1

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

@@ -0,0 +1,307 @@
+import SwiftSyntax
+
+/// Extracts the full JS-exported surface of every top-level `@ExpoModule`, `@SharedObject`, and
+/// `@Record` type: their `@JS` members and record properties. The deep counterpart to
+/// `DetectionVisitor`. Recognition is purely syntactic and re-reads what the macros read (the macro
+/// target can't be imported), so it stays in step with `JSFunction` / `JSProperty` / `JSConstructor` /
+/// `RecordProperty`.
+final class SurfaceVisitor: SyntaxVisitor {
+  private let file: String
+  private(set) var modules: [ExportedModule] = []
+  private(set) var sharedObjects: [ExportedSharedObject] = []
+  private(set) var records: [ExportedRecord] = []
+
+  init(file: String) {
+    self.file = file
+    super.init(viewMode: .sourceAccurate)
+  }
+
+  override func visit(_ node: ClassDeclSyntax) -> SyntaxVisitorContinueKind {
+    if isTopLevel(node) {
+      classify(name: node.name.text, attributes: node.attributes, members: node.memberBlock.members)
+    }
+    // The member walk reads the body itself; nested types aren't part of this surface (matching
+    // `DetectionVisitor`'s top-level-only scope), so there's no reason to descend.
+    return .skipChildren
+  }
+
+  override func visit(_ node: StructDeclSyntax) -> SyntaxVisitorContinueKind {
+    if isTopLevel(node) {
+      classify(name: node.name.text, attributes: node.attributes, members: node.memberBlock.members)
+    }
+    return .skipChildren
+  }
+
+  /// Routes a top-level type to the right collector based on which Expo macro it carries. A type
+  /// carrying none of them is ignored. `@Record` and `@ExpoModule`/`@SharedObject` are mutually
+  /// exclusive in practice, so the first match wins.
+  private func classify(name: String, attributes: AttributeListSyntax, members: MemberBlockItemListSyntax) {
+    if let attribute = attributes.firstAttribute(named: DetectedMacro.expoModule.rawValue) {
+      let (functions, properties, _) = collectJSMembers(members)
+      modules.append(
+        ExportedModule(
+          name: name,
+          jsName: stringArgument(of: attribute) ?? name,
+          functions: functions,
+          properties: properties,
+          file: file
+        ))
+      return
+    }
+
+    if let attribute = attributes.firstAttribute(named: DetectedMacro.sharedObject.rawValue) {
+      let (functions, properties, constructor) = collectJSMembers(members)
+      sharedObjects.append(
+        ExportedSharedObject(
+          name: name,
+          jsName: stringArgument(of: attribute) ?? name,
+          constructorParameters: constructor,
+          functions: functions,
+          properties: properties,
+          file: file
+        ))
+      return
+    }
+
+    if attributes.firstAttribute(named: DetectedMacro.record.rawValue) != nil {
+      records.append(ExportedRecord(name: name, properties: collectRecordProperties(members), file: file))
+    }
+  }
+
+  /// The `@JS` members of a module / shared-object body: functions, properties, and the single
+  /// `@JS init` constructor parameters (`nil` when absent). Only declarations carrying `@JS` count.
+  private func collectJSMembers(
+    _ members: MemberBlockItemListSyntax
+  ) -> (functions: [ExportedFunction], properties: [ExportedProperty], constructor: [ExportedParameter]?) {
+    var functions: [ExportedFunction] = []
+    var properties: [ExportedProperty] = []
+    var constructor: [ExportedParameter]?
+
+    for member in members {
+      let decl = member.decl
+
+      if let initDecl = decl.as(InitializerDeclSyntax.self),
+        initDecl.attributes.firstAttribute(named: DetectedMacro.js.rawValue) != nil {
+        // At most one `@JS init`; keep the first if a malformed source has more (the macro errors).
+        if constructor == nil {
+          constructor = parameters(of: initDecl.signature.parameterClause)
+        }
+        continue
+      }
+
+      if let funcDecl = decl.as(FunctionDeclSyntax.self),
+        let attribute = funcDecl.attributes.firstAttribute(named: DetectedMacro.js.rawValue) {
+        functions.append(makeFunction(funcDecl: funcDecl, attribute: attribute))
+        continue
+      }
+
+      if let varDecl = decl.as(VariableDeclSyntax.self),
+        let attribute = varDecl.attributes.firstAttribute(named: DetectedMacro.js.rawValue) {
+        properties.append(contentsOf: makeProperties(varDecl: varDecl, attribute: attribute))
+      }
+    }
+
+    return (functions, properties, constructor)
+  }
+
+  /// Builds an `ExportedFunction` from a `@JS func`: JS-name fallback, parameters, a `Void` return as
+  /// `nil`, and the effect/static flags.
+  private func makeFunction(funcDecl: FunctionDeclSyntax, attribute: AttributeSyntax) -> ExportedFunction {
+    let effects = funcDecl.signature.effectSpecifiers
+    let returnType = funcDecl.signature.returnClause?.type
+    return ExportedFunction(
+      name: funcDecl.name.text,
+      jsName: stringArgument(of: attribute) ?? funcDecl.name.text,
+      parameters: parameters(of: funcDecl.signature.parameterClause),
+      returns: isVoidType(returnType) ? nil : returnType.map { typeNode(from: $0) },
+      isAsync: effects?.asyncSpecifier != nil,
+      isThrowing: effects?.throwsClause?.throwsSpecifier != nil,
+      isStatic: isTypeLevel(funcDecl.modifiers)
+    )
+  }
+
+  /// Builds the `ExportedProperty` entries for a `@JS var`/`let`. One declaration can introduce several
+  /// bindings (`var a, b: Int`), so this returns an array. The value type is the annotation, else the
+  /// literal default's inferred type, else `nil`.
+  private func makeProperties(varDecl: VariableDeclSyntax, attribute: AttributeSyntax) -> [ExportedProperty] {
+    let isLet = varDecl.bindingSpecifier.tokenKind == .keyword(.let)
+    let isStatic = isTypeLevel(varDecl.modifiers)
+    let override = stringArgument(of: attribute)
+    var result: [ExportedProperty] = []
+
+    for binding in varDecl.bindings {
+      guard let ident = binding.pattern.as(IdentifierPatternSyntax.self) else {
+        continue
+      }
+      let name = ident.identifier.text
+      let type = valueTypeNode(annotation: binding.typeAnnotation?.type, initializer: binding.initializer?.value)
+      result.append(
+        ExportedProperty(
+          name: name,
+          jsName: override ?? name,
+          type: type,
+          isSettable: isSettable(binding: binding, isLet: isLet),
+          isStatic: isStatic
+        ))
+    }
+    return result
+  }
+
+  /// True when a binding is assignable from JS, mirroring the macro's `bindingIsSettable`: a `let` is
+  /// never settable; a stored `var` is; a computed `var` is settable iff it declares `set`/`willSet`/
+  /// `didSet` (a getter-only `var` is read-only).
+  private func isSettable(binding: PatternBindingSyntax, isLet: Bool) -> Bool {
+    if isLet {
+      return false
+    }
+    guard let accessorBlock = binding.accessorBlock else {
+      // Stored `var`, settable.
+      return true
+    }
+    switch accessorBlock.accessors {
+    case .accessors(let list):
+      return list.contains { accessor in
+        switch accessor.accessorSpecifier.tokenKind {
+        case .keyword(.set), .keyword(.willSet), .keyword(.didSet):
+          return true
+        default:
+          return false
+        }
+      }
+    case .getter:
+      // `var x: Int { ... }` shorthand getter, read-only.
+      return false
+    }
+  }
+
+  /// The `@Record` properties: every stored, non-excluded `var`/`let` binding, mirroring
+  /// `RecordMacro.recordProperties`. Computed and modifier-excluded bindings are skipped, as is one
+  /// whose type can't be determined (the macro would error, but the scan stays lenient).
+  private func collectRecordProperties(_ members: MemberBlockItemListSyntax) -> [ExportedRecordProperty] {
+    var properties: [ExportedRecordProperty] = []
+
+    for member in members {
+      guard let varDecl = member.decl.as(VariableDeclSyntax.self),
+        !isExcludedRecordModifier(varDecl.modifiers) else {
+        continue
+      }
+      for binding in varDecl.bindings {
+        if binding.accessorBlock != nil {
+          continue
+        }
+        guard let ident = binding.pattern.as(IdentifierPatternSyntax.self) else {
+          continue
+        }
+        let annotation = binding.typeAnnotation?.type
+        guard let type = valueTypeNode(annotation: annotation, initializer: binding.initializer?.value) else {
+          continue
+        }
+        properties.append(
+          ExportedRecordProperty(
+            name: ident.identifier.text,
+            type: type,
+            isOptional: annotation.map { isOptionalType($0) } ?? false,
+            hasDefault: binding.initializer != nil
+          ))
+      }
+    }
+    return properties
+  }
+
+  /// Projects a parameter clause into `ExportedParameter`s: label = first name, name = second (else
+  /// first), and `optional` when it has a default value or an optional type.
+  private func parameters(of clause: FunctionParameterClauseSyntax) -> [ExportedParameter] {
+    clause.parameters.map { parameter in
+      let label = parameter.firstName.text
+      let name = parameter.secondName?.text ?? label
+      return ExportedParameter(
+        label: label,
+        name: name,
+        type: typeNode(from: parameter.type),
+        isOptional: parameter.defaultValue != nil || isOptionalType(parameter.type)
+      )
+    }
+  }
+
+  /// True when the declaration sits at file scope. Same rule as `DetectionVisitor.isTopLevel`: its
+  /// parent is a `CodeBlockItemSyntax` directly under the source file's top-level item list.
+  private func isTopLevel(_ node: some SyntaxProtocol) -> Bool {
+    guard let item = node.parent?.as(CodeBlockItemSyntax.self) else {
+      return false
+    }
+    return item.parent?.parent?.is(SourceFileSyntax.self) == true
+  }
+}
+
+// MARK: - Syntactic helpers (shared spelling with the macros)
+
+/// True when the modifiers make a member type-level (`static` or `class`).
+private func isTypeLevel(_ modifiers: DeclModifierListSyntax) -> Bool {
+  modifiers.contains {
+    $0.name.tokenKind == .keyword(.static) || $0.name.tokenKind == .keyword(.class)
+  }
+}
+
+/// True when a modifier excludes a property from being a `@Record` field (`static`, `class`,
+/// `private`, `fileprivate`, `lazy`), mirroring `RecordMacro.isExcludedByModifier`.
+private func isExcludedRecordModifier(_ modifiers: DeclModifierListSyntax) -> Bool {
+  modifiers.contains { modifier in
+    switch modifier.name.tokenKind {
+    case .keyword(.static), .keyword(.class), .keyword(.private), .keyword(.fileprivate), .keyword(.lazy):
+      return true
+    default:
+      return false
+    }
+  }
+}
+
+/// True when a type is written as an optional: `T?`, `T!`, or `Optional<T>`, mirroring the macros'
+/// `isOptionalType`.
+private func isOptionalType(_ type: TypeSyntax) -> Bool {
+  if type.is(OptionalTypeSyntax.self) || type.is(ImplicitlyUnwrappedOptionalTypeSyntax.self) {
+    return true
+  }
+  if let identifier = type.as(IdentifierTypeSyntax.self), identifier.name.text == "Optional" {
+    return true
+  }
+  return false
+}
+
+/// The first attribute whose spelled name matches `name`. A local copy of the macros' helper (the
+/// macro target can't be imported here).
+extension AttributeListSyntax {
+  fileprivate func firstAttribute(named name: String) -> AttributeSyntax? {
+    for element in self {
+      if let attribute = element.as(AttributeSyntax.self),
+        attribute.attributeName.trimmedDescription == name {
+        return attribute
+      }
+    }
+    return nil
+  }
+}
+
+/// The node for a property/field value type: the annotation, else the literal default's inferred
+/// primitive (`var n = 1` -> `Int`), else `nil`.
+private func valueTypeNode(annotation: TypeSyntax?, initializer: ExprSyntax?) -> TypeNode? {
+  if let annotation {
+    return typeNode(from: annotation)
+  }
+  return initializer.flatMap(inferredLiteralType)
+}
+
+/// The node for a simple literal default (`var n = 1` -> `Int`); `nil` for anything non-literal.
+private func inferredLiteralType(of expression: ExprSyntax) -> TypeNode? {
+  switch expression.kind {
+  case .stringLiteralExpr:
+    return .primitive(name: "String", jsType: .string)
+  case .integerLiteralExpr:
+    return .primitive(name: "Int", jsType: .number)
+  case .floatLiteralExpr:
+    return .primitive(name: "Double", jsType: .number)
+  case .booleanLiteralExpr:
+    return .primitive(name: "Bool", jsType: .boolean)
+  default:
+    return nil
+  }
+}

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

@@ -0,0 +1,255 @@
+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
+}
+
+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, …). `name` is the possibly-qualified spelling;
+  /// the generator resolves it against the scanned types or treats it as opaque.
+  case ref(name: String)
+
+  /// 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, .ref:
+      return .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 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):
+      try container.encode("ref", forKey: .kind)
+      try container.encode(name, forKey: .name)
+    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

@@ -7,8 +7,8 @@ import Foundation
 /// `@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. (`scan-exports` will get its own
-  /// `run`-style entry returning its own result type when implemented.)
+  /// 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.)
   public static func runModules(paths: [String]) -> Int32 {
     let result = scanModules(paths: paths)
 
@@ -30,7 +30,7 @@ public enum Scanner {
 /// register a module: the Swift class name, the JS name it registers under, 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 belong to the deep `scan-exports` surface instead.
+/// 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
@@ -45,8 +45,8 @@ struct ScannedModule: Codable, Equatable {
 }
 
 /// The `scan-modules` result: the detected modules plus the stats describing the run. Encoded as the
-/// command's JSON output. (`scan-exports` will return its own shape when implemented; the two
-/// commands serve different consumers and aren't expected to share an envelope.)
+/// 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 modules: [ScannedModule]
   let stats: ScanStats

package/apple/Sources/ExpoModulesScannerCLI/main.swift

@@ -61,9 +61,10 @@ case "scan-modules":
   exit(Scanner.runModules(paths: paths))
 
 case "scan-exports":
-  // Deep extraction (members, record fields, the JS surface of each type) lands in a separate PR.
-  // The subcommand is recognized so the CLI surface is stable, but it isn't implemented yet.
-  fail("scan-exports is not yet implemented", code: 1)
+  guard !paths.isEmpty else {
+    fail("scan-exports requires at least one path", usage: true)
+  }
+  exit(Scanner.runExports(paths: paths))
 
 default:
   fail("unknown subcommand '\(subcommand)'", usage: true)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@expo/expo-modules-macros-plugin",
-  "version": "0.5.1",
+  "version": "0.6.1",
   "description": "Swift macro plugin for Expo modules",
   "license": "MIT",
   "author": "650 Industries, Inc.",