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

package/cpp/src/emscripten/val.h

@@ -17,6 +17,7 @@
 #include <climits>
 #include "./wire.h"
 #include <cstdint> // uintptr_t
+#include <stdexcept>
 #include <vector>
 
 // #include <android/log.h>
@@ -48,15 +49,14 @@ enum {
   _EMVAL_FALSE = 4
 };
 
-typedef struct _EM_DESTRUCTORS* EM_DESTRUCTORS;
 typedef struct _EM_METHOD_CALLER* EM_METHOD_CALLER;
 typedef facebook::jsi::Value EM_GENERIC_WIRE_TYPE;
-typedef const void* EM_VAR_ARGS;
 
 void _emval_incref(EM_VAL value);
 void _emval_decref(EM_VAL value);
 
-void _emval_run_destructors(EM_DESTRUCTORS handle);
+// Runs the destructors the latest _emval_as or _emval_call_method conversion queued.
+void _emval_run_destructors();
 
 EM_VAL _emval_new_array();
 EM_VAL _emval_new_array_from_memory_view(EM_VAL mv);
@@ -65,19 +65,19 @@ EM_VAL _emval_new_cstring(const char*);
 EM_VAL _emval_new_u8string(const char*);
 EM_VAL _emval_new_u16string(const char16_t*);
 
-EM_VAL _emval_take_value(TYPEID type, EM_VAR_ARGS argv);
+EM_VAL _emval_take_value(TYPEID type, const facebook::jsi::Value& value);
 
 EM_VAL _emval_new(
     EM_VAL value,
     unsigned argCount,
     const TYPEID argTypes[],
-    EM_VAR_ARGS argv);
+    facebook::jsi::Value* argv);
 
 EM_VAL _emval_get_global(const char* name);
 EM_VAL _emval_get_module_property(const char* name);
 EM_VAL _emval_get_property(EM_VAL object, EM_VAL key);
 void _emval_set_property(EM_VAL object, EM_VAL key, EM_VAL value);
-EM_GENERIC_WIRE_TYPE _emval_as(EM_VAL value, TYPEID returnType, EM_DESTRUCTORS* destructors);
+EM_GENERIC_WIRE_TYPE _emval_as(EM_VAL value, TYPEID returnType);
 int64_t _emval_as_int64(EM_VAL value, TYPEID returnType);
 uint64_t _emval_as_uint64(EM_VAL value, TYPEID returnType);
 
@@ -91,7 +91,7 @@ EM_VAL _emval_call(
     EM_VAL value,
     unsigned argCount,
     const TYPEID argTypes[],
-    EM_VAR_ARGS argv);
+    facebook::jsi::Value* argv);
 
 // DO NOT call this more than once per signature. It will
 // leak generated function objects!
@@ -102,13 +102,14 @@ EM_GENERIC_WIRE_TYPE _emval_call_method(
     EM_METHOD_CALLER caller,
     EM_VAL handle,
     const char* methodName,
-    EM_DESTRUCTORS* destructors,
-    EM_VAR_ARGS argv);
+    unsigned argCount,
+    facebook::jsi::Value* argv);
 void _emval_call_void_method(
     EM_METHOD_CALLER caller,
     EM_VAL handle,
     const char* methodName,
-    EM_VAR_ARGS argv);
+    unsigned argCount,
+    facebook::jsi::Value* argv);
 EM_VAL _emval_typeof(EM_VAL value);
 bool _emval_instanceof(EM_VAL object, EM_VAL constructor);
 bool _emval_is_number(EM_VAL object);
@@ -146,20 +147,17 @@ struct Signature {
   }
 };
 
+// Scoped to one conversion: every _emval_as / _emval_call_method that returns queues exactly one
+// destructor list in JS, and this runs it once the C++ side has read the value.
 struct DestructorsRunner {
 public:
-  explicit DestructorsRunner(EM_DESTRUCTORS d)
-      : destructors(d)
-  {}
+  DestructorsRunner() = default;
   ~DestructorsRunner() {
-    _emval_run_destructors(destructors);
+    _emval_run_destructors();
   }
 
   DestructorsRunner(const DestructorsRunner&) = delete;
   void operator=(const DestructorsRunner&) = delete;
-
-private:
-  EM_DESTRUCTORS destructors;
 };
 
 template<typename WireType>
