@zenfs/core 0.12.2 → 0.12.3

package/dist/config.d.ts

@@ -6,7 +6,7 @@ import type { AbsolutePath } from './emulation/path.js';
 export type MountConfiguration<T extends Backend> = FilesystemOf<T> | BackendConfiguration<T> | T;
 /**
  * Retrieve a file system with the given configuration.
- * @param config A BackendConfig object.
+ * @see MountConfiguration
  */
 export declare function resolveMountConfig<T extends Backend>(config: MountConfiguration<T>, _depth?: number): Promise<FilesystemOf<T>>;
 type ConfigMounts = {

package/dist/config.js

@@ -8,7 +8,7 @@ function isMountConfig(arg) {
 }
 /**
  * Retrieve a file system with the given configuration.
- * @param config A BackendConfig object.
+ * @see MountConfiguration
  */
 export async function resolveMountConfig(config, _depth = 0) {
     if (typeof config !== 'object' || config == null) {

package/dist/cred.d.ts

@@ -1,6 +1,7 @@
 /**
  * Credentials used for various operations.
- * Similar to Linux's cred struct. See https://github.com/torvalds/linux/blob/master/include/linux/cred.h
+ * Similar to Linux's cred struct.
+ * @see https://github.com/torvalds/linux/blob/master/include/linux/cred.h
  */
 export interface Cred {
     uid: number;

package/dist/emulation/async.d.ts

@@ -6,7 +6,8 @@ import type * as fs from 'node:fs';
 import type { FileContents } from '../filesystem.js';
 import { BigIntStats, type Stats } from '../stats.js';
 import { type Callback } from '../utils.js';
-import { Dirent, type Dir } from './dir.js';
+import type { Dirent } from './dir.js';
+import { type Dir } from './dir.js';
 import * as promises from './promises.js';
 import { ReadStream, WriteStream } from './streams.js';
 /**

package/dist/emulation/promises.d.ts

@@ -12,7 +12,7 @@ import type { CreateReadStreamOptions, CreateWriteStreamOptions, FileChangeInfo,
 import type { Stream } from 'node:stream';
 import type { ReadableStream as TReadableStream } from 'node:stream/web';
 import type { Interface as ReadlineInterface } from 'readline';
-import { File } from '../file.js';
+import type { File } from '../file.js';
 import type { FileContents } from '../filesystem.js';
 import { BigIntStats, type Stats } from '../stats.js';
 import { Dir, Dirent } from './dir.js';

package/dist/emulation/promises.js

@@ -1,6 +1,6 @@
 import { Buffer } from 'buffer';
 import { Errno, ErrnoError } from '../error.js';
-import { ActionType, isAppendable, isReadable, isWriteable, parseFlag, pathExistsAction, pathNotExistsAction } from '../file.js';
+import { isAppendable, isExclusive, isReadable, isTruncating, isWriteable, parseFlag } from '../file.js';
 import { BigIntStats, FileType } from '../stats.js';
 import { normalizeMode, normalizeOptions, normalizePath, normalizeTime } from '../utils.js';
 import * as constants from './constants.js';
@@ -83,7 +83,7 @@ export class FileHandle {
             throw new ErrnoError(Errno.EINVAL, 'Encoding not specified');
         }
         const encodedData = typeof data == 'string' ? Buffer.from(data, options.encoding) : data;
-        await this.file.write(encodedData, 0, encodedData.length, null);
+        await this.file.write(encodedData, 0, encodedData.length);
     }
     /**
      * Asynchronously reads data from the file.
@@ -387,40 +387,32 @@ async function _open(path, _flag, _mode = 0o644, resolveSymlinks) {
     path = resolveSymlinks && (await exists(path)) ? await realpath(path) : path;
     const { fs, path: resolved } = resolveMount(path);
     if (!(await fs.exists(path, cred))) {
-        switch (pathNotExistsAction(flag)) {
-            case ActionType.CREATE:
-                // Ensure parent exists.
-                const parentStats = await fs.stat(dirname(resolved), cred);
-                if (parentStats && !parentStats.isDirectory()) {
-                    throw ErrnoError.With('ENOTDIR', dirname(path), '_open');
-                }
-                return new FileHandle(await fs.createFile(resolved, flag, mode, cred));
-            case ActionType.THROW:
-                throw ErrnoError.With('ENOENT', path, '_open');
-            default:
-                throw new ErrnoError(Errno.EINVAL, 'Invalid file flag');
+        if ((!isWriteable(flag) && !isAppendable(flag)) || flag == 'r+') {
+            throw ErrnoError.With('ENOENT', path, '_open');
         }
-    }
-    switch (pathExistsAction(flag)) {
-        case ActionType.THROW:
-            throw ErrnoError.With('EEXIST', path, '_open');
-        case ActionType.TRUNCATE:
-            /*
-                    In a previous implementation, we deleted the file and
-                    re-created it. However, this created a race condition if another
-                    asynchronous request was trying to read the file, as the file
-                    would not exist for a small period of time.
-                */
-            const file = await fs.openFile(resolved, flag, cred);
-            await file.truncate(0);
-            await file.sync();
-            return new FileHandle(file);
-        case ActionType.NOP:
-            // Must await so thrown errors are caught by the catch below
-            return new FileHandle(await fs.openFile(resolved, flag, cred));
-        default:
-            throw new ErrnoError(Errno.EINVAL, 'Invalid file flag');
-    }
+        // Create the file
+        const parentStats = await fs.stat(dirname(resolved), cred);
+        if (parentStats && !parentStats.isDirectory()) {
+            throw ErrnoError.With('ENOTDIR', dirname(path), '_open');
+        }
+        return new FileHandle(await fs.createFile(resolved, flag, mode, cred));
+    }
+    if (isExclusive(flag)) {
+        throw ErrnoError.With('EEXIST', path, '_open');
+    }
+    if (!isTruncating(flag)) {
+        return new FileHandle(await fs.openFile(resolved, flag, cred));
+    }
+    /*
+        In a previous implementation, we deleted the file and
+        re-created it. However, this created a race condition if another
+        asynchronous request was trying to read the file, as the file
+        would not exist for a small period of time.
+    */
+    const file = await fs.openFile(resolved, flag, cred);
+    await file.truncate(0);
+    await file.sync();
+    return new FileHandle(file);
 }
 /**
  * Asynchronous file open.

package/dist/emulation/shared.d.ts

@@ -1,8 +1,8 @@
 /// <reference types="node" resolution-mode="require"/>
 import type { BigIntStatsFs, StatsFs } from 'node:fs';
-import { Cred } from '../cred.js';
+import type { Cred } from '../cred.js';
 import type { File } from '../file.js';
-import { FileSystem } from '../filesystem.js';
+import type { FileSystem } from '../filesystem.js';
 import { type AbsolutePath } from './path.js';
 export declare let cred: Cred;
 export declare function setCred(val: Cred): void;

package/dist/emulation/shared.js

@@ -3,7 +3,6 @@ import { InMemory } from '../backends/memory.js';
 import { rootCred } from '../cred.js';
 import { Errno, ErrnoError } from '../error.js';
 import { size_max } from '../inode.js';
-import { ZenFsType } from '../stats.js';
 import { normalizePath } from '../utils.js';
 import { resolve } from './path.js';
 // credentials
@@ -109,7 +108,7 @@ export function _statfs(fs, bigint) {
     const md = fs.metadata();
     const bs = md.blockSize || 4096;
     return {
-        type: (bigint ? BigInt : Number)(md.type || ZenFsType),
+        type: (bigint ? BigInt : Number)(md.type),
         bsize: (bigint ? BigInt : Number)(bs),
         ffree: (bigint ? BigInt : Number)(md.freeNodes || size_max),
         files: (bigint ? BigInt : Number)(md.totalNodes || size_max),

package/dist/emulation/streams.d.ts

@@ -2,7 +2,7 @@
 /// <reference types="node" resolution-mode="require"/>
 import type * as Node from 'fs';
 import { Readable, Writable } from 'readable-stream';
-import { Callback } from '../utils.js';
+import type { Callback } from '../utils.js';
 export declare class ReadStream extends Readable implements Node.ReadStream {
     close(callback?: Callback): void;
     bytesRead: number;

package/dist/emulation/sync.d.ts

@@ -3,7 +3,7 @@
 /// <reference types="node" resolution-mode="require"/>
 import { Buffer } from 'buffer';
 import type * as fs from 'node:fs';
-import { FileContents } from '../filesystem.js';
+import type { FileContents } from '../filesystem.js';
 import { BigIntStats, type Stats } from '../stats.js';
 import { Dir, Dirent } from './dir.js';
 /**

package/dist/emulation/sync.js

@@ -1,6 +1,6 @@
 import { Buffer } from 'buffer';
 import { Errno, ErrnoError } from '../error.js';
-import { ActionType, isAppendable, isReadable, isWriteable, parseFlag, pathExistsAction, pathNotExistsAction } from '../file.js';
+import { isAppendable, isExclusive, isReadable, isTruncating, isWriteable, parseFlag } from '../file.js';
 import { BigIntStats, FileType } from '../stats.js';
 import { normalizeMode, normalizeOptions, normalizePath, normalizeTime } from '../utils.js';
 import { COPYFILE_EXCL, F_OK, S_IFBLK, S_IFCHR, S_IFDIR, S_IFIFO, S_IFLNK, S_IFMT, S_IFREG, S_IFSOCK } from './constants.js';
@@ -108,43 +108,35 @@ function _openSync(path, _flag, _mode, resolveSymlinks = true) {
     path = resolveSymlinks && existsSync(path) ? realpathSync(path) : path;
     const { fs, path: resolved } = resolveMount(path);
     if (!fs.existsSync(resolved, cred)) {
-        switch (pathNotExistsAction(flag)) {
-            case ActionType.CREATE:
-                // Ensure parent exists.
-                const parentStats = fs.statSync(dirname(resolved), cred);
-                if (!parentStats.isDirectory()) {
-                    throw ErrnoError.With('ENOTDIR', dirname(path), '_open');
-                }
-                return fs.createFileSync(resolved, flag, mode, cred);
-            case ActionType.THROW:
-                throw ErrnoError.With('ENOENT', path, '_open');
-            default:
-                throw new ErrnoError(Errno.EINVAL, 'Invalid FileFlag object.');
+        if ((!isWriteable(flag) && !isAppendable(flag)) || flag == 'r+') {
+            throw ErrnoError.With('ENOENT', path, '_open');
+        }
+        // Create the file
+        const parentStats = fs.statSync(dirname(resolved), cred);
+        if (!parentStats.isDirectory()) {
+            throw ErrnoError.With('ENOTDIR', dirname(path), '_open');
         }
+        return fs.createFileSync(resolved, flag, mode, cred);
     }
     const stats = fs.statSync(resolved, cred);
     if (!stats.hasAccess(mode, cred)) {
         throw ErrnoError.With('EACCES', path, '_open');
     }
-    // File exists.
-    switch (pathExistsAction(flag)) {
-        case ActionType.THROW:
-            throw ErrnoError.With('EEXIST', path, '_open');
-        case ActionType.TRUNCATE:
-            // Delete file.
-            fs.unlinkSync(resolved, cred);
-            /*
-                Create file. Use the same mode as the old file.
-                Node itself modifies the ctime when this occurs, so this action
-                will preserve that behavior if the underlying file system
-                supports those properties.
-            */
-            return fs.createFileSync(resolved, flag, stats.mode, cred);
-        case ActionType.NOP:
-            return fs.openFileSync(resolved, flag, cred);
-        default:
-            throw new ErrnoError(Errno.EINVAL, 'Invalid FileFlag object.');
+    if (isExclusive(flag)) {
+        throw ErrnoError.With('EEXIST', path, '_open');
+    }
+    if (!isTruncating(flag)) {
+        return fs.openFileSync(resolved, flag, cred);
     }
+    // Delete file.
+    fs.unlinkSync(resolved, cred);
+    /*
+        Create file. Use the same mode as the old file.
+        Node itself modifies the ctime when this occurs, so this action
+        will preserve that behavior if the underlying file system
+        supports those properties.
+    */
+    return fs.createFileSync(resolved, flag, stats.mode, cred);
 }
 /**
  * Synchronous file open.
@@ -238,7 +230,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 = _openSync(typeof filename == 'number' ? fd2file(filename).path : filename.toString(), flag, options.mode, true);
     try {
-        file.writeSync(encodedData, 0, encodedData.byteLength, null);
+        file.writeSync(encodedData, 0, encodedData.byteLength);
     }
     finally {
         file.closeSync();

package/dist/error.d.ts

@@ -2,7 +2,7 @@
 /**
  * Standard libc error codes. More will be added to this enum and error strings as they are
  * needed.
- * @url https://en.wikipedia.org/wiki/Errno.h
+ * @see https://en.wikipedia.org/wiki/Errno.h
  */
 export declare enum Errno {
     /** Operation not permitted */

package/dist/error.js

@@ -1,7 +1,7 @@
 /**
  * Standard libc error codes. More will be added to this enum and error strings as they are
  * needed.
- * @url https://en.wikipedia.org/wiki/Errno.h
+ * @see https://en.wikipedia.org/wiki/Errno.h
  */
 export var Errno;
 (function (Errno) {

package/dist/file.d.ts

@@ -20,15 +20,6 @@ declare global {
         }): ArrayBuffer;
     }
 }
