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

package/README.md

@@ -2,7 +2,7 @@
 
 Rust **producer** for the crossbind embind registration protocol. Write an idiomatic Rust
 struct, register it, and it surfaces in JS as a real class - on web through emscripten's
-embind, on mobile through [`@crossbind/core-embind-jsi`](../core-embind-jsi) - **with no
+embind, on mobile through [`@crossbind/core-embind-jsi`](../embind-jsi) - **with no
 generated C++ wrapper and no cbindgen header**. The Rust side talks straight to the
 registration ABI that both hosts already consume.
 
@@ -31,7 +31,7 @@ Rust  (this package)   ──┼── crossbind_embind_register_* ─┤
 - `adapters/web.cpp` - passthrough to emscripten's `_embind_*` (10-param, identical).
 - `adapters/jsi.cpp` - wraps the raw invokers into `jsi::Function` (via
   `createFromHostFunction`) and drops `isNonnullReturn` for embind-jsi's 9-param API.
-  Compiled inside the React Native native module; shape-validated by `e2e/jsi-shape-check.cpp`.
+  Compiled inside the React Native native module and native Node.js addons.
 
 ## Demo: plain Rust in, JS classes out
 
@@ -92,7 +92,8 @@ On import the toolchain synthesizes a self-contained bridge crate under
 `<project>/.crossbind/rust-bridges/<name>/` (the user file is embedded via `#[path] mod user;` -
 no copy) plus a `counter.rs.d.ts` next to the source for full editor typing. The native builds
 bundle every app-local surface into ONE super staticlib (`rust-bridges/_app_super`) and link it
-into the app lib (iOS: merged into the force_loaded react-native-crossbind.a; Android: whole-archive).
+into the app lib (iOS: merged into the force_loaded react-native-crossbind.a; Android and Node.js
+addons: whole-archive, on Windows through its keep symbol).
 
 App-local surfaces can use UPSTREAM crates directly - the C++-style model where the app writes
 its own thin surface over a linked library and no crossbind package is involved. Declare the crates
@@ -165,7 +166,10 @@ constructor share one object), and is linked lazily with that symbol pinned
 (iOS `-Wl,-u,_crossbind_keep_<lib>`, Android `-Wl,--undefined=crossbind_keep_<lib>`) - the registration
 object is pulled, libstd stays lazy and deduplicates. Manual-bindings crates (no keep symbol)
 still fall back to force_load/whole-archive and are therefore safe only as the app's single
-Rust archive.
+Rust archive. On Windows the super staticlib links lazily too: two crates in it may import one
+DLL through raw-dylib (std and getrandom both import `ProcessPrng`), and lld cannot load the
+repeated import tables whole. There the link pins `crossbind_keep_crossbind_app_super()`, which
+reaches the keep symbol each app bridge exports; the super builds every bridge as one object.
 
 Web specifics: wasm-ld's `-u` does NOT pull archive members, so the wasm link pins keep symbols
 with `-Wl,--export=crossbind_keep_<lib>` instead; and any Rust archive in the link makes `buildWasm`
@@ -181,17 +185,20 @@ Generation rules (`crossbind/src/utils/rustBridgeGen.js`, run by `buildCargo` be
 |---|---|
 | `#[repr(i32)] pub enum Mode { Slow = 0, .. }` | embind enum |
 | `#[repr(C)] #[derive(..Default, Copy..)] pub struct Point { pub x: i32, .. }` | value object `{x, ..}` |
-| `pub fn new(..) -> Self` | constructor (max 3 args) |
-| other `pub fn ..(..) -> Self` | `smart_ptr` + static factory (max 2 args) |
-| `pub fn m(&mut self / &self, ..) -> R` | method (max 4 args), JS name camelCased |
+| `pub fn new(..) -> Self` | constructor (max 7 args) |
+| other `pub fn ..(..) -> Self` | `smart_ptr` + static factory (max 6 args) |
+| `pub fn m(&mut self / &self, ..) -> R` | method (max 6 args), JS name camelCased |
 | `text: &str` / `text: &String` parameter | `string` on the wire, borrowed at the call site |
 | `i64` / `u64` param, return or field | JS **BigInt** (full 64-bit range, sign-correct) |
-| top-level `pub fn f(..) -> R` | module-level free function (max 4 args), camelCased |
+| top-level `pub fn f(..) -> R` | module-level free function (max 6 args), camelCased |
 | `impl Display for C` | `toString()` on the class (so `` `${obj}` `` formats) |
 | `-> Result<T, E>` (ctor, factory, method or free fn; `E: Display`) | Err becomes a **thrown JS exception** |
 | `-> Option<Self>` (factory) | None becomes **JS null** (typed `X \| null`) |
 | `-> Option<i32 / f64 / bool / String>` (method or free fn) | Some -> value, None -> **null** (typed `T \| null`) |
 | `Option<i32 / f64 / bool / String>` parameter | JS undefined/null -> None (typed `T \| null \| undefined`) |
+| `Option<i64 / u64>` parameter (`JsBigIntOptArg<T>`) | a BigInt or safe-integer Number; undefined/null -> None (typed `bigint \| null \| undefined`) |
+| `Option<&[u8] / &[f64]>` parameter (`JsViewOptArg<T>`) | the typed array, read as for `&[T]`; undefined/null -> None |
+| `NonZeroU64` (and the other `NonZero` integers) parameter, also in `Option` where the integer's `Option` crosses | the integer; 0 is a thrown JS exception before the call |
 | `other: &SomeClass` parameter | pass another bound instance (borrowed for the call) |
 | `export.bindings.vectors: [{ of: 'i32', name: '..' }]` in crossbind.config.mjs | `register_vector` |
 
@@ -207,30 +214,26 @@ scattered `Box::leak`.
 
 ## Test
 
-`pnpm e2e:prod` runs two legs (needs Rust + the emscripten target + a local emsdk):
-
-1. **web** - `demo` crate → wasm, linked with `adapters/web.cpp` + `-lembind`, called from
-   node. The class is materialized by **unmodified embind-js**.
-2. **mobile-shape** - same crate compiled native, run against a jsi-*shaped* mock consumer
-   that mirrors embind-jsi's real signatures. Validates the adapter's wrapping /
-   marshalling / param-dropping.
+The conformance kit calls the `demo` crate's classes and functions (the `rust:` checks in
+`e2e/conformance/spec/run.mjs`) on every leg listed in `e2e/conformance/README.md`: through
+`adapters/web.cpp` and **unmodified embind-js** on the wasm legs, through `adapters/jsi.cpp` on
+React Native and native Node.js. `e2e/conformance-rust` checks each Rust construct in more depth.
 
 ## Status matrix
 
 | Path | State |
 |---|---|
 | web: Rust → flat ABI → embind-js (emsdk 5.0.3, 6.0.2 & 6.0.9) | ✅ tested, runs (full demo incl. f64 + string) |
