snapshot_preview1.ts

// Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.

import { relative, resolve } from "../path/mod.ts";

const CLOCKID_REALTIME = 0;
const CLOCKID_MONOTONIC = 1;
const CLOCKID_PROCESS_CPUTIME_ID = 2;
const CLOCKID_THREAD_CPUTIME_ID = 3;

const ERRNO_SUCCESS = 0;
const _ERRNO_2BIG = 1;
const ERRNO_ACCES = 2;
const ERRNO_ADDRINUSE = 3;
const ERRNO_ADDRNOTAVAIL = 4;
const _ERRNO_AFNOSUPPORT = 5;
const _ERRNO_AGAIN = 6;
const _ERRNO_ALREADY = 7;
const ERRNO_BADF = 8;
const _ERRNO_BADMSG = 9;
const ERRNO_BUSY = 10;
const _ERRNO_CANCELED = 11;
const _ERRNO_CHILD = 12;
const ERRNO_CONNABORTED = 13;
const ERRNO_CONNREFUSED = 14;
const ERRNO_CONNRESET = 15;
const _ERRNO_DEADLK = 16;
const _ERRNO_DESTADDRREQ = 17;
const _ERRNO_DOM = 18;
const _ERRNO_DQUOT = 19;
const _ERRNO_EXIST = 20;
const _ERRNO_FAULT = 21;
const _ERRNO_FBIG = 22;
const _ERRNO_HOSTUNREACH = 23;
const _ERRNO_IDRM = 24;
const _ERRNO_ILSEQ = 25;
const _ERRNO_INPROGRESS = 26;
const ERRNO_INTR = 27;
const ERRNO_INVAL = 28;
const _ERRNO_IO = 29;
const _ERRNO_ISCONN = 30;
const _ERRNO_ISDIR = 31;
const _ERRNO_LOOP = 32;
const _ERRNO_MFILE = 33;
const _ERRNO_MLINK = 34;
const _ERRNO_MSGSIZE = 35;
const _ERRNO_MULTIHOP = 36;
const _ERRNO_NAMETOOLONG = 37;
const _ERRNO_NETDOWN = 38;
const _ERRNO_NETRESET = 39;
const _ERRNO_NETUNREACH = 40;
const _ERRNO_NFILE = 41;
const _ERRNO_NOBUFS = 42;
const _ERRNO_NODEV = 43;
const ERRNO_NOENT = 44;
const _ERRNO_NOEXEC = 45;
const _ERRNO_NOLCK = 46;
const _ERRNO_NOLINK = 47;
const _ERRNO_NOMEM = 48;
const _ERRNO_NOMSG = 49;
const _ERRNO_NOPROTOOPT = 50;
const _ERRNO_NOSPC = 51;
const ERRNO_NOSYS = 52;
const ERRNO_NOTCONN = 53;
const ERRNO_NOTDIR = 54;
const _ERRNO_NOTEMPTY = 55;
const _ERRNO_NOTRECOVERABLE = 56;
const _ERRNO_NOTSOCK = 57;
const _ERRNO_NOTSUP = 58;
const _ERRNO_NOTTY = 59;
const _ERRNO_NXIO = 60;
const _ERRNO_OVERFLOW = 61;
const _ERRNO_OWNERDEAD = 62;
const _ERRNO_PERM = 63;
const ERRNO_PIPE = 64;
const _ERRNO_PROTO = 65;
const _ERRNO_PROTONOSUPPORT = 66;
const _ERRNO_PROTOTYPE = 67;
const _ERRNO_RANGE = 68;
const _ERRNO_ROFS = 69;
const _ERRNO_SPIPE = 70;
const _ERRNO_SRCH = 71;
const _ERRNO_STALE = 72;
const ERRNO_TIMEDOUT = 73;
const _ERRNO_TXTBSY = 74;
const _ERRNO_XDEV = 75;
const ERRNO_NOTCAPABLE = 76;

const RIGHTS_FD_DATASYNC = 0x0000000000000001n;
const RIGHTS_FD_READ = 0x0000000000000002n;
const _RIGHTS_FD_SEEK = 0x0000000000000004n;
const _RIGHTS_FD_FDSTAT_SET_FLAGS = 0x0000000000000008n;
const _RIGHTS_FD_SYNC = 0x0000000000000010n;
const _RIGHTS_FD_TELL = 0x0000000000000020n;
const RIGHTS_FD_WRITE = 0x0000000000000040n;
const _RIGHTS_FD_ADVISE = 0x0000000000000080n;
const RIGHTS_FD_ALLOCATE = 0x0000000000000100n;
const _RIGHTS_PATH_CREATE_DIRECTORY = 0x0000000000000200n;
const _RIGHTS_PATH_CREATE_FILE = 0x0000000000000400n;
const _RIGHTS_PATH_LINK_SOURCE = 0x0000000000000800n;
const _RIGHTS_PATH_LINK_TARGET = 0x0000000000001000n;
const _RIGHTS_PATH_OPEN = 0x0000000000002000n;
const RIGHTS_FD_READDIR = 0x0000000000004000n;
const _RIGHTS_PATH_READLINK = 0x0000000000008000n;
const _RIGHTS_PATH_RENAME_SOURCE = 0x0000000000010000n;
const _RIGHTS_PATH_RENAME_TARGET = 0x0000000000020000n;
const _RIGHTS_PATH_FILESTAT_GET = 0x0000000000040000n;
const _RIGHTS_PATH_FILESTAT_SET_SIZE = 0x0000000000080000n;
const _RIGHTS_PATH_FILESTAT_SET_TIMES = 0x0000000000100000n;
const _RIGHTS_FD_FILESTAT_GET = 0x0000000000200000n;
const RIGHTS_FD_FILESTAT_SET_SIZE = 0x0000000000400000n;
const _RIGHTS_FD_FILESTAT_SET_TIMES = 0x0000000000800000n;
const _RIGHTS_PATH_SYMLINK = 0x0000000001000000n;
const _RIGHTS_PATH_REMOVE_DIRECTORY = 0x0000000002000000n;
const _RIGHTS_PATH_UNLINK_FILE = 0x0000000004000000n;
const _RIGHTS_POLL_FD_READWRITE = 0x0000000008000000n;
const _RIGHTS_SOCK_SHUTDOWN = 0x0000000010000000n;

