From a67dce588ad3b79767a2be9818848fa15f51ec44 Mon Sep 17 00:00:00 2001
From: Dave Mkpa-Eke <daveydenco@gmail.com>
Date: Sat, 23 May 2026 00:40:35 +0100
Subject: [PATCH 1/5] feat: priority caching

---
 bun.lock                                      |  19 +--
 example/package.json                          |   2 +-
 example/src/App.tsx                           |   2 +
 example/src/CachePriorityTab.tsx              | 101 ++++++++++++
 .../margelo/nitro/image/HybridImageView.kt    |   2 +
 .../ios/HybridImageView.swift                 |   1 +
 .../android/c++/JHybridNitroImageViewSpec.cpp |   9 ++
 .../android/c++/JHybridNitroImageViewSpec.hpp |   2 +
 .../JHybridNitroImageViewStateUpdater.cpp     |   4 +
 .../kotlin/com/margelo/nitro/image/Color.kt   |   2 +-
 .../margelo/nitro/image/EncodedImageData.kt   |   2 +-
 .../nitro/image/HybridNitroImageViewSpec.kt   |   6 +
 .../com/margelo/nitro/image/RawPixelData.kt   |   2 +-
 .../ios/c++/HybridNitroImageViewSpecSwift.hpp |   7 +
 .../views/HybridNitroImageViewComponent.mm    |   5 +
 .../ios/swift/HybridNitroImageViewSpec.swift  |   1 +
 .../swift/HybridNitroImageViewSpec_cxx.swift  |  24 +++
 .../shared/c++/HybridNitroImageViewSpec.cpp   |   2 +
 .../shared/c++/HybridNitroImageViewSpec.hpp   |   2 +
 .../views/HybridNitroImageViewComponent.cpp   |  11 ++
 .../views/HybridNitroImageViewComponent.hpp   |   1 +
 .../shared/json/NitroImageViewConfig.json     |   1 +
 .../react-native-nitro-image/package.json     |   4 +-
 .../src/specs/ImageView.nitro.ts              |  14 ++
 .../android/build.gradle                      |   5 +
 .../nitro/web/image/HybridWebImageFactory.kt  |  17 +-
 .../nitro/web/image/HybridWebImageLoader.kt   |   3 +
 .../web/image/cache/PriorityMemoryCache.kt    | 149 ++++++++++++++++++
 .../nitro/web/image/cache/WeakImageCache.kt   | 119 ++++++++++++++
 .../ios/Cache/OrderedKeyMap.swift             |  73 +++++++++
 .../ios/Cache/PriorityMemoryCache.swift       | 139 ++++++++++++++++
 .../ios/HybridWebImageFactory.swift           |  17 ++
 .../ios/HybridWebImageLoader.swift            |  11 +-
 .../c++/JHybridWebImageFactorySpec.cpp        |  10 +-
 .../c++/JHybridWebImageFactorySpec.hpp        |   3 +-
 .../web/image/HybridWebImageFactorySpec.kt    |   6 +-
 .../c++/HybridWebImageFactorySpecSwift.hpp    |   7 +-
 .../ios/swift/HybridWebImageFactorySpec.swift |   2 +-
 .../swift/HybridWebImageFactorySpec_cxx.swift |  11 +-
 .../shared/c++/HybridWebImageFactorySpec.cpp  |   2 +
 .../shared/c++/HybridWebImageFactorySpec.hpp  |   3 +-
 .../react-native-nitro-web-image/package.json |   4 +-
 .../src/specs/WebImageFactory.nitro.ts        |  12 ++
 43 files changed, 793 insertions(+), 26 deletions(-)
 create mode 100644 example/src/CachePriorityTab.tsx
 create mode 100644 packages/react-native-nitro-web-image/android/src/main/java/com/margelo/nitro/web/image/cache/PriorityMemoryCache.kt
 create mode 100644 packages/react-native-nitro-web-image/android/src/main/java/com/margelo/nitro/web/image/cache/WeakImageCache.kt
 create mode 100644 packages/react-native-nitro-web-image/ios/Cache/OrderedKeyMap.swift
 create mode 100644 packages/react-native-nitro-web-image/ios/Cache/PriorityMemoryCache.swift

diff --git a/bun.lock b/bun.lock
index ba9fded4..1ce4eb7e 100644
--- a/bun.lock
+++ b/bun.lock
@@ -1,5 +1,6 @@
 {
   "lockfileVersion": 1,
+  "configVersion": 0,
   "workspaces": {
     "": {
       "name": "react-native-nitro-image-monorepo",
@@ -29,7 +30,7 @@
         "react-native-fast-image": "^8.6.3",
         "react-native-harness": "^1.0.0-alpha.25",
         "react-native-nitro-image": "workspace:*",
-        "react-native-nitro-modules": "0.35.5",
+        "react-native-nitro-modules": "0.35.7",
         "react-native-nitro-web-image": "workspace:*",
         "react-native-safe-area-context": "^5.6.0",
         "react-native-screens": "^4.14.1",
@@ -56,10 +57,10 @@
       "version": "0.14.0",
       "devDependencies": {
         "@types/react": "^19.0.6",
-        "nitrogen": "0.35.5",
+        "nitrogen": "0.35.7",
         "react": "19.1.0",
         "react-native": "0.81.0",
-        "react-native-nitro-modules": "0.35.5",
+        "react-native-nitro-modules": "0.35.7",
         "typescript": "5.8.3",
       },
       "peerDependencies": {
@@ -73,10 +74,10 @@
       "version": "0.14.0",
       "devDependencies": {
         "@types/react": "^19.0.6",
-        "nitrogen": "0.35.5",
+        "nitrogen": "0.35.7",
         "react": "19.1.0",
         "react-native": "0.81.0",
-        "react-native-nitro-modules": "0.35.5",
+        "react-native-nitro-modules": "0.35.7",
         "typescript": "5.8.3",
       },
       "peerDependencies": {
@@ -620,7 +621,7 @@
 
     "@tootallnate/quickjs-emscripten": ["@tootallnate/quickjs-emscripten@0.23.0", "", {}, "sha512-C5Mc6rdnsaJDjO3UpGW/CQTHtCKaYlScZTly4JIu97Jxo/odCiH0ITnDXSJPTOrEKk/ycSZ0AOgTmkDtkOsvIA=="],
 
-    "@ts-morph/common": ["@ts-morph/common@0.28.1", "", { "dependencies": { "minimatch": "^10.0.1", "path-browserify": "^1.0.1", "tinyglobby": "^0.2.14" } }, "sha512-W74iWf7ILp1ZKNYXY5qbddNaml7e9Sedv5lvU1V8lftlitkc9Pq1A+jlH23ltDgWYeZFFEqGCD1Ies9hqu3O+g=="],
+    "@ts-morph/common": ["@ts-morph/common@0.29.0", "", { "dependencies": { "minimatch": "^10.0.1", "path-browserify": "^1.0.1", "tinyglobby": "^0.2.14" } }, "sha512-35oUmphHbJvQ/+UTwFNme/t2p3FoKiGJ5auTjjpNTop2dyREspirjMy82PLSC1pnDJ8ah1GU98hwpVt64YXQsg=="],
 
     "@tsconfig/react-native": ["@tsconfig/react-native@2.0.3", "", {}, "sha512-jE58snEKBd9DXfyR4+ssZmYJ/W2mOSnNrvljR0aLyQJL9JKX6vlWELHkRjb3HBbcM9Uy0hZGijXbqEAjOERW2A=="],
 
@@ -1456,7 +1457,7 @@
 
     "new-github-release-url": ["new-github-release-url@2.0.0", "", { "dependencies": { "type-fest": "^2.5.1" } }, "sha512-NHDDGYudnvRutt/VhKFlX26IotXe1w0cmkDm6JGquh5bz/bDTw0LufSmH/GxTjEdpHEO+bVKFTwdrcGa/9XlKQ=="],
 
-    "nitrogen": ["nitrogen@0.35.5", "", { "dependencies": { "chalk": "^5.3.0", "react-native-nitro-modules": "^0.35.5", "ts-morph": "^27.0.0", "yargs": "^18.0.0", "zod": "^4.0.5" }, "bin": { "nitrogen": "lib/index.js" } }, "sha512-Ofl4aTW2rd44+hBcUwLXu01ViHikn2SDI7zOYc+6NcKSpnhoj42k1FwyvRj1QZPDMUT64Bwlb0DYw7Hrfd3BfQ=="],
+    "nitrogen": ["nitrogen@0.35.7", "", { "dependencies": { "chalk": "^5.3.0", "react-native-nitro-modules": "^0.35.7", "ts-morph": "^28.0.0", "yargs": "^18.0.0", "zod": "^4.0.5" }, "bin": { "nitrogen": "lib/index.js" } }, "sha512-+uXdeK1NhUfXW562qCAnN/mMzVuEUw1K58V1oelhBBQMBTZlTvfO4yTbCFX76XjOeRnbMrPosqIGSGQh3hz1MQ=="],
 
     "nocache": ["nocache@3.0.4", "", {}, "sha512-WDD0bdg9mbq6F4mRxEYcPWwfA1vxd0mrvKOyxI7Xj/atfRHVeutzuWByG//jfm4uPzp0y4Kj051EORCBSQMycw=="],
 
@@ -1622,7 +1623,7 @@
 
     "react-native-nitro-image": ["react-native-nitro-image@workspace:packages/react-native-nitro-image"],
 
-    "react-native-nitro-modules": ["react-native-nitro-modules@0.35.5", "", { "peerDependencies": { "react": "*", "react-native": "*" } }, "sha512-aa03UzC5dLg5qFfyBkVK+JGSwHTjmK7jUZzyRz11r1Yk9C/nJTFe59EeHPxxNNTagkiwQTM6p3sySgD/TDRC7Q=="],
+    "react-native-nitro-modules": ["react-native-nitro-modules@0.35.7", "", { "peerDependencies": { "react": "*", "react-native": "*" } }, "sha512-3EiU27EmnxTlD3pAXR2OBWeDg7+9tdjKrNQOPX08rFX5hJPNIT/h1i2PjvTUieOypCGTEi9nW/SNBtK3F+4HYg=="],
 
     "react-native-nitro-web-image": ["react-native-nitro-web-image@workspace:packages/react-native-nitro-web-image"],
 
@@ -1808,7 +1809,7 @@
 
     "toidentifier": ["toidentifier@1.0.1", "", {}, "sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA=="],
 
-    "ts-morph": ["ts-morph@27.0.2", "", { "dependencies": { "@ts-morph/common": "~0.28.1", "code-block-writer": "^13.0.3" } }, "sha512-fhUhgeljcrdZ+9DZND1De1029PrE+cMkIP7ooqkLRTrRLTqcki2AstsyJm0vRNbTbVCNJ0idGlbBrfqc7/nA8w=="],
+    "ts-morph": ["ts-morph@28.0.0", "", { "dependencies": { "@ts-morph/common": "~0.29.0", "code-block-writer": "^13.0.3" } }, "sha512-Wp3tnZ2bzwxyTZMtgWVzXDfm7lB1Drz+y9DmmYH/L702PQhPyVrp3pkou3yIz4qjS14GY9kcpmLiOOMvl8oG1g=="],
 
     "tslib": ["tslib@2.8.1", "", {}, "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w=="],
 
diff --git a/example/package.json b/example/package.json
index d47826e0..c20bb8cd 100644
--- a/example/package.json
+++ b/example/package.json
@@ -20,7 +20,7 @@
     "react-native-harness": "^1.0.0-alpha.25",
     "react-native-nitro-image": "workspace:*",
     "react-native-nitro-web-image": "workspace:*",
-    "react-native-nitro-modules": "0.35.5",
+    "react-native-nitro-modules": "0.35.7",
     "react-native-safe-area-context": "^5.6.0",
     "react-native-screens": "^4.14.1"
   },
diff --git a/example/src/App.tsx b/example/src/App.tsx
index 2dff6a2c..bc6270ce 100644
--- a/example/src/App.tsx
+++ b/example/src/App.tsx
@@ -7,6 +7,7 @@
 
 import { createBottomTabNavigator } from '@react-navigation/bottom-tabs'
 import { createStaticNavigation } from '@react-navigation/native'
+import { CachePriorityTab } from './CachePriorityTab'
 import { EmptyTab } from './EmptyTab'
 import { FastImageTab } from './FastImageTab'
 import { NitroImageTab } from './NitroImageTab'
@@ -17,6 +18,7 @@ const Tabs = createBottomTabNavigator({
     Empty: EmptyTab,
     FastImage: FastImageTab,
     NitroImage: NitroImageTab,
+    CachePriority: CachePriorityTab,
   },
 })
 const Navigation = createStaticNavigation(Tabs)
diff --git a/example/src/CachePriorityTab.tsx b/example/src/CachePriorityTab.tsx
new file mode 100644
index 00000000..07fb5037
--- /dev/null
+++ b/example/src/CachePriorityTab.tsx
@@ -0,0 +1,101 @@
+import { useCallback, useMemo, useState } from 'react'
+import { Button, FlatList, Platform, StyleSheet, Text, View } from 'react-native'
+import { NitroImage } from 'react-native-nitro-image'
+import { WebImages } from 'react-native-nitro-web-image'
+import { createImageURLs } from './createImageURLs'
+
+// Baseline run: tight cap + no priorities anywhere. 3 MB sits just above the
+// 800×800 hero (~2.56 MB decoded RGBA) so it can land in cache, then the
+// first thumbnail load should LRU-evict it.
+const DEMO_CACHE_BYTES = 3 * 1024 * 1024
+
+console.log(`[CachePriorityTab] platform: ${Platform.OS}`)
+console.log(`[CachePriorityTab] maxMemoryBytes before: ${WebImages.maxMemoryBytes}`)
+WebImages.maxMemoryBytes = DEMO_CACHE_BYTES
+console.log(`[CachePriorityTab] maxMemoryBytes after:  ${WebImages.maxMemoryBytes}`)
+
+/**
+ * Demonstrates cachePriority. The hero (priority 2) should survive cache
+ * pressure while thumbnails (priority 0) churn. With the configured cap,
+ * scrolling many thumbs evicts thumbs first; tapping "Reload hero" should
+ * give an instant cache hit, while thumbnails that scrolled off may need
+ * to be refetched.
+ */
+export function CachePriorityTab() {
+  const heroURL = useMemo(() => `https://picsum.photos/seed/hero/800`, [])
+  const thumbnailURLs = useMemo(() => createImageURLs(200), [])
+  const [heroNonce, setHeroNonce] = useState(0)
+
+  // Pre-build the {url} objects once so each row's `image` prop has a stable
+  // reference across re-renders — otherwise an inline `{ url }` literal would
+  // create a new object every render and re-trigger the native `image` setter.
+  const thumbnailSources = useMemo(
+    () => thumbnailURLs.map((url) => ({ url })),
+    [thumbnailURLs],
+  )
+
+  // Stable identity per hero remount; tied to the nonce so the URL identity
+  // changes only when the user taps "Reload hero".
+  const heroSource = useMemo(() => ({ url: heroURL }), [heroURL, heroNonce])
+
+  const renderItem = useCallback(
+    ({ item: source }: { item: { url: string } }) => (
+      <NitroImage
+        image={source}
+        recyclingKey={source.url}
+        style={styles.thumb}
+        resizeMode="cover"
+      />
+    ),
+    [],
+  )
+
+  return (
+    <View style={styles.container}>
+      <Text style={styles.label}>Hero (no cachePriority)</Text>
+      <NitroImage
+        key={heroNonce}
+        image={heroSource}
+        cachePriority={2}
+        recyclingKey={`${heroURL}#${heroNonce}`}
+        style={styles.hero}
+        resizeMode="cover"
+      />
+      <View style={styles.buttonRow}>
+        <Text style={styles.counter}>Remounted: {heroNonce} • check logcat: 1 SET, {heroNonce} HITs</Text>
+        <Button title="Reload hero" onPress={() => setHeroNonce((n) => n + 1)} />
+      </View>
+      <Text style={styles.label}>Thumbnails (no cachePriority)</Text>
+      <FlatList
+        numColumns={4}
+        windowSize={3}
+        data={thumbnailSources}
+        keyExtractor={(source) => source.url}
+        renderItem={renderItem}
+      />
+    </View>
+  )
+}
+
+const styles = StyleSheet.create({
+  container: {
+    flex: 1,
+  },
+  buttonRow: {
+    paddingHorizontal: 12,
+    paddingVertical: 8,
+  },
+  label: {
+    paddingHorizontal: 12,
+    paddingVertical: 6,
+    fontWeight: '600',
+  },
+  hero: {
+    width: '100%',
+    aspectRatio: 16 / 9,
+  },
+  thumb: {
+    width: '25%',
+    aspectRatio: 1,
+  },
+})
diff --git a/packages/react-native-nitro-image/android/src/main/java/com/margelo/nitro/image/HybridImageView.kt b/packages/react-native-nitro-image/android/src/main/java/com/margelo/nitro/image/HybridImageView.kt
index 672c3e2c..56ec238f 100644
--- a/packages/react-native-nitro-image/android/src/main/java/com/margelo/nitro/image/HybridImageView.kt
+++ b/packages/react-native-nitro-image/android/src/main/java/com/margelo/nitro/image/HybridImageView.kt
@@ -49,6 +49,8 @@ class HybridImageView(context: Context): HybridNitroImageViewSpec(), RecyclableV
             field = value
         }
 
+    override var cachePriority: Double? = null
+
     override fun prepareForRecycle() {
         onDisappear()
         imageView.setImageBitmap(null)
diff --git a/packages/react-native-nitro-image/ios/HybridImageView.swift b/packages/react-native-nitro-image/ios/HybridImageView.swift
index 96f47848..324ed2a6 100644
--- a/packages/react-native-nitro-image/ios/HybridImageView.swift
+++ b/packages/react-native-nitro-image/ios/HybridImageView.swift
@@ -37,6 +37,7 @@ class HybridImageView: HybridNitroImageViewSpec {
       resetImageBeforeLoad = recyclingKey != oldValue
     }
   }
+  var cachePriority: Double?
 
   private func updateResizeMode() {
     let mode = resizeMode ?? .cover
diff --git a/packages/react-native-nitro-image/nitrogen/generated/android/c++/JHybridNitroImageViewSpec.cpp b/packages/react-native-nitro-image/nitrogen/generated/android/c++/JHybridNitroImageViewSpec.cpp
index cdb27588..3926f54c 100644
--- a/packages/react-native-nitro-image/nitrogen/generated/android/c++/JHybridNitroImageViewSpec.cpp
+++ b/packages/react-native-nitro-image/nitrogen/generated/android/c++/JHybridNitroImageViewSpec.cpp
@@ -83,6 +83,15 @@ namespace margelo::nitro::image {
     static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* recyclingKey */)>("setRecyclingKey");
     method(_javaPart, recyclingKey.has_value() ? jni::make_jstring(recyclingKey.value()) : nullptr);
   }
+  std::optional<double> JHybridNitroImageViewSpec::getCachePriority() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JDouble>()>("getCachePriority");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->value()) : std::nullopt;
+  }
+  void JHybridNitroImageViewSpec::setCachePriority(std::optional<double> cachePriority) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JDouble> /* cachePriority */)>("setCachePriority");
+    method(_javaPart, cachePriority.has_value() ? jni::JDouble::valueOf(cachePriority.value()) : nullptr);
+  }
 
   // Methods
   