@@ -178,115 +176,27 @@ struct GenericWireTypeConverter<Pointee*> {
 
 template<typename T>
 T fromGenericWireType(facebook::jsi::Value& g) {
-    if constexpr (std::is_same<T, std::string>::value) {
-        return g.getString(*jsRuntime).utf8(*jsRuntime);
-    }
-  typedef typename BindingType<T>::WireType WireType;
-  WireType wt = GenericWireTypeConverter<WireType>::from(g);
-  return BindingType<T>::fromWireType(wt);
-}
-
-template<typename... Args>
-struct PackSize;
-
-template<>
-struct PackSize<> {
-  static constexpr size_t value = 0;
-};
-
-template<typename Arg, typename... Args>
-struct PackSize<Arg, Args...> {
-  static constexpr size_t value = (sizeof(typename BindingType<Arg>::WireType) + 7) / 8 + PackSize<Args...>::value;
-};
-
-union GenericWireType {
-  union {
-    unsigned u;
-    float f;
-    // Use uint32_t for pointer values.  This limits us, for now, to 32-bit
-    // address ranges even on wasm64.  This is enforced by assertions below.
-    // TODO(sbc): Allow full 64-bit address range here under wasm64, most
-    // likely by increasing the size of GenericWireType on wasm64.
-    uint32_t p;
-  } w[2];
-    double d;
-    uint64_t u;
-};
-static_assert(sizeof(GenericWireType) == 8, "GenericWireType must be 8 bytes");
-static_assert(alignof(GenericWireType) == 8, "GenericWireType must be 8-byte-aligned");
-
-inline void writeGenericWireType(GenericWireType*& cursor, float wt) {
-  cursor->w[0].f = wt;
-  ++cursor;
-}
-
-inline void writeGenericWireType(GenericWireType*& cursor, double wt) {
-  cursor->d = wt;
-  ++cursor;
-}
-
-inline void writeGenericWireType(GenericWireType*& cursor, int64_t wt) {
-  cursor->u = wt;
-  ++cursor;
-}
-
-inline void writeGenericWireType(GenericWireType*& cursor, uint64_t wt) {
-  cursor->u = wt;
-  ++cursor;
-}
-
-template<typename T>
-void writeGenericWireType(GenericWireType*& cursor, T* wt) {
-  uint64_t short_ptr = reinterpret_cast<uint64_t>(wt);
-  // assert(short_ptr <= UINT32_MAX);
-  cursor->u = short_ptr;
-  ++cursor;
-}
-
-template<typename ElementType>
-inline void writeGenericWireType(GenericWireType*& cursor, const memory_view<ElementType>& wt) {
-  uintptr_t short_ptr = reinterpret_cast<uintptr_t>(wt.data);
-  // This wire slot stores the data pointer in 32 bits (upstream wasm32 layout). On 64-bit
-  // native a pointer above 4 GiB cannot fit; abort loudly rather than silently truncating to
-  // a bogus address (release builds compile out the assert). Full 64-bit memory_view support
-  // needs a wider wire encoding on both the writer and the reader.
-  assert(short_ptr <= UINT32_MAX);
-  if (short_ptr > UINT32_MAX) {
-    abort();
-  }
-  cursor->w[0].u = wt.size;
-  cursor->w[1].p = static_cast<uint32_t>(short_ptr);
-  ++cursor;
-}
-
-template<typename T>
-void writeGenericWireType(GenericWireType*& cursor, T wt) {
-  cursor->w[0].u = static_cast<unsigned>(wt);
-  ++cursor;
-}
-
-inline void writeGenericWireTypes(GenericWireType*&) {
-}
-
-template<typename First, typename... Rest>
-EMSCRIPTEN_ALWAYS_INLINE void writeGenericWireTypes(GenericWireType*& cursor, First&& first, Rest&&... rest) {
-  writeGenericWireType(cursor, BindingType<First>::toWireType(std::forward<First>(first)));
-  writeGenericWireTypes(cursor, std::forward<Rest>(rest)...);
+  if constexpr (std::is_same<T, std::string>::value) {
+    return g.asString(*jsRuntime).utf8(*jsRuntime);
+  } else if constexpr (std::is_same<T, facebook::jsi::Value>::value) {
+    return std::move(g);
+  } else {
+    typedef typename BindingType<T>::WireType WireType;
+    WireType wt = GenericWireTypeConverter<WireType>::from(g);
+    return BindingType<T>::fromWireType(wt);
+  }
 }
 
+// Arguments cross as the values embind's JS types accept (toWireType2), the same way bound
+// functions return them, never as bytes JS would have to read out of native memory.
+// jsi::Value has no copy constructor: each toWireType2 prvalue initializes its element directly,
+// so routing one through a named const Value first would stop this from compiling.
 template<typename... Args>
-struct WireTypePack {
-  WireTypePack(Args&&... args) {
-    GenericWireType* cursor = elements.data();
-    writeGenericWireTypes(cursor, std::forward<Args>(args)...);
-  }
+struct WireValues {
+  explicit WireValues(Args&&... args)
+      : values{{BindingType<Args>::toWireType2(*jsRuntime, std::forward<Args>(args))...}} {}
 
-  operator EM_VAR_ARGS() const {
-    return elements.data();
-  }
-
-private:
-  std::array<GenericWireType, PackSize<Args...>::value> elements;
+  std::array<facebook::jsi::Value, sizeof...(Args)> values;
 };
 
 template<typename ReturnType, typename... Args>
@@ -294,15 +204,14 @@ struct MethodCaller {
   static ReturnType call(EM_VAL handle, const char* methodName, Args&&... args) {
     auto caller = Signature<ReturnType, Args...>::get_method_caller();
 
-    WireTypePack<Args...> argv(std::forward<Args>(args)...);
-    EM_DESTRUCTORS destructors;
+    WireValues<Args...> argv(std::forward<Args>(args)...);
     EM_GENERIC_WIRE_TYPE result = _emval_call_method(
       caller,
       handle,
       methodName,
-      &destructors,
-      argv);
-    DestructorsRunner rd(destructors);
+      sizeof...(Args),
+      argv.values.data());
+    DestructorsRunner rd;
     return fromGenericWireType<ReturnType>(result);
   }
 };
@@ -312,12 +221,13 @@ struct MethodCaller<void, Args...> {
   static void call(EM_VAL handle, const char* methodName, Args&&... args) {
     auto caller = Signature<void, Args...>::get_method_caller();
 
-    WireTypePack<Args...> argv(std::forward<Args>(args)...);
+    WireValues<Args...> argv(std::forward<Args>(args)...);
     _emval_call_void_method(
       caller,
       handle,
       methodName,
-      argv);
+      sizeof...(Args),
+      argv.values.data());
   }
 };
 
