react-native-windows 0.75.4 → 0.76.0-preview.1

package/ReactCommon/TEMP_UntilReactCommonUpdate/react/renderer/core/LayoutableShadowNode.cpp

@@ -0,0 +1,363 @@
+/*
+ * 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 "LayoutableShadowNode.h"
+
+#include <react/renderer/core/LayoutConstraints.h>
+#include <react/renderer/core/LayoutContext.h>
+#include <react/renderer/core/LayoutMetrics.h>
+#include <react/renderer/core/ShadowNode.h>
+#include <react/renderer/core/graphicsConversions.h>
+#include <react/renderer/debug/DebugStringConvertibleItem.h>
+
+namespace facebook::react {
+
+template <class T>
+using LayoutableSmallVector = std::vector<T>;
+
+LayoutableShadowNode::LayoutableShadowNode(
+    const ShadowNodeFragment& fragment,
+    const ShadowNodeFamily::Shared& family,
+    ShadowNodeTraits traits)
+    : ShadowNode(fragment, family, traits), layoutMetrics_({}) {}
+
+LayoutableShadowNode::LayoutableShadowNode(
+    const ShadowNode& sourceShadowNode,
+    const ShadowNodeFragment& fragment)
+    : ShadowNode(sourceShadowNode, fragment),
+      layoutMetrics_(static_cast<const LayoutableShadowNode&>(sourceShadowNode)
+                         .layoutMetrics_) {}
+
+LayoutMetrics LayoutableShadowNode::computeRelativeLayoutMetrics(
+    const ShadowNodeFamily& descendantNodeFamily,
+    const LayoutableShadowNode& ancestorNode,
+    LayoutInspectingPolicy policy) {
+  // Prelude.
+
+  if (&descendantNodeFamily == &ancestorNode.getFamily()) {
+    // Layout metrics of a node computed relatively to the same node are equal
+    // to `transform`-ed layout metrics of the node with zero `origin`.
+    auto layoutMetrics = ancestorNode.getLayoutMetrics();
+    if (layoutMetrics.displayType == DisplayType::None) {
+      return EmptyLayoutMetrics;
+    }
+    if (policy.includeTransform) {
+      layoutMetrics.frame = layoutMetrics.frame * ancestorNode.getTransform();
+    }
+    layoutMetrics.frame.origin = {0, 0};
+    return layoutMetrics;
+  }
+
+  auto ancestors = descendantNodeFamily.getAncestors(ancestorNode);
+  return computeRelativeLayoutMetrics(ancestors, policy);
+}
+
+LayoutMetrics LayoutableShadowNode::computeRelativeLayoutMetrics(
+    const AncestorList& ancestors,
+    LayoutInspectingPolicy policy) {
+  if (ancestors.empty()) {
+    // Specified nodes do not form an ancestor-descender relationship
+    // in the same tree. Aborting.
+    return EmptyLayoutMetrics;
+  }
+
+  // ------------------------------
+
+  // Step 1.
+  // Creating a list of nodes that form a chain from the descender node to
+  // ancestor node inclusively.
+  auto shadowNodeList = LayoutableSmallVector<const ShadowNode*>{};
+
+  // Finding the measured node.
+  // The last element in the `AncestorList` is a pair of a parent of the node
+  // and an index of this node in the parent's children list.
+  auto& pair = ancestors.at(ancestors.size() - 1);
+  auto descendantNode = pair.first.get().getChildren().at(pair.second).get();
+
+  // Putting the node inside the list.
+  // Even if this is a node with a `RootNodeKind` trait, we don't treat it as
+  // root because we measure it from an outside tree perspective.
+  shadowNodeList.push_back(descendantNode);
+
+  for (auto it = ancestors.rbegin(); it != ancestors.rend(); it++) {
+    auto& shadowNode = it->first.get();
+
+    shadowNodeList.push_back(&shadowNode);
+
+    if (shadowNode.getTraits().check(ShadowNodeTraits::Trait::RootNodeKind)) {
+      // If this is a node with a `RootNodeKind` trait, we need to stop right
+      // there.
+      break;
+    }
+  }
+
+  // ------------------------------
+
+  // Step 2.
+  // Computing the initial size of the measured node.
+  auto descendantLayoutableNode =
+      dynamic_cast<const LayoutableShadowNode*>(descendantNode);
+
+  if (descendantLayoutableNode == nullptr) {
+    return EmptyLayoutMetrics;
+  }
+
+  auto layoutMetrics = descendantLayoutableNode->getLayoutMetrics();
+  auto& resultFrame = layoutMetrics.frame;
+  resultFrame.origin = {0, 0};
+
+  // Step 3.
+  // Iterating on a list of nodes computing compound offset and size.
+  auto size = shadowNodeList.size();
+  for (size_t i = 0; i < size; i++) {
+    auto currentShadowNode =
+        dynamic_cast<const LayoutableShadowNode*>(shadowNodeList.at(i));
+
+    if (currentShadowNode == nullptr) {
+      return EmptyLayoutMetrics;
+    }
+
+    // Descendants of display: none don't have relative layout metrics.
+    if (currentShadowNode->getLayoutMetrics().displayType ==
+        DisplayType::None) {
+      return EmptyLayoutMetrics;
+    }
+
+    auto currentFrame = currentShadowNode->getLayoutMetrics().frame;
+    if (i == size - 1) {
+      // If it's the last element, its origin is irrelevant.
+      currentFrame.origin = {0, 0};
+    }
+
+    auto isRootNode = currentShadowNode->getTraits().check(
+        ShadowNodeTraits::Trait::RootNodeKind);
+
+    auto shouldApplyTransformation = (policy.includeTransform && !isRootNode) ||
+        (policy.includeViewportOffset && isRootNode);
+
+    // Move frame to the coordinate space of the current node.
+    resultFrame.origin += currentFrame.origin;
+
+    if (shouldApplyTransformation) {
+      // If a node has a transform, we need to use the center of that node as
+      // the origin of the transform when transforming its children (which
+      // affects the result of transforms like `scale` and `rotate`).
+      resultFrame = currentShadowNode->getTransform().applyWithCenter(
+          resultFrame, currentFrame.getCenter());
+    }
+
+    if (i != 0 && policy.includeTransform) {
+      // Transformation is not applied here and instead we delegated out in
+      // getContentOriginOffset. The reason is that for `ScrollViewShadowNode`,
+      // we need to consider `scrollAwayPaddingTop` which should NOT be included
+      // in the transform.
+      resultFrame.origin += currentShadowNode->getContentOriginOffset(true);
+    }
+
+    if (policy.enableOverflowClipping) {
+      auto overflowInset = currentShadowNode->getLayoutMetrics().overflowInset;
+      auto overflowRect = insetBy(
+          currentFrame * currentShadowNode->getTransform(), overflowInset);
+      resultFrame = Rect::intersect(resultFrame, overflowRect);
+      if (resultFrame.size.width == 0 && resultFrame.size.height == 0) {
+        return EmptyLayoutMetrics;
+      }
+    }
+  }
+
+  // ------------------------------
+
+  return layoutMetrics;
+}
+
+LayoutMetrics LayoutableShadowNode::getLayoutMetrics() const {
+  return layoutMetrics_;
+}
+
+void LayoutableShadowNode::setLayoutMetrics(LayoutMetrics layoutMetrics) {
+  ensureUnsealed();
+
+  if (layoutMetrics_ == layoutMetrics) {
+    return;
+  }
+
+  layoutMetrics_ = layoutMetrics;
+}
+
+Transform LayoutableShadowNode::getTransform() const {
+  return Transform::Identity();
+}
+
+Point LayoutableShadowNode::getContentOriginOffset(
+    bool /*includeTransform*/) const {
+  return {0, 0};
+}
+
+bool LayoutableShadowNode::canBeTouchTarget() const {
+  return false;
+}
+
+bool LayoutableShadowNode::canChildrenBeTouchTarget() const {
+  return true;
+}
+
+LayoutableShadowNode::UnsharedList
+LayoutableShadowNode::getLayoutableChildNodes() const {
+  LayoutableShadowNode::UnsharedList layoutableChildren;
+  for (const auto& childShadowNode : getChildren()) {
+    auto layoutableChildShadowNode =
+        dynamic_cast<const LayoutableShadowNode*>(childShadowNode.get());
+    if (layoutableChildShadowNode != nullptr) {
+      layoutableChildren.push_back(
+          const_cast<LayoutableShadowNode*>(layoutableChildShadowNode));
+    }
+  }
+  return layoutableChildren;
+}
+
+Size LayoutableShadowNode::measureContent(
+    const LayoutContext& /*layoutContext*/,
+    const LayoutConstraints& /*layoutConstraints*/) const {
+  return {};
+}
+
+Size LayoutableShadowNode::measure(
+    const LayoutContext& layoutContext,
+    const LayoutConstraints& layoutConstraints) const {
+  auto clonedShadowNode = clone({});
+  auto& layoutableShadowNode =
+      static_cast<LayoutableShadowNode&>(*clonedShadowNode);
+
+  auto localLayoutContext = layoutContext;
+  localLayoutContext.affectedNodes = nullptr;
+
+  layoutableShadowNode.layoutTree(localLayoutContext, layoutConstraints);
+
+  return layoutableShadowNode.getLayoutMetrics().frame.size;
+}
+
+Float LayoutableShadowNode::baseline(
+    const LayoutContext& /*layoutContext*/,
+    Size /*size*/) const {
+  return 0;
+}
+
+ShadowNode::Shared LayoutableShadowNode::findNodeAtPoint(
+    const ShadowNode::Shared& node,
+    Point point) {
+  auto layoutableShadowNode =
+      dynamic_cast<const LayoutableShadowNode*>(node.get());
+
+  if (layoutableShadowNode == nullptr) {
+    return nullptr;
+  }
+
+  if (!layoutableShadowNode->canBeTouchTarget() &&
+      !layoutableShadowNode->canChildrenBeTouchTarget()) {
+    return nullptr;
+  }
+
+  auto transform = layoutableShadowNode->getTransform();
+  auto frame = layoutableShadowNode->getLayoutMetrics().frame;
+  auto transformedFrame = frame * transform;
+  auto isPointInside = transformedFrame.containsPoint(point);
+
+  if (!isPointInside) {
+    return nullptr;
+  } else if (!layoutableShadowNode->canChildrenBeTouchTarget()) {
+    return node;
+  }
+
+  if (Transform::isVerticalInversion(transform) ||
+      Transform::isHorizontalInversion(transform)) {
+    auto centerX =
+        transformedFrame.origin.x + transformedFrame.size.width / 2.0;
+    auto centerY =
+        transformedFrame.origin.y + transformedFrame.size.height / 2.0;
+
+    // [Windows - #13644
+    auto relativeX = point.x - centerX;
+    auto relativeY = point.y - centerY;
+    // Windows]
+
+    if (Transform::isVerticalInversion(transform)) {
+      relativeY = -relativeY;
+    }
+    if (Transform::isHorizontalInversion(transform)) {
+      relativeX = -relativeX;
+    }
+
+    // [Windows - #13644
+    point.x = float(centerX + relativeX);
+    point.y = float(centerY + relativeY);
+    // Windows]
+  }
+
+  auto newPoint = point - transformedFrame.origin -
+      layoutableShadowNode->getContentOriginOffset(false);
+
+  auto sortedChildren = node->getChildren();
+  std::stable_sort(
+      sortedChildren.begin(),
+      sortedChildren.end(),
+      [](const auto& lhs, const auto& rhs) -> bool {
+        return lhs->getOrderIndex() < rhs->getOrderIndex();
+      });
+
+  for (auto it = sortedChildren.rbegin(); it != sortedChildren.rend(); it++) {
+    const auto& childShadowNode = *it;
+    auto hitView = findNodeAtPoint(childShadowNode, newPoint);
+    if (hitView) {
+      return hitView;
+    }
+  }
+  return layoutableShadowNode->canBeTouchTarget() ? node : nullptr;
+}
+
+#if RN_DEBUG_STRING_CONVERTIBLE
+SharedDebugStringConvertibleList LayoutableShadowNode::getDebugProps() const {
+  auto list = ShadowNode::getDebugProps();
+
+  auto layoutInfo = SharedDebugStringConvertibleList{};
+
+  if (!getIsLayoutClean()) {
+    layoutInfo.push_back(std::make_shared<DebugStringConvertibleItem>("dirty"));
+  }
+
+  auto layoutMetrics = getLayoutMetrics();
+  auto defaultLayoutMetrics = LayoutMetrics();
+
+  layoutInfo.push_back(std::make_shared<DebugStringConvertibleItem>(
+      "frame", toString(layoutMetrics.frame)));
+
+  if (layoutMetrics.borderWidth != defaultLayoutMetrics.borderWidth) {
+    layoutInfo.push_back(std::make_shared<DebugStringConvertibleItem>(
+        "borderWidth", toString(layoutMetrics.borderWidth)));
+  }
+
+  if (layoutMetrics.contentInsets != defaultLayoutMetrics.contentInsets) {
+    layoutInfo.push_back(std::make_shared<DebugStringConvertibleItem>(
+        "contentInsets", toString(layoutMetrics.contentInsets)));
+  }
+
+  if (layoutMetrics.displayType == DisplayType::None) {
+    layoutInfo.push_back(
+        std::make_shared<DebugStringConvertibleItem>("hidden"));
+  }
+
+  if (layoutMetrics.layoutDirection == LayoutDirection::RightToLeft) {
+    layoutInfo.push_back(std::make_shared<DebugStringConvertibleItem>("rtl"));
+  }
+
+  list.push_back(
+      std::make_shared<DebugStringConvertibleItem>("layout", "", layoutInfo));
+
+  return list;
+}
+#endif
+
+} // namespace facebook::react

