expo-modules-macros 0.32.0 → 0.33.0

package/AGENTS.md

@@ -4,9 +4,10 @@
 
 ## Layout
 
-- `Package.swift`: the SwiftPM package, at the root so that its identity is `expo-modules-macros` (an `apple/` manifest would have the identity `apple`, which conflicts with other packages that keep theirs in `apple/`). The targets name their paths under `apple/`. The `ExpoModulesMacrosPlugin` library product vends the macro target to Swift packages, and its name must differ from the target's. The test targets are declared only when `apple/Tests` exists, because the published npm package leaves it out.
+- `Package.swift`: the SwiftPM package, at the root so that its identity is `expo-modules-macros` (an `apple/` manifest would have the identity `apple`, which conflicts with other packages that keep theirs in `apple/`). The targets name their paths under `apple/`. The `ExpoModulesMacrosPlugin` library product vends the macro target to Swift packages through a target of the same name, and its name must differ from the macro target's. The test targets are declared only when `apple/Tests` exists, because the published npm package leaves it out.
 - `apple/Sources/ExpoModulesMacrosCore`: the macro implementations, in a library target so that both executables below can link them. `Macros/` holds one file per macro, and `Support/` the code that several macros share. `ProvidedMacros.swift` lists every macro with its attribute name and conformances in `ProvidedMacro.all`. `PluginServer.swift` runs the compiler plugin protocol with a provider that resolves the macros of `ProvidedMacro.all` by type name, because the default `CompilerPlugin` lookup expects them in a module named `ExpoModulesMacros`. It uses the `@_spi(PluginMessage)` API of swift-syntax.
 - `apple/Sources/ExpoModulesMacros`: the `.macro` target that the `ExpoModulesMacrosPlugin` product vends to Swift packages. It only runs the plugin server, so Swift packages don't compile the CLI.
+- `apple/Sources/ExpoModulesMacrosPlugin`: an empty target that the `ExpoModulesMacrosPlugin` product holds in place of the macro target, which it depends on. Xcode fails an iOS build when the product holds the macro target directly (see `Package.swift`).
 - `apple/Sources/ExpoModulesMacrosTool`: the executable that ships as `apple/ExpoModulesMacros` and in the Windows and Linux packages. `main.swift` runs the plugin server without arguments and sends any invocation with arguments to the CLI.
 - `apple/Sources/ExpoModulesCLI`: the library behind the command-line tool. `CLI.swift` parses the arguments, `Commands/` holds one directory per subcommand (`ScanModules/` for autolinking, `ScanExports/` for type generation, `Expand/` for `expand`, with `MacroExpander.swift`, which runs the macros in process, and `Fix/` for `fix`, which applies the Fix-Its that `expand` reports), and `Core/` holds the shared parsing, `#if` evaluation and output.
 - `apple/Sources/ExpoModulesOptimized`: declarations for the `@OptimizedFunction` macro.

package/Package.swift

@@ -14,7 +14,7 @@ let package = Package(
     // `#externalMacro(module: "ExpoModulesMacros", ...)` depends on this product, and the targets that
     // depend on it get the plugin too. CocoaPods builds keep loading the prebuilt binary. The name
     // differs from the macro target's, because SwiftPM already has a product of that name for it.
-    .library(name: "ExpoModulesMacrosPlugin", targets: ["ExpoModulesMacros"]),
+    .library(name: "ExpoModulesMacrosPlugin", targets: ["ExpoModulesMacrosPlugin"]),
     .executable(name: "ExpoModulesMacrosTool", targets: ["ExpoModulesMacrosTool"]),
   ],
   dependencies: [
@@ -51,6 +51,15 @@ let package = Package(
       ],
       path: "apple/Sources/ExpoModulesMacros"
     ),
+    // The target of the `ExpoModulesMacrosPlugin` product. The product must not hold the macro target
+    // itself: Xcode then passes the module map of `ExpoModulesMacrosCore`, which it builds for the
+    // host only, to the iOS target that depends on the product, and the build fails with
+    // `ExpoModulesMacrosCore.modulemap not found`.
+    .target(
+      name: "ExpoModulesMacrosPlugin",
+      dependencies: ["ExpoModulesMacros"],
+      path: "apple/Sources/ExpoModulesMacrosPlugin"
+    ),
     // The shipped binary, `apple/ExpoModulesMacros` and the Windows and Linux binaries. It is both the
     // compiler plugin and the scanner CLI: the compiler launches it without arguments and speaks the
     // plugin protocol over stdin, while an invocation with arguments dispatches into `ScannerCLI`

package/README.md

@@ -180,7 +180,7 @@ to `OTHER_SWIFT_FLAGS` for `ExpoModulesCore`, every pod that depends on it, and
 
 ## Swift packages
 
