react-native-tvos 0.74.5-0 → 0.75.2-0

package/ReactAndroid/src/main/java/com/facebook/react/runtime/ReactHostImpl.java

@@ -8,7 +8,6 @@
 package com.facebook.react.runtime;
 
 import static com.facebook.infer.annotation.Assertions.assertNotNull;
-import static com.facebook.infer.annotation.Assertions.nullsafeFIXME;
 import static com.facebook.infer.annotation.ThreadConfined.UI;
 import static java.lang.Boolean.FALSE;
 import static java.lang.Boolean.TRUE;
@@ -26,6 +25,7 @@ import com.facebook.infer.annotation.Assertions;
 import com.facebook.infer.annotation.Nullsafe;
 import com.facebook.infer.annotation.ThreadConfined;
 import com.facebook.infer.annotation.ThreadSafe;
+import com.facebook.proguard.annotations.DoNotStrip;
 import com.facebook.react.JSEngineResolutionAlgorithm;
 import com.facebook.react.MemoryPressureRouter;
 import com.facebook.react.ReactHost;
@@ -48,19 +48,20 @@ import com.facebook.react.bridge.queue.QueueThreadExceptionHandler;
 import com.facebook.react.bridge.queue.ReactQueueConfiguration;
 import com.facebook.react.common.LifecycleState;
 import com.facebook.react.common.build.ReactBuildConfig;
-import com.facebook.react.config.ReactFeatureFlags;
 import com.facebook.react.devsupport.DevSupportManagerBase;
-import com.facebook.react.devsupport.DisabledDevSupportManager;
+import com.facebook.react.devsupport.InspectorFlags;
+import com.facebook.react.devsupport.ReleaseDevSupportManager;
+import com.facebook.react.devsupport.interfaces.BundleLoadCallback;
 import com.facebook.react.devsupport.interfaces.DevSupportManager;
+import com.facebook.react.devsupport.interfaces.DevSupportManager.PausedInDebuggerOverlayCommandListener;
 import com.facebook.react.fabric.ComponentFactory;
 import com.facebook.react.fabric.FabricUIManager;
 import com.facebook.react.interfaces.TaskInterface;
-import com.facebook.react.interfaces.exceptionmanager.ReactJsExceptionHandler;
 import com.facebook.react.interfaces.fabric.ReactSurface;
+import com.facebook.react.internal.featureflags.ReactNativeFeatureFlags;
 import com.facebook.react.modules.appearance.AppearanceModule;
 import com.facebook.react.modules.core.DefaultHardwareBackBtnHandler;
 import com.facebook.react.modules.core.DeviceEventManagerModule;
-import com.facebook.react.runtime.internal.bolts.Continuation;
 import com.facebook.react.runtime.internal.bolts.Task;
 import com.facebook.react.runtime.internal.bolts.TaskCompletionSource;
 import com.facebook.react.turbomodule.core.interfaces.CallInvokerHolder;
