expo-modules-macros 0.28.0 → 0.29.0

package/.github/workflows/linux.yml

@@ -15,7 +15,6 @@ concurrency:
 
 defaults:
   run:
-    working-directory: apple
     shell: bash
 
 jobs:
@@ -56,8 +55,8 @@ jobs:
       - name: Cache SwiftPM build
         uses: actions/cache@55cc8345863c7cc4c66a329aec7e433d2d1c52a9 # v6.1.0
         with:
-          path: apple/.build
-          key: spm-${{ github.repository }}-${{ runner.os }}-${{ matrix.arch }}-${{ hashFiles('apple/Package.resolved') }}
+          path: .build
+          key: spm-${{ github.repository }}-${{ runner.os }}-${{ matrix.arch }}-${{ hashFiles('Package.resolved') }}
           restore-keys: |
             spm-${{ github.repository }}-${{ runner.os }}-${{ matrix.arch }}-
 
@@ -70,14 +69,13 @@ jobs:
       - name: Build release tool
         # Runs `pnpm run build` (scripts/build.js): builds the release plugin binary for this
         # architecture as platforms/linux-<arch>/ExpoModulesMacros.
-        working-directory: ${{ github.workspace }}
         run: pnpm run build
 
       - name: Verify the release tool
         # With no arguments it is the plugin server, which exits when stdin closes; with arguments it
         # is the scanner CLI.
         run: |
-          tool="../platforms/linux-${{ matrix.arch }}/ExpoModulesMacros"
+          tool="platforms/linux-${{ matrix.arch }}/ExpoModulesMacros"
           # The Swift runtime must be linked in statically, so no Swift library may be a dependency.
           needed="$(readelf --dynamic "$tool" | sed -n 's/.*(NEEDED).*\[\(.*\)\]$/\1/p')"
           echo "Needed libraries:" $needed
@@ -98,7 +96,6 @@ jobs:
         # Checks what `npm pack` would publish from `platforms/linux-<arch>`, where the release build
         # put the tool: the executable with its executable bit, the README, the license and the
         # manifest, with the `os`, `cpu` and `libc` fields for this machine.
-        working-directory: ${{ github.workspace }}
         run: |
           # The `./` matters: npm reads `platforms/linux-<arch>` as a GitHub repository.
           npm pack "./platforms/linux-${{ matrix.arch }}" --pack-destination "$RUNNER_TEMP" --json > "$RUNNER_TEMP/pack.json"
@@ -126,7 +123,6 @@ jobs:
       - name: Scan through the TypeScript wrapper
         # Installs the packed platform package. The wrapper must find the executable in
         # `@expo/modules-macros-linux-<arch>`, as it would in a project, not the local build.
-        working-directory: ${{ github.workspace }}
         run: |
           pnpm install
           pnpm add --save-optional "$PLATFORM_PACKAGE_TARBALL"

package/.github/workflows/publish.yml

@@ -284,14 +284,13 @@ jobs:
       - name: Cache SwiftPM build
         uses: actions/cache@55cc8345863c7cc4c66a329aec7e433d2d1c52a9 # v6.1.0
         with:
-          path: apple/.build
-          key: spm-${{ github.repository }}-${{ runner.os }}-${{ hashFiles('apple/Package.resolved') }}
+          path: .build
+          key: spm-${{ github.repository }}-${{ runner.os }}-${{ hashFiles('Package.resolved') }}
           restore-keys: |
             spm-${{ github.repository }}-${{ runner.os }}-
 
       - name: Resolve dependencies
         run: swift package resolve
-        working-directory: apple
 
       - name: Install dependencies
         # The wrapper's `prepublishOnly` build needs `tsc`; the tool binary needs none.

package/.github/workflows/swift.yml

@@ -11,10 +11,6 @@ concurrency:
   group: ci-${{ github.workflow }}-${{ github.ref }}
   cancel-in-progress: true
 
-defaults:
-  run:
-    working-directory: apple
-
 jobs:
   build-and-test:
     name: Build & test
