@dittolive/ditto 4.6.0 → 4.7.0-rc.3

package/react-native/cpp/src/ConnectionRequest.cpp

@@ -0,0 +1,123 @@
+#include "Utils.h"
+#include "ConnectionRequest.h"
+#include <unordered_map>
+
+namespace sharedjsi
+{
+
+Function dittoffi_connection_request_peer_key_string(Runtime &runtime)
+{
+  return Function::createFromHostFunction(runtime,
+                                          PropNameID::forAscii(runtime,
+                                                               STRINGIFIED_FUNC_NAME()),
+                                          0,
+                                          [](Runtime &runtime,
+                                             const Value &thisValue,
+                                             const Value *arguments,
+                                             size_t count) -> Value
+                                          {
+    auto connection_request = jsPointerObjectToCPointer<dittoffi_connection_request_t>(runtime, arguments[0]);
+    char *res = ::dittoffi_connection_request_peer_key_string(connection_request);
+    return cPointerToJSPointerObject<char>(runtime, res);
+  });
+}
+
+Function dittoffi_connection_request_peer_metadata_json(Runtime &runtime)
+{
+  return Function::createFromHostFunction(runtime,
+                                          PropNameID::forAscii(runtime,
+                                                               STRINGIFIED_FUNC_NAME()),
+                                          0,
+                                          [](Runtime &runtime,
+                                             const Value &thisValue,
+                                             const Value *arguments,
+                                             size_t count) -> Value
+                                          {
+    auto connection_request = jsPointerObjectToCPointer<dittoffi_connection_request_t>(runtime, arguments[0]);
+    slice_ref_uint8_t res = ::dittoffi_connection_request_peer_metadata_json(connection_request);
+    return cSlicedBoxToJSSlicedBox(runtime, res);
+
+  });
+}
+
+Function dittoffi_connection_request_identity_service_json(Runtime &runtime)
+{
+  return Function::createFromHostFunction(runtime,
+                                          PropNameID::forAscii(runtime,
+                                                               STRINGIFIED_FUNC_NAME()),
+                                          0,
+                                          [](Runtime &runtime,
+                                             const Value &thisValue,
+                                             const Value *arguments,
+                                             size_t count) -> Value
+                                          {
+    auto connection_request = jsPointerObjectToCPointer<dittoffi_connection_request_t>(runtime, arguments[0]);
+    slice_ref_uint8_t res = ::dittoffi_connection_request_identity_service_metadata_json(connection_request);
+    return cSlicedBoxToJSSlicedBox(runtime, res);
+  });
+}
+
+Function dittoffi_connection_request_authorize(Runtime &runtime)
+{
+  return Function::createFromHostFunction(runtime,
+                                          PropNameID::forAscii(runtime,
+                                                               STRINGIFIED_FUNC_NAME()),
+                                          0,
+                                          [](Runtime &runtime,
+                                             const Value &thisValue,
+                                             const Value *arguments,
+                                             size_t count) -> Value
+                                          {
+    auto connection_request = jsPointerObjectToCPointer<dittoffi_connection_request_t>(runtime, arguments[0]);
+    auto authorized_string = arguments[1].toString(runtime).utf8(runtime);
+    auto authorized = authorized_string == "Allow" ? DITTOFFI_CONNECTION_REQUEST_AUTHORIZATION_ALLOW : DITTOFFI_CONNECTION_REQUEST_AUTHORIZATION_DENY;
+
+    ::dittoffi_connection_request_authorize(connection_request, authorized);
+    return Value();
+  });
+}
+
+Function dittoffi_connection_request_connection_type(Runtime &runtime)
+{
+  return Function::createFromHostFunction(runtime,
+                                          PropNameID::forAscii(runtime,
+                                                               STRINGIFIED_FUNC_NAME()),
+                                          0,
+                                          [](Runtime &runtime,
+                                             const Value &thisValue,
+                                             const Value *arguments,
+                                             size_t count) -> Value
+                                          {
+    dittoffi_connection_type_t res = ::dittoffi_connection_request_connection_type(jsPointerObjectToCPointer<dittoffi_connection_request_t>(runtime, arguments[0]));
+    
+    static const std::unordered_map<dittoffi_connection_type_t, std::string> lookup = {
+      {DITTOFFI_CONNECTION_TYPE_BLUETOOTH, "Bluetooth"},
+      {DITTOFFI_CONNECTION_TYPE_ACCESS_POINT, "AccessPoint"},
+      {DITTOFFI_CONNECTION_TYPE_P2_P_WI_FI, "P2PWiFi"},
+      {DITTOFFI_CONNECTION_TYPE_WEB_SOCKET, "WebSocket"},
+    };
+    auto it = lookup.find(res);
+    if (it != lookup.end()) {
+      return String::createFromUtf8(runtime, it->second);
+    } else {
+      throw std::invalid_argument("Invalid dittoffi_connection_type_t type");
+    }
+  });
+}
+
+Function dittoffi_connection_request_free(Runtime &runtime)
+{
+  return Function::createFromHostFunction(runtime,
+                                          PropNameID::forAscii(runtime,
+                                                               STRINGIFIED_FUNC_NAME()),
+                                          0,
+                                          [](Runtime &runtime,
+                                             const Value &thisValue,
+                                             const Value *arguments,
+                                             size_t count) -> Value
+                                          {
+    ::dittoffi_connection_request_free(jsPointerObjectToCPointer<dittoffi_connection_request_t>(runtime, arguments[0]));
+    return Value();
+  });
+}
+}

