@crossbind/core-embind-jsi 2.0.0-beta.56 → 2.0.0-beta.60

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # @crossbind/core-embind-jsi
 
+## 2.0.0-beta.60
+
+### Patch Changes
+
+- Supplied the `std::char_traits<unsigned char>` that embind's raw-byte string binding needs. The
+  standard has never defined one, and libc++ used to instantiate the primary template anyway; from
+  the release NDK r30 ships it static_asserts instead, so naming
+  `std::basic_string<unsigned char>` stopped compiling at all. The binding is unchanged, and the
+  traits cost nothing on the toolchains that did not need them.
+
 ## 2.0.0-beta.53
 
 ### Patch Changes

package/cpp/src/emscripten/val.h

@@ -172,7 +172,7 @@ struct GenericWireTypeConverter {
 template<typename Pointee>
 struct GenericWireTypeConverter<Pointee*> {
   static Pointee* from(facebook::jsi::Value& wt) {
-    return reinterpret_cast<Pointee*>(wt.asBigInt(*jsRuntime).asUint64(*jsRuntime));
+    return reinterpret_cast<Pointee*>(addressFromValue(*jsRuntime, wt));
   }
 };
 

package/cpp/src/emscripten/wire.h

@@ -20,12 +20,63 @@
 
 #include <cstdio>
 #include <cstdlib>
+#include <cstdint>
 #include <memory>
 #include <optional>
 #include <string>
 
 #include <jsi/jsi.h>
 
+// embind registers std::basic_string<unsigned char> as the raw-byte counterpart to UTF-8
+// std::string, but the standard has never defined std::char_traits for unsigned char. libc++ used
+// to instantiate the primary template anyway; from the release NDK r30 ships it static_asserts
+// instead, so merely naming the type stops compiling. Supplying the traits keeps the binding and
+// costs nothing on the toolchains that did not need it.
+namespace std {
+template <>
+struct char_traits<unsigned char> {
+    using char_type = unsigned char;
+    using int_type = int;
+    using off_type = streamoff;
+    using pos_type = streampos;
+    using state_type = mbstate_t;
+
+    static constexpr void assign(char_type& a, const char_type& b) noexcept { a = b; }
+    static constexpr bool eq(char_type a, char_type b) noexcept { return a == b; }
+    static constexpr bool lt(char_type a, char_type b) noexcept { return a < b; }
+
+    static int compare(const char_type* a, const char_type* b, size_t n) {
+        return n == 0 ? 0 : __builtin_memcmp(a, b, n);
+    }
+    static size_t length(const char_type* s) {
+        size_t n = 0;
+        while (s[n]) ++n;
+        return n;
+    }
+    static const char_type* find(const char_type* s, size_t n, const char_type& c) {
+        for (size_t i = 0; i < n; ++i)
+            if (s[i] == c) return s + i;
+        return nullptr;
+    }
+    static char_type* move(char_type* d, const char_type* s, size_t n) {
+        return n == 0 ? d : static_cast<char_type*>(__builtin_memmove(d, s, n));
+    }
+    static char_type* copy(char_type* d, const char_type* s, size_t n) {
+        return n == 0 ? d : static_cast<char_type*>(__builtin_memcpy(d, s, n));
+    }
+    static char_type* assign(char_type* d, size_t n, char_type c) {
+        for (size_t i = 0; i < n; ++i) d[i] = c;
+        return d;
+    }
+
+    static constexpr int_type not_eof(int_type c) noexcept { return eq_int_type(c, eof()) ? ~eof() : c; }
+    static constexpr char_type to_char_type(int_type c) noexcept { return char_type(c); }
+    static constexpr int_type to_int_type(char_type c) noexcept { return int_type(c); }
+    static constexpr bool eq_int_type(int_type a, int_type b) noexcept { return a == b; }
+    static constexpr int_type eof() noexcept { return int_type(EOF); }
+};
+} // namespace std
+
 // #include <android/log.h>
 // #define APPNAME "react-native-crossbind"
 
@@ -45,6 +96,19 @@ constexpr bool has_unbound_type_names = false;
 
 namespace internal {
 
+// JS hands native pointers over as BigInt addresses, but a null pointer arrives as the number 0
+// and enum values as plain numbers: take both spellings.
+inline uint64_t addressFromValue(facebook::jsi::Runtime& rt, const facebook::jsi::Value& v) {
+    if (v.isNumber()) return static_cast<uint64_t>(v.asNumber());
+    if (v.isNull() || v.isUndefined()) return 0;
+    return v.asBigInt(rt).asUint64(rt);
+}
+
+inline int64_t integerFromValue(facebook::jsi::Runtime& rt, const facebook::jsi::Value& v) {
+    if (v.isNumber()) return static_cast<int64_t>(v.asNumber());
+    return v.asBigInt(rt).asInt64(rt);
+}
+
 typedef const void* TYPEID;
 
 // Defined in bind.cpp: registers a JS-side ArrayBuffer window covering `ptr` so
@@ -369,6 +433,68 @@ struct BindingType<uint64_t> {
         }
     };
 
+// jsi strings cross as UTF-8, so a std::u16string (embind's byte-preserving string) is transcoded; every code unit of
+// well-formed UTF-16 survives the round trip.
+inline std::string utf16ToUtf8(const std::u16string& text) {
+    std::string out;
+    out.reserve(text.size());
+    for (size_t i = 0; i < text.size(); ++i) {
+        char32_t cp = text[i];
+        if (cp >= 0xD800 && cp <= 0xDBFF && i + 1 < text.size() && text[i + 1] >= 0xDC00 && text[i + 1] <= 0xDFFF) {
+            cp = 0x10000 + ((cp - 0xD800) << 10) + (text[++i] - 0xDC00);
+        } else if (cp >= 0xD800 && cp <= 0xDFFF) {
+            cp = 0xFFFD;
+        }
+        if (cp < 0x80) {
+            out.push_back(static_cast<char>(cp));
+        } else if (cp < 0x800) {
+            out.push_back(static_cast<char>(0xC0 | (cp >> 6)));
+            out.push_back(static_cast<char>(0x80 | (cp & 0x3F)));
+        } else if (cp < 0x10000) {
+            out.push_back(static_cast<char>(0xE0 | (cp >> 12)));
+            out.push_back(static_cast<char>(0x80 | ((cp >> 6) & 0x3F)));
+            out.push_back(static_cast<char>(0x80 | (cp & 0x3F)));
+        } else {
+            out.push_back(static_cast<char>(0xF0 | (cp >> 18)));
+            out.push_back(static_cast<char>(0x80 | ((cp >> 12) & 0x3F)));
+            out.push_back(static_cast<char>(0x80 | ((cp >> 6) & 0x3F)));
+            out.push_back(static_cast<char>(0x80 | (cp & 0x3F)));
+        }
+    }
+    return out;
+}
+
+inline std::u16string utf8ToUtf16(const std::string& text) {
+    std::u16string out;
+    out.reserve(text.size());
+    size_t i = 0;
+    while (i < text.size()) {
+        unsigned char lead = static_cast<unsigned char>(text[i]);
+        size_t extra = lead < 0x80 ? 0 : (lead >> 5) == 0x6 ? 1 : (lead >> 4) == 0xE ? 2 : (lead >> 3) == 0x1E ? 3 : 4;
+        char32_t cp = extra == 0 ? lead : extra == 1 ? (lead & 0x1F) : extra == 2 ? (lead & 0x0F) : (lead & 0x07);
+        bool valid = extra < 4 && i + extra < text.size();
+        for (size_t k = 1; valid && k <= extra; ++k) {
+            unsigned char next = static_cast<unsigned char>(text[i + k]);
+            valid = (next >> 6) == 0x2;
+            cp = (cp << 6) | (next & 0x3F);
+        }
+        if (!valid) {
+            out.push_back(0xFFFD);
+            ++i;
+            continue;
+        }
+        i += extra + 1;
+        if (cp >= 0x10000) {
+            cp -= 0x10000;
+            out.push_back(static_cast<char16_t>(0xD800 + (cp >> 10)));
+            out.push_back(static_cast<char16_t>(0xDC00 + (cp & 0x3FF)));
+        } else {
+            out.push_back(static_cast<char16_t>(cp));
+        }
+    }
+    return out;
+}
+
 template<typename T>
 struct BindingType<std::basic_string<T>> {
     using String = std::basic_string<T>;
@@ -389,10 +515,18 @@ struct BindingType<std::basic_string<T>> {
     }
 
     static WireType2 toWireType2(facebook::jsi::Runtime& rt, String v) {
-        return facebook::jsi::String::createFromUtf8(rt, v);
+        if constexpr (std::is_same_v<T, char16_t>) {
+            return facebook::jsi::String::createFromUtf8(rt, utf16ToUtf8(v));
+        } else {
+            return facebook::jsi::String::createFromUtf8(rt, v);
+        }
     }
     static String fromWireType2(facebook::jsi::Runtime& rt, WireType2& v) {
-        return v.getString(rt).utf8(rt);
+        if constexpr (std::is_same_v<T, char16_t>) {
+            return utf8ToUtf16(v.getString(rt).utf8(rt));
+        } else {
+            return v.getString(rt).utf8(rt);
+        }
     }
 };
 
@@ -459,7 +593,7 @@ struct BindingType<T*> {
         return facebook::jsi::BigInt::fromUint64(rt, reinterpret_cast<uint64_t>(b));
     }
     static WireType fromWireType2(facebook::jsi::Runtime& rt, WireType2& wt) {
-        return (WireType) wt.asBigInt(rt).asUint64(rt);
+        return (WireType) addressFromValue(rt, wt);
     }
 };
 
