expo-modules-macros 0.27.1 → 0.28.0

package/README.md

@@ -24,13 +24,15 @@ This package lists them as optional dependencies, and their `os`, `cpu` and (on
 
 # Macros
 
-- **`@ExpoModule(_ name: String? = nil, classes: [Any.Type] = [])`** on a class. Turns the class into a module: binds its `@JS` members into the module's JavaScript object and resolves the module name from the argument, falling back to the class name. It also synthesizes everything inheriting from `Module` used to provide, so a module class can carry any superclass, or none.
-- **`@JS(_ jsName: String? = nil, _ options: JSOptions...)`** on a member of a module or shared object. Marks a function, property or initializer for export. `@ExpoModule` and `@SharedObject` bind each marked member straight into the JavaScript object, with the argument decoding, the call and the result encoding inlined, so there is no dynamic per-call path. The JS name defaults to the Swift name; pass a string to override it. Two `@JS` members with the same JS name on one JavaScript object are a compile-time error, since JavaScript could reach only one of them. A shared object's static and instance members bind onto different objects, so they can share a name. The macro also checks that every type crossing the boundary is convertible in the direction it travels. Outside a module or shared object, a bad type is reported on the author's own declaration. In an `@ExpoModule` or `@SharedObject` class, the class macro makes the check, since only it sees the type aliases in the class body, so the error is reported on the class and names the member and its argument labels, such as `local function 'move(_:by:returning:)' requires that 'Point' conform to 'JavaScriptEncodable'`. A `lazy var` is read-only from JavaScript. On the first read, its getter stores the value as a data property on the JavaScript object, so later reads don't call into native code. On a frozen object the value isn't stored, and each read calls the getter. The `.concurrent` option moves an `async` body off the JavaScript thread while still decoding and encoding on it. The `.withAsync("name")` option binds a synchronous function a second time under that name, as a function that returns a promise and runs the body on the concurrent thread pool. That function isn't isolated to the JavaScript thread, so its body must be safe to run on any thread. The macro reports a function isolated to a global actor through its own attribute or its type's. When the isolation comes from elsewhere, such as a protocol or the module's default isolation, the error points into the generated code, so mark the function `nonisolated`. A function or initializer can take a closure argument, such as `(Point) throws -> Size` or `(String) async throws -> Data`. JavaScript passes a function for it, and native code can store the closure and call it from any thread. A closure that throws or returns a value blocks the caller until JavaScript returns, and an `async` closure suspends instead and awaits a promise that the function returns. A closure that returns a value must be `throws`, so that an error from JavaScript can reach the caller. A non-throwing `Void` closure returns before JavaScript reads its arguments, so don't change a class instance after passing it to one.
+- **`@ExpoModule(_ name: String? = nil, classes: [Any.Type] = [])`** on a class. Turns the class into a module: binds its `@JS` members into the module's JavaScript object and resolves the module name from the argument, falling back to the class name. It also synthesizes everything inheriting from `Module` used to provide, so a module class can carry any superclass, or none. It adds an `@unchecked Sendable` conformance when the class isn't `Sendable` yet (see [Sendable conformance](#sendable-conformance)).
+- **`@JS(_ jsName: String? = nil, _ options: JSOptions...)`** on a member of a module or shared object. Marks a function, property or initializer for export. `@ExpoModule` and `@SharedObject` bind each marked member straight into the JavaScript object, with the argument decoding, the call and the result encoding inlined, so there is no dynamic per-call path. The JS name defaults to the Swift name; pass a string to override it. Two `@JS` members with the same JS name on one JavaScript object are a compile-time error, since JavaScript could reach only one of them. A shared object's static and instance members bind onto different objects, so they can share a name. The macro also checks that every type crossing the boundary is convertible in the direction it travels. Outside a module or shared object, a bad type is reported on the author's own declaration. In an `@ExpoModule` or `@SharedObject` class, the class macro makes the check, since only it sees the type aliases in the class body, so the error is reported on the class and names the member and its argument labels, such as `local function 'move(_:by:returning:)' requires that 'Point' conform to 'JavaScriptEncodable'`. A `lazy var` is read-only from JavaScript. On the first read, its getter stores the value as a data property on the JavaScript object, so later reads don't call into native code. On a frozen object the value isn't stored, and each read calls the getter. The `.concurrent` option moves an `async` body off the JavaScript thread while still decoding and encoding on it. The `.withAsync("name")` option binds a synchronous function a second time under that name, as a function that returns a promise and runs the body on the concurrent thread pool. That function isn't isolated to the JavaScript thread, so its body must be safe to run on any thread. The macro reports a function isolated to a global actor through its own attribute or its type's. When the isolation comes from elsewhere, such as a protocol, the error points into the generated code, so mark the function `nonisolated`. A function or initializer can take a closure argument, such as `(Point) throws -> Size` or `(String) async throws -> Data`. JavaScript passes a function for it, and native code can store the closure and call it from any thread. A closure that throws or returns a value blocks the caller until JavaScript returns, and an `async` closure suspends instead and awaits a promise that the function returns. A closure that returns a value must be `throws`, so that an error from JavaScript can reach the caller. A non-throwing `Void` closure returns before JavaScript reads its arguments, so don't change a class instance after passing it to one.
 - **`@Event(_ name: String? = nil, sync: Bool = false)`** on a function-typed `var`. Expands the property into a closure that emits the event, so calling the property sends it to JavaScript with the closure's parameter as the payload. The JS name defaults to the property name with a leading `on` stripped. `sync: true` dispatches inline instead of asynchronously.
-- **`@SharedObject(_ name: String? = nil)`** on a subclass of `SharedObject`, direct or not, such as a `SharedRef<T>` subclass. Binds the class's `@JS` members through the `SharedObject` hooks that core calls when it builds the JavaScript class, and emits the JS class name, which defaults to the class name. A module exposes the class through `@ExpoModule(classes:)`, which only accepts `SharedObject` subclasses.
-- **`@Record()`** on a struct, or on a final class with no inheritance clause (declare a class's protocol conformances in an extension). Treats every non-static, non-private, non-computed stored property as a field, with no per-field wrapper, and synthesizes the memberwise initializer, the conversions in both directions, and the `Record` conformance. Requiredness is inferred: a default value makes a field optional, an optional type makes it nullable and optional.
+- **`@SharedObject(_ name: String? = nil)`** on a subclass of `SharedObject`, direct or not, such as a `SharedRef<T>` subclass. Binds the class's `@JS` members through the `SharedObject` hooks that core calls when it builds the JavaScript class, and emits the JS class name, which defaults to the class name. A module exposes the class through `@ExpoModule(classes:)`, which only accepts `SharedObject` subclasses. A subclass of another `@SharedObject` class also gets the `@JS` members of that class, and its own members replace inherited members with the same JS name. A subclass that isn't `final` can't be constructed from JavaScript through the `@JS init` of its superclass, so give each subclass that JavaScript constructs its own `@JS init`. Like `@ExpoModule`, it adds an `@unchecked Sendable` conformance when the class isn't `Sendable` yet.
+- **`@Record()`** on a struct, or on a final class with no inheritance clause (declare a class's protocol conformances in an extension). Treats every non-static, non-private, non-computed stored property as a field, with no per-field wrapper, and synthesizes the memberwise initializer, the conversions in both directions, and the `Record` conformance. A record converts only from and to JavaScript values: its `from(dictionary:appContext:)` throws `RecordDictionaryConversionException`, so a record can't be created from a native `[String: Any]`. A `@Union` can be a record property. Requiredness is inferred: a default value makes a field optional, an optional type makes it nullable and optional.
 - **`@Union()`** on an enum whose cases each carry one associated value. Models a TypeScript union. Synthesizes the conversions in both directions, a typed accessor per payload type, and the `JavaScriptDecodable` and `JavaScriptEncodable` conformances. Decoding is ordered: the first case whose payload decodes wins, so the more specific case goes first.
 
+The members and conformances that `@Record` and `@Union` generate are `nonisolated`, so they also work in a module that builds with a default isolation, such as `-default-isolation MainActor`. The stored properties of a record still take that isolation. A class record, or a struct record with a property whose type isn't `Sendable`, then needs `nonisolated` on its declaration, for example `@Record nonisolated final class Options`.
+
 A tuple can cross the boundary as a `@JS` argument, result or property, a `@Record` property, a `@Union` payload, an `@Event` payload, or a parameter or result of a closure argument that isn't `async`. An unlabeled tuple such as `(Int, String)` maps to an array with one value per element, and a labeled tuple such as `(x: Double, y: Double)` to an object with one property per label. A tuple must have two or more elements, all labeled or none, and each element must be convertible. Tuples nest in other tuples, optionals, arrays and `String`-keyed dictionaries. `@ExpoModule` and `@SharedObject` also resolve a type alias of a tuple, such as `typealias Span = (start: Int, end: Int)`, when the class body declares it. A macro sees only the declaration it is attached to, so an alias declared anywhere else doesn't resolve.
 
 How that looks in a module:
@@ -64,6 +66,10 @@ final class Cache: SharedObject {
 
 The author-facing documentation for each macro lives next to its declaration in `expo-modules-core`, in `ios/Core/ExpoModulesMacros.swift`. This repository holds the implementations.
 
+## Sendable conformance
+
+Native code calls a module or shared object from more than one thread: a `.withAsync` variant runs on the concurrent thread pool, and events and closure arguments can be called from any thread. So the generated code needs the class to be `Sendable`. A subclass of `Module` or `SharedObject` can't be checked `Sendable`, because those base classes aren't, so `@ExpoModule` and `@SharedObject` add `extension MyModule: @unchecked Sendable {}`. The compiler doesn't check the class's mutable state then: keep state that more than one thread uses behind a lock or an actor. The macros add nothing when the class already declares `Sendable` or `@unchecked Sendable`, or inherits it. Swift warns on a subclass of a module or shared object until the subclass restates `@unchecked Sendable`.
+
 # Scanner
 
 The Swift compiler launches a plugin executable with no arguments and speaks the plugin protocol over stdin, so the binary treats any argument as a scanner invocation instead:

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

@@ -293,9 +293,12 @@ struct ExportedSharedObject: Encodable, Equatable {
   /// if a malformed source has more. Not named `constructor`, which every JS object inherits.
   var initializer: ExportedInitializer?
 
-  /// What the class inherits from `SharedRef<T>`, or `nil` when its superclass isn't `SharedRef`.
-  let sharedRef: ExportedSharedRef?
+  /// What the class inherits from `SharedRef<T>`, directly or through another scanned `@SharedObject`
+  /// class, or `nil` when it doesn't inherit `SharedRef`.
+  var sharedRef: ExportedSharedRef?
 
+  /// The class's `@JS` members, followed by the ones it inherits from scanned `@SharedObject`
+  /// superclasses (see `ExportedSurface.mergingInheritedMembers()`).
   var functions: [ExportedFunction]
   var properties: [ExportedProperty]
   var events: [ExportedEvent]
@@ -306,10 +309,24 @@ struct ExportedSharedObject: Encodable, Equatable {
   let platforms: [ExportedPlatform]
 
   let file: String
+
+  /// The superclass as written, without generic arguments, or `nil` when there is none or it is
+  /// `SharedObject` or `SharedRef`. Not encoded: it is only read to find the inherited members.
+  var superclass: String? = nil
+
+  /// The value of the class's own `nativeRefType` override (see `ExportedSharedRef.nativeRefType`), or
+  /// `.none` when it declares none. Not encoded: a subclass of a `SharedRef` subclass reports its own
+  /// override in the inherited `sharedRef`.
+  var ownNativeRefType: String?? = .none
+
+  private enum CodingKeys: String, CodingKey {
+    case name, jsName, initializer, sharedRef, functions, properties, events, accessLevel, platforms, file
+  }
 }
 
-/// The `SharedRef<T>` superclass of a shared object. Only the superclass written on the class is read,
-/// so a class that inherits `SharedRef` through another subclass has none.
+/// The `SharedRef<T>` superclass of a shared object. A class that inherits `SharedRef` through another
+/// `@SharedObject` class reports the `T` of that class. A class that inherits it through a class the
+/// scan doesn't report has none.
 struct ExportedSharedRef: Encodable, Equatable {
   /// The `T` in `SharedRef<T>`: the native type the object holds, which JS never sees.
   let native: TypeNode

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

@@ -0,0 +1,96 @@
+/// Adds to each `@SharedObject` class the `@JS` members it inherits from scanned `@SharedObject`
+/// superclasses.
+///
+/// The `@SharedObject` macro binds the members of the superclass on the JavaScript objects of the
+/// subclass too, since core builds each JavaScript class on the base `SharedObject` class and not on the
+/// JavaScript class of the superclass. So the reported surface of a subclass lists the inherited members
+/// as its own, and a consumer generates the same type as for any other class.
+
+extension ExportedSurface {
+  /// This surface with the inherited members added to each shared object. Runs after
+  /// `resolvingRefs()`, so the refs in an inherited member are resolved from the superclass that
+  /// declares it, as Swift resolves them.
+  ///
+  /// The superclass is looked up from the scope that encloses the class, the way `RefIndex` looks up a
+  /// ref. A superclass the scan doesn't report as a shared object (a protocol, a class without
+  /// `@SharedObject`, or a class from another module) ends the chain, so nothing is inherited through it.
+  ///
+  /// A superclass declared more than once, in `#if` branches, contributes the members of each
+  /// declaration whose platforms overlap the platforms of the class. Each member keeps its own
+  /// `platforms`.
+  ///
+  /// The members merge the way the macro binds them: the inherited ones first, then the class's own. An
+  /// own member replaces an inherited function or property with the same JS name, separately for static
+  /// and instance members. Events are kept from both: an event is a stored property that emits under its
+  /// JS name, so a subclass can't replace an inherited one, and both are sent. The `@JS init` isn't
+  /// inherited: core doesn't construct a subclass through the initializer of its superclass.
+  ///
+  /// A class that inherits `SharedRef` through its superclass gets the `sharedRef` of the superclass,
+  /// with the class's own `nativeRefType` override when it has one.
+  func mergingInheritedMembers() -> ExportedSurface {
+    let index = RefIndex(surface: self)
+    let declarations = Dictionary(grouping: sharedObjects, by: \.name)
+
+    // `chain` holds the classes being merged, so a malformed cycle in the inheritance ends instead of
+    // recursing forever.
+    func merged(_ sharedObject: ExportedSharedObject, chain: Set<String>) -> ExportedSharedObject {
+      let scope = sharedObject.name.split(separator: ".").dropLast().joined(separator: ".")
+      guard let superclass = sharedObject.superclass,
+        let entry = index.lookup(superclass, in: scope),
+        entry.kind == .sharedObject,
+        !chain.contains(entry.name)
+      else {
+        return sharedObject
+      }
+      let platforms = Set(sharedObject.platforms.map(\.name))
+      let parents = (declarations[entry.name] ?? [])
+        .filter { declaration in declaration.platforms.contains { platforms.contains($0.name) } }
+        .map { merged($0, chain: chain.union([sharedObject.name])) }
+      guard !parents.isEmpty else {
+        return sharedObject
+      }
+      var result = sharedObject
+
+      let ownMembers = Set(
+        sharedObject.functions.map { MemberKey(jsName: $0.jsName, isStatic: $0.isStatic) }
+          + sharedObject.properties.map { MemberKey(jsName: $0.jsName, isStatic: $0.isStatic) }
+      )
+      result.functions =
+        parents.flatMap(\.functions).filter {
+          !ownMembers.contains(MemberKey(jsName: $0.jsName, isStatic: $0.isStatic))
+        }
+        + sharedObject.functions
+      result.properties =
+        parents.flatMap(\.properties).filter {
+          !ownMembers.contains(MemberKey(jsName: $0.jsName, isStatic: $0.isStatic))
+        }
+        + sharedObject.properties
+      result.events = parents.flatMap(\.events) + sharedObject.events
+
+      // Every declaration of a superclass names the same superclass in practice, so the first one that
+      // inherits `SharedRef` stands for all of them.
+      if result.sharedRef == nil, let inherited = parents.lazy.compactMap(\.sharedRef).first {
+        result.sharedRef = ExportedSharedRef(
+          native: inherited.native,
+          nativeRefType: sharedObject.ownNativeRefType ?? inherited.nativeRefType
+        )
+      }
+      return result
+    }
+
+    return ExportedSurface(
+      modules: modules,
+      sharedObjects: sharedObjects.map { merged($0, chain: []) },
+      records: records,
+      enums: enums,
+      unions: unions
+    )
+  }
+}
+
+/// A member's slot on the JavaScript side: static members live on the constructor and instance members
+/// on the prototype, so the two don't replace each other.
+private struct MemberKey: Hashable {
+  let jsName: String
+  let isStatic: Bool
+}

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

@@ -57,14 +57,15 @@ func scanExports(paths: [String]) -> ScanExportsResult {
   }
 
   // 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.
+  // 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.
   let surface = ExportedSurface(
     modules: modules,
     sharedObjects: sharedObjects,
     records: records,
     enums: enums,
     unions: unions
-  ).resolvingRefs()
+  ).resolvingRefs().mergingInheritedMembers()
 
   return ScanExportsResult(
     schemaVersion: scanExportsSchemaVersion,

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

@@ -183,7 +183,9 @@ final class SurfaceVisitor: SyntaxVisitor {
           events: events,
           accessLevel: accessLevel,
           platforms: platforms,
-          file: file
+          file: file,
+          superclass: sharedObjectSuperclass(of: node),
+          ownNativeRefType: declaredNativeRefType(in: members)
         )
       )
       return
@@ -759,21 +761,50 @@ private func sharedRefSuperclass(of node: some DeclGroupSyntax) -> ExportedShare
   else {
     return nil
   }
-  return ExportedSharedRef(native: native, nativeRefType: nativeRefType(in: node.memberBlock.members))
+  return ExportedSharedRef(
+    native: native,
+    nativeRefType: declaredNativeRefType(in: node.memberBlock.members) ?? "unknown"
+  )
+}
+
+/// The superclass a `@SharedObject` class names, without generic arguments (`Outer.ImageRef`), or `nil`
+/// when it names none, `SharedObject`, or `SharedRef`. The first entry of the inheritance clause is read,
+/// since Swift requires the superclass to come first. It may also be a protocol, which then names no
+/// scanned shared object.
+private func sharedObjectSuperclass(of node: some DeclGroupSyntax) -> String? {
+  guard let type = node.inheritanceClause?.inheritedTypes.first?.type,
+    let spelling = spellingWithoutGenericArguments(of: type)
+  else {
+    return nil
+  }
+  let name = spelling.split(separator: ".").last.map(String.init)
+  return name == "SharedObject" || name == "SharedRef" ? nil : spelling
+}
+
+/// A simple or qualified type name as written, without backticks or generic arguments, or `nil` for any
+/// other kind of type.
+private func spellingWithoutGenericArguments(of type: TypeSyntax) -> String? {
+  if let identifier = type.as(IdentifierTypeSyntax.self) {
+    return identifier.name.text.filter { $0 != "`" }
+  }
+  if let member = type.as(MemberTypeSyntax.self), let base = spellingWithoutGenericArguments(of: member.baseType) {
+    return base + "." + member.name.text.filter { $0 != "`" }
+  }
+  return nil
 }
 
-/// The value of a `nativeRefType` override that returns a plain string literal: `"image"` in
-/// `override var nativeRefType: String { "image" }`, also with `return` or inside a `get` block.
-/// `unknown`, core's default, when the class declares no `nativeRefType`, and `nil` when its getter is
-/// anything else.
-private func nativeRefType(in members: MemberBlockItemListSyntax) -> String? {
+/// The value of the class's `nativeRefType` override when it returns a plain string literal: `"image"`
+/// in `override var nativeRefType: String { "image" }`, also with `return` or inside a `get` block.
+/// `.none` when the class declares no `nativeRefType` (core's default is `unknown`), and `.some(nil)`
+/// when its getter is anything else.
+private func declaredNativeRefType(in members: MemberBlockItemListSyntax) -> String?? {
   let binding = members.lazy
     .compactMap { $0.decl.as(VariableDeclSyntax.self) }
     .filter { !isTypeLevel($0.modifiers) }
     .flatMap { $0.bindings }
     .first { $0.pattern.as(IdentifierPatternSyntax.self)?.identifier.text == "nativeRefType" }
   guard let binding else {
-    return "unknown"
+    return .none
   }
   let statements: CodeBlockItemListSyntax?
   switch binding.accessorBlock?.accessors {
@@ -785,18 +816,18 @@ private func nativeRefType(in members: MemberBlockItemListSyntax) -> String? {
     statements = nil
   }
   guard let statements, statements.count == 1, let item = statements.first?.item else {
-    return nil
+    return .some(nil)
   }
   let expression = item.as(ReturnStmtSyntax.self)?.expression ?? item.as(ExprSyntax.self)
   guard let literal = expression?.as(StringLiteralExprSyntax.self),
     literal.segments.count == 1,
     let segment = literal.segments.first?.as(StringSegmentSyntax.self)
   else {
-    return nil
+    return .some(nil)
   }
   // An escape would need real unescaping, so it's treated as unreadable, as in `writtenRawValue(of:)`.
   let content = segment.content.text
-  return content.contains("\\") ? nil : content
+  return .some(content.contains("\\") ? nil : content)
 }
 
 private func isTypeLevel(_ modifiers: DeclModifierListSyntax) -> Bool {

package/apple/Sources/ExpoModulesMacros/Macros/ExpoModuleMacro.swift

@@ -13,7 +13,8 @@ import SwiftSyntaxMacros
 ///   synthesizes the `appContext` storage and `init(appContext:)` those base classes provide.
 /// - `MemberAttributeMacro`: stamps `@JavaScriptActor` on `@JS` sync members and
 ///   `@ModuleDefinitionBuilder` on a `definition()` method.
-/// - `ExtensionMacro`: adds the `AnyModule` conformance when the class doesn't inherit it.
+/// - `ExtensionMacro`: adds the `AnyModule` conformance when the class doesn't inherit it, and an
+///   `@unchecked Sendable` conformance when the class isn't `Sendable` yet.
 ///
 /// Inheriting from `Module` is therefore optional — a class can carry any superclass (or
 /// none) and still be a module, because everything inheritance used to provide is synthesized.
@@ -219,15 +220,20 @@ extension ExpoModuleMacro: ExtensionMacro {
     guard !protocols.isEmpty else {
       return []
     }
+    var extensions: [ExtensionDeclSyntax] = []
     // These base types already supply `AnyModule`; emitting a second conformance here
     // would be redundant and error.
-    if let classDecl = declaration.as(ClassDeclSyntax.self),
-      inheritsFromAny(classDecl, names: ["Module", "BaseModule", "AnyModule"])
+    if protocols.contains(where: { $0.trimmedDescription == "AnyModule" }),
+      let classDecl = declaration.as(ClassDeclSyntax.self),
+      !inheritsFromAny(classDecl, names: ["Module", "BaseModule", "AnyModule"])
     {
-      return []
+      let conformance: DeclSyntax = "extension \(type.trimmed): AnyModule {}"
+      extensions.append(conformance.cast(ExtensionDeclSyntax.self))
+    }
+    if let sendable = uncheckedSendableExtension(for: type, of: declaration, conformingTo: protocols) {
+      extensions.append(sendable)
     }
-    let conformance: DeclSyntax = "extension \(type.trimmed): AnyModule {}"
-    return [conformance.cast(ExtensionDeclSyntax.self)]
+    return extensions
   }
 }
 

package/apple/Sources/ExpoModulesMacros/Macros/RecordMacro.swift

@@ -11,8 +11,9 @@ import SwiftSyntaxMacros
 /// - `decode(_:in:)` and `encode(_:in:)` — the fast paths, reading each property straight off a JS
 ///   object and writing it straight into one,
 /// - `from(object:appContext:)` and `toObject(appContext:)`, which forward to `decode` and `encode`,
-/// - `from(dictionary:appContext:)` and `toDictionary(appContext:)` — converting each property from and
-///   to a `[String: Any]` dictionary.
+/// - `toDictionary(appContext:)`, which puts each property into a `[String: Any]` dictionary,
+/// - `from(dictionary:appContext:)`, which throws `RecordDictionaryConversionException`: a record
+///   converts only from JavaScript values, so it can't be created from a native dictionary.
 ///
 /// The type is auto-conformed to `Record` (a core protocol whose requirements are this surface); the
 /// synthesized methods override `Record`'s reflection-based defaults, and the synthesized `decode` and
@@ -37,23 +38,16 @@ import SwiftSyntaxMacros
 /// have static stored properties. The macro can't tell that an extension extends a generic type, so a
 /// record declared in one doesn't compile.
 ///
-/// The JS-value paths convert through `JavaScriptDecodable.decode` / `JavaScriptEncodable.encode`
-/// (`decode(_:in:)` / `encode(_:in:)`); the native-`Any` dictionary paths still go through the
-/// public dynamic-type API — `T.getDynamicType()` plus `cast(_:appContext:)` / `convertToJS(_:appContext:)`
-/// (`from(dictionary:)` / `toDictionary(appContext:)`), since `JavaScriptCodable` only converts JS
-/// values, not native `Any`. Both spell types as `public` symbols so the synthesized code compiles inside
-/// user modules without any internal core symbols. Every property type must therefore conform to both
-/// `AnyArgument` and `JavaScriptDecodable & JavaScriptEncodable`. The conformance assertion checks only
-/// the JS codable protocols; the compiler reports a missing `AnyArgument` at the `getDynamicType()`
-/// call.
+/// Properties convert through `JavaScriptDecodable.decode` / `JavaScriptEncodable.encode`
+/// (`decode(_:in:)` / `encode(_:in:)`), spelled with `public` symbols so the synthesized code compiles
+/// inside user modules without any internal core symbols. Every property type must conform to
+/// `JavaScriptDecodable & JavaScriptEncodable`, which the conformance assertion checks.
 ///
 /// A property whose type mentions `Any` (`Any?`, `[String: Any]?`, `[String: [Any]]`, …) can't conform to
-/// the JS codable protocols, so it isn't asserted. On the JS-value paths it converts through the
-/// `JavaScriptValue` free-form methods instead: `decodeAny`/`decodeAnyArray`/`decodeAnyDictionary` and
-/// the matching `encodeAny…` for `Any`, `[Any]` and `[String: Any]` (optional or not), and the generic
-/// `decodeAny(_:as:in:)` / `encodeAny(_:in:)` for any other type. Such a property only needs
-/// `AnyArgument` for the dictionary paths, and a bare `Any` needs nothing, since the dictionary paths
-/// pass it through unchanged.
+/// the JS codable protocols, so it isn't asserted. It converts through the `JavaScriptValue` free-form
+/// methods instead: `decodeAny`/`decodeAnyArray`/`decodeAnyDictionary` and the matching `encodeAny…` for
+/// `Any`, `[Any]` and `[String: Any]` (optional or not), and the generic `decodeAny(_:as:in:)` /
+/// `encodeAny(_:in:)` for any other type.
 ///
 /// A record class must be `final` and have no inheritance clause. The synthesized factories construct
 /// `Self` through the memberwise init, which only a final class can do without a `required` init, and
@@ -112,7 +106,7 @@ public struct RecordMacro: MemberMacro, ExtensionMacro {
       members.append(memberwiseInit(properties: properties))
     }
     members.append(fromJSObjectFactory())
-    members.append(fromDictionaryFactory(properties: properties))
+    members.append(fromDictionaryFactory())
     members.append(toDictionaryMethod(properties: properties))
     members.append(toObjectMethod())
     if cachesPropNames {
@@ -152,8 +146,10 @@ public struct RecordMacro: MemberMacro, ExtensionMacro {
       return []
     }
 
+    // `nonisolated` keeps the conformance usable on the JavaScript thread when the module builds with a
+    // default isolation, which would otherwise isolate it to the main actor.
     let ext: DeclSyntax = """
-      extension \(type.trimmed): Record {}
+      extension \(type.trimmed): nonisolated Record {}
       """
     guard let extDecl = ext.as(ExtensionDeclSyntax.self) else {
       return []
@@ -171,8 +167,7 @@ private struct RecordProperty {
   /// every identifier position in the generated code needs them.
   let name: String
   /// The property's declared type, verbatim (e.g. `String`, `Int`, `String?`). Used to build the
-  /// memberwise-init parameter and as the receiver of the per-property `decode`/`encode` (and, on the
-  /// dictionary paths, `getDynamicType()`) conversions.
+  /// memberwise-init parameter and as the receiver of the per-property `decode`/`encode` conversions.
   let type: String
   /// The default-value expression verbatim (`0`, `""`, `[]`), or `nil` when the property has none.
   /// Inlined into the memberwise init and the factories' omitted-property branch so the synthesized
@@ -304,13 +299,13 @@ private func defaultInit(properties: [RecordProperty]) -> DeclSyntax? {
   }
   if properties.contains(where: { $0.isRequired }) {
     return """
-      public init() {
-      fatalError("\\(Self.self) has required properties and cannot be created with init(); construct it through the @Record-synthesized from(dictionary:) or from(object:) factories")
+      nonisolated public init() {
+      fatalError("\\(Self.self) has required properties and cannot be created with init(); create it from JavaScript or with its memberwise initializer")
       }
       """
   }
   return """
-    public init() {
+    nonisolated public init() {
     }
     """
 }
@@ -333,7 +328,7 @@ private func memberwiseInit(properties: [RecordProperty]) -> DeclSyntax {
   let signature = params.joined(separator: ", ")
 
   return """
-    public init(\(raw: signature)) {
+    nonisolated public init(\(raw: signature)) {
     \(raw: assignments)
     }
     """
@@ -355,13 +350,13 @@ private func fromJSObjectFactory() -> DeclSyntax {
     """
 }
 
-/// `from(dictionary:appContext:)` — same as the JS path but reads from `[String: Any]` and
-/// uses the `Any?` cast overload; a missing key is `dictionary[key] == nil`.
-private func fromDictionaryFactory(properties: [RecordProperty]) -> DeclSyntax {
-  let body = factoryBody(properties: properties, readLines: dictionaryReadLines(properties: properties))
+/// `from(dictionary:appContext:)`, a `Record` requirement. A record converts only from JavaScript values,
+/// through `decode(_:in:)`, so it throws. Converting each property from a native `Any` would need the
+/// dynamic types of the 1.0 conversion API.
+private func fromDictionaryFactory() -> DeclSyntax {
   return """
-    public static func from(dictionary: [String: Any], appContext: AppContext) throws -> Self {
-    \(raw: body)
+    nonisolated public static func from(dictionary: [String: Any], appContext: AppContext) throws -> Self {
+      throw RecordDictionaryConversionException(String(describing: Self.self))
     }
     """
 }
@@ -413,44 +408,7 @@ private func jsObjectReadLines(properties: [RecordProperty], cachesPropNames: Bo
   return lines
 }
 
-/// Per-property read statements for the dictionary factory, each producing a `let field<index>` from the
-/// raw dictionary value in `entry<index>`. A bare `Any` property has no dynamic type to cast through, and
-/// the dictionary value already is an `Any`, so it's read unchanged.
-private func dictionaryReadLines(properties: [RecordProperty]) -> [String] {
-  var lines: [String] = []
-  for (index, property) in properties.enumerated() {
-    let field = fieldLocal(index)
-    let entry = "entry\(index)"
-    let exprType = expressionType(property.type)
-    let isBareAny = property.freeForm?.isBareAny == true
-    let cast: String
-    if isBareAny {
-      cast = entry
-    } else if tupleConversion(of: property.type) != nil {
-      // A type that holds a tuple has no dynamic type, so the dictionary value must already be of the
-      // property's type.
-      cast =
-        "try { () throws -> \(exprType) in guard let value = \(entry) as? \(exprType) else { throw Conversions.ConvertingException<\(exprType)>(\(entry)) }; return value }()"
-    } else {
-      cast = "try \(exprType).getDynamicType().cast(\(entry), appContext: appContext) as! \(exprType)"
-    }
-    lines.append("  let \(entry) = dictionary[\"\(property.key)\"]")
-    if property.isRequired {
-      lines.append("  guard let \(entry) else {")
-      lines.append("    throw RecordPropertyRequiredException(\"\(property.key)\")")
-      lines.append("  }")
-      lines.append("  let \(field) = \(cast)")
-    } else if property.isOptional {
-      lines.append("  let \(field): \(property.type) = (\(entry) == nil || \(entry)! is NSNull) ? nil : \(cast)")
-    } else {
-      lines.append("  let \(field) = \(entry) == nil ? \(property.defaultValue!) : \(isBareAny ? entry + "!" : cast)")
-    }
-  }
-  return lines
-}
-
-/// `toDictionary(appContext:)` — converts each property back to a JS-compatible value via the
-/// dynamic type and assembles a `[String: Any]`.
+/// `toDictionary(appContext:)`, which puts each property into a `[String: Any]` as it is.
 private func toDictionaryMethod(properties: [RecordProperty]) -> DeclSyntax {
   var lines = ["  var dictionary: [String: Any] = [:]"]
   for property in properties {
@@ -458,7 +416,7 @@ private func toDictionaryMethod(properties: [RecordProperty]) -> DeclSyntax {
   }
   lines.append("  return dictionary")
   return """
-    public func toDictionary(appContext: AppContext? = nil) -> [String: Any] {
+    nonisolated public func toDictionary(appContext: AppContext? = nil) -> [String: Any] {
     \(raw: lines.joined(separator: "\n"))
     }
     """
@@ -578,7 +536,7 @@ private func propNamesClass(properties: [RecordProperty]) -> DeclSyntax {
     "    self.\(propNameMember(index)) = JavaScriptPropNameID(runtime, string: \"\(property.key)\")"
   }
   return """
-    private final class \(raw: propNamesTypeName) {
+    nonisolated private final class \(raw: propNamesTypeName) {
       static let _key = JavaScriptRuntime.Cache.Key<\(raw: propNamesTypeName)>()
 
     \(raw: storedProperties.joined(separator: "\n"))

package/apple/Sources/ExpoModulesMacros/Macros/SharedObjectMacro.swift

@@ -21,6 +21,9 @@ import SwiftSyntaxMacros
 ///
 /// The companion `@ExpoModule(classes: [Cache.self])` registers the class with the module, which
 /// exposes it in its JavaScript object.
+///
+/// As an extension macro, it adds an `@unchecked Sendable` conformance when the class isn't
+/// `Sendable` yet.
 public struct SharedObjectMacro: MemberMacro {
   public static func expansion(
     of node: AttributeSyntax,
@@ -38,6 +41,11 @@ public struct SharedObjectMacro: MemberMacro {
     let typeName = classDecl.name.text
     let jsName = jsNameArgument(of: node) ?? withoutBackticks(typeName)
 
+    // A superclass other than `SharedObject` or `SharedRef` may be another `@SharedObject` class, so the
+    // decorator phases call `super` to bind its `@JS` members too. The base classes' phases bind nothing.
+    let callsSuper = !inheritsFromAny(classDecl, names: ["SharedObject", "SharedRef"])
+    let isFinal = classDecl.modifiers.contains { $0.name.tokenKind == .keyword(.final) }
+
     // `@JS func`s/`var`s and the `@JS init` are bound directly into the shared object's JS object by
     // the synthesized `_decorateSharedObject(prototype:)` / `_decorateSharedObject(constructor:)` / `_constructSharedObject`.
     //
@@ -117,7 +125,9 @@ public struct SharedObjectMacro: MemberMacro {
           phase: .prototype,
           functions: instanceFunctions,
           properties: instanceProperties,
-          typeName: typeName
+          typeName: typeName,
+          callsSuper: callsSuper,
+          isFinal: isFinal
         )
       )
     }
@@ -127,12 +137,14 @@ public struct SharedObjectMacro: MemberMacro {
           phase: .constructor,
           functions: staticFunctions,
           properties: staticProperties,
-          typeName: typeName
+          typeName: typeName,
+          callsSuper: callsSuper,
+          isFinal: isFinal
         )
       )
     }
     if let constructor {
-      emitted.append(constructor.buildConstructor(typeName: typeName))
+      emitted.append(constructor.buildConstructor(typeName: typeName, isFinal: isFinal))
     }
 
     // The conformance assertions of the `@JS` members, which `@JS` leaves to this macro (see
@@ -168,3 +180,18 @@ extension SharedObjectMacro: MemberAttributeMacro {
     return ["@JavaScriptActor"]
   }
 }
+
+extension SharedObjectMacro: ExtensionMacro {
+  public static func expansion(
+    of node: AttributeSyntax,
+    attachedTo declaration: some DeclGroupSyntax,
+    providingExtensionsOf type: some TypeSyntaxProtocol,
+    conformingTo protocols: [TypeSyntax],
+    in context: some MacroExpansionContext
+  ) throws -> [ExtensionDeclSyntax] {
+    guard let sendable = uncheckedSendableExtension(for: type, of: declaration, conformingTo: protocols) else {
+      return []
+    }
+    return [sendable]
+  }
+}

package/apple/Sources/ExpoModulesMacros/Macros/UnionMacro.swift

@@ -98,7 +98,9 @@ public struct UnionMacro: MemberMacro, ExtensionMacro {
       return []
     }
 
-    let conformances = missing.map { $0.trimmedDescription }.joined(separator: ", ")
+    // `nonisolated` keeps the conformances usable on the JavaScript thread when the module builds with
+    // a default isolation, which would otherwise isolate them to the main actor.
+    let conformances = missing.map { "nonisolated \($0.trimmedDescription)" }.joined(separator: ", ")
     let ext: DeclSyntax = """
       extension \(type.trimmed): \(raw: conformances) {}
       """
@@ -298,7 +300,7 @@ private func decodableKindsProperty(union: UnionType) -> DeclSyntax {
   // optimizer folds it to a constant after specialization, the same as a chain of `union(_:)` calls.
   let expression = kinds.count == 1 ? kinds[0] : "[\(kinds.joined(separator: ", "))]"
   return """
-    public static var decodableKinds: JavaScriptValueKinds {
+    nonisolated public static var decodableKinds: JavaScriptValueKinds {
       return \(raw: expression)
     }
     """
@@ -367,7 +369,7 @@ private func accessorMethods(union: UnionType) -> [DeclSyntax] {
     let mismatch =
       "(unionName: \"\(union.name)\", received: _payloadTypeName, expected: [\"\(unionCase.payloadType)\"])"
     return """
-      public func `as`(_ type: \(raw: payloadType).Type) throws -> \(raw: payloadType) {
+      nonisolated public func `as`(_ type: \(raw: payloadType).Type) throws -> \(raw: payloadType) {
         if case \(raw: unionCase.pattern) = self {
           return payload
         }
@@ -389,7 +391,7 @@ private func payloadTypeNameProperty(union: UnionType) -> DeclSyntax {
   lines.append("  }")
   let body = lines.joined(separator: "\n")
   return """
-    private var _payloadTypeName: String {
+    nonisolated private var _payloadTypeName: String {
     \(raw: body)
     }
     """

package/apple/Sources/ExpoModulesMacros/ProvidedMacros.swift

@@ -16,8 +16,8 @@ struct ProvidedMacro {
       ProvidedMacro(name: "OptimizedFunction", type: OptimizedFunctionAttachedMacro.self),
       ProvidedMacro(name: "JS", type: JSMacro.self),
       ProvidedMacro(name: "Event", type: EventMacro.self),
-      ProvidedMacro(name: "ExpoModule", type: ExpoModuleMacro.self, conformances: ["AnyModule"]),
-      ProvidedMacro(name: "SharedObject", type: SharedObjectMacro.self),
+      ProvidedMacro(name: "ExpoModule", type: ExpoModuleMacro.self, conformances: ["AnyModule", "Sendable"]),
+      ProvidedMacro(name: "SharedObject", type: SharedObjectMacro.self, conformances: ["Sendable"]),
       ProvidedMacro(name: "Record", type: RecordMacro.self, conformances: ["Record"]),
       ProvidedMacro(
         name: "Union",

package/apple/Sources/ExpoModulesMacros/Support/DecorateModuleBuilder.swift

@@ -398,7 +398,10 @@ internal struct JSProperty {
   /// closure — and installs it with `object.defineProperty(name, descriptor:)`. Capture matches the
   /// function bindings: a module captures `self` strong, a shared object captures nothing of the
   /// instance. Getter and setter are gated independently.
-  func decorateStatements(object: String, receiver: Receiver) -> String {
+  ///
+  /// With `configurable`, the accessor can be redefined, so a subclass of a shared object class can
+  /// replace it with its own member of the same JS name. A `lazy var` is always configurable.
+  func decorateStatements(object: String, receiver: Receiver, configurable: Bool = false) -> String {
     let descriptorName = derivedIdentifier(from: swiftName, suffix: "Descriptor")
     let callee = receiver.callee
     // A shared object's accessors unwrap the JS `this` into `_self` before reading/writing; a module
@@ -409,8 +412,8 @@ internal struct JSProperty {
 
     lines.append("let \(descriptorName) = runtime.createObject()")
     lines.append("\(descriptorName).setProperty(\"enumerable\", value: true)")
-    if isLazy {
-      // The getter redefines the property on `this`, which needs a configurable accessor when `this`
+    if isLazy || configurable {
+      // A lazy getter redefines the property on `this`, which needs a configurable accessor when `this`
       // is the object that holds it (a module).
       lines.append("\(descriptorName).setProperty(\"configurable\", value: true)")
     }
@@ -523,14 +526,30 @@ private func encodeIntoSlotStatement(_ type: String, freeForm: FreeFormConversio
 /// is the local the bindings decorate (matching the entry point's argument label); `receiver` selects
 /// how each binding reaches its Swift value (module `self`, shared-object instance `_self`, or the
 /// metatype for a static member).
+///
+/// `configurableProperties` makes the property accessors configurable. `replacesInherited` first
+/// redefines the name of each function as a writable data property: the object may already hold an
+/// inherited accessor with that name, which an assignment would call instead of replacing.
 private func decorateBody(
   functions: [JSFunction],
   properties: [JSProperty],
   object: String,
-  receiver: Receiver
+  receiver: Receiver,
+  configurableProperties: Bool = false,
+  replacesInherited: Bool = false
 ) -> String {
-  let functionBody = functions.map { $0.decorateStatements(object: object, receiver: receiver) }
-  let propertyBody = properties.map { $0.decorateStatements(object: object, receiver: receiver) }
+  let functionBody = functions.map { function in
+    let binding = function.decorateStatements(object: object, receiver: receiver)
+    guard replacesInherited else {
+      return binding
+    }
+    let redefine =
+      "  \(object).defineProperty(\"\(function.jsName)\", descriptor: .init(configurable: true, enumerable: true, writable: true))"
+    return redefine + "\n" + binding
+  }
+  let propertyBody = properties.map {
+    $0.decorateStatements(object: object, receiver: receiver, configurable: configurableProperties)
+  }
   return (functionBody + propertyBody).joined(separator: "\n")
 }
 
@@ -568,11 +587,21 @@ internal func buildDecorateJavaScriptObject(functions: [JSFunction], properties:
 /// constructor). The constructor *object* the static members decorate is distinct from the `@JS init`,
 /// which builds an instance and is emitted separately (see `JSConstructor.buildConstructor`). Each phase
 /// is emitted only when the type has a member for it.
+///
+/// With `callsSuper`, the phase first calls the superclass's phase, so a subclass of another
+/// `@SharedObject` class also gets the inherited `@JS` members. Core builds each JavaScript class on
+/// the base `SharedObject` class, not on the JavaScript class of the superclass, so the inherited
+/// members have to be bound on the subclass's own objects. They are bound first, so a subclass member
+/// with the same JavaScript name replaces the inherited one. For that, the property accessors of a
+/// class that isn't `final` are configurable, and a subclass redefines the name of each of its functions
+/// before it binds the function.
 internal func buildDecorateSharedObjectPhase(
   phase: Phase,
   functions: [JSFunction],
   properties: [JSProperty],
-  typeName: String
+  typeName: String,
+  callsSuper: Bool,
+  isFinal: Bool
 ) -> DeclSyntax {
   let receiver: Receiver =
     phase == .constructor
@@ -582,12 +611,18 @@ internal func buildDecorateSharedObjectPhase(
     functions: functions,
     properties: properties,
     object: phase.rawValue,
-    receiver: receiver
+    receiver: receiver,
+    configurableProperties: !isFinal,
+    replacesInherited: callsSuper
   )
+  let superCall =
+    callsSuper
+    ? "  try super._decorateSharedObject(\(phase.rawValue): \(phase.rawValue), in: runtime)\n"
+    : ""
   return """
     @JavaScriptActor
     public override class func _decorateSharedObject(\(raw: phase.rawValue): borrowing JavaScriptObject, in runtime: JavaScriptRuntime) throws {
-    \(raw: body)
+    \(raw: superCall)\(raw: body)
     }
     """
 }

package/apple/Sources/ExpoModulesMacros/Support/JSConstructor.swift

@@ -51,11 +51,24 @@ internal struct JSConstructor {
 
   /// Builds an instance from the JS arguments. Overrides the base `SharedObject` class method; returns
   /// the concrete instance, which promotes to the base `SharedObject?` return type.
-  func buildConstructor(typeName: String) -> DeclSyntax {
+  ///
+  /// A subclass without a `@JS init` of its own inherits this override, and would construct an instance
+  /// of this class instead of the subclass. Unless the class is `final`, the override returns `nil` when
+  /// called on a subclass, so core reports that the subclass has no JavaScript constructor.
+  func buildConstructor(typeName: String, isFinal: Bool) -> DeclSyntax {
+    let subclassGuard =
+      isFinal
+      ? ""
+      : """
+        guard self == \(typeName).self else {
+          return nil
+        }
+
+      """
     return """
       @JavaScriptActor
       public override class func _constructSharedObject(this: borrowing JavaScriptValue, arguments: borrowing JavaScriptValuesBuffer, in runtime: JavaScriptRuntime) throws -> SharedObject? {
-      \(raw: bodyStatements(typeName: typeName, indent: "  "))
+      \(raw: subclassGuard)\(raw: bodyStatements(typeName: typeName, indent: "  "))
       }
       """
   }

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

@@ -479,8 +479,7 @@ extension AttributeListSyntax {
   }
 }
 
-/// A type spelled so it's valid in expression position (before `.decode`/`.encode`, before
-/// `.getDynamicType()`, or after `as!`). Implicitly-unwrapped optionals (`T!`) are only allowed in
+/// A type spelled so it's valid in expression position (before `.decode`/`.encode`). Implicitly-unwrapped optionals (`T!`) are only allowed in
 /// type-annotation position, so a trailing `!` is rewritten to `?` (`T!` and `T?` are both
 /// `Optional<T>`, which the conversion layer treats identically). Other type spellings pass through
 /// unchanged.

package/apple/Sources/ExpoModulesMacros/Support/SendableConformance.swift

@@ -0,0 +1,36 @@
+import SwiftSyntax
+import SwiftSyntaxBuilder
+
+/// The `@unchecked Sendable` conformance that `@ExpoModule` and `@SharedObject` add to their class, or
+/// `nil` when the class already conforms. The compiler leaves `Sendable` out of `protocols` when the
+/// class already conforms, also through a superclass. The inheritance clause is checked too, so that
+/// `expand`, which passes every declared conformance, gives the same result for a class that spells
+/// out its own conformance.
+///
+/// A module or shared object is called from more than one thread: `.withAsync` runs a function on
+/// the concurrent thread pool, and native code calls events and closures from any thread. The class
+/// can't be checked `Sendable`, because `Module` and `SharedObject` aren't `Sendable`, so
+/// `@unchecked Sendable` is the only conformance it can have.
+internal func uncheckedSendableExtension(
+  for type: some TypeSyntaxProtocol,
+  of declaration: some DeclGroupSyntax,
+  conformingTo protocols: [TypeSyntax]
+) -> ExtensionDeclSyntax? {
+  guard protocols.contains(where: { $0.trimmedDescription == "Sendable" }) else {
+    return nil
+  }
+  let inherited = declaration.inheritanceClause?.inheritedTypes ?? []
+  if inherited.contains(where: { isSendable($0.type) }) {
+    return nil
+  }
+  let conformance: DeclSyntax = "extension \(type.trimmed): @unchecked Sendable {}"
+  return conformance.cast(ExtensionDeclSyntax.self)
+}
+
+/// Whether an inherited type is `Sendable`, with or without attributes such as `@unchecked`.
+private func isSendable(_ type: TypeSyntax) -> Bool {
+  if let attributed = type.as(AttributedTypeSyntax.self) {
+    return isSendable(attributed.baseType)
+  }
+  return baseIdentifier(of: type) == "Sendable"
+}

package/build/types.d.ts

@@ -281,16 +281,24 @@ export interface ExportedSharedObject extends ExportedAccess, ExportedAvailabili
      * which every JS object inherits.
      */
     initializer?: ExportedInitializer;
-    /** What the class inherits from `SharedRef<T>`, or absent when its superclass isn't `SharedRef`. */
+    /**
+     * What the class inherits from `SharedRef<T>`, directly or through another scanned `@SharedObject`
+     * class, or absent when it doesn't inherit `SharedRef`.
+     */
     sharedRef?: ExportedSharedRef;
+    /**
+     * The class's `@JS` members include the ones it inherits from scanned `@SharedObject` superclasses,
+     * the inherited ones first. An own member replaces an inherited one with the same JS name.
+     */
     functions: ExportedFunction[];
     properties: ExportedProperty[];
     events: ExportedEvent[];
     file: string;
 }
 /**
- * The `SharedRef<T>` superclass of a shared object. Only the superclass written on the class is read,
- * so a class that inherits `SharedRef` through another subclass has none.
+ * The `SharedRef<T>` superclass of a shared object. A class that inherits `SharedRef` through another
+ * `@SharedObject` class reports the `T` of that class. A class that inherits it through a class the
+ * scan doesn't report has none.
  */
 export interface ExportedSharedRef {
     /** The `T` in `SharedRef<T>`: the native type the object holds, which JS never sees. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-modules-macros",
-  "version": "0.27.1",
+  "version": "0.28.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.27.1",
-    "@expo/modules-macros-linux-x64": "0.27.1",
-    "@expo/modules-macros-win32-arm64": "0.27.1",
-    "@expo/modules-macros-win32-x64": "0.27.1"
+    "@expo/modules-macros-linux-arm64": "0.28.0",
+    "@expo/modules-macros-linux-x64": "0.28.0",
+    "@expo/modules-macros-win32-arm64": "0.28.0",
+    "@expo/modules-macros-win32-x64": "0.28.0"
   }
 }