package core:sys/wasm/wasi

Source

advice_t :: enum u8 {
	// *
	// 	 * The application has no advice to give on its behavior with respect to the specified data.
	NORMAL     = 0, 
	// *
	// 	 * The application expects to access the specified data sequentially from lower offsets to higher offsets.
	SEQUENTIAL = 1, 
	// *
	// 	 * The application expects to access the specified data in a random order.
	RANDOM     = 2, 
	// *
	// 	 * The application expects to access the specified data in the near future.
	WILLNEED   = 3, 
	// *
	// 	 * The application expects that it will not access the specified data in the near future.
	DONTNEED   = 4, 
	// *
	// 	 * The application expects to access the specified data once and then not reuse it thereafter.
	NOREUSE    = 5, 
}

ciovec_t :: []u8

clockid_t :: distinct u32

device_t :: distinct u64

dircookie_t :: distinct u64

dirent_t :: struct {
	d_next:   dircookie_t,
	d_ino:    inode_t,
	d_namlen: dirnamlen_t,
	d_type:   filetype_t,
}

dirnamlen_t :: distinct u32

errno_t :: enum u16 {
	NONE           = 0, 
	// No error occurred. System call completed successfully.
	SUCCESS        = 0, 
	// Argument list too long.
	TOOBIG         = 1, 
	// Permission denied.
	ACCESS         = 2, 
	// Address in use.
	ADDRINUSE      = 3, 
	// Address not available.
	ADDRNOTAVAIL   = 4, 
	// Address family not supported.
	AFNOSUPPORT    = 5, 
	// Resource unavailable, or operation would block.
	AGAIN          = 6, 
	// Connection already in progress.
	ALREADY        = 7, 
	// Bad file descriptor.
	BADF           = 8, 
	// Bad message.
	BADMSG         = 9, 
	// Device or resource busy.
	BUSY           = 10, 
	// Operation canceled.
	CANCELED       = 11, 
	// No child processes.
	CHILD          = 12, 
	// Connection aborted.
	CONNABORTED    = 13, 
	// Connection refused.
	CONNREFUSED    = 14, 
	// Connection reset.
	CONNRESET      = 15, 
	// Resource deadlock would occur.
	DEADLK         = 16, 
	// Destination address required.
	DESTADDRREQ    = 17, 
	// Mathematics argument out of domain of function.
	DOM            = 18, 
	// Reserved.
	DQUOT          = 19, 
	// File exists.
	EXIST          = 20, 
	// Bad address.
	FAULT          = 21, 
	// File too large.
	FBIG           = 22, 
	// Host is unreachable.
	HOSTUNREACH    = 23, 
	// Identifier removed.
	IDRM           = 24, 
	// Illegal byte sequence.
	ILSEQ          = 25, 
	// Operation in progress.
	INPROGRESS     = 26, 
	// Interrupted function.
	INTR           = 27, 
	// Invalid argument.
	INVAL          = 28, 
	// I/O error.
	IO             = 29, 
	// Socket is connected.
	ISCONN         = 30, 
	// Is a directory.
	ISDIR          = 31, 
	// Too many levels of symbolic links.
	LOOP           = 32, 
	// File descriptor value too large.
	MFILE          = 33, 
	// Too many links.
	MLINK          = 34, 
	// Message too large.
	MSGSIZE        = 35, 
	// Reserved.
	MULTIHOP       = 36, 
	// Filename too long.
	NAMETOOLONG    = 37, 
	// Network is down.
	NETDOWN        = 38, 
	// Connection aborted by network.
	NETRESET       = 39, 
	// Network unreachable.
	NETUNREACH     = 40, 
	// Too many files open in system.
	NFILE          = 41, 
	// No buffer space available.
	NOBUFS         = 42, 
	// No such device.
	NODEV          = 43, 
	// No such file or directory.
	NOENT          = 44, 
	// Executable file format error.
	NOEXEC         = 45, 
	// No locks available.
	NOLCK          = 46, 
	// Reserved.
	NOLINK         = 47, 
	// Not enough space.
	NOMEM          = 48, 
	// No message of the desired type.
	NOMSG          = 49, 
	// Protocol not available.
	NOPROTOOPT     = 50, 
	// No space left on device.
	NOSPC          = 51, 
	// Function not supported.
	NOSYS          = 52, 
	// The socket is not connected.
	NOTCONN        = 53, 
	// Not a directory or a symbolic link to a directory.
	NOTDIR         = 54, 
	// Directory not empty.
	NOTEMPTY       = 55, 
	// State not recoverable.
	NOTRECOVERABLE = 56, 
	// Not a socket.
	NOTSOCK        = 57, 
	// Not supported, or operation not supported on socket.
	NOTSUP         = 58, 
	// Inappropriate I/O control operation.
	NOTTY          = 59, 
	// No such device or address.
	NXIO           = 60, 
	// Value too large to be stored in data type.
	OVERFLOW       = 61, 
	// Previous owner died.
	OWNERDEAD      = 62, 
	// Operation not permitted.
	PERM           = 63, 
	// Broken pipe.
	PIPE           = 64, 
	// Protocol error.
	PROTO          = 65, 
	// Protocol not supported.
	PROTONOSUPPORT = 66, 
	// Protocol wrong type for socket.
	PROTOTYPE      = 67, 
	// Result too large.
	RANGE          = 68, 
	// Read-only file system.
	ROFS           = 69, 
	// Invalid seek.
	SPIPE          = 70, 
	// No such process.
	SRCH           = 71, 
	// Reserved.
	STALE          = 72, 
	// Connection timed out.
	TIMEDOUT       = 73, 
	// Text file busy.
	TXTBSY         = 74, 
	// Cross-device link.
	XDEV           = 75, 
	// Extension: Capabilities insufficient.
	NOTCAPABLE     = 76, 
}

