react-native 0.70.4 → 0.71.0-rc.0

package/ReactCommon/hermes/inspector/chrome/MessageTypes.cpp

@@ -1,5 +1,5 @@
 // Copyright (c) Meta Platforms, Inc. and affiliates. All Rights Reserved.
-// @generated SignedSource<<f6f9a72f332587809b4e50ab054e0a74>>
+// @generated SignedSource<<8397f2428e68a26e014f91fdb77c1eb3>>
 
 #include "MessageTypes.h"
 
@@ -63,9 +63,12 @@ std::unique_ptr<Request> Request::fromJsonThrowOnError(const std::string &str) {
       {"Profiler.start", makeUnique<profiler::StartRequest>},
       {"Profiler.stop", makeUnique<profiler::StopRequest>},
       {"Runtime.callFunctionOn", makeUnique<runtime::CallFunctionOnRequest>},
+      {"Runtime.compileScript", makeUnique<runtime::CompileScriptRequest>},
       {"Runtime.evaluate", makeUnique<runtime::EvaluateRequest>},
       {"Runtime.getHeapUsage", makeUnique<runtime::GetHeapUsageRequest>},
       {"Runtime.getProperties", makeUnique<runtime::GetPropertiesRequest>},
+      {"Runtime.globalLexicalScopeNames",
+       makeUnique<runtime::GlobalLexicalScopeNamesRequest>},
       {"Runtime.runIfWaitingForDebugger",
        makeUnique<runtime::RunIfWaitingForDebuggerRequest>},
   };
@@ -1110,6 +1113,39 @@ void runtime::CallFunctionOnRequest::accept(RequestHandler &handler) const {
   handler.handle(*this);
 }
 
+runtime::CompileScriptRequest::CompileScriptRequest()
+    : Request("Runtime.compileScript") {}
+
+runtime::CompileScriptRequest::CompileScriptRequest(const dynamic &obj)
+    : Request("Runtime.compileScript") {
+  assign(id, obj, "id");
+  assign(method, obj, "method");
+
+  dynamic params = obj.at("params");
+  assign(expression, params, "expression");
+  assign(sourceURL, params, "sourceURL");
+  assign(persistScript, params, "persistScript");
+  assign(executionContextId, params, "executionContextId");
+}
+
+dynamic runtime::CompileScriptRequest::toDynamic() const {
+  dynamic params = dynamic::object;
+  put(params, "expression", expression);
+  put(params, "sourceURL", sourceURL);
+  put(params, "persistScript", persistScript);
+  put(params, "executionContextId", executionContextId);
+
+  dynamic obj = dynamic::object;
+  put(obj, "id", id);
+  put(obj, "method", method);
+  put(obj, "params", std::move(params));
+  return obj;
+}
+
+void runtime::CompileScriptRequest::accept(RequestHandler &handler) const {
+  handler.handle(*this);
+}
+
 runtime::EvaluateRequest::EvaluateRequest() : Request("Runtime.evaluate") {}
 
 runtime::EvaluateRequest::EvaluateRequest(const dynamic &obj)
@@ -1199,6 +1235,38 @@ void runtime::GetPropertiesRequest::accept(RequestHandler &handler) const {
   handler.handle(*this);
 }
 
+runtime::GlobalLexicalScopeNamesRequest::GlobalLexicalScopeNamesRequest()
+    : Request("Runtime.globalLexicalScopeNames") {}
+
+runtime::GlobalLexicalScopeNamesRequest::GlobalLexicalScopeNamesRequest(
+    const dynamic &obj)
+    : Request("Runtime.globalLexicalScopeNames") {
+  assign(id, obj, "id");
+  assign(method, obj, "method");
+
+  auto it = obj.find("params");
+  if (it != obj.items().end()) {
+    dynamic params = it->second;
+    assign(executionContextId, params, "executionContextId");
+  }
+}
+
+dynamic runtime::GlobalLexicalScopeNamesRequest::toDynamic() const {
+  dynamic params = dynamic::object;
+  put(params, "executionContextId", executionContextId);
+
+  dynamic obj = dynamic::object;
+  put(obj, "id", id);
+  put(obj, "method", method);
+  put(obj, "params", std::move(params));
+  return obj;
+}
+
+void runtime::GlobalLexicalScopeNamesRequest::accept(
+    RequestHandler &handler) const {
+  handler.handle(*this);
+}
+
 runtime::RunIfWaitingForDebuggerRequest::RunIfWaitingForDebuggerRequest()
     : Request("Runtime.runIfWaitingForDebugger") {}
 
