@bytecodealliance/preview2-shim 0.0.16 → 0.0.18

package/lib/nodejs/filesystem.js

@@ -1,78 +1,437 @@
-import { openSync, constants, statSync, lstatSync, fstatSync, closeSync, readdirSync } from 'node:fs';
-import { _createFsStream, _dropFsStream, _getFsStreamContext } from './io.js';
-
-// default is full permissions
-let preopenCnt = 4;
-export let _descriptors = {
-  3: { type: 'directory', path: '/', parent: null, subpathTypes: {} }
-};
-let directories = [[3, '/']];
-
-export function _setPreopens (preopens) {
-  _descriptors = {};
-  directories = [,,];
-  for (const [virtualPath, path] of Object.entries(preopens)) {
-    _descriptors[preopenCnt] = { type: 'directory', path, parent: null, subpathTypes: {} };
-    directories.push([preopenCnt++, virtualPath]);
-  }
-}
+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';
 
-export function _getFullPath (fd) {
-  let path = '';
-  while (fd) {
-    path = _descriptors[fd].path + path;
-    fd = _descriptors[fd].parent;
-  }
-  return path;
-}
+const { InputStream, OutputStream, Error: StreamError } = streams;
 
-export function _getDescriptorType (fd) {
-  return _descriptors[fd].type;
-}
+const isWindows = platform === 'win32';
 
