@shopify/react-native-skia 2.11.2 → 2.12.0

package/Package.swift

@@ -0,0 +1,117 @@
+// swift-tools-version: 6.0
+//
+// SwiftPM manifest for @shopify/react-native-skia. iOS, Ganesh.
+// Additive: the CocoaPods podspec remains the supported default.
+//
+// React Native 0.87+ references a library that ships its own Package.swift
+// through a symlink at <app>/ios/build/generated/autolinking/libs/<name>, and
+// resolves the relative paths below against that symlink. They are the same
+// for every standard app, because the symlink location is.
+
+import Foundation
+import PackageDescription
+
+// Skia's xcframeworks are ~200MB and are not carried in this package. They come
+// from the react-native-skia-apple-ios npm package, which @shopify/react-native-skia
+// depends on, so a checkout that has installed its dependencies builds offline.
+// Xcode passes the symlink as the package directory, hence resolvingSymlinks.
+let packageRoot = URL(fileURLWithPath: Context.packageDirectory)
+  .resolvingSymlinksInPath().path
+
+let binariesPath = [
+  "../../react-native-skia-apple-ios", // consumer: sibling in node_modules
+  "../../node_modules/react-native-skia-apple-ios", // this monorepo
+]
+.map { "\(packageRoot)/\($0)" }
+.first { FileManager.default.fileExists(atPath: "\($0)/Package.swift") }
+
+guard let binariesPath else {
+  // Reached when the package was skipped at install time (`--omit=optional`,
+  // or a non-Apple `os` filter), which SwiftPM would otherwise report as an
+  // unresolvable dependency path.
+  fatalError(
+    """
+    react-native-skia-apple-ios was not found next to @shopify/react-native-skia. \
+    It ships the prebuilt Skia binaries this package links against. Reinstall \
+    dependencies without --omit=optional, on macOS.
+    """)
+}
+
+let package = Package(
+  name: "ReactNativeSkia",
+  platforms: [.iOS(.v15)],
+  products: [
+    // Autolinking looks this name up verbatim; react-native.config.js pins it.
+    .library(name: "ReactNativeSkia", targets: ["ReactNativeSkia"])
+  ],
+  dependencies: [
+    .package(name: "React-GeneratedCode", path: "../../../ios"),
+    .package(name: "ReactNative", path: "../../../../xcframeworks"),
+    .package(path: binariesPath),
+  ],
+  targets: [
+    .target(
+      name: "ReactNativeSkia",
+      dependencies: [
+        .product(name: "ReactHeaders", package: "ReactNative"),
+        .product(name: "ReactNativeHeaders", package: "ReactNative"),
+        .product(name: "ReactNativeDependenciesHeaders", package: "ReactNative"),
+        .product(name: "ReactAppHeaders", package: "React-GeneratedCode"),
+        .product(name: "react-native-skia-apple-ios", package: "react-native-skia-apple-ios"),
+      ],
+      // apple/ and cpp/ have no common ancestor below the package root, and
+      // .headerSearchPath cannot escape the target path.
+      path: ".",
+      exclude: [
+        "cpp/rnskia/RNDawnWindowContext.cpp", // Graphite only
+        "cpp/rnskia/RNDawnInterop.cpp", // Graphite only
+      ],
+      // Explicit, so SwiftPM never walks node_modules, lib, android, or the
+      // headers-only cpp/skia — which carries x86 AVX skcms sources that
+      // cannot build for arm64.
+      sources: [
+        "apple",
+        "cpp/api",
+        "cpp/jsi",
+        "cpp/rnskia",
+        "cpp/utils",
+        // libskottie.a needs skjson and Apple builds no libskjson archive.
+        // CocoaPods compiles this via its cpp/**/*.cpp glob.
+        "cpp/skia/modules/jsonreader/SkJSONReader.cpp",
+      ],
+      cxxSettings: [
+        // Replaces the podspec's recursive cpp/** glob, which expands to 90.
+        .headerSearchPath("cpp"), // "api/…", "jsi/…", "utils/…"
+        .headerSearchPath("cpp/skia"), // "include/core/…", "modules/…", "src/…"
+        .headerSearchPath("cpp/rnskia"), // apple/ uses bare "RNSkView.h"
+        .headerSearchPath("cpp/utils"), // apple/ uses bare "RNSkLog.h"
+
+        // CocoaPods forces both project-wide; the SwiftPM path defines neither.
+        // Skia's Apple sources still gate on them: without them RNSkiaModule's
+        // legacy branch fails to compile and -getTurboModule: is dropped, so
+        // the JSI bindings never install.
+        .define("RCT_NEW_ARCH_ENABLED", to: "1"),
+        .define("RCT_REMOVE_LEGACY_ARCH", to: "1"),
+
+        .define("SK_METAL", to: "1"),
+        .define("SK_GANESH", to: "1"),
+        .define("SK_IMAGE_READ_PIXELS_DISABLE_LEGACY_API", to: "1"),
+        .define("SK_DISABLE_LEGACY_SHAPER_FACTORY", to: "1"),
+
+        // React's prebuilt C++ ABI is NDEBUG-gated, and Skia derives
+        // SK_RELEASE from it. Omitting either breaks the Release link.
+        .define("DEBUG", .when(configuration: .debug)),
+        .define("NDEBUG", .when(configuration: .release)),
+      ],
+      linkerSettings: [
+        .linkedFramework("MetalKit"),
+        .linkedFramework("AVFoundation"),
+        .linkedFramework("AVKit"),
+        .linkedFramework("CoreMedia"),
+      ]
+    )
+  ],
+  // React Native's headers need C++20, and so does Skia m152: SkMathPriv.h
+  // calls std::countl_zero, std::countr_zero and std::popcount.
+  cxxLanguageStandard: .cxx20
+)

