From 3f5ecc99f51814b173291b6be77b51016daece42 Mon Sep 17 00:00:00 2001
From: franzap <_@franzap.com>
Date: Tue, 10 Feb 2026 22:05:47 -0300
Subject: [PATCH] Rename app back to app

---
 android/app/build.gradle.kts                  |    4 +-
 android/app/proguard-rules.pro                |    2 +-
 android/app/src/main/AndroidManifest.xml      |    4 +-
 .../zapstore/{alpha => app}/MainActivity.kt   |    6 +-
 .../plugins/AndroidPackageManagerPlugin.kt    | 1125 +++++++++--------
 .../plugins/AppRestartPlugin.kt               |    5 +-
 .../plugins/InstallResultReceiver.kt          |    2 +-
 lib/constants/app_constants.dart              |    2 +-
 .../dummy_package_manager.dart                |    4 +-
 linux/CMakeLists.txt                          |    2 +-
 macos/Runner.xcodeproj/project.pbxproj        |    6 +-
 macos/Runner/Configs/AppInfo.xcconfig         |    2 +-
 12 files changed, 649 insertions(+), 515 deletions(-)
 rename android/app/src/main/kotlin/dev/zapstore/{alpha => app}/MainActivity.kt (75%)
 rename android/app/src/main/kotlin/dev/zapstore/{alpha => app}/plugins/AndroidPackageManagerPlugin.kt (60%)
 rename android/app/src/main/kotlin/dev/zapstore/{alpha => app}/plugins/AppRestartPlugin.kt (97%)
 rename android/app/src/main/kotlin/dev/zapstore/{alpha => app}/plugins/InstallResultReceiver.kt (99%)

