@grain/stdlib 0.5.13 → 0.6.1

package/{sys → wasi}/file.gr

@@ -1,56 +1,60 @@
 /**
- * @module File: Utilities for accessing the filesystem & working with files.
+ * Utilities for accessing the filesystem & working with files.
  *
  * Many of the functions in this module are not intended to be used directly, but rather for other libraries to be built on top of them.
  *
- * @example import File from "sys/file"
+ * @example from "wasi/file" include File
  */
-
-import WasmI32, {
-  add as (+),
-  sub as (-),
-  mul as (*),
-  shl as (<<),
-  shrS as (>>),
-  shrU as (>>>),
-  eq as (==),
-  ne as (!=),
-  ltS as (<),
-  leS as (<=),
-  gtS as (>),
-  geS as (>=),
-  and as (&),
-  or as (|),
-} from "runtime/unsafe/wasmi32"
-import WasmI64 from "runtime/unsafe/wasmi64"
-import Wasi from "runtime/wasi"
-import Memory from "runtime/unsafe/memory"
-import {
+module File
+
+from "runtime/unsafe/wasmi32" include WasmI32
+use WasmI32.{
+  (+),
+  (-),
+  (*),
+  (<<),
+  (>>),
+  (>>>),
+  (==),
+  (!=),
+  (<),
+  (<=),
+  (>),
+  (>=),
+  (&),
+  (|),
+}
+from "runtime/unsafe/wasmi64" include WasmI64
+from "runtime/wasi" include Wasi
+from "runtime/unsafe/memory" include Memory
+from "runtime/dataStructures" include DataStructures
+use DataStructures.{
   tagSimpleNumber,
+  untagSimpleNumber,
   allocateArray,
+  allocateBytes,
   allocateString,
+  newInt32,
   newInt64,
   allocateInt64,
-} from "runtime/dataStructures"
-
-import List from "list"
+}
 
-/**
- * @section Types: Type declarations included in the File module.
- */
+from "list" include List
 
 /**
  * Represents a handle to an open file on the system.
  */