package/android/CMakeLists.txt

@@ -100,8 +100,7 @@ add_library(
         "${PROJECT_SOURCE_DIR}/cpp/rnskia-android/AHardwareBufferUtils.cpp"
         "${PROJECT_SOURCE_DIR}/cpp/rnskia-android/RNSkAndroidVideo.cpp"
 
-        "${PROJECT_SOURCE_DIR}/../cpp/jsi/RuntimeLifecycleMonitor.cpp"
-        "${PROJECT_SOURCE_DIR}/../cpp/jsi/RuntimeAwareCache.cpp"
+        "${PROJECT_SOURCE_DIR}/../cpp/jsi/JSICache.cpp"
         "${PROJECT_SOURCE_DIR}/../cpp/jsi/JsiPromises.cpp"
         "${PROJECT_SOURCE_DIR}/../cpp/jsi/Promise.cpp"
 

package/cpp/api/JsiSkSVGFactory.h

@@ -116,6 +116,10 @@ private:
     builder.setResourceProvider(provider);
 
     auto svg_dom = builder.make(*stream);
+    if (!svg_dom) {
+      return jsi::Value::null();
+    }
+
     return makeJsiObject(
         runtime, std::make_shared<JsiSkSVG>(getContext(), std::move(svg_dom)));
   }

package/cpp/jsi/JSICache.cpp