diff --git a/android/app/build.gradle.kts b/android/app/build.gradle.kts
index e76f3db..0f6e74f 100644
--- a/android/app/build.gradle.kts
+++ b/android/app/build.gradle.kts
@@ -16,7 +16,7 @@ if (keystorePropertiesFile.exists()) {
 }
 
 android {
-    namespace = "dev.zapstore.alpha"
+    namespace = "dev.zapstore.app"
     compileSdk = 36
     ndkVersion = "27.0.12077973"
 
@@ -32,7 +32,7 @@ android {
 
     defaultConfig {
         // TODO: Specify your own unique Application ID (https://developer.android.com/studio/build/application-id.html).
-        applicationId = "dev.zapstore.alpha"
+        applicationId = "dev.zapstore.app"
         // You can update the following values to match your application needs.
         // For more information, see: https://flutter.dev/to/review-gradle-config.
         minSdk = 29
diff --git a/android/app/proguard-rules.pro b/android/app/proguard-rules.pro
index 65e5fdd..644352e 100644
--- a/android/app/proguard-rules.pro
+++ b/android/app/proguard-rules.pro
@@ -19,7 +19,7 @@
 -keep class org.sqlite.** { *; }
 
 # Keep package manager plugin classes
--keep class dev.zapstore.alpha.plugins.** { *; }
+-keep class dev.zapstore.app.plugins.** { *; }
 
 # Ignore missing Google Play Core classes (optional dependency for dynamic features)
 -dontwarn com.google.android.play.core.splitcompat.SplitCompatApplication
diff --git a/android/app/src/main/AndroidManifest.xml b/android/app/src/main/AndroidManifest.xml
index 1e7dd2c..e55b0a2 100644
--- a/android/app/src/main/AndroidManifest.xml
+++ b/android/app/src/main/AndroidManifest.xml
@@ -16,7 +16,7 @@
     <uses-permission android:name="android.permission.WAKE_LOCK" />
 
     <application
-        android:label="Zapstore Alpha"
+        android:label="Zapstore"
         android:name="${applicationName}"
         android:icon="@mipmap/ic_launcher"
         android:enableOnBackInvokedCallback="true"
@@ -72,7 +72,7 @@
             android:value="2" />
 
         <receiver
-            android:name="dev.zapstore.alpha.plugins.InstallResultReceiver"
+            android:name="dev.zapstore.app.plugins.InstallResultReceiver"
             android:exported="false" />
     </application>
     <!-- Required to query activities that can process text, see:
diff --git a/android/app/src/main/kotlin/dev/zapstore/alpha/MainActivity.kt b/android/app/src/main/kotlin/dev/zapstore/app/MainActivity.kt
similarity index 75%
rename from android/app/src/main/kotlin/dev/zapstore/alpha/MainActivity.kt
rename to android/app/src/main/kotlin/dev/zapstore/app/MainActivity.kt
index 86750bf..d901f14 100644
--- a/android/app/src/main/kotlin/dev/zapstore/alpha/MainActivity.kt
+++ b/android/app/src/main/kotlin/dev/zapstore/app/MainActivity.kt
@@ -1,7 +1,7 @@
-package dev.zapstore.alpha
+package dev.zapstore.app
 
-import dev.zapstore.alpha.plugins.AndroidPackageManagerPlugin
-import dev.zapstore.alpha.plugins.AppRestartPlugin
+import dev.zapstore.app.plugins.AndroidPackageManagerPlugin
+import dev.zapstore.app.plugins.AppRestartPlugin
 import io.flutter.embedding.android.FlutterActivity
 import io.flutter.embedding.engine.FlutterEngine
 
diff --git a/android/app/src/main/kotlin/dev/zapstore/alpha/plugins/AndroidPackageManagerPlugin.kt b/android/app/src/main/kotlin/dev/zapstore/app/plugins/AndroidPackageManagerPlugin.kt
similarity index 60%
rename from android/app/src/main/kotlin/dev/zapstore/alpha/plugins/AndroidPackageManagerPlugin.kt
rename to android/app/src/main/kotlin/dev/zapstore/app/plugins/AndroidPackageManagerPlugin.kt
index d5b37a7..3132240 100644
--- a/android/app/src/main/kotlin/dev/zapstore/alpha/plugins/AndroidPackageManagerPlugin.kt
+++ b/android/app/src/main/kotlin/dev/zapstore/app/plugins/AndroidPackageManagerPlugin.kt
@@ -1,4 +1,4 @@
-package dev.zapstore.alpha.plugins
+package dev.zapstore.app.plugins
 
 import android.app.PendingIntent
 import android.content.Context
@@ -44,16 +44,16 @@ private const val MAX_INSTALL_WATCHDOG_MS = 120_000L
 private const val COPY_BUFFER_SIZE = 262144
 
 /**
- * Install status values emitted via EventChannel.
- * These form a simple state machine with no hanging states.
+ * Install status values emitted via EventChannel. These form a simple state machine with no hanging
+ * states.
  */
 object InstallStatus {
     const val STARTED = "started"
     const val VERIFYING = "verifying"
-    const val VERIFYING_PROGRESS = "verifyingProgress"  // Verification progress update
+    const val VERIFYING_PROGRESS = "verifyingProgress" // Verification progress update
     const val PENDING_USER_ACTION = "pendingUserAction"
-    const val INSTALLING = "installing"  // User accepted, system is now installing
-    const val SYSTEM_PROCESSING = "systemProcessing"  // Committed, cannot cancel
+    const val INSTALLING = "installing" // User accepted, system is now installing
+    const val SYSTEM_PROCESSING = "systemProcessing" // Committed, cannot cancel
     const val ALREADY_IN_PROGRESS = "alreadyInProgress"
     const val SUCCESS = "success"
     const val FAILED = "failed"
@@ -61,8 +61,8 @@ object InstallStatus {
 }
 
 /**
- * Structured error codes for failures.
- * Dart uses these for reliable error categorization instead of parsing strings.
+ * Structured error codes for failures. Dart uses these for reliable error categorization instead of
+ * parsing strings.
  */
 object ErrorCode {
     const val DOWNLOAD_FAILED = "downloadFailed"
@@ -80,18 +80,18 @@ object ErrorCode {
 
 /**
  * AndroidPackageManagerPlugin - Event-driven architecture for clean state management.
- * 
+ *
  * Architecture:
  * - MethodChannel: Fire-and-forget commands (install, uninstall, etc.)
  * - EventChannel: Streams install status events to Dart
  * - ProcessLifecycleOwner: Auto-detects app foreground state (no Dart involvement)
- * 
- * The native side is the single source of truth for install state.
- * Dart simply reacts to events - no polling, no probing, no hanging awaits.
+ *
+ * The native side is the single source of truth for install state. Dart simply reacts to events -
+ * no polling, no probing, no hanging awaits.
  */
-class AndroidPackageManagerPlugin : FlutterPlugin, MethodCallHandler, 
-    EventChannel.StreamHandler, DefaultLifecycleObserver {
-    
+class AndroidPackageManagerPlugin :
+        FlutterPlugin, MethodCallHandler, EventChannel.StreamHandler, DefaultLifecycleObserver {
+
     private lateinit var methodChannel: MethodChannel
     private lateinit var eventChannel: EventChannel
     private lateinit var context: Context
@@ -118,74 +118,87 @@ class AndroidPackageManagerPlugin : FlutterPlugin, MethodCallHandler,
 
     /** Session callback to detect progress after user confirms install */
     private var sessionCallback: PackageInstaller.SessionCallback? = null
-    
+
     private var eventSink: EventChannel.EventSink? = null
-    
+
     companion object {
         private var instance: AndroidPackageManagerPlugin? = null
-        
+
         /** Map sessionId to packageName for reverse lookup in broadcasts */
         private val sessionToPackage = ConcurrentHashMap<Int, String>()
-        
+
         /** Pending user action intents - stored for re-launch when app returns to foreground */
         private val pendingUserActionIntents = mutableMapOf<String, Intent>()
-        
+
         /** Buffer last-known event per appId when Dart isn't listening yet */
         private val bufferedEvents = mutableMapOf<String, Map<String, Any?>>()
 
         /** App foreground state - auto-managed by ProcessLifecycleOwner */
         private var isAppInForeground = true
-        
+
         private var appContext: Context? = null
-        
+
         /**
-         * Called by InstallResultReceiver when a broadcast arrives.
-         * Emits the status event to Dart via EventChannel.
+         * Called by InstallResultReceiver when a broadcast arrives. Emits the status event to Dart
+         * via EventChannel.
          */
         fun onInstallResult(
-            sessionId: Int,
-            status: String,
-            packageName: String,
-            message: String? = null,
-            isUpdate: Boolean = false,
-            confirmIntent: Intent? = null,
-            errorCode: String? = null
+                sessionId: Int,
+                status: String,
+                packageName: String,
+                message: String? = null,
+                isUpdate: Boolean = false,
+                confirmIntent: Intent? = null,
+                errorCode: String? = null
         ) {
             val pkg = packageName.ifEmpty { sessionToPackage[sessionId] ?: "unknown" }
-            
-            Log.d(TAG, "onInstallResult: pkg=$pkg, status=$status, msg=$message, errorCode=$errorCode, sessionId=$sessionId")
-            
+
+            Log.d(
+                    TAG,
+                    "onInstallResult: pkg=$pkg, status=$status, msg=$message, errorCode=$errorCode, sessionId=$sessionId"
+            )
+
             // Handle pending user action - store intent for potential re-launch
             if (status == InstallStatus.PENDING_USER_ACTION && confirmIntent != null) {
                 pendingUserActionIntents[pkg] = confirmIntent
-                
-                // Track this session as pending user action so SessionCallback can detect acceptance
+
+                // Track this session as pending user action so SessionCallback can detect
+                // acceptance
                 instance?.sessionsPendingUserAction?.add(sessionId)
-                
+
                 // Auto-launch dialog if app is in foreground
                 if (isAppInForeground) {
                     launchConfirmDialog(pkg, confirmIntent)
                 }
             }
-            
+
             // Clean up tracking on terminal states
-            if (status in listOf(InstallStatus.SUCCESS, InstallStatus.FAILED, InstallStatus.CANCELLED)) {
+            if (status in
+                            listOf(
+                                    InstallStatus.SUCCESS,
+                                    InstallStatus.FAILED,
+                                    InstallStatus.CANCELLED
+                            )
+            ) {
                 sessionToPackage.remove(sessionId)
                 pendingUserActionIntents.remove(pkg)
                 instance?.sessionsPendingUserAction?.remove(sessionId)
                 instance?.sessionsInstalling?.remove(sessionId)
                 instance?.committedSessions?.remove(sessionId)
-                
+
                 if (status == InstallStatus.SUCCESS) {
                     instance?.sessionsCompletedSuccessfully?.add(sessionId)
                 } else {
                     abandonSession(sessionId)
                 }
             }
-            
+
             val inst = instance
             if (inst == null) {
-                Log.e(TAG, "CRITICAL: Cannot emit event - plugin instance is null! pkg=$pkg, status=$status")
+                Log.e(
+                        TAG,
+                        "CRITICAL: Cannot emit event - plugin instance is null! pkg=$pkg, status=$status"
+                )
                 bufferEvent(pkg, status, message, errorCode)
                 return
             }
@@ -193,30 +206,29 @@ class AndroidPackageManagerPlugin : FlutterPlugin, MethodCallHandler,
         }
 
         private fun bufferEvent(
-            appId: String,
-            status: String,
-            message: String? = null,
-            errorCode: String? = null
+                appId: String,
+                status: String,
+                message: String? = null,
+                errorCode: String? = null
         ) {
-            val event = mutableMapOf<String, Any?>(
-                "appId" to appId,
-                "status" to status
-            )
+            val event = mutableMapOf<String, Any?>("appId" to appId, "status" to status)
             if (message != null) event["message"] = message
             if (errorCode != null) event["errorCode"] = errorCode
             bufferedEvents[appId] = event
         }
-        
+
         private fun launchConfirmDialog(packageName: String, intent: Intent) {
             val ctx = appContext ?: return
             val inst = instance
-            
+
             // Post with delay to ensure the system is ready to show the dialog.
             // Without this, the dialog may not appear when the broadcast arrives
             // immediately after session.commit() while the app is still processing.
             val launcher: () -> Unit = {
                 try {
-                    intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_SINGLE_TOP)
+                    intent.addFlags(
+                            Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_SINGLE_TOP
+                    )
                     ctx.startActivity(intent)
                     Log.d(TAG, "Launched confirmation dialog for $packageName")
                 } catch (e: Exception) {
@@ -224,7 +236,7 @@ class AndroidPackageManagerPlugin : FlutterPlugin, MethodCallHandler,
                 }
                 Unit
             }
-            
+
             if (inst != null) {
                 inst.mainHandler.postDelayed(launcher, 100)
             } else {
@@ -232,7 +244,7 @@ class AndroidPackageManagerPlugin : FlutterPlugin, MethodCallHandler,
                 Handler(Looper.getMainLooper()).postDelayed(launcher, 100)
             }
         }
-        
+
         private fun abandonSession(sessionId: Int) {
             val ctx = appContext ?: return
             try {
@@ -241,58 +253,54 @@ class AndroidPackageManagerPlugin : FlutterPlugin, MethodCallHandler,
                 Log.d(TAG, "Could not abandon session $sessionId: ${e.message}")
             }
         }
-        
+
         fun isAppInForeground(): Boolean = isAppInForeground
     }
-    
+
     // ═══════════════════════════════════════════════════════════════════════════════
     // FLUTTER PLUGIN LIFECYCLE
     // ═══════════════════════════════════════════════════════════════════════════════
-    
+
     override fun onAttachedToEngine(binding: FlutterPlugin.FlutterPluginBinding) {
         context = binding.applicationContext
         appContext = context
         instance = this
-        
+
         methodChannel = MethodChannel(binding.binaryMessenger, "android_package_manager")
         methodChannel.setMethodCallHandler(this)
-        
+
         eventChannel = EventChannel(binding.binaryMessenger, "android_package_manager/events")
         eventChannel.setStreamHandler(this)
-        
+
         // Auto-detect foreground state via ProcessLifecycleOwner
-        mainHandler.post {
-            ProcessLifecycleOwner.get().lifecycle.addObserver(this)
-        }
-        
+        mainHandler.post { ProcessLifecycleOwner.get().lifecycle.addObserver(this) }
+
         // Register session callback to detect when user accepts install dialog
         registerSessionCallback()
-        
+
         cleanupStaleSessions()
         Log.d(TAG, "AndroidPackageManagerPlugin initialized")
     }
-    
+
     override fun onDetachedFromEngine(binding: FlutterPlugin.FlutterPluginBinding) {
-        mainHandler.post {
-            ProcessLifecycleOwner.get().lifecycle.removeObserver(this)
-        }
+        mainHandler.post { ProcessLifecycleOwner.get().lifecycle.removeObserver(this) }
         unregisterSessionCallback()
         methodChannel.setMethodCallHandler(null)
         eventChannel.setStreamHandler(null)
         eventSink = null
         instance = null
     }
-    
+
     // ═══════════════════════════════════════════════════════════════════════════════
     // LIFECYCLE OBSERVER (Auto foreground detection)
     // ═══════════════════════════════════════════════════════════════════════════════
-    
+
     override fun onStart(owner: LifecycleOwner) {
         // App came to foreground
         val wasForeground = isAppInForeground
         isAppInForeground = true
         Log.d(TAG, "App foregrounded")
-        
+
         if (!wasForeground) {
             // Re-launch any pending install dialogs
             for ((packageName, intent) in pendingUserActionIntents.toMap()) {
@@ -301,69 +309,82 @@ class AndroidPackageManagerPlugin : FlutterPlugin, MethodCallHandler,
             }
         }
     }
-    
+
     override fun onStop(owner: LifecycleOwner) {
         // App went to background
         isAppInForeground = false
         Log.d(TAG, "App backgrounded")
     }
-    
+
     // ═══════════════════════════════════════════════════════════════════════════════
     // SESSION CALLBACK (Detect when user accepts install dialog)
     // ═══════════════════════════════════════════════════════════════════════════════
-    
+
     private fun registerSessionCallback() {
-        sessionCallback = object : PackageInstaller.SessionCallback() {
-            override fun onCreated(sessionId: Int) {}
-            override fun onBadgingChanged(sessionId: Int) {}
-            override fun onActiveChanged(sessionId: Int, active: Boolean) {}
-            
-            override fun onProgressChanged(sessionId: Int, progress: Float) {
-                // When we see progress on a session that was pending user action,
-                // it means the user accepted and the system is now installing.
-                val pkg = sessionToPackage[sessionId] ?: return
-                
-                // Only emit INSTALLING once per session
-                if (sessionId in sessionsPendingUserAction && sessionId !in sessionsInstalling) {
-                    sessionsInstalling.add(sessionId)
-                    sessionsPendingUserAction.remove(sessionId)
-                    Log.d(TAG, "User accepted install for $pkg (progress=$progress)")
-                    onInstallResult(
-                        sessionId = sessionId,
-                        status = InstallStatus.INSTALLING,
-                        packageName = pkg,
-                        message = "Installing..."
-                    )
+        sessionCallback =
+                object : PackageInstaller.SessionCallback() {
+                    override fun onCreated(sessionId: Int) {}
+                    override fun onBadgingChanged(sessionId: Int) {}
+                    override fun onActiveChanged(sessionId: Int, active: Boolean) {}
+
+                    override fun onProgressChanged(sessionId: Int, progress: Float) {
+                        // When we see progress on a session that was pending user action,
+                        // it means the user accepted and the system is now installing.
+                        val pkg = sessionToPackage[sessionId] ?: return
+
+                        // Only emit INSTALLING once per session
+                        if (sessionId in sessionsPendingUserAction &&
+                                        sessionId !in sessionsInstalling
+                        ) {
+                            sessionsInstalling.add(sessionId)
+                            sessionsPendingUserAction.remove(sessionId)
+                            Log.d(TAG, "User accepted install for $pkg (progress=$progress)")
+                            onInstallResult(
+                                    sessionId = sessionId,
+                                    status = InstallStatus.INSTALLING,
+                                    packageName = pkg,
+                                    message = "Installing..."
+                            )
+                        }
+                    }
+
+                    override fun onFinished(sessionId: Int, success: Boolean) {
+                        val pkg = sessionToPackage[sessionId]
+                        Log.d(
+                                TAG,
+                                "SessionCallback.onFinished: sessionId=$sessionId, success=$success, pkg=$pkg"
+                        )
+
+                        // If install succeeded and we have a tracked package, emit SUCCESS
+                        // This catches installs that completed after timeout or missed the
+                        // broadcast
+                        if (success && pkg != null && sessionId !in sessionsCompletedSuccessfully) {
+                            sessionsCompletedSuccessfully.add(sessionId)
+                            Log.d(
+                                    TAG,
+                                    "Emitting SUCCESS from onFinished for $pkg (sessionId=$sessionId)"
+                            )
+                            onInstallResult(
+                                    sessionId = sessionId,
+                                    status = InstallStatus.SUCCESS,
+                                    packageName = pkg
+                            )
+                        }
+
+                        // Clean up tracking
+                        sessionsPendingUserAction.remove(sessionId)
+                        sessionsInstalling.remove(sessionId)
+                        committedSessions.remove(sessionId)
+                    }
                 }
-            }
-            
-            override fun onFinished(sessionId: Int, success: Boolean) {
-                val pkg = sessionToPackage[sessionId]
-                Log.d(TAG, "SessionCallback.onFinished: sessionId=$sessionId, success=$success, pkg=$pkg")
-                
-                // If install succeeded and we have a tracked package, emit SUCCESS
-                // This catches installs that completed after timeout or missed the broadcast
-                if (success && pkg != null && sessionId !in sessionsCompletedSuccessfully) {
-                    sessionsCompletedSuccessfully.add(sessionId)
-                    Log.d(TAG, "Emitting SUCCESS from onFinished for $pkg (sessionId=$sessionId)")
-                    onInstallResult(
-                        sessionId = sessionId,
-                        status = InstallStatus.SUCCESS,
-                        packageName = pkg
-                    )
-                }
-                
-                // Clean up tracking
-                sessionsPendingUserAction.remove(sessionId)
-                sessionsInstalling.remove(sessionId)
-                committedSessions.remove(sessionId)
-            }
-        }
-        
-        context.packageManager.packageInstaller.registerSessionCallback(sessionCallback!!, mainHandler)
+
+        context.packageManager.packageInstaller.registerSessionCallback(
+                sessionCallback!!,
+                mainHandler
+        )
         Log.d(TAG, "Registered session callback")
     }
-    
+
     private fun unregisterSessionCallback() {
         sessionCallback?.let {
             try {
@@ -374,11 +395,11 @@ class AndroidPackageManagerPlugin : FlutterPlugin, MethodCallHandler,
         }
         sessionCallback = null
     }
-    
+
     // ═══════════════════════════════════════════════════════════════════════════════
     // EVENT CHANNEL STREAM HANDLER
     // ═══════════════════════════════════════════════════════════════════════════════
-    
+
     override fun onListen(arguments: Any?, events: EventChannel.EventSink?) {
         eventSink = events
         // Flush buffered events (if any) so Dart can reconcile state.
@@ -396,49 +417,50 @@ class AndroidPackageManagerPlugin : FlutterPlugin, MethodCallHandler,
             }
         }
     }
-    
+
     override fun onCancel(arguments: Any?) {
         eventSink = null
     }
-    
-    private fun emitInstallStatus(
-        appId: String, 
-        status: String, 
-        message: String? = null,
-        errorCode: String? = null,
-        description: String? = null,
-        progress: Double? = null
-    ) {
-        val emitNow = emit@{
-            // Update watchdog regardless of whether Dart is listening.
-            updateWatchdog(appId, status)
 
-            val sink = eventSink
-            if (sink == null) {
-                Log.e(TAG, "CRITICAL: Cannot emit event - eventSink is null! appId=$appId, status=$status, msg=$message")
-                bufferEvent(appId, status, message, errorCode)
-                return@emit
-            }
-            
-            val event = mutableMapOf<String, Any?>(
-                "appId" to appId,
-                "status" to status
-            )
-            if (message != null) {
-                event["message"] = message
-            }
-            if (errorCode != null) {
-                event["errorCode"] = errorCode
-            }
-            if (description != null) {
-                event["description"] = description
-            }
-            if (progress != null) {
-                event["progress"] = progress
-            }
-            Log.d(TAG, "Emitting to Dart: $event")
-            sink.success(event)
-        }
+    private fun emitInstallStatus(
+            appId: String,
+            status: String,
+            message: String? = null,
+            errorCode: String? = null,
+            description: String? = null,
+            progress: Double? = null
+    ) {
+        val emitNow =
+                emit@{
+                    // Update watchdog regardless of whether Dart is listening.
+                    updateWatchdog(appId, status)
+
+                    val sink = eventSink
+                    if (sink == null) {
+                        Log.e(
+                                TAG,
+                                "CRITICAL: Cannot emit event - eventSink is null! appId=$appId, status=$status, msg=$message"
+                        )
+                        bufferEvent(appId, status, message, errorCode)
+                        return@emit
+                    }
+
+                    val event = mutableMapOf<String, Any?>("appId" to appId, "status" to status)
+                    if (message != null) {
+                        event["message"] = message
+                    }
+                    if (errorCode != null) {
+                        event["errorCode"] = errorCode
+                    }
+                    if (description != null) {
+                        event["description"] = description
+                    }
+                    if (progress != null) {
+                        event["progress"] = progress
+                    }
+                    Log.d(TAG, "Emitting to Dart: $event")
+                    sink.success(event)
+                }
 
         // If we're already on the main thread (common for MethodChannel calls),
         // emit synchronously so the UI can transition immediately.
@@ -463,61 +485,79 @@ class AndroidPackageManagerPlugin : FlutterPlugin, MethodCallHandler,
     private fun scheduleWatchdog(appId: String, initialDelayMs: Long) {
         val gen = bumpWatchdogGen(appId)
         val now = System.currentTimeMillis()
-        val deadline = watchdogDeadlineMs[appId] ?: (now + MAX_INSTALL_WATCHDOG_MS).also {
-            watchdogDeadlineMs[appId] = it
-        }
+        val deadline =
+                watchdogDeadlineMs[appId]
+                        ?: (now + MAX_INSTALL_WATCHDOG_MS).also { watchdogDeadlineMs[appId] = it }
 
-        mainHandler.postDelayed({
-            if (watchdogGen[appId] != gen) return@postDelayed
+        mainHandler.postDelayed(
+                {
+                    if (watchdogGen[appId] != gen) return@postDelayed
 
-            // "Ping" reality before timing out.
-            val hasSession = hasActiveSession(appId)
-            val hasPendingUi = pendingUserActionIntents.containsKey(appId)
-            val verifyThread = verificationThreads[appId]
-            val verifyingAlive = verifyThread?.isAlive == true
+                    // "Ping" reality before timing out.
+                    val hasSession = hasActiveSession(appId)
+                    val hasPendingUi = pendingUserActionIntents.containsKey(appId)
+                    val verifyThread = verificationThreads[appId]
+                    val verifyingAlive = verifyThread?.isAlive == true
 
-            // If work is still happening, extend (bounded by deadline).
-            val now2 = System.currentTimeMillis()
-            if (now2 < deadline && (hasSession || hasPendingUi || verifyingAlive)) {
-                // Nudge Dart to show the most accurate state (esp. after reconnect).
-                if (hasPendingUi) {
-                    emitInstallStatus(appId, InstallStatus.PENDING_USER_ACTION, "User confirmation pending")
-                } else if (hasSession) {
-                    emitInstallStatus(appId, InstallStatus.STARTED)
-                } else if (verifyingAlive) {
-                    emitInstallStatus(appId, InstallStatus.VERIFYING)
-                }
-                // Backoff: next check is another INSTALL_WATCHDOG_MS.
-                scheduleWatchdog(appId, INSTALL_WATCHDOG_MS)
-                return@postDelayed
-            }
+                    // If work is still happening, extend (bounded by deadline).
+                    val now2 = System.currentTimeMillis()
+                    if (now2 < deadline && (hasSession || hasPendingUi || verifyingAlive)) {
+                        // Nudge Dart to show the most accurate state (esp. after reconnect).
+                        if (hasPendingUi) {
+                            emitInstallStatus(
+                                    appId,
+                                    InstallStatus.PENDING_USER_ACTION,
+                                    "User confirmation pending"
+                            )
+                        } else if (hasSession) {
+                            emitInstallStatus(appId, InstallStatus.STARTED)
+                        } else if (verifyingAlive) {
+                            emitInstallStatus(appId, InstallStatus.VERIFYING)
+                        }
+                        // Backoff: next check is another INSTALL_WATCHDOG_MS.
+                        scheduleWatchdog(appId, INSTALL_WATCHDOG_MS)
+                        return@postDelayed
+                    }
 
-            // Check if session is committed - if so, we can't abandon it
-            val sessionId = sessionToPackage.entries.find { it.value == appId }?.key
-            val isCommitted = sessionId != null && sessionId in committedSessions
-            
-            if (isCommitted) {
-                // Session is committed - Android is in control, we cannot abort
-                // Keep waiting and show "system processing" status
-                Log.w(TAG, "Watchdog: Session for $appId is committed (sessionId=$sessionId), system is processing. Cannot timeout.")
-                emitInstallStatus(appId, InstallStatus.SYSTEM_PROCESSING, "System is processing...")
-                // Extend deadline significantly - Android will eventually complete or fail
-                watchdogDeadlineMs[appId] = System.currentTimeMillis() + MAX_INSTALL_WATCHDOG_MS
-                scheduleWatchdog(appId, INSTALL_WATCHDOG_MS * 2)
-                return@postDelayed
-            }
-            
-            // Deadline exceeded or no evidence of progress: fail fast and cleanup.
-            Log.w(TAG, "Watchdog timeout for $appId (hasSession=$hasSession, pendingUi=$hasPendingUi, verifyingAlive=$verifyingAlive, isCommitted=$isCommitted)")
-            abandonExistingSession(appId)
-            emitInstallStatus(
-                appId,
-                InstallStatus.FAILED,
-                "Installation timed out. Please retry.",
-                ErrorCode.INSTALL_TIMEOUT
-            )
-            clearWatchdog(appId)
-        }, initialDelayMs)
+                    // Check if session is committed - if so, we can't abandon it
+                    val sessionId = sessionToPackage.entries.find { it.value == appId }?.key
+                    val isCommitted = sessionId != null && sessionId in committedSessions
+
+                    if (isCommitted) {
+                        // Session is committed - Android is in control, we cannot abort
+                        // Keep waiting and show "system processing" status
+                        Log.w(
+                                TAG,
+                                "Watchdog: Session for $appId is committed (sessionId=$sessionId), system is processing. Cannot timeout."
+                        )
+                        emitInstallStatus(
+                                appId,
+                                InstallStatus.SYSTEM_PROCESSING,
+                                "System is processing..."
+                        )
+                        // Extend deadline significantly - Android will eventually complete or fail
+                        watchdogDeadlineMs[appId] =
+                                System.currentTimeMillis() + MAX_INSTALL_WATCHDOG_MS
+                        scheduleWatchdog(appId, INSTALL_WATCHDOG_MS * 2)
+                        return@postDelayed
+                    }
+
+                    // Deadline exceeded or no evidence of progress: fail fast and cleanup.
+                    Log.w(
+                            TAG,
+                            "Watchdog timeout for $appId (hasSession=$hasSession, pendingUi=$hasPendingUi, verifyingAlive=$verifyingAlive, isCommitted=$isCommitted)"
+                    )
+                    abandonExistingSession(appId)
+                    emitInstallStatus(
+                            appId,
+                            InstallStatus.FAILED,
+                            "Installation timed out. Please retry.",
+                            ErrorCode.INSTALL_TIMEOUT
+                    )
+                    clearWatchdog(appId)
+                },
+                initialDelayMs
+        )
     }
 
     private fun updateWatchdog(appId: String, status: String) {
@@ -526,8 +566,10 @@ class AndroidPackageManagerPlugin : FlutterPlugin, MethodCallHandler,
                 // Start watchdog for verify stage
                 scheduleWatchdog(appId, VERIFY_WATCHDOG_MS)
             }
-            InstallStatus.STARTED, InstallStatus.PENDING_USER_ACTION, 
-            InstallStatus.INSTALLING, InstallStatus.SYSTEM_PROCESSING -> {
+            InstallStatus.STARTED,
+            InstallStatus.PENDING_USER_ACTION,
+            InstallStatus.INSTALLING,
+            InstallStatus.SYSTEM_PROCESSING -> {
                 // Start/refresh watchdog for install stage
                 scheduleWatchdog(appId, INSTALL_WATCHDOG_MS)
             }
@@ -537,11 +579,11 @@ class AndroidPackageManagerPlugin : FlutterPlugin, MethodCallHandler,
             }
         }
     }
-    
+
     // ═══════════════════════════════════════════════════════════════════════════════
     // METHOD CHANNEL HANDLER
     // ═══════════════════════════════════════════════════════════════════════════════
-    
+
     override fun onMethodCall(call: MethodCall, result: Result) {
         when (call.method) {
             "install" -> {
@@ -549,28 +591,23 @@ class AndroidPackageManagerPlugin : FlutterPlugin, MethodCallHandler,
                 val packageName = call.argument<String>("packageName")
                 val expectedHash = call.argument<String>("expectedHash")
                 val expectedSize = call.argument<Number>("expectedSize")?.toLong()
-                
+
                 if (filePath == null || packageName == null) {
                     result.error("MISSING_ARGUMENT", "filePath and packageName required", null)
                     return
                 }
                 installApk(filePath, packageName, expectedHash, expectedSize, result)
             }
-            
             "canInstallSilently" -> {
                 val packageName = call.argument<String>("packageName")
                 result.success(canInstallSilently(packageName))
             }
-            
             "hasUnknownSourcesPermission" -> result.success(hasUnknownSourcesPermission())
-            
             "requestInstallPermission" -> requestInstallPermission(result)
-            
             "getInstalledApps" -> {
                 val includeSystem = call.argument<Boolean>("includeSystemApps") ?: false
                 result.success(getInstalledApps(includeSystem))
             }
-            
             "uninstall" -> {
                 val packageName = call.argument<String>("packageName")
                 if (packageName == null) {
@@ -579,7 +616,6 @@ class AndroidPackageManagerPlugin : FlutterPlugin, MethodCallHandler,
                 }
                 uninstallApp(packageName, result)
             }
-            
             "launchApp" -> {
                 val packageName = call.argument<String>("packageName")
                 if (packageName == null) {
@@ -588,7 +624,6 @@ class AndroidPackageManagerPlugin : FlutterPlugin, MethodCallHandler,
                 }
                 launchApp(packageName, result)
             }
-            
             "abortInstall" -> {
                 val packageName = call.argument<String>("packageName")
                 if (packageName == null) {
@@ -597,34 +632,48 @@ class AndroidPackageManagerPlugin : FlutterPlugin, MethodCallHandler,
                 }
                 abortInstall(packageName, result)
             }
-            
             else -> result.notImplemented()
         }
     }
-    
+
     // ═══════════════════════════════════════════════════════════════════════════════
     // INSTALLATION
     // ═══════════════════════════════════════════════════════════════════════════════
-    
+
     private fun installApk(
-        filePath: String,
-        packageName: String,
-        expectedHash: String?,
-        expectedSize: Long?,
-        result: Result
+            filePath: String,
+            packageName: String,
+            expectedHash: String?,
+            expectedSize: Long?,
+            result: Result
     ) {
         val file = File(filePath)
         if (!file.exists()) {
-            emitInstallStatus(packageName, InstallStatus.FAILED, "APK file not found", ErrorCode.DOWNLOAD_FAILED)
-            result.success(mapOf("started" to false, "error" to "APK file not found", "errorCode" to ErrorCode.DOWNLOAD_FAILED))
+            emitInstallStatus(
+                    packageName,
+                    InstallStatus.FAILED,
+                    "APK file not found",
+                    ErrorCode.DOWNLOAD_FAILED
+            )
+            result.success(
+                    mapOf(
+                            "started" to false,
+                            "error" to "APK file not found",
+                            "errorCode" to ErrorCode.DOWNLOAD_FAILED
+                    )
+            )
             return
         }
-        
+
         if (hasActiveSession(packageName)) {
             if (pendingUserActionIntents.containsKey(packageName)) {
                 // Real pending dialog - re-launch it and let user complete
                 pendingUserActionIntents[packageName]?.let { launchConfirmDialog(packageName, it) }
-                emitInstallStatus(packageName, InstallStatus.PENDING_USER_ACTION, "User confirmation pending")
+                emitInstallStatus(
+                        packageName,
+                        InstallStatus.PENDING_USER_ACTION,
+                        "User confirmation pending"
+                )
                 result.success(mapOf("started" to false, "alreadyInProgress" to true))
                 return
             }
@@ -632,23 +681,39 @@ class AndroidPackageManagerPlugin : FlutterPlugin, MethodCallHandler,
             Log.d(TAG, "Abandoning stale session for $packageName")
             abandonExistingSession(packageName)
         }
-        
+
         // Check for install restrictions on main thread before starting background work
         val userManager = context.getSystemService(UserManager::class.java)
-        val installBlocked = userManager.hasUserRestriction(UserManager.DISALLOW_INSTALL_APPS) ||
-            userManager.hasUserRestriction(UserManager.DISALLOW_INSTALL_UNKNOWN_SOURCES) ||
-            userManager.hasUserRestriction(UserManager.DISALLOW_INSTALL_UNKNOWN_SOURCES_GLOBALLY)
-        
+        val installBlocked =
+                userManager.hasUserRestriction(UserManager.DISALLOW_INSTALL_APPS) ||
+                        userManager.hasUserRestriction(
+                                UserManager.DISALLOW_INSTALL_UNKNOWN_SOURCES
+                        ) ||
+                        userManager.hasUserRestriction(
+                                UserManager.DISALLOW_INSTALL_UNKNOWN_SOURCES_GLOBALLY
+                        )
+
         if (installBlocked) {
-            emitInstallStatus(packageName, InstallStatus.FAILED, "Installation blocked by device policy", ErrorCode.BLOCKED)
-            result.success(mapOf("started" to false, "error" to "Blocked by policy", "errorCode" to ErrorCode.BLOCKED))
+            emitInstallStatus(
+                    packageName,
+                    InstallStatus.FAILED,
+                    "Installation blocked by device policy",
+                    ErrorCode.BLOCKED
+            )
+            result.success(
+                    mapOf(
+                            "started" to false,
+                            "error" to "Blocked by policy",
+                            "errorCode" to ErrorCode.BLOCKED
+                    )
+            )
             return
         }
-        
+
         // Emit verifying status - all install work happens on background thread
         emitInstallStatus(packageName, InstallStatus.VERIFYING)
         result.success(mapOf("started" to true, "verifying" to true))
-        
+
         // All heavy I/O work runs on background thread to prevent ANRs
         val t = Thread {
             verifyAndInstall(file, packageName, expectedHash, expectedSize)
@@ -657,17 +722,17 @@ class AndroidPackageManagerPlugin : FlutterPlugin, MethodCallHandler,
         verificationThreads[packageName] = t
         t.start()
     }
-    
+
     /**
      * Single-pass verify and install - runs entirely on background thread.
-     * 
+     *
      * This method:
      * 1. Validates APK format (ZIP magic bytes)
      * 2. Creates install session
      * 3. Streams file ONCE - computing hash AND copying to session simultaneously
      * 4. Reports progress during copy
      * 5. Commits session on success, cleans up on failure
-     * 
+     *
      * Benefits:
      * - 50% less I/O (file read once instead of twice)
      * - No ANRs (runs off main thread)
@@ -675,104 +740,112 @@ class AndroidPackageManagerPlugin : FlutterPlugin, MethodCallHandler,
      * - Proper resource cleanup on all error paths
      */
     private fun verifyAndInstall(
-        apkFile: File,
-        packageName: String,
-        expectedHash: String?,
-        expectedSize: Long?
+            apkFile: File,
+            packageName: String,
+            expectedHash: String?,
+            expectedSize: Long?
     ) {
         // Step 1: Validate APK format before doing any heavy work
         if (!isValidApkFormat(apkFile)) {
             apkFile.delete()
             mainHandler.post {
                 emitInstallStatus(
-                    packageName,
-                    InstallStatus.FAILED,
-                    "Invalid APK file",
-                    ErrorCode.INVALID_FILE,
-                    "The downloaded file is not a valid APK format."
+                        packageName,
+                        InstallStatus.FAILED,
+                        "Invalid APK file",
+                        ErrorCode.INVALID_FILE,
+                        "The downloaded file is not a valid APK format."
                 )
             }
             return
         }
-        
+
         val packageInstaller = context.packageManager.packageInstaller
         var sessionId = -1
         var session: PackageInstaller.Session? = null
-        
+
         try {
             // Step 2: Check if this is an update
-            val isUpdate = try {
-                context.packageManager.getPackageInfo(packageName, 0)
-                true
-            } catch (_: PackageManager.NameNotFoundException) { false }
-            
+            val isUpdate =
+                    try {
+                        context.packageManager.getPackageInfo(packageName, 0)
+                        true
+                    } catch (_: PackageManager.NameNotFoundException) {
+                        false
+                    }
+
             // Step 3: Abandon any existing session and create new one
             abandonExistingSession(packageName)
-            
-            val sessionParams = PackageInstaller.SessionParams(
-                PackageInstaller.SessionParams.MODE_FULL_INSTALL
-            ).apply {
-                setAppPackageName(packageName)
-                setInstallLocation(android.content.pm.PackageInfo.INSTALL_LOCATION_AUTO)
-                
-                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
-                    setRequireUserAction(PackageInstaller.SessionParams.USER_ACTION_NOT_REQUIRED)
-                }
-                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
-                    setPackageSource(PackageInstaller.PACKAGE_SOURCE_STORE)
-                }
-                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
-                    setRequestUpdateOwnership(true)
-                }
-            }
-            
+
+            val sessionParams =
+                    PackageInstaller.SessionParams(PackageInstaller.SessionParams.MODE_FULL_INSTALL)
+                            .apply {
+                                setAppPackageName(packageName)
+                                setInstallLocation(
+                                        android.content.pm.PackageInfo.INSTALL_LOCATION_AUTO
+                                )
+
+                                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+                                    setRequireUserAction(
+                                            PackageInstaller.SessionParams.USER_ACTION_NOT_REQUIRED
+                                    )
+                                }
+                                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+                                    setPackageSource(PackageInstaller.PACKAGE_SOURCE_STORE)
+                                }
+                                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
+                                    setRequestUpdateOwnership(true)
+                                }
+                            }
+
             sessionId = packageInstaller.createSession(sessionParams)
             session = packageInstaller.openSession(sessionId)
             sessionToPackage[sessionId] = packageName
-            
+
             // Step 4: Single-pass verify + copy with progress reporting
             val digest = if (expectedHash != null) MessageDigest.getInstance("SHA-256") else null
-            
+
             FileInputStream(apkFile).use { fis ->
                 val fileSize = Os.fstat(fis.fd).st_size
-                
+
                 session.openWrite(apkFile.name, 0, fileSize).use { sessionStream ->
                     val buffer = ByteArray(COPY_BUFFER_SIZE)
                     var bytesCopied = 0L
                     var lastProgressPercent = -1
                     var bytesRead: Int
-                    
+
                     while (fis.read(buffer).also { bytesRead = it } != -1) {
                         // Hash the chunk if verification is needed
                         digest?.update(buffer, 0, bytesRead)
-                        
+
                         // Copy to session
                         sessionStream.write(buffer, 0, bytesRead)
                         bytesCopied += bytesRead
-                        
+
                         // Report progress (throttled to whole percentage changes)
                         if (fileSize > 0) {
                             val progressPercent = ((bytesCopied * 100) / fileSize).toInt()
-                            if (progressPercent != lastProgressPercent && progressPercent % 5 == 0) {
+                            if (progressPercent != lastProgressPercent && progressPercent % 5 == 0
+                            ) {
                                 lastProgressPercent = progressPercent
                                 Log.d(TAG, "Verify progress for $packageName: $progressPercent%")
                                 // Emit progress to Dart
                                 val progressFraction = bytesCopied.toDouble() / fileSize.toDouble()
                                 mainHandler.post {
                                     emitInstallStatus(
-                                        packageName,
-                                        InstallStatus.VERIFYING_PROGRESS,
-                                        progress = progressFraction
+                                            packageName,
+                                            InstallStatus.VERIFYING_PROGRESS,
+                                            progress = progressFraction
                                     )
                                 }
                             }
                         }
                     }
-                    
+
                     session.fsync(sessionStream)
                 }
             }
-            
+
             // Step 5: Verify hash if expected
             if (digest != null && expectedHash != null) {
                 val actualHash = digest.digest().joinToString("") { "%02x".format(it) }
@@ -781,20 +854,20 @@ class AndroidPackageManagerPlugin : FlutterPlugin, MethodCallHandler,
                     session.close()
                     packageInstaller.abandonSession(sessionId)
                     sessionToPackage.remove(sessionId)
-                    
+
                     mainHandler.post {
                         emitInstallStatus(
-                            packageName,
-                            InstallStatus.FAILED,
-                            "Hash verification failed",
-                            ErrorCode.HASH_MISMATCH,
-                            "The downloaded file hash does not match.\n\nExpected: $expectedHash\nActual: $actualHash"
+                                packageName,
+                                InstallStatus.FAILED,
+                                "Hash verification failed",
+                                ErrorCode.HASH_MISMATCH,
+                                "The downloaded file hash does not match.\n\nExpected: $expectedHash\nActual: $actualHash"
                         )
                     }
                     return
                 }
             }
-            
+
             // Step 6: Emit STARTED *before* commit to avoid race with SUCCESS broadcast
             // For silent installs, the SUCCESS broadcast can arrive immediately after commit.
             // We use a CountDownLatch to ensure STARTED is processed on main thread before
@@ -806,99 +879,120 @@ class AndroidPackageManagerPlugin : FlutterPlugin, MethodCallHandler,
             }
             // Wait for STARTED to be emitted (timeout prevents deadlock if main thread is blocked)
             startedLatch.await(1, TimeUnit.SECONDS)
-            
+
             // Step 7: Commit the session - this triggers the install broadcast
-            val intent = Intent(context.applicationContext, InstallResultReceiver::class.java).apply {
-                putExtra("sessionId", sessionId)
-                putExtra("packageName", packageName)
-                putExtra("isUpdate", isUpdate)
-            }
-            val pendingIntent = PendingIntent.getBroadcast(
-                context.applicationContext, sessionId, intent,
-                PendingIntent.FLAG_MUTABLE or PendingIntent.FLAG_UPDATE_CURRENT
-            )
-            
+            val intent =
+                    Intent(context.applicationContext, InstallResultReceiver::class.java).apply {
+                        putExtra("sessionId", sessionId)
+                        putExtra("packageName", packageName)
+                        putExtra("isUpdate", isUpdate)
+                    }
+            val pendingIntent =
+                    PendingIntent.getBroadcast(
+                            context.applicationContext,
+                            sessionId,
+                            intent,
+                            PendingIntent.FLAG_MUTABLE or PendingIntent.FLAG_UPDATE_CURRENT
+                    )
+
             session.commit(pendingIntent.intentSender)
-            committedSessions.add(sessionId)  // Mark as committed - abandonSession won't work now
+            committedSessions.add(sessionId) // Mark as committed - abandonSession won't work now
             Log.d(TAG, "Session $sessionId committed for $packageName")
             session.close()
-            session = null  // Prevent double-close in finally
-            
+            session = null // Prevent double-close in finally
         } catch (e: SecurityException) {
             // Clean up session on error
             session?.close()
             if (sessionId >= 0) {
-                try { packageInstaller.abandonSession(sessionId) } catch (_: Exception) {}
+                try {
+                    packageInstaller.abandonSession(sessionId)
+                } catch (_: Exception) {}
                 sessionToPackage.remove(sessionId)
             }
-            
+
             mainHandler.post {
                 emitInstallStatus(
-                    packageName,
-                    InstallStatus.FAILED,
-                    "Permission denied: ${e.message}",
-                    ErrorCode.PERMISSION_DENIED
+                        packageName,
+                        InstallStatus.FAILED,
+                        "Permission denied: ${e.message}",
+                        ErrorCode.PERMISSION_DENIED
                 )
             }
         } catch (e: Exception) {
             // Clean up session on error
             session?.close()
             if (sessionId >= 0) {
-                try { packageInstaller.abandonSession(sessionId) } catch (_: Exception) {}
+                try {
+                    packageInstaller.abandonSession(sessionId)
+                } catch (_: Exception) {}
                 sessionToPackage.remove(sessionId)
             }
-            
+
             mainHandler.post {
                 emitInstallStatus(
-                    packageName,
-                    InstallStatus.FAILED,
-                    e.message ?: "Installation failed",
-                    ErrorCode.INSTALL_FAILED
+                        packageName,
+                        InstallStatus.FAILED,
+                        e.message ?: "Installation failed",
+                        ErrorCode.INSTALL_FAILED
                 )
             }
         }
     }
-    
+
     // ═══════════════════════════════════════════════════════════════════════════════
     // SESSION MANAGEMENT
     // ═══════════════════════════════════════════════════════════════════════════════
-    
+
     private fun hasActiveSession(packageName: String): Boolean {
-        return sessionToPackage.containsValue(packageName) || 
-               findExistingSession(packageName) != null
+        return sessionToPackage.containsValue(packageName) ||
+                findExistingSession(packageName) != null
     }
-    
+
     private fun findExistingSession(packageName: String): PackageInstaller.SessionInfo? {
         return try {
-            context.packageManager.packageInstaller.mySessions
-                .find { it.appPackageName == packageName }
-        } catch (_: Exception) { null }
+            context.packageManager.packageInstaller.mySessions.find {
+                it.appPackageName == packageName
+            }
+        } catch (_: Exception) {
+            null
+        }
     }
-    
+
     private fun abandonExistingSession(packageName: String) {
         val session = findExistingSession(packageName) ?: return
         val isCommitted = session.sessionId in committedSessions
-        
+
         if (isCommitted) {
-            Log.d(TAG, "abandonExistingSession: Session ${session.sessionId} for $packageName is committed, abandon may not work")
+            Log.d(
+                    TAG,
+                    "abandonExistingSession: Session ${session.sessionId} for $packageName is committed, abandon may not work"
+            )
         }
-        
+
         try {
             context.packageManager.packageInstaller.abandonSession(session.sessionId)
-            Log.d(TAG, "abandonExistingSession: Abandoned session ${session.sessionId} for $packageName")
+            Log.d(
+                    TAG,
+                    "abandonExistingSession: Abandoned session ${session.sessionId} for $packageName"
+            )
             sessionToPackage.remove(session.sessionId)
             pendingUserActionIntents.remove(packageName)
             committedSessions.remove(session.sessionId)
         } catch (e: Exception) {
-            Log.w(TAG, "abandonExistingSession: Failed to abandon session ${session.sessionId} for $packageName: ${e.message}")
+            Log.w(
+                    TAG,
+                    "abandonExistingSession: Failed to abandon session ${session.sessionId} for $packageName: ${e.message}"
+            )
         }
     }
-    
+
     private fun cleanupStaleSessions() {
         try {
             val installer = context.packageManager.packageInstaller
             installer.mySessions.filter { !it.isActive }.forEach { session ->
-                try { installer.abandonSession(session.sessionId) } catch (_: Exception) {}
+                try {
+                    installer.abandonSession(session.sessionId)
+                } catch (_: Exception) {}
             }
             sessionToPackage.clear()
             pendingUserActionIntents.clear()
@@ -906,105 +1000,126 @@ class AndroidPackageManagerPlugin : FlutterPlugin, MethodCallHandler,
             sessionsCompletedSuccessfully.clear()
         } catch (_: Exception) {}
     }
-    
+
     // ═══════════════════════════════════════════════════════════════════════════════
     // APK VALIDATION
     // ═══════════════════════════════════════════════════════════════════════════════
-    
+
     /**
-     * Quick APK format check - validates ZIP magic bytes.
-     * This is a lightweight check that doesn't load the APK into memory.
+     * Quick APK format check - validates ZIP magic bytes. This is a lightweight check that doesn't
+     * load the APK into memory.
      */
     private fun isValidApkFormat(file: File): Boolean {
         return try {
             FileInputStream(file).use { fis ->
                 val magic = ByteArray(4)
                 if (fis.read(magic) < 4) return false
-                magic[0] == 0x50.toByte() && magic[1] == 0x4B.toByte() &&
-                    magic[2] == 0x03.toByte() && magic[3] == 0x04.toByte()
+                magic[0] == 0x50.toByte() &&
+                        magic[1] == 0x4B.toByte() &&
+                        magic[2] == 0x03.toByte() &&
+                        magic[3] == 0x04.toByte()
             }
-        } catch (_: Exception) { false }
+        } catch (_: Exception) {
+            false
+        }
     }
