@shopify/react-native-skia 2.2.11 → 2.2.13

package/cpp/api/JsiSkRuntimeShaderBuilder.h

@@ -56,9 +56,14 @@ public:
   static jsi::Value toValue(jsi::Runtime &runtime,
                             std::shared_ptr<RNSkPlatformContext> context,
                             const SkRuntimeShaderBuilder &rt) {
-    return jsi::Object::createFromHostObject(
-        runtime,
-        std::make_shared<JsiSkRuntimeShaderBuilder>(std::move(context), rt));
+    auto builder =
+        std::make_shared<JsiSkRuntimeShaderBuilder>(std::move(context), rt);
+    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, builder,
+                                                       context);
+  }
+
+  size_t getMemoryPressure() const override {
+    return sizeof(SkRuntimeShaderBuilder);
   }
 
   /**
@@ -74,9 +79,10 @@ public:
       auto rt = JsiSkRuntimeEffect::fromValue(runtime, arguments[0]);
       auto rtb = SkRuntimeShaderBuilder(rt);
       // Return the newly constructed object
-      return jsi::Object::createFromHostObject(
-          runtime, std::make_shared<JsiSkRuntimeShaderBuilder>(
-                       std::move(context), std::move(rtb)));
+      auto builder = std::make_shared<JsiSkRuntimeShaderBuilder>(
+          std::move(context), std::move(rtb));
+      return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, builder,
+                                                         context);
     };
   }
 };

package/cpp/api/JsiSkSVG.h

@@ -45,6 +45,30 @@ public:
                                    const jsi::Value &obj) {
     return obj.asObject(runtime).asHostObject<JsiSkSVG>(runtime)->getObject();
   }
+
+  size_t getMemoryPressure() const override {
+    auto svgdom = getObject();
+    if (!svgdom) {
+      return 1024; // Base size if no SVG
+    }
+
+    auto containerSize = svgdom->containerSize();
+
+    // Estimate memory usage based on SVG dimensions
+    // SVG rendering typically requires:
+    // - Vector data storage (base overhead)
+    // - Potential rasterization buffer (width * height * 4 bytes per pixel)
+    size_t rasterBufferSize =
+        static_cast<size_t>(containerSize.width() * containerSize.height() * 4);
+
+    // Add base overhead for SVG DOM structure, paths, and vector data
+    size_t baseOverhead = 32 * 1024; // 32KB for SVG DOM, paths, styles, etc.
+
+    // SVGs are typically lighter than raster images but heavier than simple
+    // vectors Use a fraction of full raster size plus base overhead
+    return (rasterBufferSize / 4) +
+           baseOverhead; // Quarter of full raster + overhead
+  }
 };
 
 } // namespace RNSkia

package/cpp/api/JsiSkSVGFactory.h

@@ -27,18 +27,22 @@ public:
     auto data = JsiSkData::fromValue(runtime, arguments[0]);
     auto stream = SkMemoryStream::Make(data);
     auto svg_dom = SkSVGDOM::Builder().make(*stream);
-    return jsi::Object::createFromHostObject(
-        runtime, std::make_shared<JsiSkSVG>(getContext(), std::move(svg_dom)));
+    auto svg = std::make_shared<JsiSkSVG>(getContext(), std::move(svg_dom));
+    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, svg,
+                                                       getContext());
   }
 
   JSI_HOST_FUNCTION(MakeFromString) {
     auto svgText = arguments[0].asString(runtime).utf8(runtime);
     auto stream = SkMemoryStream::MakeDirect(svgText.c_str(), svgText.size());
     auto svg_dom = SkSVGDOM::Builder().make(*stream);
-    return jsi::Object::createFromHostObject(
-        runtime, std::make_shared<JsiSkSVG>(getContext(), std::move(svg_dom)));
+    auto svg = std::make_shared<JsiSkSVG>(getContext(), std::move(svg_dom));
+    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, svg,
+                                                       getContext());
   }
 
+  size_t getMemoryPressure() const override { return 512; }
+
   JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkSVGFactory, MakeFromData),
                        JSI_EXPORT_FUNC(JsiSkSVGFactory, MakeFromString))
 

package/cpp/api/JsiSkShader.h

@@ -26,6 +26,8 @@ public:
       : JsiSkWrappingSkPtrHostObject<SkShader>(std::move(context),
                                                std::move(shader)) {}
 
+  size_t getMemoryPressure() const override { return 4096; }
+
   EXPORT_JSI_API_TYPENAME(JsiSkShader, Shader)
   JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkShader, dispose))
 };

package/cpp/api/JsiSkShaderFactory.h

@@ -100,9 +100,10 @@ public:
     sk_sp<SkShader> gradient = SkGradientShader::MakeLinear(
         pts, colors.data(), !positions.empty() ? positions.data() : nullptr,
         static_cast<int>(colorsSize), tileMode, flag, localMatrix);
-    return jsi::Object::createFromHostObject(
-        runtime,
-        std::make_shared<JsiSkShader>(getContext(), std::move(gradient)));
+    auto shader =
+        std::make_shared<JsiSkShader>(getContext(), std::move(gradient));
+    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, shader,
+                                                       getContext());
   }
 
   JSI_HOST_FUNCTION(MakeRadialGradient) {
@@ -128,9 +129,10 @@ public:
         center, r, colors.data(),
         !positions.empty() ? positions.data() : nullptr,
         static_cast<int>(colorsSize), tileMode, flag, localMatrix);
-    return jsi::Object::createFromHostObject(
-        runtime,
-        std::make_shared<JsiSkShader>(getContext(), std::move(gradient)));
+    auto shader =
+        std::make_shared<JsiSkShader>(getContext(), std::move(gradient));
+    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, shader,
+                                                       getContext());
   }
 
   JSI_HOST_FUNCTION(MakeSweepGradient) {
@@ -158,9 +160,10 @@ public:
         x, y, colors.data(), !positions.empty() ? positions.data() : nullptr,
         static_cast<int>(colorsSize), tileMode, startAngle, endAngle, flag,
         localMatrix);
-    return jsi::Object::createFromHostObject(
-        runtime,
-        std::make_shared<JsiSkShader>(getContext(), std::move(gradient)));
+    auto shader =
+        std::make_shared<JsiSkShader>(getContext(), std::move(gradient));
+    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, shader,
+                                                       getContext());
   }
 
   JSI_HOST_FUNCTION(MakeTwoPointConicalGradient) {
@@ -191,9 +194,10 @@ public:
         !positions.empty() ? positions.data() : nullptr,
         static_cast<int>(colorsSize), tileMode, flag, localMatrix);
 
-    return jsi::Object::createFromHostObject(
-        runtime,
-        std::make_shared<JsiSkShader>(getContext(), std::move(gradient)));
+    auto shader =
+        std::make_shared<JsiSkShader>(getContext(), std::move(gradient));
+    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, shader,
+                                                       getContext());
   }
 
   JSI_HOST_FUNCTION(MakeTurbulence) {
@@ -206,9 +210,10 @@ public:
     SkISize size = SkISize::Make(tileW, tileH);
     sk_sp<SkShader> gradient =
         SkShaders::MakeTurbulence(baseFreqX, baseFreqY, octaves, seed, &size);
-    return jsi::Object::createFromHostObject(
-        runtime,
-        std::make_shared<JsiSkShader>(getContext(), std::move(gradient)));
+    auto shader =
+        std::make_shared<JsiSkShader>(getContext(), std::move(gradient));
+    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, shader,
+                                                       getContext());
   }
 
   JSI_HOST_FUNCTION(MakeFractalNoise) {
@@ -221,9 +226,10 @@ public:
     SkISize size = SkISize::Make(tileW, tileH);
     sk_sp<SkShader> gradient =
         SkShaders::MakeFractalNoise(baseFreqX, baseFreqY, octaves, seed, &size);
-    return jsi::Object::createFromHostObject(
-        runtime,
-        std::make_shared<JsiSkShader>(getContext(), std::move(gradient)));
+    auto shader =
+        std::make_shared<JsiSkShader>(getContext(), std::move(gradient));
+    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, shader,
+                                                       getContext());
   }
 
   JSI_HOST_FUNCTION(MakeBlend) {
@@ -231,19 +237,23 @@ public:
     auto one = JsiSkShader::fromValue(runtime, arguments[1]);
     auto two = JsiSkShader::fromValue(runtime, arguments[2]);
     sk_sp<SkShader> gradient = SkShaders::Blend(blendMode, one, two);
-    return jsi::Object::createFromHostObject(
-        runtime,
-        std::make_shared<JsiSkShader>(getContext(), std::move(gradient)));
+    auto shader =
+        std::make_shared<JsiSkShader>(getContext(), std::move(gradient));
+    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, shader,
+                                                       getContext());
   }
 
   JSI_HOST_FUNCTION(MakeColor) {
     auto color = JsiSkColor::fromValue(runtime, arguments[0]);
     sk_sp<SkShader> gradient = SkShaders::Color(color);
-    return jsi::Object::createFromHostObject(
-        runtime,
-        std::make_shared<JsiSkShader>(getContext(), std::move(gradient)));
+    auto shader =
+        std::make_shared<JsiSkShader>(getContext(), std::move(gradient));
+    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, shader,
+                                                       getContext());
   }
 
+  size_t getMemoryPressure() const override { return 1024; }
+
   JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkShaderFactory, MakeLinearGradient),
                        JSI_EXPORT_FUNC(JsiSkShaderFactory, MakeRadialGradient),
                        JSI_EXPORT_FUNC(JsiSkShaderFactory, MakeSweepGradient),

package/cpp/api/JsiSkSkottie.h

@@ -586,5 +586,34 @@ public:
                std::shared_ptr<ManagedAnimation> animation)
       : JsiSkWrappingSharedPtrHostObject<ManagedAnimation>(
             std::move(context), std::move(animation)) {}
+
+  size_t getMemoryPressure() const override {
+    auto animation = getObject();
+    if (!animation || !animation->_animation) {
+      return 1024; // Base size if no animation
+    }
+
+    auto size = animation->_animation->size();
+    auto duration = animation->_animation->duration();
+    auto fps = animation->_animation->fps();
+
+    // Estimate memory usage based on animation properties
+    // Base calculation: width * height * 4 bytes per pixel * estimated frame
+    // count
+    size_t frameCount = static_cast<size_t>(duration * fps);
+    size_t estimatedFrameSize =
+        static_cast<size_t>(size.width() * size.height() * 4);
+
+    // Conservative estimate: assume some frames are cached
+    size_t cachedFrames =
+        std::min(frameCount, static_cast<size_t>(60)); // Max 60 cached frames
+    size_t animationMemory = estimatedFrameSize * cachedFrames;
+
+    // Add base overhead for animation data structures
+    size_t baseOverhead =
+        64 * 1024; // 64KB for metadata, property managers, etc.
+
+    return animationMemory + baseOverhead;
+  }
 };
 } // namespace RNSkia

package/cpp/api/JsiSkSurface.h

@@ -43,9 +43,10 @@ public:
   }
 
   JSI_HOST_FUNCTION(getCanvas) {
-    return jsi::Object::createFromHostObject(
-        runtime,
-        std::make_shared<JsiSkCanvas>(getContext(), getObject()->getCanvas()));
+    auto canvas =
+        std::make_shared<JsiSkCanvas>(getContext(), getObject()->getCanvas());
+    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, canvas,
+                                                       getContext());
   }
 
   JSI_HOST_FUNCTION(flush) {
@@ -81,8 +82,10 @@ public:
       jsiImage->setObject(image);
       return jsi::Value(runtime, arguments[1]);
     }
-    return jsi::Object::createFromHostObject(
-        runtime, std::make_shared<JsiSkImage>(getContext(), std::move(image)));
+    auto hostObjectInstance =
+        std::make_shared<JsiSkImage>(getContext(), std::move(image));
+    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
+        runtime, hostObjectInstance, getContext());
   }
 
   JSI_HOST_FUNCTION(getNativeTextureUnstable) {
@@ -90,6 +93,19 @@ public:
     return JsiTextureInfo::toValue(runtime, texInfo);
   }
 
+  size_t getMemoryPressure() const override {
+    auto surface = getObject();
+    if (!surface)
+      return 0;
+
+    // Surface memory is primarily the pixel buffer: width × height × bytes per
+    // pixel
+    int width = surface->width();
+    int height = surface->height();
+    // Assume 4 bytes per pixel (RGBA) for most surfaces
+    return width * height * 4;
+  }
+
   JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkSurface, width),
                        JSI_EXPORT_FUNC(JsiSkSurface, height),
                        JSI_EXPORT_FUNC(JsiSkSurface, getCanvas),

package/cpp/api/JsiSkSurfaceFactory.h

@@ -30,9 +30,10 @@ public:
     if (surface == nullptr) {
       return jsi::Value::null();
     }
-    return jsi::Object::createFromHostObject(
-        runtime,
-        std::make_shared<JsiSkSurface>(getContext(), std::move(surface)));
+    auto hostObjectInstance =
+        std::make_shared<JsiSkSurface>(getContext(), std::move(surface));
+    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
+        runtime, hostObjectInstance, getContext());
   }
 
   JSI_HOST_FUNCTION(MakeOffscreen) {
@@ -43,14 +44,17 @@ public:
     if (surface == nullptr) {
       return jsi::Value::null();
     }
-    return jsi::Object::createFromHostObject(
-        runtime,
-        std::make_shared<JsiSkSurface>(getContext(), std::move(surface)));
+    auto hostObjectInstance =
+        std::make_shared<JsiSkSurface>(getContext(), std::move(surface));
+    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
+        runtime, hostObjectInstance, getContext());
   }
 
   JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkSurfaceFactory, Make),
                        JSI_EXPORT_FUNC(JsiSkSurfaceFactory, MakeOffscreen))
 
+  size_t getMemoryPressure() const override { return 2048; }
+
   explicit JsiSkSurfaceFactory(std::shared_ptr<RNSkPlatformContext> context)
       : JsiSkHostObject(std::move(context)) {}
 };

package/cpp/api/JsiSkTextBlob.h

@@ -25,6 +25,18 @@ public:
       : JsiSkWrappingSkPtrHostObject<SkTextBlob>(std::move(context),
                                                  std::move(shader)) {}
 
+  size_t getMemoryPressure() const override {
+    auto textBlob = getObject();
+    if (!textBlob)
+      return 0;
+
+    // For SkTextBlob, we'll estimate based on glyph data and text positioning
+    // SkTextBlob doesn't provide direct size methods, so estimate
+    // conservatively
+    return textBlob->bounds().width() * textBlob->bounds().height() +
+           1024; // Area estimation + base overhead
+  }
+
   EXPORT_JSI_API_TYPENAME(JsiSkTextBlob, TextBlob)
   JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkTextBlob, dispose))
 };

package/cpp/api/JsiSkTextBlobFactory.h

@@ -28,9 +28,10 @@ public:
     auto str = arguments[0].asString(runtime).utf8(runtime);
     auto font = JsiSkFont::fromValue(runtime, arguments[1]);
     auto textBlob = SkTextBlob::MakeFromString(str.c_str(), *font);
-    return jsi::Object::createFromHostObject(
-        runtime,
-        std::make_shared<JsiSkTextBlob>(getContext(), std::move(textBlob)));
+    auto hostObjectInstance =
+        std::make_shared<JsiSkTextBlob>(getContext(), std::move(textBlob));
+    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
+        runtime, hostObjectInstance, getContext());
   }
 
   JSI_HOST_FUNCTION(MakeFromGlyphs) {
@@ -46,9 +47,10 @@ public:
     auto textBlob =
         SkTextBlob::MakeFromText(glyphs.data(), glyphs.size() * bytesPerGlyph,
                                  *font, SkTextEncoding::kGlyphID);
-    return jsi::Object::createFromHostObject(
-        runtime,
-        std::make_shared<JsiSkTextBlob>(getContext(), std::move(textBlob)));
+    auto hostObjectInstance =
+        std::make_shared<JsiSkTextBlob>(getContext(), std::move(textBlob));
+    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
+        runtime, hostObjectInstance, getContext());
   }
 
   JSI_HOST_FUNCTION(MakeFromRSXform) {
@@ -66,9 +68,10 @@ public:
     auto x = SkSpan(rsxforms.data(), rsxforms.size());
     auto textBlob =
         SkTextBlob::MakeFromRSXform(str.c_str(), str.length(), x, *font);
-    return jsi::Object::createFromHostObject(
-        runtime,
-        std::make_shared<JsiSkTextBlob>(getContext(), std::move(textBlob)));
+    auto hostObjectInstance =
+        std::make_shared<JsiSkTextBlob>(getContext(), std::move(textBlob));
+    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
+        runtime, hostObjectInstance, getContext());
   }
 
   JSI_HOST_FUNCTION(MakeFromRSXformGlyphs) {
@@ -94,9 +97,10 @@ public:
     auto textBlob = SkTextBlob::MakeFromRSXform(
         glyphs.data(), glyphs.size() * bytesPerGlyph, x, *font,
         SkTextEncoding::kGlyphID);
-    return jsi::Object::createFromHostObject(
-        runtime,
-        std::make_shared<JsiSkTextBlob>(getContext(), std::move(textBlob)));
+    auto hostObjectInstance =
+        std::make_shared<JsiSkTextBlob>(getContext(), std::move(textBlob));
+    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
+        runtime, hostObjectInstance, getContext());
   }
 
   JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkTextBlobFactory, MakeFromText),
@@ -105,6 +109,8 @@ public:
                        JSI_EXPORT_FUNC(JsiSkTextBlobFactory,
                                        MakeFromRSXformGlyphs), )
 
+  size_t getMemoryPressure() const override { return 2048; }
+
   explicit JsiSkTextBlobFactory(std::shared_ptr<RNSkPlatformContext> context)
       : JsiSkHostObject(std::move(context)) {}
 };

package/cpp/api/JsiSkTypeface.h

@@ -53,15 +53,31 @@ public:
     return jsiGlyphIDs;
   }
 
+  size_t getMemoryPressure() const override {
+    auto typeface = getObject();
+    if (!typeface) {
+      return 0;
+    }
+
+    // Typefaces can be quite large as they contain font data
+    // Since SkTypeface doesn't provide a direct memory usage method,
+    // estimate based on glyph count (typically ranges from 64KB to several MB)
+    int glyphCount = typeface->countGlyphs();
+    return glyphCount > 0
+               ? glyphCount * 64
+               : 65536; // 64 bytes per glyph estimate, or 64KB minimum
+  }
+
   /**
    Returns the jsi object from a host object of this type
   */
   static jsi::Value toValue(jsi::Runtime &runtime,
                             std::shared_ptr<RNSkPlatformContext> context,
                             sk_sp<SkTypeface> tf) {
-    return jsi::Object::createFromHostObject(
-        runtime,
-        std::make_shared<JsiSkTypeface>(std::move(context), std::move(tf)));
+    auto hostObjectInstance =
+        std::make_shared<JsiSkTypeface>(context, std::move(tf));
+    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
+        runtime, hostObjectInstance, context);
   }
 };
 

