react-native-windows 0.69.6 → 0.70.0

package/ReactCommon/TEMP_UntilReactCommonUpdate/react/renderer/core/PropsMacros.h

@@ -0,0 +1,91 @@
+/*
+ * 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 <react/renderer/core/RawPropsPrimitives.h>
+
+// We need to use clang pragmas inside of a macro below,
+// so we need to pull out the "if" statement here.
+#if __clang__
+#define CLANG_PRAGMA(s) _Pragma(s)
+#else
+#define CLANG_PRAGMA(s)
+#endif
+
+#define CONSTEXPR_RAW_PROPS_KEY_HASH(s)                   \
+  []{                                                     \
+    CLANG_PRAGMA("clang diagnostic push")                 \
+    CLANG_PRAGMA("clang diagnostic ignored \"-Wshadow\"") \
+    return folly::hash::fnv32_buf(s, sizeof(s) - 1);      \
+    CLANG_PRAGMA("clang diagnostic pop")                  \
+    }()
+
+#define RAW_PROPS_KEY_HASH(s) folly::hash::fnv32_buf(s, std::strlen(s))
+
+// Convenience for building setProps switch statements.
+// This injects `fromRawValue` into source; each file that uses
+// this macro must import the proper, respective headers required.
+#define RAW_SET_PROP_SWITCH_CASE(field, jsPropName, defaultValue) \
+  case CONSTEXPR_RAW_PROPS_KEY_HASH(jsPropName):                  \
+    fromRawValue(context, value, field, defaultValue);            \
+    return;
+
+// Convenience for building setProps switch statements where the field name is
+// the same as the string identifier
+#define RAW_SET_PROP_SWITCH_CASE_BASIC(field, defaultValue) \
+  RAW_SET_PROP_SWITCH_CASE(field, #field, defaultValue)
+
+#define CASE_STATEMENT_SET_FIELD_VALUE_INDEXED(         \
+    struct, field, fieldNameString, value)              \
+  case CONSTEXPR_RAW_PROPS_KEY_HASH(fieldNameString): { \
+    if (!value.hasValue()) {                            \
+      decltype(struct) defaultValues{};                 \
+      struct.field = defaultValues.field;               \
+      return;                                           \
+    }                                                   \
+    fromRawValue(context, value, struct.field);         \
+    return;                                             \
+  }
+
+#define SET_CASCADED_RECTANGLE_CORNERS(struct, prefix, suffix, rawValue) \
+  CASE_STATEMENT_SET_FIELD_VALUE_INDEXED(                                \
+      struct, topLeft, prefix "TopLeft" suffix, rawValue)                \
+  CASE_STATEMENT_SET_FIELD_VALUE_INDEXED(                                \
+      struct, topRight, prefix "TopRight" suffix, rawValue)              \
+  CASE_STATEMENT_SET_FIELD_VALUE_INDEXED(                                \
+      struct, bottomLeft, prefix "BottomLeft" suffix, rawValue)          \
+  CASE_STATEMENT_SET_FIELD_VALUE_INDEXED(                                \
+      struct, bottomRight, prefix "BottomRight" suffix, rawValue)        \
+  CASE_STATEMENT_SET_FIELD_VALUE_INDEXED(                                \
+      struct, topStart, prefix "TopStart" suffix, rawValue)              \
+  CASE_STATEMENT_SET_FIELD_VALUE_INDEXED(                                \
+      struct, topEnd, prefix "TopEnd" suffix, rawValue)                  \
+  CASE_STATEMENT_SET_FIELD_VALUE_INDEXED(                                \
+      struct, bottomStart, prefix "BottomStart" suffix, rawValue)        \
+  CASE_STATEMENT_SET_FIELD_VALUE_INDEXED(                                \
+      struct, bottomEnd, prefix "BottomEnd" suffix, rawValue)
+
+#define SET_CASCADED_RECTANGLE_EDGES(struct, prefix, suffix, rawValue) \
+  CASE_STATEMENT_SET_FIELD_VALUE_INDEXED(                              \
+      struct, left, prefix "Left" suffix, rawValue)                    \
+  CASE_STATEMENT_SET_FIELD_VALUE_INDEXED(                              \
+      struct, right, prefix "Right" suffix, rawValue)                  \
+  CASE_STATEMENT_SET_FIELD_VALUE_INDEXED(                              \
+      struct, top, prefix "Top" suffix, rawValue)                      \
+  CASE_STATEMENT_SET_FIELD_VALUE_INDEXED(                              \
+      struct, bottom, prefix "Bottom" suffix, rawValue)                \
+  CASE_STATEMENT_SET_FIELD_VALUE_INDEXED(                              \
+      struct, start, prefix "Start" suffix, rawValue)                  \
+  CASE_STATEMENT_SET_FIELD_VALUE_INDEXED(                              \
+      struct, end, prefix "End" suffix, rawValue)                      \
+  CASE_STATEMENT_SET_FIELD_VALUE_INDEXED(                              \
+      struct, horizontal, prefix "Horizontal" suffix, rawValue)        \
+  CASE_STATEMENT_SET_FIELD_VALUE_INDEXED(                              \
+      struct, vertical, prefix "Vertical" suffix, rawValue)            \
+  CASE_STATEMENT_SET_FIELD_VALUE_INDEXED(                              \
+      struct, all, prefix "" suffix, rawValue)

package/ReactCommon/TEMP_UntilReactCommonUpdate/react/renderer/graphics/RectangleEdges.h

@@ -0,0 +1,100 @@
+/*
+ * 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 <tuple>
+
+#include <folly/Hash.h>
+#include <react/renderer/graphics/Float.h>
+#include <react/renderer/graphics/Rect.h>
+
+namespace facebook {
+namespace react {
+
+/*
+ * Generic data structure describes some values associated with *edges*
+ * of a rectangle.
+ */
+template <typename T>
+struct RectangleEdges {
+  T left{};
+  T top{};
+  T right{};
+  T bottom{};
+
+  bool operator==(RectangleEdges<T> const &rhs) const noexcept {
+    return std::tie(this->left, this->top, this->right, this->bottom) ==
+        std::tie(rhs.left, rhs.top, rhs.right, rhs.bottom);
+  }
+
+  bool operator!=(RectangleEdges<T> const &rhs) const noexcept {
+    return !(*this == rhs);
+  }
+
+  bool isUniform() const noexcept {
+    return left == top && left == right && left == bottom;
+  }
+
+  static RectangleEdges<T> const ZERO;
+};
+
+template <typename T>
+RectangleEdges<T> const RectangleEdges<T>::ZERO = {};
+
+template <typename T>
+RectangleEdges<T> operator+(
+    RectangleEdges<T> const &lhs,
+    RectangleEdges<T> const &rhs) noexcept {
+  return RectangleEdges<T>{
+      lhs.left + rhs.left,
+      lhs.top + rhs.top,
+      lhs.right + rhs.right,
+      lhs.bottom + rhs.bottom};
+}
+
+template <typename T>
+RectangleEdges<T> operator-(
+    RectangleEdges<T> const &lhs,
+    RectangleEdges<T> const &rhs) noexcept {
+  return RectangleEdges<T>{
+      lhs.left - rhs.left,
+      lhs.top - rhs.top,
+      lhs.right - rhs.right,
+      lhs.bottom - rhs.bottom};
+}
+
+/*
+ * EdgeInsets
+ */
+using EdgeInsets = RectangleEdges<Float>;
+
+/*
+ * Adjusts a rectangle by the given edge insets.
+ */
+inline Rect insetBy(Rect const &rect, EdgeInsets const &insets) noexcept {
+  return Rect{
+      {rect.origin.x + insets.left, rect.origin.y + insets.top},
+      {rect.size.width - insets.left - insets.right,
+       rect.size.height - insets.top - insets.bottom}};
+}
+
+} // namespace react
+} // namespace facebook
+
+namespace std {
+
+template <typename T>
+struct hash<facebook::react::RectangleEdges<T>> {
+  size_t operator()(
+      facebook::react::RectangleEdges<T> const &edges) const noexcept {
+    return folly::hash::hash_combine(
+        0, edges.left, edges.right, edges.top, edges.bottom);
+  }
+};
+
+} // namespace std

