expo-modules-macros 0.33.0 → 0.34.0

package/.github/workflows/macos.yml

@@ -40,6 +40,19 @@ jobs:
       - name: Resolve dependencies
         run: swift package resolve
 
+      - name: Test
+        # Also builds the debug tool, which the next step uses.
+        run: swift test -v
+
+      - name: Compile the macro expansions
+        # The expansion tests compare text. This compiles and runs the expansions of the fixtures in
+        # `scripts/check-compile`, also with library evolution and with `-default-isolation MainActor`.
+        # It runs in the background during the release build, with the debug tool, which the release
+        # build doesn't change. `Wait for the compile check` fails the job when it fails.
+        id: check-compile
+        background: true
+        run: node scripts/check-compile.js .build/debug/ExpoModulesMacrosTool
+
       - name: Build release tool
         # Runs `pnpm run build` (scripts/build.js): builds the universal
         # (arm64 + x86_64) release plugin binary, copies it to
@@ -58,9 +71,6 @@ jobs:
           arch -arm64 apple/ExpoModulesMacros --help > /dev/null
           arch -x86_64 apple/ExpoModulesMacros --help > /dev/null
 
-      - name: Test
-        run: swift test -v
-
       - name: Typecheck the TypeScript wrapper
         run: |
           pnpm install
@@ -72,3 +82,6 @@ jobs:
         run: |
           pnpm run build:ts
           node scripts/check-scan.js .
+
+      - name: Wait for the compile check
+        wait: check-compile

package/AGENTS.md

@@ -17,6 +17,7 @@
 - `src/`: the TypeScript wrapper around the scanner CLI. `types.ts` mirrors the Swift `Codable` output types by hand.
 - `scripts/build.js` (`pnpm run build`): builds the release binaries: the universal macOS `apple/ExpoModulesMacros` (committed and published), and on Windows and Linux `platforms/win32-<arch>/ExpoModulesMacros.exe` or `platforms/linux-<arch>/ExpoModulesMacros` for the host architecture (not committed; published in that package).
 - `scripts/swift-format.js` (`pnpm run swift:format`, `pnpm run swift:lint`): runs swift-format on the `.swift` files that Git tracks or doesn't ignore, with the configuration in `.swift-format`.
+- `scripts/check-compile.js` (macOS only): compiles the `@ViewProps` expansions of the fixtures in `scripts/check-compile` with `swiftc` and a given plugin binary, and runs them, without a default isolation, with library evolution (also building a client from the `.swiftinterface`), and with `-default-isolation MainActor`. Warnings fail it. `Core.swift` holds stand-ins for the core and JSI symbols that the expansions use, `Props.swift` the props structs, and `main.swift` checks the decoded and reset values at run time.
 
 ## Commands
 
@@ -30,9 +31,10 @@ pnpm run typecheck           # TypeScript wrapper
 pnpm run build               # release binary (slow; on macOS uses Rosetta for x86_64)
 pnpm run swift:format        # format the Swift sources in place
 pnpm run swift:lint          # check the formatting, as CI does
+node scripts/check-compile.js .build/debug/ExpoModulesMacrosTool  # compile and run expansions (macOS, after swift build)
 ```
 
-CI runs on macOS (`.github/workflows/macos.yml`), on Windows x64 and arm64 (`.github/workflows/windows.yml`), and on Linux x64 and arm64 (`.github/workflows/linux.yml`). On macOS it runs the release build, checks both binary slices, runs `swift test` and `pnpm run typecheck`, then scans through the TypeScript wrapper with `scripts/check-scan.js`. On Windows it builds and tests the package, builds the release binary, checks that it starts without the Swift runtime, packs it into its `platforms/` package (checking the files and the `os`/`cpu` fields), installs that package, and scans through the TypeScript wrapper with `scripts/check-scan.js`, which must find the executable there. On Linux it does the same in the `swift:6.4.0-rhel-ubi9` image, and also checks that no Swift library is linked dynamically, the newest glibc symbol version that the binary needs, and that the package keeps the executable bit. On every platform, `check-scan.js` also requires `scanExports` to report the surface in `scripts/check-scan-exports.json` for its fixture, so the generated types are the same on each OS. The Swift Format workflow (`.github/workflows/swift-format.yml`) builds the pinned swift-format version and runs `pnpm run swift:lint`. Code in `Sources` and `Tests` must not assume Apple platforms or POSIX paths.
+CI runs on macOS (`.github/workflows/macos.yml`), on Windows x64 and arm64 (`.github/workflows/windows.yml`), and on Linux x64 and arm64 (`.github/workflows/linux.yml`). On macOS it runs `swift test`, starts `scripts/check-compile.js` with the debug tool as a background step, which compiles and runs the expansions of the fixtures, then runs the release build, checks both binary slices, runs `pnpm run typecheck`, scans through the TypeScript wrapper with `scripts/check-scan.js`, and waits for the compile check. On Windows it builds and tests the package, builds the release binary, checks that it starts without the Swift runtime, packs it into its `platforms/` package (checking the files and the `os`/`cpu` fields), installs that package, and scans through the TypeScript wrapper with `scripts/check-scan.js`, which must find the executable there. On Linux it does the same in the `swift:6.4.0-rhel-ubi9` image, and also checks that no Swift library is linked dynamically, the newest glibc symbol version that the binary needs, and that the package keeps the executable bit. On every platform, `check-scan.js` also requires `scanExports` to report the surface in `scripts/check-scan-exports.json` for its fixture, so the generated types are the same on each OS. The Swift Format workflow (`.github/workflows/swift-format.yml`) builds the pinned swift-format version and runs `pnpm run swift:lint`. Code in `Sources` and `Tests` must not assume Apple platforms or POSIX paths.
 
 ## Windows
 
@@ -58,13 +60,14 @@ CI runs on macOS (`.github/workflows/macos.yml`), on Windows x64 and arm64 (`.gi
 ## Changing macros
 
 - The scanner re-implements the macros' naming and member rules on the syntax tree; it does not call the macro code. When a macro changes which members it binds or how it names them (the `@JS` name override, the `on` prefix `@Event` strips, which properties `@Record` treats as fields), change `scan-exports` to match, or generated TypeScript types drift from the runtime.