package/ReactCommon/TEMP_UntilReactCommonUpdate/react/runtime/JSRuntimeFactory.h

@@ -25,8 +25,28 @@ class JSRuntime : public jsinspector_modern::RuntimeTargetDelegate {
 
   virtual ~JSRuntime() = default;
 
-  virtual void addConsoleMessage(jsi::Runtime& runtime, jsinspector_modern::ConsoleMessage message) = 0;
-  virtual bool supportsConsole() const = 0;
+  /**
+   * Get a reference to the \c RuntimeTargetDelegate owned (or implemented) by
+   * this JSRuntime. This reference must remain valid for the duration of the
+   * JSRuntime's lifetime.
+   */
+  // virtual jsinspector_modern::RuntimeTargetDelegate& getRuntimeTargetDelegate();
+
+  /**
+   * Run initialize work that must happen on the runtime's JS thread. Used for
+   * initializing TLS and registering profiling.
+   *
+   * TODO T194671568 Move the runtime constructor to the JsThread
+   */
+  virtual void unstable_initializeOnJsThread() {}
+
+ private:
+  /**
+   * Initialized by \c getRuntimeTargetDelegate if not overridden, and then
+   * never changes.
+   */
+  std::optional<jsinspector_modern::FallbackRuntimeTargetDelegate>
+      runtimeTargetDelegate_;
 };
 
 /**

package/ReactCommon/TEMP_UntilReactCommonUpdate/react/runtime/ReactInstance.cpp

@@ -43,44 +43,50 @@ ReactInstance::ReactInstance(
                                          std::weak_ptr(timerManager_),
                                      weakJsThread =
                                          std::weak_ptr(jsMessageQueueThread_),
-                                     weakJsErrorHander = std::weak_ptr(
-                                         jsErrorHandler_)](auto callback) {
-    auto jsErrorHandler = weakJsErrorHander.lock();
-    if (weakRuntime.expired() || !jsErrorHandler) {
+                                     jsErrorHandler =
+                                         jsErrorHandler_](auto callback) {
+    if (weakRuntime.expired()) {
       return;
     }
 
-    if (jsErrorHandler->hasHandledFatalError()) {
+    /**
+     * If a fatal error was caught while executing the main bundle, assume the
+     * js runtime is invalid. And stop executing any more js.
+     */
+    if (!jsErrorHandler->isRuntimeReady() &&
+        jsErrorHandler->hasHandledFatalError()) {
       LOG(INFO)
-          << "RuntimeExecutor: Detected fatal js error. Dropping work on non-js thread."
+          << "RuntimeExecutor: Detected fatal error. Dropping work on non-js thread."
           << std::endl;
       return;
     }
 
     if (auto jsThread = weakJsThread.lock()) {
-      jsThread->runOnQueue(
-          [weakRuntime, weakTimerManager, callback = std::move(callback)]() {
-            auto runtime = weakRuntime.lock();
-            if (!runtime) {
-              return;
-            }
+      jsThread->runOnQueue([jsErrorHandler,
+                            weakRuntime,
+                            weakTimerManager,
+                            callback = std::move(callback)]() {
+        auto runtime = weakRuntime.lock();
+        if (!runtime) {
+          return;
+        }
 
-            jsi::Runtime& jsiRuntime = runtime->getRuntime();
-            SystraceSection s("ReactInstance::_runtimeExecutor[Callback]");
-            try {
-              callback(jsiRuntime);
+        jsi::Runtime& jsiRuntime = runtime->getRuntime();
+        SystraceSection s("ReactInstance::_runtimeExecutor[Callback]");
+        try {
+          callback(jsiRuntime);
 
-              // If we have first-class support for microtasks,
-              // they would've been called as part of the previous callback.
-              if (!ReactNativeFeatureFlags::enableMicrotasks()) {
-                if (auto timerManager = weakTimerManager.lock()) {
-                  timerManager->callReactNativeMicrotasks(jsiRuntime);
-                }
-              }
-            } catch (jsi::JSError& originalError) {
-              handleJSError(jsiRuntime, originalError, true);
+          // If we have first-class support for microtasks,
+          // they would've been called as part of the previous callback.
+          if (!ReactNativeFeatureFlags::enableMicrotasks()) {
+            if (auto timerManager = weakTimerManager.lock()) {
+              timerManager->callReactNativeMicrotasks(jsiRuntime);
             }
-          });
+          }
+        } catch (jsi::JSError& originalError) {
+          jsErrorHandler->handleFatalError(jsiRuntime, originalError);
+        }
+      });
     }
   };
 
