unified-ble-manager 4.0.19 → 4.0.22

package/CHANGELOG.md

@@ -6,6 +6,51 @@ All notable changes to `unified-ble-manager` are documented here.
 
 No changes yet.
 
+## [4.0.22] - 2026-09-04
+
+### Fixes
+
+- Arbitrate an Android asynchronous CCCD failure against an already-in-flight
+  disconnect callback for the same GATT generation. Android can deliver status
+  133 from `onDescriptorWrite`, accept local notification rollback, and only
+  then deliver the authoritative status-19 disconnect; exact subscriptions now
+  retain that provisional failure for a bounded 250 ms evidence window so the
+  command reports typed `connection.lost` without hiding genuine CCCD errors.
+
+## [4.0.21] - 2026-09-04 (unpublished)
+
+Publication was cancelled before the npm version check after physical Android
+hardware reproduced a later callback ordering that required the 4.0.22 fix.
+
+### Fixes
+
+- Preserve Android GATT status 19 when a peer disconnects while an exact or
+  non-exact CCCD subscription is awaiting `onDescriptorWrite`. The pending
+  subscription now reports typed `connection.lost` instead of generic
+  `platform.failure`; asynchronous CCCD status 133 remains an ordinary failure
+  when local-registration rollback succeeds.
+- Preserve that typed primary link-loss result when exact CCCD rollback also
+  fails; the cleanup failure remains separately reported and retryable.
+- Classify an exact synchronous CCCD descriptor-submission rejection as link
+  loss only when the subsequent local-registration rollback is also rejected;
+  genuine subscription rejections remain ordinary failures.
+- Apply the same two-signal rule when Android accepts descriptor submission but
+  its asynchronous CCCD callback fails before the connection-state callback:
+  a rejected rollback proves the link is gone, while a successful rollback
+  preserves the original platform failure and GATT status.
+
+## [4.0.20] - 2026-09-03
+
+### Fixes
+
+- Treat Android's synchronous `setCharacteristicNotification(...) == false`
+  result as typed `connection.lost` without consulting
+  `BluetoothManager.getConnectionState`. Android can reject registration after
+  the GATT link is gone while that manager query still reports connected.
+  Exact and non-exact notification paths now share this behavior; asynchronous
+  CCCD failures retain their native status and remain ordinary subscription
+  failures unless Android reports link loss.
+
 ## [4.0.19] - 2026-09-03
 
 ### Fixes

package/MIGRATION_4.0.md

@@ -2,7 +2,7 @@
 
 # Migrating from react-native-ble-plx
 
-This source targets `4.0.19`. The `4.0.0` release is a new package and a new contract. It is **not a source-compatible rename**. There is no `new BleManager()` facade, no Base64 characteristic values, and no public transaction IDs.
+This source targets `4.0.22`. The `4.0.0` release is a new package and a new contract. It is **not a source-compatible rename**. There is no `new BleManager()` facade, no Base64 characteristic values, and no public transaction IDs.
 
 This page is for a React Native app that already uses `react-native-ble-plx`. Web, Electron, Node, and Tauri are new hosts — use those pages after you understand the RN rewrite.
 

package/README.md

@@ -18,7 +18,7 @@ root import does not pick a radio. Package SemVer and backend support labels are
 independent: each radio backend keeps its evidence-derived label. See
 [`docs/PLATFORMS.md`](docs/PLATFORMS.md).
 
-This source tree is versioned `4.0.19`. Install the exact version shown in the npm
+This source tree is versioned `4.0.22`. Install the exact version shown in the npm
 registry. During release preparation, the version in `package.json` can be ahead
 of npm until the matching tag-driven workflow publishes it; the registry and
 GitHub release remain authoritative.

package/RELEASE.md

@@ -81,7 +81,9 @@ Active `4.0.0-rc.*` release-train candidates publish to npm `latest` so a bare `
 
 On release day, set `release_candidate` to the exact candidate required by the
 release plan. RC2, RC3, RC4, `4.0.0-rc.4.1`, and RC5 are already immutable
-once tagged. Stable `4.0.0` through `4.0.18` are immutable. `4.0.19` is the current train head.
+once tagged. Stable `4.0.0` through `4.0.20` are immutable. The unpublished
+`v4.0.21` tag is also immutable after its cancelled workflow. `4.0.22` is the
+current train head.
 
 ```sh
 release_candidate=4.0.0-rc.N
@@ -109,6 +111,55 @@ The first stable tag `v4.0.0` is immutable published history. Do not recreate or
 git tag -a v4.0.0 -m "v4.0.0"
 ```
 
+## Releasing 4.0.22
+
+The `v4.0.22` tag must identify the exact current `main` commit after canonical
+CI passes. Do not tag the release branch directly.
+
+```sh
+git fetch origin --tags
+git checkout main
+git pull --ff-only origin main
+
+test "$(git branch --show-current)" = "main"
+test "$(node -p "require('./package.json').version")" = "4.0.22"
+git diff --exit-code
+git diff --cached --exit-code
+
+git tag -a v4.0.22 -m "v4.0.22"
+git push origin v4.0.22
+```
+
+Before tagging, confirm release-note extraction finds `## [4.0.22]`.
+
+## Unpublished 4.0.21 tag
+
+The immutable `v4.0.21` tag triggered workflow `33862393779`, which was
+cancelled during native prebuilds before the npm version check or publication
+after physical Android hardware exposed a remaining CCCD callback-order race.
+It must not be recreated, moved, or published manually.
+
+## Releasing 4.0.20
+
+The `v4.0.20` tag must identify the exact current `main` commit after canonical
+CI passes. Do not tag the release branch directly.
+
+```sh
+git fetch origin --tags
+git checkout main
+git pull --ff-only origin main
+
+test "$(git branch --show-current)" = "main"
+test "$(node -p "require('./package.json').version")" = "4.0.20"
+git diff --exit-code
+git diff --cached --exit-code
+
+git tag -a v4.0.20 -m "v4.0.20"
+git push origin v4.0.20
+```
+
+Before tagging, confirm release-note extraction finds `## [4.0.20]`.
+
 ## Releasing 4.0.19
 
 The `v4.0.19` tag must identify the exact current `main` commit after canonical
