@zenfs/core 2.5.8 → 2.6.1

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
      */
@@ -114,11 +127,15 @@ export declare class CopyOnWriteFS extends FileSystem {
      * Helper function:
      * - Ensures p is on writable before proceeding. Throws an error if it doesn't exist.
      * - Calls f to perform operation on writable.
+     *
+     * `keep` is the size the file is about to be truncated to, when the caller knows it.
+     * Bytes past it are discarded by the operation that follows, so they are not worth copying up.
      */
     private copyForWriteSync;
     private copyForWrite;
     /**
      * Copy from readable to writable storage.
+     * Only `[0, keep)` is copied; the caller is responsible for setting the final size.
      * PRECONDITION: File does not exist on writable storage.
      */
     private copyToWritableSync;

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,42 +179,43 @@ 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) {
-        await this.copyForWrite(path);
+        await this.copyForWrite(path, metadata.size);
         await this.writable.touch(path, metadata);
     }
     touchSync(path, metadata) {
-        this.copyForWriteSync(path);
+        this.copyForWriteSync(path, metadata.size);
         this.writable.touchSync(path, metadata);
     }
     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)))
@@ -323,32 +360,36 @@ export class CopyOnWriteFS extends FileSystem {
      * Helper function:
      * - Ensures p is on writable before proceeding. Throws an error if it doesn't exist.
      * - Calls f to perform operation on writable.
+     *
+     * `keep` is the size the file is about to be truncated to, when the caller knows it.
+     * Bytes past it are discarded by the operation that follows, so they are not worth copying up.
      */
-    copyForWriteSync(path) {
+    copyForWriteSync(path, keep) {
         if (!this.existsSync(path))
             throw withErrno('ENOENT');
         if (!this.writable.existsSync(dirname(path))) {
             this.createParentDirectoriesSync(path);
         }
         if (!this.writable.existsSync(path)) {
-            this.copyToWritableSync(path);
+            this.copyToWritableSync(path, keep);
         }
     }
-    async copyForWrite(path) {
+    async copyForWrite(path, keep) {
         if (!(await this.exists(path)))
             throw withErrno('ENOENT');
         if (!(await this.writable.exists(dirname(path)))) {
             await this.createParentDirectories(path);
         }
         if (!(await this.writable.exists(path))) {
-            return this.copyToWritable(path);
+            return this.copyToWritable(path, keep);
         }
     }
     /**
      * Copy from readable to writable storage.
+     * Only `[0, keep)` is copied; the caller is responsible for setting the final size.
      * PRECONDITION: File does not exist on writable storage.
      */
-    copyToWritableSync(path) {
+    copyToWritableSync(path, keep) {
         const stats = this.readable.statSync(path);
         if (isDirectory(stats)) {
             this.writable.mkdirSync(path, stats);
@@ -357,13 +398,16 @@ export class CopyOnWriteFS extends FileSystem {
             }
             return;
         }
-        const data = new Uint8Array(stats.size);
-        this.readable.readSync(path, data, 0, data.byteLength);
+        const size = Math.min(stats.size, keep ?? stats.size);
+        const data = new Uint8Array(size);
+        if (size)
+            this.readable.readSync(path, data, 0, size);
         this.writable.createFileSync(path, stats);
         this.writable.touchSync(path, stats);
-        this.writable.writeSync(path, data, 0);
+        if (size)
+            this.writable.writeSync(path, data, 0);
     }
-    async copyToWritable(path) {
+    async copyToWritable(path, keep) {
         const stats = await this.readable.stat(path);
         if (isDirectory(stats)) {
             await this.writable.mkdir(path, stats);
@@ -372,11 +416,14 @@ export class CopyOnWriteFS extends FileSystem {
             }
             return;
         }
-        const data = new Uint8Array(stats.size);
-        await this.readable.read(path, data, 0, stats.size);
+        const size = Math.min(stats.size, keep ?? stats.size);
+        const data = new Uint8Array(size);
+        if (size)
+            await this.readable.read(path, data, 0, size);
         await this.writable.createFile(path, stats);
         await this.writable.touch(path, stats);
-        await this.writable.write(path, data, 0);
+        if (size)
+            await this.writable.write(path, data, 0);
     }
 }
 const _CopyOnWrite = {

package/dist/backends/fetch.d.ts

@@ -39,6 +39,10 @@ export declare class FetchFS extends IndexFS {
      * @internal @hidden
      */
     _asyncDone: Promise<unknown>;
+    /**
+     * Queue an async operation started from a sync method.
+     * Failures aren't rethrown to prevent further async ops from failing
+     */
     protected _async(p: Promise<unknown>): void;
     constructor(index: Index, baseUrl: string, requestInit?: RequestInit, remoteWrite?: boolean | undefined);
     protected remove(path: string): Promise<void>;

package/dist/backends/fetch.js

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: LGPL-3.0-or-later
 import { withErrno } from 'kerium';
-import { err, warn } from 'kerium/log';
+import { debug, err, warn } from 'kerium/log';
 import { decodeUTF8 } from 'utilium';
 import * as requests from 'utilium/requests';
 import { Index } from '../internal/file_index.js';
@@ -35,8 +35,12 @@ export class FetchFS extends IndexFS {
      * @internal @hidden
      */
     _asyncDone = Promise.resolve();
+    /**
+     * Queue an async operation started from a sync method.
+     * Failures aren't rethrown to prevent further async ops from failing
+     */
     _async(p) {
-        this._asyncDone = this._asyncDone.then(() => p);
+        this._asyncDone = this._asyncDone.then(() => p).catch(e => debug('Async operation failed: ' + (e.message ?? e)));
     }
     constructor(index, baseUrl, requestInit = {}, remoteWrite) {
         super(0x206e6673, 'nfs', index);
@@ -74,7 +78,7 @@ export class FetchFS extends IndexFS {
         if (!data)
             throw withErrno('ENODATA');
         if (missing.length) {
-            this._async(requests.get(this.baseUrl + path, { start: offset, end, size: inode.size, warn }));
+            this._async(requests.get(this.baseUrl + path, { start: offset, end, size: inode.size, warn }, this.requestInit));
             throw withErrno('EAGAIN');
         }
         buffer.set(data);

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

@@ -614,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();
         }
@@ -639,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/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/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;
     /**