unified-ble-manager 4.0.23 → 4.0.24

package/CHANGELOG.md

@@ -6,6 +6,21 @@ All notable changes to `unified-ble-manager` are documented here.
 
 No changes yet.
 
+## [4.0.24] - 2026-09-05
+
+### Fixes
+
+- Arbitrate an Android characteristic-write callback failure against an
+  already-in-flight disconnect callback. A provisional write status such as
+  133 is retained for a bounded 250 ms evidence window, allowing the
+  authoritative connection-state callback to report typed `connection.lost`
+  without relabeling an isolated status 133 as link loss.
+- Preserve the Android GATT operation and status for synchronous and
+  asynchronous characteristic-write failures that are not proven link loss.
+- Make exact and UUID-keyed pending-write cleanup identity-safe so stale
+  teardown and late callbacks cannot settle a replacement write or remove its
+  payload.
+
 ## [4.0.23] - 2026-09-05
 
 ### Fixes

package/MIGRATION_4.0.md

@@ -2,7 +2,7 @@
 
 # Migrating from react-native-ble-plx
 
-This source targets `4.0.23`. 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.24`. 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.23`. Install the exact version shown in the npm
+This source tree is versioned `4.0.24`. 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

@@ -82,8 +82,8 @@ 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.20` are immutable. The unpublished
-`v4.0.21` tag is also immutable after its cancelled workflow. `4.0.22` is immutable published history. `4.0.23` is the
-current train head.
+`v4.0.21` tag is also immutable after its cancelled workflow. `4.0.22` and
+`4.0.23` are immutable published history. `4.0.24` is the current train head.
 
 ```sh
 release_candidate=4.0.0-rc.N
@@ -111,6 +111,14 @@ 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.24
+
+Release `v4.0.24` only from the exact current `main` commit after its canonical
+CI succeeds. Verify `package.json` is `4.0.24`, the worktree is clean, and
+release-note extraction finds `## [4.0.24]`. Push a new annotated `v4.0.24`
+tag; never move an earlier immutable tag. Follow the required local validation,
+publish workflow, and registry verification below.
+
 ## Releasing 4.0.23
 
 Release `v4.0.23` only from the exact current `main` commit after its canonical
