expo-modules-macros 0.29.0 → 0.31.0

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

@@ -32,12 +32,12 @@ import SwiftSyntaxMacros
 /// also self-contained: `@ExpoModule`/`@SharedObject` neither collect `@Event` members nor register
 /// their names anywhere.
 ///
-/// `@Event(sync: true)` opts into **synchronous dispatch**: the closure calls `emitSync` (inline
-/// conversion + dispatch, no scheduling) instead of `emit`, and `@ExpoModule`/`@SharedObject` stamp
-/// the member `@JavaScriptActor` so the compiler forces the call site onto the JS thread, the
-/// inverse of the async default. The isolation is on the property access, so it guards the inline
-/// `self.onTick(…)` usage; a closure stored or handed off escapes it, after which `emitSync` runs
-/// wherever the caller invokes it.
+/// Two options change how the event is dispatched, and each one calls its own `EventEmitter` method,
+/// which is callable from any thread as well:
+/// - `@Event(.inline)` calls `emitInline`: on the JS thread the listeners run before the call
+///   returns; on any other thread the event is scheduled, the same as `emit`. It never blocks.
+/// - `@Event(.blocking)` calls `emitBlocking`: the listeners run before the call returns on any
+///   thread, so a call from another thread blocks until the JS thread runs them.
 ///
 /// As a **peer**, the macro emits a never-called conformance assertion (see
 /// `TypeConformanceAssertion.swift`) checking that the payload type is JS-convertible and that the