package/cpp/api/JsiSkTypefaceFactory.h

@@ -22,10 +22,14 @@ public:
     if (typeface == nullptr) {
       return jsi::Value::null();
     }
-    return jsi::Object::createFromHostObject(
-        runtime, std::make_shared<JsiSkTypeface>(getContext(), typeface));
+    auto hostObjectInstance =
+        std::make_shared<JsiSkTypeface>(getContext(), std::move(typeface));
+    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
+        runtime, hostObjectInstance, getContext());
   }
 
+  size_t getMemoryPressure() const override { return 1024; }
+
   JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkTypefaceFactory,
                                        MakeFreeTypeFaceFromData))
 

package/cpp/api/JsiSkTypefaceFontProvider.h

@@ -59,8 +59,10 @@ public:
     if (!typeface) {
       throw std::runtime_error("Could not find font style for " + name);
     }
-    return jsi::Object::createFromHostObject(
-        runtime, std::make_shared<JsiSkTypeface>(getContext(), typeface));
+    auto hostObjectInstance =
+        std::make_shared<JsiSkTypeface>(getContext(), std::move(typeface));
+    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
+        runtime, hostObjectInstance, getContext());
   }
 
   JSI_HOST_FUNCTION(countFamilies) { return getObject()->countFamilies(); }
