basalt-core 0.0.0-rc5 → 0.1.0

package/native/core/MenuModule.cpp

@@ -34,10 +34,15 @@ bool boolProperty(Runtime &runtime, const Object &item, const char *name, bool f
   return value.isBool() ? value.asBool() : fallback;
 }
 
-// A context menu's entries, which are a flatter thing than the application
-// menu's: one level, no roles, no submenus. That is not a simplification -- a
-// popup menu on all three desktops is a list, and the nesting an application
-// menu has is what a menu *bar* is for.
+// A context menu's entries. Nested, and roles too: NSMenu, GMenu and an HMENU
+// all nest, and the reason this was a flat list was never the platforms. It was
+// that `showMenu` answers with an index and a tree has no single position -- see
+// the note on `walkMenuEntries`, which is what settled it.
+//
+// A role an entry names and this desktop cannot perform is dropped here rather
+// than shown, which is the application menu's policy for the same reason: an
+// item that does nothing is worse than one that is not there. Linux drops most
+// of them.
 std::vector<MenuEntry> entriesFrom(Runtime &runtime, const Value &value) {
   std::vector<MenuEntry> entries;
   if (!value.isObject() || !value.asObject(runtime).isArray(runtime)) {
@@ -62,6 +67,32 @@ std::vector<MenuEntry> entriesFrom(Runtime &runtime, const Value &value) {
     entry.label = stringProperty(runtime, item, "label");
     entry.enabled = boolProperty(runtime, item, "enabled", true);
     entry.shortcut = stringProperty(runtime, item, "shortcut");
+    entry.role = stringProperty(runtime, item, "role");
+
+    // `type` in Electron's spelling, because that is the vocabulary a desktop
+    // developer already has, and the roles above are Electron's for the same
+    // reason. `checked` on its own is read as a checkbox: it is the common case
+    // and making it need two words to work would be a trap.
+    const std::string type = stringProperty(runtime, item, "type");
+    const bool hasChecked = item.hasProperty(runtime, "checked");
+    if (type == "radio") {
+      entry.mark = MenuEntry::Mark::Radio;
+    } else if (type == "checkbox" || hasChecked) {
+      entry.mark = MenuEntry::Mark::Check;
+    }
+    if (entry.mark != MenuEntry::Mark::None) {
+      entry.checked = boolProperty(runtime, item, "checked", false);
+    }
+
+    const Value nested = item.getProperty(runtime, "submenu");
+    if (nested.isObject() && nested.asObject(runtime).isArray(runtime)) {
+      entry.submenu = entriesFrom(runtime, nested);
+    }
+    // Nothing is filtered here, deliberately. An entry naming a role this
+    // desktop cannot perform is not drawn -- `menuEntryShown` says so and each
+    // host skips it -- but it keeps its place in the vector, because the index
+    // that comes back is an index into the list JavaScript passed. Dropping it
+    // here would renumber everything after it onto the wrong handler.
     entries.push_back(std::move(entry));
   }
   return entries;

package/native/core/MountingWalk.h

@@ -52,6 +52,7 @@
 
 #include <algorithm>
 #include <cassert>
+#include <atomic>
 #include <cstdint>
 #include <memory>
 #include <string_view>
@@ -85,6 +86,13 @@ class MountingWalk {
   // types, and because a view can sit detached between a Remove and its Delete
   // while still needing to deliver a cancel.
   facebook::react::EventEmitter::Shared eventEmitterForTag(Tag tag) const {
+    // Nothing, once an instance teardown has been announced: every emitter in
+    // the map points into a Scheduler that is going away, and handing one out
+    // is a call into freed memory. The map itself is emptied on this thread --
+    // see `invalidatePendingMounts`.
+    if (emittersInvalid_.load(std::memory_order_acquire)) {
+      return nullptr;
+    }
     const auto it = eventEmitters_.find(tag);
     return it == eventEmitters_.end() ? nullptr : it->second;
   }
@@ -243,6 +251,11 @@ class MountingWalk {
     // core/TestSettle.h.
     noteMountApplied();
 
+    // Before anything is walked: an instance teardown may have announced itself
+    // from another thread while this transaction sat on the queue, and the
+    // emitters it left behind point into a Scheduler that is gone.
+    dropInvalidatedEmitters();
+
     for (const auto &mutation : mutations) {
       switch (mutation.type) {
         case facebook::react::ShadowViewMutation::Create:
@@ -273,12 +286,92 @@ class MountingWalk {
     resolveRefreshControls();
   }
 
+  // --- A mount that outlived the instance that made it ----------------------
+  //
+  // `executeMount` is called on the JS thread and every host queues the
+  // transaction to its UI thread, so one can still be waiting there when the
+  // React instance that produced it is torn down. A reload does exactly that,
+  // and `ReactHost::reloadReactInstance` does it on a detached thread: it stops
+  // the surfaces, destroys the Scheduler and the SurfaceManager, and builds new
+  // ones, while the mounting manager survives. Applying a queued transaction
+  // after that walks mutations whose event emitters point into an instance that
+  // is gone, and the host dies in its own UI thread with nothing to say.
+  //
+  // So a pending mount carries these two and drops itself when either says it is
+  // stale. `weak_ptr` rather than testing `use_count()`: several mounts can be
+  // queued at once, and each one's own copy would otherwise look like the
+  // manager still holding its.
+  std::weak_ptr<bool> mountGuard() const {
+    return alive_;
+  }
+
+  std::uint64_t mountEpoch() const {
+    return mountEpoch_.load(std::memory_order_relaxed);
+  }
+
+  // Called by a host when React Native hands it a null scheduler task executor,
+  // which is what `destroyReactInstance` does and the only notice a mounting
+  // manager gets that the instance is going away.
+  void invalidatePendingMounts() {
+    mountEpoch_.fetch_add(1, std::memory_order_relaxed);
+    // The emitters are the part that points into the dead instance. The views
+    // stay: the surfaces restart with the same ids, the host owns their roots,
+    // and the next transaction replaces what is under them. An event arriving in
+    // the gap now finds no emitter and does nothing, which is the right answer
+    // and was previously a call into freed memory.
+    //
+    // **A flag rather than the clear itself, and that is the whole of a crash
+    // this project chased twice.** This function runs on whatever thread
+    // `destroyReactInstance` is on, which is not the main one, while a mount
+    // queued earlier may be draining on the main thread -- and `eventEmitters_`
+    // is a `std::unordered_map`. Clearing it from under `destroy()`'s own
+    // `erase` is a plain data race, and what it produces is a wild pointer
+    // inside the hash table's `find`: `host exited -11` on CI's Mac, twice,
+    // with `MountingWalk::destroy` and an `unordered_map::erase` in the stack.
+    // backlog/testing.md carries both occurrences.
+    //
+    // So the flag goes up atomically, nothing hands an emitter out from this
+    // moment on -- which is what the clear was for -- and the map is emptied by
+    // the main thread the next time it walks a transaction or releases its
+    // views.
+    emittersInvalid_.store(true, std::memory_order_release);
+  }
+
+  // How many emitters are still remembered, whatever the flag above says.
+  //
+  // Only the suite asks, and it asks because the thing worth asserting about
+  // the teardown is *which thread* empties the map: an announcement that
+  // cleared it itself would be the data race this project chased twice, and
+  // `eventEmitterForTag` cannot tell the two apart -- it answers nothing either
+  // way. See `a_teardown_leaves_the_clearing_to_the_main_thread`.
+  std::size_t rememberedEmitterCount() const {
+    return eventEmitters_.size();
+  }
+
  protected:
   // Not virtual and not public: this is a mixin, never a base pointer.
   ~MountingWalk() = default;
 
+  // Empties the emitter map if a teardown asked for it, on the thread that owns
+  // it. The one place the map is cleared, and the reason it is not cleared where
+  // the asking happens: see `invalidatePendingMounts`.
+  void dropInvalidatedEmitters() {
+    if (emittersInvalid_.exchange(false, std::memory_order_acq_rel)) {
+      eventEmitters_.clear();
+    }
+  }
+
   // Platforms call this from their own destructor. See the note at the top.
   void releaseAllViews() {
+    dropInvalidatedEmitters();
+    // Same ordering as a Delete, and for the same reason: a side table holding a
+    // view has to be told before the view goes, not after. This path is a host's
+    // own destructor, so getting it wrong is a crash on the way out -- the kind
+    // that looks like a flaky test rather than a bug.
+    for (auto &[tag, view] : registry_) {
+      (void)view;
+      platform().forgetTag(tag);
+    }
     for (auto &[tag, view] : registry_) {
       (void)tag;
       platform().destroyView(view);
@@ -370,9 +463,17 @@ class MountingWalk {
   // in a later transaction.
   void create(const ShadowView &shadowView) {
     ViewRef view = platform().createView(shadowView);
+    // The emitter before the props, which is not the obvious order and is the
+    // one an apply needs: `updateView` is where a platform acts on what it was
+    // given, and acting on some props means sending an event at once.
+    // `<Image onLoadStart>` is the case that found this -- it fires when a load
+    // begins, a load begins on the mount that first carries the source, and
+    // `eventEmitterForTag` answered null for every one of them because the map
+    // was filled two lines further down. The event went nowhere, silently, on
+    // all three hosts.
+    rememberEventEmitter(shadowView);
     platform().updateView(view, shadowView);
     registry_[shadowView.tag] = view;
-    rememberEventEmitter(shadowView);
   }
 
   void destroy(Tag tag) {
@@ -381,6 +482,14 @@ class MountingWalk {
       LOG(WARNING) << "Delete for unknown tag " << tag;
       return;
     }
+    // The platform lets go of the tag *before* the view is released, which is
+    // the ordering every per-tag side table needs: a scroll controller to
+    // detach, a text peer to drop, a canvas to unregister. Each of those takes
+    // the view it remembers, and after `destroyView` that pointer can be freed
+    // memory -- GTK's managers were checking `RN_IS_VIEW` to find out, which
+    // cannot work and crashed once it was asked on a poisoned object. See
+    // GtkFocus.cpp's destructor for the one that bit.
+    platform().forgetTag(tag);
     platform().destroyView(it->second);
     registry_.erase(it);
     eventEmitters_.erase(tag);
@@ -391,7 +500,6 @@ class MountingWalk {
     pullToRefresh_.forget(tag);
     modalViews_.erase(tag);
     modalStack_.erase(std::remove(modalStack_.begin(), modalStack_.end(), tag), modalStack_.end());
-    platform().forgetTag(tag);
   }
 
   void insert(const facebook::react::ShadowViewMutation &mutation) {
@@ -516,6 +624,21 @@ class MountingWalk {
   std::uint64_t overlayGeneration_{0};
   std::shared_ptr<bool> alive_{std::make_shared<bool>(true)};
 
+  // Set when the React instance is torn down and cleared by the main thread;
+  // see invalidatePendingMounts and dropInvalidatedEmitters.
+  std::atomic<bool> emittersInvalid_{false};
+
+  // Bumped when the React instance is torn down; see invalidatePendingMounts.
+  //
+  // Atomic because the two ends are different threads: `destroyReactInstance`
+  // runs on a detached thread and bumps this, while `applyPendingMount` reads it
+  // on the main thread to decide whether to drop itself. A plain integer there is
+  // a data race on the guard that exists to prevent a use-after-free, which is
+  // the wrong place to have one. Relaxed ordering is enough: the only question
+  // asked of it is whether the value still equals the one a mount was queued
+  // with, and a mount that reads a stale epoch is dropped by the next one.
+  std::atomic<std::uint64_t> mountEpoch_{0};
+
   // The main thread, recorded at construction. `executeMount` arrives on the JS
   // thread and marshals here; `applyMutations` asserts it got there.
   std::thread::id mainThreadId_;

package/native/core/PlatformServices.h

@@ -11,15 +11,31 @@
 
 #pragma once
 
+#include <cstddef>
 #include <functional>
 #include <string>
+#include <utility>
 #include <vector>
 
 namespace basalt {
 
 // --- Clipboard ---------------------------------------------------------------
 
-// The clipboard's text, or empty if it holds none. Called on the main thread.
+// The clipboard's text, or empty if it holds none.
+//
+// **Called from the JavaScript thread**, by DesktopClipboardModule, which is
+// where `Clipboard.getString()` and `setString()` arrive. This comment used to
+// say "on the main thread", which was what the seam wanted rather than what it
+// got: the GTK implementation believed it and called GDK from whichever thread
+// asked, which deadlocked a CI run on 2026-10-08. See
+// PlatformServicesGtk.cpp's clipboard section and backlog/testing.md.
+//
+// So each implementation answers for its own toolkit's threading rule. GTK hands
+// the write to its main thread; Windows posts through a message-only window for
+// other work and its clipboard calls are per-thread by design; macOS uses
+// NSPasteboard, which is documented as not thread-safe and makes no blocking
+// round trip against the main thread. backlog/host-wiring.md carries what is
+// left.
 std::string clipboardText();
 void setClipboardText(const std::string &text);
 
@@ -105,6 +121,17 @@ void showFileDialog(const FileDialogRequest &request, FileDialogCallback onDone)
 
 // --- Menus --------------------------------------------------------------------
 
+// Whether this desktop can perform `role` in a popup menu.
+//
+// False for every role a platform has no implementation for: Linux and Windows
+// both lack `about`, neither having a platform about panel to ask for. Declared
+// here rather than below because MenuEntry asks it.
+bool menuRoleSupported(const std::string &role);
+
+// Performs `role` now, on whatever currently has focus. Called on the UI thread,
+// immediately before the chosen index is reported.
+void performMenuRole(const std::string &role);
+
 // One entry in a popup menu. A separator is an item with an empty label, which
 // is how GMenu, NSMenu and an HMENU each spell it too.
 struct MenuEntry {
@@ -117,12 +144,58 @@ struct MenuEntry {
   // inside it are answered in different places on all three desktops.
   std::string shortcut;
 
+  // One of kMenuRoles in MenuModel.h, or empty for an item the app implements
+  // itself. A role is performed by the platform -- the Copy that actually
+  // copies -- and still reports its index, so a caller's `onSelect` runs too.
+  //
+  // A role this platform cannot perform is dropped rather than shown, the same
+  // policy the menu bar has: an item that does nothing is worse than one that is
+  // not there. `menuRoleSupported` says which, and the three do not agree.
+  std::string role;
+
+  // Nested entries. A parent is not choosable itself: it opens its children.
+  //
+  // Both a submenu and a role on one entry is a caller's mistake; the submenu
+  // wins, because that is the one with something under it to lose.
+  std::vector<MenuEntry> submenu;
+
+  // Whether the entry carries a mark, and which kind.
+  //
+  // Two fields rather than one `checked` bool, and GTK is the reason. A GMenu
+  // item has no checked attribute at all: the mark comes from the shape of the
+  // GAction behind it, and GtkPopoverMenu picks a tick or a circle from whether
+  // that action is boolean-stateful or string-stateful with a target. So a bool
+  // cannot say which to draw, and the kind has to be its own field.
+  //
+  // `Radio` is a drawing hint rather than a capability. Windows draws a bullet
+  // and GTK a circle; NSMenu has no radio item, and the mark macOS puts beside a
+  // selected member of an exclusive group is a tick, which is what Apple's own
+  // guidance prescribes. All three can mark a chosen item, so neither kind is
+  // refused anywhere.
+  //
+  // Nothing tri-state: NSControlStateValueMixed has no counterpart on the other
+  // two, so offering it would be offering something only one desktop has.
+  enum class Mark { None, Check, Radio };
+  Mark mark{Mark::None};
+  bool checked{false};
+
   static MenuEntry separator() {
-    return MenuEntry{.label = {}, .enabled = false, .shortcut = {}};
+    // Assigned rather than a designated initializer. One that names some fields
+    // and not others is a -Wmissing-field-initializers error under -Werror, which
+    // the GTK build turns on and the AppKit one does not -- so adding `role` and
+    // `submenu` compiled on a Mac and failed all three Linux shards. Written this
+    // way, the next field costs nothing.
+    MenuEntry entry;
+    entry.enabled = false;
+    return entry;
   }
 
   bool isSeparator() const {
-    return label.empty();
+    return label.empty() && submenu.empty();
+  }
+
+  bool isParent() const {
+    return !submenu.empty();
   }
 };
 
@@ -134,6 +207,117 @@ struct MenuRequest {
   double y{-1.0};
 };
 
+// --- Indexing a menu that is now a tree ---------------------------------------
+//
+// `showMenu` answers with an index, and did so when a popup was a flat list. The
+// index is an entry's position in a *pre-order* walk of the whole menu, counting
+// separators and submenu parents -- so for a flat list it is still the position
+// in the vector, and every caller that predates nesting means what it always
+// meant.
+//
+// Hosts use `walkMenuEntries` to tag their items and `menuEntryAt` to find what
+// an index named, which is how a role is performed and how a parent is told from
+// a leaf.
+namespace detail {
+
+template <typename Visitor>
+int walkMenuEntriesFrom(const std::vector<MenuEntry> &entries, int next, Visitor &visit) {
+  for (const MenuEntry &entry : entries) {
+    const int index = next++;
+    visit(entry, index);
+    if (entry.isParent()) {
+      next = walkMenuEntriesFrom(entry.submenu, next, visit);
+    }
+  }
+  return next;
+}
+
+} // namespace detail
+
+template <typename Visitor>
+void walkMenuEntries(const std::vector<MenuEntry> &entries, Visitor &&visit) {
+  detail::walkMenuEntriesFrom(entries, 0, visit);
+}
+
+// The run of consecutive radio entries `index` belongs to, as a half-open range
+// of pre-order indexes, or {index, index} when it is not a radio entry.
+//
+// A group is a maximal run of adjacent radio siblings, ended by a separator, by a
+// non-radio entry, or by the end of the level. That is a positional definition
+// rather than an identifier on each item, and it fits all three: Win32's
+// CheckMenuRadioItem wants a contiguous range, GTK wants one action per run, and
+// AppKit wants nothing. It also cannot straddle a GMenu section, since the GTK
+// builder breaks into a new section at every separator.
+//
+// The cost is that two adjacent groups with no separator between them read as
+// one. A separator is what every desktop draws between two groups anyway.
+inline std::pair<int, int> menuRadioRun(const std::vector<MenuEntry> &siblings,
+                                        int firstIndexOfLevel,
+                                        std::size_t at) {
+  const int index = firstIndexOfLevel + static_cast<int>(at);
+  if (at >= siblings.size() || siblings[at].mark != MenuEntry::Mark::Radio) {
+    return {index, index};
+  }
+  std::size_t begin = at;
+  while (begin > 0 && siblings[begin - 1].mark == MenuEntry::Mark::Radio) {
+    begin--;
+  }
+  std::size_t end = at + 1;
+  while (end < siblings.size() && siblings[end].mark == MenuEntry::Mark::Radio) {
+    end++;
+  }
+  return {firstIndexOfLevel + static_cast<int>(begin),
+          firstIndexOfLevel + static_cast<int>(end)};
+}
+
+// How many entries a menu has, counting every level. The number of valid
+// indexes, which is not `entries.size()` once anything nests.
+inline int menuEntryCount(const std::vector<MenuEntry> &entries) {
+  int count = 0;
+  walkMenuEntries(entries, [&](const MenuEntry &, int) { ++count; });
+  return count;
+}
+
+inline const MenuEntry *menuEntryAt(const std::vector<MenuEntry> &entries, int index) {
+  const MenuEntry *found = nullptr;
+  walkMenuEntries(entries, [&](const MenuEntry &entry, int at) {
+    if (at == index) {
+      found = &entry;
+    }
+  });
+  return found;
+}
+
+// Whether an entry is drawn at all.
+//
+// False for a role this desktop cannot perform, and for a parent with nothing
+// under it that would be drawn. A dropped entry is still *counted*, which is the
+// part that matters: JavaScript numbers the list it passed, so an entry
+// disappearing from the count would shift every index after it onto the wrong
+// handler. See walkMenuEntries.
+inline bool menuEntryShown(const MenuEntry &entry);
+
+inline bool anyMenuEntryShown(const std::vector<MenuEntry> &entries) {
+  for (const MenuEntry &entry : entries) {
+    if (menuEntryShown(entry)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+inline bool menuEntryShown(const MenuEntry &entry) {
+  if (!entry.role.empty() && !menuRoleSupported(entry.role)) {
+    return false;
+  }
+  if (entry.isParent()) {
+    // An empty submenu is a dead end rather than an item, which is what a parent
+    // becomes when every child named a role this desktop does not have.
+    return anyMenuEntryShown(entry.submenu);
+  }
+  return true;
+}
+
 // Shows a popup menu and calls `onChosen` with the index of the entry picked,
 // or -1 when it was dismissed. Indexes count separators, so they line up with
 // the vector that was passed in.

package/native/core/SafeAreaComponent.cpp

@@ -0,0 +1,115 @@
+#include "SafeAreaComponent.h"
+
+#include <jsi/jsi.h>
+
+namespace facebook::react {
+
+extern const char SafeAreaProviderComponentName[] = "RNCSafeAreaProvider";
+
+void SafeAreaProviderEventEmitter::onInsetsChange(const Rect &frame,
+                                                  const EdgeInsets &insets) const {
+  dispatchEvent("insetsChange", [frame, insets](jsi::Runtime &runtime) {
+    auto frameOut = jsi::Object(runtime);
+    frameOut.setProperty(runtime, "x", frame.origin.x);
+    frameOut.setProperty(runtime, "y", frame.origin.y);
+    frameOut.setProperty(runtime, "width", frame.size.width);
+    frameOut.setProperty(runtime, "height", frame.size.height);
+
+    auto insetsOut = jsi::Object(runtime);
+    insetsOut.setProperty(runtime, "top", insets.top);
+    insetsOut.setProperty(runtime, "right", insets.right);
+    insetsOut.setProperty(runtime, "bottom", insets.bottom);
+    insetsOut.setProperty(runtime, "left", insets.left);
+
+    auto payload = jsi::Object(runtime);
+    payload.setProperty(runtime, "frame", std::move(frameOut));
+    payload.setProperty(runtime, "insets", std::move(insetsOut));
+    return payload;
+  });
+}
+
+// Emitted on every layout that produces a real frame, rather than only on a
+// change.
+//
+// A shadow node is cloned per commit, so there is nowhere here to remember what
+// was sent last without carrying Fabric State for it, and State for a value the
+// platform already knows would be machinery for its own sake. The deduplication
+// that matters is already in the library: `setInsets` and `setFrame` both
+// compare before they store, so an identical event is a React state write that
+// bails out without re-rendering, and the loop this would otherwise be settles
+// after one pass.
+//
+// The zero-size guard is not an optimisation. The first layout of a surface can
+// produce an empty frame, and emitting that would unblock the provider's
+// children against a 0x0 frame, which is worse than making them wait one more
+// pass for the real one.
+void SafeAreaProviderShadowNode::layout(LayoutContext layoutContext) {
+  ConcreteViewShadowNode::layout(layoutContext);
+
+  const auto frame = getLayoutMetrics().frame;
+  if (frame.size.width <= 0 || frame.size.height <= 0) {
+    return;
+  }
+  // Zero on every desktop: a window has no notch and no home indicator. See the
+  // header for what would change that.
+  getConcreteEventEmitter().onInsetsChange(frame, EdgeInsets{0, 0, 0, 0});
+}
+
+} // namespace facebook::react
+
+namespace basalt {
+namespace {
+
+// Written once by the host thread before JavaScript runs and read from the JS
+// thread afterwards, which is the ordering every host already has for its
+// window. Plain doubles rather than an atomic pair: a torn read here would
+// produce a slightly wrong first frame that the first `onInsetsChange`
+// immediately replaces, and a mutex on a value read once is not worth it.
+double gWindowWidth = 0;
+double gWindowHeight = 0;
+
+} // namespace
+
+void setInitialWindowFrame(double width, double height) {
+  gWindowWidth = width;
+  gWindowHeight = height;
+}
+
+DesktopSafeAreaModule::DesktopSafeAreaModule(
+    std::shared_ptr<facebook::react::CallInvoker> jsInvoker)
+    : TurboModule(kModuleName, std::move(jsInvoker)) {
+  methodMap_["getConstants"] = MethodMetadata{0, getConstants};
+}
+
+facebook::jsi::Value DesktopSafeAreaModule::getConstants(
+    facebook::jsi::Runtime &runtime,
+    facebook::react::TurboModule & /*module*/,
+    const facebook::jsi::Value * /*args*/,
+    size_t /*count*/) {
+  auto constants = facebook::jsi::Object(runtime);
+  if (gWindowWidth <= 0 || gWindowHeight <= 0) {
+    // Absent rather than zero. See setInitialWindowFrame.
+    return constants;
+  }
+
+  auto insets = facebook::jsi::Object(runtime);
+  insets.setProperty(runtime, "top", 0);
+  insets.setProperty(runtime, "right", 0);
+  insets.setProperty(runtime, "bottom", 0);
+  insets.setProperty(runtime, "left", 0);
+
+  auto frame = facebook::jsi::Object(runtime);
+  frame.setProperty(runtime, "x", 0);
+  frame.setProperty(runtime, "y", 0);
+  frame.setProperty(runtime, "width", gWindowWidth);
+  frame.setProperty(runtime, "height", gWindowHeight);
+
+  auto metrics = facebook::jsi::Object(runtime);
+  metrics.setProperty(runtime, "insets", std::move(insets));
+  metrics.setProperty(runtime, "frame", std::move(frame));
+
+  constants.setProperty(runtime, "initialWindowMetrics", std::move(metrics));
+  return constants;
+}
+
+} // namespace basalt