event_fd_readwrite_t :: struct {
	// *
	// 	 * The number of bytes available for reading or writing.
	nbytes: filesize_t,
	// *
	// 	 * The state of the file descriptor.
	flags:  eventrwflags_t,
}

event_t :: struct {
	// *
	// 	 * User-provided value that got attached to `subscription::userdata`.
	userdata:     userdata_t,
	// *
	// 	 * If non-zero, an error that occurred while processing the subscription request.
	error:        errno_t,
	// *
	// 	 * The type of event that occured
	type:         eventtype_t,
	// *
	// 	 * The contents of the event, if it is an `eventtype::fd_read` or
	// 	 * `eventtype::fd_write`. `eventtype::clock` events ignore this field.
	fd_readwrite: event_fd_readwrite_t,
}

eventrwflag_t :: enum u16 {
	// *
	// 	 * The peer of this socket has closed or disconnected.
	FD_READWRITE_HANGUP = 0, 
}

eventrwflags_t :: distinct bit_set[eventrwflag_t; u16]

eventtype_t :: enum u8 {
	// *
	// 	 * The time value of clock `subscription_clock::id` has
	// 	 * reached timestamp `subscription_clock::timeout`.
	CLOCK    = 0, 
	// *
	// 	 * File descriptor `subscription_fd_readwrite::file_descriptor` has data
	// 	 * available for reading. This event always triggers for regular files.
	FD_READ  = 1, 
	// *
	// 	 * File descriptor `subscription_fd_readwrite::file_descriptor` has capacity
	// 	 * available for writing. This event always triggers for regular files.
	FD_WRITE = 2, 
}

exitcode_t :: distinct u32

fd_t :: distinct i32

fdflag_t :: enum u16 {
	// *
	// 	 * Append mode: Data written to the file is always appended to the file's end.
	APPEND   = 0, 
	// *
	// 	 * Write according to synchronized I/O data integrity completion. Only the data stored in the file is synchronized.
	DSYNC    = 1, 
	// *
	// 	 * Non-blocking mode.
	NONBLOCK = 2, 
	// *
	// 	 * Synchronized read I/O operations.
	RSYNC    = 3, 
	// *
	// 	 * Write according to synchronized I/O file integrity completion. In
	// 	 * addition to synchronizing the data stored in the file, the implementation
	// 	 * may also synchronously update the file's metadata.
	SYNC     = 4, 
}

fdflags_t :: distinct bit_set[fdflag_t; u16]

