Include unstable features in published packages

Cargo.toml

@@ -18,7 +18,7 @@ futures-util = "0.3.30"
 oci-client = { version = "0.14", default-features = false, features = [
     "rustls-tls",
 ] }
-oci-wasm = { version = "0.2", default-features = false, features = [
+oci-wasm = { version = "0.2.1", default-features = false, features = [
     "rustls-tls",
 ] }
 semver = "1.0.23"

crates/wasm-pkg-core/src/resolver.rs

@@ -267,6 +267,7 @@ impl DecodedDependency<'_> {
         match self {
             Self::Wit { package, .. } => {
                 let mut resolve = Resolve::new();
+                resolve.all_features = true;
                 let source_files = package
                     .source_map
                     .source_files()
@@ -677,7 +678,11 @@ impl DependencyResolutionMap {
     /// Given a path to a component or a directory containing wit, use the given dependencies to
     /// generate a [`Resolve`] for the root package.
     pub async fn generate_resolve(&self, dir: impl AsRef<Path>) -> Result<(Resolve, PackageId)> {
-        let mut merged = Resolve::default();
+        let mut merged = Resolve {
+            // Retain @unstable features; downstream tooling will process them further
+            all_features: true,
+            ..Resolve::default()
+        };
 
         let deps = self.decode_dependencies().await?;
 

crates/wasm-pkg-core/tests/build.rs

@@ -1,5 +1,6 @@
 use wasm_pkg_core::{config::Config as WkgConfig, lock::LockFile};
 use wit_component::DecodedWasm;
+use wit_parser::Stability;
 
 mod common;
 
@@ -28,7 +29,7 @@ async fn test_build_wit() {
     );
     assert_eq!(
         version.unwrap().to_string(),
-        "0.2.0",
+        "0.2.3",
         "Should have the correct version"
     );
 
@@ -53,18 +54,31 @@ async fn test_build_wit() {
         _ => panic!("Should be a package"),
     };
 
-    let name = resolve
-        .package_names
-        .iter()
-        .find_map(|(name, id)| (pkg_id == *id).then_some(name))
-        .expect("Should be able to find the package name");
+    let package = resolve
+        .packages
+        .get(pkg_id)
+        .expect("Should contain decoded package");
 
     assert_eq!(
-        name.to_string(),
-        "wasi:[email protected].0",
+        package.name.to_string(),
+        "wasi:[email protected].3",
         "Should have the correct package name"
     );
 
+    // @unstable items are retained
+    let types_id = package
+        .interfaces
+        .get("types")
+        .expect("wasi:http should have a types interface");
+    let send_informational = resolve.interfaces[*types_id]
+        .functions
+        .get("[method]response-outparam.send-informational")
+        .expect("Should have send-informational method");
+    assert!(
+        matches!(send_informational.stability, Stability::Unstable { .. }),
+        "response-outparam.send-informational should be unstable"
+    );
+
     assert!(
         resolve.package_direct_deps(pkg_id).count() > 0,
         "Should have direct dependencies embedded"
@@ -85,8 +99,8 @@ async fn test_bad_dep_failure() {
         .await
         .expect("Should be able to read the world file");
     let str_world = str_world.replace(
-        "import wasi:cli/[email protected].0;",
-        "import totally:not/[email protected].0;",
+        "import wasi:cli/[email protected].3;",
+        "import totally:not/[email protected].3;",
     );
     tokio::fs::write(world_file, str_world)
         .await

crates/wasm-pkg-core/tests/fixtures/wasi-http/wit/handler.wit

@@ -1,6 +1,8 @@
 /// This interface defines a handler of incoming HTTP Requests. It should
 /// be exported by components which can respond to HTTP Requests.
+@since(version = 0.2.0)
 interface incoming-handler {
+  @since(version = 0.2.0)
   use types.{incoming-request, response-outparam};
 
   /// This function is invoked with an incoming HTTP Request, and a resource
@@ -13,6 +15,7 @@ interface incoming-handler {
   /// The implementor of this function must write a response to the
   /// `response-outparam` before returning, or else the caller will respond
   /// with an error on its behalf.
+  @since(version = 0.2.0)
   handle: func(
     request: incoming-request,
     response-out: response-outparam
@@ -21,7 +24,9 @@ interface incoming-handler {
 
 /// This interface defines a handler of outgoing HTTP Requests. It should be
 /// imported by components which wish to make HTTP Requests.
+@since(version = 0.2.0)
 interface outgoing-handler {
+  @since(version = 0.2.0)
   use types.{
     outgoing-request, request-options, future-incoming-response, error-code
   };
@@ -36,6 +41,7 @@ interface outgoing-handler {
   /// This function may return an error if the `outgoing-request` is invalid
   /// or not allowed to be made. Otherwise, protocol errors are reported
   /// through the `future-incoming-response`.
+  @since(version = 0.2.0)
   handle: func(
     request: outgoing-request,
     options: option<request-options>

crates/wasm-pkg-core/tests/fixtures/wasi-http/wit/proxy.wit

@@ -1,32 +1,50 @@
-package wasi:[email protected].0;
+package wasi:[email protected].3;
 
-/// The `wasi:http/proxy` world captures a widely-implementable intersection of
-/// hosts that includes HTTP forward and reverse proxies. Components targeting
-/// this world may concurrently stream in and out any number of incoming and
-/// outgoing HTTP requests.
-world proxy {
+/// The `wasi:http/imports` world imports all the APIs for HTTP proxies.
+/// It is intended to be `include`d in other worlds.
+@since(version = 0.2.0)
+world imports {
   /// HTTP proxies have access to time and randomness.
-  include wasi:clocks/[email protected];
-  import wasi:random/[email protected];
+  @since(version = 0.2.0)
+  import wasi:clocks/[email protected];
+  @since(version = 0.2.0)
+  import wasi:clocks/[email protected];
+  @since(version = 0.2.0)
+  import wasi:random/[email protected];
 
   /// Proxies have standard output and error streams which are expected to
   /// terminate in a developer-facing console provided by the host.
-  import wasi:cli/[email protected];
-  import wasi:cli/[email protected];
+  @since(version = 0.2.0)
+  import wasi:cli/[email protected];
+  @since(version = 0.2.0)
+  import wasi:cli/[email protected];
 
   /// TODO: this is a temporary workaround until component tooling is able to
   /// gracefully handle the absence of stdin. Hosts must return an eof stream
   /// for this import, which is what wasi-libc + tooling will do automatically
   /// when this import is properly removed.
-  import wasi:cli/[email protected];
+  @since(version = 0.2.0)
+  import wasi:cli/[email protected];
 
   /// This is the default handler to use when user code simply wants to make an
   /// HTTP request (e.g., via `fetch()`).
+  @since(version = 0.2.0)
   import outgoing-handler;
+}
+
+/// The `wasi:http/proxy` world captures a widely-implementable intersection of
+/// hosts that includes HTTP forward and reverse proxies. Components targeting
+/// this world may concurrently stream in and out any number of incoming and
+/// outgoing HTTP requests.
+@since(version = 0.2.0)
+world proxy {
+  @since(version = 0.2.0)
+  include imports;
 
   /// The host delivers incoming HTTP requests to a component by calling the
   /// `handle` function of this exported interface. A host may arbitrarily reuse
   /// or not reuse component instance when delivering incoming HTTP requests and
   /// thus a component must be able to handle 0..N calls to `handle`.
+  @since(version = 0.2.0)
   export incoming-handler;
 }