@zenfs/core 2.5.7 → 2.6.0

package/dist/backends/cow.d.ts

@@ -70,6 +70,19 @@ export declare class CopyOnWriteFS extends FileSystem {
     /** The journal to use for persisting deletions */
     journal?: Journal);
     isDeleted(path: string): boolean;
+    /**
+     * Inode numbers presented to the VFS for each path.
+     *
+     * The readable and writable layers allocate inode numbers independently, so they can collide.
+     * They can not be used as-is, since the VFS uses `ino` to tell files apart.
+     * This also keeps a file's inode number stable when it is copied up to the writable layer.
+     */
+    protected inos: Map<string, number>;
+    private _nextIno;
+    /** Moves the public inode numbers for a rename, including a directory's descendants */
+    protected renameInos(oldPath: string, newPath: string): void;
+    /** Replaces the layer's inode number with the public one for `path` */
+    protected remapIno(path: string, inode: InodeLike): InodeLike;
     /**
      * @todo Consider trying to track information on the writable as well
      */

package/dist/backends/cow.js

@@ -1,17 +1,17 @@
 import { EventEmitter } from 'eventemitter3';
 import { withErrno } from 'kerium';
 import { debug, err, warn } from 'kerium/log';
-import { canary } from 'utilium';
+import { canary, pick } from 'utilium';
 import { resolveMountConfig } from '../config.js';
 import { FileSystem } from '../internal/filesystem.js';
-import { isDirectory } from '../internal/inode.js';
+import { _inode_fields, isDirectory } from '../internal/inode.js';
 import { dirname, join } from '../path.js';
 const journalOperations = new Set(['delete']);
 /** Because TS doesn't work right w/o it */
 function isJournalOp(op) {
     return journalOperations.has(op);
 }
-const maxOpLength = Math.max(...journalOperations.values().map(op => op.length));
+const maxOpLength = Math.max(...[...journalOperations].map(op => op.length));
 const journalMagicString = '#journal@v0\n';
 /**
  * Tracks various operations for the CoW backend
@@ -102,6 +102,35 @@ export class CopyOnWriteFS extends FileSystem {
     isDeleted(path) {
         return this.journal.isDeleted(path);
     }
+    /**
+     * Inode numbers presented to the VFS for each path.
+     *
+     * The readable and writable layers allocate inode numbers independently, so they can collide.
+     * They can not be used as-is, since the VFS uses `ino` to tell files apart.
+     * This also keeps a file's inode number stable when it is copied up to the writable layer.
+     */
+    inos = new Map();
+    _nextIno = 1;
+    /** Moves the public inode numbers for a rename, including a directory's descendants */
+    renameInos(oldPath, newPath) {
+        for (const [path, ino] of [...this.inos]) {
+            if (path != oldPath && !path.startsWith(oldPath + '/'))
+                continue;
+            this.inos.delete(path);
+            this.inos.set(newPath + path.slice(oldPath.length), ino);
+        }
+    }
+    /** Replaces the layer's inode number with the public one for `path` */
+    remapIno(path, inode) {
+        let ino = this.inos.get(path);
+        if (ino === undefined) {
+            ino = this._nextIno++;
+            this.inos.set(path, ino);
+        }
+        /* Note the layer's inode is not mutated, since it may be a persistent object.
+        `Inode` fields are accessors, so a copy must be explicit rather than a spread. */
+        return { ...pick(inode, _inode_fields), attributes: inode.attributes, ino };
+    }
     /**
      * @todo Consider trying to track information on the writable as well
      */
@@ -139,6 +168,7 @@ export class CopyOnWriteFS extends FileSystem {
             if (this.isDeleted(oldPath))
                 throw withErrno('ENOENT');
         }
