@bytecodealliance/preview2-shim 0.0.20 → 0.14.0

package/lib/nodejs/filesystem.js

@@ -1,477 +1,590 @@
-import { streams } from '../common/io.js';
-import { environment } from './cli.js';
-import { constants, readSync, openSync, opendirSync, closeSync, fstatSync, lstatSync, statSync, writeSync, mkdirSync } from 'node:fs';
-import { platform } from 'node:process';
-
-const { InputStream, OutputStream, Error: StreamError } = streams;
-
-const isWindows = platform === 'win32';
+import {
+  ioCall,
+  inputStreamCreate,
+  outputStreamCreate,
+} from "../io/worker-io.js";
+import { INPUT_STREAM_CREATE, OUTPUT_STREAM_CREATE } from "../io/calls.js";
+import { FILE } from "../io/calls.js";
+// import { environment } from "./cli.js";
+import {
+  closeSync,
+  constants,
+  fdatasyncSync,
+  fstatSync,
+  fsyncSync,
+  ftruncateSync,
+  futimesSync,
+  linkSync,
+  lstatSync,
+  lutimesSync,
+  mkdirSync,
+  opendirSync,
+  openSync,
+  readlinkSync,
+  readSync,
+  renameSync,
+  rmdirSync,
+  statSync,
+  symlinkSync,
+  unlinkSync,
+  utimesSync,
+  writeSync,
+} from "node:fs";
+import { platform } from "node:process";
+
+const symbolDispose = Symbol.dispose || Symbol.for("dispose");
+
+const isWindows = platform === "win32";
 
 const nsMagnitude = 1_000_000_000_000n;
