basalt-appkit 0.0.0-rc5 → 0.1.0

package/native/CMakeLists.txt

@@ -129,8 +129,10 @@ target_include_directories(basalt_appkit_view PUBLIC appkit)
 # so anything it takes from there has to be `inline`.
 target_include_directories(basalt_appkit_view PUBLIC
     ${CMAKE_CURRENT_SOURCE_DIR}/../../basalt-core/native/core)
+# CoreImage is here for one prop: an <Image>'s `blurRadius`, which Core Graphics
+# has no filter of its own for. See RnBlurredImageCreate.
 target_link_libraries(basalt_appkit_view PUBLIC
-  "-framework Cocoa" "-framework QuartzCore" "-framework CoreText")
+  "-framework Cocoa" "-framework QuartzCore" "-framework CoreText" "-framework CoreImage")
 
 add_executable(demo_layout_appkit appkit/demo_layout_appkit.mm)
 target_compile_options(demo_layout_appkit PRIVATE -Wall -Wextra -fobjc-arc)
@@ -144,9 +146,13 @@ set(BASALT_APPKIT_TEST_SOURCES
   # Core Text, against RnTextLayout alone. No React Native, so these run in the
   # toolkit-only build too.
   tests/test_appkit_text.mm
+  tests/test_appkit_selection.mm
   # The resize modes, against a real bitmap. No React Native, so these run in
   # the toolkit-only build too.
   tests/test_appkit_image.mm
+  # Dotted and dashed borders, also against a bitmap: what a border is drawn as
+  # rather than what the view was told.
+  tests/test_appkit_borders.mm
   # The overlay scrollbar's platform half: that it is a view above the content
   # rather than paint behind it. No React Native, so these run in the
   # toolkit-only build too.
@@ -269,6 +275,10 @@ if(TARGET basalt_core)
     # package header it was never given the include path for.
     ${BASALT_PACKAGE_TESTS}
     tests/test_appkit_mounting.mm
+    # Fonts loaded at runtime: core/FontRegistry.h's macOS half, and the
+    # measurement cache a late registration has to invalidate. Needs React
+    # Native, for the AttributedString a paragraph is measured from.
+    tests/test_appkit_fonts.mm
     # Hit testing lives with the touch dispatcher, which the host builds; the
     # tests need it too, and it pulls in nothing else.
     appkit/AppKitFocus.mm
@@ -279,7 +289,11 @@ if(TARGET basalt_core)
     tests/test_appkit_input.mm
     tests/test_appkit_key_events.mm
     # <TextInput>'s controlled-value loop, through real mutations.
-    tests/test_appkit_textinput.mm)
+    tests/test_appkit_textinput.mm
+    # <ScrollView>'s props, as far as they reach without a window: the manager
+    # takes a view and an emitter lookup, so the offset a prop asks for is
+    # observable with no display at all.
+    tests/test_appkit_scrollview.mm)
 endif()
 
 add_executable(basalt_appkit_tests ${BASALT_APPKIT_TEST_SOURCES})

package/native/appkit/AppKitAppWindow.h

@@ -0,0 +1,24 @@
+// The window this process owns, for the parts of the host that need it and are
+// not the window module.
+//
+// `NSApp.keyWindow` and `NSApp.mainWindow` are both nil whenever the app is not
+// the active one, and two different things were asking only those: a bounds read
+// answered 0x0, and a menu role sent through the responder chain went nowhere.
+// Both are what an app looks like when it was launched while something else had
+// focus, which is most of the time under a test harness and some of the time on
+// a desktop.
+//
+// So the rule lives in one place. It is GTK's rule, from
+// GtkWindowControl.cpp: prefer the active window, fall back to the first visible
+// one that is not a panel.
+
+#pragma once
+
+#import <AppKit/AppKit.h>
+
+namespace basalt {
+
+// The app's own window, or nil when it has none yet. Main thread only.
+NSWindow *appWindow();
+
+} // namespace basalt

