Merge pull request #25 from jasisz/0.19-http-wasip2

http on --wasip2 (all 6 methods + headers)

Author: jasisz

CHANGELOG.md

@@ -2,6 +2,11 @@
 
 All notable changes to Aver are documented here. Starting with 0.10.0, minor releases get a codename — short, evocative, and it tells you what the release was really about.
 
+## 0.19.0 (unreleased)
+
+### Added
+- **HTTP client on `--target wasip2`.** All six methods — `Http.get`, `Http.head`, `Http.delete`, `Http.post`, `Http.put`, `Http.patch` — now compile and run as components. Response headers surface as `Map<String, List<String>>`; multi-value headers (e.g. `Set-Cookie`) keep server emit order. Failure messages name the wasi:http error variant (`http: connection-refused`, `http: DNS-timeout`, …) instead of a generic string.
+
 ## 0.18.0 "Span" (2026-05-09)
 
 > _Cross the Component Model boundary the same way Aver crosses the source/wasm one — typed effects in, canonical-ABI imports out._

Cargo.lock

@@ -54,7 +54,7 @@ wasm-compile = ["dep:wasm-encoder", "dep:wasmprinter", "dep:wasmparser", "dep:wa
 # to WIT/WASI imports — there is no preview1 ABI to preserve. See
 # docs/wasip2.md for the contract and feedback_aver_no_preview1_adapter
 # for the architectural rationale.
-wasip2 = ["wasm-compile", "dep:wit-component", "dep:wit-parser", "dep:wasmtime", "dep:wasmtime-wasi"]
+wasip2 = ["wasm-compile", "dep:wit-component", "dep:wit-parser", "dep:wasmtime", "dep:wasmtime-wasi", "dep:wasmtime-wasi-http"]
 playground = ["wasm-compile", "dep:wasm-bindgen", "runtime", "tty-render"]
 
 [dependencies]
@@ -74,6 +74,7 @@ wasmparser = { version = "0.248", optional = true }
 wasmprinter = { version = "0.248", optional = true }
 wasmtime = { version = "44", optional = true, default-features = false, features = ["cranelift", "runtime", "gc", "gc-drc", "component-model", "component-model-async"] }
 wasmtime-wasi = { version = "44", optional = true }
+wasmtime-wasi-http = { version = "44", optional = true }
 wat = { version = "1", optional = true }
 # wasip2 feature deps — versions paired by upstream wasm-tools 1.248
 # release train. `wasi-preview1-component-adapter-provider` is NOT

Cargo.toml

@@ -102,9 +102,9 @@ Aver effects lower directly to WASI 0.2 imports. The mapping is fixed per effect
 | `Time.now` / `unixMs` | `wasi:clocks/wall-clock.now` (Time.now formats RFC3339 guest-side via Howard Hinnant's `civil_from_days`) |
 | `Time.sleep` | `wasi:clocks/monotonic-clock.subscribe-duration` + `wasi:io/poll.poll` + `[resource-drop]pollable` (per-call pollable, real wait — not busy-loop) |
 | `Random.int` / `float` | `wasi:random/random.get-random-u64` + Aver-side range scaling. This is the secure `wasi:random/random` interface (same contract as `get-random-bytes`, just returning 8 cryptographically-secure bytes packed into a u64); we deliberately do NOT use `wasi:random/insecure.get-insecure-random-u64`. If we later need finer byte-level control (e.g. for `Random.bytes(n)`), the switch to `get-random-bytes` is mechanical. |
-| `Http.*` | **Compile-rejected** — out of 0.18 scope (Phase 2 / 0.19) |
-| `HttpServer.listen` / `listenWith` | **Compile-rejected** — out of 0.18 scope (Phase 3 / 0.19) |
-| `Tcp.*` | **Compile-rejected** — out of 0.18 scope (Phase 2 / 0.19) |
+| `Http.{get, head, delete, post, put, patch}` | `wasi:http/outgoing-handler.handle` + the future-incoming-response / incoming-response choreography (Phase 2 / 0.19 shipped). Method tag selects `outgoing-request.set-method`. Body-bearing verbs marshal a request body via `request.body` + `outgoing-body.write` + chunked `blocking-write-and-flush` + `outgoing-body.finish`. Headers (request and response) lower as `Map<String, List<String>>`; multi-valued field names preserve server emit order. `error-code` variant discriminants surface as per-variant `http: <name>` Err messages (39 cases). |
+| `HttpServer.listen` / `listenWith` | **Compile-rejected** — out of 0.19 client scope (Phase 3 / 0.19+); requires the `wasi:http/proxy` world + exported `incoming-handler.handle`. |
+| `Tcp.*` | **Compile-rejected** — out of 0.19 client scope (Phase 2.1 / 0.19+) |
 | `Terminal.*` (12 methods) | **Compile-rejected** — WASI 0.2 has no raw/cooked-mode operations |
 
 ### Why `Terminal.*` / `Env.set` are rejected, not stubbed

docs/wasip2.md

@@ -137,10 +137,15 @@ fn classify(effect: &str) -> Option<UnsupportedReason> {
     // inside `__rt_time_sleep`. The pollable model is hidden in the
     // helper; source-level Aver still sees `Time.sleep(ms) -> Unit`.
     // ---------- Out of 0.18 release scope ----------
-    if effect.starts_with("Http.") {
-        return Some(UnsupportedReason::OutOfRelease {
-            phase: "Phase 2 / 0.19",
-        });
+    // All wasi:http verbs graduated in 0.19: GET in Phase 2.0,
+    // HEAD/DELETE in Phase 2.J (share pipeline via set-method),
+    // POST/PUT/PATCH in Phase 2.K (outgoing-body marshalling +
+    // user headers iteration + Content-Type).
+    if matches!(
+        effect,
+        "Http.get" | "Http.head" | "Http.delete" | "Http.post" | "Http.put" | "Http.patch"
+    ) {
+        return None;
     }
     if effect.starts_with("Tcp.") {
         return Some(UnsupportedReason::OutOfRelease {
@@ -217,10 +222,8 @@ mod tests {
 
     #[test]
     fn classifies_out_of_release_rejects() {
-        assert!(matches!(
-            classify("Http.get"),
-            Some(UnsupportedReason::OutOfRelease { .. })
-        ));
+        // All Http.* graduated in 0.19; only Tcp / HttpServer
+        // remain rejected as out-of-release.
         assert!(matches!(
             classify("Tcp.connect"),
             Some(UnsupportedReason::OutOfRelease { .. })
@@ -231,6 +234,17 @@ mod tests {
         ));
     }
 
+    #[test]
+    fn all_http_methods_graduate() {
+        // Phase 2.0 (GET) + 2.J (HEAD/DELETE) + 2.K (POST/PUT/PATCH).
+        assert!(classify("Http.get").is_none());
+        assert!(classify("Http.head").is_none());
+        assert!(classify("Http.delete").is_none());
+        assert!(classify("Http.post").is_none());
+        assert!(classify("Http.put").is_none());
+        assert!(classify("Http.patch").is_none());
+    }
+
     #[test]
     fn classifies_pending_phase_rejects() {
         // Console.print/error/warn graduated in 1.2b1.5; Time.unixMs

src/codegen/wasip2/effect_check.rs

@@ -28,7 +28,7 @@ use super::wrap::Wasip2World;
 /// end-to-end on the empty world (component is a valid WASI 0.2
 /// artifact, just with no public surface). Phase 1.2 turns this
 /// into a meaningful world declaration.
-pub fn emit_world_wit(world: Wasip2World) -> String {
+pub fn emit_world_wit(world: Wasip2World, needs_http: bool) -> String {
     let local_name = world.local_name();
     let (header_note, body) = match world {
         // `wasi:cli/command` is the canonical CLI shape from the
@@ -38,15 +38,32 @@ pub fn emit_world_wit(world: Wasip2World) -> String {
         // The wasm-gc emitter exports `wasi:cli/run@0.2.4#run`
         // (canonical-ABI mangled name) when `target == Wasip2`, so
         // the contract is satisfiable at this commit.
-        Wasip2World::CliCommand => (
-            "// Phase 1.2b1.3 — wasm-gc emits `wasi:cli/run@0.2.4#run` to satisfy this world.",
-            "  include wasi:cli/command@0.2.4;",
-        ),
+        //
+        // `wasi:cli/command` does not transitively include
+        // `wasi:http/*`. When the user program reaches an `Http.*`
+        // effect, the wasm-gc backend emits canonical-ABI imports
+        // of `wasi:http/outgoing-handler@0.2.4` (and types via the
+        // implicit transitive package); the world has to declare
+        // that import explicitly so `wit-component::ComponentEncoder`
+        // matches it against the host. `needs_http` is derived in
+        // `wrap.rs` by scanning the core module's imports — single
+        // source of truth, no risk of drift between codegen and
+        // world declaration.
+        Wasip2World::CliCommand => {
+            let header =
+                "// Phase 1.2b1.3 — wasm-gc emits `wasi:cli/run@0.2.4#run` to satisfy this world.";
+            let body = if needs_http {
+                "  include wasi:cli/command@0.2.4;\n  \n  // Phase 2 / 0.19 — Http.* effects on `--target wasip2` lower\n  // directly to `wasi:http/outgoing-handler.handle` plus the\n  // future-incoming-response / incoming-response choreography.\n  // WASI 0.3 collapses this into native `future<T>` / `stream<u8>`\n  // types and three imports; a `Wasip3World` variant lands when\n  // the spec stabilises.\n  import wasi:http/outgoing-handler@0.2.4;".to_string()
+            } else {
+                "  include wasi:cli/command@0.2.4;".to_string()
+            };
+            (header, body)
+        }
         // Phase 3 / 0.19. Compile-rejected upstream in `wrap.rs`; the
         // body still pretty-prints something honest for the artifact.
         Wasip2World::HttpProxy => (
             "// Phase 3 / 0.19 — compile-rejected.",
-            "  include wasi:http/proxy@0.2.4;",
+            "  include wasi:http/proxy@0.2.4;".to_string(),
         ),
     };
     format!(

src/codegen/wasip2/wit.rs

@@ -87,7 +87,17 @@ pub fn compile_to_component(
     let mut resolve = Resolve::default();
     super::wasi_bundle::push_wasi_packages(&mut resolve)?;
 
-    let wit_source = super::wit::emit_world_wit(world);
+    // Inspect the core module's imports to decide whether the world
+    // needs `import wasi:http/outgoing-handler@0.2.4`. We scan
+    // because the codegen path that registers wasi:http slots
+    // (`module.rs` `EffectName::HttpGet` arm) and the wrap path live
+    // in different modules — having `compile_to_component` derive the
+    // bit from the only ground truth (the actual emitted imports)
+    // keeps the world exactly tracking the core's surface and avoids
+    // a second source of truth that could drift.
+    let needs_http = core_imports_use_wasi_http(core_wasm);
+
+    let wit_source = super::wit::emit_world_wit(world, needs_http);
 
     // Parse our generated WIT into the same `Resolve`. `parse` reads
     // from a string — the path argument is for error messages only,
@@ -123,3 +133,29 @@ pub fn compile_to_component(
 
     Ok((component, wit_source))
 }
+
+/// Scan a core wasm module's imports for any module name starting
+/// with `"wasi:http/"`. Used by `compile_to_component` to decide
+/// whether the generated WIT world should additionally
+/// `import wasi:http/outgoing-handler@0.2.4`.
+///
+/// Implemented via `wasmparser` to walk only the import section —
+/// avoids re-decoding the full module the way `Module::new` would,
+/// and treats malformed bytes as "no http imports" (the encoder
+/// later rejects malformed input with a clearer message).
+fn core_imports_use_wasi_http(core_wasm: &[u8]) -> bool {
+    use wasmparser::{Parser, Payload};
+    for payload in Parser::new(0).parse_all(core_wasm).flatten() {
+        if let Payload::ImportSection(reader) = payload {
+            // `into_imports()` flattens the grouped `Imports` enum
+            // (Single / Compact1 / Compact2) into a per-item iterator
+            // of `Import` values, each with its own `module` field.
+            for import in reader.into_imports().flatten() {
+                if import.module.starts_with("wasi:http/") {
+                    return true;
+                }
+            }
+        }
+    }
+    false
+}