package/react-native/cpp/src/DQL.cpp

@@ -147,7 +147,7 @@ Function dittoffi_try_experimental_register_change_observer_str_detached(Runtime
                                                                                            v_change_handler_with_query_result);
 
     Object obj(runtime);
-    obj.setProperty(runtime, "success", BigInt::fromInt64(runtime, res.success));
+    obj.setProperty(runtime, "success", int64ToBigIntOrNumber(runtime, res.success));
     obj.setProperty(runtime, "error", cPointerToJSPointerObject(runtime, res.error));
     return obj;
   });

package/react-native/cpp/src/FFIUtils.cpp

@@ -15,6 +15,12 @@ Function refCStringToString(Runtime &runtime)
                                              const Value *arguments,
                                              size_t count) -> Value
                                           {
+    char *str = jsPointerObjectToCPointer<char>(runtime, arguments[0]);
+    if (str) {
+      return String::createFromUtf8(runtime, str);
+    } else {
+      return Value::null();
+    }
     return String::createFromUtf8(runtime, jsPointerObjectToCPointer<char>(runtime, arguments[0]));
   });
 }
@@ -40,6 +46,58 @@ Function boxCStringIntoString(Runtime &runtime) {
   });
 }
 
+Function sliceRefToUInt8Array(Runtime &runtime) {
+  return Function::createFromHostFunction(runtime,
+                                          PropNameID::forAscii(runtime, STRINGIFIED_FUNC_NAME()),
+                                          0,
+                                          [](Runtime &runtime,
+                                             const Value &,
+                                             const Value *arguments,
+                                             size_t) -> Value {
+    auto fatPtrJs = arguments[0].asObject(runtime);
+    auto ptr = jsPointerObjectToCPointer<uint8_t>(runtime, fatPtrJs.getProperty(runtime, "ptr"));
+    auto len = static_cast<size_t>(fatPtrJs.getProperty(runtime, "len").asNumber());
+
+    slice_boxed_uint8 slice = {.ptr = ptr, .len = len};
+    if (!slice.ptr) {
+      return Value::null();
+    }
+
+    TypedArray<TypedArrayKind::Uint8Array> typedArray(runtime, slice.len);
+    ArrayBuffer arrayBuffer = typedArray.getBuffer(runtime);
+    std::memcpy(arrayBuffer.data(runtime), slice.ptr, slice.len);
+
+    return typedArray;
+  });
+}
+
+Function sliceBoxedToUInt8Array(Runtime &runtime) {
+  return Function::createFromHostFunction(runtime,
+                                          PropNameID::forAscii(runtime, STRINGIFIED_FUNC_NAME()),
+                                          0,
+                                          [](Runtime &runtime,
+                                             const Value &,
+                                             const Value *arguments,
+                                             size_t) -> Value {
+    auto fatPtrJs = arguments[0].asObject(runtime);
+    auto ptr = jsPointerObjectToCPointer<uint8_t>(runtime, fatPtrJs.getProperty(runtime, "ptr"));
+    auto len = static_cast<size_t>(fatPtrJs.getProperty(runtime, "len").asNumber());
+
+    slice_boxed_uint8 slice = {.ptr = ptr, .len = len};
+    if (!slice.ptr) {
+      return Value::null();
+    }
+
+    TypedArray<TypedArrayKind::Uint8Array> typedArray(runtime, slice.len);
+    ArrayBuffer arrayBuffer = typedArray.getBuffer(runtime);
+    std::memcpy(arrayBuffer.data(runtime), slice.ptr, slice.len);
+
+    ::ditto_c_bytes_free(slice);
+
+    return typedArray;
+  });
+}
+
 Function withOutBoxCBytes(Runtime &runtime) {
   return Function::createFromHostFunction(runtime,
                                           PropNameID::forAscii(runtime,

package/react-native/cpp/src/Identity.cpp

@@ -49,7 +49,7 @@ Function ditto_identity_config_make_offline_playground(Runtime &runtime)
                                           {
     std::string app_id_str = jsTypedArrayToCString(runtime, arguments[0]);
     const char *app_id = app_id_str.c_str();
-    uint64_t site_id = arguments[1].asBigInt(runtime).asUint64(runtime);
+    uint64_t site_id = bigIntOrNumberToUint64(runtime, arguments[1]);
 
     IdentityConfigResult_t config_result = ::ditto_identity_config_make_offline_playground(app_id, site_id);
     return convertConfigResultToJSIObject(runtime, config_result);
@@ -91,8 +91,7 @@ Function ditto_identity_config_make_shared_key(Runtime &runtime)
 
     std::string shared_key_str = jsTypedArrayToCString(runtime, arguments[1]);
     const char *shared_key = shared_key_str.c_str();
-
-    uint64_t site_id = arguments[2].asBigInt(runtime).asUint64(runtime);
+    uint64_t site_id = bigIntOrNumberToUint64(runtime, arguments[2]);
 
     IdentityConfigResult_t config_result = ::ditto_identity_config_make_shared_key(app_id, shared_key, site_id);
     return convertConfigResultToJSIObject(runtime, config_result);

package/react-native/cpp/src/LiveQuery.cpp

@@ -17,7 +17,7 @@ Function ditto_live_query_signal_available_next(Runtime &runtime)
                                              size_t count) -> Value
                                           {
     CDitto_t *ditto = jsPointerObjectToCPointer<CDitto_t>(runtime, arguments[0]);
-    int64_t liveQueryId = arguments[1].asBigInt(runtime).asInt64(runtime);
+    int64_t liveQueryId = bigIntOrNumberToInt64(runtime, arguments[1]);
 
     ::ditto_live_query_signal_available_next(ditto, liveQueryId);
     return Value();
@@ -36,7 +36,7 @@ Function ditto_live_query_start(Runtime &runtime)
                                              size_t count) -> Value
                                           {
     CDitto_t *ditto = jsPointerObjectToCPointer<CDitto_t>(runtime, arguments[0]);
-    int64_t liveQueryId = arguments[1].asBigInt(runtime).asInt64(runtime);
+    int64_t liveQueryId = bigIntOrNumberToInt64(runtime, arguments[1]);
     int32_t res = ::ditto_live_query_start(ditto, liveQueryId);
     return static_cast<double>(res);
   });
@@ -54,7 +54,7 @@ Function ditto_live_query_stop(Runtime &runtime)
                                              size_t count) -> Value
                                           {
     CDitto_t *ditto = jsPointerObjectToCPointer<CDitto_t>(runtime, arguments[0]);
-    int64_t liveQueryId = arguments[1].asBigInt(runtime).asInt64(runtime);
+    int64_t liveQueryId = bigIntOrNumberToInt64(runtime, arguments[1]);
 
     ::ditto_live_query_stop(ditto, liveQueryId);
     return Value();

package/react-native/cpp/src/Misc.cpp

@@ -73,13 +73,22 @@ Function dittoffi_error_code(Runtime &runtime) {
       {DITTOFFI_ERROR_CODE_DQL_QUERY_COMPILATION, "DqlQueryCompilation"},
       {DITTOFFI_ERROR_CODE_DQL_INVALID_QUERY_ARGS, "DqlInvalidQueryArgs"},
       {DITTOFFI_ERROR_CODE_DQL_UNSUPPORTED, "DqlUnsupported"},
+      {DITTOFFI_ERROR_CODE_VALIDATION_DEPTH_LIMIT_EXCEEDED, "ValidationDepthLimitExceeded"},
+      {DITTOFFI_ERROR_CODE_VALIDATION_NOT_A_MAP, "ValidationNotAMap"},
+      {DITTOFFI_ERROR_CODE_VALIDATION_SIZE_LIMIT_EXCEEDED, "ValidationSizeLimitExceeded"},
+      {DITTOFFI_ERROR_CODE_CBOR_INVALID, "ValidationInvalidCbor"},
+      {DITTOFFI_ERROR_CODE_VALIDATION_INVALID_JSON, "ValidationInvalidJson"},
+      {DITTOFFI_ERROR_CODE_ACTIVATION_NOT_ACTIVATED, "ActivationNotActivated"},
+      {DITTOFFI_ERROR_CODE_ACTIVATION_LICENSE_TOKEN_INVALID, "ActivationLicenseTokenInvalid"},
+      {DITTOFFI_ERROR_CODE_ACTIVATION_LICENSE_TOKEN_EXPIRED, "ActivationLicenseTokenExpired"},
+      {DITTOFFI_ERROR_CODE_ACTIVATION_LICENSE_UNSUPPORTED_FUTURE_VERSION, "ActivationLicenseUnsupportedFutureVersion"},
     };
 
     auto it = lookup.find(error_code);
     if (it != lookup.end()) {
       return String::createFromUtf8(runtime, it->second);
     } else {
-      throw std::invalid_argument("Invalid error code");
+      throw std::invalid_argument("Unknown error code.");
     }
   });
 }
