chore: fix wasi build on windows

Signed-off-by: Henry <mail@henrygressmann.de>

Author: explodingcamera

.github/workflows/test.yaml

@@ -19,34 +19,43 @@ jobs:
           - os: ubuntu-26.04
             rust: stable
             name: "Linux x86 (stable)"
+            target: x86_64-unknown-linux-gnu
           - os: ubuntu-26.04
             rust: nightly
             name: "Linux x86 (nightly)"
+            target: x86_64-unknown-linux-gnu
           - os: ubuntu-26.04
             rust: nightly
             name: "Linux x86 (nightly tail calls)"
+            target: x86_64-unknown-linux-gnu
             args: "--features tinywasm/nightly-tail-calls"
           - os: ubuntu-26.04
             rust: stable
             name: "Linux x86 (stable, no default features)"
+            target: x86_64-unknown-linux-gnu
             args: "--no-default-features"
           - os: ubuntu-26.04
             rust: nightly
             name: "Linux x86 (nightly, no default features)"
+            target: x86_64-unknown-linux-gnu
             args: "--no-default-features"
           - os: ubuntu-26.04
             rust: nightly
             name: "Linux x86 (nightly tail calls, no default features)"
+            target: x86_64-unknown-linux-gnu
             args: "--no-default-features --features tinywasm/nightly-tail-calls"
           - os: macos-26
             rust: stable
             name: "macOS arm64 (Apple M1)"
+            target: aarch64-apple-darwin
           - os: windows-2025
             rust: stable
             name: "Windows x86_64"
+            target: x86_64-pc-windows-msvc
           - os: ubuntu-26.04-arm
             rust: stable
             name: "Linux arm64"
+            target: aarch64-unknown-linux-gnu
           - os: ubuntu-26.04-arm
             rust: stable
             name: "Linux armv7"
@@ -65,33 +74,25 @@ jobs:
         uses: actions-rust-lang/setup-rust-toolchain@ecabd13d1c56bd1345c230e542e9144811ad706f # v2.0.0
         with:
           toolchain: ${{ matrix.rust }}
+          target: ${{ matrix.target }}
           rustflags: ""
+          build-warnings: warn
           components: rustfmt, clippy
-        if: matrix.target == ''
-
-      - name: Run tests
-        run: cargo test --workspace ${{ matrix.args }} && cargo test --workspace ${{ matrix.args }} --examples
-        if: matrix.target == ''
-
-      - name: Run clippy
-        run: cargo clippy --workspace ${{ matrix.args }}
-        if: matrix.target == ''
 
       - name: Install armv7 tools
         run: sudo apt-get update && sudo apt-get install -y gcc-arm-linux-gnueabihf qemu-user
-        if: matrix.target != ''
+        if: matrix.target == 'armv7-unknown-linux-gnueabihf'
 
-      - name: Install Rust toolchain (${{ matrix.target }})
-        uses: actions-rust-lang/setup-rust-toolchain@ecabd13d1c56bd1345c230e542e9144811ad706f # v2.0.0
-        with:
-          toolchain: ${{ matrix.rust }}
-          target: ${{ matrix.target }}
-          rustflags: ""
-        if: matrix.target != ''
-
-      - name: Run tests (${{ matrix.target }})
-        run: cargo test --workspace --target ${{ matrix.target }}
+      - name: Run tests
+        run: cargo test --workspace --target ${{ matrix.target }} ${{ matrix.args }}
         env:
           CARGO_TARGET_ARMV7_UNKNOWN_LINUX_GNUEABIHF_LINKER: arm-linux-gnueabihf-gcc
           CARGO_TARGET_ARMV7_UNKNOWN_LINUX_GNUEABIHF_RUNNER: qemu-arm -L /usr/arm-linux-gnueabihf
-        if: matrix.target != ''
+
+      - name: Run examples
+        run: cargo test --workspace --target ${{ matrix.target }} ${{ matrix.args }} --examples
+        if: matrix.target != 'armv7-unknown-linux-gnueabihf'
+
+      - name: Run clippy
+        run: cargo clippy --workspace --target ${{ matrix.target }} ${{ matrix.args }}
+        if: matrix.target != 'armv7-unknown-linux-gnueabihf'

crates/cli/src/testsuite.rs