-    
+
     // ═══════════════════════════════════════════════════════════════════════════════
     // PERMISSIONS
     // ═══════════════════════════════════════════════════════════════════════════════
-    
+
     private fun canInstallSilently(packageName: String? = null): Boolean {
         if (Build.VERSION.SDK_INT < Build.VERSION_CODES.S) {
             Log.d(TAG, "canInstallSilently($packageName): false - API < 31")
             return false
         }
-        
-        val canRequest = try {
-            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-                context.packageManager.canRequestPackageInstalls()
-            } else true
-        } catch (_: Throwable) { false }
-        
+
+        val canRequest =
+                try {
+                    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+                        context.packageManager.canRequestPackageInstalls()
+                    } else true
+                } catch (_: Throwable) {
+                    false
+                }
+
         if (!canRequest) {
             Log.d(TAG, "canInstallSilently($packageName): false - no install permission")
             return false
         }
-        
+
         if (packageName != null) {
             return try {
-                val installSource = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
-                    context.packageManager.getInstallSourceInfo(packageName)
-                } else null
-                
-                val installer = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R && installSource != null) {
-                    installSource.installingPackageName
-                } else {
-                    @Suppress("DEPRECATION")
-                    context.packageManager.getInstallerPackageName(packageName)
-                }
-                
+                val installSource =
+                        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+                            context.packageManager.getInstallSourceInfo(packageName)
+                        } else null
+
+                val installer =
+                        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R && installSource != null
+                        ) {
+                            installSource.installingPackageName
+                        } else {
+                            @Suppress("DEPRECATION")
+                            context.packageManager.getInstallerPackageName(packageName)
+                        }
+
                 val ourPackage = context.packageName
                 val result = installer == ourPackage
