basalt-appkit 0.0.0-rc5

package/native/appkit/AppKitSkiaContext.mm

@@ -0,0 +1,255 @@
+#include "AppKitSkiaContext.h"
+
+#include "PlatformServices.h"
+
+#include "MetalContext.h"
+#include "RNSkAppleVideo.h"
+
+#import <AppKit/AppKit.h>
+#import <Metal/Metal.h>
+
+#include "include/core/SkCanvas.h"
+#include "include/core/SkData.h"
+#include "include/core/SkFontMgr.h"
+#include "include/core/SkImage.h"
+#include "include/core/SkStream.h"
+#include "include/core/SkSurface.h"
+#include "include/gpu/ganesh/GrBackendSurface.h"
+#include "include/gpu/ganesh/SkImageGanesh.h"
+#include "include/gpu/ganesh/SkSurfaceGanesh.h"
+#include "include/gpu/ganesh/mtl/GrMtlBackendSurface.h"
+#include "include/ports/SkFontMgr_mac_ct.h"
+
+#include <glog/logging.h>
+
+#include <cstdint>
+#include <memory>
+#include <stdexcept>
+#include <string>
+#include <thread>
+#include <utility>
+#include <vector>
+
+namespace basalt {
+namespace {
+
+SkColorType colorTypeFor(MTLPixelFormat format) {
+  // The package's own table, which is the one Skia's Metal backend agrees with.
+  switch (format) {
+  case MTLPixelFormatRGBA8Unorm:
+    return kRGBA_8888_SkColorType;
+  case MTLPixelFormatBGRA8Unorm:
+    return kBGRA_8888_SkColorType;
+  case MTLPixelFormatRGB10A2Unorm:
+    return kRGBA_1010102_SkColorType;
+  case MTLPixelFormatR8Unorm:
+    return kGray_8_SkColorType;
+  case MTLPixelFormatRGBA16Float:
+    return kRGBA_F16_SkColorType;
+  case MTLPixelFormatRG8Unorm:
+    return kR8G8_unorm_SkColorType;
+  case MTLPixelFormatR16Float:
+    return kA16_float_SkColorType;
+  case MTLPixelFormatRG16Float:
+    return kR16G16_float_SkColorType;
+  case MTLPixelFormatR16Unorm:
+    return kA16_unorm_SkColorType;
+  case MTLPixelFormatRG16Unorm:
+    return kR16G16_unorm_SkColorType;
+  case MTLPixelFormatRGBA16Unorm:
+    return kR16G16B16A16_unorm_SkColorType;
+  case MTLPixelFormatRGBA8Unorm_sRGB:
+    return kSRGBA_8888_SkColorType;
+  default:
+    return kUnknown_SkColorType;
+  }
+}
+
+class AppKitSkiaPlatformContext : public RNSkia::RNSkPlatformContext {
+public:
+  AppKitSkiaPlatformContext(std::shared_ptr<facebook::react::CallInvoker> callInvoker,
+                            float pixelDensity)
+      : RNSkia::RNSkPlatformContext(std::move(callInvoker), pixelDensity) {}
+
+  // ---------------------------------------------------------------- threading
+
+  void runOnMainThread(std::function<void()> func) override {
+    // basalt's own, so Skia's idea of the main thread and this host's are the
+    // same one. Fire and forget, which is all `postToUiThread` offers and all
+    // this seam promises.
+    postToUiThread(std::move(func));
+  }
+
+  // ------------------------------------------------------------------- errors
+
+  void raiseError(const std::exception &err) override {
+    // Logged, not fatal. The package's Apple version calls `RCTFatal`, which
+    // takes the app down with a red box; there is no red box here yet and a
+    // shader that fails to compile is not a reason to end a session. When there
+    // is one, this is the single line that should reach it.
+    LOG(ERROR) << "react-native-skia: " << err.what();
+  }
+
+  // ------------------------------------------------------------------ surfaces
+
+  sk_sp<SkSurface> makeOffscreenSurface(int width, int height,
+                                        bool useP3ColorSpace = false) override {
+    // The one that matters most for a first port: an app rendering frames for
+    // export goes through here, not through a view.
+    return MetalContext::getInstance().MakeOffscreen(width, height, useP3ColorSpace);
+  }
+
+  GrDirectContext *getDirectContext() override {
+    return MetalContext::getInstance().getDirectContext();
+  }
+
+  // ------------------------------------------------------------------- images
+
+  sk_sp<SkImage> makeImageFromNativeBuffer(void *buffer) override {
+    return MetalContext::getInstance().MakeImageFromBuffer(buffer);
+  }
+
+  sk_sp<SkImage> makeImageFromNativeTexture(const RNSkia::TextureInfo &info, int width,
+                                            int height, bool mipMapped) override {
+    id<MTLTexture> texture = (__bridge id<MTLTexture>)(info.mtlTexture);
+    const SkColorType colorType = colorTypeFor(texture.pixelFormat);
+    if (colorType == kUnknown_SkColorType) {
+      throw std::runtime_error("react-native-skia: unsupported Metal pixel format");
+    }
+    GrMtlTextureInfo mtlInfo;
+    mtlInfo.fTexture.retain((__bridge const void *)texture);
+    GrBackendTexture backend = GrBackendTextures::MakeMtl(
+        width, height, mipMapped ? skgpu::Mipmapped::kYes : skgpu::Mipmapped::kNo, mtlInfo);
+    return SkImages::BorrowTextureFrom(getDirectContext(), backend, kTopLeft_GrSurfaceOrigin,
+                                       colorType, kPremul_SkAlphaType, nullptr);
+  }
+
+  const RNSkia::TextureInfo getTexture(sk_sp<SkImage> image) override {
+    GrBackendTexture texture;
+    if (!SkImages::GetBackendTextureFromImage(image, &texture, true)) {
+      throw std::runtime_error("react-native-skia: no backend texture for this image");
+    }
+    return metalTextureInfo(texture);
+  }
+
+  const RNSkia::TextureInfo getTexture(sk_sp<SkSurface> surface) override {
+    GrBackendTexture texture = SkSurfaces::GetBackendTexture(
+        surface.get(), SkSurfaces::BackendHandleAccess::kFlushRead);
+    return metalTextureInfo(texture);
+  }
+
+  // -------------------------------------------------------------------- fonts
+
+  sk_sp<SkFontMgr> createFontMgr() override { return SkFontMgr_New_CoreText(nullptr); }
+
+  std::vector<std::string> getSystemFontFamilies() override {
+    std::vector<std::string> families;
+    NSArray<NSString *> *names = NSFontManager.sharedFontManager.availableFontFamilies;
+    families.reserve(names.count);
+    for (NSString *name in names) {
+      families.emplace_back(name.UTF8String);
+    }
+    return families;
+  }
+
+  // -------------------------------------------------------------------- media
+
+  std::shared_ptr<RNSkia::RNSkVideo> createVideo(const std::string &url) override {
+    // The package's own AVFoundation implementation, which is one of the files
+    // that mentions no React and so compiles here unchanged.
+    return std::make_shared<RNSkia::RNSkAppleVideo>(url, this);
+  }
+
+  // ------------------------------------------------------------------ loading
+
+  void performStreamOperation(
+      const std::string &sourceUri,
+      const std::function<void(std::unique_ptr<SkStreamAsset>)> &op) override {
+    // On a thread, because callers treat this as asynchronous and the operation
+    // may read from the network. Detached for the same reason the package's is:
+    // the continuation is the completion.
+    //
+    // No asset-catalog branch. The package falls back to `[NSImage imageNamed:]`
+    // for a bare name with no scheme and no extension, which is an iOS app
+    // bundle's image set; a desktop host has files and URLs, and a bare name
+    // that reaches here is a bug worth seeing rather than silently resolving.
+    std::thread([sourceUri, op]() {
+      @autoreleasepool {
+        NSString *uri = [NSString stringWithUTF8String:sourceUri.c_str()];
+        NSURL *url = [NSURL URLWithString:uri];
+        NSData *data = nil;
+        if (url != nil && url.scheme != nil) {
+          data = [NSData dataWithContentsOfURL:url];
+        } else {
+          // A path rather than a URL, which is what a bundled asset looks like
+          // when the bundle was built on disk.
+          data = [NSData dataWithContentsOfFile:uri];
+        }
+        if (data == nil) {
+          LOG(WARNING) << "react-native-skia: could not read " << sourceUri;
+          op(nullptr);
+          return;
+        }
+        sk_sp<SkData> copy = SkData::MakeWithCopy(data.bytes, data.length);
+        op(SkMemoryStream::Make(copy));
+      }
+    }).detach();
+  }
+
+  // ------------------------------------------------- not implemented, and why
+
+  sk_sp<SkImage> takeScreenshotFromViewTag(size_t tag) override {
+    // Needs a tag-to-view lookup and a render of that view into a surface. The
+    // host has the first half -- the mounting manager keeps a tag registry --
+    // and nothing yet asks for the second. Named rather than blank: an empty
+    // image here would read as a broken renderer.
+    throw std::runtime_error(
+        "react-native-skia: makeImageSnapshot of a view is not implemented on this "
+        "host (tag " + std::to_string(tag) + "). Render to an offscreen surface instead.");
+  }
+
+  uint64_t makeNativeBuffer(sk_sp<SkImage>) override {
+    throw std::runtime_error(unsupportedNativeBuffers());
+  }
+
+  uint64_t makeTestNativeBuffer(int, int) override {
+    throw std::runtime_error(unsupportedNativeBuffers());
+  }
+
+  void releaseNativeBuffer(uint64_t) override {
+    // Deliberately quiet: nothing here hands out a buffer, so nothing can
+    // return one, and throwing from a release path would turn a leak into a
+    // crash.
+  }
+
+private:
+  static const RNSkia::TextureInfo metalTextureInfo(const GrBackendTexture &texture) {
+    if (!texture.isValid()) {
+      throw std::runtime_error("react-native-skia: invalid backend texture");
+    }
+    GrMtlTextureInfo mtlInfo;
+    if (!GrBackendTextures::GetMtlTextureInfo(texture, &mtlInfo)) {
+      throw std::runtime_error("react-native-skia: no Metal texture info");
+    }
+    RNSkia::TextureInfo info;
+    info.mtlTexture = mtlInfo.fTexture.get();
+    return info;
+  }
+
+  static std::string unsupportedNativeBuffers() {
+    return "react-native-skia: CVPixelBuffer interchange is not implemented on this "
+           "host. It is used for camera and video frame sharing, which nothing here "
+           "provides yet.";
+  }
+};
+
+} // namespace
+
+std::shared_ptr<RNSkia::RNSkPlatformContext>
+makeSkiaPlatformContext(std::shared_ptr<facebook::react::CallInvoker> callInvoker) {
+  const float density =
+      NSScreen.mainScreen != nil ? static_cast<float>(NSScreen.mainScreen.backingScaleFactor) : 1.0f;
+  return std::make_shared<AppKitSkiaPlatformContext>(std::move(callInvoker), density);
+}
+
+} // namespace basalt

