Capacitor with Bun Monorepo

Describe Capacitor's runtime architecture (native shell + WebView + bridge) and contrast it with Electron and React Native.

Identify the roles of capacitor.config.ts, the web build directory, and the native iOS/Android projects in a Capacitor app.

Install @capacitor/core and @capacitor/cli into an existing bun + Turborepo workspace and run CLI commands via bunx.

Run `bunx cap init` and configure capacitor.config.ts (appId, appName, webDir) to point at the React SPA's build output.

Add and configure a dedicated 'mobile' location within the Turborepo to house the native projects, with corresponding pipeline tasks (build, sync, open).

Configure the SPA's Vite build for a Capacitor target, ensuring a relative base path and proper history routing.

Run `bunx cap add ios` and `bunx cap add android` and explain the structure of the files each command generates.

Use `bunx cap sync` to copy web assets and update native dependencies, distinguishing it from `cap copy` and `cap update`.

Install Xcode, its command-line tools, and CocoaPods, and verify the complete iOS toolchain.

Open the generated iOS project in Xcode and identify the key files: App.xcworkspace, Podfile, and Info.plist.

Build and launch the application on the iOS Simulator using the Capacitor CLI (`bunx cap run ios`).

Build and launch the application on the iOS Simulator directly from the Xcode IDE.

Configure an Apple Developer team, bundle identifier, and automatic signing to run the app on a physical iOS device.

Customize the iOS app icon and splash screen using @capacitor/assets, driven by bun scripts.

Edit Info.plist to add usage description keys (e.g., for camera, location, biometrics) and explain why iOS mandates them.

Diagnose common iOS build failures, such as pod install errors, signing issues, and deployment target mismatches.

Install Android Studio and the Android SDK, and configure the JAVA_HOME and ANDROID_HOME environment variables.

Build and launch the app on an Android emulator using both the Capacitor CLI (`bunx cap run android`) and Android Studio.

Deploy and run the app on a physical Android device after enabling developer mode and USB debugging.

Configure essential Android properties in `build.gradle`, including `applicationId`, `versionCode`, `versionName`, and SDK versions.

Customize the Android app icon, adaptive icon, and splash screen using the @capacitor/assets tool.

Generate a private signing key and keystore for the application using `keytool` and securely store its credentials.

Configure the project's `build.gradle` file to use the signing key for debug builds.

Diagnose common Android build failures, including Gradle sync errors, SDK license issues, and AndroidManifest merge conflicts.

Explain the Capacitor plugin model and how JavaScript calls are dispatched to native Swift/Kotlin code.

Install the @capacitor/push-notifications plugin and sync it to the native iOS and Android projects.

Configure Push Notifications for iOS by enabling the APNs capability in Xcode and managing credentials in the Apple Developer portal.

Configure Push Notifications for Android by creating a Firebase project and adding the `google-services.json` file.

Implement React logic to request push permission from the user and retrieve the device registration token.

Handle incoming push notification payloads within the React app, both when it is in the foreground and background.

Install and use @capacitor/local-notifications to schedule immediate and delayed local alerts on both platforms.

Handle user interactions with local notifications to navigate to specific content within the app.

Install @capacitor/filesystem and manage files using different sandboxed directories (Data, Cache, External).

Implement the necessary runtime permission requests for the Filesystem plugin on Android.

Install the @capacitor-community/biometric-auth plugin to secure application features.

Check for biometric hardware availability and type (e.g., Face ID, Touch ID, fingerprint) before attempting to authenticate.

Build a React hook that abstracts biometric availability checks and the authentication prompt.

Gate access to a specific React component or route, requiring successful biometric authentication for entry.

Explain what can and cannot be updated via OTA according to App Store and Play Store policies.

Install and configure a third-party OTA service, such as `@capgo/capacitor-updater`, in the web app and native projects.

Set up an OTA channel and publish a new web bundle from the Turborepo using bun scripts.

Implement logic in React to check for, download, and apply an available update.

Create a user-facing component (e.g., a toast or modal) to inform the user of a pending update and prompt them to restart the app.

Create an app record in App Store Connect, configuring the bundle ID and initial required metadata.

Create an application in the Google Play Console, configuring the package name and completing initial setup.

Configure the Android project's Gradle file to generate a signed Android App Bundle (AAB) for release.

Archive a release build of the iOS app in Xcode, ensuring it is correctly signed for App Store distribution.

Prepare required store assets, including screenshots, app descriptions, and a privacy policy URL.

Complete the App Store's App Privacy questionnaire based on the app's functionality and third-party plugins.

Complete the Google Play Data Safety form, declaring data collection and security practices.

Upload the archived iOS build to App Store Connect and distribute it to internal testers via TestFlight.

Navigate the App Store Connect portal to manage TestFlight builds and invite external testers.

Upload the signed AAB to a Google Play internal testing track.

Promote a build through Google Play's closed and open testing tracks to gather feedback.

Submit the iOS application for final App Store review.

Submit the Android application for final Google Play review.