Preview changes without running the app

Set up Screenmap in this repository.

Screenmap is a GitHub Action that maps every screen of an Expo / React Native app
and comments on each pull request with screenshots of the screens that change
touched. Source: https://github.com/aleqsio/screenmap

Work through this in order.

1. Confirm this repo is an Expo / React Native app using expo-router or a
   react-navigation route map. Find the app directory: the repo root, or
   something like apps/mobile in a monorepo. Call that PROJECT.

2. Set up the EAS side. Check the app config for extra.eas.projectId — the EAS
   lane shells out to eas fingerprint:generate and eas build, and both refuse to
   run against an unlinked project. If it is missing, run "npx eas init".
   Then look at eas.json for a build profile that produces a dev client for the
   platform you want. iOS needs developmentClient: true and ios.simulator: true,
   and Screenmap defaults to a profile named "development-simulator". Android
   needs developmentClient: true and android.buildType: "apk" — an .aab cannot be
   installed on an emulator — and defaults to "development-emulator". If yours
   are named something else, pass eas_profile with the real name. If no such
   profile exists, add one. If this repo already builds its own dev client, you
   can skip EAS entirely: pass app_path pointing at it — an .app for iOS, an .apk
   for Android — instead of expo_token.

3. Create .github/workflows/screenmap-pr.yml with exactly this:

name: screenmap · PR changes
on:
  pull_request:
    types: [opened, synchronize, reopened]
concurrency:
  group: screenmap-pr-${{ github.event.pull_request.number }}
  cancel-in-progress: true
permissions:
  contents: write        # push bundles to the screenmaps branch
  pull-requests: write   # the sticky comment
  actions: write         # start the baseline if no map exists yet
jobs:
  changes:
    runs-on: macos-26
    timeout-minutes: 60
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0
      - uses: actions/setup-node@v4
        with:
          node-version: 22
      - uses: aleqsio/screenmap@v1
        with:
          mode: pr
          expo_token: ${{ secrets.EXPO_TOKEN }}   # EAS builds or reuses the dev client
          # app_path: build/MyApp.app   # ...or your own simulator build, with no expo_token
          # platform: ios   # or android, on runs-on: ubuntu-latest — a tenth of the macOS rate
          agent_provider: claude
          agent_api_key: ${{ secrets.ANTHROPIC_API_KEY }}

4. Create .github/workflows/screenmap-baseline.yml with exactly this:

name: screenmap · baseline
on:
  push:
    branches: [main]
  workflow_dispatch:
concurrency:
  group: screenmap-baseline
  cancel-in-progress: false
permissions:
  contents: write
  pull-requests: write
  actions: write         # re-run PRs waiting on this map
jobs:
  baseline:
    runs-on: macos-26
    timeout-minutes: 120
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0
      - uses: actions/setup-node@v4
        with:
          node-version: 22
      - uses: aleqsio/screenmap@v1
        with:
          mode: baseline
          expo_token: ${{ secrets.EXPO_TOKEN }}   # EAS builds or reuses the dev client
          # app_path: build/MyApp.app   # ...or your own simulator build, with no expo_token
          # platform: ios   # or android, on runs-on: ubuntu-latest — a tenth of the macOS rate
          agent_provider: claude
          agent_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
          flows_pr: "true"

5. Adapt both workflows to this repo:
   - If PROJECT is not the repo root, add "project: PROJECT" under "with:".
   - If this repo is private, add 'publish: "false"' so bundles stay as run
     artifacts instead of being pushed to a branch.
   - If I asked for Android too, remember it is one platform per job: keep the
     iOS job on macOS, add a second with "platform: android" on ubuntu-latest,
     and fold the bundles together with "screenmap-ci merge --inputs
     ios=<a>.scrmap,android=<b>.scrmap". The workflow templates in the repo show
     the shape.
   - Set the agent to yourself. Work out which CLI you are running as and put
     that in agent_provider in both workflows, then set agent_api_key to the
     secret that matches it:
     - claude -> ANTHROPIC_API_KEY
     - codex -> OPENAI_API_KEY
     - gemini -> GEMINI_API_KEY
     - opencode -> AGENT_API_KEY
     If you are some other agent, use its CLI name and the env var its key
     normally lives in, and tell me which one you picked.

6. If any route takes a parameter, write .screenmap/config.json with real values
   for them. A route like /brew/[id] is deep-linked as /brew/1, and if 1 is not
   a real id the run captures the not-found screen and reports it as that
   screen. Use ids that exist in the app's fixtures, seed data or test account:

   { "params": { "id": "v60" } }

   Plain "id" covers every route with that parameter, and prefixing the route id
   ("brew/[id].id") scopes it to one route. Anything else the agent needs, like
   how to sign in, which controls to leave alone, or how slow a screen is, goes
   in .screenmap/SKILL.md.

7. Do NOT create, print, or paste any secret yourself. Instead, tell me to add
   these in Settings -> Secrets and variables -> Actions:
   - EXPO_TOKEN (required) — expo.dev -> Account settings -> Access tokens.
   - the agent key you named in step 5 (optional). Without it Screenmap still
     runs, on the routes it can reach on its own. Tell me where to get that
     provider's key.

8. Tell me that an iOS run needs a macOS runner, which bills at ten times the
   Linux rate, so one run costs about what a short iOS build costs. An Android
   run goes on ubuntu-latest, at about a tenth of that.

When you are done, summarise what you changed and what is left for me to do by
hand. Do not commit or push unless I ask.