@mentra/bluetooth-sdk 3.2.1-dev.314 → 3.3.0-beta.942

package/android/src/test/java/com/mentra/bluetoothsdk/sgcs/MentraLiveWifiCredentialLogTest.kt

@@ -0,0 +1,55 @@
+package com.mentra.bluetoothsdk.sgcs
+
+import android.os.Looper
+import androidx.test.core.app.ApplicationProvider
+import com.mentra.bluetoothsdk.Bridge
+import java.nio.charset.StandardCharsets
+import java.time.Duration
+import java.util.UUID
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.Shadows.shadowOf
+import org.robolectric.annotation.Config
+import org.robolectric.annotation.LooperMode
+import org.robolectric.shadows.ShadowLog
+
+@RunWith(RobolectricTestRunner::class)
+@Config(sdk = [33], shadows = [G1PairingTest.ShadowLc3Cpp::class], instrumentedPackages = ["com.mentra.lc3Lib"])
+@LooperMode(LooperMode.Mode.PAUSED)
+class MentraLiveWifiCredentialLogTest {
+    @Test fun `wifi credentials reach the BLE queue without being logged`() {
+        Bridge.initialize(ApplicationProvider.getApplicationContext())
+        val ssid = "synthetic-${UUID.randomUUID()}"
+        val password = UUID.randomUUID().toString()
+        val events = mutableListOf<String>()
+        val sink = Bridge.addEventSink { type, body -> if (type == "log") events.add(body["message"].toString()) }
+        val live = MentraLive()
+        try {
+            ShadowLog.clear()
+            live.sendWifiCredentials(ssid, password)
+
+            val logs = events + ShadowLog.getLogs().map { it.msg }
+            assertFalse("password logged", logs.any { it.contains(password) })
+            assertTrue(events.any { it.endsWith("LIVE: Sending data to glasses: <set_wifi_credentials with credentials omitted>") })
+            // The glasses still receive the unchanged credentials.
+            val wire = queuedWrites(live).joinToString("") { String(it, StandardCharsets.UTF_8) }
+            assertTrue(wire.contains("set_wifi_credentials"))
+            assertTrue(wire.contains(ssid))
+            assertTrue(wire.contains(password))
+        } finally {
+            Bridge.removeEventSink(sink)
+            live.destroy()
+            shadowOf(Looper.getMainLooper()).idleFor(Duration.ofSeconds(2))
+        }
+    }
+
+    private fun queuedWrites(live: MentraLive): List<ByteArray> {
+        val queue = MentraLive::class.java.getDeclaredField("sendQueue").apply { isAccessible = true }.get(live)
+        return (queue as Iterable<*>).map { write ->
+            write!!.javaClass.getDeclaredField("data").apply { isAccessible = true }.get(write) as ByteArray
+        }
+    }
+}

package/android/src/test/java/com/mentra/bluetoothsdk/sgcs/MentraNexPairingTest.kt