@@ -104,7 +110,7 @@ ReactInstance::ReactInstance(
       //   creation task to finish before starting the destruction.
       inspectorTarget_ = &hostTarget.registerInstance(*this);
       runtimeInspectorTarget_ =
-          &inspectorTarget_->registerRuntime(*runtime_, runtimeExecutor);
+          &inspectorTarget_->registerRuntime(*runtime_, runtimeExecutor); // [Windows #13172]
       runtimeExecutorThatWaitsForInspectorSetup->flush();
     });
 
@@ -118,7 +124,17 @@ ReactInstance::ReactInstance(
         };
   }
 
-  runtimeScheduler_ = std::make_shared<RuntimeScheduler>(runtimeExecutor);
+  runtimeScheduler_ = std::make_shared<RuntimeScheduler>(
+      runtimeExecutor,
+      RuntimeSchedulerClock::now,
+      [jsErrorHandler = jsErrorHandler_](
+          jsi::Runtime& runtime, jsi::JSError& error) {
+        jsErrorHandler->handleFatalError(runtime, error);
+      });
+  runtimeScheduler_->setPerformanceEntryReporter(
+      // FIXME: Move creation of PerformanceEntryReporter to here and guarantee
+      // that its lifetime is the same as the runtime.
+      PerformanceEntryReporter::getInstance().get());
 
   bufferedRuntimeExecutor_ = std::make_shared<BufferedRuntimeExecutor>(
       [runtimeScheduler = runtimeScheduler_.get()](
@@ -148,8 +164,8 @@ RuntimeExecutor ReactInstance::getUnbufferedRuntimeExecutor() noexcept {
 
 // This BufferedRuntimeExecutor ensures that the main JS bundle finished
 // execution before any JS queued into it from C++ are executed. Use
-// getBufferedRuntimeExecutor() instead if you do not need the main JS bundle to
-// have finished. e.g. setting global variables into JS runtime.
+// getUnbufferedRuntimeExecutor() instead if you do not need the main JS bundle
+// to have finished. e.g. setting global variables into JS runtime.
 RuntimeExecutor ReactInstance::getBufferedRuntimeExecutor() noexcept {
   return [weakBufferedRuntimeExecutor_ =
               std::weak_ptr<BufferedRuntimeExecutor>(bufferedRuntimeExecutor_)](
@@ -199,28 +215,34 @@ void ReactInstance::loadScript(
        buffer = std::move(buffer),
        weakBufferedRuntimeExecuter = std::weak_ptr<BufferedRuntimeExecutor>(
            bufferedRuntimeExecutor_)](jsi::Runtime& runtime) {
-        try {
-          SystraceSection s("ReactInstance::loadScript");
-          bool hasLogger(ReactMarker::logTaggedMarkerBridgelessImpl);
-          if (hasLogger) {
-            ReactMarker::logTaggedMarkerBridgeless(
-                ReactMarker::RUN_JS_BUNDLE_START, scriptName.c_str());
-          }
+        SystraceSection s("ReactInstance::loadScript");
+        bool hasLogger(ReactMarker::logTaggedMarkerBridgelessImpl);
+        if (hasLogger) {
+          ReactMarker::logTaggedMarkerBridgeless(
+              ReactMarker::RUN_JS_BUNDLE_START, scriptName.c_str());
+        }
 
-          runtime.evaluateJavaScript(buffer, sourceURL);
-          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();
-          }
-        } catch (jsi::JSError& error) {
-          jsErrorHandler_->handleFatalError(error);
+        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();
+        }
+
+        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();
         }
       });
 }
@@ -332,6 +354,11 @@ void defineReactInstanceFlags(
   }
 }
 
