@zenfs/core 2.7.4 → 2.7.6

package/dist/node/stats.js

@@ -15,41 +15,23 @@ export class StatsCommon {
         return this._convert(Math.ceil(Number(this.size) / 512));
     }
     set blocks(value) { }
-    /**
-     * Unix-style file mode (e.g. 0o644) that includes the type of the item.
-     */
+    /** Unix-style file mode (e.g. 0o644) that includes the type of the item. */
     mode;
-    /**
-     * ID of device containing file
-     */
+    /** ID of device containing file */
     dev = this._convert(0);
-    /**
-     * Inode number
-     */
+    /** Inode number */
     ino = this._convert(0);
-    /**
-     * Device ID (if special file)
-     */
+    /** Device ID (if special file) */
     rdev = this._convert(0);
-    /**
-     * Number of hard links
-     */
+    /** Number of hard links */
     nlink = this._convert(1);
-    /**
-     * Block size for file system I/O
-     */
+    /** Block size for file system I/O */
     blksize = this._convert(4096);
-    /**
-     * User ID of owner
-     */
+    /** User ID of owner */
     uid = this._convert(0);
-    /**
-     * Group ID of owner
-     */
+    /** Group ID of owner */
     gid = this._convert(0);
-    /**
-     * Time of last access, since epoch
-     */
+    /** Time of last access, since epoch */
     atimeMs;
     get atime() {
         return new Date(Number(this.atimeMs));
@@ -63,9 +45,7 @@ export class StatsCommon {
     set atimeInstant(value) {
         this.atimeMs = this._convert(value.epochMilliseconds);
     }
-    /**
-     * Time of last modification, since epoch
-     */
+    /** Time of last modification, since epoch */
     mtimeMs;
     get mtime() {
         return new Date(Number(this.mtimeMs));
@@ -79,9 +59,7 @@ export class StatsCommon {
     set mtimeInstant(value) {
         this.mtimeMs = this._convert(value.epochMilliseconds);
     }
-    /**
-     * Time of last time file status was changed, since epoch
-     */
+    /** Time of last time file status was changed, since epoch */
     ctimeMs;
     get ctime() {
         return new Date(Number(this.ctimeMs));
@@ -95,9 +73,7 @@ export class StatsCommon {
     set ctimeInstant(value) {
         this.ctimeMs = this._convert(value.epochMilliseconds);
     }
-    /**
-     * Time of file creation, since epoch
-     */
+    /** Time of file creation, since epoch */
     birthtimeMs;
     get birthtime() {
         return new Date(Number(this.birthtimeMs));
@@ -111,26 +87,15 @@ export class StatsCommon {
     set birthtimeInstant(value) {
         this.birthtimeMs = this._convert(value.epochMilliseconds);
     }
-    /**
-     * Size of the item in bytes.
-     * For directories/symlinks, this is normally the size of the struct that represents the item.
-     */
+    /** Size of the item in bytes. For directories/symlinks, this may be the size of the struct that represents the item. */
     size;
-    /**
-     * @internal Used by inodes
-     */
+    /** @internal Used by inodes */
     data;
-    /**
-     * @internal Used by inodes
-     */
+    /** @internal Used by inodes */
     flags;
-    /**
-     * @internal Used by inodes
-     */
+    /** @internal Used by inodes */
     version;
-    /**
-     * Creates a new stats instance from a stats-like object. Can be used to copy stats (note)
-     */
+    /** Creates a new stats instance from a stats-like object. Can be used to copy stats (note) */
     constructor({ atimeMs, mtimeMs, ctimeMs, birthtimeMs, uid, gid, size, mode, ino, ...rest } = {}) {
         const now = Date.now();
         this.atimeMs = this._convert(atimeMs ?? now);
@@ -169,7 +134,7 @@ export class StatsCommon {
         return (this.mode & c.S_IFMT) === c.S_IFIFO;
     }
     toJSON() {
-        return pick(this, _inode_fields);
+        return pick(this, ..._inode_fields, 'dev', 'blksize');
     }
     /**
      * Checks if a given user/group has access to this item
@@ -225,8 +190,6 @@ export function isStatsEqual(left, right) {
         && +left.ctime == +right.ctime
         && left.mode == right.mode);
 }
-/** @internal */
-export const ZenFsType = 0x7a656e6673; // 'z' 'e' 'n' 'f' 's'
 /**
  * @hidden
  */

package/dist/node/streams.d.ts

@@ -1,45 +1,10 @@
-import type { Abortable } from 'node:events';
 import type * as fs from 'node:fs';
 import type { CreateReadStreamOptions, CreateWriteStreamOptions } from 'node:fs/promises';
 import type { Callback } from '../utils.js';
 import type { FileHandle } from './promises.js';
 import { Readable } from '@zenfs/streams/readable';
 import { Writable } from '@zenfs/streams/writable';
-interface FSImplementation {
-    open?: (...args: unknown[]) => unknown;
-    close?: (...args: unknown[]) => unknown;
-}
-interface StreamOptions extends Abortable {
-    flags?: string;
-    encoding?: BufferEncoding;
-    fd?: number | FileHandle;
-    mode?: number;
-    autoClose?: boolean;
-    emitClose?: boolean;
-    start?: number;
-    highWaterMark?: number;
-}
-/**
- * This type is from node:fs but not exported.
- * @hidden
- */
-export interface ReadStreamOptions extends StreamOptions {
-    fs?: FSImplementation & {
-        read: (...args: unknown[]) => unknown;
-    };
-    end?: number;
-}
-/**
- * This type is from node:fs but not exported.
- * @hidden
- */
-export interface WriteStreamOptions extends StreamOptions {
-    flush?: boolean;
-    fs?: FSImplementation & {
-        write: (...args: unknown[]) => unknown;
-        writev?: (...args: unknown[]) => unknown;
-    };
-}
+export type { ReadStreamOptions, WriteStreamOptions } from 'node:fs';
 /**
  * A ReadStream implementation that wraps an underlying global ReadableStream.
  */
@@ -76,4 +41,3 @@ export declare class WriteStream extends Writable implements fs.WriteStream {
     get path(): string;
     get bytesWritten(): number;
 }
-export {};

package/dist/node/sync.d.ts

@@ -210,13 +210,8 @@ export declare function mkdtempSync(this: V_Context, prefix: fs.PathLike, option
  * When the object is disposed, the directory and its contents will be removed if it still exists.
  * If the directory cannot be deleted, disposal will throw an error.
  * The object has a `remove()` method which will perform the same task.
- * @todo Add `satisfies` and maybe change return type once @types/node adds this.
  */
-export declare function mkdtempDisposableSync(this: V_Context, prefix: fs.PathLike, options?: fs.EncodingOption | fs.BufferEncodingOption): {
-    path: string;
-    remove(): void;
-    [Symbol.dispose](): void;
-};
+export declare function mkdtempDisposableSync(this: V_Context, prefix: fs.PathLike, options?: fs.EncodingOption | fs.BufferEncodingOption): fs.DisposableTempDir;
 /**
  * Synchronous `copyFile`. Copies a file.
  * @param flags Optional flags for the copy operation. Currently supports these flags:

package/dist/node/sync.js

@@ -541,7 +541,7 @@ export function rmSync(path, options) {
     path = normalizePath.call(this, path);
     let stats;
     try {
-        stats = lstatSync.bind(this)(path);
+        stats = lstatSync.call(this, path);
     }
     catch (error) {
         if (error.code != 'ENOENT' || !options?.force)
@@ -583,7 +583,6 @@ mkdtempSync;
  * When the object is disposed, the directory and its contents will be removed if it still exists.
  * If the directory cannot be deleted, disposal will throw an error.
  * The object has a `remove()` method which will perform the same task.
- * @todo Add `satisfies` and maybe change return type once @types/node adds this.
  */
 export function mkdtempDisposableSync(prefix, options) {
     const path = _tempDirName(prefix);
@@ -591,6 +590,7 @@ export function mkdtempDisposableSync(prefix, options) {
     const remove = () => rmSync(path, { recursive: true, force: true });
     return { path, remove, [Symbol.dispose]: remove };
 }
+mkdtempDisposableSync;
 /**
  * Synchronous `copyFile`. Copies a file.
  * @param flags Optional flags for the copy operation. Currently supports these flags:

package/dist/polyfills.js

@@ -57,4 +57,13 @@ Uint8Array.fromHex ??=
             }
             return bytes;
         });
+Array.fromAsync ??=
+    (warn('Using a polyfill of Array.fromAsync'),
+        async function collectAsyncIterator(it) {
+            const results = [];
+            for await (const result of it) {
+                results.push(result);
+            }
+            return results;
+        });
 /* node:coverage enable */

package/dist/utils.d.ts

@@ -3,10 +3,6 @@ import type * as fs from 'node:fs';
 import type { Worker as NodeWorker } from 'node:worker_threads';
 import { type OptionalTuple } from 'utilium';
 import type { V_Context } from './internal/contexts.js';
-declare global {
-    function atob(data: string): string;
-    function btoa(data: string): string;
-}
 /**
  * Decodes a directory listing
  * @hidden

package/dist/vfs/acl.d.ts

@@ -12,9 +12,7 @@ export declare const enum Tag {
     Group = 8,
     Mask = 16,
     Other = 32,
-    /**
-     * @internal @hidden
-     */
+    /** @internal @hidden */
     _None = 0
 }
 declare const Entry_base: import("memium").StructConstructor<BufferView<any>>;

package/dist/vfs/acl.js

@@ -62,9 +62,7 @@ export var Tag;
     Tag[Tag["Group"] = 8] = "Group";
     Tag[Tag["Mask"] = 16] = "Mask";
     Tag[Tag["Other"] = 32] = "Other";
-    /**
-     * @internal @hidden
-     */
+    /** @internal @hidden */
     Tag[Tag["_None"] = 0] = "_None";
 })(Tag || (Tag = {}));
 let Entry = (() => {

package/dist/vfs/async.js

@@ -80,7 +80,6 @@ export async function resolve($, path, preserveSymlinks, extra) {
     that means we don't need to perform any resolution for parent directories. */
     try {
         const resolved = resolveMount(path, $);
-        // Stat it to make sure it exists. The vnode cache takes precedence since it may have unsynced changes
         const stats = cacheOf(resolved.fs).get(resolved.path)?.inode ?? (await resolved.fs.stat(resolved.path));
         if (!isSymbolicLink(stats)) {
             return { ...resolved, fullPath: path, stats };
@@ -135,7 +134,6 @@ export async function open($, path, opt) {
                 throw UV('EISDIR', 'open', path);
             // Serialize entry creation with other operations on the parent directory
             const _ = __addDisposableResource(env_1, await lockPath(fs, parentPath, 'rw', parentStats), false);
-            // Another task may have created the file while we waited for the lock
             stats = cacheOf(fs).get(resolved)?.inode ?? (await fs.stat(resolved).catch(() => undefined));
             if (!stats) {
                 const { euid: uid, egid: gid } = contextOf($).credentials;
@@ -144,7 +142,6 @@ export async function open($, path, opt) {
                     uid: parentStats.mode & constants.S_ISUID ? parentStats.uid : uid,
                     gid: parentStats.mode & constants.S_ISGID ? parentStats.gid : gid,
                 });
-                // A new entry in the parent directory, which is a 'rename' event
                 emitChange($, 'rename', path);
                 return new Handle($, path, resolved, flag, cacheOf(fs).ref(resolved, inode));
             }
@@ -239,7 +236,6 @@ export async function mkdir(path, options = {}) {
 }
 export async function readdir(path, options = {}) {
     path = normalizePath.call(this, path);
-    // Node reports `readdir` failures as `scandir`
     const $ex = { syscall: 'scandir', path };
     const { fs, path: resolved, stats } = await resolve(this, path, false, $ex);
     if (!stats)
@@ -329,7 +325,6 @@ export async function rename(oldPath, newPath) {
         const _second = __addDisposableResource(env_4, oldParent.ino == newParent.ino ? null : await lockPath(fs, parents[1][0], 'rw', parents[1][1]), false);
         await src.fs.rename(src.path, dst.path);
         cacheOf(fs).rename(src.path, dst.path);
-        // Both names change which entries exist, so both are 'rename' events
         emitChange(this, 'rename', oldPath);
         emitChange(this, 'rename', newPath);
     }

package/dist/vfs/dir.d.ts

@@ -22,6 +22,9 @@ export declare function ifToDt(mode: number): DirType;
  * @see `DTTOIF` in `dirent.h`
  */
 export declare function dtToIf(dt: DirType): number;
+/**
+ * @todo [breaking] change this to an interface
+ */
 export declare class Dirent {
     ino: number;
     type: DirType;

package/dist/vfs/dir.js

@@ -19,7 +19,7 @@ export var DirType;
  * @see `IFTODT` in `dirent.h`
  */
 export function ifToDt(mode) {
-    return ((mode & 0o170000) >> 12);
+    return (mode & 0o170000) >> 12;
 }
 /**
  * Converts a directory type to a file mode.
@@ -28,6 +28,9 @@ export function ifToDt(mode) {
 export function dtToIf(dt) {
     return dt << 12;
 }
+/**
+ * @todo [breaking] change this to an interface
+ */
 export class Dirent {
     ino;
     type;

package/dist/vfs/file.d.ts

@@ -3,11 +3,6 @@ import type { FileSystem, StreamOptions } from '../internal/filesystem.js';
 import { type InodeLike } from '../internal/inode.js';
 import '../polyfills.js';
 import type { VNode } from './vnode.js';
-/** @hidden */
-export interface FileReadResult<T extends ArrayBufferView> {
-    bytesRead: number;
-    buffer: T;
-}
 /**
  * @internal
  */
@@ -17,9 +12,7 @@ export declare class Handle {
     readonly internalPath: string;
     readonly flag: number;
     readonly vnode: VNode;
-    /**
-     * Current position
-     */
+    /** Current position */
     protected _position: number;
     /**
      * Get the current file position.

package/dist/vfs/file.js

@@ -114,9 +114,7 @@ let Handle = (() => {
         internalPath;
         flag;
         vnode;
-        /**
-         * Current position
-         */
+        /** Current position */
         _position = 0;
         /**
          * Get the current file position.

package/dist/vfs/sync.js

@@ -269,7 +269,6 @@ export function readdir(path, options = {}) {
             __disposeResources(env_3);
         }
     }
-    // Iterate over entries and handle recursive case if needed
     const values = [];
     const addEntry = (entry) => {
         let entryStat;

package/dist/vfs/vcache.js

@@ -85,7 +85,6 @@ export class VCache {
         }
         else {
             node.paths.add(path);
-            // The vnode's inode is authoritative when dirty; otherwise refresh it with the newer stats
             if (!node.dirty && inode !== node.inode)
                 Object.assign(node.inode, inode);
         }

package/dist/vfs/xattr.d.ts

@@ -44,6 +44,8 @@ export interface SetOptions extends Options {
      */
     replace?: boolean;
 }
+/** Attributes outside the `user` namespace that are supported. */
+export declare const allowedRestrictedNames: Set<`user.${string}` | `trusted.${string}` | `system.${string}` | `security.${string}`>;
 /**
  * Gets the value of an extended attribute.
  *

package/dist/vfs/xattr.js

@@ -6,14 +6,15 @@ import { normalizePath } from '../utils.js';
 import { checkAccess } from './config.js';
 import { R_OK, W_OK } from '../constants.js';
 import { resolveMount } from './shared.js';
-const _allowedRestrictedNames = [];
+/** Attributes outside the `user` namespace that are supported. */
+export const allowedRestrictedNames = new Set();
 /**
  * Check permission for the attribute name.
- * For now, only attributes in the 'user' namespace are supported.
- * @throws ENOTSUP for attributes in namespaces other than 'user'
+ * Only the 'user' namespace and whatever is in {@link allowedRestrictedNames} are supported.
+ * @throws ENOTSUP for any other attribute
  */
 function checkName($, name, path, syscall) {
-    if (!name.startsWith('user.') && !_allowedRestrictedNames.includes(name))
+    if (!name.startsWith('user.') && !allowedRestrictedNames.has(name))
         throw UV('ENOTSUP', syscall, path);
 }
 export async function get(path, name, opt = {}) {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@zenfs/core",
-	"version": "2.7.4",
+	"version": "2.7.6",
 	"description": "A filesystem, anywhere",
 	"funding": {
 		"type": "individual",
@@ -23,7 +23,6 @@
 	"files": [
 		"dist",
 		"tests",
-		"types",
 		"license.md",
 		"eslint.shared.js"
 	],
@@ -93,7 +92,7 @@
 		"typedoc": "^0.28.18",
 		"typescript": "^6.0.0",
 		"typescript-eslint": "^8.58.0",
-		"zbench-js": "^0.1.0"
+		"zbench-js": "^0.2.0"
 	},
 	"prettier": {
 		"singleQuote": true,

package/tests/common/context.test.ts

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: LGPL-3.0-or-later
-import { bindContext, configure, fs, InMemory, type BoundContext } from '@zenfs/core';
+import { bindContext, configure, fs, InMemory } from '@zenfs/core';
 import assert from 'node:assert/strict';
 import { suite, test } from 'node:test';
 import { canary } from 'utilium';

package/tests/common/mutex.test.ts

@@ -1,61 +0,0 @@
-// SPDX-License-Identifier: LGPL-3.0-or-later
-import { InMemoryStore, Mutexed, StoreFS } from '@zenfs/core';
-import assert from 'node:assert/strict';
-import { suite, test } from 'node:test';
-import { wait } from 'utilium';
-
-suite('Mutexed FS', () => {
-	const fs = new (Mutexed(StoreFS))(new InMemoryStore(0x10000, 'test'));
-	fs._fs.checkRootSync();
-
-	test('lock/unlock', () => {
-		const lock = fs.lockSync();
-		assert(fs.isLocked);
-		lock.unlock();
-		assert(!fs.isLocked);
-	});
-
-	test('queueing multiple locks', async () => {
-		let lock1Resolved = false;
-		let lock2Resolved = false;
-
-		const lock1 = fs.lock(100).then(lock => {
-			lock1Resolved = true;
-			lock.unlock();
-		});
-		const lock2 = fs.lock(100).then(lock => {
-			lock2Resolved = true;
-			lock.unlock();
-		});
-
-		// Both locks are queued, so neither should be resolved initially
-		assert(!lock1Resolved);
-		assert(!lock2Resolved);
-
-		// Wait for the first lock to be resolved
-		await lock1;
-
-		assert(lock1Resolved);
-		assert(!lock2Resolved);
-
-		// Wait for the second lock to be resolved
-		await lock2;
-
-		assert(lock1Resolved);
-		assert(lock2Resolved);
-	});
-
-	test('test race conditions', async () => {
-		let x = 1;
-
-		async function foo() {
-			const lock = await fs.lock(100);
-			await wait(25);
-			x++;
-			lock.unlock();
-		}
-
-		await Promise.all([foo(), foo(), foo()]);
-		assert.equal(x, 4);
-	});
-});