@shopify/react-native-skia 2.6.4 → 2.6.6

package/android/CMakeLists.txt

@@ -4,7 +4,8 @@ cmake_minimum_required(VERSION 3.4.1)
 set (CMAKE_VERBOSE_MAKEFILE ON)
 set (CMAKE_CXX_STANDARD 20)
 
-# SKIA_LIBS_PATH is passed from Gradle (pointing to libs/android/, populated by npm postinstall)
+# SKIA_LIBS_PATH is passed from Gradle (pointing at the prebuilt Skia binaries,
+# read straight from the react-native-skia-android npm package, or libs/android for Graphite)
 # Append the ABI to get the full path
 set (SKIA_LIBS_PATH "${SKIA_LIBS_PATH}/${ANDROID_ABI}")
 
@@ -17,12 +18,12 @@ if(NOT EXISTS "${SKIA_LIBS_PATH}/libskia.a")
     message("│                                                                             │")
     message("│  Could not find libskia.a at: ${SKIA_LIBS_PATH}                             │")
     message("│                                                                             │")
-    message("│  Run the following command to install them:                                  │")
-    message("│    npx install-skia                                                         │")
+    message("│  Make sure dependencies are installed:                                       │")
+    message("│    yarn install   (or npm install)                                          │")
     message("│                                                                             │")
     message("└─────────────────────────────────────────────────────────────────────────────┘")
     message("")
-    message(FATAL_ERROR "Skia prebuilt binaries not found. Run `npx install-skia` to fix this.")
+    message(FATAL_ERROR "Skia prebuilt binaries not found. Run `yarn install` to fix this.")
 endif()
 
 # Import libskia
@@ -134,12 +135,15 @@ if(SK_GRAPHITE)
         "${PROJECT_SOURCE_DIR}/../cpp/rnwgpu/api/GPUComputePipeline.cpp"
         "${PROJECT_SOURCE_DIR}/../cpp/rnwgpu/api/GPUDevice.cpp"
         "${PROJECT_SOURCE_DIR}/../cpp/rnwgpu/api/GPUDeviceLostInfo.cpp"
+        "${PROJECT_SOURCE_DIR}/../cpp/rnwgpu/api/GPUExternalTexture.cpp"
         "${PROJECT_SOURCE_DIR}/../cpp/rnwgpu/api/GPUQuerySet.cpp"
         "${PROJECT_SOURCE_DIR}/../cpp/rnwgpu/api/GPUQueue.cpp"
         "${PROJECT_SOURCE_DIR}/../cpp/rnwgpu/api/GPURenderBundleEncoder.cpp"
         "${PROJECT_SOURCE_DIR}/../cpp/rnwgpu/api/GPURenderPassEncoder.cpp"
         "${PROJECT_SOURCE_DIR}/../cpp/rnwgpu/api/GPURenderPipeline.cpp"
         "${PROJECT_SOURCE_DIR}/../cpp/rnwgpu/api/GPUShaderModule.cpp"
+        "${PROJECT_SOURCE_DIR}/../cpp/rnwgpu/api/GPUSharedFence.cpp"
+        "${PROJECT_SOURCE_DIR}/../cpp/rnwgpu/api/GPUSharedTextureMemory.cpp"
         "${PROJECT_SOURCE_DIR}/../cpp/rnwgpu/api/GPUSupportedLimits.cpp"
         "${PROJECT_SOURCE_DIR}/../cpp/rnwgpu/api/GPUTexture.cpp"
 

package/android/build.gradle

