Merge remote-tracking branch 'origin/main' into blockless

# Conflicts:
#       Cargo.lock

crates/cli/Cargo.toml

@@ -19,16 +19,16 @@ wizer = { workspace = true }
 structopt = "0.3"
 anyhow = { workspace = true }
 brotli = "3.4.0"
-wasmprinter = { version = "0.2.78", optional = true }
+wasmprinter = { version = "0.201.0", optional = true }
 wasmtime = { workspace = true }
 wasmtime-wasi = { workspace = true }
 wasi-common = { workspace = true }
 walrus = "0.20.3"
-swc_core = { version = "0.89.7", features = ["common_sourcemap", "ecma_ast", "ecma_parser"] }
-wit-parser = "0.13.1"
+swc_core = { version = "0.90.14", features = ["common_sourcemap", "ecma_ast", "ecma_parser"] }
+wit-parser = "0.201.0"
 convert_case = "0.6.0"
 wasm-opt = "0.116.0"
-tempfile = "3.9.0"
+tempfile = "3.10.1"
 
 [dev-dependencies]
 serde_json = "1.0"
@@ -37,10 +37,10 @@ lazy_static = "1.4"
 serde = { version = "1.0", default-features = false, features = ["derive"] }
 criterion = "0.5"
 num-format = "0.4.4"
-wasmparser = "0.121.0"
+wasmparser = "0.201.0"
 
 [build-dependencies]
-anyhow = "1.0.79"
+anyhow = "1.0.80"
 wizer = { workspace = true }
 
 [[bench]]

crates/javy/Cargo.toml

@@ -11,7 +11,7 @@ categories = ["wasm"]
 
 [dependencies]
 anyhow = { workspace = true }
-quickjs-wasm-rs = { version = "3.0.1-alpha.1", path = "../quickjs-wasm-rs" }
+quickjs-wasm-rs = { version = "3.1.0-alpha.1", path = "../quickjs-wasm-rs" }
 serde_json = { version = "1.0", optional = true }
 serde-transcode = { version = "1.1", optional = true }
 rmp-serde = { version = "^1.1", optional = true }

crates/quickjs-wasm-rs/CHANGELOG.md

@@ -7,6 +7,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## Unreleased
 
+- Add a new `expose-sys` feature that exposes unstable escape hatch functions to the underlying `quickjs_wasm_sys` crate.
+
 ## [3.0.0] - 2024-01-31
 
 ### Changed

crates/quickjs-wasm-rs/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "quickjs-wasm-rs"
-version = "3.0.1-alpha.1"
+version = "3.1.0-alpha.1"
 authors.workspace = true
 edition.workspace = true
 license.workspace = true
@@ -18,3 +18,7 @@ once_cell = "1.19"
 [dev-dependencies]
 quickcheck = "1"
 serde_bytes = "0.11.14"
+
+[features]
+# Re-exports the quickjs-wasm-sys module and exposes additional, unstable APIs.
+export-sys = []

crates/quickjs-wasm-rs/src/js_binding/context.rs

@@ -141,6 +141,30 @@ impl JSContextRef {
         JSValueRef::new(self, raw)
     }
 
+    /// Returns the raw pointer to the underlying [quickjs_wasm_sys::JSContext].
+    ///
+    /// # Safety
+    /// While calling this function is safe, using it’s return value has to be
+    /// done with a sufficitenly deep understanding of QuickJS and [quickjs_wasm_sys].
+    ///
+    /// This function is not part of the crate’s semver API contract.
+    #[cfg(feature = "export-sys")]
+    pub unsafe fn as_raw(&self) -> *mut JSContext {
+        self.inner
+    }
+
+    /// Creates a `JSContextRef` from a pointer to a [quickjs_wasm_sys::JSContext].
+    ///
+    /// # Safety
+    /// The caller has to ensure that the returned `JSContextRef` is the only one
+    /// used throughout its lifetime.
+    ///
+    /// This function is not part of the crate’s semver API contract.
+    #[cfg(feature = "export-sys")]
+    pub unsafe fn from_raw(inner: *mut JSContext) -> JSContextRef {
+        JSContextRef { inner }
+    }
+
     /// Compiles JavaScript to QuickJS bytecode with an ECMAScript module scope.
     ///
     /// # Arguments

crates/quickjs-wasm-rs/src/js_binding/value.rs

@@ -58,6 +58,25 @@ impl<'a> JSValueRef<'a> {
         Self { context, value }
     }
 
