react-native 0.74.0-nightly-20240129-39cb02f6f → 1000.0.0

package/ReactAndroid/src/main/jni/react/featureflags/ReactNativeFeatureFlagsProviderHolder.cpp

@@ -4,7 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @generated SignedSource<<91f988022fbff7eba632f2ba46056025>>
+ * @generated SignedSource<<5f99c47d357e45524b359e6517d1f2eb>>
  */
 
 /**
@@ -51,4 +51,10 @@ bool ReactNativeFeatureFlagsProviderHolder::batchRenderingUpdatesInEventLoop() {
   return method(javaProvider_);
 }
 
+bool ReactNativeFeatureFlagsProviderHolder::enableSpannableBuildingUnification() {
+  static const auto method =
+      getJClass()->getMethod<jboolean()>("enableSpannableBuildingUnification");
+  return method(javaProvider_);
+}
+
 } // namespace facebook::react

package/ReactAndroid/src/main/jni/react/featureflags/ReactNativeFeatureFlagsProviderHolder.h

@@ -4,7 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @generated SignedSource<<3550f7ee28a53a4024a48301ee38ce7e>>
+ * @generated SignedSource<<6aaa06ae0c12de2f432374d0cd048460>>
  */
 
 /**
@@ -39,6 +39,7 @@ class ReactNativeFeatureFlagsProviderHolder
   bool useModernRuntimeScheduler() override;
   bool enableMicrotasks() override;
   bool batchRenderingUpdatesInEventLoop() override;
+  bool enableSpannableBuildingUnification() override;
 
  private:
   jni::global_ref<jobject> javaProvider_;

package/ReactAndroid/src/main/jni/react/jni/OnLoad.cpp

@@ -10,7 +10,6 @@
 #include <glog/logging.h>
 
 #include <fb/glog_init.h>
-#include <fb/log.h>
 #include <fbjni/fbjni.h>
 
 #include "CatalystInstanceImpl.h"
@@ -27,27 +26,29 @@
 #define WITH_GLOGINIT 1
 #endif
 
-using namespace facebook::jni;
+#ifdef WITH_XPLATINIT
+#include <fb/xplat_init.h>
+#endif
 
 namespace facebook::react {
 
 namespace {
 
-struct JavaJSExecutor : public JavaClass<JavaJSExecutor> {
+struct JavaJSExecutor : public jni::JavaClass<JavaJSExecutor> {
   static constexpr auto kJavaDescriptor =
       "Lcom/facebook/react/bridge/JavaJSExecutor;";
 };
 
-class ProxyJavaScriptExecutorHolder : public HybridClass<
-                                          ProxyJavaScriptExecutorHolder,
-                                          JavaScriptExecutorHolder> {
+class ProxyJavaScriptExecutorHolder
+    : public jni::
+          HybridClass<ProxyJavaScriptExecutorHolder, JavaScriptExecutorHolder> {
  public:
   static constexpr auto kJavaDescriptor =
       "Lcom/facebook/react/bridge/ProxyJavaScriptExecutor;";
 
-  static local_ref<jhybriddata> initHybrid(
-      alias_ref<jclass>,
-      alias_ref<JavaJSExecutor::javaobject> executorInstance) {
+  static jni::local_ref<jhybriddata> initHybrid(
+      jni::alias_ref<jclass>,
+      jni::alias_ref<JavaJSExecutor::javaobject> executorInstance) {
     return makeCxxInstance(std::make_shared<ProxyExecutorOneTimeFactory>(
         make_global(executorInstance)));
   }
@@ -67,11 +68,16 @@ class ProxyJavaScriptExecutorHolder : public HybridClass<
 } // namespace
 
 extern "C" JNIEXPORT jint JNI_OnLoad(JavaVM* vm, void* reserved) {
-  return initialize(vm, [] {
+#ifdef WITH_XPLATINIT
+  return facebook::xplat::initialize(vm, [] {
+#else
+  return jni::initialize(vm, [] {
+#endif
 #if WITH_GLOGINIT
     gloginit::initialize();
     FLAGS_minloglevel = 0;
 #endif
+
     ProxyJavaScriptExecutorHolder::registerNatives();
     CatalystInstanceImpl::registerNatives();
     CxxModuleWrapperBase::registerNatives();

package/ReactAndroid/src/main/jni/react/jni/ProxyExecutor.cpp

@@ -11,10 +11,7 @@
 #include <cxxreact/ModuleRegistry.h>
 #include <cxxreact/SystraceSection.h>
 #include <fb/assert.h>
-// #include <fb/Environment.h>
 #include <folly/json.h>
-// #include <jni/LocalReference.h>
-// #include <jni/LocalString.h>
 
 #include <memory>
 

package/ReactAndroid/src/main/jni/react/jni/ProxyExecutor.h

@@ -11,7 +11,6 @@
 #include <cxxreact/RAMBundleRegistry.h>
 #include <fbjni/fbjni.h>
 #include <jni.h>
-#include "OnLoad.h"
 
 namespace facebook::react {
 

package/ReactAndroid/src/main/jni/react/newarchdefaults/DefaultComponentsRegistry.cpp

@@ -25,12 +25,13 @@ std::shared_ptr<const ComponentDescriptorProviderRegistry>
 DefaultComponentsRegistry::sharedProviderRegistry() {
   auto providerRegistry = CoreComponentsRegistry::sharedProviderRegistry();
 
-  react_native_assert(
-      DefaultComponentsRegistry::registerComponentDescriptorsFromEntryPoint &&
-      "'registerComponentDescriptorsFromEntryPoint' was not initialized in 'JNI_OnLoad'");
-
-  (DefaultComponentsRegistry::registerComponentDescriptorsFromEntryPoint)(
-      providerRegistry);
+  if (DefaultComponentsRegistry::registerComponentDescriptorsFromEntryPoint) {
+    (DefaultComponentsRegistry::registerComponentDescriptorsFromEntryPoint)(
+        providerRegistry);
+  } else {
+    LOG(WARNING)
+        << "Custom component descriptors were not configured from JNI_OnLoad";
+  }
 
   return providerRegistry;
 }

package/ReactCommon/cxxreact/Instance.cpp

@@ -38,30 +38,46 @@ Instance::~Instance() {
   }
 }
 
+void Instance::unregisterFromInspector() {
+  if (inspectorTarget_) {
+    assert(parentInspectorTarget_);
+    parentInspectorTarget_->unregisterInstance(*inspectorTarget_);
+    parentInspectorTarget_ = nullptr;
+    inspectorTarget_ = nullptr;
+  }
+}
+
 void Instance::initializeBridge(
     std::unique_ptr<InstanceCallback> callback,
     std::shared_ptr<JSExecutorFactory> jsef,
     std::shared_ptr<MessageQueueThread> jsQueue,
-    std::shared_ptr<ModuleRegistry> moduleRegistry) {
+    std::shared_ptr<ModuleRegistry> moduleRegistry,
+    jsinspector_modern::PageTarget* parentInspectorTarget) {
   callback_ = std::move(callback);
   moduleRegistry_ = std::move(moduleRegistry);
-  jsQueue->runOnQueueSync([this, &jsef, jsQueue]() mutable {
-    nativeToJsBridge_ = std::make_shared<NativeToJsBridge>(
-        jsef.get(), moduleRegistry_, jsQueue, callback_);
-
-    nativeToJsBridge_->initializeRuntime();
-
-    /**
-     * After NativeToJsBridge is created, the jsi::Runtime should exist.
-     * Also, the JS message queue thread exists. So, it's safe to
-     * schedule all queued up js Calls.
-     */
-    jsCallInvoker_->setNativeToJsBridgeAndFlushCalls(nativeToJsBridge_);
-
-    std::scoped_lock lock(m_syncMutex);
-    m_syncReady = true;
-    m_syncCV.notify_all();
-  });
+  parentInspectorTarget_ = parentInspectorTarget;
+  jsQueue->runOnQueueSync(
+      [this, &jsef, jsQueue, parentInspectorTarget]() mutable {
+        nativeToJsBridge_ = std::make_shared<NativeToJsBridge>(
+            jsef.get(), moduleRegistry_, jsQueue, callback_);
+
+        nativeToJsBridge_->initializeRuntime();
+
+        if (parentInspectorTarget) {
+          inspectorTarget_ = &parentInspectorTarget->registerInstance(*this);
+        }
+
+        /**
+         * After NativeToJsBridge is created, the jsi::Runtime should exist.
+         * Also, the JS message queue thread exists. So, it's safe to
+         * schedule all queued up js Calls.
+         */
+        jsCallInvoker_->setNativeToJsBridgeAndFlushCalls(nativeToJsBridge_);
+
+        std::scoped_lock lock(m_syncMutex);
+        m_syncReady = true;
+        m_syncCV.notify_all();
+      });
 
   CHECK(nativeToJsBridge_);
 }

