expo-modules-macros 0.15.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,10 +15,12 @@ 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.
-- **`@JS(_ jsName: String? = nil, _ options: JSOptions...)`** on a member of a module or shared object. Marks a function, property or initializer for export. `@ExpoModule` and `@SharedObject` bind each marked member straight into the JavaScript object, with the argument decoding, the call and the result encoding inlined, so there is no dynamic per-call path. The JS name defaults to the Swift name; pass a string to override it. The macro also checks that every type crossing the boundary is convertible in the direction it travels, so a bad type is reported on the author's own declaration rather than on the enclosing type. The `.concurrent` option moves an `async` body off the JavaScript thread while still decoding and encoding on it.
+- **`@JS(_ jsName: String? = nil, _ options: JSOptions...)`** on a member of a module or shared object. Marks a function, property or initializer for export. `@ExpoModule` and `@SharedObject` bind each marked member straight into the JavaScript object, with the argument decoding, the call and the result encoding inlined, so there is no dynamic per-call path. The JS name defaults to the Swift name; pass a string to override it. The macro also checks that every type crossing the boundary is convertible in the direction it travels, so a bad type is reported on the author's own declaration rather than on the enclosing type. The `.concurrent` option moves an `async` body off the JavaScript thread while still decoding and encoding on it. A function or initializer can take a closure argument, such as `(Point) throws -> Size` or `(String) async throws -> Data`. JavaScript passes a function for it, and native code can store the closure and call it from any thread. A closure that throws or returns a value blocks the caller until JavaScript returns, and an `async` closure suspends instead and awaits a promise that the function returns. A closure that returns a value must be `throws`, so that an error from JavaScript can reach the caller. A non-throwing `Void` closure returns before JavaScript reads its arguments, so don't change a class instance after passing it to one.
 - **`@Event(_ name: String? = nil, sync: Bool = false)`** 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. `sync: true` dispatches inline instead of asynchronously.
 - **`@SharedObject(_ name: String? = nil)`** on a `SharedObject` subclass. Collects the class's `@JS` members into a class definition that a module exposes through `@ExpoModule(classes:)`.
 - **`@Record()`** on a record type. 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. Requiredness is inferred: a default value makes a field optional, an optional type makes it nullable and optional.
@@ -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