@appsent-co/react-native-watchos 0.1.0

package/build/xcframework/Hermes.xcframework/watchos-arm64/hermes.framework/Headers/TracingRuntime.h

@@ -0,0 +1,315 @@
+/*
+ * 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.
+ */
+
+#ifndef HERMES_TRACINGRUNTIME_H
+#define HERMES_TRACINGRUNTIME_H
+
+#include "SynthTrace.h"
+
+#include <hermes/hermes.h>
+#include <jsi/decorator.h>
+#include "llvh/Support/raw_ostream.h"
+
+namespace facebook {
+namespace hermes {
+namespace tracing {
+
+class TracingRuntime : public jsi::RuntimeDecorator<jsi::Runtime> {
+ public:
+  using RD = RuntimeDecorator<jsi::Runtime>;
+
+  TracingRuntime(
+      std::shared_ptr<jsi::Runtime> runtime,
+      const ::hermes::vm::RuntimeConfig &conf,
+      std::unique_ptr<llvh::raw_ostream> traceStream);
+
+  /// Assign a new ObjectID for given jsi::Pointer.
+  SynthTrace::ObjectID defObjectID(const jsi::Pointer &p);
+  /// Get the ObjectID for given jsi::Pointer.
+  SynthTrace::ObjectID useObjectID(const jsi::Pointer &p) const;
+
+  virtual void flushAndDisableTrace() = 0;
+
+  /// @name jsi::Runtime methods.
+  /// @{
+
+  jsi::Value evaluateJavaScript(
+      const std::shared_ptr<const jsi::Buffer> &buffer,
+      const std::string &sourceURL) override;
+
+  void queueMicrotask(const jsi::Function &callback) override;
+  bool drainMicrotasks(int maxMicrotasksHint = -1) override;
+
+  jsi::Object global() override;
+
+  jsi::Object createObject() override;
+  jsi::Object createObjectWithPrototype(const jsi::Value &prototype) override;
+  jsi::Object createObject(std::shared_ptr<jsi::HostObject> ho) override;
+
+  // Note that the NativeState methods do not need to be traced since they
+  // cannot be observed in JS.
+
+  jsi::BigInt createBigIntFromInt64(int64_t value) override;
+  jsi::BigInt createBigIntFromUint64(uint64_t value) override;
+  jsi::String bigintToString(const jsi::BigInt &bigint, int radix) override;
+
+  jsi::String createStringFromAscii(const char *str, size_t length) override;
+  jsi::String createStringFromUtf8(const uint8_t *utf8, size_t length) override;
+  jsi::String createStringFromUtf16(const char16_t *utf16, size_t length)
+      override;
+  std::string utf8(const jsi::PropNameID &) override;
+
+  jsi::PropNameID createPropNameIDFromAscii(const char *str, size_t length)
+      override;
+  jsi::PropNameID createPropNameIDFromUtf8(const uint8_t *utf8, size_t length)
+      override;
+  jsi::PropNameID createPropNameIDFromUtf16(
+      const char16_t *utf16,
+      size_t length) override;
+  std::string utf8(const jsi::String &) override;
+
+  std::u16string utf16(const jsi::PropNameID &) override;
+  std::u16string utf16(const jsi::String &) override;
+
+  void getStringData(
+      const jsi::String &str,
+      void *ctx,
+      void (*cb)(void *ctx, bool ascii, const void *data, size_t num)) override;
+
+  void getPropNameIdData(
+      const jsi::PropNameID &sym,
+      void *ctx,
+      void (*cb)(void *ctx, bool ascii, const void *data, size_t num)) override;
+
+  std::string symbolToString(const jsi::Symbol &) override;
+
+  jsi::PropNameID createPropNameIDFromString(const jsi::String &str) override;
+  jsi::PropNameID createPropNameIDFromSymbol(const jsi::Symbol &sym) override;
+
+  jsi::Value getProperty(const jsi::Object &obj, const jsi::String &name)
+      override;
+  jsi::Value getProperty(const jsi::Object &obj, const jsi::PropNameID &name)
+      override;
+  jsi::Value getProperty(const jsi::Object &obj, const jsi::Value &name)
+      override;
+
+  bool hasProperty(const jsi::Object &obj, const jsi::String &name) override;
+  bool hasProperty(const jsi::Object &obj, const jsi::PropNameID &name)
+      override;
+  bool hasProperty(const jsi::Object &obj, const jsi::Value &name) override;
+
+  void setPropertyValue(
+      const jsi::Object &obj,
+      const jsi::String &name,
+      const jsi::Value &value) override;
+  void setPropertyValue(
+      const jsi::Object &obj,
+      const jsi::PropNameID &name,
+      const jsi::Value &value) override;
+  void setPropertyValue(
+      const jsi::Object &obj,
+      const jsi::Value &name,
+      const jsi::Value &value) override;
+
+  void deleteProperty(const jsi::Object &obj, const jsi::PropNameID &name)
+      override;
+  void deleteProperty(const jsi::Object &obj, const jsi::String &name) override;
+  void deleteProperty(const jsi::Object &, const jsi::Value &name) override;
+
+  void setPrototypeOf(const jsi::Object &object, const jsi::Value &prototype)
+      override;
+  jsi::Value getPrototypeOf(const jsi::Object &object) override;
+
+  jsi::Array getPropertyNames(const jsi::Object &o) override;
+
+  jsi::WeakObject createWeakObject(const jsi::Object &o) override;
+
+  jsi::Value lockWeakObject(const jsi::WeakObject &wo) override;
+
+  jsi::Array createArray(size_t length) override;
+  jsi::ArrayBuffer createArrayBuffer(
+      std::shared_ptr<jsi::MutableBuffer> buffer) override;
+
+  size_t size(const jsi::Array &arr) override;
+  size_t size(const jsi::ArrayBuffer &buf) override;
+
+  uint8_t *data(const jsi::ArrayBuffer &buf) override;
+
+  jsi::Value getValueAtIndex(const jsi::Array &arr, size_t i) override;
+
+  void setValueAtIndexImpl(
+      const jsi::Array &arr,
+      size_t i,
+      const jsi::Value &value) override;
+
+  jsi::Function createFunctionFromHostFunction(
+      const jsi::PropNameID &name,
+      unsigned int paramCount,
+      jsi::HostFunctionType func) override;
+
+  jsi::Value call(
+      const jsi::Function &func,
+      const jsi::Value &jsThis,
+      const jsi::Value *args,
+      size_t count) override;
+
+  jsi::Value callAsConstructor(
+      const jsi::Function &func,
+      const jsi::Value *args,
+      size_t count) override;
+
+  void setExternalMemoryPressure(const jsi::Object &obj, size_t amount)
+      override;
+
+  /// @}
+
+  void addMarker(const std::string &marker);
+
+  SynthTrace &trace() {
+    return trace_;
+  }
+
+  const SynthTrace &trace() const {
+    return trace_;
+  }
+
+  void replaceNondeterministicFuncs();
+
+  // This is the number of records recorded as part of the 'preamble' of a synth
+  // trace. This means all the records after this amount are from the actual
+  // execution of the trace.
+  uint32_t getNumPreambleRecordsForTest() const {
+    assert(
+        numPreambleRecords_ > 0 &&
+        "Only call this method if the preamble has been executed");
+    return numPreambleRecords_;
+  }
+
+ private:
+  SynthTrace::TraceValue defTraceValue(const jsi::Value &value) {
+    return toTraceValue(value, true);
+  }
+  SynthTrace::TraceValue useTraceValue(const jsi::Value &value) {
+    return toTraceValue(value, false);
+  }
+  SynthTrace::TraceValue toTraceValue(
+      const jsi::Value &value,
+      bool assignNewUID = false);
+
+  std::vector<SynthTrace::TraceValue> argStringifyer(
+      const jsi::Value *args,
+      size_t count,
+      bool assignNewUID = false);
+
+  SynthTrace::TimeSinceStart getTimeSinceStart() const;
+
+  std::shared_ptr<jsi::Runtime> runtime_;
+  SynthTrace trace_;
+  std::deque<jsi::Function> savedFunctions;
+  const SynthTrace::TimePoint startTime_{std::chrono::steady_clock::now()};
+  uint32_t numPreambleRecords_;
+
+  SynthTrace::ObjectID currentUniqueID_{0};
+
+  /// Map from PointerValue* to ObjectID. Except WeakRef case (see below), we
+  /// assign a new ObjectID whenever we see a new def of jsi::Pointer Value.
+  std::unordered_map<const jsi::Runtime::PointerValue *, SynthTrace::ObjectID>
+      uniqueIDs_;
+
+  /// WeakObject's PointerValue* to ObjectID mapping.
+  /// The key is the PointerValue of the WeakObject at the time of
+  /// it is created.
+  /// The value is newly assign ObjectID for that PointerValue.
+  std::unordered_map<const jsi::Runtime::PointerValue *, SynthTrace::ObjectID>
+      weakRefIDs_;
+};
+
+// TracingRuntime is *almost* vm independent.  This provides the
+// vm-specific bits.  And, it's not a HermesRuntime, but it holds one.
+class TracingHermesRuntime final : public TracingRuntime {
+ public:
+  /// This constructor is not intended to be invoked directly.
+  /// Use makeTracingHermesRuntime instead.
+  ///
+  /// \p traceStream  the stream to write trace to.
+  /// \p commitAction is invoked on completion of tracing.
+  /// Completion can be triggered implicitly by crash (if crash manager is
+  /// provided) or explicitly by invocation of flush. If the committed trace
+  /// can be found in a file, the callback returns the file name. Otherwise,
+  /// the callback returns empty.
+  /// \p rollbackAction is invoked if the runtime is destructed prior to
+  /// completion of tracing. It may or may not invoked if completion failed.
+  TracingHermesRuntime(
+      std::shared_ptr<HermesRuntime> runtime,
+      const ::hermes::vm::RuntimeConfig &runtimeConfig,
+      std::unique_ptr<llvh::raw_ostream> traceStream,
+      std::function<std::string()> commitAction,
+      std::function<void()> rollbackAction);
+
+  ~TracingHermesRuntime() override;
+
+  void flushAndDisableTrace() override;
+
+  std::string flushAndDisableBridgeTrafficTrace() override;
+
+  jsi::Value evaluateJavaScript(
+      const std::shared_ptr<const jsi::Buffer> &buffer,
+      const std::string &sourceURL) override;
+
+  HermesRuntime &hermesRuntime() {
+    return static_cast<HermesRuntime &>(plain());
+  }
+
+  const HermesRuntime &hermesRuntime() const {
+    return static_cast<const HermesRuntime &>(plain());
+  }
+
+ private:
+  void crashCallback(int fd);
+
+  const ::hermes::vm::RuntimeConfig conf_;
+  const std::function<std::string()> commitAction_;
+  const std::function<void()> rollbackAction_;
+  const llvh::Optional<::hermes::vm::CrashManager::CallbackKey>
+      crashCallbackKey_;
+
+  bool flushedAndDisabled_{false};
+  std::string committedTraceFilename_;
+};
+
+/// Creates and returns a HermesRuntime that traces JSI interactions.
+/// The trace will be written to \p traceScratchPath incrementally.
+/// On completion, the file will be renamed to \p traceResultPath, and
+/// \p traceCompletionCallback (for post-processing) will be invoked.
+/// Completion can be triggered implicitly by crash (if crash manager is
+/// provided) or explicitly by invocation of flush.
+/// If the runtime is destructed without triggering trace completion,
+/// the file at \p traceScratchPath will be deleted.
+/// The return value of \p traceCompletionCallback indicates whether the
+/// invocation completed successfully.
+std::unique_ptr<TracingHermesRuntime> makeTracingHermesRuntime(
+    std::shared_ptr<HermesRuntime> hermesRuntime,
+    const ::hermes::vm::RuntimeConfig &runtimeConfig,
+    const std::string &traceScratchPath,
+    const std::string &traceResultPath,
+    std::function<bool()> traceCompletionCallback);
+
+/// Creates and returns a HermesRuntime that traces JSI interactions.
+/// If \p traceStream is non-null, writes the trace to \p traceStream.
+/// The \p forReplay parameter indicates whether the runtime is being used
+/// in trace replay.  (Its behavior can differ slightly in that case.)
+std::unique_ptr<TracingHermesRuntime> makeTracingHermesRuntime(
+    std::shared_ptr<HermesRuntime> hermesRuntime,
+    const ::hermes::vm::RuntimeConfig &runtimeConfig,
+    std::unique_ptr<llvh::raw_ostream> traceStream,
+    bool forReplay = false);
+
+} // namespace tracing
+} // namespace hermes
+} // namespace facebook
+
+#endif // HERMES_TRACINGRUNTIME_H

