catalyst-core 0.3.0-beta.5 → 0.3.0-canary.2

package/dist/native/androidProject/app/src/test/java/io/yourname/androidproject/utils/PushNotificationUtilsTest.kt

@@ -0,0 +1,119 @@
+package io.yourname.androidproject.utils
+
+import android.content.Context
+import android.webkit.WebView
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import org.mockito.kotlin.mock
+
+/**
+ * Unit tests for PushNotificationUtils (Android coverage batch 4),
+ * previously entirely untested (0/18 lines).
+ *
+ * Source-set note: this project swaps PushNotificationUtils between two
+ * source sets (noFcm/withFcm) based on buildIos/config.js's
+ * isNotificationsEnabled() check in app/build.gradle.kts. Verified
+ * empirically for this checkout: no catalyst-build.properties file exists,
+ * so isNotificationsEnabled() falls back to its default (false), and the
+ * noFcm variant is what actually compiles for testDebugUnitTest -- confirmed
+ * both by the noFcm-only compiler warnings during `./gradlew
+ * testDebugUnitTest` and by `app/build/tmp/kotlin-classes/debug` containing
+ * only io/yourname/androidproject/utils/PushNotificationUtils(.class|
+ * $Companion.class) built from the noFcm source file. This test file
+ * therefore targets app/src/noFcm/java/.../PushNotificationUtils.kt, a
+ * trivial no-op stub (Firebase disabled) whose methods only log via
+ * BridgeUtils.logInfo/logWarning (which call android.util.Log directly --
+ * safe under the mockable android.jar's isReturnDefaultValues=true, no
+ * static mocking needed) and otherwise return hardcoded
+ * false/null/empty/"none"/"" values.
+ *
+ * Out of scope: app/src/withFcm/java/.../PushNotificationUtils.kt (the real
+ * Firebase-backed implementation) is not compiled under the current build
+ * config in this checkout, so it is untestable from testDebugUnitTest here
+ * and is not covered by this file.
+ */
+class PushNotificationUtilsTest {
+
+    private val context: Context = mock()
+    private val utils = PushNotificationUtils()
+
+    @Test
+    fun `initializeAndGetToken always returns empty string`() {
+        assertEquals("", utils.initializeAndGetToken(context))
+    }
+
+    @Test
+    fun `handleIncomingPush is a no-op with a real webView`() {
+        val webView: WebView = mock()
+        // Should not throw; no-op stub only logs.
+        utils.handleIncomingPush(webView, context, mapOf("key" to "value"))
+    }
+
+    @Test
+    fun `handleIncomingPush is a no-op with a null webView`() {
+        utils.handleIncomingPush(null, context, emptyMap())
+    }
+
+    @Test
+    fun `handleTokenRefresh is a no-op with a real webView`() {
+        val webView: WebView = mock()
+        utils.handleTokenRefresh(webView, "some-token")
+    }
+
+    @Test
+    fun `handleTokenRefresh is a no-op with a null webView`() {
+        utils.handleTokenRefresh(null, "some-token")
+    }
+
+    @Test
+    fun `subscribeToTopic always returns false`() {
+        assertFalse(utils.subscribeToTopic(context, "topic"))
+    }
+
+    @Test
+    fun `unsubscribeFromTopic always returns false`() {
+        assertFalse(utils.unsubscribeFromTopic(context, "topic"))
+    }
+
+    @Test
+    fun `getPushToken always returns null`() {
+        assertNull(utils.getPushToken(context))
+    }
+
+    @Test
+    fun `getSubscribedTopics always returns an empty set`() {
+        assertTrue(utils.getSubscribedTopics(context).isEmpty())
+    }
+
+    @Test
+    fun `deleteAllPushData always returns false`() {
+        assertFalse(utils.deleteAllPushData(context))
+    }
+
+    @Test
+    fun `getPushProvider always returns none`() {
+        assertEquals("none", utils.getPushProvider(context))
+    }
+
+    @Test
+    fun `isAvailable always returns false`() {
+        assertFalse(utils.isAvailable(context))
+    }
+
+    @Test
+    fun `companion action and extra constants have expected values`() {
+        assertEquals(
+            "io.yourname.androidproject.PUSH_MESSAGE_RECEIVED",
+            PushNotificationUtils.ACTION_MESSAGE_RECEIVED
+        )
+        assertEquals(
+            "io.yourname.androidproject.PUSH_TOKEN_REFRESHED",
+            PushNotificationUtils.ACTION_TOKEN_REFRESHED
+        )
+        assertEquals("message_data", PushNotificationUtils.EXTRA_MESSAGE_DATA)
+        assertEquals("token", PushNotificationUtils.EXTRA_TOKEN)
+    }
+}

