Add Rust bindings for the runtime and the SpiderMonkey engines

.github/workflows/main.yml

@@ -24,16 +24,46 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        build: [release, debug, weval]
+        build: [release, debug]
         os: [ubuntu-latest]
+    outputs:
+      SM_TAG_EXISTS: ${{ steps.check-sm-release.outputs.SM_TAG_EXISTS }}
+      SM_TAG: ${{ steps.check-sm-release.outputs.SM_TAG }}
+      SM_CACHE_KEY_debug: ${{ steps.check-sm-release.outputs.SM_CACHE_KEY_debug }}
+      SM_CACHE_KEY_release: ${{ steps.check-sm-release.outputs.SM_CACHE_KEY_release }}
     runs-on: ${{ matrix.os }}
     steps:
     - uses: actions/checkout@v2
 
-    - name: Install Rust 1.80.0
+    - name: Check if SpiderMonkey Release Exists
+      id: check-sm-release
       run: |
-        rustup toolchain install 1.80.0
-        rustup target add wasm32-wasip1 --toolchain 1.80.0
+        SM_TAG="libspidermonkey_$(awk '/^set\(SM_TAG/ {gsub(/set\(SM_TAG |\)/, ""); print}' cmake/spidermonkey.cmake)"
+        echo "SM_TAG=${SM_TAG}" >> "$GITHUB_OUTPUT"
+        if gh release view "${SM_TAG}" >/dev/null 2>&1; then
+          echo "Found existing SpiderMonkey release tag: ${SM_TAG}"
+          echo "SM_TAG_EXISTS=true" >> "$GITHUB_OUTPUT"
+        else
+          echo "SM_TAG_EXISTS=false" >> "$GITHUB_OUTPUT"
+          echo "SM_CACHE_KEY_${{ matrix.build }}=spidermonkey-cache-${{ matrix.build }}-${{ hashFiles('cmake/spidermonkey.cmake') }}" >> "$GITHUB_OUTPUT"
+        fi
+      env:
+        GH_TOKEN: ${{ github.token }}
+
+    - name: Cache SpiderMonkey tarball
+      if: steps.check-sm-release.outputs.SM_TAG_EXISTS == 'false'
+      uses: actions/cache@v4
+      id: sm-cache
+      with:
+        path: |
+          spidermonkey-dist-${{ matrix.build }}
+        key: spidermonkey-cache-${{ matrix.build }}-${{ hashFiles('cmake/spidermonkey.cmake') }}
+
+    - name: Set env var to use cached SpiderMonkey tarball
+      if: steps.check-sm-release.outputs.SM_TAG_EXISTS == 'false' && steps.sm-cache.outputs.cache-hit == 'true'
+      run: |
+        tree spidermonkey-dist-${{ matrix.build }}
+        echo "SPIDERMONKEY_BINARIES=$(pwd)/spidermonkey-dist-${{ matrix.build }}" >> $GITHUB_ENV
 
     - uses: actions/setup-node@v2
       with:
@@ -64,3 +94,63 @@ jobs:
     - name: StarlingMonkey E2E, Integration, and WPT Tests
       run: |
         CTEST_OUTPUT_ON_FAILURE=1 ctest --test-dir cmake-build-${{ matrix.build }} -j$(nproc) --verbose
