@grain/stdlib 0.4.4 → 0.5.0

package/sys/file.gr

@@ -1,4 +1,3 @@
-/* grainc-flags --no-gc */
 /**
  * @module Sys/File: Utilities for accessing the filesystem & working with files.
  *
@@ -21,12 +20,18 @@ import WasmI32, {
   gtS as (>),
   geS as (>=),
   and as (&),
-  or 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 { tagSimpleNumber, allocateArray, allocateString, loadAdtVal, newInt64, allocateInt64 } from "runtime/dataStructures"
+import {
+  tagSimpleNumber,
+  allocateArray,
+  allocateString,
+  newInt64,
+  allocateInt64,
+} from "runtime/dataStructures"
 
 import List from "list"
 
@@ -38,7 +43,7 @@ import List from "list"
  * Represents a handle to an open file on the system.
  */
 export enum FileDescriptor {
-  FileDescriptor(Number)
+  FileDescriptor(Number),
 }
 
 /**
@@ -46,22 +51,24 @@ export enum FileDescriptor {
  */
 export enum LookupFlag {
   // Follow symlinks
-  SymlinkFollow
+  SymlinkFollow,
 }
 
 // TODO(#775): This has specific ordering requirements because of ambiguous type inference
+@unsafe
 let rec combineLookupFlagsHelp = (acc, dirflags) => {
   match (dirflags) {
     [hd, ...tl] => {
       let flag = match (hd) {
-        SymlinkFollow => Wasi._LOOKUP_FLAG_SYMLINK_FOLLOW
+        SymlinkFollow => Wasi._LOOKUP_FLAG_SYMLINK_FOLLOW,
       }
       combineLookupFlagsHelp(acc | flag, tl)
     },
-    [] => acc
+    [] => acc,
   }
 }