package/dist/native/androidProject/app/src/test/java/io/yourname/androidproject/utils/SafeAreaUtilsTest.kt

@@ -0,0 +1,108 @@
+package io.yourname.androidproject.utils
+
+import androidx.core.graphics.Insets
+import androidx.core.view.WindowInsetsCompat
+import org.junit.Assert.assertEquals
+import org.junit.Test
+import org.mockito.kotlin.doReturn
+import org.mockito.kotlin.mock
+import org.mockito.kotlin.whenever
+
+/**
+ * Unit tests for SafeAreaUtils.fromWindowInsets (Android coverage batch
+ * 3), previously entirely untested (0/17 lines).
+ *
+ * androidx.core.graphics.Insets and WindowInsetsCompat are androidx
+ * library classes (not android.jar SDK stubs) -- Insets.of(l,t,r,b) is a
+ * real static factory that actually assigns its fields, so value
+ * assertions on the returned SafeAreaInsets are meaningful here (unlike
+ * android.graphics.RectF in ViewfinderMapperTest, which IS an android.jar
+ * stub whose constructor never runs).
+ *
+ * Deliberately out of scope, per the task: getSafeAreaInsets(window,
+ * rootView, edgeToEdgeEnabled) is a thin passthrough that calls
+ * ViewCompat.getRootWindowInsets(...) -- a static androidx method --
+ * before delegating to fromWindowInsets. Testing it would require
+ * mockStatic(ViewCompat), which the task explicitly says to skip; only
+ * fromWindowInsets is covered.
+ */
+class SafeAreaUtilsTest {
+
+    private fun windowInsetsCompatWith(systemBars: Insets, cutout: Insets = Insets.NONE): WindowInsetsCompat {
+        return mock {
+            on { getInsets(WindowInsetsCompat.Type.systemBars()) } doReturn systemBars
+            on { getInsets(WindowInsetsCompat.Type.displayCutout()) } doReturn cutout
+        }
+    }
+
+    // ============================================================
+    // Null input
+    // ============================================================
+
+    @Test
+    fun `fromWindowInsets returns ZERO when insets is null`() {
+        val result = SafeAreaUtils.fromWindowInsets(null, edgeToEdgeEnabled = true)
+        assertEquals(SafeAreaInsets.ZERO, result)
+    }
+
+    // ============================================================
+    // edge-to-edge disabled -- system bars only
+    // ============================================================
+
+    @Test
+    fun `fromWindowInsets with edge-to-edge disabled returns system bar insets directly`() {
+        val systemBars = Insets.of(10, 20, 30, 40)
+        val windowInsets = windowInsetsCompatWith(systemBars)
+
+        val result = SafeAreaUtils.fromWindowInsets(windowInsets, edgeToEdgeEnabled = false)
+
+        assertEquals(SafeAreaInsets(top = 20, right = 30, bottom = 40, left = 10), result)
+    }
+
+    @Test
+    fun `fromWindowInsets with edge-to-edge disabled ignores the display cutout`() {
+        val systemBars = Insets.of(10, 20, 30, 40)
+        val cutout = Insets.of(100, 100, 100, 100)
+        val windowInsets = windowInsetsCompatWith(systemBars, cutout)
+
+        val result = SafeAreaUtils.fromWindowInsets(windowInsets, edgeToEdgeEnabled = false)
+
+        assertEquals(SafeAreaInsets(top = 20, right = 30, bottom = 40, left = 10), result)
+    }
+
+    // ============================================================
+    // edge-to-edge enabled -- max(system bars, cutout) per edge
+    // ============================================================
+
+    @Test
+    fun `fromWindowInsets with edge-to-edge enabled takes the max of system bars and cutout per edge`() {
+        val systemBars = Insets.of(10, 50, 30, 5)
+        val cutout = Insets.of(0, 20, 60, 15)
+        val windowInsets = windowInsetsCompatWith(systemBars, cutout)
+
+        val result = SafeAreaUtils.fromWindowInsets(windowInsets, edgeToEdgeEnabled = true)
+
+        // left: max(10, 0)=10, top: max(50, 20)=50, right: max(30, 60)=60, bottom: max(5, 15)=15
+        assertEquals(SafeAreaInsets(top = 50, right = 60, bottom = 15, left = 10), result)
+    }
+
+    @Test
+    fun `fromWindowInsets with edge-to-edge enabled and a zero cutout equals the system bars`() {
+        val systemBars = Insets.of(10, 20, 30, 40)
+        val windowInsets = windowInsetsCompatWith(systemBars, Insets.NONE)
+
+        val result = SafeAreaUtils.fromWindowInsets(windowInsets, edgeToEdgeEnabled = true)
+
+        assertEquals(SafeAreaInsets(top = 20, right = 30, bottom = 40, left = 10), result)
+    }
+
+    // ============================================================
+    // SafeAreaInsets.toMap()
+    // ============================================================
+
+    @Test
+    fun `toMap exposes all four edges by name`() {
+        val insets = SafeAreaInsets(top = 1, right = 2, bottom = 3, left = 4)
+        assertEquals(mapOf("top" to 1, "right" to 2, "bottom" to 3, "left" to 4), insets.toMap())
+    }
+}