@@ -159,7 +168,7 @@ Function dittoffi_get_sdk_semver(Runtime &runtime) {
   });
 }
 
-Function ditto_verify_license(Runtime &runtime) {
+Function dittoffi_try_verify_license(Runtime &runtime) {
   return Function::createFromHostFunction(runtime,
                                           PropNameID::forAscii(runtime,
                                                                STRINGIFIED_FUNC_NAME()),
@@ -169,29 +178,11 @@ Function ditto_verify_license(Runtime &runtime) {
                                              const Value *arguments,
                                              size_t count) -> Value
                                           {
-    std::string license = arguments[0].toString(runtime).utf8(runtime);
-    char **out_err_msg = NULL;
-    LicenseVerificationResult_t res = ::ditto_verify_license(license.c_str(), out_err_msg);
-
-    std::string result;
-    switch (res) {
-      case LICENSE_VERIFICATION_RESULT_LICENSE_OK:
-        result = "LicenseOk";
-        break;
-      case LICENSE_VERIFICATION_RESULT_VERIFICATION_FAILED:
-        result = "VerificationFailed";
-        break;
-      case LICENSE_VERIFICATION_RESULT_LICENSE_EXPIRED:
-        result = "LicenseExpired";
-        break;
-      case LICENSE_VERIFICATION_RESULT_UNSUPPORTED_FUTURE_VERSION:
-        result = "UnsupportedFutureVersion";
-        break;
-    }
+    std::string license = jsTypedArrayToCString(runtime, arguments[0]);
+    dittoffi_result_void_t res = ::dittoffi_try_verify_license(license.c_str());
 
     Object obj(runtime);
-    obj.setProperty(runtime, "result", String::createFromUtf8(runtime, result));
-    obj.setProperty(runtime, "errorMessage", String::createFromUtf8(runtime, *out_err_msg));
+    obj.setProperty(runtime, "error", cPointerToJSPointerObject(runtime, res.error));
     return obj;
   });
 }

package/react-native/cpp/src/Presence.cpp

@@ -7,6 +7,8 @@ namespace sharedjsi
 {
 
 DEFINE_RETAIN_RELEASE_FOR(Function, v_retain, v_release);
+DEFINE_RETAIN_RELEASE_ERASED_T_FOR(Function, retain_vptr, release_vptr);
+
 extern "C"
 {
 void v_presence_callback(void *ctx, char const *str)
@@ -18,6 +20,20 @@ void v_presence_callback(void *ctx, char const *str)
     jsCallback->call(runtime, cPointerToJSPointerObject<char>(runtime, cpp_string.c_str()));
   });
 }