-export enum FileDescriptor {
+provide enum FileDescriptor {
   FileDescriptor(Number),
 }
 
 /**
  * Flags that determine how paths should be resolved when looking up a file or directory.
  */
-export enum LookupFlag {
-  // Follow symlinks
+provide enum LookupFlag {
+  /**
+   * Follow symlinks
+   */
   SymlinkFollow,
 }
 
@@ -75,14 +79,22 @@ let combineLookupFlags = dirflags => {
 /**
  * Flags that determine how a file or directory should be opened.
  */
-export enum OpenFlag {
-  // Create file if it does not exist.
+provide enum OpenFlag {
+  /**
+   * Create file if it does not exist.
+   */
   Create,
-  // Fail if not a directory.
+  /**
+   * Fail if not a directory.
+   */
   Directory,
-  // Fail if file already exists.
+  /**
+   * Fail if file already exists.
+   */
   Exclusive,
-  // Truncate file to size 0.
+  /**
+   * Truncate file to size 0.
+   */
   Truncate,
 }
 
@@ -111,76 +123,134 @@ let combineOpenFlags = dirflags => {
  * Flags that determine which rights a `FileDescriptor` should have
  * and which rights new `FileDescriptor`s should inherit from it.
  */
-export enum Rights {
-  // The right to invoke `fdDatasync`.
-  // If `PathOpen` is set, includes the right to invoke
-  // `pathOpen` with `FdFlag::Dsync`.
+provide enum Rights {
+  /**
+   * The right to invoke `fdDatasync`.
+   * If `PathOpen` is set, includes the right to invoke
+   * `pathOpen` with `FdFlag::Dsync`.
+   */
   FdDatasync,
-  // The right to invoke `fdRead`.
-  // If `Rights::FdSeek` is set, includes the right to invoke `fdPread`.
+  /**
+   * The right to invoke `fdRead`.
+   * If `Rights::FdSeek` is set, includes the right to invoke `fdPread`.
+   */
   FdRead,
-  // The right to invoke `fdSeek`. This flag implies `Rights::FdTell`.
+  /**
+   * The right to invoke `fdSeek`. This flag implies `Rights::FdTell`.
+   */
   FdSeek,
-  // The right to invoke `fdSetFlags`.
+  /**
+   * The right to invoke `fdSetFlags`.
+   */
   FdSetFlags,
-  // The right to invoke `fdSync`.
-  // If `PathOpen` is set, includes the right to invoke
-  // `pathOpen` with `FdFlag::Rsync` and `FdFlag::Dsync`.
+  /**
+   * The right to invoke `fdSync`.
+   * If `PathOpen` is set, includes the right to invoke
+   * `pathOpen` with `FdFlag::Rsync` and `FdFlag::Dsync`.
+   */
   FdSync,
-  // The right to invoke `fdSeek` in such a way that the file offset
-  // remains unaltered (i.e., `Whence::Current` with offset zero), or to
-  // invoke `fdTell`.
+  /**
+   * The right to invoke `fdSeek` in such a way that the file offset
+   * remains unaltered (i.e., `Whence::Current` with offset zero), or to
+   * invoke `fdTell`.
+   */
   FdTell,
-  // The right to invoke `fdWrite`.
-  // If `Rights::FdSeek` is set, includes the right to invoke `fdPwrite`.
+  /**
+   * The right to invoke `fdWrite`.
+   * If `Rights::FdSeek` is set, includes the right to invoke `fdPwrite`.
+   */
   FdWrite,
-  // The right to invoke `fdAdvise`.
+  /**
+   * The right to invoke `fdAdvise`.
+   */
   FdAdvise,
-  // The right to invoke `fdAllocate`.
+  /**
+   * The right to invoke `fdAllocate`.
+   */
   FdAllocate,
-  // The right to invoke `pathCreateDirectory`.
+  /**
+   * The right to invoke `pathCreateDirectory`.
+   */
   PathCreateDirectory,
-  // If `PathOpen` is set, the right to invoke `pathOpen` with `OpenFlag::Create`.
+  /**
+   * If `PathOpen` is set, the right to invoke `pathOpen` with `OpenFlag::Create`.
+   */
   PathCreateFile,
-  // The right to invoke `pathLink` with the file descriptor as the
-  // source directory.
+  /**
+   * The right to invoke `pathLink` with the file descriptor as the
+   * source directory.
+   */
   PathLinkSource,
-  // The right to invoke `pathLink` with the file descriptor as the
-  // target directory.
+  /**
+   * The right to invoke `pathLink` with the file descriptor as the
+   * target directory.
+   */
   PathLinkTarget,
-  // The right to invoke `pathOpen`.
+  /**
+   * The right to invoke `pathOpen`.
+   */
   PathOpen,
-  // The right to invoke `fdReaddir`.
+  /**
+   * The right to invoke `fdReaddir`.
+   */
   FdReaddir,
-  // The right to invoke `pathReadlink`.
+  /**
+   * The right to invoke `pathReadlink`.
+   */
   PathReadlink,
-  // The right to invoke `pathRename` with the file descriptor as the source directory.
+  /**
+   * The right to invoke `pathRename` with the file descriptor as the source directory.
+   */
   PathRenameSource,
-  // The right to invoke `pathRename` with the file descriptor as the target directory.
+  /**
+   * The right to invoke `pathRename` with the file descriptor as the target directory.
+   */
   PathRenameTarget,
-  // The right to invoke `pathFilestats`.
+  /**
+   * The right to invoke `pathFilestats`.
+   */
   PathFilestats,
-  // The right to change a file's size (there's no `pathSetSize`).
-  // If `PathOpen` is set, includes the right to invoke `pathOpen` with `OpenFlag::Truncate`.
+  /**
+   * The right to change a file's size (there's no `pathSetSize`).
+   * If `PathOpen` is set, includes the right to invoke `pathOpen` with `OpenFlag::Truncate`.
+   */
   PathSetSize,
-  // The right to invoke `pathSetAccessTime`, `pathSetAccessTimeNow`, `pathSetModifiedTime`, or `pathSetModifiedTimeNow`.
+  /**
+   * The right to invoke `pathSetAccessTime`, `pathSetAccessTimeNow`, `pathSetModifiedTime`, or `pathSetModifiedTimeNow`.
+   */
   PathSetTimes,
-  // The right to invoke `fdFilestats`.
+  /**
+   * The right to invoke `fdFilestats`.
+   */
   FdFilestats,
-  // The right to invoke `fdSetSize`.
+  /**
+   * The right to invoke `fdSetSize`.
+   */
   FdSetSize,
-  // The right to invoke `fdSetAccessTime`, `fdSetAccessTimeNow`, `fdSetModifiedTime`, or `fdSetModifiedTimeNow`.
+  /**
+   * The right to invoke `fdSetAccessTime`, `fdSetAccessTimeNow`, `fdSetModifiedTime`, or `fdSetModifiedTimeNow`.
+   */
   FdSetTimes,
-  // The right to invoke `pathSymlink`.
+  /**
+   * The right to invoke `pathSymlink`.
+   */
   PathSymlink,
-  // The right to invoke `pathRemoveDirectory`.
+  /**
+   * The right to invoke `pathRemoveDirectory`.
+   */
   PathRemoveDirectory,
-  // The right to invoke `pathUnlinkFile`.
+  /**
+   * The right to invoke `pathUnlinkFile`.
+   */
   PathUnlinkFile,
-  // If `Rights::FdRead` is set, includes the right to invoke `pollOneoff` (not yet implemented) to subscribe to `EventType::FdRead`.
-  // If `Rights::FdWrite` is set, includes the right to invoke `pollOneoff` (not yet implemented) to subscribe to `EventType::FdWrite`.
+  /**
+   * If `Rights::FdRead` is set, includes the right to invoke `pollOneoff` (not yet implemented) to subscribe to `EventType::FdRead`.
+   * If `Rights::FdWrite` is set, includes the right to invoke `pollOneoff` (not yet implemented) to subscribe to `EventType::FdWrite`.
+   */
   PollFdReadwrite,
-  // The right to invoke `sockShutdown` (not yet implemented).
+  /**
+   * The right to invoke `sockShutdown` (not yet implemented).
+   */
   SockShutdown,
 }
 
@@ -248,6 +318,7 @@ let _RIGHT_SOCK_SHUTDOWN = 268435456N
 // TODO(#775): This has specific ordering requirements because of ambiguous type inference
 @unsafe
 let rec combineRightsHelp = (acc, dirflags) => {
+  use WasmI64.{ (|) }
   match (dirflags) {
     [] => acc,
     [hd, ...tl] => {
@@ -288,7 +359,7 @@ let rec combineRightsHelp = (acc, dirflags) => {
           0N
         },
       }
-      combineRightsHelp(WasmI64.or(flag, acc), tl)
+      combineRightsHelp(flag | acc, tl)
     },
   }
 }
@@ -300,14 +371,22 @@ let combineRights = dirflags => {
 /**
  * Flags that determine the mode(s) that a `FileDescriptor` operates in.
  */
-export enum FdFlag {
-  // Append mode: Data written to the file is always appended to the file's end.
+provide enum FdFlag {
+  /**
+   * Append mode: Data written to the file is always appended to the file's end.
+   */
   Append,
-  // Write according to synchronized I/O data integrity completion. Only the data stored in the file is synchronized.
+  /**
+   * Write according to synchronized I/O data integrity completion. Only the data stored in the file is synchronized.
+   */
   Dsync,
-  // Non-blocking mode.
+  /**
+   * Non-blocking mode.
+   */
   Nonblock,
-  // Synchronized read I/O operations.
+  /**
+   * Synchronized read I/O operations.
+   */
   Rsync,
   // Write according to synchronized I/O file integrity completion. In
   // addition to synchronizing the data stored in the file, the implementation
@@ -340,22 +419,38 @@ let combineFdFlags = dirflags => {
 /**
  * The type of file a `FileDescriptor` refers to.
  */
-export enum Filetype {
-  // The type of the file descriptor or file is unknown or is different from any of the other types specified.
+provide enum Filetype {
+  /**
+   * The type of the file descriptor or file is unknown or is different from any of the other types specified.
+   */
   Unknown,
-  // The file descriptor or file refers to a block device inode.
+  /**
+   * The file descriptor or file refers to a block device inode.
+   */
   BlockDevice,
-  // The file descriptor or file refers to a character device inode.
+  /**
+   * The file descriptor or file refers to a character device inode.
+   */
   CharacterDevice,
-  // The file descriptor or file refers to a directory inode.
+  /**
+   * The file descriptor or file refers to a directory inode.
+   */
   Directory,
-  // The file descriptor or file refers to a regular file inode.
+  /**
+   * The file descriptor or file refers to a regular file inode.
+   */
   RegularFile,
-  // The file descriptor or file refers to a datagram socket.
+  /**
+   * The file descriptor or file refers to a datagram socket.
+   */
   SocketDatagram,
-  // The file descriptor or file refers to a byte-stream socket.
+  /**
+   * The file descriptor or file refers to a byte-stream socket.
+   */
   SocketStream,
-  // The file refers to a symbolic link inode.
+  /**
+   * The file refers to a symbolic link inode.
+   */
   SymbolicLink,
 }
 
@@ -378,19 +473,25 @@ let filetypeFromNumber = filetype => {
 /**
  * Flags that determine where seeking should begin in a file.
  */
-export enum Whence {
-  // Seek relative to start-of-file.
+provide enum Whence {
+  /**
+   * Seek relative to start-of-file.
+   */
   Set,
-  // Seek relative to current position.
+  /**
+   * Seek relative to current position.
+   */
   Current,
-  // Seek relative to end-of-file.
+  /**
+   * Seek relative to end-of-file.
+   */
   End,
 }
 
 /**
  * Information about a `FileDescriptor`.
  */
-export record Stats {
+provide record Stats {
   filetype: Filetype,
   flags: List<FdFlag>,
   rights: List<Rights>,
@@ -400,7 +501,7 @@ export record Stats {
 /**
  * Information about the file that a `FileDescriptor` refers to.
  */
-export record Filestats {
+provide record Filestats {
   device: Int64,
   inode: Int64,
   filetype: Filetype,
@@ -414,32 +515,31 @@ export record Filestats {
 /**
  * An entry in a directory.
  */
-export record DirectoryEntry {
+provide record DirectoryEntry {
   inode: Int64,
   filetype: Filetype,
   path: String,
 }
 
 /**
- * @section Values: Functions and constants included in the File module.
+ * Information about a preopened directory
  */
+provide enum Prestat {
+  Dir{ prefix: String, fd: FileDescriptor },
+}
 
 /**
  * The `FileDescriptor` for `stdin`.
  */
-export let stdin = FileDescriptor(0)
+provide let stdin = FileDescriptor(0)
 /**
  * The `FileDescriptor` for `stdout`.
  */
-export let stdout = FileDescriptor(1)
+provide let stdout = FileDescriptor(1)
 /**
  * The `FileDescriptor` for `stderr`.
  */
-export let stderr = FileDescriptor(2)
-/**
- * The `FileDescriptor` for the current working directory of the process.
- */
-export let pwdfd = FileDescriptor(3)
+provide let stderr = FileDescriptor(2)
 
 /**
  * Open a file or directory.
@@ -454,20 +554,21 @@ export let pwdfd = FileDescriptor(3)
  * @returns `Ok(fd)` of the opened file or directory if successful or `Err(exception)` otherwise
  */
 @unsafe
-export let pathOpen =
-  (
-    dirFd: FileDescriptor,
-    dirFlags: List<LookupFlag>,
-    path: String,
-    openFlags: List<OpenFlag>,
-    rights: List<Rights>,
-    rightsInheriting: List<Rights>,
-    flags: List<FdFlag>,
-  ) => {
+provide let pathOpen = (
+  dirFd: FileDescriptor,
+  dirFlags: List<LookupFlag>,
+  path: String,
+  openFlags: List<OpenFlag>,
+  rights: List<Rights>,
+  rightsInheriting: List<Rights>,
+  flags: List<FdFlag>,
+) => {
   let dirFdArg = dirFd
   let pathArg = path
   let rightsInheritingArg = rightsInheriting
-  let dirFd = match (dirFd) { FileDescriptor(n) => WasmI32.fromGrain(n) >> 1n }
+  let dirFd = match (dirFd) {
+    FileDescriptor(n) => WasmI32.fromGrain(n) >> 1n,
+  }
 
   let combinedDirFlags = combineLookupFlags(dirFlags)
 
@@ -495,16 +596,15 @@ export let pathOpen =
     combinedFsFlags,
     newFd
   )
-  if (err != Wasi._ESUCCESS) {
-    Memory.free(newFd)
-    Err(Wasi.SystemError(tagSimpleNumber(err)))
-  } else {
-    let fd = FileDescriptor(tagSimpleNumber(WasmI32.load(newFd, 0n)))
 
+  if (err != Wasi._ESUCCESS) {
     Memory.free(newFd)
-
-    Ok(fd)
+    return Err(Wasi.SystemError(tagSimpleNumber(err)))
   }
+
+  let fd = FileDescriptor(tagSimpleNumber(WasmI32.load(newFd, 0n)))
+  Memory.free(newFd)
+  return Ok(fd)
 }
 
 /**
@@ -515,14 +615,16 @@ export let pathOpen =
  * @returns `Ok((contents, numBytes))` of bytes read and the number of bytes read if successful or `Err(exception)` otherwise
  */
 @unsafe
-export let fdRead = (fd: FileDescriptor, size: Number) => {
+provide let fdRead = (fd: FileDescriptor, size: Number) => {
   let fdArg = fd
-  let fd = match (fd) { FileDescriptor(n) => WasmI32.fromGrain(n) >> 1n }
+  let fd = match (fd) {
+    FileDescriptor(n) => WasmI32.fromGrain(n) >> 1n,
+  }
 
   let n = WasmI32.fromGrain(size) >> 1n
 
   let iovs = Memory.malloc(3n * 4n)
-  let strPtr = allocateString(n)
+  let strPtr = allocateBytes(n)
 
   WasmI32.store(iovs, strPtr + 2n * 4n, 0n)
   WasmI32.store(iovs, n, 4n)
@@ -533,16 +635,13 @@ export let fdRead = (fd: FileDescriptor, size: Number) => {
   if (err != Wasi._ESUCCESS) {
     Memory.free(iovs)
     Memory.free(strPtr)
-    Err(Wasi.SystemError(tagSimpleNumber(err)))
-  } else {
-    nread = WasmI32.load(nread, 0n)
-
-    WasmI32.store(strPtr, nread, 4n)
-
-    Memory.free(iovs)
-
-    Ok((WasmI32.toGrain(strPtr): String, tagSimpleNumber(nread)))
+    return Err(Wasi.SystemError(tagSimpleNumber(err)))
   }
+
+  nread = WasmI32.load(nread, 0n)
+  WasmI32.store(strPtr, nread, 4n)
+  Memory.free(iovs)
+  return Ok((WasmI32.toGrain(strPtr): Bytes, tagSimpleNumber(nread)))
 }
 
 /**
@@ -554,17 +653,19 @@ export let fdRead = (fd: FileDescriptor, size: Number) => {
  * @returns `Ok((contents, numBytes))` of bytes read and the number of bytes read if successful or `Err(exception)` otherwise
  */
 @unsafe
-export let fdPread = (fd: FileDescriptor, offset: Int64, size: Number) => {
+provide let fdPread = (fd: FileDescriptor, offset: Int64, size: Number) => {
   let fdArg = fd
   let offsetArg = offset
-  let fd = match (fd) { FileDescriptor(n) => WasmI32.fromGrain(n) >> 1n }
+  let fd = match (fd) {
+    FileDescriptor(n) => WasmI32.fromGrain(n) >> 1n,
+  }
 
   let offset = WasmI64.load(WasmI32.fromGrain(offset), 8n)
 
   let n = WasmI32.fromGrain(size) >> 1n
 
   let iovs = Memory.malloc(3n * 4n)
-  let strPtr = allocateString(n)
+  let strPtr = allocateBytes(n)
 
   WasmI32.store(iovs, strPtr + 2n * 4n, 0n)
   WasmI32.store(iovs, n, 4n)
@@ -575,16 +676,60 @@ export let fdPread = (fd: FileDescriptor, offset: Int64, size: Number) => {
   if (err != Wasi._ESUCCESS) {
     Memory.free(iovs)
     Memory.free(strPtr)
-    Err(Wasi.SystemError(tagSimpleNumber(err)))
-  } else {
-    nread = WasmI32.load(nread, 0n)
+    return Err(Wasi.SystemError(tagSimpleNumber(err)))
+  }
 
-    WasmI32.store(strPtr, nread, 4n)
+  nread = WasmI32.load(nread, 0n)
+  WasmI32.store(strPtr, nread, 4n)
+  Memory.free(iovs)
+  return Ok((WasmI32.toGrain(strPtr): Bytes, tagSimpleNumber(nread)))
+}
 
-    Memory.free(iovs)
+/**
+ * Get information about a preopened directory.
+ *
+ * @param fd: The file descriptor to check
+ * @returns `Ok(Dir{prefix, fd})` if successful or `Err(exception)` otherwise
+ *
+ * @since v0.6.0
+ */
+@unsafe
+provide let fdPrestatGet = (fd: FileDescriptor) => {
+  let fdArg = fd
+  let fd = match (fd) {
+    FileDescriptor(n) => WasmI32.fromGrain(n) >> 1n,
+  }
+
+  let dir = Memory.malloc(8n)
+  let err = Wasi.fd_prestat_get(fd, dir)
+  if (err != Wasi._ESUCCESS) {
+    Memory.free(dir)
+    return Err(Wasi.SystemError(tagSimpleNumber(err)))
+  }
+
+  let prefixLen = WasmI32.load(dir, 4n)
+  Memory.free(dir)
+
+  let prefix = allocateString(prefixLen)
+  let err = Wasi.fd_prestat_dir_name(fd, prefix + 8n, prefixLen)
+  if (err != Wasi._ESUCCESS) {
+    Memory.free(prefix)
+    return Err(Wasi.SystemError(tagSimpleNumber(err)))
+  }
 
-    Ok((WasmI32.toGrain(strPtr): String, tagSimpleNumber(nread)))
+  if (
+    prefixLen > 0n &&
+    WasmI32.eqz(WasmI32.load8U(prefix + prefixLen - 1n, 8n))
+  ) {
+    // in uvwasi environments the string is null-terminated and the size is reported including it
+    // https://github.com/grain-lang/grain/issues/1818
+    WasmI32.store(prefix, prefixLen - 1n, 4n)
   }
+
+  let prefix = WasmI32.toGrain(prefix): String
+  let fd = fdArg
+
+  return Ok(Dir{ prefix, fd })
 }
 
 /**
@@ -595,9 +740,11 @@ export let fdPread = (fd: FileDescriptor, offset: Int64, size: Number) => {
  * @returns `Ok(numBytes)` of the number of bytes written if successful or `Err(Exception)` otherwise
  */
 @unsafe
-export let fdWrite = (fd: FileDescriptor, data: String) => {
+provide let fdWrite = (fd: FileDescriptor, data: Bytes) => {
   let fdArg = fd
-  let fd = match (fd) { FileDescriptor(n) => WasmI32.fromGrain(n) >> 1n }
+  let fd = match (fd) {
+    FileDescriptor(n) => WasmI32.fromGrain(n) >> 1n,
+  }
 
   let iovs = Memory.malloc(3n * 4n)
   let strPtr = WasmI32.fromGrain(data)
@@ -610,14 +757,12 @@ export let fdWrite = (fd: FileDescriptor, data: String) => {
   let err = Wasi.fd_write(fd, iovs, 1n, nwritten)
   if (err != Wasi._ESUCCESS) {
     Memory.free(iovs)
-    Err(Wasi.SystemError(tagSimpleNumber(err)))
-  } else {
-    nwritten = WasmI32.load(nwritten, 0n)
-
-    Memory.free(iovs)
-
-    Ok(tagSimpleNumber(nwritten))
+    return Err(Wasi.SystemError(tagSimpleNumber(err)))
   }
+
+  nwritten = WasmI32.load(nwritten, 0n)
+  Memory.free(iovs)
+  return Ok(tagSimpleNumber(nwritten))
 }
 
 /**
@@ -629,10 +774,12 @@ export let fdWrite = (fd: FileDescriptor, data: String) => {
  * @returns `Ok(numBytes)` of the number of bytes written if successful or `Err(exception)` otherwise
  */
 @unsafe
-export let fdPwrite = (fd: FileDescriptor, data: String, offset: Int64) => {
+provide let fdPwrite = (fd: FileDescriptor, data: Bytes, offset: Int64) => {
   let fdArg = fd
   let offsetArg = offset
-  let fd = match (fd) { FileDescriptor(n) => WasmI32.fromGrain(n) >> 1n }
+  let fd = match (fd) {
+    FileDescriptor(n) => WasmI32.fromGrain(n) >> 1n,
+  }
 
   let iovs = Memory.malloc(3n * 4n)
   let strPtr = WasmI32.fromGrain(data)
@@ -647,14 +794,12 @@ export let fdPwrite = (fd: FileDescriptor, data: String, offset: Int64) => {
   let err = Wasi.fd_pwrite(fd, iovs, 1n, offset, nwritten)
   if (err != Wasi._ESUCCESS) {
     Memory.free(iovs)
-    Err(Wasi.SystemError(tagSimpleNumber(err)))
-  } else {
-    nwritten = WasmI32.load(nwritten, 0n)
-
-    Memory.free(iovs)
-
-    Ok(tagSimpleNumber(nwritten))
+    return Err(Wasi.SystemError(tagSimpleNumber(err)))
   }
+
+  nwritten = WasmI32.load(nwritten, 0n)
+  Memory.free(iovs)
+  return Ok(tagSimpleNumber(nwritten))
 }
 
 /**
@@ -666,11 +811,13 @@ export let fdPwrite = (fd: FileDescriptor, data: String, offset: Int64) => {
  * @returns `Ok(void)` if successful or `Err(exception)` otherwise
  */
 @unsafe
-export let fdAllocate = (fd: FileDescriptor, offset: Int64, size: Int64) => {
+provide let fdAllocate = (fd: FileDescriptor, offset: Int64, size: Int64) => {
   let fdArg = fd
   let offsetArg = offset
   let sizeArg = size
-  let fd = match (fd) { FileDescriptor(n) => WasmI32.fromGrain(n) >> 1n }
+  let fd = match (fd) {
+    FileDescriptor(n) => WasmI32.fromGrain(n) >> 1n,
+  }
 
   let offset = WasmI64.load(WasmI32.fromGrain(offset), 8n)
 
@@ -678,10 +825,10 @@ export let fdAllocate = (fd: FileDescriptor, offset: Int64, size: Int64) => {
 
   let err = Wasi.fd_allocate(fd, offset, size)
   if (err != Wasi._ESUCCESS) {
-    Err(Wasi.SystemError(tagSimpleNumber(err)))
-  } else {
-    Ok(void)
+    return Err(Wasi.SystemError(tagSimpleNumber(err)))
   }
+
+  return Ok(void)
 }
 
 /**
@@ -691,16 +838,18 @@ export let fdAllocate = (fd: FileDescriptor, offset: Int64, size: Int64) => {
  * @returns `Ok(void)` if successful or `Err(exception)` otherwise
  */
 @unsafe
-export let fdClose = (fd: FileDescriptor) => {
+provide let fdClose = (fd: FileDescriptor) => {
   let fdArg = fd
-  let fd = match (fd) { FileDescriptor(n) => WasmI32.fromGrain(n) >> 1n }
+  let fd = match (fd) {
+    FileDescriptor(n) => WasmI32.fromGrain(n) >> 1n,
+  }
 
   let err = Wasi.fd_close(fd)
   if (err != Wasi._ESUCCESS) {
-    Err(Wasi.SystemError(tagSimpleNumber(err)))
-  } else {
-    Ok(void)
+    return Err(Wasi.SystemError(tagSimpleNumber(err)))
   }
+
+  return Ok(void)
 }
 
 /**
@@ -710,16 +859,18 @@ export let fdClose = (fd: FileDescriptor) => {
  * @returns `Ok(void)` if successful or `Err(exception)` otherwise
  */
 @unsafe
-export let fdDatasync = (fd: FileDescriptor) => {
+provide let fdDatasync = (fd: FileDescriptor) => {
   let fdArg = fd
-  let fd = match (fd) { FileDescriptor(n) => WasmI32.fromGrain(n) >> 1n }
+  let fd = match (fd) {
+    FileDescriptor(n) => WasmI32.fromGrain(n) >> 1n,
+  }
 
   let err = Wasi.fd_datasync(fd)
   if (err != Wasi._ESUCCESS) {
-    Err(Wasi.SystemError(tagSimpleNumber(err)))
-  } else {
-    Ok(void)
+    return Err(Wasi.SystemError(tagSimpleNumber(err)))
   }
+
+  return Ok(void)
 }
 
 /**
@@ -729,16 +880,18 @@ export let fdDatasync = (fd: FileDescriptor) => {
  * @returns `Ok(void)` if successful or `Err(exception)` otherwise
  */
 @unsafe
-export let fdSync = (fd: FileDescriptor) => {
+provide let fdSync = (fd: FileDescriptor) => {
   let fdArg = fd
-  let fd = match (fd) { FileDescriptor(n) => WasmI32.fromGrain(n) >> 1n }
+  let fd = match (fd) {
+    FileDescriptor(n) => WasmI32.fromGrain(n) >> 1n,
+  }
 
   let err = Wasi.fd_sync(fd)
   if (err != Wasi._ESUCCESS) {
-    Err(Wasi.SystemError(tagSimpleNumber(err)))
-  } else {
-    Ok(void)
+    return Err(Wasi.SystemError(tagSimpleNumber(err)))
   }
+
+  return Ok(void)
 }
 
 let orderedFdflags = [Append, Dsync, Nonblock, Rsync, Sync]
@@ -781,56 +934,53 @@ let orderedRights = [
  * @returns `Ok(stats)` of the `Stats` associated with the file descriptor if successful or `Err(exception)` otherwise
  */
 @unsafe
-export let fdStats = (fd: FileDescriptor) => {
+provide let fdStats = (fd: FileDescriptor) => {
   let fdArg = fd
-  let fd = match (fd) { FileDescriptor(n) => WasmI32.fromGrain(n) >> 1n }
+  let fd = match (fd) {
+    FileDescriptor(n) => WasmI32.fromGrain(n) >> 1n,
+  }
 
   let structPtr = Memory.malloc(24n)
 
   let err = Wasi.fd_fdstat_get(fd, structPtr)
   if (err != Wasi._ESUCCESS) {
     Memory.free(structPtr)
-    Err(Wasi.SystemError(tagSimpleNumber(err)))
-  } else {
-    let filetype = WasmI32.load8U(structPtr, 0n)
+    return Err(Wasi.SystemError(tagSimpleNumber(err)))
+  }
+  let filetype = WasmI32.load8U(structPtr, 0n)
 
-    let filetype = filetypeFromNumber(filetype)
+  let filetype = filetypeFromNumber(filetype)
 
-    let flagsToWasmVal = (flag, i) => {
-      let fdflags = WasmI32.load16U(structPtr, 4n)
-      WasmI32.gtU(fdflags & 1n << (WasmI32.fromGrain(i) >> 1n), 0n)
-    }
-    let fdflagsList = List.filteri(flagsToWasmVal, orderedFdflags)
-
-    let (&) = WasmI64.and
-    let (>) = WasmI64.gtU
-    let (<<) = WasmI64.shl
+  let flagsToWasmVal = (flag, i) => {
+    let fdflags = WasmI32.load16U(structPtr, 4n)
+    WasmI32.gtU(fdflags & 1n << (WasmI32.fromGrain(i) >> 1n), 0n)
+  }
+  let fdflagsList = List.filteri(flagsToWasmVal, orderedFdflags)
+  use WasmI64.{ (&), gtU as (>), (<<) }
 
-    let flagsToWasmVal = (flag, i) => {
-      let rights = WasmI64.load(structPtr, 8n)
-      (rights & 1N << WasmI64.extendI32U(WasmI32.fromGrain(i) >> 1n)) > 0N
-    }
-    let rightsList = List.filteri(flagsToWasmVal, orderedRights)
+  let flagsToWasmVal = (flag, i) => {
+    let rights = WasmI64.load(structPtr, 8n)
+    (rights & 1N << WasmI64.extendI32U(WasmI32.fromGrain(i) >> 1n)) > 0N
+  }
+  let rightsList = List.filteri(flagsToWasmVal, orderedRights)
 
-    let flagsToWasmVal = (flag, i) => {
-      let rightsInheriting = WasmI64.load(structPtr, 16n)
-      (rightsInheriting &
-        1N << WasmI64.extendI32U(WasmI32.fromGrain(i) >> 1n)) >
-        0N
-    }
-    let rightsInheritingList = List.filteri(flagsToWasmVal, orderedRights)
+  let flagsToWasmVal = (flag, i) => {
+    let rightsInheriting = WasmI64.load(structPtr, 16n)
+    (rightsInheriting & 1N << WasmI64.extendI32U(WasmI32.fromGrain(i) >> 1n)) >
+      0N
+  }
+  let rightsInheritingList = List.filteri(flagsToWasmVal, orderedRights)
 
-    Memory.free(structPtr)
+  Memory.free(structPtr)
 
-    Ok(
-      {
-        filetype,
-        flags: fdflagsList,
-        rights: rightsList,
-        rightsInheriting: rightsInheritingList,
-      }
-    )
-  }
+  return Ok(
+    {
+      filetype,
+      flags: fdflagsList,
+      rights: rightsList,
+      rightsInheriting: rightsInheritingList,
+    },
+  )
 }
 
 /**
@@ -841,19 +991,21 @@ export let fdStats = (fd: FileDescriptor) => {
  * @returns `Ok(void)` if successful or `Err(exception)` otherwise
  */
 @unsafe
-export let fdSetFlags = (fd: FileDescriptor, flags: List<FdFlag>) => {
+provide let fdSetFlags = (fd: FileDescriptor, flags: List<FdFlag>) => {
   let fdArg = fd
   let flagsArg = flags
-  let fd = match (fd) { FileDescriptor(n) => WasmI32.fromGrain(n) >> 1n }
+  let fd = match (fd) {
+    FileDescriptor(n) => WasmI32.fromGrain(n) >> 1n,
+  }
 
   let flags = combineFdFlags(flags)
 
   let err = Wasi.fd_fdstat_set_flags(fd, flags)
   if (err != Wasi._ESUCCESS) {
-    Err(Wasi.SystemError(tagSimpleNumber(err)))
-  } else {
-    Ok(void)
+    return Err(Wasi.SystemError(tagSimpleNumber(err)))
   }
+
+  return Ok(void)
 }
 
 /**
@@ -865,26 +1017,27 @@ export let fdSetFlags = (fd: FileDescriptor, flags: List<FdFlag>) => {
  * @returns `Ok(void)` if successful or `Err(exception)` otherwise
  */
 @unsafe
-export let fdSetRights =
-  (
-    fd: FileDescriptor,
-    rights: List<Rights>,
-    rightsInheriting: List<Rights>,
-  ) => {
+provide let fdSetRights = (
+  fd: FileDescriptor,
+  rights: List<Rights>,
+  rightsInheriting: List<Rights>,
+) => {
   let fdArg = fd
   let rightsArg = rights
   let rightsInheritingArg = rightsInheriting
-  let fd = match (fd) { FileDescriptor(n) => WasmI32.fromGrain(n) >> 1n }
+  let fd = match (fd) {
+    FileDescriptor(n) => WasmI32.fromGrain(n) >> 1n,
+  }
 
   let rights = combineRights(rights)
   let rightsInheriting = combineRights(rightsInheriting)
 
   let err = Wasi.fd_fdstat_set_rights(fd, rights, rightsInheriting)
   if (err != Wasi._ESUCCESS) {
-    Err(Wasi.SystemError(tagSimpleNumber(err)))
-  } else {
-    Ok(void)
+    return Err(Wasi.SystemError(tagSimpleNumber(err)))
   }
+
+  return Ok(void)
 }
 
 /**
@@ -894,38 +1047,34 @@ export let fdSetRights =
  * @returns `Ok(info)` of the `Filestats` associated with the file descriptor if successful or `Err(exception)` otherwise
  */
 @unsafe
-export let fdFilestats = (fd: FileDescriptor) => {
+provide let fdFilestats = (fd: FileDescriptor) => {
   let fdArg = fd
-  let fd = match (fd) { FileDescriptor(n) => WasmI32.fromGrain(n) >> 1n }
+  let fd = match (fd) {
+    FileDescriptor(n) => WasmI32.fromGrain(n) >> 1n,
+  }
 
   let filestats = Memory.malloc(64n)
 
   let err = Wasi.fd_filestat_get(fd, filestats)
   if (err != Wasi._ESUCCESS) {
     Memory.free(filestats)
-    Err(Wasi.SystemError(tagSimpleNumber(err)))
-  } else {
-    let device = WasmI32.toGrain(newInt64(WasmI64.load(filestats, 0n))): Int64
-    let inode = WasmI32.toGrain(newInt64(WasmI64.load(filestats, 8n))): Int64
-    let filetype = filetypeFromNumber(WasmI32.load8U(filestats, 16n))
-    let linkcount = WasmI32.toGrain(
-      newInt64(WasmI64.load(filestats, 24n))
-    ): Int64
-    let size = WasmI32.toGrain(newInt64(WasmI64.load(filestats, 32n))): Int64
-    let accessed = WasmI32.toGrain(
-      newInt64(WasmI64.load(filestats, 40n))
-    ): Int64
-    let modified = WasmI32.toGrain(
-      newInt64(WasmI64.load(filestats, 48n))
-    ): Int64
-    let changed = WasmI32.toGrain(newInt64(WasmI64.load(filestats, 56n))): Int64
+    return Err(Wasi.SystemError(tagSimpleNumber(err)))
+  }
 
-    Memory.free(filestats)
+  let device = WasmI32.toGrain(newInt64(WasmI64.load(filestats, 0n))): Int64
+  let inode = WasmI32.toGrain(newInt64(WasmI64.load(filestats, 8n))): Int64
+  let filetype = filetypeFromNumber(WasmI32.load8U(filestats, 16n))
+  let linkcount = WasmI32.toGrain(newInt64(WasmI64.load(filestats, 24n))): Int64
+  let size = WasmI32.toGrain(newInt64(WasmI64.load(filestats, 32n))): Int64
+  let accessed = WasmI32.toGrain(newInt64(WasmI64.load(filestats, 40n))): Int64
+  let modified = WasmI32.toGrain(newInt64(WasmI64.load(filestats, 48n))): Int64
+  let changed = WasmI32.toGrain(newInt64(WasmI64.load(filestats, 56n))): Int64
 
-    Ok(
-      { device, inode, filetype, linkcount, size, accessed, modified, changed }
-    )
-  }
+  Memory.free(filestats)
+
+  return Ok(
+    { device, inode, filetype, linkcount, size, accessed, modified, changed },
+  )
 }
 
 /**
@@ -936,19 +1085,21 @@ export let fdFilestats = (fd: FileDescriptor) => {
  * @returns `Ok(void)` if successful or `Err(exception)` otherwise
  */
 @unsafe
-export let fdSetSize = (fd: FileDescriptor, size: Int64) => {
+provide let fdSetSize = (fd: FileDescriptor, size: Int64) => {
   let fdArg = fd
   let sizeArg = size
-  let fd = match (fd) { FileDescriptor(n) => WasmI32.fromGrain(n) >> 1n }
+  let fd = match (fd) {
+    FileDescriptor(n) => WasmI32.fromGrain(n) >> 1n,
+  }
 
   let size = WasmI64.load(WasmI32.fromGrain(size), 8n)
 
   let err = Wasi.fd_filestat_set_size(fd, size)
   if (err != Wasi._ESUCCESS) {
-    Err(Wasi.SystemError(tagSimpleNumber(err)))
-  } else {
-    Ok(void)
+    return Err(Wasi.SystemError(tagSimpleNumber(err)))
   }
+
+  return Ok(void)
 }
 
 /**
@@ -959,18 +1110,20 @@ export let fdSetSize = (fd: FileDescriptor, size: Int64) => {
  * @returns `Ok(void)` if successful or `Err(exception)` otherwise
  */
 @unsafe
-export let fdSetAccessTime = (fd: FileDescriptor, timestamp: Int64) => {
+provide let fdSetAccessTime = (fd: FileDescriptor, timestamp: Int64) => {
   let fdArg = fd
-  let fd = match (fd) { FileDescriptor(n) => WasmI32.fromGrain(n) >> 1n }
+  let fd = match (fd) {
+    FileDescriptor(n) => WasmI32.fromGrain(n) >> 1n,
+  }
 
   let time = WasmI64.load(WasmI32.fromGrain(timestamp), 8n)
 
   let err = Wasi.fd_filestat_set_times(fd, time, 0N, Wasi._TIME_SET_ATIM)
   if (err != Wasi._ESUCCESS) {
-    Err(Wasi.SystemError(tagSimpleNumber(err)))
-  } else {
-    Ok(void)
+    return Err(Wasi.SystemError(tagSimpleNumber(err)))
   }
+
+  return Ok(void)
 }
 
 /**
@@ -980,16 +1133,18 @@ export let fdSetAccessTime = (fd: FileDescriptor, timestamp: Int64) => {
  * @returns `Ok(void)` if successful or `Err(exception)` otherwise
  */
 @unsafe
-export let fdSetAccessTimeNow = (fd: FileDescriptor) => {
+provide let fdSetAccessTimeNow = (fd: FileDescriptor) => {
   let fdArg = fd
-  let fd = match (fd) { FileDescriptor(n) => WasmI32.fromGrain(n) >> 1n }
+  let fd = match (fd) {
+    FileDescriptor(n) => WasmI32.fromGrain(n) >> 1n,
+  }
 
   let err = Wasi.fd_filestat_set_times(fd, 0N, 0N, Wasi._TIME_SET_ATIM_NOW)
   if (err != Wasi._ESUCCESS) {
-    Err(Wasi.SystemError(tagSimpleNumber(err)))
-  } else {
-    Ok(void)
+    return Err(Wasi.SystemError(tagSimpleNumber(err)))
   }
+
+  return Ok(void)
 }
 
 /**
@@ -1000,18 +1155,20 @@ export let fdSetAccessTimeNow = (fd: FileDescriptor) => {
  * @returns `Ok(void)` if successful or `Err(exception)` otherwise
  */
 @unsafe
-export let fdSetModifiedTime = (fd: FileDescriptor, timestamp: Int64) => {
+provide let fdSetModifiedTime = (fd: FileDescriptor, timestamp: Int64) => {
   let fdArg = fd
-  let fd = match (fd) { FileDescriptor(n) => WasmI32.fromGrain(n) >> 1n }
+  let fd = match (fd) {
+    FileDescriptor(n) => WasmI32.fromGrain(n) >> 1n,
+  }
 
   let time = WasmI64.load(WasmI32.fromGrain(timestamp), 8n)
 
   let err = Wasi.fd_filestat_set_times(fd, 0N, time, Wasi._TIME_SET_MTIM)
   if (err != Wasi._ESUCCESS) {
-    Err(Wasi.SystemError(tagSimpleNumber(err)))
-  } else {
-    Ok(void)
+    return Err(Wasi.SystemError(tagSimpleNumber(err)))
   }
+
+  return Ok(void)
 }
 
 /**
@@ -1021,16 +1178,18 @@ export let fdSetModifiedTime = (fd: FileDescriptor, timestamp: Int64) => {
  * @returns `Ok(void)` if successful or `Err(exception)` otherwise
  */
 @unsafe
-export let fdSetModifiedTimeNow = (fd: FileDescriptor) => {
+provide let fdSetModifiedTimeNow = (fd: FileDescriptor) => {
   let fdArg = fd
-  let fd = match (fd) { FileDescriptor(n) => WasmI32.fromGrain(n) >> 1n }
+  let fd = match (fd) {
+    FileDescriptor(n) => WasmI32.fromGrain(n) >> 1n,
+  }
 
   let err = Wasi.fd_filestat_set_times(fd, 0N, 0N, Wasi._TIME_SET_MTIM_NOW)
   if (err != Wasi._ESUCCESS) {
-    Err(Wasi.SystemError(tagSimpleNumber(err)))
-  } else {
-    Ok(void)
+    return Err(Wasi.SystemError(tagSimpleNumber(err)))
   }
+
+  return Ok(void)
 }
 
 /**
@@ -1040,9 +1199,11 @@ export let fdSetModifiedTimeNow = (fd: FileDescriptor) => {
  * @returns `Ok(dirEntries)` of an array of `DirectoryEntry` for each entry in the directory if successful or `Err(exception)` otherwise
  */
 @unsafe
-export let fdReaddir = (fd: FileDescriptor) => {
+provide let fdReaddir = (fd: FileDescriptor) => {
   let fdArg = fd
-  let fd = match (fd) { FileDescriptor(n) => WasmI32.fromGrain(n) >> 1n }
+  let fd = match (fd) {
+    FileDescriptor(n) => WasmI32.fromGrain(n) >> 1n,
+  }
 
   let structWidth = 24n
 
@@ -1056,94 +1217,87 @@ export let fdReaddir = (fd: FileDescriptor) => {
   if (err != Wasi._ESUCCESS) {
     Memory.free(buf)
     Memory.free(bufUsed)
-    Err(Wasi.SystemError(tagSimpleNumber(err)))
-  } else {
-    let used = WasmI32.load(bufUsed, 0n)
+    return Err(Wasi.SystemError(tagSimpleNumber(err)))
+  }
 
-    if (used <= 0n) {
-      Memory.free(buf)
-      Memory.free(bufUsed)
-      Ok(WasmI32.toGrain(allocateArray(0n)): Array<DirectoryEntry>)
-    } else {
-      bufLen = WasmI32.load(buf, 16n) + structWidth * 2n
-
-      Memory.free(buf)
-
-      // simple linked list
-      // ptr +0n -> current buffer
-      // ptr +4n -> bufs
-      let mut bufs = 0n
-
-      let mut numEntries = 0n
-      let mut hasErr = None
-
-      while (true) {
-        numEntries += 1n
-
-        buf = Memory.malloc(bufLen)
-        let cons = Memory.malloc(8n)
-        WasmI32.store(cons, buf, 0n)
-        WasmI32.store(cons, bufs, 4n)
-        bufs = cons
-
-        let err = Wasi.fd_readdir(fd, buf, bufLen, cookie, bufUsed)
-        if (err != Wasi._ESUCCESS) {
-          while (bufs != 0n) {
-            Memory.free(WasmI32.load(bufs, 0n))
-            let next = WasmI32.load(bufs, 4n)
-            Memory.free(bufs)
-            bufs = next
-          }
-          Memory.free(bufUsed)
-          hasErr = Some(Err(Wasi.SystemError(tagSimpleNumber(err))))
-          break
-        }
-
-        if (WasmI32.load(bufUsed, 0n) != bufLen) {
-          break
-        } else {
-          let curLen = WasmI32.load(buf, 16n)
-          cookie = WasmI64.load(buf, 0n)
-          let nextDirentPtr = buf + structWidth + curLen
-          bufLen = WasmI32.load(nextDirentPtr, 16n) + structWidth * 2n
-        }
+  let used = WasmI32.load(bufUsed, 0n)
+
+  if (used <= 0n) {
+    Memory.free(buf)
+    Memory.free(bufUsed)
+    return Ok(WasmI32.toGrain(allocateArray(0n)): Array<DirectoryEntry>)
+  }
+
+  bufLen = WasmI32.load(buf, 16n) + structWidth * 2n
+
+  Memory.free(buf)
+
+  // simple linked list
+  // ptr +0n -> current buffer
+  // ptr +4n -> bufs
+  let mut bufs = 0n
+
+  let mut numEntries = 0n
+
+  while (true) {
+    numEntries += 1n
+
+    buf = Memory.malloc(bufLen)
+    let cons = Memory.malloc(8n)
+    WasmI32.store(cons, buf, 0n)
+    WasmI32.store(cons, bufs, 4n)
+    bufs = cons
+
+    let err = Wasi.fd_readdir(fd, buf, bufLen, cookie, bufUsed)
+    if (err != Wasi._ESUCCESS) {
+      while (bufs != 0n) {
+        Memory.free(WasmI32.load(bufs, 0n))
+        let next = WasmI32.load(bufs, 4n)
+        Memory.free(bufs)
+        bufs = next
       }
+      Memory.free(bufUsed)
+      return Err(Wasi.SystemError(tagSimpleNumber(err)))
+    }
 
-      match (hasErr) {
-        Some(err) => err,
-        None => {
-          Memory.free(bufUsed)
+    if (WasmI32.load(bufUsed, 0n) != bufLen) {
+      break
+    }
 
-          let arr = allocateArray(numEntries)
+    let curLen = WasmI32.load(buf, 16n)
+    cookie = WasmI64.load(buf, 0n)
+    let nextDirentPtr = buf + structWidth + curLen
+    bufLen = WasmI32.load(nextDirentPtr, 16n) + structWidth * 2n
+  }
 
-          for (let mut i = numEntries - 1n; i >= 0n; i -= 1n) {
-            let ent = WasmI32.load(bufs, 0n)
+  Memory.free(bufUsed)
 
-            let inode = WasmI32.toGrain(newInt64(WasmI64.load(ent, 8n))): Int64
+  let arr = allocateArray(numEntries)
 
-            let dirnameLen = WasmI32.load(ent, 16n)
-            let dirname = allocateString(dirnameLen)
-            Memory.copy(dirname + 8n, ent + structWidth, dirnameLen)
-            let path = WasmI32.toGrain(dirname): String
+  for (let mut i = numEntries - 1n; i >= 0n; i -= 1n) {
+    let ent = WasmI32.load(bufs, 0n)
 
-            let filetype = filetypeFromNumber(WasmI32.load8U(ent, 20n))
+    let inode = WasmI32.toGrain(newInt64(WasmI64.load(ent, 8n))): Int64
 
-            let dirent = WasmI32.fromGrain({ inode, path, filetype })
+    let dirnameLen = WasmI32.load(ent, 16n)
+    let dirname = allocateString(dirnameLen)
+    Memory.copy(dirname + 8n, ent + structWidth, dirnameLen)
+    let path = WasmI32.toGrain(dirname): String
 
-            WasmI32.store(arr + i * 4n, Memory.incRef(dirent), 8n)
+    let filetype = filetypeFromNumber(WasmI32.load8U(ent, 20n))
 
-            let next = WasmI32.load(bufs, 4n)
-            Memory.free(bufs)
-            Memory.free(ent)
+    let dirent = WasmI32.fromGrain({ inode, path, filetype })
 
-            bufs = next
-          }
+    WasmI32.store(arr + i * 4n, Memory.incRef(dirent), 8n)
 
-          Ok(WasmI32.toGrain(arr): Array<DirectoryEntry>)
-        },
-      }
-    }
+    let next = WasmI32.load(bufs, 4n)
+    Memory.free(bufs)
+    Memory.free(ent)
+
+    bufs = next
   }
+
+  return Ok(WasmI32.toGrain(arr): Array<DirectoryEntry>)
 }
 
 /**
@@ -1154,21 +1308,23 @@ export let fdReaddir = (fd: FileDescriptor) => {
  * @returns `Ok(void)` if successful or `Err(exception)` otherwise
  */
 @unsafe
-export let fdRenumber = (fromFd: FileDescriptor, toFd: FileDescriptor) => {
+provide let fdRenumber = (fromFd: FileDescriptor, toFd: FileDescriptor) => {
   let fromFdArg = fromFd
   let toFdArg = toFd
   let fromFd = match (fromFd) {
     FileDescriptor(n) => WasmI32.fromGrain(n) >> 1n,
   }
 
-  let toFd = match (toFd) { FileDescriptor(n) => WasmI32.fromGrain(n) >> 1n }
+  let toFd = match (toFd) {
+    FileDescriptor(n) => WasmI32.fromGrain(n) >> 1n,
+  }
 
   let err = Wasi.fd_renumber(fromFd, toFd)
   if (err != Wasi._ESUCCESS) {
-    Err(Wasi.SystemError(tagSimpleNumber(err)))
-  } else {
-    Ok(void)
+    return Err(Wasi.SystemError(tagSimpleNumber(err)))
   }
+
+  return Ok(void)
 }
 
 /**
@@ -1180,11 +1336,13 @@ export let fdRenumber = (fromFd: FileDescriptor, toFd: FileDescriptor) => {
  * @returns `Ok(offset)` of the new offset of the file descriptor, relative to the start of the file, if successful or `Err(exception)` otherwise
  */
 @unsafe
-export let fdSeek = (fd: FileDescriptor, offset: Int64, whence: Whence) => {
+provide let fdSeek = (fd: FileDescriptor, offset: Int64, whence: Whence) => {
   let fdArg = fd
   let offsetArg = offset
   let whenceArg = whence
-  let fd = match (fd) { FileDescriptor(n) => WasmI32.fromGrain(n) >> 1n }
+  let fd = match (fd) {
+    FileDescriptor(n) => WasmI32.fromGrain(n) >> 1n,
+  }
 
   let offset = WasmI64.load(WasmI32.fromGrain(offset), 8n)
 
@@ -1200,10 +1358,10 @@ export let fdSeek = (fd: FileDescriptor, offset: Int64, whence: Whence) => {
   let err = Wasi.fd_seek(fd, offset, whence, newoffsetPtr)
   if (err != Wasi._ESUCCESS) {
     Memory.free(newoffset)
-    Err(Wasi.SystemError(tagSimpleNumber(err)))
-  } else {
-    Ok(WasmI32.toGrain(newoffset): Int64)
+    return Err(Wasi.SystemError(tagSimpleNumber(err)))
   }
+
+  return Ok(WasmI32.toGrain(newoffset): Int64)
 }
 
 /**
@@ -1213,9 +1371,11 @@ export let fdSeek = (fd: FileDescriptor, offset: Int64, whence: Whence) => {
  * @returns `Ok(offset)` of the offset of the file descriptor, relative to the start of the file, if successful or `Err(exception)` otherwise
  */
 @unsafe
-export let fdTell = (fd: FileDescriptor) => {
+provide let fdTell = (fd: FileDescriptor) => {
   let fdArg = fd
-  let fd = match (fd) { FileDescriptor(n) => WasmI32.fromGrain(n) >> 1n }
+  let fd = match (fd) {
+    FileDescriptor(n) => WasmI32.fromGrain(n) >> 1n,
+  }
 
   let offset = allocateInt64()
   let offsetPtr = offset + 8n
@@ -1223,10 +1383,10 @@ export let fdTell = (fd: FileDescriptor) => {
   let err = Wasi.fd_tell(fd, offsetPtr)
   if (err != Wasi._ESUCCESS) {
     Memory.free(offset)
-    Err(Wasi.SystemError(tagSimpleNumber(err)))
-  } else {
-    Ok(WasmI32.toGrain(offset): Int64)
+    return Err(Wasi.SystemError(tagSimpleNumber(err)))
   }
+
+  return Ok(WasmI32.toGrain(offset): Int64)
 }
 
 /**
@@ -1237,9 +1397,11 @@ export let fdTell = (fd: FileDescriptor) => {
  * @returns `Ok(void)` if successful or `Err(exception)` otherwise
  */
 @unsafe
-export let pathCreateDirectory = (fd: FileDescriptor, path: String) => {
+provide let pathCreateDirectory = (fd: FileDescriptor, path: String) => {
   let fdArg = fd
-  let fd = match (fd) { FileDescriptor(n) => WasmI32.fromGrain(n) >> 1n }
+  let fd = match (fd) {
+    FileDescriptor(n) => WasmI32.fromGrain(n) >> 1n,
+  }
 
   let stringPtr = WasmI32.fromGrain(path)
 
@@ -1247,10 +1409,10 @@ export let pathCreateDirectory = (fd: FileDescriptor, path: String) => {
 
   let err = Wasi.path_create_directory(fd, stringPtr + 8n, size)
   if (err != Wasi._ESUCCESS) {
-    Err(Wasi.SystemError(tagSimpleNumber(err)))
-  } else {
-    Ok(void)
+    return Err(Wasi.SystemError(tagSimpleNumber(err)))
   }
+
+  return Ok(void)
 }
 
 /**
@@ -1262,14 +1424,15 @@ export let pathCreateDirectory = (fd: FileDescriptor, path: String) => {
  * @returns `Ok(info)` of the `Filestats` associated with the file descriptor if successful or `Err(exception)` otherwise
  */
 @unsafe
-export let pathFilestats =
-  (
-    fd: FileDescriptor,
-    dirFlags: List<LookupFlag>,
-    path: String,
-  ) => {
+provide let pathFilestats = (
+  fd: FileDescriptor,
+  dirFlags: List<LookupFlag>,
+  path: String,
+) => {
   let fdArg = fd
-  let fd = match (fd) { FileDescriptor(n) => WasmI32.fromGrain(n) >> 1n }
+  let fd = match (fd) {
+    FileDescriptor(n) => WasmI32.fromGrain(n) >> 1n,
+  }
 
   let combinedDirFlags = combineLookupFlags(dirFlags)
 
@@ -1288,29 +1451,23 @@ export let pathFilestats =
   )
   if (err != Wasi._ESUCCESS) {
     Memory.free(filestats)
-    Err(Wasi.SystemError(tagSimpleNumber(err)))
-  } else {
-    let device = WasmI32.toGrain(newInt64(WasmI64.load(filestats, 0n))): Int64
-    let inode = WasmI32.toGrain(newInt64(WasmI64.load(filestats, 8n))): Int64
-    let filetype = filetypeFromNumber(WasmI32.load8U(filestats, 16n))
-    let linkcount = WasmI32.toGrain(
-      newInt64(WasmI64.load(filestats, 24n))
-    ): Int64
-    let size = WasmI32.toGrain(newInt64(WasmI64.load(filestats, 32n))): Int64
-    let accessed = WasmI32.toGrain(
-      newInt64(WasmI64.load(filestats, 40n))
-    ): Int64
-    let modified = WasmI32.toGrain(
-      newInt64(WasmI64.load(filestats, 48n))
-    ): Int64
-    let changed = WasmI32.toGrain(newInt64(WasmI64.load(filestats, 56n))): Int64
+    return Err(Wasi.SystemError(tagSimpleNumber(err)))
+  }
 
-    Memory.free(filestats)
+  let device = WasmI32.toGrain(newInt64(WasmI64.load(filestats, 0n))): Int64
+  let inode = WasmI32.toGrain(newInt64(WasmI64.load(filestats, 8n))): Int64
+  let filetype = filetypeFromNumber(WasmI32.load8U(filestats, 16n))
+  let linkcount = WasmI32.toGrain(newInt64(WasmI64.load(filestats, 24n))): Int64
+  let size = WasmI32.toGrain(newInt64(WasmI64.load(filestats, 32n))): Int64
+  let accessed = WasmI32.toGrain(newInt64(WasmI64.load(filestats, 40n))): Int64
+  let modified = WasmI32.toGrain(newInt64(WasmI64.load(filestats, 48n))): Int64
+  let changed = WasmI32.toGrain(newInt64(WasmI64.load(filestats, 56n))): Int64
 
-    Ok(
-      { device, inode, filetype, linkcount, size, accessed, modified, changed }
-    )
-  }
+  Memory.free(filestats)
+
+  return Ok(
+    { device, inode, filetype, linkcount, size, accessed, modified, changed },
+  )
 }
 
 /**
@@ -1323,15 +1480,16 @@ export let pathFilestats =
  * @returns `Ok(void)` if successful or `Err(exception)` otherwise
  */
 @unsafe
-export let pathSetAccessTime =
-  (
-    fd: FileDescriptor,
-    dirFlags: List<LookupFlag>,
-    path: String,
-    timestamp: Int64,
-  ) => {
+provide let pathSetAccessTime = (
+  fd: FileDescriptor,
+  dirFlags: List<LookupFlag>,
+  path: String,
+  timestamp: Int64,
+) => {
   let fdArg = fd
-  let fd = match (fd) { FileDescriptor(n) => WasmI32.fromGrain(n) >> 1n }
+  let fd = match (fd) {
+    FileDescriptor(n) => WasmI32.fromGrain(n) >> 1n,
+  }
 
   let combinedDirFlags = combineLookupFlags(dirFlags)
 
@@ -1351,10 +1509,10 @@ export let pathSetAccessTime =
     Wasi._TIME_SET_ATIM
   )
   if (err != Wasi._ESUCCESS) {
-    Err(Wasi.SystemError(tagSimpleNumber(err)))
-  } else {
-    Ok(void)
+    return Err(Wasi.SystemError(tagSimpleNumber(err)))
   }
+
+  return Ok(void)
 }
 
 /**
@@ -1366,14 +1524,15 @@ export let pathSetAccessTime =
  * @returns `Ok(void)` if successful or `Err(exception)` otherwise
  */
 @unsafe
-export let pathSetAccessTimeNow =
-  (
-    fd: FileDescriptor,
-    dirFlags: List<LookupFlag>,
-    path: String,
-  ) => {
+provide let pathSetAccessTimeNow = (
+  fd: FileDescriptor,
+  dirFlags: List<LookupFlag>,
+  path: String,
+) => {
   let fdArg = fd
-  let fd = match (fd) { FileDescriptor(n) => WasmI32.fromGrain(n) >> 1n }
+  let fd = match (fd) {
+    FileDescriptor(n) => WasmI32.fromGrain(n) >> 1n,
+  }
 
   let combinedDirFlags = combineLookupFlags(dirFlags)
 
@@ -1391,10 +1550,10 @@ export let pathSetAccessTimeNow =
     Wasi._TIME_SET_ATIM_NOW
   )
   if (err != Wasi._ESUCCESS) {
-    Err(Wasi.SystemError(tagSimpleNumber(err)))
-  } else {
-    Ok(void)
+    return Err(Wasi.SystemError(tagSimpleNumber(err)))
   }
+
+  return Ok(void)
 }
 
 /**
@@ -1407,15 +1566,16 @@ export let pathSetAccessTimeNow =
  * @returns `Ok(void)` if successful or `Err(exception)` otherwise
  */
 @unsafe
-export let pathSetModifiedTime =
-  (
-    fd: FileDescriptor,
-    dirFlags: List<LookupFlag>,
-    path: String,
-    timestamp: Int64,
-  ) => {
+provide let pathSetModifiedTime = (
+  fd: FileDescriptor,
+  dirFlags: List<LookupFlag>,
+  path: String,
+  timestamp: Int64,
+) => {
   let fdArg = fd
-  let fd = match (fd) { FileDescriptor(n) => WasmI32.fromGrain(n) >> 1n }
+  let fd = match (fd) {
+    FileDescriptor(n) => WasmI32.fromGrain(n) >> 1n,
+  }
 
   let combinedDirFlags = combineLookupFlags(dirFlags)
 
@@ -1435,10 +1595,10 @@ export let pathSetModifiedTime =
     Wasi._TIME_SET_MTIM
   )
   if (err != Wasi._ESUCCESS) {
-    Err(Wasi.SystemError(tagSimpleNumber(err)))
-  } else {
-    Ok(void)
+    return Err(Wasi.SystemError(tagSimpleNumber(err)))
   }
+
+  return Ok(void)
 }
 
 /**
@@ -1450,14 +1610,15 @@ export let pathSetModifiedTime =
  * @returns `Ok(void)` if successful or `Err(exception)` otherwise
  */
 @unsafe
-export let pathSetModifiedTimeNow =
-  (
-    fd: FileDescriptor,
-    dirFlags: List<LookupFlag>,
-    path: String,
-  ) => {
+provide let pathSetModifiedTimeNow = (
+  fd: FileDescriptor,
+  dirFlags: List<LookupFlag>,
+  path: String,
+) => {
   let fdArg = fd
-  let fd = match (fd) { FileDescriptor(n) => WasmI32.fromGrain(n) >> 1n }
+  let fd = match (fd) {
+    FileDescriptor(n) => WasmI32.fromGrain(n) >> 1n,
+  }
 
   let combinedDirFlags = combineLookupFlags(dirFlags)
 
@@ -1475,10 +1636,10 @@ export let pathSetModifiedTimeNow =
     Wasi._TIME_SET_MTIM_NOW
   )
   if (err != Wasi._ESUCCESS) {
-    Err(Wasi.SystemError(tagSimpleNumber(err)))
-  } else {
-    Ok(void)
+    return Err(Wasi.SystemError(tagSimpleNumber(err)))
   }
+
+  return Ok(void)
 }
 
 /**
@@ -1492,14 +1653,13 @@ export let pathSetModifiedTimeNow =
  * @returns `Ok(void)` if successful or `Err(exception)` otherwise
  */
 @unsafe
-export let pathLink =
-  (
-    sourceFd: FileDescriptor,
-    dirFlags: List<LookupFlag>,
-    sourcePath: String,
-    targetFd: FileDescriptor,
-    targetPath: String,
-  ) => {
+provide let pathLink = (
+  sourceFd: FileDescriptor,
+  dirFlags: List<LookupFlag>,
+  sourcePath: String,
+  targetFd: FileDescriptor,
+  targetPath: String,
+) => {
   let sourceFdArg = sourceFd
   let targetFdArg = targetFd
   let sourceFd = match (sourceFd) {
@@ -1528,10 +1688,10 @@ export let pathLink =
     targetSize
   )
   if (err != Wasi._ESUCCESS) {
-    Err(Wasi.SystemError(tagSimpleNumber(err)))
-  } else {
-    Ok(void)
+    return Err(Wasi.SystemError(tagSimpleNumber(err)))
   }
+
+  return Ok(void)
 }
 
 /**
@@ -1543,14 +1703,15 @@ export let pathLink =
  * @returns `Ok(void)` if successful or `Err(exception)` otherwise
  */
 @unsafe
-export let pathSymlink =
-  (
-    fd: FileDescriptor,
-    sourcePath: String,
-    targetPath: String,
-  ) => {
+provide let pathSymlink = (
+  fd: FileDescriptor,
+  sourcePath: String,
+  targetPath: String,
+) => {
   let fdArg = fd
-  let fd = match (fd) { FileDescriptor(n) => WasmI32.fromGrain(n) >> 1n }
+  let fd = match (fd) {
+    FileDescriptor(n) => WasmI32.fromGrain(n) >> 1n,
+  }
 
   let sourcePtr = WasmI32.fromGrain(sourcePath)
   let targetPtr = WasmI32.fromGrain(targetPath)
@@ -1566,10 +1727,10 @@ export let pathSymlink =
     targetSize
   )
   if (err != Wasi._ESUCCESS) {
-    Err(Wasi.SystemError(tagSimpleNumber(err)))
-  } else {
-    Ok(void)
+    return Err(Wasi.SystemError(tagSimpleNumber(err)))
   }
+
+  return Ok(void)
 }
 
 /**
@@ -1580,19 +1741,21 @@ export let pathSymlink =
  * @returns `Ok(void)` if successful or `Err(exception)` otherwise
  */
 @unsafe
-export let pathUnlink = (fd: FileDescriptor, path: String) => {
+provide let pathUnlink = (fd: FileDescriptor, path: String) => {
   let fdArg = fd
-  let fd = match (fd) { FileDescriptor(n) => WasmI32.fromGrain(n) >> 1n }
+  let fd = match (fd) {
+    FileDescriptor(n) => WasmI32.fromGrain(n) >> 1n,
+  }
 
   let pathPtr = WasmI32.fromGrain(path)
   let pathSize = WasmI32.load(pathPtr, 4n)
 
   let err = Wasi.path_unlink_file(fd, pathPtr + 8n, pathSize)
   if (err != Wasi._ESUCCESS) {
-    Err(Wasi.SystemError(tagSimpleNumber(err)))
-  } else {
-    Ok(void)
+    return Err(Wasi.SystemError(tagSimpleNumber(err)))
   }
+
+  return Ok(void)
 }
 
 /**
@@ -1604,10 +1767,12 @@ export let pathUnlink = (fd: FileDescriptor, path: String) => {
  * @returns `Ok((contents, numBytes))` of the bytes read and the number of bytes read if successful or `Err(exception)` otherwise
  */
 @unsafe
-export let pathReadlink = (fd: FileDescriptor, path: String, size: Number) => {
+provide let pathReadlink = (fd: FileDescriptor, path: String, size: Number) => {
   let fdArg = fd
   let sizeArg = size
-  let fd = match (fd) { FileDescriptor(n) => WasmI32.fromGrain(n) >> 1n }
+  let fd = match (fd) {
+    FileDescriptor(n) => WasmI32.fromGrain(n) >> 1n,
+  }
 
   let pathPtr = WasmI32.fromGrain(path)
   let pathSize = WasmI32.load(pathPtr, 4n)
@@ -1623,13 +1788,13 @@ export let pathReadlink = (fd: FileDescriptor, path: String, size: Number) => {
   if (err != Wasi._ESUCCESS) {
     Memory.free(grainStrPtr)
     Memory.free(nread)
-    Err(Wasi.SystemError(tagSimpleNumber(err)))
-  } else {
-    let read = tagSimpleNumber(WasmI32.load(nread, 0n))
-    Memory.free(nread)
-
-    Ok((WasmI32.toGrain(grainStrPtr): String, read))
+    return Err(Wasi.SystemError(tagSimpleNumber(err)))
   }
+
+  let read = tagSimpleNumber(WasmI32.load(nread, 0n))
+  Memory.free(nread)
+
+  return Ok((WasmI32.toGrain(grainStrPtr): String, read))
 }
 
 /**
@@ -1640,19 +1805,21 @@ export let pathReadlink = (fd: FileDescriptor, path: String, size: Number) => {
  * @returns `Ok(void)` if successful or `Err(exception)` otherwise
  */
 @unsafe
-export let pathRemoveDirectory = (fd: FileDescriptor, path: String) => {
+provide let pathRemoveDirectory = (fd: FileDescriptor, path: String) => {
   let fdArg = fd
-  let fd = match (fd) { FileDescriptor(n) => WasmI32.fromGrain(n) >> 1n }
+  let fd = match (fd) {
+    FileDescriptor(n) => WasmI32.fromGrain(n) >> 1n,
+  }
 
   let pathPtr = WasmI32.fromGrain(path)
   let pathSize = WasmI32.load(pathPtr, 4n)
 
   let err = Wasi.path_remove_directory(fd, pathPtr + 8n, pathSize)
   if (err != Wasi._ESUCCESS) {
-    Err(Wasi.SystemError(tagSimpleNumber(err)))
-  } else {
-    Ok(void)
+    return Err(Wasi.SystemError(tagSimpleNumber(err)))
   }
+
+  return Ok(void)
 }
 
 /**
@@ -1665,13 +1832,12 @@ export let pathRemoveDirectory = (fd: FileDescriptor, path: String) => {
  * @returns `Ok(void)` if successful or `Err(exception)` otherwise
  */
 @unsafe
-export let pathRename =
-  (
-    sourceFd: FileDescriptor,
-    sourcePath: String,
-    targetFd: FileDescriptor,
-    targetPath: String,
-  ) => {
+provide let pathRename = (
+  sourceFd: FileDescriptor,
+  sourcePath: String,
+  targetFd: FileDescriptor,
+  targetPath: String,
+) => {
   let sourceFdArg = sourceFd
   let targetFdArg = targetFd
   let sourceFd = match (sourceFd) {
@@ -1697,8 +1863,256 @@ export let pathRename =
     targetSize
   )
   if (err != Wasi._ESUCCESS) {
-    Err(Wasi.SystemError(tagSimpleNumber(err)))
+    return Err(Wasi.SystemError(tagSimpleNumber(err)))
+  }
+
+  return Ok(void)
+}
+
+@unsafe
+let _CHAR_SLASH = 0x2fn
+@unsafe
+let _CHAR_DOT = 0x2en
+
+@unsafe
+let stripPrefixes = (path: String) => {
+  let origPathPtr = WasmI32.fromGrain(path)
+  let mut pathPtr = origPathPtr
+  let mut pathLen = WasmI32.load(pathPtr, 4n)
+  pathPtr += 8n
+
+  while (true) {
+    if (WasmI32.load8U(pathPtr, 0n) == _CHAR_SLASH) {
+      pathPtr += 1n
+      pathLen -= 1n
+    } else if (
+      WasmI32.load8U(pathPtr, 0n) == _CHAR_DOT &&
+      WasmI32.load8U(pathPtr, 1n) == _CHAR_SLASH
+    ) {
+      pathPtr += 2n
+      pathLen -= 2n
+    } else if (WasmI32.load8U(pathPtr, 0n) == _CHAR_DOT && pathLen == 1n) {
+      pathPtr += 1n
+      pathLen -= 1n
+      break
+    } else {
+      break
+    }
+  }
+
+  if (pathPtr == origPathPtr) {
+    path
+  } else {
+    let strippedPath = allocateString(pathLen)
+    Memory.copy(strippedPath + 8n, pathPtr, pathLen)
+    WasmI32.toGrain(strippedPath): String
+  }
+}
+
+let mut preopens = None
+@unsafe
+let populatePreopens = () => {
+  let mut preopenedDirs = []
+  // Skip stdin, stdout, and stderr.
+  for (let mut fd = 3n; fd != 0n; fd += 1n) {
+    let fd = FileDescriptor(tagSimpleNumber(fd))
+    match (fdPrestatGet(fd)) {
+      Ok(Dir{ prefix, fd }) =>
+        preopenedDirs = [(fd, stripPrefixes(prefix)), ...preopenedDirs],
+      // We've reached a bad file descriptor; we're done.
+      Err(Wasi.SystemError(e)) when untagSimpleNumber(e) == Wasi._EBADF =>
+        break,
+      Err(_) => fail "Failed to populate preopens",
+    }
+  }
+  preopens = Some(preopenedDirs)
+  preopenedDirs
+}
+
+@unsafe
+let prefixMatches = (prefix, prefixLen, path, pathLen) => {
+  // Allow an empty string as a prefix of any relative path.
+  if (WasmI32.load8U(path, 0n) != _CHAR_SLASH && prefixLen == 0n) {
+    return true
+  }
+
+  // Check whether any bytes of the prefix differ.
+  if (Memory.compare(path, prefix, prefixLen) != 0n) {
+    return false
+  }
+
+  // Ignore trailing slashes in directory names.
+  let mut i = prefixLen
+  while (i > 0n && WasmI32.load8U(prefix + i - 1n, 0n) == _CHAR_SLASH) {
+    i -= 1n
+  }
+
+  // Match only complete path components.
+  let last = WasmI32.load8U(path + i, 0n)
+  return last == _CHAR_SLASH || i == pathLen
+}
+
+@unsafe
+let rec findPath = (path, pathLen, preopens, bestMatch) => {
+  match (preopens) {
+    [(fd, prefix) as preopen, ...preopens] => {
+      let prefix = WasmI32.fromGrain(prefix)
+      let prefixLen = WasmI32.load(prefix, 4n)
+      let prefix = prefix + 8n
+
+      let (hasBestMatch, matchLen) = match (bestMatch) {
+        Some((matchPrefix, _)) =>
+          (
+            true,
+            tagSimpleNumber(WasmI32.load(WasmI32.fromGrain(matchPrefix), 4n)),
+          ),
+        None => (false, 0),
+      }
+
+      let bestMatch = if (
+        (!hasBestMatch || pathLen > untagSimpleNumber(matchLen)) &&
+        prefixMatches(prefix, prefixLen, path, pathLen)
+      ) {
+        Some(preopen)
+      } else {
+        bestMatch
+      }
+
+      findPath(path, pathLen, preopens, bestMatch)
+    },
+    [] => {
+      match (bestMatch) {
+        Some((fd, prefix)) => {
+          let matchLen = WasmI32.load(WasmI32.fromGrain(prefix), 4n)
+          let mut computed = path + matchLen
+          while (WasmI32.load8U(computed, 0n) == _CHAR_SLASH) {
+            computed += 1n
+          }
+          let computedPath = if (computed == path + pathLen) {
+            "."
+          } else {
+            let computedLen = path + pathLen - computed
+            let computedPath = allocateString(computedLen)
+            Memory.copy(computedPath + 8n, computed, computedLen)
+            WasmI32.toGrain(computedPath): String
+          }
+          Ok((fd, computedPath))
+        },
+        None => Err(Wasi.SystemError(tagSimpleNumber(Wasi._ENOENT))),
+      }
+    },
+  }
+}
+
+@unsafe
+let findPath = (path: String) => {
+  let pathPtr = WasmI32.fromGrain(path)
+  let mut pathLen = WasmI32.load(pathPtr, 4n)
+  let mut pathPtr = pathPtr + 8n
+
+  // ignore leading `/` characters
+  while (WasmI32.load8U(pathPtr, 0n) == _CHAR_SLASH) {
+    pathPtr += 1n
+    pathLen -= 1n
+  }
+
+  let preopens = match (preopens) {
+    Some(preopens) => preopens,
+    None => populatePreopens(),
+  }
+
+  let matchingPath = findPath(pathPtr, pathLen, preopens, None)
+  ignore(path)
+  matchingPath
+}
+
+// explicit just in case we ever want to support changing directories
+let cwd = "/"
+
+@unsafe
+let makeAbsolute = (path: String) => {
+  let origPathPtr = WasmI32.fromGrain(path)
+  let mut pathPtr = origPathPtr
+  let mut pathLen = WasmI32.load(pathPtr, 4n)
+  pathPtr += 8n
+
+  // already absolute
+  if (WasmI32.load8U(pathPtr, 0n) == _CHAR_SLASH) {
+    return path
+  }
+
+  // pointing at the current dirextory
+  if (
+    pathLen == 0n ||
+    pathLen == 1n && WasmI32.load8U(pathPtr, 0n) == _CHAR_DOT ||
+    pathLen == 2n &&
+      WasmI32.load8U(pathPtr, 0n) == _CHAR_DOT &&
+      WasmI32.load8U(pathPtr, 1n) == _CHAR_SLASH
+  ) {
+    return cwd
+  }
+
+  // strip leading ./
+  if (
+    WasmI32.load8U(pathPtr, 0n) == _CHAR_DOT &&
+    WasmI32.load8U(pathPtr, 1n) == _CHAR_SLASH
+  ) {
+    pathPtr += 2n
+    pathLen -= 2n
+  }
+
+  let mut cwdPtr = WasmI32.fromGrain(cwd)
+  let cwdLen = WasmI32.load(cwdPtr, 4n)
+  cwdPtr += 8n
+
+  let needSlash = WasmI32.load8U(cwdPtr + cwdLen - 1n, 0n) != _CHAR_SLASH
+
+  if (needSlash) {
+    let fullPath = allocateString(cwdLen + 1n + pathLen)
+    Memory.copy(fullPath + 8n, cwdPtr, cwdLen)
+    WasmI32.store8(fullPath + 8n + cwdLen, _CHAR_SLASH, 0n)
+    Memory.copy(fullPath + 8n + cwdLen + 1n, pathPtr, pathLen)
+    return WasmI32.toGrain(fullPath): String
   } else {
-    Ok(void)
+    let fullPath = allocateString(cwdLen + pathLen)
+    Memory.copy(fullPath + 8n, cwdPtr, cwdLen)
+    Memory.copy(fullPath + 8n + cwdLen, pathPtr, pathLen)
+    return WasmI32.toGrain(fullPath): String
+  }
+}
+
+/**
+ * Similar to `pathOpen`, but resolves the path relative to preopened directories.
+ *
+ * @param path: The path to the file or directory
+ * @param openFlags: Flags that decide how the path will be opened
+ * @param rights: The rights that dictate what may be done with the returned file descriptor
+ * @param rightsInheriting: The rights that dictate what may be done with file descriptors derived from this file descriptor
+ * @param flags: Flags which affect read/write operations on this file descriptor
+ * @returns `Ok(fd)` of the opened file or directory if successful or `Err(exception)` otherwise
+ *
+ * @since v0.6.0
+ */
+@unsafe
+provide let open = (
+  path: String,
+  openFlags: List<OpenFlag>,
+  rights: List<Rights>,
+  rightsInheriting: List<Rights>,
+  flags: List<FdFlag>,
+) => {
+  match (findPath(makeAbsolute(path))) {
+    Ok((fd, relativePath)) => {
+      pathOpen(
+        fd,
+        [SymlinkFollow],
+        relativePath,
+        openFlags,
+        rights,
+        rightsInheriting,
+        flags
+      )
+    },
+    Err(e) => Err(e),
   }
 }