basalt-core 0.0.0-rc5

package/native/core/DesktopControls.cpp

@@ -0,0 +1,232 @@
+#include "DesktopControls.h"
+
+#include <react/renderer/components/FBReactNativeSpec/ComponentDescriptors.h>
+#include <react/renderer/components/FBReactNativeSpec/EventEmitters.h>
+#include <react/renderer/components/FBReactNativeSpec/Props.h>
+#include <react/renderer/components/modal/ModalHostViewShadowNode.h>
+#include <react/renderer/components/switch/AppleSwitchShadowNode.h>
+#include <react/renderer/graphics/ColorComponents.h>
+
+#include <cstring>
+
+namespace facebook::react {
+
+// React Native's only <Switch> shadow node is the Apple one, and the two
+// translation units that finish it are both Objective-C. This is the third,
+// and the constants are in DesktopControls.h beside everything else a switch
+// is made of.
+//
+// The component name is not "AppleSwitch" despite the file it comes from:
+// React Native's JavaScript renders `Switch`, and a mismatch here is the kind
+// that renders a blank box rather than failing.
+extern const char AppleSwitchComponentName[] = "Switch";
+
+Size SwitchShadowNode::measureContent(const LayoutContext & /*layoutContext*/,
+                                      const LayoutConstraints & /*layoutConstraints*/) const {
+  return {.width = basalt::kSwitchWidth, .height = basalt::kSwitchHeight};
+}
+
+} // namespace facebook::react
+
+namespace basalt {
+
+using facebook::react::ActivityIndicatorViewProps;
+using facebook::react::ActivityIndicatorViewSize;
+using facebook::react::ModalHostViewShadowNode;
+using facebook::react::PullToRefreshViewProps;
+using facebook::react::ShadowView;
+using facebook::react::SharedColor;
+using facebook::react::Size;
+using facebook::react::SwitchProps;
+
+namespace {
+
+// A React Native colour into the four floats every view layer here wants.
+// Returns false for an unset colour, which is not the same as transparent: a
+// control with no colour draws in the platform's own, which is the behaviour
+// React Native documents for all three of these props.
+bool readColor(const SharedColor &color, float out[4]) {
+  if (!color) {
+    return false;
+  }
+  const auto components = colorComponentsFromColor(color);
+  out[0] = components.red;
+  out[1] = components.green;
+  out[2] = components.blue;
+  out[3] = components.alpha;
+  return true;
+}
+
+bool sameColor(const float a[4], const float b[4]) {
+  return std::memcmp(a, b, sizeof(float) * 4) == 0;
+}
+
+} // namespace
+
+ControlKind controlKindFor(const char *componentName) {
+  if (componentName == nullptr) {
+    return ControlKind::None;
+  }
+  if (std::strcmp(componentName, "ActivityIndicatorView") == 0) {
+    return ControlKind::ActivityIndicator;
+  }
+  if (std::strcmp(componentName, "Switch") == 0) {
+    return ControlKind::Switch;
+  }
+  if (std::strcmp(componentName, "PullToRefreshView") == 0) {
+    return ControlKind::PullToRefresh;
+  }
+  return ControlKind::None;
+}
+
+bool ControlState::operator==(const ControlState &other) const {
+  return kind == other.kind && on == other.on && disabled == other.disabled && large == other.large &&
+      hidesWhenStopped == other.hidesWhenStopped && hasForeground == other.hasForeground &&
+      sameColor(foreground, other.foreground) && hasTrackOn == other.hasTrackOn &&
+      sameColor(trackOn, other.trackOn) && hasTrackOff == other.hasTrackOff &&
+      sameColor(trackOff, other.trackOff);
+}
+
+ControlState controlStateOf(const ShadowView &shadowView) {
+  ControlState state;
+  state.kind = controlKindFor(shadowView.componentName);
+
+  switch (state.kind) {
+    case ControlKind::ActivityIndicator: {
+      const auto props = std::dynamic_pointer_cast<const ActivityIndicatorViewProps>(shadowView.props);
+      if (props == nullptr) {
+        break;
+      }
+      state.on = props->animating;
+      state.large = props->size == ActivityIndicatorViewSize::Large;
+      state.hidesWhenStopped = props->hidesWhenStopped;
+      state.hasForeground = readColor(props->color, state.foreground);
+      break;
+    }
+    case ControlKind::Switch: {
+      const auto props = std::dynamic_pointer_cast<const SwitchProps>(shadowView.props);
+      if (props == nullptr) {
+        break;
+      }
+      state.on = props->value;
+      state.disabled = props->disabled;
+      // `thumbColor` is the modern prop and `thumbTintColor` the deprecated
+      // one React Native still parses. Newer first, so an app that sets both
+      // gets the one it means.
+      state.hasForeground = readColor(props->thumbColor, state.foreground) ||
+          readColor(props->thumbTintColor, state.foreground);
+      // Likewise: `trackColor={{true, false}}` parses into these two, and the
+      // old flat `onTintColor` / `tintColor` are the fallbacks.
+      state.hasTrackOn =
+          readColor(props->trackColorForTrue, state.trackOn) || readColor(props->onTintColor, state.trackOn);
+      state.hasTrackOff =
+          readColor(props->trackColorForFalse, state.trackOff) || readColor(props->tintColor, state.trackOff);
+      break;
+    }
+    case ControlKind::PullToRefresh: {
+      const auto props = std::dynamic_pointer_cast<const PullToRefreshViewProps>(shadowView.props);
+      if (props == nullptr) {
+        break;
+      }
+      state.on = props->refreshing;
+      state.hasForeground = readColor(props->tintColor, state.foreground);
+      // A refresh control that is not refreshing shows nothing, which is the
+      // same rule an indicator states as `hidesWhenStopped`.
+      state.hidesWhenStopped = true;
+      break;
+    }
+    case ControlKind::None:
+      break;
+  }
+
+  return state;
+}
+
+std::string describeControl(const ControlState &state) {
+  switch (state.kind) {
+    case ControlKind::None:
+      return {};
+    case ControlKind::ActivityIndicator: {
+      std::string out = state.large ? "spinner-large" : "spinner";
+      out += state.on ? ":animating" : ":stopped";
+      return out;
+    }
+    case ControlKind::Switch: {
+      std::string out = state.on ? "switch:on" : "switch:off";
+      if (state.disabled) {
+        out += ":disabled";
+      }
+      return out;
+    }
+    case ControlKind::PullToRefresh:
+      return state.on ? "refresh:refreshing" : "refresh:idle";
+  }
+  return {};
+}
+
+void emitSwitchChange(const facebook::react::EventEmitter::Shared &emitter, facebook::react::Tag tag, bool value) {
+  const auto typed = std::dynamic_pointer_cast<const facebook::react::SwitchEventEmitter>(emitter);
+  if (typed == nullptr) {
+    return;
+  }
+  typed->onChange({.value = value, .target = static_cast<int>(tag)});
+}
+
+void emitRefresh(const facebook::react::EventEmitter::Shared &emitter) {
+  const auto typed = std::dynamic_pointer_cast<const facebook::react::PullToRefreshViewEventEmitter>(emitter);
+  if (typed != nullptr) {
+    typed->onRefresh({});
+  }
+}
+
+void emitModalShow(const facebook::react::EventEmitter::Shared &emitter) {
+  const auto typed = std::dynamic_pointer_cast<const facebook::react::ModalHostViewEventEmitter>(emitter);
+  if (typed != nullptr) {
+    typed->onShow({});
+  }
+}
+
+void emitModalRequestClose(const facebook::react::EventEmitter::Shared &emitter) {
+  const auto typed = std::dynamic_pointer_cast<const facebook::react::ModalHostViewEventEmitter>(emitter);
+  if (typed != nullptr) {
+    typed->onRequestClose({});
+  }
+}
+
+namespace {
+
+// The modal's state, or null for anything that is not a modal -- including a
+// modal whose state has not been created yet, which a Delete mutation's
+// ShadowView looks like.
+std::shared_ptr<const ModalHostViewShadowNode::ConcreteState> modalStateOf(const ShadowView &shadowView) {
+  if (shadowView.componentName == nullptr || std::strcmp(shadowView.componentName, "ModalHostView") != 0) {
+    return nullptr;
+  }
+  return std::static_pointer_cast<const ModalHostViewShadowNode::ConcreteState>(shadowView.state);
+}
+
+} // namespace
+
+bool modalScreenSizeNeedsUpdate(const ShadowView &shadowView, float width, float height) {
+  const auto state = modalStateOf(shadowView);
+  if (state == nullptr) {
+    return false;
+  }
+  if (width <= 0.0F || height <= 0.0F) {
+    // Before the window has a size. Committing zero would be committing the
+    // very value that makes a modal invisible.
+    return false;
+  }
+  const Size &screen = state->getData().screenSize;
+  return screen.width != width || screen.height != height;
+}
+
+void updateModalScreenSize(const ShadowView &shadowView, float width, float height) {
+  const auto state = modalStateOf(shadowView);
+  if (state == nullptr) {
+    return;
+  }
+  state->updateState(facebook::react::ModalHostViewState{Size{.width = width, .height = height}});
+}
+
+} // namespace basalt