package/ReactCommon/cxxreact/Instance.h

@@ -14,6 +14,7 @@
 
 #include <ReactCommon/RuntimeExecutor.h>
 #include <cxxreact/NativeToJsBridge.h>
+#include <jsinspector-modern/ReactCdp.h>
 
 #ifndef RN_EXPORT
 #define RN_EXPORT __attribute__((visibility("default")))
@@ -38,14 +39,15 @@ struct InstanceCallback {
   virtual void decrementPendingJSCalls() {}
 };
 
-class RN_EXPORT Instance {
+class RN_EXPORT Instance : private jsinspector_modern::InstanceTargetDelegate {
  public:
   ~Instance();
   void initializeBridge(
       std::unique_ptr<InstanceCallback> callback,
       std::shared_ptr<JSExecutorFactory> jsef,
       std::shared_ptr<MessageQueueThread> jsQueue,
-      std::shared_ptr<ModuleRegistry> moduleRegistry);
+      std::shared_ptr<ModuleRegistry> moduleRegistry,
+      jsinspector_modern::PageTarget* inspectorTarget = nullptr);
 
   void initializeRuntime();
 
@@ -132,6 +134,12 @@ class RN_EXPORT Instance {
    */
   RuntimeExecutor getRuntimeExecutor();
 
+  /**
+   * Unregisters the instance from the inspector. This method must be called
+   * on the main (non-JS) thread.
+   */
+  void unregisterFromInspector();
+
  private:
   void callNativeModules(folly::dynamic&& calls, bool isEndOfBatch);
   void loadBundle(
@@ -169,6 +177,9 @@ class RN_EXPORT Instance {
 
   std::shared_ptr<JSCallInvoker> jsCallInvoker_ =
       std::make_shared<JSCallInvoker>();
+
+  jsinspector_modern::PageTarget* parentInspectorTarget_{nullptr};
+  jsinspector_modern::InstanceTarget* inspectorTarget_{nullptr};
 };
 
 } // namespace facebook::react

package/ReactCommon/cxxreact/React-cxxreact.podspec

@@ -45,7 +45,7 @@ Pod::Spec.new do |s|
   s.dependency "fmt", "9.1.0"
   s.dependency "RCT-Folly", folly_version
   s.dependency "glog"
-  s.dependency "React-jsinspector", version
+  add_dependency(s, "React-jsinspector", :framework_name => 'jsinspector_modern')
   s.dependency "React-callinvoker", version
   s.dependency "React-runtimeexecutor", version
   s.dependency "React-perflogger", version

package/ReactCommon/cxxreact/ReactNativeVersion.h

@@ -4,7 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @generated by scripts/set-rn-version.js
+ * @generated by scripts/releases/set-rn-version.js
  */
 
 #pragma once
@@ -18,7 +18,7 @@ constexpr struct {
   int32_t Major = 0;
   int32_t Minor = 74;
   int32_t Patch = 0;
-  std::string_view Prerelease = "nightly-20240129-39cb02f6f";
+  std::string_view Prerelease = "nightly-20240131-82e9a5e4f";
 } ReactNativeVersion;
 
 } // namespace facebook::react

package/ReactCommon/jsinspector-modern/InstanceAgent.cpp

@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include <jsinspector-modern/InstanceAgent.h>
+
+namespace facebook::react::jsinspector_modern {
+
+InstanceAgent::InstanceAgent(
+    FrontendChannel frontendChannel,
+    InstanceTarget& target)
+    : frontendChannel_(frontendChannel), target_(target) {
+  (void)target_;
+}
+
+bool InstanceAgent::handleRequest(const cdp::PreparsedRequest& req) {
+  // NOTE: Our implementation of @cdp Runtime.getHeapUsage is a stub.
+  if (req.method == "Runtime.getHeapUsage") {
+    folly::dynamic res = folly::dynamic::object("id", req.id)(
+        "result", folly::dynamic::object("usedSize", 0)("totalSize", 0));
+    frontendChannel_(folly::toJson(res));
+    return true;
+  }
+  return false;
+}
+
+int InstanceAgent::getExecutionContextId() const {
+  return 1;
+}
+
+} // namespace facebook::react::jsinspector_modern

package/ReactCommon/jsinspector-modern/InstanceAgent.h

@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <jsinspector-modern/InspectorInterfaces.h>
+#include <jsinspector-modern/Parsing.h>
+#include <functional>
+
+namespace facebook::react::jsinspector_modern {
+
+class InstanceTarget;
+
+/**
+ * An Agent that handles requests from the Chrome DevTools Protocol for the
+ * given InstanceTarget.
+ */
+class InstanceAgent {
+ public:
+  /**
+   * \param frontendChannel A channel used to send responses and events to the
+   * frontend.
+   * \param target The InstanceTarget that this agent is attached to. The
+   * caller is responsible for ensuring that the InstanceTarget outlives this
+   * object.
+   */
+  explicit InstanceAgent(
+      FrontendChannel frontendChannel,
+      InstanceTarget& target);
+
+  /**
+   * Handle a CDP request. The response will be sent over the provided
+   * \c FrontendChannel synchronously or asynchronously.
+   * \param req The parsed request.
+   */
+  bool handleRequest(const cdp::PreparsedRequest& req);
+
+  /**
+   * Get the ID of the execution context that this agent is associated with.
+   * \see
+   * https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#type-ExecutionContextId
+   */
+  int getExecutionContextId() const;
+
+ private:
+  FrontendChannel frontendChannel_;
+  InstanceTarget& target_;
+};
+
+} // namespace facebook::react::jsinspector_modern

package/ReactCommon/jsinspector-modern/InstanceTarget.cpp

@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include "InstanceAgent.h"
+
+#include <jsinspector-modern/InstanceTarget.h>
+
+namespace facebook::react::jsinspector_modern {
+
+InstanceTarget::InstanceTarget(InstanceTargetDelegate& delegate)
+    : delegate_(delegate) {
+  (void)delegate_;
+}
+
+InstanceTargetDelegate::~InstanceTargetDelegate() {}
+
+std::unique_ptr<InstanceAgent> InstanceTarget::createAgent(
+    FrontendChannel channel) {
+  return std::make_unique<InstanceAgent>(channel, *this);
+}
+} // namespace facebook::react::jsinspector_modern

package/ReactCommon/jsinspector-modern/InstanceTarget.h

@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <jsinspector-modern/InspectorInterfaces.h>
+
+#include <list>
+#include <optional>
+
+namespace facebook::react::jsinspector_modern {
+
+class InstanceAgent;
+
+/**
+ * Receives events from an InstanceTarget. This is a shared interface that
+ * each React Native platform needs to implement in order to integrate with
+ * the debugging stack.
+ */
+class InstanceTargetDelegate {
+ public:
+  InstanceTargetDelegate() = default;
+  InstanceTargetDelegate(const InstanceTargetDelegate&) = delete;
+  InstanceTargetDelegate(InstanceTargetDelegate&&) = default;
+  InstanceTargetDelegate& operator=(const InstanceTargetDelegate&) = delete;
+  InstanceTargetDelegate& operator=(InstanceTargetDelegate&&) = default;
+
+  virtual ~InstanceTargetDelegate();
+};
+
+/**
+ * A Target that represents a single instance of React Native.
+ */
+class InstanceTarget {
+ public:
+  /**
+   * \param delegate The object that will receive events from this target.
+   * The caller is responsible for ensuring that the delegate outlives this
+   * object.
+   */
+  explicit InstanceTarget(InstanceTargetDelegate& delegate);
+
+  InstanceTarget(const InstanceTarget&) = delete;
+  InstanceTarget(InstanceTarget&&) = delete;
+  InstanceTarget& operator=(const InstanceTarget&) = delete;
+  InstanceTarget& operator=(InstanceTarget&&) = delete;
+
+  std::unique_ptr<InstanceAgent> createAgent(FrontendChannel channel);
+
+ private:
+  InstanceTargetDelegate& delegate_;
+};
+
+} // namespace facebook::react::jsinspector_modern

package/ReactCommon/jsinspector-modern/PageAgent.cpp

@@ -7,6 +7,7 @@
 
 #include <folly/dynamic.h>
 #include <folly/json.h>
+#include <jsinspector-modern/InstanceAgent.h>
 #include <jsinspector-modern/PageAgent.h>
 #include <jsinspector-modern/PageTarget.h>
 
@@ -70,6 +71,38 @@ void PageAgent::handleRequest(const cdp::PreparsedRequest& req) {
     return;
   }
 
+  if (req.method == "Runtime.enable") {
+    runtimeEnabled_ = true;
+
+    folly::dynamic res = folly::dynamic::object("id", req.id)(
+        "result", folly::dynamic::object());
+    std::string json = folly::toJson(res);
+    frontendChannel_(json);
+
+    if (instanceAgent_) {
+      folly::dynamic params = folly::dynamic::object(
+          "context",
+          folly::dynamic::object("id", instanceAgent_->getExecutionContextId())(
+              "origin", "")("name", "React Native"));
+      folly::dynamic contextCreated = folly::dynamic::object(
+          "method", "Runtime.executionContextCreated")("params", params);
+      frontendChannel_(folly::toJson(contextCreated));
+    }
+    return;
+  }
+  if (req.method == "Runtime.disable") {
+    runtimeEnabled_ = false;
+    folly::dynamic res = folly::dynamic::object("id", req.id)(
+        "result", folly::dynamic::object());
+    std::string json = folly::toJson(res);
+    frontendChannel_(json);
+    return;
+  }
+
+  if (instanceAgent_ && instanceAgent_->handleRequest(req)) {
+    return;
+  }
+
   folly::dynamic res = folly::dynamic::object("id", req.id)(
       "error",
       folly::dynamic::object("code", -32601)(
@@ -92,4 +125,36 @@ void PageAgent::sendInfoLogEntry(std::string_view text) {
                   "level", "info")("text", text)))));
 }
 