-The package manifest is `Package.swift` at the root of this package, so a Swift package can depend on it by its path in `node_modules` or by the URL of this repository. Its identity is then `expo-modules-macros`. The `ExpoModulesMacrosPlugin` library product holds the `ExpoModulesMacros` macro target:
+The package manifest is `Package.swift` at the root of this package, so a Swift package can depend on it by its path in `node_modules` or by the URL of this repository. Its identity is then `expo-modules-macros`. The `ExpoModulesMacrosPlugin` library product gives the `ExpoModulesMacros` macro target to the targets that depend on it:
 
 ```swift
 dependencies: [

package/apple/Sources/ExpoModulesCLI/Commands/ScanExports/ExportedSurface.swift

@@ -1,7 +1,8 @@
-/// The deep-scan surface: the full JS-exported shape of every `@ExpoModule`, `@SharedObject`, and
-/// `@Record` type, with the per-member detail a TypeScript type generator needs. Read syntactically
-/// (like the macros): each boundary type becomes a structured `TypeNode` tree so the consumer walks a
-/// tagged tree rather than re-parsing Swift type syntax.
+/// The deep-scan surface: the full JS-exported shape of every `@ExpoModule`, `@SharedObject`,
+/// `@Record`, `@Union`, and `@ExpoView` type and every `Enumerable` enum, with the per-member detail a
+/// TypeScript type generator needs. Read syntactically (like the macros): each boundary type becomes a
+/// structured `TypeNode` tree so the consumer walks a tagged tree rather than re-parsing Swift type
+/// syntax.
 ///
 /// Every declaration and member carries the `platforms` that build it, and the ones that can be
 /// written with an access modifier carry the `accessLevel` they spell. A declaration no platform
@@ -460,6 +461,122 @@ struct ExportedUnion: Encodable, Equatable {
   let file: String
 }
 
+/// An `@ExpoView` class with the props and events of the `@ViewProps` struct in its generic argument.
+/// It is reported on its own rather than under a module, because core reaches it through its
+/// `AnyNativeView` conformance.
+struct ExportedView: Encodable, Equatable {
+  /// The Swift class name. Only a view declared at file scope is reported, as in `scan-modules`.
+  let name: String
+
+  /// The name the view registers under. `@ExpoView` takes no name, so it is always the class name.
+  let jsName: String
+
+  /// The props type: the generic argument of `@ExpoView<CardProps>`, as written without backticks, or
+  /// the qualified name of the scanned `@ViewProps` struct it names (`CardView.Props`). A class without
+  /// the generic argument is not reported, because the macro rejects it.
+  var propsType: String
+
+  /// The name `propsType` is looked up under: its spelling without generic arguments, or `nil` when it
+  /// isn't a plain or qualified type name. Not encoded.
+  var propsTypeLookupName: String? = nil
+
+  /// The value props of the `@ViewProps` struct, or `nil` when the scan declares no struct named
+  /// `propsType` on a platform of the view. A struct shared by several views is copied into each of
+  /// them, and a struct declared in several `#if` branches contributes the props of each declaration
+  /// whose platforms overlap the view's.
+  var props: [ExportedViewProp]? = nil
+
+  /// The events of the `@ViewProps` struct, or `nil` when `props` is `nil`.
+  var events: [ExportedViewEvent]? = nil
+
+  /// The spelled access modifier, or `nil` when none is written.
+  let accessLevel: String?
+
+  let platforms: [ExportedPlatform]
+
+  let file: String
+
+  private enum CodingKeys: String, CodingKey {
+    case name, jsName, propsType, props, events, accessLevel, platforms, file
+  }
+}
+
+/// One value prop of a `@ViewProps` struct: a stored property that isn't function-typed. Like
+/// `ExportedRecordProperty`, but with no `required`: core resets a prop that React leaves out to its
+/// default, so JS can always omit one.
+struct ExportedViewProp: Encodable, Equatable {
+  let name: String
+
+  /// The annotated type, or the type of a literal initial value. A property with neither is not
+  /// reported, because the macro rejects it.
+  var type: TypeNode
+
+  /// The initial value as source text, or `nil` when none is written.
+  let defaultValue: String?
+
+  /// The spelled access modifier, or `nil` when none is written. Never `private` or `fileprivate`,
+  /// since those exclude a property from the props.
+  let accessLevel: String?
+
+  let platforms: [ExportedPlatform]
+
+  /// Optional-typed, read from `type`, so every spelling of an optional counts (`T?`, `T!`,
+  /// `Optional<T>`, `(T?)`). Encoded as `optional`.
+  var isOptional: Bool {
+    if case .optional = type {
+      return true
+    }
+    return false
+  }
+
+  private enum CodingKeys: String, CodingKey {
+    case name, type, defaultValue, accessLevel, platforms
+    case isOptional = "optional"
+  }
+
+  func encode(to encoder: Encoder) throws {
+    var container = encoder.container(keyedBy: CodingKeys.self)
+    try container.encode(name, forKey: .name)
+    try container.encode(type, forKey: .type)
+    try container.encode(isOptional, forKey: .isOptional)
+    try container.encodeIfPresent(defaultValue, forKey: .defaultValue)
+    try container.encodeIfPresent(accessLevel, forKey: .accessLevel)
+    try container.encode(platforms, forKey: .platforms)
+  }
+}
+
+/// One event of a `@ViewProps` struct: a function-typed stored property. Its name is the React prop
+/// name as written, with no `on` prefix stripped, so it carries no `jsName`.
+struct ExportedViewEvent: Encodable, Equatable {
+  /// The Swift property name, e.g. `onTap`.
+  let name: String
+
+  /// The type of the function's single parameter, or `nil` when it takes none (`() -> Void`) or more
+  /// than one.
+  var payload: TypeNode?
+
+  /// The spelled access modifier, or `nil` when none is written.
+  let accessLevel: String?
+
+  let platforms: [ExportedPlatform]
+}
+
+/// A `@ViewProps` struct the scan found. Not encoded: `ExportedSurface.joiningViewProps(_:)` copies its
+/// props and events into each view that names it, and a struct that no view names is not reported.
+struct ViewPropsDeclaration: Equatable {
+  /// The Swift struct name, qualified with the types it is nested in (`CardView.Props`).
+  let name: String
+
+  /// The value props, in declaration order.
+  let props: [ExportedViewProp]
+
+  /// The events, in declaration order.
+  let events: [ExportedViewEvent]
+
+  /// The platforms that build the struct, to match it with the views that build on them.
+  let platforms: [ExportedPlatform]
+}
+
 /// 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 {
@@ -468,6 +585,7 @@ struct ExportedSurface: Encodable, Equatable {
   let records: [ExportedRecord]
   let enums: [ExportedEnum]
   let unions: [ExportedUnion]
+  let views: [ExportedView]
 }
 
 /// How an `@Event` is dispatched to JavaScript, from its option. Mirrors `EventDispatch` in the macros.
@@ -488,7 +606,8 @@ enum ExportedEventDispatch: String, Encodable, Equatable {
 /// `defaultValue`, and replaces `constructorParameters` with `initializer`; version 9 adds the
 /// `sharedRef` type kind and the `sharedRef` of a shared object; version 10 adds the `tuple` and `object` type kinds (named after a tuple alias)
 /// and resolves the tuple type aliases declared in `@ExpoModule` and `@SharedObject` classes; version 11
-/// replaces the `sync` flag of an event with `dispatch`.
+/// replaces the `sync` flag of an event with `dispatch`. A new field that older consumers can ignore,
+/// such as `views`, doesn't change the version.
 let scanExportsSchemaVersion = 11
 
 /// The `scan-exports` result: the surface plus the run's stats. A distinct envelope from

package/apple/Sources/ExpoModulesCLI/Commands/ScanExports/InheritedMembers.swift

@@ -83,7 +83,8 @@ extension ExportedSurface {
       sharedObjects: sharedObjects.map { merged($0, chain: []) },
       records: records,
       enums: enums,
-      unions: unions
+      unions: unions,
+      views: views
     )
   }
 }

package/apple/Sources/ExpoModulesCLI/Commands/ScanExports/ResolveRefs.swift