-function nsToDateTime (ns) {
+function nsToDateTime(ns) {
   const seconds = ns / nsMagnitude;
   const nanoseconds = Number(ns % seconds);
   return { seconds, nanoseconds };
 }
 
-function lookupType (obj) {
-  if (obj.isFile())
-    return 'regular-file';
-  else if (obj.isSocket())
-    return 'socket';
-  else if (obj.isSymbolicLink())
-    return 'symbolic-link';
-  else if (obj.isFIFO())
-    return 'fifo';
-  else if (obj.isDirectory())
-    return 'directory';
-  else if (obj.isCharacterDevice())
-    return 'character-device';
-  else if (obj.isBlockDevice())
-    return 'block-device';
-  return 'unknown';
+function lookupType(obj) {
+  if (obj.isFile()) return "regular-file";
+  else if (obj.isSocket()) return "socket";
+  else if (obj.isSymbolicLink()) return "symbolic-link";
+  else if (obj.isFIFO()) return "fifo";
+  else if (obj.isDirectory()) return "directory";
+  else if (obj.isCharacterDevice()) return "character-device";
+  else if (obj.isBlockDevice()) return "block-device";
+  return "unknown";
 }
 
+// Note: This should implement per-segment semantics of openAt, but we cannot currently
+//       due to the lack of support for openat() in Node.js.
+//       Tracking issue: https://github.com/libuv/libuv/issues/4167
 /**
- * @typedef {
- *   { hostPreopen: string } |
- *   { fullPath: string, fd: number }
- * } DescriptorProps
+ * @implements {DescriptorProps}
  */
-export class FileSystem {
-  // Note: This should implement per-segment semantics of openAt, but we cannot currently
-  //       due to the lack of support for openat() in Node.js.
-  //       Tracking issue: https://github.com/libuv/libuv/issues/4167
-
-  // TODO: support followSymlinks
-  getFullPath (descriptor, subpath, _followSymlinks) {
-    if (subpath.indexOf('\\') !== -1)
-      subpath = subpath.replace(/\\/g, '/');
-    if (subpath[0] === '/') {
-      let bestPreopenMatch = '';
-      for (const preopenEntry of this.preopenEntries) {
-        if (subpath.startsWith(preopenEntry[1]) && (!bestPreopenMatch || bestPreopenMatch.length < preopenEntry[1].length)) {
-          bestPreopenMatch = preopenEntry;
-        }
-      }
-      if (!bestPreopenMatch)
-        throw 'no-entry';
-      descriptor = bestPreopenMatch[0];
-      subpath = subpath.slice(bestPreopenMatch[1]);
-      if (subpath[0] === '/')
-        subpath = subpath.slice(1);
-    }
-    if (subpath.startsWith('.'))
-      subpath = subpath.slice(subpath[1] === '/' ? 2 : 1);
-    if (descriptor.hostPreopen)
-      return descriptor.hostPreopen + (descriptor.hostPreopen.endsWith('/') ? '' : '/') + subpath;
-    return descriptor.fullPath + '/' + subpath;
-  }
-
-  /**
-   * 
-   * @param {[string, string][]} preopens 
-   * @param {import('./cli.js').environment} environment
-   * @returns 
-   */
-  constructor (preopens, environment) {
-    const fs = this;
-    this.cwd = environment.initialCwd();
-
-    class FileInputStream extends InputStream {
-      constructor (hostFd, position) {
-        super({
-          blockingRead (len) {
-            const buf = new Uint8Array(Number(len));
-            try {
-              var bytesRead = readSync(this.hostFd, buf, 0, buf.byteLength, this.position);
-            } catch (e) {
-              throw { tag: 'last-operation-failed', val: new StreamError(e.message) };
-            }
-            this.position += bytesRead;
-            if (bytesRead < buf.byteLength) {
-              if (bytesRead === 0)
-                throw { tag: 'closed' };
-              return new Uint8Array(buf.buffer, 0, bytesRead);
-            }
-            return buf;
-          },
-          subscribe () {
-            // TODO
-          },
-          drop () {
-            // TODO
-          }
-        });
-        this.hostFd = hostFd;
-        this.position = Number(position);
-      }
-    }
-    
-    class FileOutputStream extends OutputStream {
-      constructor (hostFd, position) {
-        super({
-          write (contents) {
-            let totalWritten = 0;
-            while (totalWritten !== contents.byteLength) {
-              const bytesWritten = writeSync(this.hostFd, contents, null, null, this.position);
-              totalWritten += bytesWritten;
-              contents = new Uint8Array(contents.buffer, bytesWritten);
-            }
-            this.position += contents.byteLength;
-          },
-          blockingFlush () {
-
-          },
-          drop () {
-
-          }
-        });
-        this.hostFd = hostFd;
-        this.position = Number(position);
-      }
-    }
-    
-    class DirectoryEntryStream {
-      constructor (dir) {
-        this.dir = dir;
-      }
-      readDirectoryEntry () {
-        let entry;
-        try {
-          entry = this.dir.readSync();
-        } catch (e) {
-          throw convertFsError(e);
-        }
-        if (entry === null) {
-          return null;
-        }
-        const name = entry.name;
-        const type = lookupType(entry);
-        return { name, type };
-      }
-      drop () {
-        this.dir.closeSync();
-      }
+let descriptorCnt = 3;
+class Descriptor {
+  #hostPreopen;
+  #fd;
+  #mode;
+  #fullPath;
+
+  static _createPreopen(hostPreopen) {
+    const descriptor = new Descriptor();
+    descriptor.#hostPreopen = hostPreopen.endsWith("/")
+      ? hostPreopen.slice(0, -1) || '/'
+      : hostPreopen;
+    // Windows requires UNC paths at minimum
+    if (isWindows) {
+      descriptor.#hostPreopen = descriptor.#hostPreopen.replace(/\\/g, '/');
+      if (descriptor.#hostPreopen === '/')
+        descriptor.#hostPreopen = '//';
     }
+    return descriptor;
+  }
 
-    /**
-     * @implements {DescriptorProps}
-     */
-    class Descriptor {
-      constructor () {
-        this.id = fs.descriptorCnt++;
-      }
-      readViaStream(offset) {
-        if (this.hostPreopen)
-          throw { tag: 'last-operation-failed', val: new StreamError };
-        return new FileInputStream(this.fd, offset);
-      }
-      writeViaStream(offset) {
-        if (this.hostPreopen)
-          throw 'is-directory';
-        return new FileOutputStream(this.fd, offset);
-      }
-    
-      appendViaStream() {
-        console.log(`[filesystem] APPEND STREAM ${this.id}`);
-      }
-    
-      advise(offset, length, advice) {
-        console.log(`[filesystem] ADVISE`, this.id, offset, length, advice);
-      }
-    
-      syncData() {
-        console.log(`[filesystem] SYNC DATA ${this.id}`);
-      }
-    
-      getFlags() {
-        console.log(`[filesystem] FLAGS FOR ${this.id}`);
-      }
-    
-      getType() {
-        if (this.hostPreopen) return 'directory';
-        const stats = fstatSync(this.fd);
-        return lookupType(stats);
-      }
-    
-      setFlags(flags) {
-        console.log(`[filesystem] SET FLAGS ${this.id} ${JSON.stringify(flags)}`);
-      }
-    
-      setSize(size) {
-        console.log(`[filesystem] SET SIZE`, this.id, size);
-      }
-    
-      setTimes(dataAccessTimestamp, dataModificationTimestamp) {
-        console.log(`[filesystem] SET TIMES`, this.id, dataAccessTimestamp, dataModificationTimestamp);
-      }
+  static _create(fd, mode, fullPath) {
+    const descriptor = new Descriptor();
+    descriptor.#fd = fd;
+    descriptor.#mode = mode;
+    if (fullPath.endsWith("/")) throw new Error("bad full path");
+    descriptor.#fullPath = fullPath;
+    return descriptor;
+  }
 
-      read(length, offset) {
-        if (!this.fullPath) throw 'bad-descriptor';
-        const buf = new Uint8Array(length);
-        const bytesRead = readSync(this.fd, buf, Number(offset), length, 0);
-        const out = new Uint8Array(buf.buffer, 0, bytesRead);
-        return [out, bytesRead === 0 ? 'ended' : 'open'];
-      }
+  constructor() {
+    // this id is purely for debugging purposes
+    this._id = descriptorCnt++;
+  }
 
-      write(buffer, offset) {
-        if (!this.fullPath) throw 'bad-descriptor';
-        return BigInt(writeSync(this.fd, buffer, Number(offset), buffer.byteLength - offset, 0));
-      }
+  readViaStream(offset) {
+    if (this.#hostPreopen) throw "is-directory";
+    return inputStreamCreate(
+      FILE,
+      ioCall(INPUT_STREAM_CREATE | FILE, null, {
+        fd: this.#fd,
+        offset,
+      })
+    );
+  }
 
-      readDirectory() {
-        if (!this.fullPath) throw 'bad-descriptor';
-        try {
-          const dir = opendirSync(isWindows ? this.fullPath.slice(1) : this.fullPath);
-          return new DirectoryEntryStream(dir);
-        }
-        catch (e) {
-          throw convertFsError(e);
-        }
-      }
+  writeViaStream(offset) {
+    if (this.#hostPreopen) throw "is-directory";
+    return outputStreamCreate(
+      FILE,
+      ioCall(OUTPUT_STREAM_CREATE | FILE, null, { fd: this.#fd, offset })
+    );
+  }
 
-      sync() {
-        console.log(`[filesystem] SYNC`, this.id);
-      }
-    
-      createDirectoryAt(path) {
-        const fullPath = fs.getFullPath(this, path);
-        try {
-          mkdirSync(fullPath);
-        }
-        catch (e) {
-          throw convertFsError(e);
-        }
-      }
+  appendViaStream() {
+    return this.writeViaStream(this.stat().size);
+  }
 
-      stat() {
-        if (this.hostPreopen) throw 'invalid';
-        let stats;
-        try {
-          stats = fstatSync(this.fd, { bigint: true });
-        }
-        catch (e) {
-          convertFsError(e);
-        }
-        const type = lookupType(stats);
-        return {
-          type,
-          linkCount: stats.nlink,
-          size: stats.size,
-          dataAccessTimestamp: nsToDateTime(stats.atimeNs),
-          dataModificationTimestamp: nsToDateTime(stats.mtimeNs),
-          statusChangeTimestamp: nsToDateTime(stats.ctimeNs),
-        };
-      }
+  advise(_offset, _length, _advice) { }
 
-      statAt(pathFlags, path) {
-        const fullPath = fs.getFullPath(this, path, false);
-        let stats;
-        try {
-          stats = (pathFlags.symlinkFollow ? statSync : lstatSync)(isWindows ? fullPath.slice(1) : fullPath, { bigint: true });
-        }
-        catch (e) {
-          convertFsError(e);
-        }
-        const type = lookupType(stats);
-        return {
-          type,
-          linkCount: stats.nlink,
-          size: stats.size,
-          dataAccessTimestamp: nsToDateTime(stats.atimeNs),
-          dataModificationTimestamp: nsToDateTime(stats.mtimeNs),
-          statusChangeTimestamp: nsToDateTime(stats.ctimeNs),
-        };
-      }
+  syncData() {
+    if (this.#hostPreopen) throw "invalid";
+    try {
+      fdatasyncSync(this.#fd);
+    } catch (e) {
+      throw convertFsError(e);
+    }
+  }
 
-      setTimesAt() {
-        console.log(`[filesystem] SET TIMES AT`, this.id);
-      }
+  getFlags() {
+    if (this.#hostPreopen) throw "invalid";
+    return this.#mode;
+  }
 
-      linkAt() {
-        console.log(`[filesystem] LINK AT`, this.id);
-      }
+  getType() {
+    if (this.#hostPreopen) return "directory";
+    const stats = fstatSync(this.#fd);
+    return lookupType(stats);
+  }
 
-      openAt(pathFlags, path, openFlags, descriptorFlags, modes) {
-        const fullPath = fs.getFullPath(this, path, pathFlags.symlinkFollow);
-        let fsOpenFlags = 0x0;
-        if (openFlags.create)
-          fsOpenFlags |= constants.O_CREAT;
-        if (openFlags.directory)
-          fsOpenFlags |= constants.O_DIRECTORY;
-        if (openFlags.exclusive)
-          fsOpenFlags |= constants.O_EXCL;
-        if (openFlags.truncate)
-          fsOpenFlags |= constants.O_TRUNC;
-
-        if (descriptorFlags.read && descriptorFlags.write)
-          fsOpenFlags |= constants.O_RDWR;
-        else if (descriptorFlags.write)
-          fsOpenFlags |= constants.O_WRONLY;
-        // TODO:
-        // if (descriptorFlags.fileIntegritySync)
-        // if (descriptorFlags.dataIntegritySync)
-        // if (descriptorFlags.requestedWriteSync)
-        // if (descriptorFlags.mutateDirectory)
-
-        let fsMode = 0x0;
-        if (modes.readable)
-          fsMode |= 0o444;
-        if (modes.writeable)
-          fsMode |= 0o222;
-        if (modes.executable)
-          fsMode |= 0o111;
-
-        try {
-          const fd = openSync(isWindows ? fullPath.slice(1) : fullPath, fsOpenFlags, fsMode);
-          return Object.assign(new Descriptor(), { fullPath, fd });
-        }
-        catch (e) {
-          throw convertFsError(e);
-        }
-      }
+  setSize(size) {
+    if (this.#hostPreopen) throw "is-directory";
+    try {
+      ftruncateSync(this.#fd, Number(size));
+    } catch (e) {
+      throw convertFsError(e);
+    }
+  }
 
-      readlinkAt() {
-        console.log(`[filesystem] READLINK AT`, this.id);
-      }
+  setTimes(dataAccessTimestamp, dataModificationTimestamp) {
+    if (this.#hostPreopen) throw "invalid";
+    let stats;
+    if (
+      dataAccessTimestamp.tag === "no-change" ||
+      dataModificationTimestamp.tag === "no-change"
+    )
+      stats = this.stat();
+    const atime = this.#getNewTimestamp(
+      dataAccessTimestamp,
+      dataAccessTimestamp.tag === "no-change" && stats.dataAccessTimestamp
+    );
+    const mtime = this.#getNewTimestamp(
+      dataModificationTimestamp,
+      dataModificationTimestamp.tag === "no-change" &&
+      stats.dataModificationTimestamp
+    );
+    try {
+      futimesSync(this.#fd, atime, mtime);
+    } catch (e) {
+      throw convertFsError(e);
+    }
+  }
 
-      removeDirectoryAt() {
-        console.log(`[filesystem] REMOVE DIR AT`, this.id);
-      }
+  #getNewTimestamp(newTimestamp, maybeNow) {
+    switch (newTimestamp.tag) {
+      case "no-change":
+        return timestampToMs(maybeNow);
+      case "now":
+        return Math.floor(Date.now() / 1e3);
+      case "timestamp":
+        return timestampToMs(newTimestamp.val);
+    }
+  }
 
-      renameAt() {
-        console.log(`[filesystem] RENAME AT`, this.id);
-      }
+  read(length, offset) {
+    if (!this.#fullPath) throw "bad-descriptor";
+    const buf = new Uint8Array(length);
+    const bytesRead = readSync(this.#fd, buf, Number(offset), length, 0);
+    const out = new Uint8Array(buf.buffer, 0, bytesRead);
+    return [out, bytesRead === 0 ? "ended" : "open"];
+  }
 
-      symlinkAt() {
-        console.log(`[filesystem] SYMLINK AT`, this.id);
-      }
+  write(buffer, offset) {
+    if (!this.#fullPath) throw "bad-descriptor";
+    return BigInt(
+      writeSync(this.#fd, buffer, Number(offset), buffer.byteLength - offset, 0)
+    );
+  }
 
-      unlinkFileAt() {
-        console.log(`[filesystem] UNLINK FILE AT`, this.id);
-      }
+  readDirectory() {
+    if (!this.#fullPath) throw "bad-descriptor";
+    try {
+      const dir = opendirSync(this.#fullPath);
+      return directoryEntryStreamCreate(dir);
+    } catch (e) {
+      throw convertFsError(e);
+    }
+  }
 
-      changeFilePermissionsAt() {
-        console.log(`[filesystem] CHANGE FILE PERMISSIONS AT`, this.id);
-      }
+  sync() {
+    if (this.#hostPreopen) throw "invalid";
+    try {
+      fsyncSync(this.#fd);
+    } catch (e) {
+      throw convertFsError(e);
+    }
+  }
 
-      changeDirectoryPermissionsAt() {
-        console.log(`[filesystem] CHANGE DIR PERMISSIONS AT`, this.id);
-      }
+  createDirectoryAt(path) {
+    const fullPath = this.#getFullPath(path);
+    try {
+      mkdirSync(fullPath);
+    } catch (e) {
+      throw convertFsError(e);
+    }
+  }
 
-      lockShared() {
-        console.log(`[filesystem] LOCK SHARED`, this.id);
-      }
+  stat() {
+    if (this.#hostPreopen) throw "invalid";
+    let stats;
+    try {
+      stats = fstatSync(this.#fd, { bigint: true });
+    } catch (e) {
+      throw convertFsError(e);
+    }
+    const type = lookupType(stats);
+    return {
+      type,
+      linkCount: stats.nlink,
+      size: stats.size,
+      dataAccessTimestamp: nsToDateTime(stats.atimeNs),
+      dataModificationTimestamp: nsToDateTime(stats.mtimeNs),
+      statusChangeTimestamp: nsToDateTime(stats.ctimeNs),
+    };
+  }
 
-      lockExclusive() {
-        console.log(`[filesystem] LOCK EXCLUSIVE`, this.id);
-      }
+  statAt(pathFlags, path) {
+    const fullPath = this.#getFullPath(path, false);
+    let stats;
+    try {
+      stats = (pathFlags.symlinkFollow ? statSync : lstatSync)(fullPath, { bigint: true });
+    } catch (e) {
+      throw convertFsError(e);
+    }
+    const type = lookupType(stats);
+    return {
+      type,
+      linkCount: stats.nlink,
+      size: stats.size,
+      dataAccessTimestamp: nsToDateTime(stats.atimeNs),
+      dataModificationTimestamp: nsToDateTime(stats.mtimeNs),
+      statusChangeTimestamp: nsToDateTime(stats.ctimeNs),
+    };
+  }
 
-      tryLockShared() {
-        console.log(`[filesystem] TRY LOCK SHARED`, this.id);
-      }
+  setTimesAt(pathFlags, path, dataAccessTimestamp, dataModificationTimestamp) {
+    const fullPath = this.#getFullPath(path, false);
+    let stats;
+    if (
+      dataAccessTimestamp.tag === "no-change" ||
+      dataModificationTimestamp.tag === "no-change"
+    )
+      stats = this.stat();
+    const atime = this.#getNewTimestamp(
+      dataAccessTimestamp,
+      dataAccessTimestamp.tag === "no-change" && stats.dataAccessTimestamp
+    );
+    const mtime = this.#getNewTimestamp(
+      dataModificationTimestamp,
+      dataModificationTimestamp.tag === "no-change" &&
+      stats.dataModificationTimestamp
+    );
+    try {
+      (pathFlags.symlinkFollow ? utimesSync : lutimesSync)(
+        fullPath,
+        atime,
+        mtime
+      );
+    } catch (e) {
+      throw convertFsError(e);
+    }
+  }
 
-      tryLockExclusive() {
-        console.log(`[filesystem] TRY LOCK EXCLUSIVE`, this.id);
-      }
+  linkAt(oldPathFlags, oldPath, newDescriptor, newPath) {
+    const oldFullPath = this.#getFullPath(oldPath, oldPathFlags.symlinkFollow);
+    const newFullPath = newDescriptor.#getFullPath(newPath, false);
+    // Windows doesn't automatically fail on trailing slashes
+    if (isWindows && newFullPath.endsWith('/'))
+      throw 'no-entry';
+    try {
+      linkSync(oldFullPath, newFullPath);
+    } catch (e) {
+      throw convertFsError(e);
+    }
+  }
 
-      unlock() {
-        console.log(`[filesystem] UNLOCK`, this.id);
-      }
+  openAt(pathFlags, path, openFlags, descriptorFlags) {
+    const fullPath = this.#getFullPath(path, pathFlags.symlinkFollow);
+    let fsOpenFlags = 0x0;
+    if (openFlags.create) fsOpenFlags |= constants.O_CREAT;
+    if (openFlags.directory) fsOpenFlags |= constants.O_DIRECTORY;
+    if (openFlags.exclusive) fsOpenFlags |= constants.O_EXCL;
+    if (openFlags.truncate) fsOpenFlags |= constants.O_TRUNC;
+
+    if (descriptorFlags.read && descriptorFlags.write)
+      fsOpenFlags |= constants.O_RDWR;
+    else if (descriptorFlags.write) fsOpenFlags |= constants.O_WRONLY;
+    else if (descriptorFlags.read) fsOpenFlags |= constants.O_RDONLY;
+    if (descriptorFlags.fileIntegritySync) fsOpenFlags |= constants.O_SYNC;
+    if (descriptorFlags.dataIntegritySync) fsOpenFlags |= constants.O_DSYNC;
+    // Unsupported:
+    // if (descriptorFlags.requestedWriteSync)
+    // if (descriptorFlags.mutateDirectory)
+
+    try {
+      const fd = openSync(fullPath, fsOpenFlags);
+      return descriptorCreate(fd, descriptorFlags, fullPath, preopenEntries);
+    } catch (e) {
+      throw convertFsError(e);
+    }
+  }
 
-      drop() {
-        if (this.fd)
-          closeSync(this.fd);
-      }
+  readlinkAt(path) {
+    const fullPath = this.#getFullPath(path, false);
+    try {
+      return readlinkSync(fullPath);
+    } catch (e) {
+      throw convertFsError(e);
+    }
+  }
 
-      metadataHash() {
-        if (this.hostPreopen)
-          return { upper: 0n, lower: BigInt(this.id) };
-        try {
-          const stats = fstatSync(this.fd, { bigint: true });
-          return { upper: stats.mtimeNs, lower: stats.ino };
-        }
-        catch (e) {
-          convertFsError(e);
-        }
-      }
+  removeDirectoryAt(path) {
+    const fullPath = this.#getFullPath(path, false);
+    try {
+      rmdirSync(fullPath);
+    } catch (e) {
+      if (isWindows && e.code === 'ENOENT')
+        throw 'not-directory';
+      throw convertFsError(e);
+    }
+  }
 
-      metadataHashAt(pathFlags, path) {
-        const fullPath = fs.getFullPath(this, path, false);
-        try {
-          const stats = (pathFlags.symlinkFollow ? statSync : lstatSync)(isWindows ? fullPath.slice(1) : fullPath, { bigint: true });
-          return { upper: stats.mtimeNs, lower: stats.ino };
-        }
-        catch (e) {
-          convertFsError(e);
+  renameAt(oldPath, newDescriptor, newPath) {
+    const oldFullPath = this.#getFullPath(oldPath, false);
+    const newFullPath = newDescriptor.#getFullPath(newPath, false);
+    try {
+      renameSync(oldFullPath, newFullPath);
+    } catch (e) {
+      if (isWindows && e.code === 'EPERM')
+        throw 'access';
+      throw convertFsError(e);
+    }
+  }
+
+  symlinkAt(target, path) {
+    const fullPath = this.#getFullPath(path, false);
+    try {
+      symlinkSync(target, fullPath);
+    } catch (e) {
+      if (isWindows && (e.code === 'EPERM' || e.code === 'EEXIST'))
+        throw 'no-entry'
+      throw convertFsError(e);
+    }
+  }
+
+  unlinkFileAt(path) {
+    const fullPath = this.#getFullPath(path, false);
+    try {
+      unlinkSync(fullPath);
+    } catch (e) {
+      throw convertFsError(e);
+    }
+  }
+
+  isSameObject(other) {
+    return other === this;
+  }
+
+  metadataHash() {
+    if (this.#hostPreopen) return { upper: 0n, lower: BigInt(this._id) };
+    try {
+      const stats = fstatSync(this.#fd, { bigint: true });
+      return { upper: stats.mtimeNs, lower: stats.ino };
+    } catch (e) {
+      throw convertFsError(e);
+    }
+  }
+
+  metadataHashAt(pathFlags, path) {
+    const fullPath = this.#getFullPath(path, false);
+    try {
+      const stats = (pathFlags.symlinkFollow ? statSync : lstatSync)(fullPath, { bigint: true });
+      return { upper: stats.mtimeNs, lower: stats.ino };
+    } catch (e) {
+      throw convertFsError(e);
+    }
+  }
+
+  // TODO: support followSymlinks
+  #getFullPath(subpath, _followSymlinks) {
+    let descriptor = this;
+    if (subpath.indexOf("\\") !== -1) subpath = subpath.replace(/\\/g, "/");
+    if (subpath[0] === '/') {
+      let bestPreopenMatch = "";
+      for (const preopenEntry of preopenEntries) {
+        if (
+          subpath.startsWith(preopenEntry[1]) &&
+          (!bestPreopenMatch ||
+            bestPreopenMatch.length < preopenEntry[1].length)
+        ) {
+          bestPreopenMatch = preopenEntry;
         }
       }
+      if (!bestPreopenMatch) throw "no-entry";
+      descriptor = bestPreopenMatch[0];
+      subpath = subpath.slice(bestPreopenMatch[1]);
+      if (subpath[0] === "/") subpath = subpath.slice(1);
     }
+    if (subpath.startsWith("."))
+      subpath = subpath.slice(subpath[1] === "/" ? 2 : 1);
+    if (descriptor.#hostPreopen)
+      return (
+        descriptor.#hostPreopen + (descriptor.#hostPreopen.endsWith('/') ? '' : (subpath.length > 0 ? "/" : "")) + subpath
+      );
+    return descriptor.#fullPath + (subpath.length > 0 ? "/" : "") + subpath;
+  }
 
-    this.descriptorCnt = 3;
-    this.preopenEntries = [];
-    for (const [virtualPath, hostPreopen] of Object.entries(preopens)) {
-      const preopenEntry = [Object.assign(new Descriptor(), { hostPreopen }), virtualPath];
-      this.preopenEntries.push(preopenEntry);
+  [symbolDispose]() {
+    if (this.#fd) closeSync(this.#fd);
+  }
+}
+const descriptorCreatePreopen = Descriptor._createPreopen;
+delete Descriptor._createPreopen;
+const descriptorCreate = Descriptor._create;
+delete Descriptor._create;
+
+class DirectoryEntryStream {
+  #dir;
+  readDirectoryEntry() {
+    let entry;
+    try {
+      entry = this.#dir.readSync();
+    } catch (e) {
+      throw convertFsError(e);
     }
-    this.preopens = {
-      Descriptor,
-      getDirectories () {
-        return fs.preopenEntries;
-      }
-    };
-    this.types = {
-      Descriptor,
-      DirectoryEntryStream,
-    };
+    if (entry === null) {
+      return null;
+    }
+    const name = entry.name;
+    const type = lookupType(entry);
+    return { name, type };
+  }
+  [symbolDispose]() {
+    this.#dir.closeSync();
+  }
+
+  static _create(dir) {
+    const dirStream = new DirectoryEntryStream();
+    dirStream.#dir = dir;
+    return dirStream;
   }
 }
+const directoryEntryStreamCreate = DirectoryEntryStream._create;
+delete DirectoryEntryStream._create;
 
-const _fs = new FileSystem({ '/': '/' }, environment);
+let preopenEntries = [];
 
-export const { preopens, types } = _fs;
+export const preopens = {
+  Descriptor,
+  getDirectories() {
+    return preopenEntries;
+  },
+};
 
-function convertFsError (e) {
+_addPreopen("/", isWindows ? "//" : "/");
+
+export const types = {
+  Descriptor,
+  DirectoryEntryStream,
+};
+
+export function _setPreopens(preopens) {
+  preopenEntries = [];
+  for (const [virtualPath, hostPreopen] of Object.entries(preopens)) {
+    _addPreopen(virtualPath, hostPreopen);
+  }
+}
+
+export function _addPreopen(virtualPath, hostPreopen) {
+  const preopenEntry = [descriptorCreatePreopen(hostPreopen), virtualPath];
+  preopenEntries.push(preopenEntry);
+}
+
+function convertFsError(e) {
   switch (e.code) {
-    case 'EACCES': throw 'access';
-    case 'EAGAIN':
-    case 'EWOULDBLOCK': throw 'would-block';
-    case 'EALREADY': throw 'already';
-    case 'EBADF': throw 'bad-descriptor';
-    case 'EBUSY': throw 'busy';
-    case 'EDEADLK': throw 'deadlock';
-    case 'EDQUOT': throw 'quota';
-    case 'EEXIST': throw 'exist';
-    case 'EFBIG': throw 'file-too-large';
-    case 'EILSEQ': throw 'illegal-byte-sequence';
-    case 'EINPROGRESS': throw 'in-progress';
-    case 'EINTR': throw 'interrupted';
-    case 'EINVAL': throw 'invalid';
-    case 'EIO': throw 'io';
-    case 'EISDIR': throw 'is-directory';
-    case 'ELOOP': throw 'loop';
-    case 'EMLINK': throw 'too-many-links';
-    case 'EMSGSIZE': throw 'message-size';
-    case 'ENAMETOOLONG': throw 'name-too-long'
-    case 'ENODEV': throw 'no-device';
-    case 'ENOENT': throw 'no-entry';
-    case 'ENOLCK': throw 'no-lock';
-    case 'ENOMEM': throw 'insufficient-memory';
-    case 'ENOSPC': throw 'insufficient-space';
-    case 'ENOTDIR': throw 'not-directory';
-    case 'ENOTEMPTY': throw 'not-empty';
-    case 'ENOTRECOVERABLE': throw 'not-recoverable';
-    case 'ENOTSUP': throw 'unsupported';
-    case 'ENOTTY': throw 'no-tty';
-    case 'ENXIO': throw 'no-such-device';
-    case 'EOVERFLOW': throw 'overflow';
-    case 'EPERM': throw 'not-permitted';
-    case 'EPIPE': throw 'pipe';
-    case 'EROFS': throw 'read-only';
-    case 'ESPIPE': throw 'invalid-seek';
-    case 'ETXTBSY': throw 'text-file-busy';
-    case 'EXDEV': throw 'cross-device';
-    default: throw e;
+    case "EACCES":
+      return "access";
+    case "EAGAIN":
+    case "EWOULDBLOCK":
+      return "would-block";
+    case "EALREADY":
+      return "already";
+    case "EBADF":
+      return "bad-descriptor";
+    case "EBUSY":
+      return "busy";
+    case "EDEADLK":
+      return "deadlock";
+    case "EDQUOT":
+      return "quota";
+    case "EEXIST":
+      return "exist";
+    case "EFBIG":
+      return "file-too-large";
+    case "EILSEQ":
+      return "illegal-byte-sequence";
+    case "EINPROGRESS":
+      return "in-progress";
+    case "EINTR":
+      return "interrupted";
+    case "EINVAL":
+      return "invalid";
+    case "EIO":
+      return "io";
+    case "EISDIR":
+      return "is-directory";
+    case "ELOOP":
+      return "loop";
+    case "EMLINK":
+      return "too-many-links";
+    case "EMSGSIZE":
+      return "message-size";
+    case "ENAMETOOLONG":
+      return "name-too-long";
+    case "ENODEV":
+      return "no-device";
+    case "ENOENT":
+      return "no-entry";
+    case "ENOLCK":
+      return "no-lock";
+    case "ENOMEM":
+      return "insufficient-memory";
+    case "ENOSPC":
+      return "insufficient-space";
+    case "ENOTDIR":
+      return "not-directory";
+    case "ENOTEMPTY":
+      return "not-empty";
+    case "ENOTRECOVERABLE":
+      return "not-recoverable";
+    case "ENOTSUP":
+      return "unsupported";
+    case "ENOTTY":
+      return "no-tty";
+    case "ENXIO":
+      return "no-such-device";
+    case "EOVERFLOW":
+      return "overflow";
+    case "EPERM":
+      return "not-permitted";
+    case "EPIPE":
+      return "pipe";
+    case "EROFS":
+      return "read-only";
+    case "ESPIPE":
+      return "invalid-seek";
+    case "ETXTBSY":
+      return "text-file-busy";
+    case "EXDEV":
+      return "cross-device";
+    default:
+      throw e;
   }
 }
+
+function timestampToMs(timestamp) {
+  return Number(timestamp.seconds) * 1000 + timestamp.nanoseconds / 1e9;
+}