-| mobile: adapter shape vs real embind-jsi signatures | ✅ shape-validated (native mock) |
 | mobile: real Hermes / device smoke (iOS simulator, RN app) | ✅ GREEN 32/32 — ctor, N-arity, bool, enum, string both ways, value object both ways, vector, smart_ptr factory, f64 both ways, delete, app-local .rs, idioms, BigInt, Display, free fns, Option both ways, class params, semver/regex imports |
 | mobile: real Hermes / device smoke (Android emulator, same RN app) | ✅ GREEN 32/32 — same demo, same adapter; cargo dep joins the cmake depends graph, keep-symbol linked; a NEW bare-crate import now links in the FIRST build (rust set busts the CMake configure) |
 | app-local `.rs` import (`./native/counter.rs`, both mobile platforms) | ✅ GREEN — synthesized bridge crate + app super staticlib + typed `counter.rs.d.ts` |
 | typed package import (`import { X } from '@crossbind/embind-rust-demo'`) | ✅ GREEN on iOS, Android AND web (vite) — resolver + proxy module + generated d.ts; web verified by playwright on chromium/firefox/webkit |
 | real-world upstream crate, packageless (`geo` via `cargoDependencies` + app-local surface) | ✅ GREEN — Hull (ConvexHull) on iOS + Android (26/26 smoke) AND in the browser (worker-mode playwright, 3 browsers): the same surface .rs serves all three platforms — a wasm output upstream geo never shipped |
-| Rust idioms: `&str`/`&String` params, `Result` → JS exception, `Option<Self>` → null | ✅ GREEN — e2e (web + jsi-mock legs), worker-mode playwright on 3 browsers, iOS sim + Android emulator (throw message, null, borrowed str all asserted) |
-| i64/u64 → BigInt, `impl Display` → toString(), top-level free functions | ✅ GREEN — same full bar (e2e both legs, 3-browser worker playwright, both devices); u64::MAX round-trips exactly, free `Result` fns throw |
+| Rust idioms: `&str`/`&String` params, `Result` → JS exception, `Option<Self>` → null | ✅ GREEN — conformance kit on every leg, worker-mode playwright on 3 browsers, iOS sim + Android emulator (throw message, null, borrowed str all asserted) |
+| i64/u64 → BigInt, `impl Display` → toString(), top-level free functions | ✅ GREEN — same full bar (conformance kit on every leg, 3-browser worker playwright, both devices); u64::MAX round-trips exactly, free `Result` fns throw |
 | DIRECT crate import (`import { Uuid } from 'cargo:uuid'` — untouched crates.io source, multi-file parse, feature-gated modules) | ✅ GREEN — worker-mode playwright on 3 browsers + iOS sim + Android emulator 26/26 (newV4 format, parse roundtrip, Display toString, Err throws) |
-| `Option<i32/f64/bool/String>` returns → value-or-null | ✅ GREEN — e2e both legs (mock reads the nullable cell natively), 3-browser worker playwright, both devices |
-| Option params + `&SomeClass` params + re-export following (`semver` matches, `regex` throwing ctor as DIRECT imports) | ✅ GREEN — e2e both legs, 3-browser worker playwright, Android 32/32 + iOS 32/32 — via the explicit cargo: scheme, so npm names never collide |
+| `Option<i32/f64/bool/String>` returns → value-or-null | ✅ GREEN — conformance kit on every leg, 3-browser worker playwright, both devices |
+| Option params + `&SomeClass` params + re-export following (`semver` matches, `regex` throwing ctor as DIRECT imports) | ✅ GREEN — conformance kit on every leg, 3-browser worker playwright, Android 32/32 + iOS 32/32 — via the explicit cargo: scheme, so npm names never collide |
 | Rust crate → real mobile archives (android/ios arm64) | ✅ compiles; iOS and Android linked+run |
 
 ### Wire contract notes (native vs wasm)

package/adapters/jsi.cpp

@@ -29,11 +29,13 @@
 #include <optional>
 #include <string>
 #include <typeinfo>
+#include <unordered_map>
 #include <unordered_set>
 // Real embind-jsi declarations (correct namespaces/linkage/signatures): jsRuntime lives in
 // `emscripten`, the _embind_register_* functions and InitFunc in `emscripten::internal` with C++
 // linkage and jsi::Function& slots. Including its header avoids any hand-declaration mismatch.
 #include <emscripten/bind.h>
+#include <crossbind/direct_reads.h>
 #include "../include/crossbind_embind.h"
 
 namespace jsi = facebook::jsi;
@@ -68,6 +70,12 @@ const void* crossbind_tid_optional_int() { static const char t = 0; return &t; }
 const void* crossbind_tid_optional_double() { static const char t = 0; return &t; }
 const void* crossbind_tid_optional_bool() { static const char t = 0; return &t; }
 const void* crossbind_tid_optional_string() { static const char t = 0; return &t; }
