@shd101wyy/yo 0.1.29 → 0.1.30

package/std/sys/bufio/buf_reader.yo

@@ -17,9 +17,10 @@
 //!   .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, 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((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;
@@ -99,7 +100,7 @@ impl(
             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, 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((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));
           });
@@ -166,7 +167,7 @@ impl(
           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));
@@ -185,7 +186,7 @@ impl(
           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,7 +228,7 @@ impl(
     })
   }),
   // Read all remaining data into an ArrayList of bytes.
-  read_bytes : (fn(self : Self, 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((io) => {
       result := ArrayList(u8).new();
@@ -236,7 +237,7 @@ impl(
         (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), 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,7 +274,7 @@ impl(
     })
   }),
   // Read all remaining data as a String.
-  read_to_string : (fn(self : Self, io : IO) -> Impl(Future(Result(String, IOError), 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(

package/std/sys/bufio/buf_writer.yo

@@ -12,9 +12,10 @@
 //! 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, 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((io) => {
-      (write_err : Option(IOError)) =.None;
+      (write_err : Option(IoError)) =.None;
       cond(
         (self._buf.len() > usize(0)) => {
           written := usize(0);
@@ -68,7 +69,7 @@ impl(
             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,12 +91,12 @@ 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, 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((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(
@@ -133,7 +134,7 @@ impl(
     })
   }),
   // Write a String to the buffer.
-  write_string : (fn(self : Self, s : String, io : IO) -> Impl(Future(Result(i32, IOError), 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()), io), io);
@@ -141,14 +142,14 @@ impl(
     })
   ),
   // Write bytes from an ArrayList to the buffer.
-  write_bytes : (fn(self : Self, data : ArrayList(u8), io : IO) -> Impl(Future(Result(i32, IOError), 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, io : IO) -> Impl(Future(Result(unit, IOError), 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,9 +167,9 @@ 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, exn : Exception) -> i32)(
     cond(
@@ -178,4 +178,4 @@ impl(
     )
   )
 );
-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),

package/std/sys/file.yo

@@ -2,64 +2,65 @@
 //!
 //! Provides low-level file I/O wrappers around the C runtime externs.
 //!
-//! Async operations return `IOFuture` which resolves to:
+//! Async operations return `IoFuture` which resolves to:
 //! - Positive value: success (fd for open, bytes for read/write, 0 for others)
 //! - Negative value: -errno on failure
-// Use IOError.from_result() to convert results to Result(i32, IOError).
+// Use IoError.from_result() to convert results to Result(i32, IoError).
 //
 // Example:
-//   IO :: import "std/io";
+//   Io :: import "std/io";
 //
 //   task := async {
 //     (path : *(u8)) = "test.txt";
-//     fd_result := await IO.openat(IO.AT_FDCWD, path, IO.O_RDONLY, i32(0));
-//     fd := IOError.from_result(fd_result).unwrap();
-//     close_result := await IO.close(fd);
+//     fd_result := await Io.openat(Io.AT_FDCWD, path, Io.O_RDONLY, i32(0));
+//     fd := IoError.from_result(fd_result).unwrap();
+//     close_result := await Io.close(fd);
 //   };
-{ IOFuture } :: import("./future.yo");
+pragma(Pragma.AllowUnsafe);
+{ IoFuture } :: import("./future.yo");
 { __yo_async_read_start, __yo_async_write_start, __yo_async_openat_start, __yo_async_close_start, __yo_async_statx_start, __yo_async_fsync_start, __yo_async_fdatasync_start, __yo_async_ftruncate_start, __yo_file_open, __yo_file_close, __yo_file_size } :: import("./externs.yo");
 // ============================================================================
-// Async File Operations (return IOFuture, use with await)
+// Async File Operations (return IoFuture, use with await)
 // ============================================================================
 // Open a file relative to dirfd. Use AT_FDCWD for current directory.
 // Returns fd on success, -errno on failure.
-openat :: (fn(dirfd : i32, path : *(u8), flags : i32, mode : i32) -> IOFuture)(
+openat :: (fn(dirfd : i32, path : *(u8), flags : i32, mode : i32) -> IoFuture)(
   __yo_async_openat_start(dirfd, path, flags, mode)
 );
 // Close a file descriptor.
 // Returns 0 on success, -errno on failure.
-close :: (fn(fd : i32) -> IOFuture)(
+close :: (fn(fd : i32) -> IoFuture)(
   __yo_async_close_start(fd)
 );
 // Read from fd into buffer at the given offset.
 // Returns number of bytes read on success, -errno on failure.
-read :: (fn(fd : i32, buffer : *(u8), size : u32, offset : u64) -> IOFuture)(
+read :: (fn(fd : i32, buffer : *(u8), size : u32, offset : u64) -> IoFuture)(
   __yo_async_read_start(fd, buffer, size, offset)
 );
 // Write buffer to fd at the given offset.
 // Returns number of bytes written on success, -errno on failure.
-write :: (fn(fd : i32, buffer : *(u8), size : u32, offset : u64) -> IOFuture)(
+write :: (fn(fd : i32, buffer : *(u8), size : u32, offset : u64) -> IoFuture)(
   __yo_async_write_start(fd, buffer, size, offset)
 );
 // Get file metadata via statx. Results are written to statxbuf.
 // Use Statx object to wrap and read the buffer.
 // Returns 0 on success, -errno on failure.
-statx :: (fn(dirfd : i32, path : *(u8), flags : i32, mask : u32, statxbuf : *(u8)) -> IOFuture)(
+statx :: (fn(dirfd : i32, path : *(u8), flags : i32, mask : u32, statxbuf : *(u8)) -> IoFuture)(
   __yo_async_statx_start(dirfd, path, flags, mask, statxbuf)
 );
 // Sync file data and metadata to disk.
 // Returns 0 on success, -errno on failure.
-fsync :: (fn(fd : i32) -> IOFuture)(
+fsync :: (fn(fd : i32) -> IoFuture)(
   __yo_async_fsync_start(fd)
 );
 // Sync file data (but not metadata) to disk.
 // Returns 0 on success, -errno on failure.
-fdatasync :: (fn(fd : i32) -> IOFuture)(
+fdatasync :: (fn(fd : i32) -> IoFuture)(
   __yo_async_fdatasync_start(fd)
 );
 // Truncate file to the given length.
 // Returns 0 on success, -errno on failure.
-ftruncate :: (fn(fd : i32, length : i64) -> IOFuture)(
+ftruncate :: (fn(fd : i32, length : i64) -> IoFuture)(
   __yo_async_ftruncate_start(fd, length)
 );
 // ============================================================================

package/std/sys/future.yo

@@ -1,13 +1,14 @@
-//! `IOFuture` type — opaque handle to a C async I/O future struct.
+//! `IoFuture` type — opaque handle to a C async I/O future struct.
 // ============================================================================
 // Extern type for I/O Future
 // ============================================================================
+pragma(Pragma.AllowUnsafe);
 extern(
   "Yo",
   __yo_io_future_t : Type
 );
-IOFuture :: Impl(Concrete(__yo_io_future_t), Future(i32));
+IoFuture :: Impl(Concrete(__yo_io_future_t), Future(i32));
 export(
   __yo_io_future_t,
-  IOFuture
+  IoFuture
 );