@@ -483,7 +491,7 @@ a green publish job and a package a consumer can actually install are not the
 same claim.
 
 ```sh
-version=4.0.23
+version=4.0.24
 
 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.23",
+      "bom-ref": "pkg:npm/unified-ble-manager@4.0.24",
       "name": "unified-ble-manager",
-      "version": "4.0.23",
+      "version": "4.0.24",
       "licenses": [
         {
           "expression": "Apache-2.0"
         }
       ],
-      "purl": "pkg:npm/unified-ble-manager@4.0.23"
+      "purl": "pkg:npm/unified-ble-manager@4.0.24"
     },
     "properties": [
       {
@@ -537,7 +537,7 @@
       "dependsOn": []
     },
     {
-      "ref": "pkg:npm/unified-ble-manager@4.0.23",
+      "ref": "pkg:npm/unified-ble-manager@4.0.24",
       "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.23"
+    "version": "4.0.24"
   },
   "source": {
     "method": "pnpm-lock production graph with installed-manifest license audit",

package/android/src/main/java/com/sfourdrinier/unifiedblemanager/protocol/UnifiedBleProtocolAndroidDispatcher.kt

@@ -409,7 +409,9 @@ class UnifiedBleProtocolAndroidDispatcher(
     ) { result ->
       result.fold(
         onSuccess = { emitSuccess(command, "write") },
-        onFailure = { error -> emitFailure(command, "writeFailed", error.message ?: "Android GATT write failed") }
+        onFailure = { error ->
+          emitGattOperationFailure(command, "writeFailed", error, "Android GATT write failed")
+        }
       )
     }
     radioOperationIds[operationKey(command)] = radioOperationId
@@ -880,8 +882,8 @@ class UnifiedBleProtocolAndroidDispatcher(
     androidGattStatus: Int? = null
   ) {
     // Claim before constructing or emitting the terminal. Link loss can race a
-    // native CCCD callback; a check followed by a later claim lets both paths
-    // publish a result for the same operation.
+    // native GATT operation callback; a check followed by a later claim lets
+    // both paths publish a result for the same operation.
     if (!claimExactPendingCommand(pendingCommands, operationKey(command), command)) return
     val errorFields = mutableMapOf<Int, ProtocolWireValue>(
         1 to ProtocolWireValue.StringValue(code),

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

@@ -49,6 +49,61 @@ internal data class OwnedRadioTeardownResult(
     get() = failures.isEmpty()
 }
 
+/** Identity-bearing owner for the legacy UUID-keyed characteristic-write path. */
+internal class AndroidPendingWriteOwner<Key>(
+  val deviceKeyUpper: String,
+  val attribute: Key,
+  val value: ByteArray,
+  val callback: (Result<ByteArray?>) -> Unit
+)
+
+/**
+ * Keeps replacement writes isolated when their legacy string key is reused.
+ * Teardown must remove the exact owner it observed, never a newer operation.
+ */
+internal class AndroidPendingWriteRegistry<Key> {
+  private val entries = ConcurrentHashMap<String, AndroidPendingWriteOwner<Key>>()
+
+  fun putIfAbsent(key: String, owner: AndroidPendingWriteOwner<Key>): Boolean =
+    entries.putIfAbsent(key, owner) == null
+
+  fun get(key: String): AndroidPendingWriteOwner<Key>? = entries[key]
+
+  fun remove(key: String, owner: AndroidPendingWriteOwner<Key>): Boolean =
+    entries.remove(key, owner)
+
+  /** Completes only the currently registered attribute, rejecting stale callbacks. */
+  fun complete(
+    key: String,
+    attribute: Key,
+    result: Result<ByteArray?>
+  ): Boolean {
+    val owner = entries[key] ?: return false
+    if (owner.attribute !== attribute) return false
+    if (!entries.remove(key, owner)) return false
+    owner.callback(result)
+    return true
+  }
+
+  fun remove(key: String): AndroidPendingWriteOwner<Key>? = entries.remove(key)
+
+  fun entriesForDevice(deviceKeyUpper: String): List<Pair<String, AndroidPendingWriteOwner<Key>>> =
+    entries.entries
+      .filter { entry -> entry.value.deviceKeyUpper == deviceKeyUpper }
+      .map { entry -> entry.key to entry.value }
+
+  fun clear() {
+    entries.clear()
+  }
+}
+
+/** Removes an exact-write payload only when it is still the observed payload. */
+internal fun <Key> removeAndroidWritePayloadIfSame(
+  values: ConcurrentHashMap<Key, ByteArray>,
+  key: Key,
+  expected: ByteArray?
+): Boolean = expected != null && values.remove(key, expected)
+
 /**
  * Tracks exact native notification registrations by GATT generation.
  *
@@ -112,7 +167,7 @@ internal class OwnedAndroidSubscriptionOwnership<K> {
 /**
  * Preserves the Android GATT callback status when an asynchronous operation
  * terminates. Status 19 means that the peer terminated the link; keeping that
- * distinction typed prevents a CCCD race from being flattened to a generic
+ * distinction typed prevents a GATT operation race from being flattened to a generic
  * platform failure before the later connection-state callback arrives.
  */
 internal class AndroidGattOperationFailure(
@@ -135,35 +190,49 @@ internal fun classifyAndroidNotificationRegistrationFailure(
 ): 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.
+ * Android may deliver an ordinary CCCD or characteristic-write callback
+ * immediately before authoritative connection-loss evidence for the same GATT
+ * generation. Keep only that provisional result pending long enough for the
+ * 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 fun shouldAwaitAndroidWriteDisconnectEvidence(failure: Throwable): Boolean =
+  failure is AndroidGattOperationFailure &&
+    failure.operation == "characteristic-write" &&
+    !failure.isLinkLoss
+
+private const val ANDROID_GATT_DISCONNECT_EVIDENCE_GRACE_MS = 250L
 
-internal class AndroidCccdTerminalArbiter<Key>(
+/**
+ * Holds an asynchronous GATT callback failure briefly so a connection-state
+ * callback already in flight can provide the authoritative terminal. The
+ * first failure is retained and each key can be claimed only once.
+ */
+internal class AndroidGattTerminalArbiter<Key>(
   private val schedule: (delayMs: Long, action: () -> Unit) -> Boolean,
   private val onFallback: (key: Key, failure: AndroidGattOperationFailure) -> Unit
 ) {
-  private val provisionalFailures = ConcurrentHashMap<Key, AndroidGattOperationFailure>()
+  private data class DeferredFailure(
+    val failure: AndroidGattOperationFailure
+  )
+
+  private val provisionalFailures = ConcurrentHashMap<Key, DeferredFailure>()
 
   fun defer(key: Key, failure: AndroidGattOperationFailure) {
-    if (provisionalFailures.putIfAbsent(key, failure) != null) return
+    val deferred = DeferredFailure(failure)
+    if (provisionalFailures.putIfAbsent(key, deferred) != null) return
     val fallback: () -> Unit = {
-      val retained = provisionalFailures.remove(key)
-      if (retained != null) onFallback(key, retained)
+      if (provisionalFailures.remove(key, deferred)) onFallback(key, deferred.failure)
     }
-    if (!schedule(ANDROID_CCCD_DISCONNECT_EVIDENCE_GRACE_MS, fallback)) fallback()
+    if (!schedule(ANDROID_GATT_DISCONNECT_EVIDENCE_GRACE_MS, fallback)) fallback()
   }
 
-  fun claim(key: Key): AndroidGattOperationFailure? = provisionalFailures.remove(key)
+  fun claim(key: Key): AndroidGattOperationFailure? = provisionalFailures.remove(key)?.failure
 
   fun isPending(key: Key): Boolean = provisionalFailures.containsKey(key)
 
@@ -172,6 +241,26 @@ internal class AndroidCccdTerminalArbiter<Key>(
   }
 }
 
+/**
+ * Applies the characteristic-write callback policy at the radio boundary.
+ * Returns true when the callback was deferred for lifecycle arbitration.
+ */
+internal fun <Key> AndroidGattTerminalArbiter<Key>.deferCharacteristicWriteFailure(
+  key: Key,
+  status: Int
+): Boolean {
+  val failure = classifyAndroidGattOperationFailure("characteristic-write", status)
+  if (!shouldAwaitAndroidWriteDisconnectEvidence(failure)) return false
+  defer(key, failure)
+  return true
+}
+
+/** Kept as a descriptive alias for existing CCCD callers and tests. */
+internal typealias AndroidCccdTerminalArbiter<Key> = AndroidGattTerminalArbiter<Key>
+
+/** Descriptive alias for characteristic-write terminal arbitration. */
+internal typealias AndroidWriteTerminalArbiter<Key> = AndroidGattTerminalArbiter<Key>
+
 /** Synchronous API rejection after local CCCD registration, before Android starts ATT work. */
 internal class AndroidCccdSubmissionFailure(
   val platformStatus: Int?
@@ -361,8 +450,8 @@ class OwnedAndroidGattRadio(private val context: Context) {
   private val pendingPhyRequests = ConcurrentHashMap<String, (Result<OwnedAndroidPhy?>) -> Unit>()
   private val pendingDesc = ConcurrentHashMap<String, (Result<Unit>) -> Unit>()
   private val pendingDescRead = ConcurrentHashMap<String, (Result<ByteArray?>) -> Unit>()
-  /** Stashed write payloads so API-33 callbacks need not read deprecated characteristic.value. */
-  private val pendingWriteValues = ConcurrentHashMap<String, ByteArray>()
+  /** Identity-bearing owners for the legacy UUID-keyed write callback path. */
+  private val pendingWriteRegistry = AndroidPendingWriteRegistry<BluetoothGattCharacteristic>()
   private val pendingBondPairs =
     ConcurrentHashMap<String, (String, OwnedAndroidSecurityState) -> Unit>()
 
@@ -404,6 +493,22 @@ class OwnedAndroidGattRadio(private val context: Context) {
       completeExactUnit(pending, Result.failure(failure))
     }
   )
+  private val exactWriteTerminalArbiter = AndroidWriteTerminalArbiter<BluetoothGattCharacteristic>(
+    schedule = { delayMs, action -> mainHandler.postDelayed(action, delayMs) },
+    onFallback = fallback@ { characteristic, failure ->
+      val observedPayload = exactWriteValues[characteristic]
+      val pending = exactWritePending.remove(characteristic) ?: return@fallback
+      removeAndroidWritePayloadIfSame(exactWriteValues, characteristic, observedPayload)
+      completeExactByte(pending, Result.failure(failure))
+    }
+  )
+  private val writeTerminalArbiter = AndroidWriteTerminalArbiter<String>(
+    schedule = { delayMs, action -> mainHandler.postDelayed(action, delayMs) },
+    onFallback = fallback@ { key, failure ->
+      val owner = pendingWriteRegistry.remove(key) ?: return@fallback
+      owner.callback(Result.failure(failure))
+    }
+  )
   private val exactDescriptorReadPending = ConcurrentHashMap<BluetoothGattDescriptor, ExactBytePending>()
   private val exactDescriptorWritePending = ConcurrentHashMap<BluetoothGattDescriptor, ExactUnitPending>()
   private val activeNativeSubscriptionOwnership =
@@ -1302,23 +1407,29 @@ class OwnedAndroidGattRadio(private val context: Context) {
         else BluetoothGattCharacteristic.WRITE_TYPE_NO_RESPONSE
       ch.writeType = writeType
       val key = pendingCharKey("write", deviceId, serviceUuid, charUuid)
-      // Stash payload for callback success (API 33 does not require ch.value).
-      pendingWriteValues[key] = value
-      pending[key] = { r ->
+      val owner = AndroidPendingWriteOwner(
+        deviceKeyUpper = deviceId.uppercase(),
+        attribute = ch,
+        value = value.copyOf()
+      ) { r ->
         if (!token.isPubliclySettled()) {
           onResult(r)
         }
         done()
       }
+      if (!pendingWriteRegistry.putIfAbsent(key, owner)) {
+        onResult(Result.failure(IllegalStateException("characteristic write is already pending")))
+        done()
+        return@enqueue
+      }
       if (Build.VERSION.SDK_INT >= 33) {
         val status = gatt.writeCharacteristic(ch, value, writeType)
         if (!acceptApi33WriteStatus(status)) {
-          pending.remove(key)
-          pendingWriteValues.remove(key)
-          onResult(
-            Result.failure(IllegalStateException("writeCharacteristic failed to start status=$status"))
-          )
-          done()
+          if (pendingWriteRegistry.remove(key, owner)) {
+            owner.callback(
+              Result.failure(classifyAndroidGattOperationFailure("characteristic-write", status))
+            )
+          }
         }
       } else {
         @Suppress("DEPRECATION")
@@ -1326,10 +1437,9 @@ class OwnedAndroidGattRadio(private val context: Context) {
         @Suppress("DEPRECATION")
         val started = gatt.writeCharacteristic(ch)
         if (!started) {
-          pending.remove(key)
-          pendingWriteValues.remove(key)
-          onResult(Result.failure(IllegalStateException("writeCharacteristic failed to start")))
-          done()
+          if (pendingWriteRegistry.remove(key, owner)) {
+            owner.callback(Result.failure(IllegalStateException("writeCharacteristic failed to start")))
+          }
         }
       }
     }
@@ -1416,11 +1526,12 @@ class OwnedAndroidGattRadio(private val context: Context) {
       if (Build.VERSION.SDK_INT >= 33) {
         val status = gatt.writeCharacteristic(characteristic, value, writeType)
         if (!acceptApi33WriteStatus(status)) {
-          exactWriteValues.remove(characteristic)
+          val observedPayload = exactWriteValues[characteristic]
           if (exactWritePending.remove(characteristic, pending)) {
+            removeAndroidWritePayloadIfSame(exactWriteValues, characteristic, observedPayload)
             completeExactByte(
               pending,
-              Result.failure(IllegalStateException("writeCharacteristic failed to start status=$status"))
+              Result.failure(classifyAndroidGattOperationFailure("characteristic-write", status))
             )
           }
         }
@@ -1430,8 +1541,9 @@ class OwnedAndroidGattRadio(private val context: Context) {
         @Suppress("DEPRECATION")
         val started = gatt.writeCharacteristic(characteristic)
         if (!started) {
-          exactWriteValues.remove(characteristic)
+          val observedPayload = exactWriteValues[characteristic]
           if (exactWritePending.remove(characteristic, pending)) {
+            removeAndroidWritePayloadIfSame(exactWriteValues, characteristic, observedPayload)
             completeExactByte(
               pending,
               Result.failure(IllegalStateException("writeCharacteristic failed to start"))
@@ -2166,12 +2278,14 @@ class OwnedAndroidGattRadio(private val context: Context) {
       pendingPhyRequests.clear()
       pendingDesc.clear()
       pendingDescRead.clear()
-      pendingWriteValues.clear()
+      pendingWriteRegistry.clear()
       exactReadPending.clear()
       exactWritePending.clear()
       exactWriteValues.clear()
       exactCccdPending.clear()
       exactCccdTerminalArbiter.clear()
+      exactWriteTerminalArbiter.clear()
+      writeTerminalArbiter.clear()
       exactDescriptorReadPending.clear()
       exactDescriptorWritePending.clear()
       activeNativeSubscriptionOwnership.clear()
@@ -2240,9 +2354,10 @@ class OwnedAndroidGattRadio(private val context: Context) {
     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.
+    // A peer link-loss callback can win the race with an asynchronous GATT
+    // callback. 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 {
@@ -2251,11 +2366,12 @@ class OwnedAndroidGattRadio(private val context: Context) {
     pending.keys
       .filter { key ->
         keyBelongsToDevice(key, "discover", deviceKeyUpper) ||
-          keyBelongsToDevice(key, "read", deviceKeyUpper) ||
-          keyBelongsToDevice(key, "write", deviceKeyUpper)
+          keyBelongsToDevice(key, "read", deviceKeyUpper)
       }
       .toList()
-      .forEach { key -> pending.remove(key)?.invoke(failBytes) }
+      .forEach { key ->
+        pending.remove(key)?.invoke(failBytes)
+      }
     pendingMtu.remove("mtu:$deviceKeyUpper")?.invoke(failInt)
     pendingRssi.remove("rssi:$deviceKeyUpper")?.invoke(failInt)
     pendingPhyReads.remove("phyRead:$deviceKeyUpper")?.invoke(
@@ -2277,10 +2393,14 @@ class OwnedAndroidGattRadio(private val context: Context) {
       .filter { key -> keyBelongsToDevice(key, "descRead", deviceKeyUpper) }
       .toList()
       .forEach { key -> pendingDescRead.remove(key)?.invoke(failBytes) }
-    pendingWriteValues.keys
-      .filter { key -> keyBelongsToDevice(key, "write", deviceKeyUpper) }
-      .toList()
-      .forEach { key -> pendingWriteValues.remove(key) }
+    // Remove only the owner observed by this teardown. A queued replacement
+    // may reuse the same UUID key while the old disconnect callback drains.
+    pendingWriteRegistry.entriesForDevice(deviceKeyUpper).forEach { (key, owner) ->
+      if (pendingWriteRegistry.remove(key, owner)) {
+        writeTerminalArbiter.claim(key)
+        owner.callback(failBytes)
+      }
+    }
     exactReadPending.entries
       .filter { it.value.deviceKeyUpper == deviceKeyUpper }
       .forEach { entry ->
@@ -2291,8 +2411,10 @@ class OwnedAndroidGattRadio(private val context: Context) {
     exactWritePending.entries
       .filter { it.value.deviceKeyUpper == deviceKeyUpper }
       .forEach { entry ->
-        exactWriteValues.remove(entry.key)
+        val observedPayload = exactWriteValues[entry.key]
         if (exactWritePending.remove(entry.key, entry.value)) {
+          removeAndroidWritePayloadIfSame(exactWriteValues, entry.key, observedPayload)
+          exactWriteTerminalArbiter.claim(entry.key)
           completeExactByte(entry.value, failBytes)
         }
       }
@@ -2826,34 +2948,48 @@ class OwnedAndroidGattRadio(private val context: Context) {
       status: Int
     ) {
       if (!isCurrentGattCallback(gatt)) return
-      exactWritePending.remove(characteristic)?.let { pending ->
+      // A provisional callback failure must remain pending while lifecycle
+      // evidence already in flight gets a chance to claim the terminal.
+      if (exactWriteTerminalArbiter.isPending(characteristic)) return
+      exactWritePending[characteristic]?.let { pending ->
+        val observedPayload = exactWriteValues[characteristic]
         if (!isCurrentGatt(pending.deviceKeyUpper, gatt, pending.gattGeneration)) {
-          exactWriteValues.remove(characteristic)
-          pending.done()
+          if (exactWritePending.remove(characteristic, pending)) {
+            exactWriteTerminalArbiter.claim(characteristic)
+            removeAndroidWritePayloadIfSame(exactWriteValues, characteristic, observedPayload)
+            pending.done()
+          }
           return@let
         }
-        val written = exactWriteValues.remove(characteristic)
         if (status == BluetoothGatt.GATT_SUCCESS) {
-          completeExactByte(pending, Result.success(written?.copyOf()))
+          if (exactWritePending.remove(characteristic, pending)) {
+            removeAndroidWritePayloadIfSame(exactWriteValues, characteristic, observedPayload)
+            completeExactByte(pending, Result.success(observedPayload?.copyOf()))
+          }
         } else {
-          completeExactByte(pending, Result.failure(IllegalStateException("write status=$status")))
+          if (exactWriteTerminalArbiter.deferCharacteristicWriteFailure(characteristic, status)) {
+            return@let
+          }
+          val failure = classifyAndroidGattOperationFailure("characteristic-write", status)
+          if (exactWritePending.remove(characteristic, pending)) {
+            removeAndroidWritePayloadIfSame(exactWriteValues, characteristic, observedPayload)
+            completeExactByte(pending, Result.failure(failure))
+          }
         }
         return
       }
       val id = gatt.device.address.uppercase()
       val key = charPendingKeyFromGatt("write", id, characteristic) ?: return
-      val stashed = pendingWriteValues.remove(key)
+      if (writeTerminalArbiter.isPending(key)) return
       if (status == BluetoothGatt.GATT_SUCCESS) {
-        // Prefer stashed payload (API 33 path never wrote ch.value).
-        val value =
-          stashed
-            ?: run {
-              @Suppress("DEPRECATION")
-              characteristic.value
-            }
-        pending.remove(key)?.invoke(Result.success(value))
+        // The owner retains the API-33 payload and rejects stale callbacks
+        // after a same-key replacement has taken ownership.
+        val owner = pendingWriteRegistry.get(key) ?: return
+        pendingWriteRegistry.complete(key, characteristic, Result.success(owner.value.copyOf()))
       } else {
-        pending.remove(key)?.invoke(Result.failure(IllegalStateException("write status=$status")))
+        if (writeTerminalArbiter.deferCharacteristicWriteFailure(key, status)) return
+        val failure = classifyAndroidGattOperationFailure("characteristic-write", status)
+        pendingWriteRegistry.complete(key, characteristic, Result.failure(failure))
       }
     }
 

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

@@ -3,6 +3,7 @@
 package com.sfourdrinier.unifiedblemanager.protocol
 
 import com.sfourdrinier.unifiedblemanager.protocol.generated.RecordKind
+import com.sfourdrinier.unifiedblemanager.radio.deferCharacteristicWriteFailure
 import com.sfourdrinier.unifiedblemanager.radio.nextUuidOccurrence
 import com.sfourdrinier.unifiedblemanager.radio.resolveUuidOccurrence
 import com.sfourdrinier.unifiedblemanager.radio.OwnedAndroidGattRadio
@@ -18,9 +19,14 @@ 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.AndroidWriteTerminalArbiter
+import com.sfourdrinier.unifiedblemanager.radio.AndroidPendingWriteOwner
+import com.sfourdrinier.unifiedblemanager.radio.AndroidPendingWriteRegistry
+import com.sfourdrinier.unifiedblemanager.radio.removeAndroidWritePayloadIfSame
 import com.sfourdrinier.unifiedblemanager.radio.OwnedRadioTeardownFailure
 import com.sfourdrinier.unifiedblemanager.radio.androidGattTerminalResult
 import com.sfourdrinier.unifiedblemanager.radio.shouldAwaitAndroidCccdDisconnectEvidence
+import com.sfourdrinier.unifiedblemanager.radio.shouldAwaitAndroidWriteDisconnectEvidence
 import org.junit.Assert.assertEquals
 import org.junit.Assert.assertArrayEquals
 import org.junit.Assert.assertFalse
@@ -132,6 +138,202 @@ class UnifiedBleProtocolAndroidDispatcherLifecycleTest {
     assertFalse(arbiter.isPending("cccd"))
   }
 
+  @Test
+  fun pendingWrite133ThenAuthoritativeDisconnectStatus8EmitsOneConnectionLostTerminal() {
+    val scheduled = mutableListOf<() -> Unit>()
+    val terminalKinds = mutableListOf<String>()
+    val arbiter = AndroidWriteTerminalArbiter<String>(
+      schedule = { _, action -> scheduled.add(action) },
+      onFallback = { _, failure ->
+        terminalKinds.add(androidGattOperationFailureCode(failure, "writeFailed"))
+      }
+    )
+    val writeFailure = classifyAndroidGattOperationFailure("characteristic-write", 133)
+
+    assertTrue(shouldAwaitAndroidWriteDisconnectEvidence(writeFailure))
+    assertFalse(
+      shouldAwaitAndroidWriteDisconnectEvidence(
+        classifyAndroidGattOperationFailure("characteristic-write", 19)
+      )
+    )
+    assertFalse(
+      shouldAwaitAndroidWriteDisconnectEvidence(
+        classifyAndroidGattOperationFailure("descriptor-write", 133)
+      )
+    )
+    assertTrue(arbiter.deferCharacteristicWriteFailure("write", writeFailure.gattStatus!!))
+
+    // The lifecycle callback is authoritative even though Android reports the
+    // transport timeout as status 8 rather than the write callback's 133.
+    val pendingCommands = mutableSetOf("write")
+    val disconnectStatus = 8
+    if (disconnectStatus == 8 && pendingCommands.remove("write")) {
+      terminalKinds.add("connectionLost")
+    }
+    val claimedFailure = arbiter.claim("write")
+    assertEquals("characteristic-write", claimedFailure?.operation)
+    assertEquals(133, claimedFailure?.gattStatus)
+    scheduled.single().invoke()
+
+    assertEquals(listOf("connectionLost"), terminalKinds)
+    val connection = ProtocolWireRecord(
+      RecordKind.CONNECTION_PATH,
+      mapOf(1 to ProtocolWireValue.RecordValue(ProtocolWireRecord(RecordKind.ATTACHMENT, emptyMap())))
+    )
+    val event = connectionLostEvent(1L, connection, disconnectStatus, 0L, 0L)
+    val error = event.requiredRecord(14)
+    assertEquals(ProtocolWireValue.StringValue("connectionLost"), event.fields[3])
+    assertEquals(ProtocolWireValue.SignedIntegerValue(8L), error.fields[8])
+  }
+
+  @Test
+  fun isolatedWrite133AfterGraceEmitsPlatformFailureRetainingOperationAndStatus() {
+    val scheduled = mutableListOf<() -> Unit>()
+    val terminalKinds = mutableListOf<String>()
+    var fallback: AndroidGattOperationFailure? = null
+    val arbiter = AndroidWriteTerminalArbiter<String>(
+      schedule = { _, action -> scheduled.add(action) },
+      onFallback = { _, failure ->
+        fallback = failure
+        terminalKinds.add(androidGattOperationFailureCode(failure, "writeFailed"))
+      }
+    )
+    val writeFailure = classifyAndroidGattOperationFailure("characteristic-write", 133)
+
+    assertTrue(arbiter.deferCharacteristicWriteFailure("write", writeFailure.gattStatus!!))
+    scheduled.single().invoke()
+
+    assertEquals(listOf("writeFailed"), terminalKinds)
+    assertTrue(fallback != null)
+    assertEquals("characteristic-write", fallback?.operation)
+    assertEquals(133, fallback?.gattStatus)
+    assertEquals(133, androidGattOperationFailureStatus(fallback!!))
+    assertEquals("writeFailed", androidGattOperationFailureCode(fallback!!, "writeFailed"))
+  }
+
+  @Test
+  fun writeTerminalArbiterPreventsDuplicateTerminalAfterDisconnectAndLateWriteCallback() {
+    val scheduled = mutableListOf<() -> Unit>()
+    val terminalKinds = mutableListOf<String>()
+    val arbiter = AndroidWriteTerminalArbiter<String>(
+      schedule = { _, action -> scheduled.add(action) },
+      onFallback = { _, failure ->
+        terminalKinds.add(androidGattOperationFailureCode(failure, "writeFailed"))
+      }
+    )
+    val writeFailure = classifyAndroidGattOperationFailure("characteristic-write", 133)
+
+    assertTrue(arbiter.deferCharacteristicWriteFailure("write", writeFailure.gattStatus!!))
+    assertTrue(arbiter.isPending("write"))
+    val claimedFailure = arbiter.claim("write")
+    assertEquals("characteristic-write", claimedFailure?.operation)
+    assertEquals(133, claimedFailure?.gattStatus)
+    assertTrue(!arbiter.isPending("write"))
+    scheduled.single().invoke()
+    // A late duplicate callback cannot reclaim the already-settled terminal.
+    assertTrue(arbiter.claim("write") == null)
+
+    val pendingCommands = mutableSetOf("write")
+    if (pendingCommands.remove("write")) terminalKinds.add("connectionLost")
+    if (pendingCommands.remove("write")) terminalKinds.add("writeFailed")
+    assertEquals(listOf("connectionLost"), terminalKinds)
+  }
+
+  @Test
+  fun pendingWriteReplacementIsIdentitySafeDuringOldDisconnectTeardownAndLateCallback() {
+    val registry = AndroidPendingWriteRegistry<String>()
+    val terminals = mutableListOf<String>()
+    val oldAttribute = "old-characteristic"
+    val replacementAttribute = "replacement-characteristic"
+    val oldOwner = AndroidPendingWriteOwner(
+      deviceKeyUpper = "AA:BB",
+      attribute = oldAttribute,
+      value = byteArrayOf(1)
+    ) { terminals.add("old") }
+    val replacementOwner = AndroidPendingWriteOwner(
+      deviceKeyUpper = "AA:BB",
+      attribute = replacementAttribute,
+      value = byteArrayOf(2)
+    ) { terminals.add("replacement") }
+
+    assertTrue(registry.putIfAbsent("write:key", oldOwner))
+    // Teardown observed the old owner, but a replacement acquired the key
+    // before the stale disconnect work finished.
+    assertTrue(registry.remove("write:key", oldOwner))
+    assertTrue(registry.putIfAbsent("write:key", replacementOwner))
+    assertFalse(registry.remove("write:key", oldOwner))
+    assertFalse(
+      registry.complete(
+        "write:key",
+        oldAttribute,
+        Result.success(byteArrayOf(9))
+      )
+    )
+    assertEquals(listOf<String>(), terminals)
+    assertTrue(registry.complete("write:key", replacementAttribute, Result.success(byteArrayOf(2))))
+    assertEquals(listOf("replacement"), terminals)
+  }
+
+  @Test
+  fun exactWriteTeardownOrRejectionCannotDeleteReplacementPayload() {
+    val values = ConcurrentHashMap<String, ByteArray>()
+    val oldPayload = byteArrayOf(1)
+    val replacementPayload = byteArrayOf(2)
+    values["write:key"] = oldPayload
+
+    // Capture the old payload before conditional owner removal, then let the
+    // replacement acquire the same key before stale cleanup runs.
+    val observed = values["write:key"]
+    values["write:key"] = replacementPayload
+    assertFalse(removeAndroidWritePayloadIfSame(values, "write:key", observed))
+    assertTrue(values["write:key"] === replacementPayload)
+  }
+
+  @Test
+  fun writeArbiterClearCannotLetPostedFallbackSettleReusedKey() {
+    val scheduled = mutableListOf<() -> Unit>()
+    val fallbacks = mutableListOf<AndroidGattOperationFailure>()
+    val arbiter = AndroidWriteTerminalArbiter<String>(
+      schedule = { _, action -> scheduled.add(action) },
+      onFallback = { _, failure -> fallbacks.add(failure) }
+    )
+    val first = classifyAndroidGattOperationFailure("characteristic-write", 133)
+    val replacement = classifyAndroidGattOperationFailure("characteristic-write", 257)
+
+    arbiter.defer("write", first)
+    arbiter.clear()
+    arbiter.defer("write", replacement)
+    scheduled[0].invoke()
+    assertTrue(arbiter.isPending("write"))
+    assertEquals(listOf<AndroidGattOperationFailure>(), fallbacks)
+    scheduled[1].invoke()
+    assertEquals(listOf(replacement), fallbacks)
+  }
+
+  @Test
+  fun characteristicWriteCallbacksAndDispatcherPreserveTypedFailurePolicy() {
+    val radio = readAndroidSource(
+      "android/src/main/java/com/sfourdrinier/unifiedblemanager/radio/OwnedAndroidGattRadio.kt"
+    )
+    val callback = radio.substring(
+      radio.indexOf("override fun onCharacteristicWrite"),
+      radio.indexOf("@Deprecated", radio.indexOf("override fun onCharacteristicWrite"))
+    )
+    assertEquals(2, Regex("deferCharacteristicWriteFailure\\(").findAll(callback).count())
+    assertTrue(callback.contains("pendingWriteRegistry.complete(key, characteristic"))
+    assertTrue(callback.contains("classifyAndroidGattOperationFailure(\"characteristic-write\", status)"))
+
+    val dispatcher = readAndroidSource(
+      "android/src/main/java/com/sfourdrinier/unifiedblemanager/protocol/UnifiedBleProtocolAndroidDispatcher.kt"
+    )
+    val write = dispatcher.substring(
+      dispatcher.indexOf("private fun write(command: ProtocolWireRecord)"),
+      dispatcher.indexOf("private fun writeDescriptor(command: ProtocolWireRecord)")
+    )
+    assertTrue(write.contains("emitGattOperationFailure(command, \"writeFailed\", error"))
+    assertFalse(write.contains("emitFailure(command, \"writeFailed\", error.message"))
+  }
+
   @Test
   fun dispatcherOnlyMapsTypedLinkLossToConnectionLost() {
     val linkLoss = classifyAndroidGattOperationFailure("cccd-write", 19)

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.23`. Tagged releases ship Node-API v8 prebuilds covering macOS and Windows `arm64`/`x64` for both Node and modern Electron.
+This source targets `4.0.24`. 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.23` source. Those options match
+Use the v2 plugin options in this `4.0.24` 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.23`; the npm registry and release
+This source targets `unified-ble-manager@4.0.24`; 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.23`; verify the published version in the npm registry.
+This source targets `4.0.24`; 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.23`, install that exact version and keep it in
+After the npm registry lists `4.0.24`, install that exact version and keep it in
 your lockfile while validating the native build:
 
 ```sh
-pnpm add unified-ble-manager@4.0.23
+pnpm add unified-ble-manager@4.0.24
 ```
 
 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.23`. 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.24`. 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.23`. 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.24`. 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.23`
+`unified-ble-manager@4.0.24`
 
 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.23';
+const UNIFIED_BLE_IMPLEMENTATION_VERSION = exports.UNIFIED_BLE_IMPLEMENTATION_VERSION = '4.0.24';
 //# 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.23';
+export const UNIFIED_BLE_IMPLEMENTATION_VERSION = '4.0.24';
 //# 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.23";
+export declare const BLUEZ_IMPLEMENTATION_VERSION = "4.0.24";
 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.23";
+export declare const COREBLUETOOTH_IMPLEMENTATION_VERSION = "4.0.24";
 /** 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.23";
+export declare const REACT_NATIVE_ANDROID_IMPLEMENTATION_VERSION = "4.0.24";
 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.23";
+export declare const REACT_NATIVE_APPLE_IMPLEMENTATION_VERSION = "4.0.24";
 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.23";
+export declare const WINRT_IMPLEMENTATION_VERSION = "4.0.24";
 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.23";
+export declare const UNIFIED_BLE_IMPLEMENTATION_VERSION = "4.0.24";
 //# 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.23";
+export declare const BLUEZ_IMPLEMENTATION_VERSION = "4.0.24";
 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.23";
+export declare const COREBLUETOOTH_IMPLEMENTATION_VERSION = "4.0.24";
 /** 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.23";
+export declare const REACT_NATIVE_ANDROID_IMPLEMENTATION_VERSION = "4.0.24";
 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.23";
+export declare const REACT_NATIVE_APPLE_IMPLEMENTATION_VERSION = "4.0.24";
 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.23";
+export declare const WINRT_IMPLEMENTATION_VERSION = "4.0.24";
 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.23";
+export declare const UNIFIED_BLE_IMPLEMENTATION_VERSION = "4.0.24";
 //# sourceMappingURL=implementation-version.d.ts.map

package/native/PREBUILDS.json

@@ -1,6 +1,6 @@
 {
   "schemaVersion": 1,
-  "package": "unified-ble-manager@4.0.23",
+  "package": "unified-ble-manager@4.0.24",
   "nodeApiVersion": 8,
   "entries": [
     {
@@ -10,7 +10,7 @@
       "nodeApiVersion": 8,
       "path": "native/electron/corebluetooth/prebuilds/darwin-arm64/unified_ble_corebluetooth.node",
       "bytes": 332368,
-      "sha256": "f7e726489d009b28133cef3d64c50cc547fa8aa71f9ae62f9318c3d63d490062"
+      "sha256": "5167159b256e1c76ffc2e4080f124785cebfe3e598451ac0ece0eec74cc97d90"
     },
     {
       "backend": "corebluetooth",
@@ -19,7 +19,7 @@
       "nodeApiVersion": 8,
       "path": "native/electron/corebluetooth/prebuilds/darwin-x64/unified_ble_corebluetooth.node",
       "bytes": 314872,
-      "sha256": "9862add5b521a780ac2db6473a2d8853a4e313049d8dc1e61450324f211f2135"
+      "sha256": "9deda9a0f8c4e6f07e688fdbeb5b6b631773863dc8b4de4c5bfaae8d4aaa3c9c"
     },
     {
       "backend": "winrt",
@@ -28,7 +28,7 @@
       "nodeApiVersion": 8,
       "path": "native/electron/winrt/prebuilds/win32-arm64/unified_ble_winrt.node",
       "bytes": 644608,
-      "sha256": "678516156c65ae3c584a517219dcedbadd313d119dc5922de2bd6b952ed5faaa"
+      "sha256": "474be5c5179de1eff20f87f88756f4d115412570483a51d78d66605a0f05292d"
     },
     {
       "backend": "winrt",
@@ -37,7 +37,7 @@
       "nodeApiVersion": 8,
       "path": "native/electron/winrt/prebuilds/win32-x64/unified_ble_winrt.node",
       "bytes": 614400,
-      "sha256": "8adb582faa716666ca75c77b58b01df036daa7ba28f095620dd657dbcdb30f5f"
+      "sha256": "48d3be097c0faa66ef6cdc53b8fb7b6543e5d71cfa327aaa07b358d2472e3383"
     }
   ]
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "unified-ble-manager",
-  "version": "4.0.23",
+  "version": "4.0.24",
   "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.23'
+export const UNIFIED_BLE_IMPLEMENTATION_VERSION = '4.0.24'