+
+
+void v_connection_handler(Erased_t const* ctx, dittoffi_connection_request *ffi_request)
+{
+  auto ptr = (void *)(ctx);
+  Arc<Function>& borrowedJsCallback = Arc<Function>::borrow_from_raw(ptr);
+  // copy ctor / retain so as to keep the ArcPointee<Function> alive until the enqueued_call completes.
+  Arc<Function> jsCallback /* = */ (borrowedJsCallback);
+  ditto_enqueue_call([=](Runtime *jsi) {
+    Runtime &runtime = *jsi;
+    auto obj = cPointerToJSPointerObject<dittoffi_connection_request_t>(runtime, ffi_request);
+    jsCallback->call(runtime, obj);
+  });
+}
 }
 
 Function ditto_presence_v3(Runtime &runtime)
@@ -76,4 +92,75 @@ Function ditto_clear_presence_v3_callback(Runtime &runtime)
   });
 }
 
+Function dittoffi_presence_peer_metadata_json(Runtime &runtime)
+{
+  return Function::createFromHostFunction(runtime,
+                                          PropNameID::forAscii(runtime,
+                                                               STRINGIFIED_FUNC_NAME()),
+                                          0,
+                                          [](Runtime &runtime,
+                                             const Value &thisValue,
+                                             const Value *arguments,
+                                             size_t count) -> Value
+                                          {
+    slice_boxed_uint8_t res = ::dittoffi_presence_peer_metadata_json(jsPointerObjectToCPointer<CDitto_t>(runtime, arguments[0]));
+    return cSlicedBoxToJSSlicedBox(runtime, res);
+
+  });
+}
+
+Function dittoffi_presence_try_set_peer_metadata_json(Runtime &runtime)
+{
+  return Function::createFromHostFunction(runtime,
+                                          PropNameID::forAscii(runtime,
+                                                               STRINGIFIED_FUNC_NAME()),
+                                          0,
+                                          [](Runtime &runtime,
+                                             const Value &thisValue,
+                                             const Value *arguments,
+                                             size_t count) -> Value
+                                          {
+    CDitto_t *ditto = jsPointerObjectToCPointer<CDitto_t>(runtime, arguments[0]);
+
+    TypedArrayBase typedArrayBase(runtime, arguments[1].asObject(runtime));
+    std::vector<uint8_t> peer_info_vec = typedArrayBase.toVector(runtime);
+    slice_ref_uint8_t peer_info = { .ptr = peer_info_vec.data(), .len = peer_info_vec.size() };
+
+    dittoffi_result_void_t res = ::dittoffi_presence_try_set_peer_metadata_json(ditto, peer_info);
+
+    Object obj(runtime);
+    obj.setProperty(runtime, "error", cPointerToJSPointerObject(runtime, res.error));
+    return obj;
+  });
+}
+
+
+Function dittoffi_presence_set_connection_request_handler(Runtime &runtime)
+{
+  return Function::createFromHostFunction(runtime,
+                                          PropNameID::forAscii(runtime,
+                                                               STRINGIFIED_FUNC_NAME()),
+                                          0,
+                                          [](Runtime &runtime,
+                                             const Value &thisValue,
+                                             const Value *arguments,
+                                             size_t count) -> Value
+                                          {
+    CDitto_t *ditto = jsPointerObjectToCPointer<CDitto_t>(runtime, arguments[0]);
+
+    Function jsCallback = arguments[1].getObject(runtime).getFunction(runtime);
+    Arc<Function> wrappedStateFfiWrapper(std::move(jsCallback));
+
+    ::dittoffi_presence_set_connection_request_handler(ditto, {
+      .ptr = (Erased_t *)Arc<Function>::into_raw(std::move(wrappedStateFfiWrapper)),
+      .vtable = {
+        .retain_vptr = retain_vptr,
+        .release_vptr = release_vptr,
+        .on_connecting = v_connection_handler,
+      },
+    });
+    return Value();
+  });
+}
+
 }