+bool isTruthy(jsi::Runtime& runtime, const jsi::Value& value) {
+  auto Boolean = runtime.global().getPropertyAsFunction(runtime, "Boolean");
+  return Boolean.call(runtime, value).getBool();
+}
+
 } // namespace
 
 void ReactInstance::initializeRuntime(
@@ -346,8 +373,48 @@ void ReactInstance::initializeRuntime(
     RuntimeSchedulerBinding::createAndInstallIfNeeded(
         runtime, runtimeScheduler_);
 
+    runtime_->unstable_initializeOnJsThread();
+
     defineReactInstanceFlags(runtime, options);
 
+    // TODO(T196834299): We should really use a C++ turbomodule for this
+    defineReadOnlyGlobal(
+        runtime,
+        "RN$handleException",
+        jsi::Function::createFromHostFunction(
+            runtime,
+            jsi::PropNameID::forAscii(runtime, "handleException"),
+            2,
+            [jsErrorHandler = jsErrorHandler_](
+                jsi::Runtime& runtime,
+                const jsi::Value& /*unused*/,
+                const jsi::Value* args,
+                size_t count) {
+              if (count < 2) {
+                throw jsi::JSError(
+                    runtime,
+                    "handleException requires 2 arguments: error, isFatal");
+              }
+
+              auto isFatal = isTruthy(runtime, args[1]);
+              if (jsErrorHandler->isRuntimeReady()) {
+                if (isFatal) {
+                  jsErrorHandler->notifyOfFatalError();
+                }
+
+                return jsi::Value(false);
+              }
+
+              if (isFatal) {
+                auto jsError =
+                    jsi::JSError(runtime, jsi::Value(runtime, args[0]));
+                jsErrorHandler->handleFatalError(runtime, jsError);
+                return jsi::Value(true);
+              }
+
+              return jsi::Value(false);
+            }));
+
     defineReadOnlyGlobal(
         runtime,
         "RN$registerCallableModule",

package/ReactCommon/packages.lock.json

@@ -14,8 +14,8 @@
       "folly": {
         "type": "Project",
         "dependencies": {
-          "Fmt": "[1.0.0, )",
-          "boost": "[1.83.0, )"
+          "boost": "[1.83.0, )",
+          "fmt": "[1.0.0, )"
         }
       }
     },

package/Scripts/NuGetRestoreForceEvaluateAllSolutions.ps1

@@ -11,10 +11,17 @@ try
     $packagesSolutions = Get-ChildItem -File -Recurse -Path packages *.sln | Where-Object { !$_.FullName.Contains('node_modules') -and !$_.FullName.Contains('e2etest') }
     $vnextSolutions = Get-ChildItem -File -Path vnext *.sln
 
+    # Run all solutions with their defaults
     $($packagesSolutions; $vnextSolutions) | Foreach {
-        Write-Host Restoring $_.FullName
+        Write-Host Restoring $_.FullName with defaults
         & msbuild /t:Restore /p:RestoreForceEvaluate=true $_.FullName
     }
+
+    # Re-run solutions that we also build a Fabric variant
+    @("$RepoRoot\vnext\ReactWindows-Desktop.sln", "$RepoRoot\vnext\Microsoft.ReactNative.CppOnly.slnf") | Foreach {
+        Write-Host Restoring $_ with Fabric
+        & msbuild /t:Restore /p:RestoreForceEvaluate=true /p:UseFabric=true /p:UseWinUI3=true $_
+    }
 }
 finally
 {

package/Scripts/Tfs/Layout-MSRN-Headers.ps1

@@ -80,12 +80,12 @@ New-Item -ItemType Directory -Path $TargetRoot\Microsoft.ReactNative.Cxx\ReactCo
 Copy-Item -Force -Path $ReactNativeRoot\ReactCommon\callinvoker\ReactCommon\CallInvoker.h -Destination $TargetRoot\Microsoft.ReactNative.Cxx\ReactCommon\
 Copy-Item -Force -Path $ReactNativeRoot\ReactCommon\callinvoker\ReactCommon\SchedulerPriority.h -Destination $TargetRoot\Microsoft.ReactNative.Cxx\ReactCommon\
 Copy-Item -Force -Path $ReactNativeRoot\ReactCommon\react\bridging\CallbackWrapper.h -Destination $TargetRoot\Microsoft.ReactNative.Cxx\ReactCommon\
+Copy-Item -Force -Path $ReactNativeRoot\ReactCommon\react\bridging\LongLivedObject.cpp -Destination $TargetRoot\Microsoft.ReactNative.Cxx\ReactCommon\
+Copy-Item -Force -Path $ReactNativeRoot\ReactCommon\react\bridging\LongLivedObject.h -Destination $TargetRoot\Microsoft.ReactNative.Cxx\ReactCommon\
 Copy-Item -Force -Path $ReactNativeRoot\ReactCommon\react\bridging\EventEmitter.h -Destination $TargetRoot\Microsoft.ReactNative.Cxx\ReactCommon\
 Copy-Item -Force -Path $ReactNativeRoot\ReactCommon\react\bridging\Function.h -Destination $TargetRoot\Microsoft.ReactNative.Cxx\ReactCommon\
 Copy-Item -Force -Path $ReactNativeRoot\ReactCommon\react\bridging\Base.h -Destination $TargetRoot\Microsoft.ReactNative.Cxx\ReactCommon\
 Copy-Item -Force -Path $ReactNativeRoot\ReactCommon\react\bridging\Convert.h -Destination $TargetRoot\Microsoft.ReactNative.Cxx\ReactCommon\
-Copy-Item -Force -Path $ReactNativeRoot\ReactCommon\react\bridging\LongLivedObject.cpp -Destination $TargetRoot\Microsoft.ReactNative.Cxx\ReactCommon\
-Copy-Item -Force -Path $ReactNativeRoot\ReactCommon\react\bridging\LongLivedObject.h -Destination $TargetRoot\Microsoft.ReactNative.Cxx\ReactCommon\
 Copy-Item -Force -Path $ReactNativeRoot\ReactCommon\react\nativemodule\core\ReactCommon\TurboModule.cpp -Destination $TargetRoot\Microsoft.ReactNative.Cxx\ReactCommon\
 Copy-Item -Force -Path $ReactNativeRoot\ReactCommon\react\nativemodule\core\ReactCommon\TurboModule.h -Destination $TargetRoot\Microsoft.ReactNative.Cxx\ReactCommon\
 Copy-Item -Force -Path $ReactNativeRoot\ReactCommon\react\nativemodule\core\ReactCommon\TurboModuleUtils.cpp -Destination $TargetRoot\Microsoft.ReactNative.Cxx\ReactCommon\

package/Shared/Modules/WebSocketModule.cpp

@@ -416,9 +416,8 @@ void WebSocketTurboModule::Connect(
   auto &optHeaders = options.headers;
   if (optHeaders.has_value()) {
     auto &headersVal = optHeaders.value();
-    for (const auto &headerVal : headersVal.AsArray()) {
+    for (const auto &entry : headersVal.AsObject()) {
       // Each header JSValueObject should only contain one key-value pair
-      const auto &entry = *headerVal.AsObject().cbegin();
       rcOptions.emplace(winrt::to_hstring(entry.first), entry.second.AsString());
     }
   }