package/native/appkit/AppKitSkiaModule.h

@@ -0,0 +1,53 @@
+// `RNSkiaModule`, the TurboModule @shopify/react-native-skia asks for by name.
+//
+// The package's own is 61 lines: one blocking synchronous `install` that builds
+// a `SkiaManager` from an `RCTBridge` and a call invoker, and the manager wraps
+// `RNSkia::RNSkManager`, which is portable C++ over JSI. basalt has a runtime and
+// a call invoker, so all that is left is the platform context -- see
+// AppKitSkiaContext.h -- and this.
+//
+// `install` is where Skia's whole JavaScript API arrives. Constructing
+// RNSkManager installs `SkiaApi` and the rest onto the global object, so
+// everything the package's JavaScript reaches for exists from that moment. Until
+// it is called, `getEnforcing('RNSkiaModule')` throws and an app that imports
+// Skia does not start at all.
+//
+// In the AppKit package rather than in core, for the reason Skia.cmake gives:
+// the Metal and AppKit halves are a host's business, and `basalt_core_probe`
+// said so by refusing to link NSScreen.
+
+#pragma once
+
+#include <ReactCommon/TurboModule.h>
+
+#include "RNSkManager.h"
+
+#include <memory>
+
+namespace basalt {
+
+class AppKitSkiaModule : public facebook::react::TurboModule {
+public:
+  static constexpr const char *kModuleName = "RNSkiaModule";
+
+  explicit AppKitSkiaModule(std::shared_ptr<facebook::react::CallInvoker> jsInvoker);
+  ~AppKitSkiaModule() override;
+
+  // The manager, or null before `install` has run. A `<Canvas>` needs it to
+  // register itself by nativeId, and the lifetime is the runtime's rather than
+  // any one view's -- which is why it is reachable here and not owned by a view.
+  //
+  // Only valid on the thread that installed it. Every caller so far is the UI
+  // thread, which is also where mounting happens.
+  static RNSkia::RNSkManager *manager();
+
+private:
+  // A plain function, because `MethodMetadata::invoker` is a function pointer
+  // rather than a std::function -- a TurboModule's methods are static dispatch.
+  static facebook::jsi::Value install(facebook::jsi::Runtime &runtime,
+                                      facebook::react::TurboModule &module,
+                                      const facebook::jsi::Value *args,
+                                      size_t count);
+};
+
+} // namespace basalt