+void PageAgent::setCurrentInstanceAgent(
+    std::unique_ptr<InstanceAgent> instanceAgent) {
+  auto previousInstanceAgent = std::move(instanceAgent_);
+  instanceAgent_ = std::move(instanceAgent);
+  if (!runtimeEnabled_) {
+    return;
+  }
+  if (previousInstanceAgent != nullptr) {
+    auto executionContextId = previousInstanceAgent->getExecutionContextId();
+    folly::dynamic contextDestroyed =
+        folly::dynamic::object("method", "Runtime.executionContextDestroyed")(
+            "params",
+            folly::dynamic::object("executionContextId", executionContextId));
+    frontendChannel_(folly::toJson(contextDestroyed));
+
+    // Because we can only have a single instance, we can report all contexts
+    // as cleared.
+    folly::dynamic contextsCleared =
+        folly::dynamic::object("method", "Runtime.executionContextsCleared");
+    frontendChannel_(folly::toJson(contextsCleared));
+  }
+  if (instanceAgent_) {
+    folly::dynamic params = folly::dynamic::object(
+        "context",
+        folly::dynamic::object("id", instanceAgent_->getExecutionContextId())(
+            "origin", "")("name", "React Native"));
+    folly::dynamic contextCreated = folly::dynamic::object(
+        "method", "Runtime.executionContextCreated")("params", params);
+    frontendChannel_(folly::toJson(contextCreated));
+  }
+}
+
 } // namespace facebook::react::jsinspector_modern