-                
-                Log.d(TAG, "canInstallSilently($packageName): installer=$installer, us=$ourPackage, result=$result")
+
+                Log.d(
+                        TAG,
+                        "canInstallSilently($packageName): installer=$installer, us=$ourPackage, result=$result"
+                )
                 if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R && installSource != null) {
                     Log.d(TAG, "  initiatingPackage=${installSource.initiatingPackageName}")
                     Log.d(TAG, "  originatingPackage=${installSource.originatingPackageName}")
                 }
-                
+
                 result
             } catch (_: PackageManager.NameNotFoundException) {
                 Log.d(TAG, "canInstallSilently($packageName): false - package not found")
-                false  // Package not found = can't silently install it
+                false // Package not found = can't silently install it
             } catch (e: Exception) {
                 Log.d(TAG, "canInstallSilently($packageName): false - error: ${e.message}")
                 false
             }
         }
-        
+
         // Check general capability (no specific package)
-        val hasPermission = try {
-            context.checkSelfPermission("android.permission.UPDATE_PACKAGES_WITHOUT_USER_ACTION") ==
-                PackageManager.PERMISSION_GRANTED
-        } catch (_: Throwable) { false }
-        
+        val hasPermission =
+                try {
+                    context.checkSelfPermission(
+                            "android.permission.UPDATE_PACKAGES_WITHOUT_USER_ACTION"
+                    ) == PackageManager.PERMISSION_GRANTED
+                } catch (_: Throwable) {
+                    false
+                }
+
         Log.d(TAG, "canInstallSilently(general): hasUpdatePermission=$hasPermission")
         return hasPermission
     }