package/native/appkit/AppKitSkiaModule.mm

@@ -0,0 +1,81 @@
+#include "AppKitSkiaModule.h"
+
+#include "AppKitSkiaContext.h"
+
+#include "RNSkManager.h"
+
+#include <glog/logging.h>
+
+#include <memory>
+#include <utility>
+
+namespace basalt {
+namespace {
+
+// The manager outlives the call that made it and is the owner of everything
+// Skia installed into the runtime, so it is held here rather than on the module:
+// a TurboModule is recreated whenever the runtime is, and Skia's bindings are
+// torn down and rebuilt with it.
+//
+// Reset rather than leaked on destruction, which matters for a reload: the
+// bindings hold a jsi::Runtime reference, and keeping them past the runtime they
+// were installed into is how a reload turns into a crash in somebody else's
+// frame.
+std::unique_ptr<RNSkia::RNSkManager> &skManager() {
+  static std::unique_ptr<RNSkia::RNSkManager> manager;
+  return manager;
+}
+
+} // namespace
+
+AppKitSkiaModule::AppKitSkiaModule(std::shared_ptr<facebook::react::CallInvoker> jsInvoker)
+    : TurboModule(kModuleName, std::move(jsInvoker)) {
+  // Blocking and synchronous on the JavaScript thread, because the package's
+  // JavaScript calls it and then immediately expects `global.SkiaApi` to be
+  // there. The arity is zero and the return is a boolean, matching what
+  // NativeSkiaModule's spec declares.
+  methodMap_["install"] = MethodMetadata{0, install};
+}
+
+AppKitSkiaModule::~AppKitSkiaModule() { skManager().reset(); }
+
+RNSkia::RNSkManager *AppKitSkiaModule::manager() { return skManager().get(); }
+
+facebook::jsi::Value AppKitSkiaModule::install(facebook::jsi::Runtime &runtime,
+                                              facebook::react::TurboModule &module,
+                                              const facebook::jsi::Value * /*args*/,
+                                              size_t /*count*/) {
+  if (skManager() != nullptr) {
+    // Already installed. The package calls this from module scope and React
+    // Native may evaluate that more than once; a second manager over the same
+    // runtime would install a second set of bindings over the first.
+    return facebook::jsi::Value(true);
+  }
+
+  // Through the derived type: `jsInvoker_` is protected on TurboModule, so a
+  // static member of this class may reach it on an AppKitSkiaModule and not on a
+  // TurboModule. The reference is always ours -- the registry only calls this
+  // through the method table we filled in.
+  auto invoker = static_cast<AppKitSkiaModule &>(module).jsInvoker_;
+  if (invoker == nullptr) {
+    LOG(ERROR) << "RNSkiaModule: no call invoker, so Skia cannot be installed";
+    return facebook::jsi::Value(false);
+  }
+
+  try {
+    skManager() = std::make_unique<RNSkia::RNSkManager>(
+        &runtime, invoker, makeSkiaPlatformContext(invoker));
+  } catch (const std::exception &error) {
+    // Reported as false rather than thrown. The package's JavaScript checks the
+    // return and says something useful about it; an exception here crosses the
+    // JSI boundary during module initialisation, where the message tends to
+    // arrive without a stack and without naming Skia.
+    LOG(ERROR) << "RNSkiaModule: install failed: " << error.what();
+    return facebook::jsi::Value(false);
+  }
+
+  LOG(INFO) << "RNSkiaModule: Skia installed";
+  return facebook::jsi::Value(true);
+}
+
+} // namespace basalt