@@ -93,9 +94,6 @@ import kotlin.jvm.functions.Function0;
 @ThreadSafe
 @Nullsafe(Nullsafe.Mode.LOCAL)
 public class ReactHostImpl implements ReactHost {
-
-  // TODO T61403233 Make this configurable by product code
-  private static final boolean DEV = ReactBuildConfig.DEBUG;
   private static final String TAG = "ReactHost";
   private static final int BRIDGELESS_MARKER_INSTANCE_KEY = 1;
   private static final AtomicInteger mCounter = new AtomicInteger(0);
@@ -103,7 +101,6 @@ public class ReactHostImpl implements ReactHost {
   private final Context mContext;
   private final ReactHostDelegate mReactHostDelegate;
   private final ComponentFactory mComponentFactory;
-  private final ReactJsExceptionHandler mReactJsExceptionHandler;
   private final DevSupportManager mDevSupportManager;
   private final Executor mBGExecutor;
   private final Executor mUIExecutor;
@@ -116,11 +113,10 @@ public class ReactHostImpl implements ReactHost {
   private final Collection<ReactInstanceEventListener> mReactInstanceEventListeners =
       Collections.synchronizedList(new ArrayList<>());
 
-  private final BridgelessAtomicRef<Task<ReactInstance>> mReactInstanceTaskRef =
-      new BridgelessAtomicRef<>(
-          Task.forResult(
-              nullsafeFIXME(
-                  null, "forResult parameter supports null, but is not annotated as @Nullable")));
+  // todo: T192399917 This no longer needs to store the react instance
+  private final BridgelessAtomicRef<Task<ReactInstance>> mCreateReactInstanceTaskRef =
+      new BridgelessAtomicRef<>(Task.forResult(null));
+  private @Nullable ReactInstance mReactInstance;
 
   private final BridgelessAtomicRef<BridgelessReactContext> mBridgelessReactContextRef =
       new BridgelessAtomicRef<>();
@@ -129,23 +125,24 @@ public class ReactHostImpl implements ReactHost {
   private final AtomicReference<WeakReference<Activity>> mLastUsedActivity =
       new AtomicReference<>(new WeakReference<>(null));
   private final BridgelessReactStateTracker mBridgelessReactStateTracker =
-      new BridgelessReactStateTracker(DEV);
+      new BridgelessReactStateTracker(ReactBuildConfig.DEBUG);
   private final ReactLifecycleStateManager mReactLifecycleStateManager =
       new ReactLifecycleStateManager(mBridgelessReactStateTracker);
   private final int mId = mCounter.getAndIncrement();
   private @Nullable JSEngineResolutionAlgorithm mJSEngineResolutionAlgorithm = null;
-  private MemoryPressureListener mMemoryPressureListener;
+  private @Nullable MemoryPressureListener mMemoryPressureListener;
   private @Nullable DefaultHardwareBackBtnHandler mDefaultHardwareBackBtnHandler;
 
   private final Set<Function0<Unit>> mBeforeDestroyListeners =
       Collections.synchronizedSet(new HashSet<>());
 
+  private @Nullable ReactHostInspectorTarget mReactHostInspectorTarget;
+
   public ReactHostImpl(
       Context context,
       ReactHostDelegate delegate,
       ComponentFactory componentFactory,
       boolean allowPackagerServerAccess,
-      ReactJsExceptionHandler reactJsExceptionHandler,
       boolean useDevSupport) {
     this(
         context,
@@ -153,7 +150,6 @@ public class ReactHostImpl implements ReactHost {
         componentFactory,
         Executors.newSingleThreadExecutor(),
         Task.UI_THREAD_EXECUTOR,
-        reactJsExceptionHandler,
         allowPackagerServerAccess,
         useDevSupport);
   }
@@ -164,7 +160,6 @@ public class ReactHostImpl implements ReactHost {
       ComponentFactory componentFactory,
       Executor bgExecutor,
       Executor uiExecutor,
-      ReactJsExceptionHandler reactJsExceptionHandler,
       boolean allowPackagerServerAccess,
       boolean useDevSupport) {
     mContext = context;
@@ -172,23 +167,18 @@ public class ReactHostImpl implements ReactHost {
     mComponentFactory = componentFactory;
     mBGExecutor = bgExecutor;
     mUIExecutor = uiExecutor;
-    mReactJsExceptionHandler = reactJsExceptionHandler;
     mQueueThreadExceptionHandler = ReactHostImpl.this::handleHostException;
     mMemoryPressureRouter = new MemoryPressureRouter(context);
-    mMemoryPressureListener =
-        level ->
-            callWithExistingReactInstance(
-                "handleMemoryPressure(" + level + ")",
-                reactInstance -> reactInstance.handleMemoryPressure(level));
     mAllowPackagerServerAccess = allowPackagerServerAccess;
-    if (DEV) {
+    mUseDevSupport = useDevSupport;
+
+    if (mUseDevSupport) {
       mDevSupportManager =
           new BridgelessDevSupportManager(
               ReactHostImpl.this, mContext, mReactHostDelegate.getJsMainModulePath());
     } else {
-      mDevSupportManager = new DisabledDevSupportManager();
+      mDevSupportManager = new ReleaseDevSupportManager();
     }
-    mUseDevSupport = useDevSupport;
   }
 
   @Override
@@ -222,7 +212,8 @@ public class ReactHostImpl implements ReactHost {
         reactInstance -> {
           log(method, "Execute");
           reactInstance.prerenderSurface(surface);
-        });
+        },
+        mBGExecutor);
   }
 
   /**
@@ -242,7 +233,8 @@ public class ReactHostImpl implements ReactHost {
         reactInstance -> {
           log(method, "Execute");
           reactInstance.startSurface(surface);
-        });
+        },
+        mBGExecutor);
   }
 
   /**
@@ -262,7 +254,8 @@ public class ReactHostImpl implements ReactHost {
             reactInstance -> {
               log(method, "Execute");
               reactInstance.stopSurface(surface);
-            })
+            },
+            mBGExecutor)
         .makeVoid();
   }
 
@@ -385,20 +378,20 @@ public class ReactHostImpl implements ReactHost {
     return surface;
   }
 
+  @Override
   public MemoryPressureRouter getMemoryPressureRouter() {
     return mMemoryPressureRouter;
   }
 
   /* package */ boolean isInstanceInitialized() {
-    final ReactInstance reactInstance = mReactInstanceTaskRef.get().getResult();
-    return reactInstance != null;
+    return mReactInstance != null;
   }
 
   @ThreadConfined(UI)
   @Override
   public boolean onBackPressed() {
     UiThreadUtil.assertOnUiThread();
-    final ReactInstance reactInstance = mReactInstanceTaskRef.get().getResult();
+    final ReactInstance reactInstance = mReactInstance;
     if (reactInstance == null) {
       return false;
     }
@@ -414,11 +407,9 @@ public class ReactHostImpl implements ReactHost {
   }
 
   public @Nullable ReactQueueConfiguration getReactQueueConfiguration() {
-    synchronized (mReactInstanceTaskRef) {
-      Task<ReactInstance> task = mReactInstanceTaskRef.get();
-      if (!task.isFaulted() && !task.isCancelled() && task.getResult() != null) {
-        return task.getResult().getReactQueueConfiguration();
-      }
+    final ReactInstance reactInstance = mReactInstance;
+    if (reactInstance != null) {
+      return reactInstance.getReactQueueConfiguration();
     }
     return null;
   }
@@ -460,8 +451,12 @@ public class ReactHostImpl implements ReactHost {
               return reloadTask.continueWithTask(
                   task -> {
                     if (task.isFaulted()) {
-                      mReactHostDelegate.handleInstanceException(task.getError());
-                      return getOrCreateDestroyTask("Reload failed", task.getError());
+                      final Exception ex = task.getError();
+                      if (mUseDevSupport) {
+                        mDevSupportManager.handleException(ex);
+                      }
+                      mReactHostDelegate.handleInstanceException(ex);
+                      return getOrCreateDestroyTask("Reload failed", ex);
                     }
 
                     return task;
@@ -472,6 +467,25 @@ public class ReactHostImpl implements ReactHost {
         .continueWithTask(Task::getResult);
   }
 
+  @DoNotStrip
+  private void setPausedInDebuggerMessage(@Nullable String message) {
+    if (message == null) {
+      mDevSupportManager.hidePausedInDebuggerOverlay();
+    } else {
+      mDevSupportManager.showPausedInDebuggerOverlay(
+          message,
+          new PausedInDebuggerOverlayCommandListener() {
+            @Override
+            public void onResume() {
+              UiThreadUtil.assertOnUiThread();
+              if (mReactHostInspectorTarget != null) {
+                mReactHostInspectorTarget.sendDebuggerResumeCommand();
+              }
+            }
+          });
+    }
+  }
+
   /**
    * Entrypoint to destroy the ReactInstance. If the ReactInstance is reloading, will wait until
    * reload is finished, before destroying.
@@ -490,7 +504,8 @@ public class ReactHostImpl implements ReactHost {
               if (mReloadTask != null) {
                 log(
                     method,
-                    "Reloading React Native. Waiting for reload to finish before destroying React Native.");
+                    "Reloading React Native. Waiting for reload to finish before destroying React"
+                        + " Native.");
                 return mReloadTask.continueWithTask(
                     task -> getOrCreateDestroyTask(reason, ex), mBGExecutor);
               }
@@ -543,7 +558,7 @@ public class ReactHostImpl implements ReactHost {
    *     BlackHoleEventDispatcher}.
    */
   /* package */ EventDispatcher getEventDispatcher() {
-    final ReactInstance reactInstance = mReactInstanceTaskRef.get().getResult();
+    final ReactInstance reactInstance = mReactInstance;
     if (reactInstance == null) {
       return BlackHoleEventDispatcher.get();
     }
@@ -554,7 +569,7 @@ public class ReactHostImpl implements ReactHost {
   /* package */
   @Nullable
   FabricUIManager getUIManager() {
-    final ReactInstance reactInstance = mReactInstanceTaskRef.get().getResult();
+    final ReactInstance reactInstance = mReactInstance;
     if (reactInstance == null) {
       return null;
     }
@@ -562,7 +577,7 @@ public class ReactHostImpl implements ReactHost {
   }
 
   /* package */ <T extends NativeModule> boolean hasNativeModule(Class<T> nativeModuleInterface) {
-    final ReactInstance reactInstance = mReactInstanceTaskRef.get().getResult();
+    final ReactInstance reactInstance = mReactInstance;
     if (reactInstance != null) {
       return reactInstance.hasNativeModule(nativeModuleInterface);
     }
@@ -570,7 +585,7 @@ public class ReactHostImpl implements ReactHost {
   }
 
   /* package */ Collection<NativeModule> getNativeModules() {
-    final ReactInstance reactInstance = mReactInstanceTaskRef.get().getResult();
+    final ReactInstance reactInstance = mReactInstance;
     if (reactInstance != null) {
       return reactInstance.getNativeModules();
     }
@@ -584,10 +599,11 @@ public class ReactHostImpl implements ReactHost {
       ReactSoftExceptionLogger.logSoftExceptionVerbose(
           TAG,
           new ReactNoCrashBridgeNotAllowedSoftException(
-              "getNativeModule(UIManagerModule.class) cannot be called when the bridge is disabled"));
+              "getNativeModule(UIManagerModule.class) cannot be called when the bridge is"
+                  + " disabled"));
     }
 
-    final ReactInstance reactInstance = mReactInstanceTaskRef.get().getResult();
+    final ReactInstance reactInstance = mReactInstance;
     if (reactInstance != null) {
       return reactInstance.getNativeModule(nativeModuleInterface);
     }
@@ -597,7 +613,7 @@ public class ReactHostImpl implements ReactHost {
   /* package */
   @Nullable
   NativeModule getNativeModule(String nativeModuleName) {
-    final ReactInstance reactInstance = mReactInstanceTaskRef.get().getResult();
+    final ReactInstance reactInstance = mReactInstance;
     if (reactInstance != null) {
       return reactInstance.getNativeModule(nativeModuleName);
     }
@@ -607,27 +623,26 @@ public class ReactHostImpl implements ReactHost {
   /* package */
   @Nullable
   RuntimeExecutor getRuntimeExecutor() {
-    final ReactInstance reactInstance = mReactInstanceTaskRef.get().getResult();
+    final String method = "getRuntimeExecutor()";
+
+    final ReactInstance reactInstance = mReactInstance;
     if (reactInstance != null) {
       return reactInstance.getBufferedRuntimeExecutor();
     }
-    ReactSoftExceptionLogger.logSoftException(
-        TAG,
-        new ReactNoCrashSoftException("Tried to get runtime executor while instance is not ready"));
+    raiseSoftException(method, "Tried to get runtime executor while instance is not ready");
     return null;
   }
 
   /* package */
   @Nullable
   CallInvokerHolder getJSCallInvokerHolder() {
-    final ReactInstance reactInstance = mReactInstanceTaskRef.get().getResult();
+    final String method = "getJSCallInvokerHolder()";
+
+    final ReactInstance reactInstance = mReactInstance;
     if (reactInstance != null) {
       return reactInstance.getJSCallInvokerHolder();
     }
-    ReactSoftExceptionLogger.logSoftException(
-        TAG,
-        new ReactNoCrashSoftException(
-            "Tried to get JSCallInvokerHolder while instance is not ready"));
+    raiseSoftException(method, "Tried to get JSCallInvokerHolder while instance is not ready");
     return null;
   }
 
@@ -650,16 +665,12 @@ public class ReactHostImpl implements ReactHost {
             + "\", data = \""
             + data
             + "\")";
-    log(method);
 
     ReactContext currentContext = getCurrentReactContext();
     if (currentContext != null) {
       currentContext.onActivityResult(activity, requestCode, resultCode, data);
     } else {
-      ReactSoftExceptionLogger.logSoftException(
-          TAG,
-          new ReactNoCrashSoftException(
-              "Tried to access onActivityResult while context is not ready"));
+      raiseSoftException(method, "Tried to access onActivityResult while context is not ready");
     }
   }
 
@@ -668,16 +679,12 @@ public class ReactHostImpl implements ReactHost {
   @Override
   public void onWindowFocusChange(boolean hasFocus) {
     final String method = "onWindowFocusChange(hasFocus = \"" + hasFocus + "\")";
-    log(method);
 
     ReactContext currentContext = getCurrentReactContext();
     if (currentContext != null) {
       currentContext.onWindowFocusChange(hasFocus);
     } else {
-      ReactSoftExceptionLogger.logSoftException(
-          TAG,
-          new ReactNoCrashSoftException(
-              "Tried to access onWindowFocusChange while context is not ready"));
+      raiseSoftException(method, "Tried to access onWindowFocusChange while context is not ready");
     }
   }
 
@@ -688,7 +695,7 @@ public class ReactHostImpl implements ReactHost {
   @ThreadConfined(UI)
   @Override
   public void onNewIntent(Intent intent) {
-    log("onNewIntent()");
+    final String method = "onNewIntent(intent = \"" + intent + "\")";
 
     ReactContext currentContext = getCurrentReactContext();
     if (currentContext != null) {
@@ -706,9 +713,7 @@ public class ReactHostImpl implements ReactHost {
       }
       currentContext.onNewIntent(getCurrentActivity(), intent);
     } else {
-      ReactSoftExceptionLogger.logSoftException(
-          TAG,
-          new ReactNoCrashSoftException("Tried to access onNewIntent while context is not ready"));
+      raiseSoftException(method, "Tried to access onNewIntent while context is not ready");
     }
   }
 
@@ -728,7 +733,7 @@ public class ReactHostImpl implements ReactHost {
 
   @Nullable
   JavaScriptContextHolder getJavaScriptContextHolder() {
-    final ReactInstance reactInstance = mReactInstanceTaskRef.get().getResult();
+    final ReactInstance reactInstance = mReactInstance;
     if (reactInstance != null) {
       return reactInstance.getJavaScriptContextHolder();
     }
@@ -754,7 +759,8 @@ public class ReactHostImpl implements ReactHost {
         reactInstance -> {
           log(method, "Execute");
           reactInstance.loadJSBundle(bundleLoader);
-        });
+        },
+        null);
   }
 
   /* package */ Task<Boolean> registerSegment(
@@ -769,14 +775,15 @@ public class ReactHostImpl implements ReactHost {
           log(method, "Execute");
           reactInstance.registerSegment(segmentId, path);
           assertNotNull(callback).invoke();
-        });
+        },
+        null);
   }
 
   /* package */ void handleHostException(Exception e) {
     final String method = "handleHostException(message = \"" + e.getMessage() + "\")";
     log(method);
 
-    if (DEV) {
+    if (mUseDevSupport) {
       mDevSupportManager.handleException(e);
     }
     destroy(method, e);
@@ -798,7 +805,8 @@ public class ReactHostImpl implements ReactHost {
         method,
         reactInstance -> {
           reactInstance.callFunctionOnModule(moduleName, methodName, args);
-        });
+        },
+        null);
   }
 
   /* package */ void attachSurface(ReactSurfaceImpl surface) {
@@ -850,8 +858,8 @@ public class ReactHostImpl implements ReactHost {
     }
   }
 
-  /* package */ interface VeniceThenable<T> {
-    void then(T t);
+  private interface ReactInstanceCalback {
+    void then(ReactInstance reactInstance);
   }
 
   @ThreadConfined("ReactHost")
@@ -885,73 +893,96 @@ public class ReactHostImpl implements ReactHost {
   @ThreadConfined(UI)
   private void moveToHostDestroy(@Nullable ReactContext currentContext) {
     mReactLifecycleStateManager.moveToOnHostDestroy(currentContext);
+    if (currentContext == null) {
+      // There's no current context/instance that requires the host inspector
+      // target to be kept alive, so we can destroy it immediately.
+      destroyInspectorHostTarget();
+    }
     setCurrentActivity(null);
   }
 
-  private void raiseSoftException(String method, String message) {
-    raiseSoftException(method, message, null);
+  private void raiseSoftException(String callingMethod, String message) {
+    raiseSoftException(callingMethod, message, null);
   }
 
-  private void raiseSoftException(String method, String message, @Nullable Throwable throwable) {
+  private void raiseSoftException(
+      String callingMethod, String message, @Nullable Throwable throwable) {
+    final String method = "raiseSoftException(" + callingMethod + ")";
     log(method, message);
-    if (ReactFeatureFlags.enableBridgelessArchitectureSoftExceptions) {
-      if (throwable != null) {
-        ReactSoftExceptionLogger.logSoftException(
-            TAG, new ReactNoCrashSoftException(method + ": " + message, throwable));
-        return;
-      }
-
+    if (throwable != null) {
       ReactSoftExceptionLogger.logSoftException(
-          TAG, new ReactNoCrashSoftException(method + ": " + message));
+          TAG, new ReactNoCrashSoftException(method + ": " + message, throwable));
+      return;
     }
+
+    ReactSoftExceptionLogger.logSoftException(
+        TAG, new ReactNoCrashSoftException(method + ": " + message));
   }
 
+  private Executor getDefaultReactInstanceExecutor() {
+    return ReactNativeFeatureFlags.useImmediateExecutorInAndroidBridgeless()
+        ? Task.IMMEDIATE_EXECUTOR
+        : mBGExecutor;
+  }
+
+  /** Schedule work on a ReactInstance that is already created. */
   private Task<Boolean> callWithExistingReactInstance(
-      final String callingMethod, final VeniceThenable<ReactInstance> continuation) {
+      final String callingMethod,
+      final ReactInstanceCalback continuation,
+      @Nullable Executor executor) {
     final String method = "callWithExistingReactInstance(" + callingMethod + ")";
 
-    return mReactInstanceTaskRef
+    if (executor == null) {
+      executor = getDefaultReactInstanceExecutor();
+    }
+
+    return mCreateReactInstanceTaskRef
         .get()
         .onSuccess(
             task -> {
-              final ReactInstance reactInstance = task.getResult();
+              final ReactInstance reactInstance = mReactInstance;
               if (reactInstance == null) {
-                raiseSoftException(method, "Execute: ReactInstance null. Dropping work.");
+                raiseSoftException(method, "Execute: reactInstance is null. Dropping work.");
                 return FALSE;
               }
 
               continuation.then(reactInstance);
               return TRUE;
             },
-            mBGExecutor);
+            executor);
   }
 
+  /** Create a ReactInstance if it doesn't exist already, and schedule work on it. */
   private Task<Void> callAfterGetOrCreateReactInstance(
-      final String callingMethod, final VeniceThenable<ReactInstance> runnable) {
+      final String callingMethod,
+      final ReactInstanceCalback runnable,
+      @Nullable Executor executor) {
     final String method = "callAfterGetOrCreateReactInstance(" + callingMethod + ")";
 
+    if (executor == null) {
+      executor = getDefaultReactInstanceExecutor();
+    }
+
     return getOrCreateReactInstance()
         .onSuccess(
-            (Continuation<ReactInstance, Void>)
-                task -> {
-                  final ReactInstance reactInstance = task.getResult();
-                  if (reactInstance == null) {
-                    raiseSoftException(method, "Execute: ReactInstance is null");
-                    return null;
-                  }
+            task -> {
+              final ReactInstance reactInstance = mReactInstance;
+              if (reactInstance == null) {
+                raiseSoftException(method, "Execute: reactInstance is null. Dropping work.");
+                return null;
+              }
 
-                  runnable.then(reactInstance);
-                  return null;
-                },
-            mBGExecutor)
+              runnable.then(reactInstance);
+              return null;
+            },
+            executor)
         .continueWith(
             task -> {
               if (task.isFaulted()) {
                 handleHostException(task.getError());
               }
               return null;
-            },
-            mBGExecutor);
+            });
   }
 
   private BridgelessReactContext getOrCreateReactContext() {
@@ -1015,7 +1046,7 @@ public class ReactHostImpl implements ReactHost {
     final String method = "getOrCreateReactInstanceTask()";
     log(method);
 
-    return mReactInstanceTaskRef.getOrCreate(
+    return mCreateReactInstanceTaskRef.getOrCreate(
         () -> {
           log(method, "Start");
           ReactMarker.logMarker(
@@ -1037,14 +1068,17 @@ public class ReactHostImpl implements ReactHost {
                             mComponentFactory,
                             devSupportManager,
                             mQueueThreadExceptionHandler,
-                            mReactJsExceptionHandler,
-                            mUseDevSupport);
+                            mUseDevSupport,
+                            getOrCreateReactHostInspectorTarget());
+                    mReactInstance = instance;
 
-                    if (ReactFeatureFlags
-                        .unstable_bridgelessArchitectureMemoryPressureHackyBoltsFix) {
-                      mMemoryPressureListener = createMemoryPressureListener(instance);
-                    }
-                    mMemoryPressureRouter.addMemoryPressureListener(mMemoryPressureListener);
+                    // eagerly initailize turbo modules
+                    instance.initializeEagerTurboModules();
+
+                    MemoryPressureListener memoryPressureListener =
+                        createMemoryPressureListener(instance);
+                    mMemoryPressureListener = memoryPressureListener;
+                    mMemoryPressureRouter.addMemoryPressureListener(memoryPressureListener);
 
                     log(method, "Loading JS Bundle");
                     instance.loadJSBundle(bundleLoader);
@@ -1134,7 +1168,7 @@ public class ReactHostImpl implements ReactHost {
     final String method = "getJSBundleLoader()";
     log(method);
 
-    if (DEV && mAllowPackagerServerAccess) {
+    if (mUseDevSupport && mAllowPackagerServerAccess) {
       return isMetroRunning()
           .onSuccessTask(
               task -> {
@@ -1147,7 +1181,7 @@ public class ReactHostImpl implements ReactHost {
               },
               mBGExecutor);
     } else {
-      if (DEV) {
+      if (ReactBuildConfig.DEBUG) {
         FLog.d(TAG, "Packager server access is disabled in this environment");
       }
 
@@ -1178,10 +1212,6 @@ public class ReactHostImpl implements ReactHost {
     return taskCompletionSource.getTask();
   }
 
-  /**
-   * TODO(T104078367): Ensure that if creating this JSBundleLoader fails, we route the errors
-   * through ReactHost's error reporting pipeline
-   */
   private Task<JSBundleLoader> loadJSBundleFromMetro() {
     final String method = "loadJSBundleFromMetro()";
     log(method);
@@ -1197,12 +1227,20 @@ public class ReactHostImpl implements ReactHost {
 
     asyncDevSupportManager.reloadJSFromServer(
         bundleURL,
-        () -> {
-          log(method, "Creating BundleLoader");
-          JSBundleLoader bundleLoader =
-              JSBundleLoader.createCachedBundleFromNetworkLoader(
-                  bundleURL, asyncDevSupportManager.getDownloadedJSBundleFile());
-          taskCompletionSource.setResult(bundleLoader);
+        new BundleLoadCallback() {
+          @Override
+          public void onSuccess() {
+            log(method, "Creating BundleLoader");
+            JSBundleLoader bundleLoader =
+                JSBundleLoader.createCachedBundleFromNetworkLoader(
+                    bundleURL, asyncDevSupportManager.getDownloadedJSBundleFile());
+            taskCompletionSource.setResult(bundleLoader);
+          }
+
+          @Override
+          public void onError(Exception cause) {
+            taskCompletionSource.setError(cause);
+          }
         });
 
     return taskCompletionSource.getTask();
@@ -1243,12 +1281,12 @@ public class ReactHostImpl implements ReactHost {
     ReactInstance unwrap(Task<ReactInstance> task, String stage);
   }
 
-  private ReactInstanceTaskUnwrapper createReactInstanceUnwraper(
+  private ReactInstanceTaskUnwrapper createReactInstanceUnwrapper(
       String tag, String method, String reason) {
 
     return (task, stage) -> {
       final ReactInstance reactInstance = task.getResult();
-      final ReactInstance currentReactInstance = mReactInstanceTaskRef.get().getResult();
+      final ReactInstance currentReactInstance = mReactInstance;
 
       final String stageLabel = "Stage: " + stage;
       final String reasonLabel = tag + " reason: " + reason;
@@ -1311,11 +1349,11 @@ public class ReactHostImpl implements ReactHost {
     raiseSoftException(method, reason);
 
     ReactInstanceTaskUnwrapper reactInstanceTaskUnwrapper =
-        createReactInstanceUnwraper("Reload", method, reason);
+        createReactInstanceUnwrapper("Reload", method, reason);
 
     if (mReloadTask == null) {
       mReloadTask =
-          mReactInstanceTaskRef
+          mCreateReactInstanceTaskRef
               .get()
               .continueWithTask(
                   (task) -> {
@@ -1323,6 +1361,8 @@ public class ReactHostImpl implements ReactHost {
                     final ReactInstance reactInstance =
                         reactInstanceTaskUnwrapper.unwrap(task, "1: Starting reload");
 
+                    unregisterInstanceFromInspector(reactInstance);
+
                     final ReactContext reactContext = mBridgelessReactContextRef.getNullable();
                     if (reactContext == null) {
                       raiseSoftException(method, "ReactContext is null. Reload reason: " + reason);
@@ -1372,8 +1412,10 @@ public class ReactHostImpl implements ReactHost {
                   task -> {
                     reactInstanceTaskUnwrapper.unwrap(task, "4: Destroying ReactContext");
 
-                    log(method, "Removing memory pressure listener");
-                    mMemoryPressureRouter.removeMemoryPressureListener(mMemoryPressureListener);
+                    if (mMemoryPressureListener != null) {
+                      log(method, "Removing memory pressure listener");
+                      mMemoryPressureRouter.removeMemoryPressureListener(mMemoryPressureListener);
+                    }
 
                     final ReactContext reactContext = mBridgelessReactContextRef.getNullable();
                     if (reactContext != null) {
@@ -1408,7 +1450,10 @@ public class ReactHostImpl implements ReactHost {
                     mBridgelessReactContextRef.reset();
 
                     log(method, "Resetting ReactInstance task ref");
-                    mReactInstanceTaskRef.reset();
+                    mCreateReactInstanceTaskRef.reset();
+
+                    log(method, "Resetting ReactInstance ptr");
+                    mReactInstance = null;
 
                     log(method, "Resetting preload task ref");
                     mStartTask = null;
@@ -1483,11 +1528,11 @@ public class ReactHostImpl implements ReactHost {
     raiseSoftException(method, reason, ex);
 
     ReactInstanceTaskUnwrapper reactInstanceTaskUnwrapper =
-        createReactInstanceUnwraper("Destroy", method, reason);
+        createReactInstanceUnwrapper("Destroy", method, reason);
 
     if (mDestroyTask == null) {
       mDestroyTask =
-          mReactInstanceTaskRef
+          mCreateReactInstanceTaskRef
               .get()
               .continueWithTask(
                   task -> {
@@ -1496,6 +1541,8 @@ public class ReactHostImpl implements ReactHost {
                     final ReactInstance reactInstance =
                         reactInstanceTaskUnwrapper.unwrap(task, "1: Starting destroy");
 
+                    unregisterInstanceFromInspector(reactInstance);
+
                     // Step 1: Destroy DevSupportManager
                     if (mUseDevSupport) {
                       log(method, "DevSupportManager cleanup");
@@ -1596,7 +1643,10 @@ public class ReactHostImpl implements ReactHost {
                     mBridgelessReactContextRef.reset();
 
                     log(method, "Resetting ReactInstance task ref");
-                    mReactInstanceTaskRef.reset();
+                    mCreateReactInstanceTaskRef.reset();
+
+                    log(method, "Resetting ReactInstance ptr");
+                    mReactInstance = null;
 
                     log(method, "Resetting Preload task ref");
                     mStartTask = null;
@@ -1643,4 +1693,38 @@ public class ReactHostImpl implements ReactHost {
       @Nullable JSEngineResolutionAlgorithm jsEngineResolutionAlgorithm) {
     mJSEngineResolutionAlgorithm = jsEngineResolutionAlgorithm;
   }
+
+  private @Nullable ReactHostInspectorTarget getOrCreateReactHostInspectorTarget() {
+    if (mReactHostInspectorTarget == null && InspectorFlags.getFuseboxEnabled()) {
+      mReactHostInspectorTarget = new ReactHostInspectorTarget(this);
+    }
+
+    return mReactHostInspectorTarget;
+  }
+
+  @ThreadConfined(UI)
+  private void destroyInspectorHostTarget() {
+    if (mReactHostInspectorTarget != null) {
+      mReactHostInspectorTarget.close();
+      mReactHostInspectorTarget = null;
+    }
+  }
+
+  @ThreadConfined(UI)
+  private void unregisterInstanceFromInspector(final @Nullable ReactInstance reactInstance) {
+    if (reactInstance != null) {
+      if (InspectorFlags.getFuseboxEnabled()) {
+        Assertions.assertCondition(
+            mReactHostInspectorTarget != null && mReactHostInspectorTarget.isValid(),
+            "Host inspector target destroyed before instance was unregistered");
+      }
+      reactInstance.unregisterFromInspector();
+    }
+    if (mReactLifecycleStateManager.getLifecycleState() == LifecycleState.BEFORE_CREATE) {
+      // If the host is being destroyed, now that the current context/instance
+      // has been unregistered, we can safely destroy the host's inspector
+      // target.
+      destroyInspectorHostTarget();
+    }
+  }
 }