@@ -410,9 +320,9 @@ public:
   explicit val(T&& value) {
     using namespace internal;
 
-    typedef internal::BindingType<T> BT;
-    WireTypePack<T> argv(std::forward<T>(value));
-    handle = _emval_take_value(internal::TypeID<T>::get(), argv);
+    handle = _emval_take_value(
+        internal::TypeID<T>::get(),
+        BindingType<T>::toWireType2(*jsRuntime, std::forward<T>(value)));
   }
 
   val() : handle(EM_VAL(internal::_EMVAL_UNDEFINED)) {}
@@ -555,15 +465,10 @@ public:
   T as(Policies...) const {
     using namespace internal;
 
-    typedef BindingType<T> BT;
     typename WithPolicies<Policies...>::template ArgTypeList<T> targetType;
 
-    EM_DESTRUCTORS destructors;
-    EM_GENERIC_WIRE_TYPE result = _emval_as(
-        handle,
-        targetType.getTypes()[0],
-        &destructors);
-    DestructorsRunner dr(destructors);
+    EM_GENERIC_WIRE_TYPE result = _emval_as(handle, targetType.getTypes()[0]);
+    DestructorsRunner dr;
     return fromGenericWireType<T>(result);
   }
 
@@ -629,8 +534,8 @@ private:
     using namespace internal;
 
     WithPolicies<>::ArgTypeList<Args...> argList;