-    
+
     private fun hasUnknownSourcesPermission(): Boolean {
         return try {
             if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
                 context.packageManager.canRequestPackageInstalls()
             } else true
-        } catch (_: Throwable) { false }
+        } catch (_: Throwable) {
+            false
+        }
     }
-    
+
     private fun requestInstallPermission(result: Result) {
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O && 
-            !context.packageManager.canRequestPackageInstalls()) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O &&
+                        !context.packageManager.canRequestPackageInstalls()
+        ) {
             try {
-                val intent = Intent(Settings.ACTION_MANAGE_UNKNOWN_APP_SOURCES).apply {
-                    data = Uri.parse("package:${context.packageName}")
-                    addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
-                }
+                val intent =
+                        Intent(Settings.ACTION_MANAGE_UNKNOWN_APP_SOURCES).apply {
+                            data = Uri.parse("package:${context.packageName}")
+                            addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+                        }
                 context.startActivity(intent)
                 result.success(mapOf("success" to true))
             } catch (e: Exception) {
@@ -1014,11 +1129,11 @@ class AndroidPackageManagerPlugin : FlutterPlugin, MethodCallHandler,
             result.success(mapOf("success" to true))
         }
     }
-    
+
     // ═══════════════════════════════════════════════════════════════════════════════
     // UNINSTALL
     // ═══════════════════════════════════════════════════════════════════════════════