package/ReactCommon/TEMP_UntilReactCommonUpdate/yoga/yoga/CompactValue.h

@@ -11,6 +11,8 @@
 
 #ifdef __cpp_lib_bit_cast
 #include <bit>
+#else
+#include <cstring>
 #endif
 #include "YGValue.h"
 #include "YGMacros.h"
@@ -169,7 +171,7 @@ class YOGA_EXPORT CompactValue {
 
   static float asFloat(uint32_t u) {
 #ifdef __cpp_lib_bit_cast
-    return std::bit_cast<float>(data);
+    return std::bit_cast<float>(u);
 #else
     float f;
     static_assert(sizeof(f) == sizeof(u));

package/Scripts/Microsoft.ReactNative.nuspec

@@ -29,27 +29,33 @@
     <file src="$nugetroot$\ARM64\Release\Microsoft.ReactNative\Microsoft.ReactNative.dll" target="runtimes\win10-arm64\native" />
     <file src="$nugetroot$\ARM64\Release\Microsoft.ReactNative\Microsoft.ReactNative.pdb" target="runtimes\win10-arm64\native" />
     <file src="$nugetroot$\ARM64\Release\Microsoft.ReactNative\Microsoft.ReactNative.pri" target="runtimes\win10-arm64\native" />
+    <file src="$nugetroot$\ARM64\Release\Microsoft.ReactNative\Microsoft.ReactNative.lib" target="lib\arm64" />
 
     <file src="$nugetroot$\x86\Release\Microsoft.ReactNative\Microsoft.ReactNative.dll" target="runtimes\win10-x86\native" />
     <file src="$nugetroot$\x86\Release\Microsoft.ReactNative\Microsoft.ReactNative.pdb" target="runtimes\win10-x86\native" />
     <file src="$nugetroot$\x86\Release\Microsoft.ReactNative\Microsoft.ReactNative.pri" target="runtimes\win10-x86\native" />
+    <file src="$nugetroot$\x86\Release\Microsoft.ReactNative\Microsoft.ReactNative.lib" target="lib\x86" />
 
     <file src="$nugetroot$\x64\Release\Microsoft.ReactNative\Microsoft.ReactNative.dll" target="runtimes\win10-x64\native" />
     <file src="$nugetroot$\x64\Release\Microsoft.ReactNative\Microsoft.ReactNative.pdb" target="runtimes\win10-x64\native" />
     <file src="$nugetroot$\x64\Release\Microsoft.ReactNative\Microsoft.ReactNative.pri" target="runtimes\win10-x64\native" />
+    <file src="$nugetroot$\x64\Release\Microsoft.ReactNative\Microsoft.ReactNative.lib" target="lib\x64" />
 
     <!-- Included in Microsoft.ReactNative.Debug -->
     <file src="$nugetroot$\ARM64\Debug\Microsoft.ReactNative\Microsoft.ReactNative.dll" target="runtimes\win10-arm64\native" />
     <file src="$nugetroot$\ARM64\Debug\Microsoft.ReactNative\Microsoft.ReactNative.pdb" target="runtimes\win10-arm64\native" />
     <file src="$nugetroot$\ARM64\Debug\Microsoft.ReactNative\Microsoft.ReactNative.pri" target="runtimes\win10-arm64\native" />
+    <file src="$nugetroot$\ARM64\Debug\Microsoft.ReactNative\Microsoft.ReactNative.lib" target="lib\arm64" />
 
     <file src="$nugetroot$\x86\Debug\Microsoft.ReactNative\Microsoft.ReactNative.dll" target="runtimes\win10-x86\native" />
     <file src="$nugetroot$\x86\Debug\Microsoft.ReactNative\Microsoft.ReactNative.pdb" target="runtimes\win10-x86\native" />
     <file src="$nugetroot$\x86\Debug\Microsoft.ReactNative\Microsoft.ReactNative.pri" target="runtimes\win10-x86\native" />
+    <file src="$nugetroot$\x86\Debug\Microsoft.ReactNative\Microsoft.ReactNative.lib" target="lib\x86" />
 
     <file src="$nugetroot$\x64\Debug\Microsoft.ReactNative\Microsoft.ReactNative.dll" target="runtimes\win10-x64\native" />
     <file src="$nugetroot$\x64\Debug\Microsoft.ReactNative\Microsoft.ReactNative.pdb" target="runtimes\win10-x64\native" />
     <file src="$nugetroot$\x64\Debug\Microsoft.ReactNative\Microsoft.ReactNative.pri" target="runtimes\win10-x64\native" />
+    <file src="$nugetroot$\x64\Debug\Microsoft.ReactNative\Microsoft.ReactNative.lib" target="lib\x64" />
 
     <!-- XBF files need to be included for Debug since they are not embedded in the PRI -->
     <file src="$nugetroot$\ARM64\Debug\Microsoft.ReactNative\**\*.xbf"  target="runtimes\win10-arm64\native" />

package/Scripts/Microsoft.ReactNative.targets

@@ -18,4 +18,11 @@
     <ReferenceCopyLocalPaths Condition="$(Configuration) == 'Debug'" Include="$(_rnwFolder)**\*.xbf" />
 
   </ItemGroup>
+
+  <ItemDefinitionGroup Condition="'$(UseRNCoreApp)'=='true'">
+    <Link>
+      <AdditionalDependencies>$(MSBuildThisFileDirectory)..\..\lib\$(Native-Platform)\Microsoft.ReactNative.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+
 </Project>

package/Shared/DevSettings.h

@@ -24,7 +24,11 @@ namespace react {
 enum class JSIEngineOverride : int32_t {
   Default = 0, // No JSI, will use the legacy ExecutorFactory
   Chakra = 1, // Use the JSIExecutorFactory with ChakraRuntime
+
+#if 0 // Deprecated
   ChakraCore = 2, // Use the JSIExecutorFactory with ChakraCoreRuntime
+#endif
+
   Hermes = 3, // Use the JSIExecutorFactory with Hermes
   V8 = 4, // Use the JSIExecutorFactory with V8
   V8Lite = 5, // Use the JSIExecutorFactory with V8Lite

package/Shared/InstanceManager.cpp

@@ -41,6 +41,35 @@ std::shared_ptr<InstanceWrapper> CreateReactInstance(
       std::move(jsBundleBasePath),
       std::move(cxxModules),
       std::move(turboModuleRegistry),
+      nullptr,
+      std::move(callback),
+      std::move(jsQueue),
+      std::move(nativeQueue),
+      std::move(devSettings),
+      GetSharedDevManager());
+
+  return inner;
+}
+
+std::shared_ptr<InstanceWrapper> CreateReactInstance(
+    std::shared_ptr<Instance> &&instance,
+    std::string &&jsBundleBasePath,
+    std::vector<
+        std::tuple<std::string, facebook::xplat::module::CxxModule::Provider, std::shared_ptr<MessageQueueThread>>>
+        &&cxxModules,
+    std::shared_ptr<TurboModuleRegistry> turboModuleRegistry,
+    std::shared_ptr<facebook::react::LongLivedObjectCollection> longLivedObjectCollection,
+    std::unique_ptr<InstanceCallback> &&callback,
+    std::shared_ptr<MessageQueueThread> jsQueue,
+    std::shared_ptr<MessageQueueThread> nativeQueue,
+    std::shared_ptr<DevSettings> devSettings) noexcept {
+  // Now create the instance
+  std::shared_ptr<InstanceWrapper> inner = InstanceImpl::MakeNoBundle(
+      std::move(instance),
+      std::move(jsBundleBasePath),
+      std::move(cxxModules),
+      std::move(turboModuleRegistry),
+      std::move(longLivedObjectCollection),
       std::move(callback),
       std::move(jsQueue),
       std::move(nativeQueue),

package/Shared/InstanceManager.h

@@ -4,6 +4,7 @@
 #pragma once
 
 #include <Logging.h>
+#include <ReactCommon/LongLivedObject.h>
 #include <cxxreact/CxxModule.h>
 #include <cxxreact/JSBigString.h>
 #include <map>
@@ -51,6 +52,19 @@ std::shared_ptr<InstanceWrapper> CreateReactInstance(
     std::shared_ptr<MessageQueueThread> nativeQueue,
     std::shared_ptr<DevSettings> devSettings) noexcept;
 
+std::shared_ptr<InstanceWrapper> CreateReactInstance(
+    std::shared_ptr<Instance> &&instance,
+    std::string &&jsBundleRelativePath,
+    std::vector<
+        std::tuple<std::string, facebook::xplat::module::CxxModule::Provider, std::shared_ptr<MessageQueueThread>>>
+        &&cxxModules,
+    std::shared_ptr<TurboModuleRegistry> turboModuleRegistry,
+    std::shared_ptr<facebook::react::LongLivedObjectCollection> longLivedObjectCollection,
+    std::unique_ptr<InstanceCallback> &&callback,
+    std::shared_ptr<MessageQueueThread> jsQueue,
+    std::shared_ptr<MessageQueueThread> nativeQueue,
+    std::shared_ptr<DevSettings> devSettings) noexcept;
+
 std::shared_ptr<InstanceWrapper> CreateReactInstance(
     std::shared_ptr<Instance> &&instance,
     std::string &&jsBundleBasePath,

package/Shared/JSI/ChakraRuntime.cpp

@@ -116,7 +116,7 @@ void ChakraRuntime::PromiseContinuation(JsValueRef funcRef) noexcept {
   if (runtimeArgs().jsQueue) {
     JsAddRef(funcRef, nullptr);
     runtimeArgs().jsQueue->runOnQueue([this, funcRef]() {
-      JsValueRef undefinedValue;
+      JsValueRef undefinedValue = nullptr;
       JsGetUndefinedValue(&undefinedValue);
       ChakraVerifyJsErrorElseThrow(JsCallFunction(funcRef, &undefinedValue, 1, nullptr));
       JsRelease(funcRef, nullptr);
@@ -280,6 +280,11 @@ facebook::jsi::Runtime::PointerValue *ChakraRuntime::cloneSymbol(
   return CloneChakraPointerValue(pointerValue);
 }
 
+facebook::jsi::Runtime::PointerValue *ChakraRuntime::cloneBigInt(
+    const facebook::jsi::Runtime::PointerValue *pointerValue) {
+  return CloneChakraPointerValue(pointerValue);
+}
+
 facebook::jsi::Runtime::PointerValue *ChakraRuntime::cloneString(
     const facebook::jsi::Runtime::PointerValue *pointerValue) {
   return CloneChakraPointerValue(pointerValue);
@@ -591,6 +596,10 @@ bool ChakraRuntime::strictEquals(const facebook::jsi::Symbol &a, const facebook:
   return StrictEquals(GetJsRef(a), GetJsRef(b));
 }
 
+bool ChakraRuntime::strictEquals(const facebook::jsi::BigInt &a, const facebook::jsi::BigInt &b) const {
+  return StrictEquals(GetJsRef(a), GetJsRef(b));
+}
+
 bool ChakraRuntime::strictEquals(const facebook::jsi::String &a, const facebook::jsi::String &b) const {
   return StrictEquals(GetJsRef(a), GetJsRef(b));
 }
@@ -976,7 +985,7 @@ ChakraRuntime::JsiValueViewArgs::JsiValueViewArgs(JsValueRef *args, size_t argCo
   JsiValueView::StoreType *const pointerStore =
       m_heapPointerStore ? m_heapPointerStore.get() : m_stackPointerStore.data();
   facebook::jsi::Value *const jsiArgs = m_heapArgs ? m_heapArgs.get() : m_stackArgs.data();
-  for (uint32_t i = 0; i < m_size; ++i) {
+  for (size_t i = 0; i < m_size; ++i) {
     jsiArgs[i] = JsiValueView::InitValue(args[i], std::addressof(pointerStore[i]));
   }
 }

package/Shared/JSI/ChakraRuntime.h

@@ -56,6 +56,7 @@ class ChakraRuntime : public facebook::jsi::Runtime, public ChakraApi, ChakraApi
   // return value must only be used as an argument to the constructor of
   // jsi::Pointer or one of its derived classes.
   PointerValue *cloneSymbol(const PointerValue *pointerValue) override;
+  PointerValue *cloneBigInt(const PointerValue *pointerValue) override;
   PointerValue *cloneString(const PointerValue *pointerValue) override;
   PointerValue *cloneObject(const PointerValue *pointerValue) override;
   PointerValue *clonePropNameID(const PointerValue *pointerValue) override;
@@ -133,6 +134,7 @@ class ChakraRuntime : public facebook::jsi::Runtime, public ChakraApi, ChakraApi
   void popScope(ScopeState *) override;
 
   bool strictEquals(const facebook::jsi::Symbol &a, const facebook::jsi::Symbol &b) const override;
+  bool strictEquals(const facebook::jsi::BigInt &a, const facebook::jsi::BigInt &b) const override;
   bool strictEquals(const facebook::jsi::String &a, const facebook::jsi::String &b) const override;
   bool strictEquals(const facebook::jsi::Object &a, const facebook::jsi::Object &b) const override;
 

package/Shared/Modules/BlobModule.cpp

@@ -139,7 +139,7 @@ vector<module::CxxModule::Method> BlobModule::getMethods() {
          auto size = blob[sizeKey].getInt();
          auto socketID = jsArgAsInt(args, 1);
 
-         winrt::array_view<uint8_t> data;
+         winrt::array_view<uint8_t const> data;
          try {
            data = persistor->ResolveMessage(std::move(blobId), offset, size);
          } catch (const std::exception &e) {
@@ -169,7 +169,7 @@ vector<module::CxxModule::Method> BlobModule::getMethods() {
            auto type = part[typeKey].asString();
            if (blobKey == type) {
              auto blob = part[dataKey];
-             winrt::array_view<uint8_t> bufferPart;
+             winrt::array_view<uint8_t const> bufferPart;
              try {
                bufferPart = persistor->ResolveMessage(
                    blob[blobIdKey].asString(), blob[offsetKey].asInt(), blob[sizeKey].asInt());
@@ -216,7 +216,7 @@ vector<module::CxxModule::Method> BlobModule::getMethods() {
 
 #pragma region IBlobPersistor
 
-winrt::array_view<uint8_t> MemoryBlobPersistor::ResolveMessage(string &&blobId, int64_t offset, int64_t size) {
+winrt::array_view<uint8_t const> MemoryBlobPersistor::ResolveMessage(string &&blobId, int64_t offset, int64_t size) {
   if (size < 1)
     return {};
 
@@ -233,7 +233,7 @@ winrt::array_view<uint8_t> MemoryBlobPersistor::ResolveMessage(string &&blobId,
   if (endBound > bytes.size() || offset >= static_cast<int64_t>(bytes.size()) || offset < 0)
     throw std::out_of_range("Offset or size out of range");
 
-  return winrt::array_view<uint8_t>(bytes.data() + offset, bytes.data() + endBound);
+  return winrt::array_view<uint8_t const>(bytes.data() + offset, bytes.data() + endBound);
 }
 
 void MemoryBlobPersistor::RemoveMessage(string &&blobId) noexcept {

package/Shared/Modules/BlobModule.h

@@ -30,7 +30,7 @@ class MemoryBlobPersistor final : public IBlobPersistor {
  public:
 #pragma region IBlobPersistor
 
-  winrt::array_view<uint8_t> ResolveMessage(std::string &&blobId, int64_t offset, int64_t size) override;
+  winrt::array_view<uint8_t const> ResolveMessage(std::string &&blobId, int64_t offset, int64_t size) override;
 
   void RemoveMessage(std::string &&blobId) noexcept override;
 

package/Shared/Modules/FileReaderModule.cpp

@@ -4,6 +4,7 @@
 #include "FileReaderModule.h"
 
 #include <ReactPropertyBag.h>
+#include <sstream>
 
 // Boost Library
 #include <boost/archive/iterators/base64_from_binary.hpp>
@@ -71,7 +72,7 @@ std::vector<module::CxxModule::Method> FileReaderModule::getMethods() {
          auto offset = blob["offset"].asInt();
          auto size = blob["size"].asInt();
 
-         winrt::array_view<uint8_t> bytes;
+         winrt::array_view<uint8_t const> bytes;
          try {
            bytes = blobPersistor->ResolveMessage(std::move(blobId), offset, size);
          } catch (const std::exception &e) {
@@ -116,7 +117,7 @@ std::vector<module::CxxModule::Method> FileReaderModule::getMethods() {
          auto offset = blob["offset"].asInt();
          auto size = blob["size"].asInt();
 
-         winrt::array_view<uint8_t> bytes;
+         winrt::array_view<uint8_t const> bytes;
          try {
            bytes = blobPersistor->ResolveMessage(std::move(blobId), offset, size);
          } catch (const std::exception &e) {

package/Shared/Modules/IBlobPersistor.h

@@ -18,7 +18,7 @@ struct IBlobPersistor {
   /// When an entry for blobId cannot be found.
   /// </exception>
   ///
-  virtual winrt::array_view<uint8_t> ResolveMessage(std::string &&blobId, int64_t offset, int64_t size) = 0;
+  virtual winrt::array_view<uint8_t const> ResolveMessage(std::string &&blobId, int64_t offset, int64_t size) = 0;
 
   virtual void RemoveMessage(std::string &&blobId) noexcept = 0;
 

package/Shared/Networking/IHttpResource.h

@@ -71,6 +71,7 @@ struct IHttpResource {
   /// </param>
   /// <param name="timeout">
   /// Request timeout in miliseconds.
+  /// Note: A value of 0 means no timeout. The resource will await the response indefinitely.
   /// </param>
   /// <param name="withCredentials">
   /// Allow including credentials in request.

package/Shared/Networking/OriginPolicyHttpFilter.cpp

@@ -12,6 +12,7 @@
 #include <boost/lexical_cast/try_lexical_convert.hpp>
 
 // Windows API
+#include <winrt/Windows.Foundation.Collections.h>
 #include <winrt/Windows.Web.Http.Headers.h>
 
 // Standard Library
@@ -653,21 +654,26 @@ ResponseOperation OriginPolicyHttpFilter::SendPreflightAsync(HttpRequestMessage
   preflightRequest.Headers().Insert(L"Access-Control-Request-Method", coRequest.Method().ToString());
 
   auto headerNames = wstring{};
-  auto headerItr = coRequest.Headers().begin();
-  if (headerItr != coRequest.Headers().end()) {
-    headerNames += (*headerItr).Key();
+  auto writeSeparator = false;
+  for (const auto &header : coRequest.Headers()) {
+    if (writeSeparator) {
+      headerNames += L", ";
+    } else {
+      writeSeparator = true;
+    }
 
-    while (++headerItr != coRequest.Headers().end())
-      headerNames += L", " + (*headerItr).Key();
+    headerNames += header.Key();
   }
 
   if (coRequest.Content()) {
-    headerItr = coRequest.Content().Headers().begin();
-    if (headerItr != coRequest.Content().Headers().end()) {
-      headerNames += (*headerItr).Key();
+    for (const auto &header : coRequest.Content().Headers()) {
+      if (writeSeparator) {
+        headerNames += L", ";
+      } else {
+        writeSeparator = true;
+      }
 
-      while (++headerItr != coRequest.Content().Headers().end())
-        headerNames += L", " + (*headerItr).Key();
+      headerNames += header.Key();
     }
   }
 

package/Shared/Networking/WinRTHttpResource.cpp

@@ -14,6 +14,7 @@
 #include <boost/algorithm/string.hpp>
 
 // Windows API
+#include <winrt/Windows.Foundation.Collections.h>
 #include <winrt/Windows.Security.Cryptography.h>
 #include <winrt/Windows.Storage.Streams.h>
 #include <winrt/Windows.Web.Http.Headers.h>
@@ -218,6 +219,12 @@ fire_and_forget WinRTHttpResource::PerformSendRequest(HttpRequestMessage &&reque
       if (!success && m_onError) {
         co_return m_onError(coReqArgs->RequestId, "Failed to append Authorization");
       }
+    } else if (boost::iequals(header.first.c_str(), "User-Agent")) {
+      bool success =
+          coRequest.Headers().TryAppendWithoutValidation(to_hstring(header.first), to_hstring(header.second));
+      if (!success && m_onError) {
+        co_return m_onError(coReqArgs->RequestId, "Failed to append User-Agent");
+      }
     } else {
       try {
         coRequest.Headers().Append(to_hstring(header.first), to_hstring(header.second));
@@ -249,7 +256,7 @@ fire_and_forget WinRTHttpResource::PerformSendRequest(HttpRequestMessage &&reque
       for (auto &byte : bytes) {
         byteVector.push_back(static_cast<uint8_t>(byte.asInt()));
       }
-      auto view = winrt::array_view<uint8_t>{byteVector};
+      auto view = winrt::array_view<uint8_t const>{byteVector};
       auto buffer = CryptographicBuffer::CreateFromByteArray(view);
       content = HttpBufferContent{std::move(buffer)};
     } else if (!data["string"].empty()) {
@@ -297,7 +304,32 @@ fire_and_forget WinRTHttpResource::PerformSendRequest(HttpRequestMessage &&reque
     auto sendRequestOp = self->m_client.SendRequestAsync(coRequest);
     self->TrackResponse(coReqArgs->RequestId, sendRequestOp);
 
-    co_await lessthrow_await_adapter<ResponseOperation>{sendRequestOp};
+    if (coReqArgs->Timeout > 0) {
+      // See https://devblogs.microsoft.com/oldnewthing/20220415-00/?p=106486
+      auto timedOut = std::make_shared<bool>(false);
+      auto sendRequestTimeout = [](auto timedOut, auto milliseconds) -> ResponseOperation {
+        // Convert milliseconds to "ticks" (10^-7 seconds)
+        co_await winrt::resume_after(winrt::Windows::Foundation::TimeSpan{milliseconds * 10000});
+        *timedOut = true;
+        co_return nullptr;
+      }(timedOut, coReqArgs->Timeout);
+
+      co_await lessthrow_await_adapter<ResponseOperation>{winrt::when_any(sendRequestOp, sendRequestTimeout)};
+
+      // Cancel either still unfinished coroutine.
+      sendRequestTimeout.Cancel();
+      sendRequestOp.Cancel();
+
+      if (*timedOut) {
+        if (self->m_onError) {
+          self->m_onError(coReqArgs->RequestId, Utilities::HResultToString(HRESULT_FROM_WIN32(ERROR_TIMEOUT)));
+        }
+        co_return self->UntrackResponse(coReqArgs->RequestId);
+      }
+    } else {
+      co_await lessthrow_await_adapter<ResponseOperation>{sendRequestOp};
+    }
+
     auto result = sendRequestOp.ErrorCode();
     if (result < 0) {
       if (self->m_onError) {