-    WireTypePack<Args...> argv(std::forward<Args>(args)...);
-    return val(impl(handle, argList.getCount(), argList.getTypes(), argv));
+    WireValues<Args...> argv(std::forward<Args>(args)...);
+    return val(impl(handle, argList.getCount(), argList.getTypes(), argv.values.data()));
   }
 
   template<typename T>
@@ -669,7 +574,7 @@ struct BindingType<val> {
     static val fromWireType2(facebook::jsi::Runtime& rt, WireType2& v) {
       // return val::undefined();
         // return val::take_ownership(reinterpret_cast<EM_VAL>((int) v.getNumber()));
-        return val::take_ownership(reinterpret_cast<EM_VAL>(v.asBigInt(rt).asUint64(rt)));
+        return val::take_ownership(reinterpret_cast<EM_VAL>(bigIntUint64(rt, v)));
     }
 };
 
@@ -690,17 +595,23 @@ std::vector<T> vecFromJSArray(const val& v, Policies... policies) {
 
 template <typename T>
 std::vector<T> convertJSArrayToNumberVector(const val& v) {
-  const size_t l = v["length"].as<size_t>();
+  // size_t is not a registered embind type on every 64-bit ABI; the length is a Number anyway.
+  const double l = v["length"].as<double>();
+  if (!(l >= 0 && l <= static_cast<double>(std::vector<T>().max_size()))) {
+    throw std::length_error("crossbind: the array length is not a valid size");
+  }
 
   std::vector<T> rv;
-  rv.resize(l);
+  rv.resize(static_cast<size_t>(l));
 
   // Copy the array into our vector through the use of typed arrays.
   // It will try to convert each element through Number().
   // See https://www.ecma-international.org/ecma-262/6.0/#sec-%typedarray%.prototype.set-array-offset
   // and https://www.ecma-international.org/ecma-262/6.0/#sec-tonumber
-  val memoryView{ typed_memory_view(l, rv.data()) };
-  memoryView.call<void>("set", v);
+  // The typed array is JS-owned and copied out: one aliasing rv would need external memory.
+  val typedArray = val::global(internal::typedArrayNameOf<T>()).new_(l);
+  typedArray.call<void>("set", v);
+  internal::copyFromTypedArray(*jsRuntime, typedArray.as<facebook::jsi::Value>(), rv.data(), rv.size() * sizeof(T));
 
   return rv;
 }

package/cpp/src/emscripten/wire.h

@@ -21,11 +21,13 @@
 #include <cstdio>
 #include <cstdlib>
 #include <cstdint>
+#include <cstring>
 #include <memory>
 #include <optional>
 #include <string>
 
 #include <jsi/jsi.h>
+#include "../crossbind/direct_reads.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
@@ -96,25 +98,40 @@ constexpr bool has_unbound_type_names = false;
 
 namespace internal {
 
+// A BigInt read straight from the engine where the runtime offers crossbind::IDirectReads, instead
+// of cloning it into a jsi::BigInt first; `this` arrives this way on every method call. Anything
+// that is not a BigInt, or does not fit, takes the jsi path and throws as it did.
+inline uint64_t bigIntUint64(facebook::jsi::Runtime& rt, const facebook::jsi::Value& v) {
+    auto* reads = static_cast<crossbind::IDirectReads*>(rt.castInterface(crossbind::IDirectReads::uuid));
+    uint64_t bits = 0;
+    bool lossless = false;
+    if (reads != nullptr && reads->bigIntToUint64(v, bits, lossless) && lossless) return bits;
+    return v.asBigInt(rt).asUint64(rt);
+}
+
+inline int64_t bigIntInt64(facebook::jsi::Runtime& rt, const facebook::jsi::Value& v) {
+    auto* reads = static_cast<crossbind::IDirectReads*>(rt.castInterface(crossbind::IDirectReads::uuid));
+    int64_t bits = 0;
+    bool lossless = false;
+    if (reads != nullptr && reads->bigIntToInt64(v, bits, lossless) && lossless) return bits;
+    return v.asBigInt(rt).asInt64(rt);
+}
+
 // 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);
+    return bigIntUint64(rt, v);
 }
 
 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);
