Small fixes for the SDK

Cargo.toml

@@ -89,13 +89,13 @@ version = "7.2.1"
 
 [workspace.dependencies]
 # Repo-local crates
-wasmer-package = { version = "0.702.1", path = "lib/package" }
+wasmer-package = { version = "0.702.1", path = "lib/package", default-features = false }
 wasmer-config = { path = "./lib/config" }
 wasmer-wasix = { path = "./lib/wasix" }
 wasmer-sdk = { path = "./lib/sdk" }
 
 # Wasmer-owned crates
-webc = "=12.0.0"
+webc = { version = "=12.0.0", default-features = false }
 shared-buffer = "0.1.4"
 loupe = "0.2.0"
 

lib/api/Cargo.toml

@@ -34,7 +34,7 @@ bytes.workspace = true
 tracing = { workspace = true, default-features = true }
 # - Optional shared dependencies.
 wat = { workspace = true, optional = true }
-symbolic-demangle.workspace = true
+symbolic-demangle = { workspace = true, optional = true }
 shared-buffer.workspace = true
 
 loupe = { workspace = true, optional = true, features = [
@@ -86,6 +86,7 @@ wasmer-types = { path = "../types", version = "=7.2.1", default-features = false
   "std",
 ] }
 wasm-bindgen.workspace = true
+wasm-bindgen-futures = { workspace = true, optional = true }
 js-sys.workspace = true
 wasmer-derive = { path = "../derive", version = "=7.2.1" }
 wasmer-compiler = { path = "../compiler", version = "=7.2.1" }
@@ -100,6 +101,7 @@ target-lexicon.workspace = true
 [target.'cfg(target_arch = "wasm32")'.dev-dependencies]
 wat.workspace = true
 anyhow.workspace = true
+futures.workspace = true
 wasm-bindgen-test.workspace = true
 macro-wasmer-engine-test = { version = "7.2.1", path = "./macro-wasmer-engine-test" }
 
@@ -125,7 +127,10 @@ artifact-size = [
 
 # Features for `sys`.
 sys = ["std", "dep:wasmer-vm", "dep:wasmer-compiler"]
-sys-default = ["sys", "wat", "cranelift"]
+sys-default = ["sys", "wat", "cranelift", "demangle"]
+
+# Improve native stack traces without forcing the demanglers into browser builds.
+demangle = ["dep:symbolic-demangle"]
 
 headless = []
 
@@ -158,7 +163,7 @@ v8-default = ["v8", "wat"]
 wasm-c-api = ["wasm-types-polyfill"]
 
 # Features for `js`.
-js = ["wasm-bindgen", "js-sys"]
+js = ["wasm-bindgen", "wasm-bindgen-futures", "js-sys"]
 js-default = ["js", "std", "wasm-types-polyfill"]
 
 wasm-types-polyfill = ["wasmparser"]

lib/api/src/backend/js/entities/external.rs

@@ -1,44 +1,127 @@
 use std::any::Any;
 
+use js_sys::{Object, Symbol};
+use wasm_bindgen::JsValue;
+
+use crate::js::entities::store::StoreHandle;
+use crate::js::utils::js_handle::JsHandle;
 use crate::js::vm::VMExternRef;
 use crate::store::{AsStoreMut, AsStoreRef};
 
-#[derive(Debug, Clone)]
 #[repr(transparent)]
 /// A WebAssembly `extern ref` in `js`.
-pub struct ExternRef;
+pub(crate) struct ExternRefData(pub(crate) Box<dyn Any + Send + Sync>);
+
+impl std::fmt::Debug for ExternRefData {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("ExternRefData").finish_non_exhaustive()
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct ExternRef {
+    value: JsHandle<JsValue>,
+    host_data: Option<StoreHandle<ExternRefData>>,
+}
+
+unsafe impl Send for ExternRef {}
+unsafe impl Sync for ExternRef {}
 
 impl ExternRef {
-    pub fn new<T>(_store: &mut impl AsStoreMut, _value: T) -> Self
+    pub fn new<T>(store: &mut impl AsStoreMut, value: T) -> Self
     where
         T: Any + Send + Sync + 'static + Sized,
     {
-        unimplemented!("ExternRef is not yet supported in Javascript");
+        let handle = StoreHandle::new(
+            store.objects_mut().as_js_mut(),
+            ExternRefData(Box::new(value)),
+        );
+        let object = Object::new();
+        js_sys::Reflect::set(
+            &object,
+            host_ref_index_key().as_ref(),
+            &JsValue::from_f64(handle.internal_handle().index() as f64),
+        )
+        .expect("setting the externref store index should succeed");
+        js_sys::Reflect::set(
+            &object,
+            host_ref_store_key().as_ref(),
+            &JsValue::from_f64(handle.store_id().as_raw().get() as f64),
+        )
+        .expect("setting the externref store ID should succeed");
+        Self {
+            value: JsHandle::new(object.into()),
+            host_data: Some(handle),
+        }
+    }
+
+    pub(crate) fn from_js_value(store: &mut impl AsStoreMut, value: JsValue) -> Self {
+        let host_data = host_handle_from_js_value(store, &value);
+        Self {
+            value: JsHandle::new(value),
+            host_data,
+        }
+    }
+
+    pub(crate) fn as_js_value(&self) -> JsValue {
+        (*self.value).clone()
     }
 
-    pub fn downcast<'a, T>(&self, _store: &'a impl AsStoreRef) -> Option<&'a T>
+    pub fn downcast<'a, T>(&self, store: &'a impl AsStoreRef) -> Option<&'a T>
     where
         T: Any + Send + Sync + 'static + Sized,
     {
-        unimplemented!("ExternRef is not yet supported in Javascript");
+        self.host_data
+            .as_ref()?
+            .get(store.as_store_ref().objects().as_js())
+            .0
+            .downcast_ref()
     }
 
     pub(crate) fn vm_externref(&self) -> VMExternRef {
-        unimplemented!("ExternRef is not yet supported in Javascript");
+        VMExternRef::new(self.as_js_value())
     }
 
     pub(crate) unsafe fn from_vm_externref(
-        _store: &mut impl AsStoreMut,
-        _vm_externref: VMExternRef,
+        store: &mut impl AsStoreMut,
+        vm_externref: VMExternRef,
     ) -> Self {
-        unimplemented!("ExternRef is not yet supported in Javascript");
+        Self::from_js_value(store, vm_externref.into_js_value())
+    }
+
+    pub fn is_from_store(&self, store: &impl AsStoreRef) -> bool {
+        self.host_data
+            .as_ref()
+            .is_none_or(|handle| handle.store_id() == store.as_store_ref().objects().id())
     }
 
-    pub fn is_from_store(&self, _store: &impl AsStoreRef) -> bool {
-        true
+    pub fn ptr_eq(&self, other: &Self) -> bool {
+        js_sys::Object::is(&self.value, &other.value)
     }
+}
+
+fn host_ref_index_key() -> Symbol {
+    Symbol::for_("wasmer.externref-index")
+}
+
+fn host_ref_store_key() -> Symbol {
+    Symbol::for_("wasmer.externref-store")
+}
 
-    pub fn ptr_eq(&self, _other: &Self) -> bool {
-        unimplemented!("ExternRef is not yet supported in Javascript");
+fn host_handle_from_js_value(
+    store: &mut impl AsStoreMut,
+    value: &JsValue,
+) -> Option<StoreHandle<ExternRefData>> {
+    let index = js_sys::Reflect::get(value, host_ref_index_key().as_ref())
+        .ok()?
+        .as_f64()? as usize;
+    let store_id = js_sys::Reflect::get(value, host_ref_store_key().as_ref())
+        .ok()?
+        .as_f64()? as u64;
+    let objects = store.objects_mut();
+    if objects.id().as_raw().get() as u64 != store_id {
+        return None;
     }
+    let internal = crate::js::entities::store::InternalStoreHandle::from_index(index)?;
+    Some(unsafe { StoreHandle::from_internal(objects.id(), internal) })
 }