@@ -0,0 +1,99 @@
+#include "JSICache.h"
+
+#include <iterator>
+#include <memory>
+#include <stdexcept>
+#include <string>
+#include <unordered_map>
+#include <utility>
+
+namespace RNJsi {
+
+namespace {
+// Hidden global holding the per-runtime cache object. Named so it is
+// obviously ours if it ever shows up in a debugger or heap snapshot.
+constexpr const char *kGlobalName = "__rnskiaJsiCache";
+} // namespace
+
+std::mutex JSICache::_registryMutex;
+std::unordered_map<jsi::Runtime *, std::weak_ptr<JSICache>> JSICache::_registry;
+
+JSICache &JSICache::get(jsi::Runtime &runtime) {
+  {
+    std::lock_guard<std::mutex> lock(_registryMutex);
+    auto it = _registry.find(&runtime);
+    if (it != _registry.end()) {
+      if (auto cache = it->second.lock()) {
+        // The cache is kept alive by `runtime`'s global, so the raw
+        // reference stays valid for as long as the caller may legally use
+        // `runtime` on this thread.
+        return *cache;
+      }
+      // Expired: the runtime that owned this entry is gone and `&runtime` is
+      // a new runtime reusing the address. Fall through and recreate.
+    }
+  }
+  auto cache = getOrCreateOnGlobal(runtime);
+  {
+    std::lock_guard<std::mutex> lock(_registryMutex);
+    // Drop entries of runtimes that are gone so the map does not grow by one
+    // stale pointer per reload / worklet runtime.
+    for (auto it = _registry.begin(); it != _registry.end();) {
+      it = it->second.expired() ? _registry.erase(it) : std::next(it);
+    }
+    _registry[&runtime] = cache;
+  }
+  return *cache;
+}
+
+std::shared_ptr<JSICache> JSICache::getOrCreateOnGlobal(jsi::Runtime &runtime) {
+  auto global = runtime.global();
+  auto existing = global.getProperty(runtime, kGlobalName);
+  if (existing.isObject()) {
+    auto obj = existing.getObject(runtime);
+    if (obj.hasNativeState<JSICache>(runtime)) {
+      return obj.getNativeState<JSICache>(runtime);
+    }
+  }
+  if (!existing.isUndefined()) {
+    // Something else already claimed our global. The most likely cause is two
+    // copies of react-native-skia loaded in one process (each has its own
+    // JSICache type, so the NativeState check above fails). Say so instead of
+    // letting Object.defineProperty throw a bare TypeError on the
+    // non-configurable property.
+    throw std::runtime_error(
+        std::string("react-native-skia: global.") + kGlobalName +
+        " already exists but is not our JSICache. Is react-native-skia "
+        "linked twice, or is another module using this global?");
+  }
+  auto cache = std::make_shared<JSICache>();
+  jsi::Object holder(runtime);
+  holder.setNativeState(runtime, cache);
+  // Non-enumerable, non-writable, non-configurable: JS code must not be able
+  // to drop the holder (which would finalize the cache under our feet).
+  auto objectCtor = global.getPropertyAsObject(runtime, "Object");
+  auto defineProperty =
+      objectCtor.getPropertyAsFunction(runtime, "defineProperty");
+  jsi::Object descriptor(runtime);
+  descriptor.setProperty(runtime, "value", std::move(holder));
+  descriptor.setProperty(runtime, "writable", false);
+  descriptor.setProperty(runtime, "enumerable", false);
+  descriptor.setProperty(runtime, "configurable", false);
+  defineProperty.call(runtime, global,
+                      jsi::String::createFromAscii(runtime, kGlobalName),
+                      descriptor);
+  return cache;
+}
+
+jsi::Object *JSICache::getPrototype(PrototypeKey key) {
+  auto it = _prototypes.find(key);
+  return it == _prototypes.end() ? nullptr : &it->second;
+}
+
+jsi::Object &JSICache::setPrototype(PrototypeKey key, jsi::Object prototype) {
+  auto [it, inserted] = _prototypes.insert_or_assign(key, std::move(prototype));
+  (void)inserted;
+  return it->second;
+}
+
+} // namespace RNJsi

package/cpp/jsi/JSICache.h

