@zenfs/core 2.6.6 → 2.7.1

package/dist/node/sync.js

@@ -76,7 +76,7 @@ renameSync;
  * Test whether or not `path` exists by checking with the file system.
  */
 export function existsSync(path) {
-    path = normalizePath(path);
+    path = normalizePath.call(this, path);
     try {
         const { fs, path: resolvedPath } = _sync.resolve(this, path);
         return fs.existsSync(resolvedPath);
@@ -117,7 +117,7 @@ lstatSync;
 export function truncateSync(path, len = 0) {
     const env_1 = { stack: [], error: void 0, hasError: false };
     try {
-        const file = __addDisposableResource(env_1, _sync.open.call(this, path, { flag: 'r+' }), false);
+        const file = __addDisposableResource(env_1, _sync.open(this, path, { flag: 'r+' }), false);
         len ||= 0;
         if (len < 0)
             throw UV('EINVAL', 'truncate', path.toString());
@@ -133,7 +133,7 @@ export function truncateSync(path, len = 0) {
 }
 truncateSync;
 export function unlinkSync(path) {
-    path = normalizePath(path);
+    path = normalizePath.call(this, path);
     const { fs, path: resolved } = resolveMount(path, this);
     try {
         const env_2 = { stack: [], error: void 0, hasError: false };
@@ -165,7 +165,7 @@ unlinkSync;
  * @param flag {@link https://nodejs.org/api/fs.html#file-system-flags}
  */
 export function openSync(path, flag, mode = constants.F_OK) {
-    return toFD(_sync.open.call(this, path, { flag, mode }));
+    return toFD(_sync.open(this, path, { flag, mode }));
 }
 openSync;
 /**
@@ -173,7 +173,7 @@ openSync;
  * @internal
  */
 export function lopenSync(path, flag, mode) {
-    return toFD(_sync.open.call(this, path, { flag, mode, preserveSymlinks: true }));
+    return toFD(_sync.open(this, path, { flag, mode, preserveSymlinks: true }));
 }
 export function readFileSync(path, _options = {}) {
     const env_3 = { stack: [], error: void 0, hasError: false };
@@ -184,7 +184,7 @@ export function readFileSync(path, _options = {}) {
             throw UV('EBADF', 'read', path.toString());
         const file = __addDisposableResource(env_3, typeof path == 'number'
             ? fromFD(this, path)
-            : _sync.open.call(this, path.toString(), { flag: options.flag, mode: 0o644, preserveSymlinks: false }), false);
+            : _sync.open(this, path.toString(), { flag: options.flag, mode: 0o644, preserveSymlinks: false }), false);
         const { size } = file.stat();
         const data = Buffer.alloc(size);
         file.readSync(data, 0, size, 0);
@@ -216,7 +216,7 @@ export function writeFileSync(path, data, _options = {}) {
         }
         const file = __addDisposableResource(env_4, typeof path == 'number'
             ? fromFD(this, path)
-            : _sync.open.call(this, path.toString(), {
+            : _sync.open(this, path.toString(), {
                 flag,
                 mode: options.mode,
             }), false);
@@ -250,7 +250,7 @@ export function appendFileSync(filename, data, _options = {}) {
     const encodedData = typeof data == 'string' ? Buffer.from(data, options.encoding) : new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
     const file = typeof filename == 'number'
         ? fromFD(this, filename)
-        : _sync.open.call(this, normalizePath(filename), {
+        : _sync.open(this, normalizePath.call(this, filename), {
             flag,
             mode: options.mode,
         });
@@ -354,7 +354,7 @@ futimesSync;
 export function rmdirSync(path) {
     const env_5 = { stack: [], error: void 0, hasError: false };
     try {
-        path = normalizePath(path);
+        path = normalizePath.call(this, path);
         const { fs, path: resolved } = _sync.resolve(this, path);
         const stats = wrap(fs, 'statSync', { path, syscall: 'rmdir' })(resolved);
         if (!isDirectory(stats))
@@ -383,7 +383,7 @@ export function mkdirSync(path, options) {
 mkdirSync;
 export function readdirSync(path, options) {
     options = typeof options === 'object' ? options : { encoding: options };
-    path = normalizePath(path);
+    path = normalizePath.call(this, path);
     const entries = [];
     const rawEntries = _sync.readdir.call(this, path, options ?? undefined);
     for (const raw of rawEntries) {
@@ -415,9 +415,9 @@ export function symlinkSync(target, path, type = 'file') {
     try {
         if (!['file', 'dir', 'junction'].includes(type))
             throw new TypeError('Invalid symlink type: ' + type);
-        path = normalizePath(path);
-        const file = __addDisposableResource(env_6, _sync.open.call(this, path, { flag: 'wx', mode: 0o644 }), false);
-        file.writeSync(encodeUTF8(normalizePath(target, true)));
+        path = normalizePath.call(this, path);
+        const file = __addDisposableResource(env_6, _sync.open(this, path, { flag: 'wx', mode: 0o644 }), false);
+        file.writeSync(encodeUTF8(normalizePath.call(this, target, true)));
         file.chmodSync(constants.S_IFLNK);
     }
     catch (e_6) {
@@ -442,7 +442,7 @@ readlinkSync;
 export function chownSync(path, uid, gid) {
     const env_7 = { stack: [], error: void 0, hasError: false };
     try {
-        const handle = __addDisposableResource(env_7, _sync.open.call(this, path, { flag: 'r+', mode: constants.F_OK }), false);
+        const handle = __addDisposableResource(env_7, _sync.open(this, path, { flag: 'r+', mode: constants.F_OK }), false);
         handle.chownSync(uid, gid);
     }
     catch (e_7) {
@@ -466,7 +466,7 @@ export function chmodSync(path, mode) {
         fd = openSync.call(this, path, 'r+');
     }
     catch (e) {
-        throw setUVMessage(Object.assign(e, { syscall: 'chmod', path: normalizePath(path) }));
+        throw setUVMessage(Object.assign(e, { syscall: 'chmod', path: normalizePath.call(this, path) }));
     }
     fchmodSync.call(this, fd, mode);
     closeSync.call(this, fd);
@@ -498,7 +498,7 @@ export function lutimesSync(path, atime, mtime) {
 lutimesSync;
 export function realpathSync(path, options) {
     const encoding = typeof options == 'string' ? options : (options?.encoding ?? 'utf8');
-    path = normalizePath(path, true);
+    path = normalizePath.call(this, path, true);
     const { fullPath } = _sync.resolve(this, path);
     if (encoding == 'utf8' || encoding == 'utf-8')
         return fullPath;
@@ -521,7 +521,7 @@ accessSync;
  * @param path The path to the file or directory to remove.
  */
 export function rmSync(path, options) {
-    path = normalizePath(path);
+    path = normalizePath.call(this, path);
     let stats;
     try {
         stats = lstatSync.bind(this)(path);
@@ -580,8 +580,8 @@ export function mkdtempDisposableSync(prefix, options) {
  * - `fs.constants.COPYFILE_EXCL`: If the destination file already exists, the operation fails.
  */
 export function copyFileSync(source, destination, flags) {
-    source = normalizePath(source);
-    destination = normalizePath(destination);
+    source = normalizePath.call(this, source);
+    destination = normalizePath.call(this, destination);
     if (flags && flags & constants.COPYFILE_EXCL && existsSync.call(this, destination))
         throw UV('EEXIST', 'copyFile', destination);
     writeFileSync.call(this, destination, readFileSync.call(this, source));
@@ -628,7 +628,7 @@ writevSync;
  * @todo Handle options
  */
 export function opendirSync(path, options) {
-    path = normalizePath(path);
+    path = normalizePath.call(this, path);
     return new Dir(path, this);
 }
 opendirSync;
@@ -645,8 +645,8 @@ opendirSync;
  * - `recursive`: If `true`, copies directories recursively.
  */
 export function cpSync(source, destination, opts) {
-    source = normalizePath(source);
-    destination = normalizePath(destination);
+    source = normalizePath.call(this, source);
+    destination = normalizePath.call(this, destination);
     const srcStats = lstatSync.call(this, source); // Use lstat to follow symlinks if not dereferencing
     if (opts?.errorOnExist && existsSync.call(this, destination))
         throw UV('EEXIST', 'cp', destination);
@@ -688,7 +688,7 @@ export function cpSync(source, destination, opts) {
 }
 cpSync;
 export function statfsSync(path, options) {
-    path = normalizePath(path);
+    path = normalizePath.call(this, path);
     const { fs } = resolveMount(path, this);
     return _statfs(fs, options?.bigint);
 }

package/dist/vfs/async.js

@@ -114,7 +114,7 @@ export async function resolve($, path, preserveSymlinks, extra) {
  * @internal
  */
 export async function open($, path, opt) {
-    path = normalizePath(path);
+    path = normalizePath.call($, path);
     const mode = normalizeMode(opt.mode, 0o644), flag = flags.parse(opt.flag);
     const $ex = { syscall: 'open', path };
     // eslint-disable-next-line prefer-const
@@ -131,7 +131,7 @@ export async function open($, path, opt) {
                 throw UV('EACCES', 'open', dirname(path));
             if (!isDirectory(parentStats))
                 throw UV('ENOTDIR', 'open', dirname(path));
-            if (!opt.allowDirectory && mode & constants.S_IFDIR)
+            if (!opt.allowDirectory && isDirectory({ mode }))
                 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);
@@ -161,7 +161,7 @@ export async function open($, path, opt) {
         throw UV('EACCES', $ex);
     if (flag & constants.O_EXCL)
         throw UV('EEXIST', $ex);
-    if (!opt.allowDirectory && mode & constants.S_IFDIR)
+    if (!opt.allowDirectory && isDirectory({ mode }))
         throw UV('EISDIR', 'open', path);
     const handle = new Handle($, path, resolved, flag, cacheOf(fs).ref(resolved, stats));
     if (flag & constants.O_TRUNC)
@@ -169,7 +169,7 @@ export async function open($, path, opt) {
     return handle;
 }
 export async function readlink(path) {
-    path = normalizePath(path);
+    path = normalizePath.call(this, path);
     const $ex = { syscall: 'readlink', path };
     const { fs, stats, path: resolved } = await resolve(this, path, true, $ex);
     if (!stats)
@@ -184,7 +184,7 @@ export async function readlink(path) {
     return decodeUTF8(data);
 }
 export async function mkdir(path, options = {}) {
-    const original = normalizePath(path);
+    const original = normalizePath.call(this, path);
     const { euid: uid, egid: gid } = contextOf(this).credentials;
     const { mode = 0o777, recursive } = options;
     const $ex = { syscall: 'mkdir', path: original };
@@ -238,7 +238,7 @@ export async function mkdir(path, options = {}) {
     return firstCreated;
 }
 export async function readdir(path, options = {}) {
-    path = normalizePath(path);
+    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);
@@ -290,8 +290,8 @@ export async function readdir(path, options = {}) {
 export async function rename(oldPath, newPath) {
     const env_4 = { stack: [], error: void 0, hasError: false };
     try {
-        oldPath = normalizePath(oldPath);
-        newPath = normalizePath(newPath);
+        oldPath = normalizePath.call(this, oldPath);
+        newPath = normalizePath.call(this, newPath);
         const $ex = { syscall: 'rename', path: oldPath, dest: newPath };
         const src = await resolve(this, oldPath, true, $ex);
         const dst = resolveMount(newPath, this, $ex);
@@ -344,8 +344,8 @@ export async function rename(oldPath, newPath) {
 export async function link(target, link) {
     const env_5 = { stack: [], error: void 0, hasError: false };
     try {
-        target = normalizePath(target);
-        link = normalizePath(link);
+        target = normalizePath.call(this, target);
+        link = normalizePath.call(this, link);
         const $ex = { syscall: 'link', path: target, dest: link };
         const { fs, path: resolved } = resolveMount(target, this, $ex);
         const dst = resolveMount(link, this, $ex);

package/dist/vfs/file.d.ts

@@ -45,6 +45,10 @@ export declare class Handle {
      * Whether the file is open or closed
      */
     protected closed: boolean;
+    /** How many descriptors refer to this open file */
+    protected refs: number;
+    /** Take another reference to the open file */
+    ref(): this;
     get isClosed(): boolean;
     /**
      * Creates a file handle for the vnode.
@@ -141,11 +145,17 @@ export declare class Handle {
     streamWrite(options: StreamOptions): WritableStream;
 }
 /**
+ * Give an open file a descriptor
  * @internal @hidden
  */
-export declare function toFD(file: Handle): number;
+export declare function toFD(file: Handle, $?: V_Context): number;
 /**
  * @internal @hidden
  */
 export declare function fromFD($: V_Context, fd: number): Handle;
 export declare function deleteFD($: V_Context, fd: number): boolean;
+/**
+ * Give an open file another descriptor
+ * @internal @hidden
+ */
+export declare function dupFD($: V_Context, fd: number): number;

package/dist/vfs/file.js

@@ -152,6 +152,15 @@ let Handle = (() => {
          * Whether the file is open or closed
          */
         closed = false;
+        /** How many descriptors refer to this open file */
+        refs = 1;
+        /** Take another reference to the open file */
+        ref() {
+            if (this.closed)
+                throw UV('EBADF', 'dup', this.path);
+            this.refs++;
+            return this;
+        }
         get isClosed() {
             return this.closed;
         }
@@ -199,6 +208,8 @@ let Handle = (() => {
             if (this.closed)
                 throw UV('EBADF', 'close', this.path);
             this.syncSync();
+            if (--this.refs > 0)
+                return;
             this.disposeSync(true);
         }
         /**
@@ -406,6 +417,8 @@ let Handle = (() => {
             if (this.closed)
                 throw UV('EBADF', 'close', this.path);
             await this.sync();
+            if (--this.refs > 0)
+                return;
             this.dispose(true);
         }
         /**
@@ -671,12 +684,14 @@ let Handle = (() => {
 export { Handle };
 // descriptors
 /**
+ * Give an open file a descriptor
  * @internal @hidden
  */
-export function toFD(file) {
-    const map = contextOf(file.context).descriptors;
-    // @todo use `Iterator` helper #296
-    const fd = Array.from(map.keys()).reduce((max, k) => Math.max(max, k), 4);
+export function toFD(file, $ = file.context) {
+    const map = contextOf($).descriptors;
+    let fd = 0;
+    while (map.has(fd))
+        fd++;
     map.set(fd, file);
     return fd;
 }
@@ -694,3 +709,10 @@ export function fromFD($, fd) {
 export function deleteFD($, fd) {
     return contextOf($).descriptors.delete(fd);
 }
+/**
+ * Give an open file another descriptor
+ * @internal @hidden
+ */
+export function dupFD($, fd) {
+    return toFD(fromFD($, fd).ref(), $);
+}

package/dist/vfs/ioctl.d.ts

@@ -1,90 +1,13 @@
-import { BufferView } from 'utilium/buffer';
+import type { PathOrFileDescriptor } from 'node:fs';
 import type { V_Context } from '../context.js';
-import { Inode } from '../internal/inode.js';
-declare const fsxattr_base: import("memium").StructConstructor<BufferView<any>>;
-declare class fsxattr extends fsxattr_base {
-    static name: string;
-    /** xflags field value */
-    accessor xflags: number;
-    /** extsize field value */
-    accessor extsize: number;
-    /** nextents field value */
-    accessor nextents: number;
-    /** project identifier */
-    accessor projid: number;
-    /** CoW extsize field value */
-    accessor cowextsize: number;
-    protected accessor pad: number[];
-    constructor(inode?: Inode);
-}
+import type { IoctlArgs, IoctlDefaultAsyncOps, IoctlDefaultSyncOps, IoctlOps } from '../internal/ioctl.js';
 /**
- * `FS_IOC_*` commands for {@link ioctl | `ioctl`}
- * @remarks
- * These are computed from a script since constant values are needed for enum member types
+ * Perform an `ioctl` on a file or file system.
+ * @category ioctl
  */
-export declare enum IOC {
-    GetFlags = 2148034049,
-    SetFlags = 1074292226,
-    GetVersion = 2148038145,
-    SetVersion = 1074296322,
-    Fiemap = 3223348747,
-    GetXattr = 2149341215,
-    SetXattr = 1075599392,
-    GetLabel = 2164298801,
-    SetLabel = 1090556978,
-    GetUUID = 2148603136,
-    GetSysfsPath = 2155943169
-}
+export declare function ioctl<const Command extends number, const Ops extends IoctlOps = IoctlDefaultAsyncOps>(this: V_Context, path: PathOrFileDescriptor, command: Command, ...args: IoctlArgs<Ops[Command]>): Promise<ReturnType<Ops[Command]>>;
 /**
- * `FS_IOC32_*` commands for {@link ioctl | `ioctl`}
- * @remarks
- * These are computed from a script since constant values are needed for enum member types
+ * Perform an `ioctl` on a file or file system
+ * @category ioctl
  */
-export declare enum IOC32 {
-    GetFlags = 2147771905,
-    SetFlags = 1074030082,
-    GetVersion = 2147776001,
-    SetVersion = 1074034178
-}
-/** Used by `ioctl` for type inference */
-interface _ioc_ops {
-    [IOC.GetFlags](): number;
-    [IOC.SetFlags](flags: number): void;
-    [IOC.GetVersion](): number;
-    [IOC.SetVersion](version: number): void;
-    [IOC.Fiemap](): never;
-    [IOC.GetXattr](name: string): fsxattr;
-    [IOC.SetXattr](name: string, value: fsxattr): never;
-    [IOC.GetLabel](): string;
-    [IOC.SetLabel](label: string): void;
-    [IOC.GetUUID](): string;
-    [IOC.GetSysfsPath](): string;
-}
-/** Used by `ioctl` for type inference */
-interface _ioc32_ops extends Record<keyof IOC32, (...args: any[]) => any> {
-    [IOC32.GetFlags](): number;
-    [IOC32.SetFlags](flags: number): void;
-    [IOC32.GetVersion](): number;
-    [IOC32.SetVersion](version: number): void;
-}
-/** Used by `ioctl` for type inference */
-type __ioctl_args__<T extends number> = T extends IOC ? Parameters<_ioc_ops[T]> : T extends IOC32 ? Parameters<_ioc32_ops[T]> : any[];
-/** Used by `ioctl` for type inference */
-type __ioctl_return__<T extends number> = T extends IOC ? ReturnType<_ioc_ops[T]> : T extends IOC32 ? ReturnType<_ioc32_ops[T]> : any;
-/** Perform an `ioctl` on a file or file system. */
-export declare function ioctl<const Command extends number, const Args extends __ioctl_args__<Command>, const Return extends __ioctl_return__<Command>>(this: V_Context, 
-/** The path to the file or file system to perform the `ioctl` on */
-path: string, 
-/** The command to perform (uint32) */
-command: Command, 
-/** The arguments to pass to the command */
-...args: Args): Promise<Return>;
-/** Perform an `ioctl` on a file or file system */
-export declare function ioctlSync<const Command extends number, const Args extends __ioctl_args__<Command>, const Return extends __ioctl_return__<Command>>(this: V_Context, 
-/** The path to the file or file system to perform the `ioctl` on */
-path: string, 
-/** The command to perform (uint32) */
-command: Command, 
-/** The arguments to pass to the command */
-...args: Args): Return;
-export {};
+export declare function ioctlSync<const Command extends number, const Ops extends IoctlOps = IoctlDefaultSyncOps>(this: V_Context, path: PathOrFileDescriptor, command: Command, ...args: IoctlArgs<Ops[Command]>): ReturnType<Ops[Command]>;