fdstat_t :: struct {
	// *
	// 	 * File type.
	fs_filetype:          filetype_t,
	// *
	// 	 * File descriptor flags.
	fs_flags:             fdflags_t,
	// *
	// 	 * Rights that apply to this file descriptor.
	fs_rights_base:       rights_t,
	// *
	// 	 * Maximum set of rights that may be installed on new file descriptors that
	// 	 * are created through this file descriptor, e.g., through `path_open`.
	fs_rights_inheriting: rights_t,
}

filedelta_t :: distinct i64

filesize_t :: distinct u64

filestat_t :: struct {
	// *
	// 	 * Device ID of device containing the file.
	dev:      device_t,
	// *
	// 	 * File serial number.
	ino:      inode_t,
	// *
	// 	 * File type.
	filetype: filetype_t,
	// *
	// 	 * Number of hard links to the file.
	nlink:    linkcount_t,
	// *
	// 	 * For regular files, the file size in bytes. For symbolic links, the length in bytes of the pathname contained in the symbolic link.
	size:     filesize_t,
	// *
	// 	 * Last data access timestamp.
	atim:     timestamp_t,
	// *
	// 	 * Last data modification timestamp.
	mtim:     timestamp_t,
	// *
	// 	 * Last file status change timestamp.
	ctim:     timestamp_t,
}

filetype_t :: enum u8 {
	// *
	// 	 * The type of the file descriptor or file is unknown or is different from any of the other types specified.
	UNKNOWN          = 0, 
	// *
	// 	 * The file descriptor or file refers to a block device inode.
	BLOCK_DEVICE     = 1, 
	// *
	// 	 * The file descriptor or file refers to a character device inode.
	CHARACTER_DEVICE = 2, 
	// *
	// 	 * The file descriptor or file refers to a directory inode.
	DIRECTORY        = 3, 
	// *
	// 	 * The file descriptor or file refers to a regular file inode.
	REGULAR_FILE     = 4, 
	// *
	// 	 * The file descriptor or file refers to a datagram socket.
	SOCKET_DGRAM     = 5, 
	// *
	// 	 * The file descriptor or file refers to a byte-stream socket.
	SOCKET_STREAM    = 6, 
	// *
	// 	 * The file refers to a symbolic link inode.
	SYMBOLIC_LINK    = 7, 
}

fstflag_t :: enum u16 {
	// *
	// 	 * Adjust the last data access timestamp to the value stored in `filestat::atim`.
	ATIM     = 0, 
	// *
	// 	 * Adjust the last data access timestamp to the time of clock `clockid::realtime`.
	ATIM_NOW = 1, 
	// *
	// 	 * Adjust the last data modification timestamp to the value stored in `filestat::mtim`.
	MTIM     = 2, 
	// *
	// 	 * Adjust the last data modification timestamp to the time of clock `clockid::realtime`.
	MTIM_NOW = 3, 
}

fstflags_t :: distinct bit_set[fstflag_t; u16]

inode_t :: distinct u64

iovec_t :: []u8

linkcount_t :: distinct u64

lookupflag_t :: enum u32 {
	// *
	// 	 * As long as the resolved path corresponds to a symbolic link, it is expanded.
	SYMLINK_FOLLOW = 0, 
}

lookupflags_t :: distinct bit_set[lookupflag_t; u32]

oflag_t :: enum u16 {
	// *
	// 	 * Create file if it does not exist.
	CREATE    = 0, 
	// *
	// 	 * Fail if not a directory.
	DIRECTORY = 1, 
	// *
	// 	 * Fail if file already exists.
	EXCL      = 2, 
	// *
	// 	 * Truncate file to size 0.
	TRUNC     = 3, 
}

oflags_t :: distinct bit_set[oflag_t; u16]

preopentype_t :: enum u8 {
	DIR = 0, 
}

prestat_dir_t :: struct {
	pr_name_len: uint,
}

prestat_t :: struct {
	tag: preopentype_t,
	using u: struct {
		dir: prestat_dir_t,
	},
}

