@@ -0,0 +1,194 @@
+name: Publish example app
+
+# Publishes the example app that demonstrates the library to the App Store and
+# Play Store. This runs *after* a library release already exists, and cannot
+# affect it: see the failure report in the `report-failure` job below.
+
+on:
+  release:
+    types: [published]
+  workflow_dispatch:
+    inputs:
+      tag:
+        description: Release tag to publish the example app for, e.g. v6.0.0
+        required: true
+      platform:
+        description: Platforms to build and submit. Pick one to retry after a partial failure, so the platform that already shipped is not submitted twice.
+        required: false
+        default: all
+        type: choice
+        options:
+          - all
+          - ios
+          - android
+
+permissions:
+  contents: read
+
+concurrency:
+  group: publish-example-app
+
+jobs:
+  publish:
+    name: Build and submit example app
+    runs-on: ubuntu-latest
+    # An EAS build for two platforms is slow, but not this slow. Without a
+    # timeout a stuck run holds the concurrency lock for six hours.
+    timeout-minutes: 120
+    permissions:
+      contents: write
+      pull-requests: write
+    steps:
+      - name: Checkout
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          ref: main
+
+      - name: Setup
+        uses: ./.github/actions/setup
+
+      - name: Resolve release tag and submit profile
+        id: release
+        env:
+          TAG: ${{ github.event.release.tag_name || inputs.tag }}
+          PLATFORM: ${{ inputs.platform }}
+        run: |
+          if [ -z "$TAG" ]; then
+            echo "::error::No release tag to publish the example app for."
+            exit 1
+          fi
+
+          # A semver version with a prerelease identifier (v6.0.0-alpha.1) goes
+          # to the test tracks, a stable one (v6.0.0) goes to production. This
+          # is derived from the tag rather than from the release's prerelease
+          # flag on purpose: .release-it.json currently pins every release to
+          # `preRelease: true` for the 6.0 alpha cycle, so that flag stays true
+          # for a stable release until somebody remembers to revert it.
+          if [ "${TAG#*-}" != "$TAG" ]; then
+            profile=preview
+          else
+            profile=production
+          fi
+
+          # A release always publishes both platforms. Only a manual retry can
+          # narrow it, to avoid resubmitting a platform that already shipped.
+          platform=${PLATFORM:-all}
+
+          echo "tag=$TAG" >> "$GITHUB_OUTPUT"
+          echo "profile=$profile" >> "$GITHUB_OUTPUT"
+          echo "platform=$platform" >> "$GITHUB_OUTPUT"
+          echo "Publishing $platform for $TAG using the $profile submit profile."
+
+      - name: Bump example app version
+        run: node scripts/bump-example-version.ts example/app.json
+
+      - name: Setup Expo
+        uses: expo/expo-github-action@c7b66a9c327a43a8fa7c0158e7f30d6040d2481e # v8.2.1
+        with:
+          eas-version: latest
+          token: ${{ secrets.EXPO_TOKEN }}
+
+      # Build numbers are assigned remotely by EAS (`appVersionSource: remote`),
+      # so a retry can never collide with an already submitted build.
+      - name: Build and submit to the app stores
+        id: submit
+        working-directory: ./example
+        env:
+          SUBMIT_PROFILE: ${{ steps.release.outputs.profile }}
+          PLATFORM: ${{ steps.release.outputs.platform }}
+        run: |
+          eas build \
+            --platform "$PLATFORM" \
+            --profile production \
+            --auto-submit-with-profile "$SUBMIT_PROFILE" \
+            --non-interactive
+
+      # Runs whenever the submit step ran at all, however it ended. `eas build`
+      # can ship one platform and fail the other, and cancelling the workflow
+      # does not cancel the build on EAS, so in every one of those cases a
+      # version may have reached a store and has to be recorded.
+      - name: Open example app version bump pull request
+        if: ${{ always() && (steps.submit.outcome == 'success' || steps.submit.outcome == 'failure' || steps.submit.outcome == 'cancelled') }}
+        uses: peter-evans/create-pull-request@5f6978faf089d4d20b00c7766989d076bb2fc7f1 # v8.1.1
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          base: main
+          add-paths: example/app.json
+          branch: chore/example-app-version-${{ steps.release.outputs.tag }}
+          commit-message: 'chore: bump example app version for ${{ steps.release.outputs.tag }}'
+          title: 'chore: bump example app version for ${{ steps.release.outputs.tag }}'
+          labels: example app
+          body: |
+            Records the example app version this run used for
+            ${{ steps.release.outputs.tag }}.
+
+            A build for that version may already have been submitted, so this only
+            keeps `example/app.json` in sync. iOS build numbers and Android version codes are not in here:
+            EAS assigns those remotely.
+
+      - name: Summarise
+        if: ${{ !cancelled() && steps.submit.outcome == 'success' }}
+        env:
+          TAG: ${{ steps.release.outputs.tag }}
+          PROFILE: ${{ steps.release.outputs.profile }}
+        run: |
+          {
+            echo "### Example app submitted for \`$TAG\`"
+            echo
+            echo "Submit profile: \`$PROFILE\`."
+            if [ "$PROFILE" = "production" ]; then
+              echo "- Android: Play Store **production** track."
+            else
+              echo "- Android: Play Store **internal** track."
+            fi
+            echo "- iOS: uploaded to App Store Connect, available in TestFlight."
+            echo
+            echo "Releasing an iOS build from TestFlight to the App Store is a"
+            echo "separate manual step in App Store Connect."
+          } >> "$GITHUB_STEP_SUMMARY"
+
+  report-failure:
+    name: Report example app deployment problem
+    needs: publish
+    # Not `failure()`: that misses a cancelled run, and cancellation is the case
+    # most likely to leave a build running on EAS with nobody told about it.
+    if: ${{ always() && needs.publish.result != 'success' }}
+    runs-on: ubuntu-latest
+    steps:
+      # Whoever published the release is already emailed that this run failed.
+      # What that email cannot tell them is that their release is fine, so say
+      # it here, where they land when they follow it.
+      - name: Say that the library release is unaffected
+        env:
+          TAG: ${{ github.event.release.tag_name || inputs.tag }}
+        run: |
+          echo "::error::The example app deployment for $TAG did not finish. The $TAG library release itself published successfully and is not affected."
+
+          cat >> "$GITHUB_STEP_SUMMARY" <<EOF
+          ## The \`$TAG\` library release is not affected
+
+          It is published on npm and on GitHub Releases exactly as expected, and
+          **nothing here changes that**. This workflow only ever runs *after* a
+          release already exists, so it cannot fail, revoke or roll back one.
+
+          - Users of the library need to do nothing. Installing \`react-native-paper\` is unaffected.
+          - Nothing has to be re-released to fix this.
+          - Only the demo app we ship to the App Store and Play Store did not update.
+
+          ## Before re-running
+
+          **Check the EAS dashboard and the stores first.** A build may already
+          have been submitted, and submitting the same version twice is the one
+          thing worth avoiding. Cancelling this workflow does not cancel a build
+          already running on EAS, so a cancelled run can still ship on its own.
+
+          Once you have confirmed what did and did not reach the stores, re-run
+          this workflow on its own, without cutting a new library release:
+
+          **Actions → Publish example app → Run workflow → tag \`$TAG\`**
+
+          If only one platform failed, pick it in the \`platform\` input so the
+          other one is not submitted a second time. Retry before merging the
+          version bump pull request this run opened, since merging it first
+          moves \`main\` on and the retry would ship under a different version.
+          EOF
@@ -109,6 +109,23 @@ yarn release
 
 NOTE: You must have a `GITHUB_TOKEN` environment variable available. You can create a GitHub access token with the "repo" access [here](https://github.com/settings/tokens).
 
+### Publishing the example app
+
+Publishing a release also builds the example app and submits it to the app stores, through the `Publish example app` workflow. It runs after the release already exists, so it cannot affect one: if it fails, the run page says so, and the release is still fine.
+
+Prereleases go to the Play internal track and TestFlight, stable releases to Play production. On iOS, `eas submit` uploads to App Store Connect and promoting the build to the App Store stays manual.
+
+The workflow needs an `EXPO_TOKEN` secret, and the store credentials configured in EAS rather than here (`eas credentials` from `example/`: an App Store Connect API key, and a Google Play service account key). Build numbers are assigned remotely by EAS, so before the first run they need seeding above the values currently in `example/app.json`:
+
+```sh
+eas build:version:set --platform android
+eas build:version:set --platform ios
+```
+
+The example app's version is bumped and comes back as a pull request. Merge it before the next release, or two releases start from the same version and ship under it.
+
+To rerun after a failure, use **Actions → Publish example app → Run workflow**. Check the stores first: a build may already have been submitted, and cancelling the workflow does not cancel one already running on EAS. If only one platform failed, pick it in the `platform` input so the other is not submitted twice. To withdraw a build that did ship, halt the rollout in the Play Console or reject it in App Store Connect.
+
 ## Reporting issues
 
 You can report issues on our [bug tracker](https://github.com/callstack/react-native-paper/issues). Please follow the issue template when opening an issue.
 
@@ -0,0 +1,30 @@
+{
+  "cli": {
+    "appVersionSource": "remote"
+  },
+  "build": {
+    "production": {
+      "node": "24.13.0",
+      "autoIncrement": true,
+      "android": {
+        "buildType": "app-bundle"
+      }
+    }
+  },
+  "submit": {
+    "production": {
+      "android": {
+        "track": "production"
+      },
+      "ios": {
+        "ascAppId": "1548934513"
+      }
+    },
+    "preview": {
+      "extends": "production",
+      "android": {
+        "track": "internal"
+      }
+    }
+  }
+}
@@ -0,0 +1,98 @@
+import { afterEach, beforeEach, expect, it } from '@jest/globals';
+import { execFileSync } from 'node:child_process';
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+const script = join(__dirname, '..', 'bump-example-version.ts');
+
+let workingDir: string;
+
+const writeAppJson = (version: string) => {
+  const appJsonPath = join(workingDir, 'app.json');
+
+  writeFileSync(
+    appJsonPath,
+    JSON.stringify({ expo: { name: 'Example', version } }, null, 2) + '\n'
+  );
+
+  return appJsonPath;
+};
+
+// stderr is captured rather than inherited so that the messages from the
+// expected failures do not land in the test output.
+const run = (appJsonPath: string) =>
+  execFileSync('node', [script, appJsonPath], {
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'pipe'],
+  });
+
+const readVersion = (appJsonPath: string) =>
+  JSON.parse(readFileSync(appJsonPath, 'utf8')).expo.version;
+
+beforeEach(() => {
+  workingDir = mkdtempSync(join(tmpdir(), 'bump-example-version-'));
+});
+
+afterEach(() => {
+  rmSync(workingDir, { recursive: true, force: true });
+});
+
+it('bumps the minor version', () => {
+  const appJsonPath = writeAppJson('3.16.0');
+
+  run(appJsonPath);
+
+  expect(readVersion(appJsonPath)).toBe('3.17.0');
+});
+
+it('resets the patch version when bumping the minor version', () => {
+  const appJsonPath = writeAppJson('3.16.5');
+
+  run(appJsonPath);
+
+  expect(readVersion(appJsonPath)).toBe('3.17.0');
+});
+
+it('prints the version it bumped to', () => {
+  const appJsonPath = writeAppJson('3.16.0');
+
+  expect(run(appJsonPath)).toContain('3.17.0');
+});
+
+it('leaves the rest of the app config untouched', () => {
+  const appJsonPath = writeAppJson('3.16.0');
+
+  run(appJsonPath);
+
+  expect(JSON.parse(readFileSync(appJsonPath, 'utf8')).expo.name).toBe(
+    'Example'
+  );
+});
+
+it('increments the minor version past a single digit', () => {
+  const appJsonPath = writeAppJson('3.9.0');
+
+  run(appJsonPath);
+
+  expect(readVersion(appJsonPath)).toBe('3.10.0');
+});
+
+it('fails when no app config path is given', () => {
+  expect(() =>
+    execFileSync('node', [script], { stdio: ['ignore', 'pipe', 'pipe'] })
+  ).toThrow(/Usage/);
+});
+
+it('fails when the app config has no expo section', () => {
+  const appJsonPath = join(workingDir, 'app.json');
+  writeFileSync(appJsonPath, JSON.stringify({}) + '\n');
+
+  expect(() => run(appJsonPath)).toThrow(/got undefined/);
+});
+
+it('fails when the current version is not a valid version', () => {
+  const appJsonPath = writeAppJson('not-a-version');
+
+  expect(() => run(appJsonPath)).toThrow(/got "not-a-version"/);
+});
@@ -0,0 +1,33 @@
+import { readFileSync, writeFileSync } from 'node:fs';
+
+type AppConfig = { expo?: { version?: string } };
+
+const appConfigPath = process.argv[2];
+
+if (!appConfigPath) {
+  console.error(
+    'Usage: node scripts/bump-example-version.ts <path to the example app config>'
+  );
+  process.exit(1);
+}
+
+const appConfig: AppConfig = JSON.parse(readFileSync(appConfigPath, 'utf8'));
+const expo = appConfig.expo;
+const currentVersion = expo?.version;
+const parsed = /^(\d+)\.(\d+)\.(\d+)$/.exec(currentVersion ?? '');
+
+if (!expo || !parsed) {
+  console.error(
+    `Expected a "major.minor.patch" version at expo.version in ${appConfigPath}, got ${JSON.stringify(currentVersion)}.`
+  );
+  process.exit(1);
+}
+
+const [, major, minor] = parsed;
+const nextVersion = `${major}.${Number(minor) + 1}.0`;
+
+expo.version = nextVersion;
+
+writeFileSync(appConfigPath, JSON.stringify(appConfig, null, 2) + '\n');
+
+console.log(`Bumped example app version to ${nextVersion}`);