ruby_wasm 2.5.0 → 2.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f42f03a6e5dcd06b68414f462b48a22402e1944e5535342f3d3b707697ffff42
-  data.tar.gz: f685a3c61822ab104266c30e1646384a0e5450c9b2eab24d84ad565b03c7b192
+  metadata.gz: 141bd526a7aa152f05058c93841d80f242c72137591183a9d5f891bf5ee715fe
+  data.tar.gz: 2f491189cc5667b6f601e08c1685ace9fc9992738d264c76587487a91f4bde0b
 SHA512:
-  metadata.gz: 96dfec4b5cb068578c121106228bf646246fca5d28b9b7fa94d47a8668bd9ead185cbc29e9f002fd25c302132970bd509ffa27dce3ee967a2c8ea203d6f3df50
-  data.tar.gz: adbaf753357914c4b25791f39915a62863f61fc062903f21037ce95c8a075b45c14228aa08acfc81ca69fd994a1b473b7fcaf219fad145b4a7cff238b240895e
+  metadata.gz: 551d4bf9b6f7485f3a286363671a1f990729a0c626dd0b2b18324146826c3176873301359003ed3978c2a36d1e5ed46d9ddce93b213968bf59f0f9302f02901d
+  data.tar.gz: 48ca26f8ccb3e18b39a541e3ab3c41a154a3ddec56890d0b87f3fb88a2d6f16b509558c316cb75182fa80a29c94e76f760731a0d75b0fd089d5b4415cfd46513

data/CONTRIBUTING.md

@@ -21,7 +21,7 @@ $ rake --tasks
 $ rake build:download_prebuilt
 
 # Build Ruby (if you need to build Ruby by yourself)
-$ rake build:head-wasm32-unknown-wasi-full
+$ rake build:head-wasm32-unknown-wasip1-full
 
 # Build npm package
 $ rake npm:ruby-head-wasm-wasi
