@react-native-firebase/storage 26.3.3 → 27.0.0

package/CHANGELOG.md

@@ -3,6 +3,27 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [27.0.0](https://github.com/invertase/react-native-firebase/compare/v26.4.0...v27.0.0) (2026-10-19)
+
+### ⚠ BREAKING CHANGES
+
+- **app, sdk:** bump Firebase Android 35, Apple 13, and JS 13
+
+### Features
+
+- **app, sdk:** bump Firebase Android 35, Apple 13, and JS 13 ([0ca03d1](https://github.com/invertase/react-native-firebase/commit/0ca03d11b0c271fb37cfbee8a0c3074a21969f0b))
+
+### Bug Fixes
+
+- **app, storage:** link Photos framework on tvOS ([56f5c1f](https://github.com/invertase/react-native-firebase/commit/56f5c1fcf83bc89d8cd80f019696e13bc96578dd))
+- **app,database:** resolve platform native module when bundlers apply package exports ([959d91f](https://github.com/invertase/react-native-firebase/commit/959d91fc79d7155d1d9a08e1f836789e6e6d6156))
+
+## [26.4.0](https://github.com/invertase/react-native-firebase/compare/v26.3.3...v26.4.0) (2026-09-05)
+
+### Bug Fixes
+
+- **storage:** use RNFBHandleMap for pending tasks ([acf77f1](https://github.com/invertase/react-native-firebase/commit/acf77f1ff1680f1ce9c65f72cf0056df7b998aa5))
+
 ## [26.3.3](https://github.com/invertase/react-native-firebase/compare/v26.3.2...v26.3.3) (2026-09-01)
 
 ### Bug Fixes

package/RNFBStorage.podspec

@@ -28,18 +28,23 @@ Pod::Spec.new do |s|
   s.ios.deployment_target = firebase_ios_target
   s.macos.deployment_target = firebase_macos_target
   s.tvos.deployment_target = firebase_tvos_target
-  s.source_files        = 'ios/**/*.{h,m,mm,cpp}'
+  s.swift_version       = '5.10'
+  s.source_files        = 'ios/**/*.{h,m,mm,cpp,swift}'
   s.private_header_files = [
     'ios/RNFBStorage/*.h',
     'ios/generated/**/*.h',
   ]
-  s.exclude_files       = 'ios/generated/RCTThirdPartyComponentsProvider.*', 'ios/generated/RCTAppDependencyProvider.*', 'ios/generated/RCTModuleProviders.*', 'ios/generated/RCTModulesConformingToProtocolsProvider.*', 'ios/generated/RCTUnstableModulesRequiringMainQueueSetupProvider.*'
+  # CocoaPods FileList uses FNM_PATHNAME: `ios/*UnitTests/**` does not match nested
+  # paths like `ios/RNFBStorageUnitTests/HostStubs/**` (those would compile into the pod).
+  s.exclude_files       = 'ios/generated/RCTThirdPartyComponentsProvider.*', 'ios/generated/RCTAppDependencyProvider.*', 'ios/generated/RCTModuleProviders.*', 'ios/generated/RCTModulesConformingToProtocolsProvider.*', 'ios/generated/RCTUnstableModulesRequiringMainQueueSetupProvider.*', 'ios/*UnitTests/**/*'
 
   # Must be set before install_modules_dependencies so RN can append use_frameworks
   # HEADER_SEARCH_PATHS (React-debug etc.). Assigning after overwrites those paths
   # and breaks from-source builds: react/timing/primitives.h → react/debug/flags.h.
+  # DEFINES_MODULE is required for the generated RNFBStorage-Swift.h interface.
   s.pod_target_xcconfig = {
     'HEADER_SEARCH_PATHS' => '"$(PODS_TARGET_SRCROOT)/ios/generated/RNFBStorageTurboModules" "$(PODS_TARGET_SRCROOT)/ios/generated"',
+    "DEFINES_MODULE" => "YES",
     "CLANG_ALLOW_NON_MODULAR_INCLUDES_IN_FRAMEWORK_MODULES" => "YES",
   }
 
@@ -61,10 +66,10 @@ Pod::Spec.new do |s|
 
   # RNFBStorageCommon.m uses PHAsset/PHAssetResource (Photos.framework) for local
   # asset uploads. See RNFBApp.podspec for why this must be declared explicitly
-  # rather than relying on Clang autolinking. iOS/macOS only -- PhotoKit doesn't
-  # exist on tvOS.
+  # rather than relying on Clang autolinking. PhotoKit is available on tvOS 10+.
   s.ios.frameworks = 'Photos'
   s.osx.frameworks = 'Photos'
+  s.tvos.frameworks = 'Photos'
 
   if defined?($RNFirebaseAsStaticFramework)
     Pod::UI.puts "#{s.name}: Using overridden static_framework value of '#{$RNFirebaseAsStaticFramework}'"

package/android/build.gradle

@@ -13,6 +13,7 @@ buildscript {
 
     dependencies {
       classpath("com.android.tools.build:gradle:8.4.0")
+      classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:${project.findProperty('kotlinVersion') ?: '2.4.0'}")
     }
   }
 }
@@ -21,6 +22,8 @@ plugins {
   id "io.invertase.gradle.build" version "1.5"
 }
 
+apply plugin: "org.jetbrains.kotlin.android"
+
 def appProject
 if (findProject(':@react-native-firebase_app')) {
   appProject = project(':@react-native-firebase_app')
@@ -93,6 +96,9 @@ dependencies {
   api appProject
   implementation platform("com.google.firebase:firebase-bom:${ReactNative.ext.getVersion("firebase", "bom")}")
   implementation "com.google.firebase:firebase-storage"
+
+  testImplementation "junit:junit:4.13.2"
+  testImplementation "org.mockito:mockito-core:5.14.2"
 }
 
 ReactNative.shared.applyPackageVersion()

package/android/src/main/java/io/invertase/firebase/storage/NativeRNFBTurboStorage.java

@@ -56,7 +56,7 @@ public class NativeRNFBTurboStorage extends NativeRNFBTurboStorageSpec {
 
   @Override
   public void invalidate() {
-    ReactNativeFirebaseStorageTask.destroyAllTasks();
+    ReactNativeFirebaseStorageTask.PENDING_TASKS.takeAllAndCancel();
     super.invalidate();
   }
 
@@ -274,6 +274,10 @@ public class NativeRNFBTurboStorage extends NativeRNFBTurboStorageSpec {
       ReactNativeFirebaseStorageDownloadTask storageTask =
           new ReactNativeFirebaseStorageDownloadTask((int) taskId, reference, appName);
       storageTask.begin(getTransactionalExecutor(), localFilePath);
+      if (storageTask.hasStorageTask() && !storageTask.registerPending()) {
+        rejectPromiseWithCodeAndMessage(promise, "internal", "Handle id already registered");
+        return;
+      }
       storageTask.addOnCompleteListener(getTransactionalExecutor(), promise);
     } catch (Exception e) {
       promiseRejectStorageException(promise, e);
@@ -294,6 +298,10 @@ public class NativeRNFBTurboStorage extends NativeRNFBTurboStorageSpec {
       ReactNativeFirebaseStorageUploadTask storageTask =
           new ReactNativeFirebaseStorageUploadTask((int) taskId, reference, appName);
       storageTask.begin(getTransactionalExecutor(), string, format, metadataMap);
+      if (!storageTask.registerPending()) {
+        rejectPromiseWithCodeAndMessage(promise, "internal", "Handle id already registered");
+        return;
+      }
       storageTask.addOnCompleteListener(getTransactionalExecutor(), promise);
     } catch (Exception e) {
       promiseRejectStorageException(promise, e);
@@ -313,6 +321,10 @@ public class NativeRNFBTurboStorage extends NativeRNFBTurboStorageSpec {
       ReactNativeFirebaseStorageUploadTask storageTask =
           new ReactNativeFirebaseStorageUploadTask((int) taskId, reference, appName);
       storageTask.begin(getTransactionalExecutor(), localFilePath, metadata);
+      if (!storageTask.registerPending()) {
+        rejectPromiseWithCodeAndMessage(promise, "internal", "Handle id already registered");
+        return;
+      }
       storageTask.addOnCompleteListener(getTransactionalExecutor(), promise);
     } catch (Exception e) {
       promiseRejectStorageException(promise, e);
@@ -321,13 +333,21 @@ public class NativeRNFBTurboStorage extends NativeRNFBTurboStorageSpec {
 
   @Override
   public boolean setTaskStatus(String appName, double taskId, double status) {
+    RNFBStorageTaskRegistry tasks = ReactNativeFirebaseStorageTask.PENDING_TASKS;
+    int id = (int) taskId;
     switch ((int) status) {
       case 0:
-        return ReactNativeFirebaseStorageTask.pauseTaskById((int) taskId);
+        {
+          StoragePendingHandle handle = tasks.get(id);
+          return handle != null && handle.pause();
+        }
       case 1:
-        return ReactNativeFirebaseStorageTask.resumeTaskById((int) taskId);
+        {
+          StoragePendingHandle handle = tasks.get(id);
+          return handle != null && handle.resume();
+        }
       case 2:
-        return ReactNativeFirebaseStorageTask.cancelTaskById((int) taskId);
+        return tasks.takeAndCancel(id);
       default:
         return false;
     }

package/android/src/main/java/io/invertase/firebase/storage/RNFBStorageTaskRegistry.kt

@@ -0,0 +1,88 @@
+package io.invertase.firebase.storage
+
+/*
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+import io.invertase.firebase.common.RNFBHandleCollisionException
+import io.invertase.firebase.common.RNFBHandleMap
+import java.util.function.Predicate
+
+/**
+ * Pending upload/download task map. Unique [put]; callers [take] or [takeAllAndCancel] then cancel
+ * outside the HandleMap lock.
+ */
+internal class RNFBStorageTaskRegistry {
+  private val map = RNFBHandleMap<Int, StoragePendingHandle?>()
+
+  @Throws(RNFBHandleCollisionException::class)
+  fun put(
+    taskId: Int,
+    handle: StoragePendingHandle?,
+  ) {
+    map.put(taskId, handle)
+  }
+
+  /**
+   * Unique put. On collision, `cancel()` the incoming handle and leave the existing mapping.
+   *
+   * @return true if stored
+   */
+  fun putOrDiscard(
+    taskId: Int,
+    handle: StoragePendingHandle?,
+  ): Boolean {
+    if (map.putIfAbsent(taskId, handle)) {
+      return true
+    }
+    handle?.cancel()
+    return false
+  }
+
+  fun get(taskId: Int): StoragePendingHandle? = map.get(taskId)
+
+  fun take(taskId: Int): StoragePendingHandle? = map.take(taskId)
+
+  fun takeIf(
+    taskId: Int,
+    shouldTake: Predicate<StoragePendingHandle?>,
+  ): StoragePendingHandle? = map.takeIf(taskId, shouldTake)
+
+  /**
+   * Cancel outside the HandleMap lock; remove the mapping only when cancel succeeds. Returns `false`
+   * when no mapping existed or cancel failed. Trailing unregister is identity-gated so a
+   * replacement put after `cancel()` (e.g. production `destroyTask`) is not stolen.
+   *
+   * Shape: get → cancel → identity takeIf on success (keep mapping when cancel returns false). iOS
+   * registry mirrors get → cancel → identity takeIf, but FIRStorage cancel is void so there is no
+   * keep-on-false path — see `RNFBStorageTaskRegistry.takeAndCancel:` / helper `setTaskStatus`.
+   */
+  fun takeAndCancel(taskId: Int): Boolean {
+    val handle = map.get(taskId) ?: return false
+    val cancelled = handle.cancel()
+    if (cancelled) {
+      map.takeIf(taskId) { h -> h === handle }
+    }
+    return cancelled
+  }
+
+  fun takeAllAndCancel() {
+    val remaining = map.takeAll()
+    for (handle in remaining) {
+      handle?.cancel()
+    }
+  }
+}

package/android/src/main/java/io/invertase/firebase/storage/ReactNativeFirebaseStorageTask.java

@@ -23,14 +23,13 @@ import static io.invertase.firebase.storage.ReactNativeFirebaseStorageCommon.STA
 import static io.invertase.firebase.storage.ReactNativeFirebaseStorageCommon.getExceptionCodeAndMessage;
 
 import android.util.Log;
-import android.util.SparseArray;
 import com.facebook.react.bridge.Arguments;
 import com.facebook.react.bridge.WritableMap;
 import com.google.firebase.storage.StorageReference;
 import com.google.firebase.storage.StorageTask;
 import javax.annotation.Nullable;
 
-class ReactNativeFirebaseStorageTask {
+class ReactNativeFirebaseStorageTask implements StoragePendingHandle {
   static final String KEY_STATE = "state";
   static final String KEY_META_DATA = "metadata";
   static final String KEY_TOTAL_BYTES = "totalBytes";
@@ -39,8 +38,7 @@ class ReactNativeFirebaseStorageTask {
   private static final String KEY_CODE = "code";
   private static final String KEY_MESSAGE = "message";
   private static final String KEY_NATIVE_ERROR_MESSAGE = "nativeErrorMessage";
-  private static final SparseArray<ReactNativeFirebaseStorageTask> PENDING_TASKS =
-      new SparseArray<>();
+  static final RNFBStorageTaskRegistry PENDING_TASKS = new RNFBStorageTaskRegistry();
   private static final String TAG = "RNFBStorageTask";
   int taskId;
   String appName;
@@ -51,43 +49,15 @@ class ReactNativeFirebaseStorageTask {
     this.taskId = taskId;
     this.storageReference = storageReference;
     this.appName = appName;
-    PENDING_TASKS.put(taskId, this);
   }
 
-  static boolean pauseTaskById(int taskId) {
-    ReactNativeFirebaseStorageTask reactNativeFirebaseStorageTask = PENDING_TASKS.get(taskId);
-    if (reactNativeFirebaseStorageTask != null) {
-      return reactNativeFirebaseStorageTask.pause();
-    }
-
-    return false;
-  }
-
-  static boolean resumeTaskById(int taskId) {
-    ReactNativeFirebaseStorageTask reactNativeFirebaseStorageTask = PENDING_TASKS.get(taskId);
-    if (reactNativeFirebaseStorageTask != null) {
-      return reactNativeFirebaseStorageTask.resume();
-    }
-
-    return false;
+  /** Register after the native {@link StorageTask} exists; collision cancels this handle. */
+  boolean registerPending() {
+    return PENDING_TASKS.putOrDiscard(taskId, this);
   }
 
-  static boolean cancelTaskById(int taskId) {
-    ReactNativeFirebaseStorageTask reactNativeFirebaseStorageTask = PENDING_TASKS.get(taskId);
-    if (reactNativeFirebaseStorageTask != null) {
-      return reactNativeFirebaseStorageTask.cancel();
-    }
-
-    return false;
-  }
-
-  static void destroyAllTasks() {
-    for (int i = 0, size = PENDING_TASKS.size(); i < size; i++) {
-      int key = PENDING_TASKS.keyAt(i);
-      ReactNativeFirebaseStorageTask reactNativeFirebaseStorageTask = PENDING_TASKS.get(key);
-      reactNativeFirebaseStorageTask.cancel();
-    }
-    PENDING_TASKS.clear();
+  boolean hasStorageTask() {
+    return storageTask != null;
   }
 
   static WritableMap buildCancelledSnapshotMap(WritableMap snapshot) {
@@ -108,39 +78,48 @@ class ReactNativeFirebaseStorageTask {
     return taskMap;
   }
 
-  private boolean pause() {
+  @Override
+  public boolean pause() {
     Log.d(TAG, "pausing task for " + storageReference.toString());
 
-    if (!storageTask.isPaused() && storageTask.isInProgress()) {
+    if (storageTask != null && !storageTask.isPaused() && storageTask.isInProgress()) {
       return storageTask.pause();
     }
 
     return false;
   }
 
-  private boolean resume() {
+  @Override
+  public boolean resume() {
     Log.d(TAG, "resuming task for " + storageReference.toString());
 
-    if (storageTask.isPaused()) {
+    if (storageTask != null && storageTask.isPaused()) {
       return storageTask.resume();
     }
 
     return false;
   }
 
-  private boolean cancel() {
+  @Override
+  public boolean cancel() {
     Log.d(TAG, "cancelling task for " + storageReference.toString());
 
-    if (!storageTask.isCanceled() && storageTask.isInProgress()) {
-      destroyTask();
-      return storageTask.cancel();
+    if (storageTask != null
+        && !storageTask.isCanceled()
+        && !storageTask.isComplete()
+        && (storageTask.isInProgress() || storageTask.isPaused())) {
+      if (storageTask.cancel()) {
+        destroyTask();
+        return true;
+      }
     }
 
     return false;
   }
 
   void destroyTask() {
-    PENDING_TASKS.remove(taskId);
+    // Identity-gated: cancel of a discarded collision must not evict another handle at taskId.
+    PENDING_TASKS.takeIf(taskId, handle -> handle == this);
 
     Log.d(TAG, "destroyed completed task for " + storageReference.toString());
   }

package/android/src/main/java/io/invertase/firebase/storage/StoragePendingHandle.java

@@ -0,0 +1,30 @@
+package io.invertase.firebase.storage;
+
+/*
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/**
+ * Pause / resume / cancel surface stored in {@link RNFBStorageTaskRegistry}. Invoked after {@code
+ * get}/{@code take}/{@code takeAll}, never under the HandleMap lock.
+ */
+interface StoragePendingHandle {
+  boolean pause();
+
+  boolean resume();
+
+  boolean cancel();
+}

package/android/src/test/java/io/invertase/firebase/storage/RNFBStorageTaskRegistryTest.java

@@ -0,0 +1,237 @@
+package io.invertase.firebase.storage;
+
+/*
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import io.invertase.firebase.common.RNFBHandleCollisionException;
+import org.junit.Test;
+
+public class RNFBStorageTaskRegistryTest {
+
+  private static final class FakeHandle implements StoragePendingHandle {
+    int pauseCount;
+    int resumeCount;
+    int cancelCount;
+    boolean pauseResult = true;
+    boolean resumeResult = true;
+    boolean cancelResult = true;
+    Runnable onCancel;
+
+    @Override
+    public boolean pause() {
+      pauseCount++;
+      return pauseResult;
+    }
+
+    @Override
+    public boolean resume() {
+      resumeCount++;
+      return resumeResult;
+    }
+
+    @Override
+    public boolean cancel() {
+      cancelCount++;
+      if (onCancel != null) {
+        onCancel.run();
+      }
+      return cancelResult;
+    }
+  }
+
+  @Test
+  public void putGetTake_happyPath() throws Exception {
+    RNFBStorageTaskRegistry registry = new RNFBStorageTaskRegistry();
+    FakeHandle handle = new FakeHandle();
+    registry.put(1, handle);
+    assertSame(handle, registry.get(1));
+    assertSame(handle, registry.take(1));
+    assertNull(registry.get(1));
+    assertEquals(0, handle.cancelCount);
+  }
+
+  @Test
+  public void put_occupiedId_throwsCollision() throws Exception {
+    RNFBStorageTaskRegistry registry = new RNFBStorageTaskRegistry();
+    FakeHandle first = new FakeHandle();
+    registry.put(1, first);
+    try {
+      registry.put(1, new FakeHandle());
+      fail("expected RNFBHandleCollisionException");
+    } catch (RNFBHandleCollisionException e) {
+      assertTrue(e.getMessage().contains("1"));
+      assertSame(first, registry.get(1));
+    }
+  }
+
+  @Test
+  public void putOrDiscard_collision_cancelsIncoming() throws Exception {
+    RNFBStorageTaskRegistry registry = new RNFBStorageTaskRegistry();
+    FakeHandle first = new FakeHandle();
+    FakeHandle duplicate = new FakeHandle();
+    registry.put(2, first);
+    assertFalse(registry.putOrDiscard(2, duplicate));
+    assertEquals(1, duplicate.cancelCount);
+    assertEquals(0, first.cancelCount);
+    assertSame(first, registry.get(2));
+  }
+
+  @Test
+  public void putOrDiscard_storesWhenFree() {
+    RNFBStorageTaskRegistry registry = new RNFBStorageTaskRegistry();
+    FakeHandle handle = new FakeHandle();
+    assertTrue(registry.putOrDiscard(3, handle));
+    assertSame(handle, registry.get(3));
+    assertEquals(0, handle.cancelCount);
+  }
+
+  @Test
+  public void putOrDiscard_collision_nullIncoming_isNoOp() throws Exception {
+    RNFBStorageTaskRegistry registry = new RNFBStorageTaskRegistry();
+    FakeHandle first = new FakeHandle();
+    registry.put(4, first);
+    assertFalse(registry.putOrDiscard(4, null));
+    assertSame(first, registry.get(4));
+  }
+
+  @Test
+  public void takeIf_whenPredicateTrue_removesAndReturns() throws Exception {
+    RNFBStorageTaskRegistry registry = new RNFBStorageTaskRegistry();
+    FakeHandle handle = new FakeHandle();
+    registry.put(8, handle);
+    assertSame(handle, registry.takeIf(8, h -> h == handle));
+    assertNull(registry.get(8));
+  }
+
+  @Test
+  public void takeIf_whenPredicateFalse_leavesMapping() throws Exception {
+    RNFBStorageTaskRegistry registry = new RNFBStorageTaskRegistry();
+    FakeHandle handle = new FakeHandle();
+    FakeHandle other = new FakeHandle();
+    registry.put(9, handle);
+    assertNull(registry.takeIf(9, h -> h == other));
+    assertSame(handle, registry.get(9));
+  }
+
+  @Test
+  public void takeIf_whenMissing_returnsNull() {
+    RNFBStorageTaskRegistry registry = new RNFBStorageTaskRegistry();
+    assertNull(registry.takeIf(99, h -> true));
+  }
+
+  @Test
+  public void takeAndCancel_cancelsAfterTake() throws Exception {
+    RNFBStorageTaskRegistry registry = new RNFBStorageTaskRegistry();
+    FakeHandle handle = new FakeHandle();
+    registry.put(5, handle);
+    assertTrue(registry.takeAndCancel(5));
+    assertEquals(1, handle.cancelCount);
+    assertNull(registry.get(5));
+  }
+
+  @Test
+  public void takeAndCancel_missingKey_isNoOp() {
+    RNFBStorageTaskRegistry registry = new RNFBStorageTaskRegistry();
+    assertFalse(registry.takeAndCancel(99));
+    assertNull(registry.get(99));
+  }
+
+  @Test
+  public void takeAndCancel_whenCancelReturnsFalse_keepsMapping() throws Exception {
+    RNFBStorageTaskRegistry registry = new RNFBStorageTaskRegistry();
+    FakeHandle handle = new FakeHandle();
+    handle.cancelResult = false;
+    registry.put(6, handle);
+    assertFalse(registry.takeAndCancel(6));
+    assertEquals(1, handle.cancelCount);
+    assertSame(handle, registry.get(6));
+  }
+
+  /**
+   * Regression: production cancel may destroyTask (clear A) then a new put B can land at the same
+   * id before takeAndCancel's trailing unregister. Trailing take must be identity-gated so B stays.
+   */
+  @Test
+  public void takeAndCancel_replacementDuringCancel_leavesReplacement() throws Exception {
+    RNFBStorageTaskRegistry registry = new RNFBStorageTaskRegistry();
+    FakeHandle replacement = new FakeHandle();
+    FakeHandle original = new FakeHandle();
+    original.onCancel =
+        () -> {
+          // Simulate destroyTask clearing this handle, then a new put at the same id.
+          assertSame(original, registry.take(9));
+          try {
+            registry.put(9, replacement);
+          } catch (RNFBHandleCollisionException e) {
+            fail(e.getMessage());
+          }
+        };
+    registry.put(9, original);
+    assertTrue(registry.takeAndCancel(9));
+    assertEquals(1, original.cancelCount);
+    assertSame(replacement, registry.get(9));
+    assertEquals(0, replacement.cancelCount);
+  }
+
+  @Test
+  public void takeAllAndCancel_cancelsSnapshotAndLeavesEmpty() throws Exception {
+    RNFBStorageTaskRegistry registry = new RNFBStorageTaskRegistry();
+    FakeHandle a = new FakeHandle();
+    FakeHandle b = new FakeHandle();
+    registry.put(1, a);
+    registry.put(2, b);
+    registry.takeAllAndCancel();
+    assertEquals(1, a.cancelCount);
+    assertEquals(1, b.cancelCount);
+    assertNull(registry.get(1));
+    assertNull(registry.get(2));
+  }
+
+  @Test
+  public void takeAllAndCancel_empty_isNoOp() {
+    RNFBStorageTaskRegistry registry = new RNFBStorageTaskRegistry();
+    registry.takeAllAndCancel();
+    assertNull(registry.get(1));
+  }
+
+  @Test
+  public void takeAllAndCancel_nullHandle_isNoOp() throws Exception {
+    RNFBStorageTaskRegistry registry = new RNFBStorageTaskRegistry();
+    registry.put(6, null);
+    registry.takeAllAndCancel();
+    assertNull(registry.get(6));
+  }
+
+  @Test
+  public void put_afterTake_allowsReuse() throws Exception {
+    RNFBStorageTaskRegistry registry = new RNFBStorageTaskRegistry();
+    FakeHandle first = new FakeHandle();
+    FakeHandle second = new FakeHandle();
+    registry.put(1, first);
+    assertSame(first, registry.take(1));
+    registry.put(1, second);
+    assertSame(second, registry.get(1));
+    assertEquals(0, first.cancelCount);
+  }
+}