package/react-native/cpp/src/Utils.cpp

@@ -8,127 +8,132 @@
 namespace sharedjsi
 {
 
-  std::string pointerToHexString(void const *ptr)
-  {
-    char buffer[20]; // Assuming a 64-bit pointer, 16 characters for address + 2 for "0x" + 1 for null-terminator.
-    snprintf(buffer, sizeof(buffer), "%p", ptr);
-    return std::string(buffer);
-  }
+std::string pointerToHexString(void const *ptr)
+{
+  char buffer[20]; // Assuming a 64-bit pointer, 16 characters for address + 2 for "0x" + 1 for null-terminator.
+  snprintf(buffer, sizeof(buffer), "%p", ptr);
+  return std::string(buffer);
+}
 
-  // To be used with `Option<slice_ref_uint8_t> (check Rust Core API)
-  slice_ref_uint8_t borrowVecAsOptRefSlice(std::vector<uint8_t> const &v)
-  {
-    slice_ref_uint8_t it{};
-    it.ptr = v.empty() ? nullptr : v.data();
-    it.len = v.size();
-    return it;
-  }
+// To be used with `Option<slice_ref_uint8_t> (check Rust Core API)
+slice_ref_uint8_t borrowVecAsOptRefSlice(std::vector<uint8_t> const &v)
+{
+  slice_ref_uint8_t it{};
+  it.ptr = v.empty() ? nullptr : v.data();
+  it.len = v.size();
+  return it;
+}
+
+// To be used with non-optional `slice_ref_uint8_t` (check Rust Core API)
+slice_ref_uint8_t borrowVecAsRefSlice(std::vector<uint8_t> const &v)
+{
+  slice_ref_uint8_t it{};
+  it.ptr = v.empty() ? (uint8_t *)0xbad000 : v.data();
+  it.len = v.size();
+  return it;
+}
 
-  // To be used with non-optional `slice_ref_uint8_t` (check Rust Core API)
-  slice_ref_uint8_t borrowVecAsRefSlice(std::vector<uint8_t> const &v)
+std::vector<uint8_t> jsTypedArrayToCVector(Runtime &runtime, const Value &arg)
+{
+  if (arg.isUndefined() || arg.isNull())
   {
-    slice_ref_uint8_t it{};
-    it.ptr = v.empty() ? (uint8_t *)0xbad000 : v.data();
-    it.len = v.size();
-    return it;
+    return {};
   }
+  TypedArrayBase typedArrayBase(runtime, arg.asObject(runtime));
+  return typedArrayBase.toVector(runtime);
+}
 
-  Function sliceBoxedToUInt8Array(Runtime &runtime)
-  {
-    return Function::createFromHostFunction(runtime,
-                                            PropNameID::forAscii(runtime,
-                                                                 STRINGIFIED_FUNC_NAME()),
-                                            0,
-                                            [](Runtime &runtime,
-                                               const Value &thisValue,
-                                               const Value *arguments,
-                                               size_t count) -> Value
-                                            {
-                                              auto fatPtrJs = arguments[0].asObject(runtime);
-                                              auto ptr = jsPointerObjectToCPointer<uint8_t>(runtime, fatPtrJs.getProperty(runtime, "ptr"));
-                                              auto len = static_cast<size_t>(fatPtrJs.getProperty(runtime, "len").asNumber());
-                                              slice_boxed_uint8 slice = {.ptr = ptr, .len = len};
-                                              if (!slice.ptr)
-                                              {
-                                                return Value::null();
-                                              }
-
-                                              auto typedArray = TypedArray<TypedArrayKind::Uint8Array>(runtime, slice.len);
-                                              auto arrayBuffer = typedArray.getBuffer(runtime);
-                                              std::memcpy(arrayBuffer.data(runtime), slice.ptr, slice.len);
-
-                                              ::ditto_c_bytes_free(slice);
-
-                                              return typedArray;
-                                            });
+std::string jsTypedArrayToCString(Runtime &runtime, const Value &arg)
+{
+  std::vector<uint8_t> vec = jsTypedArrayToCVector(runtime, arg);
+  return std::string(vec.begin(), vec.end());
+}
+
+
+
+Value int64ToBigIntOrNumber(Runtime &runtime, int64_t value) {
+  constexpr int64_t jsMaxSafeInteger = (1LL << 53) - 1;
+  constexpr int64_t jsMinSafeInteger = -(1LL << 53) + 1;
+
+  if (jsMinSafeInteger <= value && value <= jsMaxSafeInteger) {
+    return static_cast<double>(value);
+  } else {
+    return BigInt::fromInt64(runtime, value);
   }
+}
 
-  std::vector<uint8_t> jsTypedArrayToCVector(Runtime &runtime, const Value &arg)
-  {
-    if (arg.isUndefined() || arg.isNull())
-    {
-      return {};
-    }
-    TypedArrayBase typedArrayBase(runtime, arg.asObject(runtime));
-    return typedArrayBase.toVector(runtime);
+Value uint64ToBigIntOrNumber(Runtime &runtime, uint64_t value) {
+  constexpr uint64_t jsMaxSafeInteger = 1ULL << (53 - 1);
+
+  if (value <= jsMaxSafeInteger) {
+    return static_cast<double>(value);
+  } else {
+    return BigInt::fromUint64(runtime, value);
   }
+}
 
-  std::string jsTypedArrayToCString(Runtime &runtime, const Value &arg)
-  {
-    std::vector<uint8_t> vec = jsTypedArrayToCVector(runtime, arg);
-    return std::string(vec.begin(), vec.end());
+int64_t bigIntOrNumberToInt64(Runtime &runtime, Value const& value) {
+  if (value.isNumber()) {
+    return static_cast<int64_t>(value.asNumber());
+  } else if (value.isBigInt()) {
+    return value.asBigInt(runtime).asInt64(runtime);
+  } else {
+    throw jsi::JSError(runtime, "Expected a number or BigInt");
   }
+}
 
-  Value cSlicedBoxToJSSlicedBox(Runtime &runtime, slice_boxed_uint8 box_c_bytes)
-  {
-    Object obj(runtime);
-    obj.setProperty(runtime, "ptr", cPointerToJSPointerObject<uint8_t>(runtime, box_c_bytes.ptr));
-    obj.setProperty(runtime, "len", static_cast<double>(box_c_bytes.len));
-    return obj;
+uint64_t bigIntOrNumberToUint64(Runtime &runtime, Value const& value) {
+  if (value.isNumber()) {
+    return static_cast<uint64_t>(value.asNumber());
+  } else if (value.isBigInt()) {
+    return value.asBigInt(runtime).asUint64(runtime);
+  } else {
+    throw jsi::JSError(runtime, "Expected a number or BigInt");
   }
+}
 
-  using Task = std::function<void(Runtime *)>;
+using Task = std::function<void(Runtime *)>;
 
-  struct
-  {
-    std::mutex mutex;
-    std::vector<Task> tasks;
-    // std::condition_variable condition;
-  } TASKS;
+struct
+{
+  std::mutex mutex;
+  std::vector<Task> tasks;
+  // std::condition_variable condition;
+} TASKS;
 
-  void ditto_enqueue_call(Task &&task)
+void ditto_enqueue_call(Task &&task)
+{
+  std::unique_lock<std::mutex> lock{TASKS.mutex};
+  TASKS.tasks.emplace_back(task);
+  // TASKS.condition.notify_one();
+}
+
+Task try_recv_task()
+{
+  std::unique_lock<std::mutex> lock(TASKS.mutex);
+  // TASKS.condition.wait(lock, [] { return !TASKS.tasks.empty(); });
+  if (TASKS.tasks.empty())
   {
-    std::unique_lock<std::mutex> lock{TASKS.mutex};
-    TASKS.tasks.emplace_back(task);
-    // TASKS.condition.notify_one();
+    return nullptr;
   }
+  Task task{std::move(TASKS.tasks.back())};
+  TASKS.tasks.pop_back();
+  return task;
+}
 
-  Task try_recv_task()
+void ditto_tick(Runtime *jsi)
+{
+  while (1)
   {
-    std::unique_lock<std::mutex> lock(TASKS.mutex);
-    // TASKS.condition.wait(lock, [] { return !TASKS.tasks.empty(); });
-    if (TASKS.tasks.empty())
+    Task task = try_recv_task();
+    if (task == nullptr)
     {
-      return nullptr;
+      return;
     }
-    Task task{std::move(TASKS.tasks.back())};
-    TASKS.tasks.pop_back();
-    return task;
-  }
-
-  void ditto_tick(Runtime *jsi)
-  {
-    while (1)
+    else
     {
-      Task task = try_recv_task();
-      if (task == nullptr)
-      {
-        return;
-      }
-      else
-      {
-        task(jsi);
-      }
+      task(jsi);
     }
   }
 }
+}