@@ -77,15 +79,18 @@ public:
       : JsiSkWrappingSkPtrHostObject(std::move(context),
                                      std::move(tfProvider)) {}
 
+  size_t getMemoryPressure() const override { return 4096; }
+
   /**
    Returns the jsi object from a host object of this type
   */
   static jsi::Value toValue(jsi::Runtime &runtime,
                             std::shared_ptr<RNSkPlatformContext> context,
                             sk_sp<para::TypefaceFontProvider> tfProvider) {
-    return jsi::Object::createFromHostObject(
-        runtime, std::make_shared<JsiSkTypefaceFontProvider>(
-                     std::move(context), std::move(tfProvider)));
+    auto provider = std::make_shared<JsiSkTypefaceFontProvider>(
+        std::move(context), std::move(tfProvider));
+    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, provider,
+                                                       context);
   }
 };
 

package/cpp/api/JsiSkTypefaceFontProviderFactory.h

@@ -17,13 +17,16 @@ namespace para = skia::textlayout;
 class JsiSkTypefaceFontProviderFactory : public JsiSkHostObject {
 public:
   JSI_HOST_FUNCTION(Make) {
-    return jsi::Object::createFromHostObject(
-        runtime, std::make_shared<JsiSkTypefaceFontProvider>(
-                     getContext(), sk_make_sp<para::TypefaceFontProvider>()));
+    auto provider = std::make_shared<JsiSkTypefaceFontProvider>(
+        getContext(), sk_make_sp<para::TypefaceFontProvider>());
+    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, provider,
+                                                       getContext());
   }
 
   JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkTypefaceFontProviderFactory, Make))
 
