catalyst-core-internal 0.1.0 → 0.1.3

package/README.md

@@ -7,8 +7,8 @@
 
 ## Table of Contents
 
--   Overview
--   Installation
+- Overview
+- Installation
 
 ## Overview
 
@@ -20,8 +20,8 @@ This version adds support for Universal app for both Android and iOS. Please che
 
 **System Requirements**
 
--   Node version 20.4.0 or later
--   Compatible with **macOS** and **Linux**
+- Node version 20.4.0 or later
+- Compatible with **macOS** and **Linux**
 
 **Automatic Installation**
 

package/bin/catalyst.js

@@ -13,6 +13,8 @@ const validCommands = [
     "serve",
     "devBuild",
     "devServe",
+    "plugin",
+    "plugins",
     "buildApp",
     "buildApp:ios",
     "buildApp:android",
@@ -67,11 +69,14 @@ const scriptIndex = args.findIndex(
         x === "serve" ||
         x === "devBuild" ||
         x === "devServe" ||
+        x === "plugin" ||
+        x === "plugins" ||
         isPlatformCommand(x, "buildApp") ||
         isPlatformCommand(x, "setupEmulator")
 )
 const script = scriptIndex === -1 ? args[0] : args[scriptIndex]
 const nodeArgs = scriptIndex > 0 ? args.slice(0, scriptIndex) : []
+const resolvedScript = script === "plugin" ? "plugins" : script
 
 if (validCommands.includes(script)) {
     // Handle platform-specific or combined commands
@@ -90,7 +95,9 @@ if (validCommands.includes(script)) {
         // Original commands
         const result = spawnSync(
             process.execPath,
-            nodeArgs.concat(require.resolve("../dist/scripts/" + script)).concat(args.slice(scriptIndex + 1)),
+            nodeArgs
+                .concat(require.resolve("../dist/scripts/" + resolvedScript))
+                .concat(args.slice(scriptIndex + 1)),
             { stdio: "inherit" }
         )
         handleProcessResult(result)

package/dist/native/androidProject/app/src/main/java/io/yourname/androidproject/BridgeMessageValidator.kt

@@ -60,7 +60,7 @@ data class SchemaDefinition(
 object BridgeMessageValidator {
 
     private const val TAG = "BridgeMessageValidator"
-    private const val MAX_MESSAGE_SIZE = 10 * 1024 * 1024 // 10MB (match iOS)
+    private const val MAX_MESSAGE_SIZE = CatalystConstants.Bridge.MAX_MESSAGE_SIZE
 
     // Valid commands — single source of truth from CatalystConstants
     private val validCommands = CatalystConstants.Bridge.VALID_COMMANDS

package/dist/native/androidProject/app/src/main/java/io/yourname/androidproject/CustomWebview.kt

@@ -233,7 +233,7 @@ class CustomWebView(
         }
 
         // Additional security check: only allow whitelisted interface names
-        val allowedInterfaces = setOf("NativeBridge", "AndroidBridge")
+        val allowedInterfaces = setOf("NativeBridge", "AndroidBridge", "PluginBridge")
         if (name !in allowedInterfaces) {
             Log.e(TAG, "❌ Security: Interface name '$name' is not in whitelist. Refusing to add interface.")
             return
@@ -246,6 +246,17 @@ class CustomWebView(
         }
     }
 
+    fun removeJavascriptInterface(name: String) {
+        try {
+            webView.removeJavascriptInterface(name)
+            if (BuildConfig.DEBUG) {
+                Log.d(TAG, "🔌 Removed JavaScript interface: $name")
+            }
+        } catch (e: Exception) {
+            Log.w(TAG, "⚠️ Failed to remove JavaScript interface '$name': ${e.message}")
+        }
+    }
+
     fun destroy() {
         job.cancel()
         webView.destroy()

package/dist/native/androidProject/app/src/main/java/io/yourname/androidproject/MainActivity.kt

@@ -14,6 +14,7 @@ import org.json.JSONObject
 import java.util.Properties
 import io.yourname.androidproject.databinding.ActivityMainBinding
 import io.yourname.androidproject.NativeBridge
+import io.yourname.androidproject.plugins.PluginBridge
 import io.yourname.androidproject.utils.BridgeUtils
 import io.yourname.androidproject.utils.KeyboardUtil
 import io.yourname.androidproject.utils.NetworkUtils
@@ -39,6 +40,7 @@ class MainActivity : AppCompatActivity(), CoroutineScope by MainScope() {
 
     private lateinit var binding: ActivityMainBinding
     private lateinit var nativeBridge: NativeBridge
+    private lateinit var pluginBridge: PluginBridge
     private lateinit var customWebView: CustomWebView
     lateinit var properties: Properties
     private lateinit var metricsMonitor: MetricsMonitor
@@ -328,6 +330,14 @@ class MainActivity : AppCompatActivity(), CoroutineScope by MainScope() {
             Log.e(TAG, "Failed to initialize NativeBridge: ${e.message}")
         }
 
+        // Setup isolated PluginBridge
+        try {
+            pluginBridge = PluginBridge(this, customWebView.getWebView(), properties)
+            customWebView.addJavascriptInterface(pluginBridge, "PluginBridge")
+        } catch (e: Exception) {
+            Log.e(TAG, "Failed to initialize PluginBridge: ${e.message}")
+        }
+
         setupSafeAreaHandling()
 
         // Setup back press handler (modern API)
@@ -445,11 +455,16 @@ class MainActivity : AppCompatActivity(), CoroutineScope by MainScope() {
         if (::keyboardUtil.isInitialized) {
             keyboardUtil.cleanup()
         }
-        if (::nativeBridge.isInitialized) {
-            nativeBridge.cleanup()
+        if (::customWebView.isInitialized) {
+            if (::pluginBridge.isInitialized) {
+                customWebView.removeJavascriptInterface("PluginBridge")
+            }
+            if (::nativeBridge.isInitialized) {
+                customWebView.removeJavascriptInterface("NativeBridge")
+            }
+            customWebView.destroy()
         }
         coroutineContext.cancelChildren()
-        customWebView.destroy()
         super.onDestroy()
     }
 

package/dist/native/androidProject/app/src/main/java/io/yourname/androidproject/plugins/CatalystPlugin.kt

@@ -0,0 +1,5 @@
+package io.yourname.androidproject.plugins
+
+interface CatalystPlugin {
+    fun handle(command: String, data: Any?, bridge: PluginBridgeContext)
+}

package/dist/native/androidProject/app/src/main/java/io/yourname/androidproject/plugins/GeneratedPluginIndex.kt

@@ -0,0 +1,6 @@
+package io.yourname.androidproject.plugins
+
+object GeneratedPluginIndex {
+    val pluginIdToClassName: Map<String, String> = emptyMap()
+    val pluginToCommands: Map<String, Set<String>> = emptyMap()
+}

package/dist/native/androidProject/app/src/main/java/io/yourname/androidproject/plugins/PluginBridge.kt

@@ -0,0 +1,240 @@
+package io.yourname.androidproject.plugins
+
+import android.app.Activity
+import android.content.Context
+import android.util.Log
+import android.webkit.JavascriptInterface
+import android.webkit.WebView
+import io.yourname.androidproject.CatalystConstants
+import org.json.JSONArray
+import org.json.JSONException
+import org.json.JSONObject
+import java.util.Properties
+
+internal data class PluginRequest(
+    val pluginId: String,
+    val command: String,
+    val data: Any?,
+    val requestId: String?
+)
+
+private class PluginBridgeRuntimeError(
+    override val message: String,
+    val code: String,
+    cause: Throwable? = null
+) : Exception(message, cause)
+
+class PluginBridge(
+    private val activity: Activity,
+    private val webView: WebView,
+    private val properties: Properties
+) {
+    companion object {
+        private const val TAG = "PluginBridge"
+        private const val ERROR_EVENT = "PLUGIN_BRIDGE_ERROR"
+        private const val SYSTEM_PLUGIN_ID = "__bridge__"
+        private const val ERROR_CODE_INVALID_PAYLOAD = "INVALID_PAYLOAD"
+        private const val ERROR_CODE_PLUGIN_NOT_FOUND = "PLUGIN_NOT_FOUND"
+        private const val ERROR_CODE_COMMAND_NOT_SUPPORTED = "COMMAND_NOT_SUPPORTED"
+        private const val ERROR_CODE_PLUGIN_NOT_REGISTERED = "PLUGIN_NOT_REGISTERED"
+        private const val ERROR_CODE_PLUGIN_INSTANTIATION_FAILED = "PLUGIN_INSTANTIATION_FAILED"
+        private const val ERROR_CODE_PLUGIN_EXECUTION_FAILED = "PLUGIN_EXECUTION_FAILED"
+
+        private fun readRequiredString(body: JSONObject, key: String): String {
+            if (!body.has(key) || body.isNull(key)) {
+                return ""
+            }
+
+            val rawValue = body.get(key)
+            if (rawValue !is String) {
+                throw IllegalArgumentException("$key must be a string")
+            }
+
+            return rawValue.trim()
+        }
+
+        private fun readOptionalString(body: JSONObject, key: String): String? {
+            if (!body.has(key) || body.isNull(key)) {
+                return null
+            }
+
+            val rawValue = body.get(key)
+            if (rawValue !is String) {
+                throw IllegalArgumentException("$key must be a string when provided")
+            }
+
+            return rawValue.trim().ifEmpty { null }
+        }
+
+        internal fun parseRequest(payload: String?): PluginRequest {
+            if (payload.isNullOrBlank()) {
+                throw IllegalArgumentException("Payload is required")
+            }
+            val messageSize = payload.toByteArray(Charsets.UTF_8).size
+            if (messageSize > CatalystConstants.Bridge.MAX_MESSAGE_SIZE) {
+                throw IllegalArgumentException("Payload exceeds maximum size")
+            }
+
+            val body = JSONObject(payload)
+            return PluginRequest(
+                pluginId = readRequiredString(body, "pluginId"),
+                command = readRequiredString(body, "command"),
+                data = if (body.has("data") && !body.isNull("data")) body.get("data") else null,
+                requestId = readOptionalString(body, "requestId")
+            )
+        }
+    }
+
+    private val pluginIdToClassName = GeneratedPluginIndex.pluginIdToClassName
+    private val pluginToCommands = GeneratedPluginIndex.pluginToCommands
+
+    @JavascriptInterface
+    fun emit(payload: String?) {
+        var request: PluginRequest? = null
+
+        try {
+            request = parseRequest(payload)
+
+            if (request.pluginId.isEmpty()) {
+                sendBridgeError("pluginId is required", ERROR_CODE_INVALID_PAYLOAD, request)
+                return
+            }
+            if (request.command.isEmpty()) {
+                sendBridgeError("command is required", ERROR_CODE_INVALID_PAYLOAD, request)
+                return
+            }
+
+            if (!hasPlugin(request.pluginId)) {
+                sendBridgeError("Unsupported plugin: ${request.pluginId}", ERROR_CODE_PLUGIN_NOT_FOUND, request)
+                return
+            }
+
+            if (!hasCommand(request.pluginId, request.command)) {
+                sendBridgeError(
+                    "Unsupported command '${request.command}' for plugin '${request.pluginId}'",
+                    ERROR_CODE_COMMAND_NOT_SUPPORTED,
+                    request
+                )
+                return
+            }
+
+            val plugin = try {
+                getPluginForId(request.pluginId)
+            } catch (error: PluginBridgeRuntimeError) {
+                sendBridgeError(error.message, error.code, request)
+                return
+            }
+
+            val callbackContext = PluginBridgeContext(
+                activity = activity,
+                webView = webView,
+                properties = properties,
+                pluginId = request.pluginId,
+                command = request.command,
+                requestId = request.requestId
+            )
+
+            plugin.handle(request.command, request.data, callbackContext)
+        } catch (error: IllegalArgumentException) {
+            sendBridgeError(error.message ?: "Invalid payload", ERROR_CODE_INVALID_PAYLOAD, request)
+        } catch (error: JSONException) {
+            sendBridgeError("Invalid JSON payload: ${error.message}", ERROR_CODE_INVALID_PAYLOAD, request)
+        } catch (error: Exception) {
+            Log.e(TAG, "Plugin command failed for ${request?.pluginId ?: "<unknown>"}.${request?.command ?: "<unknown>"}", error)
+            sendBridgeError("Plugin execution failed: ${error.message}", ERROR_CODE_PLUGIN_EXECUTION_FAILED, request)
+        }
+    }
+
+    private fun sendBridgeError(message: String, code: String, request: PluginRequest?) {
+        PluginBridgeContext(
+            activity = activity,
+            webView = webView,
+            properties = properties,
+            pluginId = SYSTEM_PLUGIN_ID,
+            command = request?.command,
+            requestId = request?.requestId
+        ).callback(
+            ERROR_EVENT,
+            JSONObject().apply {
+                put("message", message)
+                put("code", code)
+                put("pluginId", request?.pluginId ?: SYSTEM_PLUGIN_ID)
+                request?.command?.takeIf { it.isNotEmpty() }?.let { put("command", it) }
+            }
+        )
+    }
+
+    private fun hasPlugin(pluginId: String): Boolean {
+        return pluginIdToClassName.containsKey(pluginId)
+    }
+
+    private fun hasCommand(pluginId: String, command: String): Boolean {
+        return pluginToCommands[pluginId]?.contains(command) ?: false
+    }
+
+    private fun getPluginForId(pluginId: String): CatalystPlugin {
+        val className = pluginIdToClassName[pluginId]
+            ?: throw PluginBridgeRuntimeError(
+                "No plugin registered for id: $pluginId",
+                ERROR_CODE_PLUGIN_NOT_REGISTERED
+            )
+
+        return try {
+            val clazz = Class.forName(className)
+            val instance = clazz.getDeclaredConstructor().newInstance()
+            instance as? CatalystPlugin
+                ?: throw IllegalStateException("Plugin class '$className' must implement CatalystPlugin")
+        } catch (error: Exception) {
+            Log.e(TAG, "Failed to instantiate plugin class $className for plugin $pluginId", error)
+            throw PluginBridgeRuntimeError(
+                "Failed to instantiate plugin class '$className' for plugin '$pluginId': ${error.message ?: error.javaClass.simpleName}",
+                ERROR_CODE_PLUGIN_INSTANTIATION_FAILED,
+                error
+            )
+        }
+    }
+}
+
+class PluginBridgeContext(
+    val activity: Activity,
+    val webView: WebView,
+    val properties: Properties,
+    val pluginId: String,
+    val command: String?,
+    val requestId: String?
+) {
+    val context: Context
+        get() = activity
+
+    fun callback(
+        eventName: String,
+        data: Any?,
+        command: String? = this.command
+    ) {
+        require(eventName.isNotBlank()) { "Callback eventName is required" }
+
+        val pluginLiteral = JSONObject.quote(pluginId)
+        val eventLiteral = JSONObject.quote(eventName)
+        val dataLiteral = toJavaScriptLiteral(data)
+        val requestLiteral = requestId?.let(JSONObject::quote) ?: "null"
+        val commandLiteral = command?.takeIf { it.isNotBlank() }?.let(JSONObject::quote) ?: "null"
+
+        webView.post {
+            webView.evaluateJavascript(
+                "window.PluginBridgeWeb && window.PluginBridgeWeb.callback($pluginLiteral, $eventLiteral, $dataLiteral, $requestLiteral, $commandLiteral);",
+                null
+            )
+        }
+    }
+
+    private fun toJavaScriptLiteral(value: Any?): String {
+        return when (value) {
+            null -> "null"
+            is JSONObject -> value.toString()
+            is JSONArray -> value.toString()
+            is Number, is Boolean -> value.toString()
+            is String -> JSONObject.quote(value)
+            else -> JSONObject.wrap(value)?.toString() ?: "null"
+        }
+    }
+}

package/dist/native/androidProject/app/src/test/java/io/yourname/androidproject/plugins/PluginBridgeTest.kt

@@ -0,0 +1,121 @@
+package io.yourname.androidproject.plugins
+
+import io.yourname.androidproject.CatalystConstants
+import org.json.JSONException
+import org.json.JSONObject
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Assert.fail
+import org.junit.Test
+
+class PluginBridgeTest {
+
+    @Test
+    fun `parseRequest accepts valid payload and trims string fields`() {
+        val request = PluginBridge.parseRequest(
+            """
+                {
+                    "pluginId": "  device-info-plugin  ",
+                    "command": "  getDeviceInfo  ",
+                    "data": { "includeSecurity": true },
+                    "requestId": "  req-123  "
+                }
+            """.trimIndent()
+        )
+
+        assertEquals("device-info-plugin", request.pluginId)
+        assertEquals("getDeviceInfo", request.command)
+        assertEquals("req-123", request.requestId)
+        assertEquals(true, (request.data as JSONObject).getBoolean("includeSecurity"))
+    }
+
+    @Test
+    fun `parseRequest treats blank requestId as null`() {
+        val request = PluginBridge.parseRequest(
+            """
+                {
+                    "pluginId": "device-info-plugin",
+                    "command": "getDeviceInfo",
+                    "requestId": "   "
+                }
+            """.trimIndent()
+        )
+
+        assertNull(request.requestId)
+    }
+
+    @Test
+    fun `parseRequest rejects blank payload`() {
+        try {
+            PluginBridge.parseRequest("   ")
+            fail("Expected invalid blank payload to throw")
+        } catch (error: IllegalArgumentException) {
+            assertEquals("Payload is required", error.message)
+        }
+    }
+
+    @Test
+    fun `parseRequest rejects oversized payload`() {
+        val oversizedData = "x".repeat(CatalystConstants.Bridge.MAX_MESSAGE_SIZE + 256)
+        val payload = """
+            {
+                "pluginId": "device-info-plugin",
+                "command": "getDeviceInfo",
+                "data": "$oversizedData"
+            }
+        """.trimIndent()
+
+        try {
+            PluginBridge.parseRequest(payload)
+            fail("Expected oversized payload to throw")
+        } catch (error: IllegalArgumentException) {
+            assertEquals("Payload exceeds maximum size", error.message)
+        }
+    }
+
+    @Test
+    fun `parseRequest rejects non string pluginId`() {
+        try {
+            PluginBridge.parseRequest(
+                """
+                    {
+                        "pluginId": 42,
+                        "command": "getDeviceInfo"
+                    }
+                """.trimIndent()
+            )
+            fail("Expected non-string pluginId to throw")
+        } catch (error: IllegalArgumentException) {
+            assertEquals("pluginId must be a string", error.message)
+        }
+    }
+
+    @Test
+    fun `parseRequest rejects non string requestId`() {
+        try {
+            PluginBridge.parseRequest(
+                """
+                    {
+                        "pluginId": "device-info-plugin",
+                        "command": "getDeviceInfo",
+                        "requestId": 42
+                    }
+                """.trimIndent()
+            )
+            fail("Expected non-string requestId to throw")
+        } catch (error: IllegalArgumentException) {
+            assertEquals("requestId must be a string when provided", error.message)
+        }
+    }
+
+    @Test
+    fun `parseRequest rejects invalid JSON`() {
+        try {
+            PluginBridge.parseRequest("{")
+            fail("Expected invalid JSON to throw")
+        } catch (error: JSONException) {
+            assertTrue(error.message?.isNotBlank() == true)
+        }
+    }
+}

package/dist/native/bridge/useBaseHook.js

@@ -20,7 +20,7 @@ if((0,_errors.isDevelopment)()){console.group(`🚨 ${hookName} Error`);console.
 const setDataAndComplete=(0,_react.useCallback)(newData=>{setData(newData);setLoading(false);completeProgress();setError(null);if((0,_errors.isDevelopment)()){console.log(`✅ ${hookName} Success:`,newData);}},[hookName,completeProgress]);const clear=(0,_react.useCallback)(()=>{setData(null);setError(null);resetProgress();if((0,_errors.isDevelopment)()){console.log(`🗑️ ${hookName} Cleared`);}},[hookName,resetProgress]);// Fire-and-forget native call — no-ops silently on web, routes errors through handleNativeError on native
 const callNative=(0,_react.useCallback)(fn=>{if(!isNative()){if((0,_errors.isDevelopment)()){console.warn(`${hookName} callNative skipped — not in native environment`);}return;}try{fn();}catch(err){if((0,_errors.isDevelopment)()){console.warn(`${hookName} callNative failed silently:`,err);}}},[hookName,isNative]);// Operation wrapper that handles common patterns
 const executeOperation=(0,_react.useCallback)((operationCallback,operationName="operation")=>{try{if(isWeb()){console.warn(`${hookName} requires web fallback implementation (isWeb: true)`);return;}if(!isNative()){console.error(`${hookName} executeOperation: Native bridge not available`);return;}setLoading(true);setError(null);startProgress("starting",`Starting ${operationName}...`);if((0,_errors.isDevelopment)()){console.log(`🚀 ${hookName} ${operationName} started`);}// Execute the actual operation
-operationCallback();}catch(err){handleNativeError(err);console.error(`❌ ${hookName} ${operationName} failed:`,err);}},[hookName,isWeb,startProgress,handleNativeError]);// Environment flags (computed values, not functions)
+operationCallback();}catch(err){handleNativeError(err);console.error(`❌ ${hookName} ${operationName} failed:`,err);}},[hookName,isWeb,isNative,startProgress,handleNativeError]);// Environment flags (computed values, not functions)
 const environmentFlags={isWeb:isWeb(),isNative:isNative()};// Return standardized interface
 return{// Data state
 data,// Loading states

package/dist/native/buildAppAndroid.js

@@ -1,4 +1,4 @@
-/* eslint-disable no-extra-semi */"use strict";var _renameAndroidProject=require("./renameAndroidProject.js");var _child_process=require("child_process");var _fs=_interopRequireDefault(require("fs"));var _path=_interopRequireDefault(require("path"));var _utils=require("./utils.js");var _TerminalProgress=_interopRequireDefault(require("./TerminalProgress.js"));// Import the AAB builder
+/* eslint-disable no-extra-semi */"use strict";var _renameAndroidProject=require("./renameAndroidProject.js");var _child_process=require("child_process");var _fs=_interopRequireDefault(require("fs"));var _path=_interopRequireDefault(require("path"));var _utils=require("./utils.js");var _TerminalProgress=_interopRequireDefault(require("./TerminalProgress.js"));var _pluginComposerAndroid=require("./pluginComposerAndroid.js");var _internalPluginUtils=require("./internalPluginUtils.js");// Import the AAB builder
 function _interopRequireDefault(e){return e&&e.__esModule?e:{default:e};}const configPath=`${process.env.PWD}/config/config.json`;const publicPath=`${process.env.PWD}/public`;const catalystCorePath=_path.default.dirname(require.resolve("catalyst-core-internal/package.json"));const pwd=_path.default.join(catalystCorePath,"dist/native");const ANDROID_PACKAGE="io.yourname.androidproject";// Default values for AAB building
 const DEFAULT_PROJECT_PATH=`${pwd}/androidProject`;const DEFAULT_DEPLOYMENT_PATH="./deployment";const DEFAULT_OLD_PROJECT_NAME="androidProject";// Use actual project name in catalyst
 const DEFAULT_OVERWRITE_EXISTING=true;const steps={config:"Initialize Configuration",tools:"Validate Android Tools",emulator:"Check and Start Emulator",copyAssets:"Copy Build Assets",build:"Build and Install Application",aab:"Build Signed AAB"};const progressConfig={titlePaddingTop:2,titlePaddingBottom:1,stepPaddingLeft:4,stepSpacing:1,errorPaddingLeft:6,bottomMargin:2};const progress=new _TerminalProgress.default(steps,"Catalyst Android Build",progressConfig);async function initializeConfig(){const configFile=_fs.default.readFileSync(configPath,"utf8");const config=JSON.parse(configFile);const{WEBVIEW_CONFIG,BUILD_OUTPUT_PATH}=config;if(!WEBVIEW_CONFIG||Object.keys(WEBVIEW_CONFIG).length===0){throw new Error("WebView Config missing in "+configPath);}if(!WEBVIEW_CONFIG.android){throw new Error("Android config missing in WebView Config");}// Log build type information
@@ -131,7 +131,7 @@ const canInstallOnPhysical=await testPhysicalDeviceInstallation(ADB_PATH,physica
 targetDevice={type:"physical",id:physicalDevice.id,model:physicalDevice.model};progress.log(`Using physical device: ${physicalDevice.model}`,"success");}else{// Physical device failed, fallback to emulator
 progress.log("Physical device installation test failed, falling back to emulator","warning");targetDevice=await handleEmulatorSetup(ADB_PATH,EMULATOR_PATH,androidConfig);}}else{// No physical device, use emulator (current behavior)
 targetDevice=await handleEmulatorSetup(ADB_PATH,EMULATOR_PATH,androidConfig);}progress.complete("emulator");}else{progress.log("Skipping device setup for release build","info");}// Copy build assets
-progress.start("copyAssets");await copyBuildAssets(androidConfig,buildOptimisation);await copySplashscreenAssets();await copyOfflinePage();await copyIconAssets();await configureAppName(androidConfig);await processNotifications(WEBVIEW_CONFIG);progress.log(`Build optimization: ${buildOptimisation?"Enabled":"Disabled"}`,"info");progress.complete("copyAssets");// Build based on type
+progress.start("copyAssets");await copyBuildAssets(androidConfig,buildOptimisation);await copySplashscreenAssets();await copyOfflinePage();await copyIconAssets();await configureAppName(androidConfig);const pluginConfig=(0,_internalPluginUtils.resolvePluginConfig)(WEBVIEW_CONFIG);(0,_pluginComposerAndroid.composeAndroidPlugins)({corePluginsRoot:(0,_internalPluginUtils.resolveInternalPluginsRoot)(catalystCorePath),androidProjectPath:`${pwd}/androidProject`,pluginConfig,log:(message,status="info")=>progress.log(message,status)});await processNotifications(WEBVIEW_CONFIG);progress.log(`Build optimization: ${buildOptimisation?"Enabled":"Disabled"}`,"info");progress.complete("copyAssets");// Build based on type
 let movedApkPath=null;if(buildType==="release"){// Build signed AAB for release
 progress.start("aab");await buildSignedAAB(androidConfig);progress.complete("aab");// Move APK to output directory
 movedApkPath=await moveApkToOutputPath(buildType,BUILD_OUTPUT_PATH,androidConfig.appName);}else{// Install debug app for development