+    /// Creates a new `JSValueRef` from a `u64`, which is QuickJS’s internal representation.
+    ///
+    /// # Safety
+    /// The caller has to ensure that the given value is valid and belongs to the context.
+    ///
+    /// This function is not part of the crate’s semver API contract.
+    #[cfg(feature = "export-sys")]
+    pub unsafe fn from_raw(context: &'a JSContextRef, value: JSValueRaw) -> Self {
+        JSValueRef::new_unchecked(context, value)
+    }
+
+    /// Returns QuickJS’s internal representation. Note that the value is implicitly tied to the context it came from.
+    ///
+    /// # Safety
+    /// The function is safe to call, but not part of the crate’s semver API contract.
+    #[cfg(feature = "export-sys")]
+    pub unsafe fn as_raw(&self) -> JSValueRaw {
+        self.value
+    }
     pub(super) fn eval_function(&self) -> Result<Self> {
         Self::new(self.context, unsafe {
             JS_EvalFunction(self.context.inner, self.value)

crates/quickjs-wasm-rs/src/lib.rs

@@ -66,6 +66,9 @@ mod js_binding;
 mod js_value;
 mod serialize;
 
+#[cfg(feature = "export-sys")]
+pub use quickjs_wasm_sys;
+
 pub use crate::js_binding::context::JSContextRef;
 pub use crate::js_binding::error::JSError;
 pub use crate::js_binding::exception::Exception;

crates/quickjs-wasm-sys/CHANGELOG.md

@@ -7,6 +7,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## Unreleased changes
 
+- Expose `JS_DupValue` via `JS_DupValueExt`.
+
 ## [1.2.0] - 2024-01-31
 
 - Changed: Updated to 2023-12-09 release of QuickJS.

crates/quickjs-wasm-sys/Cargo.toml

@@ -11,10 +11,10 @@ categories = ["external-ffi-bindings"]
 
 [build-dependencies]
 cc = "1.0"
-bindgen = "0.69.2"
+bindgen = "0.69.4"
 walkdir = "2"
 anyhow.workspace = true
-tokio = { version = "1.35", default-features = false, features = ["rt", "macros"] }
+tokio = { version = "1.36", default-features = false, features = ["rt", "macros"] }
 http-body-util = "0.1.0"
 hyper = "1.1"
 hyper-tls = "0.6.0"

crates/quickjs-wasm-sys/extensions/value.c

@@ -1,5 +1,15 @@
-#include "../quickjs/quickjs.h"
 #include "../quickjs/libbf.h"
+#include "../quickjs/quickjs.h"
+
+// Quick JS API Extensions.
+// These are wrapper functions on top of QuickJS API and exist because either
+// QuickJS doesn't expose a native way to achieve the desired behavior or
+// because the functions are marked inline, and in which case, bindgen can't
+// generate Rust bindings out-of-the box.
+// https://github.com/rust-lang/rust-bindgen/discussions/2405
+
+// The definitions in this file are paired with their respective `extern "C"`
+// declaration in `extensions/value.rs`.
 
 JSValue JS_NewBool_Ext(JSContext *ctx, JS_BOOL val) {
   return JS_MKVAL(JS_TAG_BOOL, (val != 0));
@@ -21,18 +31,20 @@ JSValue JS_NewFloat64_Ext(JSContext *ctx, double d) {
   return JS_NewFloat64(ctx, d);
 }
 
-JS_BOOL JS_IsFloat64_Ext(int tag) {
-  return JS_TAG_IS_FLOAT64(tag);
+JSValue JS_DupValueExt(JSContext *ctx, JSValueConst v) {
+  return JS_DupValue(ctx, v);
 }
 
-JS_BOOL JS_IsArrayBuffer_Ext(JSContext* ctx, JSValue val) {
-    size_t len;
-    return JS_GetArrayBuffer(ctx, &len, val) != 0;
+JS_BOOL JS_IsFloat64_Ext(int tag) { return JS_TAG_IS_FLOAT64(tag); }
+
+JS_BOOL JS_IsArrayBuffer_Ext(JSContext *ctx, JSValue val) {
+  size_t len;
+  return JS_GetArrayBuffer(ctx, &len, val) != 0;
 }
 
 typedef struct JSBigFloat {
-    JSRefCountHeader header; /* must come first, 32-bit */
-    bf_t num;
+  JSRefCountHeader header; /* must come first, 32-bit */
+  bf_t num;
 } JSBigFloat;
 
 JS_BOOL JS_BigIntSigned(JSContext *ctx, JSValue val) {
@@ -72,7 +84,6 @@ int JS_BigIntToUint64(JSContext *ctx, uint64_t *pres, JSValueConst val) {
   return JS_BigIntToUint64Free(ctx, pres, JS_DupValue(ctx, val));
 }
 
-
 const JSValue ext_js_null = JS_NULL;
 const JSValue ext_js_undefined = JS_UNDEFINED;
 const JSValue ext_js_false = JS_FALSE;

crates/quickjs-wasm-sys/src/extensions/value.rs

@@ -1,4 +1,5 @@
 extern "C" {
+    pub fn JS_DupValueExt(ctx: *mut JSContext, v: JSValue) -> JSValue;
     pub fn JS_NewBool_Ext(ctx: *mut JSContext, bool: i32) -> JSValue;
     pub fn JS_NewInt32_Ext(ctx: *mut JSContext, val: i32) -> JSValue;
     pub fn JS_NewUint32_Ext(ctx: *mut JSContext, val: u32) -> JSValue;