@zenfs/core 1.2.0 → 1.2.2

package/dist/config.d.ts

@@ -34,24 +34,33 @@ export interface Configuration<T extends ConfigMounts> extends SharedConfig {
     gid: number;
     /**
      * Whether to automatically add normal Linux devices
-     * @default false
      * @experimental
+     * @default false
      */
     addDevices: boolean;
     /**
      * If true, enables caching stats for certain operations.
      * This should reduce the number of stat calls performed.
-     * @default false
      * @experimental
+     * @default false
      */
     cacheStats: boolean;
     /**
      * If true, disables *all* permissions checking.
-     * This can increase performance
-     * @default false
+     *
+     * This can increase performance.
      * @experimental
+     * @default false
      */
     disableAccessChecks: boolean;
+    /**
+     * If true, disables `read` and `readSync` from immediately syncing the updated atime to the file system.
+     *
+     * This can increase performance.
+     * @experimental
+     * @default false
+     */
+    disableSyncOnRead: boolean;
 }
 /**
  * Configures ZenFS with single mount point /

package/dist/config.js

@@ -3,7 +3,7 @@ import { credentials } from './credentials.js';
 import { DeviceFS, fullDevice, nullDevice, randomDevice, zeroDevice } from './devices.js';
 import * as cache from './emulation/cache.js';
 import * as fs from './emulation/index.js';
-import { config } from './emulation/shared.js';
+import { config } from './emulation/config.js';
 import { Errno, ErrnoError } from './error.js';
 import { FileSystem } from './filesystem.js';
 function isMountConfig(arg) {
@@ -70,6 +70,7 @@ export async function configure(configuration) {
     Object.assign(credentials, { uid, gid, suid: uid, sgid: gid, euid: uid, egid: gid });
     cache.setEnabled(configuration.cacheStats ?? false);
     config.checkAccess = !configuration.disableAccessChecks;
+    config.syncOnRead = !configuration.disableSyncOnRead;
     if (configuration.addDevices) {
         const devfs = new DeviceFS();
         devfs.createDevice('/null', nullDevice);

package/dist/emulation/cache.d.ts

@@ -10,11 +10,23 @@ export declare function setEnabled(value: boolean): void;
 /**
  * Gets stats from the cache, if they exist and the cache is enabled.
  */
-export declare function getStats(path: string): Stats | undefined;
+export declare function getStatsSync(path: string): Stats | undefined;
 /**
  * Adds stats if the cache is enabled
  */
-export declare function setStats(path: string, value: Stats): void;
+export declare function setStatsSync(path: string, value: Stats): void;
+/**
+ * Clears the cache if it is enabled
+ */
+export declare function clearStatsSync(): void;
+/**
+ * Gets stats from the cache, if they exist and the cache is enabled.
+ */
+export declare function getStats(path: string): Promise<Stats | undefined> | undefined;
+/**
+ * Adds stats if the cache is enabled
+ */
+export declare function setStats(path: string, value: Promise<Stats | undefined>): void;
 /**
  * Clears the cache if it is enabled
  */

package/dist/emulation/cache.js

@@ -9,6 +9,31 @@ export let isEnabled = false;
 export function setEnabled(value) {
     isEnabled = value;
 }
+const statsSync = new Map();
+/**
+ * Gets stats from the cache, if they exist and the cache is enabled.
+ */
+export function getStatsSync(path) {
+    if (!isEnabled)
+        return;
+    return statsSync.get(path);
+}
+/**
+ * Adds stats if the cache is enabled
+ */
+export function setStatsSync(path, value) {
+    if (!isEnabled)
+        return;
+    statsSync.set(path, value);
+}
+/**
+ * Clears the cache if it is enabled
+ */
+export function clearStatsSync() {
+    if (!isEnabled)
+        return;
+    statsSync.clear();
+}
 const stats = new Map();
 /**
  * Gets stats from the cache, if they exist and the cache is enabled.

package/dist/emulation/config.d.ts

@@ -0,0 +1,10 @@
+export declare const config: {
+    /**
+     * Whether to perform access checks
+     */
+    checkAccess: boolean;
+    /**
+     * Whether to sync atime updates immediately when reading from a file
+     */
+    syncOnRead: boolean;
+};