@@ -58,10 +58,29 @@ static def findNodeModules(baseDir) {
 
 def nodeModules = findNodeModules(projectDir)
 
-// Skia prebuilt libs are copied into libs/android/ by the npm postinstall script
-// Graphite is detected via marker file created by install-skia-graphite
+// Resolve a node package directory using Node's own module resolution, so we
+// pick up the prebuilt Skia binaries straight from node_modules (no postinstall
+// copy step needed). Mirrors `require.resolve(pkg/package.json)`.
+static def resolveNodePackage(packageName, baseDir) {
+  def script = "process.stdout.write(require('path').dirname(require.resolve('${packageName}/package.json')))"
+  def proc = ["node", "-e", script].execute(null, baseDir)
+  proc.waitFor()
+  if (proc.exitValue() != 0) {
+    throw new GradleException(
+      "react-native-skia: Could not resolve the '${packageName}' package. " +
+      "Make sure dependencies are installed (yarn install / npm install).\n" + proc.err.text
+    )
+  }
+  return proc.text.trim()
+}
+
+// Graphite is detected via a marker file created by install-skia-graphite, which
+// downloads its binaries directly into libs/. For the default (Ganesh) build the
+// binaries live in the react-native-skia-android npm package and are read in place.
 def useGraphite = file("${projectDir}/../libs/.graphite").exists()
-def skiaLibsPath = "${projectDir}/../libs/android"
+def skiaLibsPath = useGraphite
+    ? "${projectDir}/../libs/android"
+    : "${resolveNodePackage('react-native-skia-android', projectDir)}/libs"
 
 logger.warn("react-native-skia: SK_GRAPHITE: ${useGraphite}")
 logger.warn("react-native-skia: Skia libs: ${skiaLibsPath}")

package/android/cpp/rnskia-android/RNSkAndroidPlatformContext.h

@@ -3,6 +3,8 @@
 #if __ANDROID_API__ >= 26
 #include <android/hardware_buffer.h>
 #endif
+#include <algorithm>
+#include <cstdint>
 #include <exception>
 #include <functional>
 #include <memory>
@@ -120,6 +122,13 @@ public:
 
   uint64_t makeNativeBuffer(sk_sp<SkImage> image) override {
 #if __ANDROID_API__ >= 26
+#if defined(SK_GRAPHITE)
+    // A Graphite GPU texture can't be read with readPixels(nullptr); read it
+    // back to a raster image first or the buffer ends up uninitialized/black.
+    if (image && image->isTextureBacked()) {
+      image = DawnContext::getInstance().MakeRasterImage(image);
+    }
+#endif
     auto bytesPerPixel = image->imageInfo().bytesPerPixel();
     int bytesPerRow = image->width() * bytesPerPixel;
     auto buf = SkData::MakeUninitialized(image->width() * image->height() *
@@ -177,6 +186,59 @@ public:
 #endif
   }
 
+  uint64_t makeTestNativeBuffer(int width, int height) override {
+#if __ANDROID_API__ >= 26
+    // Allocate an RGBA8 AHardwareBuffer and fill it with a procedural test
+    // pattern (RGB gradient + diagonal stripes), entirely on the CPU. We read
+    // the buffer's actual row stride after locking (the allocator may pad it),
+    // so the upload is correct regardless of width alignment.
+    AHardwareBuffer_Desc desc = {};
+    desc.width = static_cast<uint32_t>(width);
+    desc.height = static_cast<uint32_t>(height);
+    desc.layers = 1;
+    desc.format = AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM;
+    desc.usage = AHARDWAREBUFFER_USAGE_CPU_WRITE_RARELY |
+                 AHARDWAREBUFFER_USAGE_CPU_READ_RARELY |
+                 AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE;
+
+    AHardwareBuffer *buffer = nullptr;
+    if (AHardwareBuffer_allocate(&desc, &buffer) != 0) {
+      return 0;
+    }
+
+    AHardwareBuffer_Desc allocated = {};
+    AHardwareBuffer_describe(buffer, &allocated);
+    const size_t rowBytes = static_cast<size_t>(allocated.stride) * 4;
+
+    void *mappedBuffer = nullptr;
+    AHardwareBuffer_lock(buffer, AHARDWAREBUFFER_USAGE_CPU_WRITE_RARELY, -1,
+                         nullptr, &mappedBuffer);
+    if (mappedBuffer == nullptr) {
+      AHardwareBuffer_release(buffer);
+      return 0;
+    }
+
+    auto *base = static_cast<uint8_t *>(mappedBuffer);
+    for (int y = 0; y < height; ++y) {
+      uint8_t *row = base + y * rowBytes;
+      for (int x = 0; x < width; ++x) {
+        uint8_t r = static_cast<uint8_t>((x * 255) / std::max(width - 1, 1));
+        uint8_t g = static_cast<uint8_t>((y * 255) / std::max(height - 1, 1));
+        uint8_t b = static_cast<uint8_t>(((x + y) & 0x20) ? 220 : 30);
+        row[x * 4 + 0] = r; // RGBA byte order
+        row[x * 4 + 1] = g;
+        row[x * 4 + 2] = b;
+        row[x * 4 + 3] = 0xFF;
+      }
+    }
+
+    AHardwareBuffer_unlock(buffer, nullptr);
+    return reinterpret_cast<uint64_t>(buffer);
+#else
+    return 0;
+#endif
+  }
+
 #if !defined(SK_GRAPHITE)
   GrDirectContext *getDirectContext() override {
     return OpenGLContext::getInstance().getDirectContext();

package/android/src/paper/java/com/facebook/react/viewmanagers/SkiaWebGPUViewManagerDelegate.java

@@ -0,0 +1,35 @@
+/**
+* This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+*
+* Do not edit this file as changes may cause incorrect behavior and will be lost
+* once the code is regenerated.
+*
+* @generated by codegen project: GeneratePropsJavaDelegate.js
+*/
+
+package com.facebook.react.viewmanagers;
+
+import android.view.View;
+import androidx.annotation.Nullable;
+import com.facebook.react.uimanager.BaseViewManagerDelegate;
+import com.facebook.react.uimanager.BaseViewManager;
+import com.facebook.react.uimanager.LayoutShadowNode;
+
+public class SkiaWebGPUViewManagerDelegate<T extends View, U extends BaseViewManager<T, ? extends LayoutShadowNode> & SkiaWebGPUViewManagerInterface<T>> extends BaseViewManagerDelegate<T, U> {
+  public SkiaWebGPUViewManagerDelegate(U viewManager) {
+    super(viewManager);
+  }
+  @Override
+  public void setProperty(T view, String propName, @Nullable Object value) {
+    switch (propName) {
+      case "contextId":
+        mViewManager.setContextId(view, value == null ? 0 : ((Double) value).intValue());
+        break;
+      case "transparent":
+        mViewManager.setTransparent(view, value != null && (boolean) value);
+        break;
+      default:
+        super.setProperty(view, propName, value);
+    }
+  }
+}

package/android/src/paper/java/com/facebook/react/viewmanagers/SkiaWebGPUViewManagerInterface.java

@@ -0,0 +1,17 @@
+/**
+* This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+*
+* Do not edit this file as changes may cause incorrect behavior and will be lost
+* once the code is regenerated.
+*
+* @generated by codegen project: GeneratePropsJavaInterface.js
+*/
+
+package com.facebook.react.viewmanagers;
+
+import android.view.View;
+
+public interface SkiaWebGPUViewManagerInterface<T extends View> {
+  void setContextId(T view, int value);
+  void setTransparent(T view, boolean value);
+}

package/apple/RNSkApplePlatformContext.h

@@ -57,6 +57,8 @@ public:
 
   uint64_t makeNativeBuffer(sk_sp<SkImage> image) override;
 
+  uint64_t makeTestNativeBuffer(int width, int height) override;
+
   void releaseNativeBuffer(uint64_t pointer) override;
 
   std::shared_ptr<RNSkVideo> createVideo(const std::string &url) override;

package/apple/RNSkApplePlatformContext.mm

@@ -3,6 +3,7 @@
 #import <CoreMedia/CMSampleBuffer.h>
 #include <Metal/Metal.h>
 #import <React/RCTUtils.h>
+#include <algorithm>
 #include <set>
 #include <thread>
 #include <utility>
@@ -82,6 +83,15 @@ void RNSkApplePlatformContext::releaseNativeBuffer(uint64_t pointer) {
 }
 
 uint64_t RNSkApplePlatformContext::makeNativeBuffer(sk_sp<SkImage> image) {
+#if defined(SK_GRAPHITE)
+  // A Graphite GPU texture can't be read with readPixels(nullptr) (and can't be
+  // drawn onto a raster surface) — both yield uninitialized/black pixels. Read
+  // it back to a raster image first. (JsiNativeBuffer calls the Ganesh-only
+  // SkImage::makeNonTextureImage(), which is a no-op on Graphite.)
+  if (image && image->isTextureBacked()) {
+    image = DawnContext::getInstance().MakeRasterImage(image);
+  }
+#endif
   // 0. If Image is not in BGRA, convert to BGRA as only BGRA is supported.
   if (image->colorType() != kBGRA_8888_SkColorType) {
     const SkImageInfo bgraInfo =
@@ -170,6 +180,67 @@ uint64_t RNSkApplePlatformContext::makeNativeBuffer(sk_sp<SkImage> image) {
   return reinterpret_cast<uint64_t>(pixelBuffer);
 }
 
+uint64_t RNSkApplePlatformContext::makeTestNativeBuffer(int width, int height) {
+  // Allocate a BGRA IOSurface and fill it with a procedural test pattern (RGB
+  // gradient + diagonal stripes), entirely on the CPU. No GPU / SkImage round
+  // trip, so this works the same on every backend.
+  const int bytesPerElement = 4;
+  const int pitch = width * bytesPerElement;
+  const int allocSize = width * height * bytesPerElement;
+  OSType pixelFormat = kCVPixelFormatType_32BGRA;
+  CFMutableDictionaryRef dict = CFDictionaryCreateMutable(
+      kCFAllocatorDefault, 0, &kCFTypeDictionaryKeyCallBacks,
+      &kCFTypeDictionaryValueCallBacks);
+  auto setInt = [&](CFStringRef key, int value) {
+    CFNumberRef num =
+        CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type, &value);
+    CFDictionarySetValue(dict, key, num);
+    CFRelease(num);
+  };
+  setInt(kIOSurfaceWidth, width);
+  setInt(kIOSurfaceHeight, height);
+  setInt(kIOSurfaceBytesPerRow, pitch);
+  setInt(kIOSurfaceBytesPerElement, bytesPerElement);
+  setInt(kIOSurfacePixelFormat, static_cast<int>(pixelFormat));
+  setInt(kIOSurfaceAllocSize, allocSize);
+  IOSurfaceRef surface = IOSurfaceCreate(dict);
+  CFRelease(dict);
+  if (surface == nil) {
+    throw std::runtime_error("Failed to create " + std::to_string(width) + "x" +
+                             std::to_string(height) + " test IOSurface!");
+  }
+
+  IOSurfaceLock(surface, 0, nil);
+  auto *base = static_cast<uint8_t *>(IOSurfaceGetBaseAddress(surface));
+  const size_t rowBytes = IOSurfaceGetBytesPerRow(surface);
+  for (int y = 0; y < height; ++y) {
+    uint8_t *row = base + y * rowBytes;
+    for (int x = 0; x < width; ++x) {
+      uint8_t r = static_cast<uint8_t>((x * 255) / std::max(width - 1, 1));
+      uint8_t g = static_cast<uint8_t>((y * 255) / std::max(height - 1, 1));
+      uint8_t b = static_cast<uint8_t>(((x + y) & 0x20) ? 220 : 30);
+      row[x * 4 + 0] = b; // BGRA byte order
+      row[x * 4 + 1] = g;
+      row[x * 4 + 2] = r;
+      row[x * 4 + 3] = 0xFF;
+    }
+  }
+  IOSurfaceUnlock(surface, 0, nil);
+
+  CVPixelBufferRef pixelBuffer = nullptr;
+  CVReturn result =
+      CVPixelBufferCreateWithIOSurface(nil, surface, nil, &pixelBuffer);
+  // The CVPixelBuffer retains the IOSurface; drop our reference so the
+  // CVPixelBuffer is its sole owner (freed by releaseNativeBuffer).
+  CFRelease(surface);
+  if (result != kCVReturnSuccess) {
+    throw std::runtime_error("Failed to create CVPixelBuffer for test native "
+                             "buffer! Return value: " +
+                             std::to_string(result));
+  }
+  return reinterpret_cast<uint64_t>(pixelBuffer);
+}
+
 #if !defined(SK_GRAPHITE)
 GrDirectContext *RNSkApplePlatformContext::getDirectContext() {
   return MetalContext::getInstance().getDirectContext();

package/apple/RNWebGPUAppleNativeBuffer.mm

@@ -0,0 +1,33 @@
+#ifdef SK_GRAPHITE
+
+#import <CoreVideo/CoreVideo.h>
+
+#include "rnwgpu/api/AppleNativeBuffer.h"
+
+namespace rnwgpu {
+
+void *GetIOSurfaceFromNativeBuffer(void *cvPixelBuffer, uint32_t *outWidth,
+                                   uint32_t *outHeight) {
+  auto pixelBuffer = reinterpret_cast<CVPixelBufferRef>(cvPixelBuffer);
+  if (pixelBuffer == nullptr) {
+    if (outWidth != nullptr) {
+      *outWidth = 0;
+    }
+    if (outHeight != nullptr) {
+      *outHeight = 0;
+    }
+    return nullptr;
+  }
+  if (outWidth != nullptr) {
+    *outWidth = static_cast<uint32_t>(CVPixelBufferGetWidth(pixelBuffer));
+  }
+  if (outHeight != nullptr) {
+    *outHeight = static_cast<uint32_t>(CVPixelBufferGetHeight(pixelBuffer));
+  }
+  // The IOSurface is owned by the CVPixelBuffer; we don't retain it here.
+  return CVPixelBufferGetIOSurface(pixelBuffer);
+}
+
+} // namespace rnwgpu
+
+#endif // SK_GRAPHITE

package/cpp/api/JsiNativeBuffer.h

@@ -24,6 +24,13 @@ public:
     return jsi::BigInt::fromUint64(runtime, pointer);
   }
 
+  JSI_HOST_FUNCTION(MakeTestBuffer) {
+    auto width = static_cast<int>(arguments[0].asNumber());
+    auto height = static_cast<int>(arguments[1].asNumber());
+    uint64_t pointer = getContext()->makeTestNativeBuffer(width, height);
+    return jsi::BigInt::fromUint64(runtime, pointer);
+  }
+
   JSI_HOST_FUNCTION(Release) {
 
     jsi::BigInt pointer = arguments[0].asBigInt(runtime);
@@ -34,7 +41,8 @@ public:
   }
 
   JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiNativeBufferFactory, Release),
-                       JSI_EXPORT_FUNC(JsiNativeBufferFactory, MakeFromImage))
+                       JSI_EXPORT_FUNC(JsiNativeBufferFactory, MakeFromImage),
+                       JSI_EXPORT_FUNC(JsiNativeBufferFactory, MakeTestBuffer))
 
   size_t getMemoryPressure() const override { return 1024; }
 

package/cpp/api/JsiSkAnimatedImageFactory.h

@@ -5,7 +5,7 @@
 
 #include <jsi/jsi.h>
 
-#include "JsiPromises.h"
+#include "jsi/JsiPromises.h"
 #include "JsiSkAnimatedImage.h"
 #include "JsiSkData.h"
 #include "JsiSkHostObjects.h"

package/cpp/api/JsiSkApi.h

@@ -2,12 +2,12 @@
 
 #include <memory>
 
-#include "RNSkPlatformContext.h"
+#include "rnskia/RNSkPlatformContext.h"
 
 #include "JsiSkHostObjects.h"
 
 #ifdef SK_GRAPHITE
-#include "RNDawnContext.h"
+#include "rnskia/RNDawnContext.h"
 #include "rnwgpu/api/GPUDevice.h"
 #include "rnwgpu/async/AsyncRunner.h"
 #endif

package/cpp/api/JsiSkCanvas.h

@@ -19,7 +19,11 @@
 #include "JsiSkTextBlob.h"
 #include "JsiSkVertices.h"
 
-#include "RNSkTypedArray.h"
+#include "utils/RNSkTypedArray.h"
+
+#if defined(SK_GRAPHITE)
+#include "rnskia/RNDawnContext.h"
+#endif
 
 #include <jsi/jsi.h>
 
@@ -644,6 +648,29 @@ public:
             .getArrayBuffer(runtime);
     auto bfrPtr = reinterpret_cast<void *>(buffer.data(runtime));
 
+#if defined(SK_GRAPHITE)
+    // Graphite records draws lazily and offers no synchronous GPU readback. If
+    // this canvas belongs to a surface, snap & submit its recording, snapshot
+    // it to a CPU raster image and read from that (mirroring makeImageSnapshot).
+    // A canvas without an owning surface (e.g. a picture-recording canvas) has
+    // no texture to read back, so fall through to the raster canvas read below.
+    if (_surface) {
+      // Snapshot first: makeImageSnapshot records a copy task into the recorder
+      // that must be submitted before the texture can be read back (this is the
+      // same ordering used by JsiSkSurface::makeImageSnapshot and RNSkView).
+      auto snapshot = _surface->makeImageSnapshot();
+      if (auto *recorder = _surface->recorder()) {
+        DawnContext::getInstance().submitRecording(recorder->snap().get());
+      }
+      auto raster = DawnContext::getInstance().MakeRasterImage(snapshot);
+      if (!raster ||
+          !raster->readPixels(nullptr, *info, bfrPtr, bytesPerRow, srcX, srcY)) {
+        return jsi::Value::null();
+      }
+      return dest;
+    }
+#endif
+
     if (!_canvas->readPixels(*info, bfrPtr, bytesPerRow, srcX, srcY)) {
       return jsi::Value::null();
     }
@@ -708,7 +735,13 @@ public:
   void setCanvas(SkCanvas *canvas) { _canvas = canvas; }
   SkCanvas *getCanvas() { return _canvas; }
 
+  // Optionally associate the canvas with its owning surface. This lets
+  // readPixels fall back to a surface snapshot on Graphite, which has no
+  // synchronous canvas readback.
+  void setSurface(sk_sp<SkSurface> surface) { _surface = std::move(surface); }
+
 private:
   SkCanvas *_canvas;
+  sk_sp<SkSurface> _surface;
 };
 } // namespace RNSkia

