expo-modules-macros 0.30.0 → 0.31.0

package/README.md

@@ -26,7 +26,7 @@ This package lists them as optional dependencies, and their `os`, `cpu` and (on
 
 - **`@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. Because of that, a `.concurrent` function and a function with `.withAsync` can't take a JavaScript value such as `JavaScriptValue` or `JavaScriptObject`, which is valid only on the JavaScript thread; the macro reports such a parameter. 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, _ options: EventOptions...)`** 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. The `.sync` option dispatches inline on the JavaScript thread instead of asynchronously, and `@ExpoModule` and `@SharedObject` isolate the property to `@JavaScriptActor`.
+- **`@Event(_ name: String? = nil, _ options: EventOptions...)`** 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. By default the event is scheduled on the JavaScript thread. The `.inline` option runs the listeners before the call returns when it is made on the JavaScript thread, and schedules the event otherwise; it never blocks. The `.blocking` option runs the listeners before the call returns on any thread, so a call from another thread blocks until the JavaScript thread runs them. An event property is callable from any thread with each option.
 - **`@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.
@@ -145,11 +145,13 @@ Each applied Fix-It is printed to stdout as `<file>:<line>:<column>: fix-it: <me
 
 `fix` applies the Fix-Its of errors and of warnings, such as "Make the class 'public'" for a module class that isn't `public`. With `--only-errors`, it applies only those of errors.
 
-- A macro can stop at its first error, so after applying the Fix-Its of a file, `fix` expands it again and applies the new ones, until none applies (at most 10 passes). The location of a Fix-It is in the file as it was when the Fix-It was applied.
-- A diagnostic with more than one Fix-It is skipped, because they are alternatives. So is a Fix-It whose edits overlap the edits of another one, or whose text isn't in the file where the edit expects it. Each skipped Fix-It is printed to stderr as a warning.
+- A macro can stop at its first error, so after applying the Fix-Its of a file, `fix` expands it again and applies the new ones, until none applies (at most 10 passes, with a warning when Fix-Its are left after them). The location of a Fix-It is in the file as it was when the Fix-It was applied.
+- A diagnostic with more than one Fix-It is skipped, because they are alternatives. So is a Fix-It whose edits overlap the edits of another one, or whose text isn't in the file where the edit expects it; an insertion is checked against the few bytes after it. Each skipped Fix-It is printed to stderr as a warning.
 - It applies only the Fix-Its of the macros, not those of syntax errors.
 - It changes only the text that a Fix-It changes and doesn't format the file. An inserted keyword can make a line longer than your formatter allows, so run your formatter after `fix` if you use one.
 
+`fix` writes a file only when it still has the contents that `fix` read, so it doesn't overwrite a change saved meanwhile. It writes the file in place, so on macOS and Linux, symbolic and hard links, permissions, the owner, extended attributes and ACLs stay, and a read-only file isn't written. When a write fails, `fix` writes the original contents back and reports whether the file is unchanged; when that fails too, it saves them to a file in the temporary directory and names it. A file that can't be written is reported, and the other files are still fixed. A UTF-8 byte order mark is kept.
+
 The exit code is `0` also when a Fix-It is skipped or errors remain, `1` when a file can't be written, and `2` for an input that `expand` doesn't take.
 
 # TypeScript wrapper

package/apple/Sources/ExpoModulesCLI/Commands/Expand/ExpandReport.swift

@@ -107,8 +107,9 @@ public struct ExpansionEdit: Equatable, Sendable {
   /// The UTF-8 offset in the original file.
   public let offset: Int
 
-  /// The text that the edit replaces, so `fix` can check that the file still has it there. Empty
-  /// for an insertion.
+  /// The text that the edit replaces, so `fix` can check that the file still has it there. An
+  /// insertion also replaces a few bytes after it with themselves, so it has text to check too, and
+  /// is empty only at the end of a declaration.
   public let original: String
 
   public let replacement: String

package/apple/Sources/ExpoModulesCLI/Commands/Expand/MacroExpander.swift

@@ -35,8 +35,10 @@ public func expandMacros(source: String, file: String, symbols: [String]) -> Exp
   let originalDeclarations = OriginalDeclarations(tree)
   diagnostics += context.diagnostics.map { diagnostic in
     let location = { (position: AbsolutePosition, node: Syntax) -> SourceLocation in
-      let declarationStart = context.location(for: node.root.position, anchoredAt: node, fileName: file).offset
-      if let original = originalDeclarations.position(of: position, in: node, declarationStart: declarationStart) {
+      let original = originalDeclarations.position(of: position, in: node) {
+        context.location(for: node.root.position, anchoredAt: node, fileName: file).offset
+      }
+      if let original {
         return converter.location(for: original)
       }
       return context.location(for: position, anchoredAt: node, fileName: file)
@@ -221,13 +223,21 @@ private func originalEdits(
   of fixIt: FixIt,
   offset: (AbsolutePosition, Syntax) -> Int
 ) -> [ExpansionEdit]? {
-  var edits: [ExpansionEdit] = []
+  // The edit of each change in the tree of its node. `FixIt.edits` drops an edit that overlaps an
+  // earlier one; this applies the same rule.
+  var changes: [(edit: SourceEdit, node: Syntax)] = []
   for change in fixIt.changes {
-    // `FixIt.edits` drops an edit that overlaps an earlier one; this applies the same rule.
     guard let edit = FixIt(message: fixIt.message, changes: [change]).edits.first else {
       continue
     }
     let node = changedNode(change)
+    if !changes.contains(where: { $0.node.root.id == node.root.id && $0.edit.range.overlaps(edit.range) }) {
+      changes.append((edit, node))
+    }
+  }
+
+  var edits: [ExpansionEdit] = []
+  for (index, (edit, node)) in changes.enumerated() {
     let root = node.root
     let text = Array(root.description.utf8)
     let start = edit.range.lowerBound.utf8Offset - root.position.utf8Offset
@@ -241,19 +251,36 @@ private func originalEdits(
     guard prefix + suffix < max(old.count, new.count) else {
       continue
     }
-    let changedStart = edit.range.lowerBound.advanced(by: prefix)
-    let originalEdit = ExpansionEdit(
-      offset: offset(changedStart, node),
-      original: String(decoding: old.dropFirst(prefix).dropLast(suffix), as: UTF8.self),
-      replacement: String(decoding: new.dropFirst(prefix).dropLast(suffix), as: UTF8.self)
-    )
-    if !edits.contains(where: { overlaps($0, originalEdit) }) {
-      edits.append(originalEdit)
+    var original = Array(old.dropFirst(prefix).dropLast(suffix))
+    var replacement = Array(new.dropFirst(prefix).dropLast(suffix))
+    if original.isEmpty {
+      // An insertion has no text that `fix` can check in the file, so it also replaces the bytes after
+      // it with themselves, up to a character boundary and not into another change of the Fix-It.
+      let insertion = start + prefix
+      let nextChange = changes.enumerated().filter { $0.offset != index && $0.element.node.root.id == root.id }
+        .map { $0.element.edit.range.lowerBound.utf8Offset - root.position.utf8Offset }
+        .filter { $0 >= insertion }.min()
+      var contextEnd = min(insertion + insertionContextLength, text.count, nextChange ?? text.count)
+      while contextEnd > insertion && contextEnd < text.count && text[contextEnd] & 0xC0 == 0x80 {
+        contextEnd -= 1
+      }
+      original = Array(text[insertion..<contextEnd])
+      replacement += original
     }
+    edits.append(
+      ExpansionEdit(
+        offset: offset(edit.range.lowerBound.advanced(by: prefix), node),
+        original: String(decoding: original, as: UTF8.self),
+        replacement: String(decoding: replacement, as: UTF8.self)
+      )
+    )
   }
   return edits
 }
 
+/// The number of bytes after an insertion that its edit also replaces with themselves.
+private let insertionContextLength = 8
+
 /// The node in the tree that `change` edits.
 private func changedNode(_ change: FixIt.Change) -> Syntax {
   switch change {
@@ -268,11 +295,6 @@ private func changedNode(_ change: FixIt.Change) -> Syntax {
   }
 }
 
-/// Whether two edits change the same bytes of the original file.
-private func overlaps(_ a: ExpansionEdit, _ b: ExpansionEdit) -> Bool {
-  a.offset < b.offset + b.original.utf8.count && b.offset < a.offset + a.original.utf8.count
-}
-
 /// The lengths of the longest common prefix and suffix of `old` and `new` that don't overlap, at
 /// character boundaries, so the bytes between them are valid UTF-8 on both sides.
 private func commonAffixLengths(_ old: [UInt8], _ new: [UInt8]) -> (prefix: Int, suffix: Int) {
@@ -320,45 +342,72 @@ private func severity(_ severity: DiagnosticSeverity) -> ExpansionDiagnostic.Sev
 /// `init`) to its end is the same in both, so this moves the position by the offset of the keyword
 /// in the original declaration. A position before the keyword, in the attributes or the modifiers,
 /// isn't mapped.
-private struct OriginalDeclarations {
+///
+/// An accessor macro can get a declaration that swift-syntax rewrote rather than detached, for
+/// example an `@Event` property with a closure in its initializer, and its start doesn't map to the
+/// file. Such a declaration is found by its text when no other declaration in the file has it.
+private final class OriginalDeclarations {
   /// The declarations in the original file by the UTF-8 offset of their start, with their leading
   /// trivia: the text from the keyword to the end of each, and the position of its keyword.
-  private let declarations: [Int: [(text: String, keyword: AbsolutePosition)]]
+  private let declarationsByStart: [Int: [(text: String, keyword: AbsolutePosition)]]
+
+  /// The positions of the keywords of the declarations in the original file, by the text from the
+  /// keyword to the end of the declaration.
+  private let keywordsByText: [String: [AbsolutePosition]]
+
+  /// The positions of the keyword of each declaration that a macro got and of its original
+  /// declaration, or `nil` when it has no original declaration.
+  private var keywords: [SyntaxIdentifier: (keyword: AbsolutePosition, original: AbsolutePosition)?] = [:]
 
   init(_ tree: SourceFileSyntax) {
     let collector = DeclarationCollector(viewMode: .sourceAccurate)
     collector.walk(tree)
-    var declarations: [Int: [(text: String, keyword: AbsolutePosition)]] = [:]
+    var declarationsByStart: [Int: [(text: String, keyword: AbsolutePosition)]] = [:]
+    var keywordsByText: [String: [AbsolutePosition]] = [:]
     for declaration in collector.declarations {
       guard let keyword = keywordToken(of: declaration) else {
         continue
       }
-      declarations[declaration.position.utf8Offset, default: []].append(
-        (textFromKeyword(keyword, of: declaration), keyword.positionAfterSkippingLeadingTrivia)
+      let text = textFromKeyword(keyword, of: declaration)
+      declarationsByStart[declaration.position.utf8Offset, default: []].append(
+        (text, keyword.positionAfterSkippingLeadingTrivia)
       )
+      keywordsByText[text, default: []].append(keyword.positionAfterSkippingLeadingTrivia)
     }
-    self.declarations = declarations
+    self.declarationsByStart = declarationsByStart
+    self.keywordsByText = keywordsByText
   }
 
   /// The position in the original file of `position` in `node`, or `nil` when `node` is in the
-  /// original file, isn't in a detached declaration, is before its keyword, or no declaration with its
-  /// text starts at `declarationStart`.
+  /// original file, isn't in a declaration that a macro got, is before its keyword, or its original
+  /// declaration isn't found.
   ///
-  /// `declarationStart` is the offset that the macro system maps the start of the detached
-  /// declaration to.
-  func position(of position: AbsolutePosition, in node: Syntax, declarationStart: Int) -> AbsolutePosition? {
-    guard !node.root.is(SourceFileSyntax.self),
-      let declaration = node.root.as(DeclSyntax.self),
-      let keyword = keywordToken(of: declaration),
-      position >= keyword.positionAfterSkippingLeadingTrivia,
-      let original = declarations[declarationStart]?.first(where: {
-        $0.text == textFromKeyword(keyword, of: declaration)
-      })
-    else {
+  /// `declarationStart` returns the offset that the macro system maps the start of the declaration
+  /// to. It is called once for each declaration.
+  func position(
+    of position: AbsolutePosition,
+    in node: Syntax,
+    declarationStart: () -> Int
+  ) -> AbsolutePosition? {
+    guard !node.root.is(SourceFileSyntax.self), let declaration = node.root.as(DeclSyntax.self) else {
+      return nil
+    }
+    let found: (keyword: AbsolutePosition, original: AbsolutePosition)?
+    if let cached = keywords[declaration.id] {
+      found = cached
+    } else {
+      found = keywordToken(of: declaration).flatMap { keyword in
+        let text = textFromKeyword(keyword, of: declaration)
+        let byStart = declarationsByStart[declarationStart()]?.first { $0.text == text }?.keyword
+        let byText = keywordsByText[text].flatMap { $0.count == 1 ? $0.first : nil }
+        return (byStart ?? byText).map { (keyword.positionAfterSkippingLeadingTrivia, $0) }
+      }
+      keywords[declaration.id] = found
+    }
+    guard let found, position >= found.keyword else {
       return nil
     }
-    let offset = position.utf8Offset - keyword.positionAfterSkippingLeadingTrivia.utf8Offset
-    return AbsolutePosition(utf8Offset: original.keyword.utf8Offset + offset)
+    return AbsolutePosition(utf8Offset: found.original.utf8Offset + position.utf8Offset - found.keyword.utf8Offset)
   }
 }
 

package/apple/Sources/ExpoModulesCLI/Commands/Expand/RunExpand.swift

@@ -86,14 +86,14 @@ func expandFiles(options: ExpandOptions, expander: MacroExpander) -> Result<Expa
   }
 }
 
-/// The files of `options` with their sources, expanded with `expander`, as `expandFiles` describes.
-/// `fix` uses it too, because it edits the sources.
+/// The files of `options` with their sources and the bytes that were read, expanded with `expander`,
+/// as `expandFiles` describes. `fix` uses it too, because it edits the sources.
 func expandSources(
   options: ExpandOptions,
   expander: MacroExpander
-) -> Result<[(source: String, expanded: ExpandedFile)], ExpandInputError> {
+) -> Result<[(source: String, contents: Data, expanded: ExpandedFile)], ExpandInputError> {
   let prefilter = MacroPrefilter(attributeNames: expander.attributeNames)
-  var sources: [(file: String, source: String)] = []
+  var sources: [(file: String, source: String, contents: Data)] = []
   var seen: Set<String> = []
   for path in options.paths {
     switch isDirectory(atPath: path) {
@@ -101,12 +101,12 @@ func expandSources(
       return .failure(ExpandInputError(message: "no such file or directory '\(path)'"))
     case .some(true):
       for file in swiftFiles(in: [path]) where !seen.contains(fileIdentity(file)) {
-        guard let source = try? String(contentsOfFile: file, encoding: .utf8) else {
+        guard let (source, contents) = readSource(atPath: file) else {
           return .failure(ExpandInputError(message: "could not read '\(file)'"))
         }
         seen.insert(fileIdentity(file))
         if mightContainMacro(in: source, prefilter: prefilter) {
-          sources.append((file, source))
+          sources.append((file, source, contents))
         }
       }
     case .some(false):
@@ -116,15 +116,17 @@ func expandSources(
       guard !seen.contains(fileIdentity(path)) else {
         continue
       }
-      guard let source = try? String(contentsOfFile: path, encoding: .utf8) else {
+      guard let (source, contents) = readSource(atPath: path) else {
         return .failure(ExpandInputError(message: "could not read '\(path)'"))
       }
       seen.insert(fileIdentity(path))
-      sources.append((path, source))
+      sources.append((path, source, contents))
     }
   }
 
-  let files = sources.map { (source: $0.source, expanded: expander.expand($0.source, $0.file, options.symbols)) }
+  let files = sources.map {
+    (source: $0.source, contents: $0.contents, expanded: expander.expand($0.source, $0.file, options.symbols))
+  }
 
   let found = Set(files.flatMap { $0.expanded.expansions.compactMap(\.symbol) })
   if let missing = options.symbols.first(where: { !found.contains($0) }) {
@@ -139,6 +141,22 @@ func expandSources(
   return .success(files)
 }
 
+/// The bytes of a UTF-8 byte order mark.
+let utf8ByteOrderMark: [UInt8] = [0xEF, 0xBB, 0xBF]
+
+/// The contents of the file at `path` as text, without a UTF-8 byte order mark, and the bytes that
+/// were read. `nil` when the file can't be read or isn't UTF-8.
+func readSource(atPath path: String) -> (source: String, contents: Data)? {
+  guard let contents = try? Data(contentsOf: URL(fileURLWithPath: path)) else {
+    return nil
+  }
+  let text = contents.starts(with: utf8ByteOrderMark) ? contents.dropFirst(utf8ByteOrderMark.count) : contents[...]
+  guard let source = String(bytes: text, encoding: .utf8) else {
+    return nil
+  }
+  return (source, contents)
+}
+
 /// The expanded sources as text. A single expansion is printed as it is; more than one each get a
 /// `// <file>` or `// <file>: <symbol>` header and are separated by an empty line.
 func renderExpansions(_ files: [ExpandedFile]) -> String {

package/apple/Sources/ExpoModulesCLI/Commands/Fix/RunFix.swift

@@ -28,8 +28,7 @@ struct FixedSource: Equatable {
   let source: String
   let fixIts: [FixItReport]
 
-  /// Whether `fixSource` stopped after `maxFixPasses` passes while the last pass still applied a
-  /// Fix-It, so the source can have more.
+  /// Whether `fixSource` stopped after `maxFixPasses` passes while Fix-Its were left to apply.
   var reachedPassLimit = false
 
   var applied: [FixItReport] {
@@ -46,8 +45,16 @@ extension Scanner {
   /// `--dry-run`, the files aren't written. A file that can't be written is reported and the others are
   /// still fixed. The exit code is `0` also when a Fix-It is skipped, `1` when a file can't be written,
   /// and `2` for an input that `expand` doesn't take.
-  static func runFix(options: FixOptions, expander: MacroExpander) -> Int32 {
-    let sources: [(source: String, expanded: ExpandedFile)]
+  ///
+  /// `write` writes a fixed file and returns whether it changed it (see `writeFixedSource`); tests
+  /// replace it. A file that another path already fixed, through a hard link, isn't printed or counted
+  /// again.
+  static func runFix(
+    options: FixOptions,
+    expander: MacroExpander,
+    write: (_ source: String, _ path: String, _ original: Data) throws -> Bool = writeFixedSource
+  ) -> Int32 {
+    let sources: [(source: String, contents: Data, expanded: ExpandedFile)]
     switch expandSources(options: ExpandOptions(paths: options.paths, symbols: options.symbols), expander: expander) {
     case .success(let expanded):
       sources = expanded
@@ -58,8 +65,8 @@ extension Scanner {
 
     var appliedCount = 0
     var fixedFiles = 0
-    var failed = false
-    for (source, expanded) in sources {
+    var failedFiles = 0
+    for (source, contents, expanded) in sources {
       let fixed = fixSource(
         source,
         expanded: expanded,
@@ -73,10 +80,12 @@ extension Scanner {
       }
       if !options.dryRun {
         do {
-          try writeSource(fixed.source, toFile: expanded.file)
+          guard try write(fixed.source, expanded.file, contents) else {
+            continue
+          }
         } catch {
           writeToStandardError("error: could not write '\(expanded.file)': \(error)\n")
-          failed = true
+          failedFiles += 1
           continue
         }
       }
@@ -85,20 +94,62 @@ extension Scanner {
       fixedFiles += 1
     }
 
-    writeToStandardOutput(renderFixSummary(applied: appliedCount, files: fixedFiles, dryRun: options.dryRun))
-    return failed ? 1 : 0
+    writeToStandardOutput(
+      renderFixSummary(applied: appliedCount, files: fixedFiles, failed: failedFiles, dryRun: options.dryRun)
+    )
+    return failedFiles > 0 ? 1 : 0
   }
 }
 
-/// Writes `source` to the file at `path` in place, so a symbolic link keeps pointing to the file and a
-/// hard link keeps sharing it, and a writable file can be written in a read-only directory. Keeps the
-/// UTF-8 byte order mark of the file, which the source doesn't have because reading it as a `String`
-/// removes it.
-func writeSource(_ source: String, toFile path: String) throws {
+/// Why `writeFixedSource` didn't write a file.
+struct FixWriteError: Error, CustomStringConvertible {
+  let description: String
+}
+
+/// Writes `source`, the fixed source of the file at `path`, whose contents were `original`, and
+/// returns whether it changed the file.
+///
+/// The file must still have the contents that `fix` read, so a change that an editor saved meanwhile
+/// isn't lost. A file that already has the fixed contents, because `fix` wrote it through another
+/// hard link, is left as it is. It keeps the UTF-8 byte order mark of the file, which `readSource`
+/// removes from the source.
+///
+/// The file is written in place, so on macOS and Linux its links, permissions, owner, extended
+/// attributes and ACLs stay, and a read-only file isn't written. When the write fails, the original contents are written back,
+/// and the error tells whether the file is unchanged. When that fails too, the original contents are
+/// saved to a file in the temporary directory, which the error names.
+@discardableResult
+func writeFixedSource(_ source: String, toFile path: String, original: Data) throws -> Bool {
   let url = URL(fileURLWithPath: path)
-  let byteOrderMark: [UInt8] = [0xEF, 0xBB, 0xBF]
-  let hasByteOrderMark = try Data(contentsOf: url).starts(with: byteOrderMark)
-  try Data((hasByteOrderMark ? byteOrderMark : []) + Array(source.utf8)).write(to: url)
+  let contents = Data((original.starts(with: utf8ByteOrderMark) ? utf8ByteOrderMark : []) + Array(source.utf8))
+  guard let current = try? Data(contentsOf: url) else {
+    throw FixWriteError(description: "the file can't be read anymore")
+  }
+  guard current != contents else {
+    return false
+  }
+  guard current == original else {
+    throw FixWriteError(description: "the file changed after fix read it")
+  }
+  do {
+    try contents.write(to: url)
+  } catch {
+    if (try? Data(contentsOf: url)) != original {
+      try? original.write(to: url)
+    }
+    if (try? Data(contentsOf: url)) == original {
+      throw FixWriteError(description: "\(error); the file is unchanged")
+    }
+    let backup = FileManager.default.temporaryDirectory.appendingPathComponent(
+      "\(url.lastPathComponent).\(UUID().uuidString).original"
+    )
+    let saved = (try? original.write(to: backup)) != nil
+    throw FixWriteError(
+      description: "\(error); the file can be incomplete"
+        + (saved ? ", and its original contents are in '\(backup.path)'" : "")
+    )
+  }
+  return true
 }
 
 /// The most times that `fixSource` expands a file again after applying Fix-Its.
@@ -126,10 +177,17 @@ func fixSource(
     fixed = applyFixIts(to: fixed.source, diagnostics: selected(diagnostics))
     applied += fixed.applied
   }
+  // After the last pass, expand once more to tell whether Fix-Its are left.
+  let reachedPassLimit =
+    !fixed.applied.isEmpty
+    && !applyFixIts(
+      to: fixed.source,
+      diagnostics: selected(expander.expand(fixed.source, expanded.file, symbols).diagnostics)
+    ).applied.isEmpty
   return FixedSource(
     source: fixed.source,
     fixIts: applied + fixed.fixIts.filter { $0.skipReason != nil },
-    reachedPassLimit: !fixed.applied.isEmpty
+    reachedPassLimit: reachedPassLimit
   )
 }
 
@@ -217,12 +275,16 @@ func renderSkippedFixIts(_ fixed: FixedSource, file: String) -> String {
   return text
 }
 
-/// The summary line of `fix`, for example `Applied 3 Fix-Its in 2 files.`
-func renderFixSummary(applied: Int, files: Int, dryRun: Bool) -> String {
-  guard applied > 0 else {
-    return "No Fix-Its to apply.\n"
+/// The summary line of `fix`, for example `Applied 3 Fix-Its in 2 files.` or, when files couldn't be
+/// written, `Applied 1 Fix-It in 1 file. Could not write 1 file.`
+func renderFixSummary(applied: Int, files: Int, failed: Int = 0, dryRun: Bool) -> String {
+  let count = { (n: Int, noun: String) in "\(n) \(noun)\(n == 1 ? "" : "s")" }
+  var parts: [String] = []
+  if applied > 0 {
+    parts.append("\(dryRun ? "Would apply" : "Applied") \(count(applied, "Fix-It")) in \(count(files, "file")).")
+  }
+  if failed > 0 {
+    parts.append("Could not write \(count(failed, "file")).")
   }
-  let fixIts = "\(applied) Fix-It\(applied == 1 ? "" : "s")"
-  let fileCount = "\(files) file\(files == 1 ? "" : "s")"
-  return "\(dryRun ? "Would apply" : "Applied") \(fixIts) in \(fileCount).\n"
+  return (parts.isEmpty ? "No Fix-Its to apply." : parts.joined(separator: " ")) + "\n"
 }

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

@@ -207,8 +207,8 @@ struct ExportedEvent: Encodable, Equatable {
   /// The single payload parameter's type, or `nil` for a no-payload `() -> Void` event.
   var payload: TypeNode?
 
-  /// `@Event(.sync)`, dispatching inline on the JS thread instead of scheduling.
-  let isSync: Bool
+  /// How the event is dispatched: the default `scheduled`, or the `.inline` or `.blocking` option.
+  let dispatch: ExportedEventDispatch
 
   /// The spelled access modifier, or `nil` when none is written.
   let accessLevel: String?
@@ -216,8 +216,7 @@ struct ExportedEvent: Encodable, Equatable {
   let platforms: [ExportedPlatform]
 
   private enum CodingKeys: String, CodingKey {
-    case name, jsName, payload, accessLevel, platforms
-    case isSync = "sync"
+    case name, jsName, payload, dispatch, accessLevel, platforms
   }
 
   func encode(to encoder: Encoder) throws {
@@ -225,7 +224,7 @@ struct ExportedEvent: Encodable, Equatable {
     try container.encode(name, forKey: .name)
     try container.encode(jsName, forKey: .jsName)
     try container.encodeIfPresent(payload, forKey: .payload)
-    try container.encode(isSync, forKey: .isSync)
+    try container.encode(dispatch, forKey: .dispatch)
     try container.encodeIfPresent(accessLevel, forKey: .accessLevel)
     try container.encode(platforms, forKey: .platforms)
   }
@@ -471,6 +470,13 @@ struct ExportedSurface: Encodable, Equatable {
   let unions: [ExportedUnion]
 }
 
+/// How an `@Event` is dispatched to JavaScript, from its option. Mirrors `EventDispatch` in the macros.
+enum ExportedEventDispatch: String, Encodable, Equatable {
+  case scheduled
+  case inline
+  case blocking
+}
+
 /// Version of the `scan-exports` output shape. Bumped on any breaking change to the envelope or to
 /// anything under `exports`, so a consumer can verify it understands the output before trusting it.
 /// Versioned independently of `scanModulesSchemaVersion`: the two commands serve different consumers
@@ -481,8 +487,9 @@ struct ExportedSurface: Encodable, Equatable {
 /// declarations in `#if` blocks, adds `platforms` (with deprecations), `accessLevel`, and
 /// `defaultValue`, and replaces `constructorParameters` with `initializer`; version 9 adds the
 /// `sharedRef` type kind and the `sharedRef` of a shared object; version 10 adds the `tuple` and `object` type kinds (named after a tuple alias)
-/// and resolves the tuple type aliases declared in `@ExpoModule` and `@SharedObject` classes.
-let scanExportsSchemaVersion = 10
+/// and resolves the tuple type aliases declared in `@ExpoModule` and `@SharedObject` classes; version 11
+/// replaces the `sync` flag of an event with `dispatch`.
+let scanExportsSchemaVersion = 11
 
 /// The `scan-exports` result: the surface plus the run's stats. A distinct envelope from
 /// `ScanModulesResult` (different consumer: TS generation vs. autolinking).

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

@@ -285,7 +285,9 @@ final class SurfaceVisitor: SyntaxVisitor {
       return []
     }
     let override = stringArgument(of: attribute)
-    let isSync = hasEventOption(attribute, named: "sync")
+    let dispatch: ExportedEventDispatch =
+      hasEventOption(attribute, named: "inline")
+      ? .inline : hasEventOption(attribute, named: "blocking") ? .blocking : .scheduled
     var result: [ExportedEvent] = []
 
     for binding in varDecl.bindings {
@@ -306,7 +308,7 @@ final class SurfaceVisitor: SyntaxVisitor {
           name: name,
           jsName: override ?? defaultEventName(for: name),
           payload: functionType.parameters.first.map { typeNode(from: $0.type) },
-          isSync: isSync,
+          dispatch: dispatch,
           accessLevel: spelledAccessLevel(of: varDecl.modifiers),
           platforms: platforms
         )
@@ -704,8 +706,8 @@ private func isVoidEventReturn(_ type: TypeSyntax) -> Bool {
   return text == "Void" || text == "()" || text == "Swift.Void"
 }
 
-/// True if an `@Event` attribute lists the given option member (`@Event(.sync)` or
-/// `@Event("name", EventOptions.sync)`). Like `hasOption` in the macros, but without the array-literal
+/// True if an `@Event` attribute lists the given option member (`@Event(.inline)` or
+/// `@Event("name", EventOptions.inline)`). Like `hasOption` in the macros, but without the array-literal
 /// branch, which `EventOptions...` doesn't accept.
 private func hasEventOption(_ attribute: AttributeSyntax, named option: String) -> Bool {
   guard let arguments = attribute.arguments?.as(LabeledExprListSyntax.self) else {

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)` 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)`) 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: hasOption(node, named: "sync")
+    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

@@ -167,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)` 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/SharedObjectMacro.swift

@@ -171,10 +171,7 @@ extension SharedObjectMacro: MemberAttributeMacro {
     providingAttributesFor member: some DeclSyntaxProtocol,
     in context: some MacroExpansionContext
   ) throws -> [AttributeSyntax] {
-    // `@Event(.sync)` 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,7 +134,9 @@ 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
@@ -173,11 +175,14 @@ private func fieldAttributeDiagnostic(
       )
     ]
   )
+  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.
@@ -311,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] = []
 
@@ -321,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,8 +13,8 @@ internal func jsNameArgument(of attribute: AttributeSyntax) -> String? {
   return segment.content.text
 }
 
-/// True if the attribute lists the given option member, e.g. `@JS(.concurrent)`, `@Event(.sync)` or
-/// `@Event("name", EventOptions.sync)` -> true for the matching name. Options are written as
+/// 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.
@@ -276,20 +276,6 @@ internal func hasDefaultValue(_ parameter: FunctionParameterSyntax) -> Bool {
   return parameter.defaultValue != nil
 }
 
-/// True if the declaration is a `@Event(.sync)` 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 hasOption(attribute, named: "sync")
-}
-
 /// 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/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)`, 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 {
@@ -480,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;

package/build/types.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-modules-macros",
-  "version": "0.30.0",
+  "version": "0.31.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.30.0",
-    "@expo/modules-macros-linux-x64": "0.30.0",
-    "@expo/modules-macros-win32-arm64": "0.30.0",
-    "@expo/modules-macros-win32-x64": "0.30.0"
+    "@expo/modules-macros-linux-arm64": "0.31.0",
+    "@expo/modules-macros-linux-x64": "0.31.0",
+    "@expo/modules-macros-win32-arm64": "0.31.0",
+    "@expo/modules-macros-win32-x64": "0.31.0"
   }
 }