@@ -0,0 +1,151 @@
+package com.mentra.bluetoothsdk.sgcs
+
+import android.bluetooth.BluetoothAdapter
+import android.bluetooth.BluetoothDevice
+import android.bluetooth.BluetoothGatt
+import android.bluetooth.BluetoothProfile
+import android.bluetooth.le.ScanResult
+import android.bluetooth.le.ScanSettings
+import android.os.Looper
+import androidx.test.core.app.ApplicationProvider
+import com.mentra.bluetoothsdk.Bridge
+import com.mentra.bluetoothsdk.DeviceManager
+import com.mentra.bluetoothsdk.DeviceStore
+import com.mentra.bluetoothsdk.utils.DeviceTypes
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.Shadows.shadowOf
+import org.robolectric.annotation.Config
+import org.robolectric.annotation.Implementation
+import org.robolectric.annotation.Implements
+import org.robolectric.annotation.LooperMode
+import org.robolectric.shadows.ShadowBluetoothGatt
+
+@RunWith(RobolectricTestRunner::class)
+@Config(sdk = [33], shadows = [G1PairingTest.ShadowLc3Cpp::class, MentraNexPairingTest.ShadowNexGatt::class], instrumentedPackages = ["com.mentra.lc3Lib"])
+@LooperMode(LooperMode.Mode.PAUSED)
+class MentraNexPairingTest {
+    // Robolectric implements connection callbacks but not the PHY binder request.
+    @Implements(BluetoothGatt::class)
+    class ShadowNexGatt : ShadowBluetoothGatt() {
+        @Implementation fun setPreferredPhy(txPhy: Int, rxPhy: Int, phyOptions: Int) {}
+    }
+
+    @Before fun setup() {
+        Bridge.initialize(ApplicationProvider.getApplicationContext())
+        shadowOf(BluetoothAdapter.getDefaultAdapter()).setState(BluetoothAdapter.STATE_ON)
+        DeviceStore.set("bluetooth", "pending_device_name", "Nex1-2")
+        DeviceStore.set("bluetooth", "pending_device_address", "")
+        DeviceStore.set("bluetooth", "device_address", "")
+    }
+
+    @Test fun `fresh pairing selects only the requested Nex`() {
+        assertScansSelectedTarget("", "")
+    }
+
+    @Test fun `simulated pairing selects only the requested Nex`() {
+        assertScansSelectedTarget("Simulated Glasses", "")
+    }
+
+    @Test fun `a different saved Nex name and address cannot redirect selection`() {
+        assertScansSelectedTarget("Nex1-1", "00:00:00:00:00:01")
+    }
+
+    @Test fun `pending address targets the new Nex instead of the saved pair`() {
+        assertDirectTarget("Nex1-1", "00:00:00:00:00:01", "00:00:00:00:00:02")
+    }
+
+    @Test fun `saved Nex reconnect retains its address`() {
+        assertDirectTarget("Nex1-2", "00:00:00:00:00:02", "")
+    }
+
+    @Test fun `name-only pairing readiness cannot associate the old MAC with the new Nex`() {
+        DeviceStore.set("bluetooth", "default_wearable", DeviceTypes.NEX)
+        DeviceStore.set("bluetooth", "pending_wearable", DeviceTypes.NEX)
+        DeviceStore.set("bluetooth", "device_name", "Nex1-1")
+        DeviceStore.set("bluetooth", "device_address", "00:00:00:00:00:01")
+        DeviceStore.set("bluetooth", "shouldSendBootingMessage", false)
+        DeviceStore.set("glasses", "fullyBooted", false)
+        val old = device("00:00:00:00:00:01", "Nex1-1")
+        val selected = device("00:00:00:00:00:02", "Nex1-2")
+        val singleton = DeviceManager::class.java.getDeclaredField("_instance").apply { isAccessible = true }
+        val previous = singleton.get(null)
+        val manager = DeviceManager(initializeHardware = false)
+        singleton.set(null, manager)
+        try {
+            var nex = MentraNex()
+            manager.sgc = nex
+            nex.connectById("Nex1-2")
+            val scanner = shadowOf(BluetoothAdapter.getDefaultAdapter().bluetoothLeScanner)
+            scanner.scanCallbacks.single().onScanResult(
+                ScanSettings.CALLBACK_TYPE_ALL_MATCHES, ScanResult(selected, null, -50, 0),
+            )
+            shadowOf(Looper.getMainLooper()).idle()
+            // Drive the actual ready callback and DeviceManager's identity promotion.
+            shadowOf(selected).simulateGattConnectionChange(BluetoothGatt.GATT_SUCCESS, BluetoothProfile.STATE_CONNECTED)
+            assertEquals("Nex1-2", DeviceStore.get("bluetooth", "device_name"))
+            assertEquals("", DeviceStore.get("bluetooth", "device_address"))
+            assertEquals("", DeviceStore.get("bluetooth", "pending_device_name"))
+            manager.disconnect()
+
+            nex = MentraNex()
+            manager.sgc = nex
+            nex.connectById(DeviceStore.get("bluetooth", "device_name") as String)
+            assertTrue(shadowOf(old).bluetoothGatts.isEmpty())
+            scanner.scanCallbacks.single().onScanResult(
+                ScanSettings.CALLBACK_TYPE_ALL_MATCHES, ScanResult(selected, null, -50, 0),
+            )
+            shadowOf(Looper.getMainLooper()).idle()
+            assertEquals(2, shadowOf(selected).bluetoothGatts.size)
+        } finally {
+            manager.disconnect()
+            manager.cleanup()
+            singleton.set(null, previous)
+        }
+    }
+
+    private fun assertScansSelectedTarget(savedName: String, savedAddress: String) {
+        DeviceStore.set("bluetooth", "device_name", savedName)
+        DeviceStore.set("bluetooth", "device_address", savedAddress)
+        val old = device("00:00:00:00:00:01", "Nex1-1")
+        val prefixCollision = device("00:00:00:00:00:03", "Nex1-23")
+        val selected = device("00:00:00:00:00:02", "Nex1-2")
+        val nex = MentraNex()
+        try {
+            nex.connectById("Nex1-2")
+            val scanner = shadowOf(BluetoothAdapter.getDefaultAdapter().bluetoothLeScanner)
+            val callback = scanner.scanCallbacks.single()
+            for (found in listOf(old, prefixCollision, selected)) {
+                callback.onScanResult(ScanSettings.CALLBACK_TYPE_ALL_MATCHES, ScanResult(found, null, -50, 0))
+                shadowOf(Looper.getMainLooper()).idle()
+            }
+            assertTrue(shadowOf(old).bluetoothGatts.isEmpty())
+            assertTrue(shadowOf(prefixCollision).bluetoothGatts.isEmpty())
+            assertEquals(1, shadowOf(selected).bluetoothGatts.size)
+            assertEquals(savedName, DeviceStore.get("bluetooth", "device_name"))
+        } finally { nex.disconnect() }
+    }
+
+    private fun assertDirectTarget(savedName: String, savedAddress: String, pendingAddress: String) {
+        DeviceStore.set("bluetooth", "device_name", savedName)
+        DeviceStore.set("bluetooth", "device_address", savedAddress)
+        DeviceStore.set("bluetooth", "pending_device_address", pendingAddress)
+        val old = device("00:00:00:00:00:01", "Nex1-1")
+        val selected = device("00:00:00:00:00:02", "Nex1-2")
+        val nex = MentraNex()
+        try {
+            nex.connectById("Nex1-2")
+            shadowOf(Looper.getMainLooper()).idle()
+            assertTrue(shadowOf(old).bluetoothGatts.isEmpty())
+            assertEquals(1, shadowOf(selected).bluetoothGatts.size)
+            assertEquals(savedName, DeviceStore.get("bluetooth", "device_name"))
+        } finally { nex.disconnect() }
+    }
+
+    private fun device(address: String, name: String): BluetoothDevice =
+        BluetoothAdapter.getDefaultAdapter().getRemoteDevice(address).also { shadowOf(it).setName(name) }
+}