-    
+
     private fun uninstallApp(packageName: String, result: Result) {
         try {
             try {
@@ -1027,52 +1142,62 @@ class AndroidPackageManagerPlugin : FlutterPlugin, MethodCallHandler,
                 result.success(mapOf("isSuccess" to false, "errorMessage" to "Package not found"))
                 return
             }
-            
-            val intent = Intent(Intent.ACTION_DELETE).apply {
-                data = Uri.parse("package:$packageName")
-                addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
-            }
+
+            val intent =
+                    Intent(Intent.ACTION_DELETE).apply {
+                        data = Uri.parse("package:$packageName")
+                        addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+                    }
             context.startActivity(intent)
-            
+
             // Poll for removal with 30 second timeout
             Thread {
-                val startTime = System.currentTimeMillis()
-                
-                while (System.currentTimeMillis() - startTime < UNINSTALL_TIMEOUT_MS) {
-                    try {
-                        Thread.sleep(UNINSTALL_POLL_INTERVAL_MS)
-                        context.packageManager.getPackageInfo(packageName, 0)
-                    } catch (_: PackageManager.NameNotFoundException) {
-                        mainHandler.post {
-                            result.success(mapOf("isSuccess" to true, "packageName" to packageName))
+                        val startTime = System.currentTimeMillis()
+
+                        while (System.currentTimeMillis() - startTime < UNINSTALL_TIMEOUT_MS) {
+                            try {
+                                Thread.sleep(UNINSTALL_POLL_INTERVAL_MS)
+                                context.packageManager.getPackageInfo(packageName, 0)
+                            } catch (_: PackageManager.NameNotFoundException) {
+                                mainHandler.post {
+                                    result.success(
+                                            mapOf("isSuccess" to true, "packageName" to packageName)
+                                    )
+                                }
+                                return@Thread
+                            } catch (_: InterruptedException) {
+                                break
+                            }
                         }
-                        return@Thread
-                    } catch (_: InterruptedException) { break }
-                }
-                
-                val stillInstalled = try {
-                    context.packageManager.getPackageInfo(packageName, 0)
-                    true
-                } catch (_: PackageManager.NameNotFoundException) { false }
-                
-                mainHandler.post {
-                    result.success(mapOf(
-                        "isSuccess" to !stillInstalled,
-                        "packageName" to packageName,
-                        "cancelled" to stillInstalled
-                    ))
-                }
-            }.start()
-            
+
+                        val stillInstalled =
+                                try {
+                                    context.packageManager.getPackageInfo(packageName, 0)
+                                    true
+                                } catch (_: PackageManager.NameNotFoundException) {
+                                    false
+                                }
+
+                        mainHandler.post {
+                            result.success(
+                                    mapOf(
+                                            "isSuccess" to !stillInstalled,
+                                            "packageName" to packageName,
+                                            "cancelled" to stillInstalled
+                                    )
+                            )
+                        }
+                    }
+                    .start()
         } catch (e: Exception) {
             result.success(mapOf("isSuccess" to false, "errorMessage" to e.message))
         }
     }
