@expo/expo-modules-macros-plugin 0.11.0 → 0.12.0

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

@@ -5,8 +5,10 @@ import Foundation
 enum DetectedMacro: String, Codable, CaseIterable {
   case expoModule = "ExpoModule"
   case js = "JS"
+  case event = "Event"
   case sharedObject = "SharedObject"
   case record = "Record"
+  case union = "Union"
 }
 
 /// A single argument passed to a macro, e.g. `"Foo"` or `classes: [Bar.self]`. The label is `nil`

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

@@ -2,14 +2,17 @@ import Foundation
 import SwiftParser
 import SwiftSyntax
 
-/// Walks `paths`, and for each `.swift` file that might contain one of `macros` (the pre-filter passes
-/// it), reads the source and hands it to `process` along with the file path. Returns the run's stats.
+/// Walks `paths`, and for each `.swift` file that might contain one of `macros` or one of
+/// `conformances` (the pre-filter passes it), reads the source and hands it to `process` along with the
+/// file path. Returns the run's stats.
+///
 /// The shared core every scan command builds on: the walk, read, pre-filter, and stats are identical;
 /// only what each command does per parsed file differs (`scan-modules` collects `Detection`s,
 /// `scan-exports` walks a `SurfaceVisitor`), and that lives in `process`.
 func scanFiles(
   paths: [String],
   macros: Set<DetectedMacro>,
+  conformances: Set<String> = [],
   process: (_ source: String, _ file: String) -> Void
 ) -> ScanStats {
   let clock = ContinuousClock()
@@ -19,7 +22,7 @@ func scanFiles(
   var filesParsed = 0
 
   // Compile the pre-filter regex once per run, not once per file.
-  let prefilter = macroAttributeRegex(for: macros)
+  let prefilter = macroAttributeRegex(for: macros, conformances: conformances)
 
   for file in swiftFiles(in: paths) {
     guard let source = try? String(contentsOfFile: file, encoding: .utf8) else {
@@ -82,10 +85,23 @@ func detect(
 /// `@(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.
-func macroAttributeRegex(for macros: Set<DetectedMacro>) -> NSRegularExpression {
+///
+/// `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 alternation = macros.map(\.rawValue).sorted().joined(separator: "|")
-  return try! NSRegularExpression(pattern: "@(\(alternation))")
+  let attributes = macros.map(\.rawValue).sorted().joined(separator: "|")
+  var alternatives: [String] = []
+  if !attributes.isEmpty {
+    alternatives.append("@(\(attributes))")
+  }
+  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

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

@@ -128,6 +128,36 @@ struct ExportedRecordProperty: Encodable, Equatable {
   }
 }
 
+/// One `@Event var` on a module or shared object: a typed event JS listens for with
+/// `addListener(jsName, …)` rather than calls.
+struct ExportedEvent: Encodable, Equatable {
+  /// The Swift property name, e.g. `onStatusChange`.
+  let name: String
+
+  /// The name JS listens under: the `@Event("x")` override, else `name` with a conventional `on`
+  /// prefix stripped and decapitalized (`onStatusChange` -> `statusChange`).
+  let jsName: String
+
+  /// The single payload parameter's type, or `nil` for a no-payload `() -> Void` event.
+  let payload: TypeNode?
+
+  /// `@Event(sync: true)`, dispatching inline on the JS thread instead of scheduling.
+  let isSync: Bool
+
+  private enum CodingKeys: String, CodingKey {
+    case name, jsName, payload
+    case isSync = "sync"
+  }
+
+  func encode(to encoder: Encoder) throws {
+    var container = encoder.container(keyedBy: CodingKeys.self)
+    try container.encode(name, forKey: .name)
+    try container.encode(jsName, forKey: .jsName)
+    try container.encodeIfPresent(payload, forKey: .payload)
+    try container.encode(isSync, forKey: .isSync)
+  }
+}
+
 /// A `@ExpoModule` type and its `@JS` surface.
 struct ExportedModule: Encodable, Equatable {
   /// The Swift class name.
@@ -138,6 +168,7 @@ struct ExportedModule: Encodable, Equatable {
 
   let functions: [ExportedFunction]
   let properties: [ExportedProperty]
+  let events: [ExportedEvent]
 
   /// Absolute source path, matching `scan-modules`.
   let file: String
@@ -156,6 +187,7 @@ struct ExportedSharedObject: Encodable, Equatable {
 
   let functions: [ExportedFunction]
   let properties: [ExportedProperty]
+  let events: [ExportedEvent]
 
   let file: String
 }
@@ -170,19 +202,113 @@ struct ExportedRecord: Encodable, Equatable {
   let file: String
 }
 
+/// One case of a reported enum.
+///
+/// What `rawValue` carries depends on the enum's raw type, and a consumer reads it that way:
+/// - `String`: always present, and **decoded** (`case active = "act"` reports `act`, unquoted). A case
+///   writing none takes its own name, so nothing is left to derive.
+/// - an integer type: present only where written, as **source text** (`1`, `1 << 3`), since the value
+///   may be an expression a syntactic scan can't evaluate. Swift also continues from the preceding
+///   case's value (`case a = 1; case b` makes `b` 2), and that carry is the consumer's to apply.
+/// - no raw type: always absent, since the enum has no raw values.
+struct ExportedEnumCase: Encodable, Equatable {
+  /// The case name as declared.
+  let name: String
+
+  /// The raw value, decoded for a string and verbatim source text otherwise, or `nil` per the rule
+  /// above.
+  let rawValue: String?
+
+  private enum CodingKeys: String, CodingKey {
+    case name, rawValue
+  }
+
+  func encode(to encoder: Encoder) throws {
+    var container = encoder.container(keyedBy: CodingKeys.self)
+    try container.encode(name, forKey: .name)
+    try container.encodeIfPresent(rawValue, forKey: .rawValue)
+  }
+}
+
+/// An `Enumerable` enum: a type that crosses the boundary as its raw value rather than as an object.
+/// Detected by conformance, not by a macro attribute, because core converts it through its
+/// `RawRepresentable`/`Enumerable` conformance (`Coding/…+Enumerable`) with no macro involved.
+struct ExportedEnum: Encodable, Equatable {
+  /// The Swift enum name. No `jsName`: an enum carries no macro to spell an override on, and it
+  /// reaches JS as its raw values, not under a bound name.
+  let name: String
+
+  /// The raw value type as written (`String`, `Int`, …), or `nil` for a bare `Enumerable` conformance
+  /// with no raw type. A `nil` raw type is reported as-is rather than dropped: the enum is still
+  /// declared convertible, and the consumer decides how to treat it.
+  let rawType: TypeNode?
+
+  let cases: [ExportedEnumCase]
+
+  let file: String
+
+  private enum CodingKeys: String, CodingKey {
+    case name, rawType, cases, file
+  }
+
+  func encode(to encoder: Encoder) throws {
+    var container = encoder.container(keyedBy: CodingKeys.self)
+    try container.encode(name, forKey: .name)
+    try container.encodeIfPresent(rawType, forKey: .rawType)
+    try container.encode(cases, forKey: .cases)
+    try container.encode(file, forKey: .file)
+  }
+}
+
+/// One alternative a `@Union` may hold: the Swift case name plus its payload type. Not a member in the
+/// sense a module or shared object has members (functions, properties, events).
+struct ExportedUnionMember: Encodable, Equatable {
+  /// The case name as declared. Swift-side only: discrimination is structural, so it never reaches JS,
+  /// but it ties an alternative back to the declaration.
+  let name: String
+
+  /// The associated value's type: what this alternative decodes from. Named `type` like every other
+  /// type-valued field here; `payload` already means an event's argument type on `ExportedEvent`.
+  let type: TypeNode
+
+  private enum CodingKeys: String, CodingKey {
+    case name, type
+  }
+}
+
+/// A `@Union` enum: a typed union of its cases' payload types (`A | B | C` in TypeScript).
+///
+/// **`members` is ordered, and the order is part of the contract.** Decode tries each payload in
+/// declaration order and takes the first that succeeds, so where two shapes overlap (`Int` and
+/// `Double`, two compatible records) the earlier case wins. Reordering them describes a different
+/// union than the one the module runs.
+struct ExportedUnion: Encodable, Equatable {
+  /// The Swift enum name. No `jsName`: `@Union` takes no arguments, and a union reaches JS as its
+  /// payload types rather than under a bound name.
+  let name: String
+
+  let members: [ExportedUnionMember]
+
+  let file: String
+}
+
 /// The exported types grouped by kind, nested under `exports` in the result so the surface is one
 /// self-contained object separate from `stats`.
 struct ExportedSurface: Encodable, Equatable {
   let modules: [ExportedModule]
   let sharedObjects: [ExportedSharedObject]
   let records: [ExportedRecord]
+  let enums: [ExportedEnum]
+  let unions: [ExportedUnion]
 }
 
 /// Version of the `scan-exports` output shape. Bumped on any breaking change to the envelope or to
 /// anything under `exports`, so a consumer can verify it understands the output before trusting it.
 /// Versioned independently of `scanModulesSchemaVersion`: the two commands serve different consumers
-/// and change for different reasons.
-let scanExportsSchemaVersion = 1
+/// and change for different reasons. Version 2 added `events` to modules and shared objects; version 3
+/// added `enums`; version 4 added `unions`; version 5 resolves refs, adding `refKind` and correcting
+/// an enum ref's `typeof`.
+let scanExportsSchemaVersion = 5
 
 /// The `scan-exports` result: the surface plus the run's stats. A distinct envelope from
 /// `ScanModulesResult` (different consumer: TS generation vs. autolinking).

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

@@ -0,0 +1,199 @@
+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
+/// just a name: the parser has no idea whether the scan will turn up an `@Record`, an `Enumerable`
+/// enum, or nothing at all. Resolution is therefore a second pass over the collected surface, run once
+/// every file has been walked.
+///
+/// Two things change on a resolved ref:
+/// - `refKind` names which kind declares it, so a consumer doesn't repeat this lookup.
+/// - the `typeof` category is corrected for an enum, which crosses as its raw value rather than as an
+///   object. That correction is the reason this can't be left to the consumer: the scanner is the only
+///   side that knows the enum's `rawType`.
+///
+/// A name the scan never declared keeps `refKind: nil` and its `object` category. Not an error: it is
+/// a platform convertible (`CGPoint`, `URL`) or a type from another module, and the consumer's own
+/// catalog decides.
+
+/// The declared names of a scanned surface, each mapped to how it should be reported at a use site.
+/// Built once per scan and used for every ref lookup.
+struct RefIndex {
+  /// `name` -> the kind declaring it, plus the JS category a ref to it crosses as.
+  private var entries: [String: (kind: RefKind, jsType: JSType)] = [:]
+
+  init(surface: ExportedSurface) {
+    for record in surface.records {
+      entries[record.name] = (.record, .object)
+    }
+    for sharedObject in surface.sharedObjects {
+      entries[sharedObject.name] = (.sharedObject, .object)
+    }
+    for union in surface.unions {
+      // A union crosses as whichever alternative matched, so its category is only meaningful per
+      // member. `object` is the honest coarse answer; the consumer reads `members` for the real shape.
+      entries[union.name] = (.union, .object)
+    }
+    for enumeration in surface.enums {
+      entries[enumeration.name] = (.enum, jsType(ofRawType: enumeration.rawType))
+    }
+  }
+
+  /// How a ref to `name` should be reported, or `nil` when the scan declares no such type.
+  func lookup(_ name: String) -> (kind: RefKind, jsType: JSType)? {
+    if let entry = entries[name] {
+      return entry
+    }
+    // A qualified use site (`Media.Status`) names the same type a bare declaration did. Fall back to
+    // the trailing component, which is how the conformance and raw-type checks already match names.
+    guard let trailing = name.split(separator: ".").last.map(String.init), trailing != name else {
+      return nil
+    }
+    return entries[trailing]
+  }
+}
+
+/// The JS category a raw-value enum crosses as: its raw value's. A bare `Enumerable` conformance with
+/// no raw type has nothing to go on, so it stays an object.
+private func jsType(ofRawType rawType: TypeNode?) -> JSType {
+  guard let rawType, let jsType = rawType.jsType else {
+    return .object
+  }
+  return jsType
+}
+
+extension TypeNode {
+  /// This node with every `.ref` in it resolved against `index`, recursively. Returns an unchanged
+  /// node when nothing in it resolves.
+  func resolvingRefs(using index: RefIndex) -> TypeNode {
+    switch self {
+    case .primitive, .unknown:
+      return self
+    case .ref(let name, _, _):
+      guard let entry = index.lookup(name) else {
+        return self
+      }
+      // Only an enum crosses as something other than an object, so only it carries an override.
+      return .ref(
+        name: name, refKind: entry.kind, jsTypeOverride: entry.jsType == .object ? nil : entry.jsType)
+    case .optional(let wrapped):
+      return .optional(wrapped: wrapped.resolvingRefs(using: index))
+    case .array(let element):
+      return .array(element: element.resolvingRefs(using: index))
+    case .dictionary(let key, let value):
+      return .dictionary(
+        key: key.resolvingRefs(using: index), value: value.resolvingRefs(using: index))
+    case .promise(let value):
+      return .promise(value: value.resolvingRefs(using: index))
+    case .function(let parameters, let returns, let isAsync, let isThrowing):
+      return .function(
+        parameters: parameters.map { $0.resolvingRefs(using: index) },
+        returns: returns?.resolvingRefs(using: index),
+        isAsync: isAsync,
+        isThrowing: isThrowing
+      )
+    }
+  }
+}
+
+extension ExportedSurface {
+  /// This surface with every `.ref` in every reported type resolved against its own declarations. The
+  /// second pass `scanExports` runs once the walk is done.
+  ///
+  /// Only the boundary types are rewritten; names, flags, and ordering are untouched. The declared
+  /// types (a record's own name, a union's members) are not themselves refs, so they carry no
+  /// `refKind`: it is the *use sites* that gain one.
+  func resolvingRefs() -> ExportedSurface {
+    let index = RefIndex(surface: self)
+    return ExportedSurface(
+      modules: modules.map { module in
+        ExportedModule(
+          name: module.name,
+          jsName: module.jsName,
+          functions: module.functions.map { $0.resolvingRefs(using: index) },
+          properties: module.properties.map { $0.resolvingRefs(using: index) },
+          events: module.events.map { $0.resolvingRefs(using: index) },
+          file: module.file
+        )
+      },
+      sharedObjects: sharedObjects.map { sharedObject in
+        ExportedSharedObject(
+          name: sharedObject.name,
+          jsName: sharedObject.jsName,
+          constructorParameters: sharedObject.constructorParameters?.map { $0.resolvingRefs(using: index) },
+          functions: sharedObject.functions.map { $0.resolvingRefs(using: index) },
+          properties: sharedObject.properties.map { $0.resolvingRefs(using: index) },
+          events: sharedObject.events.map { $0.resolvingRefs(using: index) },
+          file: sharedObject.file
+        )
+      },
+      records: records.map { record in
+        ExportedRecord(
+          name: record.name,
+          properties: record.properties.map { property in
+            ExportedRecordProperty(
+              name: property.name,
+              type: property.type.resolvingRefs(using: index),
+              isOptional: property.isOptional,
+              hasDefault: property.hasDefault
+            )
+          },
+          file: record.file
+        )
+      },
+      // An enum's raw type is a primitive or an unscanned spelling, never a ref to another scanned
+      // type, so there is nothing in one to resolve.
+      enums: enums,
+      unions: unions.map { union in
+        ExportedUnion(
+          name: union.name,
+          members: union.members.map { member in
+            ExportedUnionMember(name: member.name, type: member.type.resolvingRefs(using: index))
+          },
+          file: union.file
+        )
+      }
+    )
+  }
+}
+
+extension ExportedParameter {
+  fileprivate func resolvingRefs(using index: RefIndex) -> ExportedParameter {
+    return ExportedParameter(
+      label: label, name: name, type: type.resolvingRefs(using: index), isOptional: isOptional)
+  }
+}
+
+extension ExportedFunction {
+  fileprivate func resolvingRefs(using index: RefIndex) -> ExportedFunction {
+    return ExportedFunction(
+      name: name,
+      jsName: jsName,
+      parameters: parameters.map { $0.resolvingRefs(using: index) },
+      returns: returns?.resolvingRefs(using: index),
+      isAsync: isAsync,
+      isThrowing: isThrowing,
+      isStatic: isStatic
+    )
+  }
+}
+
+extension ExportedProperty {
+  fileprivate func resolvingRefs(using index: RefIndex) -> ExportedProperty {
+    return ExportedProperty(
+      name: name,
+      jsName: jsName,
+      type: type?.resolvingRefs(using: index),
+      isSettable: isSettable,
+      isStatic: isStatic
+    )
+  }
+}
+
+extension ExportedEvent {
+  fileprivate func resolvingRefs(using index: RefIndex) -> ExportedEvent {
+    return ExportedEvent(
+      name: name, jsName: jsName, payload: payload?.resolvingRefs(using: index), isSync: isSync)
+  }
+}

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

@@ -22,27 +22,45 @@ extension Scanner {
   }
 }
 
-/// Scans `paths` for `@ExpoModule`, `@SharedObject`, and `@Record` types and returns their exported
-/// surface plus the run's stats. Separate from the public entry so tests can drive it without
-/// argv/stdout. The shared `scanFiles` walk + pre-filter selects files; a `SurfaceVisitor` extracts
-/// each one.
+/// Scans `paths` for `@ExpoModule`, `@SharedObject`, `@Record`, and `@Union` types plus `Enumerable`
+/// enums, and returns their exported surface plus the run's stats. Separate from the public entry so
+/// tests can drive it without argv/stdout.
+///
+/// The pre-filter omits `@Event`: an event only declares a member of one of these three types, so a
+/// file containing one already matches on its enclosing type. It does include `Enumerable`, which is a
+/// conformance rather than an attribute: an enum is commonly declared in a file of its own, which no
+/// macro attribute would match.
 func scanExports(paths: [String]) -> ScanExportsResult {
   var modules: [ExportedModule] = []
   var sharedObjects: [ExportedSharedObject] = []
   var records: [ExportedRecord] = []
+  var enums: [ExportedEnum] = []
+  var unions: [ExportedUnion] = []
 
-  let stats = scanFiles(paths: paths, macros: [.expoModule, .sharedObject, .record]) { source, file in
+  let stats = scanFiles(
+    paths: paths,
+    macros: [.expoModule, .sharedObject, .record, .union],
+    conformances: [enumerableConformanceName]
+  ) { source, file in
     let tree = Parser.parse(source: source)
     let visitor = SurfaceVisitor(file: file)
     visitor.walk(tree)
     modules.append(contentsOf: visitor.modules)
     sharedObjects.append(contentsOf: visitor.sharedObjects)
     records.append(contentsOf: visitor.records)
+    enums.append(contentsOf: visitor.enums)
+    unions.append(contentsOf: visitor.unions)
   }
 
+  // Refs resolve only once every file has been walked: a type parsed in one file may name a type
+  // declared in another, so the full set of declarations has to exist before any lookup is valid.
+  let surface = ExportedSurface(
+    modules: modules, sharedObjects: sharedObjects, records: records, enums: enums, unions: unions
+  ).resolvingRefs()
+
   return ScanExportsResult(
     schemaVersion: scanExportsSchemaVersion,
-    exports: ExportedSurface(modules: modules, sharedObjects: sharedObjects, records: records),
+    exports: surface,
     stats: stats
   )
 }

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

@@ -10,6 +10,8 @@ final class SurfaceVisitor: SyntaxVisitor {
   private(set) var modules: [ExportedModule] = []
   private(set) var sharedObjects: [ExportedSharedObject] = []
   private(set) var records: [ExportedRecord] = []
+  private(set) var enums: [ExportedEnum] = []
+  private(set) var unions: [ExportedUnion] = []
 
   init(file: String) {
     self.file = file
@@ -32,25 +34,57 @@ final class SurfaceVisitor: SyntaxVisitor {
     return .skipChildren
   }
 
+  /// The two kinds of enum the surface reports: a `@Union` by its attribute, an `Enumerable` enum by
+  /// its conformance (core converts it with no macro involved, so there is no attribute to key on).
+  ///
+  /// `@Union` wins when a type carries both. Its cases hold payloads rather than raw values, so there
+  /// would be nothing to report as an enum, and listing it in both arrays would describe two
+  /// contradictory JS types for one declaration.
+  override func visit(_ node: EnumDeclSyntax) -> SyntaxVisitorContinueKind {
+    guard isTopLevel(node) else {
+      return .skipChildren
+    }
+
+    if node.attributes.firstAttribute(named: DetectedMacro.union.rawValue) != nil {
+      unions.append(
+        ExportedUnion(
+          name: node.name.text,
+          members: collectUnionMembers(node.memberBlock.members),
+          file: file
+        ))
+    } else if inherits(from: enumerableConformanceName, in: node.inheritanceClause) {
+      let rawType = rawValueType(of: node.inheritanceClause)
+      enums.append(
+        ExportedEnum(
+          name: node.name.text,
+          rawType: rawType,
+          cases: collectEnumCases(node.memberBlock.members, rawType: rawType),
+          file: file
+        ))
+    }
+    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)
+      let (functions, properties, events, _) = collectJSMembers(members)
       modules.append(
         ExportedModule(
           name: name,
           jsName: stringArgument(of: attribute) ?? name,
           functions: functions,
           properties: properties,
+          events: events,
           file: file
         ))
       return
     }
 
     if let attribute = attributes.firstAttribute(named: DetectedMacro.sharedObject.rawValue) {
-      let (functions, properties, constructor) = collectJSMembers(members)
+      let (functions, properties, events, constructor) = collectJSMembers(members)
       sharedObjects.append(
         ExportedSharedObject(
           name: name,
@@ -58,6 +92,7 @@ final class SurfaceVisitor: SyntaxVisitor {
           constructorParameters: constructor,
           functions: functions,
           properties: properties,
+          events: events,
           file: file
         ))
       return
@@ -68,13 +103,17 @@ final class SurfaceVisitor: SyntaxVisitor {
     }
   }
 
-  /// 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.
+  /// The exported members of a module / shared-object body: `@JS` functions and properties, `@Event`
+  /// events, and the single `@JS init` constructor parameters (`nil` when absent).
   private func collectJSMembers(
     _ members: MemberBlockItemListSyntax
-  ) -> (functions: [ExportedFunction], properties: [ExportedProperty], constructor: [ExportedParameter]?) {
+  ) -> (
+    functions: [ExportedFunction], properties: [ExportedProperty], events: [ExportedEvent],
+    constructor: [ExportedParameter]?
+  ) {
     var functions: [ExportedFunction] = []
     var properties: [ExportedProperty] = []
+    var events: [ExportedEvent] = []
     var constructor: [ExportedParameter]?
 
     for member in members {
@@ -98,10 +137,52 @@ final class SurfaceVisitor: SyntaxVisitor {
       if let varDecl = decl.as(VariableDeclSyntax.self),
         let attribute = varDecl.attributes.firstAttribute(named: DetectedMacro.js.rawValue) {
         properties.append(contentsOf: makeProperties(varDecl: varDecl, attribute: attribute))
+        continue
+      }
+
+      if let varDecl = decl.as(VariableDeclSyntax.self),
+        let attribute = varDecl.attributes.firstAttribute(named: DetectedMacro.event.rawValue) {
+        events.append(contentsOf: makeEvents(varDecl: varDecl, attribute: attribute))
       }
     }
 
-    return (functions, properties, constructor)
+    return (functions, properties, events, constructor)
+  }
+
+  /// Builds the `ExportedEvent` entries for an `@Event var`, applying the same checks
+  /// `EventMacro.validatedEvent(of:on:)` does. A rejected declaration expands to no event, so
+  /// reporting one would describe a surface that does not exist. `@JS` on the same property is
+  /// caught by the caller, which reaches the `@JS` branch first.
+  private func makeEvents(varDecl: VariableDeclSyntax, attribute: AttributeSyntax) -> [ExportedEvent] {
+    guard varDecl.bindingSpecifier.tokenKind != .keyword(.let),
+      !isTypeLevel(varDecl.modifiers) else {
+      return []
+    }
+    let override = stringArgument(of: attribute)
+    let isSync = boolArgument(of: attribute, label: "sync") == true
+    var result: [ExportedEvent] = []
+
+    for binding in varDecl.bindings {
+      // Binding-level checks, in the macro's order: a named binding with a function type that takes
+      // at most one payload and returns Void, with no initializer or hand-written accessors.
+      guard let ident = binding.pattern.as(IdentifierPatternSyntax.self),
+        binding.initializer == nil,
+        binding.accessorBlock == nil,
+        let functionType = underlyingFunctionType(of: binding.typeAnnotation?.type),
+        isVoidEventReturn(functionType.returnClause.type),
+        functionType.parameters.count <= 1 else {
+        continue
+      }
+      let name = ident.identifier.text
+      result.append(
+        ExportedEvent(
+          name: name,
+          jsName: override ?? defaultEventName(for: name),
+          payload: functionType.parameters.first.map { typeNode(from: $0.type) },
+          isSync: isSync
+        ))
+    }
+    return result
   }
 
   /// Builds an `ExportedFunction` from a `@JS func`: JS-name fallback, parameters, a `Void` return as
@@ -208,6 +289,61 @@ final class SurfaceVisitor: SyntaxVisitor {
     return properties
   }
 
+  /// The declared cases of an enum, in source order. One `case` declaration can introduce several
+  /// cases (`case a, b`), so each element is read separately. A case carrying associated values is
+  /// skipped: it has no raw value, so it can't cross the boundary as one.
+  ///
+  /// A `String`-backed case with no written value takes the case's own name, so those are filled in
+  /// here and a `String`-backed enum reports a raw value on every case. `Int` is deliberately left
+  /// alone: see `derivedStringRawValue(for:rawType:)`.
+  private func collectEnumCases(
+    _ members: MemberBlockItemListSyntax,
+    rawType: TypeNode?
+  ) -> [ExportedEnumCase] {
+    var cases: [ExportedEnumCase] = []
+
+    for member in members {
+      guard let caseDecl = member.decl.as(EnumCaseDeclSyntax.self) else {
+        continue
+      }
+      for element in caseDecl.elements where element.parameterClause == nil {
+        let name = element.name.text
+        cases.append(
+          ExportedEnumCase(
+            name: name,
+            rawValue: writtenRawValue(of: element) ?? derivedStringRawValue(for: name, rawType: rawType)
+          ))
+      }
+    }
+    return cases
+  }
+
+  /// The alternatives of a `@Union`, in declaration order (the decode depends on it). Skips the cases
+  /// `UnionMacro.validatedUnion(of:)` rejects (no associated value, more than one, or a default), since
+  /// those don't exist at runtime. The scanner never diagnoses, it just declines to report.
+  ///
+  /// A generic `@Union` is rejected wholesale by the macro but still reported, since the declaration
+  /// names a type a consumer may meet.
+  private func collectUnionMembers(_ members: MemberBlockItemListSyntax) -> [ExportedUnionMember] {
+    var result: [ExportedUnionMember] = []
+
+    for member in members {
+      guard let caseDecl = member.decl.as(EnumCaseDeclSyntax.self) else {
+        continue
+      }
+      for element in caseDecl.elements {
+        guard let parameters = element.parameterClause?.parameters,
+          parameters.count == 1, let parameter = parameters.first,
+          parameter.defaultValue == nil else {
+          continue
+        }
+        result.append(
+          ExportedUnionMember(name: element.name.text, type: typeNode(from: parameter.type)))
+      }
+    }
+    return result
+  }
+
   /// 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] {
@@ -236,6 +372,79 @@ final class SurfaceVisitor: SyntaxVisitor {
 // MARK: - Syntactic helpers (shared spelling with the macros)
 
 /// True when the modifiers make a member type-level (`static` or `class`).
+// MARK: - `@Event` helpers
+
+// The macro target can't be imported, so these are deliberate copies of `EventMacro`'s logic. They
+// must stay in step with it: a drift changes the reported surface without failing any build.
+
+/// The Swift name with a conventional `on` prefix stripped and the remainder decapitalized
+/// (`onStatusChange` -> `statusChange`); names without the prefix pass through verbatim. A drift
+/// from the macro's copy would produce listener names the module never emits.
+func defaultEventName(for swiftName: String) -> String {
+  guard swiftName.hasPrefix("on") else {
+    return swiftName
+  }
+  let rest = swiftName.dropFirst(2)
+  guard let first = rest.first, first.isUppercase else {
+    return swiftName
+  }
+  return decapitalized(String(rest))
+}
+
+/// Lowercases the leading uppercase run the way Swift's API importer does: a single leading capital
+/// is lowercased, and a longer acronym run keeps its last capital when a lowercase letter follows it
+/// (`StatusChange` -> `statusChange`, `URLChange` -> `urlChange`, `URL` -> `url`).
+private func decapitalized(_ name: String) -> String {
+  let runEnd = name.firstIndex { !$0.isUppercase } ?? name.endIndex
+  if name[..<runEnd].count > 1 && runEnd != name.endIndex {
+    let lastCapital = name.index(before: runEnd)
+    return name[..<lastCapital].lowercased() + name[lastCapital...]
+  }
+  return name[..<runEnd].lowercased() + name[runEnd...]
+}
+
+/// The function type underlying a property's type annotation, unwrapping attributes
+/// (`@Sendable (P) -> Void`) and single-element parentheses (`((P) -> Void)`). `nil` when the
+/// annotation is missing or isn't a function type.
+private func underlyingFunctionType(of type: TypeSyntax?) -> FunctionTypeSyntax? {
+  guard let type else {
+    return nil
+  }
+  if let attributed = type.as(AttributedTypeSyntax.self) {
+    return underlyingFunctionType(of: attributed.baseType)
+  }
+  if let tuple = type.as(TupleTypeSyntax.self),
+    tuple.elements.count == 1, let element = tuple.elements.first, element.firstName == nil {
+    return underlyingFunctionType(of: element.type)
+  }
+  return type.as(FunctionTypeSyntax.self)
+}
+
+/// True when an event's function type returns `Void`. The shared `isVoidType` is not reused: it
+/// accepts neither `Swift.Void` nor a parenthesized `(Void)`, so it would drop valid events.
+private func isVoidEventReturn(_ type: TypeSyntax) -> Bool {
+  if let tuple = type.as(TupleTypeSyntax.self), tuple.elements.count == 1,
+    let element = tuple.elements.first, element.firstName == nil {
+    return isVoidEventReturn(element.type)
+  }
+  let text = type.trimmedDescription
+  return text == "Void" || text == "()" || text == "Swift.Void"
+}
+
+/// The value of a labeled boolean macro argument (`@Event(sync: true)`), or `nil` when absent.
+private func boolArgument(of attribute: AttributeSyntax, label: String) -> Bool? {
+  guard let arguments = attribute.arguments?.as(LabeledExprListSyntax.self) else {
+    return nil
+  }
+  for argument in arguments where argument.label?.text == label {
+    guard let literal = argument.expression.as(BooleanLiteralExprSyntax.self) else {
+      return nil
+    }
+    return literal.literal.tokenKind == .keyword(.true)
+  }
+  return nil
+}
+
 private func isTypeLevel(_ modifiers: DeclModifierListSyntax) -> Bool {
   modifiers.contains {
     $0.name.tokenKind == .keyword(.static) || $0.name.tokenKind == .keyword(.class)
@@ -255,6 +464,106 @@ private func isExcludedRecordModifier(_ modifiers: DeclModifierListSyntax) -> Bo
   }
 }
 
+/// The protocol whose conformance marks an enum as convertible at the JS boundary. Core converts such
+/// an enum through `Coding/…+Enumerable`, keyed on this conformance, so the scanner keys on it too.
+let enumerableConformanceName = "Enumerable"
+
+/// True when an inheritance clause names `name`. Matched on the trailing component of the written
+/// spelling, so a qualified `ExpoModulesCore.Enumerable` counts. Purely syntactic: a conformance added
+/// in a separate `extension`, or inherited through another protocol, is invisible to a scan and so is
+/// not reported.
+func inherits(from name: String, in clause: InheritanceClauseSyntax?) -> Bool {
+  guard let clause else {
+    return false
+  }
+  return clause.inheritedTypes.contains { inherited in
+    inherited.type.trimmedDescription.split(separator: ".").last.map(String.init) == name
+  }
+}
+
+/// The raw value a case writes, or `nil` when it writes none.
+///
+/// A string literal is reported **decoded**: `case a = "act"` yields `act`, with no quotes, because a
+/// `String` raw value is always fully known (see `derivedStringRawValue(for:rawType:)`) and a consumer
+/// should not have to unquote it. Every other expression is reported as **source text**, since an
+/// integer raw value may be any literal expression the scanner can't evaluate. Which of the two a
+/// `rawValue` holds follows from the enum's `rawType`, and `ExportedEnumCase` documents that contract.
+///
+/// A literal this can't decode is treated as writing no raw value rather than reported half-read: an
+/// interpolated string (`case a = "x\(y)"`, not a legal raw value anyway), or one whose segment carries
+/// a backslash escape, which would need real unescaping to turn into its value. A `String` case then
+/// falls back to the derived name, keeping that invariant intact.
+private func writtenRawValue(of element: EnumCaseElementSyntax) -> String? {
+  guard let value = element.rawValue?.value else {
+    return nil
+  }
+  guard let literal = value.as(StringLiteralExprSyntax.self) else {
+    // Not a string: an integer literal, a negative value, or an expression. Source text verbatim.
+    return value.trimmedDescription
+  }
+  guard literal.segments.count == 1,
+    let segment = literal.segments.first?.as(StringSegmentSyntax.self) else {
+    return nil
+  }
+  // The segment's text is the literal's content with its delimiters already stripped, so a plain
+  // `"act"` and a raw `#"act"#` both read as `act`. An escape is left to the fallback rather than
+  // emitted raw, since `\n` here is two characters, not a newline.
+  let content = segment.content.text
+  return content.contains("\\") ? nil : content
+}
+
+/// The raw value Swift gives a `String`-backed case that writes none: the case's own name.
+///
+/// Only `String` is derived. Its defaulting is per-case and carry-free, so a case that can't be read
+/// can't affect any other, and every legal spelling is a single-segment literal. That closes the case
+/// and lets a `String`-backed enum report a raw value on *every* case. `Int` continues
+/// from the preceding case's value (`case a = 1; case b` makes `b` 2), whether that value was written
+/// or itself derived, so one unreadable expression would corrupt every case after it. Deriving it
+/// partially would be worse than not deriving it, so integer-backed enums report only what's written
+/// and the consumer applies the continuation rule.
+private func derivedStringRawValue(for caseName: String, rawType: TypeNode?) -> String? {
+  // `String` is a `.primitive`, but a qualified `Swift.String` parses as a `.ref`, and both are legal
+  // raw types. Matching the trailing component covers each, the same way the conformance check does.
+  let name: String?
+  switch rawType {
+  case .primitive(let spelling, _), .ref(let spelling, _, _):
+    name = spelling.split(separator: ".").last.map(String.init)
+  default:
+    name = nil
+  }
+  guard name == "String" else {
+    return nil
+  }
+  // Decoded, matching how a written string literal is reported: the value, not its source spelling.
+  return caseName
+}
+
+/// Protocols an `Enumerable` enum commonly adopts, which a syntactic scan would otherwise mistake for
+/// a raw value type when one is written ahead of the conformance (`enum E: Codable, Enumerable`, which
+/// has no raw type). Only the first inherited entry is ever tested against this, so the list needs to
+/// name just what can legally precede `Enumerable`, not every protocol in existence.
+private let knownNonRawValueProtocols: Set<String> = [
+  "CaseIterable", "Codable", "Decodable", "Encodable", "Equatable", "Error", "Hashable",
+  "Identifiable", "Sendable", enumerableConformanceName,
+]
+
+/// The raw value type of an enum, or `nil` when it declares none.
+///
+/// Swift allows a raw type only in first position, so nothing after the first entry can be one. The
+/// first entry is still not necessarily a raw type: `enum E: Codable, Enumerable` is a legal
+/// raw-value-less enum, and a scan can't resolve a bare name to tell a protocol from a type. It's
+/// matched against `knownNonRawValueProtocols` instead, which covers what an `Enumerable` enum
+/// realistically adopts. An unlisted protocol written first would still be misreported as a raw type;
+/// that is the residual limit of reading this syntactically.
+func rawValueType(of clause: InheritanceClauseSyntax?) -> TypeNode? {
+  guard let first = clause?.inheritedTypes.first?.type,
+    let trailing = first.trimmedDescription.split(separator: ".").last.map(String.init),
+    !knownNonRawValueProtocols.contains(trailing) else {
+    return nil
+  }
+  return typeNode(from: first)
+}
+
 /// True when a type is written as an optional: `T?`, `T!`, or `Optional<T>`, mirroring the macros'
 /// `isOptionalType`.
 private func isOptionalType(_ type: TypeSyntax) -> Bool {

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

@@ -21,6 +21,21 @@ enum JSType: String, Encodable {
   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`.
@@ -42,9 +57,18 @@ indirect enum TypeNode: Equatable {
   /// 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)
+  /// 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`.
@@ -56,8 +80,11 @@ indirect enum TypeNode: Equatable {
     switch self {
     case .primitive(_, let jsType):
       return jsType
-    case .array, .dictionary, .promise, .ref:
+    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):
@@ -70,6 +97,7 @@ indirect enum TypeNode: Equatable {
 
 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
@@ -109,9 +137,10 @@ extension TypeNode: Encodable {
       try container.encodeIfPresent(returns, forKey: .returns)
       try container.encode(isAsync, forKey: .isAsync)
       try container.encode(isThrowing, forKey: .isThrowing)
-    case .ref(let name):
+    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)
@@ -236,7 +265,7 @@ extension TypeNode {
     switch self {
     case .primitive(let name, _):
       return name
-    case .ref(let name):
+    case .ref(let name, _, _):
       return name
     case .optional(let wrapped):
       return "\(wrapped.spelling)?"

package/build/types.d.ts

@@ -43,11 +43,21 @@ export type TypeNode = {
     async: boolean;
     throws: boolean;
 }
-/** Any other named type (record, shared object, enum, ...); `name` may be qualified. */
+/**
+ * Any other named type; `name` may be qualified.
+ *
+ * `refKind` says which of this surface's arrays declares that name, so you don't have to look it
+ * up. It is absent when the scan declares no such type: a platform convertible (`CGPoint`, `URL`)
+ * or a type from another module, which your own catalog resolves.
+ *
+ * `typeof` follows the resolved kind, so a raw-value enum reports `string` or `number` rather than
+ * `object`. Only the scanner can determine that, since it comes from the declaration's `rawType`.
+ */
  | {
     kind: 'ref';
     typeof: JSType;
     name: string;
+    refKind?: 'record' | 'sharedObject' | 'enum' | 'union';
 }
 /** A type the scanner couldn't interpret; `text` is its source spelling. */
  | {
@@ -101,9 +111,24 @@ export interface ExportedModule {
     jsName: string;
     functions: ExportedFunction[];
     properties: ExportedProperty[];
+    events: ExportedEvent[];
     /** Absolute source path. */
     file: string;
 }
+/** One `@Event var`: a typed event JS listens for by name, rather than calls. */
+export interface ExportedEvent {
+    /** The Swift property name, e.g. `onStatusChange`. */
+    name: string;
+    /**
+     * The name JS listens under: the `@Event("x")` override, else `name` with a conventional `on`
+     * prefix stripped and decapitalized (`onStatusChange` -> `statusChange`).
+     */
+    jsName: string;
+    /** The payload type, absent for a no-payload `() -> Void` event. */
+    payload?: TypeNode;
+    /** `@Event(sync: true)`, dispatching inline on the JS thread instead of scheduling. */
+    sync: boolean;
+}
 /** A `@SharedObject` type: a JS class with an optional constructor plus its `@JS` members. */
 export interface ExportedSharedObject {
     name: string;
@@ -112,6 +137,7 @@ export interface ExportedSharedObject {
     constructorParameters?: ExportedParameter[];
     functions: ExportedFunction[];
     properties: ExportedProperty[];
+    events: ExportedEvent[];
     file: string;
 }
 /** A `@Record` type and its properties. */
@@ -120,11 +146,63 @@ export interface ExportedRecord {
     properties: ExportedRecordProperty[];
     file: string;
 }
+/**
+ * One case of a reported enum.
+ *
+ * What `rawValue` carries depends on the enum's raw type:
+ * - `String`: always present, and decoded (`case active = "act"` reports `act`, unquoted). A case
+ *   writing none takes its own name, so nothing is left to derive.
+ * - an integer type: present only where written, as source text (`1`, `1 << 3`), since the value may
+ *   be an expression a syntactic scan cannot evaluate. Swift also continues from the preceding case's
+ *   value (`case a = 1; case b` makes `b` 2), and that carry is yours to apply.
+ * - no raw type: always absent, since the enum has no raw values.
+ */
+export interface ExportedEnumCase {
+    /** The case name as declared. */
+    name: string;
+    /** The raw value, decoded for a string and verbatim source text otherwise, or absent per the rule above. */
+    rawValue?: string;
+}
+/**
+ * An `Enumerable` enum: a type crossing the boundary as its raw value rather than as an object.
+ * Detected by conformance, not by a macro attribute, so it carries no `jsName`.
+ */
+export interface ExportedEnum {
+    name: string;
+    /** The raw value type as written, absent for a bare `Enumerable` conformance with no raw type. */
+    rawType?: TypeNode;
+    cases: ExportedEnumCase[];
+    file: string;
+}
+/**
+ * One alternative a `@Union` may hold. Not a member in the sense a module or shared object has members
+ * (functions, properties, events).
+ */
+export interface ExportedUnionMember {
+    /** The Swift case name. Swift-side only: discrimination is structural, so it never reaches JS. */
+    name: string;
+    /** The associated value's type: what this alternative decodes from. */
+    type: TypeNode;
+}
+/**
+ * A `@Union` enum: a typed union of its members' payload types (`A | B | C`).
+ *
+ * `members` is ordered, and the order is part of the contract: decode takes the first payload that
+ * succeeds, so where two shapes overlap (`Int` and `Double`, two compatible records) the earlier one
+ * wins. Reordering them describes a different union than the one the module runs.
+ */
+export interface ExportedUnion {
+    name: string;
+    members: ExportedUnionMember[];
+    file: string;
+}
 /** The exported types grouped by kind. */
 export interface ExportedSurface {
     modules: ExportedModule[];
     sharedObjects: ExportedSharedObject[];
     records: ExportedRecord[];
+    enums: ExportedEnum[];
+    unions: ExportedUnion[];
 }
 /** A `#if` condition the scan couldn't answer statically. */
 export interface ScanWarning {
@@ -136,7 +214,7 @@ export interface ScanWarning {
 export interface ScanStats {
     /** `.swift` files the walk found and read. */
     filesScanned: number;
-    /** Of those, how many contained a macro attribute and so were parsed. */
+    /** Of those, how many matched the pre-filter (a macro attribute or a scanned conformance). */
     filesParsed: number;
     /** Wall-clock duration of the scan, in milliseconds. */
     durationMs: number;
@@ -183,4 +261,4 @@ export interface ScanExportsResult {
  * as a clear error instead of silently misread fields.
  */
 export declare const SUPPORTED_SCAN_MODULES_SCHEMA_VERSION = 2;
-export declare const SUPPORTED_SCAN_EXPORTS_SCHEMA_VERSION = 1;
+export declare const SUPPORTED_SCAN_EXPORTS_SCHEMA_VERSION = 5;

package/build/types.js

@@ -12,4 +12,4 @@ exports.SUPPORTED_SCAN_EXPORTS_SCHEMA_VERSION = exports.SUPPORTED_SCAN_MODULES_S
  * as a clear error instead of silently misread fields.
  */
 exports.SUPPORTED_SCAN_MODULES_SCHEMA_VERSION = 2;
-exports.SUPPORTED_SCAN_EXPORTS_SCHEMA_VERSION = 1;
+exports.SUPPORTED_SCAN_EXPORTS_SCHEMA_VERSION = 5;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@expo/expo-modules-macros-plugin",
-  "version": "0.11.0",
+  "version": "0.12.0",
   "description": "Swift macro plugin for Expo modules",
   "main": "build/index.js",
   "types": "build/index.d.ts",