package/android/src/test/java/com/mentra/bluetoothsdk/sgcs/NimoBitmapAcceptanceTest.kt

@@ -0,0 +1,105 @@
+package com.mentra.bluetoothsdk.sgcs
+
+import android.graphics.Bitmap
+import androidx.test.core.app.ApplicationProvider
+import com.mentra.bluetoothsdk.Bridge
+import java.io.ByteArrayOutputStream
+import java.util.Base64
+import org.junit.After
+import org.junit.Assert.*
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.annotation.Config
+import org.robolectric.annotation.GraphicsMode
+
+@RunWith(RobolectricTestRunner::class)
+@Config(sdk = [33])
+@GraphicsMode(GraphicsMode.Mode.NATIVE)
+class NimoBitmapAcceptanceTest {
+    private lateinit var nimo: Nimo
+
+    @Before fun setup() {
+        Bridge.initialize(ApplicationProvider.getApplicationContext())
+        nimo = Nimo()
+    }
+
+    @After fun dispose() { nimo.cleanup() }
+
+    @Test fun malformedInputsAreRejectedBeforeReturning() {
+        val invalid = listOf(
+            "not base64!",
+            "data:image/jpeg;base64,${png()}",
+            "data:image/bmp;base64,${png()}",
+            Base64.getEncoder().encodeToString(byteArrayOf(0x89.toByte(), 80, 78, 71, 13, 10, 26, 10) + ByteArray(40)),
+            Base64.getEncoder().encodeToString(byteArrayOf(66, 77) + ByteArray(60)),
+            "A".repeat(NimoCanvasCodec.MAX_IMAGE_BASE64_CHARS + 1)
+        )
+        for (input in invalid) {
+            assertFalse("Malformed bitmap was accepted: ${input.take(50)}", nimo.displayBitmap(input))
+        }
+    }
+
+    @Test fun validPngAcceptsNullableGeometryAndRejectsOutOfBoundsGeometry() {
+        val image = png()
+        assertTrue(nimo.displayBitmap(image))
+        assertTrue(nimo.displayBitmap(image, 499, 219, null, null))
+        assertFalse(nimo.displayBitmap(image, 500, 0, null, null))
+        assertFalse(nimo.displayBitmap(image, 0, 0, 0, 1))
+        assertFalse(nimo.displayBitmap(image, -1, 0, 10, 10))
+    }
+
+    @Test fun jpegPixelsAreDecodedForRawAndDataUriInputs() {
+        val bitmap = Bitmap.createBitmap(2, 2, Bitmap.Config.ARGB_8888)
+        val bytes = ByteArrayOutputStream()
+        try {
+            bitmap.eraseColor(android.graphics.Color.WHITE)
+            assertTrue(bitmap.compress(Bitmap.CompressFormat.JPEG, 100, bytes))
+        } finally { bitmap.recycle() }
+        val raw = Base64.getEncoder().encodeToString(bytes.toByteArray())
+        val decode = Nimo::class.java.getDeclaredMethod(
+            "decodeCanvasImage", String::class.java, Int::class.javaPrimitiveType, Int::class.javaPrimitiveType
+        ).apply { isAccessible = true }
+        for (input in listOf(raw, "data:image/jpeg;base64,$raw")) {
+            assertTrue(nimo.displayBitmap(input))
+            assertArrayEquals(ByteArray(4) { 255.toByte() }, decode.invoke(nimo, input, 2, 2) as ByteArray)
+        }
+        assertFalse(nimo.displayBitmap("data:image/png;base64,$raw"))
+    }
+
+    @Test fun sourceRasterBudgetsRejectOversizeAndAcceptBoundaries() {
+        for ((width, height) in listOf(4097 to 1, 1 to 4097, 2049 to 2000)) {
+            assertFalse("Oversize source $width x $height", nimo.displayBitmap(png(width, height)))
+        }
+        for ((width, height) in listOf(4096 to 1, 1 to 4096, 2000 to 2000)) {
+            assertTrue("Valid boundary $width x $height", nimo.displayBitmap(png(width, height)))
+        }
+    }
+
+    @Test fun coloredRasterQuantizationMatchesIosAtEveryTwoBitBoundary() {
+        // Identical opaque 8x1 24-bit BMP in NimoCanvasSceneTests; no scaling.
+        val bmp = byteArrayOf(
+            66, 77, 78, 0, 0, 0, 0, 0, 0, 0, 54, 0, 0, 0,
+            40, 0, 0, 0, 8, 0, 0, 0, 1, 0, 0, 0, 1, 0, 24, 0,
+            0, 0, 0, 0, 24, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            0, 72, 0, 0, 73, 0, 0, 217.toByte(), 0, 0, 218.toByte(), 0,
+            0, 231.toByte(), 255.toByte(), 0, 232.toByte(), 255.toByte(), 0, 0, 0, -1, -1, -1
+        )
+        val decode = Nimo::class.java.getDeclaredMethod(
+            "decodeCanvasImage", String::class.java, Int::class.javaPrimitiveType, Int::class.javaPrimitiveType
+        ).apply { isAccessible = true }
+        val gray = decode.invoke(nimo, Base64.getEncoder().encodeToString(bmp), 8, 1) as ByteArray
+        assertArrayEquals(byteArrayOf(42, 43, 127, 128.toByte(), 212.toByte(), 213.toByte(), 0, -1), gray)
+        assertArrayEquals(byteArrayOf(0xE9.toByte(), 0x4C), NimoCanvasCodec.pack2(gray))
+    }
+
+    private fun png(width: Int = 2, height: Int = 2): String {
+        val bitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888)
+        return try {
+            val bytes = ByteArrayOutputStream()
+            assertTrue(bitmap.compress(Bitmap.CompressFormat.PNG, 100, bytes))
+            Base64.getEncoder().encodeToString(bytes.toByteArray())
+        } finally { bitmap.recycle() }
+    }
+}

