@zenfs/core 1.11.4 → 2.1.0

package/dist/internal/filesystem.d.ts

@@ -1,6 +1,6 @@
+import type { UUID } from 'node:crypto';
 import type { ConstMap } from 'utilium';
-import type { Stats, StatsLike } from '../stats.js';
-import type { File } from './file.js';
+import type { InodeLike } from './inode.js';
 /**
  * Usage information about a file system
  * @category Internals
@@ -29,46 +29,6 @@ export interface UsageInfo {
      */
     freeNodes?: number;
 }
-/**
- * Metadata about a FileSystem
- * @category Internals
- * @deprecated
- */
-export interface FileSystemMetadata extends UsageInfo {
-    /**
-     * The name of the FS
-     * @deprecated Use `FileSystem#name`
-     */
-    name: string;
-    /**
-     * Whether the FS is readonly or not
-     * @deprecated Use `FileSystem#attributes
-     */
-    readonly: boolean;
-    /**
-     * If set, disables File from using a resizable array buffer.
-     * @default false
-     * @deprecated Use `FileSystem#attributes`
-     */
-    noResizableBuffers: boolean;
-    /**
-     * If set, disables caching on async file systems.
-     * This means *sync operations will not work*.
-     * It has no affect on sync file systems.
-     * @default false
-     * @deprecated Use `FileSystem#attributes
-     */
-    noAsyncCache: boolean;
-    /**
-     * The type of the FS
-     */
-    type: number;
-    /**
-     * Various features the file system supports.
-     * @deprecated Use `FileSystem#attributes`
-     */
-    features?: unknown[];
-}
 /**
  * Attributes that control how the file system interacts with the VFS.
  * No options are set by default.
@@ -76,24 +36,22 @@ export interface FileSystemMetadata extends UsageInfo {
  * @internal
  */
 export type FileSystemAttributes = {
-    /** The FS supports setuid and setgid when creating files and directories. */
-    setid: void;
-    /** If set, disables `PreloadFile` from using a resizable array buffer. */
-    no_buffer_resize: void;
     /**
      * If set disables async file systems from preloading their contents.
      * This means *sync operations will not work* (unless the contents are cached)
      * It has no affect on sync file systems.
      */
-    no_async: void;
+    no_async_preload: void;
     /**
      * Currently unused. In the future, this will disable caching.
-     * Not recommended due to performance impact.
+     * Analogous to `S_DAX` on every file.
      */
     no_cache: void;
     /**
      * If set, the file system should not be written to.
      * This should be set for read-only file systems.
+     * Note this does NOT trigger EROFS errors;
+     * writes will silently be dropped.
      */
     no_write: void;
     /**
@@ -106,15 +64,29 @@ export type FileSystemAttributes = {
      * @internal
      */
     default_stream_write: void;
+    /**
+     * Do not update access times.
+     */
+    no_atime: void;
+    /**
+     * Ignore suid and sgid bits.
+     * @todo Implement
+     * @experimental
+     */
+    no_suid: void;
+    /**
+     * Writes are synced at once
+     * @experimental
+     */
+    sync: void;
 };
 /**
  * Options used when creating files and directories.
  * This weird naming and such is to preserve backward compatibility.
- * @todo [BREAKING] Move the `mode` parameter of `createFile` and `mkdir` into this
  * @category Internals
  * @internal
  */