@@ -34,8 +30,8 @@ jobs:
       - name: Cache SwiftPM build
         uses: actions/cache@55cc8345863c7cc4c66a329aec7e433d2d1c52a9 # v6.1.0
         with:
-          path: apple/.build
-          key: spm-${{ github.repository }}-${{ runner.os }}-${{ hashFiles('apple/Package.resolved') }}
+          path: .build
+          key: spm-${{ github.repository }}-${{ runner.os }}-${{ hashFiles('Package.resolved') }}
           restore-keys: |
             spm-${{ github.repository }}-${{ runner.os }}-
 
@@ -46,26 +42,24 @@ jobs:
         # Runs `pnpm run build` (scripts/build.js): builds the universal
         # (arm64 + x86_64) release plugin binary, copies it to
         # apple/ExpoModulesMacros, and strips it.
-        working-directory: ${{ github.workspace }}
         run: pnpm run build
 
       - name: Verify universal binary
         run: |
-          archs="$(lipo -archs ExpoModulesMacros)"
+          archs="$(lipo -archs apple/ExpoModulesMacros)"
           echo "Architectures: $archs"
           case "$archs" in *arm64*) ;; *) echo "Missing arm64 slice"; exit 1;; esac
           case "$archs" in *x86_64*) ;; *) echo "Missing x86_64 slice"; exit 1;; esac
-          arch -arm64 ./ExpoModulesMacros < /dev/null
-          arch -x86_64 ./ExpoModulesMacros < /dev/null
+          arch -arm64 apple/ExpoModulesMacros < /dev/null
+          arch -x86_64 apple/ExpoModulesMacros < /dev/null
           # With arguments the same binary runs the scanner CLI instead of the plugin server.
-          arch -arm64 ./ExpoModulesMacros --help > /dev/null
-          arch -x86_64 ./ExpoModulesMacros --help > /dev/null
+          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
-        working-directory: ${{ github.workspace }}
         run: |
           pnpm install
           pnpm run typecheck

package/.github/workflows/windows.yml

@@ -13,10 +13,6 @@ concurrency:
   group: ci-${{ github.workflow }}-${{ github.ref }}
   cancel-in-progress: true
 
-defaults:
-  run:
-    working-directory: apple
-
 jobs:
   windows:
     name: Build & test (Windows ${{ matrix.arch }})
@@ -56,8 +52,8 @@ jobs:
       - name: Cache SwiftPM build
         uses: actions/cache@55cc8345863c7cc4c66a329aec7e433d2d1c52a9 # v6.1.0
         with:
-          path: apple/.build
-          key: spm-${{ github.repository }}-${{ runner.os }}-${{ matrix.arch }}-${{ hashFiles('apple/Package.resolved') }}
+          path: .build
+          key: spm-${{ github.repository }}-${{ runner.os }}-${{ matrix.arch }}-${{ hashFiles('Package.resolved') }}
           restore-keys: |
             spm-${{ github.repository }}-${{ runner.os }}-${{ matrix.arch }}-
 
@@ -70,7 +66,6 @@ jobs:
       - name: Build release tool
         # Runs `pnpm run build` (scripts/build.js): builds the release plugin binary for this
         # architecture as platforms/win32-<arch>/ExpoModulesMacros.exe.
-        working-directory: ${{ github.workspace }}
         run: pnpm run build
 
       - name: Verify the release tool
@@ -79,7 +74,7 @@ jobs:
         # is the scanner CLI.
         shell: pwsh
         run: |