package/android/src/test/java/com/mentra/bluetoothsdk/sgcs/NimoCanvasCodecTest.kt

@@ -0,0 +1,233 @@
+package com.mentra.bluetoothsdk.sgcs
+
+import org.junit.Assert.*
+import org.junit.Test
+
+class NimoCanvasCodecTest {
+  @Test fun LatinFallbackPreservesOtherScriptsAndTheirMarks() {
+    val otherScripts = "ありがとう が パ カ\u3099 한국어 한\u302E Α\u0301 مُرَحَّبًا शि ❤️"
+    val label = NimoCanvasCodec.label("$otherScripts café—Æ\u0301", 0, 0, 500, 220)
+    val expected = "$otherScripts cafe-AE".toByteArray(Charsets.UTF_8)
+    assertArrayEquals(expected, label.payload.copyOfRange(14, label.payload.size))
+    assertEquals(expected.size, label.textBytes)
+  }
+
+  @Test fun imageSourcesAcceptRawAndMatchingDataUris() {
+    // ImageIO/BitmapFactory validate the complete raster; this boundary validates file kind and size.
+    val png = byteArrayOf(0x89.toByte(), 0x50, 0x4E, 0x47, 13, 10, 26, 10) + ByteArray(24)
+    val bmp = byteArrayOf(0x42, 0x4D) + ByteArray(56)
+    val jpeg = byteArrayOf(0xFF.toByte(), 0xD8.toByte(), 0xFF.toByte()) + ByteArray(24)
+    for ((mime, bytes) in listOf("png" to png, "bmp" to bmp, "jpeg" to jpeg)) {
+      val raw = java.util.Base64.getEncoder().encodeToString(bytes)
+      assertArrayEquals(bytes, NimoCanvasCodec.imageBytes(raw))
+      assertArrayEquals(bytes, NimoCanvasCodec.imageBytes("data:image/$mime;base64,$raw"))
+      val wrongMime = if (mime == "png") "bmp" else "png"
+      assertThrows(IllegalArgumentException::class.java) {
+        NimoCanvasCodec.imageBytes("data:image/$wrongMime;base64,$raw")
+      }
+    }
+  }
+
+  @Test fun unsupportedAndOversizedImageSourcesFailBeforeRasterDecoding() {
+    val encoder = java.util.Base64.getEncoder()
+    assertThrows(IllegalStateException::class.java) { NimoCanvasCodec.imageBytes("data:image/gif;base64,AAAA") }
+    assertThrows(IllegalArgumentException::class.java) { NimoCanvasCodec.imageBytes(encoder.encodeToString(ByteArray(54))) }
+    assertThrows(IllegalArgumentException::class.java) { NimoCanvasCodec.imageBytes("a".repeat(2_800_001)) }
+    assertThrows(IllegalArgumentException::class.java) { NimoCanvasCodec.imageBytes(encoder.encodeToString(ByteArray(2_000_001))) }
+    assertThrows(IllegalArgumentException::class.java) { NimoCanvasCodec.imageBytes("not valid base64!") }
+    assertThrows(IllegalArgumentException::class.java) { NimoCanvasCodec.imageBytes("Qk0") }
+  }
+
+  @Test fun guideGoldenPacket() {
+    val frame = NimoCanvasCodec.replace(listOf(
+      NimoCanvasCodec.rectangle(20, 20, 120, 50, 2, 8),
+      NimoCanvasCodec.label("Hello Glass", 160, 30, 300, 40, font = 2)
+    ))
+    val actual = NimoCanvasCodec.frames(4, frame, 512).single()
+    val expected = "BF003600F72D000007043200FD000000020001010C0014001400780032000208FF00031900A0001E002C012800000002FF0B0048656C6C6F20476C617373"
+    assertEquals(expected, actual.joinToString("") { "%02X".format(it.toInt() and 255) })
+  }
+
+  @Test fun fourTonePolarityAndOddPadding() {
+    assertArrayEquals(byteArrayOf(0xE4.toByte(), 0x3F),
+      NimoCanvasCodec.pack2(byteArrayOf(0, 85, 170.toByte(), 255.toByte(), 255.toByte())))
+  }
+
+  @Test fun launchAndExitGoldenPackets() {
+    fun hex(bytes: ByteArray) = bytes.joinToString("") { "%02X".format(it.toInt() and 255) }
+    assertEquals("BF000600F5E4000007010200FD00", hex(NimoCanvasCodec.frames(1, writeCapacity = 512).single()))
+    assertEquals("BF00050086E4000007030100FD", hex(NimoCanvasCodec.frames(3, writeCapacity = 512).single()))
+  }
+
+  @Test fun primitivesValidateGeometryAndUseCompactCircle() {
+    assertEquals(10, NimoCanvasCodec.line(0, 0, 499, 219).payload.size)
+    assertEquals(12, NimoCanvasCodec.rectangle(0, 0, 500, 220).payload.size)
+    assertEquals(9, NimoCanvasCodec.circle(10, 10, 10).payload.size)
+    assertThrows(IllegalArgumentException::class.java) { NimoCanvasCodec.line(0, 0, 500, 219) }
+    assertThrows(IllegalArgumentException::class.java) { NimoCanvasCodec.rectangle(Int.MAX_VALUE, 0, 10, 1) }
+    assertThrows(IllegalArgumentException::class.java) { NimoCanvasCodec.rectangle(0, 0, 501, 220) }
+    assertThrows(IllegalArgumentException::class.java) { NimoCanvasCodec.circle(0, 10, 10) }
+  }
+
+  @Test fun labelUtf8LengthAndErrors() {
+    val dashes = NimoCanvasCodec.label("—éÆß— - –", 0, 0, 100, 20)
+    val expectedText = "-eAEss- - –".toByteArray(Charsets.UTF_8)
+    assertArrayEquals(expectedText, dashes.payload.copyOfRange(14, dashes.payload.size))
+    assertEquals(expectedText.size, dashes.textBytes)
+    assertEquals(expectedText.size, dashes.payload[12].toInt())
+    val label = NimoCanvasCodec.label("😀界", 0, 0, 100, 20)
+    assertEquals(7, label.textBytes)
+    assertEquals(7, label.payload[12].toInt())
+    assertThrows(IllegalArgumentException::class.java) { NimoCanvasCodec.label("a\u0000b", 0, 0, 100, 20) }
+    assertThrows(java.nio.charset.CharacterCodingException::class.java) { NimoCanvasCodec.label("\uD800", 0, 0, 100, 20) }
+    assertThrows(IllegalArgumentException::class.java) { NimoCanvasCodec.label("界".repeat(683), 0, 0, 100, 20) }
+    assertEquals(2046, NimoCanvasCodec.label("界".repeat(682), 0, 0, 100, 20).textBytes)
+  }
+
+  @Test fun totalBudgetsAndClear() {
+    assertArrayEquals(byteArrayOf(0, 0, 1), NimoCanvasCodec.replace(emptyList()))
+    val line = NimoCanvasCodec.line(0, 0, 1, 1)
+    NimoCanvasCodec.replace(List(64) { line })
+    assertThrows(IllegalArgumentException::class.java) { NimoCanvasCodec.replace(List(65) { line }) }
+    val text = NimoCanvasCodec.label("a".repeat(2048), 0, 0, 500, 220)
+    NimoCanvasCodec.replace(List(4) { text })
+    assertThrows(IllegalArgumentException::class.java) { NimoCanvasCodec.replace(List(5) { text }) }
+    val image = NimoCanvasCodec.bitmap(0, 0, 500, 220, ByteArray(110000))
+    NimoCanvasCodec.replace(listOf(image))
+    assertThrows(IllegalArgumentException::class.java) { NimoCanvasCodec.replace(listOf(image, image)) }
+    assertThrows(IllegalArgumentException::class.java) {
+      NimoCanvasCodec.replace(listOf(NimoCanvasCodec.Object(4, ByteArray(12278))))
+    }
+  }
+
+  @Test fun hostFrameReservationBoundsNativeEncoding() {
+    val random = java.util.Random(42)
+    for (size in listOf(1, 5, 80, 160, 200)) {
+      val gray = ByteArray(size * size).also { random.nextBytes(it) }
+      val image = NimoCanvasCodec.bitmap(0, 0, size, size, gray)
+      val packed = (gray.size + 3) / 4
+      val reserved = 32 + packed + (packed + 126) / 127
+      assertTrue(3 + image.payload.size <= reserved)
+    }
+    // These are the retained prefixes of the host's over-budget regression scenes.
+    val rows = NimoCanvasCodec.textRows(List(11) { "row" }.joinToString("\n"), 0, 0, 500, 220)
+    assertTrue(NimoCanvasCodec.replace(List(5) { rows }.flatten()).size <= 12280)
+    val images = listOf(200, 80).map { size ->
+      NimoCanvasCodec.bitmap(0, 0, size, size, ByteArray(size * size).also { random.nextBytes(it) })
+    }
+    assertTrue(NimoCanvasCodec.replace(images).size <= 12280)
+  }
+
+  @Test fun explicitNewlinesRetainRowsWithoutRewrapping() {
+    val rows = NimoCanvasCodec.textRows("first\n\nthird", 12, 15, 400, 100)
+    assertEquals(2, rows.size)
+    assertEquals(15, rows[0].payload[2].toInt())
+    assertEquals(55, rows[1].payload[2].toInt())
+    assertEquals(20, rows[1].payload[6].toInt())
+    val single = NimoCanvasCodec.textRows("single", 12, 15, 400, 100).single()
+    assertEquals(20, single.payload[6].toInt())
+  }
+
+  @Test fun rleBoundaryAndLiteralRoundtrip() {
+    fun decode(data: ByteArray): ByteArray {
+      val out = java.io.ByteArrayOutputStream(); var i = 0
+      while (i < data.size) {
+        val tag = data[i++].toInt() and 255
+        val count = tag and 127
+        assertTrue(count > 0)
+        if (tag and 128 != 0) { out.write(data, i, count); i += count }
+        else { repeat(count) { out.write(data[i].toInt() and 255) }; i++ }
+      }
+      return out.toByteArray()
+    }
+    for (size in listOf(1, 2, 3, 126, 127, 128, 254, 27500)) {
+      for (input in listOf(ByteArray(size) { 33 }, ByteArray(size) { (it % 251).toByte() })) {
+        assertArrayEquals(input, decode(NimoCanvasCodec.rle(input)))
+      }
+    }
+    assertArrayEquals(byteArrayOf(3, 1, 0x82.toByte(), 2, 3), NimoCanvasCodec.rle(byteArrayOf(1, 1, 1, 2, 3)))
+  }
+
+  @Test fun bitmapIsCompleteCompressed2BppAndUsesExactOddSize() {
+    val bitmap = NimoCanvasCodec.bitmap(0, 0, 5, 1, byteArrayOf(0, 85, 170.toByte(), 255.toByte(), 255.toByte()))
+    assertEquals(1, bitmap.payload[10].toInt()) // total_chunks
+    assertEquals(2, bitmap.payload[19].toInt()) // image bpp
+    assertEquals(3, bitmap.payload[20].toInt()) // RLE is smallest here
+    assertEquals(2, bitmap.payload[21].toInt()) // original_size ceil(5/4)
+    assertArrayEquals(byteArrayOf(0x82.toByte(), 0xE4.toByte(), 0x3F), bitmap.payload.copyOfRange(29, bitmap.payload.size))
+  }
+
+  @Test fun fragmentationAtNegotiatedCapacityReassemblesWholeAppStream() {
+    val content = NimoCanvasCodec.replace(listOf(NimoCanvasCodec.label("X".repeat(2048), 0, 0, 500, 220)))
+    val baseline = NimoCanvasCodec.frames(4, content, 512).flatMap { it.drop(8) }.toByteArray()
+    for (capacity in listOf(20, 64, 185, 244, 512)) {
+      val frames = NimoCanvasCodec.frames(4, content, capacity)
+      frames.forEachIndexed { index, packet ->
+        assertTrue(packet.size <= capacity)
+        assertEquals(0, packet[1].toInt())
+        val expectedIndex = if (index == frames.lastIndex) 0 else index + 1
+        assertEquals(expectedIndex, (packet[6].toInt() and 255) or ((packet[7].toInt() and 255) shl 8))
+        assertEquals(NimoCanvasCodec.crc16(packet.copyOfRange(8, packet.size)),
+          (packet[4].toInt() and 255) or ((packet[5].toInt() and 255) shl 8))
+      }
+      assertArrayEquals(baseline, frames.flatMap { it.drop(8) }.toByteArray())
+    }
+    assertThrows(IllegalArgumentException::class.java) { NimoCanvasCodec.frames(4, content, 19) }
+    assertThrows(IllegalArgumentException::class.java) { NimoCanvasCodec.frames(4, ByteArray(12281), 512) }
+  }
+
+  @Test fun strictResponseParserAcceptsStatusOnlyErrors() {
+    fun packet(hex: String) = hex.chunked(2).map { it.toInt(16).toByte() }.toByteArray()
+    val good = packet("BF000900D87900000704050000FD000000")
+    assertArrayEquals(byteArrayOf(0, 0xFD.toByte(), 0, 0, 0), NimoCanvasCodec.response(good)!!.second)
+    assertNull(NimoCanvasCodec.response(good + 0))
+    assertNull(NimoCanvasCodec.response(good.copyOf().also { it[10] = 4 }))
+    assertNull(NimoCanvasCodec.response(good.copyOf().also { it[1] = 2 }))
+    val body = byteArrayOf(7, 4, 1, 0, 7)
+    val crc = NimoCanvasCodec.crc16(body)
+    val statusOnly = byteArrayOf(0xBF.toByte(), 0, 5, 0, crc.toByte(), (crc shr 8).toByte(), 0, 0) + body
+    assertArrayEquals(byteArrayOf(7), NimoCanvasCodec.response(statusOnly)!!.second)
+  }
+
+  @Test fun sceneCompilerKeepsGeometryOrderAndBorderBeforeText() {
+    val text = NimoCanvasCodec.Element("text", 10, 20, 100, 40, "héllo—Æsir", border = 2, radius = 3)
+    val rectangle = NimoCanvasCodec.Element("rect", 100, 100, 50, 20)
+    val actual = NimoCanvasCodec.scene(listOf(text, rectangle)) { _, _, _ -> error("Not an image") }
+    val expected = NimoCanvasCodec.replace(listOf(
+      NimoCanvasCodec.rectangle(10, 20, 100, 40, 2, 3),
+      NimoCanvasCodec.label("hello-AEsir", 10, 20, 100, 20),
+      NimoCanvasCodec.rectangle(100, 100, 50, 20, 1, 0)
+    ))
+    assertArrayEquals(expected, actual)
+    assertFalse(actual.contentEquals(NimoCanvasCodec.scene(listOf(rectangle, text)) { _, _, _ -> error("Not an image") }))
+    assertFalse(actual.contentEquals(NimoCanvasCodec.scene(listOf(text.copy(x = 11), rectangle)) { _, _, _ -> error("Not an image") }))
+  }
+
+  @Test fun scenePreflightsInvalidImageBudgetBeforeDecodingAnyPng() {
+    val image = NimoCanvasCodec.Element("image", 0, 0, 500, 220, data = "unused")
+    var decoded = 0
+    assertThrows(IllegalArgumentException::class.java) {
+      NimoCanvasCodec.scene(listOf(image, image)) { _, _, _ -> decoded++; ByteArray(110000) }
+    }
+    assertEquals(0, decoded)
+    assertThrows(IllegalArgumentException::class.java) {
+      NimoCanvasCodec.scene(listOf(image.copy(type = "html"))) { _, _, _ -> decoded++; ByteArray(110000) }
+    }
+    assertEquals(0, decoded)
+  }
+
+  @Test fun zlibCompressesDenseRepeatingImagesAndInflatesToPackedPixels() {
+    val gray = ByteArray(32768) { (((it / 17) xor (it / 43)) % 4 * 85).toByte() }
+    val bitmap = NimoCanvasCodec.bitmap(0, 0, 256, 128, gray)
+    assertEquals(7, bitmap.payload[20].toInt())
+    val inflater = java.util.zip.Inflater()
+    try {
+      inflater.setInput(bitmap.payload.copyOfRange(29, bitmap.payload.size))
+      val output = ByteArray((gray.size + 3) / 4)
+      assertEquals(output.size, inflater.inflate(output))
+      assertTrue(inflater.finished())
+      assertArrayEquals(NimoCanvasCodec.pack2(gray), output)
+    } finally { inflater.end() }
+    NimoCanvasCodec.replace(listOf(bitmap))
+  }
+}