+- The expansion tests compare text, so they don't show whether the generated code compiles. After a change to the code that `@ViewProps` generates, run `swift build` and `node scripts/check-compile.js .build/debug/ExpoModulesMacrosTool`. A new case that the generated code must handle gets a props struct in `scripts/check-compile/Props.swift`, and a check in `main.swift` when its values matter.
 - When the `scan-exports` output changes on purpose, update `scripts/check-scan-exports.json`: run `swift build`, then `node scripts/check-scan.js . --update .build/debug/ExpoModulesMacrosTool`, and review the diff. CI compares it with the output on macOS, Windows and Linux.
 - The scanner only parses files that pass the pre-filter, `MacroPrefilter` in `ExpoModulesCLI/Core/SourceScan.swift`. Each command builds it from the `macros` and `conformances` arguments of its `scanFiles` call. A new attribute or conformance the scanner must detect has to be added to those arguments (an attribute also needs a `DetectedMacro` case), or files that use it are skipped without an error.
 - A new macro needs: the implementation in `apple/Sources/ExpoModulesMacrosCore/Macros`, an entry in `ProvidedMacro.all` in `ProvidedMacros.swift` (with the attribute name and the extension conformances of its declaration), an expansion test file, the `#externalMacro` declaration in `expo-modules-core`, and an entry in the macro list in `README.md`.
 
 ## Contracts with other packages
 
-- **Macro declarations live in `expo-modules-core`** (`ios/Core/ExpoModulesMacros.swift` in `expo/expo`), as `#externalMacro(module: "ExpoModulesMacros", type: ...)`. Adding a macro, renaming a macro type or changing a macro's signature needs a matching edit there, and the type must be listed in `ProvidedMacro.all` in `ProvidedMacros.swift`, with the same attribute name and extension conformances as the declaration.
+- **Macro declarations live in `expo-modules-core`** (`ios/Core/ExpoModulesMacros.swift` in `expo/expo`), as `#externalMacro(module: "ExpoModulesMacros", type: ...)`. Adding a macro, renaming a macro type or changing a macro's signature needs a matching edit there, and the type must be listed in `ProvidedMacro.all` in `ProvidedMacros.swift`, with the same attribute name and extension conformances as the declaration. `scripts/check-compile/Core.swift` copies the `@ViewProps` declaration and `AnyViewProps` (`ios/Core/Views/v2/AnyViewProps.swift`), so a change to them in core needs the same change there.
 - **Generated code calls `expo-modules-core` API.** An expansion that uses a new core symbol only works with a core version that has it.
 - **Scanner output is versioned.** `scanModulesSchemaVersion` (`Commands/ScanModules/ScanModules.swift`), `scanExportsSchemaVersion` (`Commands/ScanExports/ExportedSurface.swift`) and `expandSchemaVersion` (`Commands/Expand/ExpandReport.swift`) change independently. When the output shape of a command changes in a way that breaks a consumer, bump its version and update the matching `SUPPORTED_*_SCHEMA_VERSION` constant. A new field that older consumers can ignore doesn't need a bump, but still update the mirror types in `src/types.ts`. The TypeScript wrapper throws when a report's version differs from its constant. `expo-modules-autolinking` gets the `scan-modules` report through the wrapper, and when the call throws, it links only the modules declared in `expo-module.config.json`.
 - **The binary path is part of the contract.** `expo-modules-autolinking` resolves this package from `expo-modules-core` and passes `-load-plugin-executable <package>/apple/<binary>#ExpoModulesMacros` to the compiler. The scanner wrapper in autolinking uses the same path, and `expo-modules-cli` uses `getScannerBinaryPath()`. On Windows the binary is `ExpoModulesMacros.exe` in `@expo/modules-macros-win32-<arch>`, and on Linux `ExpoModulesMacros` in `@expo/modules-macros-linux-<arch>`. Renaming or moving a binary needs a matching change in `expo/expo`.

package/README.md

@@ -25,13 +25,13 @@ This package lists them as optional dependencies, and their `os`, `cpu` and (on
 # Macros
 
 - **`@ExpoModule(_ name: String? = nil, classes: [Any.Type] = [])`** on a class. Turns the class into a module: binds its `@JS` members into the module's JavaScript object and resolves the module name from the argument, falling back to the class name. It also synthesizes everything inheriting from `Module` used to provide, so a module class can carry any superclass, or none. 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. The class macro reads only the class body, so `@JS` on a member of an extension, or of a type that is neither a module nor a shared object, is an error. So is `@JS` on an initializer or a `static` member of a module, since JavaScript doesn't construct a module and gets only its instance. `@JS` on any other declaration, such as a subscript, is an error too. A `@JS` function or initializer can't be generic, since the binding converts each value by its static type. `@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. A name that JavaScript already gives a meaning on the object is an error too: `__proto__` on any object, `constructor` on a shared object's prototype, and `prototype` on its constructor. The macro also checks that every type crossing the boundary is convertible in the direction it travels. For a top-level declaration, 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.
+- **`@JS(_ jsName: String? = nil, _ options: JSOptions...)`** on a member of a module or shared object. Marks a function, property or initializer for export. The class macro reads only the class body, so `@JS` on a member of an extension, or of a type that is neither a module nor a shared object, is an error. So is `@JS` on an initializer or a `static` member of a module, since JavaScript doesn't construct a module and gets only its instance. `@JS` on any other declaration, such as a subscript, is an error too. A `@JS` function or initializer can't be generic, since the binding converts each value by its static type. `@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. A name that JavaScript already gives a meaning on the object is an error too: `__proto__` on any object, `constructor` on a shared object's prototype, and `prototype` on its constructor. The macro also checks that every type crossing the boundary is convertible in the direction it travels. For a top-level declaration, 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. A synchronous function or an initializer can take the JavaScript runtime as its last parameter, `in runtime: borrowing JavaScriptRuntime`, for example to create a JavaScript value. The binding passes the runtime of the call, and JavaScript doesn't see the parameter. The runtime can be used only on the JavaScript thread, and an `async` function can resume on another thread after an `await`, so the macro reports the parameter on an `async` function or a function with `.withAsync`, and when it isn't the last parameter, isn't labeled `in`, isn't `borrowing` or is optional. The macro finds the parameter by its type as written, so write it as `JavaScriptRuntime`: a typealias or a subclass is decoded as a JavaScript argument instead.
 - **`@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. `@ExpoModule` and `@SharedObject` warn when two events in the class body have the same JS name. 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 class without an inheritance clause is an error, with a Fix-It that adds `: SharedObject`. 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. The memberwise initializer sets every field, so a field that is a `let` with a default value is an error. It doesn't set a `private` or `fileprivate` stored property, so such a property needs a default value, unless it's an optional `var` or the type declares its own memberwise initializer.
 - **`@Union()`** on an enum whose cases each carry one associated value. Models a TypeScript union. Synthesizes the conversions in both directions, a typed accessor per payload type, and the `JavaScriptDecodable` and `JavaScriptEncodable` conformances. Decoding is ordered: the first case whose payload decodes wins, so the more specific case goes first. The macro warns about a case that an earlier case always decodes first: any case after a `JavaScriptValue` case, and a case with a payload that decodes only numbers, such as `Float` or `Int32`, after a `Double`, `Float` or `CGFloat` case.
 
-The members and conformances that `@Record` and `@Union` generate are `nonisolated`, so they also work in a module that builds with a default isolation, such as `-default-isolation MainActor`. The stored properties of a record still take that isolation. A class record, or a struct record with a property whose type isn't `Sendable`, then needs `nonisolated` on its declaration, for example `@Record nonisolated final class Options`.
+The members and conformances that `@Record`, `@Union` and `@ViewProps` generate are `nonisolated`, so they also work in a module that builds with a default isolation, such as `-default-isolation MainActor`. The stored properties of a record still take that isolation. A class record, or a struct record with a property whose type isn't `Sendable`, then needs `nonisolated` on its declaration, for example `@Record nonisolated final class Options`. A `@ViewProps` struct needs it when it has an event prop (a function type isn't `Sendable`), a value prop whose type isn't `Sendable`, or a computed prop, for example `@ViewProps nonisolated struct CardProps`, and its own `init()` must be `nonisolated` too. A conformance that the type declares itself also needs `nonisolated`, for example `struct Options: nonisolated Record`.
 
 A tuple can cross the boundary as a `@JS` argument, result or property, a `@Record` property, a `@Union` payload, an `@Event` payload, or a parameter or result of a closure argument that isn't `async`. An unlabeled tuple such as `(Int, String)` maps to an array with one value per element, and a labeled tuple such as `(x: Double, y: Double)` to an object with one property per label. A tuple must have two or more elements, all labeled or none, and each element must be convertible. Tuples nest in other tuples, optionals, arrays and `String`-keyed dictionaries. `@ExpoModule` and `@SharedObject` also resolve a type alias of a tuple, such as `typealias Span = (start: Int, end: Int)`, when the class body declares it. A macro sees only the declaration it is attached to, so an alias declared anywhere else doesn't resolve.
 

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

