@crossbind/core-embind-rust 2.0.0-beta.56 → 2.0.0-beta.58

package/README.md

@@ -190,7 +190,7 @@ Generation rules (`crossbind/src/utils/rustBridgeGen.js`, run by `buildCargo` be
 | `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 -> **undefined** (typed `T \| undefined`) |
+| `-> 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`) |
 | `other: &SomeClass` parameter | pass another bound instance (borrowed for the call) |
 | `export.bindings.vectors: [{ of: 'i32', name: '..' }]` in crossbind.config.mjs | `register_vector` |
@@ -229,7 +229,7 @@ scattered `Box::leak`.
 | 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 |
 | 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-undefined | ✅ GREEN — e2e both legs (mock reads the nullable cell natively), 3-browser worker playwright, both devices |
+| `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 |
 | Rust crate → real mobile archives (android/ios arm64) | ✅ compiles; iOS and Android linked+run |
 

package/adapters/jsi.cpp

@@ -22,6 +22,7 @@
 // Compiled ONLY inside the RN native module (jsi + embind-jsi headers exist there via build_ios.js).
 
 #include <jsi/jsi.h>
+#include <cmath>
 #include <cstdint>
 #include <cstdlib>
 #include <cstring>
@@ -55,6 +56,12 @@ const void* crossbind_tid_void() { return &typeid(void); }
 const void* crossbind_tid_std_string() { return &typeid(std::string); }
 const void* crossbind_tid_int64() { return &typeid(int64_t); }
 const void* crossbind_tid_uint64() { return &typeid(uint64_t); }
+const void* crossbind_tid_int8() { return &typeid(int8_t); }
+const void* crossbind_tid_int16() { return &typeid(int16_t); }
+const void* crossbind_tid_uint8() { return &typeid(uint8_t); }
+const void* crossbind_tid_uint16() { return &typeid(uint16_t); }
+const void* crossbind_tid_uint32() { return &typeid(uint32_t); }
+const void* crossbind_tid_float() { return &typeid(float); }
 // Adapter-local identities, NOT &typeid(std::optional<T>): linked C++ bindings may register
 // the real optional typeids themselves, and these types never interop with C++ signatures.
 const void* crossbind_tid_optional_int() { static const char t = 0; return &t; }
@@ -193,6 +200,63 @@ uint8_t* crossbind_v_cb_err_take() {
 static thread_local std::string g_pendingError;
 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);
+}
+
+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));
+}
+
+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));
+}
+
+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);
+    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;
+    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;
+    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();
+}
+
+extern "C" void crossbind_embind_raise_error(uint8_t* w);
+
+extern "C" void crossbind_embind_raise_error_coded(uint8_t* w, uint8_t* c) {
+    crossbind_embind_raise_error(w);
+    if (!c) { g_pendingErrorCode.clear(); return; }
+    uint32_t len;
+    std::memcpy(&len, c, 4);
+    g_pendingErrorCode.assign((const char*)(c + 4), (size_t)len);
+    std::free(c);
+}
+
 extern "C" void crossbind_embind_raise_error(uint8_t* w) {
     uint32_t len;
     std::memcpy(&len, w, 4);
@@ -238,7 +302,16 @@ 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') return v.isBigInt() ? v.getBigInt(rt).getUint64(rt) : (uint64_t)(int64_t)v.getNumber();
+    if (c == 'j' || c == 'u') {
+        if (v.isBigInt()) return 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;
+        if (!v.isNumber() || d != std::trunc(d) || std::fabs(d) > 9007199254740991.0) {
+            throw jsi::JSError(rt, "a 64-bit integer parameter takes a BigInt or a safe integer Number");
+        }
+        return (uint64_t)(int64_t)d;
+    }
     // Optional args ('I'/'D'/'B'/'S'): undefined/null -> 0 (None); otherwise a heap cell this
     // adapter owns and frees after dispatch ('S' carries a plain string wire).
     if (c == 'I' || c == 'D' || c == 'B' || c == 'S') {
@@ -250,24 +323,31 @@ static uint64_t readArg(jsi::Runtime& rt, const jsi::Value& v, char c) {
     }
     // Pointers (this/handle/value-object wire) arrive as BigInt, int/bool/enum as Number; accept
     // either kind defensively so a host that boxed a pointer as a Number still dispatches correctly.
-    if (c == 'p') return v.isBigInt() ? v.getBigInt(rt).getUint64(rt) : (uint64_t)(int64_t)v.getNumber();
-    return v.isNumber() ? (uint64_t)(int64_t)v.getNumber() : v.getBigInt(rt).getUint64(rt); // 'i'
+    if (c == 'p') return v.isBigInt() ? v.getBigInt(rt).getUint64(rt) : v.isNumber() ? (uint64_t)(int64_t)v.getNumber() : 0;
+    // 'i': ints and enums arrive as numbers, bools as booleans (the int wire carries 0/1). Reading
+    // a BigInt out of anything else is undefined behaviour (Hermes dies in cloneBigInt), so every
+    // other value is 0.
+    if (v.isBool()) return v.getBool() ? 1 : 0;
+    if (v.isNumber()) return (uint64_t)(int64_t)v.getNumber();
+    return v.isBigInt() ? v.getBigInt(rt).getUint64(rt) : 0;
 }
 
 // Bounded-dispatch: every wire kind is integer-class in the invoker's C signature (pointers and
 // ints natively; doubles as bit patterns in u64 - see WireType for f64), so uint64-slot casts are
 // ABI-correct on every native ABI. No FP registers, no libffi; the only bound is the arity cap.
 static jsi::Value callInvoker(jsi::Runtime& rt, const std::string& sig, void* invoker,
-                              const jsi::Value* a, uint64_t ctx, bool prepend) {
+                              const jsi::Value* a, size_t count, uint64_t ctx, bool prepend) {
     const char ret = sig[0];
     const int total = (int)sig.size() - 1;  // C args the raw invoker takes (sig[1..])
 
     // s[0..total-1] are the raw invoker's C args. When prepend, sig[1] is the baked target pointer
     // (embind sliced it off), so the jsi args a[0..] fill sig[2..]; otherwise a[0..] fill sig[1..].
-    uint64_t s[6] = {0, 0, 0, 0, 0, 0};
+    // Widest call: a baked target + `this` + six declared arguments.
+    uint64_t s[8] = {0, 0, 0, 0, 0, 0, 0, 0};
     int base = 0;
     if (prepend) { s[0] = ctx; base = 1; }
-    for (int j = base; j < total && j < 6; ++j) s[j] = readArg(rt, a[j - base], sig[1 + j]);
+    // 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;
 
     uint64_t r = 0;
     if (ret == 'v') {
@@ -278,7 +358,9 @@ static jsi::Value callInvoker(jsi::Runtime& rt, const std::string& sig, void* in
             case 3: ((void(*)(uint64_t, uint64_t, uint64_t))invoker)(s[0], s[1], s[2]); break;
             case 4: ((void(*)(uint64_t, uint64_t, uint64_t, uint64_t))invoker)(s[0], s[1], s[2], s[3]); break;
             case 5: ((void(*)(uint64_t, uint64_t, uint64_t, uint64_t, uint64_t))invoker)(s[0], s[1], s[2], s[3], s[4]); break;
-            default: ((void(*)(uint64_t, uint64_t, uint64_t, uint64_t, uint64_t, uint64_t))invoker)(s[0], s[1], s[2], s[3], s[4], s[5]); break;
+            case 6: ((void(*)(uint64_t, uint64_t, uint64_t, uint64_t, uint64_t, uint64_t))invoker)(s[0], s[1], s[2], s[3], s[4], s[5]); break;
+            case 7: ((void(*)(uint64_t, uint64_t, uint64_t, uint64_t, uint64_t, uint64_t, uint64_t))invoker)(s[0], s[1], s[2], s[3], s[4], s[5], s[6]); break;
+            default: ((void(*)(uint64_t, uint64_t, uint64_t, uint64_t, uint64_t, uint64_t, uint64_t, uint64_t))invoker)(s[0], s[1], s[2], s[3], s[4], s[5], s[6], s[7]); break;
         }
     } else {
         switch (total) {
@@ -288,30 +370,43 @@ static jsi::Value callInvoker(jsi::Runtime& rt, const std::string& sig, void* in
             case 3: r = ((uint64_t(*)(uint64_t, uint64_t, uint64_t))invoker)(s[0], s[1], s[2]); break;
             case 4: r = ((uint64_t(*)(uint64_t, uint64_t, uint64_t, uint64_t))invoker)(s[0], s[1], s[2], s[3]); break;
             case 5: r = ((uint64_t(*)(uint64_t, uint64_t, uint64_t, uint64_t, uint64_t))invoker)(s[0], s[1], s[2], s[3], s[4]); break;
-            default: r = ((uint64_t(*)(uint64_t, uint64_t, uint64_t, uint64_t, uint64_t, uint64_t))invoker)(s[0], s[1], s[2], s[3], s[4], s[5]); break;
+            case 6: r = ((uint64_t(*)(uint64_t, uint64_t, uint64_t, uint64_t, uint64_t, uint64_t))invoker)(s[0], s[1], s[2], s[3], s[4], s[5]); break;
+            case 7: r = ((uint64_t(*)(uint64_t, uint64_t, uint64_t, uint64_t, uint64_t, uint64_t, uint64_t))invoker)(s[0], s[1], s[2], s[3], s[4], s[5], s[6]); break;
+            default: r = ((uint64_t(*)(uint64_t, uint64_t, uint64_t, uint64_t, uint64_t, uint64_t, uint64_t, uint64_t))invoker)(s[0], s[1], s[2], s[3], s[4], s[5], s[6], s[7]); break;
         }
     }
 
     // The consumer owns each incoming std::string arg buffer and optional arg cell; free them
     // now that the crate has copied.
-    for (int j = base; j < total && j < 6; ++j) {
+    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]);
     }
 
     // A shim raised (Result::Err): drop the sentinel return and surface a real JS exception.
+    // The error is BUILT IN JS, not thrown from here: Hermes re-wraps a C++ exception escaping a
+    // host function ("Exception in HostFunction: ..."), which loses both the plain message and the
+    // `code` property. The runtime's dyn-caller rethrows what this parks, so the object JS sees is
+    // a real Error with the binding's own message and code.
     if (g_hasPendingError) {
         g_hasPendingError = false;
         if (ret == 's' && r) std::free((void*)(uintptr_t)r);
-        throw jsi::JSError(rt, std::move(g_pendingError));
+        std::string message = std::move(g_pendingError);
+        std::string code = std::move(g_pendingErrorCode);
+        g_pendingError.clear();
+        g_pendingErrorCode.clear();
+        crossbindHelper("__crossbind_park_error").call(
+            rt, jsi::String::createFromUtf8(rt, message),
+            code.empty() ? jsi::Value::undefined() : jsi::Value(jsi::String::createFromUtf8(rt, code)));
+        return jsi::Value::undefined();
     }
 
     if (ret == 'v') return jsi::Value::undefined();
     if (ret == 's') return wireStringToJsi(rt, r);  // the crate returned a [u32 len][bytes] buffer
-    // Optional returns ('I'/'D'/'B'/'S'): nullable heap cell - 0 is None (undefined), otherwise
+    // Optional returns ('I'/'D'/'B'/'S'): nullable heap cell - 0 is None (null), otherwise
     // the malloc'd inner value ('S' points at a plain string wire); freed here after reading.
     if (ret == 'I' || ret == 'D' || ret == 'B' || ret == 'S') {
-        if (!r) return jsi::Value::undefined();
+        if (!r) return jsi::Value::null();
         if (ret == 'S') return wireStringToJsi(rt, r);
         uint8_t* cell = (uint8_t*)(uintptr_t)r;
         jsi::Value out = jsi::Value::undefined();
@@ -338,8 +433,8 @@ static jsi::Function wrapInvoker(const std::string& name, const char* sigC, void
     unsigned jsArgc = (unsigned)(sig.size() - 1 - (prepend ? 1 : 0)); // args embind actually passes
     return jsi::Function::createFromHostFunction(
         rt, jsi::PropNameID::forAscii(rt, dbg), jsArgc,
-        [sig, invoker, ctx, prepend](jsi::Runtime& rt, const jsi::Value&, const jsi::Value* a, size_t) -> jsi::Value {
-            return callInvoker(rt, sig, invoker, a, ctx, prepend);
+        [sig, invoker, ctx, prepend](jsi::Runtime& rt, const jsi::Value&, const jsi::Value* a, size_t count) -> jsi::Value {
+            return callInvoker(rt, sig, invoker, a, count, ctx, prepend);
         });
 }
 
@@ -413,6 +508,22 @@ void crossbind_embind_register_enum_value(CrossbindTid enum_ty, const char* valu
     _embind_register_enum_value(enum_ty, value_name, value);
 }
 
+void crossbind_embind_register_class_property(CrossbindTid cls, const char* name,
+    CrossbindTid getter_ty, const char* getter_sig, CrossbindFn getter, void* getter_ctx,
+    CrossbindTid setter_ty, const char* setter_sig, CrossbindFn setter, void* setter_ctx) {
+    // Not sliced: the fork's property accessors call `getter(getterContext, ptr)` and
+    // `setter(setterContext, ptr, value)`, so both contexts arrive as ordinary arguments
+    // (unlike a method invoker, where embind slices the target off).
+    auto get = wrapInvoker(std::string(name) + "_get", getter_sig, getter);
+    auto set = wrapInvoker(std::string(name) + "_set", setter_sig, setter);
+    _embind_register_class_property(cls, name, getter_ty, getter_sig, get, getter_ctx,
+        setter_ty, setter_sig, set, setter_ctx);
+}
+void crossbind_embind_register_constant(const char* name, CrossbindTid ty, double value) {
+    // The fork takes the constant as a jsi::Value; every kind we offer (int, float, bool) reads
+    // back through its own fromWireType from a plain number.
+    _embind_register_constant(name, ty, jsi::Value(value));
+}
 void crossbind_embind_register_value_object(CrossbindTid struct_ty, const char* name,
     const char* ctor_sig, CrossbindFn ctor, const char* dtor_sig, CrossbindFn dtor) {
     auto ct = wrapInvoker(std::string(name) + "_ctor", ctor_sig, ctor);

package/adapters/web.cpp

@@ -22,6 +22,21 @@ EM_JS(void, crossbind_embind_raise_error, (uint8_t* w), {
     throw new Error(msg);
 });
 
+// The same escape with a machine-readable code on the Error, the way napi-rs carries its
+// `error.code`: a null pointer means the producer had no code to give.
+EM_JS(void, crossbind_embind_raise_error_coded, (uint8_t* w, uint8_t* c), {
+    const len = HEAPU32[w >> 2];
+    const msg = UTF8ToString(w + 4, len);
+    _free(w);
+    const error = new Error(msg);
+    if (c) {
+        const codeLen = HEAPU32[c >> 2];
+        error.code = UTF8ToString(c + 4, codeLen);
+        _free(c);
+    }
+    throw error;
+});
+
 // Producer sig chars that emscripten's dynCall alphabet lacks: 's' (a jsi-marshalling hint;
 // the wasm string wire is a real pointer) -> 'p', and 'u' (unsigned 64 - signedness lives in
 // the registered typeid) -> 'j'. Translated copies are one-time registration data, leaked.
@@ -45,6 +60,12 @@ const void* crossbind_tid_void() { return &typeid(void); }
 const void* crossbind_tid_std_string() { return &typeid(std::string); }
 const void* crossbind_tid_int64() { return &typeid(int64_t); }
 const void* crossbind_tid_uint64() { return &typeid(uint64_t); }
+const void* crossbind_tid_int8() { return &typeid(int8_t); }
+const void* crossbind_tid_int16() { return &typeid(int16_t); }
+const void* crossbind_tid_uint8() { return &typeid(uint8_t); }
+const void* crossbind_tid_uint16() { return &typeid(uint16_t); }
+const void* crossbind_tid_uint32() { return &typeid(uint32_t); }
+const void* crossbind_tid_float() { return &typeid(float); }
 // Adapter-local identities, NOT &typeid(std::optional<T>): linked C++ bindings may register
 // the real optional typeids themselves, and these types never interop with C++ signatures.
 const void* crossbind_tid_optional_int() { static const char t = 0; return &t; }
@@ -54,8 +75,8 @@ const void* crossbind_tid_optional_string() { static const char t = 0; return &t
 
 }
 
-// Optional wire on wasm is an EM_VAL handle (None = the reserved undefined constant from
-// emscripten's own header). Some-values become handles through Emval.toHandle; the registered
+// 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.
 EM_JS(void*, crossbind_emval_from_number_js, (double v), { return Emval.toHandle(v); });
 EM_JS(void*, crossbind_emval_from_bool_js, (int v), { return Emval.toHandle(!!v); });
@@ -73,8 +94,8 @@ void* crossbind_emval_take_value(CrossbindTid inner, const void* argv) {
     if (inner == crossbind_tid_bool()) return crossbind_emval_from_bool_js((int)*(const uint8_t*)argv);
     return crossbind_emval_from_string_js(*(uint8_t* const*)argv);  // std::string wire pointer
 }
-void* crossbind_emval_undefined() {
-    return (void*)emscripten::internal::_EMVAL_UNDEFINED;
+void* crossbind_emval_null() {
+    return (void*)emscripten::internal::_EMVAL_NULL;
 }
 
 // Optional PARAMETERS: embind hands the invoker an EM_VAL handle; these readers consume its
@@ -124,9 +145,20 @@ void* crossbind_emval_json_to_handle(uint8_t* w) {
     return (void*)h;
 }
 
+// A Set or Map has no JSON form of its own, so the replacer writes it as the array or object the
+// Rust side expects; everything else stringifies unchanged.
+EM_JS(void*, crossbind_json_replacer, (), {
+    return Emval.toHandle(function (key, value) {
+        if (value instanceof Set) return Array.from(value);
+        if (value instanceof Map) return Object.fromEntries(value);
+        return value;
+    });
+});
+
 uint8_t* crossbind_emval_handle_to_json(void* h) {
     emscripten::val v = emscripten::val::take_ownership((emscripten::EM_VAL)h);
-    emscripten::val j = emscripten::val::global("JSON").call<emscripten::val>("stringify", v);
+    emscripten::val replacer = emscripten::val::take_ownership((emscripten::EM_VAL)crossbind_json_replacer());
+    emscripten::val j = emscripten::val::global("JSON").call<emscripten::val>("stringify", v, replacer);
     // JSON.stringify(undefined / a bare function) yields undefined: cross as null.
     std::string s = j.isUndefined() ? "null" : j.as<std::string>();
     uint8_t* w = (uint8_t*)malloc(4 + s.size());
@@ -147,6 +179,8 @@ void _embind_register_smart_ptr(CrossbindTid, CrossbindTid, const char*, emscrip
 void _embind_register_enum(CrossbindTid, const char*, size_t, bool, int);
 void _embind_register_enum_value(CrossbindTid, const char*, int);
 void _embind_register_value_object(CrossbindTid, const char*, const char*, CrossbindFn, const char*, CrossbindFn);
+void _embind_register_constant(const char*, CrossbindTid, double);
+void _embind_register_class_property(CrossbindTid, const char*, CrossbindTid, const char*, CrossbindFn, void*, CrossbindTid, const char*, CrossbindFn, void*);
 void _embind_register_value_object_field(CrossbindTid, const char*, CrossbindTid, const char*, CrossbindFn, void*, CrossbindTid, const char*, CrossbindFn, void*);
 void _embind_finalize_value_object(CrossbindTid);
 
@@ -180,6 +214,18 @@ void crossbind_embind_register_enum(CrossbindTid a, const char* b, size_t c, boo
 void crossbind_embind_register_enum_value(CrossbindTid a, const char* b, int c) {
     _embind_register_enum_value(a, b, c);
 }
+// A constant is registered by value: embind carries the wire through a double, which holds every
+// int, float and bool exactly (and a wasm32 pointer).
+// A public field reads and writes as a JS property instead of a pair of calls.
+void crossbind_embind_register_class_property(CrossbindTid cls, const char* name,
+    CrossbindTid getter_ty, const char* getter_sig, CrossbindFn getter, void* getter_ctx,
+    CrossbindTid setter_ty, const char* setter_sig, CrossbindFn setter, void* setter_ctx) {
+    _embind_register_class_property(cls, name, getter_ty, sigForWasm(getter_sig), getter, getter_ctx,
+        setter_ty, sigForWasm(setter_sig), setter, setter_ctx);
+}
+void crossbind_embind_register_constant(const char* name, CrossbindTid ty, double value) {
+    _embind_register_constant(name, ty, value);
+}
 void crossbind_embind_register_value_object(CrossbindTid a, const char* b, const char* c, CrossbindFn d, const char* e, CrossbindFn f) {
     _embind_register_value_object(a, b, c, d, e, f);
 }
@@ -243,6 +289,27 @@ EM_JS(uint8_t*, crossbind_v_as_str, (void* h), {
     stringToUTF8(s, w + 4, len + 1);
     return w;
 });
+// Typed arrays: bytes and doubles cross as the JS views themselves, copied once in each
+// direction - a view into wasm memory would dangle the moment the heap grows.
+EM_JS(void*, crossbind_v_bytes_to_js, (uint8_t* data, unsigned len), {
+    return Emval.toHandle(HEAPU8.slice(data, data + len));
+});
+EM_JS(void*, crossbind_v_f64s_to_js, (double* data, unsigned len), {
+    return Emval.toHandle(HEAPF64.slice(data >> 3, (data >> 3) + len));
+});
+EM_JS(unsigned, crossbind_v_typed_len, (void* h), {
+    const value = Emval.toValue(h);
+    return value && value.length !== undefined ? value.length : 0;
+});
+EM_JS(void, crossbind_v_bytes_from_js, (void* h, uint8_t* out, unsigned len), {
+    const value = Emval.toValue(h);
+    HEAPU8.set(value.subarray ? value.subarray(0, len) : Uint8Array.from(value).subarray(0, len), out);
+});
+EM_JS(void, crossbind_v_f64s_from_js, (void* h, double* out, unsigned len), {
+    const value = Emval.toValue(h);
+    HEAPF64.set(value.subarray ? value.subarray(0, len) : Float64Array.from(value).subarray(0, len), out >> 3);
+});
+
 EM_JS(void*, crossbind_v_call, (void* f, unsigned argc, void* argv), {
     try {
         const fn = Emval.toValue(f);

package/crate/src/lib.rs

@@ -36,6 +36,12 @@ extern "C" {
     );
     fn crossbind_embind_register_enum(enum_ty: *const c_void, name: *const c_char, size: usize, is_signed: bool, policy: i32);
     fn crossbind_embind_register_enum_value(enum_ty: *const c_void, name: *const c_char, value: i32);
+    fn crossbind_embind_register_constant(name: *const c_char, ty: *const c_void, value: f64);
+    fn crossbind_embind_register_class_property(
+        cls: *const c_void, name: *const c_char,
+        getter_ty: *const c_void, getter_sig: *const c_char, getter: usize, getter_ctx: *mut c_void,
+        setter_ty: *const c_void, setter_sig: *const c_char, setter: usize, setter_ctx: *mut c_void,
+    );
     fn crossbind_embind_register_value_object(
         struct_ty: *const c_void, name: *const c_char,
         ctor_sig: *const c_char, ctor: usize, dtor_sig: *const c_char, dtor: usize,
@@ -62,6 +68,12 @@ extern "C" {
     fn free(ptr: *mut u8);
     fn crossbind_tid_int64() -> *const c_void;
     fn crossbind_tid_uint64() -> *const c_void;
+    fn crossbind_tid_int8() -> *const c_void;
+    fn crossbind_tid_int16() -> *const c_void;
+    fn crossbind_tid_uint8() -> *const c_void;
+    fn crossbind_tid_uint16() -> *const c_void;
+    fn crossbind_tid_uint32() -> *const c_void;
+    fn crossbind_tid_float() -> *const c_void;
     fn crossbind_embind_register_optional(optional_ty: *const c_void, inner_ty: *const c_void);
     fn crossbind_tid_optional_int() -> *const c_void;
     fn crossbind_tid_optional_double() -> *const c_void;
@@ -71,6 +83,7 @@ extern "C" {
     // Adapter-owned error escape ([u32 len][bytes] wire): web throws a JS Error immediately,
     // native stores the message and throws after the invoker returns.
     fn crossbind_embind_raise_error(wire_msg: *mut u8);
+    fn crossbind_embind_raise_error_coded(msg: *mut u8, code: *mut u8);
 }
 
 // Optional wire helpers exist only on wasm (native optionals are nullable heap cells the jsi
@@ -78,7 +91,7 @@ extern "C" {
 #[cfg(target_family = "wasm")]
 extern "C" {
     fn crossbind_emval_take_value(inner_ty: *const c_void, argv: *const c_void) -> usize;
-    fn crossbind_emval_undefined() -> usize;
+    fn crossbind_emval_null() -> usize;
     fn crossbind_emval_opt_i32(handle: usize, out: *mut i32) -> i32;
     fn crossbind_emval_opt_f64(handle: usize, out: *mut f64) -> i32;
     fn crossbind_emval_opt_bool(handle: usize, out: *mut u8) -> i32;
@@ -94,6 +107,8 @@ struct Registry {
     tids: Vec<Box<u8>>,
     argtypes: Vec<Box<[*const c_void]>>,
     class_tid: HashMap<TypeId, *const c_void>,
+    class_ptr_tid: HashMap<TypeId, *const c_void>,
+    owned_ptr_tid: HashMap<TypeId, *const c_void>,
     shared_ptr_tid: HashMap<TypeId, *const c_void>,
 }
 // Raw pointers are not Send/Sync; the arena is only ever touched under its Mutex.
@@ -103,6 +118,8 @@ fn registry() -> &'static Mutex<Registry> {
     static REG: OnceLock<Mutex<Registry>> = OnceLock::new();
     REG.get_or_init(|| Mutex::new(Registry {
         cstrings: Vec::new(), tids: Vec::new(), argtypes: Vec::new(), class_tid: HashMap::new(),
+        class_ptr_tid: HashMap::new(),
+        owned_ptr_tid: HashMap::new(),
         shared_ptr_tid: HashMap::new(),
     }))
 }
@@ -222,6 +239,98 @@ impl WireType for u64 {
 }
 
 // bool crosses as an int-sized wire (0/1), the way emscripten's ABI passes it.
+// The narrower integers ride the int slot with their own type ids, so the host converter keeps
+// each one's range check instead of silently wrapping a value the Rust type cannot hold.
+macro_rules! int_wire {
+    ($( $ty:ty, $tid:ident ; )*) => {
+        $(
+            impl WireType for $ty {
+                type Wire = i32;
+                const SIG: char = 'i';
+                fn tid() -> *const c_void { unsafe { $tid() } }
+                fn from_wire(w: i32) -> $ty { w as $ty }
+                fn to_wire(self) -> i32 { self as i32 }
+            }
+        )*
+    };
+}
+
+int_wire! {
+    i8, crossbind_tid_int8;
+    i16, crossbind_tid_int16;
+    u8, crossbind_tid_uint8;
+    u16, crossbind_tid_uint16;
+    u32, crossbind_tid_uint32;
+}
+
+// f32 crosses through the double slot: JS has one number type, so the value widens on the way
+// out and narrows on the way in - the Rust signature is what asks for single precision.
+#[cfg(target_family = "wasm")]
+impl WireType for f32 {
+    type Wire = f64;
+    const SIG: char = 'd';
+    fn tid() -> *const c_void { unsafe { crossbind_tid_float() } }
+    fn from_wire(w: f64) -> f32 { w as f32 }
+    fn to_wire(self) -> f64 { self as f64 }
+}
+
+#[cfg(not(target_family = "wasm"))]
+impl WireType for f32 {
+    type Wire = u64;
+    const SIG: char = 'd';
+    fn tid() -> *const c_void { unsafe { crossbind_tid_float() } }
+    fn from_wire(w: u64) -> f32 { f64::from_bits(w) as f32 }
+    fn to_wire(self) -> u64 { (self as f64).to_bits() }
+}
+
+// usize/isize are 32-bit on wasm and 64-bit everywhere else, so each platform rides the slot
+// that carries its full range: a number on wasm, a BigInt on native.
+#[cfg(target_pointer_width = "32")]
+impl WireType for usize {
+    type Wire = i32;
+    const SIG: char = 'i';
+    fn tid() -> *const c_void { unsafe { crossbind_tid_uint32() } }
+    fn from_wire(w: i32) -> usize { w as usize }
+    fn to_wire(self) -> i32 { self as i32 }
+}
+
+#[cfg(target_pointer_width = "32")]
+impl WireType for isize {
+    type Wire = i32;
+    const SIG: char = 'i';
+    fn tid() -> *const c_void { unsafe { crossbind_tid_int() } }
+    fn from_wire(w: i32) -> isize { w as isize }
+    fn to_wire(self) -> i32 { self as i32 }
+}
+
+#[cfg(not(target_pointer_width = "32"))]
+impl WireType for usize {
+    type Wire = u64;
+    const SIG: char = 'u';
+    fn tid() -> *const c_void { unsafe { crossbind_tid_uint64() } }
+    fn from_wire(w: u64) -> usize { w as usize }
+    fn to_wire(self) -> u64 { self as u64 }
+}
+
+#[cfg(not(target_pointer_width = "32"))]
+impl WireType for isize {
+    type Wire = i64;
+    const SIG: char = 'j';
+    fn tid() -> *const c_void { unsafe { crossbind_tid_int64() } }
+    fn from_wire(w: i64) -> isize { w as isize }
+    fn to_wire(self) -> i64 { self as i64 }
+}
+
+// char crosses as a one-character string, the way JS spells a character; an incoming string
+// yields its first character (an empty one is U+FFFD, the replacement character).
+impl WireType for char {
+    type Wire = <String as WireType>::Wire;
+    const SIG: char = 's';
+    fn tid() -> *const c_void { <String as WireType>::tid() }
+    fn from_wire(w: Self::Wire) -> char { String::from_wire(w).chars().next().unwrap_or('\u{fffd}') }
+    fn to_wire(self) -> Self::Wire { self.to_string().to_wire() }
+}
+
 impl WireType for bool {
     type Wire = i32;
     const SIG: char = 'i';
@@ -265,7 +374,7 @@ impl WireType for String {
     }
 }
 
-/// Option<T> both ways: on wasm the wire is an EM_VAL handle (None = undefined; incoming
+/// Option<T> both ways: on wasm the wire is an EM_VAL handle (None = null; incoming
 /// undefined/null both read as None); on native it is a nullable heap cell (0 = None) the jsi
 /// adapter converts, tagged 'I'/'D'/'B'/'S'. Incoming cells stay adapter-owned (read, no free).
 macro_rules! option_wire {
@@ -279,7 +388,7 @@ macro_rules! option_wire {
                 fn from_wire(w: usize) -> Self { <$inner as EmvalOptRead>::emval_opt_read(w) }
                 fn to_wire(self) -> usize {
                     match self {
-                        None => unsafe { crossbind_emval_undefined() },
+                        None => unsafe { crossbind_emval_null() },
                         Some(v) => v.emval_take(),
                     }
                 }
@@ -418,6 +527,29 @@ pub fn register_optional_f64() { unsafe { crossbind_embind_register_optional(cro
 pub fn register_optional_bool() { unsafe { crossbind_embind_register_optional(crossbind_tid_optional_bool(), crossbind_tid_bool()); } }
 pub fn register_optional_string() { unsafe { crossbind_embind_register_optional(crossbind_tid_optional_string(), crossbind_tid_std_string()); } }
 
+/// A module-level constant: the value crosses once at registration, so JS reads a plain value
+/// instead of calling a getter. Only the wire kinds a double carries exactly are offered.
+pub trait ConstantValue: WireType {
+    fn as_constant(self) -> f64;
+}
+impl ConstantValue for i32 { fn as_constant(self) -> f64 { self as f64 } }
+impl ConstantValue for f64 { fn as_constant(self) -> f64 { self } }
+impl ConstantValue for bool { fn as_constant(self) -> f64 { if self { 1.0 } else { 0.0 } } }
+
+/// A string constant: the double the ABI carries is the emval handle of a JS string, which the
+/// emval type reads straight back. The handle is released on purpose - the constant owns it for
+/// the life of the module.
+pub fn constant_str(name: &str, value: &str) {
+    let handle = JsValue::from_str(value).release();
+    let name_ptr = { registry().lock().unwrap().cstr(name) };
+    unsafe { crossbind_embind_register_constant(name_ptr, crossbind_tid_emval(), handle as f64) };
+}
+
+pub fn constant<T: ConstantValue>(name: &str, value: T) {
+    let name_ptr = { registry().lock().unwrap().cstr(name) };
+    unsafe { crossbind_embind_register_constant(name_ptr, T::tid(), value.as_constant()) };
+}
+
 /// Post-raise sentinel returns: only native ever observes them (the adapter throws right after
 /// the invoker returns); on web `crossbind_embind_raise_error` throws into JS and never comes back.
 pub trait ErrSentinel {
@@ -431,13 +563,119 @@ impl ErrSentinel for bool { fn err_sentinel() -> Self { false } }
 impl ErrSentinel for () { fn err_sentinel() -> Self {} }
 impl ErrSentinel for String { fn err_sentinel() -> Self { String::new() } }
 impl<T> ErrSentinel for *mut T { fn err_sentinel() -> Self { std::ptr::null_mut() } }
+// A fallible optional (`Result<Option<T>, E>`) raises and then returns None.
+impl<T> ErrSentinel for Option<T> { fn err_sentinel() -> Self { None } }
+// The narrower integers and the pointer-wide ones share the zero sentinel.
+impl ErrSentinel for i8 { fn err_sentinel() -> Self { 0 } }
+impl ErrSentinel for i16 { fn err_sentinel() -> Self { 0 } }
+impl ErrSentinel for u8 { fn err_sentinel() -> Self { 0 } }
+impl ErrSentinel for u16 { fn err_sentinel() -> Self { 0 } }
+impl ErrSentinel for u32 { fn err_sentinel() -> Self { 0 } }
+impl ErrSentinel for f32 { fn err_sentinel() -> Self { 0.0 } }
+impl ErrSentinel for usize { fn err_sentinel() -> Self { 0 } }
+impl ErrSentinel for isize { fn err_sentinel() -> Self { 0 } }
+impl ErrSentinel for char { fn err_sentinel() -> Self { '\u{fffd}' } }
 
 /// Routes a shim's `Err` to JS as an exception, then returns a dead sentinel value.
+/// Runs a binding body so that a Rust panic reaches JS as an exception instead of tearing the
+/// process down. The panic still means a bug: state is whatever the panic left behind, the same
+/// caveat napi-rs documents for its own catch_unwind.
+///
+/// Two runtimes, two mechanisms. Native targets unwind, so the panic is caught here. The wasm
+/// target's std aborts instead of unwinding, so a panic hook raises the error from inside the
+/// panic itself - the JS throw leaves the call before the abort can run.
+pub fn guard<R: ErrSentinel>(body: impl FnOnce() -> R) -> R {
+    install_panic_hook();
+    #[cfg(target_family = "wasm")]
+    {
+        body()
+    }
+    #[cfg(not(target_family = "wasm"))]
+    {
+        match std::panic::catch_unwind(std::panic::AssertUnwindSafe(body)) {
+            Ok(value) => value,
+            Err(payload) => raise_err(panic_text(&payload)),
+        }
+    }
+}
+
+fn install_panic_hook() {
+    static ONCE: std::sync::Once = std::sync::Once::new();
+    ONCE.call_once(|| {
+        let previous = std::panic::take_hook();
+        std::panic::set_hook(Box::new(move |info| {
+            let text = match info.payload().downcast_ref::<&str>() {
+                Some(text) => (*text).to_string(),
+                None => match info.payload().downcast_ref::<String>() {
+                    Some(text) => text.clone(),
+                    None => String::from("panicked"),
+                },
+            };
+            let text = match info.location() {
+                Some(at) => format!("{text} (panicked at {}:{})", at.file(), at.line()),
+                None => text,
+            };
+            // wasm: this throws into JS and the call never comes back, so the abort below the
+            // hook is skipped. Native: the adapter parks the message and throws once the
+            // invoker returns, so unwinding still reaches the catch in `guard`.
+            #[cfg(target_family = "wasm")]
+            unsafe { crossbind_embind_raise_error(text.to_wire()) };
+            #[cfg(not(target_family = "wasm"))]
+            {
+                let _ = &text;
+                previous(info);
+            }
+        }));
+    });
+}
+
+#[cfg(not(target_family = "wasm"))]
+fn panic_text(payload: &Box<dyn std::any::Any + Send>) -> String {
+    if let Some(text) = payload.downcast_ref::<&str>() { return (*text).to_string(); }
+    if let Some(text) = payload.downcast_ref::<String>() { return text.clone(); }
+    String::from("panicked")
+}
+
 pub fn raise_err<W: ErrSentinel>(msg: String) -> W {
     unsafe { crossbind_embind_raise_error(msg.to_wire()); }
     W::err_sentinel()
 }
 
+/// The same escape carrying a machine-readable code, so JS can branch on `error.code` instead
+/// of matching message text.
+pub fn raise_err_coded<W: ErrSentinel>(msg: String, code: Option<String>) -> W {
+    let code_wire = match code {
+        Some(text) => text.to_wire(),
+        None => core::ptr::null_mut(),
+    };
+    unsafe { crossbind_embind_raise_error_coded(msg.to_wire(), code_wire); }
+    W::err_sentinel()
+}
+
+/// An error type that also implements `AsRef<str>` gives that string as the code, the way
+/// napi-rs reads a code off its error enums. Everything else has no code: the two traits below
+/// are picked apart by autoref, so no specialization feature is needed.
+/// The fallback sits behind one more reference than the specialized impl, so method lookup finds
+/// the coded one first when the bound holds and falls through to None when it does not.
+pub trait CrossbindErrorCode { fn crossbind_code(&self) -> Option<String>; }
+impl<E: AsRef<str>> CrossbindErrorCode for E {
+    fn crossbind_code(&self) -> Option<String> { Some(self.as_ref().to_string()) }
+}
+pub trait CrossbindErrorCodeFallback { fn crossbind_code(&self) -> Option<String>; }
+impl<E> CrossbindErrorCodeFallback for &E {
+    fn crossbind_code(&self) -> Option<String> { None }
+}
+
+extern "C" fn property_getter<T: 'static, F: WireType>(ctx: usize, this: *mut T) -> <F as WireType>::Wire {
+    let getter: fn(&mut T) -> F = unsafe { core::mem::transmute(ctx) };
+    getter(unsafe { &mut *this }).to_wire()
+}
+
+extern "C" fn property_setter<T: 'static, F: WireType>(ctx: usize, this: *mut T, value: <F as WireType>::Wire) {
+    let setter: fn(&mut T, F) = unsafe { core::mem::transmute(ctx) };
+    setter(unsafe { &mut *this }, F::from_wire(value));
+}
+
 extern "C" fn dtor_thunk<T>(p: *mut T) {
     if !p.is_null() {
         drop(unsafe { Box::from_raw(p) });
@@ -461,6 +699,20 @@ pub fn class_tid<T: 'static>() -> *const c_void {
         .expect("class parameter type must be registered before the binding that uses it")
 }
 
+/// The registered smart-pointer typeid of an OWNED class (`.smart_ptr(..)`), for a method or
+/// function that returns a fresh instance by value.
+pub fn owned_ptr_tid<T: 'static>() -> *const c_void {
+    registry().lock().unwrap().owned_ptr_tid.get(&TypeId::of::<T>()).copied()
+        .expect("a class that returns itself by value must register its smart pointer first")
+}
+
+/// The registered POINTER typeid of a class: a pointer parameter takes null (a reference does
+/// not), which is how `Option<&Class>` spells None.
+pub fn class_ptr_tid<T: 'static>() -> *const c_void {
+    registry().lock().unwrap().class_ptr_tid.get(&TypeId::of::<T>()).copied()
+        .expect("class parameter type must be registered before the binding that uses it")
+}
+
 /// The registered smart-pointer typeid of a SHARED class (`.smart_ptr_shared(..)`), for the
 /// generated `Arc<T>` return/parameter wrappers.
 pub fn shared_tid<T: 'static>() -> *const c_void {
@@ -503,6 +755,11 @@ extern "C" {
     fn crossbind_v_as_str(h: usize) -> *mut u8;
     fn crossbind_v_call(f: usize, argc: u32, argv: *const usize) -> usize;
     fn crossbind_v_cb_err_take() -> *mut u8;
+    fn crossbind_v_bytes_to_js(data: *const u8, len: u32) -> usize;
+    fn crossbind_v_f64s_to_js(data: *const f64, len: u32) -> usize;
+    fn crossbind_v_typed_len(h: usize) -> u32;
+    fn crossbind_v_bytes_from_js(h: usize, out: *mut u8, len: u32);
+    fn crossbind_v_f64s_from_js(h: usize, out: *mut f64, len: u32);
 }
 
 fn str_wire(s: &str) -> *mut u8 {
@@ -581,6 +838,47 @@ impl Clone for JsValue {
     }
 }
 
+/// Typed arrays: a byte or double sequence crosses as the JS view of the same name, copied once
+/// in each direction (a view into wasm memory would dangle when the heap grows).
+pub struct JsBytes(pub Vec<u8>);
+
+impl WireType for JsBytes {
+    type Wire = usize;
+    const SIG: char = 'i';
+    fn tid() -> *const c_void { unsafe { crossbind_tid_emval() } }
+    fn from_wire(w: usize) -> Self {
+        let len = unsafe { crossbind_v_typed_len(w) } as usize;
+        let mut data = vec![0u8; len];
+        unsafe { crossbind_v_bytes_from_js(w, data.as_mut_ptr(), len as u32) };
+        unsafe { crossbind_v_unref(w) };
+        JsBytes(data)
+    }
+    fn to_wire(self) -> usize {
+        unsafe { crossbind_v_bytes_to_js(self.0.as_ptr(), self.0.len() as u32) }
+    }
+}
+
+pub struct JsF64s(pub Vec<f64>);
+
+impl WireType for JsF64s {
+    type Wire = usize;
+    const SIG: char = 'i';
+    fn tid() -> *const c_void { unsafe { crossbind_tid_emval() } }
+    fn from_wire(w: usize) -> Self {
+        let len = unsafe { crossbind_v_typed_len(w) } as usize;
+        let mut data = vec![0.0f64; len];
+        unsafe { crossbind_v_f64s_from_js(w, data.as_mut_ptr(), len as u32) };
+        unsafe { crossbind_v_unref(w) };
+        JsF64s(data)
+    }
+    fn to_wire(self) -> usize {
+        unsafe { crossbind_v_f64s_to_js(self.0.as_ptr(), self.0.len() as u32) }
+    }
+}
+
+impl ErrSentinel for JsBytes { fn err_sentinel() -> Self { JsBytes(Vec::new()) } }
+impl ErrSentinel for JsF64s { fn err_sentinel() -> Self { JsF64s(Vec::new()) } }
+
 impl Drop for JsValue {
     fn drop(&mut self) {
         unsafe { crossbind_v_unref(self.handle) };
@@ -790,6 +1088,7 @@ pub fn class_<T: 'static>(name: &str) -> ClassBuilder<T> {
         name_ptr = r.cstr(name);
         dtor_sig = r.cstr("vp");
         r.class_tid.insert(TypeId::of::<T>(), cls);
+        r.class_ptr_tid.insert(TypeId::of::<T>(), ptr_ty);
     }
     unsafe {
         crossbind_embind_register_class(
@@ -804,6 +1103,26 @@ pub fn class_<T: 'static>(name: &str) -> ClassBuilder<T> {
 }
 
 impl<T: 'static> ClassBuilder<T> {
+    /// A field that reads and writes as a JS property. The getter and setter are plain shim
+    /// functions over the instance, so a private field can be exposed through accessors too.
+    pub fn property<F: WireType>(self, name: &str, getter: fn(&mut T) -> F, setter: fn(&mut T, F)) -> Self {
+        let (name_ptr, getter_sig, setter_sig);
+        {
+            let mut r = registry().lock().unwrap();
+            name_ptr = r.cstr(name);
+            getter_sig = r.cstr(&format!("{}pp", F::SIG));
+            setter_sig = r.cstr(&format!("vpp{}", F::SIG));
+        }
+        unsafe {
+            crossbind_embind_register_class_property(
+                self.cls, name_ptr,
+                F::tid(), getter_sig, property_getter::<T, F> as *const () as usize, getter as *mut c_void,
+                F::tid(), setter_sig, property_setter::<T, F> as *const () as usize, setter as *mut c_void,
+            );
+        }
+        self
+    }
+
     /// Registers a smart-pointer type for this class so factory functions can return an
     /// object that JS owns and frees on delete(). Call before `.createN`.
     pub fn smart_ptr(mut self, name: &str) -> Self {
@@ -827,6 +1146,7 @@ impl<T: 'static> ClassBuilder<T> {
             );
         }
         self.smart_ptr_ty = Some(ptr_ty);
+        registry().lock().unwrap().owned_ptr_tid.insert(TypeId::of::<T>(), ptr_ty);
         self
     }
 
@@ -918,6 +1238,10 @@ factories! {
     create0 / factory_invoker0 : ;
     create1 / factory_invoker1 : A0;
     create2 / factory_invoker2 : A0, A1;
+    create3 / factory_invoker3 : A0, A1, A2;
+    create4 / factory_invoker4 : A0, A1, A2, A3;
+    create5 / factory_invoker5 : A0, A1, A2, A3, A4;
+    create6 / factory_invoker6 : A0, A1, A2, A3, A4, A5;
 }
 
 // Arc-allocating factories for shared classes: identical registration shape, but the object
@@ -1006,6 +1330,9 @@ constructors! {
     constructor1 / ctor_invoker1 : A0;
     constructor2 / ctor_invoker2 : A0, A1;
     constructor3 / ctor_invoker3 : A0, A1, A2;
+    constructor4 / ctor_invoker4 : A0, A1, A2, A3;
+    constructor5 / ctor_invoker5 : A0, A1, A2, A3, A4;
+    constructor6 / ctor_invoker6 : A0, A1, A2, A3, A4, A5;
 }
 
 // Raw-pointer ctor variants for fallible `new`: the shim boxes the value itself (or raises and
@@ -1050,6 +1377,9 @@ constructors_ptr! {
     constructor_ptr1 / ctor_ptr_invoker1 : A0;
     constructor_ptr2 / ctor_ptr_invoker2 : A0, A1;
     constructor_ptr3 / ctor_ptr_invoker3 : A0, A1, A2;
+    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;
 }
 
 // Raw-pointer factory variants: `Result<Self, E>` raises on Err, `Option<Self>` returns null
@@ -1095,6 +1425,10 @@ factories_ptr! {
     create_ptr0 / factory_ptr_invoker0 : ;
     create_ptr1 / factory_ptr_invoker1 : A0;
     create_ptr2 / factory_ptr_invoker2 : A0, A1;
+    create_ptr3 / factory_ptr_invoker3 : A0, A1, A2;
+    create_ptr4 / factory_ptr_invoker4 : A0, A1, A2, A3;
+    create_ptr5 / factory_ptr_invoker5 : A0, A1, A2, A3, A4;
+    create_ptr6 / factory_ptr_invoker6 : A0, A1, A2, A3, A4, A5;
 }
 
 // N-arity instance methods.
@@ -1141,6 +1475,8 @@ functions! {
     function2 / method_invoker2 : A0, A1;
     function3 / method_invoker3 : A0, A1, A2;
     function4 / method_invoker4 : A0, A1, A2, A3;
+    function5 / method_invoker5 : A0, A1, A2, A3, A4;
+    function6 / method_invoker6 : A0, A1, A2, A3, A4, A5;
 }
 
 // N-arity FREE functions (`Module.name(..)` in JS, no class). embind slices the target off
@@ -1183,4 +1519,6 @@ free_functions! {
     fn2 / free_invoker2 : A0, A1;
     fn3 / free_invoker3 : A0, A1, A2;
     fn4 / free_invoker4 : A0, A1, A2, A3;
+    fn5 / free_invoker5 : A0, A1, A2, A3, A4;
+    fn6 / free_invoker6 : A0, A1, A2, A3, A4, A5;
 }

package/include/crossbind_embind.h

@@ -40,6 +40,11 @@ void crossbind_embind_register_smart_ptr(
 void crossbind_embind_register_enum(
     CrossbindTid enum_ty, const char* name, size_t size, bool is_signed, int policy_value);
 void crossbind_embind_register_enum_value(CrossbindTid enum_ty, const char* value_name, int value);
+void crossbind_embind_raise_error_coded(unsigned char* msg, unsigned char* code);
+void crossbind_embind_register_constant(const char* name, const void* ty, double value);
+void crossbind_embind_register_class_property(CrossbindTid cls, const char* name,
+    CrossbindTid getter_ty, const char* getter_sig, CrossbindFn getter, void* getter_ctx,
+    CrossbindTid setter_ty, const char* setter_sig, CrossbindFn setter, void* setter_ctx);
 void crossbind_embind_register_value_object(
     CrossbindTid struct_ty, const char* name,
     const char* ctor_sig, CrossbindFn ctor, const char* dtor_sig, CrossbindFn dtor);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@crossbind/core-embind-rust",
-  "version": "2.0.0-beta.56",
+  "version": "2.0.0-beta.58",
   "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": {