+  size_t getMemoryPressure() const override { return 2048; }
+
   explicit JsiSkTypefaceFontProviderFactory(
       std::shared_ptr<RNSkPlatformContext> context)
       : JsiSkHostObject(std::move(context)) {}

package/cpp/api/JsiSkVertices.h

@@ -29,14 +29,24 @@ public:
 
   JSI_HOST_FUNCTION(bounds) {
     const auto &result = getObject()->bounds();
-    return jsi::Object::createFromHostObject(
-        runtime, std::make_shared<JsiSkRect>(getContext(), result));
+    auto hostObjectInstance = std::make_shared<JsiSkRect>(getContext(), result);
+    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
+        runtime, hostObjectInstance, getContext());
   }
 
   JSI_HOST_FUNCTION(uniqueID) {
     return static_cast<double>(getObject()->uniqueID());
   }
 
+  size_t getMemoryPressure() const override {
+    auto vertices = getObject();
+    if (!vertices)
+      return 0;
+
+    // SkVertices provides approximateBytesUsed() to estimate memory usage
+    return vertices->approximateSize();
+  }
+
   JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkVertices, bounds),
                        JSI_EXPORT_FUNC(JsiSkVertices, uniqueID),
                        JSI_EXPORT_FUNC(JsiSkVertices, dispose))