package/native/appkit/AppKitSkiaPeer.h

@@ -0,0 +1,37 @@
+// The AppKit half of a `<Canvas>`: a Metal layer inside an ordinary view.
+//
+// The package's SkiaUIView is an RCTViewComponentView that does three things --
+// creates a drawing view, adds its layer as a sublayer of its own, and registers
+// it with RNSkManager under the nativeId. None of the three needs React Native;
+// what needed React Native was being an RCTViewComponentView. Here the view is
+// already an `RnAppKitView` that the mounting manager made, so this is the three
+// things and nothing else.
+//
+// A sublayer rather than a view of its own, exactly as the package does it: the
+// Skia layer draws itself on the GPU and takes no part in layout, hit testing or
+// the view tree. Making it a view would put it in all three.
+
+#pragma once
+
+#include <react/renderer/core/ReactPrimitives.h>
+#include <react/renderer/mounting/ShadowView.h>
+
+@class RnAppKitView;
+
+namespace basalt {
+
+// Gives `view` a Skia canvas if `shadowView` is a SkiaPictureView, updating its
+// size if it already has one. False when the component is something else, so the
+// caller can treat this as a filter rather than asking twice.
+//
+// Safe to call before `install` has run: without a manager there is nothing to
+// register with, and it does nothing and says so in the log rather than creating
+// a drawing view that no picture could ever reach.
+bool applySkiaCanvas(RnAppKitView *view, const facebook::react::ShadowView &shadowView);
+
+// Unregisters and releases the canvas for `tag`, if it had one. Called when the
+// mounting walk forgets a tag, which is the one moment a view is known to be
+// finished with.
+void forgetSkiaCanvas(facebook::react::Tag tag);
+
+} // namespace basalt

