@zenfs/core 0.13.0 → 0.14.0

package/scripts/make-index.js

@@ -78,9 +78,9 @@ function computeEntries(path) {
 		}
 
 		const stats = statSync(path);
-		entries.set('/' + relative(resolvedRoot, path), stats);
 
 		if (stats.isFile()) {
+			entries.set('/' + relative(resolvedRoot, path), stats);
 			if (options.verbose) {
 				console.log(`${color('green', 'file')} ${path}`);
 			}
@@ -90,6 +90,7 @@ function computeEntries(path) {
 		for (const file of readdirSync(path)) {
 			computeEntries(join(path, file));
 		}
+		entries.set('/' + relative(resolvedRoot, path), stats);
 		if (options.verbose) {
 			console.log(`${color('bright_green', ' dir')} ${path}`);
 		}

package/src/backends/locked.ts

@@ -1,9 +1,14 @@
-import { ErrnoError } from '../error.js';
 import type { Cred } from '../cred.js';
+import { Errno, ErrnoError } from '../error.js';
 import type { File } from '../file.js';
-import type { FileSystem, FileSystemMetadata } from '../filesystem.js';
-import { Mutex } from '../mutex.js';
+import type { FileSystemMetadata } from '../filesystem.js';
+import { FileSystem } from '../filesystem.js';
 import type { Stats } from '../stats.js';
+import type { Backend } from './backend.js';
+
+export interface MutexLock extends PromiseWithResolvers<void> {
+	[Symbol.dispose](): void;
+}
 
 /**
  * This class serializes access to an underlying async filesystem.
@@ -16,10 +21,81 @@ import type { Stats } from '../stats.js';
  * @internal
  */
 export class LockedFS<FS extends FileSystem> implements FileSystem {
-	private mutex: Mutex = new Mutex();
-
 	constructor(public readonly fs: FS) {}
 
+	/**
+	 * The current locks
+	 */
+	private locks: Map<string, MutexLock> = new Map();
+
+	protected addLock(path: string): MutexLock {
+		const lock: MutexLock = {
+			...Promise.withResolvers(),
+			[Symbol.dispose]: () => {
+				this.unlock(path);
+			},
+		};
+		this.locks.set(path, lock);
+		return lock;
+	}
+
+	/**
+	 * Locks `path` asynchronously.
+	 * If the path is currently locked, waits for it to be unlocked.
+	 * @internal
+	 */
+	public async lock(path: string): Promise<MutexLock> {
+		if (this.locks.has(path)) {
+			// Non-null assertion: we already checked locks has path
+			await this.locks.get(path)!.promise;
+		}
+
+		return this.addLock(path);
+	}
+
+	/**
+	 * Locks `path` asynchronously.
+	 * If the path is currently locked, an error will be thrown
+	 * @internal
+	 */
+	public lockSync(path: string): MutexLock {
+		if (this.locks.has(path)) {
+			// Non-null assertion: we already checked locks has path
+			throw ErrnoError.With('EBUSY', path, 'lockSync');
+		}
+
+		return this.addLock(path);
+	}
+
+	/**
+	 * Unlocks a path
+	 * @param path The path to lock
+	 * @param noThrow If true, an error will not be thrown if the path is already unlocked
+	 * @returns Whether the path was unlocked
+	 * @internal
+	 */
+	public unlock(path: string, noThrow: boolean = false): boolean {
+		if (!this.locks.has(path)) {
+			if (noThrow) {
+				return false;
+			}
+			throw new ErrnoError(Errno.EPERM, 'Can not unlock an already unlocked path', path);
+		}
+
+		// Non-null assertion: we already checked locks has path
+		this.locks.get(path)!.resolve();
+		this.locks.delete(path);
+		return true;
+	}
+
+	/**
+	 * Whether `path` is locked
+	 * @internal
+	 */
+	public isLocked(path: string): boolean {
+		return this.locks.has(path);
+	}
+
 	public async ready(): Promise<void> {
 		await this.fs.ready();
 	}
@@ -32,150 +108,156 @@ export class LockedFS<FS extends FileSystem> implements FileSystem {
 	}
 
 	public async rename(oldPath: string, newPath: string, cred: Cred): Promise<void> {
-		await this.mutex.lock(oldPath);
+		// eslint-disable-next-line @typescript-eslint/no-unused-vars
+		using _ = await this.lock(oldPath);
 		await this.fs.rename(oldPath, newPath, cred);
-		this.mutex.unlock(oldPath);
 	}
 
 	public renameSync(oldPath: string, newPath: string, cred: Cred): void {
-		if (this.mutex.isLocked(oldPath)) {
-			throw ErrnoError.With('EBUSY', oldPath, 'rename');
-		}
+		// eslint-disable-next-line @typescript-eslint/no-unused-vars
+		using _ = this.lockSync(oldPath);
 		return this.fs.renameSync(oldPath, newPath, cred);
 	}
 
 	public async stat(path: string, cred: Cred): Promise<Stats> {
-		await this.mutex.lock(path);
-		const stats = await this.fs.stat(path, cred);
-		this.mutex.unlock(path);
-		return stats;
+		// eslint-disable-next-line @typescript-eslint/no-unused-vars
+		using _ = await this.lock(path);
+		return await this.fs.stat(path, cred);
 	}
 
 	public statSync(path: string, cred: Cred): Stats {
-		if (this.mutex.isLocked(path)) {
-			throw ErrnoError.With('EBUSY', path, 'stat');
-		}
+		// eslint-disable-next-line @typescript-eslint/no-unused-vars
+		using _ = this.lockSync(path);
 		return this.fs.statSync(path, cred);
 	}
 
 	public async openFile(path: string, flag: string, cred: Cred): Promise<File> {
-		await this.mutex.lock(path);
-		const fd = await this.fs.openFile(path, flag, cred);
-		this.mutex.unlock(path);
-		return fd;
+		// eslint-disable-next-line @typescript-eslint/no-unused-vars
+		using _ = await this.lock(path);
+		return await this.fs.openFile(path, flag, cred);
 	}
 
 	public openFileSync(path: string, flag: string, cred: Cred): File {
-		if (this.mutex.isLocked(path)) {
-			throw ErrnoError.With('EBUSY', path, 'openFile');
-		}
+		// eslint-disable-next-line @typescript-eslint/no-unused-vars
+		using _ = this.lockSync(path);
 		return this.fs.openFileSync(path, flag, cred);
 	}
 
 	public async createFile(path: string, flag: string, mode: number, cred: Cred): Promise<File> {
-		await this.mutex.lock(path);
-		const fd = await this.fs.createFile(path, flag, mode, cred);
-		this.mutex.unlock(path);
-		return fd;
+		// eslint-disable-next-line @typescript-eslint/no-unused-vars
+		using _ = await this.lock(path);
+		return await this.fs.createFile(path, flag, mode, cred);
 	}
 
 	public createFileSync(path: string, flag: string, mode: number, cred: Cred): File {
-		if (this.mutex.isLocked(path)) {
-			throw ErrnoError.With('EBUSY', path, 'createFile');
-		}
+		// eslint-disable-next-line @typescript-eslint/no-unused-vars
+		using _ = this.lockSync(path);
 		return this.fs.createFileSync(path, flag, mode, cred);
 	}
 
 	public async unlink(path: string, cred: Cred): Promise<void> {
-		await this.mutex.lock(path);
+		// eslint-disable-next-line @typescript-eslint/no-unused-vars
+		using _ = await this.lock(path);
 		await this.fs.unlink(path, cred);
-		this.mutex.unlock(path);
 	}
 
 	public unlinkSync(path: string, cred: Cred): void {
-		if (this.mutex.isLocked(path)) {
-			throw ErrnoError.With('EBUSY', path, 'unlink');
-		}
+		// eslint-disable-next-line @typescript-eslint/no-unused-vars
+		using _ = this.lockSync(path);
 		return this.fs.unlinkSync(path, cred);
 	}
 
 	public async rmdir(path: string, cred: Cred): Promise<void> {
-		await this.mutex.lock(path);
+		// eslint-disable-next-line @typescript-eslint/no-unused-vars
+		using _ = await this.lock(path);
 		await this.fs.rmdir(path, cred);
-		this.mutex.unlock(path);
 	}
 
 	public rmdirSync(path: string, cred: Cred): void {
-		if (this.mutex.isLocked(path)) {
-			throw ErrnoError.With('EBUSY', path, 'rmdir');
-		}
+		// eslint-disable-next-line @typescript-eslint/no-unused-vars
+		using _ = this.lockSync(path);
 		return this.fs.rmdirSync(path, cred);
 	}
 
 	public async mkdir(path: string, mode: number, cred: Cred): Promise<void> {
-		await this.mutex.lock(path);
+		// eslint-disable-next-line @typescript-eslint/no-unused-vars
+		using _ = await this.lock(path);
 		await this.fs.mkdir(path, mode, cred);
-		this.mutex.unlock(path);
 	}
 
 	public mkdirSync(path: string, mode: number, cred: Cred): void {
-		if (this.mutex.isLocked(path)) {
-			throw ErrnoError.With('EBUSY', path, 'mkdir');
-		}
+		// eslint-disable-next-line @typescript-eslint/no-unused-vars
+		using _ = this.lockSync(path);
 		return this.fs.mkdirSync(path, mode, cred);
 	}
 
 	public async readdir(path: string, cred: Cred): Promise<string[]> {
-		await this.mutex.lock(path);
-		const files = await this.fs.readdir(path, cred);
-		this.mutex.unlock(path);
-		return files;
+		// eslint-disable-next-line @typescript-eslint/no-unused-vars
+		using _ = await this.lock(path);
+		return await this.fs.readdir(path, cred);
 	}
 
 	public readdirSync(path: string, cred: Cred): string[] {
-		if (this.mutex.isLocked(path)) {
-			throw ErrnoError.With('EBUSY', path, 'readdir');
-		}
+		// eslint-disable-next-line @typescript-eslint/no-unused-vars
+		using _ = this.lockSync(path);
 		return this.fs.readdirSync(path, cred);
 	}
 
 	public async exists(path: string, cred: Cred): Promise<boolean> {
-		await this.mutex.lock(path);
-		const exists = await this.fs.exists(path, cred);
-		this.mutex.unlock(path);
-		return exists;
+		// eslint-disable-next-line @typescript-eslint/no-unused-vars
+		using _ = await this.lock(path);
+		return await this.fs.exists(path, cred);
 	}
 
 	public existsSync(path: string, cred: Cred): boolean {
-		if (this.mutex.isLocked(path)) {
-			throw ErrnoError.With('EBUSY', path, 'exists');
-		}
+		// eslint-disable-next-line @typescript-eslint/no-unused-vars
+		using _ = this.lockSync(path);
 		return this.fs.existsSync(path, cred);
 	}
 
 	public async link(srcpath: string, dstpath: string, cred: Cred): Promise<void> {
-		await this.mutex.lock(srcpath);
+		// eslint-disable-next-line @typescript-eslint/no-unused-vars
+		using _ = await this.lock(srcpath);
 		await this.fs.link(srcpath, dstpath, cred);
-		this.mutex.unlock(srcpath);
 	}
 
 	public linkSync(srcpath: string, dstpath: string, cred: Cred): void {
-		if (this.mutex.isLocked(srcpath)) {
-			throw ErrnoError.With('EBUSY', srcpath, 'link');
-		}
+		// eslint-disable-next-line @typescript-eslint/no-unused-vars
+		using _ = this.lockSync(srcpath);
 		return this.fs.linkSync(srcpath, dstpath, cred);
 	}
 
 	public async sync(path: string, data: Uint8Array, stats: Readonly<Stats>): Promise<void> {
-		await this.mutex.lock(path);
+		// eslint-disable-next-line @typescript-eslint/no-unused-vars
+		using _ = await this.lock(path);
 		await this.fs.sync(path, data, stats);
-		this.mutex.unlock(path);
 	}
 
 	public syncSync(path: string, data: Uint8Array, stats: Readonly<Stats>): void {
-		if (this.mutex.isLocked(path)) {
-			throw ErrnoError.With('EBUSY', path, 'sync');
-		}
+		// eslint-disable-next-line @typescript-eslint/no-unused-vars
+		using _ = this.lockSync(path);
 		return this.fs.syncSync(path, data, stats);
 	}
 }
+
+export const Locked = {
+	name: 'Locked',
+	options: {
+		fs: {
+			type: 'object',
+			required: true,
+			description: '',
+			validator(fs) {
+				if (!(fs instanceof FileSystem)) {
+					throw new ErrnoError(Errno.EINVAL, 'fs passed to LockedFS must be a FileSystem');
+				}
+			},
+		},
+	},
+	isAvailable() {
+		return true;
+	},
+	create({ fs }) {
+		return new LockedFS(fs);
+	},
+} satisfies Backend<LockedFS<FileSystem>, { fs: FileSystem }>;

package/src/backends/overlay.ts

@@ -86,6 +86,9 @@ export class UnlockedOverlayFS extends FileSystem {
 	public async sync(path: string, data: Uint8Array, stats: Readonly<Stats>): Promise<void> {
 		const cred = stats.cred(0, 0);
 		await this.createParentDirectories(path, cred);
+		if (!(await this._writable.exists(path, cred))) {
+			await this._writable.createFile(path, 'w', 0o644, cred);
+		}
 		await this._writable.sync(path, data, stats);
 	}
 
@@ -160,7 +163,7 @@ export class UnlockedOverlayFS extends FileSystem {
 	public async stat(path: string, cred: Cred): Promise<Stats> {
 		this.checkInitialized();
 		try {
-			return this._writable.stat(path, cred);
+			return await this._writable.stat(path, cred);
 		} catch (e) {
 			if (this._deletedFiles.has(path)) {
 				throw ErrnoError.With('ENOENT', path, 'stat');

package/src/backends/store/store.ts

@@ -1,5 +1,6 @@
 import { ErrnoError } from '../../error.js';
 import type { Ino } from '../../inode.js';
+import '../../symbol-dispose.js';
 
 /**
  * Represents a key-value store.

package/src/emulation/promises.ts

@@ -18,6 +18,7 @@ import { dirname, join, parse } from './path.js';
 import { _statfs, cred, fd2file, fdMap, file2fd, fixError, mounts, resolveMount } from './shared.js';
 import { ReadStream, WriteStream } from './streams.js';
 export * as constants from './constants.js';
+import '../symbol-dispose.js';
 
 export class FileHandle implements promises.FileHandle {
 	/**
@@ -456,12 +457,8 @@ lstat satisfies typeof promises.lstat;
  * @param len
  */
 export async function truncate(path: fs.PathLike, len: number = 0): Promise<void> {
-	const handle = await open(path, 'r+');
-	try {
-		await handle.truncate(len);
-	} finally {
-		await handle.close();
-	}
+	await using handle = await open(path, 'r+');
+	await handle.truncate(len);
 }
 truncate satisfies typeof promises.truncate;
 
@@ -554,13 +551,8 @@ export async function readFile(
 	_options?: (fs.ObjectEncodingOptions & { flag?: fs.OpenMode }) | BufferEncoding | null
 ): Promise<Buffer | string> {
 	const options = normalizeOptions(_options, null, 'r', 0o644);
-	const handle: FileHandle | promises.FileHandle = typeof path == 'object' && 'fd' in path ? path : await open(path as string, options.flag, options.mode);
-
-	try {
-		return await handle.readFile(options);
-	} finally {
-		await handle.close();
-	}
+	await using handle: FileHandle | promises.FileHandle = typeof path == 'object' && 'fd' in path ? path : await open(path as string, options.flag, options.mode);
+	return await handle.readFile(options);
 }
 readFile satisfies typeof promises.readFile;
 
@@ -581,16 +573,13 @@ export async function writeFile(
 	_options?: (fs.ObjectEncodingOptions & { mode?: fs.Mode; flag?: fs.OpenMode; flush?: boolean }) | BufferEncoding | null
 ): Promise<void> {
 	const options = normalizeOptions(_options, 'utf8', 'w+', 0o644);
-	const handle = path instanceof FileHandle ? path : await open(path.toString(), options.flag, options.mode);
-	try {
-		const _data = typeof data == 'string' ? data : data;
-		if (typeof _data != 'string' && !(_data instanceof Uint8Array)) {
-			throw new ErrnoError(Errno.EINVAL, 'Iterables and streams not supported', handle.file.path, 'writeFile');
-		}
-		await handle.writeFile(_data, options);
-	} finally {
-		await handle.close();
+	await using handle = path instanceof FileHandle ? path : await open(path.toString(), options.flag, options.mode);
+
+	const _data = typeof data == 'string' ? data : data;
+	if (typeof _data != 'string' && !(_data instanceof Uint8Array)) {
+		throw new ErrnoError(Errno.EINVAL, 'Iterables and streams not supported', handle.file.path, 'writeFile');
 	}
+	await handle.writeFile(_data, options);
 }
 writeFile satisfies typeof promises.writeFile;
 
@@ -618,13 +607,9 @@ export async function appendFile(
 		throw new ErrnoError(Errno.EINVAL, 'Encoding not specified');
 	}
 	const encodedData = typeof data == 'string' ? Buffer.from(data, options.encoding!) : new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
-	const handle: FileHandle | promises.FileHandle = typeof path == 'object' && 'fd' in path ? path : await open(path as string, options.flag, options.mode);
+	await using handle: FileHandle | promises.FileHandle = typeof path == 'object' && 'fd' in path ? path : await open(path as string, options.flag, options.mode);
 
-	try {
-		await handle.appendFile(encodedData, options);
-	} finally {
-		await handle.close();
-	}
+	await handle.appendFile(encodedData, options);
 }
 appendFile satisfies typeof promises.appendFile;
 
@@ -775,14 +760,10 @@ export async function readlink(path: fs.PathLike, options: fs.BufferEncodingOpti
 export async function readlink(path: fs.PathLike, options?: fs.EncodingOption | null): Promise<string>;
 export async function readlink(path: fs.PathLike, options?: fs.BufferEncodingOption | fs.EncodingOption | string | null): Promise<string | Buffer>;
 export async function readlink(path: fs.PathLike, options?: fs.BufferEncodingOption | fs.EncodingOption | string | null): Promise<string | Buffer> {
-	const handle = await _open(normalizePath(path), 'r', 0o644, false);
-	try {
-		const value = await handle.readFile();
-		const encoding = typeof options == 'object' ? options?.encoding : options;
-		return encoding == 'buffer' ? value : value.toString(encoding! as BufferEncoding);
-	} finally {
-		await handle.close();
-	}
+	await using handle = await _open(normalizePath(path), 'r', 0o644, false);
+	const value = await handle.readFile();
+	const encoding = typeof options == 'object' ? options?.encoding : options;
+	return encoding == 'buffer' ? value : value.toString(encoding! as BufferEncoding);
 }
 readlink satisfies typeof promises.readlink;
 
@@ -795,12 +776,8 @@ readlink satisfies typeof promises.readlink;
  * @param gid
  */
 export async function chown(path: fs.PathLike, uid: number, gid: number): Promise<void> {
-	const handle = await open(path, 'r+');
-	try {
-		await handle.chown(uid, gid);
-	} finally {
-		await handle.close();
-	}
+	await using handle = await open(path, 'r+');
+	await handle.chown(uid, gid);
 }
 chown satisfies typeof promises.chown;
 
@@ -811,12 +788,8 @@ chown satisfies typeof promises.chown;
  * @param gid
  */
 export async function lchown(path: fs.PathLike, uid: number, gid: number): Promise<void> {
-	const handle: FileHandle = await _open(path, 'r+', 0o644, false);
-	try {
-		await handle.chown(uid, gid);
-	} finally {
-		await handle.close();
-	}
+	await using handle: FileHandle = await _open(path, 'r+', 0o644, false);
+	await handle.chown(uid, gid);
 }
 lchown satisfies typeof promises.lchown;
 
@@ -826,12 +799,8 @@ lchown satisfies typeof promises.lchown;
  * @param mode
  */
 export async function chmod(path: fs.PathLike, mode: fs.Mode): Promise<void> {
-	const handle = await open(path, 'r+');
-	try {
-		await handle.chmod(mode);
-	} finally {
-		await handle.close();
-	}
+	await using handle = await open(path, 'r+');
+	await handle.chmod(mode);
 }
 chmod satisfies typeof promises.chmod;
 
@@ -841,12 +810,8 @@ chmod satisfies typeof promises.chmod;
  * @param mode
  */
 export async function lchmod(path: fs.PathLike, mode: fs.Mode): Promise<void> {
-	const handle: FileHandle = await _open(path, 'r+', 0o644, false);
-	try {
-		await handle.chmod(mode);
-	} finally {
-		await handle.close();
-	}
+	await using handle: FileHandle = await _open(path, 'r+', 0o644, false);
+	await handle.chmod(mode);
 }
 lchmod satisfies typeof promises.lchmod;
 
@@ -857,12 +822,8 @@ lchmod satisfies typeof promises.lchmod;
  * @param mtime
  */
 export async function utimes(path: fs.PathLike, atime: string | number | Date, mtime: string | number | Date): Promise<void> {
-	const handle = await open(path, 'r+');
-	try {
-		await handle.utimes(atime, mtime);
-	} finally {
-		await handle.close();
-	}
+	await using handle = await open(path, 'r+');
+	await handle.utimes(atime, mtime);
 }
 utimes satisfies typeof promises.utimes;
 
@@ -873,12 +834,8 @@ utimes satisfies typeof promises.utimes;
  * @param mtime
  */
 export async function lutimes(path: fs.PathLike, atime: fs.TimeLike, mtime: fs.TimeLike): Promise<void> {
-	const handle: FileHandle = await _open(path, 'r+', 0o644, false);
-	try {
-		await handle.utimes(new Date(atime), new Date(mtime));
-	} finally {
-		await handle.close();
-	}
+	await using handle: FileHandle = await _open(path, 'r+', 0o644, false);
+	await handle.utimes(new Date(atime), new Date(mtime));
 }
 lutimes satisfies typeof promises.lutimes;
 

package/src/emulation/sync.ts

@@ -99,12 +99,12 @@ lstatSync satisfies typeof fs.lstatSync;
  * @param len
  */
 export function truncateSync(path: fs.PathLike, len: number | null = 0): void {
-	const fd = openSync(path, 'r+');
-	try {
-		ftruncateSync(fd, len);
-	} finally {
-		closeSync(fd);
+	using file = _openSync(path, 'r+');
+	len ||= 0;
+	if (len < 0) {
+		throw new ErrnoError(Errno.EINVAL);
 	}
+	file.truncateSync(len);
 }
 truncateSync satisfies typeof fs.truncateSync;
 
@@ -194,17 +194,13 @@ export function lopenSync(path: fs.PathLike, flag: string, mode?: fs.Mode | null
  */
 function _readFileSync(fname: string, flag: string, resolveSymlinks: boolean): Uint8Array {
 	// Get file.
-	const file = _openSync(fname, flag, 0o644, resolveSymlinks);
-	try {
-		const stat = file.statSync();
-		// Allocate buffer.
-		const data = new Uint8Array(stat.size);
-		file.readSync(data, 0, stat.size, 0);
-		file.closeSync();
-		return data;
-	} finally {
-		file.closeSync();
-	}
+	using file = _openSync(fname, flag, 0o644, resolveSymlinks);
+	const stat = file.statSync();
+	// Allocate buffer.
+	const data = new Uint8Array(stat.size);
+	file.readSync(data, 0, stat.size, 0);
+	file.closeSync();
+	return data;
 }
 
 /**
@@ -255,12 +251,8 @@ export function writeFileSync(path: fs.PathOrFileDescriptor, data: FileContents,
 	if (!encodedData) {
 		throw new ErrnoError(Errno.EINVAL, 'Data not specified');
 	}
-	const file = _openSync(typeof path == 'number' ? fd2file(path).path! : path.toString(), flag, options.mode, true);
-	try {
-		file.writeSync(encodedData, 0, encodedData.byteLength, 0);
-	} finally {
-		file.closeSync();
-	}
+	using file = _openSync(typeof path == 'number' ? fd2file(path).path! : path.toString(), flag, options.mode, true);
+	file.writeSync(encodedData, 0, encodedData.byteLength, 0);
 }
 writeFileSync satisfies typeof fs.writeFileSync;
 
@@ -285,12 +277,8 @@ export function appendFileSync(filename: fs.PathOrFileDescriptor, data: FileCont
 		throw new ErrnoError(Errno.EINVAL, 'Encoding not specified');
 	}
 	const encodedData = typeof data == 'string' ? Buffer.from(data, options.encoding!) : new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
-	const file = _openSync(typeof filename == 'number' ? fd2file(filename).path! : filename.toString(), flag, options.mode, true);
-	try {
-		file.writeSync(encodedData, 0, encodedData.byteLength);
-	} finally {
-		file.closeSync();
-	}
+	using file = _openSync(typeof filename == 'number' ? fd2file(filename).path! : filename.toString(), flag, options.mode, true);
+	file.writeSync(encodedData, 0, encodedData.byteLength);
 }
 appendFileSync satisfies typeof fs.appendFileSync;
 

package/src/file.ts

@@ -4,6 +4,7 @@ import { Errno, ErrnoError } from './error.js';
 import type { FileSystem } from './filesystem.js';
 import { size_max } from './inode.js';
 import { Stats, type FileType } from './stats.js';
+import './symbol-dispose.js';
 
 /*
 	Typescript does not include a type declaration for resizable array buffers. 

package/src/filesystem.ts

@@ -463,16 +463,11 @@ export function Async<T extends typeof FileSystem>(
 					await this.crossCopy(join(path, file));
 				}
 			} else {
-				const asyncFile = await this.openFile(path, parseFlag('r'), rootCred);
-				const syncFile = this._sync.createFileSync(path, parseFlag('w'), stats.mode, stats.cred());
-				try {
-					const buffer = new Uint8Array(stats.size);
-					await asyncFile.read(buffer);
-					syncFile.writeSync(buffer, 0, stats.size);
-				} finally {
-					await asyncFile.close();
-					syncFile.closeSync();
-				}
+				await using asyncFile = await this.openFile(path, parseFlag('r'), rootCred);
+				using syncFile = this._sync.createFileSync(path, parseFlag('w'), stats.mode, stats.cred());
+				const buffer = new Uint8Array(stats.size);
+				await asyncFile.read(buffer);
+				syncFile.writeSync(buffer, 0, stats.size);
 			}
 		}
 

package/src/index.ts

@@ -14,7 +14,6 @@ export * from './cred.js';
 export * from './file.js';
 export * from './filesystem.js';
 export * from './inode.js';
-export * from './mutex.js';
 export * from './stats.js';
 export * from './utils.js';