@@ -146,9 +156,10 @@ public:
                                texs.size() > 0 ? texs.data() : nullptr,
                                colors.size() > 0 ? colors.data() : nullptr,
                                indicesSize, indices.data());
-      return jsi::Object::createFromHostObject(
-          runtime,
-          std::make_shared<JsiSkVertices>(context, std::move(vertices)));
+      auto hostObjectInstance =
+          std::make_shared<JsiSkVertices>(context, std::move(vertices));
+      return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
+          runtime, hostObjectInstance, context);
     };
   }
 };

package/cpp/api/JsiSkiaContext.h

@@ -37,9 +37,10 @@ public:
     if (surface == nullptr) {
       return jsi::Value::null();
     }
-    return jsi::Object::createFromHostObject(
-        runtime,
-        std::make_shared<JsiSkSurface>(getContext(), std::move(surface)));
+    auto hostObjectInstance =
+        std::make_shared<JsiSkSurface>(getContext(), std::move(surface));
+    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
+        runtime, hostObjectInstance, getContext());
   }
 
   JSI_HOST_FUNCTION(present) {
@@ -54,6 +55,8 @@ public:
                  std::shared_ptr<WindowContext> ctx)
       : JsiSkWrappingSharedPtrHostObject(std::move(context), std::move(ctx)) {}
 
