@shd101wyy/yo 0.1.28 → 0.1.30

package/std/sys/bufio/buf_reader.yo

@@ -10,16 +10,17 @@
 //! IO_file :: import "std/sys/file";
 //!
 //! reader := BufReader.new(fd);
-//! line := io.await(reader.read_line(using(io)));
+//! line := io.await(reader.read_line(io));
 //! match(line,
 //!   .Ok(.Some(s)) => println(s),
 //!   .Ok(.None) => println("EOF"),
 //!   .Err(e) => println(e.to_string())
 //! );
 //! ```
+pragma(Pragma.AllowUnsafe);
 { ArrayList } :: import("../../collections/array_list");
 open(import("../../string"));
-{ IOError } :: import("../errors");
+{ IoError } :: import("../errors");
 IO_file :: import("../file");
 { GlobalAllocator } :: import("../../allocator");
 { malloc, free } :: GlobalAllocator;
@@ -68,19 +69,19 @@ impl(
   // Read a line from the reader (up to and including '\n').
   // Returns .None on EOF when no data is available.
   // Returns .Some(line) with the line content (without the trailing '\n').
-  read_line : (fn(self : Self, using(io : IO)) -> Impl(Future(Result(Option(String), IOError), IO)))({
+  read_line : (fn(self : Self, io : Io) -> Impl(Future(Result(Option(String), IoError), Io)))({
     the_fd := self._fd;
-    io.async((using(io : IO)) => {
+    io.async((io) => {
       line_bytes := ArrayList(u8).new();
       found_newline := false;
       hit_eof := false;
-      (read_err : Option(IOError)) =.None;
+      (read_err : Option(IoError)) =.None;
       while(runtime(((!(found_newline)) && (!(hit_eof))) && read_err.is_none()), {
         cond(
           (self._pos < self._filled) => {
             scan := self._pos;
             while(runtime((scan < self._filled) && (!(found_newline))), {
-              b := self._buf.get(scan).unwrap();
+              b := self._buf(scan);
               cond(
                 (b == _NEWLINE) => {
                   found_newline = true;
@@ -95,11 +96,11 @@ impl(
           },
           true => {
             raw_buf := *(u8)(malloc(self._capacity).unwrap());
-            n := io.await(IO_file.read(the_fd, raw_buf, u32(self._capacity), self._offset));
+            n := io.await(IO_file.read(the_fd, raw_buf, u32(self._capacity), self._offset), io);
             cond(
               (n < i32(0)) => {
                 free(.Some(*(void)(raw_buf)));
-                read_err =.Some(IOError.from_errno(i32(0) - n));
+                read_err =.Some(IoError.from_errno(i32(0) - n));
               },
               (n == i32(0)) => {
                 free(.Some(*(void)(raw_buf)));
@@ -134,11 +135,11 @@ impl(
   }),
   // Read up to `size` bytes into a provided buffer.
   // Returns the number of bytes actually read.
-  read : (fn(self : Self, buf : *(u8), size : u32, using(io : IO)) -> Impl(Future(Result(i32, IOError), IO)))({
+  read : (fn(self : Self, buf : *(u8), size : u32, io : Io) -> Impl(Future(Result(i32, IoError), Io)))({
     the_fd := self._fd;
-    io.async((using(io : IO)) => {
+    io.async((io) => {
       available := (self._filled - self._pos);
-      (read_err : Option(IOError)) =.None;
+      (read_err : Option(IoError)) =.None;
       (read_n : i32) = i32(0);
       done := false;
       // If there's data already buffered, serve from buffer
@@ -150,7 +151,7 @@ impl(
           );
           i := usize(0);
           while(runtime(i < to_copy), {
-            b := self._buf.get(self._pos + i).unwrap();
+            b := self._buf(self._pos + i);
             (buf &+ i).* = b;
             i = (i + usize(1));
           });
@@ -163,10 +164,10 @@ impl(
       // Buffer is empty and large read: bypass buffer
       cond(
         ((!(done)) && (usize(size) >= self._capacity)) => {
-          n := io.await(IO_file.read(the_fd, buf, size, self._offset));
+          n := io.await(IO_file.read(the_fd, buf, size, self._offset), io);
           cond(
             (n < i32(0)) => {
-              read_err =.Some(IOError.from_errno(i32(0) - n));
+              read_err =.Some(IoError.from_errno(i32(0) - n));
             },
             true => {
               self._offset = (self._offset + u64(n));
@@ -181,11 +182,11 @@ impl(
       cond(
         (!(done)) => {
           raw_buf := *(u8)(malloc(self._capacity).unwrap());
-          n := io.await(IO_file.read(the_fd, raw_buf, u32(self._capacity), self._offset));
+          n := io.await(IO_file.read(the_fd, raw_buf, u32(self._capacity), self._offset), io);
           cond(
             (n < i32(0)) => {
               free(.Some(*(void)(raw_buf)));
-              read_err =.Some(IOError.from_errno(i32(0) - n));
+              read_err =.Some(IoError.from_errno(i32(0) - n));
             },
             (n == i32(0)) => {
               free(.Some(*(void)(raw_buf)));
@@ -208,7 +209,7 @@ impl(
               );
               j := usize(0);
               while(runtime(j < to_copy), {
-                b := self._buf.get(j).unwrap();
+                b := self._buf(j);
                 (buf &+ j).* = b;
                 j = (j + usize(1));
               });
@@ -227,16 +228,16 @@ impl(
     })
   }),
   // Read all remaining data into an ArrayList of bytes.
-  read_bytes : (fn(self : Self, using(io : IO)) -> Impl(Future(Result(ArrayList(u8), IOError), IO)))({
+  read_bytes : (fn(self : Self, io : Io) -> Impl(Future(Result(ArrayList(u8), IoError), Io)))({
     the_fd := self._fd;
-    io.async((using(io : IO)) => {
+    io.async((io) => {
       result := ArrayList(u8).new();
       // First drain any buffered data
       cond(
         (self._pos < self._filled) => {
           i := self._pos;
           while(runtime(i < self._filled), {
-            result.push(self._buf.get(i).unwrap());
+            result.push(self._buf(i));
             i = (i + usize(1));
           });
           self._pos = self._filled;
@@ -245,12 +246,12 @@ impl(
       );
       // Then read the rest from fd
       raw_buf := *(u8)(malloc(self._capacity).unwrap());
-      (read_err : Option(IOError)) =.None;
+      (read_err : Option(IoError)) =.None;
       while(runtime(true), {
-        n := io.await(IO_file.read(the_fd, raw_buf, u32(self._capacity), self._offset));
+        n := io.await(IO_file.read(the_fd, raw_buf, u32(self._capacity), self._offset), io);
         cond(
           (n < i32(0)) => {
-            read_err =.Some(IOError.from_errno(i32(0) - n));
+            read_err =.Some(IoError.from_errno(i32(0) - n));
             break;
           },
           (n == i32(0)) => break,
@@ -273,9 +274,9 @@ impl(
     })
   }),
   // Read all remaining data as a String.
-  read_to_string : (fn(self : Self, using(io : IO)) -> Impl(Future(Result(String, IOError), IO)))(
-    io.async((using(io : IO)) => {
-      bytes_result := io.await(self.read_bytes(using(io)));
+  read_to_string : (fn(self : Self, io : Io) -> Impl(Future(Result(String, IoError), Io)))(
+    io.async((io) => {
+      bytes_result := io.await(self.read_bytes(io), io);
       match(
         bytes_result,
         .Ok(bytes) =>.Ok(String.from_bytes(bytes)),

package/std/sys/bufio/buf_writer.yo

@@ -9,12 +9,13 @@
 //! { BufWriter } :: import "std/sys/bufio/buf_writer";
 //!
 //! writer := BufWriter.new(fd);
-//! io.await(writer.write_string(`hello\n`, using(io)));
-//! io.await(writer.flush(using(io)));
+//! io.await(writer.write_string(`hello\n`, io));
+//! io.await(writer.flush(io));
 //! ```
+pragma(Pragma.AllowUnsafe);
 { ArrayList } :: import("../../collections/array_list");
 open(import("../../string"));
-{ IOError } :: import("../errors");
+{ IoError } :: import("../errors");
 IO_file :: import("../file");
 { GlobalAllocator } :: import("../../allocator");
 { malloc, free } :: GlobalAllocator;
@@ -54,10 +55,10 @@ impl(
     self._buf.len()
   ),
   // Internal: flush the buffer contents to fd.
-  _flush_inner : (fn(self : Self, using(io : IO)) -> Impl(Future(Result(unit, IOError), IO)))({
+  _flush_inner : (fn(self : Self, io : Io) -> Impl(Future(Result(unit, IoError), Io)))({
     the_fd := self._fd;
-    io.async((using(io : IO)) => {
-      (write_err : Option(IOError)) =.None;
+    io.async((io) => {
+      (write_err : Option(IoError)) =.None;
       cond(
         (self._buf.len() > usize(0)) => {
           written := usize(0);
@@ -65,10 +66,10 @@ impl(
           while(runtime((written < total) && write_err.is_none()), {
             remaining := u32(total - written);
             buf_ptr := self._buf.ptr().unwrap();
-            n := io.await(IO_file.write(the_fd, buf_ptr &+ written, remaining, self._offset));
+            n := io.await(IO_file.write(the_fd, buf_ptr &+ written, remaining, self._offset), io);
             cond(
               (n < i32(0)) => {
-                write_err =.Some(IOError.from_errno(i32(0) - n));
+                write_err =.Some(IoError.from_errno(i32(0) - n));
               },
               true => {
                 written = (written + usize(n));
@@ -90,18 +91,18 @@ impl(
   // Write bytes from a pointer into the buffer.
   // Automatically flushes when the buffer is full.
   // Returns total number of bytes written.
-  write : (fn(self : Self, data : *(u8), size : u32, using(io : IO)) -> Impl(Future(Result(i32, IOError), IO)))({
+  write : (fn(self : Self, data : *(u8), size : u32, io : Io) -> Impl(Future(Result(i32, IoError), Io)))({
     the_fd := self._fd;
-    io.async((using(io : IO)) => {
+    io.async((io) => {
       remaining := usize(size);
       src_pos := usize(0);
-      (write_err : Option(IOError)) =.None;
+      (write_err : Option(IoError)) =.None;
       while(runtime((remaining > usize(0)) && write_err.is_none()), {
         space := (self._capacity - self._buf.len());
         cond(
           (space == usize(0)) => {
             // Buffer full, flush it
-            flush_result := io.await(self._flush_inner(using(io)));
+            flush_result := io.await(self._flush_inner(io), io);
             match(
               flush_result,
               .Err(e) => {
@@ -133,24 +134,24 @@ impl(
     })
   }),
   // Write a String to the buffer.
-  write_string : (fn(self : Self, s : String, using(io : IO)) -> Impl(Future(Result(i32, IOError), IO)))(
-    io.async((using(io : IO)) => {
+  write_string : (fn(self : Self, s : String, io : Io) -> Impl(Future(Result(i32, IoError), Io)))(
+    io.async((io) => {
       bytes := s.as_bytes();
-      result := io.await(self.write(bytes.ptr().unwrap(), u32(bytes.len()), using(io)));
+      result := io.await(self.write(bytes.ptr().unwrap(), u32(bytes.len()), io), io);
       result
     })
   ),
   // Write bytes from an ArrayList to the buffer.
-  write_bytes : (fn(self : Self, data : ArrayList(u8), using(io : IO)) -> Impl(Future(Result(i32, IOError), IO)))(
-    io.async((using(io : IO)) => {
-      result := io.await(self.write(data.ptr().unwrap(), u32(data.len()), using(io)));
+  write_bytes : (fn(self : Self, data : ArrayList(u8), io : Io) -> Impl(Future(Result(i32, IoError), Io)))(
+    io.async((io) => {
+      result := io.await(self.write(data.ptr().unwrap(), u32(data.len()), io), io);
       result
     })
   ),
   // Flush all buffered data to the underlying file descriptor.
-  flush : (fn(self : Self, using(io : IO)) -> Impl(Future(Result(unit, IOError), IO)))(
-    io.async((using(io : IO)) => {
-      flush_result := io.await(self._flush_inner(using(io)));
+  flush : (fn(self : Self, io : Io) -> Impl(Future(Result(unit, IoError), Io)))(
+    io.async((io) => {
+      flush_result := io.await(self._flush_inner(io), io);
       flush_result
     })
   )

package/std/sys/clock.yo

@@ -2,6 +2,7 @@
 //!
 //! Provides a synchronous wrapper for reading wall-clock and monotonic time.
 //! Returns 0 on success, -errno / negative platform error on failure.
+pragma(Pragma.AllowUnsafe);
 { platform, Platform } :: import("../process");
 { __yo_sync_clock_gettime } :: import("./externs.yo");
 // Wall clock time (Unix epoch seconds + nanoseconds)

package/std/sys/copy.yo

@@ -7,6 +7,7 @@
 //!
 //! - `copyfile`: 0 on success, -errno on failure
 //! - `sendfile`: bytes transferred on success, -errno on failure
+pragma(Pragma.AllowUnsafe);
 { __yo_sync_copyfile, __yo_sync_sendfile } :: import("./externs.yo");
 // Copy a file using kernel-accelerated copy.
 // flags: 0 = default, 1 = COPYFILE_EXCL (fail if dst exists)

package/std/sys/dir.yo

@@ -3,7 +3,7 @@
 //! Provides low-level directory manipulation wrappers around C runtime externs.
 //!
 //! Async operations (`mkdir`, `unlink`, `rename`, `symlink`, `link`, `getdents`)
-//! return `IOFuture` which resolves to:
+//! return `IoFuture` which resolves to:
 //! - 0 on success (for mkdir, unlink, rename, symlink, link)
 //! - Bytes read for getdents
 //! - Negative value: -errno on failure
@@ -20,35 +20,36 @@
 //     result := await mkdir(AT_FDCWD, *(u8)("/tmp/yo_test_dir"), i32(0o755));
 //     assert(result == i32(0));
 //   };
-{ IOFuture } :: import("./future.yo");
+pragma(Pragma.AllowUnsafe);
+{ IoFuture } :: import("./future.yo");
 { __yo_async_mkdirat_start, __yo_async_unlinkat_start, __yo_async_renameat_start, __yo_async_symlinkat_start, __yo_async_linkat_start, __yo_sync_readlinkat, __yo_async_getdents_start, __yo_dirent_size, __yo_dirent_reclen, __yo_dirent_type, __yo_dirent_name, __yo_dirent_ino } :: import("./externs.yo");
 // ============================================================================
-// Async Directory Operations (return IOFuture, use with await)
+// Async Directory Operations (return IoFuture, use with await)
 // ============================================================================
 // Create a directory relative to dirfd. Use AT_FDCWD for current directory.
 // Returns 0 on success, -errno on failure.
-mkdir :: (fn(dirfd : i32, path : *(u8), mode : i32) -> IOFuture)(
+mkdir :: (fn(dirfd : i32, path : *(u8), mode : i32) -> IoFuture)(
   __yo_async_mkdirat_start(dirfd, path, mode)
 );
 // Remove a file or directory relative to dirfd.
 // Use flags=0 for files, flags=AT_REMOVEDIR (0x200) for directories.
 // Returns 0 on success, -errno on failure.
-unlink :: (fn(dirfd : i32, path : *(u8), flags : i32) -> IOFuture)(
+unlink :: (fn(dirfd : i32, path : *(u8), flags : i32) -> IoFuture)(
   __yo_async_unlinkat_start(dirfd, path, flags)
 );
 // Rename/move a file or directory.
 // Returns 0 on success, -errno on failure.
-rename :: (fn(olddirfd : i32, oldpath : *(u8), newdirfd : i32, newpath : *(u8)) -> IOFuture)(
+rename :: (fn(olddirfd : i32, oldpath : *(u8), newdirfd : i32, newpath : *(u8)) -> IoFuture)(
   __yo_async_renameat_start(olddirfd, oldpath, newdirfd, newpath)
 );
 // Create a symbolic link at linkpath pointing to target.
 // Returns 0 on success, -errno on failure.
-symlink :: (fn(target : *(u8), newdirfd : i32, linkpath : *(u8)) -> IOFuture)(
+symlink :: (fn(target : *(u8), newdirfd : i32, linkpath : *(u8)) -> IoFuture)(
   __yo_async_symlinkat_start(target, newdirfd, linkpath)
 );
 // Create a hard link from oldpath to newpath.
 // Returns 0 on success, -errno on failure.
-link :: (fn(olddirfd : i32, oldpath : *(u8), newdirfd : i32, newpath : *(u8), flags : i32) -> IOFuture)(
+link :: (fn(olddirfd : i32, oldpath : *(u8), newdirfd : i32, newpath : *(u8), flags : i32) -> IoFuture)(
   __yo_async_linkat_start(olddirfd, oldpath, newdirfd, newpath, flags)
 );
 // Read the target of a symbolic link into buf.
@@ -93,7 +94,7 @@ readlink :: (fn(dirfd : i32, path : *(u8), buf : *(u8), bufsize : usize) -> i32)
 //     free(.Some(*(void)(buf)));
 //     await close(fd);
 //   };
-getdents :: (fn(fd : i32, buf : *(u8), buf_size : u32) -> IOFuture)(
+getdents :: (fn(fd : i32, buf : *(u8), buf_size : u32) -> IoFuture)(
   __yo_async_getdents_start(fd, buf, buf_size)
 );
 // ============================================================================

package/std/sys/dns.yo

@@ -3,7 +3,7 @@
 //! Provides async DNS resolution wrapping `getaddrinfo`/`getnameinfo`, plus
 //! accessors for iterating the linked list of `addrinfo` results.
 //!
-//! All async operations return `IOFuture` which resolves to:
+//! All async operations return `IoFuture` which resolves to:
 //! - 0: success
 //! - Non-zero: raw `gai_error` code (`EAI_NONAME`, `EAI_AGAIN`, etc.)
 //
@@ -36,12 +36,13 @@
 //     );
 //     dns.free_result(result_ptr);
 //   };
+pragma(Pragma.AllowUnsafe);
 { GlobalAllocator } :: import("../allocator");
 { malloc, free } :: GlobalAllocator;
-{ IOFuture } :: import("./future.yo");
+{ IoFuture } :: import("./future.yo");
 { __yo_async_getaddrinfo_start, __yo_async_getnameinfo_start, __yo_freeaddrinfo, __yo_addrinfo_size, __yo_addrinfo_flags, __yo_addrinfo_family, __yo_addrinfo_socktype, __yo_addrinfo_protocol, __yo_addrinfo_addrlen, __yo_addrinfo_addr, __yo_addrinfo_canonname, __yo_addrinfo_next } :: import("./externs.yo");
 // ============================================================================
-// DNS Resolution (return IOFuture, use with await)
+// DNS Resolution (return IoFuture, use with await)
 // ============================================================================
 // Resolve hostname to a linked list of addrinfo results.
 // node: hostname or IP string (e.g. "localhost", "example.com")
@@ -50,7 +51,7 @@
 // result: pointer to a ?*(u8) that will receive the head of the result list
 // Returns 0 on success, non-zero gai_error on failure.
 // Caller must call freeaddrinfo() on the result when done.
-getaddrinfo :: (fn(node : *(u8), service : ?*(u8), hints : ?*(u8), result : *(?*(u8))) -> IOFuture)(
+getaddrinfo :: (fn(node : *(u8), service : ?*(u8), hints : ?*(u8), result : *(?*(u8))) -> IoFuture)(
   __yo_async_getaddrinfo_start(node, service, hints, result)
 );
 // Reverse lookup: convert a socket address to hostname and service strings.
@@ -62,7 +63,7 @@ getaddrinfo :: (fn(node : *(u8), service : ?*(u8), hints : ?*(u8), result : *(?*
 // servlen: size of service buffer
 // flags: NI_NUMERICHOST, NI_NUMERICSERV, etc.
 // Returns 0 on success, -gai_error on failure.
-getnameinfo :: (fn(addr : *(u8), addrlen : u32, host : *(u8), hostlen : usize, service : *(u8), servlen : usize, flags : i32) -> IOFuture)(
+getnameinfo :: (fn(addr : *(u8), addrlen : u32, host : *(u8), hostlen : usize, service : *(u8), servlen : usize, flags : i32) -> IoFuture)(
   __yo_async_getnameinfo_start(addr, addrlen, host, hostlen, service, servlen, flags)
 );
 // Free an addrinfo result list returned by getaddrinfo.

package/std/sys/errors.yo

@@ -1,13 +1,13 @@
-//! `IOError` type — comprehensive I/O error type with errno-to-error mapping.
+//! `IoError` type — comprehensive I/O error type with errno-to-error mapping.
 { String } :: import("../string");
 { ToString } :: import("../fmt");
 { Error, Exception } :: import("../error");
 { ENOENT, EPERM, EACCES, EEXIST, ENOTDIR, EISDIR, ENOTEMPTY, EPIPE, EAGAIN, EWOULDBLOCK, EINVAL, EINTR, EMFILE, ENFILE, EFBIG, ENOSPC, EROFS, EXDEV, EMLINK, ENAMETOOLONG, ENOTSUP, EOPNOTSUPP, ETIMEDOUT, EBUSY, ECONNREFUSED, ECONNRESET, ECONNABORTED, ENOTCONN, EADDRINUSE, EADDRNOTAVAIL, ENETUNREACH, EHOSTUNREACH, ENETDOWN, EISCONN, EBADF, EIO } :: import("../libc/errno");
 // ============================================================================
-// IOError - I/O error type
+// IoError - I/O error type
 // ============================================================================
 /// Comprehensive I/O error type with errno-to-error mapping.
-IOError :: enum(
+IoError :: enum(
   /// File or directory not found (ENOENT).
   NotFound,
   /// Permission denied (EACCES, EPERM).
@@ -51,7 +51,7 @@ IOError :: enum(
   /// Bad file descriptor (EBADF).
   BadFileDescriptor,
   /// Generic I/O error (EIO).
-  IOError,
+  IoError,
   /// Connection refused (ECONNREFUSED).
   ConnectionRefused,
   /// Connection reset by peer (ECONNRESET).
@@ -76,7 +76,7 @@ IOError :: enum(
   Other(code : i32)
 );
 impl(
-  IOError,
+  IoError,
   from_errno : (fn(errno : i32) -> Self)(
     cond(
       (errno == i32(ENOENT)) =>.NotFound,
@@ -100,7 +100,7 @@ impl(
       (errno == i32(ETIMEDOUT)) =>.TimedOut,
       (errno == i32(EBUSY)) =>.Busy,
       (errno == i32(EBADF)) =>.BadFileDescriptor,
-      (errno == i32(EIO)) =>.IOError,
+      (errno == i32(EIO)) =>.IoError,
       (errno == i32(ECONNREFUSED)) =>.ConnectionRefused,
       (errno == i32(ECONNRESET)) =>.ConnectionReset,
       (errno == i32(ECONNABORTED)) =>.ConnectionAborted,
@@ -122,7 +122,7 @@ impl(
   )
 );
 impl(
-  IOError,
+  IoError,
   ToString(
     to_string : (
       self -> {
@@ -149,7 +149,7 @@ impl(
           .TimedOut => String.from("operation timed out"),
           .Busy => String.from("resource busy"),
           .BadFileDescriptor => String.from("bad file descriptor"),
-          .IOError => String.from("I/O error"),
+          .IoError => String.from("I/O error"),
           .ConnectionRefused => String.from("connection refused"),
           .ConnectionReset => String.from("connection reset by peer"),
           .ConnectionAborted => String.from("connection aborted"),
@@ -167,15 +167,15 @@ impl(
     )
   )
 );
-impl(IOError, Error());
+impl(IoError, Error());
 impl(
-  IOError,
+  IoError,
   // Check a raw result code, throwing on error via Exception effect.
-  check : (fn(result : i32, using(exn : Exception)) -> i32)(
+  check : (fn(result : i32, exn : Exception) -> i32)(
     cond(
       (result >= i32(0)) => result,
       true => exn.throw(dyn(Self.from_errno(i32(0) - result)))
     )
   )
 );
-export(IOError);
+export(IoError);

package/std/sys/events.yo

@@ -1,4 +1,5 @@
 //! TTY, Poll, and FS Event constants.
+pragma(Pragma.AllowUnsafe);
 { __yo_fs_event_init, __yo_fs_event_start, __yo_fs_event_stop, __yo_fs_event_close, __yo_poll_init, __yo_poll_start, __yo_poll_stop, __yo_poll_close } :: import("./externs.yo");
 // ============================================================================
 // TTY Mode Constants (libuv uv_tty_mode_t equivalent)

package/std/sys/externs.yo

@@ -1,7 +1,8 @@
 //! Extern C runtime function declarations.
 //!
 //! All low-level extern functions for async I/O operations.
-{ IOFuture } :: import("./future.yo");
+pragma(Pragma.AllowUnsafe);
+{ IoFuture } :: import("./future.yo");
 // ============================================================================
 // Extern C runtime functions
 // ============================================================================
@@ -10,23 +11,23 @@ extern(
   // ========================================================================
   // File Operations
   // ========================================================================
-  __yo_async_read_start : (fn(fd : i32, buffer : *(u8), size : u32, offset : u64) -> IOFuture),
-  __yo_async_write_start : (fn(fd : i32, buffer : *(u8), size : u32, offset : u64) -> IOFuture),
-  __yo_async_openat_start : (fn(dirfd : i32, path : *(u8), flags : i32, mode : i32) -> IOFuture),
-  __yo_async_close_start : (fn(fd : i32) -> IOFuture),
-  __yo_async_statx_start : (fn(dirfd : i32, path : *(u8), flags : i32, mask : u32, statxbuf : *(u8)) -> IOFuture),
-  __yo_async_mkdirat_start : (fn(dirfd : i32, path : *(u8), mode : i32) -> IOFuture),
-  __yo_async_unlinkat_start : (fn(dirfd : i32, path : *(u8), flags : i32) -> IOFuture),
-  __yo_async_renameat_start : (fn(olddirfd : i32, oldpath : *(u8), newdirfd : i32, newpath : *(u8)) -> IOFuture),
-  __yo_async_symlinkat_start : (fn(target : *(u8), newdirfd : i32, linkpath : *(u8)) -> IOFuture),
-  __yo_async_linkat_start : (fn(olddirfd : i32, oldpath : *(u8), newdirfd : i32, newpath : *(u8), flags : i32) -> IOFuture),
-  __yo_async_fsync_start : (fn(fd : i32) -> IOFuture),
-  __yo_async_fdatasync_start : (fn(fd : i32) -> IOFuture),
-  __yo_async_ftruncate_start : (fn(fd : i32, length : i64) -> IOFuture),
+  __yo_async_read_start : (fn(fd : i32, buffer : *(u8), size : u32, offset : u64) -> IoFuture),
+  __yo_async_write_start : (fn(fd : i32, buffer : *(u8), size : u32, offset : u64) -> IoFuture),
+  __yo_async_openat_start : (fn(dirfd : i32, path : *(u8), flags : i32, mode : i32) -> IoFuture),
+  __yo_async_close_start : (fn(fd : i32) -> IoFuture),
+  __yo_async_statx_start : (fn(dirfd : i32, path : *(u8), flags : i32, mask : u32, statxbuf : *(u8)) -> IoFuture),
+  __yo_async_mkdirat_start : (fn(dirfd : i32, path : *(u8), mode : i32) -> IoFuture),
+  __yo_async_unlinkat_start : (fn(dirfd : i32, path : *(u8), flags : i32) -> IoFuture),
+  __yo_async_renameat_start : (fn(olddirfd : i32, oldpath : *(u8), newdirfd : i32, newpath : *(u8)) -> IoFuture),
+  __yo_async_symlinkat_start : (fn(target : *(u8), newdirfd : i32, linkpath : *(u8)) -> IoFuture),
+  __yo_async_linkat_start : (fn(olddirfd : i32, oldpath : *(u8), newdirfd : i32, newpath : *(u8), flags : i32) -> IoFuture),
+  __yo_async_fsync_start : (fn(fd : i32) -> IoFuture),
+  __yo_async_fdatasync_start : (fn(fd : i32) -> IoFuture),
+  __yo_async_ftruncate_start : (fn(fd : i32, length : i64) -> IoFuture),
   // ========================================================================
   // Directory Listing (for fs.readdir)
   // ========================================================================
-  __yo_async_getdents_start : (fn(fd : i32, buf : *(u8), buf_size : u32) -> IOFuture),
+  __yo_async_getdents_start : (fn(fd : i32, buf : *(u8), buf_size : u32) -> IoFuture),
   __yo_dirent_size : (fn() -> usize),
   __yo_dirent_reclen : (fn(entry : *(u8)) -> u16),
   __yo_dirent_type : (fn(entry : *(u8)) -> u8),
@@ -41,18 +42,18 @@ extern(
   // ========================================================================
   // Socket Operations (for tcp, udp, unix sockets)
   // ========================================================================
-  __yo_async_socket_start : (fn(domain : i32, sock_type : i32, protocol : i32) -> IOFuture),
-  __yo_async_bind_start : (fn(sockfd : i32, addr : *(u8), addrlen : u32) -> IOFuture),
-  __yo_async_listen_start : (fn(sockfd : i32, backlog : i32) -> IOFuture),
-  __yo_async_accept_start : (fn(sockfd : i32, addr : *(u8), addrlen : *(u32)) -> IOFuture),
-  __yo_async_connect_start : (fn(sockfd : i32, addr : *(u8), addrlen : u32) -> IOFuture),
-  __yo_async_send_start : (fn(sockfd : i32, buf : *(u8), len : usize, flags : i32) -> IOFuture),
-  __yo_async_recv_start : (fn(sockfd : i32, buf : *(u8), len : usize, flags : i32) -> IOFuture),
-  __yo_async_sendto_start : (fn(sockfd : i32, buf : *(u8), len : usize, flags : i32, dest_addr : *(u8), addrlen : u32) -> IOFuture),
-  __yo_async_recvfrom_start : (fn(sockfd : i32, buf : *(u8), len : usize, flags : i32, src_addr : *(u8), addrlen : *(u32)) -> IOFuture),
-  __yo_async_shutdown_start : (fn(sockfd : i32, how : i32) -> IOFuture),
-  __yo_async_setsockopt_start : (fn(sockfd : i32, level : i32, optname : i32, optval : *(u8), optlen : u32) -> IOFuture),
-  __yo_async_getsockopt_start : (fn(sockfd : i32, level : i32, optname : i32, optval : *(u8), optlen : *(u32)) -> IOFuture),
+  __yo_async_socket_start : (fn(domain : i32, sock_type : i32, protocol : i32) -> IoFuture),
+  __yo_async_bind_start : (fn(sockfd : i32, addr : *(u8), addrlen : u32) -> IoFuture),
+  __yo_async_listen_start : (fn(sockfd : i32, backlog : i32) -> IoFuture),
+  __yo_async_accept_start : (fn(sockfd : i32, addr : *(u8), addrlen : *(u32)) -> IoFuture),
+  __yo_async_connect_start : (fn(sockfd : i32, addr : *(u8), addrlen : u32) -> IoFuture),
+  __yo_async_send_start : (fn(sockfd : i32, buf : *(u8), len : usize, flags : i32) -> IoFuture),
+  __yo_async_recv_start : (fn(sockfd : i32, buf : *(u8), len : usize, flags : i32) -> IoFuture),
+  __yo_async_sendto_start : (fn(sockfd : i32, buf : *(u8), len : usize, flags : i32, dest_addr : *(u8), addrlen : u32) -> IoFuture),
+  __yo_async_recvfrom_start : (fn(sockfd : i32, buf : *(u8), len : usize, flags : i32, src_addr : *(u8), addrlen : *(u32)) -> IoFuture),
+  __yo_async_shutdown_start : (fn(sockfd : i32, how : i32) -> IoFuture),
+  __yo_async_setsockopt_start : (fn(sockfd : i32, level : i32, optname : i32, optval : *(u8), optlen : u32) -> IoFuture),
+  __yo_async_getsockopt_start : (fn(sockfd : i32, level : i32, optname : i32, optval : *(u8), optlen : *(u32)) -> IoFuture),
   __yo_sync_getsockname : (fn(sockfd : i32, addr : *(u8), addrlen : *(u32)) -> i32),
   __yo_sync_getpeername : (fn(sockfd : i32, addr : *(u8), addrlen : *(u32)) -> i32),
   __yo_sync_setsockopt : (fn(sockfd : i32, level : i32, optname : i32, optval : *(u8), optlen : u32) -> i32),
@@ -68,8 +69,8 @@ extern(
   // ========================================================================
   // Process Operations
   // ========================================================================
-  __yo_async_spawn_start : (fn(file : *(u8), argv : *(?*(u8)), envp : ?*(?*(u8)), stdin_fd : i32, stdout_fd : i32, stderr_fd : i32) -> IOFuture),
-  __yo_async_waitpid_start : (fn(pid : i32, options : i32) -> IOFuture),
+  __yo_async_spawn_start : (fn(file : *(u8), argv : *(?*(u8)), envp : ?*(?*(u8)), stdin_fd : i32, stdout_fd : i32, stderr_fd : i32) -> IoFuture),
+  __yo_async_waitpid_start : (fn(pid : i32, options : i32) -> IoFuture),
   __yo_process_exit_status : (fn(status : i32) -> i32),
   __yo_process_term_signal : (fn(status : i32) -> i32),
   // ========================================================================
@@ -128,7 +129,7 @@ extern(
   // ========================================================================
   // Timer Operations
   // ========================================================================
-  __yo_async_sleep_start : (fn(milliseconds : u64) -> IOFuture),
+  __yo_async_sleep_start : (fn(milliseconds : u64) -> IoFuture),
   // ========================================================================
   // File Extra Operations (async only: sleep remains async)
   // ========================================================================
@@ -143,15 +144,15 @@ extern(
   // ========================================================================
   // Directory Scanning
   // ========================================================================
-  __yo_async_scandir_start : (fn(dirfd : i32, path : *(u8)) -> IOFuture),
-  __yo_async_opendir_start : (fn(path : *(u8)) -> IOFuture),
-  __yo_async_readdir_start : (fn(dir : *(u8), entries : *(u8), max_entries : usize) -> IOFuture),
-  __yo_async_closedir_start : (fn(dir : *(u8)) -> IOFuture),
+  __yo_async_scandir_start : (fn(dirfd : i32, path : *(u8)) -> IoFuture),
+  __yo_async_opendir_start : (fn(path : *(u8)) -> IoFuture),
+  __yo_async_readdir_start : (fn(dir : *(u8), entries : *(u8), max_entries : usize) -> IoFuture),
+  __yo_async_closedir_start : (fn(dir : *(u8)) -> IoFuture),
   // ========================================================================
   // DNS Operations
   // ========================================================================
-  __yo_async_getaddrinfo_start : (fn(node : *(u8), service : ?*(u8), hints : ?*(u8), result : *(?*(u8))) -> IOFuture),
-  __yo_async_getnameinfo_start : (fn(addr : *(u8), addrlen : u32, host : *(u8), hostlen : usize, service : *(u8), servlen : usize, flags : i32) -> IOFuture),
+  __yo_async_getaddrinfo_start : (fn(node : *(u8), service : ?*(u8), hints : ?*(u8), result : *(?*(u8))) -> IoFuture),
+  __yo_async_getnameinfo_start : (fn(addr : *(u8), addrlen : u32, host : *(u8), hostlen : usize, service : *(u8), servlen : usize, flags : i32) -> IoFuture),
   __yo_freeaddrinfo : (fn(res : *(u8)) -> unit),
   __yo_addrinfo_size : (fn() -> usize),
   __yo_addrinfo_flags : (fn(ai : *(u8)) -> i32),
@@ -191,7 +192,7 @@ extern(
   __yo_poll_stop : (fn(handle : *(u8)) -> i32),
   __yo_poll_close : (fn(handle : *(u8)) -> unit),
   // ========================================================================
-  // Synchronous Operations (no IOFuture overhead)
+  // Synchronous Operations (no IoFuture overhead)
   // ========================================================================
   __yo_sync_pipe : (fn(pipefd : *(i32)) -> i32),
   __yo_sync_dup : (fn(oldfd : i32) -> i32),