-          $exe = (Resolve-Path "../platforms/win32-${{ matrix.arch }}/ExpoModulesMacros.exe").Path
+          $exe = (Resolve-Path "platforms/win32-${{ matrix.arch }}/ExpoModulesMacros.exe").Path
           $env:PATH = "$env:SystemRoot\System32;$env:SystemRoot"
           cmd /c "`"$exe`" < NUL"
           if ($LASTEXITCODE -ne 0) { throw "The plugin server exited with $LASTEXITCODE" }
@@ -90,7 +85,6 @@ jobs:
         # Checks what `npm pack` would publish from `platforms/win32-<arch>`, where the release build
         # put the tool: the executable, the README, the license and the manifest, with the `os` and
         # `cpu` fields for this machine.
-        working-directory: ${{ github.workspace }}
         shell: pwsh
         run: |
           # The `./` matters: npm reads `platforms/win32-<arch>` as a GitHub repository.
@@ -109,7 +103,6 @@ jobs:
       - name: Scan through the TypeScript wrapper
         # Installs the packed platform package. The wrapper must find the executable in
         # `@expo/modules-macros-win32-<arch>`, as it would in a project, not the local build.
-        working-directory: ${{ github.workspace }}
         shell: pwsh
         run: |
           pnpm install

package/AGENTS.md

@@ -4,9 +4,11 @@
 
 ## Layout
 
-- `apple/Package.swift`: the SwiftPM package. The test targets are declared only when `apple/Tests` exists, because the published npm package leaves it out.
-- `apple/Sources/ExpoModulesMacros`: the compiler plugin executable. `Plugin.swift` registers the macros of `ProvidedMacro.all` in `providingMacros` and holds the entry point that sends any invocation with arguments to the CLI. `Macros/` holds one file per macro, and `Support/` the code that several macros share. `ProvidedMacros.swift` lists every macro with its attribute name and conformances in `ProvidedMacro.all`, and `Expand/MacroExpander.swift` runs the macros in process for `expand`, because only this executable target can see them.
-- `apple/Sources/ExpoModulesCLI`: the library behind the command-line tool. `CLI.swift` parses the arguments, `Commands/` holds one directory per subcommand (`ScanModules/` for autolinking, `ScanExports/` for type generation, `Expand/` for the report types and the output of `expand`, which gets the expansion from the executable as a `MacroExpander`), and `Core/` holds the shared parsing, `#if` evaluation and output.
+- `Package.swift`: the SwiftPM package, at the root so that its identity is `expo-modules-macros` (an `apple/` manifest would have the identity `apple`, which conflicts with other packages that keep theirs in `apple/`). The targets name their paths under `apple/`. The `ExpoModulesMacrosPlugin` library product vends the macro target to Swift packages, and its name must differ from the target's. The test targets are declared only when `apple/Tests` exists, because the published npm package leaves it out.
+- `apple/Sources/ExpoModulesMacrosCore`: the macro implementations, in a library target so that both executables below can link them. `Macros/` holds one file per macro, and `Support/` the code that several macros share. `ProvidedMacros.swift` lists every macro with its attribute name and conformances in `ProvidedMacro.all`. `PluginServer.swift` runs the compiler plugin protocol with a provider that resolves the macros of `ProvidedMacro.all` by type name, because the default `CompilerPlugin` lookup expects them in a module named `ExpoModulesMacros`. It uses the `@_spi(PluginMessage)` API of swift-syntax.
+- `apple/Sources/ExpoModulesMacros`: the `.macro` target that the `ExpoModulesMacrosPlugin` product vends to Swift packages. It only runs the plugin server, so Swift packages don't compile the CLI.
+- `apple/Sources/ExpoModulesMacrosTool`: the executable that ships as `apple/ExpoModulesMacros` and in the Windows and Linux packages. `main.swift` runs the plugin server without arguments and sends any invocation with arguments to the CLI.
+- `apple/Sources/ExpoModulesCLI`: the library behind the command-line tool. `CLI.swift` parses the arguments, `Commands/` holds one directory per subcommand (`ScanModules/` for autolinking, `ScanExports/` for type generation, `Expand/` for `expand`, with `MacroExpander.swift`, which runs the macros in process), and `Core/` holds the shared parsing, `#if` evaluation and output.
 - `apple/Sources/ExpoModulesOptimized`: declarations for the `@OptimizedFunction` macro.
 - `apple/Tests`: `ExpoModulesMacrosTests` (expansion tests) and `ExpoModulesCLITests`.
 - `platforms/`: the Windows packages `@expo/modules-macros-win32-x64` and `-arm64`, and the Linux packages `@expo/modules-macros-linux-x64` and `-arm64` (a `package.json` with `os` and `cpu`, plus `libc` on Linux, a README and a copy of `LICENSE`). The Publish workflow runs `scripts/set-platform-versions.js` to give them the version of this package. Their `ExpoModulesMacros.exe` (Windows) or `ExpoModulesMacros` (Linux) is written there by `pnpm run build` on that platform and isn't committed.