@@ -103,7 +103,11 @@ impl TestSuite {
         use std::fs::OpenOptions;
         use std::io::Write;
 
-        let mut file = OpenOptions::new().create(true).append(true).read(true).open(path)?;
+        if std::env::var("CI").is_ok_and(|value| value == "true") {
+            return Ok(());
+        }
+
+        let mut file = OpenOptions::new().create(true).read(true).write(true).open(path)?;
         let last_line = BufReader::new(&file).lines().last().transpose()?;
 
         if let Some(last) = last_line

crates/wasi/src/p1/abi.rs

@@ -31,6 +31,7 @@ pub(super) const INTR: Errno = Errno(27);
 pub(super) const INVAL: Errno = Errno(28);
 pub(super) const IO: Errno = Errno(29);
 pub(super) const ISDIR: Errno = Errno(31);
+#[cfg(any(unix, target_os = "android"))]
 pub(super) const LOOP: Errno = Errno(32);
 pub(super) const MFILE: Errno = Errno(33);
 pub(super) const MLINK: Errno = Errno(34);
@@ -41,6 +42,7 @@ pub(super) const NOSPC: Errno = Errno(51);
 pub(super) const NOTCONN: Errno = Errno(53);
 pub(super) const NOTDIR: Errno = Errno(54);
 pub(super) const NOTEMPTY: Errno = Errno(55);
+#[cfg(unix)]
 pub(super) const NOTSOCK: Errno = Errno(57);
 pub(super) const NOTSUP: Errno = Errno(58);
 pub(super) const OVERFLOW: Errno = Errno(61);
@@ -187,6 +189,7 @@ fn platform_io_errno(_error: &io::Error) -> Errno {
     IO
 }
 
+#[cfg(unix)]
 impl From<rustix::io::Errno> for Errno {
     fn from(error: rustix::io::Errno) -> Self {
         use rustix::io::Errno as E;

crates/wasi/src/p1/imports/fd.rs

@@ -1,6 +1,7 @@
 use std::io::{Read, Seek, SeekFrom, Write};
 
 use cap_fs_ext::{DirEntryExt, DirExt, MetadataExt};
+#[cfg(unix)]
 use cap_std::fs::FileExt;
 use tinywasm::FuncContext;
 
@@ -185,9 +186,12 @@ fn read_from_fd(
     buffer.resize(iovecs.byte_len, 0);
     let read = match &mut descriptor.resource {
         Resource::Stdin => std::io::stdin().lock().read(&mut buffer),
+        #[cfg(unix)]
         Resource::File(file) if let Some(offset) = offset => {
             file.read_at(&mut buffer, checked_offset(offset, iovecs.byte_len)?)
         }
+        #[cfg(not(unix))]
+        Resource::File(_) if offset.is_some() => return Ok(NOTSUP),
         Resource::File(file) => file.read(&mut buffer),
         Resource::TcpStream(stream) => stream.read(&mut buffer),
         Resource::UdpSocket(socket) => socket.recv(&mut buffer),
@@ -224,7 +228,10 @@ fn write_to_fd(
     let written = match &mut descriptor.resource {
         Resource::Stdout => std::io::stdout().lock().write(&data),
         Resource::Stderr => std::io::stderr().lock().write(&data),
+        #[cfg(unix)]
         Resource::File(file) if let Some(offset) = offset => file.write_at(&data, checked_offset(offset, data.len())?),
+        #[cfg(not(unix))]
+        Resource::File(_) if offset.is_some() => return Ok(NOTSUP),
         Resource::File(file) => file.write(&data),
         Resource::TcpStream(stream) => stream.write(&data),
         Resource::UdpSocket(socket) => socket.send(&data),
@@ -237,6 +244,7 @@ fn write_to_fd(
         .map_or_else(|errno| errno, |()| SUCCESS))
 }
 
+#[cfg(unix)]
 fn checked_offset(offset: u64, len: usize) -> Result<u64, Errno> {
     offset.checked_add(len as u64).map(|_| offset).ok_or(OVERFLOW)
 }

crates/wasi/src/p1/imports/mod.rs

@@ -5,6 +5,10 @@ mod path;
 mod poll;
 mod process;
 mod random;
+#[cfg(unix)]
+mod sock;
+#[cfg(not(unix))]
+#[path = "sock_windows.rs"]
 mod sock;
 
 use tinywasm::{HostFunction, Imports};

crates/wasi/src/p1/imports/poll.rs

@@ -1,5 +1,6 @@
 use std::io::Seek;
 
+#[cfg(unix)]
 use rustix::event::{PollFd, PollFlags, Timespec};
 use tinywasm::FuncContext;
 
@@ -12,6 +13,7 @@ use super::WasiResult;
 enum Readiness {
     Ready,
     Clock(u64),
+    #[cfg(unix)]
     Poll,
 }
 
@@ -20,12 +22,16 @@ struct PendingEvent {
     readiness: Readiness,
 }
 
+#[cfg(unix)]
 struct PollTarget {
     event_index: usize,
     fd: i32,
     event_type: u8,
 }
 
+#[cfg(not(unix))]
+struct PollTarget;
+
 impl PendingEvent {
     fn new(userdata: u64, error: Errno, event_type: u8, available: u64, readiness: Readiness) -> Self {
         let mut bytes = [0; 32];
@@ -134,11 +140,21 @@ fn subscribe_fd(
         pending_events.push(PendingEvent::new(userdata, SUCCESS, event_type, available, Readiness::Ready));
         return Ok(());
     }
-    poll_targets.push(PollTarget { event_index: pending_events.len(), fd, event_type });
-    pending_events.push(PendingEvent::new(userdata, SUCCESS, event_type, 0, Readiness::Poll));
-    Ok(())
+    #[cfg(not(unix))]
+    {
+        let _ = poll_targets;
+        pending_events.push(PendingEvent::new(userdata, NOTSUP, event_type, 0, Readiness::Ready));
+        Ok(())
+    }
+    #[cfg(unix)]
+    {
+        poll_targets.push(PollTarget { event_index: pending_events.len(), fd, event_type });
+        pending_events.push(PendingEvent::new(userdata, SUCCESS, event_type, 0, Readiness::Poll));
+        Ok(())
+    }
 }
 
+#[cfg(unix)]
 fn wait_for_events(
     ctx: &FuncContext<'_>,
     poll_targets: &[PollTarget],
@@ -217,3 +233,21 @@ fn wait_for_events(
     }
     Ok(u64::try_from(started.elapsed().as_nanos()).unwrap_or(u64::MAX))
 }
+
+#[cfg(not(unix))]
+fn wait_for_events(
+    _ctx: &FuncContext<'_>,
+    poll_targets: &[PollTarget],
+    _pending_events: &mut [PendingEvent],
+    timeout_ns: Option<u64>,
+) -> WasiResult<u64> {
+    if !poll_targets.is_empty() {
+        return Err(NOTSUP.into());
+    }
+    if let Some(nanoseconds) = timeout_ns {
+        std::thread::sleep(std::time::Duration::from_nanos(nanoseconds));
+        Ok(nanoseconds)
+    } else {
+        Ok(0)
+    }
+}

crates/wasi/src/p1/imports/sock_windows.rs

@@ -0,0 +1,21 @@
+use tinywasm::FuncContext;
+
+use crate::p1::abi::{Errno, NOTSUP};
+
+use super::WasiResult;
+
+pub(super) fn sock_accept(_ctx: FuncContext<'_>, _args: (i32, i32, i32)) -> WasiResult<Errno> {
+    Ok(NOTSUP)
+}
+
+pub(super) fn sock_recv(_ctx: FuncContext<'_>, _args: (i32, i32, i32, i32, i32, i32)) -> WasiResult<Errno> {
+    Ok(NOTSUP)
+}
+
+pub(super) fn sock_send(_ctx: FuncContext<'_>, _args: (i32, i32, i32, i32, i32)) -> WasiResult<Errno> {
+    Ok(NOTSUP)
+}
+
+pub(super) fn sock_shutdown(_ctx: FuncContext<'_>, _args: (i32, i32)) -> WasiResult<Errno> {
+    Ok(NOTSUP)
+}

crates/wasi/tests/p1.rs

@@ -236,6 +236,7 @@ fn provides_clocks_randomness_and_timer_polling() -> tinywasm::Result<()> {
     Ok(())
 }
 
+#[cfg(unix)]
 #[test]
 fn polls_accepts_and_uses_tcp_streams() -> tinywasm::Result<()> {
     use std::io::{Read, Write};
@@ -282,6 +283,7 @@ fn polls_accepts_and_uses_tcp_streams() -> tinywasm::Result<()> {
     Ok(())
 }
 
+#[cfg(unix)]
 #[test]
 fn sends_and_receives_udp_datagrams() -> tinywasm::Result<()> {
     let socket = std::net::UdpSocket::bind("127.0.0.1:0").unwrap();