@@ -0,0 +1,90 @@
+#pragma once
+
+#include <jsi/jsi.h>
+
+#include <memory>
+#include <mutex>
+#include <typeindex>
+#include <unordered_map>
+
+namespace RNJsi {
+
+namespace jsi = facebook::jsi;
+
+/**
+ * Per-runtime store for JSI values that native code wants to keep across
+ * calls (currently: the prototype object of every NativeObject class).
+ *
+ * Ownership model (borrowed from react-native-nitro-modules' JSICache):
+ *
+ * - One JSICache exists per jsi::Runtime. It is attached as the NativeState
+ *   of a hidden object stored on that runtime's `global`, so the RUNTIME owns
+ *   the cache. When the runtime is destroyed the engine finalizes the object,
+ *   ~JSICache runs while the runtime is still alive, and every cached
+ *   jsi::Object is released correctly. Nothing outlives its runtime and
+ *   nothing has to be leaked.
+ *
+ * - Native code reaches the cache through JSICache::get(runtime). A static
+ *   map of std::weak_ptr, keyed by jsi::Runtime*, makes the lookup cheap; the
+ *   pointer is only a map key, never proof that a runtime is alive. If the
+ *   weak_ptr is expired (the runtime that owned it is gone) the entry is
+ *   recreated on the runtime asking for it. This is what makes an in-process
+ *   runtime recreate (expo-updates OTA apply, DevSettings.reload) safe even
+ *   when the new runtime is allocated at the address of the freed one: the
+ *   old cache was destroyed with the old runtime, so the reused address can
+ *   only ever resolve to a fresh cache.
+ *
+ * - The cache itself is not locked: a jsi::Runtime is single-threaded, and
+ *   the cache is only ever touched from its runtime's thread. Only the static
+ *   runtime -> cache map is guarded.
+ *
+ * The same mechanism works for worklet runtimes (Reanimated UI runtime,
+ * createWorkletRuntime, ...); each gets its own JSICache.
+ */
+class JSICache final : public jsi::NativeState {
+public:
+  /**
+   * Key identifying one cached prototype: the C++ type of the NativeObject
+   * subclass (std::type_index(typeid(Derived))), as in Nitro. It prints as
+   * the class name in a debugger.
+   */
+  using PrototypeKey = std::type_index;
+
+  /**
+   * Returns the cache owned by `runtime`, creating it on first use. Must be
+   * called on the runtime's thread.
+   */
+  static JSICache &get(jsi::Runtime &runtime);
+
+  /**
+   * Returns the cached prototype for `key` or nullptr if none was stored.
+   *
+   * The pointer points into `_prototypes`. std::unordered_map never
+   * invalidates pointers/references to elements on insert or rehash (only on
+   * erase of that element, which we never do), so it stays valid for as long
+   * as the runtime does. Do not swap the container for one without that
+   * guarantee (std::vector, absl::flat_hash_map, ...).
+   */
+  jsi::Object *getPrototype(PrototypeKey key);
+
+  /**
+   * Stores (or replaces) the prototype for `key` and returns it.
+   */
+  jsi::Object &setPrototype(PrototypeKey key, jsi::Object prototype);
+
+  JSICache() = default;
+  ~JSICache() override = default;
+  JSICache(const JSICache &) = delete;
+  JSICache &operator=(const JSICache &) = delete;
+
+private:
+  static std::shared_ptr<JSICache> getOrCreateOnGlobal(jsi::Runtime &runtime);
+
+  std::unordered_map<PrototypeKey, jsi::Object> _prototypes;
+
+  // Runtime -> cache. Weak on purpose: the runtime's global owns the cache.
+  static std::mutex _registryMutex;
+  static std::unordered_map<jsi::Runtime *, std::weak_ptr<JSICache>> _registry;
+};
+
+} // namespace RNJsi

package/cpp/jsi/NativeObject.h

@@ -8,14 +8,14 @@
 #include <jsi/jsi.h>
 #include <memory>
 #include <mutex>
-#include <optional>
 #include <string>
 #include <type_traits>
+#include <typeindex>
 #include <unordered_map>
 #include <utility>
 
 #include "jsi/BoxedNativeObject.h"