-    
+
     // ═══════════════════════════════════════════════════════════════════════════════
     // APP LAUNCH
     // ═══════════════════════════════════════════════════════════════════════════════
-    
+
     private fun launchApp(packageName: String, result: Result) {
         try {
             val launchIntent = context.packageManager.getLaunchIntentForPackage(packageName)
@@ -1087,51 +1212,52 @@ class AndroidPackageManagerPlugin : FlutterPlugin, MethodCallHandler,
             result.success(mapOf("isSuccess" to false, "errorMessage" to e.message))
         }
     }
-    
+
     // ═══════════════════════════════════════════════════════════════════════════════
     // ABORT INSTALL (User-initiated cancellation)
     // ═══════════════════════════════════════════════════════════════════════════════
-    
+
     /**
-     * Explicitly abort an install operation and clear all tracking.
-     * This is best-effort - if the session is already committed, Android may still complete it.
+     * Explicitly abort an install operation and clear all tracking. This is best-effort - if the
+     * session is already committed, Android may still complete it.
      */
     private fun abortInstall(packageName: String, result: Result) {
         Log.d(TAG, "abortInstall called for $packageName")
-        
+
         // Find and clean up the session
         val sessionId = sessionToPackage.entries.find { it.value == packageName }?.key
         val isCommitted = sessionId != null && sessionId in committedSessions
-        
+
         // Clear all tracking for this package
         clearAllTrackingForPackage(packageName)
-        
+
         // Clear watchdog
         clearWatchdog(packageName)
-        
+
         // Try to abandon the session (will fail silently if already committed)
         abandonExistingSession(packageName)
-        
+
         // Emit cancelled status so Dart knows to clean up
         emitInstallStatus(packageName, InstallStatus.CANCELLED, "Installation aborted by user")
-        
-        result.success(mapOf(
-            "success" to true,
-            "wasCommitted" to isCommitted,
-            "message" to if (isCommitted) {
-                "Session was already committed. Android may still complete the install."
-            } else {
-                "Install aborted successfully."
-            }
-        ))
+
+        result.success(
+                mapOf(
+                        "success" to true,
+                        "wasCommitted" to isCommitted,
+                        "message" to
+                                if (isCommitted) {
+                                    "Session was already committed. Android may still complete the install."
+                                } else {
+                                    "Install aborted successfully."
+                                }
+                )
+        )
     }
-    
-    /**
-     * Clear all tracking maps for a given package.
-     */
+
+    /** Clear all tracking maps for a given package. */
     private fun clearAllTrackingForPackage(packageName: String) {
         pendingUserActionIntents.remove(packageName)
-        
+
         val sessionId = sessionToPackage.entries.find { it.value == packageName }?.key
         if (sessionId != null) {
             sessionToPackage.remove(sessionId)
@@ -1140,64 +1266,73 @@ class AndroidPackageManagerPlugin : FlutterPlugin, MethodCallHandler,
             committedSessions.remove(sessionId)
             sessionsCompletedSuccessfully.remove(sessionId)
         }
-        
+
         verificationThreads.remove(packageName)
     }
-    
+
     // ═══════════════════════════════════════════════════════════════════════════════
     // INSTALLED APPS
     // ═══════════════════════════════════════════════════════════════════════════════
-    
+
     private fun getInstalledApps(includeSystemApps: Boolean): List<Map<String, Any?>> {
         val pm = context.packageManager
         return pm.getInstalledPackages(0).mapNotNull { pkg ->
             val appInfo = pkg.applicationInfo ?: return@mapNotNull null
             val isSystem = (appInfo.flags and android.content.pm.ApplicationInfo.FLAG_SYSTEM) != 0
             if (!includeSystemApps && isSystem) return@mapNotNull null
-            
-            val versionCode = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
-                pkg.longVersionCode
-            } else {
-                @Suppress("DEPRECATION")
-                pkg.versionCode.toLong()
-            }
-            
+
+            val versionCode =
+                    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
+                        pkg.longVersionCode
+                    } else {
+                        @Suppress("DEPRECATION") pkg.versionCode.toLong()
+                    }
+
             mapOf(
-                "name" to appInfo.loadLabel(pm)?.toString(),
-                "bundleId" to pkg.packageName,
-                "versionName" to pkg.versionName,
-                "versionCode" to versionCode,
-                "signatureHash" to getSignatureHash(pkg.packageName),
-                "canInstallSilently" to canInstallSilently(pkg.packageName)
+                    "name" to appInfo.loadLabel(pm)?.toString(),
+                    "bundleId" to pkg.packageName,
+                    "versionName" to pkg.versionName,
+                    "versionCode" to versionCode,
+                    "signatureHash" to getSignatureHash(pkg.packageName),
+                    "canInstallSilently" to canInstallSilently(pkg.packageName)
             )
         }
     }