+
+    - name: Set up cacheable SpiderMonkey artifacts
+      if: steps.check-sm-release.outputs.SM_TAG_EXISTS == 'false' && steps.sm-cache.outputs.cache-hit != 'true'
+      run: |
+        mkdir -p spidermonkey-dist-${{ matrix.build }}
+        cp -a cmake-build-${{ matrix.build }}/spidermonkey-obj/dist/libspidermonkey.a spidermonkey-dist-${{ matrix.build }}/
+        cp -aL cmake-build-${{ matrix.build }}/spidermonkey-obj/dist/include spidermonkey-dist-${{ matrix.build }}/
+        tree spidermonkey-dist-${{ matrix.build }}
+
+      # Upload tarball as an artifact of the github action run, so the output
+      # can be inspected for pull requests.
+    - name: Upload SpiderMonkey tarball
+      uses: actions/upload-artifact@v4
+      if: (github.event_name != 'push' || (github.ref != 'refs/heads/main' && !startsWith(github.ref, 'refs/tags/v')))
+        && steps.check-sm-release.outputs.SM_TAG_EXISTS == 'false' && steps.sm-cache.outputs.cache-hit != 'true'
+      with:
+        name: spidermonkey-${{ matrix.build }}
+        path: spidermonkey-dist-${{ matrix.build }}/*
+
+  release-spidermonkey:
+    needs: test
+    if: needs.test.outputs.SM_TAG_EXISTS == 'false' && (github.event_name == 'push' && 
+          (github.ref == 'refs/heads/main' || startsWith(github.ref, 'refs/tags/v')))
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+    steps:
+    - name: Restore SpiderMonkey Debug Cache
+      uses: actions/cache/restore@v4
+      id: sm-cache-debug
+      with:
+        path: |
+          spidermonkey-dist-debug
+        key: ${{ needs.test.outputs.SM_CACHE_KEY_debug }}
+        fail-on-cache-miss: true
+    - name: Restore SpiderMonkey Release Cache
+      uses: actions/cache/restore@v4
+      id: sm-cache-release
+      with:
+        path: |
+          spidermonkey-dist-release
+        key: ${{ needs.test.outputs.SM_CACHE_KEY_release }}
+        fail-on-cache-miss: true
+
+    - name: Create SpiderMonkey Tar Balls
+      run: |
+        mkdir -p release-artifacts
+        tar -a -cf release-artifacts/spidermonkey-static-debug.tar.gz spidermonkey-dist-debug/*
+        tar -a -cf release-artifacts/spidermonkey-static-release.tar.gz spidermonkey-dist-release/*
+        tree release-artifacts
+
+    - name: Do the Release
+      uses: softprops/action-gh-release@72f2c25fcb47643c292f7107632f7a47c1df5cd8 #2.3.2
+      with:
+        body: |
+          This release contains pre-built SpiderMonkey artifacts to be used by the StarlingMonkey
+          build system. It's not meant for general public consumption and doesn't come with any
+          stability or availability guarantees.
+        tag_name: ${{ needs.test.outputs.SM_TAG }}
+        files: release-artifacts/*

.gitignore

@@ -22,9 +22,11 @@
 /.spin
 
 # Rust compilation output
-/target
+/runtime/crates/target/
 
 /tests/e2e/*/*.wasm
 /tests/e2e/*/*.log
 /tests/integration/*/*.wasm
 /tests/integration/*/*.log
+/deps/*.lock
+/deps/*-source

AUTHORS.md

@@ -2,4 +2,8 @@ The portions of this code found in the initial commit are Copyright © 2021-2023
 contributors to Fastly's
 [js-compute-runtime project](https://github.com/fastly/js-compute-runtime/).
 
-Changes following that initial commit are Copyright © the respective contributors.
+Changes following that initial commit are Copyright © the respective contributors where not documented otherwise.
+
+## Rust Bindings
+
+The Rust bindings found under [runtime/crates](runtime/crates) are based on the Servo project's [mozjs and mozjs-sys](https://github.com/servo/mozjs) crates. The code under that folder is Copyright © The Servo Project Developers up to the fork, and Copyright © the respective contributors where not documented otherwise from then on.  

CMakeLists.txt

@@ -20,6 +20,10 @@ else()
 endif()
 message(STATUS "Using host API: ${HOST_API}")
 
+# Ensure that the CPM cache is created outside the build dir, even if no location is specified by the developer.
+if(NOT DEFINED ENV{CPM_SOURCE_CACHE})
+    set(ENV{CPM_SOURCE_CACHE} ${CMAKE_CURRENT_SOURCE_DIR}/deps/cpm_cache)
+endif()
 include("CPM")
 include("toolchain")
 
@@ -32,36 +36,36 @@ include("binaryen")
 include("wizer")
 include("weval")
 include("wasmtime")
+include("cbindgen")
 
-include("fmt")
 include("spidermonkey")
 include("openssl")
 include("${HOST_API}/host_api.cmake")
 include("build-crates")
 
 option(ENABLE_JS_DEBUGGER "Enable support for debugging content via a socket connection" ON)
 
-add_library(extension_api INTERFACE include/extension-api.h runtime/encode.h runtime/decode.h)
+add_library(extension_api INTERFACE include/extension-api.h runtime/cpp/encode.h runtime/cpp/decode.h)
 if (ENABLE_JS_DEBUGGER)
     target_compile_definitions(extension_api INTERFACE ENABLE_JS_DEBUGGER)
 endif()
 target_link_libraries(extension_api INTERFACE rust-url spidermonkey)
-target_include_directories(extension_api INTERFACE include deps/include runtime)
+target_include_directories(extension_api INTERFACE include deps/include runtime/cpp)
 
 include("builtins")
 
 include("tests/wpt-harness/wpt.cmake")
 
 set(SOURCES
-    runtime/js.cpp
-    runtime/allocator.cpp
-    runtime/encode.cpp
-    runtime/decode.cpp
-    runtime/engine.cpp
-    runtime/event_loop.cpp
-    runtime/builtin.cpp
-    runtime/script_loader.cpp
-    runtime/debugger.cpp
+    runtime/cpp/js.cpp
+    runtime/cpp/allocator.cpp
+    runtime/cpp/encode.cpp
+    runtime/cpp/decode.cpp
+    runtime/cpp/engine.cpp
+    runtime/cpp/event_loop.cpp
+    runtime/cpp/builtin.cpp
+    runtime/cpp/script_loader.cpp
+    runtime/cpp/debugger.cpp
 )
 
 add_executable(starling-raw.wasm ${SOURCES})

LICENSE

@@ -186,7 +186,7 @@
       same "printed page" as the copyright notice for easier
       identification within third-party archives.
 
-    Copyright 2020 Fastly, Inc.
+    Copyright StarlingMonkey project contributors
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.

README.md

@@ -71,43 +71,60 @@ cmake -S . -B cmake-build-debug -DCMAKE_BUILD_TYPE=Debug
 
 3. Build the runtime
 
-Building the runtime is done in two phases: first, cmake is used to build a raw version as a
-WebAssembly core module. Then, that module is turned into a [WebAssembly Component][wasm-component]
-using the `componentize.sh` script generated by the build.
+The build system provides two targets for the runtime: `starling-raw.wasm` and `starling.wasm`. The former is a raw WebAssembly core module that can be used to build a WebAssembly Component, while the latter is the final componentized runtime that can be used directly with a WebAssembly Component-aware runtime like [wasmtime](https://wasmtime.dev/).
 
-The following command will build the `starling-raw.wasm` runtime module in the `cmake-build-release`
+A key difference is that `starling.wasm` can only be used for runtime-evaluation of JavaScript code,
+while `starling-raw.wasm` can be used to build a WebAssembly Component that is specialized for a specific
+JavaScript application, and as a result has much faster startup times.
+
+## Using StarlingMonkey with dynamically loaded JS code
+
+The following command will build the `starling.wasm` runtime module in the `cmake-build-release`
 directory:
 
 ```console
 # Use cmake-build-debug for the debug build
-# Change the value for `--parallel` to match the number of CPU cores in your system
-cmake --build cmake-build-release --parallel 8
+cmake --build cmake-build-release -t starling --parallel $(nproc)
 ```
 
-Then, the `starling-raw.wasm` module can be turned into a component with the following command:
+The resulting runtime can be used to load and evaluate JS code dynamically:
 
 ```console
-cd cmake-build-release
-./componentize.sh -o starling.wasm
+wasmtime -S http cmake-build-release/starling.wasm -e "console.log('hello world')"
+# or, to load a file:
+wasmtime -S http --dir . starling.wasm index.js
 ```
 
-The resulting runtime can be used to load and evaluate JS code dynamically:
+
+## Creating a specialized runtime for your JS code
+
+To create a specialized version of the runtime, first build a raw, unspecialized core wasm version of StarlingMonkey:
 
 ```console
-wasmtime -S http starling.wasm -e "console.log('hello world')"
-# or, to load a file:
-wasmtime -S http --dir . starling.wasm index.js
+# Use cmake-build-debug for the debug build
+cmake --build cmake-build-release -t starling-raw.wasm --parallel $(nproc)
 ```
 
-Alternatively, a JS file can be provided during componentization:
+Then, the `starling-raw.wasm` module can be turned into a component specialized for your code with the following command:
 
 ```console
 cd cmake-build-release
-./componentize.sh index.js -o starling.wasm
+./componentize.sh index.js -o index.wasm
 ```
 
-This way, the JS file will be loaded during componentization, and the top-level code will be
-executed, and can e.g. register a handler for the `fetch` event to serve HTTP requests.
+This mode currently only supports the creation of HTTP server components, which means that the `index.js` file must register a `fetch` event handler. For example, your `index.js` could contain the following code:
+
+```javascript
+addEventListener('fetch', event => {
+  event.respondWith(new Response('Hello, world!'));
+});
+```
+
+Componentizing this code like above allows running it like this:
+
+```console
+wasmtime serve -S cli --dir . index.wasm
+```
 
 [cmake]: https://cmake.org/
 [gh-pages]: https://bytecodealliance.github.io/StarlingMonkey/

builtins/install_builtins.cpp

@@ -1,17 +1,25 @@
 #include "extension-api.h"
 
-#define NS_DEF(ns)                                                                                 \
-  namespace ns {                                                                                   \
-  extern bool install(api::Engine *engine);                                                        \
+#define NS_DEF(ns)                              \
+  namespace ns {                                \
+  extern bool install(api::Engine *engine);     \
   }
+#define RS_DEF(install_fn)                      \
+extern "C" bool install_fn(api::Engine *engine);
 #include "builtins.incl"
+#undef RS_DEF
 #undef NS_DEF
 
+
 bool install_builtins(api::Engine *engine) {
-#define NS_DEF(ns)                                                                                 \
-  if (!ns::install(engine))                                                                        \
+#define NS_DEF(ns)                              \
+  if (!ns::install(engine))                     \
+    return false;
+#define RS_DEF(install_fn)                      \
+  if (!install_fn(engine))                      \
     return false;
 #include "builtins.incl"
+#undef RS_DEF
 #undef NS_DEF
 
   return true;

builtins/web/base64.cpp

@@ -212,7 +212,7 @@ JS::Result<std::string> forgivingBase64Decode(std::string_view data,
   auto hasWhitespace = std::find_if(data.begin(), data.end(), &isAsciiWhitespace);
   std::string dataWithoutAsciiWhitespace;
 
-  if (hasWhitespace) {
+  if (*hasWhitespace) {
     dataWithoutAsciiWhitespace = data;
     dataWithoutAsciiWhitespace.erase(std::remove_if(dataWithoutAsciiWhitespace.begin() +
                                                         std::distance(data.begin(), hasWhitespace),

builtins/web/console.cpp

@@ -468,7 +468,7 @@ static bool console_out(JSContext *cx, unsigned argc, JS::Value *vp) {
 
 // https://console.spec.whatwg.org/#assert
 // assert(condition, ...data)
-static bool assert(JSContext *cx, unsigned argc, JS::Value *vp) {
+static bool assert_(JSContext *cx, unsigned argc, JS::Value *vp) {
   JS::CallArgs args = CallArgsFromVp(argc, vp);
   args.rval().setUndefined();
   auto condition = args.get(0).toBoolean();
@@ -811,7 +811,7 @@ static bool trace(JSContext *cx, unsigned argc, JS::Value *vp) {
 }
 
 const JSFunctionSpec Console::methods[] = {
-    JS_FN("assert", assert, 0, JSPROP_ENUMERATE),
+    JS_FN("assert", assert_, 0, JSPROP_ENUMERATE),
     JS_FN("clear", no_op, 0, JSPROP_ENUMERATE),
     JS_FN("count", count, 0, JSPROP_ENUMERATE),
     JS_FN("countReset", countReset, 0, JSPROP_ENUMERATE),

builtins/web/crypto/uuid.cpp

@@ -1,8 +1,6 @@
 #include "uuid.h"
 #include "host_api.h"
 
-#include <fmt/core.h>
-
 namespace builtins {
 namespace web {
 namespace crypto {

builtins/web/event/event-target.cpp

@@ -102,7 +102,7 @@ bool default_passive_value() {
 
 namespace JS {
 
-template <typename T> struct JS::GCPolicy<RefPtr<T>> {
+template <typename T> struct GCPolicy<RefPtr<T>> {
   static void trace(JSTracer *trc, RefPtr<T> *tp, const char *name) {
     if (T *target = tp->get()) {
       GCPolicy<T>::trace(trc, target, name);

builtins/web/fetch/fetch-api.cpp

@@ -18,8 +18,6 @@ using blob::Blob;
 using fetch::Headers;
 using host_api::HostString;
 
-static api::Engine *ENGINE;
-
 enum class FetchScheme {
   About,
   Blob,
@@ -107,7 +105,8 @@ bool fetch_https(JSContext *cx, HandleObject request_obj, HostString method, Hos
   // If the request body is streamed, we need to wait for streaming to complete
   // before marking the request as pending.
   if (!streaming) {
-    ENGINE->queue_async_task(new ResponseFutureTask(request_obj, pending_handle));
+    api::Engine::from_context(cx)
+      .queue_async_task(new ResponseFutureTask(request_obj, pending_handle));
   }
 
   SetReservedSlot(request_obj, static_cast<uint32_t>(Request::Slots::ResponsePromise),
@@ -345,8 +344,6 @@ bool fetch(JSContext *cx, unsigned argc, Value *vp) {
 const JSFunctionSpec methods[] = {JS_FN("fetch", fetch, 2, JSPROP_ENUMERATE), JS_FS_END};
 
 bool install(api::Engine *engine) {
-  ENGINE = engine;
-
   if (!JS_DefineFunctions(engine->cx(), engine->global(), methods))
     return false;
   if (!request_response::install(engine)) {

builtins/web/fetch/fetch-utils.cpp

@@ -160,7 +160,7 @@ std::optional<std::tuple<size_t, size_t>> extract_range(std::string_view range_q
 
   auto to_size = [](std::string_view s) -> std::optional<size_t> {
     size_t v;
-    auto [ptr, ec] = std::from_chars(s.begin(), s.end(), v);
+    auto [ptr, ec] = std::from_chars(&*s.begin(), &*s.end(), v);
     return ec == std::errc() ? std::optional<size_t>(v) : std::nullopt;
   };