@@ -20,8 +22,8 @@
 Swift 6.2 is required (Xcode 26 or newer on macOS). The package manager is pnpm, at the version in `packageManager` in `package.json`.
 
 ```sh
-cd apple && swift build      # debug build
-cd apple && swift test       # all Swift tests
+swift build                  # debug build
+swift test                   # all Swift tests
 pnpm install                 # TypeScript dependencies
 pnpm run typecheck           # TypeScript wrapper
 pnpm run build               # release binary (slow; on macOS uses Rosetta for x86_64)
@@ -56,7 +58,7 @@ CI runs on macOS (`.github/workflows/swift.yml`), on Windows x64 and arm64 (`.gi
 
 - 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 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/ExpoModulesMacros/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`.
+- 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
 
@@ -64,6 +66,7 @@ CI runs on macOS (`.github/workflows/swift.yml`), on Windows x64 and arm64 (`.gi
 - **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, bump its version and update the matching `SUPPORTED_*_SCHEMA_VERSION` constant and mirror types in `src/types.ts`. `expo-modules-autolinking` also checks the `scan-modules` version.
 - **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`.
+- **Swift packages depend on the product.** A Swift package that declares or uses the macros depends on the `ExpoModulesMacrosPlugin` product and builds the plugin from source, without the binary. Renaming the product or the macro target, or moving `Package.swift`, needs a matching change in `expo/expo`.
 
 ## Releases
 
@@ -74,4 +77,4 @@ CI runs on macOS (`.github/workflows/swift.yml`), on Windows x64 and arm64 (`.gi
 
 ## Installed copies
 
-In `node_modules`, the compiler runs the prebuilt binary `apple/ExpoModulesMacros` (on Windows and Linux, the binary from `@expo/modules-macros-<platform>-<arch>`); editing the Swift sources there has no effect. Macro and scanner fixes belong in this repository and ship in a new release. The TypeScript wrapper ships compiled in `build/`, since `src/` is not published.
+In `node_modules`, a CocoaPods build runs the prebuilt binary `apple/ExpoModulesMacros` (on Windows and Linux, the binary from `@expo/modules-macros-<platform>-<arch>`); editing the Swift sources there has no effect. Macro and scanner fixes belong in this repository and ship in a new release. The TypeScript wrapper ships compiled in `build/`, since `src/` is not published.

package/Package.swift