@@ -51,11 +51,10 @@ public struct EventMacro: AccessorMacro {
   ) throws -> [AccessorDeclSyntax] {
     let event = try validatedEvent(of: node, on: declaration)
     // The closure's parameter and return types are inferred from the property's declared type
-    // through the getter, so the body never has to spell the payload type. A sync event calls
-    // `emitSync` (inline dispatch, JS thread only); the default calls the scheduling `emit`.
-    // A payload that holds a tuple can't conform to the payload protocols, so it's passed with a
-    // closure that encodes it.
-    let emitMethod = event.isSync ? "emitSync" : "emit"
+    // through the getter, so the body never has to spell the payload type. The dispatch option
+    // picks the `EventEmitter` method. A payload that holds a tuple can't conform to the payload
+    // protocols, so it's passed with a closure that encodes it.
+    let emitMethod = event.dispatch.emitMethod
     let closure: String
     if let tuple = event.payloadType.flatMap({ tupleConversion(of: $0) }) {
       let encode = encoderClosure(encoding: tuple.encodeCall(of: "value", into: "slot"))
@@ -96,9 +95,13 @@ extension EventMacro: PeerMacro {
     //
     // A payload that holds a tuple is encoded element by element (see `TupleConversion`), so the types
     // in it are asserted `JavaScriptEncodable`, which the encode closure needs, in its place.
+    // `emitInline` and `emitBlocking` take only `JavaScriptEncodable` payloads, so with those options
+    // the payload is asserted `JavaScriptEncodable` too.
     let name = event.swiftName
     let tupleElementTypes = event.payloadType.flatMap { tupleConversion(of: $0)?.conformingTypes }
-    let payloadConstraint = tupleElementTypes == nil ? jsConvertibleProtocolName : javaScriptEncodableProtocolName
+    let payloadConstraint =
+      tupleElementTypes == nil && event.dispatch == .scheduled
+      ? jsConvertibleProtocolName : javaScriptEncodableProtocolName
     let payloads =
       tupleElementTypes.map { distinctAssertableTypes($0, constraint: payloadConstraint) }
       ?? event.payloadType.flatMap { assertableBoundaryType($0, constraint: payloadConstraint) }.map { [$0] } ?? []
@@ -127,8 +130,8 @@ private struct EventMember {
   let jsName: String
   /// The payload type as written, or `nil` for a no-payload `() -> Void` event.
   let payloadType: String?
-  /// Whether the event dispatches synchronously (`@Event(sync: true)`) via `emitSync`.
-  let isSync: Bool
+  /// How the event is dispatched, from the `.inline` or `.blocking` option.
+  let dispatch: EventDispatch
 
   var hasPayload: Bool {
     return payloadType != nil
@@ -208,14 +211,88 @@ private func validatedEvent(
   }
 
   let swiftName = identifier.identifier.text
+  let dispatch = try eventDispatch(of: node)
   return EventMember(
     swiftName: swiftName,
     jsName: jsNameArgument(of: node) ?? defaultEventName(for: withoutBackticks(swiftName)),
     payloadType: functionType.parameters.first?.type.trimmedDescription,
-    isSync: boolArgument(of: node, label: "sync") == true
+    dispatch: dispatch
   )
 }
 
+/// How an `@Event` is dispatched to JavaScript, picked by its option.
+private enum EventDispatch {
+  case scheduled
+  case inline
+  case blocking
+
+  var emitMethod: String {
+    switch self {
+    case .scheduled:
+      return "emit"
+    case .inline:
+      return "emitInline"
+    case .blocking:
+      return "emitBlocking"
+    }
+  }
+}
+
+/// Reads the dispatch option of an `@Event` attribute. `.inline` and `.blocking` exclude each other.
+private func eventDispatch(of node: AttributeSyntax) throws -> EventDispatch {
+  let isInline = hasOption(node, named: "inline")
+  let isBlocking = hasOption(node, named: "blocking")
+  if isInline && isBlocking {
+    throw conflictingOptionsDiagnostic(in: node)
+  }
+  if isInline {
+    return .inline
+  }
+  if isBlocking {
+    return .blocking
+  }
+  return .scheduled
+}
+
+/// The error for `@Event(.inline, .blocking)`, with a single Fix-It that removes the option written
+/// last. One Fix-It (rather than one for each option) lets the `fix` command apply it, since it skips
+/// a diagnostic with alternatives.
+private func conflictingOptionsDiagnostic(in node: AttributeSyntax) -> DiagnosticsError {
+  let message = EventDiagnosticMessage(
+    "@Event can't be both '.inline' and '.blocking'; '.blocking' also runs the listeners inline on the JS thread, so remove one of the options",
+    id: "event-conflicting-options"
+  )
+  guard let arguments = node.arguments?.as(LabeledExprListSyntax.self),
+    let index = arguments.lastIndex(where: { isDispatchOption($0.expression) })
+  else {
+    return DiagnosticsError(diagnostics: [Diagnostic(node: node, message: message)])
+  }
+  let removed = arguments[index]
+  var remaining = Array(arguments)
+  remaining.removeAll { $0.id == removed.id }
+  // The argument before the removed one keeps its comma only when another argument follows it.
+  if let last = remaining.indices.last {
+    remaining[last] = remaining[last].with(\.trailingComma, nil)
+  }
+  let optionName = removed.expression.as(MemberAccessExprSyntax.self)?.declName.baseName.text ?? "option"
+  let fixIt = FixIt(
+    message: EventFixItMessage("Remove '.\(optionName)'", id: "event-remove-option"),
+    changes: [
+      .replace(oldNode: Syntax(arguments), newNode: Syntax(LabeledExprListSyntax(remaining)))
+    ]
+  )
+  return DiagnosticsError(diagnostics: [Diagnostic(node: node, message: message, fixIts: [fixIt])])
+}
+
+/// True when the expression is the `.inline` or `.blocking` option (or `EventOptions.<option>`).
+private func isDispatchOption(_ expression: ExprSyntax) -> Bool {
+  guard let member = expression.as(MemberAccessExprSyntax.self) else {
+    return false
+  }
+  let name = member.declName.baseName.text
+  return name == "inline" || name == "blocking"
+}
+
 // MARK: - Default event name
 
 /// The default JS event name for a property: the Swift name with the conventional `on` prefix

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

@@ -38,6 +38,13 @@ public struct ExpoModuleMacro: MemberMacro {
     guard let classDecl = declaration.as(ClassDeclSyntax.self) else {
       throw MacroExpansionErrorMessage("@ExpoModule can only be applied to a class")
     }
+    diagnoseNonPublicClass(
+      classDecl,
+      macroName: "@ExpoModule",
+      reason: "register it",
+      idPrefix: "expomodule",
+      in: context
+    )
 
     // The module name is fully resolved here (the explicit `@ExpoModule("…")` argument, else the
     // class name) and emitted as a non-optional `_jsName` static below — so the
@@ -160,10 +167,7 @@ extension ExpoModuleMacro: MemberAttributeMacro {
     // checked at compile time. Skipped when the member already chose an isolation
     // (`nonisolated` or another global actor), or when `.concurrent` or `.withAsync("name")` runs
     // it on the concurrent pool. See `shouldStampJavaScriptActor`.
-    // `@Event(sync: true)` members get the stamp too: a sync event dispatches inline, so the
-    // isolation forces its call site onto the JS thread. Async events (the default) are
-    // deliberately left unstamped — their `emit` schedules onto the JS thread itself.
-    if memberHasJSAttribute(member) || isSyncEventMember(member),
+    if memberHasJSAttribute(member),
       shouldStampJavaScriptActor(on: member, enclosedBy: declaration)
     {
       attributes.append("@JavaScriptActor")

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

@@ -36,6 +36,7 @@ public struct JSMacro: PeerMacro {
     diagnoseClosureTypes(in: declaration, in: context)
     diagnoseConcurrentOption(of: node, on: declaration, in: context)
     diagnoseAsyncVariantOption(of: node, on: declaration, in: context)
+    diagnoseJavaScriptValuesOffThread(of: node, on: declaration, in: context)
 
     // In an `@ExpoModule` or `@SharedObject` class, the class macro emits the assertion instead: it sees
     // the type aliases declared in the class body, which this macro can't (see `TupleTypeAliases`).
@@ -83,7 +84,7 @@ private func diagnoseConcurrentOption(
   on declaration: some DeclSyntaxProtocol,
   in context: some MacroExpansionContext
 ) {
-  guard hasJSOption(node, named: "concurrent") else {
+  guard hasOption(node, named: "concurrent") else {
     return
   }
   if let funcDecl = declaration.as(FunctionDeclSyntax.self) {
@@ -248,6 +249,58 @@ private func insertAsyncFixIt(for funcDecl: FunctionDeclSyntax) -> FixIt {
 /// `consuming`, `sending`) are fine: the binding passes the decoded value under whichever convention
 /// the parameter asks for. The specifier is left off the decode and the assertion (see
 /// `SpecifiedType`); a parameter reported here is also left out of the assertion.
+/// The JSI types that own an engine value and release it wherever they are dropped. Such a value is
+/// valid only on the JavaScript thread. `JavaScriptPromise` releases its value on the JavaScript
+/// thread, and `JavaScriptRef` and `JavaScriptCallback` exist to carry a value across threads, so they
+/// aren't listed.
+private let javaScriptThreadBoundTypes: Set<String> = [
+  "JavaScriptValue", "JavaScriptObject", "JavaScriptFunction", "JavaScriptArray", "JavaScriptArrayBuffer",
+  "JavaScriptTypedArray", "JavaScriptBigInt", "JavaScriptWeakObject",
+]
+
+/// Emits the diagnostic for a JSI value parameter of a `@JS(.concurrent)` function or of the variant
+/// that `@JS(.withAsync("name"))` adds. Both run the body on the concurrent thread pool, never on the
+/// JavaScript thread, so the body can't use the value, and the value is released off the JavaScript
+/// thread too.
+private func diagnoseJavaScriptValuesOffThread(
+  of node: AttributeSyntax,
+  on declaration: some DeclSyntaxProtocol,
+  in context: some MacroExpansionContext
+) {
+  guard let funcDecl = declaration.as(FunctionDeclSyntax.self) else {
+    return
+  }
+  let option: String
+  let reason: String
+  if hasOption(node, named: "concurrent") {
+    option = ".concurrent"
+    reason = "'.concurrent' runs the body on the concurrent thread pool"
+  } else if asyncVariantOption(of: node) != nil {
+    option = ".withAsync"
+    reason = "the variant that '.withAsync' adds runs the function on the concurrent thread pool"
+  } else {
+    return
+  }
+  for parameter in funcDecl.signature.parameterClause.parameters {
+    let type = SpecifiedType(parameter.type).type
+    guard let name = baseIdentifier(of: optionalWrappedType(type) ?? type), javaScriptThreadBoundTypes.contains(name)
+    else {
+      continue
+    }
+    let parameterName = (parameter.secondName ?? parameter.firstName).text
+    context.diagnose(
+      Diagnostic(
+        node: parameter.type,
+        message: JSDiagnosticMessage(
+          "'\(parameterName)' can't be a '\(name)' in a '\(option)' function: \(reason), and a JavaScript value is valid only on the JavaScript thread. Take a native type that the value decodes to, such as a @Record or [String: Any], or remove '\(option)'.",
+          id: "js-javascript-value-off-thread",
+          severity: .error
+        )
+      )
+    )
+  }
+}
+
 private func diagnoseParameterSpecifiers(
   in declaration: some DeclSyntaxProtocol,
   in context: some MacroExpansionContext

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

@@ -8,7 +8,7 @@ import SwiftSyntaxMacros
 /// is emitted as a `_jsName` override.
 ///
 ///   @SharedObject
-///   final class Cache: SharedObject {
+///   public final class Cache: SharedObject {
 ///     @JS
 ///     init(name: String) { self.name = name }
 ///
@@ -34,6 +34,13 @@ public struct SharedObjectMacro: MemberMacro {
     guard let classDecl = declaration.as(ClassDeclSyntax.self) else {
       throw MacroExpansionErrorMessage("@SharedObject can only be applied to a class")
     }
+    diagnoseNonPublicClass(
+      classDecl,
+      macroName: "@SharedObject",
+      reason: "export it",
+      idPrefix: "sharedobject",
+      in: context
+    )
 
     // The superclass isn't checked here: the macro sees only this declaration, so it can't tell an
     // indirect subclass (`class Thumbnail: ImageRef`) from an unrelated class. The compiler reports a
@@ -164,10 +171,7 @@ extension SharedObjectMacro: MemberAttributeMacro {
     providingAttributesFor member: some DeclSyntaxProtocol,
     in context: some MacroExpansionContext
   ) throws -> [AttributeSyntax] {
-    // `@Event(sync: true)` members are stamped alongside `@JS` ones: a sync event dispatches
-    // inline, so the isolation forces its call site onto the JS thread. Async events (the
-    // default) stay unstamped — their `emit` schedules onto the JS thread itself.
-    guard memberHasJSAttribute(member) || isSyncEventMember(member) else {
+    guard memberHasJSAttribute(member) else {
       return []
     }
     // `@JS(.concurrent)` opts the member out of the JS-thread stamp and onto the concurrent pool.

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

@@ -134,36 +134,71 @@ private let maxValueProps = 64
 /// The error for a leftover `@Field`, attached to the attribute itself and carrying a fix-it that
 /// deletes it. `@ViewProps` treats every stored property as a prop, so the attribute has no meaning
 /// here; left in place it would wrap the value in `Field<T>` and the props type would decode against
-/// the wrong type.
+/// the wrong type. A `@Field` with arguments, such as `@Field(.keyed("borderColor"))`, gets no
+/// fix-it: they can set the prop name, which removing the attribute would change silently, so the
+/// message tells the author to rename the property.
 private func fieldAttributeDiagnostic(
   for attribute: AttributeSyntax,
   on varDecl: VariableDeclSyntax
 ) -> Diagnostic {
-  // Rebuild the attribute list without this entry, so the fix-it removes the attribute and the
-  // trivia it carried rather than leaving a blank line behind.
-  var attributes = varDecl.attributes
-  if let index = attributes.firstIndex(where: { element in
+  // The token after the attribute takes over the trivia of the attribute: the line break,
+  // indentation and comments before it, and the comments after it. Its own leading whitespace is
+  // left out unless a comment comes before it, so `@Field var size` and `@Field` on its own line both
+  // become `var size` on the line of the attribute, and `@Field // note` keeps the line break after
+  // the comment.
+  var newDecl = varDecl
+  if let next = attribute.lastToken(viewMode: .sourceAccurate)?.nextToken(viewMode: .sourceAccurate) {
+    let comments = Trivia(pieces: attribute.trailingTrivia.pieces.drop(while: \.isWhitespace))
+    let nextTrivia =
+      comments.isEmpty ? Trivia(pieces: next.leadingTrivia.pieces.drop(while: \.isWhitespace)) : next.leadingTrivia
+    newDecl =
+      LeadingTriviaRewriter(token: next.id, trivia: attribute.leadingTrivia + comments + nextTrivia)
+      .rewrite(varDecl).cast(VariableDeclSyntax.self)
+  }
+  // Then remove the attribute with its trivia, so it doesn't leave a blank line behind. The rewritten
+  // declaration is a new tree, so the attribute is found by its place in the list.
+  if let index = varDecl.attributes.firstIndex(where: { element in
     guard case .attribute(let candidate) = element else {
       return false
     }
     return candidate == attribute
   }) {
-    attributes.remove(at: index)
+    let offset = varDecl.attributes.distance(from: varDecl.attributes.startIndex, to: index)
+    newDecl.attributes.remove(at: newDecl.attributes.index(newDecl.attributes.startIndex, offsetBy: offset))
   }
   let fixIt = FixIt(
     message: ViewPropsFixItMessage("Remove the '@Field' attribute", id: "viewprops-remove-field"),
     changes: [
       .replace(
         oldNode: Syntax(varDecl),
-        newNode: Syntax(varDecl.with(\.attributes, attributes))
+        newNode: Syntax(newDecl)
       )
     ]
   )
+  let hasArguments = attribute.arguments?.as(LabeledExprListSyntax.self)?.isEmpty == false
   let message = ViewPropsDiagnosticMessage(
-    "@Field is no longer used — @ViewProps treats every stored property as a prop. Remove the @Field attribute",
+    hasArguments
+      ? "@Field is no longer used: @ViewProps treats every stored property as a prop, named after the property. Remove the @Field attribute, and rename the property if its arguments set another prop name"
+      : "@Field is no longer used: @ViewProps treats every stored property as a prop. Remove the @Field attribute",
     id: "viewprops-field-attribute"
   )
-  return Diagnostic(node: attribute, message: message, fixIts: [fixIt])
+  return Diagnostic(node: attribute, message: message, fixIts: hasArguments ? [] : [fixIt])
+}
+
+/// Replaces the leading trivia of one token.
+private final class LeadingTriviaRewriter: SyntaxRewriter {
+  private let token: SyntaxIdentifier
+  private let trivia: Trivia
+
+  init(token: SyntaxIdentifier, trivia: Trivia) {
+    self.token = token
+    self.trivia = trivia
+    super.init(viewMode: .sourceAccurate)
+  }
+
+  override func visit(_ token: TokenSyntax) -> TokenSyntax {
+    token.id == self.token ? token.with(\.leadingTrivia, trivia) : token
+  }
 }
 
 /// The error for an optional event prop, attached to the declared type and carrying a fix-it that
@@ -281,6 +316,22 @@ private func validatedViewProps(of declaration: some DeclGroupSyntax) throws ->
     )
   }
 
+  // `@Field` is the v1 property wrapper and has no meaning here — every stored property is already
+  // part of the surface. Left in place it would wrap the value in `Field<T>`, so the props type
+  // would decode against the wrong type. Flag every one rather than emit code built on them, all at
+  // once, so a `@Field` without a fix-it doesn't hide the fix-its of the others.
+  let fieldDiagnostics = declaration.memberBlock.members.compactMap { member -> Diagnostic? in
+    guard let varDecl = member.decl.as(VariableDeclSyntax.self), !isExcludedByModifier(varDecl.modifiers),
+      let fieldAttribute = varDecl.attributes.firstAttribute(named: "Field")
+    else {
+      return nil
+    }
+    return fieldAttributeDiagnostic(for: fieldAttribute, on: varDecl)
+  }
+  if !fieldDiagnostics.isEmpty {
+    throw DiagnosticsError(diagnostics: fieldDiagnostics)
+  }
+
   var valueProps: [ViewProp] = []
   var eventProps: [ViewProp] = []
 
@@ -291,13 +342,6 @@ private func validatedViewProps(of declaration: some DeclGroupSyntax) throws ->
     if isExcludedByModifier(varDecl.modifiers) {
       continue
     }
-    // `@Field` is the v1 property wrapper and has no meaning here — every stored property is already
-    // part of the surface. Left in place it would wrap the value in `Field<T>`, so the props type
-    // would decode against the wrong type. Flag it rather than emit code built on it.
-    if let fieldAttribute = varDecl.attributes.firstAttribute(named: "Field") {
-      throw DiagnosticsError(diagnostics: [fieldAttributeDiagnostic(for: fieldAttribute, on: varDecl)])
-    }
-
     for binding in varDecl.bindings {
       // A computed property is never a prop, but an accessor block alone doesn't mean computed:
       // `willSet`/`didSet` observers imply stored storage. `bindingIsSettable` draws exactly that

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

@@ -13,26 +13,12 @@ internal func jsNameArgument(of attribute: AttributeSyntax) -> String? {
   return segment.content.text
 }
 
-/// Reads a labeled boolean-literal argument of an attribute, e.g. `@Event(sync: true)` -> true.
-/// Returns nil if the attribute has no argument with that label or its value isn't a boolean literal.
-internal func boolArgument(of attribute: AttributeSyntax, label: String) -> Bool? {
-  guard let args = attribute.arguments?.as(LabeledExprListSyntax.self) else {
-    return nil
-  }
-  for arg in args where arg.label?.text == label {
-    guard let literal = arg.expression.as(BooleanLiteralExprSyntax.self) else {
-      return nil
-    }
-    return literal.literal.tokenKind == .keyword(.true)
-  }
-  return nil
-}
-
-/// True if the attribute lists the given `JSOptions` member, e.g. `@JS(.concurrent)` or
-/// `@JS("name", [.concurrent])` -> true for "concurrent". Options are written as member-access
-/// expressions (`.concurrent`), optionally inside an array literal when more than one is combined, so
-/// both spellings are scanned. The leading string literal, when present, is the JS name and is skipped.
-internal func hasJSOption(_ attribute: AttributeSyntax, named option: String) -> Bool {
+/// True if the attribute lists the given option member, e.g. `@JS(.concurrent)`, `@Event(.inline)` or
+/// `@Event("name", EventOptions.inline)` -> true for the matching name. Options are written as
+/// member-access expressions, one per variadic argument. Array literals are scanned too, though the
+/// variadic declarations in `expo-modules-core` don't accept them. The leading string literal, when
+/// present, is the JS name and is skipped.
+internal func hasOption(_ attribute: AttributeSyntax, named option: String) -> Bool {
   guard let args = attribute.arguments?.as(LabeledExprListSyntax.self) else {
     return false
   }
@@ -49,7 +35,7 @@ internal func hasJSOption(_ attribute: AttributeSyntax, named option: String) ->
   return false
 }
 
-/// True when the expression is the member access `.<option>` (or `JSOptions.<option>`).
+/// True when the expression is the member access `.<option>` (or `JSOptions.<option>`, `EventOptions.<option>`).
 private func namesOption(_ expression: ExprSyntax, _ option: String) -> Bool {
   guard let member = expression.as(MemberAccessExprSyntax.self) else {
     return false
@@ -64,7 +50,7 @@ internal func isConcurrentJSMember(_ decl: DeclSyntaxProtocol) -> Bool {
   guard let attribute = memberAttributes(of: decl).firstAttribute(named: "JS") else {
     return false
   }
-  return hasJSOption(attribute, named: "concurrent")
+  return hasOption(attribute, named: "concurrent")
 }
 
 /// The `.withAsync("name")` option of a `@JS` attribute, e.g. `@JS(.withAsync("loadAsync"))` or
@@ -74,7 +60,7 @@ internal func asyncVariantOption(of attribute: AttributeSyntax) -> FunctionCallE
   return asyncVariantOptions(of: attribute).first
 }
 
-/// Every `.withAsync(...)` option of a `@JS` attribute, in source order. Like `hasJSOption`, it scans
+/// Every `.withAsync(...)` option of a `@JS` attribute, in source order. Like `hasOption`, it scans
 /// the arguments and the elements of an array literal.
 internal func asyncVariantOptions(of attribute: AttributeSyntax) -> [FunctionCallExprSyntax] {
   guard let args = attribute.arguments?.as(LabeledExprListSyntax.self) else {
@@ -290,20 +276,6 @@ internal func hasDefaultValue(_ parameter: FunctionParameterSyntax) -> Bool {
   return parameter.defaultValue != nil
 }
 
-/// True if the declaration is a `@Event(sync: true)` property. A sync event dispatches inline on the
-/// JS thread instead of scheduling, so `@ExpoModule`/`@SharedObject` stamp it with `@JavaScriptActor`,
-/// making "must be called on the JS thread" a compile-time guarantee at the call site. Async events
-/// (the default) are deliberately not stamped: their `emit` schedules onto the JS thread itself, so
-/// they stay callable from any thread.
-internal func isSyncEventMember(_ decl: DeclSyntaxProtocol) -> Bool {
-  guard let varDecl = decl.as(VariableDeclSyntax.self),
-    let attribute = varDecl.attributes.firstAttribute(named: "Event")
-  else {
-    return false
-  }
-  return boolArgument(of: attribute, label: "sync") == true
-}
-
 /// Reads a labeled array-literal argument of an attribute, e.g. `@ExpoModule(classes: [Foo.self, Bar.self])`,
 /// and returns the type names referenced (e.g. `["Foo", "Bar"]`). Each element must be a
 /// `<TypeName>.self` member-access expression; non-conforming elements are skipped silently.

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

@@ -0,0 +1,105 @@
+import SwiftDiagnostics
+import SwiftSyntax
+import SwiftSyntaxMacros
+
+/// Warns when a class that autolinking exports isn't `public` or `open`. Autolinking generates the modules
+/// provider in the app target, so it can reference only public classes of other modules. The warning has a
+/// fix-it that makes the class `public`. A local class is skipped, because it can't have an access modifier.
+internal func diagnoseNonPublicClass(
+  _ classDecl: ClassDeclSyntax,
+  macroName: String,
+  reason: String,
+  idPrefix: String,
+  in context: some MacroExpansionContext
+) {
+  guard !isLocal(context: context) else {
+    return
+  }
+  let accessModifier = classDecl.modifiers.first { accessLevelKeywords.contains($0.name.tokenKind) }
+  if let accessModifier,
+    [.keyword(.public), .keyword(.open)].contains(accessModifier.name.tokenKind)
+  {
+    return
+  }
+  let name = classDecl.name.text
+  context.diagnose(
+    Diagnostic(
+      node: accessModifier.map(Syntax.init) ?? Syntax(classDecl.classKeyword),
+      message: PublicAccessDiagnosticMessage(
+        "\(macroName) class '\(name)' should be public or open, so that the modules provider that autolinking generates in the app target can \(reason)",
+        id: "\(idPrefix)-class-not-public"
+      ),
+      fixIts: [makePublicFixIt(for: classDecl, replacing: accessModifier, idPrefix: idPrefix)]
+    )
+  )
+}
+
+private let accessLevelKeywords: [TokenKind] = [
+  .keyword(.open), .keyword(.public), .keyword(.package), .keyword(.internal), .keyword(.fileprivate),
+  .keyword(.private),
+]
+
+/// True when the declaration is inside a function, closure or another scope that isn't a type or an extension.
+private func isLocal(context: some MacroExpansionContext) -> Bool {
+  return context.lexicalContext.contains { node in
+    return !node.is(ClassDeclSyntax.self) && !node.is(StructDeclSyntax.self) && !node.is(EnumDeclSyntax.self)
+      && !node.is(ActorDeclSyntax.self) && !node.is(ExtensionDeclSyntax.self)
+  }
+}
+
+/// The fix-it for a class that isn't public: replace its access modifier with `public`, or add `public` before
+/// its other modifiers.
+private func makePublicFixIt(
+  for classDecl: ClassDeclSyntax,
+  replacing accessModifier: DeclModifierSyntax?,
+  idPrefix: String
+) -> FixIt {
+  let message = PublicAccessFixItMessage("Make the class 'public'", id: "\(idPrefix)-class-insert-public")
+  if let accessModifier {
+    let newModifier = accessModifier.with(\.name, accessModifier.name.with(\.tokenKind, .keyword(.public)))
+    return FixIt(message: message, changes: [.replace(oldNode: Syntax(accessModifier), newNode: Syntax(newModifier))])
+  }
+  // The new modifier takes over the leading trivia of the first modifier or of `class` (the line break after the
+  // attribute), so it lands where the declaration started.
+  let newDecl: ClassDeclSyntax
+  if let firstModifier = classDecl.modifiers.first {
+    let publicModifier = DeclModifierSyntax(
+      name: .keyword(.public, leadingTrivia: firstModifier.leadingTrivia, trailingTrivia: .space)
+    )
+    var modifiers = classDecl.modifiers
+    modifiers[modifiers.startIndex] = firstModifier.with(\.leadingTrivia, [])
+    modifiers.insert(publicModifier, at: modifiers.startIndex)
+    newDecl = classDecl.with(\.modifiers, modifiers)
+  } else {
+    let classKeyword = classDecl.classKeyword
+    let publicModifier = DeclModifierSyntax(
+      name: .keyword(.public, leadingTrivia: classKeyword.leadingTrivia, trailingTrivia: .space)
+    )
+    newDecl =
+      classDecl
+      .with(\.modifiers, [publicModifier])
+      .with(\.classKeyword, classKeyword.with(\.leadingTrivia, []))
+  }
+  return FixIt(message: message, changes: [.replace(oldNode: Syntax(classDecl), newNode: Syntax(newDecl))])
+}
+
+private struct PublicAccessDiagnosticMessage: DiagnosticMessage {
+  let message: String
+  let diagnosticID: MessageID
+  let severity: DiagnosticSeverity = .warning
+
+  init(_ message: String, id: String) {
+    self.message = message
+    self.diagnosticID = MessageID(domain: "ExpoModulesMacros", id: id)
+  }
+}
+
+private struct PublicAccessFixItMessage: FixItMessage {
+  let message: String
+  let fixItID: MessageID
+
+  init(_ message: String, id: String) {
+    self.message = message
+    self.fixItID = MessageID(domain: "ExpoModulesMacros", id: id)
+  }
+}

package/build/types.d.ts

@@ -260,8 +260,8 @@ export interface ExportedEvent extends ExportedAccess, ExportedAvailability {
     jsName: string;
     /** The payload type, absent for a no-payload `() -> Void` event. */
     payload?: TypeNode;
-    /** `@Event(sync: true)`, dispatching inline on the JS thread instead of scheduling. */
-    sync: boolean;
+    /** How the event is dispatched: the default `scheduled`, or the `.inline` or `.blocking` option. */
+    dispatch: 'scheduled' | 'inline' | 'blocking';
 }
 /** The `@JS init` of a shared object: the constructor JS calls with `new`. */
 export interface ExportedInitializer extends ExportedAccess, ExportedAvailability {
@@ -391,10 +391,16 @@ export interface ScanStats {
     /** Wall-clock duration of the scan, in milliseconds. */
     durationMs: number;
 }
-/** One module in the `scan-modules` output. */
-export interface ScannedModule {
+/**
+ * One class in the `scan-modules` output: an `@ExpoModule` class in `modules`, or a `@SharedObject`
+ * class in `sharedObjects`.
+ */
+export interface ScannedClass {
     name: string;
-    /** The resolved JS name: the `@ExpoModule("Foo")` override, else the class name. */
+    /**
+     * The resolved JS name: the `@ExpoModule("Foo")` or `@SharedObject("Foo")` override, else the class
+     * name.
+     */
     jsName: string;
     /**
      * The spelled access level, or `internal` when none is written. The generated provider references
@@ -403,7 +409,7 @@ export interface ScannedModule {
     accessLevel: string;
     /**
      * The OSes whose builds include this class, resolved from the enclosing `#if` conditions. An
-     * unconditional module lists every OS. Empty means no build is known to include it, so don't
+     * unconditional class lists every OS. Empty means no build is known to include it, so don't
      * register it.
      */
     platforms: ScannedPlatform[];
@@ -412,7 +418,10 @@ export interface ScannedModule {
 /** The `scan-modules` result. */
 export interface ScanModulesResult {
     schemaVersion: number;
-    modules: ScannedModule[];
+    /** The top-level `@ExpoModule` classes. */
+    modules: ScannedClass[];
+    /** The top-level `@SharedObject` classes, with the same platform rules as `modules`. */
+    sharedObjects: ScannedClass[];
     warnings: ScanWarning[];
     stats: ScanStats;
 }
@@ -471,5 +480,5 @@ export interface ExpandResult {
  * as a clear error instead of silently misread fields.
  */
 export declare const SUPPORTED_SCAN_MODULES_SCHEMA_VERSION = 2;
-export declare const SUPPORTED_SCAN_EXPORTS_SCHEMA_VERSION = 10;
+export declare const SUPPORTED_SCAN_EXPORTS_SCHEMA_VERSION = 11;
 export declare const SUPPORTED_EXPAND_SCHEMA_VERSION = 1;