-export interface CreationOptions {
+export interface CreationOptions extends Partial<InodeLike> {
     /**
      * The uid to create the file.
      * This is ignored if the FS supports setuid and the setuid bit is set
@@ -125,23 +97,14 @@ export interface CreationOptions {
      * This is ignored if the FS supports setgid and the setgid bit is set
      */
     gid: number;
-    /**
-     * The mode to create the file with.
-     */
-    mode?: number;
-}
-/**
- * This is the correct type that will be used when the API is updated in a breaking release
- * @category Internals
- * @internal
- */
-export interface PureCreationOptions extends CreationOptions {
     /**
      * The mode to create the file with.
      */
     mode: number;
 }
 /**
+ * Options for streaming operations
+ * @category Internals
  * @internal
  */
 export interface StreamOptions {
@@ -160,7 +123,7 @@ export declare abstract class FileSystem {
      * A unique ID for this kind of file system.
      * Currently unused internally, but could be used for partition tables or something
      */
-    readonly id: number;
+    readonly type: number;
     /**
      * The name for this file system.
      * For example, tmpfs for an in memory one
@@ -172,6 +135,13 @@ export declare abstract class FileSystem {
      * @internal @protected
      */
     _mountPoint?: string;
+    /**
+     * The UUID of the file system.
+     * @privateRemarks This is only used by `ioctl`
+     * @internal @protected
+     */
+    _uuid: UUID;
+    get uuid(): UUID;
     /**
      * @see FileSystemAttributes
      */
@@ -181,7 +151,7 @@ export declare abstract class FileSystem {
      * A unique ID for this kind of file system.
      * Currently unused internally, but could be used for partition tables or something
      */
-    id: number, 
+    type: number, 
     /**
      * The name for this file system.
      * For example, tmpfs for an in memory one
@@ -194,42 +164,29 @@ export declare abstract class FileSystem {
      * @experimental
      */
     usage(): UsageInfo;
-    /**
-     * Get metadata about the current file system
-     * @deprecated
-     */
-    metadata(): FileSystemMetadata;
     ready(): Promise<void>;
     abstract rename(oldPath: string, newPath: string): Promise<void>;
     abstract renameSync(oldPath: string, newPath: string): void;
-    abstract stat(path: string): Promise<Stats>;
-    abstract statSync(path: string): Stats;
-    /**
-     * Opens the file at `path` with `flag`. The file must exist.
-     * @param path The path to open.
-     * @param flag The flag to use when opening the file.
-     */
-    abstract openFile(path: string, flag: string): Promise<File>;
-    /**
-     * Opens the file at `path` with `flag`. The file must exist.
-     * @param path The path to open.
-     * @param flag The flag to use when opening the file.
-     */
-    abstract openFileSync(path: string, flag: string): File;
+    abstract stat(path: string): Promise<InodeLike>;
+    abstract statSync(path: string): InodeLike;
+    /** Modify metadata. */
+    abstract touch(path: string, metadata: Partial<InodeLike>): Promise<void>;
+    /** Modify metadata. */
+    abstract touchSync(path: string, metadata: Partial<InodeLike>): void;
     /**
-     * Create the file at `path` with the given options. Then, open it with `flag`.
+     * Create the file at `path` with the given options.
      */
-    abstract createFile(path: string, flag: string, mode: number, options: CreationOptions): Promise<File>;
+    abstract createFile(path: string, options: CreationOptions): Promise<InodeLike>;
     /**
-     * Create the file at `path` with the given options. Then, open it with `flag`.
+     * Create the file at `path` with the given options.
      */
-    abstract createFileSync(path: string, flag: string, mode: number, options: CreationOptions): File;
+    abstract createFileSync(path: string, options: CreationOptions): InodeLike;
     abstract unlink(path: string): Promise<void>;
     abstract unlinkSync(path: string): void;
     abstract rmdir(path: string): Promise<void>;
     abstract rmdirSync(path: string): void;
-    abstract mkdir(path: string, mode: number, options: CreationOptions): Promise<void>;
-    abstract mkdirSync(path: string, mode: number, options: CreationOptions): void;
+    abstract mkdir(path: string, options: CreationOptions): Promise<InodeLike>;
+    abstract mkdirSync(path: string, options: CreationOptions): InodeLike;
     abstract readdir(path: string): Promise<string[]>;
     abstract readdirSync(path: string): string[];
     /**
@@ -242,22 +199,22 @@ export declare abstract class FileSystem {
     existsSync(path: string): boolean;
     abstract link(target: string, link: string): Promise<void>;
     abstract linkSync(target: string, link: string): void;
-    abstract sync(path: string, data?: Uint8Array, stats?: Readonly<Partial<StatsLike>>): Promise<void>;
-    abstract syncSync(path: string, data?: Uint8Array, stats?: Readonly<Partial<StatsLike>>): void;
+    abstract sync(): Promise<void>;
+    abstract syncSync(): void;
     /**
      * Reads into a buffer
      * @param buffer The buffer to read into. You must set the `byteOffset` and `byteLength` appropriately!
-     * @param offset The offset into the file to start reading from
+     * @param start The offset into the file to start reading from
      * @param end The position in the file to stop reading
      */
-    abstract read(path: string, buffer: Uint8Array, offset: number, end: number): Promise<void>;
+    abstract read(path: string, buffer: Uint8Array, start: number, end: number): Promise<void>;
     /**
      * Reads into a buffer
      * @param buffer The buffer to read into. You must set the `byteOffset` and `byteLength` appropriately!
-     * @param offset The offset into the file to start reading from
+     * @param start The offset into the file to start reading from
      * @param end The position in the file to stop reading
      */
-    abstract readSync(path: string, buffer: Uint8Array, offset: number, end: number): void;
+    abstract readSync(path: string, buffer: Uint8Array, start: number, end: number): void;
     /**
      * Writes a buffer to a file
      * @param buffer The buffer to write. You must set the `byteOffset` and `byteLength` appropriately!

package/dist/internal/filesystem.js

@@ -7,19 +7,28 @@ const _chunkSize = 0x1000;
  * @internal
  */
 export class FileSystem {
+    get uuid() {
+        return this._uuid;
+    }
     constructor(
     /**
      * A unique ID for this kind of file system.
      * Currently unused internally, but could be used for partition tables or something
      */
-    id, 
+    type, 
     /**
      * The name for this file system.
      * For example, tmpfs for an in memory one
      */
     name) {
-        this.id = id;
+        this.type = type;
         this.name = name;
+        /**
+         * The UUID of the file system.
+         * @privateRemarks This is only used by `ioctl`
+         * @internal @protected
+         */
+        this._uuid = crypto.randomUUID();
         /**
          * @see FileSystemAttributes
          */
@@ -44,23 +53,6 @@ export class FileSystem {
             freeSpace: 0,
         };
     }
-    /* node:coverage disable */
-    /**
-     * Get metadata about the current file system
-     * @deprecated
-     */
-    metadata() {
-        return {
-            ...this.usage(),
-            name: this.name,
-            readonly: this.attributes.has('no_write'),
-            noResizableBuffers: this.attributes.has('no_buffer_resize'),
-            noAsyncCache: this.attributes.has('no_async'),
-            features: Array.from(this.attributes.keys()),
-            type: this.id,
-        };
-    }
-    /* node:coverage enable */
     async ready() { }
     /**
      * Test whether or not `path` exists.
@@ -115,8 +107,17 @@ export class FileSystem {
         let position = (_a = options.start) !== null && _a !== void 0 ? _a : 0;
         return new WritableStream({
             write: async (chunk, controller) => {
-                await this.write(path, chunk, position).catch(controller.error.bind(controller));
+                let err = false;
+                const _err = (ex) => {
+                    err = true;
+                    controller.error(ex);
+                };
+                const { size } = await this.stat(path);
+                await this.write(path, chunk, position).catch(_err);
+                if (err)
+                    return;
                 position += chunk.byteLength;
+                await this.touch(path, { mtimeMs: Date.now(), size: Math.max(size, position) }).catch(_err);
             },
         });
     }

package/dist/internal/index.d.ts

@@ -1,9 +1,8 @@
+export { log } from 'kerium';
 export * from './credentials.js';
 export * from './devices.js';
 export * from './error.js';
 export * from './file_index.js';
-export * from './file.js';
 export * from './filesystem.js';
 export * from './index_fs.js';
 export * from './inode.js';
-export * as log from './log.js';

package/dist/internal/index.js

@@ -1,9 +1,8 @@
+export { log } from 'kerium'; // DO NOT USE
 export * from './credentials.js';
 export * from './devices.js';
 export * from './error.js';
 export * from './file_index.js';
-export * from './file.js';
 export * from './filesystem.js';
 export * from './index_fs.js';
 export * from './inode.js';
-export * as log from './log.js';

package/dist/internal/index_fs.d.ts

@@ -1,7 +1,5 @@
-import { Stats } from '../stats.js';
-import { type File } from './file.js';
 import { Index } from './file_index.js';
-import { FileSystem, type CreationOptions, type PureCreationOptions, type UsageInfo } from './filesystem.js';
+import { FileSystem, type CreationOptions, type UsageInfo } from './filesystem.js';
 import { Inode, type InodeLike } from './inode.js';
 /**
  * A file system that uses an `Index` for metadata.
@@ -12,24 +10,16 @@ export declare abstract class IndexFS extends FileSystem {
     readonly index: Index;
     constructor(id: number, name: string, index?: Index);
     usage(): UsageInfo;
-    /**
-     * @deprecated
-     */
-    reloadFiles(): never;
-    /**
-     * @deprecated
-     */
-    reloadFilesSync(): never;
     /**
      * Finds all the paths in the index that need to be moved for a rename
      */
     private pathsForRename;
     rename(oldPath: string, newPath: string): Promise<void>;
     renameSync(oldPath: string, newPath: string): void;
-    stat(path: string): Promise<Stats>;
-    statSync(path: string): Stats;
-    openFile(path: string, flag: string): Promise<File>;
-    openFileSync(path: string, flag: string): File;
+    stat(path: string): Promise<Inode>;
+    statSync(path: string): Inode;
+    touch(path: string, metadata: InodeLike): Promise<void>;
+    touchSync(path: string, metadata: InodeLike): void;
     protected _remove(path: string, isUnlink: boolean): void;
     protected abstract remove(path: string): Promise<void>;
     protected abstract removeSync(path: string): void;
@@ -37,23 +27,15 @@ export declare abstract class IndexFS extends FileSystem {
     unlinkSync(path: string): void;
     rmdir(path: string): Promise<void>;
     rmdirSync(path: string): void;
-    protected create(path: string, options: PureCreationOptions): Inode;
-    createFile(path: string, flag: string, mode: number, options: CreationOptions): Promise<File>;
-    createFileSync(path: string, flag: string, mode: number, options: CreationOptions): File;
-    mkdir(path: string, mode: number, options: CreationOptions): Promise<void>;
-    mkdirSync(path: string, mode: number, options: CreationOptions): void;
+    protected create(path: string, options: CreationOptions): Inode;
+    createFile(path: string, options: CreationOptions): Promise<InodeLike>;
+    createFileSync(path: string, options: CreationOptions): InodeLike;
+    mkdir(path: string, options: CreationOptions): Promise<InodeLike>;
+    mkdirSync(path: string, options: CreationOptions): InodeLike;
     link(target: string, link: string): Promise<void>;
     linkSync(target: string, link: string): void;
     readdir(path: string): Promise<string[]>;
     readdirSync(path: string): string[];
-    /**
-     * Optional hook for implementations to support updating metadata
-     */
-    protected syncMetadata?(path: string, metadata: Readonly<InodeLike>): Promise<void>;
-    sync(path: string, data?: Uint8Array, stats?: Readonly<InodeLike>): Promise<void>;
-    /**
-     * Optional hook for implementations to support updating metadata
-     */
-    protected syncMetadataSync?(path: string, metadata: Readonly<InodeLike>): void;
-    syncSync(path: string, data?: Uint8Array, stats?: Readonly<InodeLike>): void;
+    sync(): Promise<void>;
+    syncSync(): void;
 }

package/dist/internal/index_fs.js

@@ -1,10 +1,8 @@
 /* eslint-disable @typescript-eslint/require-await */
+import { withErrno } from 'kerium';
 import { _throw } from 'utilium';
-import { Stats } from '../stats.js';
+import { dirname, join, relative } from '../path.js';
 import { S_IFDIR, S_IFMT, S_IFREG, S_ISGID, S_ISUID } from '../vfs/constants.js';
-import { dirname, join, relative } from '../vfs/path.js';
-import { ErrnoError } from './error.js';
-import { LazyFile } from './file.js';
 import { Index } from './file_index.js';
 import { FileSystem } from './filesystem.js';
 import { Inode } from './inode.js';
@@ -21,28 +19,14 @@ export class IndexFS extends FileSystem {
     usage() {
         return this.index.usage();
     }
-    /* node:coverage disable */
-    /**
-     * @deprecated
-     */
-    reloadFiles() {
-        throw ErrnoError.With('ENOTSUP');
-    }
-    /**
-     * @deprecated
-     */
-    reloadFilesSync() {
-        throw ErrnoError.With('ENOTSUP');
-    }
-    /* node:coverage enable */
     /**
      * Finds all the paths in the index that need to be moved for a rename
      */
     pathsForRename(oldPath, newPath) {
         if (!this.index.has(oldPath))
-            throw ErrnoError.With('ENOENT', oldPath, 'rename');
+            throw withErrno('ENOENT');
         if ((dirname(newPath) + '/').startsWith(oldPath + '/'))
-            throw ErrnoError.With('EBUSY', dirname(oldPath), 'rename');
+            throw withErrno('EBUSY');
         const toRename = [];
         for (const [from, inode] of this.index.entries()) {
             const rel = relative(oldPath, from);
@@ -82,35 +66,36 @@ export class IndexFS extends FileSystem {
     async stat(path) {
         const inode = this.index.get(path);
         if (!inode)
-            throw ErrnoError.With('ENOENT', path, 'stat');
-        return new Stats(inode);
+            throw withErrno('ENOENT');
+        return inode;
     }
     statSync(path) {
         const inode = this.index.get(path);
         if (!inode)
-            throw ErrnoError.With('ENOENT', path, 'stat');
-        return new Stats(inode);
+            throw withErrno('ENOENT');
+        return inode;
     }
-    async openFile(path, flag) {
+    async touch(path, metadata) {
         var _a;
-        const stats = (_a = this.index.get(path)) !== null && _a !== void 0 ? _a : _throw(ErrnoError.With('ENOENT', path, 'openFile'));
-        return new LazyFile(this, path, flag, stats);
+        const inode = (_a = this.index.get(path)) !== null && _a !== void 0 ? _a : _throw(withErrno('ENOENT'));
+        inode.update(metadata);
     }
-    openFileSync(path, flag) {
+    touchSync(path, metadata) {
         var _a;
-        const stats = (_a = this.index.get(path)) !== null && _a !== void 0 ? _a : _throw(ErrnoError.With('ENOENT', path, 'openFile'));
-        return new LazyFile(this, path, flag, stats);
+        const inode = (_a = this.index.get(path)) !== null && _a !== void 0 ? _a : _throw(withErrno('ENOENT'));
+        inode.update(metadata);
     }
     _remove(path, isUnlink) {
-        const syscall = isUnlink ? 'unlink' : 'rmdir';
         const inode = this.index.get(path);
         if (!inode)
-            throw ErrnoError.With('ENOENT', path, syscall);
+            throw withErrno('ENOENT');
         const isDir = (inode.mode & S_IFMT) == S_IFDIR;
         if (!isDir && !isUnlink)
-            throw ErrnoError.With('ENOTDIR', path, syscall);
+            throw withErrno('ENOTDIR');
         if (isDir && isUnlink)
-            throw ErrnoError.With('EISDIR', path, syscall);
+            throw withErrno('EISDIR');
+        if (isDir && this.readdirSync(path).length)
+            throw withErrno('ENOTEMPTY');
         this.index.delete(path);
     }
     async unlink(path) {
@@ -130,12 +115,11 @@ export class IndexFS extends FileSystem {
         this.removeSync(path);
     }
     create(path, options) {
-        const syscall = (options.mode & S_IFMT) == S_IFDIR ? 'mkdir' : 'createFile';
         if (this.index.has(path))
-            throw ErrnoError.With('EEXIST', path, syscall);
+            throw withErrno('EEXIST');
         const parent = this.index.get(dirname(path));
         if (!parent)
-            throw ErrnoError.With('ENOENT', dirname(path), syscall);
+            throw withErrno('ENOENT');
         const id = this.index._alloc();
         const inode = new Inode({
             ino: id,
@@ -148,25 +132,27 @@ export class IndexFS extends FileSystem {
         this.index.set(path, inode);
         return inode;
     }
-    async createFile(path, flag, mode, options) {
-        const node = this.create(path, { mode: mode | S_IFREG, ...options });
-        return new LazyFile(this, path, flag, node.toStats());
+    async createFile(path, options) {
+        options.mode |= S_IFREG;
+        return this.create(path, options);
     }
-    createFileSync(path, flag, mode, options) {
-        const node = this.create(path, { mode: mode | S_IFREG, ...options });
-        return new LazyFile(this, path, flag, node.toStats());
+    createFileSync(path, options) {
+        options.mode |= S_IFREG;
+        return this.create(path, options);
     }
-    async mkdir(path, mode, options) {
-        this.create(path, { mode: mode | S_IFDIR, ...options });
+    async mkdir(path, options) {
+        options.mode |= S_IFDIR;
+        return this.create(path, options);
     }
-    mkdirSync(path, mode, options) {
-        this.create(path, { mode: mode | S_IFDIR, ...options });
+    mkdirSync(path, options) {
+        options.mode |= S_IFDIR;
+        return this.create(path, options);
     }
     link(target, link) {
-        throw ErrnoError.With('ENOSYS', link, 'link');
+        throw withErrno('ENOSYS');
     }
     linkSync(target, link) {
-        throw ErrnoError.With('ENOSYS', link, 'link');
+        throw withErrno('ENOSYS');
     }
     async readdir(path) {
         return Object.keys(this.index.directoryEntries(path));
@@ -174,24 +160,6 @@ export class IndexFS extends FileSystem {
     readdirSync(path) {
         return Object.keys(this.index.directoryEntries(path));
     }
-    async sync(path, data, stats) {
-        var _a;
-        const inode = this.index.get(path);
-        if (!inode)
-            throw ErrnoError.With('ENOENT', path, 'sync');
-        if (inode.update(stats))
-            await ((_a = this.syncMetadata) === null || _a === void 0 ? void 0 : _a.call(this, path, stats));
-        if (data)
-            await this.write(path, data, 0);
-    }
-    syncSync(path, data, stats) {
-        var _a;
-        const inode = this.index.get(path);
-        if (!inode)
-            throw ErrnoError.With('ENOENT', path, 'sync');
-        if (inode.update(stats))
-            (_a = this.syncMetadataSync) === null || _a === void 0 ? void 0 : _a.call(this, path, stats);
-        if (data)
-            this.writeSync(path, data, 0);
-    }
+    async sync() { }
+    syncSync() { }
 }