Move the wasip2 impl into src/sys/p2 behind a backend facade

Cargo.toml

@@ -20,6 +20,7 @@ json = ["dep:serde", "dep:serde_json"]
 anyhow.workspace = true
 async-task.workspace = true
 bytes.workspace = true
+cfg-if.workspace = true
 futures-lite.workspace = true
 http-body-util.workspace = true
 http-body.workspace = true
@@ -71,6 +72,7 @@ anyhow = "1"
 async-task = "4.7"
 axum = { version = "0.8.6", default-features = false }
 bytes = "1.10.1"
+cfg-if = "1"
 cargo_metadata = "0.22"
 clap = { version = "4.5.26", features = ["derive"] }
 futures-core = "0.3.19"

src/http.rs

@@ -0,0 +1,3 @@
+//! HTTP networking support
+//!
+pub use crate::sys::http::*;

src/io/mod.rs

@@ -5,18 +5,15 @@ mod cursor;
 mod empty;
 mod read;
 mod seek;
-mod stdio;
-mod streams;
 mod write;
 
 pub use crate::runtime::AsyncPollable;
+pub use crate::sys::io::*;
 pub use copy::*;
 pub use cursor::*;
 pub use empty::*;
 pub use read::*;
 pub use seek::*;
-pub use stdio::*;
-pub use streams::*;
 pub use write::*;
 
 /// The error type for I/O operations.

src/lib.rs

@@ -55,6 +55,9 @@
 //! These are unique capabilities provided by WASI 0.2, and because this library
 //! is specific to that are exposed from here.
 
+#[allow(unreachable_pub)]
+mod sys;
+
 pub mod future;
 #[macro_use]
 pub mod http;

src/net.rs

@@ -0,0 +1,3 @@
+//! Async network abstractions.
+
+pub use crate::sys::net::*;

src/rand.rs

@@ -0,0 +1,3 @@
+//! Random number generation.
+
+pub use crate::sys::rand::*;

src/runtime.rs

@@ -0,0 +1,10 @@
+//! Async event loop support.
+//!
+//! The way to use this is to call [`block_on()`]. Inside the future, [`Reactor::current`]
+//! will give an instance of the [`Reactor`] running the event loop, which can be
+//! to [`AsyncPollable::wait_for`] instances of
+//! [`wasip2::Pollable`](https://docs.rs/wasi/latest/wasi/io/poll/struct.Pollable.html).
+//! This will automatically wait for the futures to resolve, and call the
+//! necessary wakers to work.
+
+pub use crate::sys::runtime::*;

src/sys/mod.rs

@@ -0,0 +1,40 @@
+//! Platform-specific backends.
+//!
+//! Each supported target provides an implementation under `src/sys/`, selected
+//! here by a single `cfg-if`. The crate-root modules (`crate::time`,
+//! `crate::io`, ...) are target-agnostic facades, free of `#[cfg]`, written
+//! against the `crate::sys::*` items the selected backend provides. There is no
+//! shared `trait`: backends are duck-typed in the `std::sys` style, and the
+//! `const _` assertions below check the shapes the facades depend on.
+//!
+//! Backend modules: `time`, `io`, `net`, `http`, `rand`, `runtime`. The reified
+//! pollable types (`AsyncPollable`, `WaitFor`) are p2-only and intentionally
+//! left out of the common contract; once a second backend lands they become a
+//! localized escape hatch rather than facade `#[cfg]`s.
+
+cfg_if::cfg_if! {
+    if #[cfg(all(target_os = "wasi", target_env = "p2"))] {
+        mod p2;
+        use p2 as backend;
+    } else {
+        compile_error!("unsupported target: wstd only compiles on `wasm32-wasip2`");
+    }
+}
+
+pub use backend::*;
+
+// Check the selected backend provides the shapes the facades rely on, so drift
+// fails here instead of deep inside a facade.
+const _: fn() = || {
+    fn assert_async_read<T: crate::io::AsyncRead>() {}
+    fn assert_async_write<T: crate::io::AsyncWrite>() {}
+    fn assert_sleep_future<T: core::future::Future<Output = ()>>() {}
+
+    assert_async_read::<crate::sys::io::AsyncInputStream>();
+    assert_async_write::<crate::sys::io::AsyncOutputStream>();
+    assert_sleep_future::<crate::sys::time::Sleep>();
+
+    let _: fn() -> crate::sys::time::MonotonicInstant = crate::sys::time::now;
+    let _: fn(crate::sys::time::MonotonicInstant) -> crate::sys::time::Sleep =
+        crate::sys::time::sleep_until;
+};

src/http/body.rs → src/sys/p2/http/body.rs

@@ -1,8 +1,5 @@
-use crate::http::{
-    Error, HeaderMap,
-    error::Context as _,
-    fields::{header_map_from_wasi, header_map_to_wasi},
-};
+use super::fields::{header_map_from_wasi, header_map_to_wasi};
+use crate::http::{Error, HeaderMap, error::Context as _};
 use crate::io::{AsyncInputStream, AsyncOutputStream};
 use crate::runtime::{AsyncPollable, Reactor, WaitFor};
 

src/http/response.rs → src/sys/p2/http/response.rs