-    
+
     private fun getSignatureHash(packageName: String): String {
         return try {
             val pm = context.packageManager
-            val pkgInfo = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
-                pm.getPackageInfo(packageName, PackageManager.PackageInfoFlags.of(
-                    PackageManager.GET_SIGNING_CERTIFICATES.toLong()))
-            } else {
-                @Suppress("DEPRECATION")
-                pm.getPackageInfo(packageName, PackageManager.GET_SIGNATURES)
-            }
-            
-            val signatures = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
-                pkgInfo.signingInfo?.let { si ->
-                    if (si.hasMultipleSigners()) si.apkContentsSigners else si.signingCertificateHistory
-                } ?: emptyArray()
-            } else {
-                @Suppress("DEPRECATION")
-                pkgInfo.signatures ?: emptyArray()
-            }
-            
+            val pkgInfo =
+                    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+                        pm.getPackageInfo(
+                                packageName,
+                                PackageManager.PackageInfoFlags.of(
+                                        PackageManager.GET_SIGNING_CERTIFICATES.toLong()
+                                )
+                        )
+                    } else {
+                        @Suppress("DEPRECATION")
+                        pm.getPackageInfo(packageName, PackageManager.GET_SIGNATURES)
+                    }
+
+            val signatures =
+                    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
+                        pkgInfo.signingInfo?.let { si ->
+                            if (si.hasMultipleSigners()) si.apkContentsSigners
+                            else si.signingCertificateHistory
+                        }
+                                ?: emptyArray()
+                    } else {
+                        @Suppress("DEPRECATION") pkgInfo.signatures ?: emptyArray()
+                    }
+
             if (signatures.isEmpty()) return ""
-            
-            MessageDigest.getInstance("SHA-256")
-                .digest(signatures[0].toByteArray())
-                .joinToString("") { "%02x".format(it) }
-        } catch (_: Exception) { "" }
+
+            MessageDigest.getInstance("SHA-256").digest(signatures[0].toByteArray()).joinToString(
+                            ""
+                    ) { "%02x".format(it) }
+        } catch (_: Exception) {
+            ""
+        }
     }
 }
diff --git a/android/app/src/main/kotlin/dev/zapstore/alpha/plugins/AppRestartPlugin.kt b/android/app/src/main/kotlin/dev/zapstore/app/plugins/AppRestartPlugin.kt
similarity index 97%
rename from android/app/src/main/kotlin/dev/zapstore/alpha/plugins/AppRestartPlugin.kt
rename to android/app/src/main/kotlin/dev/zapstore/app/plugins/AppRestartPlugin.kt
index 0295d71..e2bf1a8 100644
--- a/android/app/src/main/kotlin/dev/zapstore/alpha/plugins/AppRestartPlugin.kt
+++ b/android/app/src/main/kotlin/dev/zapstore/app/plugins/AppRestartPlugin.kt
@@ -1,4 +1,4 @@
-package dev.zapstore.alpha.plugins
+package dev.zapstore.app.plugins
 
 import android.content.Context
 import android.content.Intent
@@ -39,5 +39,4 @@ class AppRestartPlugin : FlutterPlugin, MethodChannel.MethodCallHandler {
         context.startActivity(intent)
         exitProcess(0)
     }
-}
-
+}
\ No newline at end of file
diff --git a/android/app/src/main/kotlin/dev/zapstore/alpha/plugins/InstallResultReceiver.kt b/android/app/src/main/kotlin/dev/zapstore/app/plugins/InstallResultReceiver.kt
similarity index 99%
rename from android/app/src/main/kotlin/dev/zapstore/alpha/plugins/InstallResultReceiver.kt
rename to android/app/src/main/kotlin/dev/zapstore/app/plugins/InstallResultReceiver.kt
index fe43ec1..c4854ed 100644
--- a/android/app/src/main/kotlin/dev/zapstore/alpha/plugins/InstallResultReceiver.kt
+++ b/android/app/src/main/kotlin/dev/zapstore/app/plugins/InstallResultReceiver.kt
@@ -1,4 +1,4 @@
-package dev.zapstore.alpha.plugins
+package dev.zapstore.app.plugins
 
 import android.content.BroadcastReceiver
 import android.content.Context
diff --git a/lib/constants/app_constants.dart b/lib/constants/app_constants.dart
index 3cde44e..a144b94 100644
--- a/lib/constants/app_constants.dart
+++ b/lib/constants/app_constants.dart
@@ -1,5 +1,5 @@
 /// Application identifier for Zapstore itself
-const kZapstoreAppIdentifier = 'dev.zapstore.alpha';
+const kZapstoreAppIdentifier = 'dev.zapstore.app';
 
 /// Zapstore's public key for relay-signed apps
 const kZapstorePubkey =
diff --git a/lib/services/package_manager/dummy_package_manager.dart b/lib/services/package_manager/dummy_package_manager.dart
index 0f41b3a..45778d2 100644
--- a/lib/services/package_manager/dummy_package_manager.dart
+++ b/lib/services/package_manager/dummy_package_manager.dart
@@ -13,8 +13,8 @@ final class DummyPackageManager extends PackageManager {
           versionCode: 1,
           signatureHash: 'dummy_signature_1',
         ),
-        'dev.zapstore.alpha': const PackageInfo(
-          appId: 'dev.zapstore.alpha',
+        'dev.zapstore.app': const PackageInfo(
+          appId: 'dev.zapstore.app',
           name: 'Zapstore',
           version: '1.0.0',
           versionCode: 1,
diff --git a/linux/CMakeLists.txt b/linux/CMakeLists.txt
index 9a75665..bf2cf20 100644
--- a/linux/CMakeLists.txt
+++ b/linux/CMakeLists.txt
@@ -7,7 +7,7 @@ project(runner LANGUAGES CXX)
 set(BINARY_NAME "zapstore")
 # The unique GTK application identifier for this application. See:
 # https://wiki.gnome.org/HowDoI/ChooseApplicationID
-set(APPLICATION_ID "dev.zapstore.alpha")
+set(APPLICATION_ID "dev.zapstore.app")
 
 # Explicitly opt in to modern CMake behaviors to avoid warnings with recent
 # versions of CMake.
diff --git a/macos/Runner.xcodeproj/project.pbxproj b/macos/Runner.xcodeproj/project.pbxproj
index 3509d9f..db78591 100644
--- a/macos/Runner.xcodeproj/project.pbxproj
+++ b/macos/Runner.xcodeproj/project.pbxproj
@@ -479,7 +479,7 @@
 				CURRENT_PROJECT_VERSION = 1;
 				GENERATE_INFOPLIST_FILE = YES;
 				MARKETING_VERSION = 1.0;
-				PRODUCT_BUNDLE_IDENTIFIER = dev.zapstore.alpha.RunnerTests;
+				PRODUCT_BUNDLE_IDENTIFIER = dev.zapstore.app.RunnerTests;
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				SWIFT_VERSION = 5.0;
 				TEST_HOST = "$(BUILT_PRODUCTS_DIR)/zapstore.app/$(BUNDLE_EXECUTABLE_FOLDER_PATH)/zapstore";
@@ -494,7 +494,7 @@
 				CURRENT_PROJECT_VERSION = 1;
 				GENERATE_INFOPLIST_FILE = YES;
 				MARKETING_VERSION = 1.0;
-				PRODUCT_BUNDLE_IDENTIFIER = dev.zapstore.alpha.RunnerTests;
+				PRODUCT_BUNDLE_IDENTIFIER = dev.zapstore.app.RunnerTests;
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				SWIFT_VERSION = 5.0;
 				TEST_HOST = "$(BUILT_PRODUCTS_DIR)/zapstore.app/$(BUNDLE_EXECUTABLE_FOLDER_PATH)/zapstore";
@@ -509,7 +509,7 @@
 				CURRENT_PROJECT_VERSION = 1;
 				GENERATE_INFOPLIST_FILE = YES;
 				MARKETING_VERSION = 1.0;
-				PRODUCT_BUNDLE_IDENTIFIER = dev.zapstore.alpha.RunnerTests;
+				PRODUCT_BUNDLE_IDENTIFIER = dev.zapstore.app.RunnerTests;
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				SWIFT_VERSION = 5.0;
 				TEST_HOST = "$(BUILT_PRODUCTS_DIR)/zapstore.app/$(BUNDLE_EXECUTABLE_FOLDER_PATH)/zapstore";
diff --git a/macos/Runner/Configs/AppInfo.xcconfig b/macos/Runner/Configs/AppInfo.xcconfig
index 11ff13d..e742701 100644
--- a/macos/Runner/Configs/AppInfo.xcconfig
+++ b/macos/Runner/Configs/AppInfo.xcconfig
@@ -8,7 +8,7 @@
 PRODUCT_NAME = zapstore_alpha
 
 // The application's bundle identifier
-PRODUCT_BUNDLE_IDENTIFIER = dev.zapstore.alpha
+PRODUCT_BUNDLE_IDENTIFIER = dev.zapstore.app
 
 // The copyright displayed in application information
 PRODUCT_COPYRIGHT = Copyright © 2025 com.example. All rights reserved.