expo-modules-macros 0.16.0 → 0.17.0-0

package/.github/workflows/publish.yml

@@ -16,15 +16,65 @@ on:
           - preminor
           - premajor
           - prerelease
+      dry_run:
+        description: Dry run (build everything and run `npm publish --dry-run`, but don't publish, commit, tag or create a release)
+        type: boolean
+        default: false
 
 concurrency:
   group: publish-${{ github.workflow }}
   cancel-in-progress: false
 
 jobs:
+  build-windows:
+    name: Build Windows tool (${{ matrix.arch }})
+    # SwiftPM builds macro tools only for the host, so each architecture builds on a runner of its own.
+    runs-on: ${{ matrix.runner }}
+    timeout-minutes: 30
+    strategy:
+      matrix:
+        include:
+          - arch: x64
+            runner: windows-latest
+            build_arch: amd64
+          - arch: arm64
+            runner: windows-11-arm
+            build_arch: arm64
+    steps:
+      - name: Checkout
+        uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5
+
+      - name: Install Swift
+        uses: compnerd/gha-setup-swift@bbae8ce86bac5a3449f3992b3d88bc4ca25f2057 # v0.5.0
+        with:
+          swift-version: swift-6.4.0-release
+          swift-build: 6.4.0-RELEASE
+          build_arch: ${{ matrix.build_arch }}
+
+      - name: Setup Node
+        uses: actions/setup-node@949feb2413d6458794dcd2491c4babbbce0c15c1 # v7.1.0
+        with:
+          node-version: 24
+
+      - name: Build release tool
+        # Runs scripts/build.js: builds the release plugin binary for this architecture as
+        # platforms/win32-<arch>/ExpoModulesMacros.exe.
+        run: npm run build
+
+      - name: Upload tool
+        uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
+        with:
+          # Named after the package directory: the publish job downloads every artifact into
+          # `platforms/`, and each one lands in a directory of its name.
+          name: win32-${{ matrix.arch }}
+          path: platforms/win32-${{ matrix.arch }}/ExpoModulesMacros.exe
+          if-no-files-found: error
+
   publish:
     name: Build and publish to npm
-    # Builds the native macOS tool binary, so it must run on macOS.
+    needs: build-windows
+    # Builds the native macOS tool binary, so it must run on macOS. The Windows binaries come from the
+    # build-windows jobs.
     # The package declares swift-tools-version 6.2, which requires Xcode 26+.
     runs-on: macos-26
     permissions:
@@ -42,9 +92,9 @@ jobs:
           token: ${{ secrets.GITHUB_TOKEN }}
 
       - name: Setup Node
-        uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4
+        uses: actions/setup-node@949feb2413d6458794dcd2491c4babbbce0c15c1 # v7.1.0
         with:
-          node-version: 22
+          node-version: 24
           registry-url: https://registry.npmjs.org
 
       - name: Update npm
@@ -64,13 +114,24 @@ jobs:
           version=$(npm version "${{ inputs.release_type }}" --no-git-tag-version)
           echo "version=$version" >> "$GITHUB_OUTPUT"
           echo "Bumping to $version"
+          # npm 11 doesn't publish a prerelease version (one with a hyphen) without a dist-tag, and
+          # it must not become `latest` anyway.
+          case "$version" in
+            *-*) tag=next ;;
+            *) tag=latest ;;
+          esac
+          echo "tag=$tag" >> "$GITHUB_OUTPUT"
+          echo "Publishing with the dist-tag $tag"
+          # The platform packages get the same version, and `expo-modules-macros` lists them as
+          # optional dependencies with that exact version.
+          node scripts/set-platform-versions.js
 
       - name: Select Xcode
         # Pin to an Xcode that ships Swift 6.2 (required by Package.swift).
         run: sudo xcode-select -switch /Applications/Xcode_26.4.1.app
 
       - name: Cache SwiftPM build
-        uses: actions/cache@0057852bfaa89a56745cba8c7296529d2fc39830 # v4
+        uses: actions/cache@55cc8345863c7cc4c66a329aec7e433d2d1c52a9 # v6.1.0
         with:
           path: apple/.build
           key: spm-${{ github.repository }}-${{ runner.os }}-${{ hashFiles('apple/Package.resolved') }}
@@ -86,18 +147,42 @@ jobs:
         run: npm install
 
       - name: Build release tool
-        # Runs apple/build.js: builds the release plugin binary,
+        # Runs scripts/build.js: builds the release plugin binary,
         # copies it to apple/ExpoModulesMacros, and strips it.
         run: npm run build
 
+      - name: Download Windows tools
+        # Each artifact goes into the directory of its name: `platforms/win32-<arch>`.
+        uses: actions/download-artifact@9000827ccba6bdab643e8b6fd33ac0654aef8333 # v8.0.2
+        with:
+          pattern: win32-*
+          path: platforms
+
+      - name: Verify Windows tools
+        run: ls -l platforms/win32-x64/ExpoModulesMacros.exe platforms/win32-arm64/ExpoModulesMacros.exe
+
+      - name: Publish the Windows packages
+        # Published before `expo-modules-macros`, whose optional dependencies point at them, so that
+        # package is never on npm without them. Each package needs trusted publishing (OIDC)
+        # configured on npmjs.com for this workflow.
+        env:
+          DRY_RUN: ${{ inputs.dry_run && '--dry-run' || '' }}
+        run: |
+          for arch in x64 arm64; do
+            npm publish --access public --tag "${{ steps.bump.outputs.tag }}" $DRY_RUN "./platforms/win32-$arch"
+          done
+
       - name: Publish
         # Authentication is handled via OIDC trusted publishing — no token needed.
         # npm generates provenance automatically when publishing via OIDC.
-        run: npm publish --access public
+        env:
+          DRY_RUN: ${{ inputs.dry_run && '--dry-run' || '' }}
+        run: npm publish --access public --tag "${{ steps.bump.outputs.tag }}" $DRY_RUN
 
-      # Everything below only runs once the publish above has succeeded.
+      # Everything below only runs once the publish above has succeeded, and not in a dry run.
 
       - name: Commit, tag and push
+        if: ${{ !inputs.dry_run }}
         run: |
           version="${{ steps.bump.outputs.version }}"
           git commit -am "Release $version"
@@ -107,6 +192,7 @@ jobs:
           git push --follow-tags origin HEAD
 
       - name: Create GitHub release
