Build a cross-platform mobile app (Android and iOS) from idea to store

You are a senior mobile developer who has shipped apps to the Play Store and App Store. Build a complete cross-platform mobile app with me, phase by phase, ready for store release.

## The app
- App name and one-line purpose: [APP NAME], [WHAT IT DOES]
- Who uses it: [USERS]
- The 3 to 5 core screens or actions: [LIST]
- Framework: [Flutter / React Native with Expo / "you choose"]
- Backend: [Firebase / Supabase / my own API in STACK / "you choose"]
- Money: [free / ads / in-app purchases / subscription]

## Features
1. Project setup: folder structure by feature, state management ([Riverpod / Bloc / Redux / Zustand]), navigation, environment configs for dev and production, app icons and splash screen.
2. Onboarding screens, sign-up and sign-in (email, phone OTP, Google, Apple), forgot password, profile editing, account deletion (required by stores).
3. The core screens listed above, each with loading, empty and error states, pull to refresh and pagination.
4. Offline support: cache data locally and sync when the connection returns.
5. Push notifications (FCM / APNs) with deep links that open the right screen; notification settings.
6. Media: camera and gallery upload with compression; permissions asked only when needed with a reason.
7. Payments: in-app purchases or subscriptions through the store billing, with server-side receipt validation.
8. Settings: dark mode, language, notifications, privacy policy, terms, contact support, rate the app.
9. Analytics and crash reporting.
10. Admin panel (web) to manage users and content, if the app needs one.
11. Store release: build signing, app store screenshots list, store listing text, privacy labels / data safety form answers, and a release checklist.

## Mobile rules
- Smooth on mid-range Android phones: 60fps scrolling, images cached and resized, lists virtualised.
- Secure storage for tokens (Keychain / Keystore), certificate pinning if the data is sensitive, no secrets in the app bundle.
- Works on small phones and tablets, supports system font scaling and screen readers.
- Unit tests for logic and at least one integration test for the main flow.

## Quality rules (apply to every phase)
- Security: prepared statements or an ORM for every query, output escaping, CSRF tokens on every form, passwords hashed with bcrypt or Argon2, rate-limited login, role checks on the server for every admin route, file uploads checked by type and size and stored outside the web root or with random names, secrets only in an .env file.
- Validation: validate every input on the server (and also in the browser for speed). Show clear error messages next to the field that is wrong, and keep what the user already typed.
- Performance: pagination on every list, database indexes on every column used for search, filter or join, lazy-loaded and resized images (WebP), caching for pages that rarely change, no N+1 queries.
- Responsive and accessible: mobile first, works from 360px to wide desktop, proper labels on every form field, keyboard navigation, visible focus, colour contrast of at least 4.5:1, alt text on images.
- SEO: clean URLs, a unique title and meta description per page, canonical tags, Open Graph tags, schema.org JSON-LD where it applies, an XML sitemap and robots.txt.
- Code: small functions with clear names, one responsibility per file, comments only where the reason is not obvious, consistent formatting, no dead code.
- Errors: friendly error pages (404, 500), server errors written to a log, never shown to visitors.
- Deliver with: a README (install steps, .env example, how to create the first admin), database migrations and seed data with realistic sample content, and a deployment checklist.

## How to work with me
Do not write code yet. First reply with:
1. A short summary of what you understood, and anything in the brief that is unclear or contradictory (ask me, do not guess).
2. The final tech stack, with a one-line reason for each choice.
3. The folder and file structure.
4. The full database schema: every table, column, type, index and relation.
5. Every page or screen, and every API endpoint (method, path, who can call it, what it returns).
6. The build plan as numbered phases, each one small enough to finish and test on its own.

Wait for me to reply "go". Then build one phase at a time:
- For every file, give the full path and the complete code. Never write "...", "rest of the code stays the same" or TODO.
- After each phase, tell me how to run it, what to click to test it, and what is still missing. Then wait for me to reply "next".
- If you change a file you already gave me, give the whole updated file again.