@@ -537,7 +671,7 @@ struct EnumBindingType {
         return WireType2((int) v);
     }
     static Enum fromWireType2(facebook::jsi::Runtime& rt, WireType2& v) {
-        return (WireType) v.asBigInt(rt).asUint64(rt);
+        return (WireType) integerFromValue(rt, v);
     }
 };
 

package/js/embind.js

@@ -1411,10 +1411,10 @@ function __embind_register_optional(rawOptionalType, rawInnerType) {
     var inner = innerTypes[0];
     return [{
       name: `std::optional<${inner.name}>`,
-      // No value crosses as undefined (JS may also hand back null); a present value
+      // No value crosses as null (a wire of undefined reads the same); a present value
       // rides the inner type's own converters unchanged.
       'fromWireType': function (wt) {
-        if (wt === undefined || wt === null) return undefined;
+        if (wt === undefined || wt === null) return null;
         return inner['fromWireType'](wt);
       },
       'toWireType': function (destructors, o) {
@@ -1547,6 +1547,11 @@ function __embind_register_bigint(primitiveType, name, size, minRange, maxRange)
       if (typeof value != "bigint" && typeof value != "number") {
         throw new TypeError(`Cannot convert "${embindRepr(value)}" to ${this.name}`);
       }
+      // A Number crosses only while it is an exact integer: BigInt(2**53 + 1) would round
+      // silently, and a 64-bit slot deserves the exact value (the wasm glue gets the same rule).
+      if (typeof value == "number" && !Number.isSafeInteger(value)) {
+        throw new TypeError(`a 64-bit integer parameter takes a BigInt or a safe integer Number, got ${embindRepr(value)}`);
+      }
       if (value < minRange || value > maxRange) {
         throw new TypeError(`Passing a number "${embindRepr(value)}" from JS side to C/C++ side to an argument of type "${name}", which is outside the valid range [${minRange}, ${maxRange}]!`);
       }
@@ -2006,66 +2011,17 @@ function lengthBytesUTF32(str) {
 }
 function __embind_register_std_wstring(rawType, charSize, name) {
   name = readLatin1String(name);
-  var decodeString, encodeString, getHeap, lengthBytesUTF, shift;
-  if (charSize === 2) {
-    decodeString = UTF16ToString;
-    encodeString = stringToUTF16;
-    lengthBytesUTF = lengthBytesUTF16;
-    getHeap = () => HEAPU16;
-    shift = 1;
-  } else if (charSize === 4) {
-    decodeString = UTF32ToString;
-    encodeString = stringToUTF32;
-    lengthBytesUTF = lengthBytesUTF32;
-    getHeap = () => HEAPU32;
-    shift = 2;
-  }
   registerType(rawType, {
     name: name,
+    // The C++ BindingType turns the jsi string into the C++ string and back (wire.h), as it does for std::string.
     'fromWireType': function (value) {
-      // Code mostly taken from _embind_register_std_string fromWireType
-      var length = HEAPU32[value >> 2];
-      var HEAP = getHeap();
-      var str;
-
-      var decodeStartPtr = value + 4;
-      // Looping here to support possible embedded '0' bytes
-      for (var i = 0; i <= length; ++i) {
-        var currentBytePtr = value + 4 + i * charSize;
-        if (i == length || HEAP[currentBytePtr >> shift] == 0) {
-          var maxReadBytes = currentBytePtr - decodeStartPtr;
-          var stringSegment = decodeString(decodeStartPtr, maxReadBytes);
-          if (str === undefined) {
-            str = stringSegment;
-          } else {
-            str += String.fromCharCode(0);
-            str += stringSegment;
-          }
-          decodeStartPtr = currentBytePtr + charSize;
-        }
-      }
-
-      _free(value);
-
-      return str;
+      return value;
     },
     'toWireType': function (destructors, value) {
       if (!(typeof value == 'string')) {
         throwBindingError('Cannot pass non-string to C++ string type ' + name);
       }
-      // console.log('registerType toWireType');
-
-      // assumes 4-byte alignment
-      var length = lengthBytesUTF(value);
-      var ptr = _malloc(4 + length + charSize);
-      HEAPU32[ptr >> 2] = length >> shift;
-
-      encodeString(value, ptr + 4, length + charSize);
-
-      if (destructors !== null) {
-        destructors.push(_free, ptr);
-      }
-      return ptr;
+      return value;
     },
     'argPackAdvance': 8n,
     'readValueFromPointer': simpleReadValueFromPointer,
@@ -2192,7 +2148,13 @@ function __crossbind_json_to_handle(text) {
 globalThis.__crossbind_json_to_handle = __crossbind_json_to_handle;
 
 function __crossbind_handle_to_json(handle) {
-  const s = JSON.stringify(Emval.toValue(handle));
+  // A Set or Map has no JSON form of its own: write it as the array or object the Rust side
+  // expects, the same rule the web adapter's replacer follows.
+  const s = JSON.stringify(Emval.toValue(handle), (key, value) => {
+    if (value instanceof Set) return Array.from(value);
+    if (value instanceof Map) return Object.fromEntries(value);
+    return value;
+  });
   __emval_decref(handle);
   return s === undefined ? 'null' : s;
 }
@@ -2215,6 +2177,18 @@ function __crossbind_v_from_num(v) {
 }
 globalThis.__crossbind_v_from_num = __crossbind_v_from_num;
 
+// A handle's value as a plain array, so the adapter can copy a typed array element by element.
+function __crossbind_v_to_array(h) {
+  return Array.from(Emval.toValue(h));
+}
+globalThis.__crossbind_v_to_array = __crossbind_v_to_array;
+
+// Any JS value the adapter already built (a typed array, say) gets a handle of its own.
+function __crossbind_v_from_value(v) {
+  return Emval.toHandle(v);
+}
+globalThis.__crossbind_v_from_value = __crossbind_v_from_value;
+
 function __crossbind_v_from_bool(v) {
   return Emval.toHandle(!!v);
 }
@@ -2507,13 +2481,30 @@ function replacePublicSymbol(name, value, numArguments) {
 
 
 
+// A Rust binding cannot throw through Hermes: an exception escaping a host function comes back
+// as "Exception in HostFunction: ...", with the message rewritten and any property (the error
+// `code`) gone. The adapter parks the error here instead, and every invoker rethrows it on the
+// way out, so JS sees an Error this runtime built.
+globalThis.__crossbind_park_error = function (message, code) {
+  var error = new Error(message);
+  if (code !== undefined) error.code = code;
+  globalThis.__crossbindParkedError = error;
+};
+
 function getDynCaller(signature, rawFunction, slice) {
   return (...args) => {
     //console.log('getDynCallerReturn', signature, rawFunction, args.length, ...args);
     if (slice) {
       args = args.slice(1);
     }
-    return rawFunction(...args);
+    globalThis.__crossbindParkedError = null;
+    const result = rawFunction(...args);
+    const parked = globalThis.__crossbindParkedError;
+    if (parked) {
+      globalThis.__crossbindParkedError = null;
+      throw parked;
+    }
+    return result;
   };
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@crossbind/core-embind-jsi",
-  "version": "2.0.0-beta.56",
+  "version": "2.0.0-beta.60",
   "description": "The Embind JSI integration tool enables seamless C++ integration with React Native and Expo.",
   "homepage": "https://github.com/crossbind/crossbind/tree/main/core/embind-jsi#readme",
   "repository": {