@depup/react-native 0.86.0-depup.49 → 0.87.0-depup.0

package/ReactCommon/react/renderer/viewtransition/ViewTransitionModule.cpp

@@ -7,6 +7,7 @@
 
 #include "ViewTransitionModule.h"
 
+#include <cxxreact/TraceSection.h>
 #include <glog/logging.h>
 #include <react/renderer/components/root/RootShadowNode.h>
 #include <react/renderer/core/LayoutableShadowNode.h>
@@ -17,6 +18,19 @@
 
 namespace facebook::react {
 
+namespace {
+
+RawProps makePseudoElementRawProps(
+    const ViewTransitionModule::AnimationKeyFrameViewLayoutMetrics& metrics) {
+  return RawProps(
+      folly::dynamic::object("position", "absolute")(
+          "left", metrics.originFromRoot.x)("top", metrics.originFromRoot.y)(
+          "width", metrics.size.width)("height", metrics.size.height)(
+          "pointerEvents", "none")("opacity", 0)("collapsable", false));
+}
+
+} // namespace
+
 ViewTransitionModule::~ViewTransitionModule() {
   if (uiManager_ != nullptr) {
     if (uiManager_->getViewTransitionDelegate() == this) {
@@ -45,7 +59,7 @@ void ViewTransitionModule::initialize(
         });
 
     // Register on surfaces started in the future
-    uiManager_->setOnSurfaceStartCallback(
+    uiManager_->addOnSurfaceStartCallback(
         [weakThis](const ShadowTree& shadowTree) {
           shadowTree.getMountingCoordinator()->setMountingOverrideDelegate(
               weakThis);
@@ -59,6 +73,7 @@ void ViewTransitionModule::applyViewTransitionName(
     const ShadowNode& shadowNode,
     const std::string& name,
     const std::string& /*className*/) {
+  TraceSection s("ViewTransitionModule::applyViewTransitionName", "name", name);
   auto tag = shadowNode.getTag();
   auto surfaceId = shadowNode.getSurfaceId();
 
@@ -73,14 +88,22 @@ void ViewTransitionModule::applyViewTransitionName(
       .size = layoutMetrics.frame.size,
       .pointScaleFactor = layoutMetrics.pointScaleFactor};
 
-  nameRegistry_[tag].insert(name);
-
-  // If applyViewTransitionName is called after transition started, this is the
-  // "new" state (end snapshot). Otherwise, this is the "old" state (start
-  // snapshot)
-  if (!transitionStarted_) {
+  // Calls outside mutationCallback are from the before-mutation phase (old
+  // state for an upcoming transition). Assign a provisional next transition ID
+  // so startViewTransitionEnd cleanup preserves these entries.
+  auto currentTransitionId =
+      insideMutationCallback_ ? activeTransitionId_ : activeTransitionId_ + 1;
+  nameRegistry_[tag].names.insert(name);
+  nameRegistry_[tag].transitionId = currentTransitionId;
+
+  // Old state: called outside mutationCallback (before-mutation phase).
+  // New state: called inside mutationCallback (after-mutation phase).
+  if (!insideMutationCallback_) {
     AnimationKeyFrameView oldView{
-        .layoutMetrics = keyframeMetrics, .tag = tag, .surfaceId = surfaceId};
+        .layoutMetrics = keyframeMetrics,
+        .tag = tag,
+        .surfaceId = surfaceId,
+        .transitionId = currentTransitionId};
     oldLayout_[name] = oldView;
 
     // Request the platform to capture a bitmap snapshot of the old view
@@ -88,6 +111,10 @@ void ViewTransitionModule::applyViewTransitionName(
     if (uiManager_ != nullptr) {
       auto* delegate = uiManager_->getDelegate();
       if (delegate != nullptr) {
+        TraceSection snapshotSection(
+            "ViewTransitionModule::applyViewTransitionName - uiManagerDidCaptureViewSnapshot",
+            "name",
+            name);
         delegate->uiManagerDidCaptureViewSnapshot(tag, surfaceId);
       }
     }
@@ -98,6 +125,11 @@ void ViewTransitionModule::applyViewTransitionName(
       auto& pseudoElementsBySourceTag = it->second;
       auto innerIt = pseudoElementsBySourceTag.find(tag);
 
+      TraceSection clonePseudoElementSection(
+          "ViewTransitionModule::applyViewTransitionName - maybeClonePseudoElement",
+          "name",
+          name);
+
       if (innerIt != pseudoElementsBySourceTag.end()) {
         // Only clone the pseudo-element if the layout metrics changed
         // since it was last created/refreshed (e.g. due to scrolling or
@@ -109,13 +141,7 @@ void ViewTransitionModule::applyViewTransitionName(
                 keyframeMetrics.originFromRoot.y ||
             cachedMetrics.size.width != keyframeMetrics.size.width ||
             cachedMetrics.size.height != keyframeMetrics.size.height) {
-          auto updatedRawProps = RawProps(
-              folly::dynamic::object("left", keyframeMetrics.originFromRoot.x)(
-                  "top", keyframeMetrics.originFromRoot.y)(
-                  "width", keyframeMetrics.size.width)(
-                  "height", keyframeMetrics.size.height)(
-                  "pointerEvents", "none")("opacity", 0)("collapsable", false)(
-                  "position", "absolute"));
+          auto updatedRawProps = makePseudoElementRawProps(keyframeMetrics);
 
           auto updatedNode = uiManager_->cloneNode(
               *innerIt->second.node,
@@ -140,7 +166,10 @@ void ViewTransitionModule::applyViewTransitionName(
 
   } else {
     AnimationKeyFrameView newView{
-        .layoutMetrics = keyframeMetrics, .tag = tag, .surfaceId = surfaceId};
+        .layoutMetrics = keyframeMetrics,
+        .tag = tag,
+        .surfaceId = surfaceId,
+        .transitionId = activeTransitionId_};
     newLayout_[name] = newView;
   }
 }
@@ -148,6 +177,8 @@ void ViewTransitionModule::applyViewTransitionName(
 void ViewTransitionModule::createViewTransitionInstance(
     const std::string& name,
     Tag pseudoElementTag) {
+  TraceSection s(
+      "ViewTransitionModule::createViewTransitionInstance", "name", name);
   if (uiManager_ == nullptr) {
     return;
   }
@@ -171,31 +202,17 @@ void ViewTransitionModule::createViewTransitionInstance(
 
   // Build props: absolute position matching old element, non-interactive
   if (pseudoElementTag > 0 && view.tag > 0) {
-    // Create a base node with layout props via createNode
     // TODO: T262559684 created dedicated shadow node type for old pseudo
     // element
-    auto rawProps = RawProps(
-        folly::dynamic::object("position", "absolute")(
-            "left", view.layoutMetrics.originFromRoot.x)(
-            "top", view.layoutMetrics.originFromRoot.y)(
-            "width", view.layoutMetrics.size.width)(
-            "height", view.layoutMetrics.size.height)("pointerEvents", "none")(
-            "opacity", 0)("collapsable", false));
-
-    auto baseNode = uiManager_->createNode(
+    auto rawProps = makePseudoElementRawProps(view.layoutMetrics);
+
+    auto pseudoElementNode = uiManager_->createNode(
         pseudoElementTag,
         "View",
         view.surfaceId,
         std::move(rawProps),
         nullptr /* instanceHandle */);
 
-    if (baseNode == nullptr) {
-      return;
-    }
-
-    // Clone the shadow node — bitmap will be set by platform
-    auto pseudoElementNode = baseNode->clone({});
-
     if (pseudoElementNode != nullptr) {
       if (!forNextTransition) {
         oldPseudoElementNodes_[name] = pseudoElementNode;
@@ -216,6 +233,7 @@ RootShadowNode::Unshared ViewTransitionModule::shadowTreeWillCommit(
   if (oldPseudoElementNodes_.empty()) {
     return newRootShadowNode;
   }
+  TraceSection s("ViewTransitionModule::shadowTreeWillCommit");
 
   auto surfaceId = shadowTree.getSurfaceId();
 
@@ -323,12 +341,14 @@ void ViewTransitionModule::cancelViewTransitionName(
 
 void ViewTransitionModule::restoreViewTransitionName(
     const ShadowNode& shadowNode) {
-  nameRegistry_[shadowNode.getTag()].merge(
+  nameRegistry_[shadowNode.getTag()].names.merge(
       cancelledNameRegistry_[shadowNode.getTag()]);
   cancelledNameRegistry_.erase(shadowNode.getTag());
 }
 
 void ViewTransitionModule::applySnapshotsOnPseudoElementShadowNodes() {
+  TraceSection s(
+      "ViewTransitionModule::applySnapshotsOnPseudoElementShadowNodes");
   if (oldPseudoElementNodes_.empty() || uiManager_ == nullptr) {
     return;
   }
@@ -349,6 +369,7 @@ void ViewTransitionModule::applySnapshotsOnPseudoElementShadowNodes() {
 
 LayoutMetrics ViewTransitionModule::captureLayoutMetricsFromRoot(
     const ShadowNode& shadowNode) {
+  TraceSection s("ViewTransitionModule::captureLayoutMetricsFromRoot");
   if (uiManager_ == nullptr) {
     return EmptyLayoutMetrics;
   }
@@ -394,13 +415,22 @@ void ViewTransitionModule::startViewTransition(
 
   // Mark transition as started
   transitionStarted_ = true;
+  activeTransitionId_ = ++transitionIdCounter_;
+
+  TraceSection s(
+      "ViewTransitionModule::startViewTransition",
+      "transitionId",
+      activeTransitionId_);
+
   pendingAnimationIds_.clear();
   onCompleteCallback_ = onCompleteCallback;
 
   // Call mutation callback (including commitRoot, measureInstance,
   // applyViewTransitionName, createViewTransitionInstance for old & new)
   if (mutationCallback) {
+    insideMutationCallback_ = true;
     mutationCallback();
+    insideMutationCallback_ = false;
   }
 
   applySnapshotsOnPseudoElementShadowNodes();
@@ -449,13 +479,32 @@ void ViewTransitionModule::suspendOnActiveViewTransition() {
 }
 
 void ViewTransitionModule::startViewTransitionEnd() {
-  for (const auto& [tag, names] : nameRegistry_) {
-    for (const auto& name : names) {
-      oldLayout_.erase(name);
-      newLayout_.erase(name);
+  TraceSection s(
+      "ViewTransitionModule::startViewTransitionEnd",
+      "transitionId",
+      activeTransitionId_);
+  auto finishedId = activeTransitionId_;
+
+  // Only clear layout and registry entries belonging to the finished
+  // transition. A suspended transition's before-mutation phase may have
+  // already written entries with a newer transitionId — preserve those.
+  for (auto it = nameRegistry_.begin(); it != nameRegistry_.end();) {
+    if (it->second.transitionId == finishedId) {
+      for (const auto& name : it->second.names) {
+        if (auto oit = oldLayout_.find(name);
+            oit != oldLayout_.end() && oit->second.transitionId == finishedId) {
+          oldLayout_.erase(oit);
+        }
+        if (auto nit = newLayout_.find(name);
+            nit != newLayout_.end() && nit->second.transitionId == finishedId) {
+          newLayout_.erase(nit);
+        }
+      }
+      it = nameRegistry_.erase(it);
+    } else {
+      ++it;
     }
   }
-  nameRegistry_.clear();
   oldPseudoElementNodes_.clear();
 
   // Clear any pending bitmap snapshots that were captured but never consumed.

package/ReactCommon/react/renderer/viewtransition/ViewTransitionModule.h

@@ -98,17 +98,25 @@ class ViewTransitionModule : public UIManagerViewTransitionDelegate,
     AnimationKeyFrameViewLayoutMetrics layoutMetrics;
     Tag tag{0};
     SurfaceId surfaceId{0};
+    uint32_t transitionId{0};
   };
 
  private:
+  uint32_t transitionIdCounter_{0};
+  uint32_t activeTransitionId_{0};
+
   // registry of layout of old/new views
   std::unordered_map<std::string, AnimationKeyFrameView> oldLayout_{};
   std::unordered_map<std::string, AnimationKeyFrameView> newLayout_{};
-  // tag -> names registry, populated during applyViewTransitionName
+  // tag -> (names, transitionId) registry, populated during applyViewTransitionName
   // Note that tag and name are not 1:1 mapping
   // - In some nested composition 2 names are mappped to the same tag
   // - tags of old and new views are mapped to the same name(s)
-  std::unordered_map<Tag, std::unordered_set<std::string>> nameRegistry_{};
+  struct NameRegistryEntry {
+    std::unordered_set<std::string> names;
+    uint32_t transitionId{0};
+  };
+  std::unordered_map<Tag, NameRegistryEntry> nameRegistry_{};
 
   // used for cancel/restore viewTransitionName
   std::unordered_map<Tag, std::unordered_set<std::string>> cancelledNameRegistry_{};
@@ -138,6 +146,8 @@ class ViewTransitionModule : public UIManagerViewTransitionDelegate,
 
   bool transitionStarted_{false};
 
+  bool insideMutationCallback_{false};
+
   bool transitionReadyFinished_{false};
 
   // When suspendNextTransition_ is true and a transition is active, the next

package/ReactCommon/react/runtime/PlatformTimerRegistry.h

@@ -8,9 +8,12 @@
 #pragma once
 
 #include <cstdint>
+#include <memory>
 
 namespace facebook::react {
 
+class TimerManager;
+
 /**
  * This interface is implemented by each platform.
  * Responsibility: Call into some platform API to register/schedule, or delete
@@ -27,6 +30,13 @@ class PlatformTimerRegistry {
   virtual ~PlatformTimerRegistry() noexcept = default;
 
   virtual void quit() {}
+
+  /**
+   * Provides the owning TimerManager so the registry can fire due timers via
+   * TimerManager::callTimer. The default is a no-op for platforms that wire the
+   * TimerManager through other means.
+   */
+  virtual void setTimerManager(std::weak_ptr<TimerManager> /*timerManager*/) {}
 };
 
 using TimerManagerDelegate = PlatformTimerRegistry;

package/ReactCommon/react/runtime/ReactInstance.cpp

@@ -8,12 +8,11 @@
 #include "ReactInstance.h"
 
 #include <ReactCommon/RuntimeExecutor.h>
-#include <cxxreact/ErrorUtils.h>
 #include <cxxreact/JSBigString.h>
-#include <cxxreact/JSExecutor.h>
 #include <cxxreact/ReactMarker.h>
 #include <cxxreact/TraceSection.h>
 #include <glog/logging.h>
+#include <jserrorhandler/ErrorUtils.h>
 #include <jsi/JSIDynamic.h>
 #include <jsi/hermes-interfaces.h>
 #include <jsi/instrumentation.h>
@@ -48,6 +47,16 @@ std::shared_ptr<RuntimeScheduler> createRuntimeScheduler(
   return scheduler;
 }
 
+void setHermesEventLoopControl(
+    jsi::Runtime& runtime,
+    facebook::hermes::IEventLoopControl* eventLoopControl) {
+  auto* setEventLoopControl =
+      jsi::castInterface<facebook::hermes::ISetEventLoopControl>(&runtime);
+  if (setEventLoopControl != nullptr) {
+    setEventLoopControl->setEventLoopControl(eventLoopControl);
+  }
+}
+
 std::string getSyntheticBundlePath(uint32_t bundleId) {
   std::array<char, 32> buffer{};
   std::snprintf(buffer.data(), buffer.size(), "seg-%u.js", bundleId);
@@ -156,6 +165,11 @@ ReactInstance::ReactInstance(
         });
   }
 
+  runtimeExecutor(
+      [runtimeScheduler = runtimeScheduler_.get()](jsi::Runtime& runtime) {
+        setHermesEventLoopControl(runtime, runtimeScheduler);
+      });
+
   bufferedRuntimeExecutor_ = std::make_shared<BufferedRuntimeExecutor>(
       [runtimeScheduler = runtimeScheduler_.get()](
           std::function<void(jsi::Runtime & runtime)>&& callback) {
@@ -163,6 +177,11 @@ ReactInstance::ReactInstance(
       });
 }
 ReactInstance::~ReactInstance() noexcept {
+  // This is thread safe because there is no JSI call at this point, and there
+  // won't be any concurrent calls to getEventLoopControl().
+  // We need to clear this pointer before runtimeScheduler_ is destroyed.
+  setHermesEventLoopControl(runtime_->getRuntime(), nullptr);
+
   if (timerManager_ != nullptr) {
     timerManager_->quit();
   }
@@ -235,62 +254,63 @@ void ReactInstance::loadScript(
   std::shared_ptr<const jsi::Buffer> buffer(std::move(script));
   std::string scriptName = simpleBasename(sourceURL);
 
-  runtimeScheduler_->scheduleWork([this,
-                                   scriptName,
-                                   sourceURL,
-                                   buffer = std::move(buffer),
-                                   weakBufferedRuntimeExecuter =
-                                       std::weak_ptr<BufferedRuntimeExecutor>(
-                                           bufferedRuntimeExecutor_),
-                                   beforeLoad,
-                                   afterLoad](jsi::Runtime& runtime) mutable {
-    if (beforeLoad) {
-      beforeLoad(runtime);
-    }
-    TraceSection s("ReactInstance::loadScript");
-    bool hasLogger(ReactMarker::logTaggedMarkerBridgelessImpl != nullptr);
-    if (hasLogger) {
-      ReactMarker::logTaggedMarkerBridgeless(
-          ReactMarker::RUN_JS_BUNDLE_START, scriptName.c_str());
-      ReactMarker::logMarkerBridgeless(ReactMarker::INIT_REACT_RUNTIME_START);
-      ReactMarker::logMarkerBridgeless(ReactMarker::APP_STARTUP_START);
-    }
+  runtimeScheduler_->scheduleWork(
+      [jsErrorHandler = jsErrorHandler_,
+       scriptName,
+       sourceURL = sourceURL,
+       buffer = std::move(buffer),
+       weakBufferedRuntimeExecuter =
+           std::weak_ptr<BufferedRuntimeExecutor>(bufferedRuntimeExecutor_),
+       beforeLoad,
+       afterLoad](jsi::Runtime& runtime) mutable {
+        if (beforeLoad) {
+          beforeLoad(runtime);
+        }
+        TraceSection s("ReactInstance::loadScript");
+        bool hasLogger(ReactMarker::logTaggedMarkerImpl);
+        if (hasLogger) {
+          ReactMarker::logTaggedMarker(
+              ReactMarker::RUN_JS_BUNDLE_START, scriptName.c_str());
+          ReactMarker::logMarker(ReactMarker::INIT_REACT_RUNTIME_START);
+          ReactMarker::logMarker(ReactMarker::APP_STARTUP_START);
+        }
 
-    // Check if the shermes unit is avaliable.
-    auto* shUnitAPI = jsi::castInterface<hermes::IHermesSHUnit>(&runtime);
-    auto* shUnitCreator = shUnitAPI ? shUnitAPI->getSHUnitCreator() : nullptr;
-    if (shUnitCreator) {
-      LOG(WARNING) << "ReactInstance: evaluateSHUnit";
-      auto* hermesAPI = jsi::castInterface<hermes::IHermes>(&runtime);
-      hermesAPI->evaluateSHUnit(shUnitCreator);
-    } else {
-      LOG(WARNING) << "ReactInstance: evaluateJavaScript() with JS bundle";
-      runtime.evaluateJavaScript(buffer, sourceURL);
-    }
+        // Check if the shermes unit is avaliable.
+        auto* shUnitAPI = jsi::castInterface<hermes::IHermesSHUnit>(&runtime);
+        auto* shUnitCreator =
+            shUnitAPI ? shUnitAPI->getSHUnitCreator() : nullptr;
+        if (shUnitCreator) {
+          LOG(WARNING) << "ReactInstance: evaluateSHUnit";
+          auto* hermesAPI = jsi::castInterface<hermes::IHermes>(&runtime);
+          hermesAPI->evaluateSHUnit(shUnitCreator);
+        } else {
+          LOG(WARNING) << "ReactInstance: evaluateJavaScript() with JS bundle";
+          runtime.evaluateJavaScript(buffer, sourceURL);
+        }
 
-    /**
-     * TODO(T183610671): We need a safe/reliable way to enable the js
-     * pipeline from javascript. Remove this after we figure that out, or
-     * after we just remove the js pipeline.
-     */
-    if (!jsErrorHandler_->hasHandledFatalError()) {
-      jsErrorHandler_->setRuntimeReady();
-    }
+        /**
+         * TODO(T183610671): We need a safe/reliable way to enable the js
+         * pipeline from javascript. Remove this after we figure that out, or
+         * after we just remove the js pipeline.
+         */
+        if (!jsErrorHandler->hasHandledFatalError()) {
+          jsErrorHandler->setRuntimeReady();
+        }
 
-    if (hasLogger) {
-      ReactMarker::logTaggedMarkerBridgeless(
-          ReactMarker::RUN_JS_BUNDLE_STOP, scriptName.c_str());
-      ReactMarker::logMarkerBridgeless(ReactMarker::INIT_REACT_RUNTIME_STOP);
-      ReactMarker::logMarkerBridgeless(ReactMarker::APP_STARTUP_STOP);
-    }
-    if (auto strongBufferedRuntimeExecuter =
-            weakBufferedRuntimeExecuter.lock()) {
-      strongBufferedRuntimeExecuter->flush();
-    }
-    if (afterLoad) {
-      afterLoad(runtime);
-    }
-  });
+        if (hasLogger) {
+          ReactMarker::logTaggedMarker(
+              ReactMarker::RUN_JS_BUNDLE_STOP, scriptName.c_str());
+          ReactMarker::logMarker(ReactMarker::INIT_REACT_RUNTIME_STOP);
+          ReactMarker::logMarker(ReactMarker::APP_STARTUP_STOP);
+        }
+        if (auto strongBufferedRuntimeExecuter =
+                weakBufferedRuntimeExecuter.lock()) {
+          strongBufferedRuntimeExecuter->flush();
+        }
+        if (afterLoad) {
+          afterLoad(runtime);
+        }
+      });
 }
 
 /*
@@ -369,21 +389,16 @@ void ReactInstance::registerSegment(
           "Empty segment registered with ID " + tag + " from " + segmentPath);
     }
 
-    bool hasLogger(ReactMarker::logTaggedMarkerBridgelessImpl != nullptr);
-    if (hasLogger) {
-      ReactMarker::logTaggedMarkerBridgeless(
-          ReactMarker::REGISTER_JS_SEGMENT_START, tag.c_str());
-    }
+    ReactMarker::logTaggedMarker(
+        ReactMarker::REGISTER_JS_SEGMENT_START, tag.c_str());
     LOG(WARNING) << "Starting to evaluate segment " << segmentId
                  << " in ReactInstance::registerSegment";
     runtime.evaluateJavaScript(
         std::move(script), getSyntheticBundlePath(segmentId));
     LOG(WARNING) << "Finished evaluating segment " << segmentId
                  << " in ReactInstance::registerSegment";
-    if (hasLogger) {
-      ReactMarker::logTaggedMarkerBridgeless(
-          ReactMarker::REGISTER_JS_SEGMENT_STOP, tag.c_str());
-    }
+    ReactMarker::logTaggedMarker(
+        ReactMarker::REGISTER_JS_SEGMENT_STOP, tag.c_str());
   });
 }
 

package/ReactCommon/react/runtime/hermes/HermesInstance.cpp

@@ -12,90 +12,11 @@
 #include <jsinspector-modern/InspectorFlags.h>
 #include <react/featureflags/ReactNativeFeatureFlags.h>
 
-#ifdef HERMES_ENABLE_DEBUGGER
-#include <hermes/inspector-modern/chrome/Registration.h>
-
-#ifndef HERMES_V1_ENABLED
-#include <hermes/inspector/RuntimeAdapter.h>
-#endif
-
-#include <jsi/decorator.h>
-#endif
-
 using namespace facebook::hermes;
 using namespace facebook::jsi;
 
 namespace facebook::react {
 
-#if defined(HERMES_ENABLE_DEBUGGER) && !defined(HERMES_V1_ENABLED)
-
-// Wrapper that strongly retains the HermesRuntime for on device debugging.
-//
-// HermesInstanceRuntimeAdapter needs to strongly retain the HermesRuntime. Why:
-//   - facebook::hermes::inspector_modern::chrome::Connection::Impl owns the
-//   Adapter
-//   - facebook::hermes::inspector_modern::chrome::Connection::Impl also owns
-//   jsi:: objects
-//   - jsi:: objects need to be deleted before the Runtime.
-//
-// If Adapter doesn't share ownership over jsi::Runtime, the runtime can be
-// deleted before Connection::Impl cleans up all its jsi:: Objects. This will
-// lead to a runtime crash.
-class HermesInstanceRuntimeAdapter : public inspector_modern::RuntimeAdapter {
- public:
-  HermesInstanceRuntimeAdapter(
-      std::shared_ptr<HermesRuntime> hermesRuntime,
-      std::shared_ptr<MessageQueueThread> msgQueueThread)
-      : hermesRuntime_(std::move(hermesRuntime)),
-        messageQueueThread_(std::move(msgQueueThread)) {}
-  virtual ~HermesInstanceRuntimeAdapter() = default;
-
-  HermesRuntime& getRuntime() override {
-    return *hermesRuntime_;
-  }
-
-  void tickleJs() override {
-    std::weak_ptr<HermesRuntime> weakRuntime(hermesRuntime_);
-    messageQueueThread_->runOnQueue([weakRuntime]() {
-      auto runtime = weakRuntime.lock();
-      if (!runtime) {
-        return;
-      }
-      jsi::Function func =
-          runtime->global().getPropertyAsFunction(*runtime, "__tickleJs");
-      func.call(*runtime);
-    });
-  }
-
- private:
-  std::shared_ptr<HermesRuntime> hermesRuntime_;
-  std::shared_ptr<MessageQueueThread> messageQueueThread_;
-};
-
-class DecoratedRuntime : public jsi::RuntimeDecorator<jsi::Runtime> {
- public:
-  DecoratedRuntime(
-      std::unique_ptr<HermesRuntime> runtime,
-      std::shared_ptr<MessageQueueThread> msgQueueThread)
-      : RuntimeDecorator<jsi::Runtime>(*runtime), runtime_(std::move(runtime)) {
-    auto adapter = std::make_unique<HermesInstanceRuntimeAdapter>(
-        runtime_, msgQueueThread);
-
-    debugToken_ = inspector_modern::chrome::enableDebugging(
-        std::move(adapter), "Hermes Bridgeless React Native");
-  }
-
-  ~DecoratedRuntime() {
-    inspector_modern::chrome::disableDebugging(debugToken_);
-  }
-
- private:
-  std::shared_ptr<HermesRuntime> runtime_;
-  inspector_modern::chrome::DebugSessionToken debugToken_;
-};
-
-#endif // defined(HERMES_ENABLE_DEBUGGER) && !defined(HERMES_V1_ENABLED)
-
 class HermesJSRuntime : public JSRuntime {
  public:
   HermesJSRuntime(
@@ -164,17 +85,7 @@ std::unique_ptr<JSRuntime> HermesInstance::createJSRuntime(
                             .getPropertyAsObject(*hermesRuntime, "prototype");
   errorPrototype.setProperty(*hermesRuntime, "jsEngine", "hermes");
 
-#if defined(HERMES_ENABLE_DEBUGGER) && !defined(HERMES_V1_ENABLED)
-  auto& inspectorFlags = jsinspector_modern::InspectorFlags::getInstance();
-  if (!inspectorFlags.getFuseboxEnabled()) {
-    std::unique_ptr<DecoratedRuntime> decoratedRuntime =
-        std::make_unique<DecoratedRuntime>(
-            std::move(hermesRuntime), msgQueueThread);
-    return std::make_unique<JSIRuntimeHolder>(std::move(decoratedRuntime));
-  }
-#else
   (void)msgQueueThread;
-#endif
 
   HermesRuntime& hermesRuntimeRef = *hermesRuntime;
   return std::make_unique<HermesJSRuntime>(