@@ -1,9 +1,10 @@
 use http::StatusCode;
 use wasip2::http::types::IncomingResponse;
 
+use super::fields::header_map_from_wasi;
+use crate::http::HeaderMap;
 use crate::http::body::{Body, BodyHint};
 use crate::http::error::Error;
-use crate::http::fields::{HeaderMap, header_map_from_wasi};
 
 pub use http::response::{Builder, Response};
 

src/sys/p2/io/mod.rs

@@ -0,0 +1,5 @@
+mod stdio;
+mod streams;
+
+pub use stdio::*;
+pub use streams::*;

src/io/stdio.rs → src/sys/p2/io/stdio.rs

@@ -1,4 +1,4 @@
-use super::{AsyncInputStream, AsyncOutputStream, AsyncRead, AsyncWrite, Result};
+use crate::io::{AsyncInputStream, AsyncOutputStream, AsyncRead, AsyncWrite, Result};
 use std::cell::LazyCell;
 use wasip2::cli::terminal_input::TerminalInput;
 use wasip2::cli::terminal_output::TerminalOutput;

src/io/streams.rs → src/sys/p2/io/streams.rs

@@ -1,5 +1,5 @@
-use super::{AsyncPollable, AsyncRead, AsyncWrite};
-use crate::runtime::WaitFor;
+use crate::io::{AsyncRead, AsyncWrite};
+use crate::runtime::{AsyncPollable, WaitFor};
 use std::future::{Future, poll_fn};
 use std::pin::Pin;
 use std::sync::{Mutex, OnceLock};

src/sys/p2/mod.rs

@@ -0,0 +1,8 @@
+//! The wasip2 (`wasm32-wasip2`) backend.
+
+pub mod http;
+pub mod io;
+pub mod net;
+pub mod rand;
+pub mod runtime;
+pub mod time;

src/runtime/mod.rs → src/sys/p2/runtime/mod.rs

@@ -8,7 +8,7 @@
 //! necessary wakers to work.
 
 #![deny(missing_debug_implementations, nonstandard_style)]
-#![warn(missing_docs, unreachable_pub)]
+#![warn(missing_docs)]
 
 mod block_on;
 mod reactor;

src/sys/p2/time/mod.rs

@@ -0,0 +1,78 @@
+//! Monotonic and system clocks for the wasip2 backend.
+//!
+//! This is the platform half of the [`crate::time`] facade. The facade owns the
+//! portable `Duration`/`Instant`/`Timer` types and all of their arithmetic;
+//! this module provides only the primitives that genuinely depend on the WASI
+//! 0.2 clocks. See [`crate::sys`] for the full backend contract.
+
+use std::future::Future;
+use std::pin::Pin;
+use std::task::{Context, Poll};
+use wasip2::clocks::{monotonic_clock, wall_clock};
+
+use crate::runtime::{Reactor, WaitFor};
+
+/// A measurement of the monotonic clock, in nanoseconds.
+///
+/// The facade's `Instant` wraps this. Keeping it a plain integer lets the
+/// facade own all time arithmetic without coupling to the backend.
+pub type MonotonicInstant = monotonic_clock::Instant;
+
+/// A span of monotonic-clock time, in nanoseconds.
+pub type MonotonicDuration = monotonic_clock::Duration;
+
+/// Return the current monotonic-clock instant.
+pub fn now() -> MonotonicInstant {
+    monotonic_clock::now()
+}
+
+/// A measurement of the system clock, useful for talking to external entities
+/// like the file system or other processes. May be converted losslessly to a
+/// more useful `std::time::SystemTime` to provide more methods.
+#[derive(Debug, Clone, Copy)]
+#[allow(dead_code)]
+pub struct SystemTime(wall_clock::Datetime);
+
+impl SystemTime {
+    pub fn now() -> Self {
+        Self(wall_clock::now())
+    }
+}
+
+impl From<SystemTime> for std::time::SystemTime {
+    fn from(st: SystemTime) -> Self {
+        std::time::SystemTime::UNIX_EPOCH
+            + std::time::Duration::from_secs(st.0.seconds)
+            + std::time::Duration::from_nanos(st.0.nanoseconds.into())
+    }
+}
+
+/// A future that resolves once the monotonic clock reaches a deadline.
+///
+/// Created by [`sleep_until`]. This is the backend `Sleep` type named by the
+/// facade's `Timer`/`Wait`; on p2 it is a thin wrapper over a reactor-scheduled
+/// `monotonic-clock` pollable.
+#[must_use = "futures do nothing unless polled or .awaited"]
+#[derive(Debug)]
+pub struct Sleep {
+    wait_for: WaitFor,
+}
+
+impl Future for Sleep {
+    type Output = ();
+
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        Pin::new(&mut self.wait_for).poll(cx)
+    }
+}
+
+/// Create a [`Sleep`] future that resolves when the monotonic clock reaches
+/// `deadline`.
+///
+/// Must be called from within [`crate::runtime::block_on`].
+pub fn sleep_until(deadline: MonotonicInstant) -> Sleep {
+    let pollable = Reactor::current().schedule(monotonic_clock::subscribe_instant(deadline));
+    Sleep {
+        wait_for: pollable.wait_for(),
+    }
+}