@@ -48,15 +48,15 @@ To select a build profile, see [profiles section in README](https://github.com/r
 
 ```console
 # Build only a specific combination of ruby version, profile, and target
-$ rake build:head-wasm32-unknown-wasi-full
+$ rake build:head-wasm32-unknown-wasip1-full
 # Clean up the build directory
-$ rake build:head-wasm32-unknown-wasi-full:clean
+$ rake build:head-wasm32-unknown-wasip1-full:clean
 # Force to re-execute "make install"
-$ rake build:head-wasm32-unknown-wasi-full:remake
+$ rake build:head-wasm32-unknown-wasip1-full:remake
 
 # Output is in the `rubies` directory
-$ tree -L 3 rubies/head-wasm32-unknown-wasi-full
-rubies/head-wasm32-unknown-wasi-full/
+$ tree -L 3 rubies/head-wasm32-unknown-wasip1-full
+rubies/head-wasm32-unknown-wasip1-full/
 ├── usr
 │   └── local
 │       ├── bin
@@ -124,5 +124,5 @@ $ npm install --save @ruby/wasm-wasi@latest
 # or if you want the nightly snapshot
 $ npm install --save @ruby/wasm-wasi@next
 # or you can specify the exact snapshot version
-$ npm install --save @ruby/wasm-wasi@2.5.0-2024-01-28-a
+$ npm install --save @ruby/wasm-wasi@2.5.1-2024-04-21-a
 ```

data/Cargo.lock

@@ -1012,6 +1012,7 @@ version = "0.6.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4778544796676e8428e9c622460ebf284bea52d8b10db3aeb449d8b5e61b3a13"
 dependencies = [
+ "bytes",
  "magnus-macros",
  "rb-sys",
  "rb-sys-env",
@@ -1268,18 +1269,18 @@ dependencies = [
 
 [[package]]
 name = "rb-sys"
-version = "0.9.86"
+version = "0.9.97"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7285f2a7b92f58ab198e3fd59a71d2861478f9c4642f41e83582385818941697"
+checksum = "47d30bcad206b51f2f66121190ca678dce1fdf3a2eae0ac5d838d1818b19bdf5"
 dependencies = [
  "rb-sys-build",
 ]
 
 [[package]]
 name = "rb-sys-build"
-version = "0.9.86"
+version = "0.9.97"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "71583945f94dabb6c0dfa63f1b71e929c1901e1e288ef3739ab8bed3b7069550"
+checksum = "3cbd92f281615f3c2dcb9dcb0f0576624752afbf9a7f99173b37c4b55b62dd8a"
 dependencies = [
  "bindgen",
  "lazy_static",
@@ -1362,9 +1363,11 @@ checksum = "c08c74e62047bb2de4ff487b251e4a92e24f48745648451635cec7d591162d9f"
 name = "ruby_wasm"
 version = "0.0.0"
 dependencies = [
+ "bytes",
  "magnus",
  "structopt",
  "wasi-vfs-cli",
+ "wit-component",
  "wizer",
 ]
 
@@ -1498,6 +1501,15 @@ dependencies = [
  "windows-sys 0.48.0",
 ]
 
+[[package]]
+name = "spdx"
+version = "0.10.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "29ef1a0fa1e39ac22972c8db23ff89aea700ab96aa87114e1fb55937a631a0c9"
+dependencies = [
+ "smallvec",
+]
+
 [[package]]
 name = "sptr"
 version = "0.3.2"
@@ -1892,6 +1904,31 @@ dependencies = [
  "leb128",
 ]
 
+[[package]]
+name = "wasm-encoder"
+version = "0.203.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "87e3b46a0d9d9143d57aa926c42e2af284b5cb8f0c7b71079afc7a6fca42db50"
+dependencies = [
+ "leb128",
+]
+
+[[package]]
+name = "wasm-metadata"
+version = "0.203.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "19fbd9b7017bdb3ceb63503a18d1aa7b0d026e18ce659d40b93bd9a15391424f"
+dependencies = [
+ "anyhow",
+ "indexmap 2.1.0",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "spdx",
+ "wasm-encoder 0.203.0",
+ "wasmparser 0.203.0",
+]
+
 [[package]]
 name = "wasmparser"
 version = "0.106.0"
@@ -1912,6 +1949,17 @@ dependencies = [
  "semver",
 ]
 
+[[package]]
+name = "wasmparser"
+version = "0.203.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1b473b35fff082e8c8377f4e2c8d48075e562aa051e48a02229bdcafbf349d37"
+dependencies = [
+ "bitflags 2.4.1",
+ "indexmap 2.1.0",
+ "semver",
+]
+
 [[package]]
 name = "wasmprinter"
 version = "0.2.75"
@@ -2002,7 +2050,7 @@ dependencies = [
  "syn 2.0.48",
  "wasmtime-component-util",
  "wasmtime-wit-bindgen",
- "wit-parser",
+ "wit-parser 0.13.0",
 ]
 
 [[package]]
@@ -2255,7 +2303,7 @@ dependencies = [
  "anyhow",
  "heck 0.4.1",
  "indexmap 2.1.0",
- "wit-parser",
+ "wit-parser 0.13.0",
 ]
 
 [[package]]
@@ -2525,6 +2573,25 @@ dependencies = [
  "windows-sys 0.52.0",
 ]
 
+[[package]]
+name = "wit-component"
+version = "0.203.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "379c4e193d37b3e2c808e99515c2a91dc19e7b3b160adfbb374463875375d6ff"
+dependencies = [
+ "anyhow",
+ "bitflags 2.4.1",
+ "indexmap 2.1.0",
+ "log",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "wasm-encoder 0.203.0",
+ "wasm-metadata",
+ "wasmparser 0.203.0",
+ "wit-parser 0.203.0",
+]
+
 [[package]]
 name = "wit-parser"
 version = "0.13.0"
@@ -2542,6 +2609,24 @@ dependencies = [
  "unicode-xid",
 ]
 
+[[package]]
+name = "wit-parser"
+version = "0.203.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f547f9154c0fbd020c81c348d703b549bafd16ea68b15927acb5c890467e734"
+dependencies = [
+ "anyhow",
+ "id-arena",
+ "indexmap 2.1.0",
+ "log",
+ "semver",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "unicode-xid",
+ "wasmparser 0.203.0",
+]
+
 [[package]]
 name = "witx"
 version = "0.9.1"

data/Gemfile

@@ -7,7 +7,7 @@ gemspec
 group :development do
   gem "rake"
   gem "rake-compiler"
-  gem "rb_sys", "0.9.85"
+  gem "rb_sys", "0.9.97"
 end
 
 group :check do

data/README.md

@@ -17,17 +17,17 @@ Try ruby.wasm in [TryRuby](https://try.ruby-lang.org/playground#code=puts+RUBY_D
 - [Complete Examples](https://github.com/ruby/ruby.wasm/tree/main/packages/npm-packages/ruby-wasm-wasi/example)
 - [Community Showcase](https://github.com/ruby/ruby.wasm/wiki/Showcase)
 
-## Quick Example: Ruby on browser
+## Quick Example: Ruby on Web browser
 
 Create and save `index.html` page with the following contents:
 
 ```html
 <html>
-  <script src="https://cdn.jsdelivr.net/npm/@ruby/3.3-wasm-wasi@2.5.0/dist/browser.script.iife.js"></script>
+  <script src="https://cdn.jsdelivr.net/npm/@ruby/3.3-wasm-wasi@2.5.1/dist/browser.script.iife.js"></script>
   <script type="text/ruby">
     require "js"
 
-    puts RUBY_VERSION # => Hello, world! (printed to the browser console)
+    puts RUBY_VERSION # (Printed to the Web browser console)
     JS.global[:document].write "Hello, world!"
   </script>
 </html>
@@ -40,18 +40,18 @@ Dependencies: [wasmtime](https://github.com/bytecodealliance/wasmtime)
 ```console
 $ gem install ruby_wasm
 # Download a prebuilt Ruby release
-$ curl -LO https://github.com/ruby/ruby.wasm/releases/latest/download/ruby-3.3-wasm32-unknown-wasi-full.tar.gz
-$ tar xfz ruby-3.3-wasm32-unknown-wasi-full.tar.gz
+$ curl -LO https://github.com/ruby/ruby.wasm/releases/latest/download/ruby-3.3-wasm32-unknown-wasip1-full.tar.gz
+$ tar xfz ruby-3.3-wasm32-unknown-wasip1-full.tar.gz
 
 # Extract ruby binary not to pack itself
-$ mv ruby-3.3-wasm32-unknown-wasi-full/usr/local/bin/ruby ruby.wasm
+$ mv ruby-3.3-wasm32-unknown-wasip1-full/usr/local/bin/ruby ruby.wasm
 
 # Put your app code
 $ mkdir src
 $ echo "puts 'Hello'" > src/my_app.rb
 
 # Pack the whole directory under /usr and your app dir
-$ rbwasm pack ruby.wasm --dir ./src::/src --dir ./ruby-3.3-wasm32-unknown-wasi-full/usr::/usr -o my-ruby-app.wasm
+$ rbwasm pack ruby.wasm --dir ./src::/src --dir ./ruby-3.3-wasm32-unknown-wasip1-full/usr::/usr -o my-ruby-app.wasm
 
 # Run the packed scripts
 $ wasmtime my-ruby-app.wasm /src/my_app.rb
@@ -110,8 +110,8 @@ A _build_ is a combination of ruby version, _profile_, and _target_.
   </thead>
   <tbody>
     <tr>
-      <td><code>wasm32-unknown-wasi</code></td>
-      <td>Targeting WASI-compatible environments (e.g. Node.js, browsers with polyfill, <a href="https://github.com/bytecodealliance/wasmtime">wasmtime</a>, and so on)</td>
+      <td><code>wasm32-unknown-wasip1</code></td>
+      <td>Targeting <a href="https://github.com/WebAssembly/WASI/tree/main/legacy/preview1">WASI Preview1</a> compatible environments <br>(e.g. Node.js, browsers with polyfill, <a href="https://github.com/bytecodealliance/wasmtime">wasmtime</a>, and so on)</td>
     </tr>
     <tr>
       <td><code>wasm32-unknown-emscripten</code></td>

data/Rakefile

@@ -7,6 +7,7 @@ $LOAD_PATH << File.join(File.dirname(__FILE__), "lib")
 require "bundler/gem_tasks"
 require "ruby_wasm/rake_task"
 require "ruby_wasm/packager"
+require "ruby_wasm/cli"
 
 BUILD_SOURCES = %w[3.3 3.2 head]
 BUILD_PROFILES = %w[full minimal]
@@ -14,7 +15,7 @@ BUILD_PROFILES = %w[full minimal]
 BUILDS =
   BUILD_SOURCES
     .product(BUILD_PROFILES)
-    .map { |src, profile| [src, "wasm32-unknown-wasi", profile] } +
+    .map { |src, profile| [src, "wasm32-unknown-wasip1", profile] } +
     BUILD_SOURCES.map { |src| [src, "wasm32-unknown-emscripten", "full"] }
 
 NPM_PACKAGES = [
@@ -28,26 +29,26 @@ NPM_PACKAGES = [
     name: "ruby-head-wasm-wasi",
     ruby_version: "head",
     gemfile: "packages/npm-packages/ruby-wasm-wasi/Gemfile",
-    target: "wasm32-unknown-wasi"
+    target: "wasm32-unknown-wasip1"
   },
   {
     name: "ruby-3.3-wasm-wasi",
     ruby_version: "3.3",
     gemfile: "packages/npm-packages/ruby-wasm-wasi/Gemfile",
-    target: "wasm32-unknown-wasi"
+    target: "wasm32-unknown-wasip1"
   },
   {
     name: "ruby-3.2-wasm-wasi",
     ruby_version: "3.2",
     gemfile: "packages/npm-packages/ruby-wasm-wasi/Gemfile",
-    target: "wasm32-unknown-wasi"
+    target: "wasm32-unknown-wasip1"
   },
-  { name: "ruby-wasm-wasi", target: "wasm32-unknown-wasi" }
+  { name: "ruby-wasm-wasi", target: "wasm32-unknown-wasip1" }
 ]
 
 STANDALONE_PACKAGES = [
-  { name: "ruby", build: "head-wasm32-unknown-wasi-full" },
-  { name: "irb", build: "head-wasm32-unknown-wasi-full" }
+  { name: "ruby", build: "head-wasm32-unknown-wasip1-full" },
+  { name: "irb", build: "head-wasm32-unknown-wasip1-full" }
 ]
 
 LIB_ROOT = File.dirname(__FILE__)

data/docs/cheat_sheet.md

@@ -38,7 +38,7 @@ The easiest way to run Ruby on browser is to use `browser.script.iife.js` script
 
 ```html
 <html>
-  <script src="https://cdn.jsdelivr.net/npm/@ruby/3.3-wasm-wasi@2.5.0/dist/browser.script.iife.js"></script>
+  <script src="https://cdn.jsdelivr.net/npm/@ruby/3.3-wasm-wasi@2.5.1/dist/browser.script.iife.js"></script>
   <script type="text/ruby">
     require "js"
     JS.global[:document].write "Hello, world!"
@@ -51,8 +51,8 @@ If you want to control Ruby VM from JavaScript, you can use `@ruby/wasm-wasi` pa
 ```html
 <html>
   <script type="module">
-    import { DefaultRubyVM } from "https://cdn.jsdelivr.net/npm/@ruby/wasm-wasi@2.5.0/dist/browser/+esm";
-    const response = await fetch("https://cdn.jsdelivr.net/npm/@ruby/3.3-wasm-wasi@2.5.0/dist/ruby+stdlib.wasm");
+    import { DefaultRubyVM } from "https://cdn.jsdelivr.net/npm/@ruby/wasm-wasi@2.5.1/dist/browser/+esm";
+    const response = await fetch("https://cdn.jsdelivr.net/npm/@ruby/3.3-wasm-wasi@2.5.1/dist/ruby+stdlib.wasm");
     const module = await WebAssembly.compileStreaming(response);
     const { vm } = await DefaultRubyVM(module);
 
@@ -69,11 +69,11 @@ If you want to control Ruby VM from JavaScript, you can use `@ruby/wasm-wasi` pa
 
 ```html
 <html>
-  <script src="https://cdn.jsdelivr.net/npm/@ruby/wasm-wasi@2.5.0/dist/browser.umd.js"></script>
+  <script src="https://cdn.jsdelivr.net/npm/@ruby/wasm-wasi@2.5.1/dist/browser.umd.js"></script>
   <script>
     const main = async () => {
       const { DefaultRubyVM } = window["ruby-wasm-wasi"];
-      const response = await fetch("https://cdn.jsdelivr.net/npm/@ruby/3.3-wasm-wasi@2.5.0/dist/ruby+stdlib.wasm");
+      const response = await fetch("https://cdn.jsdelivr.net/npm/@ruby/3.3-wasm-wasi@2.5.1/dist/ruby+stdlib.wasm");
       const module = await WebAssembly.compileStreaming(response);
       const { vm } = await DefaultRubyVM(module);
 
@@ -128,7 +128,7 @@ end
 
 ```html
 <html>
-  <script src="https://cdn.jsdelivr.net/npm/@ruby/3.3-wasm-wasi@2.5.0/dist/browser.script.iife.js"></script>
+  <script src="https://cdn.jsdelivr.net/npm/@ruby/3.3-wasm-wasi@2.5.1/dist/browser.script.iife.js"></script>
   <script type="text/ruby" data-eval="async">
     require "js"
 
@@ -143,8 +143,8 @@ Or using `@ruby/wasm-wasi` package API `RubyVM#evalAsync`:
 ```html
 <html>
   <script type="module">
-    import { DefaultRubyVM } from "https://cdn.jsdelivr.net/npm/@ruby/wasm-wasi@2.5.0/dist/browser/+esm";
-    const response = await fetch("https://cdn.jsdelivr.net/npm/@ruby/3.3-wasm-wasi@2.5.0/dist/ruby+stdlib.wasm");
+    import { DefaultRubyVM } from "https://cdn.jsdelivr.net/npm/@ruby/wasm-wasi@2.5.1/dist/browser/+esm";
+    const response = await fetch("https://cdn.jsdelivr.net/npm/@ruby/3.3-wasm-wasi@2.5.1/dist/ruby+stdlib.wasm");
     const module = await WebAssembly.compileStreaming(response);
     const { vm } = await DefaultRubyVM(module);
 

data/ext/ruby_wasm/Cargo.toml

@@ -10,7 +10,9 @@ publish = false
 crate-type = ["cdylib"]
 
 [dependencies]
-magnus = "0.6.2"
+magnus = { version = "0.6.2", features = ["bytes"] }
+bytes = "1"
 wizer = "4.0.0"
 wasi-vfs-cli = { git = "https://github.com/kateinoigakukun/wasi-vfs/", tag = "0.5.2" }
 structopt = "0.3.26"
+wit-component = "0.203.0"

data/ext/ruby_wasm/src/lib.rs

@@ -1,4 +1,4 @@
-use std::path::PathBuf;
+use std::{collections::HashMap, path::PathBuf};
 
 use magnus::{
     eval, exception, function, method,
@@ -6,13 +6,13 @@ use magnus::{
     value::{self, InnerValue},
     wrap, Error, ExceptionClass, RModule, Ruby,
 };
-use wizer::Wizer;
 use structopt::StructOpt;
+use wizer::Wizer;
 
 static RUBY_WASM: value::Lazy<RModule> =
     value::Lazy::new(|ruby| ruby.define_module("RubyWasmExt").unwrap());
 
-fn preinit(core_module: Vec<u8>) -> Result<Vec<u8>, Error> {
+fn preinit(core_module: bytes::Bytes) -> Result<bytes::Bytes, Error> {
     let rbwasm_error = eval("RubyWasmExt::Error")?;
     let rbwasm_error = ExceptionClass::from_value(rbwasm_error).unwrap();
     let mut wizer = Wizer::new();
@@ -26,6 +26,7 @@ fn preinit(core_module: Vec<u8>) -> Result<Vec<u8>, Error> {
     wizer
         .run(&core_module)
         .map_err(|e| Error::new(rbwasm_error, format!("failed to run wizer: {}", e)))
+        .map(|output| output.into())
 }
 
 struct WasiVfsInner {
@@ -50,17 +51,174 @@ impl WasiVfs {
     }
 
     fn map_dir(&self, guest_dir: String, host_dir: String) {
-        self.0.borrow_mut().map_dirs.push((guest_dir.into(), host_dir.into()));
+        self.0
+            .borrow_mut()
+            .map_dirs
+            .push((guest_dir.into(), host_dir.into()));
+    }
+
+    fn pack(&self, wasm_bytes: bytes::Bytes) -> Result<bytes::Bytes, Error> {
+        let output_bytes = wasi_vfs_cli::pack(&wasm_bytes, self.0.borrow().map_dirs.clone())
+            .map_err(|e| {
+                Error::new(
+                    exception::standard_error(),
+                    format!("failed to pack wasi vfs: {}", e),
+                )
+            })?;
+        Ok(output_bytes.into())
+    }
+}
+
+#[wrap(class = "RubyWasmExt::ComponentLink")]
+struct ComponentLink(std::cell::RefCell<Option<wit_component::Linker>>);
+
+impl ComponentLink {
+    fn new() -> Self {
+        Self(std::cell::RefCell::new(Some(
+            wit_component::Linker::default(),
+        )))
+    }
+    fn linker(
+        &self,
+        body: impl FnOnce(wit_component::Linker) -> Result<wit_component::Linker, Error>,
+    ) -> Result<(), Error> {
+        let mut linker = self.0.take().ok_or_else(|| {
+            Error::new(
+                exception::standard_error(),
+                "linker is already consumed".to_string(),
+            )
+        })?;
+        linker = body(linker)?;
+        self.0.replace(Some(linker));
+        Ok(())
+    }
+
+    fn library(&self, name: String, module: bytes::Bytes, dl_openable: bool) -> Result<(), Error> {
+        self.linker(|linker| {
+            linker.library(&name, &module, dl_openable).map_err(|e| {
+                Error::new(
+                    exception::standard_error(),
+                    format!("failed to link library: {}", e),
+                )
+            })
+        })
+    }
+    fn adapter(&self, name: String, module: bytes::Bytes) -> Result<(), Error> {
+        self.linker(|linker| {
+            linker.adapter(&name, &module).map_err(|e| {
+                Error::new(
+                    exception::standard_error(),
+                    format!("failed to link adapter: {}", e),
+                )
+            })
+        })
+    }
+    fn validate(&self, validate: bool) -> Result<(), Error> {
+        self.linker(|linker| Ok(linker.validate(validate)))
+    }
+    fn stack_size(&self, size: u32) -> Result<(), Error> {
+        self.linker(|linker| Ok(linker.stack_size(size)))
+    }
+    fn stub_missing_functions(&self, stub: bool) -> Result<(), Error> {
+        self.linker(|linker| Ok(linker.stub_missing_functions(stub)))
+    }
+    fn use_built_in_libdl(&self, use_libdl: bool) -> Result<(), Error> {
+        self.linker(|linker| Ok(linker.use_built_in_libdl(use_libdl)))
+    }
+    fn encode(&self) -> Result<bytes::Bytes, Error> {
+        // Take the linker out of the cell and consume it
+        let linker = self.0.borrow_mut().take().ok_or_else(|| {
+            Error::new(
+                exception::standard_error(),
+                "linker is already consumed".to_string(),
+            )
+        })?;
+        let encoded = linker.encode().map_err(|e| {
+            Error::new(
+                exception::standard_error(),
+                format!("failed to encode linker: {}", e),
+            )
+        })?;
+        Ok(encoded.into())
+    }
+}
+
+#[wrap(class = "RubyWasmExt::ComponentEncode")]
+struct ComponentEncode(std::cell::RefCell<Option<wit_component::ComponentEncoder>>);
+
+impl ComponentEncode {
+    fn new() -> Self {
+        Self(std::cell::RefCell::new(Some(
+            wit_component::ComponentEncoder::default(),
+        )))
     }
 
-    fn pack(&self, wasm_bytes: Vec<u8>) -> Result<Vec<u8>, Error> {
-        let output_bytes = wasi_vfs_cli::pack(&wasm_bytes, self.0.borrow().map_dirs.clone()).map_err(|e| {
+    fn encoder(
+        &self,
+        body: impl FnOnce(
+            wit_component::ComponentEncoder,
+        ) -> Result<wit_component::ComponentEncoder, Error>,
+    ) -> Result<(), Error> {
+        let mut encoder = self.0.take().ok_or_else(|| {
             Error::new(
                 exception::standard_error(),
-                format!("failed to pack wasi vfs: {}", e),
+                "encoder is already consumed".to_string(),
             )
         })?;
-        Ok(output_bytes)
+        encoder = body(encoder)?;
+        self.0.replace(Some(encoder));
+        Ok(())
+    }
+
+    fn validate(&self, validate: bool) -> Result<(), Error> {
+        self.encoder(|encoder| Ok(encoder.validate(validate)))
+    }
+
+    fn adapter(&self, name: String, module: bytes::Bytes) -> Result<(), Error> {
+        self.encoder(|encoder| {
+            encoder.adapter(&name, &module).map_err(|e| {
+                Error::new(
+                    exception::standard_error(),
+                    format!("failed to encode adapter: {}", e),
+                )
+            })
+        })
+    }
+
+    fn module(&self, module: bytes::Bytes) -> Result<(), Error> {
+        self.encoder(|encoder| {
+            encoder.module(&module).map_err(|e| {
+                Error::new(
+                    exception::standard_error(),
+                    format!("failed to encode module: {}", e),
+                )
+            })
+        })
+    }
+
+    fn realloc_via_memory_grow(&self, realloc: bool) -> Result<(), Error> {
+        self.encoder(|encoder| Ok(encoder.realloc_via_memory_grow(realloc)))
+    }
+
+    fn import_name_map(&self, map: HashMap<String, String>) -> Result<(), Error> {
+        self.encoder(|encoder| Ok(encoder.import_name_map(map)))
+    }
+
+    fn encode(&self) -> Result<bytes::Bytes, Error> {
+        // Take the encoder out of the cell and consume it
+        let encoder = self.0.borrow_mut().take().ok_or_else(|| {
+            Error::new(
+                exception::standard_error(),
+                "encoder is already consumed".to_string(),
+            )
+        })?;
+        let encoded = encoder.encode().map_err(|e| {
+            Error::new(
+                exception::standard_error(),
+                format!("failed to encode component: {}", e),
+            )
+        })?;
+        Ok(encoded.into())
     }
 }
 
@@ -76,5 +234,37 @@ fn init(ruby: &Ruby) -> Result<(), Error> {
     wasi_vfs.define_singleton_method("run_cli", function!(WasiVfs::run_cli, 1))?;
     wasi_vfs.define_method("map_dir", method!(WasiVfs::map_dir, 2))?;
     wasi_vfs.define_method("pack", method!(WasiVfs::pack, 1))?;
+
+    let component_link = module.define_class("ComponentLink", ruby.class_object())?;
+    component_link.define_singleton_method("new", function!(ComponentLink::new, 0))?;
+    component_link.define_method("library", method!(ComponentLink::library, 3))?;
+    component_link.define_method("adapter", method!(ComponentLink::adapter, 2))?;
+    component_link.define_method("validate", method!(ComponentLink::validate, 1))?;
+    component_link.define_method("stack_size", method!(ComponentLink::stack_size, 1))?;
+    component_link.define_method(
+        "stub_missing_functions",
+        method!(ComponentLink::stub_missing_functions, 1),
+    )?;
+    component_link.define_method(
+        "use_built_in_libdl",
+        method!(ComponentLink::use_built_in_libdl, 1),
+    )?;
+    component_link.define_method("encode", method!(ComponentLink::encode, 0))?;
+
+    let component_encode = module.define_class("ComponentEncode", ruby.class_object())?;
+    component_encode.define_singleton_method("new", function!(ComponentEncode::new, 0))?;
+    component_encode.define_method("validate", method!(ComponentEncode::validate, 1))?;
+    component_encode.define_method("adapter", method!(ComponentEncode::adapter, 2))?;
+    component_encode.define_method("module", method!(ComponentEncode::module, 1))?;
+    component_encode.define_method(
+        "realloc_via_memory_grow",
+        method!(ComponentEncode::realloc_via_memory_grow, 1),
+    )?;
+    component_encode.define_method(
+        "import_name_map",
+        method!(ComponentEncode::import_name_map, 1),
+    )?;
+    component_encode.define_method("encode", method!(ComponentEncode::encode, 0))?;
+
     Ok(())
 }

data/lib/ruby_wasm/build/executor.rb

@@ -128,6 +128,10 @@ module RubyWasm
       FileUtils.mkdir_p(list)
     end
 
+    def ln_s(src, dest)
+      FileUtils.ln_s(src, dest)
+    end
+
     def write(path, data)
       File.write(path, data)
     end