+const void* crossbind_tid_optional_int64() { static const char t = 0; return &t; }
+const void* crossbind_tid_optional_uint64() { static const char t = 0; return &t; }
+const void* crossbind_tid_bytes_arg() { static const char t = 0; return &t; }
+const void* crossbind_tid_f64s_arg() { static const char t = 0; return &t; }
+const void* crossbind_tid_bytes_opt_arg() { static const char t = 0; return &t; }
+const void* crossbind_tid_f64s_opt_arg() { static const char t = 0; return &t; }
 
 // Idempotent: every Rust archive in the app may ask for the same optional type.
 void crossbind_embind_register_optional(const void* opt, const void* /*inner: adapter converts*/) {
@@ -129,17 +137,62 @@ static uint8_t* crossbindWireFromString(const std::string& s) {
     std::memcpy(w + 4, s.data(), s.size());
     return w;
 }
-static jsi::Function crossbindHelper(const char* name) {
-    return jsRuntime->global().getPropertyAsFunction(*jsRuntime, name);
+// Helpers and constructors are looked up once per runtime: a global lookup on every call cost more
+// than the call. Each bindings initialisation starts a new cache; the old one is leaked on purpose,
+// because the runtime its functions belong to may already be gone.
+static std::unordered_map<const char*, jsi::Function>* g_helpers = new std::unordered_map<const char*, jsi::Function>();
+struct ViewNames {
+    jsi::PropNameID buffer;
+    jsi::PropNameID byteOffset;
+    jsi::PropNameID length;
+};
+static ViewNames* g_viewNames = nullptr;
+static void resetHelpers() {
+    g_helpers = new std::unordered_map<const char*, jsi::Function>();
+    g_viewNames = nullptr;
+}
+static InitFunc g_resetHelpersOnInit(resetHelpers);
+
+static ViewNames& viewNames(jsi::Runtime& rt) {
+    if (g_viewNames == nullptr) {
+        g_viewNames = new ViewNames{jsi::PropNameID::forAscii(rt, "buffer"), jsi::PropNameID::forAscii(rt, "byteOffset"),
+                                    jsi::PropNameID::forAscii(rt, "length")};
+    }
+    return *g_viewNames;
+}
+
+// Typed array arguments ('y' bytes, 'z' doubles; 'Y'/'Z' when optional): embind-jsi hands the
+// invoker the view itself, or null for a missing optional one.
+static void registerTypedArgs() {
+    auto& rt = *jsRuntime;
+    auto registerTypedArg = rt.global().getPropertyAsFunction(rt, "__crossbind_register_typed_arg");
+    registerTypedArg.call(rt, jsi::BigInt::fromUint64(rt, (uint64_t)(uintptr_t)crossbind_tid_bytes_arg()), "Uint8Array", false, false);
+    registerTypedArg.call(rt, jsi::BigInt::fromUint64(rt, (uint64_t)(uintptr_t)crossbind_tid_f64s_arg()), "Float64Array", true, false);
+    registerTypedArg.call(rt, jsi::BigInt::fromUint64(rt, (uint64_t)(uintptr_t)crossbind_tid_bytes_opt_arg()), "Uint8Array | null", false, true);
+    registerTypedArg.call(rt, jsi::BigInt::fromUint64(rt, (uint64_t)(uintptr_t)crossbind_tid_f64s_opt_arg()), "Float64Array | null", true, true);
+}
+static InitFunc g_registerTypedArgsOnInit(registerTypedArgs);
+
+// `name` must be a string literal: the cache is keyed by its address.
+static jsi::Function& crossbindHelper(const char* name) {
+    auto found = g_helpers->find(name);
+    if (found == g_helpers->end()) {
+        found = g_helpers->emplace(name, jsRuntime->global().getPropertyAsFunction(*jsRuntime, name)).first;
+    }
+    return found->second;
 }
 static thread_local std::string g_cbError;
 static thread_local bool g_hasCbError = false;
 
 extern "C" {
+// Rust values holding JS handles can outlive the runtime (thread-local ones drop inside exit(),
+// after the host cleared jsRuntime); their handles then have nothing left to release.
 void crossbind_v_ref(size_t h) {
+    if (jsRuntime == nullptr) return;
     crossbindHelper("__emval_incref").call(*jsRuntime, crossbindVHandle(h));
 }
 void crossbind_v_unref(size_t h) {
+    if (jsRuntime == nullptr) return;
     crossbindHelper("__emval_decref").call(*jsRuntime, crossbindVHandle(h));
 }
 // Fork emval constants: undefined = 1n (init_emval seeds 1..4, reserved = 5).
@@ -202,46 +255,54 @@ static thread_local bool g_hasPendingError = false;
 
 static thread_local std::string g_pendingErrorCode;
 
-// Typed arrays on the native runtime: the adapter builds the JS view and hands back its handle,
-// one copy in each direction.
-// jsi::Object carries no index setter, so the elements go into a jsi::Array first and the
-// TypedArray constructor copies them (`new Uint8Array([...])`).
-static jsi::Object typedArrayFrom(jsi::Runtime& rt, const char* ctor, jsi::Array values) {
-    return rt.global().getPropertyAsFunction(rt, ctor)
-        .callAsConstructor(rt, values).asObject(rt);
+// Typed arrays on the native runtime: one copy in each direction, through the backing store of an
+// array JavaScript allocated, so no ArrayBuffer ever wraps native memory. Copying element by element
+// through jsi cost about 100 ns a byte.
+static size_t typedArrayToJs(jsi::Runtime& rt, const char* ctor, const void* data, size_t length, size_t bytes) {
+    auto array = crossbindHelper(ctor).callAsConstructor(rt, (double)length).asObject(rt);
+    if (bytes) std::memcpy(array.getPropertyAsObject(rt, "buffer").getArrayBuffer(rt).data(rt), data, bytes);
+    return (size_t)crossbindHandleOf(crossbindHelper("__crossbind_v_from_value").call(rt, array));
+}
+
+// A view of one of `kinds` is copied straight out of its backing store; false leaves a plain array
+// or another view to the element-by-element path.
+static bool typedArrayFromJs(jsi::Runtime& rt, size_t h, std::initializer_list<const char*> kinds, void* out, size_t bytes) {
+    auto value = crossbindHelper("__crossbind_v_value").call(rt, crossbindVHandle(h));
+    if (!value.isObject()) return false;
+    auto view = value.getObject(rt);
+    bool isKind = false;
+    for (const char* kind : kinds) isKind = isKind || view.instanceOf(rt, crossbindHelper(kind));
+    if (!isKind) return false;
+    auto buffer = view.getPropertyAsObject(rt, "buffer");
+    if (!buffer.isArrayBuffer(rt)) return false;
+    auto offset = (size_t)view.getProperty(rt, "byteOffset").getNumber();
+    if (bytes) std::memcpy(out, buffer.getArrayBuffer(rt).data(rt) + offset, bytes);
+    return true;
 }
 
 extern "C" size_t crossbind_v_bytes_to_js(const uint8_t* data, unsigned len) {
-    auto& rt = *jsRuntime;
-    auto values = jsi::Array(rt, (size_t)len);
-    for (unsigned i = 0; i < len; ++i) values.setValueAtIndex(rt, i, jsi::Value((double)data[i]));
-    auto array = typedArrayFrom(rt, "Uint8Array", std::move(values));
-    return (size_t)crossbindHandleOf(crossbindHelper("__crossbind_v_from_value").call(rt, array));
+    return typedArrayToJs(*jsRuntime, "Uint8Array", data, len, len);
 }
 
 extern "C" size_t crossbind_v_f64s_to_js(const double* data, unsigned len) {
-    auto& rt = *jsRuntime;
-    auto values = jsi::Array(rt, (size_t)len);
-    for (unsigned i = 0; i < len; ++i) values.setValueAtIndex(rt, i, jsi::Value(data[i]));
-    auto array = typedArrayFrom(rt, "Float64Array", std::move(values));
-    return (size_t)crossbindHandleOf(crossbindHelper("__crossbind_v_from_value").call(rt, array));
+    return typedArrayToJs(*jsRuntime, "Float64Array", data, len, (size_t)len * sizeof(double));
 }
 
 extern "C" unsigned crossbind_v_typed_len(size_t h) {
-    auto& rt = *jsRuntime;
-    auto value = crossbindHelper("__crossbind_v_get").call(rt, crossbindVHandle(h), jsi::String::createFromAscii(rt, "length"));
-    auto number = crossbindHelper("__crossbind_v_as_num").call(rt, value);
+    auto number = crossbindHelper("__crossbind_v_length").call(*jsRuntime, crossbindVHandle(h));
     return number.isNumber() ? (unsigned)number.getNumber() : 0;
 }
 
 extern "C" void crossbind_v_bytes_from_js(size_t h, uint8_t* out, unsigned len) {
     auto& rt = *jsRuntime;
+    if (typedArrayFromJs(rt, h, {"Uint8Array", "Uint8ClampedArray", "Int8Array"}, out, len)) return;
     auto array = crossbindHelper("__crossbind_v_to_array").call(rt, crossbindVHandle(h)).asObject(rt).asArray(rt);
     for (unsigned i = 0; i < len; ++i) out[i] = (uint8_t)array.getValueAtIndex(rt, i).getNumber();
 }
 
 extern "C" void crossbind_v_f64s_from_js(size_t h, double* out, unsigned len) {
     auto& rt = *jsRuntime;
+    if (typedArrayFromJs(rt, h, {"Float64Array"}, out, (size_t)len * sizeof(double))) return;
     auto array = crossbindHelper("__crossbind_v_to_array").call(rt, crossbindVHandle(h)).asObject(rt).asArray(rt);
     for (unsigned i = 0; i < len; ++i) out[i] = array.getValueAtIndex(rt, i).getNumber();
 }
@@ -280,7 +341,49 @@ static jsi::Value wireStringToJsi(jsi::Runtime& rt, uint64_t w) {
     return jsi::Value(jsi::String::createFromUtf8(rt, str));
 }
 
-static uint64_t readArg(jsi::Runtime& rt, const jsi::Value& v, char c) {
+// Where a typed array argument's elements are: the crate's ViewWire.
+struct ViewWire {
+    const void* data;
+    size_t length;
+};
+
+static crossbind::IDirectReads* directReads(jsi::Runtime& rt) {
+    return static_cast<crossbind::IDirectReads*>(rt.castInterface(crossbind::IDirectReads::uuid));
+}
+
+// embind-jsi's toWireType already made the argument a view of the element kind over an ArrayBuffer,
+// so its elements are lent in place for the call. Reading its properties through the Node-API
+// runtime cost about 440 ns, which the runtime's own interface does in one call.
+static uint64_t readView(jsi::Runtime& rt, const jsi::Value& v, ViewWire& view) {
+    auto* reads = directReads(rt);
+    void* data = nullptr;
+    size_t length = 0;
+    if (reads != nullptr && reads->typedArrayElements(v, data, length)) {
+        view.data = data;
+        view.length = length;
+        return (uint64_t)(uintptr_t)&view;
+    }
+    auto& names = viewNames(rt);
+    auto object = v.asObject(rt);
+    auto buffer = object.getProperty(rt, names.buffer).asObject(rt);
+    if (!buffer.isArrayBuffer(rt)) throw jsi::JSError(rt, "a typed array argument needs an ArrayBuffer");
+    view.length = (size_t)object.getProperty(rt, names.length).asNumber();
+    view.data = view.length == 0 ? nullptr
+        : buffer.getArrayBuffer(rt).data(rt) + (size_t)object.getProperty(rt, names.byteOffset).asNumber();
+    return (uint64_t)(uintptr_t)&view;
+}
+
+static uint64_t readArg(jsi::Runtime& rt, const jsi::Value& v, char c, ViewWire& view) {
+    if (c == 'y' || c == 'z') return readView(rt, v, view);
+    if (c == 'Y' || c == 'Z') return v.isUndefined() || v.isNull() ? 0 : readView(rt, v, view);
+    // Optional 64-bit args ('J'/'U'): the value a plain 'j'/'u' takes, in a cell this adapter frees.
+    if (c == 'J' || c == 'U') {
+        if (v.isUndefined() || v.isNull()) return 0;
+        uint64_t bits = readArg(rt, v, c == 'J' ? 'j' : 'u', view);
+        void* cell = std::malloc(8);
+        std::memcpy(cell, &bits, 8);
+        return (uint64_t)(uintptr_t)cell;
+    }
     if (c == 's') {
         // embind-jsi passes std::string args as a jsi::String; build the crate's [u32 len][bytes]
         // wire buffer here (freed by the caller after dispatch - the crate's from_wire only copies).
@@ -303,7 +406,12 @@ static uint64_t readArg(jsi::Runtime& rt, const jsi::Value& v, char c) {
     // i64/u64 ('j'/'u') arrive as JS BigInt (embind bigint types), Number accepted as a courtesy;
     // both directions are raw 64-bit slots, so the unsigned bit copy is sign-correct either way.
     if (c == 'j' || c == 'u') {
-        if (v.isBigInt()) return v.getBigInt(rt).getUint64(rt);
+        if (v.isBigInt()) {
+            auto* reads = directReads(rt);
+            uint64_t bits = 0;
+            bool lossless = false;
+            return reads != nullptr && reads->bigIntToUint64(v, bits, lossless) ? bits : v.getBigInt(rt).getUint64(rt);
+        }
         // A Number is accepted only while it is an exact integer JS can represent; anything
         // else would be truncated silently, and a 64-bit slot deserves the exact value.
         double d = v.isNumber() ? v.getNumber() : 0;
@@ -316,7 +424,7 @@ static uint64_t readArg(jsi::Runtime& rt, const jsi::Value& v, char c) {
     // adapter owns and frees after dispatch ('S' carries a plain string wire).
     if (c == 'I' || c == 'D' || c == 'B' || c == 'S') {
         if (v.isUndefined() || v.isNull()) return 0;
-        if (c == 'S') return readArg(rt, v, 's');
+        if (c == 'S') return readArg(rt, v, 's', view);
         if (c == 'I') { int32_t x = (int32_t)v.getNumber(); void* p = std::malloc(4); std::memcpy(p, &x, 4); return (uint64_t)(uintptr_t)p; }
         if (c == 'D') { double x = v.getNumber(); void* p = std::malloc(8); std::memcpy(p, &x, 8); return (uint64_t)(uintptr_t)p; }
         uint8_t b = v.getBool() ? 1 : 0; void* p = std::malloc(1); std::memcpy(p, &b, 1); return (uint64_t)(uintptr_t)p;
@@ -344,10 +452,11 @@ static jsi::Value callInvoker(jsi::Runtime& rt, const std::string& sig, void* in
     // (embind sliced it off), so the jsi args a[0..] fill sig[2..]; otherwise a[0..] fill sig[1..].
     // Widest call: a baked target + `this` + six declared arguments.
     uint64_t s[8] = {0, 0, 0, 0, 0, 0, 0, 0};
+    ViewWire views[8];
     int base = 0;
     if (prepend) { s[0] = ctx; base = 1; }
     // A call with fewer JS args than the signature must not read past the argument array.
-    for (int j = base; j < total && j < 8; ++j) s[j] = (size_t)(j - base) < count ? readArg(rt, a[j - base], sig[1 + j]) : 0;
+    for (int j = base; j < total && j < 8; ++j) s[j] = (size_t)(j - base) < count ? readArg(rt, a[j - base], sig[1 + j], views[j]) : 0;
 
     uint64_t r = 0;
     if (ret == 'v') {
@@ -380,7 +489,7 @@ static jsi::Value callInvoker(jsi::Runtime& rt, const std::string& sig, void* in
     // now that the crate has copied.
     for (int j = base; j < total && j < 8; ++j) {
         const char cj = sig[1 + j];
-        if (cj == 's' || cj == 'S' || cj == 'I' || cj == 'D' || cj == 'B') std::free((void*)(uintptr_t)s[j]);
+        if (cj == 's' || cj == 'S' || cj == 'I' || cj == 'D' || cj == 'B' || cj == 'J' || cj == 'U') std::free((void*)(uintptr_t)s[j]);
     }
 
     // A shim raised (Result::Err): drop the sentinel return and surface a real JS exception.

package/adapters/web.cpp

@@ -72,9 +72,57 @@ const void* crossbind_tid_optional_int() { static const char t = 0; return &t; }
 const void* crossbind_tid_optional_double() { static const char t = 0; return &t; }
 const void* crossbind_tid_optional_bool() { static const char t = 0; return &t; }
 const void* crossbind_tid_optional_string() { static const char t = 0; return &t; }
+const void* crossbind_tid_optional_int64() { static const char t = 0; return &t; }
+const void* crossbind_tid_optional_uint64() { static const char t = 0; return &t; }
+const void* crossbind_tid_bytes_arg() { static const char t = 0; return &t; }
+const void* crossbind_tid_f64s_arg() { static const char t = 0; return &t; }
+const void* crossbind_tid_bytes_opt_arg() { static const char t = 0; return &t; }
+const void* crossbind_tid_f64s_opt_arg() { static const char t = 0; return &t; }
 
 }
 
+// Typed array arguments: the view is copied once into wasm memory behind a { data, length } header
+// (the crate's ViewWire) and freed after the call. Another typed array or a plain array is converted
+// element by element first. An optional one passes null or undefined as a null pointer.
+EM_JS_DEPS(crossbind_typed_arg_deps, "$registerType,$throwBindingError,$embindRepr");
+EM_JS(void, crossbind_register_typed_arg, (const void* rawType, const char* name, int isDoubles, int isOptional), {
+    const typeName = UTF8ToString(name);
+    const View = isDoubles ? Float64Array : Uint8Array;
+    const isLent = isDoubles
+        ? (value) => value instanceof Float64Array
+        : (value) => value instanceof Uint8Array || value instanceof Uint8ClampedArray || value instanceof Int8Array;
+    registerType(rawType, {
+        name: typeName,
+        toWireType(destructors, value) {
+            if (isOptional && (value === null || value === undefined)) return 0;
+            if (!isLent(value)) {
+                if (!Array.isArray(value) && !(ArrayBuffer.isView(value) && !(value instanceof DataView))) {
+                    throwBindingError(`Cannot pass ${embindRepr(value)} as a ${typeName}`);
+                }
+                value = View.from(value);
+            }
+            const base = _malloc(8 + value.byteLength);
+            if (!base) throwBindingError(`Cannot copy ${value.byteLength} bytes into wasm memory`);
+            HEAPU32[base >> 2] = base + 8;
+            HEAPU32[(base >> 2) + 1] = value.length;
+            if (isDoubles) HEAPF64.set(value, (base + 8) >> 3);
+            else HEAPU8.set(value, base + 8);
+            if (destructors !== null) destructors.push(_free, base);
+            return base;
+        },
+        destructorFunction(ptr) {
+            _free(ptr);
+        },
+    });
+});
+
+EMSCRIPTEN_BINDINGS(crossbind_typed_args) {
+    crossbind_register_typed_arg(crossbind_tid_bytes_arg(), "Uint8Array", 0, 0);
+    crossbind_register_typed_arg(crossbind_tid_f64s_arg(), "Float64Array", 1, 0);
+    crossbind_register_typed_arg(crossbind_tid_bytes_opt_arg(), "Uint8Array | null", 0, 1);
+    crossbind_register_typed_arg(crossbind_tid_f64s_opt_arg(), "Float64Array | null", 1, 1);
+}
+
 // Optional wire on wasm is an EM_VAL handle (None = the reserved null constant from
 // emscripten's own header: a missing value is null on every runtime, like C++ nullptr). Some-values become handles through Emval.toHandle; the registered
 // optional type's fromWireType does toValue + decref, so the refcount stays balanced.
@@ -118,6 +166,14 @@ int crossbind_emval_opt_bool(void* h, uint8_t* out) {
     *out = v.as<bool>() ? 1 : 0;
     return 1;
 }
+// A 64-bit optional reads through the registered bigint type, so it takes what a plain 64-bit
+// parameter takes: a BigInt or a safe-integer Number.
+int crossbind_emval_opt_bits64(void* h, uint64_t* out, int isSigned) {
+    emscripten::val v = emscripten::val::take_ownership((emscripten::EM_VAL)h);
+    if (v.isUndefined() || v.isNull()) return 0;
+    *out = isSigned ? (uint64_t)v.as<int64_t>() : v.as<uint64_t>();
+    return 1;
+}
 int crossbind_emval_opt_string(void* h, uint8_t** out) {
     emscripten::val v = emscripten::val::take_ownership((emscripten::EM_VAL)h);
     if (v.isUndefined() || v.isNull()) return 0;

package/crate/src/lib.rs

@@ -173,7 +173,9 @@ macro_rules! bindings {
             }
             #[used]
             #[cfg_attr(target_vendor = "apple", link_section = "__DATA,__mod_init_func")]
-            #[cfg_attr(not(target_vendor = "apple"), link_section = ".init_array")]
+            // The Windows CRT runs no .init_array; it calls what .CRT$XCU holds when the DLL loads.
+            #[cfg_attr(windows, link_section = ".CRT$XCU")]
+            #[cfg_attr(not(any(target_vendor = "apple", windows)), link_section = ".init_array")]
             static __CROSSBIND_EMBIND_CTOR: extern "C" fn() = __crossbind_embind_ctor;
         };
     };
@@ -418,6 +420,65 @@ option_wire! {
     String, crossbind_tid_optional_string, 'S';
 }
 
+extern "C" {
+    fn crossbind_tid_optional_int64() -> *const c_void;
+    fn crossbind_tid_optional_uint64() -> *const c_void;
+}
+#[cfg(target_family = "wasm")]
+extern "C" {
+    fn crossbind_emval_opt_bits64(handle: usize, out: *mut u64, signed: i32) -> i32;
+}
+
+mod sealed {
+    pub trait Sealed {}
+    impl Sealed for i64 {}
+    impl Sealed for u64 {}
+}
+
+#[doc(hidden)]
+pub trait BigIntElement: sealed::Sealed + Copy + 'static {
+    const SIGNED: bool;
+}
+impl BigIntElement for i64 { const SIGNED: bool = true; }
+impl BigIntElement for u64 { const SIGNED: bool = false; }
+
+/// An `Option<i64>` / `Option<u64>` parameter: a BigInt or a safe-integer Number, null or undefined
+/// for `None`. Generic, so it is compiled into the crate that uses it and a cargo archive built
+/// before it existed still links next to one built after.
+pub struct JsBigIntOptArg<T>(pub Option<T>);
+
+impl<T: BigIntElement> WireType for JsBigIntOptArg<T> {
+    #[cfg(target_family = "wasm")]
+    type Wire = usize;
+    #[cfg(not(target_family = "wasm"))]
+    type Wire = *mut u8;
+    #[cfg(target_family = "wasm")]
+    const SIG: char = 'i';
+    #[cfg(not(target_family = "wasm"))]
+    const SIG: char = if T::SIGNED { 'J' } else { 'U' };
+    fn tid() -> *const c_void {
+        unsafe { if T::SIGNED { crossbind_tid_optional_int64() } else { crossbind_tid_optional_uint64() } }
+    }
+    #[cfg(target_family = "wasm")]
+    fn from_wire(w: usize) -> Self {
+        let mut bits: u64 = 0;
+        if unsafe { crossbind_emval_opt_bits64(w, &mut bits, T::SIGNED as i32) } == 0 { return JsBigIntOptArg(None); }
+        JsBigIntOptArg(Some(unsafe { core::mem::transmute_copy::<u64, T>(&bits) }))
+    }
+    #[cfg(not(target_family = "wasm"))]
+    fn from_wire(w: *mut u8) -> Self {
+        if w.is_null() { return JsBigIntOptArg(None); }
+        JsBigIntOptArg(Some(unsafe { core::ptr::read_unaligned(w as *const T) }))
+    }
+    fn to_wire(self) -> Self::Wire { unreachable!("an optional 64-bit integer is only a parameter") }
+}
+
+/// Registers the optional type a `JsBigIntOptArg<T>` parameter names (adapter-idempotent).
+pub fn register_optional_bigint<T: BigIntElement>() {
+    let inner = unsafe { if T::SIGNED { crossbind_tid_int64() } else { crossbind_tid_uint64() } };
+    unsafe { crossbind_embind_register_optional(<JsBigIntOptArg<T> as WireType>::tid(), inner) };
+}
+
 // wasm Some-path: hand the inner's in-memory repr to _emval_take_value. JS copies the value
 // synchronously, so stack temporaries suffice; the string wire is freed by embind itself.
 #[cfg(target_family = "wasm")]
@@ -879,6 +940,102 @@ impl WireType for JsF64s {
 impl ErrSentinel for JsBytes { fn err_sentinel() -> Self { JsBytes(Vec::new()) } }
 impl ErrSentinel for JsF64s { fn err_sentinel() -> Self { JsF64s(Vec::new()) } }
 
+extern "C" {
+    fn crossbind_tid_bytes_arg() -> *const c_void;
+    fn crossbind_tid_f64s_arg() -> *const c_void;
+}
+
+// A typed array argument reaches the adapter as the JS view itself, and the adapter says where its
+// elements are: in the view's own backing store on the native runtime, in a copy in wasm memory on
+// the web. Either stays valid until the call returns.
+#[repr(C)]
+struct ViewWire {
+    data: *const c_void,
+    length: usize,
+}
+
+#[doc(hidden)]
+pub trait ViewElement: Copy + 'static {
+    const NATIVE_SIG: char;
+    fn tid() -> *const c_void;
+}
+
+impl ViewElement for u8 {
+    const NATIVE_SIG: char = 'y';
+    fn tid() -> *const c_void { unsafe { crossbind_tid_bytes_arg() } }
+}
+
+impl ViewElement for f64 {
+    const NATIVE_SIG: char = 'z';
+    fn tid() -> *const c_void { unsafe { crossbind_tid_f64s_arg() } }
+}
+
+/// A byte or double parameter: `&[T]` reads the caller's view in place, `Vec<T>` copies it once.
+pub struct JsViewArg<T> {
+    data: *const T,
+    length: usize,
+}
+
+pub type JsBytesArg = JsViewArg<u8>;
+pub type JsF64sArg = JsViewArg<f64>;
+
+impl<T: ViewElement> JsViewArg<T> {
+    pub fn as_slice(&self) -> &[T] {
+        if self.length == 0 { &[] } else { unsafe { std::slice::from_raw_parts(self.data, self.length) } }
+    }
+    pub fn to_vec(&self) -> Vec<T> {
+        self.as_slice().to_vec()
+    }
+}
+
+impl<T: ViewElement> WireType for JsViewArg<T> {
+    type Wire = usize;
+    #[cfg(target_family = "wasm")]
+    const SIG: char = 'p';
+    #[cfg(not(target_family = "wasm"))]
+    const SIG: char = T::NATIVE_SIG;
+    fn tid() -> *const c_void { T::tid() }
+    fn from_wire(w: usize) -> Self {
+        if w == 0 { return JsViewArg { data: core::ptr::null(), length: 0 }; }
+        let view = unsafe { &*(w as *const ViewWire) };
+        JsViewArg { data: view.data as *const T, length: view.length }
+    }
+    fn to_wire(self) -> usize { unreachable!("a typed array argument is never returned") }
+}
+
+extern "C" {
+    fn crossbind_tid_bytes_opt_arg() -> *const c_void;
+    fn crossbind_tid_f64s_opt_arg() -> *const c_void;
+}
+
+/// An `Option<&[T]>` parameter: null or undefined is `None`, a view is read as for `JsViewArg`.
+/// Generic like `JsBigIntOptArg`, for the same reason.
+pub struct JsViewOptArg<T>(Option<JsViewArg<T>>);
+
+pub type JsBytesOptArg = JsViewOptArg<u8>;
+pub type JsF64sOptArg = JsViewOptArg<f64>;
+
+impl<T: ViewElement> JsViewOptArg<T> {
+    pub fn as_slice(&self) -> Option<&[T]> {
+        self.0.as_ref().map(|view| view.as_slice())
+    }
+}
+
+impl<T: ViewElement> WireType for JsViewOptArg<T> {
+    type Wire = usize;
+    #[cfg(target_family = "wasm")]
+    const SIG: char = 'p';
+    #[cfg(not(target_family = "wasm"))]
+    const SIG: char = if T::NATIVE_SIG == 'y' { 'Y' } else { 'Z' };
+    fn tid() -> *const c_void {
+        unsafe { if T::NATIVE_SIG == 'y' { crossbind_tid_bytes_opt_arg() } else { crossbind_tid_f64s_opt_arg() } }
+    }
+    fn from_wire(w: usize) -> Self {
+        JsViewOptArg(if w == 0 { None } else { Some(JsViewArg::from_wire(w)) })
+    }
+    fn to_wire(self) -> usize { unreachable!("a typed array argument is never returned") }
+}
+
 impl Drop for JsValue {
     fn drop(&mut self) {
         unsafe { crossbind_v_unref(self.handle) };
@@ -1287,6 +1444,10 @@ arc_factories! {
     create_arc0 / arc_factory_invoker0 : ;
     create_arc1 / arc_factory_invoker1 : A0;
     create_arc2 / arc_factory_invoker2 : A0, A1;
+    create_arc3 / arc_factory_invoker3 : A0, A1, A2;
+    create_arc4 / arc_factory_invoker4 : A0, A1, A2, A3;
+    create_arc5 / arc_factory_invoker5 : A0, A1, A2, A3, A4;
+    create_arc6 / arc_factory_invoker6 : A0, A1, A2, A3, A4, A5;
 }
 
 // N-arity constructors: one monomorphized invoker + builder method per argument count.
@@ -1380,6 +1541,7 @@ constructors_ptr! {
     constructor_ptr4 / ctor_ptr_invoker4 : A0, A1, A2, A3;
     constructor_ptr5 / ctor_ptr_invoker5 : A0, A1, A2, A3, A4;
     constructor_ptr6 / ctor_ptr_invoker6 : A0, A1, A2, A3, A4, A5;
+    constructor_ptr7 / ctor_ptr_invoker7 : A0, A1, A2, A3, A4, A5, A6;
 }
 
 // Raw-pointer factory variants: `Result<Self, E>` raises on Err, `Option<Self>` returns null
@@ -1522,3 +1684,45 @@ free_functions! {
     fn5 / free_invoker5 : A0, A1, A2, A3, A4;
     fn6 / free_invoker6 : A0, A1, A2, A3, A4, A5;
 }
+
+// N-arity STATIC functions (`Class.name(..)` in JS): a free function registered on its class,
+// so it rides the free-function invokers. Generic only, so a cargo archive built before these
+// existed still links next to one built after.
+macro_rules! static_functions {
+    ($( $method:ident / $invoker:ident : $($arg:ident),* ; )*) => {
+        impl<T: 'static> ClassBuilder<T> {
+            $(
+                pub fn $method<$($arg: WireType,)* R: WireType>(self, name: &str, f: fn($($arg),*) -> R) -> Self {
+                    let mut sig = String::new();
+                    sig.push(R::SIG); sig.push('p');
+                    let mut args = vec![R::tid()];
+                    $( sig.push(<$arg as WireType>::SIG); args.push(<$arg as WireType>::tid()); )*
+                    let (argc, arg_ptr, name_ptr, sig_ptr);
+                    {
+                        let mut r = registry().lock().unwrap();
+                        argc = args.len() as u32;
+                        arg_ptr = r.argtypes(args);
+                        name_ptr = r.cstr(name);
+                        sig_ptr = r.cstr(&sig);
+                    }
+                    unsafe {
+                        crossbind_embind_register_class_class_function(
+                            self.cls, name_ptr, argc, arg_ptr, sig_ptr,
+                            $invoker::<$($arg,)* R> as *const () as usize, f as *const () as usize, false, false,
+                        );
+                    }
+                    self
+                }
+            )*
+        }
+    };
+}
+static_functions! {
+    static_function0 / free_invoker0 : ;
+    static_function1 / free_invoker1 : A0;
+    static_function2 / free_invoker2 : A0, A1;
+    static_function3 / free_invoker3 : A0, A1, A2;
+    static_function4 / free_invoker4 : A0, A1, A2, A3;
+    static_function5 / free_invoker5 : A0, A1, A2, A3, A4;
+    static_function6 / free_invoker6 : A0, A1, A2, A3, A4, A5;
+}

package/include/crossbind_embind.h

@@ -33,6 +33,8 @@ CrossbindTid crossbind_tid_optional_int(void);
 CrossbindTid crossbind_tid_optional_double(void);
 CrossbindTid crossbind_tid_optional_bool(void);
 CrossbindTid crossbind_tid_optional_string(void);
+CrossbindTid crossbind_tid_optional_int64(void);
+CrossbindTid crossbind_tid_optional_uint64(void);
 void crossbind_embind_register_smart_ptr(
     CrossbindTid ptr_ty, CrossbindTid pointee_ty, const char* name, int sharing_policy,
     const char* gp_sig, CrossbindFn get_pointee, const char* ctor_sig, CrossbindFn constructor,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@crossbind/core-embind-rust",
-  "version": "2.0.0-beta.60",
+  "version": "2.0.0-beta.63",
   "description": "Rust producer for the crossbind embind registration protocol - bind Rust structs as classes reachable from JS on web (embind) and mobile (embind-jsi). Research/spike stage.",
   "homepage": "https://github.com/crossbind/crossbind/tree/main/core/embind-rust#readme",
   "repository": {
@@ -19,7 +19,6 @@
     "react-native"
   ],
   "scripts": {
-    "e2e:prod": "node e2e/run.mjs",
-    "clear": "rm -rf crate/target demo/target e2e/demo.mjs e2e/demo.wasm e2e/jsi-shape-check"
+    "clear": "rm -rf crate/target demo/target"
   }
 }