riflag_t :: enum u16 {
	// *
	// 	 * Returns the message without removing it from the socket's receive queue.
	RECV_PEEK    = 0, 
	// *
	// 	 * On byte-stream sockets, block until the full amount of data can be returned.
	RECV_WAITALL = 1, 
}

riflags_t :: distinct bit_set[riflag_t; u16]

rights_flag_t :: enum u64 {
	// *
	// 	 * The right to invoke `fd_datasync`.
	// 	 * If `path_open` is set, includes the right to invoke
	// 	 * `path_open` with `fdflags::dsync`.
	FD_DATASYNC             = 0, 
	// *
	// 	 * The right to invoke `fd_read` and `sock_recv`.
	// 	 * If `rights::fd_seek` is set, includes the right to invoke `fd_pread`.
	FD_READ                 = 1, 
	// *
	// 	 * The right to invoke `fd_seek`. This flag implies `rights::fd_tell`.
	FD_SEEK                 = 2, 
	// *
	// 	 * The right to invoke `fd_fdstat_set_flags`.
	FD_FDSTAT_SET_FLAGS     = 3, 
	// *
	// 	 * The right to invoke `fd_sync`.
	// 	 * If `path_open` is set, includes the right to invoke
	// 	 * `path_open` with `fdflags::rsync` and `fdflags::dsync`.
	FD_SYNC                 = 4, 
	// *
	// 	 * The right to invoke `fd_seek` in such a way that the file offset
	// 	 * remains unaltered (i.e., `whence::cur` with offset zero), or to
	// 	 * invoke `fd_tell`.
	FD_TELL                 = 5, 
	// *
	// 	 * The right to invoke `fd_write` and `sock_send`.
	// 	 * If `rights::fd_seek` is set, includes the right to invoke `fd_pwrite`.
	FD_WRITE                = 6, 
	// *
	// 	 * The right to invoke `fd_advise`.
	FD_ADVISE               = 7, 
	// *
	// 	 * The right to invoke `fd_allocate`.
	FD_ALLOCATE             = 8, 
	// *
	// 	 * The right to invoke `path_create_directory`.
	PATH_CREATE_DIRECTORY   = 9, 
	// *
	// 	 * If `path_open` is set, the right to invoke `path_open` with `oflags::creat`.
	PATH_CREATE_FILE        = 10, 
	// *
	// 	 * The right to invoke `path_link` with the file descriptor as the
	// 	 * source directory.
	PATH_LINK_SOURCE        = 11, 
	// *
	// 	 * The right to invoke `path_link` with the file descriptor as the
	// 	 * target directory.
	PATH_LINK_TARGET        = 12, 
	// *
	// 	 * The right to invoke `path_open`.
	PATH_OPEN               = 13, 
	// *
	// 	 * The right to invoke `fd_readdir`.
	FD_READDIR              = 14, 
	// *
	// 	 * The right to invoke `path_readlink`.
	PATH_READLINK           = 15, 
	// *
	// 	 * The right to invoke `path_rename` with the file descriptor as the source directory.
	PATH_RENAME_SOURCE      = 16, 
	// *
	// 	 * The right to invoke `path_rename` with the file descriptor as the target directory.
	PATH_RENAME_TARGET      = 17, 
	// *
	// 	 * The right to invoke `path_filestat_get`.
	PATH_FILESTAT_GET       = 18, 
	// *
	// 	 * The right to change a file's size (there is no `path_filestat_set_size`).
	// 	 * If `path_open` is set, includes the right to invoke `path_open` with `oflags::trunc`.
	PATH_FILESTAT_SET_SIZE  = 19, 
	// *
	// 	 * The right to invoke `path_filestat_set_times`.
	PATH_FILESTAT_SET_TIMES = 20, 
	// *
	// 	 * The right to invoke `fd_filestat_get`.
	FD_FILESTAT_GET         = 21, 
	// *
	// 	 * The right to invoke `fd_filestat_set_size`.
	FD_FILESTAT_SET_SIZE    = 22, 
	// *
	// 	 * The right to invoke `fd_filestat_set_times`.
	FD_FILESTAT_SET_TIMES   = 23, 
	// *
	// 	 * The right to invoke `path_symlink`.
	PATH_SYMLINK            = 24, 
	// *
	// 	 * The right to invoke `path_remove_directory`.
	PATH_REMOVE_DIRECTORY   = 25, 
	// *
	// 	 * The right to invoke `path_unlink_file`.
	PATH_UNLINK_FILE        = 26, 
	// *
	// 	 * If `rights::fd_read` is set, includes the right to invoke `poll_oneoff` to subscribe to `eventtype::fd_read`.
	// 	 * If `rights::fd_write` is set, includes the right to invoke `poll_oneoff` to subscribe to `eventtype::fd_write`.
	POLL_FD_READWRITE       = 27, 
	// *
	// 	 * The right to invoke `sock_shutdown`.
	SOCK_SHUTDOWN           = 28, 
}