diff --git a/packages/react-native-nitro-image/nitrogen/generated/android/c++/JHybridNitroImageViewSpec.hpp b/packages/react-native-nitro-image/nitrogen/generated/android/c++/JHybridNitroImageViewSpec.hpp
index 42681e55..5e417b92 100644
--- a/packages/react-native-nitro-image/nitrogen/generated/android/c++/JHybridNitroImageViewSpec.hpp
+++ b/packages/react-native-nitro-image/nitrogen/generated/android/c++/JHybridNitroImageViewSpec.hpp
@@ -56,6 +56,8 @@ namespace margelo::nitro::image {
     void setResizeMode(std::optional<ResizeMode> resizeMode) override;
     std::optional<std::string> getRecyclingKey() override;
     void setRecyclingKey(const std::optional<std::string>& recyclingKey) override;
+    std::optional<double> getCachePriority() override;
+    void setCachePriority(std::optional<double> cachePriority) override;
 
   public:
     // Methods
diff --git a/packages/react-native-nitro-image/nitrogen/generated/android/c++/views/JHybridNitroImageViewStateUpdater.cpp b/packages/react-native-nitro-image/nitrogen/generated/android/c++/views/JHybridNitroImageViewStateUpdater.cpp
index 81eb6e4c..104c9e2e 100644
--- a/packages/react-native-nitro-image/nitrogen/generated/android/c++/views/JHybridNitroImageViewStateUpdater.cpp
+++ b/packages/react-native-nitro-image/nitrogen/generated/android/c++/views/JHybridNitroImageViewStateUpdater.cpp
@@ -49,6 +49,10 @@ void JHybridNitroImageViewStateUpdater::updateViewProps(jni::alias_ref<jni::JCla
     hybridView->setRecyclingKey(props->recyclingKey.value);
     props->recyclingKey.isDirty = false;
   }
+  if (props->cachePriority.isDirty) {
+    hybridView->setCachePriority(props->cachePriority.value);
+    props->cachePriority.isDirty = false;
+  }
 
   // Update hybridRef if it changed
   if (props->hybridRef.isDirty) {
diff --git a/packages/react-native-nitro-image/nitrogen/generated/android/kotlin/com/margelo/nitro/image/Color.kt b/packages/react-native-nitro-image/nitrogen/generated/android/kotlin/com/margelo/nitro/image/Color.kt
index 8bd3a854..0b9a685c 100644
--- a/packages/react-native-nitro-image/nitrogen/generated/android/kotlin/com/margelo/nitro/image/Color.kt
+++ b/packages/react-native-nitro-image/nitrogen/generated/android/kotlin/com/margelo/nitro/image/Color.kt
@@ -43,7 +43,7 @@ data class Color(
   }
 
   override fun hashCode(): Int {
-    return arrayOf(
+    return arrayOf<Any?>(
       r,
       g,
       b,
diff --git a/packages/react-native-nitro-image/nitrogen/generated/android/kotlin/com/margelo/nitro/image/EncodedImageData.kt b/packages/react-native-nitro-image/nitrogen/generated/android/kotlin/com/margelo/nitro/image/EncodedImageData.kt
index b07a2cfa..240af55c 100644
--- a/packages/react-native-nitro-image/nitrogen/generated/android/kotlin/com/margelo/nitro/image/EncodedImageData.kt
+++ b/packages/react-native-nitro-image/nitrogen/generated/android/kotlin/com/margelo/nitro/image/EncodedImageData.kt
@@ -43,7 +43,7 @@ data class EncodedImageData(
   }
 
   override fun hashCode(): Int {
-    return arrayOf(
+    return arrayOf<Any?>(
       buffer,
       width,
       height,
diff --git a/packages/react-native-nitro-image/nitrogen/generated/android/kotlin/com/margelo/nitro/image/HybridNitroImageViewSpec.kt b/packages/react-native-nitro-image/nitrogen/generated/android/kotlin/com/margelo/nitro/image/HybridNitroImageViewSpec.kt
index 2781d821..afa1379a 100644
--- a/packages/react-native-nitro-image/nitrogen/generated/android/kotlin/com/margelo/nitro/image/HybridNitroImageViewSpec.kt
+++ b/packages/react-native-nitro-image/nitrogen/generated/android/kotlin/com/margelo/nitro/image/HybridNitroImageViewSpec.kt
@@ -43,6 +43,12 @@ abstract class HybridNitroImageViewSpec: HybridView() {
   @set:DoNotStrip
   @set:Keep
   abstract var recyclingKey: String?
+  
+  @get:DoNotStrip
+  @get:Keep
+  @set:DoNotStrip
+  @set:Keep
+  abstract var cachePriority: Double?
 
   // Methods
   
diff --git a/packages/react-native-nitro-image/nitrogen/generated/android/kotlin/com/margelo/nitro/image/RawPixelData.kt b/packages/react-native-nitro-image/nitrogen/generated/android/kotlin/com/margelo/nitro/image/RawPixelData.kt
index 1284ef23..0142bc18 100644
--- a/packages/react-native-nitro-image/nitrogen/generated/android/kotlin/com/margelo/nitro/image/RawPixelData.kt
+++ b/packages/react-native-nitro-image/nitrogen/generated/android/kotlin/com/margelo/nitro/image/RawPixelData.kt
@@ -43,7 +43,7 @@ data class RawPixelData(
   }
 
   override fun hashCode(): Int {
-    return arrayOf(
+    return arrayOf<Any?>(
       buffer,
       width,
       height,
diff --git a/packages/react-native-nitro-image/nitrogen/generated/ios/c++/HybridNitroImageViewSpecSwift.hpp b/packages/react-native-nitro-image/nitrogen/generated/ios/c++/HybridNitroImageViewSpecSwift.hpp
index b794f603..5b5c7756 100644
--- a/packages/react-native-nitro-image/nitrogen/generated/ios/c++/HybridNitroImageViewSpecSwift.hpp
+++ b/packages/react-native-nitro-image/nitrogen/generated/ios/c++/HybridNitroImageViewSpecSwift.hpp
@@ -94,6 +94,13 @@ namespace margelo::nitro::image {
     inline void setRecyclingKey(const std::optional<std::string>& recyclingKey) noexcept override {
       _swiftPart.setRecyclingKey(recyclingKey);
     }
+    inline std::optional<double> getCachePriority() noexcept override {
+      auto __result = _swiftPart.getCachePriority();
+      return __result;
+    }
+    inline void setCachePriority(std::optional<double> cachePriority) noexcept override {
+      _swiftPart.setCachePriority(cachePriority);
+    }
 
   public:
     // Methods
diff --git a/packages/react-native-nitro-image/nitrogen/generated/ios/c++/views/HybridNitroImageViewComponent.mm b/packages/react-native-nitro-image/nitrogen/generated/ios/c++/views/HybridNitroImageViewComponent.mm
index 176e7b23..9655d5d4 100644
--- a/packages/react-native-nitro-image/nitrogen/generated/ios/c++/views/HybridNitroImageViewComponent.mm
+++ b/packages/react-native-nitro-image/nitrogen/generated/ios/c++/views/HybridNitroImageViewComponent.mm
@@ -94,6 +94,11 @@ - (void) updateProps:(const std::shared_ptr<const react::Props>&)props
     swiftPart.setRecyclingKey(newViewProps.recyclingKey.value);
     newViewProps.recyclingKey.isDirty = false;
   }
+  // cachePriority: optional
+  if (newViewProps.cachePriority.isDirty) {
+    swiftPart.setCachePriority(newViewProps.cachePriority.value);
+    newViewProps.cachePriority.isDirty = false;
+  }
 
   swiftPart.afterUpdate();
 
diff --git a/packages/react-native-nitro-image/nitrogen/generated/ios/swift/HybridNitroImageViewSpec.swift b/packages/react-native-nitro-image/nitrogen/generated/ios/swift/HybridNitroImageViewSpec.swift
index 07709254..fb745ca0 100644
--- a/packages/react-native-nitro-image/nitrogen/generated/ios/swift/HybridNitroImageViewSpec.swift
+++ b/packages/react-native-nitro-image/nitrogen/generated/ios/swift/HybridNitroImageViewSpec.swift
@@ -13,6 +13,7 @@ public protocol HybridNitroImageViewSpec_protocol: HybridObject, HybridView {
   var image: Variant__any_HybridImageSpec___any_HybridImageLoaderSpec_? { get set }
   var resizeMode: ResizeMode? { get set }
   var recyclingKey: String? { get set }
+  var cachePriority: Double? { get set }
 
   // Methods
   
diff --git a/packages/react-native-nitro-image/nitrogen/generated/ios/swift/HybridNitroImageViewSpec_cxx.swift b/packages/react-native-nitro-image/nitrogen/generated/ios/swift/HybridNitroImageViewSpec_cxx.swift
index 7f878b7c..480f1491 100644
--- a/packages/react-native-nitro-image/nitrogen/generated/ios/swift/HybridNitroImageViewSpec_cxx.swift
+++ b/packages/react-native-nitro-image/nitrogen/generated/ios/swift/HybridNitroImageViewSpec_cxx.swift
@@ -218,6 +218,30 @@ open class HybridNitroImageViewSpec_cxx {
       }()
     }
   }
+  
+  public final var cachePriority: bridge.std__optional_double_ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_double_ in
+        if let __unwrappedValue = self.__implementation.cachePriority {
+          return bridge.create_std__optional_double_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.cachePriority = { () -> Double? in
+        if bridge.has_value_std__optional_double_(newValue) {
+          let __unwrapped = bridge.get_std__optional_double_(newValue)
+          return __unwrapped
+        } else {
+          return nil
+        }
+      }()
+    }
+  }
 
   // Methods
   public final func getView() -> UnsafeMutableRawPointer {
diff --git a/packages/react-native-nitro-image/nitrogen/generated/shared/c++/HybridNitroImageViewSpec.cpp b/packages/react-native-nitro-image/nitrogen/generated/shared/c++/HybridNitroImageViewSpec.cpp
index 04c55de6..c249f3a0 100644
--- a/packages/react-native-nitro-image/nitrogen/generated/shared/c++/HybridNitroImageViewSpec.cpp
+++ b/packages/react-native-nitro-image/nitrogen/generated/shared/c++/HybridNitroImageViewSpec.cpp
@@ -20,6 +20,8 @@ namespace margelo::nitro::image {
       prototype.registerHybridSetter("resizeMode", &HybridNitroImageViewSpec::setResizeMode);
       prototype.registerHybridGetter("recyclingKey", &HybridNitroImageViewSpec::getRecyclingKey);
       prototype.registerHybridSetter("recyclingKey", &HybridNitroImageViewSpec::setRecyclingKey);
+      prototype.registerHybridGetter("cachePriority", &HybridNitroImageViewSpec::getCachePriority);
+      prototype.registerHybridSetter("cachePriority", &HybridNitroImageViewSpec::setCachePriority);
     });
   }
 
diff --git a/packages/react-native-nitro-image/nitrogen/generated/shared/c++/HybridNitroImageViewSpec.hpp b/packages/react-native-nitro-image/nitrogen/generated/shared/c++/HybridNitroImageViewSpec.hpp
index 61e4e744..c88f6325 100644
--- a/packages/react-native-nitro-image/nitrogen/generated/shared/c++/HybridNitroImageViewSpec.hpp
+++ b/packages/react-native-nitro-image/nitrogen/generated/shared/c++/HybridNitroImageViewSpec.hpp
@@ -61,6 +61,8 @@ namespace margelo::nitro::image {
       virtual void setResizeMode(std::optional<ResizeMode> resizeMode) = 0;
       virtual std::optional<std::string> getRecyclingKey() = 0;
       virtual void setRecyclingKey(const std::optional<std::string>& recyclingKey) = 0;
+      virtual std::optional<double> getCachePriority() = 0;
+      virtual void setCachePriority(std::optional<double> cachePriority) = 0;
 
     public:
       // Methods
diff --git a/packages/react-native-nitro-image/nitrogen/generated/shared/c++/views/HybridNitroImageViewComponent.cpp b/packages/react-native-nitro-image/nitrogen/generated/shared/c++/views/HybridNitroImageViewComponent.cpp
index cdae2e81..c428e7bb 100644
--- a/packages/react-native-nitro-image/nitrogen/generated/shared/c++/views/HybridNitroImageViewComponent.cpp
+++ b/packages/react-native-nitro-image/nitrogen/generated/shared/c++/views/HybridNitroImageViewComponent.cpp
@@ -56,6 +56,16 @@ namespace margelo::nitro::image::views {
         throw std::runtime_error(std::string("NitroImageView.recyclingKey: ") + exc.what());
       }
     }()),
+    cachePriority([&]() -> CachedProp<std::optional<double>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("cachePriority", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.cachePriority;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<double>>::fromRawValue(*runtime, value, sourceProps.cachePriority);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("NitroImageView.cachePriority: ") + exc.what());
+      }
+    }()),
     hybridRef([&]() -> CachedProp<std::optional<std::function<void(const std::shared_ptr<HybridNitroImageViewSpec>& /* ref */)>>> {
       try {
         const react::RawValue* rawValue = rawProps.at("hybridRef", nullptr, nullptr);
@@ -72,6 +82,7 @@ namespace margelo::nitro::image::views {
       case hashString("image"): return true;
       case hashString("resizeMode"): return true;
       case hashString("recyclingKey"): return true;
+      case hashString("cachePriority"): return true;
       case hashString("hybridRef"): return true;
       default: return false;
     }
diff --git a/packages/react-native-nitro-image/nitrogen/generated/shared/c++/views/HybridNitroImageViewComponent.hpp b/packages/react-native-nitro-image/nitrogen/generated/shared/c++/views/HybridNitroImageViewComponent.hpp
index 91248b9e..32d12e8a 100644
--- a/packages/react-native-nitro-image/nitrogen/generated/shared/c++/views/HybridNitroImageViewComponent.hpp
+++ b/packages/react-native-nitro-image/nitrogen/generated/shared/c++/views/HybridNitroImageViewComponent.hpp
@@ -49,6 +49,7 @@ namespace margelo::nitro::image::views {
     CachedProp<std::optional<std::variant<std::shared_ptr<HybridImageSpec>, std::shared_ptr<HybridImageLoaderSpec>>>> image;
     CachedProp<std::optional<ResizeMode>> resizeMode;
     CachedProp<std::optional<std::string>> recyclingKey;
+    CachedProp<std::optional<double>> cachePriority;
     CachedProp<std::optional<std::function<void(const std::shared_ptr<HybridNitroImageViewSpec>& /* ref */)>>> hybridRef;
 
   private:
diff --git a/packages/react-native-nitro-image/nitrogen/generated/shared/json/NitroImageViewConfig.json b/packages/react-native-nitro-image/nitrogen/generated/shared/json/NitroImageViewConfig.json
index e376831b..da107cec 100644
--- a/packages/react-native-nitro-image/nitrogen/generated/shared/json/NitroImageViewConfig.json
+++ b/packages/react-native-nitro-image/nitrogen/generated/shared/json/NitroImageViewConfig.json
@@ -7,6 +7,7 @@
     "image": true,
     "resizeMode": true,
     "recyclingKey": true,
+    "cachePriority": true,
     "hybridRef": true
   }
 }
diff --git a/packages/react-native-nitro-image/package.json b/packages/react-native-nitro-image/package.json
index cfb2e634..55ba7235 100644
--- a/packages/react-native-nitro-image/package.json
+++ b/packages/react-native-nitro-image/package.json
@@ -58,10 +58,10 @@
   },
   "devDependencies": {
     "@types/react": "^19.0.6",
-    "nitrogen": "0.35.5",
+    "nitrogen": "0.35.7",
     "react": "19.1.0",
     "react-native": "0.81.0",
-    "react-native-nitro-modules": "0.35.5",
+    "react-native-nitro-modules": "0.35.7",
     "typescript": "5.8.3"
   },
   "peerDependencies": {
diff --git a/packages/react-native-nitro-image/src/specs/ImageView.nitro.ts b/packages/react-native-nitro-image/src/specs/ImageView.nitro.ts
index 572a3a69..7b016b0f 100644
--- a/packages/react-native-nitro-image/src/specs/ImageView.nitro.ts
+++ b/packages/react-native-nitro-image/src/specs/ImageView.nitro.ts
@@ -55,6 +55,20 @@ export interface NativeNitroImageViewProps extends HybridViewProps {
    * ```
    */
   recyclingKey?: string
+  /**
+   * Hint for the memory cache about how important this image is to keep.
+   *
+   * When the cache is over its byte budget, entries are evicted lowest
+   * priority first; within the same priority the least-recently-used
+   * entry is evicted first.
+   *
+   * - `0`: low — evicted first (thumbnails, decorative)
+   * - `1`: normal — default
+   * - `2`: high — evicted last (heroes, avatars)
+   *
+   * @default 1
+   */
+  cachePriority?: number
 }
 
 export interface NativeNitroImageViewMethods extends HybridViewMethods {
diff --git a/packages/react-native-nitro-web-image/android/build.gradle b/packages/react-native-nitro-web-image/android/build.gradle
index 7270e0bd..2b44e8f9 100644
--- a/packages/react-native-nitro-web-image/android/build.gradle
+++ b/packages/react-native-nitro-web-image/android/build.gradle
@@ -120,6 +120,7 @@ android {
       }
     }
   }
+
 }
 
 repositories {
@@ -142,5 +143,9 @@ dependencies {
   implementation("io.coil-kt.coil3:coil:3.3.0")
   implementation("io.coil-kt.coil3:coil-network-okhttp:3.3.0")
   implementation("io.coil-kt.coil3:coil-gif:3.3.0")
+  // Lock primitive used to match Coil's RealMemoryCache synchronization.
+  implementation("org.jetbrains.kotlinx:atomicfu:0.29.0")
+
+  testImplementation("junit:junit:4.13.2")
 }
 
diff --git a/packages/react-native-nitro-web-image/android/src/main/java/com/margelo/nitro/web/image/HybridWebImageFactory.kt b/packages/react-native-nitro-web-image/android/src/main/java/com/margelo/nitro/web/image/HybridWebImageFactory.kt
index e282f35b..04a0019e 100644
--- a/packages/react-native-nitro-web-image/android/src/main/java/com/margelo/nitro/web/image/HybridWebImageFactory.kt
+++ b/packages/react-native-nitro-web-image/android/src/main/java/com/margelo/nitro/web/image/HybridWebImageFactory.kt
@@ -2,6 +2,7 @@ package com.margelo.nitro.web.image
 
 import androidx.annotation.Keep
 import coil3.ImageLoader
+import coil3.memory.MemoryCache
 import coil3.request.ImageRequest
 import com.facebook.common.internal.DoNotStrip
 import com.facebook.react.bridge.ReactApplicationContext
@@ -9,6 +10,7 @@ import com.margelo.nitro.NitroModules
 import com.margelo.nitro.core.Promise
 import com.margelo.nitro.image.HybridImageLoaderSpec
 import com.margelo.nitro.image.HybridImageSpec
+import com.margelo.nitro.web.image.cache.PriorityMemoryCache
 import com.margelo.nitro.web.image.extensions.loadImageAsync
 
 @DoNotStrip
@@ -16,7 +18,20 @@ import com.margelo.nitro.web.image.extensions.loadImageAsync
 class HybridWebImageFactory: HybridWebImageFactorySpec() {
     private val context: ReactApplicationContext
         get() = NitroModules.applicationContext ?: throw Error("No context - NitroModules.applicationContext was null!")
-    private val imageLoader = ImageLoader(context)
+    private val imageLoader = ImageLoader.Builder(context)
+        .memoryCache {
+            // Set initialMaxSize to Coil default.
+            PriorityMemoryCache(
+                initialMaxSize = MemoryCache.Builder().maxSizePercent(context).build().maxSize,
+            )
+        }
+        .build()
+
+    override var maxMemoryBytes: Double
+        get() = (imageLoader.memoryCache?.maxSize ?: 0L).toDouble()
+        set(value) {
+            imageLoader.memoryCache?.maxSize = value.toLong()
+        }
 
     override fun createWebImageLoader(
         url: String,
diff --git a/packages/react-native-nitro-web-image/android/src/main/java/com/margelo/nitro/web/image/HybridWebImageLoader.kt b/packages/react-native-nitro-web-image/android/src/main/java/com/margelo/nitro/web/image/HybridWebImageLoader.kt
index d4fd6b40..c1768d49 100644
--- a/packages/react-native-nitro-web-image/android/src/main/java/com/margelo/nitro/web/image/HybridWebImageLoader.kt
+++ b/packages/react-native-nitro-web-image/android/src/main/java/com/margelo/nitro/web/image/HybridWebImageLoader.kt
@@ -8,6 +8,7 @@ import com.margelo.nitro.core.Promise
 import com.margelo.nitro.image.HybridImageSpec
 import com.margelo.nitro.image.HybridImageLoaderSpec
 import com.margelo.nitro.image.HybridNitroImageViewSpec
+import com.margelo.nitro.web.image.cache.CACHE_PRIORITY_EXTRA
 import com.margelo.nitro.web.image.extensions.applyOptions
 import com.margelo.nitro.web.image.extensions.loadImageAsync
 
@@ -21,9 +22,11 @@ class HybridWebImageLoader(private val imageLoader: ImageLoader,
 
     override fun requestImage(forView: HybridNitroImageViewSpec) {
         val imageView = forView.view as? ImageView ?: return
+        val cachePriority = forView.cachePriority?.toInt() ?: 1
 
         imageView.load(url, imageLoader) {
             this.applyOptions(options)
+            memoryCacheKeyExtra(CACHE_PRIORITY_EXTRA, cachePriority.toString())
         }
     }
 
diff --git a/packages/react-native-nitro-web-image/android/src/main/java/com/margelo/nitro/web/image/cache/PriorityMemoryCache.kt b/packages/react-native-nitro-web-image/android/src/main/java/com/margelo/nitro/web/image/cache/PriorityMemoryCache.kt
new file mode 100644
index 00000000..0100d470
--- /dev/null
+++ b/packages/react-native-nitro-web-image/android/src/main/java/com/margelo/nitro/web/image/cache/PriorityMemoryCache.kt
@@ -0,0 +1,149 @@
+package com.margelo.nitro.web.image.cache
+
+import coil3.Image
+import coil3.memory.MemoryCache
+import coil3.memory.MemoryCache.Key
+import kotlinx.atomicfu.locks.SynchronizedObject
+import kotlinx.atomicfu.locks.synchronized
+
+const val CACHE_PRIORITY_EXTRA = "cachePriority"
+private const val BUCKET_COUNT = 3
+private const val DEFAULT_PRIORITY = 1
+
+
+class PriorityMemoryCache(
+    initialMaxSize: Long,
+) : MemoryCache {
+
+    private val lock = SynchronizedObject()
+    // `true` auto-moves the entry to the MRU tail.
+    private val buckets = Array(BUCKET_COUNT) { LinkedHashMap<Key, InternalValue>(16, 0.75f, true) }
+    private val keyToBucket = HashMap<Key, Int>()
+    private var currentBytes = 0L
+    // Weak tier mirrors Coil's WeakMemoryCache. Catches images that are evicted
+    // from the strong tier but still strong-referenced by an in-flight consumer.
+    private val weakCache = WeakImageCache()
+
+    override val initialMaxSize: Long = initialMaxSize
+
+    override val size: Long
+        get() = synchronized(lock) {
+            currentBytes
+        }
+
+    override var maxSize: Long = initialMaxSize
+        get() = synchronized(lock) {
+            field
+        }
+        set(value) = synchronized(lock) {
+            field = value
+            trimToSize(value)
+        }
+
+    override val keys: Set<Key>
+        get() = synchronized(lock) {
+            HashSet(keyToBucket.keys) + weakCache.keys
+        }
+
+    override fun get(key: Key): MemoryCache.Value? = synchronized(lock) {
+        val bucketIndex = keyToBucket[key]
+        if (bucketIndex == null) {
+            // Strong miss, fall back to the weak tier (mirrors RealMemoryCache.get from Coil).
+            val weakHit = weakCache.get(key) ?: return null
+            if (!weakHit.image.shareable) weakCache.remove(key)
+            return weakHit
+        }
+        val cachedEntry = buckets[bucketIndex][key] ?: return null
+
+        // Unshareable images (e.g. animated GIFs) can't be safely held by two
+        // consumers at once, so hand the entry out and drop it from both tiers.
+        if (!cachedEntry.image.shareable) {
+            keyToBucket.remove(key)
+            buckets[bucketIndex].remove(key)
+            currentBytes -= cachedEntry.size
+            weakCache.remove(key)
+        }
+        return MemoryCache.Value(cachedEntry.image, cachedEntry.extras)
+    }
+
+    override fun set(key: Key, value: MemoryCache.Value) = synchronized(lock) {
+        val entryBytes = value.image.size
+        check(entryBytes >= 0) { "Image size must be non-negative: $entryBytes" }
+
+        // Replace any prior entry under this key; forward the displaced image to weak
+        evictFromStrongToWeak(key)
+
+        // Refuse oversized entries would otherwise evict the rest of the cache.
+        // Coil's RealStrongMemoryCache.set still hands oversized values to weak.
+        if (entryBytes > maxSize) {
+            weakCache.set(key, value.image, value.extras, entryBytes)
+            return@synchronized
+        }
+
+        val priority = parsePriority(key)
+        buckets[priority][key] = InternalValue(value.image, value.extras, entryBytes)
+        keyToBucket[key] = priority
+        currentBytes += entryBytes
+
+        trimToSize(maxSize)
+    }
+
+    override fun remove(key: Key): Boolean = synchronized(lock) {
+        val removedStrong = removeFromStrong(key)
+        val removedWeak = weakCache.remove(key)
+        return removedStrong || removedWeak
+    }
+
+    override fun trimToSize(size: Long) = synchronized(lock) {
+        while (currentBytes > size) {
+            if (!evictOne()) return@synchronized
+        }
+    }
+
+    override fun clear() = synchronized(lock) {
+        for (bucket in buckets) bucket.clear()
+        keyToBucket.clear()
+        currentBytes = 0L
+        weakCache.clear()
+    }
+
+    private fun evictOne(): Boolean {
+        for (priority in 0 until BUCKET_COUNT) {
+            val bucket = buckets[priority]
+            if (bucket.isEmpty()) continue
+            // Head of an access-order LinkedHashMap = least-recently-used entry.
+            val oldestKey = bucket.entries.iterator().next().key
+            evictFromStrongToWeak(oldestKey)
+            return true
+        }
+        return false
+    }
+
+    /** Pull an entry out of the strong tier and hand it to the weak tier. */
+    private fun evictFromStrongToWeak(key: Key) {
+        val bucketIndex = keyToBucket.remove(key) ?: return
+        val displaced = buckets[bucketIndex].remove(key) ?: return
+        currentBytes -= displaced.size
+        weakCache.set(key, displaced.image, displaced.extras, displaced.size)
+    }
+
+    /** Strong-tier-only removal. Caller is responsible for the weak tier. */
+    private fun removeFromStrong(key: Key): Boolean {
+        val bucketIndex = keyToBucket.remove(key) ?: return false
+        val value = buckets[bucketIndex].remove(key) ?: return false
+        currentBytes -= value.size
+        return true
+    }
+
+    private fun parsePriority(key: Key): Int {
+        val rawPriority = key.extras[CACHE_PRIORITY_EXTRA]?.toIntOrNull() ?: DEFAULT_PRIORITY
+        // Clamp out-of-range priorities to a valid bucket index.
+        return rawPriority.coerceIn(0, BUCKET_COUNT - 1)
+    }
+
+    private class InternalValue(
+        val image: Image,
+        val extras: Map<String, Any>,
+        val size: Long,
+    )
+}
diff --git a/packages/react-native-nitro-web-image/android/src/main/java/com/margelo/nitro/web/image/cache/WeakImageCache.kt b/packages/react-native-nitro-web-image/android/src/main/java/com/margelo/nitro/web/image/cache/WeakImageCache.kt
new file mode 100644
index 00000000..c85d0cbe
--- /dev/null
+++ b/packages/react-native-nitro-web-image/android/src/main/java/com/margelo/nitro/web/image/cache/WeakImageCache.kt
@@ -0,0 +1,119 @@
+package com.margelo.nitro.web.image.cache
+
+import coil3.Image
+import coil3.memory.MemoryCache.Key
+import coil3.memory.MemoryCache.Value
+import java.lang.ref.WeakReference
+
+/**
+ * Holds weak references to images that have been evicted from the strong cache.
+ *
+ * A port of coil3.memory.RealWeakMemoryCache:
+ * https://github.com/coil-kt/coil/blob/3.3.0/coil-core/src/commonMain/kotlin/coil3/memory/WeakMemoryCache.kt
+ */
+internal class WeakImageCache {
+
+    internal val cache = LinkedHashMap<Key, ArrayList<InternalValue>>()
+    private var operationsSinceCleanUp = 0
+
+    val keys: Set<Key>
+        get() = cache.keys.toSet()
+
+    fun get(key: Key): Value? {
+        val values = cache[key] ?: return null
+
+        // Find the first image that hasn't been collected.
+        var value: Value? = null
+        for (index in values.indices) {
+            val image = values[index].image.get()
+            if (image != null) {
+                value = Value(image, values[index].extras)
+                break
+            }
+        }
+
+        cleanUpIfNecessary()
+        return value
+    }
+
+    fun set(key: Key, image: Image, extras: Map<String, Any>, size: Long) {
+        val values = cache.getOrPut(key) { arrayListOf() }
+
+        // Insert the value into the list sorted descending by size.
+        val newValue = InternalValue(WeakReference(image), extras, size)
+        if (values.isEmpty()) {
+            values += newValue
+        } else {
+            for (index in values.indices) {
+                val value = values[index]
+                if (size >= value.size) {
+                    if (value.image.get() === image) {
+                        values[index] = newValue
+                    } else {
+                        values.add(index, newValue)
+                    }
+                    break
+                }
+            }
+        }
+
+        cleanUpIfNecessary()
+    }
+
+    fun remove(key: Key): Boolean {
+        return cache.remove(key) != null
+    }
+
+    fun clear() {
+        operationsSinceCleanUp = 0
+        cache.clear()
+    }
+
+    private fun cleanUpIfNecessary() {
+        if (operationsSinceCleanUp++ >= CLEAN_UP_INTERVAL) {
+            cleanUp()
+        }
+    }
+
+    /** Remove any dereferenced images from the cache. */
+    internal fun cleanUp() {
+        operationsSinceCleanUp = 0
+
+        // Remove all the values whose references have been collected.
+        val iterator = cache.values.iterator()
+        while (iterator.hasNext()) {
+            val list = iterator.next()
+
+            if (list.size <= 1) {
+                // Typically, the list will only contain 1 item. Handle this case in an optimal way here.
+                if (list.firstOrNull()?.image?.get() == null) {
+                    iterator.remove()
+                }
+            } else {
+                // Iterate over the list of values and delete individual entries that have been collected.
+                var writeIndex = 0
+                for (readIndex in list.indices) {
+                    if (list[readIndex].image.get() != null) {
+                        list[writeIndex] = list[readIndex]
+                        writeIndex++
+                    }
+                }
+                while (list.size > writeIndex) list.removeAt(list.size - 1)
+
+                if (list.isEmpty()) {
+                    iterator.remove()
+                }
+            }
+        }
+    }
+
+    internal class InternalValue(
+        val image: WeakReference<Image>,
+        val extras: Map<String, Any>,
+        val size: Long,
+    )
+
+    companion object {
+        private const val CLEAN_UP_INTERVAL = 10
+    }
+}
diff --git a/packages/react-native-nitro-web-image/ios/Cache/OrderedKeyMap.swift b/packages/react-native-nitro-web-image/ios/Cache/OrderedKeyMap.swift
new file mode 100644
index 00000000..135940f5
--- /dev/null
+++ b/packages/react-native-nitro-web-image/ios/Cache/OrderedKeyMap.swift
@@ -0,0 +1,73 @@
+//
+//  OrderedKeyMap.swift
+//  NitroWebImage
+//
+
+import Foundation
+
+/// Order-preserving map used as the LRU list within a single priority bucket.
+/// Head = LRU, tail = MRU.
+final class OrderedKeyMap<Key: Hashable, Value> {
+  private final class Node {
+    let key: Key
+    var value: Value
+    var prev: Node?
+    var next: Node?
+    init(key: Key, value: Value) {
+      self.key = key
+      self.value = value
+    }
+  }
+
+  private var head: Node?
+  private var tail: Node?
+  private var nodes: [Key: Node] = [:]
+
+  var isEmpty: Bool { nodes.isEmpty }
+
+  func append(_ key: Key, value: Value) {
+    let node = Node(key: key, value: value)
+    nodes[key] = node
+    linkAtTail(node)
+  }
+
+  func moveToTail(_ key: Key) -> Value? {
+    guard let node = nodes[key] else { return nil }
+    unlink(node)
+    linkAtTail(node)
+    return node.value
+  }
+
+  @discardableResult
+  func remove(_ key: Key) -> Value? {
+    guard let node = nodes.removeValue(forKey: key) else { return nil }
+    unlink(node)
+    return node.value
+  }
+
+  func popHead() -> (Key, Value)? {
+    guard let node = head else { return nil }
+    unlink(node)
+    nodes.removeValue(forKey: node.key)
+    return (node.key, node.value)
+  }
+
+  private func linkAtTail(_ node: Node) {
+    node.prev = tail
+    node.next = nil
+    tail?.next = node
+    tail = node
+    if head == nil { head = node }
+  }
+
+  private func unlink(_ node: Node) {
+    let prev = node.prev
+    let next = node.next
+    prev?.next = next
+    next?.prev = prev
+    if head === node { head = next }
+    if tail === node { tail = prev }
+    node.prev = nil
+    node.next = nil
+  }
+}
diff --git a/packages/react-native-nitro-web-image/ios/Cache/PriorityMemoryCache.swift b/packages/react-native-nitro-web-image/ios/Cache/PriorityMemoryCache.swift
new file mode 100644
index 00000000..15854f7c
--- /dev/null
+++ b/packages/react-native-nitro-web-image/ios/Cache/PriorityMemoryCache.swift
@@ -0,0 +1,139 @@
+//
+//  PriorityMemoryCache.swift
+//  NitroWebImage
+//
+
+import Foundation
+import SDWebImage
+import UIKit
+
+
+final class PriorityMemoryCache: NSObject, SDMemoryCacheProtocol {
+  static let cachePriorityExtra = "cachePriority"
+  static let prioritySeparator: Character = "|"
+
+  private static let bucketCount = 3
+  private static let defaultPriority = 1
+
+  private let lock = NSLock()
+  private var buckets: [OrderedKeyMap<NSString, InternalValue>] =
+    (0..<bucketCount).map { _ in OrderedKeyMap() }
+  private var keyToBucket: [NSString: Int] = [:]
+  private var currentBytes: UInt = 0
+  private let _config: SDImageCacheConfig
+  private var memoryWarningObserver: NSObjectProtocol?
+
+  var config: SDImageCacheConfig { _config }
+
+  init(config: SDImageCacheConfig) {
+    self._config = config
+    super.init()
+    // when iOS warns about memory pressure, halve the cache (priority-aware via trimToSizeLocked)
+    memoryWarningObserver = NotificationCenter.default.addObserver(
+      forName: UIApplication.didReceiveMemoryWarningNotification,
+      object: nil,
+      queue: nil,
+    ) { [weak self] _ in
+      guard let self = self else { return }
+
+      self.trimToSizeLocked(UInt(self._config.maxMemoryCost) / 2)
+    }
+  }
+
+  deinit {
+    if let observer = memoryWarningObserver {
+      NotificationCenter.default.removeObserver(observer)
+    }
+  }
+
+  // MARK: - SDMemoryCache
+
+  func object(forKey key: Any) -> Any? {
+    guard let key = key as? NSString else { return nil }
+    lock.lock()
+    defer { lock.unlock() }
+
+    guard let bucketIndex = keyToBucket[key] else { return nil }
+    return buckets[bucketIndex].moveToTail(key)?.object
+  }
+
+  func setObject(_ object: Any?, forKey key: Any) {
+    setObject(object, forKey: key, cost: 0)
+  }
+
+  func setObject(_ object: Any?, forKey key: Any, cost: UInt) {
+    guard let key = key as? NSString else { return }
+    lock.lock()
+    defer { lock.unlock() }
+
+    // Replace any prior entry under this key.
+    removeLocked(key)
+
+    guard let object = object else { return }
+
+    let maxBytes = UInt(_config.maxMemoryCost)
+    // Refuse oversized entries, would otherwise evict the rest of the cache.
+    if maxBytes > 0 && cost > maxBytes { return }
+
+    let priority = Self.parsePriority(key)
+    buckets[priority].append(key, value: InternalValue(object: object, cost: cost))
+    keyToBucket[key] = priority
+    currentBytes &+= cost
+
+    if maxBytes > 0 { trimToSizeLocked(maxBytes) }
+  }
+
+  func removeObject(forKey key: Any) {
+    guard let key = key as? NSString else { return }
+    lock.lock()
+    defer { lock.unlock() }
+    _ = removeLocked(key)
+  }
+
+  func removeAllObjects() {
+    lock.lock()
+    defer { lock.unlock() }
+    for index in 0..<buckets.count { buckets[index] = OrderedKeyMap() }
+    keyToBucket.removeAll()
+    currentBytes = 0
+  }
+
+  // MARK: - Internal helpers (caller holds the lock)
+
+  @discardableResult
+  private func removeLocked(_ key: NSString) -> Bool {
+    guard let bucketIndex = keyToBucket.removeValue(forKey: key) else { return false }
+    guard let value = buckets[bucketIndex].remove(key) else { return false }
+    currentBytes = currentBytes >= value.cost ? currentBytes - value.cost : 0
+    return true
+  }
+
+  private func trimToSizeLocked(_ target: UInt) {
+    while currentBytes > target {
+      if !evictOneLocked() { return }
+    }
+  }
+
+  private func evictOneLocked() -> Bool {
+    for priority in 0..<Self.bucketCount {
+      guard let (key, value) = buckets[priority].popHead() else { continue }
+      keyToBucket.removeValue(forKey: key)
+      currentBytes = currentBytes >= value.cost ? currentBytes - value.cost : 0
+      return true
+    }
+    return false
+  }
+
+  private static func parsePriority(_ key: NSString) -> Int {
+    let str = key as String
+    guard let sepIndex = str.firstIndex(of: prioritySeparator) else { return defaultPriority }
+    let prefix = str[str.startIndex..<sepIndex]
+    guard let raw = Int(prefix) else { return defaultPriority }
+    return max(0, min(bucketCount - 1, raw))
+  }
+
+  private struct InternalValue {
+    let object: Any
+    let cost: UInt
+  }
+}
diff --git a/packages/react-native-nitro-web-image/ios/HybridWebImageFactory.swift b/packages/react-native-nitro-web-image/ios/HybridWebImageFactory.swift
index cca50b66..7e73e01d 100644
--- a/packages/react-native-nitro-web-image/ios/HybridWebImageFactory.swift
+++ b/packages/react-native-nitro-web-image/ios/HybridWebImageFactory.swift
@@ -11,6 +11,23 @@ import SDWebImage
 import NitroImage
 
 class HybridWebImageFactory: HybridWebImageFactorySpec {
+  override init() {
+    // Install our priority-aware memory cache as the shared SDImageCache class.
+    // Setting this on the default config must happen before any SDImageCache
+    // instance is constructed, so do it here on the factory's first init.
+    SDImageCacheConfig.default.memoryCacheClass = PriorityMemoryCache.self
+    // NOTE: deliberately small for demo/manual verification of priority eviction.
+    // Big enough to hold a handful of decoded bitmaps so eviction is observable.
+    // Restore to 64 * 1024 * 1024 for production defaults.
+    SDImageCacheConfig.default.maxMemoryCost = 16 * 1024 * 1024
+    super.init()
+  }
+
+  var maxMemoryBytes: Double {
+    get { Double(SDImageCacheConfig.default.maxMemoryCost) }
+    set { SDImageCacheConfig.default.maxMemoryCost = UInt(max(0, newValue)) }
+  }
+
   func loadFromURLAsync(url urlString: String, options: AsyncImageLoadOptions?) throws -> Promise<any HybridImageSpec> {
     guard let url = URL(string: urlString) else {
       throw RuntimeError.error(withMessage: "URL string \"\(urlString)\" is not a valid URL!")
diff --git a/packages/react-native-nitro-web-image/ios/HybridWebImageLoader.swift b/packages/react-native-nitro-web-image/ios/HybridWebImageLoader.swift
index e95e8986..98e1ca5d 100644
--- a/packages/react-native-nitro-web-image/ios/HybridWebImageLoader.swift
+++ b/packages/react-native-nitro-web-image/ios/HybridWebImageLoader.swift
@@ -32,10 +32,19 @@ class HybridWebImageLoader: HybridImageLoaderSpec {
   }
 
   func requestImage(forView view: (any HybridNitroImageViewSpec)) throws {
+    let cachePriority = Int(view.cachePriority ?? 1)
     guard let view = view as? NativeImageView else { throw RuntimeError.error(withMessage: "Invalid view type!") }
 
     let webImageOptions = options?.toSDWebImageOptions() ?? []
-    let webImageContext = options?.toSDWebImageContext()
+    var webImageContext = options?.toSDWebImageContext() ?? [:]
+
+    // Bake cachePriority into the memory cache key via SDWebImage's
+    // CacheKeyFilter. Our PriorityMemoryCache parses the `"P|"` prefix
+    // to pick the bucket.
+    webImageContext[.cacheKeyFilter] = SDWebImageCacheKeyFilter { url in
+      "\(cachePriority)\(PriorityMemoryCache.prioritySeparator)\(url.absoluteString)"
+    }
+
     view.imageView.sd_setImage(with: url,
                                placeholderImage: view.imageView.image,
                                options: webImageOptions,
diff --git a/packages/react-native-nitro-web-image/nitrogen/generated/android/c++/JHybridWebImageFactorySpec.cpp b/packages/react-native-nitro-web-image/nitrogen/generated/android/c++/JHybridWebImageFactorySpec.cpp
index 891f71ab..193c36c7 100644
--- a/packages/react-native-nitro-web-image/nitrogen/generated/android/c++/JHybridWebImageFactorySpec.cpp
+++ b/packages/react-native-nitro-web-image/nitrogen/generated/android/c++/JHybridWebImageFactorySpec.cpp
@@ -60,7 +60,15 @@ namespace margelo::nitro::web::image {
   }
 
   // Properties
-  
+  double JHybridWebImageFactorySpec::getMaxMemoryBytes() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<double()>("getMaxMemoryBytes");
+    auto __result = method(_javaPart);
+    return __result;
+  }
+  void JHybridWebImageFactorySpec::setMaxMemoryBytes(double maxMemoryBytes) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(double /* maxMemoryBytes */)>("setMaxMemoryBytes");
+    method(_javaPart, maxMemoryBytes);
+  }
 
   // Methods
   std::shared_ptr<margelo::nitro::image::HybridImageLoaderSpec> JHybridWebImageFactorySpec::createWebImageLoader(const std::string& url, const std::optional<AsyncImageLoadOptions>& options) {
diff --git a/packages/react-native-nitro-web-image/nitrogen/generated/android/c++/JHybridWebImageFactorySpec.hpp b/packages/react-native-nitro-web-image/nitrogen/generated/android/c++/JHybridWebImageFactorySpec.hpp
index 2b72b176..5843a47b 100644
--- a/packages/react-native-nitro-web-image/nitrogen/generated/android/c++/JHybridWebImageFactorySpec.hpp
+++ b/packages/react-native-nitro-web-image/nitrogen/generated/android/c++/JHybridWebImageFactorySpec.hpp
@@ -50,7 +50,8 @@ namespace margelo::nitro::web::image {
 
   public:
     // Properties
-    
+    double getMaxMemoryBytes() override;
+    void setMaxMemoryBytes(double maxMemoryBytes) override;
 
   public:
     // Methods
diff --git a/packages/react-native-nitro-web-image/nitrogen/generated/android/kotlin/com/margelo/nitro/web/image/HybridWebImageFactorySpec.kt b/packages/react-native-nitro-web-image/nitrogen/generated/android/kotlin/com/margelo/nitro/web/image/HybridWebImageFactorySpec.kt
index 929c9d8f..8ea7f592 100644
--- a/packages/react-native-nitro-web-image/nitrogen/generated/android/kotlin/com/margelo/nitro/web/image/HybridWebImageFactorySpec.kt
+++ b/packages/react-native-nitro-web-image/nitrogen/generated/android/kotlin/com/margelo/nitro/web/image/HybridWebImageFactorySpec.kt
@@ -28,7 +28,11 @@ import com.margelo.nitro.core.HybridObject
 )
 abstract class HybridWebImageFactorySpec: HybridObject() {
   // Properties
-  
+  @get:DoNotStrip
+  @get:Keep
+  @set:DoNotStrip
+  @set:Keep
+  abstract var maxMemoryBytes: Double
 
   // Methods
   @DoNotStrip
diff --git a/packages/react-native-nitro-web-image/nitrogen/generated/ios/c++/HybridWebImageFactorySpecSwift.hpp b/packages/react-native-nitro-web-image/nitrogen/generated/ios/c++/HybridWebImageFactorySpecSwift.hpp
index dccacced..10cc64c0 100644
--- a/packages/react-native-nitro-web-image/nitrogen/generated/ios/c++/HybridWebImageFactorySpecSwift.hpp
+++ b/packages/react-native-nitro-web-image/nitrogen/generated/ios/c++/HybridWebImageFactorySpecSwift.hpp
@@ -76,7 +76,12 @@ namespace margelo::nitro::web::image {
 
   public:
     // Properties
-    
+    inline double getMaxMemoryBytes() noexcept override {
+      return _swiftPart.getMaxMemoryBytes();
+    }
+    inline void setMaxMemoryBytes(double maxMemoryBytes) noexcept override {
+      _swiftPart.setMaxMemoryBytes(std::forward<decltype(maxMemoryBytes)>(maxMemoryBytes));
+    }
 
   public:
     // Methods
diff --git a/packages/react-native-nitro-web-image/nitrogen/generated/ios/swift/HybridWebImageFactorySpec.swift b/packages/react-native-nitro-web-image/nitrogen/generated/ios/swift/HybridWebImageFactorySpec.swift
index e79ff116..0eace650 100644
--- a/packages/react-native-nitro-web-image/nitrogen/generated/ios/swift/HybridWebImageFactorySpec.swift
+++ b/packages/react-native-nitro-web-image/nitrogen/generated/ios/swift/HybridWebImageFactorySpec.swift
@@ -11,7 +11,7 @@ import NitroModules
 /// See ``HybridWebImageFactorySpec``
 public protocol HybridWebImageFactorySpec_protocol: HybridObject {
   // Properties
-  
+  var maxMemoryBytes: Double { get set }
 
   // Methods
   func createWebImageLoader(url: String, options: AsyncImageLoadOptions?) throws -> (any HybridImageLoaderSpec)
diff --git a/packages/react-native-nitro-web-image/nitrogen/generated/ios/swift/HybridWebImageFactorySpec_cxx.swift b/packages/react-native-nitro-web-image/nitrogen/generated/ios/swift/HybridWebImageFactorySpec_cxx.swift
index 1b075797..6368095a 100644
--- a/packages/react-native-nitro-web-image/nitrogen/generated/ios/swift/HybridWebImageFactorySpec_cxx.swift
+++ b/packages/react-native-nitro-web-image/nitrogen/generated/ios/swift/HybridWebImageFactorySpec_cxx.swift
@@ -122,7 +122,16 @@ open class HybridWebImageFactorySpec_cxx {
   }
 
   // Properties
-  
+  public final var maxMemoryBytes: Double {
+    @inline(__always)
+    get {
+      return self.__implementation.maxMemoryBytes
+    }
+    @inline(__always)
+    set {
+      self.__implementation.maxMemoryBytes = newValue
+    }
+  }
 
   // Methods
   @inline(__always)
diff --git a/packages/react-native-nitro-web-image/nitrogen/generated/shared/c++/HybridWebImageFactorySpec.cpp b/packages/react-native-nitro-web-image/nitrogen/generated/shared/c++/HybridWebImageFactorySpec.cpp
index 7bb6801b..4e357a8b 100644
--- a/packages/react-native-nitro-web-image/nitrogen/generated/shared/c++/HybridWebImageFactorySpec.cpp
+++ b/packages/react-native-nitro-web-image/nitrogen/generated/shared/c++/HybridWebImageFactorySpec.cpp
@@ -14,6 +14,8 @@ namespace margelo::nitro::web::image {
     HybridObject::loadHybridMethods();
     // load custom methods/properties
     registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("maxMemoryBytes", &HybridWebImageFactorySpec::getMaxMemoryBytes);
+      prototype.registerHybridSetter("maxMemoryBytes", &HybridWebImageFactorySpec::setMaxMemoryBytes);
       prototype.registerHybridMethod("createWebImageLoader", &HybridWebImageFactorySpec::createWebImageLoader);
       prototype.registerHybridMethod("loadFromURLAsync", &HybridWebImageFactorySpec::loadFromURLAsync);
       prototype.registerHybridMethod("preload", &HybridWebImageFactorySpec::preload);
diff --git a/packages/react-native-nitro-web-image/nitrogen/generated/shared/c++/HybridWebImageFactorySpec.hpp b/packages/react-native-nitro-web-image/nitrogen/generated/shared/c++/HybridWebImageFactorySpec.hpp
index 6440db1f..fd4b9f37 100644
--- a/packages/react-native-nitro-web-image/nitrogen/generated/shared/c++/HybridWebImageFactorySpec.hpp
+++ b/packages/react-native-nitro-web-image/nitrogen/generated/shared/c++/HybridWebImageFactorySpec.hpp
@@ -55,7 +55,8 @@ namespace margelo::nitro::web::image {
 
     public:
       // Properties
-      
+      virtual double getMaxMemoryBytes() = 0;
+      virtual void setMaxMemoryBytes(double maxMemoryBytes) = 0;
 
     public:
       // Methods
diff --git a/packages/react-native-nitro-web-image/package.json b/packages/react-native-nitro-web-image/package.json
index 7c6f28eb..9f704b77 100644
--- a/packages/react-native-nitro-web-image/package.json
+++ b/packages/react-native-nitro-web-image/package.json
@@ -57,10 +57,10 @@
   },
   "devDependencies": {
     "@types/react": "^19.0.6",
-    "nitrogen": "0.35.5",
+    "nitrogen": "0.35.7",
     "react": "19.1.0",
     "react-native": "0.81.0",
-    "react-native-nitro-modules": "0.35.5",
+    "react-native-nitro-modules": "0.35.7",
     "typescript": "5.8.3"
   },
   "peerDependencies": {
diff --git a/packages/react-native-nitro-web-image/src/specs/WebImageFactory.nitro.ts b/packages/react-native-nitro-web-image/src/specs/WebImageFactory.nitro.ts
index 7f3bd8dd..1e89e61f 100644
--- a/packages/react-native-nitro-web-image/src/specs/WebImageFactory.nitro.ts
+++ b/packages/react-native-nitro-web-image/src/specs/WebImageFactory.nitro.ts
@@ -86,6 +86,18 @@ export interface AsyncImageLoadOptions {
 
 export interface WebImageFactory
   extends HybridObject<{ ios: 'swift'; android: 'kotlin' }> {
+  /**
+   * The maximum size, in bytes, of the in-memory image cache used by
+   * {@linkcode WebImages}.
+   *
+   * When the cache exceeds this budget, entries are evicted lowest
+   * {@linkcode NativeNitroImageViewProps.cachePriority | cachePriority}
+   * first, then least-recently-used within that priority.
+   *
+   * @default 64 * 1024 * 1024
+   */
+  maxMemoryBytes: number
+
   /**
    * Create a deferred {@linkcode ImageLoader} that loads the {@linkcode Image}
    * from the given {@linkcode url}.

From 9e091de834a2e2a8d0c336e4ad200f97b4035503 Mon Sep 17 00:00:00 2001
From: Dave Mkpa-Eke <daveydenco@gmail.com>
Date: Sat, 23 May 2026 00:40:54 +0100
Subject: [PATCH 2/5] add test tab

---
 example/src/CachePriorityTab.tsx | 30 ++++++++++++++++++++++--------
 1 file changed, 22 insertions(+), 8 deletions(-)

diff --git a/example/src/CachePriorityTab.tsx b/example/src/CachePriorityTab.tsx
index 07fb5037..84b0bd74 100644
--- a/example/src/CachePriorityTab.tsx
+++ b/example/src/CachePriorityTab.tsx
@@ -1,5 +1,12 @@
 import { useCallback, useMemo, useState } from 'react'
-import { Button, FlatList, Platform, StyleSheet, Text, View } from 'react-native'
+import {
+  Button,
+  FlatList,
+  Platform,
+  StyleSheet,
+  Text,
+  View,
+} from 'react-native'
 import { NitroImage } from 'react-native-nitro-image'
 import { WebImages } from 'react-native-nitro-web-image'
 import { createImageURLs } from './createImageURLs'
@@ -10,9 +17,13 @@ import { createImageURLs } from './createImageURLs'
 const DEMO_CACHE_BYTES = 3 * 1024 * 1024
 
 console.log(`[CachePriorityTab] platform: ${Platform.OS}`)
-console.log(`[CachePriorityTab] maxMemoryBytes before: ${WebImages.maxMemoryBytes}`)
+console.log(
+  `[CachePriorityTab] maxMemoryBytes before: ${WebImages.maxMemoryBytes}`,
+)
 WebImages.maxMemoryBytes = DEMO_CACHE_BYTES
-console.log(`[CachePriorityTab] maxMemoryBytes after:  ${WebImages.maxMemoryBytes}`)
+console.log(
+  `[CachePriorityTab] maxMemoryBytes after:  ${WebImages.maxMemoryBytes}`,
+)
 
 /**
  * Demonstrates cachePriority. The hero (priority 2) should survive cache
@@ -34,9 +45,7 @@ export function CachePriorityTab() {
     [thumbnailURLs],
   )
 
-  // Stable identity per hero remount; tied to the nonce so the URL identity
-  // changes only when the user taps "Reload hero".
-  const heroSource = useMemo(() => ({ url: heroURL }), [heroURL, heroNonce])
+  const heroSource = useMemo(() => ({ url: heroURL }), [heroURL])
 
   const renderItem = useCallback(
     ({ item: source }: { item: { url: string } }) => (
@@ -62,8 +71,13 @@ export function CachePriorityTab() {
         resizeMode="cover"
       />
       <View style={styles.buttonRow}>
-        <Text style={styles.counter}>Remounted: {heroNonce} • check logcat: 1 SET, {heroNonce} HITs</Text>
-        <Button title="Reload hero" onPress={() => setHeroNonce((n) => n + 1)} />
+        <Text style={styles.counter}>
+          Remounted: {heroNonce} • check logcat: 1 SET, {heroNonce} HITs
+        </Text>
+        <Button
+          title="Reload hero"
+          onPress={() => setHeroNonce((n) => n + 1)}
+        />
       </View>
       <Text style={styles.label}>Thumbnails (no cachePriority)</Text>
       <FlatList

From 39695e8edc80fce76f6c49d6d7ec3240373fc191 Mon Sep 17 00:00:00 2001
From: Dave Mkpa-Eke <daveydenco@gmail.com>
Date: Sat, 23 May 2026 00:48:37 +0100
Subject: [PATCH 3/5] cleanup

---
 example/src/CachePriorityTab.tsx              | 34 +------------------
 .../android/build.gradle                      |  2 --
 2 files changed, 1 insertion(+), 35 deletions(-)

diff --git a/example/src/CachePriorityTab.tsx b/example/src/CachePriorityTab.tsx
index 84b0bd74..0a56a2e1 100644
--- a/example/src/CachePriorityTab.tsx
+++ b/example/src/CachePriorityTab.tsx
@@ -1,45 +1,13 @@
 import { useCallback, useMemo, useState } from 'react'
-import {
-  Button,
-  FlatList,
-  Platform,
-  StyleSheet,
-  Text,
-  View,
-} from 'react-native'
+import { Button, FlatList, StyleSheet, Text, View } from 'react-native'
 import { NitroImage } from 'react-native-nitro-image'
-import { WebImages } from 'react-native-nitro-web-image'
 import { createImageURLs } from './createImageURLs'
 
-// Baseline run: tight cap + no priorities anywhere. 3 MB sits just above the
-// 800×800 hero (~2.56 MB decoded RGBA) so it can land in cache, then the
-// first thumbnail load should LRU-evict it.
-const DEMO_CACHE_BYTES = 3 * 1024 * 1024
-
-console.log(`[CachePriorityTab] platform: ${Platform.OS}`)
-console.log(
-  `[CachePriorityTab] maxMemoryBytes before: ${WebImages.maxMemoryBytes}`,
-)
-WebImages.maxMemoryBytes = DEMO_CACHE_BYTES
-console.log(
-  `[CachePriorityTab] maxMemoryBytes after:  ${WebImages.maxMemoryBytes}`,
-)
-
-/**
- * Demonstrates cachePriority. The hero (priority 2) should survive cache
- * pressure while thumbnails (priority 0) churn. With the configured cap,
- * scrolling many thumbs evicts thumbs first; tapping "Reload hero" should
- * give an instant cache hit, while thumbnails that scrolled off may need
- * to be refetched.
- */
 export function CachePriorityTab() {
   const heroURL = useMemo(() => `https://picsum.photos/seed/hero/800`, [])
   const thumbnailURLs = useMemo(() => createImageURLs(200), [])
   const [heroNonce, setHeroNonce] = useState(0)
 
-  // Pre-build the {url} objects once so each row's `image` prop has a stable
-  // reference across re-renders — otherwise an inline `{ url }` literal would
-  // create a new object every render and re-trigger the native `image` setter.
   const thumbnailSources = useMemo(
     () => thumbnailURLs.map((url) => ({ url })),
     [thumbnailURLs],
diff --git a/packages/react-native-nitro-web-image/android/build.gradle b/packages/react-native-nitro-web-image/android/build.gradle
index 2b44e8f9..65fb61b0 100644
--- a/packages/react-native-nitro-web-image/android/build.gradle
+++ b/packages/react-native-nitro-web-image/android/build.gradle
@@ -145,7 +145,5 @@ dependencies {
   implementation("io.coil-kt.coil3:coil-gif:3.3.0")
   // Lock primitive used to match Coil's RealMemoryCache synchronization.
   implementation("org.jetbrains.kotlinx:atomicfu:0.29.0")
-
-  testImplementation("junit:junit:4.13.2")
 }
 

From 5ae9e8f66263f35bc96c932b33ff7a1426ec4f9d Mon Sep 17 00:00:00 2001
From: Dave Mkpa-Eke <daveydenco@gmail.com>
Date: Sat, 23 May 2026 00:59:03 +0100
Subject: [PATCH 4/5] more cleanup

---
 .../margelo/nitro/web/image/HybridWebImageFactory.kt |  6 ------
 .../ios/HybridWebImageFactory.swift                  |  5 -----
 .../android/c++/JHybridWebImageFactorySpec.cpp       | 10 +---------
 .../android/c++/JHybridWebImageFactorySpec.hpp       |  3 +--
 .../margelo/nitro/web/image/AsyncImageLoadOptions.kt |  2 +-
 .../nitro/web/image/HybridWebImageFactorySpec.kt     |  6 +-----
 .../ios/c++/HybridWebImageFactorySpecSwift.hpp       |  7 +------
 .../ios/swift/HybridWebImageFactorySpec.swift        |  2 +-
 .../ios/swift/HybridWebImageFactorySpec_cxx.swift    | 11 +----------
 .../shared/c++/HybridWebImageFactorySpec.cpp         |  2 --
 .../shared/c++/HybridWebImageFactorySpec.hpp         |  3 +--
 .../src/specs/WebImageFactory.nitro.ts               | 12 ------------
 12 files changed, 8 insertions(+), 61 deletions(-)

diff --git a/packages/react-native-nitro-web-image/android/src/main/java/com/margelo/nitro/web/image/HybridWebImageFactory.kt b/packages/react-native-nitro-web-image/android/src/main/java/com/margelo/nitro/web/image/HybridWebImageFactory.kt
index 04a0019e..e8ad51f6 100644
--- a/packages/react-native-nitro-web-image/android/src/main/java/com/margelo/nitro/web/image/HybridWebImageFactory.kt
+++ b/packages/react-native-nitro-web-image/android/src/main/java/com/margelo/nitro/web/image/HybridWebImageFactory.kt
@@ -27,12 +27,6 @@ class HybridWebImageFactory: HybridWebImageFactorySpec() {
         }
         .build()
 
-    override var maxMemoryBytes: Double
-        get() = (imageLoader.memoryCache?.maxSize ?: 0L).toDouble()
-        set(value) {
-            imageLoader.memoryCache?.maxSize = value.toLong()
-        }
-
     override fun createWebImageLoader(
         url: String,
         options: AsyncImageLoadOptions?
diff --git a/packages/react-native-nitro-web-image/ios/HybridWebImageFactory.swift b/packages/react-native-nitro-web-image/ios/HybridWebImageFactory.swift
index 7e73e01d..0e32cc42 100644
--- a/packages/react-native-nitro-web-image/ios/HybridWebImageFactory.swift
+++ b/packages/react-native-nitro-web-image/ios/HybridWebImageFactory.swift
@@ -23,11 +23,6 @@ class HybridWebImageFactory: HybridWebImageFactorySpec {
     super.init()
   }
 
-  var maxMemoryBytes: Double {
-    get { Double(SDImageCacheConfig.default.maxMemoryCost) }
-    set { SDImageCacheConfig.default.maxMemoryCost = UInt(max(0, newValue)) }
-  }
-
   func loadFromURLAsync(url urlString: String, options: AsyncImageLoadOptions?) throws -> Promise<any HybridImageSpec> {
     guard let url = URL(string: urlString) else {
       throw RuntimeError.error(withMessage: "URL string \"\(urlString)\" is not a valid URL!")
diff --git a/packages/react-native-nitro-web-image/nitrogen/generated/android/c++/JHybridWebImageFactorySpec.cpp b/packages/react-native-nitro-web-image/nitrogen/generated/android/c++/JHybridWebImageFactorySpec.cpp
index 193c36c7..891f71ab 100644
--- a/packages/react-native-nitro-web-image/nitrogen/generated/android/c++/JHybridWebImageFactorySpec.cpp
+++ b/packages/react-native-nitro-web-image/nitrogen/generated/android/c++/JHybridWebImageFactorySpec.cpp
@@ -60,15 +60,7 @@ namespace margelo::nitro::web::image {
   }
 
   // Properties
-  double JHybridWebImageFactorySpec::getMaxMemoryBytes() {
-    static const auto method = _javaPart->javaClassStatic()->getMethod<double()>("getMaxMemoryBytes");
-    auto __result = method(_javaPart);
-    return __result;
-  }
-  void JHybridWebImageFactorySpec::setMaxMemoryBytes(double maxMemoryBytes) {
-    static const auto method = _javaPart->javaClassStatic()->getMethod<void(double /* maxMemoryBytes */)>("setMaxMemoryBytes");
-    method(_javaPart, maxMemoryBytes);
-  }
+  
 
   // Methods
   std::shared_ptr<margelo::nitro::image::HybridImageLoaderSpec> JHybridWebImageFactorySpec::createWebImageLoader(const std::string& url, const std::optional<AsyncImageLoadOptions>& options) {
diff --git a/packages/react-native-nitro-web-image/nitrogen/generated/android/c++/JHybridWebImageFactorySpec.hpp b/packages/react-native-nitro-web-image/nitrogen/generated/android/c++/JHybridWebImageFactorySpec.hpp
index 5843a47b..2b72b176 100644
--- a/packages/react-native-nitro-web-image/nitrogen/generated/android/c++/JHybridWebImageFactorySpec.hpp
+++ b/packages/react-native-nitro-web-image/nitrogen/generated/android/c++/JHybridWebImageFactorySpec.hpp
@@ -50,8 +50,7 @@ namespace margelo::nitro::web::image {
 
   public:
     // Properties
-    double getMaxMemoryBytes() override;
-    void setMaxMemoryBytes(double maxMemoryBytes) override;
+    
 
   public:
     // Methods
diff --git a/packages/react-native-nitro-web-image/nitrogen/generated/android/kotlin/com/margelo/nitro/web/image/AsyncImageLoadOptions.kt b/packages/react-native-nitro-web-image/nitrogen/generated/android/kotlin/com/margelo/nitro/web/image/AsyncImageLoadOptions.kt
index 737c13c5..00c765f9 100644
--- a/packages/react-native-nitro-web-image/nitrogen/generated/android/kotlin/com/margelo/nitro/web/image/AsyncImageLoadOptions.kt
+++ b/packages/react-native-nitro-web-image/nitrogen/generated/android/kotlin/com/margelo/nitro/web/image/AsyncImageLoadOptions.kt
@@ -71,7 +71,7 @@ data class AsyncImageLoadOptions(
   }
 
   override fun hashCode(): Int {
-    return arrayOf(
+    return arrayOf<Any?>(
       priority,
       forceRefresh,
       cacheKey,
diff --git a/packages/react-native-nitro-web-image/nitrogen/generated/android/kotlin/com/margelo/nitro/web/image/HybridWebImageFactorySpec.kt b/packages/react-native-nitro-web-image/nitrogen/generated/android/kotlin/com/margelo/nitro/web/image/HybridWebImageFactorySpec.kt
index 8ea7f592..929c9d8f 100644
--- a/packages/react-native-nitro-web-image/nitrogen/generated/android/kotlin/com/margelo/nitro/web/image/HybridWebImageFactorySpec.kt
+++ b/packages/react-native-nitro-web-image/nitrogen/generated/android/kotlin/com/margelo/nitro/web/image/HybridWebImageFactorySpec.kt
@@ -28,11 +28,7 @@ import com.margelo.nitro.core.HybridObject
 )
 abstract class HybridWebImageFactorySpec: HybridObject() {
   // Properties
-  @get:DoNotStrip
-  @get:Keep
-  @set:DoNotStrip
-  @set:Keep
-  abstract var maxMemoryBytes: Double
+  
 
   // Methods
   @DoNotStrip
diff --git a/packages/react-native-nitro-web-image/nitrogen/generated/ios/c++/HybridWebImageFactorySpecSwift.hpp b/packages/react-native-nitro-web-image/nitrogen/generated/ios/c++/HybridWebImageFactorySpecSwift.hpp
index 10cc64c0..dccacced 100644
--- a/packages/react-native-nitro-web-image/nitrogen/generated/ios/c++/HybridWebImageFactorySpecSwift.hpp
+++ b/packages/react-native-nitro-web-image/nitrogen/generated/ios/c++/HybridWebImageFactorySpecSwift.hpp
@@ -76,12 +76,7 @@ namespace margelo::nitro::web::image {
 
   public:
     // Properties
-    inline double getMaxMemoryBytes() noexcept override {
-      return _swiftPart.getMaxMemoryBytes();
-    }
-    inline void setMaxMemoryBytes(double maxMemoryBytes) noexcept override {
-      _swiftPart.setMaxMemoryBytes(std::forward<decltype(maxMemoryBytes)>(maxMemoryBytes));
-    }
+    
 
   public:
     // Methods
diff --git a/packages/react-native-nitro-web-image/nitrogen/generated/ios/swift/HybridWebImageFactorySpec.swift b/packages/react-native-nitro-web-image/nitrogen/generated/ios/swift/HybridWebImageFactorySpec.swift
index 0eace650..e79ff116 100644
--- a/packages/react-native-nitro-web-image/nitrogen/generated/ios/swift/HybridWebImageFactorySpec.swift
+++ b/packages/react-native-nitro-web-image/nitrogen/generated/ios/swift/HybridWebImageFactorySpec.swift
@@ -11,7 +11,7 @@ import NitroModules
 /// See ``HybridWebImageFactorySpec``
 public protocol HybridWebImageFactorySpec_protocol: HybridObject {
   // Properties
-  var maxMemoryBytes: Double { get set }
+  
 
   // Methods
   func createWebImageLoader(url: String, options: AsyncImageLoadOptions?) throws -> (any HybridImageLoaderSpec)
diff --git a/packages/react-native-nitro-web-image/nitrogen/generated/ios/swift/HybridWebImageFactorySpec_cxx.swift b/packages/react-native-nitro-web-image/nitrogen/generated/ios/swift/HybridWebImageFactorySpec_cxx.swift
index 6368095a..1b075797 100644
--- a/packages/react-native-nitro-web-image/nitrogen/generated/ios/swift/HybridWebImageFactorySpec_cxx.swift
+++ b/packages/react-native-nitro-web-image/nitrogen/generated/ios/swift/HybridWebImageFactorySpec_cxx.swift
@@ -122,16 +122,7 @@ open class HybridWebImageFactorySpec_cxx {
   }
 
   // Properties
-  public final var maxMemoryBytes: Double {
-    @inline(__always)
-    get {
-      return self.__implementation.maxMemoryBytes
-    }
-    @inline(__always)
-    set {
-      self.__implementation.maxMemoryBytes = newValue
-    }
-  }
+  
 
   // Methods
   @inline(__always)
diff --git a/packages/react-native-nitro-web-image/nitrogen/generated/shared/c++/HybridWebImageFactorySpec.cpp b/packages/react-native-nitro-web-image/nitrogen/generated/shared/c++/HybridWebImageFactorySpec.cpp
index 4e357a8b..7bb6801b 100644
--- a/packages/react-native-nitro-web-image/nitrogen/generated/shared/c++/HybridWebImageFactorySpec.cpp
+++ b/packages/react-native-nitro-web-image/nitrogen/generated/shared/c++/HybridWebImageFactorySpec.cpp
@@ -14,8 +14,6 @@ namespace margelo::nitro::web::image {
     HybridObject::loadHybridMethods();
     // load custom methods/properties
     registerHybrids(this, [](Prototype& prototype) {
-      prototype.registerHybridGetter("maxMemoryBytes", &HybridWebImageFactorySpec::getMaxMemoryBytes);
-      prototype.registerHybridSetter("maxMemoryBytes", &HybridWebImageFactorySpec::setMaxMemoryBytes);
       prototype.registerHybridMethod("createWebImageLoader", &HybridWebImageFactorySpec::createWebImageLoader);
       prototype.registerHybridMethod("loadFromURLAsync", &HybridWebImageFactorySpec::loadFromURLAsync);
       prototype.registerHybridMethod("preload", &HybridWebImageFactorySpec::preload);
diff --git a/packages/react-native-nitro-web-image/nitrogen/generated/shared/c++/HybridWebImageFactorySpec.hpp b/packages/react-native-nitro-web-image/nitrogen/generated/shared/c++/HybridWebImageFactorySpec.hpp
index fd4b9f37..6440db1f 100644
--- a/packages/react-native-nitro-web-image/nitrogen/generated/shared/c++/HybridWebImageFactorySpec.hpp
+++ b/packages/react-native-nitro-web-image/nitrogen/generated/shared/c++/HybridWebImageFactorySpec.hpp
@@ -55,8 +55,7 @@ namespace margelo::nitro::web::image {
 
     public:
       // Properties
-      virtual double getMaxMemoryBytes() = 0;
-      virtual void setMaxMemoryBytes(double maxMemoryBytes) = 0;
+      
 
     public:
       // Methods
diff --git a/packages/react-native-nitro-web-image/src/specs/WebImageFactory.nitro.ts b/packages/react-native-nitro-web-image/src/specs/WebImageFactory.nitro.ts
index 1e89e61f..7f3bd8dd 100644
--- a/packages/react-native-nitro-web-image/src/specs/WebImageFactory.nitro.ts
+++ b/packages/react-native-nitro-web-image/src/specs/WebImageFactory.nitro.ts
@@ -86,18 +86,6 @@ export interface AsyncImageLoadOptions {
 
 export interface WebImageFactory
   extends HybridObject<{ ios: 'swift'; android: 'kotlin' }> {
-  /**
-   * The maximum size, in bytes, of the in-memory image cache used by
-   * {@linkcode WebImages}.
-   *
-   * When the cache exceeds this budget, entries are evicted lowest
-   * {@linkcode NativeNitroImageViewProps.cachePriority | cachePriority}
-   * first, then least-recently-used within that priority.
-   *
-   * @default 64 * 1024 * 1024
-   */
-  maxMemoryBytes: number
-
   /**
    * Create a deferred {@linkcode ImageLoader} that loads the {@linkcode Image}
    * from the given {@linkcode url}.

From 8b13b66816c151d917ae5894de46d9bdde2c04bc Mon Sep 17 00:00:00 2001
From: Dave Mkpa-Eke <daveydenco@gmail.com>
Date: Sat, 23 May 2026 01:02:05 +0100
Subject: [PATCH 5/5] cleanup

---
 .../ios/HybridWebImageFactory.swift                      | 9 ++-------
 1 file changed, 2 insertions(+), 7 deletions(-)

diff --git a/packages/react-native-nitro-web-image/ios/HybridWebImageFactory.swift b/packages/react-native-nitro-web-image/ios/HybridWebImageFactory.swift
index 0e32cc42..e732ae39 100644
--- a/packages/react-native-nitro-web-image/ios/HybridWebImageFactory.swift
+++ b/packages/react-native-nitro-web-image/ios/HybridWebImageFactory.swift
@@ -12,14 +12,9 @@ import NitroImage
 
 class HybridWebImageFactory: HybridWebImageFactorySpec {
   override init() {
-    // Install our priority-aware memory cache as the shared SDImageCache class.
-    // Setting this on the default config must happen before any SDImageCache
-    // instance is constructed, so do it here on the factory's first init.
+    // Must be set before any SDImageCache instance is constructed.
     SDImageCacheConfig.default.memoryCacheClass = PriorityMemoryCache.self
-    // NOTE: deliberately small for demo/manual verification of priority eviction.
-    // Big enough to hold a handful of decoded bitmaps so eviction is observable.
-    // Restore to 64 * 1024 * 1024 for production defaults.
-    SDImageCacheConfig.default.maxMemoryCost = 16 * 1024 * 1024
+    SDImageCacheConfig.default.maxMemoryCost = 64 * 1024 * 1024 // Set default memory to 64MB.
     super.init()
   }