package/native/core/DesktopControls.h

@@ -0,0 +1,170 @@
+// The four React Native components that are a control rather than a box.
+//
+// <ActivityIndicator>, <Switch>, <RefreshControl> and <Modal> have almost
+// nothing in common on screen and everything in common here: each one is a
+// handful of props that three view layers have to read the same way, and each
+// one would otherwise be read three times, slightly differently. Reading them
+// once is what keeps a switch the same size and the same colour on GTK, AppKit
+// and Win32 -- which `scripts/compare_hosts.sh` checks by diffing the tree
+// dumps line by line, and which a per-host `dynamic_pointer_cast` would have
+// quietly broken the first time one host defaulted a colour.
+//
+// What is deliberately *not* here is any drawing. A GtkSwitch, an NSSwitch and
+// a Direct2D rounded rectangle have no shared vocabulary, so the split is the
+// same one the rest of this project makes: the props are portable, the pixels
+// are not.
+//
+// Two shadow-node obligations also live here, because React Native leaves them
+// to the platform and both platform answers it ships are Objective-C:
+//
+//   * `SwitchShadowNode::measureContent`. React Native's only <Switch> shadow
+//     node is the Apple one, and it measures by instantiating a UISwitch or an
+//     NSSwitch on the main thread. The size below is a constant instead, which
+//     is also why a switch is the same size on all three desktops rather than
+//     whatever each toolkit's theme happens to want.
+//
+//   * The <Modal>'s screen size. `ModalHostViewScreenSize()` is already defined
+//     by React Native's own cxx platform file and returns zero, so a modal
+//     would lay out 0x0 and render nothing. The host sends the real size
+//     through the shadow node's state instead, exactly as the iOS host does;
+//     see `modalScreenSizeNeedsUpdate` below.
+
+#pragma once
+
+#include "ControlMetrics.h"
+
+#include <react/renderer/core/EventEmitter.h>
+#include <react/renderer/mounting/ShadowView.h>
+
+#include <string>
+
+namespace basalt {
+
+// --- What kind of control a component name means ----------------------------
+
+enum class ControlKind {
+  None,
+  // <ActivityIndicator>. Spins while `animating`.
+  ActivityIndicator,
+  // <Switch>. On or off, and possibly disabled.
+  Switch,
+  // <RefreshControl>. A spinner that is on while `refreshing`, plus the pull
+  // that turns it on; see PullToRefresh.h for the pull.
+  PullToRefresh,
+};
+
+// The component name React Native mounts each of these under. Free functions
+// rather than a table so a caller can compare without allocating.
+ControlKind controlKindFor(const char *componentName);
+
+// --- The props, read once ----------------------------------------------------
+
+// Every control's state, flattened. One struct rather than three because the
+// three overlap almost completely and every host stores exactly one of these
+// per view; three would be three unions or three fields.
+struct ControlState {
+  ControlKind kind = ControlKind::None;
+
+  // A switch's `value`; an indicator's `animating`; a refresh control's
+  // `refreshing`. The one bit every control has.
+  bool on = false;
+
+  // <Switch> only. A disabled switch is drawn dimmed and does not toggle.
+  bool disabled = false;
+
+  // <ActivityIndicator> only: `size="large"`.
+  bool large = false;
+
+  // <ActivityIndicator> only. When set -- which is React Native's default --
+  // a stopped indicator is not drawn at all rather than drawn still.
+  bool hidesWhenStopped = true;
+
+  // The colour of the moving part: an indicator's `color`, a refresh control's
+  // `tintColor`, a switch's `thumbColor`. Unset means the platform's own.
+  bool hasForeground = false;
+  float foreground[4] = {0.0F, 0.0F, 0.0F, 0.0F};
+
+  // <Switch> only: `trackColor.true` and `trackColor.false`.
+  bool hasTrackOn = false;
+  float trackOn[4] = {0.0F, 0.0F, 0.0F, 0.0F};
+  bool hasTrackOff = false;
+  float trackOff[4] = {0.0F, 0.0F, 0.0F, 0.0F};
+
+  bool operator==(const ControlState &other) const;
+  bool operator!=(const ControlState &other) const { return !(*this == other); }
+};
+
+// The control state a mounted view carries, or a `None` state for every
+// component that is not one of the three. Safe to call on any ShadowView.
+ControlState controlStateOf(const facebook::react::ShadowView &shadowView);
+
+// The field all three hosts print in `describeTree`, or an empty string for a
+// view that is not a control.
+//
+// Written once because the tree dump is a cross-platform contract: three hosts
+// formatting the same state their own way is a diff on every line, which is a
+// mistake this project has already made twice (phase 53's `role=`, and
+// `focusable` printing in two places on GTK).
+std::string describeControl(const ControlState &state);
+
+// --- Metrics -----------------------------------------------------------------
+//
+// kSwitchWidth, kSwitchHeight, kSpinnerSmall and kSpinnerLarge are in
+// ControlMetrics.h next door, because the Windows view layer draws a switch and
+// a spinner and cannot include this file; see its header.
+
+// How far a scroll view has to be pulled past its top before a <RefreshControl>
+// fires. React Native's iOS control uses roughly this.
+inline constexpr double kPullToRefreshThreshold = 80.0;
+
+// How tall a <RefreshControl> is while it is refreshing. The JavaScript side
+// puts this in the view's style, so Yoga makes room for it; the number is here
+// so the two cannot disagree.
+inline constexpr float kRefreshControlHeight = 40.0F;
+
+// --- The events ---------------------------------------------------------------
+//
+// Four one-line calls that exist as functions so that the codegen event
+// emitters stay out of MountingWalk.h and out of three view layers. Each is a
+// no-op for a null emitter, which is what a view between a Remove and its
+// Delete has.
+
+// <Switch> was toggled. `tag` is the switch's own, which React Native's payload
+// carries as `target`.
+void emitSwitchChange(const facebook::react::EventEmitter::Shared &emitter, facebook::react::Tag tag, bool value);
+
+// <RefreshControl> was pulled far enough. React Native expects this once per
+// pull; core/PullToRefresh.h is what makes that true.
+void emitRefresh(const facebook::react::EventEmitter::Shared &emitter);
+
+// <Modal> appeared. React Native's contract is that this fires after the modal
+// is on screen, which here is after the transaction that mounted it.
+void emitModalShow(const facebook::react::EventEmitter::Shared &emitter);
+
+// The person asked for the <Modal> to close -- Escape, on a desktop, which is
+// the same role Android's back button plays. React Native does not close the
+// modal itself: the app's handler sets `visible` to false, and not handling it
+// leaves the modal up, which is deliberate.
+void emitModalRequestClose(const facebook::react::EventEmitter::Shared &emitter);
+
+// --- <Modal> -----------------------------------------------------------------
+
+// Whether this view is a <Modal> whose state still says the screen is a
+// different size than it is, and so needs the host to commit a new one.
+//
+// `ModalHostViewComponentDescriptor::adopt` reads the size out of the shadow
+// node's state and applies it as the node's own, which is how a modal comes to
+// cover the window without the app giving it a size. React Native's cxx
+// platform reports that size as zero -- so without this a modal lays out 0x0
+// and the app shows nothing at all, with no error anywhere.
+//
+// Returns false for every component that is not a <Modal>, and for a modal
+// already holding this size: committing state unconditionally would commit on
+// every mount forever.
+bool modalScreenSizeNeedsUpdate(const facebook::react::ShadowView &shadowView, float width, float height);
+
+// Commits `width` x `height` as the modal's screen size. Call only when
+// `modalScreenSizeNeedsUpdate` said so.
+void updateModalScreenSize(const facebook::react::ShadowView &shadowView, float width, float height);
+
+} // namespace basalt