rights_t :: distinct bit_set[rights_flag_t; u64]

roflag_t :: enum u16 {
	// *
	// 	 * Returned by `sock_recv`: Message data has been truncated.
	RECV_DATA_TRUNCATED = 0, 
}

roflags_t :: distinct bit_set[roflag_t; u16]

sdflag_t :: enum u8 {
	// *
	// 	 * Disables further receive operations.
	RD = 0, 
	// *
	// 	 * Disables further send operations.
	WR = 1, 
}

sdflags_t :: distinct bit_set[sdflag_t; u8]

siflag_t :: enum u16 {
}

siflags_t :: distinct bit_set[siflag_t; u16]

signal_t :: enum u8 {
	// *
	// 	 * No signal. Note that POSIX has special semantics for `kill(pid, 0)`,
	// 	 * so this value is reserved.
	NONE   = 0, 
	// *
	// 	 * Hangup.
	// 	 * Action: Terminates the process.
	HUP    = 1, 
	// *
	// 	 * Terminate interrupt signal.
	// 	 * Action: Terminates the process.
	INT    = 2, 
	// *
	// 	 * Terminal quit signal.
	// 	 * Action: Terminates the process.
	QUIT   = 3, 
	// *
	// 	 * Illegal instruction.
	// 	 * Action: Terminates the process.
	ILL    = 4, 
	// *
	// 	 * Trace/breakpoint trap.
	// 	 * Action: Terminates the process.
	TRAP   = 5, 
	// *
	// 	 * Process abort signal.
	// 	 * Action: Terminates the process.
	ABRT   = 6, 
	// *
	// 	 * Access to an undefined portion of a memory object.
	// 	 * Action: Terminates the process.
	BUS    = 7, 
	// *
	// 	 * Erroneous arithmetic operation.
	// 	 * Action: Terminates the process.
	FPE    = 8, 
	// *
	// 	 * Kill.
	// 	 * Action: Terminates the process.
	KILL   = 9, 
	// *
	// 	 * User-defined signal 1.
	// 	 * Action: Terminates the process.
	USR1   = 10, 
	// *
	// 	 * Invalid memory reference.
	// 	 * Action: Terminates the process.
	SEGV   = 11, 
	// *
	// 	 * User-defined signal 2.
	// 	 * Action: Terminates the process.
	USR2   = 12, 
	// *
	// 	 * Write on a pipe with no one to read it.
	// 	 * Action: Ignored.
	PIPE   = 13, 
	// *
	// 	 * Alarm clock.
	// 	 * Action: Terminates the process.
	ALRM   = 14, 
	// *
	// 	 * Termination signal.
	// 	 * Action: Terminates the process.
	TERM   = 15, 
	// *
	// 	 * Child process terminated, stopped, or continued.
	// 	 * Action: Ignored.
	CHLD   = 16, 
	// *
	// 	 * Continue executing, if stopped.
	// 	 * Action: Continues executing, if stopped.
	CONT   = 17, 
	// *
	// 	 * Stop executing.
	// 	 * Action: Stops executing.
	STOP   = 18, 
	// *
	// 	 * Terminal stop signal.
	// 	 * Action: Stops executing.
	TSTP   = 19, 
	// *
	// 	 * Background process attempting read.
	// 	 * Action: Stops executing.
	TTIN   = 20, 
	// *
	// 	 * Background process attempting write.
	// 	 * Action: Stops executing.
	TTOU   = 21, 
	// *
	// 	 * High bandwidth data is available at a socket.
	// 	 * Action: Ignored.
	URG    = 22, 
	// *
	// 	 * CPU time limit exceeded.
	// 	 * Action: Terminates the process.
	XCPU   = 23, 
	// *
	// 	 * File size limit exceeded.
	// 	 * Action: Terminates the process.
	XFSZ   = 24, 
	// *
	// 	 * Virtual timer expired.
	// 	 * Action: Terminates the process.
	VTALRM = 25, 
	// *
	// 	 * Profiling timer expired.
	// 	 * Action: Terminates the process.
	PROF   = 26, 
	// *
	// 	 * Window changed.
	// 	 * Action: Ignored.
	WINCH  = 27, 
	// *
	// 	 * I/O possible.
	// 	 * Action: Terminates the process.
	POLL   = 28, 
	// *
	// 	 * Power failure.
	// 	 * Action: Terminates the process.
	PWR    = 29, 
	// *
	// 	 * Bad system call.
	// 	 * Action: Terminates the process.
	SYS    = 30, 
}