package/native/appkit/AppKitImageLoader.h

@@ -23,7 +23,9 @@
 #include <functional>
 #include <string>
 #include <unordered_map>
+#include <vector>
 
+#include "ImageBytes.h"
 #include "ImageCache.h"
 
 #include <react/io/IImageLoader.h>
@@ -49,7 +51,43 @@ class AppKitImageLoader : public facebook::react::IImageLoader {
   AppKitImageLoader(AppKitImageLoader &&) = delete;
   AppKitImageLoader &operator=(AppKitImageLoader &&) = delete;
 
-  void load(const std::string &uri, Callback &&callback);
+  // `onProgress` is optional and is `basalt::ImageProgress`: how much of an
+  // http fetch has arrived, called from the fetching thread. Only an http URI
+  // reports anything; see core/ImageBytes.h.
+  //
+  // Not marshalled to the main thread, unlike the callback above, and that is
+  // the point of it: a Fabric event emitter may be dispatched from any thread,
+  // and a progress tick that had to wait for the main queue would arrive after
+  // the image it is about.
+  void load(const std::string &uri,
+            Callback &&callback,
+            basalt::ImageProgress onProgress = {});
+
+  // The frames of an animated image, or null.
+  //
+  // Separate from `load` because being animated is a property of the file
+  // rather than of the request: `load` answers with the first frame, which is
+  // what a still <Image> draws and what an animated one starts on, and this
+  // says whether there is more. Both come out of the same decode, so asking
+  // costs nothing.
+  //
+  // The arrays are the loader's own and stay at the same addresses for as long
+  // as the URI is cached, which is what lets a view tell "the same animation
+  // again" from "a different one" when a layout-only mutation re-applies the
+  // props. The pointer is good until the next load, since an eviction can take
+  // the entry away.
+  struct Animation {
+    // CGImageRefs, one per frame, bridged into an NSArray so that
+    // RnAppKitView.h stays free of C++ -- the same reason the paragraph is
+    // handed over as an object.
+    NSArray *frames;
+    // The file's own delays in milliseconds, unclamped: the clamp is
+    // core/ImageAnimation.h's and belongs where the arithmetic is.
+    NSArray<NSNumber *> *delaysMs;
+    // Zero for forever, which is what a looping GIF carries.
+    unsigned loopCount;
+  };
+  const Animation *animation(const std::string &uri);
 
   // --- IImageLoader ----------------------------------------------------------
   //
@@ -70,8 +108,17 @@ class AppKitImageLoader : public facebook::react::IImageLoader {
   // Nothing evicts from this yet; see docs/BACKLOG.md.
   // Caches an image and releases whatever the policy dropped.
   void remember(const std::string &uri, CGImageRef image);
+  void rememberAnimation(const std::string &uri,
+                         const std::vector<CGImageRef> &frames,
+                         const std::vector<unsigned> &delaysMs,
+                         unsigned loopCount);
+  void releaseAnimation(Animation &animation);
+  void forgetAnimations();
 
   std::unordered_map<std::string, CGImageRef> cache_;
+  // Only for the files that have more than one frame, so a still image costs
+  // nothing. Keyed by the same URI and dropped by the same eviction.
+  std::unordered_map<std::string, Animation> animations_;
   // Which URI goes next, and when. The images are this class's; the decision
   // is shared with the other two hosts. See core/ImageCache.h.
   basalt::ImageCachePolicy policy_;

package/native/appkit/AppKitImageLoader.mm

@@ -4,8 +4,10 @@
 
 #import <ImageIO/ImageIO.h>
 
+#include <optional>
 #include <thread>
 #include <utility>
+#include <vector>
 
 namespace basalt {
 
@@ -14,8 +16,17 @@ struct AppKitImageLoader::Pending {
   AppKitImageLoader *loader;
   std::string uri;
   CGImageRef image;
+  // Every frame and its delay, for a file that has more than one. Decoded on
+  // the worker thread with the first frame, because a CGImage is immutable and
+  // the expensive part is the same work either way.
+  std::vector<CGImageRef> frames;
+  std::vector<unsigned> delaysMs;
+  unsigned loopCount;
   std::string error;
   Callback callback;
+  // Called from the worker thread as the bytes arrive, rather than from the
+  // main-queue delivery below: see the header.
+  basalt::ImageProgress onProgress;
 };
 
 AppKitImageLoader::AppKitImageLoader() = default;
@@ -26,6 +37,29 @@ AppKitImageLoader::~AppKitImageLoader() {
     CGImageRelease(image);
   }
   cache_.clear();
+  forgetAnimations();
+}
+
+// Releases every frame of every animation.
+//
+// Each frame carries two references: the one the decode produced, which this
+// class owns, and the one the NSArray took when the frame went in. So both have
+// to go: the `CGImageRelease` drops the decode's, and nilling the array lets
+// ARC drop the array's.
+void AppKitImageLoader::forgetAnimations() {
+  for (auto &[uri, animation] : animations_) {
+    (void)uri;
+    releaseAnimation(animation);
+  }
+  animations_.clear();
+}
+
+void AppKitImageLoader::releaseAnimation(Animation &animation) {
+  for (id frame in animation.frames) {
+    CGImageRelease((__bridge CGImageRef)frame);
+  }
+  animation.frames = nil;
+  animation.delaysMs = nil;
 }
 
 namespace {
@@ -35,7 +69,96 @@ namespace {
 // means telling it a size and a context -- so a 160x100 PNG can come back
 // 320x200 on a Retina display, which then measures wrong. CGImageSource hands
 // back exactly what is in the file.
-CGImageRef decode(const std::string &bytes, std::string *error) {
+// One frame's delay in milliseconds, or nothing when the format carries none.
+//
+// Three dictionaries for three formats, and the unclamped delay first where
+// there is one: ImageIO's clamped value has already had a floor of its own
+// applied, and the clamp belongs in core/ImageAnimation.h where both hosts and
+// the next one can see it.
+std::optional<unsigned> delayOfFrame(CGImageSourceRef source, size_t index) {
+  CFDictionaryRef properties = CGImageSourceCopyPropertiesAtIndex(source, index, nullptr);
+  if (properties == nullptr) {
+    return std::nullopt;
+  }
+
+  std::optional<unsigned> milliseconds;
+  for (CFStringRef container : {kCGImagePropertyGIFDictionary,
+                                kCGImagePropertyPNGDictionary,
+                                kCGImagePropertyWebPDictionary}) {
+    const void *found = CFDictionaryGetValue(properties, container);
+    if (found == nullptr) {
+      continue;
+    }
+    CFDictionaryRef dictionary = static_cast<CFDictionaryRef>(found);
+    for (CFStringRef key : {kCGImagePropertyGIFUnclampedDelayTime,
+                            kCGImagePropertyGIFDelayTime,
+                            kCGImagePropertyAPNGUnclampedDelayTime,
+                            kCGImagePropertyAPNGDelayTime,
+                            kCGImagePropertyWebPUnclampedDelayTime,
+                            kCGImagePropertyWebPDelayTime}) {
+      const void *value = CFDictionaryGetValue(dictionary, key);
+      if (value == nullptr) {
+        continue;
+      }
+      double seconds = 0.0;
+      if (CFNumberGetValue(static_cast<CFNumberRef>(value), kCFNumberDoubleType, &seconds)) {
+        milliseconds = static_cast<unsigned>(seconds * 1000.0 + 0.5);
+        break;
+      }
+    }
+    if (milliseconds.has_value()) {
+      break;
+    }
+  }
+
+  CFRelease(properties);
+  return milliseconds;
+}
+
+// How many times round, zero for forever.
+//
+// There is no "absent" case to handle, which was measured rather than assumed:
+// ImageIO answers `kCGImagePropertyGIFLoopCount` with 1 for a GIF carrying no
+// NETSCAPE2.0 extension at all, which is the format's way of saying play once.
+// So the fallback below is unreachable for a GIF and left as forever for a
+// format that really says nothing.
+unsigned loopCountOf(CGImageSourceRef source) {
+  CFDictionaryRef properties = CGImageSourceCopyProperties(source, nullptr);
+  if (properties == nullptr) {
+    return 0;
+  }
+
+  unsigned loops = 0;
+  for (auto [container, key] :
+       {std::pair<CFStringRef, CFStringRef>{kCGImagePropertyGIFDictionary,
+                                            kCGImagePropertyGIFLoopCount},
+        std::pair<CFStringRef, CFStringRef>{kCGImagePropertyPNGDictionary,
+                                            kCGImagePropertyAPNGLoopCount},
+        std::pair<CFStringRef, CFStringRef>{kCGImagePropertyWebPDictionary,
+                                            kCGImagePropertyWebPLoopCount}}) {
+    const void *found = CFDictionaryGetValue(properties, container);
+    if (found == nullptr) {
+      continue;
+    }
+    const void *value = CFDictionaryGetValue(static_cast<CFDictionaryRef>(found), key);
+    int count = 0;
+    if (value != nullptr &&
+        CFNumberGetValue(static_cast<CFNumberRef>(value), kCFNumberIntType, &count) &&
+        count > 0) {
+      loops = static_cast<unsigned>(count);
+      break;
+    }
+  }
+
+  CFRelease(properties);
+  return loops;
+}
+
+CGImageRef decode(const std::string &bytes,
+                  std::string *error,
+                  std::vector<CGImageRef> *frames = nullptr,
+                  std::vector<unsigned> *delaysMs = nullptr,
+                  unsigned *loopCount = nullptr) {
   if (bytes.empty()) {
     *error = "no image data";
     return nullptr;
@@ -56,15 +179,51 @@ CGImageRef decode(const std::string &bytes, std::string *error) {
     return nullptr;
   }
 
-  // Index 0: an animated GIF and a multi-page TIFF both have more, and drawing
-  // the first frame is the honest thing to do until there is an animator. See
-  // docs/BACKLOG.md.
   CGImageRef image = CGImageSourceCreateImageAtIndex(source, 0, nullptr);
-  CFRelease(source);
   if (image == nullptr) {
+    CFRelease(source);
     *error = "could not decode image";
     return nullptr;
   }
+
+  // The rest of the frames, when there are any. A multi-page TIFF reaches here
+  // too and is deliberately not animated: it carries no per-frame delay, so
+  // `delayOfFrame` answers nothing, the frames are dropped, and the caller sees
+  // the still first page -- which is what a multi-page TIFF is.
+  if (frames != nullptr && delaysMs != nullptr && loopCount != nullptr) {
+    const size_t count = CGImageSourceGetCount(source);
+    if (count > 1) {
+      std::vector<unsigned> delays;
+      std::vector<CGImageRef> decoded;
+      bool everyFrameHasADelay = true;
+      for (size_t index = 0; index < count; index++) {
+        const std::optional<unsigned> delay = delayOfFrame(source, index);
+        if (!delay.has_value()) {
+          everyFrameHasADelay = false;
+          break;
+        }
+        CGImageRef frame = index == 0 ? CGImageRetain(image)
+                                      : CGImageSourceCreateImageAtIndex(source, index, nullptr);
+        if (frame == nullptr) {
+          everyFrameHasADelay = false;
+          break;
+        }
+        decoded.push_back(frame);
+        delays.push_back(*delay);
+      }
+      if (everyFrameHasADelay) {
+        *frames = std::move(decoded);
+        *delaysMs = std::move(delays);
+        *loopCount = loopCountOf(source);
+      } else {
+        for (CGImageRef frame : decoded) {
+          CGImageRelease(frame);
+        }
+      }
+    }
+  }
+
+  CFRelease(source);
   return image;
 }
 
@@ -79,7 +238,18 @@ void AppKitImageLoader::remember(const std::string &uri, CGImageRef image) {
   // Height times the row stride, which is what the decode actually allocated
   // -- rows are padded, so width times four is an underestimate on some
   // widths and this is not.
-  const size_t bytes = CGImageGetBytesPerRow(image) * CGImageGetHeight(image);
+  size_t bytes = CGImageGetBytesPerRow(image) * CGImageGetHeight(image);
+  // Every frame of an animation, because every frame is decoded and held: a
+  // sixty-frame GIF is sixty images and accounting for one of them would let
+  // the cache hold far more than it was told to.
+  if (const auto found = animations_.find(uri); found != animations_.end()) {
+    for (id frame in found->second.frames) {
+      CGImageRef one = (__bridge CGImageRef)frame;
+      if (one != image) {
+        bytes += CGImageGetBytesPerRow(one) * CGImageGetHeight(one);
+      }
+    }
+  }
 
   for (const std::string &evicted : policy_.insert(uri, bytes)) {
     const auto it = cache_.find(evicted);
@@ -87,10 +257,16 @@ void AppKitImageLoader::remember(const std::string &uri, CGImageRef image) {
       CGImageRelease(it->second);
       cache_.erase(it);
     }
+    if (const auto animated = animations_.find(evicted); animated != animations_.end()) {
+      releaseAnimation(animated->second);
+      animations_.erase(animated);
+    }
   }
 }
 
-void AppKitImageLoader::load(const std::string &uri, Callback &&callback) {
+void AppKitImageLoader::load(const std::string &uri,
+                             Callback &&callback,
+                             basalt::ImageProgress onProgress) {
   if (uri.empty()) {
     callback(nullptr, "empty source uri");
     return;
@@ -102,20 +278,28 @@ void AppKitImageLoader::load(const std::string &uri, Callback &&callback) {
     return;
   }
 
-  auto *pending = new Pending{this, uri, nullptr, {}, std::move(callback)};
+  auto *pending = new Pending{this,      uri, nullptr,            {}, {}, 0U, {},
+                              std::move(callback), std::move(onProgress)};
 
   std::thread([pending]() {
     std::string bytes;
     // Both the fetch and the decode run here. A CGImage is immutable and
     // thread-safe, so unlike the GTK side there is nothing that has to wait for
     // the main thread except the delivery itself.
-    if (fetchImageBytes(pending->uri, &bytes, &pending->error)) {
-      pending->image = decode(bytes, &pending->error);
+    if (fetchImageBytes(pending->uri, &bytes, &pending->error, pending->onProgress)) {
+      pending->image = decode(bytes, &pending->error, &pending->frames, &pending->delaysMs,
+                              &pending->loopCount);
     }
 
     dispatch_async_f(dispatch_get_main_queue(), pending, [](void *data) {
       std::unique_ptr<Pending> done{static_cast<Pending *>(data)};
       if (done->image != nullptr) {
+        // The frames first, so that `remember` can account for all of them in
+        // one insert rather than growing the cache's idea of this URI twice.
+        if (done->frames.size() > 1) {
+          done->loader->rememberAnimation(done->uri, done->frames, done->delaysMs,
+                                          done->loopCount);
+        }
         // The cache takes the reference the decode produced; the callback
         // borrows it, and a view that keeps the image retains its own.
         done->loader->remember(done->uri, done->image);
@@ -144,6 +328,40 @@ void AppKitImageLoader::loadImage(const std::string &uri,
   });
 }
 
+// Keeps the frames as NSArrays, built once here. The arrays are what the view
+// is handed, and handing back the same arrays each time is what lets it tell a
+// re-mount from a new animation; see RnAppKitView's setRnImageFrames.
+void AppKitImageLoader::rememberAnimation(const std::string &uri,
+                                          const std::vector<CGImageRef> &frames,
+                                          const std::vector<unsigned> &delaysMs,
+                                          unsigned loopCount) {
+  if (const auto found = animations_.find(uri); found != animations_.end()) {
+    // A second decode of the same URI, which a cache miss on one and a hit on
+    // the other can produce. The frames already held are the ones views are
+    // drawing, so these are dropped rather than swapped in.
+    for (CGImageRef frame : frames) {
+      CGImageRelease(frame);
+    }
+    return;
+  }
+
+  NSMutableArray *images = [NSMutableArray arrayWithCapacity:frames.size()];
+  NSMutableArray<NSNumber *> *delays = [NSMutableArray arrayWithCapacity:delaysMs.size()];
+  for (size_t index = 0; index < frames.size(); index++) {
+    // The array's own retain, and the decode's reference is what this class
+    // releases on eviction.
+    [images addObject:(__bridge id)frames[index]];
+    [delays addObject:@(delaysMs[index])];
+  }
+
+  animations_[uri] = Animation{images, delays, loopCount};
+}
+
+const AppKitImageLoader::Animation *AppKitImageLoader::animation(const std::string &uri) {
+  const auto found = animations_.find(uri);
+  return found == animations_.end() ? nullptr : &found->second;
+}
+
 facebook::react::IImageLoader::CacheStatus AppKitImageLoader::getCacheStatus(
     const std::string &uri) {
   // Memory or nothing: there is no disk cache here, and saying `Disk` would be

package/native/appkit/AppKitMenuBar.mm

@@ -22,6 +22,9 @@
 // would deliver it to the wrong object and do nothing.
 
 #include "MenuModel.h"
+#include "TextSelection.h"
+
+#import "AppKitAppWindow.h"
 
 #import <Cocoa/Cocoa.h>
 
@@ -113,6 +116,14 @@ SEL selectorForRole(const std::string &role) {
   return nullptr;
 }
 
+// --- Roles, for a popup menu too ----------------------------------------------
+//
+// `showMenu` in PlatformServicesAppKit.mm performs a role itself rather than
+// handing the item a `nil` target the way the bar does. The bar can let AppKit
+// route the action, because nothing is waiting on an answer; a popup resolves a
+// promise with the index chosen, so it has to stay in the conversation. It calls
+// these two, declared in core/PlatformServices.h.
+
 // The shortcut a role brings with it. macOS has a standard one for each, and an
 // app that spelled its own would be fighting the platform.
 NSString *keyEquivalentForRole(const std::string &role, NSEventModifierFlags *mask) {
@@ -328,6 +339,53 @@ MenuModel defaultMenu() {
 
 } // namespace
 
+// Every role in kMenuRoles, which is the whole list: each one is an NSResponder
+// or NSApplication action that macOS has implemented since before this project.
+bool menuRoleSupported(const std::string &role) {
+  return selectorForRole(role) != nullptr;
+}
+
+void performMenuRole(const std::string &role) {
+  // A paragraph's selection first, when there is one: `Copy` over selected text
+  // means that text, and the responder chain below is what the role meant when
+  // only a <TextInput> could hold a selection. At most one of the two exists --
+  // pressing in a field clears a paragraph's selection on the way past -- so
+  // the order settles a case that does not arise rather than choosing between
+  // two live selections.
+  //
+  // This is also what makes Cmd+C work for a selected paragraph: the
+  // application menu's Copy item carries the key equivalent and performs this
+  // role, so there is no second key path to write. See core/TextSelection.h.
+  if (role == "copy" && copySelectedText()) {
+    return;
+  }
+
+  SEL selector = selectorForRole(role);
+  if (selector == nullptr) {
+    return;
+  }
+
+  // The app's own window first, and this is not belt and braces: `sendAction:`
+  // with `to:nil` walks the responder chain from the **key window's** first
+  // responder, and an app that is not the active one has no key window. So a
+  // `paste` role reached nothing at all whenever the host was launched behind
+  // something else, which is most of the time under the harness. The scenario
+  // "a role in a context menu performs it" found it by failing on a developer
+  // Mac while every CI shard passed, CI's runner having nothing else on screen.
+  //
+  // `tryToPerform:with:` walks from the responder it is sent to, which is the
+  // same walk with a different starting point: the field that has focus in the
+  // window this process owns.
+  NSWindow *const target = appWindow();
+  if (target != nil && [target.firstResponder tryToPerform:selector with:nil]) {
+    return;
+  }
+
+  // And then the usual routing, which is what answers for a role no responder
+  // wants: `terminate:` belongs to the application and not to a field.
+  [NSApp sendAction:selector to:nil from:nil];
+}
+
 bool applicationMenuSupported() {
   return true;
 }

package/native/appkit/AppKitMountingManager.h

@@ -17,6 +17,8 @@
 #import "AppKitScrollView.h"
 #import "AppKitTextInput.h"
 
+#include "LabelRegistry.h"
+#include "LiveRegions.h"
 #include "MountingWalk.h"
 #include "RnAppKitView.h"
 
@@ -57,6 +59,13 @@ class AppKitMountingManager final : public facebook::react::IMountingManager,
   // object is in reach, so this passes it on. See core/UIManagerAccess.h.
   void setUIManager(std::weak_ptr<facebook::react::UIManager> uiManager) noexcept override;
 
+  // React Native hands this a null executor from `destroyReactInstance`, which
+  // is the only notice a mounting manager gets that the instance is going
+  // away -- a reload destroys one and builds another while this object
+  // survives. See MountingWalk::invalidatePendingMounts.
+  void setSchedulerTaskExecutor(
+      facebook::react::SchedulerTaskExecutor &&schedulerTaskExecutor) noexcept override;
+
   // --- Host-facing ----------------------------------------------------------
   //
   // createSurfaceRoot, destroySurfaceRoot, getSurfaceRoot, viewForTag and
@@ -114,6 +123,17 @@ class AppKitMountingManager final : public facebook::react::IMountingManager,
   void applyTextInput(RnAppKitView *view, const facebook::react::ShadowView &shadowView);
   void applyLayoutMetrics(RnAppKitView *view, const facebook::react::ShadowView &shadowView);
 
+  // The labelled-by relations whose resolution changed in the transaction that
+  // just mounted. Once per transaction rather than per view, because a view can
+  // name a label that mounts after it.
+  void applyLabelRelations();
+
+  // Announces any live region whose text changed in the transaction that just
+  // mounted. Once per transaction, and after it, because the text to announce is
+  // what the region says *now*: a <Text> inside it may have been updated by a
+  // later mutation in the same batch.
+  void announceLiveRegions();
+
   AppKitScrollViewManager scrollViews_;
   AppKitTextInputManager textInputs_;
   // Shared rather than held by value: React Native's `ImageLoaderModule` takes
@@ -130,6 +150,20 @@ class AppKitMountingManager final : public facebook::react::IMountingManager,
   // The source each <Image> is currently showing, so that a mutation which
   // changed only layout does not restart the load.
   std::unordered_map<facebook::react::Tag, std::string> imageUris_;
+
+  // Which view each `nativeID` names, and which views are waiting to be labelled
+  // by one. Shared with the GTK host; see core/LabelRegistry.h for why the
+  // resolution cannot happen as the props arrive.
+  basalt::LabelRegistry labels_;
+
+  // Which views are live regions and what each last said, so a changed status
+  // message can be announced. Shared with the GTK host; see core/LiveRegions.h.
+  basalt::LiveRegionRegistry liveRegions_;
+
+  // Each live region's `accessibilityLabel`, which stands in for its text when
+  // the app set one. Kept beside the registry so both hosts decide it the same
+  // way and in the same order.
+  std::unordered_map<facebook::react::Tag, std::string> liveRegionLabels_;
 };
 
 } // namespace basalt