package/dist/native/androidProject/build.gradle.kts

@@ -7,5 +7,6 @@ buildscript {
 
 plugins {
     alias(libs.plugins.android.application) apply false
+    alias(libs.plugins.android.library) apply false
     alias(libs.plugins.jetbrains.kotlin.android) apply false
 }

package/dist/native/androidProject/gradle/libs.versions.toml

@@ -12,6 +12,23 @@ webkit = "1.13.0"
 googleServices = "4.4.0"
 androidxCredentials = "1.3.0"
 googleId = "1.1.1"
+# JVM unit test coverage (Tier 1, mirrors the CatalystCoreLogic llvm-cov
+# setup on iOS — see #432/#413). 0.8.12 is the latest 0.8.x line still
+# compatible with this project's Gradle 8.13 / AGP 8.11.1 without pulling
+# in Jacoco's newer bytecode-instrumentation changes meant for JDK 21+
+# language features this app doesn't use.
+jacoco = "0.8.12"
+# Test-only deps for #413 (Tier 1 Android unit tests). kotlinReflect is
+# pinned ahead of the project's forced 2.0.21 Kotlin compiler version
+# solely to satisfy mockito-kotlin 6.x's own kotlin-reflect requirement
+# (>=2.1.20) — see the resolutionStrategy override in app/build.gradle.kts.
+# kotlinxCoroutinesTest is pinned to the 1.10.x line (not the newer 1.11.x)
+# because 1.11.x requires Kotlin 2.2.20, which is out of scope here; 1.10.x
+# is the latest line still JVM-compatible with Kotlin 2.1.x.
+mockitoCore = "5.23.0"
+mockitoKotlin = "6.3.0"
+kotlinReflect = "2.1.20"
+kotlinxCoroutinesTest = "1.10.2"
 
 [libraries]
 androidx-core-ktx = { group = "androidx.core", name = "core-ktx", version.ref = "coreKtx" }
@@ -25,8 +42,17 @@ androidx-webkit = { group = "androidx.webkit", name = "webkit", version.ref = "w
 androidx-credentials = { group = "androidx.credentials", name = "credentials", version.ref = "androidxCredentials" }
 androidx-credentials-play-services-auth = { group = "androidx.credentials", name = "credentials-play-services-auth", version.ref = "androidxCredentials" }
 googleid = { group = "com.google.android.libraries.identity.googleid", name = "googleid", version.ref = "googleId" }
+mockito-core = { group = "org.mockito", name = "mockito-core", version.ref = "mockitoCore" }
+mockito-kotlin = { group = "org.mockito.kotlin", name = "mockito-kotlin", version.ref = "mockitoKotlin" }
+kotlin-reflect = { group = "org.jetbrains.kotlin", name = "kotlin-reflect", version.ref = "kotlinReflect" }
+kotlinx-coroutines-test = { group = "org.jetbrains.kotlinx", name = "kotlinx-coroutines-test", version.ref = "kotlinxCoroutinesTest" }
 
 [plugins]
 android-application = { id = "com.android.application", version.ref = "agp" }
+# Same AGP version as android-application -- needed so the optional
+# :catalyst-ai library module (wired in settings.gradle.kts when the npm
+# package is installed) can apply `id("com.android.library")` without
+# declaring its own version.
+android-library = { id = "com.android.library", version.ref = "agp" }
 jetbrains-kotlin-android = { id = "org.jetbrains.kotlin.android", version.ref = "kotlin" }
 google-services = { id = "com.google.gms.google-services", version.ref = "googleServices" }

package/dist/native/androidProject/settings.gradle.kts

@@ -34,12 +34,15 @@ dependencyResolutionManagement {
 rootProject.name = "Catalyst Application"
 include(":app")
 
-// @catalyst/cloud-ai — include when the package is installed.
-// The npm package ships an /android library module for native AI; wire it here so Gradle picks it up.
-// After running: npm install @catalyst/cloud-ai && npm run sync-packages -- --packages cloud-ai
-// Also set ai.enabled=true in your app config to enable useLegacyPackaging for GPU dlopen().
-val cloudAiDir = File(rootDir, "../node_modules/@catalyst/cloud-ai/android")
-if (cloudAiDir.exists()) {
-    include(":catalyst-cloud-ai")
-    project(":catalyst-cloud-ai").projectDir = cloudAiDir
+// catalyst-ai — include when the npm package is installed.
+// The package ships an /android library module (namespace io.catalyst.nativeai)
+// for native AI; wire it here so Gradle picks it up. After running:
+//   npm install catalyst-ai && npm run sync-packages -- --packages ai
+// (an `ai.enabled=true` build syncs it automatically -- see
+// buildAndroid/index.js:syncAIPackageIfEnabled). Also set ai.enabled=true in
+// your app config to enable useLegacyPackaging for GPU dlopen().
+val catalystAiDir = File(rootDir, "../node_modules/catalyst-ai/android")
+if (catalystAiDir.exists()) {
+    include(":catalyst-ai")
+    project(":catalyst-ai").projectDir = catalystAiDir
 }

package/dist/native/androidSetup.js

@@ -4,7 +4,7 @@ var _fs = _interopRequireDefault(require("fs"));
 var _path = _interopRequireDefault(require("path"));
 var _child_process = require("child_process");
 var _utils = require("./utils.js");
-var _TerminalProgress = _interopRequireDefault(require("./TerminalProgress.js"));
+var _terminalProgress = _interopRequireDefault(require("./terminalProgress.js"));
 var _setupServer = require("./setupServer.js");
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 const catalystCorePath = _path.default.dirname(require.resolve("catalyst-core/package.json"));
@@ -27,7 +27,7 @@ const progressPaddingConfig = {
   errorPaddingLeft: 6,
   bottomMargin: 2
 };
-const progress = new _TerminalProgress.default(steps, "Catalyst Universal Android Setup", progressPaddingConfig);
+const progress = new _terminalProgress.default(steps, "Catalyst Universal Android Setup", progressPaddingConfig);
 async function checkJavaInstallation() {
   try {
     (0, _utils.runCommand)("java -version");

package/dist/native/bridge/WebBridge.d.ts

@@ -0,0 +1,98 @@
+declare class WebBridge {
+    /**
+     * Registered callback handlers, keyed by native interface name.
+     *
+     * Declared without an initializer so it erases to nothing at compile time —
+     * the constructor below remains the only thing that assigns it, exactly as
+     * before this file was converted.
+     */
+    handlers: Map<string, (data: any) => void>;
+    /** True once {@link WebBridge.init} has attached this instance to `window`. */
+    initialized: boolean;
+    constructor();
+    /**
+     * Log initialization info
+     */
+    _logInitialization(): void;
+    /**
+     * Static method to initialize WebBridge on window object
+     */
+    static init: () => any;
+    /**
+     * Main callback handler called by native platforms
+     * @param {string} interfaceName - The callback interface name
+     * @param {any} data - Data from native platform
+     */
+    callback: (interfaceName: any, data: any) => void;
+    /**
+     * Register a callback handler for a native interface
+     * @param {string} interfaceName - The callback interface name (from NATIVE_CALLBACKS)
+     * @param {function} callback - The callback function to execute
+     * @returns {boolean} - Success status
+     */
+    register: (interfaceName: any, callback: any) => boolean;
+    /**
+     * Unregister a callback handler
+     * @param {string} interfaceName - The callback interface name to unregister
+     * @returns {boolean} - Success status
+     */
+    unregister: (interfaceName: any) => boolean;
+    /**
+     * Check if a callback interface is registered
+     * @param {string} interfaceName - The callback interface name
+     * @returns {boolean} - Registration status
+     */
+    isRegistered: (interfaceName: any) => boolean;
+    /**
+     * Get all registered callback interfaces
+     * @returns {string[]} - Array of registered interface names
+     */
+    getRegisteredInterfaces: () => string[];
+    /**
+     * Get handler for a specific interface (for debugging)
+     * @param {string} interfaceName - The callback interface name
+     * @returns {function|null} - The registered handler or null
+     */
+    getHandler: (interfaceName: any) => (data: any) => void;
+    /**
+     * Clear all registered handlers
+     */
+    clearAll: () => void;
+    /**
+     * Debug method to log current state
+     */
+    debug: () => void;
+    /**
+     * Test callback functionality (for debugging)
+     * @param {string} interfaceName - The callback interface to test
+     * @param {any} testData - Test data to pass
+     */
+    testCallback: (interfaceName: any, testData?: string) => void;
+    /**
+     * Request haptic feedback
+     * @param {string} feedbackType - Type of haptic feedback (VIRTUAL_KEY, LONG_PRESS, DEFAULT)
+     * @returns {Promise<Object>} - Promise that resolves with haptic feedback result or rejects with error
+     */
+    requestHapticFeedback: (feedbackType?: string) => Promise<unknown>;
+    /**
+     * Open camera and capture image
+     * @param {Object} options - Camera options (quality, format, cameraDevice, flashMode, allowEditing)
+     * @returns {Promise<Object>} - Promise that resolves with camera result or rejects with error
+     */
+    openCamera: (options?: {}) => Promise<any>;
+    /**
+     * Request camera permission
+     * @param {Object} config - Permission configuration (includeDetails)
+     * @returns {Promise<Object>} - Promise that resolves with permission status or rejects with error
+     */
+    requestCameraPermission: (config?: {}) => Promise<any>;
+    getDeviceInfoFromLegacyBridge: (parseDeviceInfo: any) => Promise<unknown>;
+    getDeviceInfoFromPluginBridge: (parseDeviceInfo: any) => Promise<unknown>;
+    shouldFallbackToLegacyDeviceInfo: (error: any) => boolean;
+    /**
+     * Get device information
+     * @returns {Promise<Object>} - Promise that resolves with device info or rejects with error
+     */
+    getDeviceInfo: () => Promise<unknown>;
+}
+export default WebBridge;

package/dist/native/bridge/WebBridge.js

@@ -8,6 +8,7 @@ var _NativeInterfaces = require("./constants/NativeInterfaces.js");
 var _NativeBridge = _interopRequireDefault(require("./utils/NativeBridge.js"));
 var _CameraUtils = _interopRequireDefault(require("./utils/CameraUtils.js"));
 var _PluginBridge = _interopRequireDefault(require("../plugin-bridge/PluginBridge.js"));
+var _index = require("../../errors/index.js");
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
 const DEVICE_INFO_PLUGIN = {
@@ -47,6 +48,16 @@ const createDeviceInfoError = (payload, fallbackMessage) => {
   return error;
 };
 class WebBridge {
+  /**
+   * Registered callback handlers, keyed by native interface name.
+   *
+   * Declared without an initializer so it erases to nothing at compile time —
+   * the constructor below remains the only thing that assigns it, exactly as
+   * before this file was converted.
+   */
+
+  /** True once {@link WebBridge.init} has attached this instance to `window`. */
+
   constructor() {
     this.handlers = new Map();
     this.initialized = false;
@@ -69,10 +80,15 @@ class WebBridge {
    */
   static init = () => {
     if (typeof window === "undefined") {
-      console.error("🌉 WebBridge cannot be initialized outside the browser!");
+      console.error((0, _index.formatError)((0, _index.createError)(_index.ERROR_CODES.RUNTIME_NATIVE_BRIDGE_INIT_FAILED, {
+        details: "WebBridge.init() was called outside a browser environment (no `window`)."
+      })));
       return null;
     }
     if (window.WebBridge) {
+      // Not a failure — the bridge is already up and working, just return it.
+      // No code here: RUNTIME-NATIVE-022 means init genuinely failed, which
+      // this path is not.
       console.warn("🌉 WebBridge already initialized!");
       return window.WebBridge;
     }
@@ -109,19 +125,27 @@ class WebBridge {
 
     // Validate interface
     if (!(0, _NativeInterfaces.isValidCallback)(interfaceName)) {
-      console.error(`🌉 Invalid callback interface: ${interfaceName}`);
+      console.error((0, _index.formatError)((0, _index.createError)(_index.ERROR_CODES.RUNTIME_NATIVE_BRIDGE_INVALID_CALLBACK, {
+        details: `Received "${interfaceName}", which is not in the registered NATIVE_CALLBACKS list.`
+      })));
       console.log("🌉 Available callbacks:", _NativeInterfaces.ALL_CALLBACKS);
       return;
     }
     if (!this.handlers.has(interfaceName)) {
-      console.warn(`🌉 No handler registered for interface: ${interfaceName}`);
+      console.warn((0, _index.formatError)((0, _index.createError)(_index.ERROR_CODES.RUNTIME_NATIVE_BRIDGE_HANDLER_NOT_REGISTERED, {
+        details: `No handler registered for interface "${interfaceName}".`
+      })));
       return;
     }
     try {
       const handler = this.handlers.get(interfaceName);
       handler(data);
     } catch (error) {
-      console.error(`🌉 Error executing callback for ${interfaceName}:`, error);
+      const wrapped = (0, _index.createError)(_index.ERROR_CODES.RUNTIME_NATIVE_BRIDGE_HANDLER_THREW, {
+        details: `The handler registered for "${interfaceName}" threw.`,
+        cause: error
+      });
+      console.error((0, _index.formatError)(wrapped));
 
       // In development, provide more helpful error info
       if (process.env.NODE_ENV === "development") {
@@ -143,13 +167,17 @@ class WebBridge {
   register = (interfaceName, callback) => {
     // Validate callback function
     if (typeof callback !== "function") {
-      console.error("🌉 Callback must be a function!");
+      console.error((0, _index.formatError)((0, _index.createError)(_index.ERROR_CODES.RUNTIME_NATIVE_BRIDGE_INVALID_REGISTRATION, {
+        details: `register("${interfaceName}", ...) was called with a non-function callback (got ${typeof callback}).`
+      })));
       return false;
     }
 
     // Validate interface name
     if (!(0, _NativeInterfaces.isValidCallback)(interfaceName)) {
-      console.error(`🌉 Invalid callback interface: ${interfaceName}`);
+      console.error((0, _index.formatError)((0, _index.createError)(_index.ERROR_CODES.RUNTIME_NATIVE_BRIDGE_INVALID_REGISTRATION, {
+        details: `register() was called with "${interfaceName}", which is not a valid callback interface.`
+      })));
       console.log("🌉 Available callback interfaces:", _NativeInterfaces.ALL_CALLBACKS);
       return false;
     }
@@ -391,6 +419,12 @@ class WebBridge {
         }
       }));
       try {
+        // `as any` only because PluginBridge is still plain JS: TypeScript
+        // infers its `emit({ pluginId, command, data = null } = {})` shape
+        // from the `= {}` default alone and concludes it accepts only
+        // `{ data?: any }`, rejecting the two keys the body itself reads.
+        // The assertion erases at compile time — the emitted call is byte
+        // for byte the one this file made before the conversion.
         _PluginBridge.default.emit({
           pluginId: DEVICE_INFO_PLUGIN.pluginId,
           command: DEVICE_INFO_PLUGIN.command