const _WHENCE_SET = 0;
const _WHENCE_CUR = 1;
const _WHENCE_END = 2;

const FILETYPE_UNKNOWN = 0;
const _FILETYPE_BLOCK_DEVICE = 1;
const FILETYPE_CHARACTER_DEVICE = 2;
const FILETYPE_DIRECTORY = 3;
const FILETYPE_REGULAR_FILE = 4;
const _FILETYPE_SOCKET_DGRAM = 5;
const _FILETYPE_SOCKET_STREAM = 6;
const FILETYPE_SYMBOLIC_LINK = 7;

const _ADVICE_NORMAL = 0;
const _ADVICE_SEQUENTIAL = 1;
const _ADVICE_RANDOM = 2;
const _ADVICE_WILLNEED = 3;
const _ADVICE_DONTNEED = 4;
const _ADVICE_NOREUSE = 5;

const FDFLAGS_APPEND = 0x0001;
const FDFLAGS_DSYNC = 0x0002;
const FDFLAGS_NONBLOCK = 0x0004;
const FDFLAGS_RSYNC = 0x0008;
const FDFLAGS_SYNC = 0x0010;

const _FSTFLAGS_ATIM = 0x0001;
const FSTFLAGS_ATIM_NOW = 0x0002;
const _FSTFLAGS_MTIM = 0x0004;
const FSTFLAGS_MTIM_NOW = 0x0008;

const LOOKUPFLAGS_SYMLINK_FOLLOW = 0x0001;

const OFLAGS_CREAT = 0x0001;
const OFLAGS_DIRECTORY = 0x0002;
const OFLAGS_EXCL = 0x0004;
const OFLAGS_TRUNC = 0x0008;

const _EVENTTYPE_CLOCK = 0;
const _EVENTTYPE_FD_READ = 1;
const _EVENTTYPE_FD_WRITE = 2;

const _EVENTRWFLAGS_FD_READWRITE_HANGUP = 1;
const _SUBCLOCKFLAGS_SUBSCRIPTION_CLOCK_ABSTIME = 1;

const _SIGNAL_NONE = 0;
const _SIGNAL_HUP = 1;
const _SIGNAL_INT = 2;
const _SIGNAL_QUIT = 3;
const _SIGNAL_ILL = 4;
const _SIGNAL_TRAP = 5;
const _SIGNAL_ABRT = 6;
const _SIGNAL_BUS = 7;
const _SIGNAL_FPE = 8;
const _SIGNAL_KILL = 9;
const _SIGNAL_USR1 = 10;
const _SIGNAL_SEGV = 11;
const _SIGNAL_USR2 = 12;
const _SIGNAL_PIPE = 13;
const _SIGNAL_ALRM = 14;
const _SIGNAL_TERM = 15;
const _SIGNAL_CHLD = 16;
const _SIGNAL_CONT = 17;
const _SIGNAL_STOP = 18;
const _SIGNAL_TSTP = 19;
const _SIGNAL_TTIN = 20;
const _SIGNAL_TTOU = 21;
const _SIGNAL_URG = 22;
const _SIGNAL_XCPU = 23;
const _SIGNAL_XFSZ = 24;
const _SIGNAL_VTALRM = 25;
const _SIGNAL_PROF = 26;
const _SIGNAL_WINCH = 27;
const _SIGNAL_POLL = 28;
const _SIGNAL_PWR = 29;
const _SIGNAL_SYS = 30;

const _RIFLAGS_RECV_PEEK = 0x0001;
const _RIFLAGS_RECV_WAITALL = 0x0002;

const _ROFLAGS_RECV_DATA_TRUNCATED = 0x0001;

const _SDFLAGS_RD = 0x0001;
const _SDFLAGS_WR = 0x0002;

const PREOPENTYPE_DIR = 0;

function syscall<T extends CallableFunction>(target: T) {
  return function (...args: unknown[]) {
    try {
      return target(...args);
    } catch (err) {
      if (err instanceof ExitStatus) {
        throw err;
      }

      switch (err.name) {
        case "NotFound":
          return ERRNO_NOENT;

        case "PermissionDenied":
          return ERRNO_ACCES;

        case "ConnectionRefused":
          return ERRNO_CONNREFUSED;

        case "ConnectionReset":
          return ERRNO_CONNRESET;

        case "ConnectionAborted":
          return ERRNO_CONNABORTED;

        case "NotConnected":
          return ERRNO_NOTCONN;

        case "AddrInUse":
          return ERRNO_ADDRINUSE;

        case "AddrNotAvailable":
          return ERRNO_ADDRNOTAVAIL;

        case "BrokenPipe":
          return ERRNO_PIPE;

        case "InvalidData":
          return ERRNO_INVAL;

        case "TimedOut":
          return ERRNO_TIMEDOUT;

        case "Interrupted":
          return ERRNO_INTR;

        case "BadResource":
          return ERRNO_BADF;

        case "Busy":
          return ERRNO_BUSY;

        default:
          return ERRNO_INVAL;
      }
    }
  };
}

interface FileDescriptor {
  rid?: number;
  type?: number;
  flags?: number;
  path?: string;
  vpath?: string;
  entries?: Deno.DirEntry[];
}

export class ExitStatus {
  code: number;

  constructor(code: number) {
    this.code = code;
  }
}

export interface ContextOptions {
  /**
   * An array of strings that the WebAssembly instance will see as command-line
   * arguments.
   *
   * The first argument is the virtual path to the command itself.
   */
  args?: string[];

  /**
   * An object of string keys mapped to string values that the WebAssembly module will see as its environment.
   */
  env?: { [key: string]: string | undefined };

  /**
   * An object of string keys mapped to string values that the WebAssembly module will see as it's filesystem.
   *
   * The string keys of are treated as directories within the sandboxed
   * filesystem, the values are the real paths to those directories on the host
   * machine.
   *
   */
  preopens?: { [key: string]: string };