package/build/xcframework/Hermes.xcframework/watchos-arm64/hermes.framework/Headers/hermes.h

@@ -0,0 +1,211 @@
+/*
+ * 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.
+ */
+
+#ifndef HERMES_HERMES_H
+#define HERMES_HERMES_H
+
+#include <exception>
+#include <list>
+#include <map>
+#include <memory>
+#include <ostream>
+#include <string>
+
+#include <hermes/Public/HermesExport.h>
+#include <hermes/Public/RuntimeConfig.h>
+#include <hermes/Public/SamplingProfiler.h>
+#include <jsi/hermes-interfaces.h>
+#include <jsi/jsi.h>
+#include <unordered_map>
+
+struct HermesTestHelper;
+struct SHUnit;
+struct SHRuntime;
+
+namespace hermes {
+namespace vm {
+class GCExecTrace;
+class Runtime;
+} // namespace vm
+} // namespace hermes
+
+namespace facebook {
+namespace jsi {
+
+class ThreadSafeRuntime;
+
+}
+
+namespace hermes {
+
+namespace debugger {
+class Debugger;
+}
+
+class HermesRuntime;
+/// The Hermes Root API interface. This is the entry point to create the Hermes
+/// runtime and to access Hermes-specific methods that do not rely on a runtime
+/// instance.
+class HERMES_EXPORT IHermesRootAPI : public jsi::ICast {
+ public:
+  static constexpr jsi::UUID uuid{
+      0xb654d898,
+      0xdfad,
+      0x11ef,
+      0x859a,
+      0x325096b39f47};
+
+  // Returns an instance of Hermes Runtime.
+  virtual std::unique_ptr<HermesRuntime> makeHermesRuntime(
+      const ::hermes::vm::RuntimeConfig &runtimeConfig) = 0;
+
+  virtual bool isHermesBytecode(const uint8_t *data, size_t len) = 0;
+
+  // Returns the supported bytecode version.
+  virtual uint32_t getBytecodeVersion() = 0;
+
+  // (EXPERIMENTAL) Issues madvise calls for portions of the given
+  // bytecode file that will likely be used when loading the bytecode
+  // file and running its global function.
+  virtual void prefetchHermesBytecode(const uint8_t *data, size_t len) = 0;
+
+  // Returns whether the data is valid HBC with more extensive checks than
+  // isHermesBytecode and returns why it isn't in errorMessage (if nonnull)
+  // if not.
+  virtual bool hermesBytecodeSanityCheck(
+      const uint8_t *data,
+      size_t len,
+      std::string *errorMessage = nullptr) = 0;
+
+  /// Sets a global fatal handler that is shared across all active Hermes
+  /// runtimes. Setting fatal handler in multiple places will override the
+  /// previous fatal handler set by this functionality.
+  /// The fatal handler must not throw exceptions, as Hermes is compiled without
+  /// exceptions.
+  virtual void setFatalHandler(void (*handler)(const std::string &)) = 0;
+
+  // Assuming that \p data is valid HBC bytecode data, returns a pointer to the
+  // first element of the epilogue, data append to the end of the bytecode
+  // stream. Return pair contain ptr to data and header.
+  virtual std::pair<const uint8_t *, size_t> getBytecodeEpilogue(
+      const uint8_t *data,
+      size_t len) = 0;
+
+  /// Enable sampling profiler.
+  /// Starts a separate thread that polls VM state with \p meanHzFreq frequency.
+  /// Any subsequent call to \c enableSamplingProfiler() is ignored until
+  /// next call to \c disableSamplingProfiler()
+  virtual void enableSamplingProfiler(double meanHzFreq = 100) = 0;
+
+  /// Disable the sampling profiler
+  virtual void disableSamplingProfiler() = 0;
+
+  /// Dump sampled stack trace to the given file name.
+  virtual void dumpSampledTraceToFile(const std::string &fileName) = 0;
+
+  /// Dump sampled stack trace to the given stream.
+  virtual void dumpSampledTraceToStream(std::ostream &stream) = 0;
+
+  /// Return the executed JavaScript function info.
+  /// This information holds the segmentID, Virtualoffset and sourceURL.
+  /// This information is needed specifically to be able to symbolicate non-CJS
+  /// bundles correctly. This API will be simplified later to simply return a
+  /// segmentID and virtualOffset, when we are able to only support CJS bundles.
+  virtual std::unordered_map<std::string, std::vector<std::string>>
+  getExecutedFunctions() = 0;
+
+  /// \return whether code coverage profiler is enabled or not.
+  virtual bool isCodeCoverageProfilerEnabled() = 0;
+
+  /// Enable code coverage profiler.
+  virtual void enableCodeCoverageProfiler() = 0;
+
+  /// Disable code coverage profiler.
+  virtual void disableCodeCoverageProfiler() = 0;
+
+ protected:
+  /// The destructor is protected as delete calls on interfaces must not occur.
+  /// It is also non-virtual to simplify the v-table.
+  ~IHermesRootAPI() {}
+};
+
+/// The setFatalHandler functionality has global effects, which may cause
+/// unintended or surprising behavior for users of this API. For this reason, it
+/// is not recommended and the functionality is provided by the optional
+/// interface ISetFatalHandler.
+class HERMES_EXPORT ISetFatalHandler : public jsi::ICast {
+ public:
+  static constexpr jsi::UUID uuid{
+      0xda98a610,
+      0x09cb,
+      0x11f0,
+      0x87bf,
+      0x325096b39f47};
+  /// Sets a global fatal handler that is shared across all active Hermes
+  /// runtimes. Setting fatal handler in multiple places will override the
+  /// previous fatal handler set by this functionality.
+  /// The fatal handler must not throw exceptions, as Hermes is compiled without
+  /// exceptions.
+  virtual void setFatalHandler(void (*handler)(const std::string &)) = 0;
+
+ protected:
+  ~ISetFatalHandler() = default;
+};
+
+/// Interface for methods that are exposed for test purposes.
+class HERMES_EXPORT IHermesTestHelpers : public jsi::ICast {
+ public:
+  static constexpr jsi::UUID uuid{
+      0x664e489a,
+      0xf941,
+      0x11ef,
+      0xa44c,
+      0x325096b39f47};
+
+  virtual size_t rootsListLengthForTests() const = 0;
+
+ protected:
+  ~IHermesTestHelpers() = default;
+};
+
+class HermesRuntime : public jsi::Runtime, public IHermes {
+ public:
+  /// Similar to jsi::Runtime, HermesRuntime is treated as an object, rather
+  /// than a pure interface. This is to prevent breaking usages of
+  /// HermesRuntime prior to the introduction of jsi::IRuntime, IHermes, and
+  /// other interfaces.
+  ~HermesRuntime() override = default;
+
+  using jsi::Runtime::castInterface;
+};
+
+/// Returns a pointer to an object that can be cast into IHermesRootAPI, which
+/// can be used to create a Hermes runtime and to access global Hermes-specific
+/// methods. This object has static lifetime.
+HERMES_EXPORT jsi::ICast *makeHermesRootAPI();
+
+/// Return a RuntimeConfig that is more suited for running untrusted JS than
+/// the default config. Disables some language features and may trade off some
+/// performance for security.
+///
+/// Can serve as a starting point with tweaks to re-enable needed features:
+///   auto conf = hardenedHermesRuntimeConfig().rebuild();
+///   ...
+///   auto runtime = makeHermesRuntime(conf.build());
+HERMES_EXPORT ::hermes::vm::RuntimeConfig hardenedHermesRuntimeConfig();
+
+HERMES_EXPORT std::unique_ptr<HermesRuntime> makeHermesRuntime(
+    const ::hermes::vm::RuntimeConfig &runtimeConfig =
+        ::hermes::vm::RuntimeConfig());
+HERMES_EXPORT std::unique_ptr<jsi::ThreadSafeRuntime>
+makeThreadSafeHermesRuntime(
+    const ::hermes::vm::RuntimeConfig &runtimeConfig =
+        ::hermes::vm::RuntimeConfig());
+} // namespace hermes
+} // namespace facebook
+
+#endif