package/ReactCommon/jsinspector-modern/PageAgent.h

@@ -10,6 +10,7 @@
 #include "PageTarget.h"
 
 #include <jsinspector-modern/InspectorInterfaces.h>
+#include <jsinspector-modern/InstanceAgent.h>
 #include <jsinspector-modern/Parsing.h>
 
 #include <functional>
@@ -18,6 +19,8 @@
 namespace facebook::react::jsinspector_modern {
 
 class PageTarget;
+class InstanceAgent;
+class InstanceTarget;
 
 /**
  * An Agent that handles requests from the Chrome DevTools Protocol for the
@@ -47,6 +50,14 @@ class PageAgent {
    */
   void handleRequest(const cdp::PreparsedRequest& req);
 
+  /**
+   * Replace the current InstanceAgent with the given one and notify the
+   * frontend about the new instance.
+   * \param agent The new InstanceAgent. May be null to signify that there is
+   * currently no active instance.
+   */
+  void setCurrentInstanceAgent(std::unique_ptr<InstanceAgent> agent);
+
  private:
   /**
    * Send a simple Log.entryAdded notification with the given
@@ -62,6 +73,8 @@ class PageAgent {
   FrontendChannel frontendChannel_;
   PageTargetController& targetController_;
   const PageTarget::SessionMetadata sessionMetadata_;
+  std::unique_ptr<InstanceAgent> instanceAgent_;
+  bool runtimeEnabled_{false};
 };
 
 } // namespace facebook::react::jsinspector_modern

package/ReactCommon/jsinspector-modern/PageTarget.cpp

@@ -6,7 +6,9 @@
  */
 
 #include "PageTarget.h"
+#include "InspectorInterfaces.h"
 #include "InspectorUtilities.h"
+#include "InstanceTarget.h"
 #include "PageAgent.h"
 #include "Parsing.h"
 
@@ -72,6 +74,21 @@ class PageTargetSession {
     }
   }
 