-export function _setDescriptorType (fd, type) {
-  _descriptors[fd].type = type;
+const nsMagnitude = 1_000_000_000_000n;
+function nsToDateTime (ns) {
+  const seconds = ns / nsMagnitude;
+  const nanoseconds = Number(ns % seconds);
+  return { seconds, nanoseconds };
 }
 
-export function _setSubdescriptorType (fd, path, type) {
-  while (_descriptors[fd].parent) {
-    path = _descriptors[fd].path + path;
-    fd = _descriptors[fd].parent;
-  }
-  _descriptors[fd].subpathTypes[path] = type;
+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';
 }
 
-export function _addOpenedDescriptor (fd, path, parentFd) {
-  if (fd < preopenCnt || _descriptors[fd])
-    throw 'bad-descriptor';
-  let type = null;
-  for (const [_path, _type] of Object.entries(_descriptors[parentFd].subpathTypes)) {
-    if (_path === path)
-      type = _type;
+/**
+ * @typedef {
+ *   { hostPreopen: string } |
+ *   { fullPath: string, fd: number }
+ * } 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;
   }
-  _descriptors[fd] = { path, type, parent: parentFd, subpathTypes: {} };
-}
 
-export function _removeOpenedDescriptor (fd) {
-  if (fd < preopenCnt)
-    throw 'eperm';
-  delete _descriptors[fd];
-}
+  /**
+   * 
+   * @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();
+      }
+    }
+
+    /**
+     * @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);
+      }
+
+      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'];
+      }
+
+      write(buffer, offset) {
+        if (!this.fullPath) throw 'bad-descriptor';
+        return BigInt(writeSync(this.fd, buffer, Number(offset), buffer.byteLength - offset, 0));
+      }
+
+      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);
+        }
+      }
+
+      sync() {
+        console.log(`[filesystem] SYNC`, this.id);
+      }
+    
+      createDirectoryAt(path) {
+        const fullPath = fs.getFullPath(this, path);
+        try {
+          mkdirSync(fullPath);
+        }
+        catch (e) {
+          throw convertFsError(e);
+        }
+      }
+
+      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),
+        };
+      }
+
+      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),
+        };
+      }
+
+      setTimesAt() {
+        console.log(`[filesystem] SET TIMES AT`, this.id);
+      }
+
+      linkAt() {
+        console.log(`[filesystem] LINK AT`, this.id);
+      }
+
+      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);
+        }
+      }
+
+      readlinkAt() {
+        console.log(`[filesystem] READLINK AT`, this.id);
+      }
+
+      removeDirectoryAt() {
+        console.log(`[filesystem] REMOVE DIR AT`, this.id);
+      }
+
+      renameAt() {
+        console.log(`[filesystem] RENAME AT`, this.id);
+      }
+
+      symlinkAt() {
+        console.log(`[filesystem] SYMLINK AT`, this.id);
+      }
+
+      unlinkFileAt() {
+        console.log(`[filesystem] UNLINK FILE AT`, this.id);
+      }
+
+      changeFilePermissionsAt() {
+        console.log(`[filesystem] CHANGE FILE PERMISSIONS AT`, this.id);
+      }
+
+      changeDirectoryPermissionsAt() {
+        console.log(`[filesystem] CHANGE DIR PERMISSIONS AT`, this.id);
+      }
+
+      lockShared() {
+        console.log(`[filesystem] LOCK SHARED`, this.id);
+      }
+
+      lockExclusive() {
+        console.log(`[filesystem] LOCK EXCLUSIVE`, this.id);
+      }
+
+      tryLockShared() {
+        console.log(`[filesystem] TRY LOCK SHARED`, this.id);
+      }
+
+      tryLockExclusive() {
+        console.log(`[filesystem] TRY LOCK EXCLUSIVE`, this.id);
+      }
+
+      unlock() {
+        console.log(`[filesystem] UNLOCK`, this.id);
+      }
+
+      drop() {
+        if (this.fd)
+          closeSync(this.fd);
+      }
+
+      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);
+        }
+      }
+
+      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);
+        }
+      }
+    }
 
-export const preopens = {
-  getDirectories () {
-    return directories;
+    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);
+    }
+    this.preopens = {
+      Descriptor,
+      getDirectories () {
+        return fs.preopenEntries;
+      }
+    };
+    this.types = {
+      Descriptor,
+    };
   }
 }
 
-const nsMagnitude = 1_000_000_000_000n;
-function nsToDateTime (ns) {
-  const seconds = ns / nsMagnitude;
-  const nanoseconds = Number(ns % seconds);
-  return { seconds, nanoseconds };
-}
+const _fs = new FileSystem({ '/': '/' }, environment);
+
+export const { preopens, types } = _fs;
 
-function _convertFsError (e) {
+function convertFsError (e) {
   switch (e.code) {
     case 'EACCES': throw 'access';
     case 'EAGAIN':
@@ -115,287 +474,3 @@ function _convertFsError (e) {
     default: throw e;
   }
 }
-
-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';
-}
-
-export const types = {
-  readViaStream(fd, offset) {
-    if (Number(offset) !== 0)
-      throw new Error('Read streams with non-zero offset not currently supported');
-    const stream = _createFsStream(fd, 'file', { offset: 0 });
-    return stream;
-  },
-
-  writeViaStream(fd, offset) {
-    console.log(`[filesystem] WRITE STREAM ${fd} ${offset}`);
-  },
-
-  appendViaStream(fd) {
-    console.log(`[filesystem] APPEND STREAM ${fd}`);
-  },
-
-  advise(fd, offset, length, advice) {
-    console.log(`[filesystem] ADVISE`, fd, offset, length, advice);
-  },
-
-  syncData(fd) {
-    console.log(`[filesystem] SYNC DATA ${fd}`);
-  },
-
-  getFlags(fd) {
-    console.log(`[filesystem] FLAGS FOR ${fd}`);
-  },
-
-  getType(fd) {
-    let type = _getDescriptorType(fd);
-    if (type === null) {
-      types.stat(fd);
-      type = _getDescriptorType(fd);
-    }
-    return type;
-  },
-
-  setFlags(fd, flags) {
-    console.log(`[filesystem] SET FLAGS ${fd} ${JSON.stringify(flags)}`);
-  },
-
-  setSize(fd, size) {
-    console.log(`[filesystem] SET SIZE`, fd, size);
-  },
-
-  setTimes(fd, dataAccessTimestamp, dataModificationTimestamp) {
-    console.log(`[filesystem] SET TIMES`, fd, dataAccessTimestamp, dataModificationTimestamp);
-  },
-
-  read(fd, length, offset) {
-    console.log(`[filesystem] READ`, fd, length, offset);
-  },
-
-  write(fd, buffer, offset) {
-    console.log(`[filesystem] WRITE`, fd, buffer, offset);
-  },
-
-  readDirectory(fd) {
-    const fullPath = _getFullPath(fd);
-    let dirs;
-    try {
-      dirs = readdirSync(fullPath, { withFileTypes: true });
-    }
-    catch (e) {
-      _convertFsError(e);
-    }
-    return _createFsStream(fd, 'dir', { dirs, cursor: 0, fd });
-  },
-
-  sync(fd) {
-    console.log(`[filesystem] SYNC`, fd);
-  },
-
-  createDirectoryAt(fd, path) {
-    console.log(`[filesystem] CREATE DIRECTORY`, fd, path);
-  },
-
-  stat(fd) {
-    let stats;
-    try {
-      stats = fstatSync(fd, { bigint: true });
-    }
-    catch (e) {
-      _convertFsError(e);
-    }
-    const type = _lookupType(stats);
-    _setDescriptorType(fd, type);
-    return {
-      device: stats.dev,
-      inode: stats.ino,
-      type,
-      linkCount: stats.nlink,
-      size: stats.size,
-      dataAccessTimestamp: nsToDateTime(stats.atimeNs),
-      dataModificationTimestamp: nsToDateTime(stats.mtimeNs),
-      statusChangeTimestamp: nsToDateTime(stats.ctimeNs),
-    };
-  },
-
-  statAt(fd, { symlinkFollow }, path) {
-    const fullPath = _descriptors[fd].path + path;
-    let stats;
-    try {
-      stats = (symlinkFollow ? statSync : lstatSync)(fullPath, { bigint: true });
-    }
-    catch (e) {
-      _convertFsError(e);
-    }
-    const type = _lookupType(stats);
-    _setSubdescriptorType(fd, path, type);
-    return {
-      device: stats.dev,
-      inode: stats.ino,
-      type,
-      linkCount: stats.nlink,
-      size: stats.size,
-      dataAccessTimestamp: nsToDateTime(stats.atimeNs),
-      dataModificationTimestamp: nsToDateTime(stats.mtimeNs),
-      statusChangeTimestamp: nsToDateTime(stats.ctimeNs),
-    };
-  },
-
-  setTimesAt(fd) {
-    console.log(`[filesystem] SET TIMES AT`, fd);
-  },
-
-  linkAt(fd) {
-    console.log(`[filesystem] LINK AT`, fd);
-  },
-
-  openAt(fd, pathFlags, path, openFlags, descriptorFlags, modes) {
-    // TODO
-    // if (pathFlags.symlinkFollow) {
-    //   // resolve symlink
-    // }
-    const fullPath = _descriptors[fd].path + path;
-    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;
-    // 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;
-    let localFd;
-    try {
-      localFd = openSync(fullPath, fsOpenFlags, fsMode);
-    }
-    catch (e) {
-      _convertFsError(e);
-    }
-    _addOpenedDescriptor(localFd, path, fd);
-    return localFd;
-  },
-
-  readlinkAt(fd) {
-    console.log(`[filesystem] READLINK AT`, fd);
-  },
-
-  removeDirectoryAt(fd) {
-    console.log(`[filesystem] REMOVE DIR AT`, fd);
-  },
-
-  renameAt(fd) {
-    console.log(`[filesystem] RENAME AT`, fd);
-  },
-
-  symlinkAt(fd) {
-    console.log(`[filesystem] SYMLINK AT`, fd);
-  },
-
-  unlinkFileAt(fd) {
-    console.log(`[filesystem] UNLINK FILE AT`, fd);
-  },
-
-  changeFilePermissionsAt(fd) {
-    console.log(`[filesystem] CHANGE FILE PERMISSIONS AT`, fd);
-  },
-
-  changeDirectoryPermissionsAt(fd) {
-    console.log(`[filesystem] CHANGE DIR PERMISSIONS AT`, fd);
-  },
-
-  lockShared(fd) {
-    console.log(`[filesystem] LOCK SHARED`, fd);
-  },
-
-  lockExclusive(fd) {
-    console.log(`[filesystem] LOCK EXCLUSIVE`, fd);
-  },
-
-  tryLockShared(fd) {
-    console.log(`[filesystem] TRY LOCK SHARED`, fd);
-  },
-
-  tryLockExclusive(fd) {
-    console.log(`[filesystem] TRY LOCK EXCLUSIVE`, fd);
-  },
-
-  unlock(fd) {
-    console.log(`[filesystem] UNLOCK`, fd);
-  },
-
-  dropDescriptor(fd) {
-    _removeOpenedDescriptor(fd);
-    closeSync(fd);
-  },
-
-  readDirectoryEntry(stream) {
-    const streamValue = _getFsStreamContext(stream, 'dir');
-    if (streamValue.cursor === streamValue.dirs.length)
-      return null;
-    const dir = streamValue.dirs[streamValue.cursor++];
-    const type = _lookupType(dir);
-    _setSubdescriptorType(streamValue.fd, '/' + dir.name, type);
-    return { inode: null, type, name: dir.name };
-  },
-
-  dropDirectoryEntryStream(stream) {
-    _dropFsStream(stream);
-  },
-
-  metadataHash(fd) {
-    let stats;
-    try {
-      stats = fstatSync(fd, { bigint: true });
-    }
-    catch (e) {
-      _convertFsError(e);
-    }
-    const type = _lookupType(stats);
-    _setDescriptorType(fd, type);
-    return { upper: BigInt(stats.size), lower: stats.mtimeNs };
-  },
-
-  metadataHashAt(fd, { symlinkFollow }, path) {
-    const fullPath = _descriptors[fd].path + path;
-    let stats;
-    try {
-      stats = (symlinkFollow ? statSync : lstatSync)(fullPath, { bigint: true });
-    }
-    catch (e) {
-      _convertFsError(e);
-    }
-    const type = _lookupType(stats);
-    _setSubdescriptorType(fd, path, type);
-    return { upper: BigInt(stats.size), lower: stats.mtimeNs };
-  }
-};