package/native/core/DevBundle.cpp

@@ -0,0 +1,108 @@
+#include "DevBundle.h"
+
+#include <folly/json.h>
+#include <glog/logging.h>
+
+#include <mutex>
+
+namespace basalt {
+
+namespace {
+
+std::mutex &stateMutex() {
+  static std::mutex mutex;
+  return mutex;
+}
+
+std::string &devOrigin() {
+  static std::string origin;
+  return origin;
+}
+
+std::optional<DevBundleError> &lastError() {
+  static std::optional<DevBundleError> error;
+  return error;
+}
+
+// Metro answers an error with JSON: `type`, `message`, and usually a code frame
+// already formatted into `message` with ANSI colour. Anything else -- a proxy's
+// HTML, a plain string -- comes back as itself.
+std::string messageFrom(const std::string &body) {
+  try {
+    const folly::dynamic parsed = folly::parseJson(body);
+    if (parsed.isObject()) {
+      if (const auto *message = parsed.get_ptr("message"); message != nullptr && message->isString()) {
+        return message->asString();
+      }
+    }
+  } catch (const std::exception &) {
+    // Not JSON. Fall through to the body itself.
+  }
+
+  constexpr size_t kMaxRawBody = 4000;
+  return body.size() > kMaxRawBody ? body.substr(0, kMaxRawBody) + "\n[...truncated]" : body;
+}
+
+} // namespace
+
+void setDevServerOrigin(const std::string &host, uint32_t port) {
+  const std::lock_guard<std::mutex> lock(stateMutex());
+  devOrigin() = "http://" + host + ":" + std::to_string(port) + "/";
+}
+
+bool isDevBundleRequest(const std::string &method, const std::string &url) {
+  if (method != "GET") {
+    return false;
+  }
+
+  std::string origin;
+  {
+    const std::lock_guard<std::mutex> lock(stateMutex());
+    origin = devOrigin();
+  }
+  if (origin.empty() || url.compare(0, origin.size(), origin) != 0) {
+    return false;
+  }
+
+  // `/index.bundle?platform=...`, or `/index.bundle` with no query at all.
+  const auto query = url.find('?');
+  const std::string path = query == std::string::npos ? url : url.substr(0, query);
+  constexpr std::string_view kSuffix = ".bundle";
+  return path.size() >= kSuffix.size() &&
+      path.compare(path.size() - kSuffix.size(), kSuffix.size(), kSuffix) == 0;
+}
+
+void recordDevBundleError(long status, const std::string &url, const std::string &body) {
+  const std::string message = messageFrom(body);
+
+  // Logged here rather than left to the host, because this is the moment the
+  // developer's actual error is in hand and there is nowhere else it survives.
+  LOG(ERROR) << "Metro answered " << status << " for " << url << "\n" << message;
+
+  const std::lock_guard<std::mutex> lock(stateMutex());
+  lastError() = DevBundleError{.status = status, .message = message};
+}
+
+namespace {
+
+std::optional<std::string> &fetched() {
+  static std::optional<std::string> url;
+  return url;
+}
+
+} // namespace
+
+void recordDevBundleFetched(const std::string &url) {
+  fetched() = url;
+}
+
+std::optional<std::string> devBundleFetched() {
+  return fetched();
+}
+
+std::optional<DevBundleError> devBundleError() {
+  const std::lock_guard<std::mutex> lock(stateMutex());
+  return lastError();
+}
+
+} // namespace basalt