@@ -74,26 +74,32 @@ struct RefIndex {
   /// dropped one at a time (`Media.Status` -> `Status`): a use site may qualify a name with a module
   /// the scan doesn't see, which is how the conformance and raw-type checks already match names.
   func lookup(_ name: String, in scope: String) -> Entry? {
-    let name = name.hasPrefix("Self.") ? String(name.dropFirst("Self.".count)) : name
-    var components = scope.split(separator: ".").map(String.init)
-    while true {
-      if let entry = entries[(components + [name]).joined(separator: ".")] {
-        return entry
-      }
-      if components.isEmpty {
-        break
-      }
-      components.removeLast()
+    return scopedLookup(name, in: scope, entries: entries)
+  }
+}
+
+/// The entry that a use of `name` written inside the type `scope` names, from `entries` keyed by
+/// qualified name. Swift's lookup rules, as `RefIndex.lookup(_:in:)` documents them.
+private func scopedLookup<Entry>(_ name: String, in scope: String, entries: [String: Entry]) -> Entry? {
+  let name = name.hasPrefix("Self.") ? String(name.dropFirst("Self.".count)) : name
+  var components = scope.split(separator: ".").map(String.init)
+  while true {
+    if let entry = entries[(components + [name]).joined(separator: ".")] {
+      return entry
     }
-    var suffix = name.split(separator: ".").map(String.init).dropFirst()
-    while !suffix.isEmpty {
-      if let entry = entries[suffix.joined(separator: ".")] {
-        return entry
-      }
-      suffix = suffix.dropFirst()
+    if components.isEmpty {
+      break
+    }
+    components.removeLast()
+  }
+  var suffix = name.split(separator: ".").map(String.init).dropFirst()
+  while !suffix.isEmpty {
+    if let entry = entries[suffix.joined(separator: ".")] {
+      return entry
     }
-    return nil
+    suffix = suffix.dropFirst()
   }
+  return nil
 }
 
 /// The JS category a raw-value enum crosses as: its raw value's. A bare `Enumerable` conformance with
@@ -214,6 +220,59 @@ extension ExportedSurface {
           return resolvedMember
         }
         return resolved
+      },
+      // The props and events are written in the `@ViewProps` struct, so their refs are looked up from
+      // it. `joiningViewProps(_:)` runs first and sets `propsType` to the struct's qualified name.
+      views: views.map { view in
+        var resolved = view
+        resolved.props = view.props?.map { prop in
+          var resolvedProp = prop
+          resolvedProp.type = prop.type.resolvingRefs(using: index, in: view.propsType)
+          return resolvedProp
+        }
+        resolved.events = view.events?.map { event in
+          var resolvedEvent = event
+          resolvedEvent.payload = event.payload?.resolvingRefs(using: index, in: view.propsType)
+          return resolvedEvent
+        }
+        return resolved
+      }
+    )
+  }
+
+  /// This surface with the props and events of each view's `@ViewProps` struct copied into the view.
+  /// The struct is looked up from the view like a ref, by its name without generic arguments, so it
+  /// may be declared in another file or nested (`CardView.Props`). A found struct gives the view its
+  /// qualified name as `propsType`. A view whose struct the scan doesn't declare keeps `props` and
+  /// `events` at `nil`, and `propsType` as written.
+  ///
+  /// A struct declared more than once, in `#if` branches, contributes the props and events of each
+  /// declaration whose platforms overlap the platforms of the view, as a superclass does in
+  /// `mergingInheritedMembers()`. Each prop and event keeps its own `platforms`. A view that builds on
+  /// none of those platforms is treated as one whose struct the scan doesn't declare.
+  func joiningViewProps(_ declarations: [ViewPropsDeclaration]) -> ExportedSurface {
+    let entries = Dictionary(grouping: declarations, by: \.name)
+    return ExportedSurface(
+      modules: modules,
+      sharedObjects: sharedObjects,
+      records: records,
+      enums: enums,
+      unions: unions,
+      views: views.map { view in
+        let platforms = Set(view.platforms.map(\.name))
+        guard let name = view.propsTypeLookupName,
+          let variants = scopedLookup(name, in: view.name, entries: entries)?.filter({ declaration in
+            declaration.platforms.contains { platforms.contains($0.name) }
+          }),
+          let first = variants.first
+        else {
+          return view
+        }
+        var joined = view
+        joined.propsType = first.name
+        joined.props = variants.flatMap(\.props)
+        joined.events = variants.flatMap(\.events)
+        return joined
       }
     )
   }

package/apple/Sources/ExpoModulesCLI/Commands/ScanExports/ScanExports.swift

@@ -26,11 +26,11 @@ extension Scanner {
   }
 }
 