size_t :: uint

subclockflag_t :: enum u16 {
	// *
	// 	 * If set, treat the timestamp provided in
	// 	 * `subscription_clock::timeout` as an absolute timestamp of clock
	// 	 * `subscription_clock::id`. If clear, treat the timestamp
	// 	 * provided in `subscription_clock::timeout` relative to the
	// 	 * current time value of clock `subscription_clock::id`.
	SUBSCRIPTION_CLOCK_ABSTIME = 0, 
}

subclockflags_t :: distinct bit_set[subclockflag_t; u16]

subscription_clock_t :: struct {
	// *
	// 	 * The clock against which to compare the timestamp.
	id:        clockid_t,
	// *
	// 	 * The absolute or relative timestamp.
	timeout:   timestamp_t,
	// *
	// 	 * The amount of time that the implementation may wait additionally
	// 	 * to coalesce with other events.
	precision: timestamp_t,
	// *
	// 	 * Flags specifying whether the timeout is absolute or relative
	flags:     subclockflags_t,
}

subscription_fd_readwrite_t :: struct {
	// *
	// 	 * The file descriptor on which to wait for it to become ready for reading or writing.
	file_descriptor: fd_t,
}

subscription_t :: struct {
	// *
	// 	 * User-provided value that is attached to the subscription in the
	// 	 * implementation and returned through `event::userdata`.
	userdata: userdata_t,
	// *
	// 	 * The type of the event to which to subscribe, and its contents
	using contents: struct {
		tag: eventtype_t,
		using u: struct #raw_union {
			clock:    subscription_clock_t,
			fd_read:  subscription_fd_readwrite_t,
			fd_write: subscription_fd_readwrite_t,
		},
	},
}

timestamp_t :: distinct u64

userdata_t :: distinct u64

whence_t :: enum u8 {
	SET = 0, 
	CUR = 1, 
	END = 2, 
}

CLOCK_MONOTONIC :: clockid_t(1)

CLOCK_PROCESS_CPUTIME_ID :: clockid_t(2)

CLOCK_REALTIME :: clockid_t(0)

CLOCK_THREAD_CPUTIME_ID :: clockid_t(3)

DIRCOOKIE_START :: u64(0)

args_get :: proc "contextless" (argv: [^]cstring, argv_buf: [^]u8) -> errno_t ---

args_sizes_get :: proc "contextless" () -> (num_args, size_of_args: uint, err: errno_t) {…}

clock_res_get :: proc "contextless" (id: clockid_t) -> (ts: timestamp_t, err: errno_t) {…}

clock_time_get :: proc "contextless" (id: clockid_t, precision: timestamp_t) -> (ts: timestamp_t, err: errno_t) {…}

environ_get :: proc "contextless" (environ: [^]cstring, environ_buf: [^]u8) -> errno_t ---

environ_sizes_get :: proc "contextless" () -> (num_envs, size_of_envs: uint, err: errno_t) {…}

fd_advise :: proc "contextless" (fd: fd_t, offset: filesize_t, len: filesize_t, advice: advice_t) -> errno_t ---