+    return bigIntInt64(rt, v);
 }
 
 typedef const void* TYPEID;
 
-// Defined in bind.cpp: registers a JS-side ArrayBuffer window covering `ptr` so
-// heap reads on values we hand out by pointer cannot miss every window.
-void ensureWindowFor(uint64_t ptr);
-
 // We don't need the full std::type_info implementation.  We
 // just need a unique identifier per type and polymorphic type
 // identification.
@@ -396,7 +413,7 @@ struct BindingType<int64_t> {
         return facebook::jsi::BigInt::fromInt64(rt, b);
     }
     static WireType fromWireType2(facebook::jsi::Runtime& rt, WireType2& wt) {
-        return wt.asBigInt(rt).asInt64(rt);
+        return bigIntInt64(rt, wt);
     }
 };
 
@@ -416,7 +433,57 @@ struct BindingType<uint64_t> {
         return facebook::jsi::BigInt::fromUint64(rt, b);
     }
     static WireType fromWireType2(facebook::jsi::Runtime& rt, WireType2& wt) {
-        return wt.asBigInt(rt).asUint64(rt);
+        return bigIntUint64(rt, wt);
+    }
+};
+
+// int64_t is long long on Apple platforms and long on Android: the other 64-bit pair crosses as a BigInt too.
+template<typename T>
+constexpr bool isOther64BitInteger = std::is_integral_v<T> && sizeof(T) == 8
+    && !std::is_same_v<T, int64_t> && !std::is_same_v<T, uint64_t>;
+
+template<typename T>
+struct BindingType<T, std::enable_if_t<isOther64BitInteger<T>>> {
+    using Exact = std::conditional_t<std::is_signed_v<T>, int64_t, uint64_t>;
+    typedef T WireType;
+    typedef const facebook::jsi::Value WireType2;
+
+    static WireType toWireType(WireType b) {
+        return b;
+    }
+    static WireType fromWireType(WireType wt) {
+        return wt;
+    }
+
+    static WireType2 toWireType2(facebook::jsi::Runtime& rt, WireType b) {
+        return BindingType<Exact>::toWireType2(rt, static_cast<Exact>(b));
+    }
+    static WireType fromWireType2(facebook::jsi::Runtime& rt, WireType2& wt) {
+        return static_cast<WireType>(BindingType<Exact>::fromWireType2(rt, wt));
+    }
+};
+
+// Windows keeps long at 32 bits, still a type apart from int: it crosses as a Number like int does.
+template<typename T>
+constexpr bool isNarrowLong = (std::is_same_v<T, long> || std::is_same_v<T, unsigned long>) && sizeof(T) == 4;
+
+template<typename T>
+struct BindingType<T, std::enable_if_t<isNarrowLong<T>>> {
+    typedef T WireType;
+    typedef const facebook::jsi::Value WireType2;
+
+    static WireType toWireType(WireType b) {
+        return b;
+    }
+    static WireType fromWireType(WireType wt) {
+        return wt;
+    }
+
+    static WireType2 toWireType2(facebook::jsi::Runtime& rt, WireType b) {
+        return WireType2((double) b);
+    }
+    static WireType fromWireType2(facebook::jsi::Runtime& rt, WireType2& wt) {
+        return (WireType) wt.getNumber();
     }
 };
 