+  /**
+   * Replace the current instance agent inside pageAgent_ with a new one
+   * connected to the new InstanceTarget.
+   * \param instance The new instance target. May be nullptr to indicate there's
+   * no current instance.
+   */
+  void setCurrentInstance(InstanceTarget* instance) {
+    if (instance) {
+      pageAgent_.setCurrentInstanceAgent(
+          instance->createAgent(frontendChannel_));
+    } else {
+      pageAgent_.setCurrentInstanceAgent(nullptr);
+    }
+  }
+
  private:
   // Owned by this instance, but shared (weakly) with the frontend channel
   std::shared_ptr<RAIIRemoteConnection> remote_;
@@ -86,6 +103,7 @@ std::unique_ptr<ILocalConnection> PageTarget::connect(
     SessionMetadata sessionMetadata) {
   auto session = std::make_shared<PageTargetSession>(
       std::move(connectionToFrontend), controller_, std::move(sessionMetadata));
+  session->setCurrentInstance(currentInstance_ ? &*currentInstance_ : nullptr);
   sessions_.push_back(std::weak_ptr(session));
   return std::make_unique<CallbackLocalConnection>(
       [session](std::string message) { (*session)(message); });
@@ -108,6 +126,25 @@ PageTarget::~PageTarget() {
 
 PageTargetDelegate::~PageTargetDelegate() {}
 
+InstanceTarget& PageTarget::registerInstance(InstanceTargetDelegate& delegate) {
+  assert(!currentInstance_ && "Only one instance allowed");
+  currentInstance_.emplace(delegate);
+  forEachSession(
+      [currentInstance = &*currentInstance_](PageTargetSession& session) {
+        session.setCurrentInstance(currentInstance);
+      });
+  return *currentInstance_;
+}
+
+void PageTarget::unregisterInstance(InstanceTarget& instance) {
+  assert(
+      currentInstance_.has_value() && &currentInstance_.value() == &instance &&
+      "Invalid unregistration");
+  forEachSession(
+      [](PageTargetSession& session) { session.setCurrentInstance(nullptr); });
+  currentInstance_.reset();
+}
+
 PageTargetController::PageTargetController(PageTarget& target)
     : target_(target) {}
 
@@ -115,4 +152,8 @@ PageTargetDelegate& PageTargetController::getDelegate() {
   return target_.getDelegate();
 }
 
+bool PageTargetController::hasInstance() const {
+  return target_.hasInstance();
+}
+
 } // namespace facebook::react::jsinspector_modern