  /**
   * Determines if calls to exit from within the WebAssembly module will terminate the proess or return.
   */
  exitOnReturn?: boolean;
}

/**
 * The Context class provides the environment required to run WebAssembly
 * modules compiled to run with the WebAssembly System Interface.
 *
 * Each context represents a distinct sandboxed environment and must have its
 * command-line arguments, environment variables, and pre-opened directory
 * structure configured explicitly.
 */
export default class Context {
  args: string[];
  env: { [key: string]: string | undefined };
  exitOnReturn: boolean;
  memory: WebAssembly.Memory;

  fds: FileDescriptor[];

  exports: Record<string, WebAssembly.ImportValue>;
  #started: boolean;

  constructor(options: ContextOptions) {
    this.args = options.args ?? [];
    this.env = options.env ?? {};
    this.exitOnReturn = options.exitOnReturn ?? true;
    this.memory = null!;

    this.fds = [
      {
        rid: Deno.stdin.rid,
        type: FILETYPE_CHARACTER_DEVICE,
        flags: FDFLAGS_APPEND,
      },
      {
        rid: Deno.stdout.rid,
        type: FILETYPE_CHARACTER_DEVICE,
        flags: FDFLAGS_APPEND,
      },
      {
        rid: Deno.stderr.rid,
        type: FILETYPE_CHARACTER_DEVICE,
        flags: FDFLAGS_APPEND,
      },
    ];

    if (options.preopens) {
      for (const [vpath, path] of Object.entries(options.preopens)) {
        const type = FILETYPE_DIRECTORY;
        const entries = Array.from(Deno.readDirSync(path));

        const entry = {
          type,
          entries,
          path,
          vpath,
        };

        this.fds.push(entry);
      }
    }

    this.exports = {
      "args_get": syscall((
        argvOffset: number,
        argvBufferOffset: number,
      ): number => {
        const args = this.args;
        const textEncoder = new TextEncoder();
        const memoryData = new Uint8Array(this.memory.buffer);
        const memoryView = new DataView(this.memory.buffer);

        for (const arg of args) {
          memoryView.setUint32(argvOffset, argvBufferOffset, true);
          argvOffset += 4;

          const data = textEncoder.encode(`${arg}\0`);
          memoryData.set(data, argvBufferOffset);
          argvBufferOffset += data.length;
        }

        return ERRNO_SUCCESS;
      }),

      "args_sizes_get": syscall((
        argcOffset: number,
        argvBufferSizeOffset: number,
      ): number => {
        const args = this.args;
        const textEncoder = new TextEncoder();
        const memoryView = new DataView(this.memory.buffer);

        memoryView.setUint32(argcOffset, args.length, true);
        memoryView.setUint32(
          argvBufferSizeOffset,
          args.reduce(function (acc, arg) {
            return acc + textEncoder.encode(`${arg}\0`).length;
          }, 0),
          true,
        );

        return ERRNO_SUCCESS;
      }),

      "environ_get": syscall((
        environOffset: number,
        environBufferOffset: number,
      ): number => {
        const entries = Object.entries(this.env);
        const textEncoder = new TextEncoder();
        const memoryData = new Uint8Array(this.memory.buffer);
        const memoryView = new DataView(this.memory.buffer);

        for (const [key, value] of entries) {
          memoryView.setUint32(environOffset, environBufferOffset, true);
          environOffset += 4;

          const data = textEncoder.encode(`${key}=${value}\0`);
          memoryData.set(data, environBufferOffset);
          environBufferOffset += data.length;
        }

        return ERRNO_SUCCESS;
      }),

      "environ_sizes_get": syscall((
        environcOffset: number,
        environBufferSizeOffset: number,
      ): number => {
        const entries = Object.entries(this.env);
        const textEncoder = new TextEncoder();
        const memoryView = new DataView(this.memory.buffer);

        memoryView.setUint32(environcOffset, entries.length, true);
        memoryView.setUint32(
          environBufferSizeOffset,
          entries.reduce(function (acc, [key, value]) {
            return acc + textEncoder.encode(`${key}=${value}\0`).length;
          }, 0),
          true,
        );

        return ERRNO_SUCCESS;
      }),

      "clock_res_get": syscall((
        id: number,
        resolutionOffset: number,
      ): number => {
        const memoryView = new DataView(this.memory.buffer);

        switch (id) {
          case CLOCKID_REALTIME: {
            const resolution = BigInt(1e6);

            memoryView.setBigUint64(
              resolutionOffset,
              resolution,
              true,
            );
            break;
          }

          case CLOCKID_MONOTONIC:
          case CLOCKID_PROCESS_CPUTIME_ID:
          case CLOCKID_THREAD_CPUTIME_ID: {
            const resolution = BigInt(1e3);
            memoryView.setBigUint64(resolutionOffset, resolution, true);
            break;
          }

          default:
            return ERRNO_INVAL;
        }

        return ERRNO_SUCCESS;
      }),

      "clock_time_get": syscall((
        id: number,
        precision: bigint,
        timeOffset: number,
      ): number => {
        const memoryView = new DataView(this.memory.buffer);

        switch (id) {
          case CLOCKID_REALTIME: {
            const time = BigInt(Date.now()) * BigInt(1e6);
            memoryView.setBigUint64(timeOffset, time, true);
            break;
          }

          case CLOCKID_MONOTONIC:
          case CLOCKID_PROCESS_CPUTIME_ID:
          case CLOCKID_THREAD_CPUTIME_ID: {
            const t = performance.now();
            const s = Math.trunc(t);
            const ms = Math.floor((t - s) * 1e3);

            const time = BigInt(s) * BigInt(1e9) + BigInt(ms) * BigInt(1e6);

            memoryView.setBigUint64(timeOffset, time, true);
            break;
          }

          default:
            return ERRNO_INVAL;
        }

        return ERRNO_SUCCESS;
      }),

      "fd_advise": syscall((
        _fd: number,
        _offset: bigint,
        _length: bigint,
        _advice: number,
      ): number => {
        return ERRNO_NOSYS;
      }),

      "fd_allocate": syscall((
        _fd: number,
        _offset: bigint,
        _length: bigint,
      ): number => {
        return ERRNO_NOSYS;
      }),

      "fd_close": syscall((
        fd: number,
      ): number => {
        const entry = this.fds[fd];
        if (!entry) {
          return ERRNO_BADF;
        }

        if (entry.rid) {
          Deno.close(entry.rid);
        }

        delete this.fds[fd];

        return ERRNO_SUCCESS;
      }),

      "fd_datasync": syscall((
        fd: number,
      ): number => {
        const entry = this.fds[fd];
        if (!entry) {
          return ERRNO_BADF;
        }

        Deno.fdatasyncSync(entry.rid!);

        return ERRNO_SUCCESS;
      }),

      "fd_fdstat_get": syscall((
        fd: number,
        offset: number,
      ): number => {
        const entry = this.fds[fd];
        if (!entry) {
          return ERRNO_BADF;
        }

        const memoryView = new DataView(this.memory.buffer);
        memoryView.setUint8(offset, entry.type!);
        memoryView.setUint16(offset + 2, entry.flags!, true);
        memoryView.setBigUint64(offset + 8, 0n, true); // TODO
        memoryView.setBigUint64(offset + 16, 0n, true); // TODO

        return ERRNO_SUCCESS;
      }),

      "fd_fdstat_set_flags": syscall((
        _fd: number,
        _flags: number,
      ): number => {
        return ERRNO_NOSYS;
      }),

      "fd_fdstat_set_rights": syscall((
        _fd: number,
        _rightsBase: bigint,
        _rightsInheriting: bigint,
      ): number => {
        return ERRNO_NOSYS;
      }),

      "fd_filestat_get": syscall((
        fd: number,
        offset: number,
      ): number => {
        const entry = this.fds[fd];
        if (!entry) {
          return ERRNO_BADF;
        }

        const memoryView = new DataView(this.memory.buffer);

        const info = Deno.fstatSync(entry.rid!);

        if (entry.type === undefined) {
          switch (true) {
            case info.isFile:
              entry.type = FILETYPE_REGULAR_FILE;
              break;

            case info.isDirectory:
              entry.type = FILETYPE_DIRECTORY;
              break;

            case info.isSymlink:
              entry.type = FILETYPE_SYMBOLIC_LINK;
              break;

            default:
              entry.type = FILETYPE_UNKNOWN;
              break;
          }
        }

        memoryView.setBigUint64(offset, BigInt(info.dev ? info.dev : 0), true);
        offset += 8;

        memoryView.setBigUint64(offset, BigInt(info.ino ? info.ino : 0), true);
        offset += 8;

        memoryView.setUint8(offset, entry.type);
        offset += 8;

        memoryView.setUint32(offset, Number(info.nlink), true);
        offset += 8;

        memoryView.setBigUint64(offset, BigInt(info.size), true);
        offset += 8;

        memoryView.setBigUint64(
          offset,
          BigInt(info.atime ? info.atime.getTime() * 1e6 : 0),
          true,
        );
        offset += 8;

        memoryView.setBigUint64(
          offset,
          BigInt(info.mtime ? info.mtime.getTime() * 1e6 : 0),
          true,
        );
        offset += 8;

        memoryView.setBigUint64(
          offset,
          BigInt(info.birthtime ? info.birthtime.getTime() * 1e6 : 0),
          true,
        );
        offset += 8;

        return ERRNO_SUCCESS;
      }),

      "fd_filestat_set_size": syscall((
        fd: number,
        size: bigint,
      ): number => {
        const entry = this.fds[fd];
        if (!entry) {
          return ERRNO_BADF;
        }

        Deno.ftruncateSync(entry.rid!, Number(size));

        return ERRNO_SUCCESS;
      }),

      "fd_filestat_set_times": syscall((
        fd: number,
        atim: bigint,
        mtim: bigint,
        flags: number,
      ): number => {
        const entry = this.fds[fd];
        if (!entry) {
          return ERRNO_BADF;
        }

        if (!entry.path) {
          return ERRNO_INVAL;
        }

        if ((flags & FSTFLAGS_ATIM_NOW) == FSTFLAGS_ATIM_NOW) {
          atim = BigInt(Date.now() * 1e6);
        }

        if ((flags & FSTFLAGS_MTIM_NOW) == FSTFLAGS_MTIM_NOW) {
          mtim = BigInt(Date.now() * 1e6);
        }

        Deno.utimeSync(entry.path!, Number(atim), Number(mtim));

        return ERRNO_SUCCESS;
      }),

      "fd_pread": syscall((
        fd: number,
        iovsOffset: number,
        iovsLength: number,
        offset: bigint,
        nreadOffset: number,
      ): number => {
        const entry = this.fds[fd];
        if (entry == null) {
          return ERRNO_BADF;
        }

        const seek = Deno.seekSync(entry.rid!, 0, Deno.SeekMode.Current);
        const memoryView = new DataView(this.memory.buffer);

        let nread = 0;
        for (let i = 0; i < iovsLength; i++) {
          const dataOffset = memoryView.getUint32(iovsOffset, true);
          iovsOffset += 4;

          const dataLength = memoryView.getUint32(iovsOffset, true);
          iovsOffset += 4;

          const data = new Uint8Array(
            this.memory.buffer,
            dataOffset,
            dataLength,
          );
          nread += Deno.readSync(entry.rid!, data) as number;
        }

        Deno.seekSync(entry.rid!, seek, Deno.SeekMode.Start);
        memoryView.setUint32(nreadOffset, nread, true);

        return ERRNO_SUCCESS;
      }),

      "fd_prestat_get": syscall((
        fd: number,
        prestatOffset: number,
      ): number => {
        const entry = this.fds[fd];
        if (!entry) {
          return ERRNO_BADF;
        }

        if (!entry.vpath) {
          return ERRNO_BADF;
        }

        const memoryView = new DataView(this.memory.buffer);
        memoryView.setUint8(prestatOffset, PREOPENTYPE_DIR);
        memoryView.setUint32(
          prestatOffset + 4,
          new TextEncoder().encode(entry.vpath).byteLength,
          true,
        );

        return ERRNO_SUCCESS;
      }),

      "fd_prestat_dir_name": syscall((
        fd: number,
        pathOffset: number,
        pathLength: number,
      ): number => {
        const entry = this.fds[fd];
        if (!entry) {
          return ERRNO_BADF;
        }

        if (!entry.vpath) {
          return ERRNO_BADF;
        }

        const data = new Uint8Array(this.memory.buffer, pathOffset, pathLength);
        data.set(new TextEncoder().encode(entry.vpath));

        return ERRNO_SUCCESS;
      }),

      "fd_pwrite": syscall((
        fd: number,
        iovsOffset: number,
        iovsLength: number,
        offset: bigint,
        nwrittenOffset: number,
      ): number => {
        const entry = this.fds[fd];
        if (!entry) {
          return ERRNO_BADF;
        }

        const seek = Deno.seekSync(entry.rid!, 0, Deno.SeekMode.Current);
        const memoryView = new DataView(this.memory.buffer);

        let nwritten = 0;
        for (let i = 0; i < iovsLength; i++) {
          const dataOffset = memoryView.getUint32(iovsOffset, true);
          iovsOffset += 4;

          const dataLength = memoryView.getUint32(iovsOffset, true);
          iovsOffset += 4;

          const data = new Uint8Array(
            this.memory.buffer,
            dataOffset,
            dataLength,
          );
          nwritten += Deno.writeSync(entry.rid!, data) as number;
        }

        Deno.seekSync(entry.rid!, seek, Deno.SeekMode.Start);
        memoryView.setUint32(nwrittenOffset, nwritten, true);

        return ERRNO_SUCCESS;
      }),

      "fd_read": syscall((
        fd: number,
        iovsOffset: number,
        iovsLength: number,
        nreadOffset: number,
      ): number => {
        const entry = this.fds[fd];
        if (!entry) {
          return ERRNO_BADF;
        }

        const memoryView = new DataView(this.memory.buffer);

        let nread = 0;
        for (let i = 0; i < iovsLength; i++) {
          const dataOffset = memoryView.getUint32(iovsOffset, true);
          iovsOffset += 4;

          const dataLength = memoryView.getUint32(iovsOffset, true);
          iovsOffset += 4;

          const data = new Uint8Array(
            this.memory.buffer,
            dataOffset,
            dataLength,
          );
          nread += Deno.readSync(entry.rid!, data) as number;
        }

        memoryView.setUint32(nreadOffset, nread, true);

        return ERRNO_SUCCESS;
      }),

      "fd_readdir": syscall((
        fd: number,
        bufferOffset: number,
        bufferLength: number,
        cookie: bigint,
        bufferUsedOffset: number,
      ): number => {
        const entry = this.fds[fd];
        if (!entry) {
          return ERRNO_BADF;
        }

        const memoryData = new Uint8Array(this.memory.buffer);
        const memoryView = new DataView(this.memory.buffer);

        let bufferUsed = 0;

        const entries = Array.from(Deno.readDirSync(entry.path!));
        for (let i = Number(cookie); i < entries.length; i++) {
          const nameData = new TextEncoder().encode(entries[i].name);

          const entryInfo = Deno.statSync(
            resolve(entry.path!, entries[i].name),
          );
          const entryData = new Uint8Array(24 + nameData.byteLength);
          const entryView = new DataView(entryData.buffer);

          entryView.setBigUint64(0, BigInt(i + 1), true);
          entryView.setBigUint64(
            8,
            BigInt(entryInfo.ino ? entryInfo.ino : 0),
            true,
          );
          entryView.setUint32(16, nameData.byteLength, true);

          let type: number;
          switch (true) {
            case entries[i].isFile:
              type = FILETYPE_REGULAR_FILE;
              break;

            case entries[i].isDirectory:
              type = FILETYPE_REGULAR_FILE;
              break;

            case entries[i].isSymlink:
              type = FILETYPE_SYMBOLIC_LINK;
              break;

            default:
              type = FILETYPE_REGULAR_FILE;
              break;
          }

          entryView.setUint8(20, type);
          entryData.set(nameData, 24);

          const data = entryData.slice(
            0,
            Math.min(entryData.length, bufferLength - bufferUsed),
          );
          memoryData.set(data, bufferOffset + bufferUsed);
          bufferUsed += data.byteLength;
        }

        memoryView.setUint32(bufferUsedOffset, bufferUsed, true);

        return ERRNO_SUCCESS;
      }),

      "fd_renumber": syscall((
        fd: number,
        to: number,
      ): number => {
        if (!this.fds[fd]) {
          return ERRNO_BADF;
        }

        if (!this.fds[to]) {
          return ERRNO_BADF;
        }

        if (this.fds[to].rid) {
          Deno.close(this.fds[to].rid!);
        }

        this.fds[to] = this.fds[fd];
        delete this.fds[fd];

        return ERRNO_SUCCESS;
      }),

      "fd_seek": syscall((
        fd: number,
        offset: bigint,
        whence: number,
        newOffsetOffset: number,
      ): number => {
        const entry = this.fds[fd];
        if (!entry) {
          return ERRNO_BADF;
        }

        const memoryView = new DataView(this.memory.buffer);

        // FIXME Deno does not support seeking with big integers
        const newOffset = Deno.seekSync(entry.rid!, Number(offset), whence);
        memoryView.setBigUint64(newOffsetOffset, BigInt(newOffset), true);

        return ERRNO_SUCCESS;
      }),

      "fd_sync": syscall((
        fd: number,
      ): number => {
        const entry = this.fds[fd];
        if (!entry) {
          return ERRNO_BADF;
        }

        Deno.fsyncSync(entry.rid!);

        return ERRNO_SUCCESS;
      }),

      "fd_tell": syscall((
        fd: number,
        offsetOffset: number,
      ): number => {
        const entry = this.fds[fd];
        if (!entry) {
          return ERRNO_BADF;
        }

        const memoryView = new DataView(this.memory.buffer);

        const offset = Deno.seekSync(entry.rid!, 0, Deno.SeekMode.Current);
        memoryView.setBigUint64(offsetOffset, BigInt(offset), true);

        return ERRNO_SUCCESS;
      }),

      "fd_write": syscall((
        fd: number,
        iovsOffset: number,
        iovsLength: number,
        nwrittenOffset: number,
      ): number => {
        const entry = this.fds[fd];
        if (!entry) {
          return ERRNO_BADF;
        }

        const memoryView = new DataView(this.memory.buffer);

        let nwritten = 0;
        for (let i = 0; i < iovsLength; i++) {
          const dataOffset = memoryView.getUint32(iovsOffset, true);
          iovsOffset += 4;

          const dataLength = memoryView.getUint32(iovsOffset, true);
          iovsOffset += 4;

          const data = new Uint8Array(
            this.memory.buffer,
            dataOffset,
            dataLength,
          );
          nwritten += Deno.writeSync(entry.rid!, data) as number;
        }

        memoryView.setUint32(nwrittenOffset, nwritten, true);

        return ERRNO_SUCCESS;
      }),

      "path_create_directory": syscall((
        fd: number,
        pathOffset: number,
        pathLength: number,
      ): number => {
        const entry = this.fds[fd];
        if (!entry) {
          return ERRNO_BADF;
        }

        if (!entry.path) {
          return ERRNO_INVAL;
        }

        const textDecoder = new TextDecoder();
        const data = new Uint8Array(this.memory.buffer, pathOffset, pathLength);
        const path = resolve(entry.path!, textDecoder.decode(data));

        Deno.mkdirSync(path);

        return ERRNO_SUCCESS;
      }),

      "path_filestat_get": syscall((
        fd: number,
        flags: number,
        pathOffset: number,
        pathLength: number,
        bufferOffset: number,
      ): number => {
        const entry = this.fds[fd];
        if (!entry) {
          return ERRNO_BADF;
        }

        if (!entry.path) {
          return ERRNO_INVAL;
        }

        const textDecoder = new TextDecoder();
        const data = new Uint8Array(this.memory.buffer, pathOffset, pathLength);
        const path = resolve(entry.path!, textDecoder.decode(data));

        const memoryView = new DataView(this.memory.buffer);

        const info = (flags & LOOKUPFLAGS_SYMLINK_FOLLOW) != 0
          ? Deno.statSync(path)
          : Deno.lstatSync(path);

        memoryView.setBigUint64(
          bufferOffset,
          BigInt(info.dev ? info.dev : 0),
          true,
        );
        bufferOffset += 8;

        memoryView.setBigUint64(
          bufferOffset,
          BigInt(info.ino ? info.ino : 0),
          true,
        );
        bufferOffset += 8;

        switch (true) {
          case info.isFile:
            memoryView.setUint8(bufferOffset, FILETYPE_REGULAR_FILE);
            bufferOffset += 8;
            break;

          case info.isDirectory:
            memoryView.setUint8(bufferOffset, FILETYPE_DIRECTORY);
            bufferOffset += 8;
            break;

          case info.isSymlink:
            memoryView.setUint8(bufferOffset, FILETYPE_SYMBOLIC_LINK);
            bufferOffset += 8;
            break;

          default:
            memoryView.setUint8(bufferOffset, FILETYPE_UNKNOWN);
            bufferOffset += 8;
            break;
        }

        memoryView.setUint32(bufferOffset, Number(info.nlink), true);
        bufferOffset += 8;

        memoryView.setBigUint64(bufferOffset, BigInt(info.size), true);
        bufferOffset += 8;

        memoryView.setBigUint64(
          bufferOffset,
          BigInt(info.atime ? info.atime.getTime() * 1e6 : 0),
          true,
        );
        bufferOffset += 8;

        memoryView.setBigUint64(
          bufferOffset,
          BigInt(info.mtime ? info.mtime.getTime() * 1e6 : 0),
          true,
        );
        bufferOffset += 8;

        memoryView.setBigUint64(
          bufferOffset,
          BigInt(info.birthtime ? info.birthtime.getTime() * 1e6 : 0),
          true,
        );
        bufferOffset += 8;

        return ERRNO_SUCCESS;
      }),

      "path_filestat_set_times": syscall((
        fd: number,
        flags: number,
        pathOffset: number,
        pathLength: number,
        atim: bigint,
        mtim: bigint,
        fstflags: number,
      ): number => {
        const entry = this.fds[fd];
        if (!entry) {
          return ERRNO_BADF;
        }

        if (!entry.path) {
          return ERRNO_INVAL;
        }

        const textDecoder = new TextDecoder();
        const data = new Uint8Array(this.memory.buffer, pathOffset, pathLength);
        const path = resolve(entry.path!, textDecoder.decode(data));

        if ((fstflags & FSTFLAGS_ATIM_NOW) == FSTFLAGS_ATIM_NOW) {
          atim = BigInt(Date.now()) * BigInt(1e6);
        }

        if ((fstflags & FSTFLAGS_MTIM_NOW) == FSTFLAGS_MTIM_NOW) {
          mtim = BigInt(Date.now()) * BigInt(1e6);
        }

        Deno.utimeSync(path, Number(atim), Number(mtim));

        return ERRNO_SUCCESS;
      }),

      "path_link": syscall((
        oldFd: number,
        oldFlags: number,
        oldPathOffset: number,
        oldPathLength: number,
        newFd: number,
        newPathOffset: number,
        newPathLength: number,
      ): number => {
        const oldEntry = this.fds[oldFd];
        const newEntry = this.fds[newFd];
        if (!oldEntry || !newEntry) {
          return ERRNO_BADF;
        }

        if (!oldEntry.path || !newEntry.path) {
          return ERRNO_INVAL;
        }

        const textDecoder = new TextDecoder();
        const oldData = new Uint8Array(
          this.memory.buffer,
          oldPathOffset,
          oldPathLength,
        );
        const oldPath = resolve(oldEntry.path!, textDecoder.decode(oldData));
        const newData = new Uint8Array(
          this.memory.buffer,
          newPathOffset,
          newPathLength,
        );
        const newPath = resolve(newEntry.path!, textDecoder.decode(newData));

        Deno.linkSync(oldPath, newPath);

        return ERRNO_SUCCESS;
      }),

      "path_open": syscall((
        fd: number,
        dirflags: number,
        pathOffset: number,
        pathLength: number,
        oflags: number,
        rightsBase: bigint,
        rightsInheriting: bigint,
        fdflags: number,
        openedFdOffset: number,
      ): number => {
        const entry = this.fds[fd];
        if (!entry) {
          return ERRNO_BADF;
        }

        if (!entry.path) {
          return ERRNO_INVAL;
        }

        const textDecoder = new TextDecoder();
        const pathData = new Uint8Array(
          this.memory.buffer,
          pathOffset,
          pathLength,
        );
        const resolvedPath = resolve(entry.path!, textDecoder.decode(pathData));

        if (relative(entry.path, resolvedPath).startsWith("..")) {
          return ERRNO_NOTCAPABLE;
        }

        let path;
        if (
          (dirflags & LOOKUPFLAGS_SYMLINK_FOLLOW) == LOOKUPFLAGS_SYMLINK_FOLLOW
        ) {
          try {
            path = Deno.realPathSync(resolvedPath);
            if (relative(entry.path, path).startsWith("..")) {
              return ERRNO_NOTCAPABLE;
            }
          } catch (_err) {
            path = resolvedPath;
          }
        } else {
          path = resolvedPath;
        }

        if ((oflags & OFLAGS_DIRECTORY) !== 0) {
          // XXX (caspervonb) this isn't ideal as we can't get a rid for the
          // directory this way so there's no native fstat but Deno.open
          // doesn't work with directories on windows so we'll have to work
          // around it for now.
          const entries = Array.from(Deno.readDirSync(path));
          const openedFd = this.fds.push({
            flags: fdflags,
            path,
            entries,
          }) - 1;

          const memoryView = new DataView(this.memory.buffer);
          memoryView.setUint32(openedFdOffset, openedFd, true);

          return ERRNO_SUCCESS;
        }

        const options = {
          read: false,
          write: false,
          append: false,
          truncate: false,
          create: false,
          createNew: false,
        };

        if ((oflags & OFLAGS_CREAT) !== 0) {
          options.create = true;
          options.write = true;
        }

        if ((oflags & OFLAGS_EXCL) !== 0) {
          options.createNew = true;
        }

        if ((oflags & OFLAGS_TRUNC) !== 0) {
          options.truncate = true;
          options.write = true;
        }

        const read = (
          RIGHTS_FD_READ |
          RIGHTS_FD_READDIR
        );

        if ((rightsBase & read) != 0n) {
          options.read = true;
        }

        const write = (
          RIGHTS_FD_DATASYNC |
          RIGHTS_FD_WRITE |
          RIGHTS_FD_ALLOCATE |
          RIGHTS_FD_FILESTAT_SET_SIZE
        );

        if ((rightsBase & write) != 0n) {
          options.write = true;
        }

        if ((fdflags & FDFLAGS_APPEND) != 0) {
          options.append = true;
        }

        if ((fdflags & FDFLAGS_DSYNC) != 0) {
          // TODO (caspervonb) review if we can emulate this.
        }

        if ((fdflags & FDFLAGS_NONBLOCK) != 0) {
          // TODO (caspervonb) review if we can emulate this.
        }

        if ((fdflags & FDFLAGS_RSYNC) != 0) {
          // TODO (caspervonb) review if we can emulate this.
        }

        if ((fdflags & FDFLAGS_SYNC) != 0) {
          // TODO (caspervonb) review if we can emulate this.
        }

        if (!options.read && !options.write && !options.truncate) {
          options.read = true;
        }

        const { rid } = Deno.openSync(path, options);
        const openedFd = this.fds.push({
          rid,
          flags: fdflags,
          path,
        }) - 1;

        const memoryView = new DataView(this.memory.buffer);
        memoryView.setUint32(openedFdOffset, openedFd, true);

        return ERRNO_SUCCESS;
      }),

      "path_readlink": syscall((
        fd: number,
        pathOffset: number,
        pathLength: number,
        bufferOffset: number,
        bufferLength: number,
        bufferUsedOffset: number,
      ): number => {
        const entry = this.fds[fd];
        if (!entry) {
          return ERRNO_BADF;
        }

        if (!entry.path) {
          return ERRNO_INVAL;
        }

        const memoryData = new Uint8Array(this.memory.buffer);
        const memoryView = new DataView(this.memory.buffer);

        const pathData = new Uint8Array(
          this.memory.buffer,
          pathOffset,
          pathLength,
        );
        const path = resolve(entry.path!, new TextDecoder().decode(pathData));

        const link = Deno.readLinkSync(path);
        const linkData = new TextEncoder().encode(link);
        memoryData.set(new Uint8Array(linkData, 0, bufferLength), bufferOffset);

        const bufferUsed = Math.min(linkData.byteLength, bufferLength);
        memoryView.setUint32(bufferUsedOffset, bufferUsed, true);

        return ERRNO_SUCCESS;
      }),

      "path_remove_directory": syscall((
        fd: number,
        pathOffset: number,
        pathLength: number,
      ): number => {
        const entry = this.fds[fd];
        if (!entry) {
          return ERRNO_BADF;
        }

        if (!entry.path) {
          return ERRNO_INVAL;
        }

        const textDecoder = new TextDecoder();
        const data = new Uint8Array(this.memory.buffer, pathOffset, pathLength);
        const path = resolve(entry.path!, textDecoder.decode(data));

        if (!Deno.statSync(path).isDirectory) {
          return ERRNO_NOTDIR;
        }

        Deno.removeSync(path);

        return ERRNO_SUCCESS;
      }),

      "path_rename": syscall((
        fd: number,
        oldPathOffset: number,
        oldPathLength: number,
        newFd: number,
        newPathOffset: number,
        newPathLength: number,
      ): number => {
        const oldEntry = this.fds[fd];
        const newEntry = this.fds[newFd];
        if (!oldEntry || !newEntry) {
          return ERRNO_BADF;
        }

        if (!oldEntry.path || !newEntry.path) {
          return ERRNO_INVAL;
        }

        const textDecoder = new TextDecoder();
        const oldData = new Uint8Array(
          this.memory.buffer,
          oldPathOffset,
          oldPathLength,
        );
        const oldPath = resolve(oldEntry.path!, textDecoder.decode(oldData));
        const newData = new Uint8Array(
          this.memory.buffer,
          newPathOffset,
          newPathLength,
        );
        const newPath = resolve(newEntry.path!, textDecoder.decode(newData));

        Deno.renameSync(oldPath, newPath);

        return ERRNO_SUCCESS;
      }),

      "path_symlink": syscall((
        oldPathOffset: number,
        oldPathLength: number,
        fd: number,
        newPathOffset: number,
        newPathLength: number,
      ): number => {
        const entry = this.fds[fd];
        if (!entry) {
          return ERRNO_BADF;
        }

        if (!entry.path) {
          return ERRNO_INVAL;
        }

        const textDecoder = new TextDecoder();
        const oldData = new Uint8Array(
          this.memory.buffer,
          oldPathOffset,
          oldPathLength,
        );
        const oldPath = textDecoder.decode(oldData);
        const newData = new Uint8Array(
          this.memory.buffer,
          newPathOffset,
          newPathLength,
        );
        const newPath = resolve(entry.path!, textDecoder.decode(newData));

        Deno.symlinkSync(oldPath, newPath);

        return ERRNO_SUCCESS;
      }),

      "path_unlink_file": syscall((
        fd: number,
        pathOffset: number,
        pathLength: number,
      ): number => {
        const entry = this.fds[fd];
        if (!entry) {
          return ERRNO_BADF;
        }

        if (!entry.path) {
          return ERRNO_INVAL;
        }

        const textDecoder = new TextDecoder();
        const data = new Uint8Array(this.memory.buffer, pathOffset, pathLength);
        const path = resolve(entry.path!, textDecoder.decode(data));

        Deno.removeSync(path);

        return ERRNO_SUCCESS;
      }),

      "poll_oneoff": syscall((
        _inOffset: number,
        _outOffset: number,
        _nsubscriptions: number,
        _neventsOffset: number,
      ): number => {
        return ERRNO_NOSYS;
      }),

      "proc_exit": syscall((
        rval: number,
      ): never => {
        if (this.exitOnReturn) {
          Deno.exit(rval);
        }

        throw new ExitStatus(rval);
      }),

      "proc_raise": syscall((
        _sig: number,
      ): number => {
        return ERRNO_NOSYS;
      }),

      "sched_yield": syscall((): number => {
        return ERRNO_SUCCESS;
      }),

      "random_get": syscall((
        bufferOffset: number,
        bufferLength: number,
      ): number => {
        const buffer = new Uint8Array(
          this.memory.buffer,
          bufferOffset,
          bufferLength,
        );
        crypto.getRandomValues(buffer);

        return ERRNO_SUCCESS;
      }),

      "sock_recv": syscall((
        _fd: number,
        _riDataOffset: number,
        _riDataLength: number,
        _riFlags: number,
        _roDataLengthOffset: number,
        _roFlagsOffset: number,
      ): number => {
        return ERRNO_NOSYS;
      }),

      "sock_send": syscall((
        _fd: number,
        _siDataOffset: number,
        _siDataLength: number,
        _siFlags: number,
        _soDataLengthOffset: number,
      ): number => {
        return ERRNO_NOSYS;
      }),

      "sock_shutdown": syscall((
        _fd: number,
        _how: number,
      ): number => {
        return ERRNO_NOSYS;
      }),
    };

    this.#started = false;
  }