+        this.renameInos(oldPath, newPath);
     }
     renameSync(oldPath, newPath) {
         this.copyForWriteSync(oldPath);
@@ -149,25 +179,26 @@ export class CopyOnWriteFS extends FileSystem {
             if (this.isDeleted(oldPath))
                 throw withErrno('ENOENT');
         }
+        this.renameInos(oldPath, newPath);
     }
     async stat(path) {
         try {
-            return await this.writable.stat(path);
+            return this.remapIno(path, await this.writable.stat(path));
         }
         catch {
             if (this.isDeleted(path))
                 throw withErrno('ENOENT');
-            return await this.readable.stat(path);
+            return this.remapIno(path, await this.readable.stat(path));
         }
     }
     statSync(path) {
         try {
-            return this.writable.statSync(path);
+            return this.remapIno(path, this.writable.statSync(path));
         }
         catch {
             if (this.isDeleted(path))
                 throw withErrno('ENOENT');
-            return this.readable.statSync(path);
+            return this.remapIno(path, this.readable.statSync(path));
         }
     }
     async touch(path, metadata) {
@@ -180,11 +211,11 @@ export class CopyOnWriteFS extends FileSystem {
     }
     async createFile(path, options) {
         await this.createParentDirectories(path);
-        return await this.writable.createFile(path, options);
+        return this.remapIno(path, await this.writable.createFile(path, options));
     }
     createFileSync(path, options) {
         this.createParentDirectoriesSync(path);
-        return this.writable.createFileSync(path, options);
+        return this.remapIno(path, this.writable.createFileSync(path, options));
     }
     async link(srcpath, dstpath) {
         await this.copyForWrite(srcpath);
@@ -204,6 +235,7 @@ export class CopyOnWriteFS extends FileSystem {
         if (await this.exists(path)) {
             this.journal.add('delete', path);
         }
+        this.inos.delete(path);
     }
     unlinkSync(path) {
         if (!this.existsSync(path))
@@ -215,6 +247,7 @@ export class CopyOnWriteFS extends FileSystem {
         if (this.existsSync(path)) {
             this.journal.add('delete', path);
         }
+        this.inos.delete(path);
     }
     async rmdir(path) {
         if (!(await this.exists(path)))
@@ -223,12 +256,14 @@ export class CopyOnWriteFS extends FileSystem {
             await this.writable.rmdir(path);
         }
         if (!(await this.exists(path))) {
+            this.inos.delete(path);
             return;
         }
         // Check if directory is empty.
         if ((await this.readdir(path)).length)
             throw withErrno('ENOTEMPTY');
         this.journal.add('delete', path);
+        this.inos.delete(path);
     }
     rmdirSync(path) {
         if (!this.existsSync(path))
@@ -237,24 +272,26 @@ export class CopyOnWriteFS extends FileSystem {
             this.writable.rmdirSync(path);
         }
         if (!this.existsSync(path)) {
+            this.inos.delete(path);
             return;
         }
         // Check if directory is empty.
         if (this.readdirSync(path).length)
             throw withErrno('ENOTEMPTY');
         this.journal.add('delete', path);
+        this.inos.delete(path);
     }
     async mkdir(path, options) {
         if (await this.exists(path))
             throw withErrno('EEXIST');
         await this.createParentDirectories(path);
-        return await this.writable.mkdir(path, options);
+        return this.remapIno(path, await this.writable.mkdir(path, options));
     }
     mkdirSync(path, options) {
         if (this.existsSync(path))
             throw withErrno('EEXIST');
         this.createParentDirectoriesSync(path);
-        return this.writable.mkdirSync(path, options);
+        return this.remapIno(path, this.writable.mkdirSync(path, options));
     }
     async readdir(path) {
         if (this.isDeleted(path) || !(await this.exists(path)))

package/dist/backends/single_buffer.d.ts

@@ -5,7 +5,7 @@ import type { UsageInfo } from '../internal/filesystem.js';
 import { StoreFS } from './store/fs.js';
 import { SyncMapTransaction, type SyncMapStore } from './store/map.js';
 import type { Store } from './store/store.js';
-type Lock = Disposable & (() => void);
+type SBLock = Disposable & (() => void);
 declare const MetadataEntry_base: import("memium").StructConstructor<BufferView<any>>;
 declare class MetadataEntry extends MetadataEntry_base {
     static name: string;
@@ -52,7 +52,7 @@ export declare class MetadataBlock extends MetadataBlock_base<ArrayBufferLike> {
      * Wait for the block to be unlocked.
      */
     waitUnlocked(depth?: number): void;
-    lock(): Lock;
+    lock(): SBLock;
 }
 declare const SuperBlock_base: import("memium/decorators").StructFromTypedArray<BigUint64Array<ArrayBuffer>>;
 /**

package/dist/backends/store/fs.d.ts

@@ -63,18 +63,18 @@ export declare class StoreFS<T extends Store = Store> extends FileSystem {
      */
     rename(oldPath: string, newPath: string): Promise<void>;
     renameSync(oldPath: string, newPath: string): void;
-    stat(path: string): Promise<InodeLike>;
-    statSync(path: string): InodeLike;
+    stat(path: string): Promise<Inode>;
+    statSync(path: string): Inode;
     touch(path: string, metadata: Partial<InodeLike>): Promise<void>;
     touchSync(path: string, metadata: Partial<InodeLike>): void;
-    createFile(path: string, options: CreationOptions): Promise<InodeLike>;
-    createFileSync(path: string, options: CreationOptions): InodeLike;
+    createFile(path: string, options: CreationOptions): Promise<Inode>;
+    createFileSync(path: string, options: CreationOptions): Inode;
     unlink(path: string): Promise<void>;
     unlinkSync(path: string): void;
     rmdir(path: string): Promise<void>;
     rmdirSync(path: string): void;
-    mkdir(path: string, options: CreationOptions): Promise<InodeLike>;
-    mkdirSync(path: string, options: CreationOptions): InodeLike;
+    mkdir(path: string, options: CreationOptions): Promise<Inode>;
+    mkdirSync(path: string, options: CreationOptions): Inode;
     readdir(path: string): Promise<string[]>;
     readdirSync(path: string): string[];
     /**

package/dist/backends/store/fs.js

@@ -454,12 +454,10 @@ export class StoreFS extends FileSystem {
         }
     }
     async createFile(path, options) {
-        options.mode |= S_IFREG;
-        return await this.commitNew(path, options, new Uint8Array());
+        return await this.commitNew(path, { ...options, mode: options.mode | S_IFREG }, new Uint8Array());
     }
     createFileSync(path, options) {
-        options.mode |= S_IFREG;
-        return this.commitNewSync(path, options, new Uint8Array());
+        return this.commitNewSync(path, { ...options, mode: options.mode | S_IFREG }, new Uint8Array());
     }
     async unlink(path) {
         return this.remove(path, false);
@@ -478,12 +476,10 @@ export class StoreFS extends FileSystem {
         this.removeSync(path, true);
     }
     async mkdir(path, options) {
-        options.mode |= S_IFDIR;
-        return await this.commitNew(path, options, encodeUTF8('{}'));
+        return await this.commitNew(path, { ...options, mode: options.mode | S_IFDIR }, encodeUTF8('{}'));
     }
     mkdirSync(path, options) {
-        options.mode |= S_IFDIR;
-        return this.commitNewSync(path, options, encodeUTF8('{}'));
+        return this.commitNewSync(path, { ...options, mode: options.mode | S_IFDIR }, encodeUTF8('{}'));
     }
     async readdir(path) {
         const env_11 = { stack: [], error: void 0, hasError: false };
@@ -618,13 +614,17 @@ export class StoreFS extends FileSystem {
         try {
             const tx = __addDisposableResource(env_17, this.transaction(), true);
             const inode = await this.findInode(tx, path);
+            const end = offset + data.byteLength;
             let buffer = data;
             if (!tx.flag('partial')) {
-                buffer = extendBuffer((await tx.get(inode.data)) ?? new Uint8Array(), offset + data.byteLength);
+                buffer = extendBuffer((await tx.get(inode.data)) ?? new Uint8Array(), end);
                 buffer.set(data, offset);
                 offset = 0;
             }
             await tx.set(inode.data, buffer, offset);
+            // Update the inode in the same transaction, so data and metadata can not get out of sync (#286)
+            inode.update({ size: Math.max(inode.size, end), mtimeMs: Date.now() });
+            await tx.set(inode.ino, inode);
             this._add(inode.ino, path);
             await tx.commit();
         }
@@ -643,13 +643,17 @@ export class StoreFS extends FileSystem {
         try {
             const tx = __addDisposableResource(env_18, this.transaction(), false);
             const inode = this.findInodeSync(tx, path);
+            const end = offset + data.byteLength;
             let buffer = data;
             if (!tx.flag('partial')) {
-                buffer = extendBuffer(tx.getSync(inode.data) ?? new Uint8Array(), offset + data.byteLength);
+                buffer = extendBuffer(tx.getSync(inode.data) ?? new Uint8Array(), end);
                 buffer.set(data, offset);
                 offset = 0;
             }
             tx.setSync(inode.data, buffer, offset);
+            // Update the inode in the same transaction, so data and metadata can not get out of sync (#286)
+            inode.update({ size: Math.max(inode.size, end), mtimeMs: Date.now() });
+            tx.setSync(inode.ino, inode);
             this._add(inode.ino, path);
             tx.commitSync();
         }

package/dist/internal/devices.d.ts

@@ -103,18 +103,18 @@ export declare class DeviceFS extends StoreFS<InMemoryStore> {
     constructor();
     rename(oldPath: string, newPath: string): Promise<void>;
     renameSync(oldPath: string, newPath: string): void;
-    stat(path: string): Promise<InodeLike>;
-    statSync(path: string): InodeLike;
+    stat(path: string): Promise<Inode>;
+    statSync(path: string): Inode;
     touch(path: string, metadata: InodeLike): Promise<void>;
     touchSync(path: string, metadata: InodeLike): void;
-    createFile(path: string, options: CreationOptions): Promise<InodeLike>;
-    createFileSync(path: string, options: CreationOptions): InodeLike;
+    createFile(path: string, options: CreationOptions): Promise<Inode>;
+    createFileSync(path: string, options: CreationOptions): Inode;
     unlink(path: string): Promise<void>;
     unlinkSync(path: string): void;
     rmdir(path: string): Promise<void>;
     rmdirSync(path: string): void;
-    mkdir(path: string, options: CreationOptions): Promise<InodeLike>;
-    mkdirSync(path: string, options: CreationOptions): InodeLike;
+    mkdir(path: string, options: CreationOptions): Promise<Inode>;
+    mkdirSync(path: string, options: CreationOptions): Inode;
     readdir(path: string): Promise<string[]>;
     readdirSync(path: string): string[];
     link(target: string, link: string): Promise<void>;

package/dist/internal/filesystem.d.ts

@@ -91,21 +91,21 @@ export interface FileSystemAttributes {
  * @category Internals
  * @internal
  */
-export interface CreationOptions extends Partial<InodeLike> {
+export interface CreationOptions extends Readonly<Partial<InodeLike>> {
     /**
      * The uid to create the file.
      * This is ignored if the FS supports setuid and the setuid bit is set
      */
-    uid: number;
+    readonly uid: number;
     /**
      * The gid to create the file.
      * This is ignored if the FS supports setgid and the setgid bit is set
      */
-    gid: number;
+    readonly gid: number;
     /**
      * The mode to create the file with.
      */
-    mode: number;
+    readonly mode: number;
 }
 /**
  * Options for streaming operations

package/dist/internal/index_fs.d.ts

@@ -28,12 +28,12 @@ export declare abstract class IndexFS extends FileSystem {
     rmdir(path: string): Promise<void>;
     rmdirSync(path: string): void;
     protected create(path: string, options: CreationOptions): Inode;
-    createFile(path: string, options: CreationOptions): Promise<InodeLike>;
-    createFileSync(path: string, options: CreationOptions): InodeLike;
+    createFile(path: string, options: CreationOptions): Promise<Inode>;
+    createFileSync(path: string, options: CreationOptions): Inode;
     protected _mkdir?(path: string, options: CreationOptions): Promise<void>;
     protected _mkdirSync?(path: string, options: CreationOptions): void;
-    mkdir(path: string, options: CreationOptions): Promise<InodeLike>;
-    mkdirSync(path: string, options: CreationOptions): InodeLike;
+    mkdir(path: string, options: CreationOptions): Promise<Inode>;
+    mkdirSync(path: string, options: CreationOptions): Inode;
     link(target: string, link: string): Promise<void>;
     linkSync(target: string, link: string): void;
     readdir(path: string): Promise<string[]>;

package/dist/internal/index_fs.js

@@ -94,13 +94,13 @@ export class IndexFS extends FileSystem {
         const inode = this.index.get(path);
         if (!inode)
             throw withErrno('ENOENT');
-        return inode;
+        return new Inode(inode);
     }
     statSync(path) {
         const inode = this.index.get(path);
         if (!inode)
             throw withErrno('ENOENT');
-        return inode;
+        return new Inode(inode);
     }
     async touch(path, metadata) {
         const inode = this.index.get(path) ?? _throw(withErrno('ENOENT'));
@@ -165,21 +165,19 @@ export class IndexFS extends FileSystem {
         return inode;
     }
     async createFile(path, options) {
-        options.mode |= S_IFREG;
-        return this.create(path, options);
+        return this.create(path, { ...options, mode: options.mode | S_IFREG });
     }
     createFileSync(path, options) {
-        options.mode |= S_IFREG;
-        return this.create(path, options);
+        return this.create(path, { ...options, mode: options.mode | S_IFREG });
     }
     async mkdir(path, options) {
-        options.mode |= S_IFDIR;
+        options = { ...options, mode: options.mode | S_IFDIR };
         const inode = this.create(path, options);
         await this._mkdir?.(path, options);
         return inode;
     }
     mkdirSync(path, options) {
-        options.mode |= S_IFDIR;
+        options = { ...options, mode: options.mode | S_IFDIR };
         const inode = this.create(path, options);
         this._mkdirSync?.(path, options);
         return inode;

package/dist/internal/inode.js

@@ -451,6 +451,9 @@ let Inode = (() => {
                 data = args[0];
                 args = [sizeof(Inode)];
             }
+            if (args[0] instanceof Inode) {
+                args = [new Uint8Array(args[0].buffer, args[0].byteOffset, args[0].byteLength)];
+            }
             super(...args);
             __runInitializers(this, ___data_extraInitializers);
             if (this.byteLength < sizeof(Inode)) {

package/dist/node/async.js

@@ -373,7 +373,7 @@ export function watchFile(path, options, listener) {
             listener(curr, prev);
         }
     });
-    statWatchers.set(normalizedPath, { watcher, listeners: new Set() });
+    statWatchers.set(normalizedPath, { watcher, listeners: new Set([listener]) });
 }
 watchFile;
 /**

package/dist/node/dir.d.ts

@@ -22,9 +22,11 @@ export declare class Dirent<Name extends string | Buffer = string> implements _D
      */
     get path(): string;
     /**
+     * `vfs.path` is relative to the directory that was read,
+     * so `parentPath` is resolved against it— like Node does.
      * @internal
      */
-    static from(vfs: VFSDirent, encoding?: BufferEncoding | 'buffer' | null): Dirent<string>;
+    static from(vfs: VFSDirent, encoding?: BufferEncoding | 'buffer' | null, parentPath?: string): Dirent<string>;
     isFile(): boolean;
     isDirectory(): boolean;
     isBlockDevice(): boolean;

package/dist/node/dir.js

@@ -1,7 +1,6 @@
 import { Buffer } from 'buffer';
-import { withErrno } from 'kerium';
 import { warn } from 'kerium/log';
-import { parse } from '../path.js';
+import { join, parse } from '../path.js';
 import { DirType } from '../vfs/dir.js';
 import { readdir } from './promises.js';
 import { readdirSync } from './sync.js';
@@ -32,12 +31,14 @@ export class Dirent {
         return this._parentPath;
     }
     /**
+     * `vfs.path` is relative to the directory that was read,
+     * so `parentPath` is resolved against it— like Node does.
      * @internal
      */
-    static from(vfs, encoding) {
+    static from(vfs, encoding, parentPath = '.') {
         const dirent = new Dirent();
         const { base, dir } = parse(vfs.path);
-        dirent._parentPath = dir || '.';
+        dirent._parentPath = join(parentPath, dir);
         dirent._name = base;
         dirent.ino = vfs.ino;
         dirent.type = vfs.type;
@@ -66,6 +67,14 @@ export class Dirent {
         return this.type === DirType.SOCK;
     }
 }
+/**
+ * Thrown when a `Dir` is used after it has been closed.
+ * Note this is a plain `Error` with a Node error code, not an `Exception`.
+ * @internal @hidden
+ */
+function dirClosed() {
+    return Object.assign(new Error('Directory handle was closed'), { code: 'ERR_DIR_CLOSED' });
+}
 /**
  * A class representing a directory stream.
  */
@@ -75,7 +84,7 @@ export class Dir {
     closed = false;
     checkClosed() {
         if (this.closed)
-            throw withErrno('EBADF', 'Can not use closed Dir');
+            throw dirClosed();
     }
     _entries;
     constructor(path, context) {
@@ -83,6 +92,13 @@ export class Dir {
         this.context = context;
     }
     close(cb) {
+        if (this.closed) {
+            const error = dirClosed();
+            if (!cb)
+                return Promise.reject(error);
+            cb(error);
+            return;
+        }
         this.closed = true;
         if (!cb) {
             return Promise.resolve();
@@ -94,6 +110,8 @@ export class Dir {
      * Subsequent reads will result in errors.
      */
     closeSync() {
+        if (this.closed)
+            throw dirClosed();
         this.closed = true;
     }
     async _read() {

package/dist/node/promises.d.ts

@@ -18,8 +18,10 @@ import { ReadStream, WriteStream } from './streams.js';
 export * as constants from '../constants.js';
 export declare class FileHandle implements promises.FileHandle {
     protected context: V_Context;
-    readonly fd: number;
     protected vfs: Handle;
+    protected _fd: number;
+    /** The file descriptor, or -1 once the handle has been closed */
+    get fd(): number;
     constructor(context: V_Context, fd: number);
     private _emitChange;
     /**
@@ -239,7 +241,7 @@ export declare function writeFile(this: V_Context, path: fs.PathLike | promises.
  * @option mode Defaults to `0644`.
  * @option flag Defaults to `'a'`.
  */
-export declare function appendFile(this: V_Context, path: fs.PathLike | promises.FileHandle, data: FileContents, _options?: BufferEncoding | (fs.EncodingOption & {
+export declare function appendFile(this: V_Context, path: fs.PathLike | promises.FileHandle, data: FileContents | Iterable<string | ArrayBufferView> | AsyncIterable<string | ArrayBufferView>, _options?: BufferEncoding | (fs.EncodingOption & {
     mode?: fs.Mode;
     flag?: fs.OpenMode;
 }) | null): Promise<void>;