@@ -434,64 +501,80 @@ 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.
+// well-formed UTF-16 survives the round trip. Both directions size their output once and write through a pointer:
+// a push_back per unit was most of the cost of moving bytes (readBytes) across.
 inline std::string utf16ToUtf8(const std::u16string& text) {
-    std::string out;
-    out.reserve(text.size());
-    for (size_t i = 0; i < text.size(); ++i) {
+    // At most three bytes per code unit; a surrogate pair takes four for two.
+    std::string out(text.size() * 3, '\0');
+    char* o = out.data();
+    const size_t n = text.size();
+    for (size_t i = 0; i < n; ++i) {
         char32_t cp = text[i];
-        if (cp >= 0xD800 && cp <= 0xDBFF && i + 1 < text.size() && text[i + 1] >= 0xDC00 && text[i + 1] <= 0xDFFF) {
+        if (cp < 0x800) {
+            // One byte or two, chosen without a branch: in byte data half the units are above 0x7F
+            // at random. The spare second byte stays inside the three reserved per unit.
+            const bool isTwoBytes = cp >= 0x80;
+            o[0] = static_cast<char>(isTwoBytes ? 0xC0 | (cp >> 6) : cp);
+            o[1] = static_cast<char>(0x80 | (cp & 0x3F));
+            o += 1 + isTwoBytes;
+            continue;
+        }
+        if (cp >= 0xD800 && cp <= 0xDBFF && i + 1 < n && 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)));
+        if (cp < 0x10000) {
+            *o++ = static_cast<char>(0xE0 | (cp >> 12));
+            *o++ = static_cast<char>(0x80 | ((cp >> 6) & 0x3F));
+            *o++ = 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)));
+            *o++ = static_cast<char>(0xF0 | (cp >> 18));
+            *o++ = static_cast<char>(0x80 | ((cp >> 12) & 0x3F));
+            *o++ = static_cast<char>(0x80 | ((cp >> 6) & 0x3F));
+            *o++ = static_cast<char>(0x80 | (cp & 0x3F));
         }
     }
+    out.resize(static_cast<size_t>(o - out.data()));
     return out;
 }
 
 inline std::u16string utf8ToUtf16(const std::string& text) {
-    std::u16string out;
-    out.reserve(text.size());
+    // Never more code units than bytes.
+    std::u16string out(text.size(), u'\0');
+    char16_t* o = out.data();
+    const size_t n = text.size();
     size_t i = 0;
-    while (i < text.size()) {
+    while (i < n) {
         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();
+        if (lead < 0x80) {
+            *o++ = lead;
+            ++i;
+            continue;
+        }
+        size_t extra = (lead >> 5) == 0x6 ? 1 : (lead >> 4) == 0xE ? 2 : (lead >> 3) == 0x1E ? 3 : 4;
+        char32_t cp = extra == 1 ? (lead & 0x1F) : extra == 2 ? (lead & 0x0F) : (lead & 0x07);
+        bool valid = extra < 4 && i + extra < n;
         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);
+            *o++ = 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)));
+            *o++ = static_cast<char16_t>(0xD800 + (cp >> 10));
+            *o++ = static_cast<char16_t>(0xDC00 + (cp & 0x3FF));
         } else {
-            out.push_back(static_cast<char16_t>(cp));
+            *o++ = static_cast<char16_t>(cp);
         }
     }
+    out.resize(static_cast<size_t>(o - out.data()));
     return out;
 }
 
@@ -521,11 +604,12 @@ struct BindingType<std::basic_string<T>> {
             return facebook::jsi::String::createFromUtf8(rt, v);
         }
     }
+    // asString, not getString: a non-string argument then throws into JS instead of being read as one.
     static String fromWireType2(facebook::jsi::Runtime& rt, WireType2& v) {
         if constexpr (std::is_same_v<T, char16_t>) {
-            return utf8ToUtf16(v.getString(rt).utf8(rt));
+            return utf8ToUtf16(v.asString(rt).utf8(rt));
         } else {
-            return v.getString(rt).utf8(rt);
+            return v.asString(rt).utf8(rt);
         }
     }
 };