@@ -424,7 +475,7 @@ a green publish job and a package a consumer can actually install are not the
 same claim.
 
 ```sh
-version=4.0.19
+version=4.0.22
 
 npm view "unified-ble-manager@$version" version
 npm view unified-ble-manager dist-tags --json

package/SBOM.cdx.json

@@ -6,15 +6,15 @@
   "metadata": {
     "component": {
       "type": "library",
-      "bom-ref": "pkg:npm/unified-ble-manager@4.0.19",
+      "bom-ref": "pkg:npm/unified-ble-manager@4.0.22",
       "name": "unified-ble-manager",
-      "version": "4.0.19",
+      "version": "4.0.22",
       "licenses": [
         {
           "expression": "Apache-2.0"
         }
       ],
-      "purl": "pkg:npm/unified-ble-manager@4.0.19"
+      "purl": "pkg:npm/unified-ble-manager@4.0.22"
     },
     "properties": [
       {
@@ -537,7 +537,7 @@
       "dependsOn": []
     },
     {
-      "ref": "pkg:npm/unified-ble-manager@4.0.19",
+      "ref": "pkg:npm/unified-ble-manager@4.0.22",
       "dependsOn": [
         "pkg:npm/%40babel/runtime@7.29.7",
         "pkg:npm/node-addon-api@8.9.0",

package/THIRD_PARTY_LICENSES.json

@@ -4,7 +4,7 @@
   "schemaVersion": "1.0.0",
   "package": {
     "name": "unified-ble-manager",
-    "version": "4.0.19"
+    "version": "4.0.22"
   },
   "source": {
     "method": "pnpm-lock production graph with installed-manifest license audit",

package/android/src/main/java/com/sfourdrinier/unifiedblemanager/radio/OwnedAndroidGattRadio.kt

@@ -131,12 +131,91 @@ internal fun classifyAndroidGattOperationFailure(
 ): AndroidGattOperationFailure = AndroidGattOperationFailure(operation, gattStatus)
 
 internal fun classifyAndroidNotificationRegistrationFailure(
-  operation: String,
-  connected: Boolean
-): Throwable = if (connected) {
-  IllegalStateException("$operation failed")
-} else {
-  AndroidGattOperationFailure(operation, null, isLinkLoss = true)
+  operation: String
+): AndroidGattOperationFailure = AndroidGattOperationFailure(operation, null, isLinkLoss = true)
+
+/**
+ * Android may deliver an ordinary CCCD callback immediately before the
+ * authoritative status-19 connection callback for the same GATT generation.
+ * Keep only that provisional result pending long enough for lifecycle evidence
+ * already in flight to claim it. Descriptor writes and already-typed link loss
+ * are never delayed.
+ */
+internal fun shouldAwaitAndroidCccdDisconnectEvidence(failure: Throwable): Boolean =
+  failure is AndroidGattOperationFailure &&
+    failure.operation == "cccd-write" &&
+    !failure.isLinkLoss
+
+private const val ANDROID_CCCD_DISCONNECT_EVIDENCE_GRACE_MS = 250L
+
+internal class AndroidCccdTerminalArbiter<Key>(
+  private val schedule: (delayMs: Long, action: () -> Unit) -> Boolean,
+  private val onFallback: (key: Key, failure: AndroidGattOperationFailure) -> Unit
+) {
+  private val provisionalFailures = ConcurrentHashMap<Key, AndroidGattOperationFailure>()
+
+  fun defer(key: Key, failure: AndroidGattOperationFailure) {
+    if (provisionalFailures.putIfAbsent(key, failure) != null) return
+    val fallback: () -> Unit = {
+      val retained = provisionalFailures.remove(key)
+      if (retained != null) onFallback(key, retained)
+    }
+    if (!schedule(ANDROID_CCCD_DISCONNECT_EVIDENCE_GRACE_MS, fallback)) fallback()
+  }
+
+  fun claim(key: Key): AndroidGattOperationFailure? = provisionalFailures.remove(key)
+
+  fun isPending(key: Key): Boolean = provisionalFailures.containsKey(key)
+
+  fun clear() {
+    provisionalFailures.clear()
+  }
+}
+
+/** Synchronous API rejection after local CCCD registration, before Android starts ATT work. */
+internal class AndroidCccdSubmissionFailure(
+  val platformStatus: Int?
+) : IllegalStateException(
+  if (platformStatus == null) "writeDescriptor failed to start"
+  else "writeDescriptor failed to start status=$platformStatus"
+)
+
+/** Android rejected removal of the exact local notification registration. */
+internal class AndroidNotificationRollbackRejected :
+  IllegalStateException("setCharacteristicNotification rollback was rejected")
+
+internal fun androidGattTerminalResult(
+  result: Result<Unit>,
+  rollbackFailure: OwnedRadioTeardownFailure?
+): Result<Unit> {
+  val primaryFailure = result.exceptionOrNull()
+  val registrationRollbackRejected =
+    rollbackFailure?.throwable is AndroidNotificationRollbackRejected
+  if (registrationRollbackRejected && primaryFailure is AndroidCccdSubmissionFailure) {
+    return Result.failure(classifyAndroidNotificationRegistrationFailure("cccd-write"))
+  }
+  if (
+    registrationRollbackRejected &&
+    primaryFailure is AndroidGattOperationFailure &&
+    primaryFailure.operation == "cccd-write" &&
+    !primaryFailure.isLinkLoss
+  ) {
+    return Result.failure(
+      AndroidGattOperationFailure(
+        primaryFailure.operation,
+        primaryFailure.gattStatus,
+        isLinkLoss = true
+      )
+    )
+  }
+  if (rollbackFailure == null || result.isFailure) return result
+  return Result.failure(
+    IllegalStateException(
+      "CCCD operation failed; CCCD rollback failed: " +
+        (rollbackFailure.throwable.message ?: "unknown error"),
+      rollbackFailure.throwable
+    )
+  )
 }
 
 /** Runtime adapter state derived from Android hardware and granted permissions. */
@@ -318,6 +397,13 @@ class OwnedAndroidGattRadio(private val context: Context) {
   private val exactWritePending = ConcurrentHashMap<BluetoothGattCharacteristic, ExactBytePending>()
   private val exactWriteValues = ConcurrentHashMap<BluetoothGattCharacteristic, ByteArray>()
   private val exactCccdPending = ConcurrentHashMap<BluetoothGattDescriptor, ExactUnitPending>()
+  private val exactCccdTerminalArbiter = AndroidCccdTerminalArbiter<BluetoothGattDescriptor>(
+    schedule = { delayMs, action -> mainHandler.postDelayed(action, delayMs) },
+    onFallback = fallback@ { descriptor, failure ->
+      val pending = exactCccdPending.remove(descriptor) ?: return@fallback
+      completeExactUnit(pending, Result.failure(failure))
+    }
+  )
   private val exactDescriptorReadPending = ConcurrentHashMap<BluetoothGattDescriptor, ExactBytePending>()
   private val exactDescriptorWritePending = ConcurrentHashMap<BluetoothGattDescriptor, ExactUnitPending>()
   private val activeNativeSubscriptionOwnership =
@@ -1047,11 +1133,6 @@ class OwnedAndroidGattRadio(private val context: Context) {
     return failures
   }
 
-  fun isConnected(deviceId: String): Boolean {
-    val device = adapter?.getRemoteDevice(deviceId) ?: return false
-    return bluetoothManager.getConnectionState(device, BluetoothProfile.GATT) == BluetoothProfile.STATE_CONNECTED
-  }
-
   fun discover(deviceId: String, onDone: (Boolean) -> Unit): Long {
     return enqueue(
       deviceId,
@@ -1565,12 +1646,10 @@ class OwnedAndroidGattRadio(private val context: Context) {
         return@enqueue
       }
       if (!gatt.setCharacteristicNotification(ch, enable)) {
-        val connected = runCatching { isConnected(deviceId) }.getOrDefault(true)
         onResult(
           Result.failure(
             classifyAndroidNotificationRegistrationFailure(
-              "setCharacteristicNotification",
-              connected
+              "setCharacteristicNotification"
             )
           )
         )
@@ -1683,14 +1762,12 @@ class OwnedAndroidGattRadio(private val context: Context) {
         return@enqueue
       }
       if (!gatt.setCharacteristicNotification(characteristic, enable)) {
-        val connected = runCatching { isConnected(deviceId) }.getOrDefault(true)
         completeExactUnitDirect(
           onResult,
           done,
           Result.failure(
             classifyAndroidNotificationRegistrationFailure(
-              "setCharacteristicNotification",
-              connected
+              "setCharacteristicNotification"
             )
           ),
           token
@@ -1768,7 +1845,7 @@ class OwnedAndroidGattRadio(private val context: Context) {
           if (exactCccdPending.remove(cccd, pending)) {
             completeExactUnit(
               pending,
-              Result.failure(IllegalStateException("writeDescriptor failed to start status=$status"))
+              Result.failure(AndroidCccdSubmissionFailure(status))
             )
           }
         }
@@ -1781,7 +1858,7 @@ class OwnedAndroidGattRadio(private val context: Context) {
           if (exactCccdPending.remove(cccd, pending)) {
             completeExactUnit(
               pending,
-              Result.failure(IllegalStateException("writeDescriptor failed to start"))
+              Result.failure(AndroidCccdSubmissionFailure(null))
             )
           }
         }
@@ -2094,6 +2171,7 @@ class OwnedAndroidGattRadio(private val context: Context) {
       exactWritePending.clear()
       exactWriteValues.clear()
       exactCccdPending.clear()
+      exactCccdTerminalArbiter.clear()
       exactDescriptorReadPending.clear()
       exactDescriptorWritePending.clear()
       activeNativeSubscriptionOwnership.clear()
@@ -2152,12 +2230,24 @@ class OwnedAndroidGattRadio(private val context: Context) {
       }
   }
 
-  private fun failPendingForDevice(deviceKeyUpper: String, reason: String) {
+  private fun failPendingForDevice(
+    deviceKeyUpper: String,
+    reason: String,
+    gattStatus: Int? = null
+  ) {
     effectiveMtuByDevice.remove(deviceKeyUpper)
     deviceQueues.remove(deviceKeyUpper)?.clear(IllegalStateException(reason))
     val failBytes = Result.failure<ByteArray?>(IllegalStateException(reason))
     val failInt = Result.failure<Int>(IllegalStateException(reason))
     val failUnit = Result.failure<Unit>(IllegalStateException(reason))
+    // A peer link-loss callback can win the race with onDescriptorWrite. Keep
+    // that exact Android status on pending CCCD work so the protocol boundary
+    // reports connectionLost instead of flattening the race to platformFailure.
+    val failCccd: Result<Unit> = if (gattStatus == ANDROID_GATT_LINK_LOSS_STATUS) {
+      Result.failure(classifyAndroidGattOperationFailure("cccd-write", gattStatus))
+    } else {
+      failUnit
+    }
     pending.keys
       .filter { key ->
         keyBelongsToDevice(key, "discover", deviceKeyUpper) ||
@@ -2180,7 +2270,9 @@ class OwnedAndroidGattRadio(private val context: Context) {
           keyBelongsToDevice(key, "descWrite", deviceKeyUpper)
       }
       .toList()
-      .forEach { key -> pendingDesc.remove(key)?.invoke(failUnit) }
+      .forEach { key ->
+        pendingDesc.remove(key)?.invoke(if (key.startsWith("cccd:")) failCccd else failUnit)
+      }
     pendingDescRead.keys
       .filter { key -> keyBelongsToDevice(key, "descRead", deviceKeyUpper) }
       .toList()
@@ -2208,7 +2300,11 @@ class OwnedAndroidGattRadio(private val context: Context) {
       .filter { it.value.deviceKeyUpper == deviceKeyUpper }
       .forEach { entry ->
         if (exactCccdPending.remove(entry.key, entry.value)) {
-          completeExactUnit(entry.value, failUnit)
+          exactCccdTerminalArbiter.claim(entry.key)
+          completeExactUnit(
+            entry.value,
+            if (entry.value.subscriptionEnabled != null) failCccd else failUnit
+          )
         }
       }
     exactDescriptorReadPending.entries
@@ -2360,17 +2456,7 @@ class OwnedAndroidGattRadio(private val context: Context) {
       pending.done()
       return
     }
-    val terminalResult = if (rollbackFailure == null) {
-      result
-    } else {
-      Result.failure(
-        IllegalStateException(
-          "${result.exceptionOrNull()?.message ?: "CCCD operation failed"}; " +
-            "CCCD rollback failed: ${rollbackFailure.throwable.message ?: "unknown error"}",
-          result.exceptionOrNull() ?: rollbackFailure.throwable
-        )
-      )
-    }
+    val terminalResult = androidGattTerminalResult(result, rollbackFailure)
     if (terminalResult.isSuccess && !pending.token.isPubliclySettled()) {
       pending.subscriptionEnabled?.let { enabled ->
         pending.subscriptionCharacteristic?.let { characteristic ->
@@ -2417,7 +2503,7 @@ class OwnedAndroidGattRadio(private val context: Context) {
       } else {
         OwnedRadioTeardownFailure(
           "cccdRollback:$deviceKeyUpper:generation=$generation",
-          IllegalStateException("setCharacteristicNotification rollback was rejected")
+          AndroidNotificationRollbackRejected()
         )
       }
     } catch (throwable: Throwable) {
@@ -2425,6 +2511,16 @@ class OwnedAndroidGattRadio(private val context: Context) {
     }
   }
 
+  private fun deferExactCccdFailure(
+    descriptor: BluetoothGattDescriptor,
+    pending: ExactUnitPending,
+    failure: AndroidGattOperationFailure
+  ) {
+    if (exactCccdPending[descriptor] === pending) {
+      exactCccdTerminalArbiter.defer(descriptor, failure)
+    }
+  }
+
   private fun completeExactUnitDirect(
     callback: (Result<Unit>) -> Unit,
     done: () -> Unit,
@@ -2491,7 +2587,7 @@ class OwnedAndroidGattRadio(private val context: Context) {
         // Always pass gatt status: status 133 etc. means failed connect, not clean disconnect.
         // R3-F003: close() only after STATE_DISCONNECTED (not from disconnect()/connect prior).
         dispatchConnectionState(id, false, status)
-        failPendingForDevice(key, "disconnected status=$status")
+        failPendingForDevice(key, "disconnected status=$status", status)
         val teardownFailure = completeGattTeardown(key, gatt, generation)
         pendingDisconnectCallbacks.remove(key)?.invoke(teardownFailure)
         if (teardownFailure != null) return
@@ -2528,18 +2624,29 @@ class OwnedAndroidGattRadio(private val context: Context) {
         }
         return
       }
-      exactCccdPending.remove(descriptor)?.let { pending ->
+      exactCccdPending[descriptor]?.let { pending ->
+        // The first callback owns the terminal. A contradictory duplicate
+        // callback cannot replace a provisional failure during arbitration.
+        if (exactCccdTerminalArbiter.isPending(descriptor)) return
         if (!isCurrentGatt(pending.deviceKeyUpper, gatt, pending.gattGeneration)) {
-          pending.done()
+          if (exactCccdPending.remove(descriptor, pending)) {
+            exactCccdTerminalArbiter.claim(descriptor)
+            pending.done()
+          }
           return@let
         }
         if (status == BluetoothGatt.GATT_SUCCESS) {
-          completeExactUnit(pending, Result.success(Unit))
+          if (exactCccdPending.remove(descriptor, pending)) {
+            completeExactUnit(pending, Result.success(Unit))
+          }
         } else {
-          completeExactUnit(
-            pending,
-            Result.failure(classifyAndroidGattOperationFailure("cccd-write", status))
-          )
+          val failure = classifyAndroidGattOperationFailure("cccd-write", status)
+          if (shouldAwaitAndroidCccdDisconnectEvidence(failure)) {
+            deferExactCccdFailure(descriptor, pending, failure)
+          } else if (exactCccdPending.remove(descriptor, pending)) {
+            exactCccdTerminalArbiter.claim(descriptor)
+            completeExactUnit(pending, Result.failure(failure))
+          }
         }
         return
       }

package/android/src/test/java/com/sfourdrinier/unifiedblemanager/protocol/UnifiedBleProtocolAndroidDispatcherLifecycleTest.kt

@@ -14,6 +14,13 @@ import com.sfourdrinier.unifiedblemanager.radio.bondedPeerAdapterReadiness
 import com.sfourdrinier.unifiedblemanager.radio.requiresImmediateGattTeardownOnAdapterState
 import com.sfourdrinier.unifiedblemanager.radio.classifyAndroidGattOperationFailure
 import com.sfourdrinier.unifiedblemanager.radio.classifyAndroidNotificationRegistrationFailure
+import com.sfourdrinier.unifiedblemanager.radio.AndroidGattOperationFailure
+import com.sfourdrinier.unifiedblemanager.radio.AndroidCccdSubmissionFailure
+import com.sfourdrinier.unifiedblemanager.radio.AndroidNotificationRollbackRejected
+import com.sfourdrinier.unifiedblemanager.radio.AndroidCccdTerminalArbiter
+import com.sfourdrinier.unifiedblemanager.radio.OwnedRadioTeardownFailure
+import com.sfourdrinier.unifiedblemanager.radio.androidGattTerminalResult
+import com.sfourdrinier.unifiedblemanager.radio.shouldAwaitAndroidCccdDisconnectEvidence
 import org.junit.Assert.assertEquals
 import org.junit.Assert.assertArrayEquals
 import org.junit.Assert.assertFalse
@@ -44,6 +51,87 @@ class UnifiedBleProtocolAndroidDispatcherLifecycleTest {
     assertEquals(133, ordinaryFailure.gattStatus)
   }
 
+  @Test
+  fun onlyProvisionalAsyncCccdFailuresAwaitAuthoritativeDisconnectEvidence() {
+    assertTrue(
+      shouldAwaitAndroidCccdDisconnectEvidence(
+        classifyAndroidGattOperationFailure("cccd-write", 133)
+      )
+    )
+    assertFalse(
+      shouldAwaitAndroidCccdDisconnectEvidence(
+        classifyAndroidGattOperationFailure("cccd-write", 19)
+      )
+    )
+    assertFalse(
+      shouldAwaitAndroidCccdDisconnectEvidence(
+        classifyAndroidGattOperationFailure("descriptor-write", 133)
+      )
+    )
+    assertFalse(
+      shouldAwaitAndroidCccdDisconnectEvidence(
+        IllegalStateException("ordinary failure")
+      )
+    )
+
+    val radio = readAndroidSource(
+      "android/src/main/java/com/sfourdrinier/unifiedblemanager/radio/OwnedAndroidGattRadio.kt"
+    )
+    val callback = radio.substring(
+      radio.indexOf("override fun onDescriptorWrite"),
+      radio.indexOf("@Deprecated(\"Deprecated in Java\")")
+    )
+    assertTrue(callback.contains("deferExactCccdFailure(descriptor, pending, failure)"))
+
+    val disconnectCleanup = radio.substring(
+      radio.indexOf("exactCccdPending.entries"),
+      radio.indexOf("exactDescriptorReadPending.entries")
+    )
+    assertTrue(
+      disconnectCleanup.indexOf("exactCccdPending.remove(entry.key, entry.value)") <
+        disconnectCleanup.indexOf("exactCccdTerminalArbiter.claim(entry.key)")
+    )
+  }
+
+  @Test
+  fun cccdTerminalArbiterLetsDisconnectWinAndPreservesOrdinaryFallbackExactlyOnce() {
+    val scheduled = mutableListOf<() -> Unit>()
+    val fallbacks = mutableListOf<Pair<String, AndroidGattOperationFailure>>()
+    val arbiter = AndroidCccdTerminalArbiter<String>(
+      schedule = { _, action -> scheduled.add(action) },
+      onFallback = { key, failure -> fallbacks.add(key to failure) }
+    )
+    val first = classifyAndroidGattOperationFailure("cccd-write", 133)
+
+    arbiter.defer("disconnect-wins", first)
+    arbiter.defer("disconnect-wins", classifyAndroidGattOperationFailure("cccd-write", 257))
+    assertTrue(arbiter.isPending("disconnect-wins"))
+    assertEquals(1, scheduled.size)
+    assertTrue(arbiter.claim("disconnect-wins") === first)
+    scheduled.removeAt(0).invoke()
+    assertTrue(fallbacks.isEmpty())
+
+    arbiter.defer("ordinary-fallback", first)
+    scheduled.removeAt(0).invoke()
+    assertEquals(listOf("ordinary-fallback" to first), fallbacks)
+    assertFalse(arbiter.isPending("ordinary-fallback"))
+  }
+
+  @Test
+  fun cccdTerminalArbiterCannotStrandFailureWhenSchedulingIsRejected() {
+    val fallbacks = mutableListOf<AndroidGattOperationFailure>()
+    val arbiter = AndroidCccdTerminalArbiter<String>(
+      schedule = { _, _ -> false },
+      onFallback = { _, failure -> fallbacks.add(failure) }
+    )
+    val failure = classifyAndroidGattOperationFailure("cccd-write", 133)
+
+    arbiter.defer("cccd", failure)
+
+    assertEquals(listOf(failure), fallbacks)
+    assertFalse(arbiter.isPending("cccd"))
+  }
+
   @Test
   fun dispatcherOnlyMapsTypedLinkLossToConnectionLost() {
     val linkLoss = classifyAndroidGattOperationFailure("cccd-write", 19)
@@ -64,20 +152,212 @@ class UnifiedBleProtocolAndroidDispatcherLifecycleTest {
   }
 
   @Test
-  fun synchronousNotificationRegistrationFailureIsTypedAsLinkLossWhenAndroidReportsDisconnected() {
-    val disconnected = classifyAndroidNotificationRegistrationFailure(
-      operation = "notification-registration",
-      connected = false
+  fun synchronousNotificationRegistrationFailureIsTypedAsLinkLossDespiteStaleManagerState() {
+    val failure = classifyAndroidNotificationRegistrationFailure(
+      operation = "notification-registration"
+    )
+    assertEquals("connectionLost", androidGattOperationFailureCode(failure, "subscriptionFailed"))
+    assertNull(androidGattOperationFailureStatus(failure))
+
+    val ordinaryCccdFailure = classifyAndroidGattOperationFailure("cccd-write", 133)
+    assertEquals(
+      "subscriptionFailed",
+      androidGattOperationFailureCode(ordinaryCccdFailure, "subscriptionFailed")
+    )
+    assertEquals(133, androidGattOperationFailureStatus(ordinaryCccdFailure))
+  }
+
+  @Test
+  fun exactAndNonExactNotificationRegistrationFailuresShareTheTypedLinkLossClassifier() {
+    val radio = readAndroidSource(
+      "android/src/main/java/com/sfourdrinier/unifiedblemanager/radio/OwnedAndroidGattRadio.kt"
+    )
+    val nonExact = radio.substring(
+      radio.indexOf("private fun setNotify("),
+      radio.indexOf("/** Enables or disables an exact duplicate-safe")
+    )
+    val exact = radio.substring(
+      radio.indexOf("private fun setNotifyTarget("),
+      radio.indexOf("private fun rollbackNotifyRegistration")
+    )
+
+    assertTrue(nonExact.contains("classifyAndroidNotificationRegistrationFailure("))
+    assertTrue(exact.contains("classifyAndroidNotificationRegistrationFailure("))
+    assertFalse(nonExact.contains("isConnected("))
+    assertFalse(exact.contains("isConnected("))
+    assertFalse(radio.contains("fun isConnected("))
+  }
+
+  @Test
+  fun disconnectStatus19PreservesTypedCccdFailureWhileDrainingBothSubscribePaths() {
+    val radio = readAndroidSource(
+      "android/src/main/java/com/sfourdrinier/unifiedblemanager/radio/OwnedAndroidGattRadio.kt"
+    )
+    val pendingDrain = radio.substring(
+      radio.indexOf("private fun failPendingForDevice("),
+      radio.indexOf("private fun findChar(")
+    )
+    val disconnectCallback = radio.substring(
+      radio.indexOf("override fun onConnectionStateChange"),
+      radio.indexOf("override fun onDescriptorWrite")
+    )
+    val nonExactSubscribe = radio.substring(
+      radio.indexOf("private fun setNotify("),
+      radio.indexOf("/** Enables or disables an exact duplicate-safe")
+    )
+    val exactSubscribe = radio.substring(
+      radio.indexOf("private fun setNotifyTarget("),
+      radio.indexOf("private fun rollbackNotifyRegistration")
+    )
+    val descriptorCallback = radio.substring(
+      radio.indexOf("override fun onDescriptorWrite"),
+      radio.indexOf("@Deprecated(\"Deprecated in Java\")")
+    )
+
+    assertTrue(pendingDrain.contains("gattStatus: Int?"))
+    assertTrue(pendingDrain.contains("classifyAndroidGattOperationFailure(\"cccd-write\", gattStatus)"))
+    assertTrue(pendingDrain.contains("if (key.startsWith(\"cccd:\")) failCccd else failUnit"))
+    assertTrue(pendingDrain.contains("if (entry.value.subscriptionEnabled != null) failCccd else failUnit"))
+    assertTrue(nonExactSubscribe.contains("pendingDesc[key]"))
+    assertTrue(exactSubscribe.contains("exactCccdPending.putIfAbsent(cccd, pending)"))
+    assertTrue(descriptorCallback.contains("classifyAndroidGattOperationFailure"))
+    assertTrue(
+      disconnectCallback.contains(
+        "failPendingForDevice(key, \"disconnected status=\$status\", status)"
+      )
+    )
+  }
+
+  @Test
+  fun cccdRollbackFailureDoesNotReplaceThePrimaryTypedGattFailure() {
+    val radio = readAndroidSource(
+      "android/src/main/java/com/sfourdrinier/unifiedblemanager/radio/OwnedAndroidGattRadio.kt"
+    )
+    val completion = radio.substring(
+      radio.indexOf("private fun completeExactUnit("),
+      radio.indexOf("private fun rollbackNotifyRegistration")
+    )
+
+    assertTrue(completion.contains("androidGattTerminalResult(result, rollbackFailure)"))
+    assertTrue(completion.contains("registerRetryableCleanup(rollbackFailure.operation)"))
+    assertTrue(completion.contains("reportCleanupFailure(rollbackFailure)"))
+  }
+
+  @Test
+  fun cccdRollbackFailurePreservesTypedPrimaryAndKeepsSuccessfulPrimaryCleanupFailureBehavior() {
+    val primary = classifyAndroidGattOperationFailure("cccd-write", 19)
+    val rollbackFailure = OwnedRadioTeardownFailure(
+      "cccdRollback:AA:BB",
+      IllegalStateException("link is gone")
+    )
+
+    val typedFailure = androidGattTerminalResult(Result.failure<Unit>(primary), rollbackFailure)
+    val typedError = typedFailure.exceptionOrNull()
+    assertTrue(typedError === primary)
+    assertTrue(typedError is AndroidGattOperationFailure)
+    if (typedError !is AndroidGattOperationFailure) throw AssertionError("typed primary was flattened")
+    assertTrue(typedError.isLinkLoss)
+
+    val callbackFailure = classifyAndroidGattOperationFailure("cccd-write", 133)
+    val callbackFailureWithGenericCleanupError = androidGattTerminalResult(
+      Result.failure<Unit>(callbackFailure),
+      rollbackFailure
+    )
+    assertTrue(callbackFailureWithGenericCleanupError.exceptionOrNull() === callbackFailure)
+
+    val rejectedRegistrationRollback = OwnedRadioTeardownFailure(
+      "cccdRollback:AA:BB",
+      AndroidNotificationRollbackRejected()
+    )
+    val linkLossAfterCallbackFailure = androidGattTerminalResult(
+      Result.failure<Unit>(callbackFailure),
+      rejectedRegistrationRollback
+    )
+    val callbackError = linkLossAfterCallbackFailure.exceptionOrNull()
+    assertTrue(callbackError is AndroidGattOperationFailure)
+    if (callbackError !is AndroidGattOperationFailure) {
+      throw AssertionError("CCCD callback failure plus rejected rollback was not classified")
+    }
+    assertTrue(callbackError.isLinkLoss)
+    assertEquals(133, callbackError.gattStatus)
+
+    val descriptorFailure = classifyAndroidGattOperationFailure("descriptor-write", 133)
+    assertTrue(
+      androidGattTerminalResult(
+        Result.failure<Unit>(descriptorFailure),
+        rejectedRegistrationRollback
+      ).exceptionOrNull() === descriptorFailure
+    )
+
+    val successfulPrimary = androidGattTerminalResult(Result.success(Unit), rollbackFailure)
+    assertTrue(successfulPrimary.isFailure)
+    assertTrue(successfulPrimary.exceptionOrNull() is IllegalStateException)
+    assertTrue(successfulPrimary.exceptionOrNull()?.message?.contains("CCCD rollback failed") == true)
+
+    val ordinaryPrimary = IllegalStateException("ordinary CCCD failure")
+    val ordinaryFailure = androidGattTerminalResult(Result.failure<Unit>(ordinaryPrimary), rollbackFailure)
+    assertTrue(ordinaryFailure.exceptionOrNull() === ordinaryPrimary)
+
+    val synchronousSubmission = AndroidCccdSubmissionFailure(133)
+    assertEquals(133, synchronousSubmission.platformStatus)
+    val linkLossAfterSubmission = androidGattTerminalResult(
+      Result.failure<Unit>(synchronousSubmission),
+      rejectedRegistrationRollback
+    )
+    val linkLossError = linkLossAfterSubmission.exceptionOrNull()
+    assertTrue(linkLossError is AndroidGattOperationFailure)
+    if (linkLossError !is AndroidGattOperationFailure) throw AssertionError("submission failure was not classified")
+    assertTrue(linkLossError.isLinkLoss)
+    assertTrue(
+      androidGattTerminalResult(Result.failure(synchronousSubmission), null).exceptionOrNull() ===
+        synchronousSubmission
+    )
+    val legacySubmission = AndroidCccdSubmissionFailure(null)
+    assertNull(legacySubmission.platformStatus)
+  }
+
+  @Test
+  fun exactCccdSubmissionRejectionIsMarkedBeforeRollbackClassification() {
+    val radio = readAndroidSource(
+      "android/src/main/java/com/sfourdrinier/unifiedblemanager/radio/OwnedAndroidGattRadio.kt"
+    )
+    val exactSubscribe = radio.substring(
+      radio.indexOf("private fun setNotifyTarget("),
+      radio.indexOf("private fun rollbackNotifyRegistration")
+    )
+    val completion = radio.substring(
+      radio.indexOf("private fun completeExactUnit("),
+      radio.indexOf("private fun rollbackNotifyRegistration")
+    )
+
+    assertTrue(exactSubscribe.contains("AndroidCccdSubmissionFailure"))
+    assertTrue(exactSubscribe.contains("AndroidCccdSubmissionFailure(status)"))
+    assertTrue(exactSubscribe.contains("AndroidCccdSubmissionFailure(null)"))
+    assertTrue(completion.contains("androidGattTerminalResult(result, rollbackFailure)"))
+  }
+
+  @Test
+  fun publicSubscribeUsesExactNotificationPathWhileLegacyPrivatePathStaysOrdinary() {
+    val dispatcher = readAndroidSource(
+      "android/src/main/java/com/sfourdrinier/unifiedblemanager/protocol/UnifiedBleProtocolAndroidDispatcher.kt"
+    )
+    val subscribe = dispatcher.substring(
+      dispatcher.indexOf("private fun subscribe(command: ProtocolWireRecord, enable: Boolean)"),
+      dispatcher.indexOf("private fun destroy(command: ProtocolWireRecord)")
     )
-    assertEquals("connectionLost", androidGattOperationFailureCode(disconnected, "subscriptionFailed"))
-    assertNull(androidGattOperationFailureStatus(disconnected))
+    assertTrue(subscribe.contains("radio.setNotifyExact("))
+    assertFalse(subscribe.contains("radio.setNotify("))
 
-    val connected = classifyAndroidNotificationRegistrationFailure(
-      operation = "notification-registration",
-      connected = true
+    val radio = readAndroidSource(
+      "android/src/main/java/com/sfourdrinier/unifiedblemanager/radio/OwnedAndroidGattRadio.kt"
+    )
+    val legacy = radio.substring(
+      radio.indexOf("private fun setNotify("),
+      radio.indexOf("/** Enables or disables an exact duplicate-safe")
     )
-    assertEquals("subscriptionFailed", androidGattOperationFailureCode(connected, "subscriptionFailed"))
-    assertNull(androidGattOperationFailureStatus(connected))
+    assertTrue(legacy.contains("IllegalStateException(\"writeDescriptor failed to start status=\$status\")"))
+    assertTrue(legacy.contains("IllegalStateException(\"writeDescriptor failed to start\")"))
+    assertFalse(legacy.contains("AndroidCccdSubmissionFailure"))
   }
 
   @Test

package/docs/ELECTRON.md

@@ -4,7 +4,7 @@
 
 Main owns the radio. The renderer uses a versioned IPC client and never loads a native addon.
 
-This source targets `4.0.19`. Tagged releases ship Node-API v8 prebuilds covering macOS and Windows `arm64`/`x64` for both Node and modern Electron.
+This source targets `4.0.22`. Tagged releases ship Node-API v8 prebuilds covering macOS and Windows `arm64`/`x64` for both Node and modern Electron.
 
 `unified-ble-manager/electron/main` and
 `unified-ble-manager/electron/renderer` are the only Electron entrypoints.

package/docs/EXPO_PLUGIN.md

@@ -7,7 +7,7 @@ start a radio, request runtime permissions during prebuild, or prove physical
 radio/restoration reliability. Expo Go is not a supported BLE execution
 environment because it cannot contain this native module.
 
-Use the v2 plugin options in this `4.0.19` source. Those options match
+Use the v2 plugin options in this `4.0.22` source. Those options match
 the schema introduced at `4.0.0-rc.4`. Expo Go cannot load this native module.
 
 ## Installation and development build

package/docs/GAPS.4.0.md

@@ -14,7 +14,7 @@ This file tracks platform code, CI, package, lab, and live-radio evidence. It do
 
 The clean-baseline contract, unified core, public manager, deterministic backend, TCK, native protocol, first-party backend implementations, host-isolated package exports, SDK/CLI, and legacy-absence gates exist in the 4.0 source. Passing deterministic, compile, ABI, or package tests are implementation proof; they do not become physical-radio support evidence unless a retained record proves the corresponding live scenario.
 
-This source targets `unified-ble-manager@4.0.19`; the npm registry and release
+This source targets `unified-ble-manager@4.0.22`; the npm registry and release
 provenance, not a source version string, determine whether it is published.
 Earlier stable releases remain immutable published history. Backend support labels remain
 evidence-derived. This package does not rewrite the evidence inventory: a backend remains at the support level

package/docs/GETTING_STARTED.md

@@ -4,7 +4,7 @@
 
 This page gets you to a first scan, connect, read, notify, and teardown on React Native. Other hosts are linked at the bottom. The root import does not turn Bluetooth on.
 
-This source targets `4.0.19`; verify the published version in the npm registry.
+This source targets `4.0.22`; verify the published version in the npm registry.
 
 ## Pick a host
 
@@ -38,11 +38,11 @@ request runtime permissions on Android 12+, add
 #### Expo / CNG v2
 
 The Expo v2 schema and `unified-ble-manager/expo` factory are in this source.
-After the npm registry lists `4.0.19`, install that exact version and keep it in
+After the npm registry lists `4.0.22`, install that exact version and keep it in
 your lockfile while validating the native build:
 
 ```sh