+  size_t getMemoryPressure() const override { return 8192; }
+
   /**
    * Creates the function for construction a new instance of the SkFont
    * wrapper
@@ -75,9 +78,10 @@ public:
       auto result =
           context->makeContextFromNativeSurface(surface, width, height);
       // Return the newly constructed object
-      return jsi::Object::createFromHostObject(
-          runtime, std::make_shared<JsiSkiaContext>(std::move(context),
-                                                    std::move(result)));
+      auto hostObjectInstance =
+          std::make_shared<JsiSkiaContext>(context, std::move(result));
+      return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
+          runtime, hostObjectInstance, context);
     };
   }
 };

package/cpp/api/JsiSkottieFactory.h

@@ -51,13 +51,16 @@ public:
     if (!managedAnimation->_animation) {
       return jsi::Value::null();
     }
-    return jsi::Object::createFromHostObject(
-        runtime, std::make_shared<JsiSkSkottie>(getContext(),
-                                                std::move(managedAnimation)));
+    auto skottie = std::make_shared<JsiSkSkottie>(getContext(),
+                                                  std::move(managedAnimation));
+    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, skottie,
+                                                       getContext());
   }
 
   JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkottieFactory, Make))
 
+  size_t getMemoryPressure() const override { return 4096; }
+
   explicit JsiSkottieFactory(std::shared_ptr<RNSkPlatformContext> context)
       : JsiSkHostObject(std::move(context)) {}
 };