+        if: ${{ !inputs.dry_run }}
         env:
           GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         # Tag prerelease versions (those containing a hyphen) as prereleases.

package/.github/workflows/swift.yml

@@ -29,7 +29,7 @@ jobs:
         run: sudo xcode-select -switch /Applications/Xcode_26.4.1.app
 
       - name: Cache SwiftPM build
-        uses: actions/cache@0057852bfaa89a56745cba8c7296529d2fc39830 # v4
+        uses: actions/cache@55cc8345863c7cc4c66a329aec7e433d2d1c52a9 # v6.1.0
         with:
           path: apple/.build
           key: spm-${{ github.repository }}-${{ runner.os }}-${{ hashFiles('apple/Package.resolved') }}
@@ -40,7 +40,7 @@ jobs:
         run: swift package resolve
 
       - name: Build release tool
-        # Runs `npm run build` (apple/build.js): builds the universal
+        # Runs `npm 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 }}

package/.github/workflows/windows.yml

@@ -0,0 +1,144 @@
+name: Windows
+
+# Builds and tests the package on Windows, and checks the release tool there. The Windows binaries
+# aren't published yet, so this runs apart from the macOS workflow.
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+  workflow_dispatch: {}
+
+concurrency:
+  group: ci-${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+defaults:
+  run:
+    working-directory: apple
+
+jobs:
+  windows:
+    name: Build & test (Windows ${{ matrix.arch }})
+    runs-on: ${{ matrix.runner }}
+    # A run takes about 4 to 5 minutes. The limit stops a hang, for example in the plugin server,
+    # from holding a runner for the default 6 hours.
+    timeout-minutes: 30
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - arch: x64
+            runner: windows-latest
+            build_arch: amd64
+          - arch: arm64
+            runner: windows-11-arm
+            build_arch: arm64
+    steps:
+      - name: Checkout
+        uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5
+
+      - name: Install Swift
+        uses: compnerd/gha-setup-swift@bbae8ce86bac5a3449f3992b3d88bc4ca25f2057 # v0.5.0
+        with:
+          swift-version: swift-6.4.0-release
+          swift-build: 6.4.0-RELEASE
+          build_arch: ${{ matrix.build_arch }}
+
+      - name: Setup Node
+        uses: actions/setup-node@949feb2413d6458794dcd2491c4babbbce0c15c1 # v7.1.0
+        with:
+          node-version: 24
+
+      - 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') }}
+          restore-keys: |
+            spm-${{ github.repository }}-${{ runner.os }}-${{ matrix.arch }}-
+
+      - name: Build
+        run: swift build
+
+      - name: Test
+        run: swift test
+
+      - name: Build release tool
+        # Runs `npm run build` (scripts/build.js): builds the release plugin binary for this
+        # architecture as platforms/win32-<arch>/ExpoModulesMacros.exe.
+        working-directory: ${{ github.workspace }}
+        run: npm run build
+
+      - name: Verify the release tool
+        # Runs it with only the Windows directories on PATH, so it must not need the Swift runtime DLLs.
+        # With no arguments it is the plugin server, which exits when stdin closes; with arguments it
+        # is the scanner CLI.
+        shell: pwsh
+        run: |
+          $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" }
+          & $exe --help | Out-Null
+          if ($LASTEXITCODE -ne 0) { throw "The scanner CLI exited with $LASTEXITCODE" }
+
+      - name: Pack the platform package
+        # 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.
+          $package = "./platforms/win32-${{ matrix.arch }}"
+          $pack = npm pack $package --pack-destination $env:RUNNER_TEMP --json | ConvertFrom-Json
+          if ($LASTEXITCODE -ne 0) { throw "npm pack failed" }
+          $files = ($pack[0].files | ForEach-Object { $_.path } | Sort-Object) -join ","
+          Write-Host "$($pack[0].filename): $files ($($pack[0].size) bytes packed)"
+          if ($files -ne "ExpoModulesMacros.exe,LICENSE,package.json,README.md") { throw "Unexpected files: $files" }
+          $manifest = Get-Content "$package/package.json" -Raw | ConvertFrom-Json
+          if (($manifest.os -join ",") -ne "win32" -or ($manifest.cpu -join ",") -ne "${{ matrix.arch }}") {
+            throw "Unexpected os/cpu: $($manifest.os) / $($manifest.cpu)"
+          }
+          "PLATFORM_PACKAGE_TARBALL=$(Join-Path $env:RUNNER_TEMP $pack[0].filename)" | Out-File -FilePath $env:GITHUB_ENV -Encoding utf8 -Append
+
+      - 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: |
+          npm install
+          if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
+          npm install --no-save $env:PLATFORM_PACKAGE_TARBALL
+          if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
+          npm run build:ts
+          if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
+          $fixture = Join-Path $env:RUNNER_TEMP "scan-fixture"
+          New-Item -ItemType Directory -Force $fixture | Out-Null
+          Set-Content (Join-Path $fixture "Module.swift") "@ExpoModule`npublic final class WindowsModule {}"
+          @'
+          const path = require('node:path');
+          const { getScannerBinaryPath, scanModules } = require(path.resolve('build'));
+          const binaryPath = getScannerBinaryPath();
+          const expected = path.join('node_modules', '@expo', `modules-macros-win32-${process.arch}`, 'ExpoModulesMacros.exe');
+          if (!binaryPath.endsWith(expected)) {
+            console.error(`getScannerBinaryPath() returned ${binaryPath}, not a path ending in ${expected}`);
+            process.exit(1);
+          }
+          console.log(`getScannerBinaryPath() returned ${binaryPath}`);
+          scanModules([process.argv[2]]).then((result) => {
+            const module = result.modules.find((candidate) => candidate.name === 'WindowsModule');
+            if (!module) {
+              console.error(JSON.stringify(result, null, 2));
+              process.exit(1);
+            }
+            console.log(`scanModules reported ${module.name} in ${module.file}`);
+          }, (error) => {
+            console.error(error);
+            process.exit(1);
+          });
+          '@ | Set-Content (Join-Path $env:RUNNER_TEMP "scan-check.js")
+          node (Join-Path $env:RUNNER_TEMP "scan-check.js") $fixture

package/AGENTS.md

@@ -9,22 +9,28 @@
 - `apple/Sources/ExpoModulesScanner`: the scanner library. `Modules/` implements `scan-modules` (autolinking), `Exports/` implements `scan-exports` (type generation), `Core/` holds the shared parsing and `#if` evaluation, and `CLI.swift` is the command-line front end.
 - `apple/Sources/ExpoModulesOptimized`: declarations for the `@OptimizedFunction` macro.
 - `apple/Tests`: `ExpoModulesMacrosTests` (expansion tests) and `ExpoModulesScannerTests`.
+- `platforms/`: the Windows packages `@expo/modules-macros-win32-x64` and `-arm64` (a `package.json` with `os` and `cpu`, 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` is written there by `npm run build` on Windows and isn't committed.
 - `apple/PodTests`: a stub test so that `expo/expo` native tests can install this package as a pod. Do not add real tests here.
 - `src/`: the TypeScript wrapper around the scanner CLI. `types.ts` mirrors the Swift `Codable` output types by hand.
-- `apple/build.js`: builds the universal release binary that is committed under `apple/`.
+- `scripts/build.js` (`npm run build`): builds the release binaries: the universal macOS `apple/ExpoModulesMacros` (committed and published), and on Windows `platforms/win32-<arch>/ExpoModulesMacros.exe` for the host architecture (not committed; published in that package).
 
 ## Commands
 
-Swift 6.2 is required (Xcode 26 or newer).
+Swift 6.2 is required (Xcode 26 or newer on macOS).
 
 ```sh
 cd apple && swift build      # debug build
 cd apple && swift test       # all Swift tests
 npm run typecheck            # TypeScript wrapper
-npm run build                # universal release binary (slow; uses Rosetta for x86_64)
+npm run build                # release binary (slow; on macOS uses Rosetta for x86_64)
 ```
 
-CI (`.github/workflows/swift.yml`) runs the release build, checks both binary slices, then runs `swift test` and `npm run typecheck`.
+CI runs on macOS (`.github/workflows/swift.yml`) and on Windows x64 and arm64 (`.github/workflows/windows.yml`). On macOS it runs the release build, checks both binary slices, then runs `swift test` and `npm run typecheck`. 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, which must find the executable there. Code in `Sources` and `Tests` must not assume Apple platforms or POSIX paths.
+
+## Windows
+
+- Outside Apple platforms, `Sources` import `FoundationEssentials` instead of `Foundation` (`#if canImport(FoundationEssentials)`). Full Foundation brings in ICU, which would add tens of megabytes to the statically linked Windows binary. Don't use APIs that only `Foundation` has (`FileHandle`, `NSRegularExpression`, `CharacterSet`, `FileManager.enumerator`, `NSString` path methods); `Core/StandardStreams.swift` writes to stdout and stderr.
+- The Windows binaries link the Swift runtime statically (`-static-stdlib`), because Swift has no stable ABI on Windows and the scanner must also run without a Swift toolchain. SwiftPM's `--static-swift-stdlib` has no effect there.
 
 ## Conventions
 
@@ -46,14 +52,14 @@ CI (`.github/workflows/swift.yml`) runs the release build, checks both binary sl
 - **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 `providingMacros` in `Plugin.swift`.
 - **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` (`Modules/ScanModules.swift`) and `scanExportsSchemaVersion` (`Exports/ExportedSurface.swift`) change independently. When the output shape of a command changes, bump its version and update the matching `SUPPORTED_SCAN_*_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. Renaming or moving the binary needs a matching change in `expo/expo`.
+- **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>`. Renaming or moving a binary needs a matching change in `expo/expo`.
 
 ## Releases
 
-- Do not rebuild or commit the binary under `apple/` in a feature change. Only the **Publish** workflow (`.github/workflows/publish.yml`, manual) rebuilds it, and it commits the result as `Release vX.Y.Z` after the npm publish succeeds.
+- Do not rebuild or commit the binary under `apple/` in a feature change. Only the **Publish** workflow (`.github/workflows/publish.yml`, manual) rebuilds it, and it commits the result as `Release vX.Y.Z` after the npm publish succeeds. It also builds the Windows binaries and publishes them in the `platforms/` packages, with the same version.
 - Do not edit the `version` in `package.json` by hand. The Publish workflow bumps it.
 - Commit and PR titles are short and imperative, with code identifiers in backticks, for example ``Report `@Union` types in `scan-exports` ``.
 
 ## Installed copies
 
-In `node_modules`, the compiler runs the prebuilt binary `apple/ExpoModulesMacros`; 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`, the compiler runs the prebuilt binary `apple/ExpoModulesMacros` (on Windows, `ExpoModulesMacros.exe` from `@expo/modules-macros-win32-<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/README.md

@@ -15,6 +15,8 @@ The same executable doubles as a source scanner CLI.
 
 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.
 
+The Windows binaries ship in their own packages, `@expo/modules-macros-win32-x64` and `@expo/modules-macros-win32-arm64`, each with an `ExpoModulesMacros.exe`. This package lists them as optional dependencies, and their `os` and `cpu` fields make npm, pnpm and Yarn install only the one that matches a Windows machine, so other machines don't download them. The Swift runtime is linked in statically, so the executables run without a Swift toolchain; they need only Windows system libraries and the Microsoft Visual C++ runtime.
+
 # 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.
@@ -67,7 +69,6 @@ subcommands:
   scan-exports   deep scan of the full JS-exported surface (type generation)
 
 options (scan-modules only):
-  --platform <os>   evaluate '#if os(...)' against this platform
   --define <flag>   treat a conditional compilation flag as set; repeatable
 ```
 
@@ -96,11 +97,13 @@ 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.
 
+On Windows, the compiler loads `ExpoModulesMacros.exe` from `@expo/modules-macros-win32-<arch>` with the same flag. `getScannerBinaryPath()` in the TypeScript wrapper returns the binary for the current platform and architecture. On Windows it falls back to the local `npm run build` output in `platforms/win32-<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`.
 
 # Development
 
-Requires macOS 13 or newer and a toolchain with Swift 6.2, which means Xcode 26 or newer.
+Requires a toolchain with Swift 6.2 or newer: on macOS 13 or newer that means Xcode 26 or newer, and on Windows the Swift toolchain from swift.org (CI uses 6.4).
 
 ```sh
 cd apple
@@ -108,12 +111,21 @@ swift build
 swift test
 ```
 
-`npm run build` runs `apple/build.js`, which builds the release binary 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. The resulting binary is committed to the repository.
+`npm 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).
+
+- 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.
+
+The macOS binary is committed to the repository. The Windows binaries aren't: the Publish workflow builds them and puts them into the packages in `platforms/`.
 
 # Releasing
 
 The **Publish** workflow is manual (`workflow_dispatch`) and takes a release type. It bumps the version, builds the universal binary, and publishes to npm through OIDC trusted publishing. The commit, tag and GitHub release are created only after the publish succeeds, so a failed build leaves the branch untouched.
 
+Windows jobs (x64 and arm64) build the `.exe` files first. After the version bump, `scripts/set-platform-versions.js` gives the packages in `platforms/` the same version and lists them in this package's `optionalDependencies` with that exact version. The workflow publishes the two Windows packages before `expo-modules-macros`, so this package is never on npm without them. Each package needs trusted publishing configured on npmjs.com for the Publish workflow.
+
+Prerelease versions (`prepatch`, `preminor`, `premajor`, `prerelease`) are published with the `next` dist-tag, and the others with `latest`. With **Dry run** checked, the workflow builds everything and runs `npm publish --dry-run` for the three packages, but doesn't publish, commit, tag or create a release. Use it to check a change to the workflow.
+
 # Contributing
 
 Contributions are very welcome! Please refer to the guidelines described in the [contributing guide](https://github.com/expo/expo#contributing).

package/apple/Package.resolved

@@ -1,13 +1,13 @@
 {
-  "originHash" : "4832fa479257148c1acb46952c02540c156db6e744797638db69be31154d5ad2",
+  "originHash" : "f142f4d4b3ea8f139f9a2f206e382cf98031da4c8ea8691ddec05cb0c9d2285f",
   "pins" : [
     {
       "identity" : "swift-syntax",
       "kind" : "remoteSourceControl",
       "location" : "https://github.com/swiftlang/swift-syntax.git",
       "state" : {
-        "revision" : "4799286537280063c85a32f09884cfbca301b1a1",
-        "version" : "602.0.0"
+        "revision" : "79e4b74a295b6eb74a8b585e3a39d29e70c1dbd1",
+        "version" : "603.0.2"
       }
     }
   ],

package/apple/Package.swift

@@ -9,7 +9,7 @@ let package = Package(
   name: "ExpoModulesMacros",
   platforms: [.macOS(.v13)],
   dependencies: [
-    .package(url: "https://github.com/swiftlang/swift-syntax.git", from: "602.0.0-latest")
+    .package(url: "https://github.com/swiftlang/swift-syntax.git", from: "603.0.0-latest")
   ],
   targets: [
     // The plugin executable doubles as the scanner CLI: the compiler launches it without arguments

package/apple/Sources/ExpoModulesMacros/ExpoModulesOptimizedMacro.swift

@@ -1,4 +1,3 @@
-import Foundation
 import SwiftSyntax
 import SwiftSyntaxBuilder
 import SwiftSyntaxMacros

package/apple/Sources/ExpoModulesMacros/Plugin.swift

@@ -1,8 +1,15 @@
 import ExpoModulesScanner
-import Foundation
 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] = [
     OptimizedFunctionAttachedMacro.self,

package/apple/Sources/ExpoModulesMacros/ViewPropsMacro.swift

@@ -1,4 +1,3 @@
-import Foundation
 import SwiftDiagnostics
 import SwiftSyntax
 import SwiftSyntaxBuilder
@@ -248,10 +247,22 @@ private struct ViewProp {
   /// The name with any escaping backticks removed: the JS-visible key, so the enum's raw value and
   /// `_eventNames` both read `"default"`, never `` "`default`" ``.
   var wireName: String {
-    return name.trimmingCharacters(in: CharacterSet(charactersIn: "`"))
+    return withoutBackticks(name)
   }
 }
 
+/// `name` without the backticks that escape it: `` `default` `` becomes `default`.
+private func withoutBackticks(_ name: String) -> String {
+  var name = Substring(name)
+  while name.first == "`" {
+    name.removeFirst()
+  }
+  while name.last == "`" {
+    name.removeLast()
+  }
+  return String(name)
+}
+
 private struct ViewPropsModel {
   /// Value props, in declaration order. The order is the bit order, so it is part of the ABI
   /// between a compiled view and the runtime that fills the mask.
@@ -344,7 +355,7 @@ private func validatedViewProps(of declaration: some DeclGroupSyntax) throws ->
       // `PropSet` stores its mask in `rawValue`, so a value prop of that name would emit a static
       // member shadowing it and the option set would not compile ("circular reference"). The error
       // would point at generated code, so catch it here and name the property.
-      if !isEvent && name.trimmingCharacters(in: CharacterSet(charactersIn: "`")) == "rawValue" {
+      if !isEvent && withoutBackticks(name) == "rawValue" {
         throw MacroExpansionErrorMessage(
           "'rawValue' can't be used as a prop name — it collides with the synthesized PropSet's storage. Rename the property"
         )

package/apple/Sources/ExpoModulesScanner/CLI.swift

@@ -1,5 +1,3 @@
-import Foundation
-
 /// Command-line front end for the scanner: parses the subcommand and paths, then delegates to the
 /// matching `Scanner` entry (which runs the scan and writes its JSON output). Lives in the library
 /// so the macro plugin executable can dispatch into it: the compiler always launches that executable
@@ -16,12 +14,12 @@ public enum ScannerCLI {
   public static func run(arguments: [String]) -> Int32 {
     // `-h`/`--help` anywhere is treated as a help request: print usage to stdout and exit 0.
     if arguments.contains(where: { $0 == "-h" || $0 == "--help" }) {
-      printUsage(to: .standardOutput)
+      writeToStandardOutput(usageText)
       return 0
     }
 
     guard let subcommand = arguments.first else {
-      printUsage()
+      writeToStandardError(usageText)
       return 2
     }
 
@@ -79,7 +77,11 @@ 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`).
 private var toolName: String {
-  return (CommandLine.arguments.first as NSString?)?.lastPathComponent ?? "ExpoModulesScanner"
+  guard let path = CommandLine.arguments.first else {
+    return "ExpoModulesScanner"
+  }
+  // Windows paths may use either separator.
+  return String(path.split(whereSeparator: { $0 == "/" || $0 == "\\" }).last ?? Substring(path))
 }
 
 private var usageText: String {
@@ -100,15 +102,8 @@ private var usageText: String {
   """
 }
 
-/// Prints the usage text to the given handle. Goes to stdout when help was explicitly requested
-/// (a successful action), stderr when it accompanies a usage error.
-private func printUsage(to handle: FileHandle = .standardError) {
-  handle.write(Data(usageText.utf8))
-}
-
 /// Reports a usage error on stderr, followed by the usage text, and returns the usage exit code.
 private func usageError(_ message: String) -> Int32 {
-  FileHandle.standardError.write(Data("error: \(message)\n".utf8))
-  printUsage()
+  writeToStandardError("error: \(message)\n" + usageText)
   return 2
 }

package/apple/Sources/ExpoModulesScanner/Core/Detection.swift

@@ -1,5 +1,3 @@
-import Foundation
-
 /// Which Expo macro was found on a declaration. The scanner recognizes the entry-point macros that
 /// mark a type or member as part of a module's JS surface, plus `@Record` for convertible types.
 enum DetectedMacro: String, Codable, CaseIterable {

package/apple/Sources/ExpoModulesScanner/Core/ScanBuildConfiguration.swift

@@ -23,6 +23,11 @@ struct ScanBuildConfiguration: BuildConfiguration {
     return name.lowercased() == platform.lowercased()
   }
 
+  /// The scan evaluates only Apple OSes, which all produce Mach-O, as `objectFormat(...)` spells it.
+  func isActiveTargetObjectFormat(name: String) throws -> Bool {
+    return name == "MachO"
+  }
+
   // MARK: - Unanswerable conditions
 
   // These vary within a single platform's build (device vs simulator, arm64 vs x86_64) or depend

package/apple/Sources/ExpoModulesScanner/Core/SourceScan.swift

@@ -1,4 +1,8 @@
+#if canImport(FoundationEssentials)
+import FoundationEssentials
+#else
 import Foundation
+#endif
 import SwiftParser
 import SwiftSyntax
 
@@ -21,12 +25,12 @@ func scanFiles(
   var filesScanned = 0
   var filesParsed = 0
 
-  // Compile the pre-filter regex once per run, not once per file.
-  let prefilter = macroAttributeRegex(for: macros, conformances: conformances)
+  // Build the pre-filter once per run, not once per file.
+  let prefilter = MacroPrefilter(macros: macros, conformances: conformances)
 
   for file in swiftFiles(in: paths) {
     guard let source = try? String(contentsOfFile: file, encoding: .utf8) else {
-      FileHandle.standardError.write(Data("warning: could not read \(file)\n".utf8))
+      writeToStandardError("warning: could not read \(file)\n")
       continue
     }
     filesScanned += 1
@@ -81,27 +85,57 @@ func detect(
 
 // MARK: - Pre-filter
 
-/// Builds the pre-filter regex for a macro set, e.g. `@(ExpoModule)` for a `modules` scan or
-/// `@(ExpoModule|JS|Record|SharedObject)` for an `exports` scan. A precompiled `NSRegularExpression`
-/// benchmarked ~20x faster over a large source tree than calling `String.contains` once per macro
-/// name, because it scans each file in a single pass. Compiled once per run and reused per file.
+/// The spelled forms whose presence makes a file worth parsing: each macro's attribute right after an
+/// `@` (`@ExpoModule`, `@JS`, …), plus bare names for the types recognized by a conformance rather than
+/// an attribute (`Enumerable` for `scan-exports`). A bare name matches more loosely than an
+/// `@`-prefixed one, which costs a wasted parse and never a miss.
 ///
-/// `conformances` adds bare (unprefixed) alternatives for types recognized by conformance rather than
-/// by an attribute (`Enumerable` for `scan-exports`). They join the same alternation so the scan stays
-/// one pass; a bare name matches more loosely than an `@`-prefixed one, which costs a wasted parse and
-/// never a miss.
-func macroAttributeRegex(
-  for macros: Set<DetectedMacro>,
-  conformances: Set<String> = []
-) -> NSRegularExpression {
-  // Sort for a stable pattern regardless of the set's iteration order.
-  let attributes = macros.map(\.rawValue).sorted().joined(separator: "|")
-  var alternatives: [String] = []
-  if !attributes.isEmpty {
-    alternatives.append("@(\(attributes))")
+/// Matching is a single pass over the UTF-8 bytes, checking the names only where an `@` or a bare
+/// name's first byte occurs, rather than one search per name. It runs on every file a whole-tree scan
+/// reads, far more than it parses, so it has to stay cheap. Built once per run and reused per file.
+struct MacroPrefilter {
+  /// The attribute names matched right after an `@`, as UTF-8.
+  private let attributes: [[UInt8]]
+
+  /// The names matched anywhere, as UTF-8.
+  private let bareNames: [[UInt8]]
+
+  init(macros: Set<DetectedMacro>, conformances: Set<String> = []) {
+    attributes = macros.map { Array($0.rawValue.utf8) }
+    bareNames = conformances.map { Array($0.utf8) }
+  }
+
+  /// True if `source` contains one of the attributes after an `@`, or one of the bare names.
+  func matches(_ source: String) -> Bool {
+    var source = source
+    return source.withUTF8 { bytes in
+      for index in bytes.indices {
+        let byte = bytes[index]
+        if byte == UInt8(ascii: "@") {
+          for name in attributes where bytes.hasBytes(name, at: index + 1) {
+            return true
+          }
+        }
+        for name in bareNames where name.first == byte && bytes.hasBytes(name, at: index) {
+          return true
+        }
+      }
+      return false
+    }
+  }
+}
+
+extension UnsafeBufferPointer<UInt8> {
+  /// True if the bytes starting at `index` begin with `prefix`.
+  fileprivate func hasBytes(_ prefix: [UInt8], at index: Int) -> Bool {
+    guard index + prefix.count <= count else {
+      return false
+    }
+    for offset in prefix.indices where self[index + offset] != prefix[offset] {
+      return false
+    }
+    return true
   }
-  alternatives.append(contentsOf: conformances.sorted())
-  return try! NSRegularExpression(pattern: alternatives.joined(separator: "|"))
 }
 
 /// True if the source text contains one of the pre-filter's spelled macro attributes, so it's worth
@@ -109,9 +143,8 @@ func macroAttributeRegex(
 /// in which case the file is parsed and correctly yields no detections — a wasted parse, never a
 /// missed module. It assumes the attribute is written with no space after `@` (`@ExpoModule`, not
 /// `@ ExpoModule`), which is universal in practice; the rare spaced form would be skipped.
-func mightContainMacro(in source: String, prefilter: NSRegularExpression) -> Bool {
-  let range = NSRange(source.startIndex..., in: source)
-  return prefilter.firstMatch(in: source, range: range) != nil
+func mightContainMacro(in source: String, prefilter: MacroPrefilter) -> Bool {
+  return prefilter.matches(source)
 }
 
 // MARK: - File discovery
@@ -144,13 +177,12 @@ func swiftFiles(in paths: [String]) -> [String] {
   var result: [String] = []
 
   for path in paths {
-    var isDirectory: ObjCBool = false
-    guard fileManager.fileExists(atPath: path, isDirectory: &isDirectory) else {
-      FileHandle.standardError.write(Data("warning: no such path \(path)\n".utf8))
+    guard let isDirectory = isDirectory(atPath: path, fileManager: fileManager) else {
+      writeToStandardError("warning: no such path \(path)\n")
       continue
     }
 
-    if isDirectory.boolValue {
+    if isDirectory {
       result.append(contentsOf: swiftFiles(inDirectory: URL(fileURLWithPath: path), fileManager: fileManager))
     } else if path.hasSuffix(".swift") {
       // A directory walk already yields absolute paths; resolve a directly-passed file the same way
@@ -162,6 +194,54 @@ func swiftFiles(in paths: [String]) -> [String] {
   return result.sorted()
 }
 
+/// Whether `path` is a directory (following symbolic links), or `nil` if nothing exists there.
+private func isDirectory(atPath path: String, fileManager: FileManager) -> Bool? {
+  #if canImport(FoundationEssentials)
+  var isDirectory = false
+  #else
+  var isDirectory: ObjCBool = false
+  #endif
+  guard fileManager.fileExists(atPath: path, isDirectory: &isDirectory) else {
+    return nil
+  }
+  #if canImport(FoundationEssentials)
+  return isDirectory
+  #else
+  return isDirectory.boolValue
+  #endif
+}
+
+#if canImport(FoundationEssentials)
+/// Recursively lists the `.swift` files under a directory, without descending into pruned directories.
+/// `FoundationEssentials`, used outside Apple platforms, has no directory enumerator, so each directory
+/// is listed on its own and the walk recurses into the subdirectories that aren't pruned. Like the
+/// enumerator walk on Apple platforms, it skips names starting with a dot and doesn't follow symbolic
+/// links to directories.
+private func swiftFiles(inDirectory directory: URL, fileManager: FileManager) -> [String] {
+  return swiftFiles(inDirectoryAtPath: directory.path, fileManager: fileManager)
+}
+
+private func swiftFiles(inDirectoryAtPath directory: String, fileManager: FileManager) -> [String] {
+  guard let names = try? fileManager.contentsOfDirectory(atPath: directory) else {
+    return []
+  }
+
+  var result: [String] = []
+  for name in names where !name.hasPrefix(".") {
+    let path = directory + "/" + name
+    // `attributesOfItem` doesn't follow a symbolic link, so a link reads as `.typeSymbolicLink`.
+    let type = (try? fileManager.attributesOfItem(atPath: path))?[.type] as? FileAttributeType
+    if type == .typeDirectory {
+      if !prunedDirectoryNames.contains(name) {
+        result.append(contentsOf: swiftFiles(inDirectoryAtPath: path, fileManager: fileManager))
+      }
+    } else if name.hasSuffix(".swift") {
+      result.append(path)
+    }
+  }
+  return result
+}
+#else
 /// Recursively enumerates `.swift` files under a directory, calling `skipDescendants()` on any
 /// pruned directory so its subtree is never read. Uses the URL enumerator (rather than the
 /// path-based one) precisely because it supports skipping a subtree mid-walk.
@@ -191,3 +271,4 @@ private func swiftFiles(inDirectory directory: URL, fileManager: FileManager) ->
   }
   return result
 }
+#endif

package/apple/Sources/ExpoModulesScanner/Core/StandardStreams.swift

@@ -0,0 +1,45 @@
+#if canImport(Darwin)
+import Darwin
+#elseif canImport(Glibc)
+import Glibc
+#elseif os(Windows)
+import CRT
+#endif
+
+// Output goes straight to the file descriptors rather than through Foundation's `FileHandle`, which
+// `FoundationEssentials` doesn't have. Outside Apple platforms the scanner uses only
+// `FoundationEssentials`, so the binary doesn't link full Foundation and its ICU data.
+
+/// Writes `text` to stdout as is, without adding a newline.
+func writeToStandardOutput(_ text: String) {
+  writeAll(text, toFileDescriptor: 1)
+}
+
+/// Writes `text` to stderr as is, without adding a newline.
+func writeToStandardError(_ text: String) {
+  writeAll(text, toFileDescriptor: 2)
+}
+
+/// Writes the UTF-8 bytes of `text` to `descriptor`, repeating the write until every byte is out. Retries
+/// a write that a signal interrupted, and stops early if one fails otherwise, since there is nowhere
+/// left to report that.
+private func writeAll(_ text: String, toFileDescriptor descriptor: Int32) {
+  var text = text
+  text.withUTF8 { bytes in
+    var remaining = UnsafeRawBufferPointer(bytes)
+    while !remaining.isEmpty {
+      #if os(Windows)
+      let written = Int(_write(descriptor, remaining.baseAddress, CUnsignedInt(remaining.count)))
+      #else
+      let written = write(descriptor, remaining.baseAddress, remaining.count)
+      #endif
+      if written < 0 && errno == EINTR {
+        continue
+      }
+      guard written > 0 else {
+        return
+      }
+      remaining = UnsafeRawBufferPointer(rebasing: remaining[written...])
+    }
+  }
+}

package/apple/Sources/ExpoModulesScanner/Exports/ExportedSurface.swift

@@ -1,5 +1,3 @@
-import Foundation
-
 /// The deep-scan surface: the full JS-exported shape of every `@ExpoModule`, `@SharedObject`, and
 /// `@Record` type, with the per-member detail a TypeScript type generator needs. Read syntactically
 /// (like the macros): each boundary type becomes a structured `TypeNode` tree so the consumer walks a

package/apple/Sources/ExpoModulesScanner/Exports/ResolveRefs.swift

@@ -1,5 +1,3 @@
-import Foundation
-
 /// Fills in each `.ref`'s `refKind` once the whole scan is done.
 ///
 /// A `TypeNode` is parsed from one `TypeSyntax` in isolation, so at parse time a name like `Status` is

package/apple/Sources/ExpoModulesScanner/Exports/ScanExports.swift

@@ -1,4 +1,8 @@
+#if canImport(FoundationEssentials)
+import FoundationEssentials
+#else
 import Foundation
+#endif
 import SwiftParser
 import SwiftSyntax
 
@@ -12,11 +16,10 @@ extension Scanner {
       let encoder = JSONEncoder()
       encoder.outputFormatting = [.prettyPrinted, .sortedKeys]
       let data = try encoder.encode(result)
-      FileHandle.standardOutput.write(data)
-      FileHandle.standardOutput.write(Data("\n".utf8))
+      writeToStandardOutput(String(decoding: data, as: UTF8.self) + "\n")
       return 0
     } catch {
-      FileHandle.standardError.write(Data("error: failed to encode results: \(error)\n".utf8))
+      writeToStandardError("error: failed to encode results: \(error)\n")
       return 1
     }
   }

package/apple/Sources/ExpoModulesScanner/Modules/ScanModules.swift

@@ -1,4 +1,8 @@
+#if canImport(FoundationEssentials)
+import FoundationEssentials
+#else
 import Foundation
+#endif
 import SwiftParser
 
 /// The scanner's public entry point. Argument parsing, subcommand dispatch, and usage text live in
@@ -20,11 +24,10 @@ public enum Scanner {
       let encoder = JSONEncoder()
       encoder.outputFormatting = [.prettyPrinted, .sortedKeys]
       let data = try encoder.encode(result)
-      FileHandle.standardOutput.write(data)
-      FileHandle.standardOutput.write(Data("\n".utf8))
+      writeToStandardOutput(String(decoding: data, as: UTF8.self) + "\n")
       return 0
     } catch {
-      FileHandle.standardError.write(Data("error: failed to encode results: \(error)\n".utf8))
+      writeToStandardError("error: failed to encode results: \(error)\n")
       return 1
     }
   }

package/build/index.d.ts

@@ -29,8 +29,17 @@ export declare class ScannerSchemaVersionError extends Error {
     constructor(command: string, found: number, expected: number);
 }
 /**
- * Absolute path to the scanner binary shipped with this package. It doubles as the macro plugin
- * executable, so it lives next to the Swift package rather than in a `bin` directory.
+ * Absolute path to the scanner binary for the current platform. It doubles as the macro plugin
+ * executable.
+ *
+ * - macOS: the universal binary shipped in this package, next to the Swift package rather than in a
+ *   `bin` directory.
+ * - Windows: `ExpoModulesMacros.exe` from the package for the current architecture (see
+ *   `windowsBinaryPackageName`). When that package isn't installed, for example in this repository,
+ *   it falls back to the executable that `npm run build` writes to `platforms/win32-<arch>`.
+ *
+ * The path isn't checked here; running a missing binary fails with a `ScannerError` that says how to
+ * get it.
  */
 export declare function getScannerBinaryPath(): string;
 /**

package/build/index.js

@@ -51,11 +51,47 @@ class ScannerSchemaVersionError extends Error {
 }
 exports.ScannerSchemaVersionError = ScannerSchemaVersionError;
 /**
- * Absolute path to the scanner binary shipped with this package. It doubles as the macro plugin
- * executable, so it lives next to the Swift package rather than in a `bin` directory.
+ * The package with the Windows binary for the current architecture, for example
+ * `@expo/modules-macros-win32-x64`. It is an optional dependency of this package, and its `os` and
+ * `cpu` fields make package managers install it only on a matching Windows machine.
+ */
+function windowsBinaryPackageName() {
+    return `@expo/modules-macros-win32-${process.arch}`;
+}
+/**
+ * Absolute path to the scanner binary for the current platform. It doubles as the macro plugin
+ * executable.
+ *
+ * - macOS: the universal binary shipped in this package, next to the Swift package rather than in a
+ *   `bin` directory.
+ * - Windows: `ExpoModulesMacros.exe` from the package for the current architecture (see
+ *   `windowsBinaryPackageName`). When that package isn't installed, for example in this repository,
+ *   it falls back to the executable that `npm run build` writes to `platforms/win32-<arch>`.
+ *
+ * The path isn't checked here; running a missing binary fails with a `ScannerError` that says how to
+ * get it.
  */
 function getScannerBinaryPath() {
-    return node_path_1.default.join(__dirname, '..', 'apple', 'ExpoModulesMacros');
+    if (process.platform !== 'win32') {
+        return node_path_1.default.join(__dirname, '..', 'apple', 'ExpoModulesMacros');
+    }
+    try {
+        const packageJson = require.resolve(`${windowsBinaryPackageName()}/package.json`);
+        return node_path_1.default.join(node_path_1.default.dirname(packageJson), 'ExpoModulesMacros.exe');
+    }
+    catch {
+        return node_path_1.default.join(__dirname, '..', 'platforms', `win32-${process.arch}`, 'ExpoModulesMacros.exe');
+    }
+}
+/** The message for a scanner binary that doesn't exist at `binaryPath`. */
+function missingBinaryMessage(binaryPath) {
+    if (process.platform === 'win32') {
+        return (`The scanner binary is missing at ${binaryPath}. On Windows it comes from the optional package ` +
+            `${windowsBinaryPackageName()}, which your package manager installs only on Windows x64 and arm64. ` +
+            'Reinstall dependencies without skipping optional ones (for example without `--omit=optional`), ' +
+            'or run `npm run build` in this package to build it locally.');
+    }
+    return `The scanner binary is missing at ${binaryPath}. Run \`npm run build\` in this package to build it.`;
 }
 /**
  * Runs a scanner subcommand and parses its JSON report.
@@ -92,7 +128,7 @@ function runScanner(binaryPath, args) {
                 // number. Only the latter is an exit status.
                 const exitCode = typeof error.code === 'number' ? error.code : null;
                 if (error.code === 'ENOENT') {
-                    reject(new ScannerError(`The scanner binary is missing at ${binaryPath}. Run \`npm run build\` in this package to build it.`, null, stderr));
+                    reject(new ScannerError(missingBinaryMessage(binaryPath), null, stderr));
                     return;
                 }
                 reject(new ScannerError(`\`${node_path_1.default.basename(binaryPath)} ${args.join(' ')}\` failed: ${stderr.trim() || error.message}`, exitCode, stderr));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-modules-macros",
-  "version": "0.16.0",
+  "version": "0.17.0-0",
   "description": "Swift macro plugin for Expo modules",
   "main": "build/index.js",
   "types": "build/index.d.ts",
@@ -12,7 +12,7 @@
     "url": "git+https://github.com/expo/expo-modules-macros.git"
   },
   "scripts": {
-    "build": "node apple/build.js",
+    "build": "node scripts/build.js",
     "build:ts": "tsc -p tsconfig.json",
     "clean": "rm -rf build",
     "typecheck": "tsc -p tsconfig.json --noEmit",
@@ -21,5 +21,9 @@
   "devDependencies": {
     "@types/node": "^20.11.0",
     "typescript": "^5.4.0"
+  },
+  "optionalDependencies": {
+    "@expo/modules-macros-win32-arm64": "0.17.0-0",
+    "@expo/modules-macros-win32-x64": "0.17.0-0"
   }
 }

package/apple/build.js

@@ -1,138 +0,0 @@
-#!/usr/bin/env node
-
-const childProcess = require('node:child_process');
-const fs = require('node:fs/promises');
-const os = require('node:os');
-const path = require('node:path');
-const { promisify } = require('node:util');
-
-const execFile = promisify(childProcess.execFile);
-
-/**
- * Runs a command and resolves when it exits successfully.
- */
-function spawnAsync(command, args, options = {}) {
-  return new Promise((resolve, reject) => {
-    const child = childProcess.spawn(command, args, { stdio: 'inherit', ...options });
-    child.once('error', reject);
-    child.once('close', (code, signal) => {
-      if (code === 0) {
-        resolve();
-      } else {
-        reject(new Error(`\`${command} ${args.join(' ')}\` exited with ${signal ?? `code ${code}`}`));
-      }
-    });
-  });
-}
-
-/**
- * Builds the macro plugin for the given architecture and returns the path to the built binary.
- * SwiftPM always builds macro tools for the host architecture, so the x86_64 slice
- * is built by running the whole toolchain under Rosetta with `arch -${arch}`.
- */
-async function buildForArch(arch) {
-  const buildArgs = ['build', '-c', 'release'];
-  if (arch === os.machine()) {
-    await spawnAsync('swift', buildArgs, { cwd: __dirname });
-  } else {
-    await spawnAsync('arch', [`-${arch}`, 'swift', ...buildArgs], { cwd: __dirname });
-  }
-
-  const binPath = path.join(__dirname, `.build/${arch}-apple-macosx/release/ExpoModulesMacros-tool`);
-  try {
-    await fs.access(binPath);
-  } catch {
-    throw new Error(`Could not find the built ExpoModulesMacros-tool at ${binPath}`);
-  }
-  return binPath;
-}
-
-/**
- * Checks whether the Swift toolchain actually runs for the given architecture by
- * verifying the host target triple it reports, e.g. `Target: x86_64-apple-macosx26.0`
- * under Rosetta. Exit status alone is not enough: if `arch` ever fell back to the
- * native architecture, the probe would pass but the build would produce a wrong slice.
- */
-async function canRunSwiftForArch(arch) {
-  try {
-    const { stdout } = await execFile('arch', [`-${arch}`, 'swift', '--version']);
-    return stdout.includes(`${arch}-apple`);
-  } catch {
-    return false;
-  }
-}
-
-/**
- * Checks whether the toolchain can build for the given architecture.
- * Building x86_64 on Apple Silicon requires Rosetta, so when it is missing,
- * try to install it before giving up.
- */
-async function canBuildForArch(arch) {
-  if (arch === os.machine()) {
-    return true;
-  }
-  if (await canRunSwiftForArch(arch)) {
-    return true;
-  }
-  if (arch === 'x86_64' && os.machine() === 'arm64') {
-    try {
-      console.log('Installing Rosetta to build the x86_64 slice...');
-      await spawnAsync('sudo', ['softwareupdate', '--install-rosetta', '--agree-to-license']);
-      return await canRunSwiftForArch(arch);
-    } catch {
-      // No sudo access or the install failed - fall through to the unsupported arch warning.
-    }
-  }
-  return false;
-}
-
-/**
- * Asserts that the built binary contains a slice for each of the given architectures.
- */
-async function verifyArchs(binaryPath, archs) {
-  const { stdout } = await execFile('lipo', ['-archs', binaryPath]);
-  const builtArchs = stdout.trim().split(/\s+/);
-  for (const arch of archs) {
-    if (!builtArchs.includes(arch)) {
-      throw new Error(`The built binary at ${binaryPath} is missing the ${arch} slice`);
-    }
-  }
-}
-
-async function main() {
-  const outputPath = path.join(__dirname, 'ExpoModulesMacros');
-
-  const archs = [];
-  for (const arch of ['arm64', 'x86_64']) {
-    if (await canBuildForArch(arch)) {
-      archs.push(arch);
-    } else {
-      console.warn(`The Swift toolchain cannot run for ${arch} - the built binary will not support ${arch} Macs.`);
-    }
-  }
-  if (archs.length === 0) {
-    throw new Error('The Swift toolchain is not available for any supported architecture');
-  }
-
-  // Builds run sequentially as SwiftPM locks the shared .build directory.
-  const binPaths = [];
-  for (const arch of archs) {
-    binPaths.push(await buildForArch(arch));
-  }
-
-  await fs.rm(outputPath, { force: true });
-  if (binPaths.length > 1) {
-    await spawnAsync('lipo', ['-create', ...binPaths, '-output', outputPath]);
-  } else {
-    await fs.copyFile(binPaths[0], outputPath);
-  }
-
-  await spawnAsync('strip', [outputPath]);
-  await verifyArchs(outputPath, archs);
-  await spawnAsync('lipo', ['-info', outputPath]);
-}
-
-main().catch((error) => {
-  console.error('Build failed:', error.message);
-  process.exit(1);
-});