  /**
   * Attempt to begin execution of instance as a command by invoking its
   * _start() export.
   *
   * If the instance does not contain a _start() export, or if the instance
   * contains an _initialize export an error will be thrown.
   *
   * The instance must also have a WebAssembly.Memory export named "memory"
   * which will be used as the address space, if it does not an error will be
   * thrown.
   */
  start(instance: WebAssembly.Instance) {
    if (this.#started) {
      throw new Error("WebAssembly.Instance has already started");
    }

    this.#started = true;

    const { _start, _initialize, memory } = instance.exports;

    if (!(memory instanceof WebAssembly.Memory)) {
      throw new TypeError("WebAsembly.instance must provide a memory export");
    }

    this.memory = memory;

    if (typeof _initialize == "function") {
      throw new TypeError(
        "WebAsembly.instance export _initialize must not be a function",
      );
    }

    if (typeof _start != "function") {
      throw new TypeError(
        "WebAssembly.Instance export _start must be a function",
      );
    }

    _start();
  }

  /**
   * Attempt to initialize instance as a reactor by invoking its _initialize() export.
   *
   * If instance contains a _start() export, then an exception is thrown.
   *
   * The instance must also have a WebAssembly.Memory export named "memory"
   * which will be used as the address space, if it does not an error will be
   * thrown.
   */
  initialize(instance: WebAssembly.Instance) {
    if (this.#started) {
      throw new Error("WebAssembly.Instance has already started");
    }

    this.#started = true;

    const { _start, _initialize, memory } = instance.exports;

    if (!(memory instanceof WebAssembly.Memory)) {
      throw new TypeError("WebAsembly.instance must provide a memory export");
    }

    this.memory = memory;

    if (typeof _start == "function") {
      throw new TypeError(
        "WebAssembly.Instance export _start must not be a function",
      );
    }

    if (typeof _initialize != "function") {
      throw new TypeError(
        "WebAsembly.instance export _initialize must be a function",
      );
    }

    _initialize();
  }
}