package/native/appkit/AppKitSkiaPeer.mm

@@ -0,0 +1,123 @@
+#include "AppKitSkiaPeer.h"
+
+#include "AppKitSkiaModule.h"
+#include "AppKitSkiaView.h"
+#include "SkiaPictureViewComponent.h"
+
+#import "RnAppKitView.h"
+
+#include "RNSkPictureView.h"
+
+#include <glog/logging.h>
+
+#include <memory>
+#include <string>
+#include <unordered_map>
+
+namespace basalt {
+namespace {
+
+using Canvas = SkiaDrawingViewOf<RNSkia::RNSkPictureView>;
+
+struct Attached {
+  std::shared_ptr<Canvas> canvas;
+  // The id it was registered under, kept so the unregister matches: a view whose
+  // nativeID changed would otherwise leave the old registration behind, pointing
+  // at a canvas nothing draws into.
+  size_t nativeId = 0;
+};
+
+std::unordered_map<facebook::react::Tag, Attached> &attached() {
+  static std::unordered_map<facebook::react::Tag, Attached> map;
+  return map;
+}
+
+// `<Canvas>` stringifies a counter into nativeID. Anything else on a
+// SkiaPictureView is not ours to interpret.
+bool parseNativeId(NSString *identifier, size_t &out) {
+  if (identifier == nil || identifier.length == 0) {
+    return false;
+  }
+  const std::string text = identifier.UTF8String;
+  try {
+    size_t consumed = 0;
+    const unsigned long long value = std::stoull(text, &consumed);
+    if (consumed != text.size()) {
+      return false;
+    }
+    out = static_cast<size_t>(value);
+    return true;
+  } catch (const std::exception &) {
+    return false;
+  }
+}
+
+} // namespace
+
+bool applySkiaCanvas(RnAppKitView *view, const facebook::react::ShadowView &shadowView) {
+  if (shadowView.componentName == nullptr ||
+      std::string(shadowView.componentName) !=
+          facebook::react::SkiaPictureViewComponentName) {
+    return false;
+  }
+
+  const auto tag = shadowView.tag;
+  // In points, which is what the drawing view wants: the canvas provider scales
+  // by the layer's contentsScale itself, and passing pixels here draws at twice
+  // the size on a Retina display.
+  const auto &frame = shadowView.layoutMetrics.frame;
+  const int width = static_cast<int>(frame.size.width);
+  const int height = static_cast<int>(frame.size.height);
+
+  size_t nativeId = 0;
+  if (!parseNativeId(view.rnNativeId, nativeId)) {
+    // Not an error: a SkiaPictureView is mounted before its nativeID has been
+    // applied in some orders, and the next updateView carries it.
+    return true;
+  }
+
+  RNSkia::RNSkManager *manager = AppKitSkiaModule::manager();
+  if (manager == nullptr) {
+    LOG(WARNING) << "SkiaPictureView tag " << tag
+                 << " mounted before RNSkiaModule.install ran, so it has no canvas";
+    return true;
+  }
+
+  auto &entry = attached()[tag];
+  if (entry.canvas == nullptr) {
+    entry.canvas = std::make_shared<Canvas>(manager->getPlatformContext());
+    entry.nativeId = nativeId;
+    // Under the view's own layer, and below nothing: a canvas has no React
+    // children to sit above, and the package adds it the same way.
+    [view.layer addSublayer:entry.canvas->layer()];
+    manager->setSkiaView(nativeId, entry.canvas->drawView());
+    LOG(INFO) << "SkiaPictureView tag " << tag << " registered as Skia view " << nativeId;
+  } else if (entry.nativeId != nativeId) {
+    // The id moved. Re-register rather than leave the manager pointing the old
+    // canvas at the new id's pictures.
+    manager->unregisterSkiaView(entry.nativeId);
+    entry.nativeId = nativeId;
+    manager->setSkiaView(nativeId, entry.canvas->drawView());
+  }
+
+  if (width > 0 && height > 0) {
+    entry.canvas->setSize(width, height);
+  }
+  return true;
+}
+
+void forgetSkiaCanvas(facebook::react::Tag tag) {
+  auto it = attached().find(tag);
+  if (it == attached().end()) {
+    return;
+  }
+  if (RNSkia::RNSkManager *manager = AppKitSkiaModule::manager()) {
+    manager->unregisterSkiaView(it->second.nativeId);
+  }
+  if (it->second.canvas != nullptr) {
+    [it->second.canvas->layer() removeFromSuperlayer];
+  }
+  attached().erase(it);
+}
+
+} // namespace basalt