package/cpp/api/JsiSkDataFactory.h

@@ -5,7 +5,7 @@
 
 #include <jsi/jsi.h>
 
-#include "JsiPromises.h"
+#include "jsi/JsiPromises.h"
 #include "JsiSkData.h"
 #include "api/third_party/base64.h"
 

package/cpp/api/JsiSkFont.h

@@ -6,7 +6,7 @@
 #include <vector>
 
 #include "JsiSkHostObjects.h"
-#include "RNSkLog.h"
+#include "utils/RNSkLog.h"
 #include <jsi/jsi.h>
 
 #include "JsiSkPaint.h"

package/cpp/api/JsiSkFontMgr.h

@@ -7,7 +7,7 @@
 
 #include "JsiSkFontStyle.h"
 #include "JsiSkHostObjects.h"
-#include "RNSkLog.h"
+#include "utils/RNSkLog.h"
 #include <jsi/jsi.h>
 
 #pragma clang diagnostic push

package/cpp/api/JsiSkHostObjects.h

@@ -5,9 +5,9 @@
 #include <string>
 #include <utility>
 
-#include "JsiHostObject.h"
-#include "RNSkLog.h"
-#include "RNSkPlatformContext.h"
+#include "jsi/JsiHostObject.h"
+#include "utils/RNSkLog.h"
+#include "rnskia/RNSkPlatformContext.h"
 
 namespace RNSkia {
 

package/cpp/api/JsiSkImage.h

@@ -12,10 +12,10 @@
 #include "api/third_party/base64.h"
 
 #include "JsiTextureInfo.h"
-#include "RNSkTypedArray.h"
+#include "utils/RNSkTypedArray.h"
 
 #if defined(SK_GRAPHITE)
-#include "RNDawnContext.h"
+#include "rnskia/RNDawnContext.h"
 #include "include/gpu/graphite/Context.h"
 #else
 #include "include/gpu/ganesh/GrDirectContext.h"
@@ -277,9 +277,6 @@ public:
   }
 
   JSI_HOST_FUNCTION(readPixels) {
-#if defined(SK_GRAPHITE)
-    throw std::runtime_error("Not implemented yet");
-#else
     int srcX = 0;
     int srcY = 0;
     if (count > 0 && !arguments[0].isUndefined()) {
@@ -313,13 +310,24 @@ public:
             .getArrayBuffer(runtime);
     auto bfrPtr = reinterpret_cast<void *>(buffer.data(runtime));
 
+#if defined(SK_GRAPHITE)
+    // Graphite offers no synchronous GPU readback, so fall back to a CPU raster
+    // copy of the image (a no-op when the image is already raster) and read the
+    // pixels from that. This matches the Ganesh behaviour for non-texture and
+    // texture-backed images alike.
+    auto image = DawnContext::getInstance().MakeRasterImage(getObject());
+    if (!image ||
+        !image->readPixels(nullptr, info, bfrPtr, bytesPerRow, srcX, srcY)) {
+      return jsi::Value::null();
+    }
+#else
     auto grContext = getContext()->getDirectContext();
     if (!getObject()->readPixels(grContext, info, bfrPtr, bytesPerRow, srcX,
                                  srcY)) {
       return jsi::Value::null();
     }
-    return dest;
 #endif
+    return dest;
   }
 
   JSI_HOST_FUNCTION(makeNonTextureImage) {

package/cpp/api/JsiSkImageFactory.h

@@ -5,14 +5,14 @@
 
 #include <jsi/jsi.h>
 
-#include "JsiPromises.h"
+#include "jsi/JsiPromises.h"
 #include "JsiSkData.h"
 #include "JsiSkHostObjects.h"
 #include "JsiSkImage.h"
 #include "JsiSkImageInfo.h"
 
 #ifdef SK_GRAPHITE
-#include "RNDawnContext.h"
+#include "rnskia/RNDawnContext.h"
 #include "rnwgpu/api/GPUTexture.h"
 #endif
 

package/cpp/api/JsiSkPath.h

@@ -14,7 +14,7 @@
 #include "JsiSkPoint.h"
 #include "JsiSkRRect.h"
 #include "JsiSkRect.h"
-#include "RNSkLog.h"
+#include "utils/RNSkLog.h"
 
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wdocumentation"

package/cpp/api/JsiSkPathFactory.h

@@ -17,7 +17,7 @@
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wdocumentation"
 
-#include "RNSkLog.h"
+#include "utils/RNSkLog.h"
 #include "include/core/SkPath.h"
 #include "include/core/SkPathBuilder.h"
 #include "include/core/SkPathUtils.h"

package/cpp/api/JsiSkSurface.h

@@ -15,7 +15,7 @@
 #include "JsiSkImage.h"
 
 #if defined(SK_GRAPHITE)
-#include "RNDawnContext.h"
+#include "rnskia/RNDawnContext.h"
 #endif
 
 #pragma clang diagnostic push
@@ -72,8 +72,12 @@ public:
   }
 
   JSI_HOST_FUNCTION(getCanvas) {
+    auto surface = getObject();
     auto canvas =
-        std::make_shared<JsiSkCanvas>(getContext(), getObject()->getCanvas());
+        std::make_shared<JsiSkCanvas>(getContext(), surface->getCanvas());
+    // Keep a reference to the owning surface so the canvas can read pixels back
+    // through a snapshot on Graphite (which lacks synchronous canvas readback).
+    canvas->setSurface(surface);
     return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, canvas,
                                                        getContext());
   }
