@zenfs/core 0.17.1 → 0.18.0

package/src/backends/store/fs.ts

@@ -1,8 +1,8 @@
-import type { Cred } from '../../cred.js';
-import { R_OK, S_IFDIR, S_IFREG, W_OK } from '../../emulation/constants.js';
+import { credentials } from '../../credentials.js';
+import { S_IFDIR, S_IFREG } from '../../emulation/constants.js';
 import { basename, dirname, join, resolve } from '../../emulation/path.js';
 import { Errno, ErrnoError } from '../../error.js';
-import { PreloadFile, flagToMode } from '../../file.js';
+import { PreloadFile } from '../../file.js';
 import { FileSystem, type FileSystemMetadata } from '../../filesystem.js';
 import { type Ino, Inode, randomIno, rootIno } from '../../inode.js';
 import type { FileType, Stats } from '../../stats.js';
@@ -64,7 +64,7 @@ export class StoreFS<T extends Store = Store> extends FileSystem {
 	/**
 	 * @todo Make rename compatible with the cache.
 	 */
-	public async rename(oldPath: string, newPath: string, cred: Cred): Promise<void> {
+	public async rename(oldPath: string, newPath: string): Promise<void> {
 		await using tx = this.store.transaction();
 		const oldParent = dirname(oldPath),
 			oldName = basename(oldPath),
@@ -74,10 +74,6 @@ export class StoreFS<T extends Store = Store> extends FileSystem {
 			oldDirNode = await this.findINode(tx, oldParent),
 			oldDirList = await this.getDirListing(tx, oldDirNode, oldParent);
 
-		if (!oldDirNode.toStats().hasAccess(W_OK, cred)) {
-			throw ErrnoError.With('EACCES', oldPath, 'rename');
-		}
-
 		if (!oldDirList[oldName]) {
 			throw ErrnoError.With('ENOENT', oldPath, 'rename');
 		}
@@ -105,15 +101,13 @@ export class StoreFS<T extends Store = Store> extends FileSystem {
 		}
 
 		if (newDirList[newName]) {
-			// If it's a file, delete it.
+			// If it's a file, delete it, if it's a directory, throw a permissions error.
 			const newNameNode = await this.getINode(tx, newDirList[newName], newPath);
-			if (newNameNode.toStats().isFile()) {
-				await tx.remove(newNameNode.ino);
-				await tx.remove(newDirList[newName]);
-			} else {
-				// If it's a directory, throw a permissions error.
+			if (!newNameNode.toStats().isFile()) {
 				throw ErrnoError.With('EPERM', newPath, 'rename');
 			}
+			await tx.remove(newNameNode.ino);
+			await tx.remove(newDirList[newName]);
 		}
 		newDirList[newName] = nodeId;
 		// Commit the two changed directory listings.
@@ -122,7 +116,7 @@ export class StoreFS<T extends Store = Store> extends FileSystem {
 		await tx.commit();
 	}
 
-	public renameSync(oldPath: string, newPath: string, cred: Cred): void {
+	public renameSync(oldPath: string, newPath: string): void {
 		using tx = this.store.transaction();
 		const oldParent = dirname(oldPath),
 			oldName = basename(oldPath),
@@ -132,10 +126,6 @@ export class StoreFS<T extends Store = Store> extends FileSystem {
 			oldDirNode = this.findINodeSync(tx, oldParent),
 			oldDirList = this.getDirListingSync(tx, oldDirNode, oldParent);
 
-		if (!oldDirNode.toStats().hasAccess(W_OK, cred)) {
-			throw ErrnoError.With('EACCES', oldPath, 'rename');
-		}
-
 		if (!oldDirList[oldName]) {
 			throw ErrnoError.With('ENOENT', oldPath, 'rename');
 		}
@@ -163,15 +153,13 @@ export class StoreFS<T extends Store = Store> extends FileSystem {
 		}
 
 		if (newDirList[newName]) {
-			// If it's a file, delete it.
+			// If it's a file, delete it, if it's a directory, throw a permissions error.
 			const newNameNode = this.getINodeSync(tx, newDirList[newName], newPath);
-			if (newNameNode.toStats().isFile()) {
-				tx.removeSync(newNameNode.ino);
-				tx.removeSync(newDirList[newName]);
-			} else {
-				// If it's a directory, throw a permissions error.
+			if (!newNameNode.toStats().isFile()) {
 				throw ErrnoError.With('EPERM', newPath, 'rename');
 			}
+			tx.removeSync(newNameNode.ino);
+			tx.removeSync(newDirList[newName]);
 		}
 		newDirList[newName] = ino;
 
@@ -181,114 +169,92 @@ export class StoreFS<T extends Store = Store> extends FileSystem {
 		tx.commitSync();
 	}
 
-	public async stat(path: string, cred: Cred): Promise<Stats> {
+	public async stat(path: string): Promise<Stats> {
 		await using tx = this.store.transaction();
 		const inode = await this.findINode(tx, path);
 		if (!inode) {
 			throw ErrnoError.With('ENOENT', path, 'stat');
 		}
-		const stats = inode.toStats();
-		if (!stats.hasAccess(R_OK, cred)) {
-			throw ErrnoError.With('EACCES', path, 'stat');
-		}
-		return stats;
+		return inode.toStats();
 	}
 
-	public statSync(path: string, cred: Cred): Stats {
+	public statSync(path: string): Stats {
 		using tx = this.store.transaction();
 		// Get the inode to the item, convert it into a Stats object.
-		const stats = this.findINodeSync(tx, path).toStats();
-		if (!stats.hasAccess(R_OK, cred)) {
-			throw ErrnoError.With('EACCES', path, 'stat');
-		}
-		return stats;
+		return this.findINodeSync(tx, path).toStats();
 	}
 
-	public async createFile(path: string, flag: string, mode: number, cred: Cred): Promise<PreloadFile<this>> {
-		const node = await this.commitNew(path, S_IFREG, mode, cred, new Uint8Array(0));
+	public async createFile(path: string, flag: string, mode: number): Promise<PreloadFile<this>> {
+		const node = await this.commitNew(path, S_IFREG, mode, new Uint8Array(0));
 		return new PreloadFile(this, path, flag, node.toStats(), new Uint8Array(0));
 	}
 
-	public createFileSync(path: string, flag: string, mode: number, cred: Cred): PreloadFile<this> {
-		this.commitNewSync(path, S_IFREG, mode, cred);
-		return this.openFileSync(path, flag, cred);
+	public createFileSync(path: string, flag: string, mode: number): PreloadFile<this> {
+		this.commitNewSync(path, S_IFREG, mode);
+		return this.openFileSync(path, flag);
 	}
 
-	public async openFile(path: string, flag: string, cred: Cred): Promise<PreloadFile<this>> {
+	public async openFile(path: string, flag: string): Promise<PreloadFile<this>> {
 		await using tx = this.store.transaction();
 		const node = await this.findINode(tx, path),
 			data = await tx.get(node.ino);
-		if (!node.toStats().hasAccess(flagToMode(flag), cred)) {
-			throw ErrnoError.With('EACCES', path, 'openFile');
-		}
 		if (!data) {
 			throw ErrnoError.With('ENOENT', path, 'openFile');
 		}
 		return new PreloadFile(this, path, flag, node.toStats(), data);
 	}
 
-	public openFileSync(path: string, flag: string, cred: Cred): PreloadFile<this> {
+	public openFileSync(path: string, flag: string): PreloadFile<this> {
 		using tx = this.store.transaction();
 		const node = this.findINodeSync(tx, path),
 			data = tx.getSync(node.ino);
-		if (!node.toStats().hasAccess(flagToMode(flag), cred)) {
-			throw ErrnoError.With('EACCES', path, 'openFile');
-		}
 		if (!data) {
 			throw ErrnoError.With('ENOENT', path, 'openFile');
 		}
 		return new PreloadFile(this, path, flag, node.toStats(), data);
 	}
 
-	public async unlink(path: string, cred: Cred): Promise<void> {
-		return this.remove(path, false, cred);
+	public async unlink(path: string): Promise<void> {
+		return this.remove(path, false);
 	}
 
-	public unlinkSync(path: string, cred: Cred): void {
-		this.removeSync(path, false, cred);
+	public unlinkSync(path: string): void {
+		this.removeSync(path, false);
 	}
 
-	public async rmdir(path: string, cred: Cred): Promise<void> {
+	public async rmdir(path: string): Promise<void> {
 		// Check first if directory is empty.
-		const list = await this.readdir(path, cred);
-		if (list.length > 0) {
+		if ((await this.readdir(path)).length) {
 			throw ErrnoError.With('ENOTEMPTY', path, 'rmdir');
 		}
-		await this.remove(path, true, cred);
+		await this.remove(path, true);
 	}
 
-	public rmdirSync(path: string, cred: Cred): void {
+	public rmdirSync(path: string): void {
 		// Check first if directory is empty.
-		if (this.readdirSync(path, cred).length > 0) {
+		if (this.readdirSync(path).length) {
 			throw ErrnoError.With('ENOTEMPTY', path, 'rmdir');
-		} else {
-			this.removeSync(path, true, cred);
 		}
+		this.removeSync(path, true);
 	}
 
-	public async mkdir(path: string, mode: number, cred: Cred): Promise<void> {
-		await this.commitNew(path, S_IFDIR, mode, cred, encode('{}'));
+	public async mkdir(path: string, mode: number): Promise<void> {
+		await this.commitNew(path, S_IFDIR, mode, encode('{}'));
 	}
 
-	public mkdirSync(path: string, mode: number, cred: Cred): void {
-		this.commitNewSync(path, S_IFDIR, mode, cred, encode('{}'));
+	public mkdirSync(path: string, mode: number): void {
+		this.commitNewSync(path, S_IFDIR, mode, encode('{}'));
 	}
 
-	public async readdir(path: string, cred: Cred): Promise<string[]> {
+	public async readdir(path: string): Promise<string[]> {
 		await using tx = this.store.transaction();
 		const node = await this.findINode(tx, path);
-		if (!node.toStats().hasAccess(R_OK, cred)) {
-			throw ErrnoError.With('EACCES', path, 'readdur');
-		}
 		return Object.keys(await this.getDirListing(tx, node, path));
 	}
 
-	public readdirSync(path: string, cred: Cred): string[] {
+	public readdirSync(path: string): string[] {
 		using tx = this.store.transaction();
 		const node = this.findINodeSync(tx, path);
-		if (!node.toStats().hasAccess(R_OK, cred)) {
-			throw ErrnoError.With('EACCES', path, 'readdir');
-		}
 		return Object.keys(this.getDirListingSync(tx, node, path));
 	}
 
@@ -334,66 +300,39 @@ export class StoreFS<T extends Store = Store> extends FileSystem {
 		tx.commitSync();
 	}
 
-	public async link(existing: string, newpath: string, cred: Cred): Promise<void> {
+	public async link(target: string, link: string): Promise<void> {
 		await using tx = this.store.transaction();
-		const existingDir: string = dirname(existing),
-			existingDirNode = await this.findINode(tx, existingDir);
 
-		if (!existingDirNode.toStats().hasAccess(R_OK, cred)) {
-			throw ErrnoError.With('EACCES', existingDir, 'link');
-		}
-
-		const newDir: string = dirname(newpath),
+		const newDir: string = dirname(link),
 			newDirNode = await this.findINode(tx, newDir),
-			newListing = await this.getDirListing(tx, newDirNode, newDir);
-
-		if (!newDirNode.toStats().hasAccess(W_OK, cred)) {
-			throw ErrnoError.With('EACCES', newDir, 'link');
-		}
+			listing = await this.getDirListing(tx, newDirNode, newDir);
 
-		const ino = await this._findINode(tx, existingDir, basename(existing));
-		const node = await this.getINode(tx, ino, existing);
-
-		if (!node.toStats().hasAccess(W_OK, cred)) {
-			throw ErrnoError.With('EACCES', newpath, 'link');
-		}
+		const ino = await this._findINode(tx, dirname(target), basename(target));
+		const node = await this.getINode(tx, ino, target);
 
 		node.nlink++;
-		newListing[basename(newpath)] = ino;
+		listing[basename(link)] = ino;
 
 		tx.setSync(ino, node.data);
-		tx.setSync(newDirNode.ino, encodeDirListing(newListing));
+		tx.setSync(newDirNode.ino, encodeDirListing(listing));
 		tx.commitSync();
 	}
 
-	public linkSync(existing: string, newpath: string, cred: Cred): void {
+	public linkSync(target: string, link: string): void {
 		using tx = this.store.transaction();
-		const existingDir: string = dirname(existing),
-			existingDirNode = this.findINodeSync(tx, existingDir);
-
-		if (!existingDirNode.toStats().hasAccess(R_OK, cred)) {
-			throw ErrnoError.With('EACCES', existingDir, 'link');
-		}
 
-		const newDir: string = dirname(newpath),
+		const newDir: string = dirname(link),
 			newDirNode = this.findINodeSync(tx, newDir),
-			newListing = this.getDirListingSync(tx, newDirNode, newDir);
+			listing = this.getDirListingSync(tx, newDirNode, newDir);
 
-		if (!newDirNode.toStats().hasAccess(W_OK, cred)) {
-			throw ErrnoError.With('EACCES', newDir, 'link');
-		}
-
-		const ino = this._findINodeSync(tx, existingDir, basename(existing));
-		const node = this.getINodeSync(tx, ino, existing);
+		const ino = this._findINodeSync(tx, dirname(target), basename(target));
+		const node = this.getINodeSync(tx, ino, target);
 
-		if (!node.toStats().hasAccess(W_OK, cred)) {
-			throw ErrnoError.With('EACCES', newpath, 'link');
-		}
 		node.nlink++;
-		newListing[basename(newpath)] = ino;
+		listing[basename(link)] = ino;
 
 		tx.setSync(ino, node.data);
-		tx.setSync(newDirNode.ino, encodeDirListing(newListing));
+		tx.setSync(newDirNode.ino, encodeDirListing(listing));
 		tx.commitSync();
 	}
 
@@ -616,16 +555,11 @@ export class StoreFS<T extends Store = Store> extends FileSystem {
 	 * @param cred The UID/GID to create the file with
 	 * @param data The data to store at the file's data node.
 	 */
-	private async commitNew(path: string, type: FileType, mode: number, cred: Cred, data: Uint8Array): Promise<Inode> {
+	private async commitNew(path: string, type: FileType, mode: number, data: Uint8Array): Promise<Inode> {
 		await using tx = this.store.transaction();
 		const parentPath = dirname(path),
 			parent = await this.findINode(tx, parentPath);
 
-		//Check that the creater has correct access
-		if (!parent.toStats().hasAccess(W_OK, cred)) {
-			throw ErrnoError.With('EACCES', path, 'commitNewFile');
-		}
-
 		const fname = basename(path),
 			listing = await this.getDirListing(tx, parent, parentPath);
 
@@ -635,21 +569,21 @@ export class StoreFS<T extends Store = Store> extends FileSystem {
 			we will create a file with name '' in root should path == '/'.
 		*/
 		if (path === '/') {
-			throw ErrnoError.With('EEXIST', path, 'commitNewFile');
+			throw ErrnoError.With('EEXIST', path, 'commitNew');
 		}
 
 		// Check if file already exists.
 		if (listing[fname]) {
 			await tx.abort();
-			throw ErrnoError.With('EEXIST', path, 'commitNewFile');
+			throw ErrnoError.With('EEXIST', path, 'commitNew');
 		}
 
 		// Commit data.
 		const inode = new Inode();
 		inode.ino = await this.addNew(tx, data, path);
 		inode.mode = mode | type;
-		inode.uid = cred.uid;
-		inode.gid = cred.gid;
+		inode.uid = credentials.uid;
+		inode.gid = credentials.gid;
 		inode.size = data.length;
 
 		// Update and commit parent directory listing.
@@ -668,16 +602,11 @@ export class StoreFS<T extends Store = Store> extends FileSystem {
 	 * @param data The data to store at the file's data node.
 	 * @return The Inode for the new file.
 	 */
-	protected commitNewSync(path: string, type: FileType, mode: number, cred: Cred, data: Uint8Array = new Uint8Array()): Inode {
+	protected commitNewSync(path: string, type: FileType, mode: number, data: Uint8Array = new Uint8Array()): Inode {
 		using tx = this.store.transaction();
 		const parentPath = dirname(path),
 			parent = this.findINodeSync(tx, parentPath);
 
-		//Check that the creater has correct access
-		if (!parent.toStats().hasAccess(W_OK, cred)) {
-			throw ErrnoError.With('EACCES', path, 'commitNewFile');
-		}
-
 		const fname = basename(path),
 			listing = this.getDirListingSync(tx, parent, parentPath);
 
@@ -687,12 +616,12 @@ export class StoreFS<T extends Store = Store> extends FileSystem {
 			we will create a file with name '' in root should p == '/'.
 		*/
 		if (path === '/') {
-			throw ErrnoError.With('EEXIST', path, 'commitNewFile');
+			throw ErrnoError.With('EEXIST', path, 'commitNew');
 		}
 
 		// Check if file already exists.
 		if (listing[fname]) {
-			throw ErrnoError.With('EEXIST', path, 'commitNewFile');
+			throw ErrnoError.With('EEXIST', path, 'commitNew');
 		}
 
 		// Commit data.
@@ -700,8 +629,8 @@ export class StoreFS<T extends Store = Store> extends FileSystem {
 		node.ino = this.addNewSync(tx, data, path);
 		node.size = data.length;
 		node.mode = mode | type;
-		node.uid = cred.uid;
-		node.gid = cred.gid;
+		node.uid = credentials.uid;
+		node.gid = credentials.gid;
 		// Update and commit parent directory listing.
 		listing[fname] = this.addNewSync(tx, node.data, path);
 		tx.setSync(parent.ino, encodeDirListing(listing));
@@ -715,7 +644,7 @@ export class StoreFS<T extends Store = Store> extends FileSystem {
 	 * @param isDir Does the path belong to a directory, or a file?
 	 * @todo Update mtime.
 	 */
-	private async remove(path: string, isDir: boolean, cred: Cred): Promise<void> {
+	private async remove(path: string, isDir: boolean): Promise<void> {
 		await using tx = this.store.transaction();
 		const parent: string = dirname(path),
 			parentNode = await this.findINode(tx, parent),
@@ -723,7 +652,7 @@ export class StoreFS<T extends Store = Store> extends FileSystem {
 			fileName: string = basename(path);
 
 		if (!listing[fileName]) {
-			throw ErrnoError.With('ENOENT', path, 'removeEntry');
+			throw ErrnoError.With('ENOENT', path, 'remove');
 		}
 
 		const fileIno = listing[fileName];
@@ -731,19 +660,15 @@ export class StoreFS<T extends Store = Store> extends FileSystem {
 		// Get file inode.
 		const fileNode = await this.getINode(tx, fileIno, path);
 
-		if (!fileNode.toStats().hasAccess(W_OK, cred)) {
-			throw ErrnoError.With('EACCES', path, 'removeEntry');
-		}
-
 		// Remove from directory listing of parent.
 		delete listing[fileName];
 
 		if (!isDir && fileNode.toStats().isDirectory()) {
-			throw ErrnoError.With('EISDIR', path, 'removeEntry');
+			throw ErrnoError.With('EISDIR', path, 'remove');
 		}
 
 		if (isDir && !fileNode.toStats().isDirectory()) {
-			throw ErrnoError.With('ENOTDIR', path, 'removeEntry');
+			throw ErrnoError.With('ENOTDIR', path, 'remove');
 		}
 
 		await tx.set(parentNode.ino, encodeDirListing(listing));
@@ -764,7 +689,7 @@ export class StoreFS<T extends Store = Store> extends FileSystem {
 	 * @param isDir Does the path belong to a directory, or a file?
 	 * @todo Update mtime.
 	 */
-	protected removeSync(path: string, isDir: boolean, cred: Cred): void {
+	protected removeSync(path: string, isDir: boolean): void {
 		using tx = this.store.transaction();
 		const parent: string = dirname(path),
 			parentNode = this.findINodeSync(tx, parent),
@@ -773,25 +698,21 @@ export class StoreFS<T extends Store = Store> extends FileSystem {
 			fileIno: Ino = listing[fileName];
 
 		if (!fileIno) {
-			throw ErrnoError.With('ENOENT', path, 'removeEntry');
+			throw ErrnoError.With('ENOENT', path, 'remove');
 		}
 
 		// Get file inode.
 		const fileNode = this.getINodeSync(tx, fileIno, path);
 
-		if (!fileNode.toStats().hasAccess(W_OK, cred)) {
-			throw ErrnoError.With('EACCES', path, 'removeEntry');
-		}
-
 		// Remove from directory listing of parent.
 		delete listing[fileName];
 
 		if (!isDir && fileNode.toStats().isDirectory()) {
-			throw ErrnoError.With('EISDIR', path, 'removeEntry');
+			throw ErrnoError.With('EISDIR', path, 'remove');
 		}
 
 		if (isDir && !fileNode.toStats().isDirectory()) {
-			throw ErrnoError.With('ENOTDIR', path, 'removeEntry');
+			throw ErrnoError.With('ENOTDIR', path, 'remove');
 		}
 
 		// Update directory listing.

package/src/config.ts

@@ -1,8 +1,9 @@
 import type { Backend, BackendConfiguration, FilesystemOf, SharedConfig } from './backends/backend.js';
 import { checkOptions, isBackend, isBackendConfig } from './backends/backend.js';
+import { credentials } from './credentials.js';
 import * as fs from './emulation/index.js';
 import type { AbsolutePath } from './emulation/path.js';
-import { setCred, type MountObject } from './emulation/shared.js';
+import type { MountObject } from './emulation/shared.js';
 import { Errno, ErrnoError } from './error.js';
 import { FileSystem } from './filesystem.js';
 
@@ -107,7 +108,7 @@ export async function configure<T extends ConfigMounts>(config: Partial<Configur
 	const uid = 'uid' in config ? config.uid || 0 : 0;
 	const gid = 'gid' in config ? config.gid || 0 : 0;
 
-	setCred({ uid, gid, suid: uid, sgid: gid, euid: uid, egid: gid });
+	Object.assign(credentials, { uid, gid, suid: uid, sgid: gid, euid: uid, egid: gid });
 
 	if (!config.mounts) {
 		return;

package/src/{cred.ts → credentials.ts}

@@ -3,7 +3,7 @@
  * Similar to Linux's cred struct.
  * @see https://github.com/torvalds/linux/blob/master/include/linux/cred.h
  */
-export interface Cred {
+export interface Credentials {
 	uid: number;
 	gid: number;
 	suid: number;
@@ -12,7 +12,16 @@ export interface Cred {
 	egid: number;
 }
 
-export const rootCred: Cred = {
+export const credentials: Credentials = {
+	uid: 0,
+	gid: 0,
+	suid: 0,
+	sgid: 0,
+	euid: 0,
+	egid: 0,
+};
+
+export const rootCredentials: Credentials = {
 	uid: 0,
 	gid: 0,
 	suid: 0,

package/src/emulation/async.ts

@@ -3,14 +3,14 @@ import type * as fs from 'node:fs';
 import { Errno, ErrnoError } from '../error.js';
 import type { FileContents } from '../filesystem.js';
 import { BigIntStats, type Stats } from '../stats.js';
-import { normalizeMode, type Callback } from '../utils.js';
+import { normalizeMode, normalizePath, type Callback } from '../utils.js';
 import { R_OK } from './constants.js';
 import type { Dirent } from './dir.js';
 import type { Dir } from './dir.js';
 import * as promises from './promises.js';
 import { fd2file } from './shared.js';
 import { ReadStream, WriteStream } from './streams.js';
-import { FSWatcher } from './watchers.js';
+import { FSWatcher, StatWatcher } from './watchers.js';
 
 const nop = () => {};
 
@@ -673,36 +673,92 @@ export function access(path: fs.PathLike, cbMode: number | Callback, cb: Callbac
 }
 access satisfies Omit<typeof fs.access, '__promisify__'>;
 
+const statWatchers: Map<string, { watcher: StatWatcher; listeners: Set<(curr: Stats, prev: Stats) => void> }> = new Map();
+
 /**
- * @todo Implement
+ * Watch for changes on a file. The callback listener will be called each time the file is accessed.
+ *
+ * The `options` argument may be omitted. If provided, it should be an object with a `persistent` boolean and an `interval` number specifying the polling interval in milliseconds.
+ *
+ * When a change is detected, the `listener` callback is called with the current and previous `Stats` objects.
+ *
+ * @param path The path to the file to watch.
+ * @param options Optional options object specifying `persistent` and `interval`.
+ * @param listener The callback listener to be called when the file changes.
  */
 export function watchFile(path: fs.PathLike, listener: (curr: Stats, prev: Stats) => void): void;
 export function watchFile(path: fs.PathLike, options: { persistent?: boolean; interval?: number }, listener: (curr: Stats, prev: Stats) => void): void;
 export function watchFile(
 	path: fs.PathLike,
 	optsListener: { persistent?: boolean; interval?: number } | ((curr: Stats, prev: Stats) => void),
-	listener: (curr: Stats, prev: Stats) => void = nop
+	listener?: (curr: Stats, prev: Stats) => void
 ): void {
-	throw ErrnoError.With('ENOSYS', path.toString(), 'watchFile');
+	const normalizedPath = normalizePath(path.toString());
+	const options: { persistent?: boolean; interval?: number } = typeof optsListener != 'function' ? optsListener : {};
+
+	if (typeof optsListener === 'function') {
+		listener = optsListener;
+	}
+
+	if (!listener) {
+		throw new ErrnoError(Errno.EINVAL, 'No listener specified', path.toString(), 'watchFile');
+	}
+
+	if (statWatchers.has(normalizedPath)) {
+		const entry = statWatchers.get(normalizedPath);
+		if (entry) {
+			entry.listeners.add(listener);
+		}
+		return;
+	}
+
+	const watcher = new StatWatcher(normalizedPath, options);
+	watcher.on('change', (curr: Stats, prev: Stats) => {
+		const entry = statWatchers.get(normalizedPath);
+		if (!entry) {
+			return;
+		}
+		for (const listener of entry.listeners) {
+			listener(curr, prev);
+		}
+	});
+	statWatchers.set(normalizedPath, { watcher, listeners: new Set() });
 }
 watchFile satisfies Omit<typeof fs.watchFile, '__promisify__'>;
 
 /**
- * @todo Implement
+ * Stop watching for changes on a file.
+ *
+ * If the `listener` is specified, only that particular listener is removed.
+ * If no `listener` is specified, all listeners are removed, and the file is no longer watched.
+ *
+ * @param path The path to the file to stop watching.
+ * @param listener Optional listener to remove.
  */
 export function unwatchFile(path: fs.PathLike, listener: (curr: Stats, prev: Stats) => void = nop): void {
-	throw ErrnoError.With('ENOSYS', path.toString(), 'unwatchFile');
+	const normalizedPath = normalizePath(path.toString());
+
+	const entry = statWatchers.get(normalizedPath);
+	if (entry) {
+		if (listener && listener !== nop) {
+			entry.listeners.delete(listener);
+		} else {
+			// If no listener is specified, remove all listeners
+			entry.listeners.clear();
+		}
+		if (entry.listeners.size === 0) {
+			// No more listeners, stop the watcher
+			entry.watcher.stop();
+			statWatchers.delete(normalizedPath);
+		}
+	}
 }
 unwatchFile satisfies Omit<typeof fs.unwatchFile, '__promisify__'>;
 
-export function watch(path: fs.PathLike, listener?: (event: string, filename: string) => any): fs.FSWatcher;
-export function watch(path: fs.PathLike, options: { persistent?: boolean }, listener?: (event: string, filename: string) => any): fs.FSWatcher;
-export function watch(
-	path: fs.PathLike,
-	options?: fs.WatchOptions | ((event: string, filename: string) => any),
-	listener?: (event: string, filename: string) => any
-): fs.FSWatcher {
-	const watcher = new FSWatcher<string>(typeof options == 'object' ? options : {});
+export function watch(path: fs.PathLike, listener?: (event: string, filename: string) => any): FSWatcher;
+export function watch(path: fs.PathLike, options: { persistent?: boolean }, listener?: (event: string, filename: string) => any): FSWatcher;
+export function watch(path: fs.PathLike, options?: fs.WatchOptions | ((event: string, filename: string) => any), listener?: (event: string, filename: string) => any): FSWatcher {
+	const watcher = new FSWatcher<string>(normalizePath(path), typeof options == 'object' ? options : {});
 	listener = typeof options == 'function' ? options : listener;
 	watcher.on('change', listener || nop);
 	return watcher;
@@ -770,7 +826,7 @@ export function createReadStream(path: fs.PathLike, _options?: BufferEncoding |
 			handle
 				?.close()
 				.then(() => callback(error))
-				.catch(callback);
+				.catch(nop);
 		},
 	});