-/**
- * @hidden
- */
-export declare enum ActionType {
-    NOP = 0,
-    THROW = 1,
-    TRUNCATE = 2,
-    CREATE = 3
-}
 export declare function parseFlag(flag: string | number): string;
 export declare function flagToString(flag: number): string;
 export declare function flagToNumber(flag: string): number;
@@ -43,8 +34,6 @@ export declare function isTruncating(flag: string): boolean;
 export declare function isAppendable(flag: string): boolean;
 export declare function isSynchronous(flag: string): boolean;
 export declare function isExclusive(flag: string): boolean;
-export declare function pathExistsAction(flag: string): ActionType;
-export declare function pathNotExistsAction(flag: string): ActionType;
 export declare abstract class File {
     /**
      * Get the current file position.
@@ -101,7 +90,7 @@ export declare abstract class File {
      *   the current position.
      * @returns Promise resolving to the new length of the buffer
      */
-    abstract write(buffer: Uint8Array, offset?: number, length?: number, position?: number | null): Promise<number>;
+    abstract write(buffer: Uint8Array, offset?: number, length?: number, position?: number): Promise<number>;
     /**
      * Write buffer to the file.
      * Note that it is unsafe to use fs.writeSync multiple times on the same file
@@ -114,7 +103,7 @@ export declare abstract class File {
      *   data should be written. If position is null, the data will be written at
      *   the current position.
      */
-    abstract writeSync(buffer: Uint8Array, offset?: number, length?: number, position?: number | null): number;
+    abstract writeSync(buffer: Uint8Array, offset?: number, length?: number, position?: number): number;
     /**
      * Read data from the file.
      * @param buffer The buffer that the data will be

package/dist/file.js

@@ -1,21 +1,7 @@
-import { ErrnoError, Errno } from './error.js';
 import { O_APPEND, O_CREAT, O_EXCL, O_RDONLY, O_RDWR, O_SYNC, O_TRUNC, O_WRONLY, S_IFMT } from './emulation/constants.js';
+import { Errno, ErrnoError } from './error.js';
 import { size_max } from './inode.js';
 import { Stats } from './stats.js';
-/**
- * @hidden
- */
-export var ActionType;
-(function (ActionType) {
-    // Indicates that the code should not do anything.
-    ActionType[ActionType["NOP"] = 0] = "NOP";
-    // Indicates that the code should throw an exception.
-    ActionType[ActionType["THROW"] = 1] = "THROW";
-    // Indicates that the code should truncate the file, but only if it is a file.
-    ActionType[ActionType["TRUNCATE"] = 2] = "TRUNCATE";
-    // Indicates that the code should create the file.
-    ActionType[ActionType["CREATE"] = 3] = "CREATE";
-})(ActionType || (ActionType = {}));
 const validFlags = ['r', 'r+', 'rs', 'rs+', 'w', 'wx', 'w+', 'wx+', 'a', 'ax', 'a+', 'ax+'];
 export function parseFlag(flag) {
     if (typeof flag === 'number') {
@@ -117,21 +103,6 @@ export function isSynchronous(flag) {
 export function isExclusive(flag) {
     return flag.indexOf('x') !== -1;
 }
-export function pathExistsAction(flag) {
-    if (isExclusive(flag)) {
-        return ActionType.THROW;
-    }
-    if (isTruncating(flag)) {
-        return ActionType.TRUNCATE;
-    }
-    return ActionType.NOP;
-}
-export function pathNotExistsAction(flag) {
-    if ((isWriteable(flag) || isAppendable(flag)) && flag !== 'r+') {
-        return ActionType.CREATE;
-    }
-    return ActionType.THROW;
-}
 export class File {
     [Symbol.asyncDispose]() {
         return this.close();
@@ -306,7 +277,7 @@ export class PreloadFile extends File {
      *   data should be written. If position is null, the data will be written at
      *   the current position.
      */
-    async write(buffer, offset = 0, length = this.stats.size, position = 0) {
+    async write(buffer, offset = 0, length = this.stats.size, position = this.position) {
         const bytesWritten = this.writeSync(buffer, offset, length, position);
         await this.sync();
         return bytesWritten;
@@ -324,9 +295,8 @@ export class PreloadFile extends File {
      *   the current position.
      * @returns bytes written
      */
-    writeSync(buffer, offset = 0, length = this.stats.size, position = 0) {
+    writeSync(buffer, offset = 0, length = this.stats.size, position = this.position) {
         this.dirty = true;
-        position ?? (position = this.position);
         if (!isWriteable(this.flag)) {
             throw new ErrnoError(Errno.EPERM, 'File not opened with a writeable mode.');
         }

package/dist/filesystem.d.ts

@@ -1,6 +1,6 @@
 import { type Cred } from './cred.js';
 import { type File } from './file.js';
-import type { Stats } from './stats.js';
+import { type Stats } from './stats.js';
 export type FileContents = ArrayBufferView | string;
 /**
  * Metadata about a FileSystem
@@ -50,24 +50,16 @@ export interface FileSystemMetadata {
     /**
      * The type of the FS
      */
-    type?: number;
+    type: number;
 }
 /**
  * Structure for a filesystem. All ZenFS backends must extend this.
  *
- * This class includes some default implementations
+ * This class includes default implementations for `exists` and `existsSync`
  *
- * Assume the following about arguments passed to each API method:
- *
- * - Every path is an absolute path. `.`, `..`, and other items are resolved into an absolute form.
- * - All arguments are present. Any optional arguments at the Node API level have been passed in with their default values.
+ * If you are extending this class, note that every path is an absolute path and all arguments are present.
  */
 export declare abstract class FileSystem {
-    /**
-     * Numeric type, used for statfs
-     * @internal @protected
-     */
-    _type?: number;
     /**
      * Get metadata about the current file system
      */
@@ -75,8 +67,7 @@ export declare abstract class FileSystem {
     constructor();
     ready(): Promise<void>;
     /**
-     * Asynchronous rename. No arguments other than a possible exception
-     * are given to the completion callback.
+     * Asynchronous rename.
      */
     abstract rename(oldPath: string, newPath: string, cred: Cred): Promise<void>;
     /**
@@ -92,26 +83,24 @@ export declare abstract class FileSystem {
      */
     abstract statSync(path: string, cred: Cred): Stats;
     /**
-     * Opens the file at path p with the given flag. The file must exist.
-     * @param p The path to open.
+     * Opens the file at `path` with the given 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, cred: Cred): Promise<File>;
     /**
-     * Opens the file at path p with the given flag. The file must exist.
-     * @param p The path to open.
+     * Opens the file at `path` with the given flag. The file must exist.
+     * @param path The path to open.
      * @param flag The flag to use when opening the file.
      * @return A File object corresponding to the opened file.
      */
     abstract openFileSync(path: string, flag: string, cred: Cred): File;
     /**
-     * Create the file at path p with the given mode. Then, open it with the given
-     * flag.
+     * Create the file at `path` with the given mode. Then, open it with the given flag.
      */
     abstract createFile(path: string, flag: string, mode: number, cred: Cred): Promise<File>;
     /**
-     * Create the file at path p with the given mode. Then, open it with the given
-     * flag.
+     * Create the file at `path` with the given mode. Then, open it with the given flag.
      */
     abstract createFileSync(path: string, flag: string, mode: number, cred: Cred): File;
     /**
@@ -132,21 +121,16 @@ export declare abstract class FileSystem {
     abstract rmdirSync(path: string, cred: Cred): void;
     /**
      * Asynchronous `mkdir`.
-     * @param mode Mode to make the directory using. Can be ignored if
-     *   the filesystem doesn't support permissions.
+     * @param mode Mode to make the directory using.
      */
     abstract mkdir(path: string, mode: number, cred: Cred): Promise<void>;
     /**
      * Synchronous `mkdir`.
-     * @param mode Mode to make the directory using. Can be ignored if
-     *   the filesystem doesn't support permissions.
+     * @param mode Mode to make the directory using.
      */
     abstract mkdirSync(path: string, mode: number, cred: Cred): void;
     /**
      * Asynchronous `readdir`. Reads the contents of a directory.
-     *
-     * The callback gets two arguments `(err, files)` where `files` is an array of
-     * the names of the files in the directory excluding `'.'` and `'..'`.
      */
     abstract readdir(path: string, cred: Cred): Promise<string[]>;
     /**
@@ -233,13 +217,11 @@ declare abstract class AsyncFS extends FileSystem {
 /**
  * Async() implements synchronous methods on an asynchronous file system
  *
- * Implementing classes must define a protected _sync property for the synchronous file system used as a cache.
- * by:
- *
- * - Performing operations over the in-memory copy, while asynchronously pipelining them
- *   to the backing store.
- * - During application loading, the contents of the async file system can be reloaded into
- *   the synchronous store, if desired.
+ * Implementing classes must define `_sync` for the synchronous file system used as a cache.
+ * Synchronous methods on an asynchronous FS are implemented by:
+ *	- Performing operations over the in-memory copy,
+ * 	while asynchronously pipelining them to the backing store.
+ * 	- During loading, the contents of the async file system are eloaded into the synchronous store.
  *
  */
 export declare function Async<T extends abstract new (...args: any[]) => FileSystem>(FS: T): (abstract new (...args: any[]) => AsyncFS) & T;

package/dist/filesystem.js

@@ -2,15 +2,13 @@ import { ErrnoError, Errno } from './error.js';
 import { rootCred } from './cred.js';
 import { join } from './emulation/path.js';
 import { PreloadFile, parseFlag } from './file.js';
+import { ZenFsType } from './stats.js';
 /**
  * Structure for a filesystem. All ZenFS backends must extend this.
  *
- * This class includes some default implementations
+ * This class includes default implementations for `exists` and `existsSync`
  *
- * Assume the following about arguments passed to each API method:
- *
- * - Every path is an absolute path. `.`, `..`, and other items are resolved into an absolute form.
- * - All arguments are present. Any optional arguments at the Node API level have been passed in with their default values.
+ * If you are extending this class, note that every path is an absolute path and all arguments are present.
  */
 export class FileSystem {
     /**
@@ -24,7 +22,7 @@ export class FileSystem {
             freeSpace: 0,
             noResizableBuffers: false,
             noAsyncCache: false,
-            type: this._type,
+            type: ZenFsType,
         };
     }
     constructor() { }
@@ -99,13 +97,11 @@ export function Sync(FS) {
 /**
  * Async() implements synchronous methods on an asynchronous file system
  *
- * Implementing classes must define a protected _sync property for the synchronous file system used as a cache.
- * by:
- *
- * - Performing operations over the in-memory copy, while asynchronously pipelining them
- *   to the backing store.
- * - During application loading, the contents of the async file system can be reloaded into
- *   the synchronous store, if desired.
+ * Implementing classes must define `_sync` for the synchronous file system used as a cache.
+ * Synchronous methods on an asynchronous FS are implemented by:
+ *	- Performing operations over the in-memory copy,
+ * 	while asynchronously pipelining them to the backing store.
+ * 	- During loading, the contents of the async file system are eloaded into the synchronous store.
  *
  */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any

package/dist/stats.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" resolution-mode="require"/>
 import type * as Node from 'fs';
-import { Cred } from './cred.js';
+import type { Cred } from './cred.js';
 /**
  * Indicates the type of the given file. Applied to 'mode'.
  */

package/dist/utils.d.ts

@@ -2,9 +2,9 @@
 /// <reference types="node" resolution-mode="require"/>
 import type { OptionalTuple } from 'utilium';
 import { ErrnoError } from './error.js';
-import { Cred } from './cred.js';
+import type { Cred } from './cred.js';
 import { type AbsolutePath } from './emulation/path.js';
-import { FileSystem } from './filesystem.js';
+import type { FileSystem } from './filesystem.js';
 import type * as fs from 'node:fs';
 declare global {
     function atob(data: string): string;

package/license.md

@@ -1,6 +1,6 @@
-Copyright (c) 2023-2024 James P. and other ZenFS contributors.
-
+Copyright (c) James P. and other ZenFS contributors.
 Copyright (c) 2013-2023 John Vilk and other BrowserFS contributors.
+Copyright (c) Joyent, Inc. and other Node contributors for `test/fixtures/node`.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of
 this software and associated documentation files (the "Software"), to deal in
@@ -19,27 +19,3 @@ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
-
-This license applies to all parts of ZenFS, except for the following items:
-
--   The test fixtures located in `test/fixtures/node`. Their license follows:
-    """
-    Copyright Joyent, Inc. and other Node contributors. All rights reserved.
-    Permission is hereby granted, free of charge, to any person obtaining a copy
-    of this software and associated documentation files (the "Software"), to
-    deal in the Software without restriction, including without limitation the
-    rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
-    sell copies of the Software, and to permit persons to whom the Software is
-    furnished to do so, subject to the following conditions:
-
-    The above copyright notice and this permission notice shall be included in
-    all copies or substantial portions of the Software.
-
-    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
-    IN THE SOFTWARE.
-    """

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@zenfs/core",
-	"version": "0.12.2",
+	"version": "0.12.3",
 	"description": "A filesystem in your browser",
 	"main": "dist/index.js",
 	"types": "src/index.ts",
@@ -38,7 +38,7 @@
 	"scripts": {
 		"format": "prettier --write .",
 		"format:check": "prettier --check .",
-		"lint": "eslint src tests && tsc -p tsconfig.json --noEmit",
+		"lint": "tsc -p tsconfig.json --noEmit && eslint src tests",
 		"test": "npm run build && tsc -p tests/tsconfig.json --noEmit && cross-env NODE_OPTIONS=--experimental-vm-modules npx jest",
 		"build": "node scripts/build.js --globalName=ZenFS --entry src/index.ts",
 		"build:docs": "typedoc --out docs --name ZenFS src/index.ts",