package/native/core/DevBundle.h

@@ -0,0 +1,69 @@
+// What happened when this process asked Metro for its bundle.
+//
+// React Native's cxx `DevServerHelper` hands the response body straight to the
+// JS engine without looking at the status code, and `ReactHost` treats any
+// failure as "Metro is not running" and quietly loads the on-disk bundle
+// instead. That is right for one of the two ways the fetch can fail and wrong
+// for the other:
+//
+//   - Nothing is listening. curl reports a connection error, no body is
+//     produced, and falling back to the prebuilt bundle is exactly what should
+//     happen. Verified.
+//   - Metro is running and answers 500, which is what it does for any error in
+//     your app -- a syntax error, a missing import, a failing transform. The
+//     body is Metro's JSON error report, and compiling it as JavaScript
+//     produces `Compiling JS failed: 1:8:';' expected`, naming a line in
+//     Metro's error rather than a line in your code.
+//
+// This file separates the two. `core/HttpClient.cpp` recognises the bundle
+// request, and on a non-2xx status records the failure here and reports an
+// error instead of a body -- so nothing tries to compile it. The host reads
+// `devBundleError()` after `loadScript` returns and refuses to start on a
+// server error, because the alternative is running yesterday's bundle while the
+// developer stares at code that is not what is executing.
+
+#pragma once
+
+// For uint32_t, which nothing else here brings in. It compiled on Windows
+// only because windows.h had already been pulled in behind it, and on a Mac for
+// the same kind of reason; Linux said so, which is what the Linux job is for.
+#include <cstdint>
+#include <optional>
+#include <string>
+
+namespace basalt {
+
+// Called by the host in dev mode, before the bundle is fetched. Without it
+// `isDevBundleRequest` matches nothing and everything below is inert -- which
+// is the correct behaviour in release, where there is no dev server.
+void setDevServerOrigin(const std::string &host, uint32_t port);
+
+// True for the one request that fetches the bundle: a GET to the dev server's
+// own origin for a path ending in `.bundle`. An app's own fetch() cannot match
+// unless it deliberately asks Metro for a bundle.
+bool isDevBundleRequest(const std::string &method, const std::string &url);
+
+struct DevBundleError {
+  long status{0};
+  std::string message;
+};
+
+// Records a non-2xx response to the bundle request. `body` is Metro's error
+// payload; the message is extracted from it if it is the JSON Metro sends.
+void recordDevBundleError(long status, const std::string &url, const std::string &body);
+
+// The last recorded failure, if any. Set on the request thread and read on the
+// main thread after loadScript has joined it.
+std::optional<DevBundleError> devBundleError();
+
+// That the bundle came from Metro, with the URL it came from.
+//
+// Recorded for one reason: the host's "loaded script" line named the on-disk
+// path either way, because that is the argument `loadScript` was given -- and
+// `ReactHost` does not say which of the two it used. So a dev run against Metro
+// reported the path of a bundle it had not executed, and a stale file on disk
+// looked like the thing that was running. That cost an afternoon, twice.
+void recordDevBundleFetched(const std::string &url);
+std::optional<std::string> devBundleFetched();
+
+} // namespace basalt

