@glassly/bluetooth-sdk 0.1.0-dev.113 → 0.1.0-dev.114

package/android/src/main/java/com/glassly/bluetoothsdk/DeviceManager.kt

@@ -703,6 +703,17 @@ class DeviceManager {
     // native re-dispatch coherent (nav exit re-applies a complete scene, not
     // whatever element happened to arrive last).
     private var sceneState: SceneFrame? = null
+
+    /** Paces scene frames and legacy layouts to display_max_fps; clears bypass it. */
+    private val pacer =
+        DisplayPacer(dispatchScene = { dispatchSceneFrame(it) }, sendLegacy = { sendCurrentState() }).also {
+            it.setMaxFps((DeviceStore.store.get("bluetooth", "display_max_fps") as? Number)?.toInt() ?: DisplayPacer.DEFAULT_FPS)
+        }
+
+    fun setDisplayMaxFps(fps: Int) = pacer.setMaxFps(fps)
+
+    /** Drop paced display work (screen off): the retained state repaints on re-enable. */
+    fun cancelPendingDisplay() = pacer.cancel()
     // MARK: - End Unique
 
     // MARK: - Voice Data Handling
@@ -1208,6 +1219,7 @@ class DeviceManager {
         if (sgc != null && sgc?.type != wearable) {
             Bridge.log("MAN: Manager already initialized, cleaning up previous sgc")
             Bridge.log("MAN: Cleaning up previous sgc type: ${sgc?.type}")
+            pacer.cancel()
             sgc?.cleanup()
             sgc = null
             resetSystemTimeSync()
@@ -1580,6 +1592,7 @@ class DeviceManager {
 
     fun clearDisplay() {
         Bridge.log("MAN: Clearing Display")
+        pacer.cancel()
         sgc?.clearDisplay()
     }
 
@@ -1647,7 +1660,11 @@ class DeviceManager {
         }
 
         viewState = newViewState
-        sendCurrentState()
+        if (layoutType == "clear_view") {
+            pacer.flushLegacy()
+        } else {
+            pacer.submitLegacy()
+        }
     }
 
     /** Parse + store a scene frame, then dispatch it. */
@@ -1682,7 +1699,11 @@ class DeviceManager {
             frame.copy(replay = true, elements = frame.elements.map { it.copy(change = "created") })
         viewState = ViewState(" ", " ", " ", "scene", " ", null, null)
 
-        dispatchSceneFrame(frame)
+        if (frame.elements.isEmpty()) {
+            pacer.flushScene(frame)
+        } else {
+            pacer.submitScene(frame)
+        }
     }
 
     /** Guarded scene dispatch — mirrors sendCurrentState's send conditions. */
@@ -2306,6 +2327,7 @@ class DeviceManager {
     }
 
     fun disconnect(clearPendingIdentity: Boolean = true) {
+        pacer.cancel()
         sgc?.clearDisplay()
         sgc?.disconnect()
         sgc = null // Clear the SGC reference after disconnect

package/android/src/main/java/com/glassly/bluetoothsdk/DeviceStore.kt

@@ -132,6 +132,7 @@ object DeviceStore {
         store.set("bluetooth", "voice_activity_detection_enabled", BluetoothSdkDefaults.VOICE_ACTIVITY_DETECTION_ENABLED)
         store.set("bluetooth", "loudness_gate_enabled", BluetoothSdkDefaults.LOUDNESS_GATE_ENABLED)
         store.set("bluetooth", "screen_disabled", false)
+        store.set("bluetooth", "display_max_fps", DisplayPacer.DEFAULT_FPS)
         store.set("bluetooth", "button_photo_size", "max")
         store.set("bluetooth", "button_max_recording_time", 10)
         store.set("bluetooth", "camera_fov", mapOf("fov" to 118, "roi_position" to 0))
@@ -241,6 +242,11 @@ object DeviceStore {
                     }
                 }
             }
+            "bluetooth" to "display_max_fps" -> {
+                (value as? Number)?.let { fps ->
+                    DeviceManager.getInstance().setDisplayMaxFps(fps.toInt())
+                }
+            }
             "bluetooth" to "dashboard_height" -> {
                 scheduleDashboardHeightToGlasses()
             }
@@ -294,6 +300,7 @@ object DeviceStore {
             "bluetooth" to "screen_disabled" -> {
                 (value as? Boolean)?.let { disabled ->
                     if (disabled) {
+                        DeviceManager.getInstance().cancelPendingDisplay()
                         DeviceManager.getInstance().sgc?.exit()
                     } else {
                         DeviceManager.getInstance().sgc?.clearDisplay()

package/android/src/main/java/com/glassly/bluetoothsdk/DisplayPacer.kt

@@ -0,0 +1,198 @@
+package com.glassly.bluetoothsdk
+
+import android.os.Handler
+import android.os.Looper
+import com.glassly.bluetoothsdk.sgcs.SceneFrame
+
+/**
+ * Paces display updates leaving the phone to at most [setMaxFps] per second.
+ *
+ * Updates that arrive inside the current slot are held and sent at the next
+ * one, last-wins: a newer scene frame replaces a pending one (with the pending
+ * frame's per-element annotations folded in so per-element devices never miss
+ * a change), a legacy layout replaces a pending scene and vice versa. Clears
+ * ([flushScene] with an empty frame, [flushLegacy]) bypass the pacer and drop
+ * pending work.
+ *
+ * Safe to call from any thread; the trailing send runs on the scheduler's
+ * thread (main looper by default). Sinks are always invoked outside the lock.
+ */
+class DisplayPacer(
+    private val dispatchScene: (SceneFrame) -> Unit,
+    private val sendLegacy: () -> Unit,
+    private val clock: () -> Long = { System.nanoTime() / 1_000_000 },
+    private val scheduler: Scheduler = MainScheduler(),
+) {
+    /** Runs [block] after [delayMs]; the returned function cancels it. */
+    fun interface Scheduler {
+        fun schedule(delayMs: Long, block: () -> Unit): () -> Unit
+    }
+
+    private class MainScheduler : Scheduler {
+        private val handler = Handler(Looper.getMainLooper())
+
+        override fun schedule(delayMs: Long, block: () -> Unit): () -> Unit {
+            val runnable = Runnable { block() }
+            handler.postDelayed(runnable, delayMs)
+            return { handler.removeCallbacks(runnable) }
+        }
+    }
+
+    companion object {
+        const val MIN_FPS = 2
+        const val MAX_FPS = 20
+        const val DEFAULT_FPS = 8
+
+        fun intervalFor(fps: Int): Long = 1000L / fps.coerceIn(MIN_FPS, MAX_FPS)
+
+        /**
+         * Fold pending frame [previous] into [next] (both unsent). The device
+         * only ever sees the merged frame, so an element the pending frame
+         * changed must not read as "unchanged" in the merged one, and ids the
+         * pending frame removed must still be removed unless [next] re-creates
+         * them. A different app is already a from-scratch replay.
+         */
+        fun merge(previous: SceneFrame?, next: SceneFrame): SceneFrame {
+            if (previous == null || previous.appId != next.appId) return next
+            val pending = previous.elements.associateBy { it.id }
+            val elements =
+                next.elements.map { el ->
+                    val prior = pending[el.id] ?: return@map el
+                    when {
+                        prior.change == "created" -> el.copy(change = "created")
+                        prior.change != "unchanged" && el.change == "unchanged" -> el.copy(change = "updated")
+                        else -> el
+                    }
+                }
+            val painted = next.elements.mapTo(HashSet()) { it.id }
+            val removed = (previous.removed + next.removed).distinct().filter { it !in painted }
+            return next.copy(replay = previous.replay || next.replay, elements = elements, removed = removed)
+        }
+    }
+
+    private val lock = Any()
+    private var intervalMs: Long = intervalFor(DEFAULT_FPS)
+    private var lastSendAt: Long = Long.MIN_VALUE / 2
+    private var pendingScene: SceneFrame? = null
+    private var pendingLegacy = false
+    private var cancelTimer: (() -> Unit)? = null
+
+    fun setMaxFps(fps: Int) {
+        var send: (() -> Unit)? = null
+        synchronized(lock) {
+            intervalMs = intervalFor(fps)
+            if (!hasPending()) return
+            stopTimer()
+            send = armOrTake(clock())
+        }
+        send?.invoke()
+    }
+
+    /** Send [frame] at the next slot; replaces any pending update. */
+    fun submitScene(frame: SceneFrame) {
+        var send: (() -> Unit)? = null
+        synchronized(lock) {
+            val now = clock()
+            val merged = merge(pendingScene, frame)
+            pendingScene = merged
+            pendingLegacy = false
+            if (now - lastSendAt >= intervalMs) {
+                stopTimer()
+                send = take(now)
+            } else if (cancelTimer == null) {
+                armTimer(now)
+            }
+        }
+        send?.invoke()
+    }
+
+    /** Send the current legacy view state at the next slot; replaces any pending update. */
+    fun submitLegacy() {
+        var send: (() -> Unit)? = null
+        synchronized(lock) {
+            val now = clock()
+            pendingScene = null
+            pendingLegacy = true
+            if (now - lastSendAt >= intervalMs) {
+                stopTimer()
+                send = take(now)
+            } else if (cancelTimer == null) {
+                armTimer(now)
+            }
+        }
+        send?.invoke()
+    }
+
+    /** Immediate send for an empty (clearing) frame; pending removes ride along. */
+    fun flushScene(frame: SceneFrame) {
+        val merged: SceneFrame
+        synchronized(lock) {
+            stopTimer()
+            merged = merge(pendingScene, frame)
+            pendingScene = null
+            pendingLegacy = false
+            lastSendAt = clock()
+        }
+        dispatchScene(merged)
+    }
+
+    /** Immediate legacy send (clear_view); drops any pending scene. */
+    fun flushLegacy() {
+        synchronized(lock) {
+            stopTimer()
+            pendingScene = null
+            pendingLegacy = false
+            lastSendAt = clock()
+        }
+        sendLegacy()
+    }
+
+    /** Drop pending work without sending (disconnect, screen off, clearDisplay). */
+    fun cancel() {
+        synchronized(lock) {
+            stopTimer()
+            pendingScene = null
+            pendingLegacy = false
+        }
+    }
+
+    private fun hasPending() = pendingScene != null || pendingLegacy
+
+    private fun stopTimer() {
+        cancelTimer?.invoke()
+        cancelTimer = null
+    }
+
+    /** Lock held. Either sends now (returns the send) or arms the slot timer. */
+    private fun armOrTake(now: Long): (() -> Unit)? {
+        if (now - lastSendAt >= intervalMs) return take(now)
+        armTimer(now)
+        return null
+    }
+
+    /** Lock held. Consume pending work into a send closure and stamp the slot. */
+    private fun take(now: Long): (() -> Unit)? {
+        val scene = pendingScene
+        val legacy = pendingLegacy
+        pendingScene = null
+        pendingLegacy = false
+        if (scene == null && !legacy) return null
+        lastSendAt = now
+        return if (scene != null) ({ dispatchScene(scene) }) else ({ sendLegacy() })
+    }
+
+    /** Lock held. Arm the single trailing timer for the next slot. */
+    private fun armTimer(now: Long) {
+        val delay = (lastSendAt + intervalMs - now).coerceAtLeast(0)
+        cancelTimer = scheduler.schedule(delay) { onTimer() }
+    }
+
+    private fun onTimer() {
+        var send: (() -> Unit)? = null
+        synchronized(lock) {
+            cancelTimer = null
+            send = take(clock())
+        }
+        send?.invoke()
+    }
+}

package/android/src/main/java/com/glassly/bluetoothsdk/GeneratedReleaseMetadata.kt

@@ -3,9 +3,9 @@ package com.glassly.bluetoothsdk
 /** Generated by release CI. Do not edit in a release checkout. */
 internal object GeneratedReleaseMetadata {
     const val FAMILY_BASE_VERSION: String = "0.1.0"
-    const val RELEASE_IDENTITY: String = "0.1.0-dev.113"
-    const val RELEASE_SET_ID: String = "glassly-0.1.0-dev.113"
-    const val SOURCE_COMMIT: String = "e63da43b467758373b960b0ee9167ef29938a11c"
+    const val RELEASE_IDENTITY: String = "0.1.0-dev.114"
+    const val RELEASE_SET_ID: String = "glassly-0.1.0-dev.114"
+    const val SOURCE_COMMIT: String = "17263133b35c04f044ba0d3acd9f80efc81999d4"
     const val OTA_MANIFEST_URL: String = ""
     const val OTA_MANIFEST_SHA256: String = ""
 }

package/android/src/main/java/com/glassly/bluetoothsdk/sgcs/G2.kt

@@ -1578,9 +1578,12 @@ class G2 : SGCManager() {
             supportsCfwSceneRendering &&
                 listOf("scene17", "shapes16", "anim18", "texcache12", "teximg13", "font15").all { it in cfwFeatures }
 
-    /** TEXT_INLINE records: default text drawn by the glasses' font, no cache upload. */
+    /**
+     * TEXT_INLINE records (contract revision 19; no token, the capability
+     * response must fit one BLE frame): default text drawn by the glasses' font.
+     */
     private val supportsCfwInlineText: Boolean
-        get() = "inlinetext17" in cfwFeatures
+        get() = cfwProtocolVersion >= 19
 
     /** The on-glass slot table must be re-SET on the next vector frame. */
     private var cfwSceneInvalid = true

package/android/src/main/java/com/glassly/bluetoothsdk/sgcs/G2Flasher.kt

@@ -50,8 +50,8 @@ internal object G2FirmwareCatalog {
                 displayName = "Glassly CFW",
                 version = "2.2.9.22 CFW",
                 fileName = "g2-glassly-cfw-2.2.9.22.evenota.bin",
-                sha256 = "560d4d94344573d11ba58690221c0ea7d5a5e8c8d29c12f158e81078484b815c",
-                size = 4_528_184,
+                sha256 = "0c5990320d9f48fdca9b539be801f8f231f530fba286353c247dbe7911283f63",
+                size = 4_528_170,
             ),
         )
 

package/android/src/test/java/com/glassly/bluetoothsdk/DisplayPacerTest.kt

@@ -0,0 +1,277 @@
+package com.glassly.bluetoothsdk
+
+import com.glassly.bluetoothsdk.sgcs.SceneElement
+import com.glassly.bluetoothsdk.sgcs.SceneFrame
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class DisplayPacerTest {
+    private class FakeScheduler : DisplayPacer.Scheduler {
+        var delay: Long? = null
+        var block: (() -> Unit)? = null
+        var scheduled = 0
+
+        override fun schedule(delayMs: Long, block: () -> Unit): () -> Unit {
+            scheduled++
+            delay = delayMs
+            this.block = block
+            return {
+                if (this.block === block) {
+                    this.block = null
+                    delay = null
+                }
+            }
+        }
+
+        fun fire() {
+            val b = block ?: error("no timer armed")
+            block = null
+            delay = null
+            b()
+        }
+    }
+
+    private class Harness(fps: Int = 8) {
+        var now = 1_000L
+        val scheduler = FakeScheduler()
+        val scenes = mutableListOf<SceneFrame>()
+        var legacySends = 0
+        val pacer =
+            DisplayPacer(
+                dispatchScene = { scenes.add(it) },
+                sendLegacy = { legacySends++ },
+                clock = { now },
+                scheduler = scheduler,
+            ).also { it.setMaxFps(fps) }
+    }
+
+    private fun element(id: String, change: String = "created", x: Int = 0) =
+        SceneElement(
+            id = id, type = "text", x = x, y = 0, w = 10, h = 10, text = id, data = null,
+            border = 0, radius = 0, change = change, contentHash = "h-$id",
+        )
+
+    private fun frame(
+        vararg elements: SceneElement,
+        removed: List<String> = emptyList(),
+        appId: String = "app",
+        replay: Boolean = false,
+        epoch: Int = 1,
+    ) = SceneFrame(appId = appId, epoch = epoch, replay = replay, elements = elements.toList(), removed = removed)
+
+    private fun SceneFrame.change(id: String) = elements.first { it.id == id }.change
+
+    @Test
+    fun firstSubmitSendsImmediately() {
+        val h = Harness()
+        h.pacer.submitScene(frame(element("a")))
+        assertEquals(1, h.scenes.size)
+        assertNull(h.scheduler.block)
+    }
+
+    @Test
+    fun secondSubmitInsideWindowIsHeldUntilTheSlot() {
+        val h = Harness(fps = 10) // 100 ms slots
+        h.pacer.submitScene(frame(element("a"), epoch = 1))
+        h.now += 30
+        h.pacer.submitScene(frame(element("a", change = "updated"), epoch = 2))
+        assertEquals(1, h.scenes.size)
+        assertEquals(70L, h.scheduler.delay)
+        h.now += 70
+        h.scheduler.fire()
+        assertEquals(2, h.scenes.size)
+        assertEquals(2, h.scenes[1].epoch)
+    }
+
+    @Test
+    fun rapidFramesCoalesceIntoOneMergedSend() {
+        val h = Harness(fps = 10)
+        h.pacer.submitScene(frame(element("a"), epoch = 1))
+        h.now += 10
+        h.pacer.submitScene(frame(element("a", change = "updated"), element("b", change = "created"), epoch = 2))
+        h.now += 10
+        h.pacer.submitScene(frame(element("a", change = "unchanged"), element("b", change = "moved", x = 5), epoch = 3))
+        h.now += 10
+        h.pacer.submitScene(
+            frame(element("a", change = "unchanged"), element("b", change = "unchanged", x = 5), epoch = 4),
+        )
+        assertEquals(1, h.scheduler.scheduled)
+        h.now += 70
+        h.scheduler.fire()
+        assertEquals(2, h.scenes.size)
+        val sent = h.scenes[1]
+        assertEquals(4, sent.epoch)
+        assertEquals("updated", sent.change("a"))
+        assertEquals("created", sent.change("b"))
+        assertEquals(5, sent.elements.first { it.id == "b" }.x)
+    }
+
+    @Test
+    fun updatedThenUnchangedBecomesUpdated() {
+        val h = Harness()
+        h.pacer.submitScene(frame(element("a")))
+        h.now += 1
+        h.pacer.submitScene(frame(element("a", change = "moved", x = 3)))
+        h.now += 1
+        h.pacer.submitScene(frame(element("a", change = "unchanged", x = 3)))
+        h.now += 200
+        h.scheduler.fire()
+        assertEquals("updated", h.scenes[1].change("a"))
+    }
+
+    @Test
+    fun removedThenRecreatedIdIsNotRemoved() {
+        val h = Harness()
+        h.pacer.submitScene(frame(element("a"), element("b")))
+        h.now += 1
+        h.pacer.submitScene(frame(element("a", change = "unchanged"), removed = listOf("b")))
+        h.now += 1
+        h.pacer.submitScene(frame(element("a", change = "unchanged"), element("b", change = "created")))
+        h.now += 200
+        h.scheduler.fire()
+        val sent = h.scenes[1]
+        assertTrue(sent.removed.isEmpty())
+        assertEquals("created", sent.change("b"))
+    }
+
+    @Test
+    fun pendingRemovesSurviveIntoTheMergedFrame() {
+        val h = Harness()
+        h.pacer.submitScene(frame(element("a"), element("b"), element("c")))
+        h.now += 1
+        h.pacer.submitScene(frame(element("a", change = "unchanged"), removed = listOf("b", "c")))
+        h.now += 1
+        h.pacer.submitScene(frame(element("a", change = "unchanged"), removed = listOf("c")))
+        h.now += 200
+        h.scheduler.fire()
+        assertEquals(listOf("b", "c"), h.scenes[1].removed)
+    }
+
+    @Test
+    fun appSwitchDiscardsPending() {
+        val h = Harness()
+        h.pacer.submitScene(frame(element("a"), appId = "one"))
+        h.now += 1
+        h.pacer.submitScene(frame(element("a", change = "updated"), removed = listOf("z"), appId = "one"))
+        h.now += 1
+        h.pacer.submitScene(frame(element("b", change = "created"), appId = "two", replay = true))
+        h.now += 200
+        h.scheduler.fire()
+        val sent = h.scenes[1]
+        assertEquals("two", sent.appId)
+        assertTrue(sent.removed.isEmpty())
+        assertEquals(listOf("b"), sent.elements.map { it.id })
+    }
+
+    @Test
+    fun emptyFrameFlushesImmediatelyWithPendingRemoves() {
+        val h = Harness()
+        h.pacer.submitScene(frame(element("a"), element("b")))
+        h.now += 1
+        h.pacer.submitScene(frame(element("a", change = "unchanged"), removed = listOf("b")))
+        h.now += 1
+        h.pacer.flushScene(frame(removed = listOf("a")))
+        assertEquals(2, h.scenes.size)
+        assertEquals(setOf("a", "b"), h.scenes[1].removed.toSet())
+        assertTrue(h.scenes[1].elements.isEmpty())
+        assertNull(h.scheduler.block)
+        // Nothing left pending: a later timer must not resend.
+        h.now += 200
+        h.pacer.setMaxFps(8)
+        assertEquals(2, h.scenes.size)
+    }
+
+    @Test
+    fun clearViewFlushesImmediatelyAndDropsPendingScene() {
+        val h = Harness()
+        h.pacer.submitScene(frame(element("a")))
+        h.now += 1
+        h.pacer.submitScene(frame(element("a", change = "updated")))
+        assertNotNull(h.scheduler.block)
+        h.pacer.flushLegacy()
+        assertEquals(1, h.legacySends)
+        assertEquals(1, h.scenes.size)
+        assertNull(h.scheduler.block)
+    }
+
+    @Test
+    fun legacyAfterSceneDropsThePendingScene() {
+        val h = Harness()
+        h.pacer.submitScene(frame(element("a")))
+        h.now += 1
+        h.pacer.submitScene(frame(element("a", change = "updated")))
+        h.now += 1
+        h.pacer.submitLegacy()
+        h.now += 200
+        h.scheduler.fire()
+        assertEquals(1, h.scenes.size)
+        assertEquals(1, h.legacySends)
+    }
+
+    @Test
+    fun sceneAfterLegacyDropsThePendingLegacy() {
+        val h = Harness()
+        h.pacer.submitLegacy()
+        assertEquals(1, h.legacySends)
+        h.now += 1
+        h.pacer.submitLegacy()
+        h.now += 1
+        h.pacer.submitScene(frame(element("a")))
+        h.now += 200
+        h.scheduler.fire()
+        assertEquals(1, h.legacySends)
+        assertEquals(1, h.scenes.size)
+    }
+
+    @Test
+    fun setMaxFpsRearmsAPendingTimer() {
+        val h = Harness(fps = 2) // 500 ms slots
+        h.pacer.submitScene(frame(element("a")))
+        h.now += 50
+        h.pacer.submitScene(frame(element("a", change = "updated")))
+        assertEquals(450L, h.scheduler.delay)
+        h.pacer.setMaxFps(20) // 50 ms slots: the slot is already due
+        assertEquals(2, h.scenes.size)
+        assertNull(h.scheduler.block)
+
+        h.now += 10
+        h.pacer.submitScene(frame(element("a", change = "updated")))
+        assertEquals(40L, h.scheduler.delay)
+        h.pacer.setMaxFps(10)
+        assertEquals(90L, h.scheduler.delay)
+        assertEquals(2, h.scenes.size)
+    }
+
+    @Test
+    fun cancelDropsPendingWithoutSending() {
+        val h = Harness()
+        h.pacer.submitScene(frame(element("a")))
+        h.now += 1
+        h.pacer.submitScene(frame(element("a", change = "updated")))
+        h.pacer.cancel()
+        assertNull(h.scheduler.block)
+        h.now += 200
+        h.pacer.setMaxFps(8)
+        assertEquals(1, h.scenes.size)
+        assertFalse(h.scheduler.block != null)
+    }
+
+    @Test
+    fun lateSubmitAfterTheSlotSendsMergedImmediately() {
+        val h = Harness(fps = 10)
+        h.pacer.submitScene(frame(element("a")))
+        h.now += 10
+        h.pacer.submitScene(frame(element("a", change = "updated"), element("b", change = "created")))
+        // The timer is late; a submit past the slot sends now with the pending fold.
+        h.now += 200
+        h.pacer.submitScene(frame(element("a", change = "unchanged"), element("b", change = "unchanged")))
+        assertEquals(2, h.scenes.size)
+        assertEquals("updated", h.scenes[1].change("a"))
+        assertEquals("created", h.scenes[1].change("b"))
+        assertNull(h.scheduler.block)
+    }
+}

package/build/generated/releaseMetadata.js

@@ -1,9 +1,9 @@
 export const BLUETOOTH_SDK_RELEASE_METADATA = Object.freeze({
     "schemaVersion": 1,
     "familyBaseVersion": "0.1.0",
-    "releaseIdentity": "0.1.0-dev.113",
-    "releaseSetId": "glassly-0.1.0-dev.113",
-    "sourceCommit": "e63da43b467758373b960b0ee9167ef29938a11c",
+    "releaseIdentity": "0.1.0-dev.114",
+    "releaseSetId": "glassly-0.1.0-dev.114",
+    "sourceCommit": "17263133b35c04f044ba0d3acd9f80efc81999d4",
     "otaManifestUrl": null,
     "otaManifestSha256": null
 });

package/build/generated/releaseMetadata.js.map

@@ -1 +1 @@
-{"version":3,"file":"releaseMetadata.js","sourceRoot":"","sources":["../../src/generated/releaseMetadata.ts"],"names":[],"mappings":"AAWA,MAAM,CAAC,MAAM,8BAA8B,GAA0C,MAAM,CAAC,MAAM,CAAC;IACjG,eAAe,EAAE,CAAC;IAClB,mBAAmB,EAAE,OAAO;IAC5B,iBAAiB,EAAE,eAAe;IAClC,cAAc,EAAE,uBAAuB;IACvC,cAAc,EAAE,0CAA0C;IAC1D,gBAAgB,EAAE,IAAI;IACtB,mBAAmB,EAAE,IAAI;CAC1B,CAAC,CAAA","sourcesContent":["/** Generated by release CI. Do not edit in a release checkout. */\nexport interface BluetoothSdkReleaseMetadata {\n  schemaVersion: 1\n  familyBaseVersion: string | null\n  releaseIdentity: string | null\n  releaseSetId: string | null\n  sourceCommit: string | null\n  otaManifestUrl: string | null\n  otaManifestSha256: string | null\n}\n\nexport const BLUETOOTH_SDK_RELEASE_METADATA: Readonly<BluetoothSdkReleaseMetadata> = Object.freeze({\n  \"schemaVersion\": 1,\n  \"familyBaseVersion\": \"0.1.0\",\n  \"releaseIdentity\": \"0.1.0-dev.113\",\n  \"releaseSetId\": \"glassly-0.1.0-dev.113\",\n  \"sourceCommit\": \"e63da43b467758373b960b0ee9167ef29938a11c\",\n  \"otaManifestUrl\": null,\n  \"otaManifestSha256\": null\n})\n"]}
+{"version":3,"file":"releaseMetadata.js","sourceRoot":"","sources":["../../src/generated/releaseMetadata.ts"],"names":[],"mappings":"AAWA,MAAM,CAAC,MAAM,8BAA8B,GAA0C,MAAM,CAAC,MAAM,CAAC;IACjG,eAAe,EAAE,CAAC;IAClB,mBAAmB,EAAE,OAAO;IAC5B,iBAAiB,EAAE,eAAe;IAClC,cAAc,EAAE,uBAAuB;IACvC,cAAc,EAAE,0CAA0C;IAC1D,gBAAgB,EAAE,IAAI;IACtB,mBAAmB,EAAE,IAAI;CAC1B,CAAC,CAAA","sourcesContent":["/** Generated by release CI. Do not edit in a release checkout. */\nexport interface BluetoothSdkReleaseMetadata {\n  schemaVersion: 1\n  familyBaseVersion: string | null\n  releaseIdentity: string | null\n  releaseSetId: string | null\n  sourceCommit: string | null\n  otaManifestUrl: string | null\n  otaManifestSha256: string | null\n}\n\nexport const BLUETOOTH_SDK_RELEASE_METADATA: Readonly<BluetoothSdkReleaseMetadata> = Object.freeze({\n  \"schemaVersion\": 1,\n  \"familyBaseVersion\": \"0.1.0\",\n  \"releaseIdentity\": \"0.1.0-dev.114\",\n  \"releaseSetId\": \"glassly-0.1.0-dev.114\",\n  \"sourceCommit\": \"17263133b35c04f044ba0d3acd9f80efc81999d4\",\n  \"otaManifestUrl\": null,\n  \"otaManifestSha256\": null\n})\n"]}

package/ios/Source/BluetoothSDK.swift

@@ -491,6 +491,7 @@ public final class BluetoothSDK {
     }
 
     public func clearDisplay() async throws {
+        DeviceManager.shared.cancelPendingDisplay()
         DeviceManager.shared.sgc?.clearDisplay()
     }
 

package/ios/Source/BluetoothSdkDefaults.swift

@@ -11,7 +11,7 @@ enum BluetoothSdkDefaults {
     static let voiceActivityDetectionEnabled = false
     static let loudnessGateEnabled = true
     private static let infoSdkVersionKey = "BluetoothSdkVersion"
-    private static let swiftPackageSdkVersion = "0.1.0-dev.113"
+    private static let swiftPackageSdkVersion = "0.1.0-dev.114"
     private static let swiftPackageSdkVersionPlaceholder = "__GLASSLY" + "_BLUETOOTH_SDK_VERSION__"
 
     private static func normalizedSdkVersion(_ value: String?) -> String? {

package/ios/Source/DeviceManager.swift

@@ -320,6 +320,21 @@ struct ViewState {
     /// native re-dispatch coherent (nav exit re-applies a complete scene).
     var sceneState: SceneFrame?
 
+    /// Paces scene frames and legacy layouts to display_max_fps; clears bypass it.
+    private lazy var pacer = DisplayPacer(
+        dispatchScene: { [weak self] frame in self?.dispatchSceneFrame(frame) },
+        sendLegacy: { [weak self] in self?.sendCurrentState() }
+    )
+
+    func setDisplayMaxFps(_ fps: Int) {
+        pacer.setMaxFps(fps)
+    }
+
+    /// Drop paced display work (screen off): the retained state repaints on re-enable.
+    func cancelPendingDisplay() {
+        pacer.cancel()
+    }
+
     override init() {
         Bridge.log("MAN: init()")
         super.init()
@@ -669,6 +684,7 @@ struct ViewState {
         Bridge.log("Initializing manager for wearable: \(wearable)")
         if sgc != nil && sgc?.type != wearable {
             Bridge.log("MAN: Manager already initialized, cleaning up previous sgc")
+            pacer.cancel()
             sgc?.cleanup()
             sgc = nil
             resetSystemTimeSync()
@@ -1310,7 +1326,11 @@ struct ViewState {
         }
 
         viewState = newViewState
-        sendCurrentState()
+        if layoutType == "clear_view" {
+            pacer.flushLegacy()
+        } else {
+            pacer.submitLegacy()
+        }
     }
 
     /// Parse + store a scene frame, then dispatch it.
@@ -1349,7 +1369,11 @@ struct ViewState {
             text: " ", data: nil, animationData: nil
         )
 
-        dispatchSceneFrame(frame)
+        if frame.elements.isEmpty {
+            pacer.flushScene(frame)
+        } else {
+            pacer.submitScene(frame)
+        }
     }
 
     /// Guarded scene dispatch - mirrors sendCurrentState's send conditions.
@@ -1947,6 +1971,7 @@ struct ViewState {
     }
 
     func disconnect(clearPendingConnection: Bool = true) {
+        pacer.cancel()
         sgc?.clearDisplay() // clear the screen
         sgc?.disconnect()
         sgc = nil // Clear the SGC reference after disconnect

package/ios/Source/DeviceStore.swift

@@ -115,6 +115,7 @@ class DeviceStore {
         store.set("bluetooth", "use_native_dashboard", false)
         // Debug escape hatch: G2 CFW direct-framebuffer rendering (off = stock containers).
         store.set("bluetooth", "cfw_scene_renderer", true)
+        store.set("bluetooth", "display_max_fps", DisplayPacer.defaultFps)
         // G2 on-glass ANCS notification behavior + app filter (iOS).
         store.set(
             "bluetooth", "notification_ctrl",
@@ -231,6 +232,11 @@ class DeviceStore {
                 Task { await DeviceManager.shared.sgc?.cfwSceneRendererToggled(enabled) }
             }
 
+        case ("bluetooth", "display_max_fps"):
+            if let fps = value as? NSNumber {
+                DeviceManager.shared.setDisplayMaxFps(fps.intValue)
+            }
+
         case ("bluetooth", "dashboard_height"):
             scheduleDashboardHeightToGlasses()
 
@@ -278,6 +284,7 @@ class DeviceStore {
         case ("bluetooth", "screen_disabled"):
             if let disabled = value as? Bool {
                 if disabled {
+                    DeviceManager.shared.cancelPendingDisplay()
                     DeviceManager.shared.sgc?.exit()
                 } else {
                     DeviceManager.shared.sgc?.clearDisplay()

package/ios/Source/DisplayPacer.swift

@@ -0,0 +1,179 @@
+import Foundation
+
+/// Paces display updates leaving the phone to at most `setMaxFps` per second.
+///
+/// Updates that arrive inside the current slot are held and sent at the next
+/// one, last-wins: a newer scene frame replaces a pending one (with the pending
+/// frame's per-element annotations folded in so per-element devices never miss
+/// a change), a legacy layout replaces a pending scene and vice versa. Clears
+/// (`flushScene` with an empty frame, `flushLegacy`) bypass the pacer and drop
+/// pending work.
+@MainActor
+final class DisplayPacer {
+    /// Runs `block` after `delayMs`; the returned closure cancels it.
+    typealias Scheduler = (_ delayMs: Int64, _ block: @escaping @MainActor () -> Void) -> () -> Void
+
+    static let minFps = 2
+    static let maxFps = 20
+    static let defaultFps = 8
+
+    static func interval(forFps fps: Int) -> Int64 {
+        Int64(1000 / min(max(fps, minFps), maxFps))
+    }
+
+    static func monotonicMs() -> Int64 {
+        Int64(DispatchTime.now().uptimeNanoseconds / 1_000_000)
+    }
+
+    static func taskScheduler(_ delayMs: Int64, _ block: @escaping @MainActor () -> Void) -> () -> Void {
+        let task = Task { @MainActor in
+            try? await Task.sleep(nanoseconds: UInt64(max(0, delayMs)) * 1_000_000)
+            if Task.isCancelled { return }
+            block()
+        }
+        return { task.cancel() }
+    }
+
+    /// Fold pending frame `previous` into `next` (both unsent). The device only
+    /// ever sees the merged frame, so an element the pending frame changed must
+    /// not read as "unchanged" in the merged one, and ids the pending frame
+    /// removed must still be removed unless `next` re-creates them. A different
+    /// app is already a from-scratch replay.
+    static func merge(_ previous: SceneFrame?, into next: SceneFrame) -> SceneFrame {
+        guard let previous, previous.appId == next.appId else { return next }
+        var pending: [String: SceneElement] = [:]
+        for el in previous.elements { pending[el.id] = el }
+        let elements = next.elements.map { el -> SceneElement in
+            guard let prior = pending[el.id] else { return el }
+            if prior.change == "created" { return el.with(change: "created") }
+            if prior.change != "unchanged", el.change == "unchanged" { return el.with(change: "updated") }
+            return el
+        }
+        let painted = Set(next.elements.map(\.id))
+        var seen = Set<String>()
+        var removed: [String] = []
+        for id in previous.removed + next.removed where !painted.contains(id) && seen.insert(id).inserted {
+            removed.append(id)
+        }
+        return SceneFrame(
+            appId: next.appId, epoch: next.epoch, replay: previous.replay || next.replay,
+            elements: elements, removed: removed,
+            canvasWidth: next.canvasWidth, canvasHeight: next.canvasHeight
+        )
+    }
+
+    private let dispatchScene: (SceneFrame) -> Void
+    private let sendLegacy: () -> Void
+    private let clock: () -> Int64
+    private let scheduler: Scheduler
+
+    private var intervalMs: Int64 = DisplayPacer.interval(forFps: DisplayPacer.defaultFps)
+    private var lastSendAt: Int64 = Int64.min / 2
+    private var pendingScene: SceneFrame?
+    private var pendingLegacy = false
+    private var cancelTimer: (() -> Void)?
+
+    init(
+        dispatchScene: @escaping (SceneFrame) -> Void,
+        sendLegacy: @escaping () -> Void,
+        clock: @escaping () -> Int64 = DisplayPacer.monotonicMs,
+        scheduler: @escaping Scheduler = DisplayPacer.taskScheduler
+    ) {
+        self.dispatchScene = dispatchScene
+        self.sendLegacy = sendLegacy
+        self.clock = clock
+        self.scheduler = scheduler
+    }
+
+    func setMaxFps(_ fps: Int) {
+        intervalMs = Self.interval(forFps: fps)
+        guard hasPending else { return }
+        stopTimer()
+        let now = clock()
+        if now - lastSendAt >= intervalMs {
+            take(now)?()
+        } else {
+            armTimer(now)
+        }
+    }
+
+    /// Send `frame` at the next slot; replaces any pending update.
+    func submitScene(_ frame: SceneFrame) {
+        let now = clock()
+        pendingScene = Self.merge(pendingScene, into: frame)
+        pendingLegacy = false
+        submitPending(now)
+    }
+
+    /// Send the current legacy view state at the next slot; replaces any pending update.
+    func submitLegacy() {
+        let now = clock()
+        pendingScene = nil
+        pendingLegacy = true
+        submitPending(now)
+    }
+
+    /// Immediate send for an empty (clearing) frame; pending removes ride along.
+    func flushScene(_ frame: SceneFrame) {
+        stopTimer()
+        let merged = Self.merge(pendingScene, into: frame)
+        pendingScene = nil
+        pendingLegacy = false
+        lastSendAt = clock()
+        dispatchScene(merged)
+    }
+
+    /// Immediate legacy send (clear_view); drops any pending scene.
+    func flushLegacy() {
+        stopTimer()
+        pendingScene = nil
+        pendingLegacy = false
+        lastSendAt = clock()
+        sendLegacy()
+    }
+
+    /// Drop pending work without sending (disconnect, screen off, clearDisplay).
+    func cancel() {
+        stopTimer()
+        pendingScene = nil
+        pendingLegacy = false
+    }
+
+    private var hasPending: Bool { pendingScene != nil || pendingLegacy }
+
+    private func submitPending(_ now: Int64) {
+        if now - lastSendAt >= intervalMs {
+            stopTimer()
+            take(now)?()
+        } else if cancelTimer == nil {
+            armTimer(now)
+        }
+    }
+
+    private func stopTimer() {
+        cancelTimer?()
+        cancelTimer = nil
+    }
+
+    /// Consume pending work into a send closure and stamp the slot.
+    private func take(_ now: Int64) -> (() -> Void)? {
+        let scene = pendingScene
+        let legacy = pendingLegacy
+        pendingScene = nil
+        pendingLegacy = false
+        if scene == nil, !legacy { return nil }
+        lastSendAt = now
+        if let scene { return { self.dispatchScene(scene) } }
+        return { self.sendLegacy() }
+    }
+
+    /// Arm the single trailing timer for the next slot.
+    private func armTimer(_ now: Int64) {
+        let delay = max(0, lastSendAt + intervalMs - now)
+        cancelTimer = scheduler(delay) { [weak self] in
+            guard let self else { return }
+            self.cancelTimer = nil
+            self.take(self.clock())?()
+        }
+    }
+}

package/ios/Source/GeneratedReleaseMetadata.swift

@@ -3,9 +3,9 @@ import Foundation
 /// Generated by release CI. Do not edit in a release checkout.
 enum GeneratedReleaseMetadata {
     static let familyBaseVersion = "0.1.0"
-    static let releaseIdentity = "0.1.0-dev.113"
-    static let releaseSetId = "glassly-0.1.0-dev.113"
-    static let sourceCommit = "e63da43b467758373b960b0ee9167ef29938a11c"
+    static let releaseIdentity = "0.1.0-dev.114"
+    static let releaseSetId = "glassly-0.1.0-dev.114"
+    static let sourceCommit = "17263133b35c04f044ba0d3acd9f80efc81999d4"
     static let otaManifestUrl = ""
     static let otaManifestSha256 = ""
 }

package/ios/Source/sgcs/G2.swift

@@ -1810,9 +1810,10 @@ final class G2: NSObject, SGCManager {
             .allSatisfy(cfwFeatures.contains)
     }
 
-    /// TEXT_INLINE records: default text drawn by the glasses' font, no cache upload.
+    /// TEXT_INLINE records (contract revision 19; no token, the capability
+    /// response must fit one BLE frame): default text drawn by the glasses' font.
     private var supportsCfwInlineText: Bool {
-        cfwFeatures.contains("inlinetext17")
+        cfwProtocolVersion >= 19
     }
 
     /// The on-glass slot table must be re-SET on the next vector frame.

package/ios/Source/sgcs/G2Flasher.swift

@@ -37,8 +37,8 @@ enum G2FirmwareCatalog {
             displayName: "Glassly CFW",
             version: "2.2.9.22 CFW",
             fileName: "g2-glassly-cfw-2.2.9.22.evenota.bin",
-            sha256: "560d4d94344573d11ba58690221c0ea7d5a5e8c8d29c12f158e81078484b815c",
-            size: 4_528_184
+            sha256: "0c5990320d9f48fdca9b539be801f8f231f530fba286353c247dbe7911283f63",
+            size: 4_528_170
         ),
     ]
 

package/ios/Tests/BluetoothSDKTests/DisplayPacerTests.swift

@@ -0,0 +1,255 @@
+@testable import BluetoothSDK
+import Foundation
+import XCTest
+
+@MainActor
+final class DisplayPacerTests: XCTestCase {
+    @MainActor private final class Harness {
+        var now: Int64 = 1000
+        var delay: Int64?
+        var block: (@MainActor () -> Void)?
+        var scheduled = 0
+        var scenes: [SceneFrame] = []
+        var legacySends = 0
+        var pacer: DisplayPacer!
+
+        init(fps: Int = 8) {
+            pacer = DisplayPacer(
+                dispatchScene: { [unowned self] in self.scenes.append($0) },
+                sendLegacy: { [unowned self] in self.legacySends += 1 },
+                clock: { [unowned self] in self.now },
+                scheduler: { [unowned self] delayMs, block in
+                    self.scheduled += 1
+                    self.delay = delayMs
+                    self.block = block
+                    let token = self.scheduled
+                    return {
+                        if self.scheduled == token {
+                            self.block = nil
+                            self.delay = nil
+                        }
+                    }
+                }
+            )
+            pacer.setMaxFps(fps)
+        }
+
+        func fire() {
+            guard let b = block else { XCTFail("no timer armed"); return }
+            block = nil
+            delay = nil
+            b()
+        }
+    }
+
+    private func element(_ id: String, change: String = "created", x: Int32 = 0) -> SceneElement {
+        SceneElement(
+            id: id, type: "text", x: x, y: 0, w: 10, h: 10, text: id, data: nil, border: 0, radius: 0,
+            change: change, contentHash: "h-\(id)"
+        )
+    }
+
+    private func frame(
+        _ elements: [SceneElement], removed: [String] = [], appId: String = "app", replay: Bool = false,
+        epoch: Int = 1
+    ) -> SceneFrame {
+        SceneFrame(appId: appId, epoch: epoch, replay: replay, elements: elements, removed: removed)
+    }
+
+    private func change(_ frame: SceneFrame, _ id: String) -> String? {
+        frame.elements.first { $0.id == id }?.change
+    }
+
+    func testFirstSubmitSendsImmediately() {
+        let h = Harness()
+        h.pacer.submitScene(frame([element("a")]))
+        XCTAssertEqual(h.scenes.count, 1)
+        XCTAssertNil(h.block)
+    }
+
+    func testSecondSubmitInsideWindowIsHeldUntilTheSlot() {
+        let h = Harness(fps: 10)
+        h.pacer.submitScene(frame([element("a")], epoch: 1))
+        h.now += 30
+        h.pacer.submitScene(frame([element("a", change: "updated")], epoch: 2))
+        XCTAssertEqual(h.scenes.count, 1)
+        XCTAssertEqual(h.delay, 70)
+        h.now += 70
+        h.fire()
+        XCTAssertEqual(h.scenes.count, 2)
+        XCTAssertEqual(h.scenes[1].epoch, 2)
+    }
+
+    func testRapidFramesCoalesceIntoOneMergedSend() {
+        let h = Harness(fps: 10)
+        h.pacer.submitScene(frame([element("a")], epoch: 1))
+        h.now += 10
+        h.pacer.submitScene(frame([element("a", change: "updated"), element("b", change: "created")], epoch: 2))
+        h.now += 10
+        h.pacer.submitScene(frame([element("a", change: "unchanged"), element("b", change: "moved", x: 5)], epoch: 3))
+        h.now += 10
+        h.pacer.submitScene(
+            frame([element("a", change: "unchanged"), element("b", change: "unchanged", x: 5)], epoch: 4)
+        )
+        XCTAssertEqual(h.scheduled, 1)
+        h.now += 70
+        h.fire()
+        XCTAssertEqual(h.scenes.count, 2)
+        let sent = h.scenes[1]
+        XCTAssertEqual(sent.epoch, 4)
+        XCTAssertEqual(change(sent, "a"), "updated")
+        XCTAssertEqual(change(sent, "b"), "created")
+        XCTAssertEqual(sent.elements.first { $0.id == "b" }?.x, 5)
+    }
+
+    func testUpdatedThenUnchangedBecomesUpdated() {
+        let h = Harness()
+        h.pacer.submitScene(frame([element("a")]))
+        h.now += 1
+        h.pacer.submitScene(frame([element("a", change: "moved", x: 3)]))
+        h.now += 1
+        h.pacer.submitScene(frame([element("a", change: "unchanged", x: 3)]))
+        h.now += 200
+        h.fire()
+        XCTAssertEqual(change(h.scenes[1], "a"), "updated")
+    }
+
+    func testRemovedThenRecreatedIdIsNotRemoved() {
+        let h = Harness()
+        h.pacer.submitScene(frame([element("a"), element("b")]))
+        h.now += 1
+        h.pacer.submitScene(frame([element("a", change: "unchanged")], removed: ["b"]))
+        h.now += 1
+        h.pacer.submitScene(frame([element("a", change: "unchanged"), element("b", change: "created")]))
+        h.now += 200
+        h.fire()
+        XCTAssertTrue(h.scenes[1].removed.isEmpty)
+        XCTAssertEqual(change(h.scenes[1], "b"), "created")
+    }
+
+    func testPendingRemovesSurviveIntoTheMergedFrame() {
+        let h = Harness()
+        h.pacer.submitScene(frame([element("a"), element("b"), element("c")]))
+        h.now += 1
+        h.pacer.submitScene(frame([element("a", change: "unchanged")], removed: ["b", "c"]))
+        h.now += 1
+        h.pacer.submitScene(frame([element("a", change: "unchanged")], removed: ["c"]))
+        h.now += 200
+        h.fire()
+        XCTAssertEqual(h.scenes[1].removed, ["b", "c"])
+    }
+
+    func testAppSwitchDiscardsPending() {
+        let h = Harness()
+        h.pacer.submitScene(frame([element("a")], appId: "one"))
+        h.now += 1
+        h.pacer.submitScene(frame([element("a", change: "updated")], removed: ["z"], appId: "one"))
+        h.now += 1
+        h.pacer.submitScene(frame([element("b", change: "created")], appId: "two", replay: true))
+        h.now += 200
+        h.fire()
+        let sent = h.scenes[1]
+        XCTAssertEqual(sent.appId, "two")
+        XCTAssertTrue(sent.removed.isEmpty)
+        XCTAssertEqual(sent.elements.map(\.id), ["b"])
+    }
+
+    func testEmptyFrameFlushesImmediatelyWithPendingRemoves() {
+        let h = Harness()
+        h.pacer.submitScene(frame([element("a"), element("b")]))
+        h.now += 1
+        h.pacer.submitScene(frame([element("a", change: "unchanged")], removed: ["b"]))
+        h.now += 1
+        h.pacer.flushScene(frame([], removed: ["a"]))
+        XCTAssertEqual(h.scenes.count, 2)
+        XCTAssertEqual(Set(h.scenes[1].removed), ["a", "b"])
+        XCTAssertTrue(h.scenes[1].elements.isEmpty)
+        XCTAssertNil(h.block)
+        h.now += 200
+        h.pacer.setMaxFps(8)
+        XCTAssertEqual(h.scenes.count, 2)
+    }
+
+    func testClearViewFlushesImmediatelyAndDropsPendingScene() {
+        let h = Harness()
+        h.pacer.submitScene(frame([element("a")]))
+        h.now += 1
+        h.pacer.submitScene(frame([element("a", change: "updated")]))
+        XCTAssertNotNil(h.block)
+        h.pacer.flushLegacy()
+        XCTAssertEqual(h.legacySends, 1)
+        XCTAssertEqual(h.scenes.count, 1)
+        XCTAssertNil(h.block)
+    }
+
+    func testLegacyAfterSceneDropsThePendingScene() {
+        let h = Harness()
+        h.pacer.submitScene(frame([element("a")]))
+        h.now += 1
+        h.pacer.submitScene(frame([element("a", change: "updated")]))
+        h.now += 1
+        h.pacer.submitLegacy()
+        h.now += 200
+        h.fire()
+        XCTAssertEqual(h.scenes.count, 1)
+        XCTAssertEqual(h.legacySends, 1)
+    }
+
+    func testSceneAfterLegacyDropsThePendingLegacy() {
+        let h = Harness()
+        h.pacer.submitLegacy()
+        XCTAssertEqual(h.legacySends, 1)
+        h.now += 1
+        h.pacer.submitLegacy()
+        h.now += 1
+        h.pacer.submitScene(frame([element("a")]))
+        h.now += 200
+        h.fire()
+        XCTAssertEqual(h.legacySends, 1)
+        XCTAssertEqual(h.scenes.count, 1)
+    }
+
+    func testSetMaxFpsRearmsAPendingTimer() {
+        let h = Harness(fps: 2)
+        h.pacer.submitScene(frame([element("a")]))
+        h.now += 50
+        h.pacer.submitScene(frame([element("a", change: "updated")]))
+        XCTAssertEqual(h.delay, 450)
+        h.pacer.setMaxFps(20)
+        XCTAssertEqual(h.scenes.count, 2)
+        XCTAssertNil(h.block)
+
+        h.now += 10
+        h.pacer.submitScene(frame([element("a", change: "updated")]))
+        XCTAssertEqual(h.delay, 40)
+        h.pacer.setMaxFps(10)
+        XCTAssertEqual(h.delay, 90)
+        XCTAssertEqual(h.scenes.count, 2)
+    }
+
+    func testCancelDropsPendingWithoutSending() {
+        let h = Harness()
+        h.pacer.submitScene(frame([element("a")]))
+        h.now += 1
+        h.pacer.submitScene(frame([element("a", change: "updated")]))
+        h.pacer.cancel()
+        XCTAssertNil(h.block)
+        h.now += 200
+        h.pacer.setMaxFps(8)
+        XCTAssertEqual(h.scenes.count, 1)
+        XCTAssertNil(h.block)
+    }
+
+    func testLateSubmitAfterTheSlotSendsMergedImmediately() {
+        let h = Harness(fps: 10)
+        h.pacer.submitScene(frame([element("a")]))
+        h.now += 10
+        h.pacer.submitScene(frame([element("a", change: "updated"), element("b", change: "created")]))
+        h.now += 200
+        h.pacer.submitScene(frame([element("a", change: "unchanged"), element("b", change: "unchanged")]))
+        XCTAssertEqual(h.scenes.count, 2)
+        XCTAssertEqual(change(h.scenes[1], "a"), "updated")
+        XCTAssertEqual(change(h.scenes[1], "b"), "created")
+        XCTAssertNil(h.block)
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@glassly/bluetooth-sdk",
-  "version": "0.1.0-dev.113",
+  "version": "0.1.0-dev.114",
   "description": "SDK for communicating with smart glasses",
   "main": "build/index.js",
   "react-native": "src/index.ts",

package/src/generated/releaseMetadata.ts

@@ -12,9 +12,9 @@ export interface BluetoothSdkReleaseMetadata {
 export const BLUETOOTH_SDK_RELEASE_METADATA: Readonly<BluetoothSdkReleaseMetadata> = Object.freeze({
   "schemaVersion": 1,
   "familyBaseVersion": "0.1.0",
-  "releaseIdentity": "0.1.0-dev.113",
-  "releaseSetId": "glassly-0.1.0-dev.113",
-  "sourceCommit": "e63da43b467758373b960b0ee9167ef29938a11c",
+  "releaseIdentity": "0.1.0-dev.114",
+  "releaseSetId": "glassly-0.1.0-dev.114",
+  "sourceCommit": "17263133b35c04f044ba0d3acd9f80efc81999d4",
   "otaManifestUrl": null,
   "otaManifestSha256": null
 })