@@ -0,0 +1,110 @@
+// swift-tools-version: 6.2
+// The swift-tools-version declares the minimum version of Swift required to build this package.
+
+import CompilerPluginSupport
+import Foundation
+import PackageDescription
+
+let package = Package(
+  name: "ExpoModulesMacros",
+  platforms: [.macOS(.v13)],
+  products: [
+    // Lets a SwiftPM package depend on the macros, so the compiler builds and loads the plugin from
+    // source, with no `-load-plugin-executable` flag. A target that declares the macros with
+    // `#externalMacro(module: "ExpoModulesMacros", ...)` depends on this product, and the targets that
+    // depend on it get the plugin too. CocoaPods builds keep loading the prebuilt binary. The name
+    // differs from the macro target's, because SwiftPM already has a product of that name for it.
+    .library(name: "ExpoModulesMacrosPlugin", targets: ["ExpoModulesMacros"]),
+    .executable(name: "ExpoModulesMacrosTool", targets: ["ExpoModulesMacrosTool"]),
+  ],
+  dependencies: [
+    .package(url: "https://github.com/swiftlang/swift-syntax.git", from: "604.0.0-latest")
+  ],
+  targets: [
+    // The macro implementations, shared by the plugin and the tool. The macro target can't be a
+    // dependency of an executable, so they live in a library target.
+    .target(
+      name: "ExpoModulesMacrosCore",
+      dependencies: [
+        .product(name: "SwiftSyntax", package: "swift-syntax"),
+        .product(name: "SwiftSyntaxBuilder", package: "swift-syntax"),
+        .product(name: "SwiftSyntaxMacros", package: "swift-syntax"),
+        .product(name: "SwiftDiagnostics", package: "swift-syntax"),
+        // For the plugin server, which resolves the macros by type name (see PluginServer.swift).
+        .product(name: "_SwiftCompilerPluginMessageHandling", package: "swift-syntax"),
+      ],
+      path: "apple/Sources/ExpoModulesMacrosCore"
+    ),
+    // The plugin that Swift packages build from source. It serves only the macros, so it doesn't
+    // compile the CLI. It lists the swift-syntax products of the implementation again: when SwiftPM
+    // uses its prebuilt swift-syntax, it links the prebuilt library only for the products that the
+    // macro target itself depends on, and the link fails without them.
+    .macro(
+      name: "ExpoModulesMacros",
+      dependencies: [
+        "ExpoModulesMacrosCore",
+        .product(name: "SwiftSyntax", package: "swift-syntax"),
+        .product(name: "SwiftSyntaxBuilder", package: "swift-syntax"),
+        .product(name: "SwiftSyntaxMacros", package: "swift-syntax"),
+        .product(name: "SwiftDiagnostics", package: "swift-syntax"),
+        .product(name: "SwiftCompilerPlugin", package: "swift-syntax"),
+      ],
+      path: "apple/Sources/ExpoModulesMacros"
+    ),
+    // The shipped binary, `apple/ExpoModulesMacros` and the Windows and Linux binaries. It is both the
+    // compiler plugin and the scanner CLI: the compiler launches it without arguments and speaks the
+    // plugin protocol over stdin, while an invocation with arguments dispatches into `ScannerCLI`
+    // (see main.swift). CocoaPods builds, `expo-modules-autolinking` and `expo-modules-cli` all
+    // use this one executable.
+    .executableTarget(
+      name: "ExpoModulesMacrosTool",
+      dependencies: [
+        "ExpoModulesCLI",
+        "ExpoModulesMacrosCore",
+      ],
+      path: "apple/Sources/ExpoModulesMacrosTool"
+    ),
+    .target(
+      name: "ExpoModulesCLI",
+      dependencies: [
+        "ExpoModulesMacrosCore",
+        .product(name: "SwiftSyntax", package: "swift-syntax"),
+        .product(name: "SwiftParser", package: "swift-syntax"),
+        .product(name: "SwiftIfConfig", package: "swift-syntax"),
+        // For `expand`, which runs the macros in process.
+        .product(name: "SwiftSyntaxMacros", package: "swift-syntax"),
+        .product(name: "SwiftSyntaxMacroExpansion", package: "swift-syntax"),
+        .product(name: "SwiftParserDiagnostics", package: "swift-syntax"),
+        .product(name: "SwiftBasicFormat", package: "swift-syntax"),
+        .product(name: "SwiftDiagnostics", package: "swift-syntax"),
+      ],
+      path: "apple/Sources/ExpoModulesCLI"
+    ),
+  ]
+)
+
+// The Tests directory is excluded from the published npm package,
+// so only declare the test target when building from the repository.
+if FileManager.default.fileExists(atPath: Context.packageDirectory + "/apple/Tests") {
+  package.targets.append(
+    .testTarget(
+      name: "ExpoModulesMacrosTests",
+      dependencies: [
+        "ExpoModulesMacrosCore",
+        "ExpoModulesCLI",
+        .product(name: "SwiftSyntaxMacrosGenericTestSupport", package: "swift-syntax"),
+      ],
+      path: "apple/Tests/ExpoModulesMacrosTests"
+    )
+  )
+  package.targets.append(
+    .testTarget(
+      name: "ExpoModulesCLITests",
+      dependencies: [
+        "ExpoModulesCLI",
+        .product(name: "SwiftParser", package: "swift-syntax"),
+      ],
+      path: "apple/Tests/ExpoModulesCLITests"
+    )
+  )
+}

package/README.md

@@ -13,7 +13,7 @@ The same executable doubles as a source scanner CLI.
 
 # Installation
 