-pnpm add unified-ble-manager@4.0.19
+pnpm add unified-ble-manager@4.0.22
 ```
 
 The package does not run in Expo Go.

package/docs/NODE.md

@@ -10,7 +10,7 @@ The root import does not open an adapter. Pick one backend:
 | `unified-ble-manager/node/winrt`         | Windows                                      |
 | `unified-ble-manager/node/bluez`         | Linux (needs `dbus-next@^0.10.2` in the app) |
 
-This source targets `4.0.19`. Tagged releases ship Node-API v8 prebuilds for macOS and Windows on `arm64` and `x64`. A normal install should not compile native code. BlueZ talks D-Bus and has no addon.
+This source targets `4.0.22`. Tagged releases ship Node-API v8 prebuilds for macOS and Windows on `arm64` and `x64`. A normal install should not compile native code. BlueZ talks D-Bus and has no addon.
 
 ## One-call factories
 

package/docs/WEB.md

@@ -6,7 +6,7 @@ Use `unified-ble-manager/web` to run the public UBM manager directly in a browse
 
 The complete runnable TypeScript/Vite application is in [`example-web/`](../example-web/).
 
-This guide targets `4.0.19`. Web Bluetooth support still depends on the browser, operating system, adapter, and peripheral. UBM reports those runtime boundaries; it does not fabricate a fallback backend.
+This guide targets `4.0.22`. Web Bluetooth support still depends on the browser, operating system, adapter, and peripheral. UBM reports those runtime boundaries; it does not fabricate a fallback backend.
 
 ## Requirements
 

package/docs/generated/PLATFORM_SUPPORT.md

@@ -6,7 +6,7 @@ This page is generated by `scripts/docs/generate-platform-support.js` from valid
 
 ## Current package
 
-`unified-ble-manager@4.0.19`
+`unified-ble-manager@4.0.22`
 
 No evidence record is bound to this exact package version and artifact. Consequently, this generated page makes no Preview, Live Preview, Supported, or Reliability-qualified platform claim for the current package.
 

package/lib/commonjs/implementation-version.js

@@ -7,5 +7,5 @@ exports.UNIFIED_BLE_IMPLEMENTATION_VERSION = void 0;
 // src/implementation-version.ts
 
 /** The one production version stamped into every first-party backend identity. */
-const UNIFIED_BLE_IMPLEMENTATION_VERSION = exports.UNIFIED_BLE_IMPLEMENTATION_VERSION = '4.0.19';
+const UNIFIED_BLE_IMPLEMENTATION_VERSION = exports.UNIFIED_BLE_IMPLEMENTATION_VERSION = '4.0.22';
 //# sourceMappingURL=implementation-version.js.map

package/lib/module/implementation-version.js

@@ -3,5 +3,5 @@
 // src/implementation-version.ts
 
 /** The one production version stamped into every first-party backend identity. */
-export const UNIFIED_BLE_IMPLEMENTATION_VERSION = '4.0.19';
+export const UNIFIED_BLE_IMPLEMENTATION_VERSION = '4.0.22';
 //# sourceMappingURL=implementation-version.js.map

package/lib/typescript/commonjs/src/backends/bluez/bluez-backend-provider.d.ts

@@ -4,7 +4,7 @@ import { type BackendCompatibilityOffer } from '../../backend-contract/primitive
 import { type BluezBusKind, type BluezDbusBoundaryFactory } from './bluez-dbus-contract';
 export declare const BLUEZ_BACKEND_ID = "unified-ble:bluez-dbus";
 export declare const BLUEZ_PLATFORM_ID = "unified-ble:linux-bluez";
-export declare const BLUEZ_IMPLEMENTATION_VERSION = "4.0.19";
+export declare const BLUEZ_IMPLEMENTATION_VERSION = "4.0.22";
 export declare const bluezCompatibility: BackendCompatibilityOffer;
 export interface BluezBackendProviderOptions {
     readonly busKind: BluezBusKind;

package/lib/typescript/commonjs/src/backends/corebluetooth/corebluetooth-identity.d.ts

@@ -1,7 +1,7 @@
 import { type FeatureRegistry } from '../../backend-contract/capabilities';
 export declare const COREBLUETOOTH_BACKEND_ID = "unified-ble:corebluetooth";
 export declare const COREBLUETOOTH_PLATFORM_ID = "unified-ble:macos-corebluetooth";
-export declare const COREBLUETOOTH_IMPLEMENTATION_VERSION = "4.0.19";
+export declare const COREBLUETOOTH_IMPLEMENTATION_VERSION = "4.0.22";
 /** Identity metadata for a direct-GATT boundary that shares this backend core. */
 export interface DirectGattBackendIdentityOptions {
     readonly registeredBackendId: string;

package/lib/typescript/commonjs/src/backends/reactnative/react-native-android-provider.d.ts

@@ -9,7 +9,7 @@ import { ReactNativeAndroidProtocolBoundary } from '../../native-protocol/rn-and
 import { ReactNativeRestorationCoordinator, type ReactNativeRestorationActivation, type ReactNativeRestorationBackendProvider } from './react-native-restoration';
 export declare const REACT_NATIVE_ANDROID_BACKEND_ID = "unified-ble:react-native-android";
 export declare const REACT_NATIVE_ANDROID_PLATFORM_ID = "unified-ble:android-gatt";
-export declare const REACT_NATIVE_ANDROID_IMPLEMENTATION_VERSION = "4.0.19";
+export declare const REACT_NATIVE_ANDROID_IMPLEMENTATION_VERSION = "4.0.22";
 export declare const REACT_NATIVE_ANDROID_DEFAULT_ADAPTER_NATIVE_ID = "android-default-adapter";
 export declare const reactNativeAndroidCompatibility: NativeCompatibilityOffer;
 export interface ReactNativeAndroidBackendProviderOptions {

package/lib/typescript/commonjs/src/backends/reactnative/react-native-apple-provider.d.ts

@@ -3,7 +3,7 @@ import type { Spec as NativeProtocolControl } from '../../NativeUnifiedBleProtoc
 import { type ReactNativeRestorationBackendProvider } from './react-native-restoration';
 export declare const REACT_NATIVE_APPLE_BACKEND_ID = "unified-ble:react-native-apple";
 export declare const REACT_NATIVE_APPLE_PLATFORM_ID = "unified-ble:apple-corebluetooth";
-export declare const REACT_NATIVE_APPLE_IMPLEMENTATION_VERSION = "4.0.19";
+export declare const REACT_NATIVE_APPLE_IMPLEMENTATION_VERSION = "4.0.22";
 export declare const REACT_NATIVE_APPLE_DEFAULT_ADAPTER_NATIVE_ID = "apple-corebluetooth-default-adapter";
 export declare const reactNativeAppleCompatibility: NativeCompatibilityOffer;
 export interface ReactNativeAppleBackendProviderOptions {

package/lib/typescript/commonjs/src/backends/winrt/winrt-provider.d.ts

@@ -3,7 +3,7 @@ import { type BackendCompatibilityOffer } from '../../backend-contract/primitive
 import { type WinRtAdapterRecord, type WinRtBoundary } from './winrt-boundary';
 export declare const WINRT_BACKEND_ID = "unified-ble:winrt";
 export declare const WINRT_PLATFORM_ID = "unified-ble:windows-winrt";
-export declare const WINRT_IMPLEMENTATION_VERSION = "4.0.19";
+export declare const WINRT_IMPLEMENTATION_VERSION = "4.0.22";
 export declare const winRtCompatibility: BackendCompatibilityOffer;
 export interface WinRtBackendProviderOptions {
     readonly boundaryFactory: () => WinRtBoundary;

package/lib/typescript/commonjs/src/implementation-version.d.ts

@@ -1,3 +1,3 @@
 /** The one production version stamped into every first-party backend identity. */
-export declare const UNIFIED_BLE_IMPLEMENTATION_VERSION = "4.0.19";
+export declare const UNIFIED_BLE_IMPLEMENTATION_VERSION = "4.0.22";
 //# sourceMappingURL=implementation-version.d.ts.map

package/lib/typescript/module/src/backends/bluez/bluez-backend-provider.d.ts

@@ -4,7 +4,7 @@ import { type BackendCompatibilityOffer } from '../../backend-contract/primitive
 import { type BluezBusKind, type BluezDbusBoundaryFactory } from './bluez-dbus-contract.js';
 export declare const BLUEZ_BACKEND_ID = "unified-ble:bluez-dbus";
 export declare const BLUEZ_PLATFORM_ID = "unified-ble:linux-bluez";
-export declare const BLUEZ_IMPLEMENTATION_VERSION = "4.0.19";
+export declare const BLUEZ_IMPLEMENTATION_VERSION = "4.0.22";
 export declare const bluezCompatibility: BackendCompatibilityOffer;
 export interface BluezBackendProviderOptions {
     readonly busKind: BluezBusKind;

package/lib/typescript/module/src/backends/corebluetooth/corebluetooth-identity.d.ts

@@ -1,7 +1,7 @@
 import { type FeatureRegistry } from '../../backend-contract/capabilities.js';
 export declare const COREBLUETOOTH_BACKEND_ID = "unified-ble:corebluetooth";
 export declare const COREBLUETOOTH_PLATFORM_ID = "unified-ble:macos-corebluetooth";
-export declare const COREBLUETOOTH_IMPLEMENTATION_VERSION = "4.0.19";
+export declare const COREBLUETOOTH_IMPLEMENTATION_VERSION = "4.0.22";
 /** Identity metadata for a direct-GATT boundary that shares this backend core. */
 export interface DirectGattBackendIdentityOptions {
     readonly registeredBackendId: string;

package/lib/typescript/module/src/backends/reactnative/react-native-android-provider.d.ts

@@ -9,7 +9,7 @@ import { ReactNativeAndroidProtocolBoundary } from '../../native-protocol/rn-and
 import { ReactNativeRestorationCoordinator, type ReactNativeRestorationActivation, type ReactNativeRestorationBackendProvider } from './react-native-restoration.js';
 export declare const REACT_NATIVE_ANDROID_BACKEND_ID = "unified-ble:react-native-android";
 export declare const REACT_NATIVE_ANDROID_PLATFORM_ID = "unified-ble:android-gatt";
-export declare const REACT_NATIVE_ANDROID_IMPLEMENTATION_VERSION = "4.0.19";
+export declare const REACT_NATIVE_ANDROID_IMPLEMENTATION_VERSION = "4.0.22";
 export declare const REACT_NATIVE_ANDROID_DEFAULT_ADAPTER_NATIVE_ID = "android-default-adapter";
 export declare const reactNativeAndroidCompatibility: NativeCompatibilityOffer;
 export interface ReactNativeAndroidBackendProviderOptions {

package/lib/typescript/module/src/backends/reactnative/react-native-apple-provider.d.ts

@@ -3,7 +3,7 @@ import type { Spec as NativeProtocolControl } from '../../NativeUnifiedBleProtoc
 import { type ReactNativeRestorationBackendProvider } from './react-native-restoration.js';
 export declare const REACT_NATIVE_APPLE_BACKEND_ID = "unified-ble:react-native-apple";
 export declare const REACT_NATIVE_APPLE_PLATFORM_ID = "unified-ble:apple-corebluetooth";
-export declare const REACT_NATIVE_APPLE_IMPLEMENTATION_VERSION = "4.0.19";
+export declare const REACT_NATIVE_APPLE_IMPLEMENTATION_VERSION = "4.0.22";
 export declare const REACT_NATIVE_APPLE_DEFAULT_ADAPTER_NATIVE_ID = "apple-corebluetooth-default-adapter";
 export declare const reactNativeAppleCompatibility: NativeCompatibilityOffer;
 export interface ReactNativeAppleBackendProviderOptions {

package/lib/typescript/module/src/backends/winrt/winrt-provider.d.ts

@@ -3,7 +3,7 @@ import { type BackendCompatibilityOffer } from '../../backend-contract/primitive
 import { type WinRtAdapterRecord, type WinRtBoundary } from './winrt-boundary.js';
 export declare const WINRT_BACKEND_ID = "unified-ble:winrt";
 export declare const WINRT_PLATFORM_ID = "unified-ble:windows-winrt";
-export declare const WINRT_IMPLEMENTATION_VERSION = "4.0.19";
+export declare const WINRT_IMPLEMENTATION_VERSION = "4.0.22";
 export declare const winRtCompatibility: BackendCompatibilityOffer;
 export interface WinRtBackendProviderOptions {
     readonly boundaryFactory: () => WinRtBoundary;

package/lib/typescript/module/src/implementation-version.d.ts

@@ -1,3 +1,3 @@
 /** The one production version stamped into every first-party backend identity. */
-export declare const UNIFIED_BLE_IMPLEMENTATION_VERSION = "4.0.19";
+export declare const UNIFIED_BLE_IMPLEMENTATION_VERSION = "4.0.22";
 //# sourceMappingURL=implementation-version.d.ts.map

package/native/PREBUILDS.json

@@ -1,6 +1,6 @@
 {
   "schemaVersion": 1,
-  "package": "unified-ble-manager@4.0.19",
+  "package": "unified-ble-manager@4.0.22",
   "nodeApiVersion": 8,
   "entries": [
     {
@@ -10,7 +10,7 @@
       "nodeApiVersion": 8,
       "path": "native/electron/corebluetooth/prebuilds/darwin-arm64/unified_ble_corebluetooth.node",
       "bytes": 332368,
-      "sha256": "61b75e5654408cdd18ac9697b620676b460a58f8c209fe8e3ea784f22ad715d5"
+      "sha256": "32005cc887bee75665ad0dd1ebf8ea39affaab593d41d53b65c7e05810185abd"
     },
     {
       "backend": "corebluetooth",
@@ -19,7 +19,7 @@
       "nodeApiVersion": 8,
       "path": "native/electron/corebluetooth/prebuilds/darwin-x64/unified_ble_corebluetooth.node",
       "bytes": 314872,
-      "sha256": "663ab35a6abfc38481d90c21f05f51e473675871c4abf89204785dfe8b810a72"
+      "sha256": "b57f1f75ea39424b7525560408f84f0fac67467073fd05e0606c44383a94bcf5"
     },
     {
       "backend": "winrt",
@@ -28,7 +28,7 @@
       "nodeApiVersion": 8,
       "path": "native/electron/winrt/prebuilds/win32-arm64/unified_ble_winrt.node",
       "bytes": 644608,
-      "sha256": "f0c87192e08ba429a069ea8d40bdc04926ae58d7f0212b8afd29de72c9a21773"
+      "sha256": "3dbd53397b3386dff78d77942ba0f83329c4126cec1fa4d8ff6c910daddef9ce"
     },
     {
       "backend": "winrt",
@@ -37,7 +37,7 @@
       "nodeApiVersion": 8,
       "path": "native/electron/winrt/prebuilds/win32-x64/unified_ble_winrt.node",
       "bytes": 614400,
-      "sha256": "2f3143d4e784d768fa603a01e68e3229fc8e84ee31d736d138e745b3cc4295c7"
+      "sha256": "0b37b8bdbd55ecce5edbd7b30615181aa8891951799a86c33557a1f7011563cb"
     }
   ]
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "unified-ble-manager",
-  "version": "4.0.19",
+  "version": "4.0.22",
   "description": "Unified Bluetooth Low Energy manager for React Native, Electron, Tauri, Web, and desktop",
   "packageManager": "pnpm@10.14.0",
   "main": "lib/commonjs/index.js",

package/src/implementation-version.ts

@@ -1,4 +1,4 @@
 // src/implementation-version.ts
 
 /** The one production version stamped into every first-party backend identity. */
-export const UNIFIED_BLE_IMPLEMENTATION_VERSION = '4.0.19'
+export const UNIFIED_BLE_IMPLEMENTATION_VERSION = '4.0.22'