@@ -1422,6 +1490,25 @@ dynamic runtime::CallFunctionOnResponse::toDynamic() const {
   return obj;
 }
 
+runtime::CompileScriptResponse::CompileScriptResponse(const dynamic &obj) {
+  assign(id, obj, "id");
+
+  dynamic res = obj.at("result");
+  assign(scriptId, res, "scriptId");
+  assign(exceptionDetails, res, "exceptionDetails");
+}
+
+dynamic runtime::CompileScriptResponse::toDynamic() const {
+  dynamic res = dynamic::object;
+  put(res, "scriptId", scriptId);
+  put(res, "exceptionDetails", exceptionDetails);
+
+  dynamic obj = dynamic::object;
+  put(obj, "id", id);
+  put(obj, "result", std::move(res));
+  return obj;
+}
+
 runtime::EvaluateResponse::EvaluateResponse(const dynamic &obj) {
   assign(id, obj, "id");
 
@@ -1481,6 +1568,24 @@ dynamic runtime::GetPropertiesResponse::toDynamic() const {
   return obj;
 }
 
+runtime::GlobalLexicalScopeNamesResponse::GlobalLexicalScopeNamesResponse(
+    const dynamic &obj) {
+  assign(id, obj, "id");
+
+  dynamic res = obj.at("result");
+  assign(names, res, "names");
+}
+
+dynamic runtime::GlobalLexicalScopeNamesResponse::toDynamic() const {
+  dynamic res = dynamic::object;
+  put(res, "names", names);
+
+  dynamic obj = dynamic::object;
+  put(obj, "id", id);
+  put(obj, "result", std::move(res));
+  return obj;
+}
+
 /// Notifications
 debugger::BreakpointResolvedNotification::BreakpointResolvedNotification()
     : Notification("Debugger.breakpointResolved") {}

package/ReactCommon/hermes/inspector/chrome/MessageTypes.h

@@ -1,5 +1,5 @@
 // Copyright (c) Meta Platforms, Inc. and affiliates. All Rights Reserved.
-// @generated SignedSource<<fcbcfeecbc72ca30c8ed005ad47839bb>>
+// @generated SignedSource<<2bada3d9c303c840ddcc292c7ba52604>>
 
 #pragma once
 
@@ -52,6 +52,8 @@ struct CallArgument;
 struct CallFrame;
 struct CallFunctionOnRequest;
 struct CallFunctionOnResponse;
+struct CompileScriptRequest;
+struct CompileScriptResponse;
 struct ConsoleAPICalledNotification;
 struct EvaluateRequest;
 struct EvaluateResponse;
@@ -63,6 +65,8 @@ struct GetHeapUsageRequest;
 struct GetHeapUsageResponse;
 struct GetPropertiesRequest;
 struct GetPropertiesResponse;
+struct GlobalLexicalScopeNamesRequest;
+struct GlobalLexicalScopeNamesResponse;
 struct InternalPropertyDescriptor;
 struct PropertyDescriptor;
 struct RemoteObject;
@@ -139,9 +143,11 @@ struct RequestHandler {
   virtual void handle(const profiler::StartRequest &req) = 0;
   virtual void handle(const profiler::StopRequest &req) = 0;
   virtual void handle(const runtime::CallFunctionOnRequest &req) = 0;
+  virtual void handle(const runtime::CompileScriptRequest &req) = 0;
   virtual void handle(const runtime::EvaluateRequest &req) = 0;
   virtual void handle(const runtime::GetHeapUsageRequest &req) = 0;
   virtual void handle(const runtime::GetPropertiesRequest &req) = 0;
+  virtual void handle(const runtime::GlobalLexicalScopeNamesRequest &req) = 0;
   virtual void handle(const runtime::RunIfWaitingForDebuggerRequest &req) = 0;
 };
 
@@ -177,9 +183,11 @@ struct NoopRequestHandler : public RequestHandler {
   void handle(const profiler::StartRequest &req) override {}
   void handle(const profiler::StopRequest &req) override {}
   void handle(const runtime::CallFunctionOnRequest &req) override {}
+  void handle(const runtime::CompileScriptRequest &req) override {}
   void handle(const runtime::EvaluateRequest &req) override {}
   void handle(const runtime::GetHeapUsageRequest &req) override {}
   void handle(const runtime::GetPropertiesRequest &req) override {}
+  void handle(const runtime::GlobalLexicalScopeNamesRequest &req) override {}
   void handle(const runtime::RunIfWaitingForDebuggerRequest &req) override {}
 };
 
@@ -650,6 +658,19 @@ struct runtime::CallFunctionOnRequest : public Request {
   folly::Optional<std::string> objectGroup;
 };
 
+struct runtime::CompileScriptRequest : public Request {
+  CompileScriptRequest();
+  explicit CompileScriptRequest(const folly::dynamic &obj);
+
+  folly::dynamic toDynamic() const override;
+  void accept(RequestHandler &handler) const override;
+
+  std::string expression;
+  std::string sourceURL;
+  bool persistScript{};
+  folly::Optional<runtime::ExecutionContextId> executionContextId;
+};
+
 struct runtime::EvaluateRequest : public Request {
   EvaluateRequest();
   explicit EvaluateRequest(const folly::dynamic &obj);
@@ -686,6 +707,16 @@ struct runtime::GetPropertiesRequest : public Request {
   folly::Optional<bool> ownProperties;
 };
 
+struct runtime::GlobalLexicalScopeNamesRequest : public Request {
+  GlobalLexicalScopeNamesRequest();
+  explicit GlobalLexicalScopeNamesRequest(const folly::dynamic &obj);
+
+  folly::dynamic toDynamic() const override;
+  void accept(RequestHandler &handler) const override;
+
+  folly::Optional<runtime::ExecutionContextId> executionContextId;
+};
+
 struct runtime::RunIfWaitingForDebuggerRequest : public Request {
   RunIfWaitingForDebuggerRequest();
   explicit RunIfWaitingForDebuggerRequest(const folly::dynamic &obj);
@@ -787,6 +818,15 @@ struct runtime::CallFunctionOnResponse : public Response {
   folly::Optional<runtime::ExceptionDetails> exceptionDetails;
 };
 
+struct runtime::CompileScriptResponse : public Response {
+  CompileScriptResponse() = default;
+  explicit CompileScriptResponse(const folly::dynamic &obj);
+  folly::dynamic toDynamic() const override;
+
+  folly::Optional<runtime::ScriptId> scriptId;
+  folly::Optional<runtime::ExceptionDetails> exceptionDetails;
+};
+
 struct runtime::EvaluateResponse : public Response {
   EvaluateResponse() = default;
   explicit EvaluateResponse(const folly::dynamic &obj);
@@ -816,6 +856,14 @@ struct runtime::GetPropertiesResponse : public Response {
   folly::Optional<runtime::ExceptionDetails> exceptionDetails;
 };
 
+struct runtime::GlobalLexicalScopeNamesResponse : public Response {
+  GlobalLexicalScopeNamesResponse() = default;
+  explicit GlobalLexicalScopeNamesResponse(const folly::dynamic &obj);
+  folly::dynamic toDynamic() const override;
+
+  std::vector<std::string> names;
+};
+
 /// Notifications
 struct debugger::BreakpointResolvedNotification : public Notification {
   BreakpointResolvedNotification();

package/ReactCommon/hermes/inspector/chrome/Registration.cpp

@@ -22,14 +22,14 @@ ConnectionDemux &demux() {
 
 } // namespace
 
-void enableDebugging(
+DebugSessionToken enableDebugging(
     std::unique_ptr<RuntimeAdapter> adapter,
     const std::string &title) {
-  demux().enableDebugging(std::move(adapter), title);
+  return demux().enableDebugging(std::move(adapter), title);
 }
 
-void disableDebugging(jsi::Runtime &runtime) {
-  demux().disableDebugging(runtime);
+void disableDebugging(DebugSessionToken session) {
+  demux().disableDebugging(session);
 }
 
 } // namespace chrome

package/ReactCommon/hermes/inspector/chrome/Registration.h

@@ -18,20 +18,24 @@ namespace hermes {
 namespace inspector {
 namespace chrome {
 
+using DebugSessionToken = int;
+
 /*
  * enableDebugging adds this runtime to the list of debuggable JS targets
- * (called "pages" in the higher-leavel React Native API) in this process. It
- * should be called before any JS runs in the runtime.
+ * (called "pages" in the higher-level React Native API) in this process. It
+ * should be called before any JS runs in the runtime. The returned token
+ * can be used to disable debugging for this runtime.
  */
-extern void enableDebugging(
+extern DebugSessionToken enableDebugging(
     std::unique_ptr<RuntimeAdapter> adapter,
     const std::string &title);
 
 /*
  * disableDebugging removes this runtime from the list of debuggable JS targets
- * in this process.
+ * in this process. The runtime to remove is identified by the token returned
+ * from enableDebugging.
  */
-extern void disableDebugging(jsi::Runtime &runtime);
+extern void disableDebugging(DebugSessionToken session);
 
 } // namespace chrome
 } // namespace inspector

package/ReactCommon/hermes/inspector/chrome/cli/main.cpp

@@ -213,9 +213,11 @@ static void runDebuggerLoop(
 
 static void runScript(const std::string &scriptSource, const std::string &url) {
   std::shared_ptr<fbhermes::HermesRuntime> runtime(
-      fbhermes::makeHermesRuntime());
-  auto adapter = std::make_unique<fbhermes::inspector::SharedRuntimeAdapter>(
-      runtime, runtime->getDebugger());
+      fbhermes::makeHermesRuntime(::hermes::vm::RuntimeConfig::Builder()
+                                      .withEnableSampleProfiling(true)
+                                      .build()));
+  auto adapter =
+      std::make_unique<fbhermes::inspector::SharedRuntimeAdapter>(runtime);
   fbhermes::inspector::chrome::Connection conn(
       std::move(adapter), "hermes-chrome-debug-server");
   std::thread debuggerLoop(runDebuggerLoop, std::ref(conn), scriptSource);

package/ReactCommon/hermes/inspector/chrome/tests/ConnectionDemuxTests.cpp

@@ -98,11 +98,9 @@ TEST(ConnectionDemuxTests, TestEnableDisable) {
   ConnectionDemux demux{*inspector};
 
   int id1 = demux.enableDebugging(
-      std::make_unique<SharedRuntimeAdapter>(runtime1, runtime1->getDebugger()),
-      "page1");
+      std::make_unique<SharedRuntimeAdapter>(runtime1), "page1");
   int id2 = demux.enableDebugging(
-      std::make_unique<SharedRuntimeAdapter>(runtime2, runtime2->getDebugger()),
-      "page2");
+      std::make_unique<SharedRuntimeAdapter>(runtime2), "page2");
 
   expectPages(*inspector, {{id1, "page1"}, {id2, "page2"}});
 
@@ -126,7 +124,7 @@ TEST(ConnectionDemuxTests, TestEnableDisable) {
 
   // Disable debugging on runtime2. This should remove its page from the list
   // and call onDisconnect on its remoteConn
-  demux.disableDebugging(*runtime2);
+  demux.disableDebugging(id2);
   expectPages(*inspector, {{id1, "page1"}});
   remoteData2->expectDisconnected();
 

package/ReactCommon/hermes/inspector/chrome/tests/ConnectionTests.cpp

@@ -2884,6 +2884,54 @@ TEST(ConnectionTests, testBasicProfilerOperation) {
   asyncRuntime.stop();
 }
 
+TEST(ConnectionTests, testGlobalLexicalScopeNames) {
+  TestContext context;
+  AsyncHermesRuntime &asyncRuntime = context.runtime();
+  SyncConnection &conn = context.conn();
+  int msgId = 1;
+  asyncRuntime.executeScriptAsync(R"(
+    let globalLet = "let";
+    const globalConst = "const";
+    var globalVar = "var";
+
+    let func1 = () => {
+      let local1 = 111;
+      func2();
+    }
+
+    function func2() {
+      let func3 = () => {
+        let local3 = 333;
+        debugger;
+      }
+
+      let local2 = 222;
+      func3();
+    }
+
+    func1();
+  )");
+  send<m::debugger::EnableRequest>(conn, msgId++);
+  expectExecutionContextCreated(conn);
+  expectNotification<m::debugger::ScriptParsedNotification>(conn);
+  expectNotification<m::debugger::PausedNotification>(conn);
+
+  m::runtime::GlobalLexicalScopeNamesRequest req;
+  req.id = msgId;
+  req.executionContextId = 1;
+  conn.send(req.toJson());
+
+  auto resp =
+      expectResponse<m::runtime::GlobalLexicalScopeNamesResponse>(conn, msgId);
+  EXPECT_EQ(resp.id, msgId++);
+  std::sort(resp.names.begin(), resp.names.end());
+  std::vector<std::string> expectedNames{"func1", "globalConst", "globalLet"};
+  EXPECT_EQ(resp.names, expectedNames);
+
+  send<m::debugger::ResumeRequest>(conn, msgId++);
+  expectNotification<m::debugger::ResumedNotification>(conn);
+}
+
 } // namespace chrome
 } // namespace inspector
 } // namespace hermes

package/ReactCommon/hermes/inspector/chrome/tests/SyncConnection.cpp

@@ -56,9 +56,7 @@ SyncConnection::SyncConnection(
     std::shared_ptr<HermesRuntime> runtime,
     bool waitForDebugger)
     : connection_(
-          std::make_unique<SharedRuntimeAdapter>(
-              runtime,
-              runtime->getDebugger()),
+          std::make_unique<SharedRuntimeAdapter>(runtime),
           "testConn",
           waitForDebugger) {
   connection_.connect(std::make_unique<RemoteConnnection>(*this));

package/ReactCommon/hermes/inspector/tests/InspectorTests.cpp

@@ -93,9 +93,7 @@ struct HermesDebugContext {
       folly::Future<Unit> &&finished)
       : runtime(makeHermesRuntime()),
         inspector(
-            std::make_shared<SharedRuntimeAdapter>(
-                runtime,
-                runtime->getDebugger()),
+            std::make_shared<SharedRuntimeAdapter>(runtime),
             observer,
             false),
         stopFlag(false),

package/ReactCommon/hermes/inspector/tools/message_types.txt

@@ -37,3 +37,5 @@ Runtime.executionContextCreated
 Runtime.getHeapUsage
 Runtime.getProperties
 Runtime.runIfWaitingForDebugger
+Runtime.globalLexicalScopeNames
+Runtime.compileScript

package/ReactCommon/hermes/inspector/tools/run_msggen

@@ -12,7 +12,7 @@ FBSOURCE=$(hg root)
 CLANG_FORMAT="${FBSOURCE}/tools/third-party/clang-format/clang-format"
 SIGNEDSOURCE="${FBSOURCE}/tools/signedsource"
 
-cd "${DIR}/msggen"
+pushd "../../../../packages/hermes-inspector-msggen"
 
 yarn install
 yarn build
@@ -28,3 +28,5 @@ node bin/index.js \
 
 "${SIGNEDSOURCE}" sign "${HEADER_PATH}"
 "${SIGNEDSOURCE}" sign "${CPP_PATH}"
+
+popd >/dev/null

package/ReactCommon/jserrorhandler/BUCK

@@ -0,0 +1,30 @@
+load("//tools/build_defs/oss:rn_defs.bzl", "ANDROID", "APPLE", "CXX", "react_native_xplat_target", "rn_xplat_cxx_library")
+
+# TODO: Expolre merging this module into venice so we don't to load this library seperately
+rn_xplat_cxx_library(
+    name = "jserrorhandler",
+    srcs = glob(["*.cpp"]),
+    header_namespace = "",
+    exported_headers = {"JsErrorHandler/JsErrorHandler.h": "JsErrorHandler.h"},
+    compiler_flags = [
+        "-fexceptions",
+        "-frtti",
+    ],
+    labels = [
+        "pfh:ReactNative_CommonInfrastructurePlaceholder",
+    ],
+    platforms = (ANDROID, APPLE, CXX),
+    preprocessor_flags = [
+        "-DLOG_TAG=\"ReactNative\"",
+        "-DWITH_FBSYSTRACE=1",
+    ],
+    visibility = [
+        "PUBLIC",
+    ],
+    deps = [
+        "//xplat/folly:dynamic",
+        "//xplat/folly:json",
+        "//xplat/jsi:jsi",
+        react_native_xplat_target("react/renderer/mapbuffer:mapbuffer"),
+    ],
+)

package/ReactCommon/jserrorhandler/JsErrorHandler.cpp

@@ -0,0 +1,107 @@
+/*
+ * 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 "JsErrorHandler.h"
+#include <react/renderer/mapbuffer/MapBufferBuilder.h>
+#include <regex>
+#include <sstream>
+#include <string>
+#include <vector>
+
+namespace facebook {
+namespace react {
+
+using facebook::react::JSErrorHandlerKey;
+
+static MapBuffer
+parseErrorStack(const jsi::JSError &error, bool isFatal, bool isHermes) {
+  /**
+   * This parses the different stack traces and puts them into one format
+   * This borrows heavily from TraceKit (https://github.com/occ/TraceKit)
+   * This is the same regex from stacktrace-parser.js.
+   */
+  const std::regex REGEX_CHROME(
+      R"(^\s*at (?:(?:(?:Anonymous function)?|((?:\[object object\])?\S+(?: \[as \S+\])?)) )?\(?((?:file|http|https):.*?):(\d+)(?::(\d+))?\)?\s*$)");
+  const std::regex REGEX_GECKO(
+      R"(^(?:\s*([^@]*)(?:\((.*?)\))?@)?(\S.*?):(\d+)(?::(\d+))?\s*$)");
+  const std::regex REGEX_NODE(
+      R"(^\s*at (?:((?:\[object object\])?\S+(?: \[as \S+\])?) )?\(?(.*?):(\d+)(?::(\d+))?\)?\s*$)");
+
+  // Capture groups for Hermes (from parseHermesStack.js):
+  // 1. function name
+  // 2. is this a native stack frame?
+  // 3. is this a bytecode address or a source location?
+  // 4. source URL (filename)
+  // 5. line number (1 based)
+  // 6. column number (1 based) or virtual offset (0 based)
+  const std::regex REGEX_HERMES(
+      R"(^ {4}at (.+?)(?: \((native)\)?| \((address at )?(.*?):(\d+):(\d+)\))$)");
+
+  std::string line;
+  std::stringstream strStream(error.getStack());
+
+  auto errorObj = MapBufferBuilder();
+  std::vector<MapBuffer> frames;
+
+  while (std::getline(strStream, line, '\n')) {
+    auto frame = MapBufferBuilder();
+    auto searchResults = std::smatch{};
+
+    if (isHermes) {
+      if (std::regex_search(line, searchResults, REGEX_HERMES)) {
+        std::string str2 = std::string(searchResults[2]);
+        if (str2.compare("native")) {
+          frame.putString(kFrameFileName, std::string(searchResults[4]));
+          frame.putString(kFrameMethodName, std::string(searchResults[1]));
+          frame.putInt(kFrameLineNumber, std::stoi(searchResults[5]));
+          frame.putInt(kFrameColumnNumber, std::stoi(searchResults[6]));
+          frames.push_back(frame.build());
+        }
+      }
+    } else {
+      if (std::regex_search(line, searchResults, REGEX_GECKO)) {
+        frame.putString(kFrameFileName, std::string(searchResults[3]));
+        frame.putString(kFrameMethodName, std::string(searchResults[1]));
+        frame.putInt(kFrameLineNumber, std::stoi(searchResults[4]));
+        frame.putInt(kFrameColumnNumber, std::stoi(searchResults[5]));
+      } else if (
+          std::regex_search(line, searchResults, REGEX_CHROME) ||
+          std::regex_search(line, searchResults, REGEX_NODE)) {
+        frame.putString(kFrameFileName, std::string(searchResults[2]));
+        frame.putString(kFrameMethodName, std::string(searchResults[1]));
+        frame.putInt(kFrameLineNumber, std::stoi(searchResults[3]));
+        frame.putInt(kFrameColumnNumber, std::stoi(searchResults[4]));
+      } else {
+        continue;
+      }
+      frames.push_back(frame.build());
+    }
+  }
+  errorObj.putMapBufferList(kAllStackFrames, std::move(frames));
+  errorObj.putString(kErrorMessage, "EarlyJsError: " + error.getMessage());
+  // TODO: If needed, can increment exceptionId by 1 each time
+  errorObj.putInt(kExceptionId, 0);
+  errorObj.putBool(kIsFatal, isFatal);
+  return errorObj.build();
+}
+
+JsErrorHandler::JsErrorHandler(
+    JsErrorHandler::JsErrorHandlingFunc jsErrorHandlingFunc) {
+  this->_jsErrorHandlingFunc = jsErrorHandlingFunc;
+};
+
+JsErrorHandler::~JsErrorHandler() {}
+
+void JsErrorHandler::handleJsError(const jsi::JSError &error, bool isFatal) {
+  // TODO: Current error parsing works and is stable. Can investigate using
+  // REGEX_HERMES to get additional Hermes data, though it requires JS setup.
+  MapBuffer errorMap = parseErrorStack(error, isFatal, false);
+  _jsErrorHandlingFunc(std::move(errorMap));
+}
+
+} // namespace react
+} // namespace facebook

package/ReactCommon/jserrorhandler/JsErrorHandler.h

@@ -0,0 +1,39 @@
+/*
+ * 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 <jsi/jsi.h>
+#include <react/renderer/mapbuffer/MapBuffer.h>
+
+namespace facebook {
+namespace react {
+
+enum JSErrorHandlerKey : uint16_t {
+  kFrameFileName = 0,
+  kFrameMethodName = 1,
+  kFrameLineNumber = 2,
+  kFrameColumnNumber = 3,
+  kAllStackFrames = 4,
+  kErrorMessage = 5,
+  kExceptionId = 6,
+  kIsFatal = 7
+};
+
+class JsErrorHandler {
+ public:
+  using JsErrorHandlingFunc = std::function<void(MapBuffer errorMap)>;
+
+  JsErrorHandler(JsErrorHandlingFunc jsErrorHandlingFunc);
+  ~JsErrorHandler();
+
+  void handleJsError(const jsi::JSError &error, bool isFatal);
+
+ private:
+  JsErrorHandlingFunc _jsErrorHandlingFunc;
+};
+
+} // namespace react
+} // namespace facebook

package/ReactCommon/jsi/BUCK

@@ -19,6 +19,7 @@ rn_xplat_cxx_library(
         "-Wdelete-non-virtual-dtor",
         "-Wwrite-strings",
     ],
+    compiler_flags_pedantic = True,
     cxx_compiler_flags = [
         "-Wglobal-constructors",
         "-Wmissing-prototypes",
@@ -29,7 +30,6 @@ rn_xplat_cxx_library(
     ],
     labels = [
         "pfh:ReactNative_CommonInfrastructurePlaceholder",
-        "supermodule:xplat/default/public.react_native.infra",
     ],
     visibility = ["PUBLIC"],
 )
@@ -43,17 +43,16 @@ rn_xplat_cxx_library(
     exported_headers = [
         "jsi/JSIDynamic.h",
     ],
+    compiler_flags_pedantic = True,
     fbobjc_force_static = True,
     labels = [
         "pfh:ReactNative_CommonInfrastructurePlaceholder",
-        "supermodule:xplat/default/public.react_native.infra",
     ],
     visibility = [
         "PUBLIC",
     ],
     xcode_public_headers_symlinks = True,
     deps = [
-        "//xplat/folly:molly",
         react_native_xplat_dep("jsi:jsi"),
     ],
 )
@@ -68,6 +67,7 @@ rn_xplat_cxx_library(
         "JSCRuntime.h",
     ],
     apple_sdks = (IOS, MACOSX),
+    compiler_flags_pedantic = True,
     fbobjc_compiler_flags = [
         "-Os",
     ],
@@ -76,7 +76,6 @@ rn_xplat_cxx_library(
     ],
     labels = [
         "pfh:ReactNative_CommonInfrastructurePlaceholder",
-        "supermodule:xplat/default/public.react_native.infra",
     ],
     platforms = APPLE,
     visibility = ["PUBLIC"],