@@ -616,20 +700,14 @@ struct GenericBindingType {
     }
 
     static WireType2 toWireType2(facebook::jsi::Runtime& rt, const T& v) {
-        // By-value returns allocate fresh heap blocks; without a covering window JS-side
-        // memory reads on the new object die with "Heap error ... no covering window".
-        uint64_t ptr = reinterpret_cast<uint64_t>(new T(v));
-        ensureWindowFor(ptr);
-        return facebook::jsi::BigInt::fromUint64(rt, ptr);
+        return facebook::jsi::BigInt::fromUint64(rt, reinterpret_cast<uint64_t>(new T(v)));
     }
     static WireType2 toWireType2(facebook::jsi::Runtime& rt, T&& v) {
-        uint64_t ptr = reinterpret_cast<uint64_t>(new T(std::forward<T>(v)));
-        ensureWindowFor(ptr);
-        return facebook::jsi::BigInt::fromUint64(rt, ptr);
+        return facebook::jsi::BigInt::fromUint64(rt, reinterpret_cast<uint64_t>(new T(std::forward<T>(v))));
     }
 
     static ActualT& fromWireType2(facebook::jsi::Runtime& rt, WireType2& wt) {
-        return *reinterpret_cast<WireType>(wt.getBigInt(rt).getUint64(rt));
+        return *reinterpret_cast<WireType>(bigIntUint64(rt, wt));
     }
 };
 
@@ -697,6 +775,46 @@ constexpr bool typeSupportsMemoryView() {
                  sizeof(T) == 4 || sizeof(T) == 8));
 }
 
+template<typename T>
+constexpr const char* typedArrayNameOf() {
+    static_assert(typeSupportsMemoryView<T>(), "type does not map to a typed array");
+    if constexpr (std::is_floating_point<T>::value) {
+        return sizeof(T) == 4 ? "Float32Array" : "Float64Array";
+    } else if constexpr (sizeof(T) == 1) {
+        return std::is_signed<T>::value ? "Int8Array" : "Uint8Array";
+    } else if constexpr (sizeof(T) == 2) {
+        return std::is_signed<T>::value ? "Int16Array" : "Uint16Array";
+    } else if constexpr (sizeof(T) == 4) {
+        return std::is_signed<T>::value ? "Int32Array" : "Uint32Array";
+    } else {
+        return std::is_signed<T>::value ? "BigInt64Array" : "BigUint64Array";
+    }
+}
+
+// Native memory reaches JS only as a copy in an ArrayBuffer JS allocated: Electron's V8 memory
+// cage refuses ArrayBuffers over external memory.
+inline facebook::jsi::Value copyToTypedArray(
+    facebook::jsi::Runtime& rt, const char* arrayName, const void* data, size_t count, size_t bytes) {
+    facebook::jsi::Object array = rt.global().getPropertyAsFunction(rt, arrayName)
+        .callAsConstructor(rt, static_cast<double>(count)).asObject(rt);
+    if (bytes > 0) {
+        facebook::jsi::ArrayBuffer buffer = array.getProperty(rt, "buffer").asObject(rt).getArrayBuffer(rt);
+        memcpy(buffer.data(rt), data, bytes);
+    }
+    return facebook::jsi::Value(std::move(array));
+}
+
+inline void copyFromTypedArray(facebook::jsi::Runtime& rt, const facebook::jsi::Value& typedArray, void* data, size_t bytes) {
+    if (bytes == 0) return;
+    facebook::jsi::Object view = typedArray.asObject(rt);
+    size_t offset = static_cast<size_t>(view.getProperty(rt, "byteOffset").asNumber());
+    facebook::jsi::ArrayBuffer buffer = view.getProperty(rt, "buffer").asObject(rt).getArrayBuffer(rt);
+    if (offset > buffer.size(rt) || bytes > buffer.size(rt) - offset) {
+        throw facebook::jsi::JSINativeException("crossbind: the typed array is smaller than the native buffer it fills");
+    }
+    memcpy(data, buffer.data(rt) + offset, bytes);
+}
+
 } // namespace internal
 
 template<typename ElementType>
@@ -734,9 +852,13 @@ struct BindingType<memory_view<ElementType>> {
     // on the C++ side, nor is toWireType implemented in
     // JavaScript.)
     typedef memory_view<ElementType> WireType;
+    typedef const facebook::jsi::Value WireType2;
     static WireType toWireType(const memory_view<ElementType>& mv) {
         return mv;
     }
+    static WireType2 toWireType2(facebook::jsi::Runtime& rt, const memory_view<ElementType>& mv) {
+        return copyToTypedArray(rt, typedArrayNameOf<ElementType>(), mv.data, mv.size, mv.size * sizeof(ElementType));
+    }
 };
 
 } // namespace internal