expo-modules-macros 0.27.1 → 0.29.0

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/main.swift

@@ -0,0 +1,6 @@
+import ExpoModulesMacrosCore
+
+// The plugin executable that SwiftPM builds for the packages that depend on the
+// `ExpoModulesMacrosPlugin` product. It only serves the macros, so it doesn't link the CLI; the
+// binary that this package ships is `ExpoModulesMacrosTool`, which does both.
+try runPluginServer()

package/apple/Sources/{ExpoModulesMacros → ExpoModulesMacrosCore}/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 → ExpoModulesMacrosCore}/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 → ExpoModulesMacrosCore}/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 → ExpoModulesMacrosCore}/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/ExpoModulesMacrosCore/PluginServer.swift

@@ -0,0 +1,40 @@
+@_spi(PluginMessage) import SwiftCompilerPluginMessageHandling
+import SwiftSyntaxMacros
+
+/// The module name that `expo-modules-core` passes to `#externalMacro`, and the name of the macro
+/// target that SwiftPM loads as the plugin.
+private let pluginModuleName = "ExpoModulesMacros"
+
+/// Runs the compiler plugin server on stdin and stdout until the compiler closes the connection.
+///
+/// `CompilerPlugin.main()` finds a macro by comparing `String(reflecting:)` of each type with
+/// `<module>.<type>` from `#externalMacro`. The macro types live in this module, not in a module
+/// named `ExpoModulesMacros`, so both executables that serve the plugin (the SwiftPM macro target and
+/// the shipped tool) use this provider, which matches the type name under the plugin module name.
+public func runPluginServer() throws {
+  let connection = try StandardIOMessageConnection()
+  let listener = CompilerPluginMessageListener(connection: connection, provider: ProvidedMacroProvider())
+  try listener.main()
+}
+
+private struct ProvidedMacroProvider: PluginProvider {
+  let macros: [String: Macro.Type] = Dictionary(
+    uniqueKeysWithValues: ProvidedMacro.all.map { (String(describing: $0.type), $0.type) }
+  )
+
+  func resolveMacro(moduleName: String, typeName: String) throws -> Macro.Type {
+    guard moduleName == pluginModuleName, let type = macros[typeName] else {
+      throw UnknownMacroError(moduleName: moduleName, typeName: typeName)
+    }
+    return type
+  }
+}
+
+private struct UnknownMacroError: Error, CustomStringConvertible {
+  let moduleName: String
+  let typeName: String
+
+  var description: String {
+    "macro implementation type '\(moduleName).\(typeName)' could not be found in the Expo Modules macro plugin"
+  }
+}

package/apple/Sources/{ExpoModulesMacros → ExpoModulesMacrosCore}/ProvidedMacros.swift

@@ -3,21 +3,21 @@ import SwiftSyntaxMacros
 
 /// A macro that the plugin provides, with the attribute name and the extension conformances of its
 /// declaration in `expo-modules-core`.
-struct ProvidedMacro {
-  let name: String
-  let type: Macro.Type
-  var conformances: [TypeSyntax] = []
+public struct ProvidedMacro {
+  public let name: String
+  public let type: Macro.Type
+  public var conformances: [TypeSyntax] = []
 
   /// Every macro of the plugin. The compiler gets the types from `providingMacros`, and `expand`
   /// matches the attributes by name and passes the same conformances as the compiler, so both read
   /// this list.
-  static var all: [ProvidedMacro] {
+  public static var all: [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 → ExpoModulesMacrosCore}/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 → ExpoModulesMacrosCore}/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 → ExpoModulesMacrosCore}/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.
@@ -525,7 +524,7 @@ internal func encodeCall(_ type: String, freeForm: FreeFormConversion?, of value
 /// `name` without the backticks that escape it: `` `default` `` becomes `default`. Swift needs the
 /// backticks in every identifier position, but a name JavaScript sees (a JS member name, an event
 /// name, a record key) is the bare name.
-internal func withoutBackticks(_ name: String) -> String {
+public func withoutBackticks(_ name: String) -> String {
   var name = Substring(name)
   while name.first == "`" {
     name.removeFirst()