package/dist/emulation/config.js

@@ -0,0 +1,10 @@
+export const config = {
+    /**
+     * Whether to perform access checks
+     */
+    checkAccess: true,
+    /**
+     * Whether to sync atime updates immediately when reading from a file
+     */
+    syncOnRead: true,
+};

package/dist/emulation/promises.js

@@ -56,7 +56,8 @@ import * as cache from './cache.js';
 import * as constants from './constants.js';
 import { Dir, Dirent } from './dir.js';
 import { dirname, join, parse } from './path.js';
-import { _statfs, config, fd2file, fdMap, file2fd, fixError, mounts, resolveMount } from './shared.js';
+import { _statfs, fd2file, fdMap, file2fd, fixError, mounts, resolveMount } from './shared.js';
+import { config } from './config.js';
 import { ReadStream, WriteStream } from './streams.js';
 import { FSWatcher, emitChange } from './watchers.js';
 export * as constants from './constants.js';
@@ -434,7 +435,7 @@ export async function unlink(path) {
     path = normalizePath(path);
     const { fs, path: resolved } = resolveMount(path);
     try {
-        if (config.checkAccess && !(cache.getStats(path) || (await fs.stat(resolved))).hasAccess(constants.W_OK)) {
+        if (config.checkAccess && !(await (cache.getStats(path) || fs.stat(resolved))).hasAccess(constants.W_OK)) {
             throw ErrnoError.With('EACCES', resolved, 'unlink');
         }
         await fs.unlink(resolved);
@@ -583,7 +584,10 @@ export async function rmdir(path) {
     path = await realpath(path);
     const { fs, path: resolved } = resolveMount(path);
     try {
-        const stats = cache.getStats(path) || (await fs.stat(resolved));
+        const stats = await (cache.getStats(path) || fs.stat(resolved));
+        if (!stats) {
+            throw ErrnoError.With('ENOENT', path, 'readdir');
+        }
         if (!stats.isDirectory()) {
             throw ErrnoError.With('ENOTDIR', resolved, 'rmdir');
         }
@@ -639,8 +643,12 @@ export async function readdir(path, options) {
         throw fixError(e, { [resolved]: path });
     };
     const { fs, path: resolved } = resolveMount(path);
-    const stats = cache.getStats(path) || (await fs.stat(resolved).catch(handleError));
-    cache.setStats(path, stats);
+    const _stats = cache.getStats(path) || fs.stat(resolved).catch(handleError);
+    cache.setStats(path, _stats);
+    const stats = await _stats;
+    if (!stats) {
+        throw ErrnoError.With('ENOENT', path, 'readdir');
+    }
     if (config.checkAccess && !stats.hasAccess(constants.R_OK)) {
         throw ErrnoError.With('EACCES', path, 'readdir');
     }
@@ -662,8 +670,9 @@ export async function readdir(path, options) {
     const addEntry = async (entry) => {
         let entryStats;
         if (options?.recursive || options?.withFileTypes) {
-            entryStats = cache.getStats(join(path, entry)) || (await fs.stat(join(resolved, entry)).catch(handleError));
-            cache.setStats(join(path, entry), entryStats);
+            const _entryStats = cache.getStats(join(path, entry)) || fs.stat(join(resolved, entry)).catch(handleError);
+            cache.setStats(join(path, entry), _entryStats);
+            entryStats = await _entryStats;
         }
         if (options?.withFileTypes) {
             values.push(new Dirent(entry, entryStats));
@@ -933,15 +942,17 @@ access;
  */
 export async function rm(path, options) {
     path = normalizePath(path);
-    const stats = cache.getStats(path) ||
-        (await stat(path).catch((error) => {
-            if (error.code != 'ENOENT' || !options?.force)
-                throw error;
-        }));
+    const _stats = cache.getStats(path) ||
+        stat(path).catch((error) => {
+            if (error.code == 'ENOENT' && options?.force)
+                return undefined;
+            throw error;
+        });
+    cache.setStats(path, _stats);
+    const stats = await _stats;
     if (!stats) {
         return;
     }
-    cache.setStats(path, stats);
     switch (stats.mode & constants.S_IFMT) {
         case constants.S_IFDIR:
             if (options?.recursive) {

package/dist/emulation/shared.d.ts

@@ -43,12 +43,6 @@ export declare function mountObject(mounts: MountObject): void;
  * @hidden
  */
 export declare function _statfs<const T extends boolean>(fs: FileSystem, bigint?: T): T extends true ? BigIntStatsFs : StatsFs;
-export declare const config: {
-    /**
-     * Whether to perform access checks
-     */
-    checkAccess: boolean;
-};
 /**
  * Options used for caching, among other things.
  * @internal *UNSTABLE*

package/dist/emulation/shared.js

@@ -115,9 +115,3 @@ export function _statfs(fs, bigint) {
         blocks: (bigint ? BigInt : Number)(md.totalSpace / bs),
     };
 }
-export const config = {
-    /**
-     * Whether to perform access checks
-     */
-    checkAccess: true,
-};

package/dist/emulation/sync.js

@@ -53,7 +53,8 @@ import { decodeUTF8, normalizeMode, normalizeOptions, normalizePath, normalizeTi
 import * as constants from './constants.js';
 import { Dir, Dirent } from './dir.js';
 import { dirname, join, parse } from './path.js';
-import { _statfs, config, fd2file, fdMap, file2fd, fixError, mounts, resolveMount } from './shared.js';
+import { _statfs, fd2file, fdMap, file2fd, fixError, mounts, resolveMount } from './shared.js';
+import { config } from './config.js';
 import { emitChange } from './watchers.js';
 import * as cache from './cache.js';
 export function renameSync(oldPath, newPath) {
@@ -146,7 +147,7 @@ export function unlinkSync(path) {
     path = normalizePath(path);
     const { fs, path: resolved } = resolveMount(path);
     try {
-        if (config.checkAccess && !(cache.getStats(path) || fs.statSync(resolved)).hasAccess(constants.W_OK)) {
+        if (config.checkAccess && !(cache.getStatsSync(path) || fs.statSync(resolved)).hasAccess(constants.W_OK)) {
             throw ErrnoError.With('EACCES', resolved, 'unlink');
         }
         fs.unlinkSync(resolved);
@@ -393,7 +394,7 @@ export function rmdirSync(path) {
     path = normalizePath(path);
     const { fs, path: resolved } = resolveMount(realpathSync(path));
     try {
-        const stats = cache.getStats(path) || fs.statSync(resolved);
+        const stats = cache.getStatsSync(path) || fs.statSync(resolved);
         if (!stats.isDirectory()) {
             throw ErrnoError.With('ENOTDIR', resolved, 'rmdir');
         }
@@ -446,8 +447,8 @@ export function readdirSync(path, options) {
     const { fs, path: resolved } = resolveMount(realpathSync(path));
     let entries;
     try {
-        const stats = cache.getStats(path) || fs.statSync(resolved);
-        cache.setStats(path, stats);
+        const stats = cache.getStatsSync(path) || fs.statSync(resolved);
+        cache.setStatsSync(path, stats);
         if (config.checkAccess && !stats.hasAccess(constants.R_OK)) {
             throw ErrnoError.With('EACCES', resolved, 'readdir');
         }
@@ -473,8 +474,8 @@ export function readdirSync(path, options) {
     // Iterate over entries and handle recursive case if needed
     const values = [];
     for (const entry of entries) {
-        const entryStat = cache.getStats(join(path, entry)) || fs.statSync(join(resolved, entry));
-        cache.setStats(join(path, entry), entryStat);
+        const entryStat = cache.getStatsSync(join(path, entry)) || fs.statSync(join(resolved, entry));
+        cache.setStatsSync(join(path, entry), entryStat);
         if (options?.withFileTypes) {
             values.push(new Dirent(entry, entryStat));
         }
@@ -500,7 +501,7 @@ export function readdirSync(path, options) {
         }
     }
     if (!options?._isIndirect) {
-        cache.clearStats();
+        cache.clearStatsSync();
     }
     return values;
 }
@@ -637,7 +638,7 @@ export function rmSync(path, options) {
     path = normalizePath(path);
     let stats;
     try {
-        stats = cache.getStats(path) || statSync(path);
+        stats = cache.getStatsSync(path) || statSync(path);
     }
     catch (error) {
         if (error.code != 'ENOENT' || !options?.force)
@@ -646,7 +647,7 @@ export function rmSync(path, options) {
     if (!stats) {
         return;
     }
-    cache.setStats(path, stats);
+    cache.setStatsSync(path, stats);
     switch (stats.mode & constants.S_IFMT) {
         case constants.S_IFDIR:
             if (options?.recursive) {
@@ -665,11 +666,11 @@ export function rmSync(path, options) {
         case constants.S_IFIFO:
         case constants.S_IFSOCK:
         default:
-            cache.clearStats();
+            cache.clearStatsSync();
             throw new ErrnoError(Errno.EPERM, 'File type not supported', path, 'rm');
     }
     if (!options?._isIndirect) {
-        cache.clearStats();
+        cache.clearStatsSync();
     }
 }
 rmSync;

package/dist/file.d.ts

@@ -1,7 +1,7 @@
 import type { FileReadResult } from 'node:fs/promises';
 import type { FileSystem } from './filesystem.js';
-import { Stats, type FileType } from './stats.js';
 import './polyfills.js';
+import { Stats, type FileType } from './stats.js';
 /**
     Typescript does not include a type declaration for resizable array buffers.
     It has been standardized into ECMAScript though

package/dist/file.js

@@ -1,7 +1,8 @@
 import { O_APPEND, O_CREAT, O_EXCL, O_RDONLY, O_RDWR, O_SYNC, O_TRUNC, O_WRONLY, S_IFMT, size_max } from './emulation/constants.js';
+import { config } from './emulation/config.js';
 import { Errno, ErrnoError } from './error.js';
-import { Stats } from './stats.js';
 import './polyfills.js';
+import { Stats } from './stats.js';
 const validFlags = ['r', 'r+', 'rs', 'rs+', 'w', 'wx', 'w+', 'wx+', 'a', 'ax', 'a+', 'ax+'];
 export function parseFlag(flag) {
     if (typeof flag === 'number') {
@@ -383,7 +384,8 @@ export class PreloadFile extends File {
      */
     async read(buffer, offset, length, position) {
         const bytesRead = this._read(buffer, offset, length, position);
-        await this.sync();
+        if (config.syncOnRead)
+            await this.sync();
         return { bytesRead, buffer };
     }
     /**
@@ -397,7 +399,8 @@ export class PreloadFile extends File {
      */
     readSync(buffer, offset, length, position) {
         const bytesRead = this._read(buffer, offset, length, position);
-        this.statSync();
+        if (config.syncOnRead)
+            this.syncSync();
         return bytesRead;
     }
     async chmod(mode) {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@zenfs/core",
-	"version": "1.2.0",
+	"version": "1.2.2",
 	"description": "A filesystem, anywhere",
 	"funding": {
 		"type": "individual",

package/readme.md

@@ -32,7 +32,7 @@ npm install @zenfs/core
 ```js
 import { fs } from '@zenfs/core'; // You can also use the default export
 
-fs.writeFileSync('/test.txt', 'You can do this in anywhere (including browsers)!');
+fs.writeFileSync('/test.txt', 'You can do this anywhere, including browsers!');
 
 const contents = fs.readFileSync('/test.txt', 'utf-8');
 console.log(contents);

package/scripts/test.js

@@ -31,6 +31,11 @@ options:
 
 if (options.verbose) console.debug('Forcing tests to exit (--test-force-exit)');
 
+if (!existsSync(join(import.meta.dirname, '../dist'))) {
+	console.log('ERROR: Missing build. If you are using an installed package, please submit a bug report.');
+	process.exit(1);
+}
+
 const testsGlob = join(import.meta.dirname, `../tests/fs/${options.test || '*'}.test.ts`);
 
 for (const setupFile of positionals) {

package/src/config.ts

@@ -5,7 +5,8 @@ import { DeviceFS, fullDevice, nullDevice, randomDevice, zeroDevice } from './de
 import * as cache from './emulation/cache.js';
 import * as fs from './emulation/index.js';
 import type { AbsolutePath } from './emulation/path.js';
-import { config, type MountObject } from './emulation/shared.js';
+import { type MountObject } from './emulation/shared.js';
+import { config } from './emulation/config.js';
 import { Errno, ErrnoError } from './error.js';
 import { FileSystem } from './filesystem.js';
 
@@ -95,26 +96,36 @@ export interface Configuration<T extends ConfigMounts> extends SharedConfig {
 
 	/**
 	 * Whether to automatically add normal Linux devices
-	 * @default false
 	 * @experimental
+	 * @default false
 	 */
 	addDevices: boolean;
 
 	/**
 	 * If true, enables caching stats for certain operations.
 	 * This should reduce the number of stat calls performed.
-	 * @default false
 	 * @experimental
+	 * @default false
 	 */
 	cacheStats: boolean;
 
 	/**
 	 * If true, disables *all* permissions checking.
-	 * This can increase performance
-	 * @default false
+	 *
+	 * This can increase performance.
 	 * @experimental
+	 * @default false
 	 */
 	disableAccessChecks: boolean;
+
+	/**
+	 * If true, disables `read` and `readSync` from immediately syncing the updated atime to the file system.
+	 *
+	 * This can increase performance.
+	 * @experimental
+	 * @default false
+	 */
+	disableSyncOnRead: boolean;
 }
 
 /**
@@ -142,6 +153,7 @@ export async function configure<T extends ConfigMounts>(configuration: Partial<C
 
 	cache.setEnabled(configuration.cacheStats ?? false);
 	config.checkAccess = !configuration.disableAccessChecks;
+	config.syncOnRead = !configuration.disableSyncOnRead;
 
 	if (configuration.addDevices) {
 		const devfs = new DeviceFS();

package/src/emulation/cache.ts

@@ -14,12 +14,41 @@ export function setEnabled(value: boolean): void {
 	isEnabled = value;
 }
 
-const stats = new Map<string, Stats>();
+const statsSync = new Map<string, Stats>();
 
 /**
  * Gets stats from the cache, if they exist and the cache is enabled.
  */
-export function getStats(path: string): Stats | undefined {
+export function getStatsSync(path: string): Stats | undefined {
+	if (!isEnabled) return;
+
+	return statsSync.get(path);
+}
+
+/**
+ * Adds stats if the cache is enabled
+ */
+export function setStatsSync(path: string, value: Stats): void {
+	if (!isEnabled) return;
+
+	statsSync.set(path, value);
+}
+
+/**
+ * Clears the cache if it is enabled
+ */
+export function clearStatsSync(): void {
+	if (!isEnabled) return;
+
+	statsSync.clear();
+}
+
+const stats = new Map<string, Promise<Stats | undefined>>();
+
+/**
+ * Gets stats from the cache, if they exist and the cache is enabled.
+ */
+export function getStats(path: string): Promise<Stats | undefined> | undefined {
 	if (!isEnabled) return;
 
 	return stats.get(path);
@@ -28,7 +57,7 @@ export function getStats(path: string): Stats | undefined {
 /**
  * Adds stats if the cache is enabled
  */
-export function setStats(path: string, value: Stats): void {
+export function setStats(path: string, value: Promise<Stats | undefined>): void {
 	if (!isEnabled) return;
 
 	stats.set(path, value);

package/src/emulation/config.ts

@@ -0,0 +1,11 @@
+export const config = {
+	/**
+	 * Whether to perform access checks
+	 */
+	checkAccess: true,
+
+	/**
+	 * Whether to sync atime updates immediately when reading from a file
+	 */
+	syncOnRead: true,
+};

package/src/emulation/promises.ts

@@ -16,7 +16,8 @@ import * as cache from './cache.js';
 import * as constants from './constants.js';
 import { Dir, Dirent } from './dir.js';
 import { dirname, join, parse } from './path.js';
-import { _statfs, config, fd2file, fdMap, file2fd, fixError, mounts, resolveMount, type InternalOptions, type ReaddirOptions } from './shared.js';
+import { _statfs, fd2file, fdMap, file2fd, fixError, mounts, resolveMount, type InternalOptions, type ReaddirOptions } from './shared.js';
+import { config } from './config.js';
 import { ReadStream, WriteStream } from './streams.js';
 import { FSWatcher, emitChange } from './watchers.js';
 export * as constants from './constants.js';
@@ -470,7 +471,7 @@ export async function unlink(path: fs.PathLike): Promise<void> {
 	path = normalizePath(path);
 	const { fs, path: resolved } = resolveMount(path);
 	try {
-		if (config.checkAccess && !(cache.getStats(path) || (await fs.stat(resolved))).hasAccess(constants.W_OK)) {
+		if (config.checkAccess && !(await (cache.getStats(path) || fs.stat(resolved)))!.hasAccess(constants.W_OK)) {
 			throw ErrnoError.With('EACCES', resolved, 'unlink');
 		}
 		await fs.unlink(resolved);
@@ -623,7 +624,10 @@ export async function rmdir(path: fs.PathLike): Promise<void> {
 	path = await realpath(path);
 	const { fs, path: resolved } = resolveMount(path);
 	try {
-		const stats = cache.getStats(path) || (await fs.stat(resolved));
+		const stats = await (cache.getStats(path) || fs.stat(resolved));
+		if (!stats) {
+			throw ErrnoError.With('ENOENT', path, 'readdir');
+		}
 		if (!stats.isDirectory()) {
 			throw ErrnoError.With('ENOTDIR', resolved, 'rmdir');
 		}
@@ -715,8 +719,13 @@ export async function readdir(
 
 	const { fs, path: resolved } = resolveMount(path);
 
-	const stats = cache.getStats(path) || (await fs.stat(resolved).catch(handleError));
-	cache.setStats(path, stats);
+	const _stats = cache.getStats(path) || fs.stat(resolved).catch(handleError);
+	cache.setStats(path, _stats);
+	const stats = await _stats;
+
+	if (!stats) {
+		throw ErrnoError.With('ENOENT', path, 'readdir');
+	}
 
 	if (config.checkAccess && !stats.hasAccess(constants.R_OK)) {
 		throw ErrnoError.With('EACCES', path, 'readdir');
@@ -743,8 +752,9 @@ export async function readdir(
 	const addEntry = async (entry: string) => {
 		let entryStats: Stats | undefined;
 		if (options?.recursive || options?.withFileTypes) {
-			entryStats = cache.getStats(join(path, entry)) || (await fs.stat(join(resolved, entry)).catch(handleError));
-			cache.setStats(join(path, entry), entryStats);
+			const _entryStats = cache.getStats(join(path, entry)) || fs.stat(join(resolved, entry)).catch(handleError);
+			cache.setStats(join(path, entry), _entryStats);
+			entryStats = await _entryStats;
 		}
 		if (options?.withFileTypes) {
 			values.push(new Dirent(entry, entryStats!));
@@ -967,18 +977,20 @@ access satisfies typeof promises.access;
 export async function rm(path: fs.PathLike, options?: fs.RmOptions & InternalOptions) {
 	path = normalizePath(path);
 
-	const stats =
+	const _stats =
 		cache.getStats(path) ||
-		(await stat(path).catch((error: ErrnoError) => {
-			if (error.code != 'ENOENT' || !options?.force) throw error;
-		}));
+		stat(path).catch((error: ErrnoError) => {
+			if (error.code == 'ENOENT' && options?.force) return undefined;
+			throw error;
+		});
+
+	cache.setStats(path, _stats);
+	const stats = await _stats;
 
 	if (!stats) {
 		return;
 	}
 
-	cache.setStats(path, stats);
-
 	switch (stats.mode & constants.S_IFMT) {
 		case constants.S_IFDIR:
 			if (options?.recursive) {

package/src/emulation/shared.ts

@@ -134,13 +134,6 @@ export function _statfs<const T extends boolean>(fs: FileSystem, bigint?: T): T
 	} as T extends true ? BigIntStatsFs : StatsFs;
 }
 
-export const config = {
-	/**
-	 * Whether to perform access checks
-	 */
-	checkAccess: true,
-};
-
 /**
  * Options used for caching, among other things.
  * @internal *UNSTABLE*