fd_allocate :: proc "contextless" (fd: fd_t, offset: filesize_t, len: filesize_t) -> errno_t ---

fd_close :: proc "contextless" (fd: fd_t) -> errno_t ---

fd_datasync :: proc "contextless" (fd: fd_t) -> errno_t ---

fd_fdstat_get :: proc "contextless" (fd: fd_t) -> (stat: fdstat_t, err: errno_t) {…}

fd_fdstat_set_flags :: proc "contextless" (fd: fd_t, flags: fdflags_t) -> errno_t ---

fd_fdstat_set_rights :: proc "contextless" (fd: fd_t, fs_rights_base: rights_t, fs_rights_inheritin: rights_t) -> errno_t ---

fd_filestat_get :: proc "contextless" (fd: fd_t) -> (stat: filestat_t, err: errno_t) {…}

fd_filestat_set_size :: proc "contextless" (fd: fd_t, size: filesize_t) -> errno_t ---

fd_filestat_set_times :: proc "contextless" (fd: fd_t, atim: timestamp_t, mtim: timestamp_t, fst_flags: fstflags_t) -> errno_t ---

fd_pread :: proc "contextless" (fd: fd_t, iovs: [][]u8, offset: filesize_t) -> (n: uint, err: errno_t) {…}

fd_prestat_dir_name :: proc "contextless" (fd: fd_t, path: []u8) -> errno_t ---

fd_prestat_get :: proc "contextless" (fd: fd_t) -> (desc: prestat_t, err: errno_t) {…}

fd_pwrite :: proc "contextless" (fd: fd_t, iovs: [][]u8, offset: filesize_t) -> (n: uint, err: errno_t) {…}

fd_read :: proc "contextless" (fd: fd_t, iovs: [][]u8) -> (n: uint, err: errno_t) {…}

fd_readdir :: proc "contextless" (fd: fd_t, buf: []u8, cookie: dircookie_t) -> (n: uint, err: errno_t) {…}

fd_renumber :: proc "contextless" (fd: fd_t, to: fd_t) -> errno_t ---

fd_seek :: proc "contextless" (fd: fd_t, offset: filedelta_t, whence: whence_t) -> (new_offset: filesize_t, err: errno_t) {…}

fd_sync :: proc "contextless" (f: fd_t) -> errno_t ---

fd_tell :: proc "contextless" (fd: fd_t) -> (offset: filesize_t, err: errno_t) {…}

fd_write :: proc "contextless" (fd: fd_t, iovs: [][]u8) -> (n: uint, err: errno_t) {…}

path_create_directory :: proc "contextless" (fd: fd_t, path: string) -> errno_t ---

path_filestat_get :: proc "contextless" (fd: fd_t, flags: lookupflags_t, path: string) -> (offset: filestat_t, err: errno_t) {…}

path_filestat_set_times :: proc "contextless" (
	fd:        fd_t, 
	flags:     lookupflags_t, 
	path:      string, 
	atim:      timestamp_t, 
	mtim:      timestamp_t, 
	fst_flags: fstflags_t, 
) -> errno_t ---

path_link :: proc "contextless" (old_fd: fd_t, old_flags: lookupflags_t, old_path: string, new_fd: fd_t, new_path: string) -> errno_t ---

path_open :: proc "contextless" (
	fd:                   fd_t, 
	dirflags:             lookupflags_t, 
	path:                 string, 
	oflags:               oflags_t, 
	fs_rights_base:       rights_t, 
	fs_rights_inheriting: rights_t, 
	fdflags:              fdflags_t, 
) -> (file: fd_t, err: errno_t) {…}

path_readlink :: proc "contextless" (fd: fd_t, path: string, buf: []u8) -> (n: uint, err: errno_t) {…}

path_remove_directory :: proc "contextless" (fd: fd_t, path: string) -> errno_t ---

path_rename :: proc "contextless" (fd: fd_t, old_path: string, new_fd: fd_t, new_path: string) -> errno_t ---

path_symlink :: proc "contextless" (old_path: string, fd: fd_t, new_path: string) -> errno_t ---

path_unlink_file :: proc "contextless" (fd: fd_t, path: string) -> errno_t ---