package/build/xcframework/Hermes.xcframework/watchos-arm64/hermes.framework/Headers/hermes_tracing.h

@@ -0,0 +1,55 @@
+/*
+ * 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.
+ */
+
+#ifndef HERMES_HERMES_TRACING_H
+#define HERMES_HERMES_TRACING_H
+
+#include <hermes/hermes.h>
+
+namespace llvh {
+class raw_ostream;
+} // namespace llvh
+
+namespace facebook {
+namespace hermes {
+
+/// Creates and returns a tracing runtime if \p runtimeConfig.SynthTraceMode is
+/// either SynthTraceMode::Tracing or SynthTraceMode::TracingAndReplaying.
+/// Otherwise, returns the passed \n hermesRuntime as is.
+/// The trace will be written to \p traceScratchPath incrementally.
+/// On completion, the file will be renamed to \p traceResultPath, and
+/// \p traceCompletionCallback (for post-processing) will be invoked.
+/// Completion can be triggered implicitly by crash (if crash manager is
+/// provided) or explicitly by invocation of flush.
+/// If the runtime is destructed without triggering trace completion,
+/// the file at \p traceScratchPath will be deleted.
+/// The return value of \p traceCompletionCallback indicates whether the
+/// invocation completed successfully. If \p traceCompletionCallback is null, it
+/// also assumes as if the callback is successful.
+std::shared_ptr<jsi::Runtime> makeTracingHermesRuntime(
+    std::shared_ptr<HermesRuntime> hermesRuntime,
+    const ::hermes::vm::RuntimeConfig &runtimeConfig,
+    const std::string &traceScratchPath,
+    const std::string &traceResultPath,
+    std::function<bool()> traceCompletionCallback);
+
+/// Creates and returns a tracing runtime that wrapps the passed
+/// \p hermesRuntime. This API is mainly for Synth Trace replay (and tracing),
+/// and for testing.
+/// \p traceStream  the stream to write trace to.
+/// \p forReplay indicates whether the runtime is being used in trace replay and
+/// tracing.
+std::shared_ptr<jsi::Runtime> makeTracingHermesRuntime(
+    std::shared_ptr<HermesRuntime> hermesRuntime,
+    const ::hermes::vm::RuntimeConfig &runtimeConfig,
+    std::unique_ptr<llvh::raw_ostream> traceStream,
+    bool forReplay = false);
+
+} // namespace hermes
+} // namespace facebook
+
+#endif

package/build/xcframework/Hermes.xcframework/watchos-arm64/hermes.framework/Info.plist

@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>CFBundleDevelopmentRegion</key>
+	<string>English</string>
+	<key>CFBundleExecutable</key>
+	<string>hermes</string>
+	<key>CFBundleIconFile</key>
+	<string></string>
+	<key>CFBundleIdentifier</key>
+	<string>dev.hermesengine.watchos</string>
+	<key>CFBundleInfoDictionaryVersion</key>
+	<string>6.0</string>
+	<key>CFBundleName</key>
+	<string></string>
+	<key>CFBundlePackageType</key>
+	<string>FMWK</string>
+	<key>CFBundleSignature</key>
+	<string>????</string>
+	<key>CFBundleVersion</key>
+	<string>0.12.0</string>
+	<key>CFBundleShortVersionString</key>
+	<string>0.12.0</string>
+	<key>CSResourcesFileMapped</key>
+	<true/>
+</dict>
+</plist>