@nimbus-sh/core 0.1.0

package/src/substrate/lifo/node-compat/fs.ts

@@ -0,0 +1,762 @@
+import type { VFS } from '../kernel/vfs/index.js';
+import { VFSError } from '../kernel/vfs/index.js';
+import type { Stat as VfsStat } from '../kernel/vfs/types.js';
+import { resolve, basename } from '../utils/path.js';
+import { encode, decode } from '../utils/encoding.js';
+import { Readable, Writable } from './stream.js';
+import { EventEmitter } from './events.js';
+import { Buffer } from './buffer.js';
+
+// ─── Dirent ───
+
+interface Dirent {
+  name: string;
+  path: string;
+  isFile: () => boolean;
+  isDirectory: () => boolean;
+  isSymbolicLink: () => boolean;
+  isBlockDevice: () => boolean;
+  isCharacterDevice: () => boolean;
+  isFIFO: () => boolean;
+  isSocket: () => boolean;
+}
+
+// ─── Stat conversion ───
+
+interface NodeStat {
+  dev: number;
+  ino: number;
+  mode: number;
+  nlink: number;
+  uid: number;
+  gid: number;
+  rdev: number;
+  size: number;
+  blksize: number;
+  blocks: number;
+  atimeMs: number;
+  mtimeMs: number;
+  ctimeMs: number;
+  birthtimeMs: number;
+  atime: Date;
+  mtime: Date;
+  ctime: Date;
+  birthtime: Date;
+  isFile: () => boolean;
+  isDirectory: () => boolean;
+  isSymbolicLink: () => boolean;
+  isBlockDevice: () => boolean;
+  isCharacterDevice: () => boolean;
+  isFIFO: () => boolean;
+  isSocket: () => boolean;
+}
+
+function toNodeStat(stat: VfsStat): NodeStat {
+  const isFile = stat.type === 'file';
+  const isDir = stat.type === 'directory';
+  return {
+    dev: 0,
+    ino: 0,
+    mode: stat.mode,
+    nlink: isDir ? 2 : 1,
+    uid: 1000,
+    gid: 1000,
+    rdev: 0,
+    size: stat.size,
+    blksize: 4096,
+    blocks: Math.ceil(stat.size / 512),
+    atimeMs: stat.mtime,
+    mtimeMs: stat.mtime,
+    ctimeMs: stat.ctime,
+    birthtimeMs: stat.ctime,
+    atime: new Date(stat.mtime),
+    mtime: new Date(stat.mtime),
+    ctime: new Date(stat.ctime),
+    birthtime: new Date(stat.ctime),
+    isFile: () => isFile,
+    isDirectory: () => isDir,
+    isSymbolicLink: () => false,
+    isBlockDevice: () => false,
+    isCharacterDevice: () => false,
+    isFIFO: () => false,
+    isSocket: () => false,
+  };
+}
+
+// ─── Error helpers ───
+
+interface NodeError extends Error {
+  code: string;
+  errno: number;
+  syscall: string;
+  path: string;
+}
+
+function toNodeError(e: VFSError, syscall: string, path: string): NodeError {
+  const err = new Error(e.message) as NodeError;
+  err.code = e.code;
+  err.errno = -2;
+  err.syscall = syscall;
+  err.path = path;
+  err.name = 'Error';
+  return err;
+}
+
+function makeEnoent(syscall: string, path: string): NodeError {
+  const err = new Error(`ENOENT: no such file or directory, ${syscall} '${path}'`) as NodeError;
+  err.code = 'ENOENT';
+  err.errno = -2;
+  err.syscall = syscall;
+  err.path = path;
+  return err;
+}
+
+function makeEbadf(syscall: string): NodeError {
+  const err = new Error(`EBADF: bad file descriptor, ${syscall}`) as NodeError;
+  err.code = 'EBADF';
+  err.errno = -9;
+  err.syscall = syscall;
+  err.path = '';
+  return err;
+}
+
+type Callback<T> = (err: NodeError | null, result?: T) => void;
+
+function resolvePath(cwd: string, p: string | URL): string {
+  const str = typeof p === 'string' ? p : p.pathname;
+  return resolve(cwd, str);
+}
+
+// ─── File descriptor entry ───
+
+interface FdEntry {
+  path: string;
+  position: number;
+  flags: string;
+  closed: boolean;
+}
+
+// ─── Open flags ───
+
+const O_RDONLY = 0;
+const O_WRONLY = 1;
+const O_RDWR = 2;
+const O_CREAT = 64;
+const O_TRUNC = 512;
+const O_APPEND = 1024;
+
+function parseFlags(flags: string | number): number {
+  if (typeof flags === 'number') return flags;
+  switch (flags) {
+    case 'r': return O_RDONLY;
+    case 'r+': return O_RDWR;
+    case 'w': return O_WRONLY | O_CREAT | O_TRUNC;
+    case 'w+': return O_RDWR | O_CREAT | O_TRUNC;
+    case 'a': return O_WRONLY | O_CREAT | O_APPEND;
+    case 'a+': return O_RDWR | O_CREAT | O_APPEND;
+    case 'ax': return O_WRONLY | O_CREAT | O_APPEND;
+    default: return O_RDONLY;
+  }
+}
+
+export function createFs(vfs: VFS, cwd: string) {
+  // ─── File descriptor table ───
+
+  const fdTable = new Map<number, FdEntry>();
+  let nextFd = 10; // start above stdin/stdout/stderr
+
+  function getFd(fd: number): FdEntry {
+    const entry = fdTable.get(fd);
+    if (!entry || entry.closed) throw makeEbadf('fd');
+    return entry;
+  }
+
+  // ─── Sync API ───
+
+  function readFileSync(path: string | URL, options?: string | { encoding?: string; flag?: string }): string | Uint8Array {
+    const encoding = typeof options === 'string' ? options : options?.encoding;
+    const abs = resolvePath(cwd, path);
+    if (encoding) {
+      return vfs.readFileString(abs);
+    }
+    // Return Buffer (not raw Uint8Array) so .toString() yields UTF-8 text.
+    // Many packages do JSON.parse(fs.readFileSync('package.json')) without
+    // encoding, expecting Buffer.toString() to return the file contents.
+    const raw = vfs.readFile(abs);
+    return Buffer.from(raw);
+  }
+
+  function writeFileSync(path: string | URL, data: string | Uint8Array, _options?: string | { encoding?: string }): void {
+    const abs = resolvePath(cwd, path);
+    vfs.writeFile(abs, data);
+  }
+
+  function appendFileSync(path: string | URL, data: string | Uint8Array): void {
+    const abs = resolvePath(cwd, path);
+    vfs.appendFile(abs, data);
+  }
+
+  function existsSync(path: string | URL): boolean {
+    const abs = resolvePath(cwd, path);
+    return vfs.exists(abs);
+  }
+
+  function statSync(path: string | URL): NodeStat {
+    const abs = resolvePath(cwd, path);
+    return toNodeStat(vfs.stat(abs));
+  }
+
+  function lstatSync(path: string | URL): NodeStat {
+    return statSync(path);
+  }
+
+  function mkdirSync(path: string | URL, options?: { recursive?: boolean; mode?: number } | number): void {
+    const abs = resolvePath(cwd, path);
+    const opts = typeof options === 'number' ? {} : options;
+    vfs.mkdir(abs, { recursive: opts?.recursive });
+  }
+
+  function readdirSync(path: string | URL, options?: { encoding?: string; withFileTypes?: boolean }): string[] | Dirent[] {
+    const abs = resolvePath(cwd, path);
+    const entries = vfs.readdir(abs);
+    if (options?.withFileTypes) {
+      return entries.map((e) => ({
+        name: e.name,
+        path: abs,
+        isFile: () => e.type === 'file',
+        isDirectory: () => e.type === 'directory',
+        isSymbolicLink: () => false,
+        isBlockDevice: () => false,
+        isCharacterDevice: () => false,
+        isFIFO: () => false,
+        isSocket: () => false,
+      }));
+    }
+    return entries.map((e) => e.name);
+  }
+
+  function unlinkSync(path: string | URL): void {
+    const abs = resolvePath(cwd, path);
+    vfs.unlink(abs);
+  }
+
+  function rmdirSync(path: string | URL, options?: { recursive?: boolean }): void {
+    const abs = resolvePath(cwd, path);
+    if (options?.recursive) {
+      vfs.rmdirRecursive(abs);
+    } else {
+      vfs.rmdir(abs);
+    }
+  }
+
+  function renameSync(oldPath: string | URL, newPath: string | URL): void {
+    const abs1 = resolvePath(cwd, oldPath);
+    const abs2 = resolvePath(cwd, newPath);
+    vfs.rename(abs1, abs2);
+  }
+
+  function copyFileSync(src: string | URL, dest: string | URL): void {
+    const abs1 = resolvePath(cwd, src);
+    const abs2 = resolvePath(cwd, dest);
+    vfs.copyFile(abs1, abs2);
+  }
+
+  function chmodSync(path: string | URL, mode: number): void {
+    vfs.chmod(resolvePath(cwd, path), mode);
+  }
+
+  function chownSync(_path: string | URL, _uid: number, _gid: number): void {
+    // No-op in VFS
+  }
+
+  function accessSync(path: string | URL, _mode?: number): void {
+    const abs = resolvePath(cwd, path);
+    if (!vfs.exists(abs)) {
+      throw makeEnoent('access', abs);
+    }
+  }
+
+  const realpathSync = Object.assign(
+    function realpathSync(path: string | URL): string {
+      const abs = resolvePath(cwd, path);
+      if (!vfs.exists(abs)) {
+        throw makeEnoent('realpath', abs);
+      }
+      return abs;
+    },
+    {
+      native: function realpathSyncNative(path: string | URL): string {
+        const abs = resolvePath(cwd, path);
+        if (!vfs.exists(abs)) {
+          throw makeEnoent('realpath', abs);
+        }
+        return abs;
+      },
+    },
+  );
+
+  function truncateSync(path: string | URL, len?: number): void {
+    const abs = resolvePath(cwd, path);
+    const data = vfs.readFile(abs);
+    const newLen = len ?? 0;
+    if (newLen >= data.length) return;
+    vfs.writeFile(abs, data.slice(0, newLen));
+  }
+
+  // ─── File descriptor sync API ───
+  // NOTE: File descriptor operations work with mounted native filesystems via VFS
+  // delegation. The fd table maps fds to VFS paths. When operations like readSync/
+  // writeSync call vfs.readFile()/vfs.writeFile() on those paths, the VFS mount system
+  // automatically delegates to the appropriate provider (e.g. NativeFsProvider).
+
+  function openSync(path: string | URL, flags?: string | number, _mode?: number): number {
+    const abs = resolvePath(cwd, path);
+    const numFlags = parseFlags(flags ?? 'r');
+
+    if (numFlags & O_CREAT) {
+      if (!vfs.exists(abs)) {
+        vfs.writeFile(abs, '');
+      }
+    }
+
+    if (numFlags & O_TRUNC) {
+      vfs.writeFile(abs, '');
+    }
+
+    if (!vfs.exists(abs)) {
+      throw makeEnoent('open', abs);
+    }
+
+    const fd = nextFd++;
+    fdTable.set(fd, {
+      path: abs,
+      position: (numFlags & O_APPEND) ? vfs.readFile(abs).length : 0,
+      flags: typeof flags === 'string' ? flags : 'r',
+      closed: false,
+    });
+    return fd;
+  }
+
+  function closeSync(fd: number): void {
+    const entry = getFd(fd);
+    entry.closed = true;
+    fdTable.delete(fd);
+  }
+
+  function readSync(fd: number, buffer: Uint8Array, offset: number, length: number, position: number | null): number {
+    const entry = getFd(fd);
+    const data = vfs.readFile(entry.path);
+    const pos = position !== null ? position : entry.position;
+    const available = Math.max(0, data.length - pos);
+    const bytesToRead = Math.min(length, available);
+    if (bytesToRead === 0) return 0;
+    buffer.set(data.subarray(pos, pos + bytesToRead), offset);
+    if (position === null) {
+      entry.position = pos + bytesToRead;
+    }
+    return bytesToRead;
+  }
+
+  function writeSync(fd: number, bufferOrString: Uint8Array | string, offsetOrPosition?: number, lengthOrEncoding?: number | string, position?: number | null): number {
+    const entry = getFd(fd);
+
+    let data: Uint8Array;
+    let pos: number;
+
+    if (typeof bufferOrString === 'string') {
+      data = encode(bufferOrString);
+      pos = typeof offsetOrPosition === 'number' ? offsetOrPosition : entry.position;
+    } else {
+      const offset = (offsetOrPosition as number) ?? 0;
+      const length = (typeof lengthOrEncoding === 'number' ? lengthOrEncoding : bufferOrString.length - offset);
+      data = bufferOrString.subarray(offset, offset + length);
+      pos = position !== null && position !== undefined ? position : entry.position;
+    }
+
+    const fileData = vfs.readFile(entry.path);
+    const endPos = pos + data.length;
+    const newSize = Math.max(fileData.length, endPos);
+    const newData = new Uint8Array(newSize);
+    newData.set(fileData, 0);
+    newData.set(data, pos);
+    vfs.writeFile(entry.path, newData);
+
+    entry.position = endPos;
+    return data.length;
+  }
+
+  function fstatSync(fd: number): NodeStat {
+    const entry = getFd(fd);
+    return toNodeStat(vfs.stat(entry.path));
+  }
+
+  function ftruncateSync(fd: number, len?: number): void {
+    const entry = getFd(fd);
+    truncateSync(entry.path, len);
+  }
+
+  function fsyncSync(_fd: number): void {
+    // No-op - VFS is always in sync
+  }
+
+  function fdatasyncSync(_fd: number): void {
+    // No-op
+  }
+
+  // ─── Symlink stubs ───
+
+  function symlinkSync(_target: string, _path: string, _type?: string): void {
+    // No-op - VFS has no symlink support yet
+  }
+
+  function linkSync(_existingPath: string, _newPath: string): void {
+    // No-op
+  }
+
+  function readlinkSync(path: string | URL): string {
+    // Return the path itself since we have no symlinks
+    return resolvePath(cwd, path);
+  }
+
+  // ─── Callback API ───
+
+  function wrapCallback<T>(syncFn: () => T, cb: Callback<T>): void {
+    queueMicrotask(() => {
+      try {
+        const result = syncFn();
+        cb(null, result);
+      } catch (e) {
+        if (e instanceof VFSError) {
+          cb(toNodeError(e, '', ''));
+        } else if ((e as NodeError).code) {
+          cb(e as NodeError);
+        } else {
+          throw e;
+        }
+      }
+    });
+  }
+
+  function readFile(path: string | URL, optionsOrCb: string | { encoding?: string } | Callback<string | Uint8Array>, cb?: Callback<string | Uint8Array>): void {
+    const callback = typeof optionsOrCb === 'function' ? optionsOrCb : cb!;
+    const options = typeof optionsOrCb === 'function' ? undefined : optionsOrCb;
+    wrapCallback(() => readFileSync(path, options), callback);
+  }
+
+  function writeFile(path: string | URL, data: string | Uint8Array, optionsOrCb: string | { encoding?: string } | Callback<void>, cb?: Callback<void>): void {
+    const callback = typeof optionsOrCb === 'function' ? optionsOrCb : cb!;
+    wrapCallback(() => writeFileSync(path, data), callback);
+  }
+
+  function stat(path: string | URL, cb: Callback<NodeStat>): void {
+    wrapCallback(() => statSync(path), cb);
+  }
+
+  function lstat(path: string | URL, cb: Callback<NodeStat>): void {
+    wrapCallback(() => lstatSync(path), cb);
+  }
+
+  function mkdir(path: string | URL, optionsOrCb: { recursive?: boolean } | Callback<void>, cb?: Callback<void>): void {
+    const callback = typeof optionsOrCb === 'function' ? optionsOrCb : cb!;
+    const options = typeof optionsOrCb === 'function' ? undefined : optionsOrCb;
+    wrapCallback(() => mkdirSync(path, options), callback);
+  }
+
+  function readdir(path: string | URL, optionsOrCb: { encoding?: string; withFileTypes?: boolean } | Callback<string[] | Dirent[]>, cb?: Callback<string[] | Dirent[]>): void {
+    const options = typeof optionsOrCb === 'function' ? undefined : optionsOrCb;
+    const callback = typeof optionsOrCb === 'function' ? optionsOrCb : cb!;
+    wrapCallback(() => readdirSync(path, options), callback);
+  }
+
+  function unlink(path: string | URL, cb: Callback<void>): void {
+    wrapCallback(() => unlinkSync(path), cb);
+  }
+
+  function rename(oldPath: string | URL, newPath: string | URL, cb: Callback<void>): void {
+    wrapCallback(() => renameSync(oldPath, newPath), cb);
+  }
+
+  function access(path: string | URL, modeOrCb: number | Callback<void>, cb?: Callback<void>): void {
+    const callback = typeof modeOrCb === 'function' ? modeOrCb : cb!;
+    const mode = typeof modeOrCb === 'function' ? undefined : modeOrCb;
+    wrapCallback(() => accessSync(path, mode), callback);
+  }
+
+  function exists(path: string | URL, cb: (exists: boolean) => void): void {
+    queueMicrotask(() => {
+      cb(existsSync(path));
+    });
+  }
+
+  function open(path: string | URL, flagsOrCb: string | number | Callback<number>, modeOrCb?: number | Callback<number>, cb?: Callback<number>): void {
+    let callback: Callback<number>;
+    let flags: string | number;
+    let mode: number | undefined;
+
+    if (typeof flagsOrCb === 'function') {
+      callback = flagsOrCb;
+      flags = 'r';
+    } else if (typeof modeOrCb === 'function') {
+      callback = modeOrCb;
+      flags = flagsOrCb;
+    } else {
+      callback = cb!;
+      flags = flagsOrCb;
+      mode = modeOrCb;
+    }
+
+    wrapCallback(() => openSync(path, flags, mode), callback);
+  }
+
+  function close(fd: number, cb: Callback<void>): void {
+    wrapCallback(() => closeSync(fd), cb);
+  }
+
+  function read(fd: number, buffer: Uint8Array, offset: number, length: number, position: number | null, cb: Callback<number>): void {
+    wrapCallback(() => readSync(fd, buffer, offset, length, position), cb);
+  }
+
+  function fstat(fd: number, cb: Callback<NodeStat>): void {
+    wrapCallback(() => fstatSync(fd), cb);
+  }
+
+  const realpath = Object.assign(
+    function realpath(path: string | URL, optOrCb: unknown, cb?: Callback<string>): void {
+      const callback = typeof optOrCb === 'function' ? optOrCb as Callback<string> : cb!;
+      wrapCallback(() => realpathSync(path), callback);
+    },
+    {
+      native: function realpathNative(path: string | URL, optOrCb: unknown, cb?: Callback<string>): void {
+        const callback = typeof optOrCb === 'function' ? optOrCb as Callback<string> : cb!;
+        wrapCallback(() => realpathSync(path), callback);
+      },
+    },
+  );
+
+  // ─── Stream API ───
+
+  // NOTE: createReadStream works with mounted native filesystems via VFS delegation.
+  // When the path is under a NativeFsProvider mount, vfs.readFile() delegates to the
+  // mount provider, which reads from the real host filesystem. The data is still buffered
+  // in memory before being pushed to the stream.
+  function createReadStream(path: string | URL, options?: { encoding?: string; start?: number; end?: number; highWaterMark?: number }): Readable {
+    const abs = resolvePath(cwd, path);
+    const stream = new Readable();
+
+    queueMicrotask(() => {
+      try {
+        const data = vfs.readFile(abs);
+        const start = options?.start ?? 0;
+        const end = options?.end !== undefined ? options.end + 1 : data.length;
+        const slice = data.subarray(start, end);
+
+        if (options?.encoding) {
+          stream.push(decode(slice));
+        } else {
+          // Push as string since our Readable works with strings
+          stream.push(decode(slice));
+        }
+        stream.push(null);
+      } catch (e) {
+        stream.emit('error', e);
+      }
+    });
+
+    return stream;
+  }
+
+  // NOTE: createWriteStream works with mounted native filesystems via VFS delegation.
+  // When the path is under a NativeFsProvider mount, vfs.writeFile() and vfs.appendFile()
+  // delegate to the mount provider, which writes to the real host filesystem.
+  function createWriteStream(path: string | URL, options?: { flags?: string; encoding?: string }): Writable {
+    const abs = resolvePath(cwd, path);
+    const flags = options?.flags ?? 'w';
+    const chunks: string[] = [];
+
+    if (flags.includes('w')) {
+      // Truncate on open
+      try { vfs.writeFile(abs, ''); } catch { /* parent may not exist yet */ }
+    }
+
+    const stream = new Writable();
+
+    stream.write = (chunk: string, _encoding?: string, cb?: () => void): boolean => {
+      chunks.push(chunk);
+      try {
+        if (flags.includes('a')) {
+          vfs.appendFile(abs, chunk);
+        } else {
+          vfs.writeFile(abs, chunks.join(''));
+        }
+      } catch (e) {
+        stream.emit('error', e);
+        return false;
+      }
+      if (cb) cb();
+      return true;
+    };
+
+    stream.end = (chunk?: string): void => {
+      if (chunk) stream.write(chunk);
+      stream.emit('finish');
+      stream.emit('close');
+    };
+
+    return stream;
+  }
+
+  // ─── Watch API ───
+
+  function watch(filename: string | URL, optionsOrListener?: { persistent?: boolean; recursive?: boolean; encoding?: string } | ((eventType: string, filename: string) => void), listener?: (eventType: string, filename: string) => void): EventEmitter {
+    const abs = resolvePath(cwd, filename);
+    const cb = typeof optionsOrListener === 'function' ? optionsOrListener : listener;
+
+    const watcher = new EventEmitter();
+
+    // Use VFS onChange to detect changes (coarse-grained)
+    const origOnChange = vfs.onChange;
+    vfs.onChange = () => {
+      origOnChange?.();
+      const eventType = 'change';
+      const name = basename(abs);
+      if (cb) cb(eventType, name);
+      watcher.emit('change', eventType, name);
+    };
+
+    (watcher as unknown as Record<string, unknown>).close = () => {
+      vfs.onChange = origOnChange;
+    };
+
+    return watcher;
+  }
+
+  // ─── Promises API ───
+
+  const promises = {
+    readFile: async (path: string | URL, options?: string | { encoding?: string }) => readFileSync(path, options),
+    writeFile: async (path: string | URL, data: string | Uint8Array) => writeFileSync(path, data),
+    appendFile: async (path: string | URL, data: string | Uint8Array) => appendFileSync(path, data),
+    stat: async (path: string | URL) => statSync(path),
+    lstat: async (path: string | URL) => lstatSync(path),
+    mkdir: async (path: string | URL, options?: { recursive?: boolean }) => { mkdirSync(path, options); },
+    readdir: async (path: string | URL, options?: { encoding?: string; withFileTypes?: boolean }) => readdirSync(path, options),
+    unlink: async (path: string | URL) => unlinkSync(path),
+    rmdir: async (path: string | URL, options?: { recursive?: boolean }) => rmdirSync(path, options),
+    rename: async (oldPath: string | URL, newPath: string | URL) => renameSync(oldPath, newPath),
+    copyFile: async (src: string | URL, dest: string | URL) => copyFileSync(src, dest),
+    access: async (path: string | URL, mode?: number) => accessSync(path, mode),
+    realpath: async (path: string | URL) => realpathSync(path),
+    truncate: async (path: string | URL, len?: number) => truncateSync(path, len),
+    chmod: async (path: string | URL, mode: number) => chmodSync(path, mode),
+    chown: async (_path: string | URL, _uid: number, _gid: number) => {},
+    open: async (path: string | URL, flags?: string | number, mode?: number) => {
+      const fd = openSync(path, flags, mode);
+      return {
+        fd,
+        close: async () => closeSync(fd),
+        read: async (buffer: Uint8Array, offset: number, length: number, position: number | null) => ({
+          bytesRead: readSync(fd, buffer, offset, length, position),
+          buffer,
+        }),
+        write: async (data: Uint8Array | string) => ({
+          bytesWritten: writeSync(fd, data),
+        }),
+        stat: async () => fstatSync(fd),
+        truncate: async (len?: number) => ftruncateSync(fd, len),
+      };
+    },
+    rm: async (path: string | URL, options?: { recursive?: boolean; force?: boolean }) => {
+      const abs = resolvePath(cwd, path);
+      try {
+        const s = vfs.stat(abs);
+        if (s.type === 'directory') {
+          if (options?.recursive) {
+            vfs.rmdirRecursive(abs);
+          } else {
+            vfs.rmdir(abs);
+          }
+        } else {
+          vfs.unlink(abs);
+        }
+      } catch (e) {
+        if (options?.force && e instanceof VFSError && e.code === 'ENOENT') return;
+        throw e;
+      }
+    },
+  };
+
+  // ─── Constants ───
+
+  const constants = {
+    F_OK: 0,
+    R_OK: 4,
+    W_OK: 2,
+    X_OK: 1,
+    O_RDONLY,
+    O_WRONLY,
+    O_RDWR,
+    O_CREAT,
+    O_TRUNC,
+    O_APPEND,
+    COPYFILE_EXCL: 1,
+    COPYFILE_FICLONE: 2,
+    COPYFILE_FICLONE_FORCE: 4,
+  };
+
+  return {
+    // Sync
+    readFileSync,
+    writeFileSync,
+    appendFileSync,
+    existsSync,
+    statSync,
+    lstatSync,
+    mkdirSync,
+    readdirSync,
+    unlinkSync,
+    rmdirSync,
+    renameSync,
+    copyFileSync,
+    chmodSync,
+    chownSync,
+    accessSync,
+    realpathSync,
+    truncateSync,
+    openSync,
+    closeSync,
+    readSync,
+    writeSync,
+    fstatSync,
+    ftruncateSync,
+    fsyncSync,
+    fdatasyncSync,
+    symlinkSync,
+    linkSync,
+    readlinkSync,
+    // Callback
+    readFile,
+    writeFile,
+    stat,
+    lstat,
+    mkdir,
+    readdir,
+    unlink,
+    rename,
+    access,
+    exists,
+    open,
+    close,
+    read,
+    fstat,
+    realpath,
+    // Streams
+    createReadStream,
+    createWriteStream,
+    // Watch
+    watch,
+    // Promises
+    promises,
+    // Constants
+    constants,
+  };
+}