expo-modules-macros 0.16.0 → 0.17.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/DecorateModuleBuilder.swift

@@ -154,7 +154,7 @@ internal struct JSFunction {
       lines.append(contentsOf: encodeResultLines().map { "  " + $0 })
     } else {
       lines.append("  \(callExpression(receiver: receiver, arity: arity))")
-      lines.append("  return .undefined")
+      lines.append("  return .undefined()")
     }
     lines.append("}")
     return lines
@@ -204,7 +204,7 @@ internal struct JSFunction {
 
   /// The flat (single-arity) call-and-encode lines used when no trailing parameter is omittable:
   /// `let result = <callee>.f(...)` then the return encode (or the no-return `<callee>.f(...)` +
-  /// `.undefined`).
+  /// `.undefined()`).
   private func callAndEncodeLines(receiver: Receiver, arity: Int, decodingFrom: Int) -> [String] {
     var lines: [String] = []
     for index in decodingFrom..<arity {
@@ -215,7 +215,7 @@ internal struct JSFunction {
       lines.append(contentsOf: encodeResultLines())
     } else {
       lines.append(callExpression(receiver: receiver, arity: arity))
-      lines.append("return .undefined")
+      lines.append("return .undefined()")
     }
     return lines
   }
@@ -225,7 +225,7 @@ internal struct JSFunction {
   /// value as the primitive's `toJavaScriptValue(in:)` except for `Int`/`UInt`, where it range-checks
   /// and throws instead of silently encoding an out-of-safe-range value as a lossy number — the
   /// catchable error is the right behavior, and matches how non-primitive integers already encode. A
-  /// no-return function returns `.undefined` instead.
+  /// no-return function returns `.undefined()` instead.
   ///
   /// For an `async` function the encode must run on the JS thread. An `async` body may suspend and
   /// resume on an arbitrary cooperative-pool thread, and encoding a heap-allocated JS value (a string,
@@ -235,7 +235,7 @@ internal struct JSFunction {
   /// which always run on the JS thread — keep encoding directly without the wrapper.
   private func encodeResultLines() -> [String] {
     guard let returnType else {
-      return ["return .undefined"]
+      return ["return .undefined()"]
     }
     let encode = "try \(expressionType(returnType)).encode(result, in: runtime)"
     if isAsync {
@@ -340,7 +340,7 @@ internal struct JSProperty {
       let setDecode = "\(callee).\(swiftName) = try \(decodeCall(valueType, from: "arguments.unownedValue(at: 0)"))"
       lines.append(
         accessorClosure(
-          descriptorName, "set", receiver: receiver, body: "\(unwrap)\(setDecode)\nreturn .undefined"))
+          descriptorName, "set", receiver: receiver, body: "\(unwrap)\(setDecode)\nreturn .undefined()"))
     }
 
     lines.append("\(object).defineProperty(\"\(jsName)\", descriptor: \(descriptorName))")
@@ -437,7 +437,7 @@ internal func buildDecorateSharedObjectPhase(
 }
 
 /// True when a return clause is absent or written as `Void` / `()` — i.e. the function returns
-/// nothing JS-visible, so the binding returns `.undefined`.
+/// nothing JS-visible, so the binding returns `.undefined()`.
 private func isVoidType(_ type: TypeSyntax?) -> Bool {
   guard let type else {
     return true

package/apple/Sources/ExpoModulesMacros/ExpoModulesOptimizedMacro.swift

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

package/apple/Sources/ExpoModulesMacros/FreeFormTypes.swift

@@ -30,13 +30,16 @@ private let freeFormDecodeMethods: [String: String] = [
   "[String:Any]": "decodeAnyDictionary",
 ]
 
-/// The type-safe alternative a free-form type's diagnostic steers to: the same shape with the `Any`
-/// element replaced by `JavaScriptValue`, which conforms to the codable protocols. Keyed by the
-/// free-form type's normalized spelling; spelled with conventional spacing for the message.
+/// The type-safe alternative a free-form type's diagnostic steers to: the JS wrapper of the same shape
+/// (`JavaScriptArray` for an array, `JavaScriptObject` for a dictionary, `JavaScriptValue` for an
+/// untyped value). The wrappers conform to the codable protocols and keep the value unconverted; a
+/// non-copyable `JavaScriptValue` cannot be an element of a Swift array or dictionary, so the container
+/// shapes map to a wrapper rather than to a container of values. Keyed by the free-form type's
+/// normalized spelling.
 private let typedFreeFormReplacements: [String: String] = [
   "Any": "JavaScriptValue",
-  "[Any]": "[JavaScriptValue]",
-  "[String:Any]": "[String: JavaScriptValue]",
+  "[Any]": "JavaScriptArray",
+  "[String:Any]": "JavaScriptObject",
 ]
 
 /// True when a boundary type (as written) is one of the free-form spellings, ignoring internal
@@ -54,8 +57,8 @@ internal func freeFormDecodeMethod(for type: String) -> String? {
   return freeFormDecodeMethods[normalizedTypeSpelling(type)]
 }
 
-/// The type-safe alternative to suggest in place of a free-form type (its `Any` element replaced by
-/// `JavaScriptValue`), or `nil` when the type isn't free-form.
+/// The type-safe alternative to suggest in place of a free-form type (the JS wrapper of the same shape),
+/// or `nil` when the type isn't free-form.
 internal func typedFreeFormReplacement(for type: String) -> String? {
   return typedFreeFormReplacements[normalizedTypeSpelling(type)]
 }

package/apple/Sources/ExpoModulesMacros/JSConstructor.swift

@@ -51,7 +51,7 @@ internal struct JSConstructor {
   func buildConstructor(typeName: String) -> DeclSyntax {
     return """
       @JavaScriptActor
-      public override class func _constructSharedObject(this: JavaScriptValue, arguments: borrowing JavaScriptValuesBuffer, in runtime: JavaScriptRuntime) throws -> SharedObject? {
+      public override class func _constructSharedObject(this: borrowing JavaScriptValue, arguments: borrowing JavaScriptValuesBuffer, in runtime: JavaScriptRuntime) throws -> SharedObject? {
       \(raw: bodyStatements(typeName: typeName, indent: "  "))
       }
       """

package/apple/Sources/ExpoModulesMacros/JSMacro.swift

@@ -120,7 +120,7 @@ private func insertAsyncFixIt(for funcDecl: FunctionDeclSyntax) -> FixIt {
 /// `JavaScriptValue.decodeAny…`; there is no free-form encode, so any position that encodes is a hard
 /// error. That means:
 /// - a function/constructor **parameter** typed free-form gets a warning steering to
-///   `[String: JavaScriptValue]` (the type-safe alternative), but compiles;
+///   `JavaScriptValue` (the type-safe alternative), but compiles;
 /// - a function **return** typed free-form is an error (it would need to encode);
 /// - a **property** typed free-form is an error regardless of settability, because its getter always
 ///   encodes.
@@ -156,9 +156,8 @@ private func diagnoseFreeFormTypes(
   }
 }
 
-/// The tail of a free-form encode error: the reshaped `JavaScriptValue` alternative when the type is a
-/// container (`[String: Any]` -> `[String: JavaScriptValue]`), otherwise the passthrough suggestion
-/// for a bare `Any`. Both conform to the codable protocols, so either is a valid fix.
+/// The tail of a free-form encode error: the typed wrapper of the same shape (`JavaScriptArray`,
+/// `JavaScriptObject`) when there is one, otherwise the plain `JavaScriptValue` passthrough suggestion.
 private func suggestedAlternative(for freeFormType: String) -> String {
   if let reshaped = typedFreeFormReplacement(for: freeFormType), reshaped != "JavaScriptValue" {
     return "Use '\(reshaped)', or 'JavaScriptValue' to pass a JS value through unchanged."
@@ -189,7 +188,7 @@ private func freeFormArgumentWarning(
   suggesting suggestedType: String
 ) -> JSDiagnosticMessage {
   return JSDiagnosticMessage(
-    "Prefer '\(suggestedType)' over the free-form '\(freeFormType)' for a @JS argument. Free-form decoding boxes every value as 'Any' (slower, no static typing); the 'JavaScriptValue' element keeps each value inspectable without erasing it.",
+    "Prefer '\(suggestedType)' over the free-form '\(freeFormType)' for a @JS argument. Free-form decoding boxes every value as 'Any' (slower, no static typing); '\(suggestedType)' keeps the JS value inspectable without converting it.",
     id: "js-free-form-argument",
     severity: .warning
   )

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/RecordMacro.swift

@@ -529,7 +529,7 @@ private func toObjectMethod(properties: [RecordProperty], inheritsRecord: Bool)
     switch property.freeForm {
     case .shape(_, let encodeMethod, let isOptional, _):
       encode = isOptional
-        ? "self.\(property.name) == nil ? .null : try JavaScriptValue.\(encodeMethod)(self.\(property.name)!, in: runtime)"
+        ? "self.\(property.name) == nil ? .null() : try JavaScriptValue.\(encodeMethod)(self.\(property.name)!, in: runtime)"
         : "try JavaScriptValue.\(encodeMethod)(self.\(property.name), in: runtime)"
     case .generic:
       // The explicit `as Any` keeps an optional property from warning about its implicit coercion.