-/// 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.
+/// Scans `paths` for `@ExpoModule`, `@SharedObject`, `@Record`, `@Union`, `@ExpoView`, and
+/// `@ViewProps` 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
+/// The pre-filter omits `@Event`: an event only declares a member of a module or shared object, 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.
@@ -40,10 +40,12 @@ func scanExports(paths: [String]) -> ScanExportsResult {
   var records: [ExportedRecord] = []
   var enums: [ExportedEnum] = []
   var unions: [ExportedUnion] = []
+  var views: [ExportedView] = []
+  var viewProps: [ViewPropsDeclaration] = []
 
   let stats = scanFiles(
     paths: paths,
-    macros: [.expoModule, .sharedObject, .record, .union],
+    macros: [.expoModule, .sharedObject, .record, .union, .expoView, .viewProps],
     conformances: [enumerableConformanceName]
   ) { source, file in
     let tree = Parser.parse(source: source)
@@ -54,18 +56,23 @@ func scanExports(paths: [String]) -> ScanExportsResult {
     records.append(contentsOf: visitor.records)
     enums.append(contentsOf: visitor.enums)
     unions.append(contentsOf: visitor.unions)
+    views.append(contentsOf: visitor.views)
+    viewProps.append(contentsOf: visitor.viewProps)
   }
 
   // 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. The
-  // same holds for a superclass, so the inherited members are merged after that.
+  // same holds for a view's `@ViewProps` struct, which is joined before the refs resolve so that the
+  // refs in its props resolve from the struct, and for a superclass, so the inherited members are
+  // merged last.
   let surface = ExportedSurface(
     modules: modules,
     sharedObjects: sharedObjects,
     records: records,
     enums: enums,
-    unions: unions
-  ).resolvingRefs().mergingInheritedMembers()
+    unions: unions,
+    views: views
+  ).joiningViewProps(viewProps).resolvingRefs().mergingInheritedMembers()
 
   return ScanExportsResult(
     schemaVersion: scanExportsSchemaVersion,

package/apple/Sources/ExpoModulesCLI/Commands/ScanExports/SurfaceVisitor.swift

@@ -1,10 +1,10 @@
 import SwiftSyntax
 
-/// Extracts the full JS-exported surface of every `@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`.
+/// Extracts the full JS-exported surface of every `@ExpoModule`, `@SharedObject`, `@Record`,
+/// `@ExpoView`, and `@ViewProps` type: their `@JS` members, record properties, view props, and view
+/// events. 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` / `validatedViewProps`.
 ///
 /// Types nested in another type's body, or in a file-scope `extension`, are reported under their
 /// qualified Swift name (`Options.Encoding`), so a ref to one can be resolved from the scope it is
@@ -12,10 +12,10 @@ import SwiftSyntax
 ///
 /// Each declaration and member reports the platforms that build it (see `PlatformResolver`), and one
 /// that no platform builds is not reported. `#if` is read only where the runtime sees what it holds:
-/// around types, `@Event` members, and enum cases. `@ExpoModule`, `@SharedObject`, `@Record`, and
-/// `@Union` read only the members written directly in the type body, so `@JS` members, record
-/// properties, and union cases in a `#if` clause are never bound and are not reported. An `@Event`
-/// expands on its own declaration, and the compiler reads enum cases itself.
+/// around types, `@Event` members, and enum cases. `@ExpoModule`, `@SharedObject`, `@Record`,
+/// `@Union`, and `@ViewProps` read only the members written directly in the type body, so `@JS`
+/// members, record properties, union cases, and view props in a `#if` clause are never bound and are
+/// not reported. An `@Event` expands on its own declaration, and the compiler reads enum cases itself.
 final class SurfaceVisitor: SyntaxVisitor {
   private let file: String
   private let platformResolver: PlatformResolver
@@ -24,6 +24,10 @@ final class SurfaceVisitor: SyntaxVisitor {
   private(set) var records: [ExportedRecord] = []
   private(set) var enums: [ExportedEnum] = []
   private(set) var unions: [ExportedUnion] = []
+  private(set) var views: [ExportedView] = []
+  /// The `@ViewProps` structs, which `ExportedSurface.joiningViewProps(_:)` copies into the views once
+  /// every file has been walked.
+  private(set) var viewProps: [ViewPropsDeclaration] = []
 
   init(file: String, tree: SourceFileSyntax) {
     self.file = file
@@ -120,8 +124,8 @@ final class SurfaceVisitor: SyntaxVisitor {
   }
 
   /// Routes a class or struct 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.
+  /// carrying none of them is ignored. The macros are mutually exclusive in practice, so the first
+  /// match wins.
   ///
   /// `name` is the declared name and `scope` the names of the types enclosing it. The reported `name`
   /// is qualified with the scope, while a default `jsName` is the declared name alone, as the macros
@@ -201,6 +205,38 @@ final class SurfaceVisitor: SyntaxVisitor {
           file: file
         )
       )
+      return
+    }
+
+    // `@ExpoView` applies only to a class, and needs the props type as its generic argument.
+    if node.is(ClassDeclSyntax.self),
+      let attribute = attributes.firstAttribute(named: DetectedMacro.expoView.rawValue),
+      let propsType = genericArgumentType(of: attribute)
+    {
+      // Only a file-scope view is reported, as `scan-modules` reports only those.
+      guard scope.isEmpty else {
+        return
+      }
+      // `props` and `events` are filled in by `ExportedSurface.joiningViewProps(_:)`, since the
+      // `@ViewProps` struct can be declared in another file.
+      views.append(
+        ExportedView(
+          name: qualified,
+          jsName: name,
+          propsType: String(propsType.trimmedDescription.filter { $0 != "`" }),
+          propsTypeLookupName: spellingWithoutGenericArguments(of: propsType),
+          accessLevel: accessLevel,
+          platforms: platforms,
+          file: file
+        )
+      )
+      return
+    }
+
+    // `@ViewProps` applies only to a struct.
+    if node.is(StructDeclSyntax.self), attributes.firstAttribute(named: DetectedMacro.viewProps.rawValue) != nil {
+      let (props, events) = collectViewProps(members)
+      viewProps.append(ViewPropsDeclaration(name: qualified, props: props, events: events, platforms: platforms))
     }
   }
 
@@ -425,7 +461,7 @@ final class SurfaceVisitor: SyntaxVisitor {
     // `@Record` reads only the properties written directly in the body, so `#if` is not looked into.
     for member in members {
       guard let varDecl = member.decl.as(VariableDeclSyntax.self),
-        !isExcludedRecordModifier(varDecl.modifiers)
+        !isExcludedByModifier(varDecl.modifiers)
       else {
         continue
       }
@@ -459,6 +495,76 @@ final class SurfaceVisitor: SyntaxVisitor {
     return properties
   }
 
+  /// The value props and events of a `@ViewProps` struct, mirroring `validatedViewProps` in the macro:
+  /// every binding of a `var` or `let` that no modifier excludes, except a computed one. A property
+  /// with `willSet`/`didSet` or a `set` counts, as in the macro. A function-typed property is an event,
+  /// and every other one a value prop.
+  ///
+  /// The scan stays lenient where the macro reports an error, and leaves out only what can't be
+  /// described: a property whose type can't be determined, an optional function type, and an event
+  /// that doesn't return `Void`. A value prop the macro rejects for another reason, such as a `let` or
+  /// a missing default, is still reported.
+  private func collectViewProps(
+    _ members: MemberBlockItemListSyntax
+  ) -> (props: [ExportedViewProp], events: [ExportedViewEvent]) {
+    var props: [ExportedViewProp] = []
+    var events: [ExportedViewEvent] = []
+
+    // `@ViewProps` reads only the properties written directly in the body, so `#if` is not looked into.
+    for member in members {
+      guard let varDecl = member.decl.as(VariableDeclSyntax.self),
+        !isExcludedByModifier(varDecl.modifiers)
+      else {
+        continue
+      }
+      let platforms = platformResolver.platforms(of: varDecl)
+      guard !platforms.isEmpty else {
+        continue
+      }
+      for binding in varDecl.bindings {
+        if binding.accessorBlock != nil && !isSettable(binding: binding, isLet: false) {
+          continue
+        }
+        guard let ident = binding.pattern.as(IdentifierPatternSyntax.self) else {
+          continue
+        }
+        let name = ident.identifier.identifierName
+        let annotation = binding.typeAnnotation?.type
+
+        if let annotation, let functionType = viewEventFunctionType(of: annotation) {
+          // An optional function type and a non-`Void` result are errors in the macro.
+          guard !isOptionalEventType(annotation), isVoidEventReturn(functionType.returnClause.type) else {
+            continue
+          }
+          let parameters = functionType.parameters
+          events.append(
+            ExportedViewEvent(
+              name: name,
+              payload: parameters.count == 1 ? parameters.first.map { typeNode(from: $0.type) } : nil,
+              accessLevel: spelledAccessLevel(of: varDecl.modifiers),
+              platforms: platforms
+            )
+          )
+          continue
+        }
+
+        guard let type = valueTypeNode(annotation: annotation, initializer: binding.initializer?.value) else {
+          continue
+        }
+        props.append(
+          ExportedViewProp(
+            name: name,
+            type: type,
+            defaultValue: binding.initializer?.value.trimmedDescription,
+            accessLevel: spelledAccessLevel(of: varDecl.modifiers),
+            platforms: platforms
+          )
+        )
+      }
+    }
+    return (props, events)
+  }
+
   /// 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.
@@ -706,6 +812,44 @@ private func isVoidEventReturn(_ type: TypeSyntax) -> Bool {
   return text == "Void" || text == "()" || text == "Swift.Void"
 }
 
+/// The function type a `@ViewProps` property declares, or `nil` when the type isn't a function.
+/// Unwraps parentheses, attributes (`@Sendable`), and the optional spellings `T?`, `T!`, and
+/// `Optional<T>`, like `underlyingFunctionType` in `ViewPropsMacro`.
+private func viewEventFunctionType(of type: TypeSyntax) -> FunctionTypeSyntax? {
+  if let functionType = type.as(FunctionTypeSyntax.self) {
+    return functionType
+  }
+  if let tuple = type.as(TupleTypeSyntax.self), tuple.elements.count == 1, let only = tuple.elements.first {
+    return viewEventFunctionType(of: only.type)
+  }
+  if let attributed = type.as(AttributedTypeSyntax.self) {
+    return viewEventFunctionType(of: attributed.baseType)
+  }
+  if let optional = type.as(OptionalTypeSyntax.self) {
+    return viewEventFunctionType(of: optional.wrappedType)
+  }
+  if let implicitlyUnwrapped = type.as(ImplicitlyUnwrappedOptionalTypeSyntax.self) {
+    return viewEventFunctionType(of: implicitlyUnwrapped.wrappedType)
+  }
+  if let identifier = type.as(IdentifierTypeSyntax.self),
+    identifier.name.text == "Optional",
+    let argument = identifier.genericArgumentClause?.arguments.first,
+    case .type(let wrapped) = argument.argument
+  {
+    return viewEventFunctionType(of: wrapped)
+  }
+  return nil
+}
+
+/// True when a `@ViewProps` event is written as an optional (`(() -> Void)?`, also after attributes),
+/// which the macro rejects. Like the macros' `isOptionalType`, it reads only the outermost type.
+private func isOptionalEventType(_ type: TypeSyntax) -> Bool {
+  if let attributed = type.as(AttributedTypeSyntax.self) {
+    return isOptionalEventType(attributed.baseType)
+  }
+  return isOptionalType(type)
+}
+
 /// True if an `@Event` attribute lists the given option member (`@Event(.inline)` or
 /// `@Event("name", EventOptions.inline)`). Like `hasOption` in the macros, but without the array-literal
 /// branch, which `EventOptions...` doesn't accept.
@@ -836,9 +980,10 @@ private func isTypeLevel(_ modifiers: DeclModifierListSyntax) -> Bool {
   }
 }
 
-/// 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 {
+/// True when a modifier excludes a property from being a `@Record` field or a `@ViewProps` prop
+/// (`static`, `class`, `private`, `fileprivate`, `lazy`), mirroring `isExcludedByModifier` in the
+/// macros.
+private func isExcludedByModifier(_ modifiers: DeclModifierListSyntax) -> Bool {
   modifiers.contains { modifier in
     switch modifier.name.tokenKind {
     case .keyword(.static), .keyword(.class), .keyword(.private), .keyword(.fileprivate), .keyword(.lazy):
@@ -951,9 +1096,17 @@ func rawValueType(of clause: InheritanceClauseSyntax?) -> TypeNode? {
   return typeNode(from: first)
 }
 
-/// True when a type is written as an optional: `T?`, `T!`, or `Optional<T>`, mirroring the macros'
-/// `isOptionalType`.
+/// True when a type is written as an optional: `T?`, `T!`, or `Optional<T>`, also in parentheses
+/// (`(T?)`) or behind attributes, mirroring the macros' `isOptionalType`.
 private func isOptionalType(_ type: TypeSyntax) -> Bool {
+  if let tuple = type.as(TupleTypeSyntax.self), tuple.elements.count == 1, let only = tuple.elements.first,
+    only.firstName == nil
+  {
+    return isOptionalType(only.type)
+  }
+  if let attributed = type.as(AttributedTypeSyntax.self) {
+    return isOptionalType(attributed.baseType)
+  }
   if type.is(OptionalTypeSyntax.self) || type.is(ImplicitlyUnwrappedOptionalTypeSyntax.self) {
     return true
   }
@@ -963,13 +1116,14 @@ private func isOptionalType(_ type: TypeSyntax) -> Bool {
   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).
+/// The first attribute whose name matches `name` as `attributeName(of:)` reads it, so
+/// `@ExpoView<CardProps>` and `@ExpoModulesCore.ExpoView<CardProps>` match `ExpoView`. 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
+        attributeName(of: attribute) == name
       {
         return attribute
       }

package/apple/Sources/ExpoModulesCLI/Commands/ScanModules/ScanModules.swift

@@ -34,8 +34,8 @@ public enum Scanner {
   }
 }
 
-/// One class in the `scan-modules` output: an `@ExpoModule` class in `modules`, or a `@SharedObject`
-/// class in `sharedObjects`. Trimmed to what `expo-modules-autolinking` needs to register the class:
+/// One class in the `scan-modules` output: an `@ExpoModule` class in `modules`, a `@SharedObject`
+/// class in `sharedObjects`, or an `@ExpoView` class in `views`. Trimmed to what `expo-modules-autolinking` needs to register the class:
 /// 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, because this command doesn't need them (the macro is always on a
@@ -45,7 +45,7 @@ struct ScannedClass: Codable, Equatable {
   let name: String
 
   /// The fully-resolved JS name: the `@ExpoModule("Foo")` or `@SharedObject("Foo")` override when
-  /// present, otherwise the class name. Resolved here (rather than left `nil`) so it matches how the
+  /// present, otherwise the class name. `@ExpoView` takes no name, so a view's JS name is its 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
 
@@ -70,7 +70,7 @@ struct ScannedClass: Codable, Equatable {
 /// `ScannedClass`, 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. A new field that older
-/// consumers can ignore, such as `sharedObjects`, doesn't change the version.
+/// consumers can ignore, such as `sharedObjects` or `views`, doesn't change the version.
 let scanModulesSchemaVersion = 2
 
 /// The `scan-modules` result: the detected modules plus the stats describing the run. Encoded as the
@@ -84,6 +84,10 @@ struct ScanModulesResult: Codable, Equatable {
   /// `modules`.
   let sharedObjects: [ScannedClass]
 
+  /// The top-level `@ExpoView` classes, in the same order and with the same platform rules as
+  /// `modules`.
+  let views: [ScannedClass]
+
   /// 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]
@@ -102,7 +106,7 @@ private let platformUniverse: [(condition: String, reported: String)] = [
   (condition: "visionOS", reported: "visionOS"),
 ]
 
-/// Scans the given paths for top-level `@ExpoModule` and `@SharedObject` types and returns every one
+/// Scans the given paths for top-level `@ExpoModule`, `@SharedObject` and `@ExpoView` types and returns every one
 /// 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
@@ -115,10 +119,11 @@ private let platformUniverse: [(condition: String, reported: String)] = [
 func scanModules(paths: [String], defines: Set<String> = []) -> ScanModulesResult {
   var modules: [ScannedClass] = []
   var sharedObjects: [ScannedClass] = []
+  var views: [ScannedClass] = []
   var warnings: [ScanWarning] = []
   var seenWarnings = Set<ScanWarning>()
 
-  let macros: Set<DetectedMacro> = [.expoModule, .sharedObject]
+  let macros: Set<DetectedMacro> = [.expoModule, .sharedObject, .expoView]
   let stats = scanFiles(paths: paths, macros: macros) { source, file in
     let tree = Parser.parse(source: source)
 
@@ -162,6 +167,8 @@ func scanModules(paths: [String], defines: Set<String> = []) -> ScanModulesResul
       switch detection.macro {
       case .sharedObject:
         sharedObjects.append(scanned)
+      case .expoView:
+        views.append(scanned)
       default:
         modules.append(scanned)
       }
@@ -172,6 +179,7 @@ func scanModules(paths: [String], defines: Set<String> = []) -> ScanModulesResul
     schemaVersion: scanModulesSchemaVersion,
     modules: modules,
     sharedObjects: sharedObjects,
+    views: views,
     warnings: warnings,
     stats: stats
   )

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

@@ -7,6 +7,8 @@ enum DetectedMacro: String, Codable, CaseIterable {
   case sharedObject = "SharedObject"
   case record = "Record"
   case union = "Union"
+  case expoView = "ExpoView"
+  case viewProps = "ViewProps"
 }
 
 /// A single argument passed to a macro, e.g. `"Foo"` or `classes: [Bar.self]`. The label is `nil`
@@ -43,6 +45,10 @@ struct Detection: Codable, Equatable {
   /// `@SharedObject("Baz")`, otherwise `nil` (the name defaults to `name` at expansion time).
   let jsName: String?
 
+  /// The generic argument of the attribute as written, which is the props type of `@ExpoView<CardProps>`,
+  /// otherwise `nil`.
+  var genericArgument: String? = nil
+
   /// Every argument passed to the macro, in source order, e.g. `@ExpoModule("Foo", classes: [Bar.self])`
   /// yields a positional `"Foo"` and a `classes:` argument. Empty when the macro is written bare.
   let arguments: [MacroArgument]

package/apple/Sources/ExpoModulesCLI/Core/DetectionVisitor.swift

@@ -3,7 +3,7 @@ import SwiftIfConfig
 import SwiftSyntax
 
 /// Walks a parsed source file and records top-level declarations carrying `@ExpoModule`, `@JS`,
-/// `@SharedObject`, or `@Record`. Only file-scope declarations are considered: these macros apply to
+/// `@SharedObject`, `@Record`, `@Union`, `@ExpoView`, or `@ViewProps`. Only file-scope declarations are considered: these macros apply to
 /// top-level types, so descending into type and function bodies would only surface false positives.
 /// Recognition mirrors the macros themselves — a purely syntactic match on the spelled attribute
 /// name — so it sees the same declarations the compiler would hand the plugin, without compiling
@@ -119,7 +119,7 @@ final class DetectionVisitor: SyntaxVisitor {
   ) {
     for element in attributes {
       guard let attribute = element.as(AttributeSyntax.self),
-        let macro = DetectedMacro(rawValue: attribute.attributeName.trimmedDescription),
+        let macro = DetectedMacro(rawValue: attributeName(of: attribute)),
         detectedMacros.contains(macro)
       else {
         continue
@@ -132,6 +132,7 @@ final class DetectionVisitor: SyntaxVisitor {
           declarationKind: kind,
           accessLevel: accessLevel(of: modifiers),
           jsName: stringArgument(of: attribute),
+          genericArgument: genericArgument(of: attribute),
           arguments: arguments(of: attribute),
           file: file,
           line: location.line,
@@ -155,6 +156,44 @@ private func accessLevel(of modifiers: DeclModifierListSyntax) -> String {
   return "internal"
 }
 
+/// The attribute's name without a generic argument clause, so `@ExpoView<CardProps>` is `ExpoView`. A
+/// name qualified with the module that declares the macros is read without the module, so
+/// `@ExpoModulesCore.ExpoView<CardProps>` is `ExpoView` too.
+func attributeName(of attribute: AttributeSyntax) -> String {
+  if let identifier = attribute.attributeName.as(IdentifierTypeSyntax.self) {
+    return identifier.name.text
+  }
+  if let member = attribute.attributeName.as(MemberTypeSyntax.self),
+    member.baseType.as(IdentifierTypeSyntax.self)?.name.text == macrosModuleName
+  {
+    return member.name.text
+  }
+  return attribute.attributeName.trimmedDescription
+}
+
+/// The module that declares the macros, which an attribute may be qualified with:
+/// `@ExpoModulesCore.ExpoView<CardProps>`.
+let macrosModuleName = "ExpoModulesCore"
+
+/// The first generic argument of the attribute as written, e.g. `@ExpoView<CardProps>` -> "CardProps".
+/// Returns `nil` when the attribute has no generic argument clause.
+private func genericArgument(of attribute: AttributeSyntax) -> String? {
+  return genericArgumentType(of: attribute)?.trimmedDescription
+}
+
+/// The first generic argument of the attribute, `CardProps` in `@ExpoView<CardProps>` and in
+/// `@ExpoModulesCore.ExpoView<CardProps>`, or `nil` when the attribute has no generic argument clause.
+/// Like `genericArgument(of:)` in `ExpoViewMacro`.
+func genericArgumentType(of attribute: AttributeSyntax) -> TypeSyntax? {
+  let clause =
+    attribute.attributeName.as(IdentifierTypeSyntax.self)?.genericArgumentClause
+    ?? attribute.attributeName.as(MemberTypeSyntax.self)?.genericArgumentClause
+  guard let first = clause?.arguments.first, case .type(let type) = first.argument else {
+    return nil
+  }
+  return type
+}
+
 /// Every argument passed to the attribute, in source order, each as a label (or `nil` when
 /// positional) plus the value expression's source text. Returns an empty array when the attribute
 /// is written bare (`@ExpoModule`) or with empty parens.

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

@@ -106,9 +106,10 @@ struct MacroPrefilter {
   }
 
   /// A pre-filter for attributes that `DetectedMacro` doesn't list, such as every macro that `expand`
-  /// runs.
+  /// runs. Each name also matches qualified with the module that declares the macros
+  /// (`@ExpoModulesCore.ExpoView`), since the scanners read that spelling as the bare one.
   init(attributeNames: Set<String>, conformances: Set<String> = []) {
-    attributes = attributeNames.map { Array($0.utf8) }
+    attributes = attributeNames.flatMap { [Array($0.utf8), Array("\(macrosModuleName).\($0)".utf8)] }
     bareNames = conformances.map { Array($0.utf8) }
   }
 

package/apple/Sources/ExpoModulesMacrosCore/Macros/ExpoViewMacro.swift

@@ -3,11 +3,11 @@ import SwiftSyntax
 import SwiftSyntaxBuilder
 import SwiftSyntaxMacros
 
-/// Member macro applied to an `ExpoView` subclass, binding it to its props type:
+/// Member and extension macro applied to an `ExpoNativeView` subclass, binding it to its props type:
 ///
 ///   @ExpoView<CardProps>
-///   final class CardView: ExpoView {
-///     override func didUpdateProps(_ diff: CardProps.Diff) {
+///   final class CardView: ExpoNativeView {
+///     func didUpdateProps(_ diff: CardProps.Diff) {
 ///       if diff.changed(.color) {
 ///         backgroundColor = props.color
 ///       }
@@ -21,23 +21,25 @@ import SwiftSyntaxMacros
 /// compile error at the author's own line ("requires that 'X' conform to 'AnyViewProps'")
 /// rather than a macro diagnostic. This macro therefore validates nothing about the props type.
 ///
-/// The whole expansion is one line:
+/// The expansion is a typealias and a conformance:
 ///
 ///   public typealias Props = CardProps
+///   extension CardView: AnyNativeView {}
 ///
-/// That is deliberately all of it. There is **no view definition**: no `ViewDefinition`, no
-/// `View(…) { }` builder, no `Props(_:)` or `Events(_:)` element. `_synthesizedViewDefinition()`
-/// existed only to hand core a DSL value the old registration path could consume, and modules and
-/// shared objects already moved to direct hooks. Core reads the props type from this typealias and
-/// the event names from the props type's own `_eventNames` (synthesized by `@ViewProps`), both
-/// static, neither needing a builder to be evaluated.
+/// There is **no view definition**: no `ViewDefinition`, no `View(…) { }` builder, no `Props(_:)` or
+/// `Events(_:)` element. Core reaches the view through the `AnyNativeView` conformance: it reads the
+/// props type from the `Props` typealias, which satisfies the protocol's associated type, and the
+/// event names from the props type's own `_eventNames` (synthesized by `@ViewProps`). Both are
+/// static, so no builder has to be evaluated.
 ///
-/// Views also get no `_decorateView` hook in its place: `_decorateModule` and `_decorateSharedObject`
-/// exist to bind members into a JS object, and a view has no such object. Props reach a view through
-/// Fabric's mounting layer, not a JS call, so a view's runtime entry point is the props update hook.
+/// Views also get no `_decorateView` hook: `_decorateModule` and `_decorateSharedObject` exist to bind
+/// members into a JS object, and a view has no such object. Props reach a view through Fabric's
+/// mounting layer, not a JS call, so a view's runtime entry point is the props update hook.
 ///
-/// `didUpdateProps` is a core-called override, not synthesized here.
-public struct ExpoViewMacro: MemberMacro {
+/// `didUpdateProps` is an `AnyNativeView` requirement with a default in core, not synthesized here.
+/// It isn't an `override`: `ExpoNativeView` has no such method, because its parameter type depends on
+/// the props type.
+public struct ExpoViewMacro: MemberMacro, ExtensionMacro {
   public static func expansion(
     of node: AttributeSyntax,
     providingMembersOf declaration: some DeclGroupSyntax,
@@ -87,38 +89,66 @@ public struct ExpoViewMacro: MemberMacro {
       """
     ]
   }
+
+  public static func expansion(
+    of node: AttributeSyntax,
+    attachedTo declaration: some DeclGroupSyntax,
+    providingExtensionsOf type: some TypeSyntaxProtocol,
+    conformingTo protocols: [TypeSyntax],
+    in context: some MacroExpansionContext
+  ) throws -> [ExtensionDeclSyntax] {
+    // A class that the member macro rejects gets no conformance either: the member macro has already
+    // reported the error, and a conformance without the `Props` typealias would only add a second
+    // error about the associated type.
+    guard let classDecl = declaration.as(ClassDeclSyntax.self),
+      inheritsFromAny(classDecl, names: expoViewBaseClassNames),
+      classDecl.genericParameterClause == nil,
+      existingPropsMemberKind(in: classDecl) == nil,
+      genericArgument(of: node) != nil,
+      !inheritsProtocol(named: nativeViewProtocolName, in: declaration)
+    else {
+      return []
+    }
+    let ext: DeclSyntax = """
+      extension \(type.trimmed): \(raw: nativeViewProtocolName) {}
+      """
+    guard let extDecl = ext.as(ExtensionDeclSyntax.self) else {
+      return []
+    }
+    return [extDecl]
+  }
 }
 
 // MARK: - Diagnostics
 
-/// The error for a class that doesn't name `ExpoView` in its inheritance clause, carrying a fix-it
+/// The error for a class that doesn't name `ExpoNativeView` in its inheritance clause, carrying a fix-it
 /// that adds it.
 ///
 /// The fix-it only applies where the edit is unambiguous. With no inheritance clause at all it
-/// inserts `: ExpoView`; with an existing clause it prepends `ExpoView` as the first entry, since
+/// inserts `: ExpoNativeView`; with an existing clause it prepends `ExpoNativeView` as the first entry, since
 /// Swift requires the superclass to come before any protocol. A class that already names some other
 /// superclass gets the diagnostic without a fix-it: replacing that superclass is a decision the macro
 /// can't make (see the indirect-inheritance note on `expoViewBaseClassNames`).
 private func missingBaseClassDiagnostic(for classDecl: ClassDeclSyntax) -> Diagnostic {
   let message = ExpoViewDiagnosticMessage(
-    "@ExpoView class must inherit from ExpoView. Add `: ExpoView` to the class declaration.",
+    "@ExpoView class must inherit from ExpoNativeView. Add `: ExpoNativeView` to the class declaration.",
     id: "expoview-missing-base-class"
   )
   var fixIts: [FixIt] = []
 
   if classDecl.inheritanceClause == nil {
-    // `class CardView {` → `class CardView: ExpoView {`. The name carries the space before `{` as
+    // `class CardView {` → `class CardView: ExpoNativeView {`. The name carries the space before `{` as
     // trailing trivia, so move it onto the clause to keep the spacing.
     let name = classDecl.name
     let clause = InheritanceClauseSyntax(
       colon: .colonToken(trailingTrivia: .space),
       inheritedTypes: InheritedTypeListSyntax([
-        InheritedTypeSyntax(type: TypeSyntax(IdentifierTypeSyntax(name: .identifier("ExpoView"))))
+        InheritedTypeSyntax(type: TypeSyntax(IdentifierTypeSyntax(name: .identifier("ExpoNativeView"))))
       ])
     )
     fixIts.append(
       FixIt(
-        message: ExpoViewFixItMessage("Inherit from 'ExpoView'", id: "expoview-add-base-class"),
+        message: ExpoViewFixItMessage("Inherit from 'ExpoNativeView'", id: "expoview-add-base-class"),
         changes: [
           .replace(
             oldNode: Syntax(classDecl),
@@ -132,16 +162,16 @@ private func missingBaseClassDiagnostic(for classDecl: ClassDeclSyntax) -> Diagn
       )
     )
   } else if let clause = classDecl.inheritanceClause, inheritsOnlyProtocolsByConvention(clause) {
-    // `class CardView: Identifiable {` → `class CardView: ExpoView, Identifiable {`.
+    // `class CardView: Identifiable {` → `class CardView: ExpoNativeView, Identifiable {`.
     var inherited = clause.inheritedTypes
     if var first = inherited.first {
       first.trailingComma = .commaToken(trailingTrivia: .space)
-      first.type = TypeSyntax(IdentifierTypeSyntax(name: .identifier("ExpoView")))
+      first.type = TypeSyntax(IdentifierTypeSyntax(name: .identifier("ExpoNativeView")))
       inherited.insert(first, at: inherited.startIndex)
     }
     fixIts.append(
       FixIt(
-        message: ExpoViewFixItMessage("Inherit from 'ExpoView'", id: "expoview-add-base-class"),
+        message: ExpoViewFixItMessage("Inherit from 'ExpoNativeView'", id: "expoview-add-base-class"),
         changes: [
           .replace(
             oldNode: Syntax(clause),
@@ -157,7 +187,7 @@ private func missingBaseClassDiagnostic(for classDecl: ClassDeclSyntax) -> Diagn
 
 /// Whether every entry in the clause looks like a protocol rather than a superclass, by the
 /// capitalization-free heuristic that a Swift superclass must come first: if the first entry is one
-/// the macro would be replacing, prepending `ExpoView` would produce two superclasses. A macro can't
+/// the macro would be replacing, prepending `ExpoNativeView` would produce two superclasses. A macro can't
 /// resolve names, so this only reports true when the clause is empty of anything that could be a
 /// base class the author chose deliberately. Conservative by design: a wrong guess here would emit a
 /// fix-it that doesn't compile.
@@ -223,14 +253,14 @@ private func existingPropsMemberKind(in classDecl: ClassDeclSyntax) -> String? {
 }
 
 /// Base classes an `@ExpoView` may inherit from. The check is syntactic, matching the name in the
-/// class's own inheritance clause: both `: ExpoView` and a qualified `: ExpoModulesCore.ExpoView`
+/// class's own inheritance clause: both `: ExpoNativeView` and a qualified `: ExpoModulesCore.ExpoNativeView`
 /// pass, since `baseIdentifier` reads the trailing name.
 ///
-/// Indirect inheritance does not: a view whose superclass is itself an `ExpoView` subclass
-/// (`class Base: ExpoView` then `class CardView: Base`) is rejected, because a macro can't resolve
+/// Indirect inheritance does not: a view whose superclass is itself an `ExpoNativeView` subclass
+/// (`class Base: ExpoNativeView` then `class CardView: Base`) is rejected, because a macro can't resolve
 /// the superclass to check. `@SharedObject` has the same limitation, through the same helper. The
-/// workaround is to apply `@ExpoView` to the class that names `ExpoView` directly.
-private let expoViewBaseClassNames: Set<String> = ["ExpoView"]
+/// workaround is to apply `@ExpoView` to the class that names `ExpoNativeView` directly.
+private let expoViewBaseClassNames: Set<String> = ["ExpoNativeView"]
 
 /// The attribute's single generic argument, verbatim (`@ExpoView<CardProps>` → `"CardProps"`), or
 /// `nil` when the attribute carries no generic argument clause.
@@ -257,3 +287,7 @@ private func genericArgument(of attribute: AttributeSyntax) -> String? {
   }
   return type.trimmedDescription
 }
+
+/// The core protocol that `@ExpoView` conforms the class to. Core registers the view and decodes its
+/// props through it.
+private let nativeViewProtocolName = "AnyNativeView"

package/apple/Sources/ExpoModulesMacrosCore/Macros/ViewPropsMacro.swift

@@ -861,17 +861,6 @@ private func isVoidType(_ type: TypeSyntax) -> Bool {
   return ["Void", "Swift.Void"].contains(type.trimmedDescription)
 }
 
-/// The type inside any number of unlabeled one-element parentheses: `(T)` and `((T))` are `T`. A
-/// label would make it a tuple, which Swift rejects with a single element anyway.
-private func withoutParentheses(_ type: TypeSyntax) -> TypeSyntax {
-  guard let tuple = type.as(TupleTypeSyntax.self), tuple.elements.count == 1, let only = tuple.elements.first,
-    only.firstName == nil
-  else {
-    return type
-  }
-  return withoutParentheses(only.type)
-}
-
 /// True if the binding is computed with a `mutating get`.
 private func hasMutatingGetter(_ binding: PatternBindingSyntax) -> Bool {
   guard case .accessors(let accessors) = binding.accessorBlock?.accessors else {

package/apple/Sources/ExpoModulesMacrosCore/ProvidedMacros.swift

@@ -25,7 +25,7 @@ public struct ProvidedMacro {
         conformances: ["JavaScriptDecodable", "JavaScriptEncodable"]
       ),
       ProvidedMacro(name: "ViewProps", type: ViewPropsMacro.self, conformances: ["AnyViewProps"]),
-      ProvidedMacro(name: "ExpoView", type: ExpoViewMacro.self),
+      ProvidedMacro(name: "ExpoView", type: ExpoViewMacro.self, conformances: ["AnyNativeView"]),
     ]
   }
 }

package/apple/Sources/ExpoModulesMacrosCore/Support/MacroHelpers.swift

@@ -111,9 +111,11 @@ internal func hasAsyncVariant(_ decl: DeclSyntaxProtocol) -> Bool {
   return asyncVariantOption(of: attribute) != nil
 }
 
-/// True if the type is written as an optional: `T?`, `T!`, or the explicit `Optional<T>`. Used to
-/// decide argument requiredness (an optional parameter may be omitted) and record-field nullability.
+/// True if the type is written as an optional: `T?`, `T!`, or the explicit `Optional<T>`, also in
+/// parentheses (`(T?)`), which Swift treats as the same type. Used to decide argument requiredness (an
+/// optional parameter may be omitted) and record-field nullability.
 internal func isOptionalType(_ type: TypeSyntax) -> Bool {
+  let type = withoutParentheses(type)
   if let attributed = type.as(AttributedTypeSyntax.self) {
     return isOptionalType(attributed.baseType)
   }
@@ -159,6 +161,17 @@ internal struct SpecifiedType {
 /// a fresh decoded value satisfies either way.
 internal let ownershipSpecifiers: Set<String> = ["borrowing", "consuming", "sending", "__shared", "__owned"]
 
+/// The type inside any number of unlabeled one-element parentheses: `(T)` and `((T))` are `T`. A
+/// label would make it a tuple, which Swift rejects with a single element anyway.
+internal func withoutParentheses(_ type: TypeSyntax) -> TypeSyntax {
+  guard let tuple = type.as(TupleTypeSyntax.self), tuple.elements.count == 1, let only = tuple.elements.first,
+    only.firstName == nil
+  else {
+    return type
+  }
+  return withoutParentheses(only.type)
+}
+
 /// The type wrapped by one optional layer (`T?`, `T!` or `Optional<T>`), or `nil` when the type isn't
 /// optional.
 internal func optionalWrappedType(_ type: TypeSyntax) -> TypeSyntax? {

package/apple/Sources/ExpoModulesMacrosPlugin/ExpoModulesMacrosPlugin.swift

@@ -0,0 +1 @@
+// Empty on purpose: this target only carries the dependency on the macro target (see Package.swift).

package/build/types.d.ts

@@ -368,6 +368,58 @@ export interface ExportedUnion extends ExportedAccess, ExportedAvailability {
     members: ExportedUnionMember[];
     file: string;
 }
+/**
+ * One value prop of a `@ViewProps` struct: a stored property that isn't function-typed. It has no
+ * `required`: native code resets a prop that React leaves out to its default, so JS can always omit
+ * one.
+ */
+export interface ExportedViewProp extends ExportedAccess, ExportedAvailability {
+    name: string;
+    type: TypeNode;
+    /** Optional-typed: true exactly when `type` is an `optional` node. */
+    optional: boolean;
+    /** The initial value as Swift source text, absent when none is written. */
+    defaultValue?: string;
+}
+/**
+ * One event of a `@ViewProps` struct: a function-typed stored property. Its name is the React prop
+ * name as written, with no `on` prefix stripped, so it has no `jsName`.
+ */
+export interface ExportedViewEvent extends ExportedAccess, ExportedAvailability {
+    /** The Swift property name, e.g. `onTap`. */
+    name: string;
+    /**
+     * The type of the function's single parameter, absent when it takes none (`() -> Void`) or more
+     * than one.
+     */
+    payload?: TypeNode;
+}
+/**
+ * An `@ExpoView` class with the props and events of the `@ViewProps` struct in its generic argument.
+ * It is reported on its own rather than under a module.
+ */
+export interface ExportedView extends ExportedAccess, ExportedAvailability {
+    /** The Swift class name. Only a view declared at file scope is reported. */
+    name: string;
+    /** The name the view registers under. `@ExpoView` takes no name, so it is always the class name. */
+    jsName: string;
+    /**
+     * The props type: the generic argument of `@ExpoView<CardProps>`, as written without backticks
+     * (`ExternalProps<Int>`), or the qualified name of the scanned `@ViewProps` struct it names
+     * (`CardView.Props`).
+     */
+    propsType: string;
+    /**
+     * The value props of the `@ViewProps` struct, in declaration order. Absent when the scan declares
+     * no struct named `propsType` on a platform of the view, so unknown props differ from no props. A
+     * struct declared in several `#if` branches contributes the props of each declaration whose
+     * platforms overlap the view's, and each prop keeps its own `platforms`.
+     */
+    props?: ExportedViewProp[];
+    /** The events of the `@ViewProps` struct, in declaration order. Absent when `props` is absent. */
+    events?: ExportedViewEvent[];
+    file: string;
+}
 /** The exported types grouped by kind. */
 export interface ExportedSurface {
     modules: ExportedModule[];
@@ -375,6 +427,7 @@ export interface ExportedSurface {
     records: ExportedRecord[];
     enums: ExportedEnum[];
     unions: ExportedUnion[];
+    views: ExportedView[];
 }
 /** A `#if` condition the scan couldn't answer statically. */
 export interface ScanWarning {
@@ -392,14 +445,14 @@ export interface ScanStats {
     durationMs: number;
 }
 /**
- * One class in the `scan-modules` output: an `@ExpoModule` class in `modules`, or a `@SharedObject`
- * class in `sharedObjects`.
+ * One class in the `scan-modules` output: an `@ExpoModule` class in `modules`, a `@SharedObject`
+ * class in `sharedObjects`, or an `@ExpoView` class in `views`.
  */
 export interface ScannedClass {
     name: string;
     /**
      * The resolved JS name: the `@ExpoModule("Foo")` or `@SharedObject("Foo")` override, else the class
-     * name.
+     * name. A view's JS name is its class name.
      */
     jsName: string;
     /**
@@ -422,6 +475,8 @@ export interface ScanModulesResult {
     modules: ScannedClass[];
     /** The top-level `@SharedObject` classes, with the same platform rules as `modules`. */
     sharedObjects: ScannedClass[];
+    /** The top-level `@ExpoView` classes, with the same platform rules as `modules`. */
+    views: ScannedClass[];
     warnings: ScanWarning[];
     stats: ScanStats;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-modules-macros",
-  "version": "0.32.0",
+  "version": "0.33.0",
   "description": "Swift macro plugin for Expo modules",
   "main": "build/index.js",
   "types": "build/index.d.ts",
@@ -26,9 +26,9 @@
     "typescript": "^5.4.0"
   },
   "optionalDependencies": {
-    "@expo/modules-macros-linux-arm64": "0.32.0",
-    "@expo/modules-macros-linux-x64": "0.32.0",
-    "@expo/modules-macros-win32-arm64": "0.32.0",
-    "@expo/modules-macros-win32-x64": "0.32.0"
+    "@expo/modules-macros-linux-arm64": "0.33.0",
+    "@expo/modules-macros-linux-x64": "0.33.0",
+    "@expo/modules-macros-win32-arm64": "0.33.0",
+    "@expo/modules-macros-win32-x64": "0.33.0"
   }
 }