-#include "jsi/RuntimeAwareCache.h" // Use Skia's RuntimeAwareCache
+#include "jsi/JSICache.h"
 
 // Forward declare to avoid circular dependency
 namespace RNJsi {
@@ -37,51 +37,6 @@ static constexpr size_t kMinMemoryPressure = 256;
 // Forward declaration
 template <typename Derived> class NativeObject;
 
-/**
- * Per-runtime cache entry for a prototype object.
- * Uses std::optional<jsi::Object> so the prototype is stored directly
- * without extra indirection.
- */
-struct PrototypeCacheEntry {
-  std::optional<jsi::Object> prototype;
-};
-
-/**
- * Wrapper for static RuntimeAwareCache that handles hot reload.
- *
- * When used with static storage (like prototype caches), the cache persists
- * across hot reloads. But the JSI objects inside become invalid when the
- * runtime is destroyed. This wrapper tracks which main-runtime generation the
- * cache was created for and allocates a new cache when the native module is
- * reinstalled (RNSkManager construction bumps the generation).
- *
- * The generation is used instead of the runtime pointer on purpose: on an
- * in-process runtime recreate (expo-updates reloadAsync, DevSettings.reload)
- * Hermes frequently allocates the new runtime at the address of the freed
- * one. A pointer comparison then sees "same runtime", keeps the stale cache,
- * and create()/installConstructor() end up passing a jsi::Object owned by the
- * dead runtime to the new one (use-after-free).
- *
- * The old cache is intentionally leaked - we cannot safely destroy JSI
- * objects after their runtime is gone.
- */
-template <typename T> struct StaticRuntimeAwareCache {
-  RNJsi::RuntimeAwareCache<T> *cache = nullptr;
-  uint64_t cacheGeneration = 0;
-
-  RNJsi::RuntimeAwareCache<T> &get(jsi::Runtime & /*rt*/) {
-    auto generation =
-        RNJsi::BaseRuntimeAwareCache::getMainJsRuntimeGeneration();
-    if (cache == nullptr || cacheGeneration != generation) {
-      // First use, or the main runtime was reinstalled (hot reload / OTA):
-      // allocate a fresh cache and leak the old one.
-      cache = new RNJsi::RuntimeAwareCache<T>();
-      cacheGeneration = generation;
-    }
-    return *cache;
-  }
-};
-
 /**
  * Base class for native objects using the NativeState pattern.
  *
@@ -118,29 +73,20 @@ public:
   using IsNativeObject = std::true_type;
 
   /**
-   * Get the prototype cache for this type.
-   * Each NativeObject<Derived> type has its own static cache.
-   * Uses StaticRuntimeAwareCache to properly handle runtime lifecycle
-   * and hot reload (where the main runtime is destroyed and recreated).
-   *
-   * Callers must hold getPrototypeCacheMutex(): the cache is reached
-   * concurrently from the main JS thread (create()) and from worklet
-   * runtime threads (BoxedNativeObject::unbox() -> installPrototype()).
+   * Key under which this class's prototype is stored in the per-runtime
+   * JSICache: the C++ type of Derived.
    */
-  static RNJsi::RuntimeAwareCache<PrototypeCacheEntry> &
-  getPrototypeCache(jsi::Runtime &runtime) {
-    static StaticRuntimeAwareCache<PrototypeCacheEntry> cache;
-    return cache.get(runtime);
+  static JSICache::PrototypeKey prototypeKey() {
+    return std::type_index(typeid(Derived));
   }
 
   /**
-   * Per-class mutex guarding getPrototypeCache() and prototype
-   * installation. Serializes the StaticRuntimeAwareCache pointer swap
-   * (hot reload) and the per-runtime cache lookups.
+   * Returns this class's prototype on `runtime`, or nullptr if it has not
+   * been installed there yet. The prototype is owned by the runtime (see
+   * JSICache), so the pointer is valid for as long as `runtime` is.
    */
-  static std::mutex &getPrototypeCacheMutex() {
-    static std::mutex mutex;
-    return mutex;
+  static jsi::Object *getCachedPrototype(jsi::Runtime &runtime) {
+    return JSICache::get(runtime).getPrototype(prototypeKey());
   }
 
   /**
@@ -148,30 +94,21 @@ public:
    * Called automatically by create(), but can be called manually.
    */
   static void installPrototype(jsi::Runtime &runtime) {
-    std::lock_guard<std::mutex> lock(getPrototypeCacheMutex());
-    ensurePrototypeLocked(runtime);
+    ensurePrototype(runtime);
   }
 
   /**
-   * Look up (and install on first use) the prototype entry for this runtime.
-   *
-   * Callers must hold getPrototypeCacheMutex() and must consume the returned
-   * entry while still holding it: the lookup and the use of the prototype
-   * have to share one lock scope, because a reinstall of the native module
-   * (generation bump, see StaticRuntimeAwareCache) can swap the cache from
-   * any thread. A caller that released the lock in between would re-resolve
-   * a fresh cache with an empty entry and hand out an object without a
-   * prototype.
+   * Look up (and install on first use) the prototype for this runtime.
    *
-   * The returned reference stays valid for the runtime's lifetime: the
-   * RuntimeAwareCache is heap-allocated and never freed, and
-   * std::unordered_map keeps references to its elements stable across
-   * rehashes.
+   * The returned reference is owned by the runtime's JSICache and stays
+   * valid for as long as the runtime does (std::unordered_map keeps
+   * references to its elements stable across rehashes). No locking is
+   * needed: a jsi::Runtime is single-threaded and its cache is only ever
+   * touched from its own thread.
    */
-  static PrototypeCacheEntry &ensurePrototypeLocked(jsi::Runtime &runtime) {
-    auto &entry = getPrototypeCache(runtime).get(runtime);
-    if (entry.prototype.has_value()) {
-      return entry; // Already installed
+  static jsi::Object &ensurePrototype(jsi::Runtime &runtime) {
+    if (auto *cached = getCachedPrototype(runtime)) {
+      return *cached; // Already installed on this runtime
     }
 
     // Create prototype object
@@ -288,9 +225,9 @@ public:
           });
     });
 
-    // Cache the prototype
-    entry.prototype = std::move(prototype);
-    return entry;
+    // Hand the prototype to the runtime-owned cache
+    return JSICache::get(runtime).setPrototype(prototypeKey(),
+                                               std::move(prototype));
   }
 
   /**
@@ -301,8 +238,7 @@ public:
    * created internally by the native code).
    */
   static void installConstructor(jsi::Runtime &runtime) {
-    std::lock_guard<std::mutex> lock(getPrototypeCacheMutex());
-    auto &entry = ensurePrototypeLocked(runtime);
+    auto &prototype = ensurePrototype(runtime);
 
     // Create a constructor function that throws when called directly
     auto ctor = jsi::Function::createFromHostFunction(
@@ -316,10 +252,10 @@ public:
 
     // Set the prototype property on the constructor
     // This is what makes `instanceof` work
-    ctor.setProperty(runtime, "prototype", *entry.prototype);
+    ctor.setProperty(runtime, "prototype", prototype);
 
     // Set constructor property on prototype pointing back to constructor
-    entry.prototype->setProperty(runtime, "constructor", ctor);
+    prototype.setProperty(runtime, "constructor", ctor);
 
     // Install on global
     runtime.global().setProperty(runtime, Derived::CLASS_NAME, std::move(ctor));
@@ -339,16 +275,13 @@ public:
     // Attach native state
     obj.setNativeState(runtime, instance);
 
-    // Install (on first use) and apply the prototype in a single lock scope
-    // so a concurrent cache swap cannot slip in between the two steps.
+    // Install (on first use) and apply the prototype
     {
-      std::lock_guard<std::mutex> lock(getPrototypeCacheMutex());
-      auto &entry = ensurePrototypeLocked(runtime);
-      // Use Object.setPrototypeOf to set the prototype
+      auto &prototype = ensurePrototype(runtime);
       auto objectCtor = runtime.global().getPropertyAsObject(runtime, "Object");
       auto setPrototypeOf =
           objectCtor.getPropertyAsFunction(runtime, "setPrototypeOf");
-      setPrototypeOf.call(runtime, obj, *entry.prototype);
+      setPrototypeOf.call(runtime, obj, prototype);
     }
 
     // Set memory pressure hint for GC

package/cpp/jsi/ViewProperty.h

@@ -1,40 +1,16 @@
 #pragma once
 
-#include <atomic>
 #include <functional>
 #include <jsi/jsi.h>
 #include <memory>
 #include <string>
 #include <variant>
 
-#include "RuntimeLifecycleMonitor.h"
 #include "api/JsiSkPicture.h"
 
 namespace RNJsi {
 namespace jsi = facebook::jsi;
 
-class RuntimeAwareRuntimeGuard : public RuntimeLifecycleListener {
-public:
-  explicit RuntimeAwareRuntimeGuard(jsi::Runtime &runtime)
-      : _runtime(&runtime) {
-    RuntimeLifecycleMonitor::addListener(runtime, this);
-  }
-
-  ~RuntimeAwareRuntimeGuard() override {
-    auto runtime = _runtime.load();
-    if (runtime != nullptr) {
-      RuntimeLifecycleMonitor::removeListener(*runtime, this);
-    }
-  }
-
-  void onRuntimeDestroyed(jsi::Runtime *) override { _runtime.store(nullptr); }
-
-  jsi::Runtime *getRuntime() const { return _runtime.load(); }
-
-private:
-  std::atomic<jsi::Runtime *> _runtime;
-};
-
 class ViewProperty {
 public:
   ViewProperty(jsi::Runtime &runtime, const jsi::Value &value) {

package/cpp/rnskia/RNDawnContext.h

@@ -147,7 +147,8 @@ public:
     vkBegin.newLayout = 0;
     beginAccessDesc.nextInChain = &vkBegin;
 #endif
-    bool success = memory.BeginAccess(texture, &beginAccessDesc);
+    bool success =
+        memory.BeginAccess(texture, &beginAccessDesc) == wgpu::Status::Success;
 
     if (success) {
       skgpu::graphite::BackendTexture betFromView =

package/cpp/rnskia/RNDawnWindowContext.h

@@ -82,6 +82,7 @@ private:
     config.width = _width;
     config.height = _height;
     config.presentMode = wgpu::PresentMode::Fifo;
+    config.usage = supportedSurfaceUsage();
 #ifdef __APPLE__
     config.alphaMode = wgpu::CompositeAlphaMode::Premultiplied;
 #endif
@@ -93,6 +94,27 @@ private:
 #endif
   }
 
+  // Graphite needs more than RenderAttachment on the swapchain texture:
+  // TextureBinding so a render pass can reload the existing contents through
+  // LoadOp::ExpandResolveTexture (any backdrop filter or mid-frame readback
+  // splits the pass), and CopySrc for copy tasks. Only request what the
+  // surface reports as supported.
+  wgpu::TextureUsage supportedSurfaceUsage() {
+    wgpu::TextureUsage usage = wgpu::TextureUsage::RenderAttachment;
+    wgpu::SurfaceCapabilities capabilities;
+    if (_surface.GetCapabilities(_device.GetAdapter(), &capabilities) !=
+        wgpu::Status::Success) {
+      return usage;
+    }
+    for (auto extra :
+         {wgpu::TextureUsage::TextureBinding, wgpu::TextureUsage::CopySrc}) {
+      if (capabilities.usages & extra) {
+        usage |= extra;
+      }
+    }
+    return usage;
+  }
+
   bool surfaceSupportsFormat(wgpu::TextureFormat format) {
     wgpu::SurfaceCapabilities capabilities;
     if (_surface.GetCapabilities(_device.GetAdapter(), &capabilities) !=

package/cpp/rnskia/RNSkManager.cpp

@@ -9,8 +9,6 @@
 #include "RNSkView.h"
 #include "api/JsiSkApi.h"
 
-#include "jsi/RuntimeAwareCache.h"
-
 namespace RNSkia {
 namespace jsi = facebook::jsi;
 
@@ -21,20 +19,11 @@ RNSkManager::RNSkManager(
     : _jsRuntime(jsRuntime), _platformContext(platformContext),
       _jsCallInvoker(jsCallInvoker),
       _viewApi(std::make_shared<RNSkJsiViewApi>(platformContext)) {
-
-  // Register main runtime
-  RNJsi::BaseRuntimeAwareCache::setMainJsRuntime(_jsRuntime);
-
   // Install bindings
   installBindings();
 }
 
 RNSkManager::~RNSkManager() {
-  // The main runtime is going away: key out the process-wide prototype
-  // caches now rather than at the next install(), so nothing allocated at
-  // this runtime's address in between can be mistaken for it.
-  RNJsi::BaseRuntimeAwareCache::invalidateMainJsRuntime();
-
   // Free up any references
   _viewApi = nullptr;
   _jsRuntime = nullptr;

package/cpp/skia/include/core/RasterContext.h

@@ -0,0 +1,25 @@
+/*
+ * Copyright 2026 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef RasterContext_DEFINED
+#define RasterContext_DEFINED
+
+#include "include/core/SkRefCnt.h"
+
+#include <memory>
+
+class SkContext;
+struct SkContextOptions;
+
+namespace SkContexts {
+
+// Creates a context for SkContext with only Software Rasterization
+std::unique_ptr<SkContext> MakeRaster(const SkContextOptions& options);
+
+}  // namespace SkContexts
+
+#endif  // RasterContext_DEFINED