-This package is not meant to be installed directly. It is a dependency of `expo-modules-core`, so every Expo project already has it. The published package contains a prebuilt universal (arm64 + x86_64) macOS binary at `apple/ExpoModulesMacros`, so consumers never build the plugin themselves.
+This package is not meant to be installed directly. It is a dependency of `expo-modules-core`, so every Expo project already has it. The published package contains a prebuilt universal (arm64 + x86_64) macOS binary at `apple/ExpoModulesMacros`, so CocoaPods builds never build the plugin themselves. A Swift package can build it from source instead (see [Swift packages](#swift-packages)).
 
 The Windows and Linux binaries ship in their own packages, one per platform and architecture:
 
@@ -145,16 +145,33 @@ The binary is a compiled executable, so each call still spawns a process. What t
 
 to `OTHER_SWIFT_FLAGS` for `ExpoModulesCore`, every pod that depends on it, and their test specs. Expo's SPM prebuilds pass the same flag when they generate `Package.swift`, so both build systems load the same binary.
 
+## Swift packages
+
+The package manifest is `Package.swift` at the root of this package, so a Swift package can depend on it by its path in `node_modules` or by the URL of this repository. Its identity is then `expo-modules-macros`. The `ExpoModulesMacrosPlugin` library product holds the `ExpoModulesMacros` macro target:
+
+```swift
+dependencies: [
+  .package(path: "../node_modules/expo-modules-macros")
+],
+targets: [
+  .target(
+    name: "ExpoModulesCore",
+    dependencies: [.product(name: "ExpoModulesMacrosPlugin", package: "expo-modules-macros")]
+  )
+]
+```
+
+SwiftPM then builds the plugin from source for the host (the macros, without the scanner CLI) and loads it into every target that depends on that target, with no `-load-plugin-executable` flag and no unsafe flags. When the resolved swift-syntax version is a release, SwiftPM and Xcode can use their prebuilt swift-syntax for it, so only the sources of this package compile.
+
 On Windows and Linux, the compiler loads `ExpoModulesMacros.exe` from `@expo/modules-macros-win32-<arch>` or `ExpoModulesMacros` from `@expo/modules-macros-linux-<arch>` with the same flag. `getScannerBinaryPath()` in the TypeScript wrapper returns the binary for the current platform and architecture. On Windows and Linux it falls back to the local `pnpm run build` output in `platforms/<platform>-<arch>` when the platform package isn't installed, for example in this repository.
 
-The module and type names in `#externalMacro` must stay in sync with `apple/Sources/ExpoModulesMacros/Plugin.swift`.
+The module and type names in `#externalMacro` must stay in sync with `ProvidedMacro.all` in `apple/Sources/ExpoModulesMacrosCore/ProvidedMacros.swift`.
 
 # Development
 
 Requires a toolchain with Swift 6.2 or newer: on macOS 13 or newer that means Xcode 26 or newer, and on Windows and Linux the Swift toolchain from swift.org (CI uses 6.4).
 
 ```sh
-cd apple
 swift build
 swift test
 ```
@@ -174,7 +191,7 @@ cp "$(cd /tmp/swift-format && swift build -c release --show-bin-path)/swift-form
 
 Then add `~/.local/bin` to `PATH`.
 
-`pnpm run build` runs `scripts/build.js`, which builds the release binary with SwiftPM's native build system (Swift Build, the default since Swift 6.4, doesn't build a macro tool that no target in the package uses).
+`pnpm run build` runs `scripts/build.js`, which builds the release binary, the `ExpoModulesMacrosTool` executable, with SwiftPM's native build system.
 
 - On macOS, it builds for arm64 and x86_64, merges the slices into `apple/ExpoModulesMacros` with `lipo`, strips it, and verifies both slices are present. SwiftPM only builds macro tools for the host architecture, so the x86_64 slice is produced by running the toolchain under Rosetta; the script installs Rosetta if it is missing.
 - On Windows, it builds for the host architecture only, with the Swift runtime linked in statically and without debug info, and writes `platforms/win32-<arch>/ExpoModulesMacros.exe` (`x64` or `arm64`, as Node's `process.arch` names them), the file that the package for that architecture publishes. It strips the executable with `llvm-strip` from the Swift toolchain and checks the architecture in its header.

package/apple/Sources/ExpoModulesCLI/CLI.swift

@@ -110,7 +110,7 @@ public enum ScannerCLI {
 }
 
 /// The invoked executable's basename, so the usage text matches however the tool was launched
-/// (the `ExpoModulesMacros` shipped in the package, or a locally built `ExpoModulesMacros-tool`).
+/// (the `ExpoModulesMacros` shipped in the package, or a locally built `ExpoModulesMacrosTool`).
 private var toolName: String {
   guard let path = CommandLine.arguments.first else {
     return "ExpoModulesMacros"

package/apple/Sources/{ExpoModulesMacros → ExpoModulesCLI/Commands}/Expand/MacroExpander.swift

@@ -1,4 +1,4 @@
-import ExpoModulesCLI
+import ExpoModulesMacrosCore
 import SwiftBasicFormat
 import SwiftDiagnostics
 import SwiftParser

package/apple/Sources/ExpoModulesMacros/main.swift

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

package/apple/Sources/ExpoModulesMacrosCore/PluginServer.swift

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

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

@@ -3,15 +3,15 @@ import SwiftSyntaxMacros
 
 /// A macro that the plugin provides, with the attribute name and the extension conformances of its
 /// declaration in `expo-modules-core`.
-struct ProvidedMacro {
-  let name: String
-  let type: Macro.Type
-  var conformances: [TypeSyntax] = []
+public struct ProvidedMacro {
+  public let name: String
+  public let type: Macro.Type
+  public var conformances: [TypeSyntax] = []
 
   /// Every macro of the plugin. The compiler gets the types from `providingMacros`, and `expand`
   /// matches the attributes by name and passes the same conformances as the compiler, so both read
   /// this list.
-  static var all: [ProvidedMacro] {
+  public static var all: [ProvidedMacro] {
     [
       ProvidedMacro(name: "OptimizedFunction", type: OptimizedFunctionAttachedMacro.self),
       ProvidedMacro(name: "JS", type: JSMacro.self),

package/apple/Sources/{ExpoModulesMacros → ExpoModulesMacrosCore}/Support/MacroHelpers.swift

@@ -524,7 +524,7 @@ internal func encodeCall(_ type: String, freeForm: FreeFormConversion?, of value
 /// `name` without the backticks that escape it: `` `default` `` becomes `default`. Swift needs the
 /// backticks in every identifier position, but a name JavaScript sees (a JS member name, an event
 /// name, a record key) is the bare name.
-internal func withoutBackticks(_ name: String) -> String {
+public func withoutBackticks(_ name: String) -> String {
   var name = Substring(name)
   while name.first == "`" {
     name.removeFirst()

package/apple/Sources/ExpoModulesMacrosTool/main.swift

@@ -0,0 +1,27 @@
+import ExpoModulesCLI
+import ExpoModulesMacrosCore
+
+#if canImport(Darwin)
+import Darwin
+#elseif canImport(Glibc)
+import Glibc
+#elseif os(Windows)
+import CRT
+#endif
+
+// The binary that this package ships as `ExpoModulesMacros`: the compiler plugin, which CocoaPods
+// builds load, and the scanner CLI, which `expo-modules-autolinking` and `expo-modules-cli` run. The
+// compiler always launches a plugin executable without arguments and speaks the plugin protocol over
+// stdin, so any argument means a scanner invocation (`ExpoModulesMacros scan-modules <path>...`);
+// with none, this starts the plugin server. The CLI gets `expandMacros`, so `expand` runs the macros
+// of this executable.
+let arguments = Array(CommandLine.arguments.dropFirst())
+if arguments.isEmpty {
+  try runPluginServer()
+} else {
+  let expander = MacroExpander(
+    attributeNames: Set(ProvidedMacro.all.map(\.name)),
+    expand: expandMacros
+  )
+  exit(ScannerCLI.run(arguments: arguments, expander: expander))
+}

package/package.json

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

package/apple/Package.swift

@@ -1,66 +0,0 @@
-// swift-tools-version: 6.2
-// The swift-tools-version declares the minimum version of Swift required to build this package.
-
-import CompilerPluginSupport
-import Foundation
-import PackageDescription
-
-let package = Package(
-  name: "ExpoModulesMacros",
-  platforms: [.macOS(.v13)],
-  dependencies: [
-    .package(url: "https://github.com/swiftlang/swift-syntax.git", from: "604.0.0-latest")
-  ],
-  targets: [
-    // The plugin executable doubles as the scanner CLI: the compiler launches it without arguments
-    // and speaks the plugin protocol over stdin, while an invocation with arguments dispatches into
-    // `ScannerCLI` (see the entry point in Plugin.swift). Sharing the binary keeps the package to a
-    // single shipped executable; the scanner adds little on top of the SwiftSyntax the macros
-    // already link.
-    .macro(
-      name: "ExpoModulesMacros",
-      dependencies: [
-        "ExpoModulesCLI",
-        .product(name: "SwiftSyntaxMacros", package: "swift-syntax"),
-        .product(name: "SwiftCompilerPlugin", package: "swift-syntax"),
-        // For `expand`, which runs the macros in process.
-        .product(name: "SwiftSyntaxMacroExpansion", package: "swift-syntax"),
-        .product(name: "SwiftParser", package: "swift-syntax"),
-        .product(name: "SwiftParserDiagnostics", package: "swift-syntax"),
-        .product(name: "SwiftBasicFormat", package: "swift-syntax"),
-      ]
-    ),
-    .target(
-      name: "ExpoModulesCLI",
-      dependencies: [
-        .product(name: "SwiftSyntax", package: "swift-syntax"),
-        .product(name: "SwiftParser", package: "swift-syntax"),
-        .product(name: "SwiftIfConfig", package: "swift-syntax"),
-      ]
-    ),
-  ]
-)
-
-// The Tests directory is excluded from the published npm package,
-// so only declare the test target when building from the repository.
-if FileManager.default.fileExists(atPath: Context.packageDirectory + "/Tests") {
-  package.targets.append(
-    .testTarget(
-      name: "ExpoModulesMacrosTests",
-      dependencies: [
-        "ExpoModulesMacros",
-        "ExpoModulesCLI",
-        .product(name: "SwiftSyntaxMacrosGenericTestSupport", package: "swift-syntax"),
-      ]
-    )
-  )
-  package.targets.append(
-    .testTarget(
-      name: "ExpoModulesCLITests",
-      dependencies: [
-        "ExpoModulesCLI",
-        .product(name: "SwiftParser", package: "swift-syntax"),
-      ]
-    )
-  )
-}

package/apple/Sources/ExpoModulesMacros/Plugin.swift

@@ -1,36 +0,0 @@
-import ExpoModulesCLI
-import SwiftCompilerPlugin
-import SwiftSyntaxMacros
-
-#if canImport(Darwin)
-import Darwin
-#elseif canImport(Glibc)
-import Glibc
-#elseif os(Windows)
-import CRT
-#endif
-
-struct ExpoModulesMacrosPlugin: CompilerPlugin {
-  let providingMacros: [Macro.Type] = ProvidedMacro.all.map(\.type)
-}
-
-/// The executable doubles as the scanner CLI. The compiler always launches a plugin executable
-/// without arguments and speaks the plugin protocol over stdin, so any argument means a scanner
-/// invocation (`ExpoModulesMacros scan-modules <path>...`); with none, this starts the plugin
-/// server exactly as `@main` on the `CompilerPlugin` type would. The CLI gets `expandMacros`, so
-/// `expand` runs the macros of this executable.
-@main
-enum EntryPoint {
-  static func main() throws {
-    let arguments = Array(CommandLine.arguments.dropFirst())
-    if arguments.isEmpty {
-      try ExpoModulesMacrosPlugin.main()
-    } else {
-      let expander = MacroExpander(
-        attributeNames: Set(ProvidedMacro.all.map(\.name)),
-        expand: expandMacros
-      )
-      exit(ScannerCLI.run(arguments: arguments, expander: expander))
-    }
-  }
-}