package/native/core/DevMenu.cpp

@@ -0,0 +1,99 @@
+#include "DevMenu.h"
+
+#include "PlatformServices.h"
+#include "TestDialog.h"
+
+#include <react/runtime/ReactHost.h>
+
+#include <folly/dynamic.h>
+
+namespace basalt {
+
+std::vector<DevMenuItem> devMenuItems(facebook::react::ReactHost *reactHost) {
+  std::vector<DevMenuItem> items;
+
+  items.push_back(DevMenuItem{
+      .label = "Reload",
+      .shortcut = "Ctrl+R",
+      .action =
+          [reactHost] {
+            if (reactHost == nullptr) {
+              return;
+            }
+            // Through JavaScript, because the C++ side has no way in: the
+            // reload lives on ReactHost's private `reloadReactInstance`, and
+            // the only thing wired to it is the callback React Native's own
+            // DevSettings module holds. See the header.
+            reactHost->emitDeviceEvent(folly::dynamic::array(kDevMenuEvent, kDevMenuReload));
+          },
+  });
+
+  items.push_back(DevMenuItem{
+      .label = "Toggle Element Inspector",
+      .shortcut = "Ctrl+I",
+      .action =
+          [reactHost] {
+            if (reactHost == nullptr) {
+              return;
+            }
+            // React Native's own event, handled by AppContainer-dev.js. The
+            // inspector it renders is ordinary React views, so it needs
+            // nothing of this platform beyond mounting them -- which is why
+            // this works on all three hosts without a line of platform code.
+            reactHost->emitDeviceEvent(folly::dynamic::array("toggleElementInspector"));
+          },
+  });
+
+  items.push_back(DevMenuItem{
+      .label = "Open Debugger",
+      .shortcut = "Ctrl+J",
+      .action =
+          [reactHost] {
+            if (reactHost != nullptr) {
+              reactHost->openDebugger();
+            }
+          },
+  });
+
+  return items;
+}
+
+void showDevMenu(facebook::react::ReactHost *reactHost, double x, double y) {
+  if (reactHost == nullptr) {
+    return;
+  }
+
+  // Built fresh each time rather than kept: an item's label will eventually
+  // depend on state -- "Disable Fast Refresh" versus "Enable" -- and a menu
+  // built once would be the first thing to go stale.
+  auto items = std::make_shared<std::vector<DevMenuItem>>(devMenuItems(reactHost));
+
+  MenuRequest request;
+  request.x = x;
+  request.y = y;
+  request.entries.reserve(items->size());
+  for (const DevMenuItem &item : *items) {
+    request.entries.push_back(MenuEntry{
+        .label = item.label,
+        .enabled = true,
+        .shortcut = item.shortcut,
+    });
+  }
+
+  // Through presentMenu rather than showMenu, so BASALT_TEST_MENU can answer
+  // it: a menu nobody dismisses stops an automated run where it stands. See
+  // core/TestDialog.h.
+  presentMenu(request, [items](int index) {
+    // -1 is a dismissal, which is not a failure and is the common case: a menu
+    // opened by a keystroke is closed by another one at least as often as it
+    // is chosen from.
+    if (index < 0 || static_cast<size_t>(index) >= items->size()) {
+      return;
+    }
+    if (const auto &action = (*items)[static_cast<size_t>(index)].action) {
+      action();
+    }
+  });
+}
+
+} // namespace basalt