package/native/appkit/AppKitSkiaView.h

@@ -0,0 +1,62 @@
+// The drawing half of a `<Canvas>`, which is Skia's and not ours.
+//
+// `RNSkAppleView.h` in the package is this, in fifty header-only lines, and
+// basalt cannot include it: its first `#import` is
+// "RNSkApplePlatformContext.h", whose own first line is
+// <React/RCTBridge+Private.h>. Nothing in the template needs either -- it uses
+// `RNSkia::RNSkPlatformContext`, which is portable C++ in cpp/rnskia, and
+// `RNSkMetalCanvasProvider`, which compiles here already. So this is the same
+// template with the include it does not need left out.
+//
+// Copied rather than shimmed. A shim `React/RCTBridge+Private.h` would make the
+// original compile and would then have to keep making it compile, for a header
+// whose contents are not ours to predict. Fifty lines that say what they do are
+// the cheaper of the two, and the thing being copied is a bridge between two
+// interfaces rather than logic that can drift.
+
+#pragma once
+
+#import <QuartzCore/QuartzCore.h>
+
+#include "RNSkMetalCanvasProvider.h"
+#include "RNSkPlatformContext.h"
+#include "RNSkView.h"
+
+#include <functional>
+#include <memory>
+
+namespace basalt {
+
+// What the AppKit view needs of whatever is drawing into it, without knowing
+// which RNSkView subclass that is.
+class SkiaDrawingView {
+public:
+  virtual ~SkiaDrawingView() = default;
+  virtual CALayer *layer() = 0;
+  virtual void setSize(int width, int height) = 0;
+  virtual std::shared_ptr<RNSkia::RNSkView> drawView() = 0;
+};
+
+// T is an RNSkView subclass -- RNSkPictureView for a `<Canvas>`. The canvas
+// provider is Metal's, and its redraw callback is the view's own
+// `requestRedraw`, which is how a picture pushed from JavaScript reaches the
+// screen without anybody polling.
+template <class T> class SkiaDrawingViewOf final : public SkiaDrawingView, public T {
+public:
+  explicit SkiaDrawingViewOf(std::shared_ptr<RNSkia::RNSkPlatformContext> context)
+      : T(context, std::make_shared<RNSkMetalCanvasProvider>(
+                       std::bind(&RNSkia::RNSkView::requestRedraw, this), context, true)) {}
+
+  CALayer *layer() override { return provider()->getLayer(); }
+
+  void setSize(int width, int height) override { provider()->setSize(width, height); }
+
+  std::shared_ptr<RNSkia::RNSkView> drawView() override { return this->shared_from_this(); }
+
+private:
+  std::shared_ptr<RNSkMetalCanvasProvider> provider() {
+    return std::static_pointer_cast<RNSkMetalCanvasProvider>(this->getCanvasProvider());
+  }
+};
+
+} // namespace basalt

package/native/appkit/AppKitSnapshot.h

@@ -0,0 +1,21 @@
+// Rendering a view tree to a PNG without showing it.
+//
+// Shared by the demo and the mount harness, and the only way either of them
+// proves anything: a tree dump prints the frames that were *set*, which looks
+// identical whether or not the coordinate system, the layer tree and the paint
+// path are right. A picture does not.
+
+#pragma once
+
+#ifdef __OBJC__
+#import "RnAppKitView.h"
+
+// Renders `root` to a PNG at `path`. Returns false if the file could not be
+// written. Needs no window server and shows nothing on screen.
+//
+// Works on a detached tree and on one already mounted in a live window; a
+// detached one gets an offscreen window of its own, because AppKit only
+// assembles a layer tree during a display cycle and a view with no window never
+// has one.
+bool RnAppKitWriteSnapshot(RnAppKitView *root, NSString *path);
+#endif