@@ -81,8 +85,12 @@ public:
   JSI_HOST_FUNCTION(flush) {
     auto surface = getObject();
 #if defined(SK_GRAPHITE)
-    auto recording = surface->recorder()->snap();
-    DawnContext::getInstance().submitRecording(recording.get());
+    // A raster surface (e.g. Skia.Surface.Make) has no Graphite recorder;
+    // only Graphite-backed surfaces need to snap and submit a recording.
+    if (auto *recorder = surface->recorder()) {
+      auto recording = recorder->snap();
+      DawnContext::getInstance().submitRecording(recording.get());
+    }
 #else
     if (auto dContext = GrAsDirectContext(surface->recordingContext())) {
       dContext->flushAndSubmit();
@@ -102,8 +110,12 @@ public:
       image = surface->makeImageSnapshot();
     }
 #if defined(SK_GRAPHITE)
-    auto recording = surface->recorder()->snap();
-    DawnContext::getInstance().submitRecording(recording.get());
+    // A raster surface (e.g. Skia.Surface.Make) has no Graphite recorder; its
+    // snapshot is already a valid CPU image, so skip the recording submit.
+    if (auto *recorder = surface->recorder()) {
+      auto recording = recorder->snap();
+      DawnContext::getInstance().submitRecording(recording.get());
+    }
 #endif
     if (count > 1 && arguments[1].isObject()) {
       auto jsiImage =

package/cpp/api/JsiSkTypeface.h

@@ -7,7 +7,7 @@
 #include <jsi/jsi.h>
 
 #include "JsiSkHostObjects.h"
-#include "RNSkLog.h"
+#include "utils/RNSkLog.h"
 
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wdocumentation"

package/cpp/api/JsiSkTypefaceFontProvider.h

@@ -9,7 +9,7 @@
 #include "JsiSkHostObjects.h"
 #include "JsiSkTypeface.h"
 
-#include "RNSkLog.h"
+#include "utils/RNSkLog.h"
 
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wdocumentation"