@@ -639,8 +639,10 @@ final class SurfaceVisitor: SyntaxVisitor {
 
   /// Projects a parameter clause into `ExportedParameter`s: label = first name, name = second (else
   /// first), `optional` when it has a default value or an optional type, and the default as written.
+  /// A parameter that takes the JavaScript runtime (its type is written as `JavaScriptRuntime`) is left
+  /// out: the binding passes the runtime itself, and JavaScript doesn't see the parameter.
   private func parameters(of clause: FunctionParameterClauseSyntax) -> [ExportedParameter] {
-    clause.parameters.map { parameter in
+    clause.parameters.filter { !takesRuntime($0) }.map { parameter in
       let label = parameter.firstName.identifierName
       let name = parameter.secondName?.identifierName ?? label
       return ExportedParameter(
@@ -800,6 +802,35 @@ private func underlyingFunctionType(of type: TypeSyntax?) -> FunctionTypeSyntax?
   return type.as(FunctionTypeSyntax.self)
 }
 
+/// True when a parameter takes the JavaScript runtime: its type, without specifiers such as `borrowing`,
+/// is written as `JavaScriptRuntime` or `….JavaScriptRuntime`, or as an optional of it. This matches
+/// `isRuntimeParameter` in the macros: a type that also carries attributes (`@Sendable`) isn't one.
+private func takesRuntime(_ parameter: FunctionParameterSyntax) -> Bool {
+  var type = parameter.type
+  if let attributed = type.as(AttributedTypeSyntax.self) {
+    guard attributed.attributes.isEmpty else {
+      return false
+    }
+    type = attributed.baseType
+  }
+  if let optional = type.as(OptionalTypeSyntax.self) {
+    type = optional.wrappedType
+  } else if let implicitlyUnwrapped = type.as(ImplicitlyUnwrappedOptionalTypeSyntax.self) {
+    type = implicitlyUnwrapped.wrappedType
+  } else if let identifier = type.as(IdentifierTypeSyntax.self), identifier.name.text == "Optional",
+    let argument = identifier.genericArgumentClause?.arguments.first, case .type(let wrapped) = argument.argument
+  {
+    type = wrapped
+  }
+  if let identifier = type.as(IdentifierTypeSyntax.self) {
+    return identifier.name.text == "JavaScriptRuntime"
+  }
+  if let member = type.as(MemberTypeSyntax.self) {
+    return member.name.text == "JavaScriptRuntime"
+  }
+  return false
+}
+
 /// True when an event's function type returns `Void`. The shared `isVoidType` is not reused: it
 /// accepts neither `Swift.Void` nor a parenthesized `(Void)`, so it would drop valid events.
 private func isVoidEventReturn(_ type: TypeSyntax) -> Bool {

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

@@ -51,6 +51,7 @@ public struct JSMacro: PeerMacro {
     diagnoseConcurrentOption(of: node, on: declaration, in: context)
     diagnoseAsyncVariantOption(of: node, on: declaration, in: context)
     diagnoseJavaScriptValuesOffThread(of: node, on: declaration, in: context)
+    diagnoseRuntimeParameter(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`).
@@ -425,6 +426,175 @@ private func diagnoseJavaScriptValuesOffThread(
   }
 }
 
+/// Emits the diagnostics for a parameter that takes the JavaScript runtime (see `isRuntimeParameter`).
+/// The binding passes the runtime of the call, which can be used only on the JavaScript thread. So
+/// the parameter must be:
+/// - in a synchronous function or an initializer. An `async` function can resume on another thread
+///   after an `await`: `@JavaScriptActor` runs a job on the thread that enqueues it, and doesn't move
+///   it to the JavaScript thread. A `.concurrent` function and the variant that `.withAsync` adds run
+///   on the concurrent thread pool;
+/// - `borrowing`, so the body can't keep the runtime for later without an explicit `copy`;
+/// - not optional, since the binding always has a runtime to pass;
+/// - the last parameter, labeled `in` (or `runtime`), so every declaration reads the same and the JavaScript
+///   arguments keep their order.
+private func diagnoseRuntimeParameter(
+  of node: AttributeSyntax,
+  on declaration: some DeclSyntaxProtocol,
+  in context: some MacroExpansionContext
+) {
+  let parameters: FunctionParameterListSyntax
+  if let funcDecl = declaration.as(FunctionDeclSyntax.self) {
+    parameters = funcDecl.signature.parameterClause.parameters
+    // `.concurrent` is checked first: its body never runs on the JavaScript thread, so making the
+    // function synchronous doesn't help (a synchronous `.concurrent` function is an error too).
+    let offThread: (reason: String, remedy: String)?
+    if hasOption(node, named: "concurrent") {
+      offThread = ("'.concurrent' runs the body on the concurrent thread pool", "Remove the parameter.")
+    } else if funcDecl.signature.effectSpecifiers?.asyncSpecifier != nil {
+      offThread = (
+        "an 'async' function can resume on another thread after an 'await'",
+        "Remove the parameter, or make the function synchronous."
+      )
+    } else if asyncVariantOption(of: node) != nil {
+      offThread = (
+        "the variant that '.withAsync' adds runs the function on the concurrent thread pool",
+        "Remove the parameter, or remove '.withAsync'."
+      )
+    } else {
+      offThread = nil
+    }
+    if let offThread {
+      for parameter in parameters where isRuntimeParameter(parameter) {
+        context.diagnose(
+          Diagnostic(
+            node: parameter.type,
+            message: JSDiagnosticMessage(
+              "A @JS function can take the JavaScript runtime only when it's synchronous: \(offThread.reason), and the runtime can be used only on the JavaScript thread. \(offThread.remedy)",
+              id: "js-runtime-parameter-async",
+              severity: .error
+            )
+          )
+        )
+      }
+      return
+    }
+  } else if let initDecl = declaration.as(InitializerDeclSyntax.self) {
+    parameters = initDecl.signature.parameterClause.parameters
+  } else {
+    return
+  }
+  for (index, parameter) in parameters.enumerated() where isRuntimeParameter(parameter) {
+    guard index == parameters.count - 1 else {
+      context.diagnose(
+        Diagnostic(
+          node: parameter,
+          message: JSDiagnosticMessage(
+            "The JavaScript runtime must be the last parameter of a @JS function or initializer, and only one parameter can take it. Move it to the end as 'in runtime: borrowing JavaScriptRuntime'.",
+            id: "js-runtime-parameter-position",
+            severity: .error
+          )
+        )
+      )
+      continue
+    }
+    // The errors and the docs name only `in`, which matches the JSI API, such as `encode(_:into:in:)`.
+    // An escaped label (`` `in` ``) is the same label.
+    if !runtimeParameterLabels.contains(withoutBackticks(parameter.firstName.text)) {
+      context.diagnose(
+        Diagnostic(
+          node: parameter.firstName,
+          message: JSDiagnosticMessage(
+            "The parameter that takes the JavaScript runtime must be labeled 'in', as in 'in runtime: borrowing JavaScriptRuntime'.",
+            id: "js-runtime-parameter-label",
+            severity: .error
+          ),
+          fixIts: [runtimeLabelFixIt(for: parameter)]
+        )
+      )
+    }
+    let specified = SpecifiedType(parameter.type)
+    let wrapped = optionalWrappedType(specified.type)
+    if let wrapped {
+      context.diagnose(
+        Diagnostic(
+          node: specified.type,
+          message: JSDiagnosticMessage(
+            "The parameter that takes the JavaScript runtime can't be optional: the binding always passes the runtime of the call.",
+            id: "js-runtime-parameter-optional",
+            severity: .error
+          ),
+          fixIts: [
+            FixIt(
+              message: JSFixItMessage("Remove the optional", id: "js-runtime-parameter-remove-optional"),
+              changes: [
+                .replace(
+                  oldNode: Syntax(specified.type),
+                  newNode: Syntax(
+                    wrapped.trimmed
+                      .with(\.leadingTrivia, specified.type.leadingTrivia)
+                      .with(\.trailingTrivia, specified.type.trailingTrivia)
+                  )
+                )
+              ]
+            )
+          ]
+        )
+      )
+    }
+    if specified.specifiers != ["borrowing"] {
+      context.diagnose(
+        Diagnostic(
+          node: parameter.type,
+          message: JSDiagnosticMessage(
+            "The parameter that takes the JavaScript runtime must be 'borrowing': the runtime can be used only on the JavaScript thread, and a borrowed parameter can't be kept for later without an explicit 'copy'.",
+            id: "js-runtime-parameter-borrowing",
+            severity: .error
+          ),
+          fixIts: [
+            FixIt(
+              message: JSFixItMessage("Mark the parameter 'borrowing'", id: "js-runtime-parameter-insert-borrowing"),
+              changes: [
+                .replace(
+                  oldNode: Syntax(parameter.type),
+                  newNode: Syntax(borrowingType(wrapped ?? specified.type, like: parameter.type))
+                )
+              ]
+            )
+          ]
+        )
+      )
+    }
+  }
+}
+
+/// The labels that the runtime parameter can have.
+private let runtimeParameterLabels: Set<String> = ["in", "runtime"]
+
+/// The fix-it that labels the runtime parameter `in`. It keeps the parameter name that the body uses, or
+/// names the parameter `runtime` when it has no name.
+private func runtimeLabelFixIt(for parameter: FunctionParameterSyntax) -> FixIt {
+  var newParameter = parameter
+  let name = parameter.secondName ?? (parameter.firstName.tokenKind == .wildcard ? nil : parameter.firstName)
+  newParameter.firstName = .keyword(.in, leadingTrivia: parameter.firstName.leadingTrivia, trailingTrivia: .space)
+  newParameter.secondName = name?.trimmed ?? .identifier("runtime")
+  return FixIt(
+    message: JSFixItMessage("Label the parameter 'in'", id: "js-runtime-parameter-label"),
+    changes: [.replace(oldNode: Syntax(parameter), newNode: Syntax(newParameter))]
+  )
+}
+
+/// The type `type` with the single specifier `borrowing`, with the trivia of `original`.
+private func borrowingType(_ type: TypeSyntax, like original: TypeSyntax) -> TypeSyntax {
+  let specifier = SimpleTypeSpecifierSyntax(specifier: .keyword(.borrowing, trailingTrivia: .space))
+  let attributed = AttributedTypeSyntax(
+    specifiers: [.simpleTypeSpecifier(specifier)],
+    baseType: type.trimmed
+  )
+  return TypeSyntax(attributed)
+    .with(\.leadingTrivia, original.leadingTrivia)
+    .with(\.trailingTrivia, original.trailingTrivia)
+}
+
 private func diagnoseParameterSpecifiers(
   in declaration: some DeclSyntaxProtocol,
   in context: some MacroExpansionContext
@@ -437,7 +607,8 @@ private func diagnoseParameterSpecifiers(
   } else {
     return
   }
-  for parameter in parameters {
+  // The runtime parameter isn't decoded, and `diagnoseRuntimeParameter` requires it to be `borrowing`.
+  for parameter in parameters where !isRuntimeParameter(parameter) {
     guard let specifier = SpecifiedType(parameter.type).unsupportedSpecifier else {
       continue
     }
@@ -608,7 +779,8 @@ private func argumentBoundaryTypes(of parameters: FunctionParameterListSyntax) -
   // A closure in any other position is diagnosed by `diagnoseClosureTypes` and left out here, since
   // its metatype isn't a valid expression in the assertion.
   var types: [AssertedType] = []
-  for parameter in parameters {
+  // The runtime parameter takes no JavaScript argument, so nothing decodes into it.
+  for parameter in parameters where !isRuntimeParameter(parameter) {
     let label = parameter.firstName.tokenKind == .wildcard ? nil : parameter.firstName.text
     // The specifier isn't part of the asserted type, and a parameter with one the binding can't honor
     // is reported by `diagnoseParameterSpecifiers` and not asserted.

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

@@ -39,6 +39,10 @@ import SwiftSyntaxMacros
 ///   event without an initial value an empty closure (`{}`, `{ _ in }`, ...) and leaves the value
 ///   props at their initial values. It is never generated when the type declares its own `init()`.
 ///   Like any initializer in the struct body, the generated one removes the memberwise initializer.
+/// - `_resetViewProp(_:in:)`: sets one value prop back to its default, by assigning the property's
+///   initial value or `nil`, so a reset evaluates only that prop's default. It is a static member of
+///   the struct body, because an initial value can name a static member without `Self.` or a member of
+///   an enclosing type, which an instance method or the extension can't.
 ///
 /// An event's function type must return `Void`, because JavaScript can't return a value to it.
 ///
@@ -47,7 +51,16 @@ import SwiftSyntaxMacros
 /// - `allProps`: every bit set, the changed set on the first application.
 /// - `propSet(for:)`: one name's bit, for folding raw changed keys into the mask.
 /// - `_decode(_:from:in:)`: assigns one value prop from a JavaScript value. `null` and `undefined`
-///   reset it to its value in `Self()`, and any other value decodes through `JavaScriptDecodable`.
+///   reset it with `_resetViewProp(_:in:)`, and any other value decodes through
+///   `JavaScriptDecodable`.
+///
+/// `_decode` and `_resetViewProp` run on the JavaScript actor. The other generated types and members
+/// and the conformance are `nonisolated`, so core can use them on any thread also when the module
+/// builds with a default isolation, such as `-default-isolation MainActor`. The props' own
+/// declarations still take that isolation, so a struct with an event prop, a value prop whose type
+/// isn't `Sendable`, or a computed prop needs `nonisolated` on its declaration, and the author's
+/// `init()` must be `nonisolated` too. So must a conformance that the author declares
+/// (`: nonisolated AnyViewProps`).
 ///
 /// Author-facing shape — no conformance to spell out:
 ///
@@ -83,6 +96,9 @@ public struct ViewPropsMacro: MemberMacro, ExtensionMacro {
     if let initializer = defaultInitializer(props: props) {
       members.append(initializer)
     }
+    if let reset = resetFunction(valueProps: props.valueProps) {
+      members.append(reset)
+    }
     return members
   }
 
@@ -120,29 +136,33 @@ public struct ViewPropsMacro: MemberMacro, ExtensionMacro {
       ? "0"
       : "0b" + String(repeating: "1", count: props.valueProps.count)
 
-    // With no value prop there's nothing to switch over, so return the empty set.
+    // With no value prop, `PropName` has no case, so the function can't be called and its body is
+    // empty, like the one of `_decode`. Swift reports any statement in it, also an empty `switch`, as
+    // "will never be executed". The body starts with a line break, so the empty one closes on the
+    // next line.
     let propSetBody: String
     if props.valueProps.isEmpty {
-      propSetBody = "    return []"
+      propSetBody = ""
     } else {
       let cases = props.valueProps
         .map { "    case .\($0.name):\n      return .\($0.name)" }
         .joined(separator: "\n")
-      propSetBody = "    switch name {\n\(cases)\n    }"
+      propSetBody = "\n    switch name {\n\(cases)\n    }"
     }
 
     let decodeBody = decodeFunctionBody(valueProps: props.valueProps)
 
-    let conformanceClause = alreadyConforms ? "" : ": \(viewPropsProtocolName)"
+    // `nonisolated` keeps the conformance and its members usable on the JavaScript thread when the
+    // module builds with a default isolation, which would otherwise isolate them to the main actor.
+    let conformanceClause = alreadyConforms ? "" : ": nonisolated \(viewPropsProtocolName)"
     let ext: DeclSyntax = """
       extension \(type.trimmed)\(raw: conformanceClause) {
-        public static let allProps = PropSet(rawValue: \(raw: allPropsMask))
+        nonisolated public static let allProps = PropSet(rawValue: \(raw: allPropsMask))
 
         /// `@inlinable` so core's raw-key fold can inline the lookup across the module boundary:
         /// it runs once per changed key per props batch.
         @inlinable
-        public static func propSet(for name: PropName) -> PropSet {
-      \(raw: propSetBody)
+        nonisolated public static func propSet(for name: PropName) -> PropSet {\(raw: propSetBody)
         }
 
         @JavaScriptActor
@@ -488,9 +508,11 @@ private struct ViewProp {
   /// The property's declared type, verbatim, or the type of its literal initial value. `_decode`
   /// doesn't spell it: the decoded type is inferred from the assignment.
   let type: String
-  /// Whether the prop is computed with a `mutating get`, which `_decode` can only read from a
+  /// Whether the prop is computed with a `mutating get`, which `_resetViewProp` can only read from a
   /// mutable value.
   let hasMutatingGetter: Bool
+  /// What `_resetViewProp` assigns when React removes the prop. Events aren't reset.
+  let defaultValue: PropDefault
 
   /// The name with any escaping backticks removed: the JS-visible key, so the enum's raw value and
   /// `_eventNames` both read `"default"`, never `` "`default`" ``.
@@ -499,6 +521,49 @@ private struct ViewProp {
   }
 }
 
+/// The value that a value prop goes back to when React removes it. Each one equals the prop's value
+/// in `Self()`.
+private enum PropDefault {
+  /// The initial value of a stored property, as written. Evaluating it again gives the value that
+  /// `Self()` gives the property.
+  case initialValue(ExprSyntax)
+  /// The implicit `nil` of a `var` whose type is written as `T?` or `T!`.
+  case implicitNil
+  /// The prop's value in a new `Self()`, when the macro can't tell it from the declaration: the
+  /// struct declares its own `init()`, which can set any value, the prop is computed, the property
+  /// has an attribute, such as a property wrapper, whose value after `init(wrappedValue:)` can differ
+  /// from its initial value, or the initial value has a `#` expression, such as `#function` or
+  /// `#line`, whose value depends on where it's evaluated.
+  case newInstance
+}
+
+/// The default of a property with the given binding, for a struct that does or doesn't declare its own
+/// `init()`.
+private func propDefault(
+  of binding: PatternBindingSyntax,
+  in varDecl: VariableDeclSyntax,
+  declaredType: TypeSyntax?,
+  declaresUsableInitializer: Bool
+) -> PropDefault {
+  if declaresUsableInitializer || !isStoredBinding(binding) || !varDecl.attributes.isEmpty {
+    return .newInstance
+  }
+  if let initializer = binding.initializer {
+    // A macro expansion, also a literal such as `#function`, can depend on where it's evaluated, so
+    // a copy in `_resetViewProp` could give another value.
+    let hasPoundExpression = initializer.value.tokens(viewMode: .sourceAccurate).contains {
+      $0.tokenKind == .pound
+    }
+    return hasPoundExpression ? .newInstance : .initialValue(initializer.value)
+  }
+  if varDecl.bindingSpecifier.tokenKind == .keyword(.var), let declaredType, hasImplicitNilDefault(declaredType) {
+    return .implicitNil
+  }
+  // A value prop without a default is reported, so this is only reached for an event, which isn't
+  // reset.
+  return .newInstance
+}
+
 /// An event prop declared without an initial value, which the generated `init()` assigns.
 private struct EventDefault {
   /// The property name as written, backticks included.
@@ -664,7 +729,17 @@ private func validatedViewProps(
       // Only stored storage takes an initial value; a computed prop with a setter needs none.
       let needsInitialValue =
         binding.initializer == nil && isStoredBinding(binding) && !declaresUsableInitializer
-      let prop = ViewProp(name: name, type: resolvedType, hasMutatingGetter: hasMutatingGetter(binding))
+      let prop = ViewProp(
+        name: name,
+        type: resolvedType,
+        hasMutatingGetter: hasMutatingGetter(binding),
+        defaultValue: propDefault(
+          of: binding,
+          in: varDecl,
+          declaredType: declaredType,
+          declaresUsableInitializer: declaresUsableInitializer
+        )
+      )
       if let eventFunctionType {
         // An event is dispatched to JavaScript, which can't hand a value back to the caller.
         if !returnsVoid(eventFunctionType) {
@@ -926,6 +1001,10 @@ private func underlyingFunctionType(of type: TypeSyntax) -> FunctionTypeSyntax?
 /// Emitted even when empty, so a props type with only events still conforms. An enum with no cases
 /// can't declare a raw type, so the empty one conforms to `RawRepresentable` by hand, with `String`
 /// as its `RawValue` like the others.
+///
+/// The enum is `@frozen`, so the `switch` in the `@inlinable` `propSet(for:)` compiles in a module
+/// built with library evolution, where it would otherwise need a case for unknown values. The cases
+/// and their order are already part of the ABI, as the bits of `PropSet`.
 private func propNameEnum(valueProps: [ViewProp]) -> DeclSyntax {
   // An escaped case takes its raw value from the bare identifier already, but spelling it out keeps
   // the wire key visible in the generated source and independent of that implicit rule.
@@ -939,7 +1018,7 @@ private func propNameEnum(valueProps: [ViewProp]) -> DeclSyntax {
     .joined(separator: "\n")
   if valueProps.isEmpty {
     return """
-      public enum PropName: RawRepresentable, CaseIterable {
+      @frozen nonisolated public enum PropName: RawRepresentable, CaseIterable {
         public init?(rawValue: String) {
           return nil
         }
@@ -952,7 +1031,7 @@ private func propNameEnum(valueProps: [ViewProp]) -> DeclSyntax {
       """
   }
   return """
-    public enum PropName: String, CaseIterable {
+    @frozen nonisolated public enum PropName: String, CaseIterable {
     \(raw: cases)
     }
     """
@@ -970,7 +1049,7 @@ private func propSetStruct(valueProps: [ViewProp]) -> DeclSyntax {
 
   if valueProps.isEmpty {
     return """
-      public struct PropSet: OptionSet, Sendable {
+      nonisolated public struct PropSet: OptionSet, Sendable {
         public let rawValue: UInt64
 
         public init(rawValue: UInt64) {
@@ -980,7 +1059,7 @@ private func propSetStruct(valueProps: [ViewProp]) -> DeclSyntax {
       """
   }
   return """
-    public struct PropSet: OptionSet, Sendable {
+    nonisolated public struct PropSet: OptionSet, Sendable {
       public let rawValue: UInt64
 
       public init(rawValue: UInt64) {
@@ -998,31 +1077,23 @@ private func propSetStruct(valueProps: [ViewProp]) -> DeclSyntax {
 private func eventNamesConstant(eventProps: [ViewProp]) -> DeclSyntax {
   let names = eventProps.map { "\"\($0.wireName)\"" }.joined(separator: ", ")
   return """
-    public static let _eventNames: [String] = [\(raw: names)]
+    nonisolated public static let _eventNames: [String] = [\(raw: names)]
     """
 }
 
 /// The body of `_decode`, which core calls once per changed prop. React sends a removed prop as
-/// `null`, so `null` and `undefined` reset the prop to its value in a fresh `Self()`; any other value
-/// decodes through `JavaScriptDecodable`, with the type inferred from the assignment. The helper is a
-/// static member of `AnyViewProps`, reached through `Self.`, so a prop named `_decodeViewProp`
-/// doesn't shadow it. The checks run
-/// once, before the switch, so each case is a single assignment. Members are reached through `self.`
-/// so that a prop named like a parameter (`value`, `runtime`) isn't shadowed by it.
+/// `null`, so `null` and `undefined` reset the prop with `_resetViewProp`; any other value decodes
+/// through `JavaScriptDecodable`, with the type inferred from the assignment. `_decodeViewProp` is a
+/// static member of `AnyViewProps`, reached through `Self.`, so a prop with the same name doesn't
+/// shadow it. The checks run once, before the switch, so each case is a single assignment. Members
+/// are reached through `self.` so that a prop named like a parameter (`value`, `runtime`) isn't
+/// shadowed by it.
 ///
 /// With no value prop the body is empty: `PropName` is uninhabited, so the function is never called.
-///
-/// `defaults` is a `var` only when a prop has a `mutating get`, which can't be read from a constant.
-/// Otherwise it's a `let`, so the common case gets no "never mutated" warning.
 private func decodeFunctionBody(valueProps: [ViewProp]) -> String {
   if valueProps.isEmpty {
     return ""
   }
-  let defaultsSpecifier = valueProps.contains(where: \.hasMutatingGetter) ? "var" : "let"
-  let resetCases =
-    valueProps
-    .map { "      case .\($0.name):\n        self.\($0.name) = defaults.\($0.name)" }
-    .joined(separator: "\n")
   let decodeCases =
     valueProps
     .map { "    case .\($0.name):\n      self.\($0.name) = try Self._decodeViewProp(value, in: runtime)" }
@@ -1032,10 +1103,7 @@ private func decodeFunctionBody(valueProps: [ViewProp]) -> String {
   return """
 
         if value.isNull() || value.isUndefined() {
-          \(defaultsSpecifier) defaults = Self()
-          switch name {
-    \(resetCases)
-          }
+          Self._resetViewProp(name, in: &self)
           return
         }
         switch name {
@@ -1044,6 +1112,79 @@ private func decodeFunctionBody(valueProps: [ViewProp]) -> String {
     """
 }
 
+/// `_resetViewProp(_:in:)`, which sets one value prop back to its default when React removes it. Each
+/// case assigns the prop's initial value or `nil`, so a reset evaluates only that prop's default. A
+/// prop whose default the macro can't tell from the declaration reads it from a new `Self()`.
+///
+/// A static function of the struct body resolves names as a property initializer does: a static
+/// member without `Self.` and a member of an enclosing type, which `_decode` in the extension can't
+/// name. The parameters are `_name` and `_props`, with a number after the name when an initial value
+/// uses it, so they don't hide a declaration that an initial value names.
+///
+/// A default argument such as `#function` or `#line` of a function that an initial value calls gets
+/// the location of `_resetViewProp`, which the macro can't see.
+///
+/// `nil` with no value prop: `PropName` is uninhabited, so `_decode` never resets.
+private func resetFunction(valueProps: [ViewProp]) -> DeclSyntax? {
+  if valueProps.isEmpty {
+    return nil
+  }
+  let usedNames = Set(
+    valueProps.flatMap { prop -> [String] in
+      guard case .initialValue(let expression) = prop.defaultValue else {
+        return []
+      }
+      return expression.tokens(viewMode: .sourceAccurate).compactMap { token in
+        guard case .identifier(let text) = token.tokenKind else {
+          return nil
+        }
+        return withoutBackticks(text)
+      }
+    }
+  )
+  let nameParameter = unusedName("_name", in: usedNames)
+  let propsParameter = unusedName("_props", in: usedNames)
+  let cases =
+    valueProps
+    .map { prop -> String in
+      let assignment: String
+      switch prop.defaultValue {
+      case .initialValue(let expression):
+        assignment = "\(propsParameter).\(prop.name) = \(expression.trimmedDescription)"
+      case .implicitNil:
+        assignment = "\(propsParameter).\(prop.name) = nil"
+      case .newInstance where prop.hasMutatingGetter:
+        // A mutating getter can't be read from a constant. The local is scoped to its case, where
+        // no initial value is copied.
+        assignment = "var _defaults = Self()\n    \(propsParameter).\(prop.name) = _defaults.\(prop.name)"
+      case .newInstance:
+        assignment = "\(propsParameter).\(prop.name) = Self().\(prop.name)"
+      }
+      return "  case .\(prop.name):\n    \(assignment)"
+    }
+    .joined(separator: "\n")
+  return """
+    @JavaScriptActor
+    static func _resetViewProp(_ \(raw: nameParameter): PropName, in \(raw: propsParameter): inout Self) {
+      switch \(raw: nameParameter) {
+    \(raw: cases)
+      }
+    }
+    """
+}
+
+/// `base`, or `base` with the lowest number after it that gives a name not in `names`.
+private func unusedName(_ base: String, in names: Set<String>) -> String {
+  if !names.contains(base) {
+    return base
+  }
+  var number = 1
+  while names.contains("\(base)\(number)") {
+    number += 1
+  }
+  return "\(base)\(number)"
+}
+
 /// The public `init()` that `AnyViewProps` requires, when Swift's own can't satisfy it: it gives each
 /// event prop without an initial value an empty closure, and leaves the value props at their initial
 /// values. `nil` when the type declares a usable `init()`, or when Swift's `init()` is enough (see
@@ -1054,7 +1195,7 @@ private func defaultInitializer(props: ViewPropsModel) -> DeclSyntax? {
   }
   if props.eventDefaults.isEmpty {
     return """
-      public init() {
+      nonisolated public init() {
       }
       """
   }
@@ -1062,7 +1203,7 @@ private func defaultInitializer(props: ViewPropsModel) -> DeclSyntax? {
     .map { "  self.\($0.name) = \($0.emptyClosure)" }
     .joined(separator: "\n")
   return """
-    public init() {
+    nonisolated public init() {
     \(raw: assignments)
     }
     """

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

@@ -17,10 +17,17 @@ import SwiftSyntax
 /// A synchronous function marked `@JS(.withAsync("name"))` also binds a promise-returning variant
 /// under that name (see `asyncVariant`). It decodes and encodes like an `async` function, and calls
 /// the function on the concurrent pool.
+///
+/// A synchronous function can take the JavaScript runtime as its last parameter,
+/// `in runtime: borrowing JavaScriptRuntime`. JavaScript doesn't see it: the binding passes the runtime
+/// of the call.
 internal struct JSFunction {
   let swiftName: String
   private(set) var jsName: String
+  /// The parameters that take JavaScript arguments, without the runtime parameter.
   let parameters: [FunctionParameterSyntax]
+  /// The label of the parameter that takes the JavaScript runtime, or `nil` when the function has none.
+  private let runtimeLabel: String?
   /// The declared return type as written, or `nil` when the function returns `Void`/nothing.
   let returnType: String?
   /// How the return value encodes when its type mentions `Any`, or `nil` for any other type.
@@ -39,7 +46,9 @@ internal struct JSFunction {
     self.swiftName = funcDecl.name.text
     self.jsName = jsNameArgument(of: attribute) ?? withoutBackticks(funcDecl.name.text)
     self.nameToken = funcDecl.name
-    self.parameters = Array(funcDecl.signature.parameterClause.parameters)
+    let declaredParameters = funcDecl.signature.parameterClause.parameters
+    self.parameters = declaredParameters.filter { !isRuntimeParameter($0) }
+    self.runtimeLabel = declaredParameters.first(where: isRuntimeParameter)?.firstName.text
 
     let declaredReturnType = funcDecl.signature.returnClause?.type
     self.returnType = isVoidType(declaredReturnType) ? nil : declaredReturnType?.trimmedDescription
@@ -264,6 +273,9 @@ internal struct JSFunction {
       }
       callArguments.append(label == "_" ? value : "\(label): \(value)")
     }
+    if let runtimeLabel {
+      callArguments.append(runtimeLabel == "_" ? "runtime" : "\(runtimeLabel): runtime")
+    }
     return callArguments.joined(separator: ", ")
   }
 
@@ -338,12 +350,14 @@ internal struct JSFunction {
     // returns nothing binds through the `Void` overload (`JavaScriptRuntime.VoidFunctionClosure`)
     // instead, which leaves JS's result as `undefined`. A call through it is faster than through a
     // result-slot closure that writes nothing. The closure declares `-> Void` because a body of several
-    // statements without a `return` is otherwise ambiguous between the overloads.
+    // statements without a `return` is otherwise ambiguous between the overloads. A function that takes
+    // the runtime binds through the result-slot overload even when it returns nothing, so it gets the
+    // runtime as the closure's parameter instead of capturing the decorator's.
     let captures = receiver.captureClause
     let parameters =
       isAsync
       ? "(this: borrowing JavaScriptUnownedValue, arguments: consuming JavaScriptValuesBuffer)"
-      : returnType == nil
+      : returnType == nil && runtimeLabel == nil
         ? "(this: borrowing JavaScriptUnownedValue, arguments: consuming JavaScriptValuesBuffer) -> Void"
         : resultSlotClosureParameters
 

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

@@ -4,12 +4,18 @@ import SwiftSyntax
 /// have a single constructor). Instead of a `Constructor { … }` DSL entry, the macro synthesizes an
 /// override of `SharedObject._constructSharedObject(...)` that decodes the JS arguments and returns a
 /// fresh instance; unlike the method/property bindings it produces the native instance rather than
-/// recovering one.
+/// recovering one. Like a function, it can take the JavaScript runtime as its last parameter.
 internal struct JSConstructor {
+  /// The parameters that take JavaScript arguments, without the runtime parameter.
   let parameters: [FunctionParameterSyntax]
+  /// The label of the parameter that takes the JavaScript runtime, or `nil` when the initializer has
+  /// none.
+  private let runtimeLabel: String?
 
   init(initDecl: InitializerDeclSyntax) {
-    self.parameters = Array(initDecl.signature.parameterClause.parameters)
+    let declaredParameters = initDecl.signature.parameterClause.parameters
+    self.parameters = declaredParameters.filter { !isRuntimeParameter($0) }
+    self.runtimeLabel = declaredParameters.first(where: isRuntimeParameter)?.firstName.text
   }
 
   /// The body statements, indented with `indent`: arity guard, per-argument decode through
@@ -39,6 +45,9 @@ internal struct JSConstructor {
       let label = parameter.firstName.text
       callArguments.append(label == "_" ? "arg\(index)" : "\(label): arg\(index)")
     }
+    if let runtimeLabel {
+      callArguments.append(runtimeLabel == "_" ? "runtime" : "\(runtimeLabel): runtime")
+    }
 
     lines.append("return \(typeName)(\(callArguments.joined(separator: ", ")))")
 

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

@@ -128,6 +128,17 @@ internal func isOptionalType(_ type: TypeSyntax) -> Bool {
   return false
 }
 
+/// True when the parameter takes the JavaScript runtime instead of a JavaScript argument: its type,
+/// without specifiers, is written as `JavaScriptRuntime` (or `….JavaScriptRuntime`), or as an optional
+/// of it. The binding passes the runtime of the call, and JavaScript doesn't see the parameter. `@JS`
+/// requires it to be the last parameter, labeled `in` or `runtime`, `borrowing` and not optional (see
+/// `diagnoseRuntimeParameter`). A macro can't resolve types, so a typealias or a subclass of
+/// `JavaScriptRuntime` isn't detected.
+internal func isRuntimeParameter(_ parameter: FunctionParameterSyntax) -> Bool {
+  let type = SpecifiedType(parameter.type).type
+  return baseIdentifier(of: optionalWrappedType(type) ?? type) == "JavaScriptRuntime"
+}
+
 /// A parameter's type split from the specifiers written in front of it (`borrowing`, `consuming`,
 /// `sending`, `inout`, `isolated`, ...). The specifiers aren't part of the type: the decode call and
 /// the conformance assertion need the bare type (`borrowing Point.decode(...)` isn't valid Swift), and
@@ -620,8 +631,9 @@ internal func isExcludedByModifier(_ modifiers: DeclModifierListSyntax) -> Bool
 
 /// True if the type's inheritance clause already lists a protocol with the given name. Matches
 /// either the bare identifier (`Record`) or a qualified member access ending in the name
-/// (`ExpoModulesCore.Record`). Used by the extension macros to skip a conformance the author already
-/// spelled out. Works for `struct`, `class`, and `enum` declarations; any other declaration kind has no
+/// (`ExpoModulesCore.Record`), also with `nonisolated` or an attribute such as `@preconcurrency`
+/// before it. Used by the extension macros to skip a conformance the author already spelled out.
+/// Works for `struct`, `class`, and `enum` declarations; any other declaration kind has no
 /// inheritance clause to read and reports `false`.
 internal func inheritsProtocol(named name: String, in declaration: some DeclGroupSyntax) -> Bool {
   let inheritanceClause: InheritanceClauseSyntax?
@@ -637,5 +649,11 @@ internal func inheritsProtocol(named name: String, in declaration: some DeclGrou
   guard let inherited = inheritanceClause?.inheritedTypes else {
     return false
   }
-  return inherited.contains { baseIdentifier(of: $0.type) == name }
+  return inherited.contains { entry in
+    var type = entry.type
+    while let attributed = type.as(AttributedTypeSyntax.self) {
+      type = attributed.baseType
+    }
+    return baseIdentifier(of: type) == name
+  }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-modules-macros",
-  "version": "0.33.0",
+  "version": "0.34.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.33.0",
-    "@expo/modules-macros-linux-x64": "0.33.0",
-    "@expo/modules-macros-win32-arm64": "0.33.0",
-    "@expo/modules-macros-win32-x64": "0.33.0"
+    "@expo/modules-macros-linux-arm64": "0.34.0",
+    "@expo/modules-macros-linux-x64": "0.34.0",
+    "@expo/modules-macros-win32-arm64": "0.34.0",
+    "@expo/modules-macros-win32-x64": "0.34.0"
   }
 }