-let combineLookupFlags = (dirflags) => {
+@unsafe
+let combineLookupFlags = dirflags => {
   combineLookupFlagsHelp(0n, dirflags)
 }
 
@@ -80,6 +87,7 @@ export enum OpenFlag {
 }
 
 // TODO(#775): This has specific ordering requirements because of ambiguous type inference
+@unsafe
 let rec combineOpenFlagsHelp = (acc, dirflags) => {
   match (dirflags) {
     [hd, ...tl] => {
@@ -91,10 +99,11 @@ let rec combineOpenFlagsHelp = (acc, dirflags) => {
       }
       combineOpenFlagsHelp(acc | flag, tl)
     },
-    [] => acc
+    [] => acc,
   }
 }
-let combineOpenFlags = (dirflags) => {
+@unsafe
+let combineOpenFlags = dirflags => {
   combineOpenFlagsHelp(0n, dirflags)
 }
 
@@ -177,37 +186,67 @@ export enum Rights {
 
 // Grain currently cannot close over unsafe wasm i64s, so these are here in
 // module so they get inlined
+@unsafe
 let _RIGHT_FD_DATASYNC = 1N
+@unsafe
 let _RIGHT_FD_READ = 2N
+@unsafe
 let _RIGHT_FD_SEEK = 4N
+@unsafe
 let _RIGHT_FD_FDSTAT_SET_FLAGS = 8N
+@unsafe
 let _RIGHT_FD_SYNC = 16N
+@unsafe
 let _RIGHT_FD_TELL = 32N
+@unsafe
 let _RIGHT_FD_WRITE = 64N
+@unsafe
 let _RIGHT_FD_ADVISE = 128N
+@unsafe
 let _RIGHT_FD_ALLOCATE = 256N
+@unsafe
 let _RIGHT_PATH_CREATE_DIRECTORY = 512N
+@unsafe
 let _RIGHT_PATH_CREATE_FILE = 1024N
+@unsafe
 let _RIGHT_PATH_LINK_SOURCE = 2048N
+@unsafe
 let _RIGHT_PATH_LINK_TARGET = 4096N
+@unsafe
 let _RIGHT_PATH_OPEN = 8192N
+@unsafe
 let _RIGHT_FD_READDIR = 16384N
+@unsafe
 let _RIGHT_PATH_READLINK = 32768N
+@unsafe
 let _RIGHT_PATH_RENAME_SOURCE = 65536N
+@unsafe
 let _RIGHT_PATH_RENAME_TARGET = 131072N
+@unsafe
 let _RIGHT_PATH_FILESTAT_GET = 262144N
+@unsafe
 let _RIGHT_PATH_FILESTAT_SET_SIZE = 524288N
+@unsafe
 let _RIGHT_PATH_FILESTAT_SET_TIMES = 1048576N
+@unsafe
 let _RIGHT_FD_FILESTAT_GET = 2097152N
+@unsafe
 let _RIGHT_FD_FILESTAT_SET_SIZE = 4194304N
+@unsafe
 let _RIGHT_FD_FILESTAT_SET_TIMES = 8388608N
+@unsafe
 let _RIGHT_PATH_SYMLINK = 16777216N
+@unsafe
 let _RIGHT_PATH_REMOVE_DIRECTORY = 33554432N
+@unsafe
 let _RIGHT_PATH_UNLINK_FILE = 67108864N
+@unsafe
 let _RIGHT_POLL_FD_READWRITE = 134217728N
+@unsafe
 let _RIGHT_SOCK_SHUTDOWN = 268435456N
 
 // TODO(#775): This has specific ordering requirements because of ambiguous type inference
+@unsafe
 let rec combineRightsHelp = (acc, dirflags) => {
   match (dirflags) {
     [] => acc,
@@ -242,13 +281,19 @@ let rec combineRightsHelp = (acc, dirflags) => {
         PathUnlinkFile => _RIGHT_PATH_UNLINK_FILE,
         PollFdReadwrite => _RIGHT_POLL_FD_READWRITE,
         SockShutdown => _RIGHT_SOCK_SHUTDOWN,
-        _ => fail "Unknown file right"
+        _ => {
+          ignore(fail "Unknown file right")
+          // `fail` won't allow us to get here, but this is necessary
+          // to make the wasm types work out
+          0N
+        },
       }
       combineRightsHelp(WasmI64.or(flag, acc), tl)
-    }
+    },
   }
 }
-let combineRights = (dirflags) => {
+@unsafe
+let combineRights = dirflags => {
   combineRightsHelp(0N, dirflags)
 }
 
@@ -271,6 +316,7 @@ export enum FdFlag {
 }
 
 // TODO(#775): This has specific ordering requirements because of ambiguous type inference
+@unsafe
 let rec combineFdFlagsHelp = (acc, dirflags) => {
   match (dirflags) {
     [hd, ...tl] => {
@@ -283,10 +329,11 @@ let rec combineFdFlagsHelp = (acc, dirflags) => {
       }
       combineFdFlagsHelp(acc | flag, tl)
     },
-    [] => acc
+    [] => acc,
   }
 }
-let combineFdFlags = (dirflags) => {
+@unsafe
+let combineFdFlags = dirflags => {
   combineFdFlagsHelp(0n, dirflags)
 }
 
@@ -313,7 +360,8 @@ export enum Filetype {
 }
 
 // TODO(#775): This has specific ordering requirements because of ambiguous type inference
-let filetypeFromNumber = (filetype) => {
+@unsafe
+let filetypeFromNumber = filetype => {
   match (filetype) {
     0n => Unknown,
     1n => BlockDevice,
@@ -323,7 +371,7 @@ let filetypeFromNumber = (filetype) => {
     5n => SocketDatagram,
     6n => SocketStream,
     7n => SymbolicLink,
-    _ => fail "Unknown filetype"
+    _ => fail "Unknown filetype",
   }
 }
 
@@ -346,7 +394,7 @@ export record Stats {
   filetype: Filetype,
   flags: List<FdFlag>,
   rights: List<Rights>,
-  rightsInheriting: List<Rights>
+  rightsInheriting: List<Rights>,
 }
 
 /**
@@ -360,7 +408,7 @@ export record Filestats {
   size: Int64,
   accessed: Int64,
   modified: Int64,
-  changed: Int64
+  changed: Int64,
 }
 
 /**
@@ -369,7 +417,7 @@ export record Filestats {
 export record DirectoryEntry {
   inode: Int64,
   filetype: Filetype,
-  path: String
+  path: String,
 }
 
 /**
@@ -393,18 +441,6 @@ export let stderr = FileDescriptor(2)
  */
 export let pwdfd = FileDescriptor(3)
 
-let wasmSafeOk = (val) => {
-  Memory.incRef(WasmI32.fromGrain(Ok))
-  Memory.incRef(WasmI32.fromGrain(val))
-  Ok(val)
-}
-
-let wasmSafeErr = (err) => {
-  Memory.incRef(WasmI32.fromGrain(Err))
-  Memory.incRef(WasmI32.fromGrain(err))
-  Err(err)
-}
-
 /**
  * Open a file or directory.
  *
@@ -417,21 +453,21 @@ let wasmSafeErr = (err) => {
  * @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
  */
-export let rec pathOpen = (
-  dirFd: FileDescriptor,
-  dirFlags: List<LookupFlag>,
-  path: String,
-  openFlags: List<OpenFlag>,
-  rights: List<Rights>,
-  rightsInheriting: List<Rights>,
-  flags: List<FdFlag>
-) => {
+@unsafe
+export 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)
 
@@ -459,25 +495,16 @@ export let rec pathOpen = (
     combinedFsFlags,
     newFd
   )
-  let ret = if (err != Wasi._ESUCCESS) {
+  if (err != Wasi._ESUCCESS) {
     Memory.free(newFd)
-    wasmSafeErr(Wasi.SystemError(tagSimpleNumber(err)))
+    Err(Wasi.SystemError(tagSimpleNumber(err)))
   } else {
     let fd = FileDescriptor(tagSimpleNumber(WasmI32.load(newFd, 0n)))
 
     Memory.free(newFd)
 
-    wasmSafeOk(fd)
+    Ok(fd)
   }
-  Memory.decRef(WasmI32.fromGrain(dirFdArg))
-  Memory.decRef(WasmI32.fromGrain(dirFlags))
-  Memory.decRef(WasmI32.fromGrain(pathArg))
-  Memory.decRef(WasmI32.fromGrain(openFlags))
-  Memory.decRef(WasmI32.fromGrain(rights))
-  Memory.decRef(WasmI32.fromGrain(rightsInheritingArg))
-  Memory.decRef(WasmI32.fromGrain(flags))
-  Memory.decRef(WasmI32.fromGrain(pathOpen))
-  ret
 }
 
 /**
@@ -487,27 +514,26 @@ export let rec pathOpen = (
  * @param size: The maximum number of bytes to read from the file descriptor
  * @returns `Ok((contents, numBytes))` of bytes read and the number of bytes read if successful or `Err(exception)` otherwise
  */
-export let rec fdRead = (fd: FileDescriptor, size: Number) => {
+@unsafe
+export 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)
 
-  WasmI32.store(iovs, strPtr + (2n * 4n), 0n)
+  WasmI32.store(iovs, strPtr + 2n * 4n, 0n)
   WasmI32.store(iovs, n, 4n)
 
-  let mut nread = iovs + (3n * 4n)
+  let mut nread = iovs + 3n * 4n
 
   let err = Wasi.fd_read(fd, iovs, 1n, nread)
-  let ret = if (err != Wasi._ESUCCESS) {
+  if (err != Wasi._ESUCCESS) {
     Memory.free(iovs)
     Memory.free(strPtr)
-    wasmSafeErr(Wasi.SystemError(tagSimpleNumber(err)))
+    Err(Wasi.SystemError(tagSimpleNumber(err)))
   } else {
     nread = WasmI32.load(nread, 0n)
 
@@ -515,12 +541,8 @@ export let rec fdRead = (fd: FileDescriptor, size: Number) => {
 
     Memory.free(iovs)
 
-    wasmSafeOk((WasmI32.toGrain(strPtr): String, tagSimpleNumber(nread)))
+    Ok((WasmI32.toGrain(strPtr): String, tagSimpleNumber(nread)))
   }
-  Memory.decRef(WasmI32.fromGrain(fd))
-  Memory.decRef(WasmI32.fromGrain(size))
-  Memory.decRef(WasmI32.fromGrain(fdRead))
-  ret
 }
 
 /**
@@ -531,12 +553,11 @@ export let rec fdRead = (fd: FileDescriptor, size: Number) => {
  * @param size: The maximum number of bytes to read from the file descriptor
  * @returns `Ok((contents, numBytes))` of bytes read and the number of bytes read if successful or `Err(exception)` otherwise
  */
-export let rec fdPread = (fd: FileDescriptor, offset: Int64, size: Number) => {
+@unsafe
+export 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)
 
@@ -545,16 +566,16 @@ export let rec fdPread = (fd: FileDescriptor, offset: Int64, size: Number) => {
   let iovs = Memory.malloc(3n * 4n)
   let strPtr = allocateString(n)
 
-  WasmI32.store(iovs, strPtr + (2n * 4n), 0n)
+  WasmI32.store(iovs, strPtr + 2n * 4n, 0n)
   WasmI32.store(iovs, n, 4n)
 
-  let mut nread = iovs + (3n * 4n)
+  let mut nread = iovs + 3n * 4n
 
   let err = Wasi.fd_pread(fd, iovs, 1n, offset, nread)
-  let ret = if (err != Wasi._ESUCCESS) {
+  if (err != Wasi._ESUCCESS) {
     Memory.free(iovs)
     Memory.free(strPtr)
-    wasmSafeErr(Wasi.SystemError(tagSimpleNumber(err)))
+    Err(Wasi.SystemError(tagSimpleNumber(err)))
   } else {
     nread = WasmI32.load(nread, 0n)
 
@@ -562,13 +583,8 @@ export let rec fdPread = (fd: FileDescriptor, offset: Int64, size: Number) => {
 
     Memory.free(iovs)
 
-    wasmSafeOk((WasmI32.toGrain(strPtr): String, tagSimpleNumber(nread)))
+    Ok((WasmI32.toGrain(strPtr): String, tagSimpleNumber(nread)))
   }
-  Memory.decRef(WasmI32.fromGrain(fdArg))
-  Memory.decRef(WasmI32.fromGrain(offsetArg))
-  Memory.decRef(WasmI32.fromGrain(size))
-  Memory.decRef(WasmI32.fromGrain(fdPread))
-  ret
 }
 
 /**
@@ -578,11 +594,10 @@ export let rec fdPread = (fd: FileDescriptor, offset: Int64, size: Number) => {
  * @param data: The data to be written
  * @returns `Ok(numBytes)` of the number of bytes written if successful or `Err(Exception)` otherwise
  */
-export let rec fdWrite = (fd: FileDescriptor, data: String) => {
+@unsafe
+export let fdWrite = (fd: FileDescriptor, data: 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 iovs = Memory.malloc(3n * 4n)
   let strPtr = WasmI32.fromGrain(data)
@@ -590,23 +605,19 @@ export let rec fdWrite = (fd: FileDescriptor, data: String) => {
   WasmI32.store(iovs, strPtr + 8n, 0n)
   WasmI32.store(iovs, WasmI32.load(strPtr, 4n), 4n)
 
-  let mut nwritten = iovs + (3n * 4n)
+  let mut nwritten = iovs + 3n * 4n
 
   let err = Wasi.fd_write(fd, iovs, 1n, nwritten)
-  let ret = if (err != Wasi._ESUCCESS) {
+  if (err != Wasi._ESUCCESS) {
     Memory.free(iovs)
-    wasmSafeErr(Wasi.SystemError(tagSimpleNumber(err)))
+    Err(Wasi.SystemError(tagSimpleNumber(err)))
   } else {
     nwritten = WasmI32.load(nwritten, 0n)
 
     Memory.free(iovs)
 
-    wasmSafeOk(tagSimpleNumber(nwritten))
+    Ok(tagSimpleNumber(nwritten))
   }
-  Memory.decRef(WasmI32.fromGrain(fdArg))
-  Memory.decRef(WasmI32.fromGrain(data))
-  Memory.decRef(WasmI32.fromGrain(fdWrite))
-  ret
 }
 
 /**
@@ -617,39 +628,33 @@ export let rec fdWrite = (fd: FileDescriptor, data: String) => {
  * @param offset: The position within the file to begin writing
  * @returns `Ok(numBytes)` of the number of bytes written if successful or `Err(exception)` otherwise
  */
-export let rec fdPwrite = (fd: FileDescriptor, data: String, offset: Int64) => {
+@unsafe
+export let fdPwrite = (fd: FileDescriptor, data: String, 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)
 
-  WasmI32.store(iovs, strPtr + (2n * 4n), 0n)
+  WasmI32.store(iovs, strPtr + 2n * 4n, 0n)
   WasmI32.store(iovs, WasmI32.load(strPtr, 4n), 4n)
 
   let offset = WasmI64.load(WasmI32.fromGrain(offset), 8n)
 
-  let mut nwritten = iovs + (3n * 4n)
+  let mut nwritten = iovs + 3n * 4n
 
   let err = Wasi.fd_pwrite(fd, iovs, 1n, offset, nwritten)
-  let ret = if (err != Wasi._ESUCCESS) {
+  if (err != Wasi._ESUCCESS) {
     Memory.free(iovs)
-    wasmSafeErr(Wasi.SystemError(tagSimpleNumber(err)))
+    Err(Wasi.SystemError(tagSimpleNumber(err)))
   } else {
     nwritten = WasmI32.load(nwritten, 0n)
 
     Memory.free(iovs)
 
-    wasmSafeOk(tagSimpleNumber(nwritten))
+    Ok(tagSimpleNumber(nwritten))
   }
-  Memory.decRef(WasmI32.fromGrain(fdArg))
-  Memory.decRef(WasmI32.fromGrain(data))
-  Memory.decRef(WasmI32.fromGrain(offsetArg))
-  Memory.decRef(WasmI32.fromGrain(fdPwrite))
-  ret
 }
 
 /**
@@ -660,29 +665,23 @@ export let rec fdPwrite = (fd: FileDescriptor, data: String, offset: Int64) => {
  * @param size: The number of bytes to allocate
  * @returns `Ok(void)` if successful or `Err(exception)` otherwise
  */
-export let rec fdAllocate = (fd: FileDescriptor, offset: Int64, size: Int64) => {
+@unsafe
+export 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)
 
   let size = WasmI64.load(WasmI32.fromGrain(size), 8n)
 
   let err = Wasi.fd_allocate(fd, offset, size)
-  let ret = if (err != Wasi._ESUCCESS) {
-    wasmSafeErr(Wasi.SystemError(tagSimpleNumber(err)))
+  if (err != Wasi._ESUCCESS) {
+    Err(Wasi.SystemError(tagSimpleNumber(err)))
   } else {
-    wasmSafeOk(void)
+    Ok(void)
   }
-  Memory.decRef(WasmI32.fromGrain(fdArg))
-  Memory.decRef(WasmI32.fromGrain(offsetArg))
-  Memory.decRef(WasmI32.fromGrain(sizeArg))
-  Memory.decRef(WasmI32.fromGrain(fdAllocate))
-  ret
 }
 
 /**
@@ -691,21 +690,17 @@ export let rec fdAllocate = (fd: FileDescriptor, offset: Int64, size: Int64) =>
  * @param fd: The file descriptor to close
  * @returns `Ok(void)` if successful or `Err(exception)` otherwise
  */
-export let rec fdClose = (fd: FileDescriptor) => {
+@unsafe
+export 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)
-  let ret = if (err != Wasi._ESUCCESS) {
-    wasmSafeErr(Wasi.SystemError(tagSimpleNumber(err)))
+  if (err != Wasi._ESUCCESS) {
+    Err(Wasi.SystemError(tagSimpleNumber(err)))
   } else {
-    wasmSafeOk(void)
+    Ok(void)
   }
-  Memory.decRef(WasmI32.fromGrain(fdArg))
-  Memory.decRef(WasmI32.fromGrain(fdClose))
-  ret
 }
 
 /**
@@ -714,21 +709,17 @@ export let rec fdClose = (fd: FileDescriptor) => {
  * @param fd: The file descriptor to synchronize
  * @returns `Ok(void)` if successful or `Err(exception)` otherwise
  */
-export let rec fdDatasync = (fd: FileDescriptor) => {
+@unsafe
+export 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)
-  let ret = if (err != Wasi._ESUCCESS) {
-    wasmSafeErr(Wasi.SystemError(tagSimpleNumber(err)))
+  if (err != Wasi._ESUCCESS) {
+    Err(Wasi.SystemError(tagSimpleNumber(err)))
   } else {
-    wasmSafeOk(void)
+    Ok(void)
   }
-  Memory.decRef(WasmI32.fromGrain(fdArg))
-  Memory.decRef(WasmI32.fromGrain(fdDatasync))
-  ret
 }
 
 /**
@@ -737,37 +728,51 @@ export let rec fdDatasync = (fd: FileDescriptor) => {
  * @param fd: The file descriptor to synchronize
  * @returns `Ok(void)` if successful or `Err(exception)` otherwise
  */
-export let rec fdSync = (fd: FileDescriptor) => {
+@unsafe
+export 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)
-  let ret = if (err != Wasi._ESUCCESS) {
-    wasmSafeErr(Wasi.SystemError(tagSimpleNumber(err)))
+  if (err != Wasi._ESUCCESS) {
+    Err(Wasi.SystemError(tagSimpleNumber(err)))
   } else {
-    wasmSafeOk(void)
+    Ok(void)
   }
-  Memory.decRef(WasmI32.fromGrain(fdArg))
-  Memory.decRef(WasmI32.fromGrain(fdSync))
-  ret
-}
-
-
-let wasmSafeCons = (a, b) => {
-  // [TODO] Once grain-lang/grain#802 is fixed:
-  // Memory.incRef(WasmI32.fromGrain([...]))
-  Memory.incRef(WasmI32.fromGrain(cons))
-  Memory.incRef(WasmI32.fromGrain(a))
-  Memory.incRef(WasmI32.fromGrain(b))
-  cons(a, b)
-  // [TODO] Once grain-lang/grain#802 is fixed:
-  // [a, ...b]
 }
 
-let orderedFdflags = wasmSafeCons(Append, wasmSafeCons(Dsync, wasmSafeCons(Nonblock, wasmSafeCons(Rsync, wasmSafeCons(Sync, [])))))
-let orderedRights = wasmSafeCons(FdDatasync, wasmSafeCons(FdRead, wasmSafeCons(FdSeek, wasmSafeCons(FdSetFlags, wasmSafeCons(FdSync, wasmSafeCons(FdTell, wasmSafeCons(FdWrite, wasmSafeCons(FdAdvise, wasmSafeCons(FdAllocate, wasmSafeCons(PathCreateDirectory, wasmSafeCons(PathCreateFile, wasmSafeCons(PathLinkSource, wasmSafeCons(PathLinkTarget, wasmSafeCons(PathOpen, wasmSafeCons(FdReaddir, wasmSafeCons(PathReadlink, wasmSafeCons(PathRenameSource, wasmSafeCons(PathRenameTarget, wasmSafeCons(PathFilestats, wasmSafeCons(PathSetSize, wasmSafeCons(PathSetTimes, wasmSafeCons(FdFilestats, wasmSafeCons(FdSetSize, wasmSafeCons(FdSetTimes, wasmSafeCons(PathSymlink, wasmSafeCons(PathRemoveDirectory, wasmSafeCons(PathUnlinkFile, wasmSafeCons(PollFdReadwrite, wasmSafeCons(SockShutdown, [])))))))))))))))))))))))))))))
+let orderedFdflags = [Append, Dsync, Nonblock, Rsync, Sync]
+let orderedRights = [
+  FdDatasync,
+  FdRead,
+  FdSeek,
+  FdSetFlags,
+  FdSync,
+  FdTell,
+  FdWrite,
+  FdAdvise,
+  FdAllocate,
+  PathCreateDirectory,
+  PathCreateFile,
+  PathLinkSource,
+  PathLinkTarget,
+  PathOpen,
+  FdReaddir,
+  PathReadlink,
+  PathRenameSource,
+  PathRenameTarget,
+  PathFilestats,
+  PathSetSize,
+  PathSetTimes,
+  FdFilestats,
+  FdSetSize,
+  FdSetTimes,
+  PathSymlink,
+  PathRemoveDirectory,
+  PathUnlinkFile,
+  PollFdReadwrite,
+  SockShutdown,
+]
 
 /**
  * Retrieve information about a file descriptor.
@@ -775,18 +780,17 @@ let orderedRights = wasmSafeCons(FdDatasync, wasmSafeCons(FdRead, wasmSafeCons(F
  * @param fd: The file descriptor of which to retrieve information
  * @returns `Ok(stats)` of the `Stats` associated with the file descriptor if successful or `Err(exception)` otherwise
  */
-export let rec fdStats = (fd: FileDescriptor) => {
+@unsafe
+export 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)
-  let ret = if (err != Wasi._ESUCCESS) {
+  if (err != Wasi._ESUCCESS) {
     Memory.free(structPtr)
-    wasmSafeErr(Wasi.SystemError(tagSimpleNumber(err)))
+    Err(Wasi.SystemError(tagSimpleNumber(err)))
   } else {
     let filetype = WasmI32.load8U(structPtr, 0n)
 
@@ -794,13 +798,9 @@ export let rec fdStats = (fd: FileDescriptor) => {
 
     let flagsToWasmVal = (flag, i) => {
       let fdflags = WasmI32.load16U(structPtr, 4n)
-      WasmI32.gtU((fdflags & (1n << (WasmI32.fromGrain(i) >> 1n))), 0n)
+      WasmI32.gtU(fdflags & 1n << (WasmI32.fromGrain(i) >> 1n), 0n)
     }
-    Memory.incRef(WasmI32.fromGrain(List.filteri))
-    Memory.incRef(WasmI32.fromGrain(flagsToWasmVal))
-    Memory.incRef(WasmI32.fromGrain(orderedFdflags))
     let fdflagsList = List.filteri(flagsToWasmVal, orderedFdflags)
-    Memory.free(WasmI32.fromGrain(flagsToWasmVal))
 
     let (&) = WasmI64.and
     let (>) = WasmI64.gtU
@@ -808,31 +808,29 @@ export let rec fdStats = (fd: FileDescriptor) => {
 
     let flagsToWasmVal = (flag, i) => {
       let rights = WasmI64.load(structPtr, 8n)
-      (rights & (1N << WasmI64.extendI32U(WasmI32.fromGrain(i) >> 1n))) > 0N
+      (rights & 1N << WasmI64.extendI32U(WasmI32.fromGrain(i) >> 1n)) > 0N
     }
-    Memory.incRef(WasmI32.fromGrain(List.filteri))
-    Memory.incRef(WasmI32.fromGrain(flagsToWasmVal))
-    Memory.incRef(WasmI32.fromGrain(orderedRights))
     let rightsList = List.filteri(flagsToWasmVal, orderedRights)
-    Memory.free(WasmI32.fromGrain(flagsToWasmVal))
 
     let flagsToWasmVal = (flag, i) => {
       let rightsInheriting = WasmI64.load(structPtr, 16n)
-      (rightsInheriting & (1N << WasmI64.extendI32U(WasmI32.fromGrain(i) >> 1n))) > 0N
+      (rightsInheriting &
+        1N << WasmI64.extendI32U(WasmI32.fromGrain(i) >> 1n)) >
+      0N
     }
-    Memory.incRef(WasmI32.fromGrain(List.filteri))
-    Memory.incRef(WasmI32.fromGrain(flagsToWasmVal))
-    Memory.incRef(WasmI32.fromGrain(orderedRights))
     let rightsInheritingList = List.filteri(flagsToWasmVal, orderedRights)
-    Memory.free(WasmI32.fromGrain(flagsToWasmVal))
 
     Memory.free(structPtr)
 
-    wasmSafeOk({ filetype, flags: fdflagsList, rights: rightsList, rightsInheriting: rightsInheritingList })
+    Ok(
+      {
+        filetype,
+        flags: fdflagsList,
+        rights: rightsList,
+        rightsInheriting: rightsInheritingList,
+      }
+    )
   }
-  Memory.decRef(WasmI32.fromGrain(fdArg))
-  Memory.decRef(WasmI32.fromGrain(fdStats))
-  ret
 }
 
 /**
@@ -842,25 +840,20 @@ export let rec fdStats = (fd: FileDescriptor) => {
  * @param flags: The flags to apply to the file descriptor
  * @returns `Ok(void)` if successful or `Err(exception)` otherwise
  */
-export let rec fdSetFlags = (fd: FileDescriptor, flags: List<FdFlag>) => {
+@unsafe
+export 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)
-  let ret = if (err != Wasi._ESUCCESS) {
-    wasmSafeErr(Wasi.SystemError(tagSimpleNumber(err)))
+  if (err != Wasi._ESUCCESS) {
+    Err(Wasi.SystemError(tagSimpleNumber(err)))
   } else {
-    wasmSafeOk(void)
+    Ok(void)
   }
-  Memory.decRef(WasmI32.fromGrain(fdArg))
-  Memory.decRef(WasmI32.fromGrain(flagsArg))
-  Memory.decRef(WasmI32.fromGrain(fdSetFlags))
-  ret
 }
 
 /**
@@ -871,28 +864,27 @@ export let rec fdSetFlags = (fd: FileDescriptor, flags: List<FdFlag>) => {
  * @param rightsInheriting: Inheriting rights to apply to the file descriptor
  * @returns `Ok(void)` if successful or `Err(exception)` otherwise
  */
-export let rec fdSetRights = (fd: FileDescriptor, rights: List<Rights>, rightsInheriting: List<Rights>) => {
+@unsafe
+export 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)
-  let ret = if (err != Wasi._ESUCCESS) {
-    wasmSafeErr(Wasi.SystemError(tagSimpleNumber(err)))
+  if (err != Wasi._ESUCCESS) {
+    Err(Wasi.SystemError(tagSimpleNumber(err)))
   } else {
-    wasmSafeOk(void)
+    Ok(void)
   }
-  Memory.decRef(WasmI32.fromGrain(fdArg))
-  Memory.decRef(WasmI32.fromGrain(rightsArg))
-  Memory.decRef(WasmI32.fromGrain(rightsInheritingArg))
-  Memory.decRef(WasmI32.fromGrain(fdSetRights))
-  ret
 }
 
 /**
@@ -901,35 +893,39 @@ export let rec fdSetRights = (fd: FileDescriptor, rights: List<Rights>, rightsIn
  * @param fd: The file descriptor of the file to retrieve information
  * @returns `Ok(info)` of the `Filestats` associated with the file descriptor if successful or `Err(exception)` otherwise
  */
-export let rec fdFilestats = (fd: FileDescriptor) => {
+@unsafe
+export 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)
-  let ret = if (err != Wasi._ESUCCESS) {
+  if (err != Wasi._ESUCCESS) {
     Memory.free(filestats)
-    wasmSafeErr(Wasi.SystemError(tagSimpleNumber(err)))
+    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 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 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
 
     Memory.free(filestats)
 
-    wasmSafeOk({ device, inode, filetype, linkcount, size, accessed, modified, changed })
+    Ok(
+      { device, inode, filetype, linkcount, size, accessed, modified, changed }
+    )
   }
-  Memory.decRef(WasmI32.fromGrain(fdArg))
-  Memory.decRef(WasmI32.fromGrain(fdFilestats))
-  ret
 }
 
 /**
@@ -939,25 +935,20 @@ export let rec fdFilestats = (fd: FileDescriptor) => {
  * @param size: The number of bytes to retain in the file
  * @returns `Ok(void)` if successful or `Err(exception)` otherwise
  */
-export let rec fdSetSize = (fd: FileDescriptor, size: Int64) => {
+@unsafe
+export 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)
-  let ret = if (err != Wasi._ESUCCESS) {
-    wasmSafeErr(Wasi.SystemError(tagSimpleNumber(err)))
+  if (err != Wasi._ESUCCESS) {
+    Err(Wasi.SystemError(tagSimpleNumber(err)))
   } else {
-    wasmSafeOk(void)
+    Ok(void)
   }
-  Memory.decRef(WasmI32.fromGrain(fdArg))
-  Memory.decRef(WasmI32.fromGrain(sizeArg))
-  Memory.decRef(WasmI32.fromGrain(fdSetSize))
-  ret
 }
 
 /**
@@ -967,24 +958,19 @@ export let rec fdSetSize = (fd: FileDescriptor, size: Int64) => {
  * @param timestamp: The time to set
  * @returns `Ok(void)` if successful or `Err(exception)` otherwise
  */
-export let rec fdSetAccessTime = (fd: FileDescriptor, timestamp: Int64) => {
+@unsafe
+export 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)
-  let ret = if (err != Wasi._ESUCCESS) {
-    wasmSafeErr(Wasi.SystemError(tagSimpleNumber(err)))
+  if (err != Wasi._ESUCCESS) {
+    Err(Wasi.SystemError(tagSimpleNumber(err)))
   } else {
-    wasmSafeOk(void)
+    Ok(void)
   }
-  Memory.decRef(WasmI32.fromGrain(fdArg))
-  Memory.decRef(WasmI32.fromGrain(timestamp))
-  Memory.decRef(WasmI32.fromGrain(fdSetAccessTime))
-  ret
 }
 
 /**
@@ -993,21 +979,17 @@ export let rec fdSetAccessTime = (fd: FileDescriptor, timestamp: Int64) => {
  * @param fd: The file descriptor of the file to update
  * @returns `Ok(void)` if successful or `Err(exception)` otherwise
  */
-export let rec fdSetAccessTimeNow = (fd: FileDescriptor) => {
+@unsafe
+export 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)
-  let ret = if (err != Wasi._ESUCCESS) {
-    wasmSafeErr(Wasi.SystemError(tagSimpleNumber(err)))
+  if (err != Wasi._ESUCCESS) {
+    Err(Wasi.SystemError(tagSimpleNumber(err)))
   } else {
-    wasmSafeOk(void)
+    Ok(void)
   }
-  Memory.decRef(WasmI32.fromGrain(fdArg))
-  Memory.decRef(WasmI32.fromGrain(fdSetAccessTimeNow))
-  ret
 }
 
 /**
@@ -1017,24 +999,19 @@ export let rec fdSetAccessTimeNow = (fd: FileDescriptor) => {
  * @param timestamp: The time to set
  * @returns `Ok(void)` if successful or `Err(exception)` otherwise
  */
-export let rec fdSetModifiedTime = (fd: FileDescriptor, timestamp: Int64) => {
+@unsafe
+export 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)
-  let ret = if (err != Wasi._ESUCCESS) {
-    wasmSafeErr(Wasi.SystemError(tagSimpleNumber(err)))
+  if (err != Wasi._ESUCCESS) {
+    Err(Wasi.SystemError(tagSimpleNumber(err)))
   } else {
-    wasmSafeOk(void)
+    Ok(void)
   }
-  Memory.decRef(WasmI32.fromGrain(fdArg))
-  Memory.decRef(WasmI32.fromGrain(timestamp))
-  Memory.decRef(WasmI32.fromGrain(fdSetModifiedTime))
-  ret
 }
 
 /**
@@ -1043,21 +1020,17 @@ export let rec fdSetModifiedTime = (fd: FileDescriptor, timestamp: Int64) => {
  * @param fd: The file descriptor of the file to update
  * @returns `Ok(void)` if successful or `Err(exception)` otherwise
  */
-export let rec fdSetModifiedTimeNow = (fd: FileDescriptor) => {
+@unsafe
+export 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)
-  let ret = if (err != Wasi._ESUCCESS) {
-    wasmSafeErr(Wasi.SystemError(tagSimpleNumber(err)))
+  if (err != Wasi._ESUCCESS) {
+    Err(Wasi.SystemError(tagSimpleNumber(err)))
   } else {
-    wasmSafeOk(void)
+    Ok(void)
   }
-  Memory.decRef(WasmI32.fromGrain(fdArg))
-  Memory.decRef(WasmI32.fromGrain(fdSetModifiedTime))
-  ret
 }
 
 /**
@@ -1066,11 +1039,10 @@ export let rec fdSetModifiedTimeNow = (fd: FileDescriptor) => {
  * @param fd: The directory to read
  * @returns `Ok(dirEntries)` of an array of `DirectoryEntry` for each entry in the directory if successful or `Err(exception)` otherwise
  */
-export let rec fdReaddir = (fd: FileDescriptor) => {
+@unsafe
+export 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
 
@@ -1081,17 +1053,17 @@ export let rec fdReaddir = (fd: FileDescriptor) => {
   let mut bufLen = structWidth
 
   let err = Wasi.fd_readdir(fd, buf, bufLen, cookie, bufUsed)
-  let ret = if (err != Wasi._ESUCCESS) {
+  if (err != Wasi._ESUCCESS) {
     Memory.free(buf)
     Memory.free(bufUsed)
-    wasmSafeErr(Wasi.SystemError(tagSimpleNumber(err)))
+    Err(Wasi.SystemError(tagSimpleNumber(err)))
   } else {
     let used = WasmI32.load(bufUsed, 0n)
 
     if (used <= 0n) {
       Memory.free(buf)
       Memory.free(bufUsed)
-      wasmSafeOk(WasmI32.toGrain(allocateArray(0n)): Array<DirectoryEntry>)
+      Ok(WasmI32.toGrain(allocateArray(0n)): Array<DirectoryEntry>)
     } else {
       bufLen = WasmI32.load(buf, 16n) + structWidth * 2n
 
@@ -1167,14 +1139,11 @@ export let rec fdReaddir = (fd: FileDescriptor) => {
             bufs = next
           }
 
-          wasmSafeOk(WasmI32.toGrain(arr): Array<DirectoryEntry>)
-        }
+          Ok(WasmI32.toGrain(arr): Array<DirectoryEntry>)
+        },
       }
     }
   }
-  Memory.decRef(WasmI32.fromGrain(fdArg))
-  Memory.decRef(WasmI32.fromGrain(fdReaddir))
-  ret
 }
 
 /**
@@ -1184,27 +1153,22 @@ export let rec fdReaddir = (fd: FileDescriptor) => {
  * @param toFd: The file descriptor to overwrite
  * @returns `Ok(void)` if successful or `Err(exception)` otherwise
  */
-export let rec fdRenumber = (fromFd: FileDescriptor, toFd: FileDescriptor) => {
+@unsafe
+export let fdRenumber = (fromFd: FileDescriptor, toFd: FileDescriptor) => {
   let fromFdArg = fromFd
   let toFdArg = toFd
   let fromFd = match (fromFd) {
-    FileDescriptor(n) => WasmI32.fromGrain(n) >> 1n
+    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)
-  let ret = if (err != Wasi._ESUCCESS) {
-    wasmSafeErr(Wasi.SystemError(tagSimpleNumber(err)))
+  if (err != Wasi._ESUCCESS) {
+    Err(Wasi.SystemError(tagSimpleNumber(err)))
   } else {
-    wasmSafeOk(void)
+    Ok(void)
   }
-  Memory.decRef(WasmI32.fromGrain(fromFdArg))
-  Memory.decRef(WasmI32.fromGrain(toFdArg))
-  Memory.decRef(WasmI32.fromGrain(fdRenumber))
-  ret
 }
 
 /**
@@ -1215,37 +1179,31 @@ export let rec fdRenumber = (fromFd: FileDescriptor, toFd: FileDescriptor) => {
  * @param whence: The location from which the offset is relative
  * @returns `Ok(offset)` of the new offset of the file descriptor, relative to the start of the file, if successful or `Err(exception)` otherwise
  */
-export let rec fdSeek = (fd: FileDescriptor, offset: Int64, whence: Whence) => {
+@unsafe
+export 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)
 
   let whence = match (whence) {
     Set => Wasi._WHENCE_SET,
     Current => Wasi._WHENCE_CUR,
-    End => Wasi._WHENCE_END
+    End => Wasi._WHENCE_END,
   }
 
   let newoffset = allocateInt64()
   let newoffsetPtr = newoffset + 8n
 
   let err = Wasi.fd_seek(fd, offset, whence, newoffsetPtr)
-  let ret = if (err != Wasi._ESUCCESS) {
+  if (err != Wasi._ESUCCESS) {
     Memory.free(newoffset)
-    wasmSafeErr(Wasi.SystemError(tagSimpleNumber(err)))
+    Err(Wasi.SystemError(tagSimpleNumber(err)))
   } else {
-    wasmSafeOk(WasmI32.toGrain(newoffset): Int64)
+    Ok(WasmI32.toGrain(newoffset): Int64)
   }
-  Memory.decRef(WasmI32.fromGrain(fdArg))
-  Memory.decRef(WasmI32.fromGrain(offsetArg))
-  Memory.decRef(WasmI32.fromGrain(whenceArg))
-  Memory.decRef(WasmI32.fromGrain(fdSeek))
-  ret
 }
 
 /**
@@ -1254,25 +1212,21 @@ export let rec fdSeek = (fd: FileDescriptor, offset: Int64, whence: Whence) => {
  * @param fd: The file descriptor to read the offset
  * @returns `Ok(offset)` of the offset of the file descriptor, relative to the start of the file, if successful or `Err(exception)` otherwise
  */
-export let rec fdTell = (fd: FileDescriptor) => {
+@unsafe
+export 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
 
   let err = Wasi.fd_tell(fd, offsetPtr)
-  let ret = if (err != Wasi._ESUCCESS) {
+  if (err != Wasi._ESUCCESS) {
     Memory.free(offset)
-    wasmSafeErr(Wasi.SystemError(tagSimpleNumber(err)))
+    Err(Wasi.SystemError(tagSimpleNumber(err)))
   } else {
-    wasmSafeOk(WasmI32.toGrain(offset): Int64)
+    Ok(WasmI32.toGrain(offset): Int64)
   }
-  Memory.decRef(WasmI32.fromGrain(fdArg))
-  Memory.decRef(WasmI32.fromGrain(fdTell))
-  ret
 }
 
 /**
@@ -1282,26 +1236,21 @@ export let rec fdTell = (fd: FileDescriptor) => {
  * @param path: The path to the new directory
  * @returns `Ok(void)` if successful or `Err(exception)` otherwise
  */
-export let rec pathCreateDirectory = (fd: FileDescriptor, path: String) => {
+@unsafe
+export 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)
 
   let size = WasmI32.load(stringPtr, 4n)
 
   let err = Wasi.path_create_directory(fd, stringPtr + 8n, size)
-  let ret = if (err != Wasi._ESUCCESS) {
-    wasmSafeErr(Wasi.SystemError(tagSimpleNumber(err)))
+  if (err != Wasi._ESUCCESS) {
+    Err(Wasi.SystemError(tagSimpleNumber(err)))
   } else {
-    wasmSafeOk(void)
+    Ok(void)
   }
-  Memory.decRef(WasmI32.fromGrain(fdArg))
-  Memory.decRef(WasmI32.fromGrain(path))
-  Memory.decRef(WasmI32.fromGrain(pathCreateDirectory))
-  ret
 }
 
 /**
@@ -1312,11 +1261,15 @@ export let rec pathCreateDirectory = (fd: FileDescriptor, path: String) => {
  * @param path: The path to retrieve information about
  * @returns `Ok(info)` of the `Filestats` associated with the file descriptor if successful or `Err(exception)` otherwise
  */
-export let rec pathFilestats = (fd: FileDescriptor, dirFlags: List<LookupFlag>, path: String) => {
+@unsafe
+export 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)
 
@@ -1326,30 +1279,38 @@ export let rec pathFilestats = (fd: FileDescriptor, dirFlags: List<LookupFlag>,
 
   let filestats = Memory.malloc(64n)
 
-  let err = Wasi.path_filestat_get(fd, combinedDirFlags, pathPtr, pathSize, filestats)
-  let ret = if (err != Wasi._ESUCCESS) {
+  let err = Wasi.path_filestat_get(
+    fd,
+    combinedDirFlags,
+    pathPtr,
+    pathSize,
+    filestats
+  )
+  if (err != Wasi._ESUCCESS) {
     Memory.free(filestats)
-    wasmSafeErr(Wasi.SystemError(tagSimpleNumber(err)))
+    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 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 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
 
-
     Memory.free(filestats)
 
-    wasmSafeOk({ device, inode, filetype, linkcount, size, accessed, modified, changed })
+    Ok(
+      { device, inode, filetype, linkcount, size, accessed, modified, changed }
+    )
   }
-  Memory.decRef(WasmI32.fromGrain(fdArg))
-  Memory.decRef(WasmI32.fromGrain(dirFlags))
-  Memory.decRef(WasmI32.fromGrain(path))
-  Memory.decRef(WasmI32.fromGrain(pathFilestats))
-  ret
 }
 
 /**
@@ -1361,11 +1322,16 @@ export let rec pathFilestats = (fd: FileDescriptor, dirFlags: List<LookupFlag>,
  * @param timestamp: The time to set
  * @returns `Ok(void)` if successful or `Err(exception)` otherwise
  */
-export let rec pathSetAccessTime = (fd: FileDescriptor, dirFlags: List<LookupFlag>, path: String, timestamp: Int64) => {
+@unsafe
+export 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)
 
@@ -1375,18 +1341,20 @@ export let rec pathSetAccessTime = (fd: FileDescriptor, dirFlags: List<LookupFla
 
   let time = WasmI64.load(WasmI32.fromGrain(timestamp), 8n)
 
-  let err = Wasi.path_filestat_set_times(fd, combinedDirFlags, pathPtr, pathSize, time, 0N, Wasi._TIME_SET_ATIM)
-  let ret = if (err != Wasi._ESUCCESS) {
-    wasmSafeErr(Wasi.SystemError(tagSimpleNumber(err)))
+  let err = Wasi.path_filestat_set_times(
+    fd,
+    combinedDirFlags,
+    pathPtr,
+    pathSize,
+    time,
+    0N,
+    Wasi._TIME_SET_ATIM
+  )
+  if (err != Wasi._ESUCCESS) {
+    Err(Wasi.SystemError(tagSimpleNumber(err)))
   } else {
-    wasmSafeOk(void)
+    Ok(void)
   }
-  Memory.decRef(WasmI32.fromGrain(fdArg))
-  Memory.decRef(WasmI32.fromGrain(dirFlags))
-  Memory.decRef(WasmI32.fromGrain(path))
-  Memory.decRef(WasmI32.fromGrain(timestamp))
-  Memory.decRef(WasmI32.fromGrain(pathSetAccessTime))
-  ret
 }
 
 /**
@@ -1397,11 +1365,15 @@ export let rec pathSetAccessTime = (fd: FileDescriptor, dirFlags: List<LookupFla
  * @param path: The path to set the time
  * @returns `Ok(void)` if successful or `Err(exception)` otherwise
  */
-export let pathSetAccessTimeNow = (fd: FileDescriptor, dirFlags: List<LookupFlag>, path: String) => {
+@unsafe
+export 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)
 
@@ -1409,17 +1381,20 @@ export let pathSetAccessTimeNow = (fd: FileDescriptor, dirFlags: List<LookupFlag
   let pathSize = WasmI32.load(pathPtr, 4n)
   pathPtr += 8n
 
-  let err = Wasi.path_filestat_set_times(fd, combinedDirFlags, pathPtr, pathSize, 0N, 0N, Wasi._TIME_SET_ATIM_NOW)
-  let ret = if (err != Wasi._ESUCCESS) {
-    wasmSafeErr(Wasi.SystemError(tagSimpleNumber(err)))
+  let err = Wasi.path_filestat_set_times(
+    fd,
+    combinedDirFlags,
+    pathPtr,
+    pathSize,
+    0N,
+    0N,
+    Wasi._TIME_SET_ATIM_NOW
+  )
+  if (err != Wasi._ESUCCESS) {
+    Err(Wasi.SystemError(tagSimpleNumber(err)))
   } else {
-    wasmSafeOk(void)
+    Ok(void)
   }
-  Memory.decRef(WasmI32.fromGrain(fdArg))
-  Memory.decRef(WasmI32.fromGrain(dirFlags))
-  Memory.decRef(WasmI32.fromGrain(path))
-  Memory.decRef(WasmI32.fromGrain(pathSetAccessTime))
-  ret
 }
 
 /**
@@ -1431,11 +1406,16 @@ export let pathSetAccessTimeNow = (fd: FileDescriptor, dirFlags: List<LookupFlag
  * @param timestamp: The time to set
  * @returns `Ok(void)` if successful or `Err(exception)` otherwise
  */
-export let rec pathSetModifiedTime = (fd: FileDescriptor, dirFlags: List<LookupFlag>, path: String, timestamp: Int64) => {
+@unsafe
+export 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)
 
@@ -1445,18 +1425,20 @@ export let rec pathSetModifiedTime = (fd: FileDescriptor, dirFlags: List<LookupF
 
   let time = WasmI64.load(WasmI32.fromGrain(timestamp), 8n)
 
-  let err = Wasi.path_filestat_set_times(fd, combinedDirFlags, pathPtr, pathSize, 0N, time, Wasi._TIME_SET_MTIM)
-  let ret = if (err != Wasi._ESUCCESS) {
-    wasmSafeErr(Wasi.SystemError(tagSimpleNumber(err)))
+  let err = Wasi.path_filestat_set_times(
+    fd,
+    combinedDirFlags,
+    pathPtr,
+    pathSize,
+    0N,
+    time,
+    Wasi._TIME_SET_MTIM
+  )
+  if (err != Wasi._ESUCCESS) {
+    Err(Wasi.SystemError(tagSimpleNumber(err)))
   } else {
-    wasmSafeOk(void)
+    Ok(void)
   }
-  Memory.decRef(WasmI32.fromGrain(fdArg))
-  Memory.decRef(WasmI32.fromGrain(dirFlags))
-  Memory.decRef(WasmI32.fromGrain(path))
-  Memory.decRef(WasmI32.fromGrain(timestamp))
-  Memory.decRef(WasmI32.fromGrain(pathSetModifiedTime))
-  ret
 }
 
 /**
@@ -1467,11 +1449,15 @@ export let rec pathSetModifiedTime = (fd: FileDescriptor, dirFlags: List<LookupF
  * @param path: The path to set the time
  * @returns `Ok(void)` if successful or `Err(exception)` otherwise
  */
-export let rec pathSetModifiedTimeNow = (fd: FileDescriptor, dirFlags: List<LookupFlag>, path: String) => {
+@unsafe
+export 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)
 
@@ -1479,17 +1465,20 @@ export let rec pathSetModifiedTimeNow = (fd: FileDescriptor, dirFlags: List<Look
   let pathSize = WasmI32.load(pathPtr, 4n)
   pathPtr += 8n
 
-  let err = Wasi.path_filestat_set_times(fd, combinedDirFlags, pathPtr, pathSize, 0N, 0N, Wasi._TIME_SET_MTIM_NOW)
-  let ret = if (err != Wasi._ESUCCESS) {
-    wasmSafeErr(Wasi.SystemError(tagSimpleNumber(err)))
+  let err = Wasi.path_filestat_set_times(
+    fd,
+    combinedDirFlags,
+    pathPtr,
+    pathSize,
+    0N,
+    0N,
+    Wasi._TIME_SET_MTIM_NOW
+  )
+  if (err != Wasi._ESUCCESS) {
+    Err(Wasi.SystemError(tagSimpleNumber(err)))
   } else {
-    wasmSafeOk(void)
+    Ok(void)
   }
-  Memory.decRef(WasmI32.fromGrain(fdArg))
-  Memory.decRef(WasmI32.fromGrain(dirFlags))
-  Memory.decRef(WasmI32.fromGrain(path))
-  Memory.decRef(WasmI32.fromGrain(pathSetModifiedTimeNow))
-  ret
 }
 
 /**
@@ -1502,15 +1491,23 @@ export let rec pathSetModifiedTimeNow = (fd: FileDescriptor, dirFlags: List<Look
  * @param targetPath: The path to the target of the link
  * @returns `Ok(void)` if successful or `Err(exception)` otherwise
  */
-export let rec pathLink = (sourceFd: FileDescriptor, dirFlags: List<LookupFlag>, sourcePath: String, targetFd: FileDescriptor, targetPath: String) => {
+@unsafe
+export let pathLink =
+  (
+    sourceFd: FileDescriptor,
+    dirFlags: List<LookupFlag>,
+    sourcePath: String,
+    targetFd: FileDescriptor,
+    targetPath: String,
+  ) => {
   let sourceFdArg = sourceFd
   let targetFdArg = targetFd
   let sourceFd = match (sourceFd) {
-    FileDescriptor(n) => WasmI32.fromGrain(n) >> 1n
+    FileDescriptor(n) => WasmI32.fromGrain(n) >> 1n,
   }
 
   let targetFd = match (targetFd) {
-    FileDescriptor(n) => WasmI32.fromGrain(n) >> 1n
+    FileDescriptor(n) => WasmI32.fromGrain(n) >> 1n,
   }
 
   let combinedDirFlags = combineLookupFlags(dirFlags)
@@ -1521,19 +1518,20 @@ export let rec pathLink = (sourceFd: FileDescriptor, dirFlags: List<LookupFlag>,
   let sourceSize = WasmI32.load(sourcePtr, 4n)
   let targetSize = WasmI32.load(targetPtr, 4n)
 
-  let err = Wasi.path_link(sourceFd, combinedDirFlags, sourcePtr + 8n, sourceSize, targetFd, targetPtr + 8n, targetSize)
-  let ret = if (err != Wasi._ESUCCESS) {
-    wasmSafeErr(Wasi.SystemError(tagSimpleNumber(err)))
+  let err = Wasi.path_link(
+    sourceFd,
+    combinedDirFlags,
+    sourcePtr + 8n,
+    sourceSize,
+    targetFd,
+    targetPtr + 8n,
+    targetSize
+  )
+  if (err != Wasi._ESUCCESS) {
+    Err(Wasi.SystemError(tagSimpleNumber(err)))
   } else {
-    wasmSafeOk(void)
+    Ok(void)
   }
-  Memory.decRef(WasmI32.fromGrain(sourceFdArg))
-  Memory.decRef(WasmI32.fromGrain(dirFlags))
-  Memory.decRef(WasmI32.fromGrain(sourcePath))
-  Memory.decRef(WasmI32.fromGrain(targetFdArg))
-  Memory.decRef(WasmI32.fromGrain(targetPath))
-  Memory.decRef(WasmI32.fromGrain(pathLink))
-  ret
 }
 
 /**
@@ -1544,11 +1542,15 @@ export let rec pathLink = (sourceFd: FileDescriptor, dirFlags: List<LookupFlag>,
  * @param targetPath: The path to the target of the link
  * @returns `Ok(void)` if successful or `Err(exception)` otherwise
  */
-export let rec pathSymlink = (fd: FileDescriptor, sourcePath: String, targetPath: String) => {
+@unsafe
+export 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)
@@ -1556,17 +1558,18 @@ export let rec pathSymlink = (fd: FileDescriptor, sourcePath: String, targetPath
   let sourceSize = WasmI32.load(sourcePtr, 4n)
   let targetSize = WasmI32.load(targetPtr, 4n)
 
-  let err = Wasi.path_symlink(sourcePtr + 8n, sourceSize, fd, targetPtr + 8n, targetSize)
-  let ret = if (err != Wasi._ESUCCESS) {
-    wasmSafeErr(Wasi.SystemError(tagSimpleNumber(err)))
+  let err = Wasi.path_symlink(
+    sourcePtr + 8n,
+    sourceSize,
+    fd,
+    targetPtr + 8n,
+    targetSize
+  )
+  if (err != Wasi._ESUCCESS) {
+    Err(Wasi.SystemError(tagSimpleNumber(err)))
   } else {
-    wasmSafeOk(void)
+    Ok(void)
   }
-  Memory.decRef(WasmI32.fromGrain(fdArg))
-  Memory.decRef(WasmI32.fromGrain(sourcePath))
-  Memory.decRef(WasmI32.fromGrain(targetPath))
-  Memory.decRef(WasmI32.fromGrain(pathSymlink))
-  ret
 }
 
 /**
@@ -1576,25 +1579,20 @@ export let rec pathSymlink = (fd: FileDescriptor, sourcePath: String, targetPath
  * @param path: The path of the file to unlink
  * @returns `Ok(void)` if successful or `Err(exception)` otherwise
  */
-export let rec pathUnlink = (fd: FileDescriptor, path: String) => {
+@unsafe
+export 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)
-  let ret = if (err != Wasi._ESUCCESS) {
-    wasmSafeErr(Wasi.SystemError(tagSimpleNumber(err)))
+  if (err != Wasi._ESUCCESS) {
+    Err(Wasi.SystemError(tagSimpleNumber(err)))
   } else {
-    wasmSafeOk(void)
+    Ok(void)
   }
-  Memory.decRef(WasmI32.fromGrain(fdArg))
-  Memory.decRef(WasmI32.fromGrain(path))
-  Memory.decRef(WasmI32.fromGrain(pathUnlink))
-  ret
 }
 
 /**
@@ -1605,12 +1603,11 @@ export let rec pathUnlink = (fd: FileDescriptor, path: String) => {
  * @param size: The number of bytes to read
  * @returns `Ok((contents, numBytes))` of the bytes read and the number of bytes read if successful or `Err(exception)` otherwise
  */
-export let rec pathReadlink = (fd: FileDescriptor, path: String, size: Number) => {
+@unsafe
+export 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,21 +1620,16 @@ export let rec pathReadlink = (fd: FileDescriptor, path: String, size: Number) =
   let nread = Memory.malloc(4n)
 
   let err = Wasi.path_readlink(fd, pathPtr, pathSize + 8n, strPtr, size, nread)
-  let ret = if (err != Wasi._ESUCCESS) {
+  if (err != Wasi._ESUCCESS) {
     Memory.free(grainStrPtr)
     Memory.free(nread)
-    wasmSafeErr(Wasi.SystemError(tagSimpleNumber(err)))
+    Err(Wasi.SystemError(tagSimpleNumber(err)))
   } else {
     let read = tagSimpleNumber(WasmI32.load(nread, 0n))
     Memory.free(nread)
 
-    wasmSafeOk((WasmI32.toGrain(grainStrPtr): String, read))
+    Ok((WasmI32.toGrain(grainStrPtr): String, read))
   }
-  Memory.decRef(WasmI32.fromGrain(fdArg))
-  Memory.decRef(WasmI32.fromGrain(path))
-  Memory.decRef(WasmI32.fromGrain(sizeArg))
-  Memory.decRef(WasmI32.fromGrain(pathReadlink))
-  ret
 }
 
 /**
@@ -1647,25 +1639,20 @@ export let rec pathReadlink = (fd: FileDescriptor, path: String, size: Number) =
  * @param path: The path to the directory to remove
  * @returns `Ok(void)` if successful or `Err(exception)` otherwise
  */
-export let rec pathRemoveDirectory = (fd: FileDescriptor, path: String) => {
+@unsafe
+export 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)
-  let ret = if (err != Wasi._ESUCCESS) {
-    wasmSafeErr(Wasi.SystemError(tagSimpleNumber(err)))
+  if (err != Wasi._ESUCCESS) {
+    Err(Wasi.SystemError(tagSimpleNumber(err)))
   } else {
-    wasmSafeOk(void)
+    Ok(void)
   }
-  Memory.decRef(WasmI32.fromGrain(fdArg))
-  Memory.decRef(WasmI32.fromGrain(path))
-  Memory.decRef(WasmI32.fromGrain(pathRemoveDirectory))
-  ret
 }
 
 /**
@@ -1677,15 +1664,22 @@ export let rec pathRemoveDirectory = (fd: FileDescriptor, path: String) => {
  * @param targetPath: The new path of the file
  * @returns `Ok(void)` if successful or `Err(exception)` otherwise
  */
-export let rec pathRename = (sourceFd: FileDescriptor, sourcePath: String, targetFd: FileDescriptor, targetPath: String) => {
+@unsafe
+export let pathRename =
+  (
+    sourceFd: FileDescriptor,
+    sourcePath: String,
+    targetFd: FileDescriptor,
+    targetPath: String,
+  ) => {
   let sourceFdArg = sourceFd
   let targetFdArg = targetFd
   let sourceFd = match (sourceFd) {
-    FileDescriptor(n) => WasmI32.fromGrain(n) >> 1n
+    FileDescriptor(n) => WasmI32.fromGrain(n) >> 1n,
   }
 
   let targetFd = match (targetFd) {
-    FileDescriptor(n) => WasmI32.fromGrain(n) >> 1n
+    FileDescriptor(n) => WasmI32.fromGrain(n) >> 1n,
   }
 
   let sourcePtr = WasmI32.fromGrain(sourcePath)
@@ -1694,16 +1688,17 @@ export let rec pathRename = (sourceFd: FileDescriptor, sourcePath: String, targe
   let sourceSize = WasmI32.load(sourcePtr, 4n)
   let targetSize = WasmI32.load(targetPtr, 4n)
 
-  let err = Wasi.path_rename(sourceFd, sourcePtr + 8n, sourceSize, targetFd, targetPtr + 8n, targetSize)
-  let ret = if (err != Wasi._ESUCCESS) {
-    wasmSafeErr(Wasi.SystemError(tagSimpleNumber(err)))
+  let err = Wasi.path_rename(
+    sourceFd,
+    sourcePtr + 8n,
+    sourceSize,
+    targetFd,
+    targetPtr + 8n,
+    targetSize
+  )
+  if (err != Wasi._ESUCCESS) {
+    Err(Wasi.SystemError(tagSimpleNumber(err)))
   } else {
-    wasmSafeOk(void)
+    Ok(void)
   }
-  Memory.decRef(WasmI32.fromGrain(sourceFdArg))
-  Memory.decRef(WasmI32.fromGrain(sourcePath))
-  Memory.decRef(WasmI32.fromGrain(targetFdArg))
-  Memory.decRef(WasmI32.fromGrain(targetPath))
-  Memory.decRef(WasmI32.fromGrain(pathRename))
-  ret
 }