poll_oneoff :: proc "contextless" (subscription_in: ^subscription_t, event_out: ^event_t, nsubscriptions: uint) -> (n: uint, err: errno_t) {…}

proc_exit :: proc "contextless" (rval: exitcode_t) -> ! ---

proc_raise :: proc "contextless" (sig: signal_t) -> errno_t ---

random_get :: proc "contextless" (buf: []u8) -> errno_t ---

sched_yield :: proc "contextless" () -> errno_t ---

sock_recv :: proc "contextless" (fd: fd_t, ri_data: [][]u8, ri_flags: riflags_t) -> (n: uint, flags: roflags_t, err: errno_t) {…}

sock_send :: proc "contextless" (fd: fd_t, si_data: [][]u8, si_flags: siflags_t) -> (n: uint, err: errno_t) {…}

sock_shutdown :: proc "contextless" (fd: fd_t, how: sdflags_t) -> errno_t ---

wasi_args_sizes_get :: proc "contextless" (retptr0: ^uint, retptr1: ^uint) -> errno_t ---

wasi_clock_res_get :: proc "contextless" (id: clockid_t, retptr0: ^timestamp_t) -> errno_t ---

wasi_clock_time_get :: proc "contextless" (id: clockid_t, precision: timestamp_t, retptr0: ^timestamp_t) -> errno_t ---

wasi_environ_sizes_get :: proc "contextless" (retptr0: ^uint, retptr1: ^uint) -> errno_t ---

wasi_fd_fdstat_get :: proc "contextless" (fd: fd_t, retptr0: ^fdstat_t) -> errno_t ---

wasi_fd_filestat_get :: proc "contextless" (fd: fd_t, retptr0: ^filestat_t) -> errno_t ---

wasi_fd_pread :: proc "contextless" (fd: fd_t, iovs: [][]u8, offset: filesize_t, retptr0: ^uint) -> errno_t ---

wasi_fd_prestat_get :: proc "contextless" (fd: fd_t, retptr0: ^prestat_t) -> errno_t ---

wasi_fd_pwrite :: proc "contextless" (fd: fd_t, iovs: [][]u8, offset: filesize_t, retptr0: ^uint) -> errno_t ---

wasi_fd_read :: proc "contextless" (fd: fd_t, iovs: [][]u8, retptr0: ^uint) -> errno_t ---

wasi_fd_readdir :: proc "contextless" (fd: fd_t, buf: []u8, cookie: dircookie_t, retptr0: ^uint) -> errno_t ---

wasi_fd_seek :: proc "contextless" (fd: fd_t, offset: filedelta_t, whence: whence_t, retptr0: ^filesize_t) -> errno_t ---

wasi_fd_tell :: proc "contextless" (fd: fd_t, retptr0: ^filesize_t) -> errno_t ---

wasi_fd_write :: proc "contextless" (fd: fd_t, iovs: [][]u8, retptr0: ^uint) -> errno_t ---

wasi_path_filestat_get :: proc "contextless" (fd: fd_t, flags: lookupflags_t, path: string, retptr0: ^filestat_t) -> errno_t ---

wasi_path_open :: proc "contextless" (
	fd:                   fd_t, 
	dirflags:             lookupflags_t, 
	path:                 string, 
	oflags:               oflags_t, 
	fs_rights_base:       rights_t, 
	fs_rights_inheriting: rights_t, 
	fdflags:              fdflags_t, 
	retptr:               ^fd_t, 
) -> errno_t ---

wasi_path_readlink :: proc "contextless" (fd: fd_t, path: string, buf: []u8, retptr0: ^uint) -> errno_t ---

wasi_poll_oneoff :: proc "contextless" (subscription_in: ^subscription_t, event_out: ^event_t, nsubscriptions: uint, retptr0: ^uint) -> errno_t ---

wasi_sock_recv :: proc "contextless" (fd: fd_t, ri_data: [][]u8, ri_flags: riflags_t, retptr0: ^uint, retptr1: ^roflags_t) -> errno_t ---

wasi_sock_send :: proc "contextless" (fd: fd_t, si_data: [][]u8, si_flags: siflags_t, retptr0: ^uint) -> errno_t ---