@zenfs/core 1.2.9 → 1.3.0

package/dist/emulation/shared.js

@@ -69,6 +69,15 @@ export function resolveMount(path) {
     }
     throw new ErrnoError(Errno.EIO, 'ZenFS not initialized with a file system');
 }
+/**
+ * Wait for all file systems to be ready and synced.
+ * May be removed at some point.
+ * @experimental @internal
+ */
+export async function _synced() {
+    await Promise.all([...mounts.values()].map(m => m.ready()));
+    return;
+}
 /**
  * Reverse maps the paths in text from the mounted FileSystem to the global path
  * @hidden
@@ -87,7 +96,10 @@ export function fixError(e, paths) {
     if (typeof e.stack == 'string') {
         e.stack = fixPaths(e.stack, paths);
     }
-    e.message = fixPaths(e.message, paths);
+    try {
+        e.message = fixPaths(e.message, paths);
+    }
+    catch { }
     return e;
 }
 /**

package/dist/emulation/sync.d.ts

@@ -64,7 +64,7 @@ export declare function writeFileSync(path: fs.PathOrFileDescriptor, data: FileC
  * Asynchronously append data to a file, creating the file if it not yet exists.
  * @option encoding Defaults to `'utf8'`.
  * @option mode Defaults to `0644`.
- * @option flag Defaults to `'a'`.
+ * @option flag Defaults to `'a+'`.
  */
 export declare function appendFileSync(filename: fs.PathOrFileDescriptor, data: FileContents, _options?: fs.WriteFileOptions): void;
 /**

package/dist/emulation/sync.js

@@ -147,7 +147,7 @@ export function unlinkSync(path) {
     path = normalizePath(path);
     const { fs, path: resolved } = resolveMount(path);
     try {
-        if (config.checkAccess && !(cache.getStatsSync(path) || fs.statSync(resolved)).hasAccess(constants.W_OK)) {
+        if (config.checkAccess && !(cache.stats.getSync(path) || fs.statSync(resolved)).hasAccess(constants.W_OK)) {
             throw ErrnoError.With('EACCES', resolved, 'unlink');
         }
         fs.unlinkSync(resolved);
@@ -272,12 +272,12 @@ writeFileSync;
  * Asynchronously append data to a file, creating the file if it not yet exists.
  * @option encoding Defaults to `'utf8'`.
  * @option mode Defaults to `0644`.
- * @option flag Defaults to `'a'`.
+ * @option flag Defaults to `'a+'`.
  */
 export function appendFileSync(filename, data, _options = {}) {
     const env_4 = { stack: [], error: void 0, hasError: false };
     try {
-        const options = normalizeOptions(_options, 'utf8', 'a', 0o644);
+        const options = normalizeOptions(_options, 'utf8', 'a+', 0o644);
         const flag = parseFlag(options.flag);
         if (!isAppendable(flag)) {
             throw new ErrnoError(Errno.EINVAL, 'Flag passed to appendFile must allow for appending.');
@@ -393,7 +393,7 @@ export function rmdirSync(path) {
     path = normalizePath(path);
     const { fs, path: resolved } = resolveMount(realpathSync(path));
     try {
-        const stats = cache.getStatsSync(path) || fs.statSync(resolved);
+        const stats = cache.stats.getSync(path) || fs.statSync(resolved);
         if (!stats.isDirectory()) {
             throw ErrnoError.With('ENOTDIR', resolved, 'rmdir');
         }
@@ -446,8 +446,8 @@ export function readdirSync(path, options) {
     const { fs, path: resolved } = resolveMount(realpathSync(path));
     let entries;
     try {
-        const stats = cache.getStatsSync(path) || fs.statSync(resolved);
-        cache.setStatsSync(path, stats);
+        const stats = cache.stats.getSync(path) || fs.statSync(resolved);
+        cache.stats.setSync(path, stats);
         if (config.checkAccess && !stats.hasAccess(constants.R_OK)) {
             throw ErrnoError.With('EACCES', resolved, 'readdir');
         }
@@ -462,8 +462,8 @@ export function readdirSync(path, options) {
     // Iterate over entries and handle recursive case if needed
     const values = [];
     for (const entry of entries) {
-        const entryStat = cache.getStatsSync(join(path, entry)) || fs.statSync(join(resolved, entry));
-        cache.setStatsSync(join(path, entry), entryStat);
+        const entryStat = cache.stats.getSync(join(path, entry)) || fs.statSync(join(resolved, entry));
+        cache.stats.setSync(join(path, entry), entryStat);
         if (options?.withFileTypes) {
             values.push(new Dirent(entry, entryStat));
         }
@@ -489,7 +489,7 @@ export function readdirSync(path, options) {
         }
     }
     if (!options?._isIndirect) {
-        cache.clearStatsSync();
+        cache.stats.clearSync();
     }
     return values;
 }
@@ -593,14 +593,15 @@ lutimesSync;
 export function realpathSync(path, options) {
     path = normalizePath(path);
     const { base, dir } = parse(path);
-    const lpath = join(dir == '/' ? '/' : realpathSync(dir), base);
+    const lpath = join(dir == '/' ? '/' : cache.paths.getSync(dir) || realpathSync(dir), base);
     const { fs, path: resolvedPath, mountPoint } = resolveMount(lpath);
     try {
         const stats = fs.statSync(resolvedPath);
         if (!stats.isSymbolicLink()) {
             return lpath;
         }
-        return realpathSync(mountPoint + readlinkSync(lpath, options).toString());
+        const target = mountPoint + readlinkSync(lpath, options).toString();
+        return cache.paths.getSync(target) || realpathSync(target);
     }
     catch (e) {
         if (e.code == 'ENOENT') {
@@ -626,7 +627,7 @@ export function rmSync(path, options) {
     path = normalizePath(path);
     let stats;
     try {
-        stats = cache.getStatsSync(path) || statSync(path);
+        stats = cache.stats.getSync(path) || statSync(path);
     }
     catch (error) {
         if (error.code != 'ENOENT' || !options?.force)
@@ -635,7 +636,7 @@ export function rmSync(path, options) {
     if (!stats) {
         return;
     }
-    cache.setStatsSync(path, stats);
+    cache.stats.setSync(path, stats);
     switch (stats.mode & constants.S_IFMT) {
         case constants.S_IFDIR:
             if (options?.recursive) {
@@ -654,11 +655,11 @@ export function rmSync(path, options) {
         case constants.S_IFIFO:
         case constants.S_IFSOCK:
         default:
-            cache.clearStatsSync();
+            cache.stats.clearSync();
             throw new ErrnoError(Errno.EPERM, 'File type not supported', path, 'rm');
     }
     if (!options?._isIndirect) {
-        cache.clearStatsSync();
+        cache.stats.clearSync();
     }
 }
 rmSync;

package/dist/file.d.ts

@@ -38,7 +38,7 @@ 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 abstract class File {
+export declare abstract class File<FS extends FileSystem = FileSystem> {
     /**
      * @internal
      * The file system that created the file
@@ -138,12 +138,7 @@ export declare abstract class File {
  * An implementation of `File` that operates completely in-memory.
  * `PreloadFile`s are backed by a `Uint8Array`.
  */
-export declare class PreloadFile<FS extends FileSystem> extends File {
-    /**
-     * The file system that created the file.
-     * @internal
-     */
-    fs: FS;
+export declare class PreloadFile<FS extends FileSystem> extends File<FS> {
     readonly flag: string;
     readonly stats: Stats;
     /**
@@ -166,12 +161,7 @@ export declare class PreloadFile<FS extends FileSystem> extends File {
      * Creates a file with `path` and, optionally, the given contents.
      * Note that, if contents is specified, it will be mutated by the file.
      */
-    constructor(
-    /**
-     * The file system that created the file.
-     * @internal
-     */
-    fs: FS, path: string, flag: string, stats: Stats, 
+    constructor(fs: FS, path: string, flag: string, stats: Stats, 
     /**
      * A buffer containing the entire contents of the file.
      */
@@ -255,8 +245,6 @@ export declare class PreloadFile<FS extends FileSystem> extends File {
     utimesSync(atime: Date, mtime: Date): void;
     _setType(type: FileType): Promise<void>;
     _setTypeSync(type: FileType): void;
-    [Symbol.asyncDispose](): Promise<void>;
-    [Symbol.dispose](): void;
 }
 /**
  * For the file systems which do not sync to anything.

package/dist/file.js

@@ -1,5 +1,5 @@
-import { O_APPEND, O_CREAT, O_EXCL, O_RDONLY, O_RDWR, O_SYNC, O_TRUNC, O_WRONLY, S_IFMT, size_max } from './emulation/constants.js';
 import { config } from './emulation/config.js';
+import { O_APPEND, O_CREAT, O_EXCL, O_RDONLY, O_RDWR, O_SYNC, O_TRUNC, O_WRONLY, S_IFMT, size_max } from './emulation/constants.js';
 import { Errno, ErrnoError } from './error.js';
 import './polyfills.js';
 import { Stats } from './stats.js';
@@ -114,11 +114,11 @@ export class File {
         this.fs = fs;
         this.path = path;
     }
-    [Symbol.asyncDispose]() {
-        return this.close();
+    async [Symbol.asyncDispose]() {
+        await this.close();
     }
     [Symbol.dispose]() {
-        return this.closeSync();
+        this.closeSync();
     }
     /**
      * Default implementation maps to `sync`.
@@ -142,18 +142,12 @@ export class PreloadFile extends File {
      * Creates a file with `path` and, optionally, the given contents.
      * Note that, if contents is specified, it will be mutated by the file.
      */
-    constructor(
-    /**
-     * The file system that created the file.
-     * @internal
-     */
-    fs, path, flag, stats, 
+    constructor(fs, path, flag, stats, 
     /**
      * A buffer containing the entire contents of the file.
      */
     _buffer = new Uint8Array(new ArrayBuffer(0, fs.metadata().noResizableBuffers ? {} : { maxByteLength: size_max }))) {
         super(fs, path);
-        this.fs = fs;
         this.flag = flag;
         this.stats = stats;
         this._buffer = _buffer;
@@ -280,12 +274,12 @@ export class PreloadFile extends File {
         if (length > this._buffer.length) {
             const data = new Uint8Array(length - this._buffer.length);
             // Write will set stats.size and handle syncing.
-            this.writeSync(data, 0, data.length, this._buffer.length);
+            this._write(data, 0, data.length, this._buffer.length);
             return;
         }
         this.stats.size = length;
         // Truncate.
-        this._buffer = this._buffer.slice(0, length);
+        this._buffer = length ? this._buffer.slice(0, length) : new Uint8Array();
     }
     async truncate(length) {
         this._truncate(length);
@@ -484,12 +478,6 @@ export class PreloadFile extends File {
         this.stats.mode = (this.stats.mode & ~S_IFMT) | type;
         this.syncSync();
     }
-    async [Symbol.asyncDispose]() {
-        await this.close();
-    }
-    [Symbol.dispose]() {
-        this.closeSync();
-    }
 }
 /**
  * For the file systems which do not sync to anything.

package/dist/inode.d.ts

@@ -1,26 +1,16 @@
 import { Stats, type StatsLike } from './stats.js';
-/**
- * Alias for an ino.
- * This will be helpful if in the future inode numbers/IDs are changed to strings or numbers.
- */
-export type Ino = bigint;
 /**
  * Room inode
  * @hidden
  */
 export declare const rootIno = 0n;
-/**
- * Generate a random ino
- * @internal
- */
-export declare function randomIno(): Ino;
 /**
  * Generic inode definition that can easily be serialized.
+ * @internal
  */
 export declare class Inode implements StatsLike {
-    get data(): Uint8Array;
-    constructor(buffer?: ArrayBufferLike);
-    ino: Ino;
+    constructor(buffer?: ArrayBufferLike | ArrayBufferView);
+    data: bigint;
     size: number;
     mode: number;
     nlink: number;
@@ -30,6 +20,7 @@ export declare class Inode implements StatsLike {
     birthtimeMs: number;
     mtimeMs: number;
     ctimeMs: number;
+    ino: bigint;
     /**
      * Handy function that converts the Inode to a Node Stats object.
      */

package/dist/inode.js

@@ -36,38 +36,27 @@ var __setFunctionName = (this && this.__setFunctionName) || function (f, name, p
     if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : "";
     return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name });
 };
+import { deserialize, sizeof, struct, types as t } from 'utilium';
 import { Stats } from './stats.js';
-import { types as t, struct, sizeof, serialize, deserialize } from 'utilium';
+import { randomBigInt } from './utils.js';
 /**
  * Room inode
  * @hidden
  */
 export const rootIno = 0n;
-/**
- * Generates a random 32 bit integer, then converts to a hex string
- */
-function _random() {
-    return Math.round(Math.random() * 2 ** 32).toString(16);
-}
-/**
- * Generate a random ino
- * @internal
- */
-export function randomIno() {
-    return BigInt('0x' + _random() + _random());
-}
 /**
  * Generic inode definition that can easily be serialized.
+ * @internal
  */
 let Inode = (() => {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
     let _classDecorators = [struct()];
     let _classDescriptor;
     let _classExtraInitializers = [];
     let _classThis;
-    let _ino_decorators;
-    let _ino_initializers = [];
-    let _ino_extraInitializers = [];
+    let _data_decorators;
+    let _data_initializers = [];
+    let _data_extraInitializers = [];
     let _size_decorators;
     let _size_initializers = [];
     let _size_extraInitializers = [];
@@ -95,13 +84,13 @@ let Inode = (() => {
     let _ctimeMs_decorators;
     let _ctimeMs_initializers = [];
     let _ctimeMs_extraInitializers = [];
+    let _ino_decorators;
+    let _ino_initializers = [];
+    let _ino_extraInitializers = [];
     var Inode = _classThis = class {
-        get data() {
-            return serialize(this);
-        }
         constructor(buffer) {
-            this.ino = __runInitializers(this, _ino_initializers, void 0);
-            this.size = (__runInitializers(this, _ino_extraInitializers), __runInitializers(this, _size_initializers, void 0));
+            this.data = __runInitializers(this, _data_initializers, void 0);
+            this.size = (__runInitializers(this, _data_extraInitializers), __runInitializers(this, _size_initializers, void 0));
             this.mode = (__runInitializers(this, _size_extraInitializers), __runInitializers(this, _mode_initializers, void 0));
             this.nlink = (__runInitializers(this, _mode_extraInitializers), __runInitializers(this, _nlink_initializers, void 0));
             this.uid = (__runInitializers(this, _nlink_extraInitializers), __runInitializers(this, _uid_initializers, void 0));
@@ -110,7 +99,8 @@ let Inode = (() => {
             this.birthtimeMs = (__runInitializers(this, _atimeMs_extraInitializers), __runInitializers(this, _birthtimeMs_initializers, void 0));
             this.mtimeMs = (__runInitializers(this, _birthtimeMs_extraInitializers), __runInitializers(this, _mtimeMs_initializers, void 0));
             this.ctimeMs = (__runInitializers(this, _mtimeMs_extraInitializers), __runInitializers(this, _ctimeMs_initializers, void 0));
-            __runInitializers(this, _ctimeMs_extraInitializers);
+            this.ino = (__runInitializers(this, _ctimeMs_extraInitializers), __runInitializers(this, _ino_initializers, void 0));
+            __runInitializers(this, _ino_extraInitializers);
             if (buffer) {
                 if (buffer.byteLength < sizeof(Inode)) {
                     throw new RangeError(`Can not create an inode from a buffer less than ${sizeof(Inode)} bytes`);
@@ -119,7 +109,8 @@ let Inode = (() => {
                 return;
             }
             // set defaults on a fresh inode
-            this.ino = randomIno();
+            this.ino = randomBigInt();
+            this.data = randomBigInt();
             this.nlink = 1;
             this.size = 4096;
             const now = Date.now();
@@ -162,8 +153,8 @@ let Inode = (() => {
                 this.uid = stats.uid;
                 hasChanged = true;
             }
-            if (this.uid !== stats.uid) {
-                this.uid = stats.uid;
+            if (this.gid !== stats.gid) {
+                this.gid = stats.gid;
                 hasChanged = true;
             }
             if (this.atimeMs !== stats.atimeMs) {
@@ -184,7 +175,7 @@ let Inode = (() => {
     __setFunctionName(_classThis, "Inode");
     (() => {
         const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
-        _ino_decorators = [(_a = t).uint64.bind(_a)];
+        _data_decorators = [(_a = t).uint64.bind(_a)];
         _size_decorators = [(_b = t).uint32.bind(_b)];
         _mode_decorators = [(_c = t).uint16.bind(_c)];
         _nlink_decorators = [(_d = t).uint32.bind(_d)];
@@ -194,7 +185,8 @@ let Inode = (() => {
         _birthtimeMs_decorators = [(_h = t).float64.bind(_h)];
         _mtimeMs_decorators = [(_j = t).float64.bind(_j)];
         _ctimeMs_decorators = [(_k = t).float64.bind(_k)];
-        __esDecorate(null, null, _ino_decorators, { kind: "field", name: "ino", static: false, private: false, access: { has: obj => "ino" in obj, get: obj => obj.ino, set: (obj, value) => { obj.ino = value; } }, metadata: _metadata }, _ino_initializers, _ino_extraInitializers);
+        _ino_decorators = [(_l = t).uint64.bind(_l)];
+        __esDecorate(null, null, _data_decorators, { kind: "field", name: "data", static: false, private: false, access: { has: obj => "data" in obj, get: obj => obj.data, set: (obj, value) => { obj.data = value; } }, metadata: _metadata }, _data_initializers, _data_extraInitializers);
         __esDecorate(null, null, _size_decorators, { kind: "field", name: "size", static: false, private: false, access: { has: obj => "size" in obj, get: obj => obj.size, set: (obj, value) => { obj.size = value; } }, metadata: _metadata }, _size_initializers, _size_extraInitializers);
         __esDecorate(null, null, _mode_decorators, { kind: "field", name: "mode", static: false, private: false, access: { has: obj => "mode" in obj, get: obj => obj.mode, set: (obj, value) => { obj.mode = value; } }, metadata: _metadata }, _mode_initializers, _mode_extraInitializers);
         __esDecorate(null, null, _nlink_decorators, { kind: "field", name: "nlink", static: false, private: false, access: { has: obj => "nlink" in obj, get: obj => obj.nlink, set: (obj, value) => { obj.nlink = value; } }, metadata: _metadata }, _nlink_initializers, _nlink_extraInitializers);
@@ -204,6 +196,7 @@ let Inode = (() => {
         __esDecorate(null, null, _birthtimeMs_decorators, { kind: "field", name: "birthtimeMs", static: false, private: false, access: { has: obj => "birthtimeMs" in obj, get: obj => obj.birthtimeMs, set: (obj, value) => { obj.birthtimeMs = value; } }, metadata: _metadata }, _birthtimeMs_initializers, _birthtimeMs_extraInitializers);
         __esDecorate(null, null, _mtimeMs_decorators, { kind: "field", name: "mtimeMs", static: false, private: false, access: { has: obj => "mtimeMs" in obj, get: obj => obj.mtimeMs, set: (obj, value) => { obj.mtimeMs = value; } }, metadata: _metadata }, _mtimeMs_initializers, _mtimeMs_extraInitializers);
         __esDecorate(null, null, _ctimeMs_decorators, { kind: "field", name: "ctimeMs", static: false, private: false, access: { has: obj => "ctimeMs" in obj, get: obj => obj.ctimeMs, set: (obj, value) => { obj.ctimeMs = value; } }, metadata: _metadata }, _ctimeMs_initializers, _ctimeMs_extraInitializers);
+        __esDecorate(null, null, _ino_decorators, { kind: "field", name: "ino", static: false, private: false, access: { has: obj => "ino" in obj, get: obj => obj.ino, set: (obj, value) => { obj.ino = value; } }, metadata: _metadata }, _ino_initializers, _ino_extraInitializers);
         __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
         Inode = _classThis = _classDescriptor.value;
         if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });

package/dist/mixins/async.d.ts

@@ -7,16 +7,9 @@ export type AsyncOperation = {
     [K in keyof AsyncFSMethods]: [K, ...Parameters<FileSystem[K]>];
 }[keyof AsyncFSMethods];
 /**
- * Async() implements synchronous methods on an asynchronous file system
- *
- * 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 preloaded into the synchronous store.
- *
+ * @internal
  */
-export declare function Async<T extends typeof FileSystem>(FS: T): Mixin<T, {
+export interface Async {
     /**
      * @internal @protected
      */
@@ -33,4 +26,16 @@ export declare function Async<T extends typeof FileSystem>(FS: T): Mixin<T, {
     readdirSync(path: string): string[];
     linkSync(srcpath: string, dstpath: string): void;
     syncSync(path: string, data: Uint8Array, stats: Readonly<Stats>): void;
-}>;
+}
+/**
+ * Async() implements synchronous methods on an asynchronous file system
+ *
+ * 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 preloaded into the synchronous store.
+ *
+ */
+export declare function Async<const T extends typeof FileSystem>(FS: T): Mixin<T, Async>;
+export declare function asyncPatch<T extends typeof FileSystem>(fs: Mixin<T, Async>): void;

package/dist/mixins/async.js

@@ -80,6 +80,7 @@ export function Async(FS) {
         }
         async ready() {
             await super.ready();
+            await this.queueDone();
             if (this._isInitialized || this._disableSync) {
                 return;
             }
@@ -131,7 +132,7 @@ export function Async(FS) {
         }
         openFileSync(path, flag) {
             this.checkSync(path, 'openFile');
-            const file = this._sync.openFileSync(path, flag);
+            const file = this._sync.openFileSync(path, flag + '+');
             const stats = file.statSync();
             const buffer = new Uint8Array(stats.size);
             file.readSync(buffer);
@@ -228,3 +229,4 @@ export function Async(FS) {
     }
     return AsyncFS;
 }
+export function asyncPatch(fs) { }

package/dist/stats.js

@@ -1,5 +1,5 @@
 import { credentials } from './credentials.js';
-import { S_IFBLK, S_IFCHR, S_IFDIR, S_IFIFO, S_IFLNK, S_IFMT, S_IFREG, S_IFSOCK, S_IRWXG, S_IRWXO, S_IRWXU, size_max } from './emulation/constants.js';
+import { R_OK, S_IFBLK, S_IFCHR, S_IFDIR, S_IFIFO, S_IFLNK, S_IFMT, S_IFREG, S_IFSOCK, S_IRGRP, S_IROTH, S_IRUSR, S_IWGRP, S_IWOTH, S_IWUSR, S_IXGRP, S_IXOTH, S_IXUSR, size_max, W_OK, X_OK, } from './emulation/constants.js';
 /**
  * Provides information about a particular entry in the file system.
  * Common code used by both Stats and BigIntStats.
@@ -110,12 +110,37 @@ export class StatsCommon {
      */
     hasAccess(mode) {
         if (credentials.euid === 0 || credentials.egid === 0) {
-            //Running as root
+            // Running as root
             return true;
         }
-        // Mask for
-        const adjusted = (credentials.uid == this.uid ? S_IRWXU : 0) | (credentials.gid == this.gid ? S_IRWXG : 0) | S_IRWXO;
-        return (mode & this.mode & adjusted) == mode;
+        let perm = 0;
+        // Owner permissions
+        if (credentials.uid === this.uid) {
+            if (this.mode & S_IRUSR)
+                perm |= R_OK;
+            if (this.mode & S_IWUSR)
+                perm |= W_OK;
+            if (this.mode & S_IXUSR)
+                perm |= X_OK;
+        }
+        // Group permissions
+        if (credentials.gid === this.gid) {
+            if (this.mode & S_IRGRP)
+                perm |= R_OK;
+            if (this.mode & S_IWGRP)
+                perm |= W_OK;
+            if (this.mode & S_IXGRP)
+                perm |= X_OK;
+        }
+        // Others permissions
+        if (this.mode & S_IROTH)
+            perm |= R_OK;
+        if (this.mode & S_IWOTH)
+            perm |= W_OK;
+        if (this.mode & S_IXOTH)
+            perm |= X_OK;
+        // Perform the access check
+        return (perm & mode) === mode;
     }
     /**
      * Convert the current stats object into a credentials object

package/dist/utils.d.ts

@@ -50,13 +50,6 @@ export declare function decodeDirListing(data: Uint8Array): Record<string, bigin
  */
 export declare function encodeDirListing(data: Record<string, bigint>): Uint8Array;
 export type Callback<Args extends unknown[] = []> = (e?: ErrnoError, ...args: OptionalTuple<Args>) => unknown;
-/**
- * converts Date or number to a integer UNIX timestamp
- * Grabbed from NodeJS sources (lib/fs.js)
- *
- * @internal
- */
-export declare function _toUnixTimestamp(time: Date | number): number;
 /**
  * Normalizes a mode
  * @internal
@@ -88,3 +81,8 @@ export declare function normalizeOptions(options: fs.WriteFileOptions | (fs.Enco
     mode: number;
 };
 export type Concrete<T extends ClassLike> = Pick<T, keyof T> & (new (...args: any[]) => InstanceType<T>);
+/**
+ * Generate a random ino
+ * @internal
+ */
+export declare function randomBigInt(): bigint;

package/dist/utils.js

@@ -143,21 +143,6 @@ export function decodeDirListing(data) {
 export function encodeDirListing(data) {
     return encodeUTF8(JSON.stringify(data, (k, v) => (k == '' ? v : v.toString())));
 }
-/**
- * converts Date or number to a integer UNIX timestamp
- * Grabbed from NodeJS sources (lib/fs.js)
- *
- * @internal
- */
-export function _toUnixTimestamp(time) {
-    if (typeof time === 'number') {
-        return Math.floor(time);
-    }
-    if (time instanceof Date) {
-        return Math.floor(time.getTime() / 1000);
-    }
-    throw new Error('Cannot parse time');
-}
 /**
  * Normalizes a mode
  * @internal
@@ -185,13 +170,12 @@ export function normalizeTime(time) {
     if (time instanceof Date) {
         return time;
     }
-    if (typeof time == 'number') {
-        return new Date(time * 1000);
-    }
-    if (typeof time == 'string') {
+    try {
         return new Date(time);
     }
-    throw new ErrnoError(Errno.EINVAL, 'Invalid time.');
+    catch {
+        throw new ErrnoError(Errno.EINVAL, 'Invalid time.');
+    }
 }
 /**
  * Normalizes a path
@@ -229,3 +213,10 @@ export function normalizeOptions(options, encoding = 'utf8', flag, mode = 0) {
         mode: normalizeMode('mode' in options ? options?.mode : null, mode),
     };
 }
+/**
+ * Generate a random ino
+ * @internal
+ */
+export function randomBigInt() {
+    return crypto.getRandomValues(new BigUint64Array(1))[0];
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@zenfs/core",
-	"version": "1.2.9",
+	"version": "1.3.0",
 	"description": "A filesystem, anywhere",
 	"funding": {
 		"type": "individual",

package/src/backends/fetch.ts

@@ -106,7 +106,7 @@ export class FetchFS extends IndexFS {
 			baseUrl += '/';
 		}
 
-		super(typeof index != 'string' ? index : fetchFile<IndexData>(baseUrl + index, 'json', requestInit));
+		super(typeof index != 'string' ? index : fetchFile<IndexData>(index, 'json', requestInit));
 
 		this.baseUrl = baseUrl;
 		this.requestInit = requestInit;

package/src/backends/memory.ts

@@ -1,4 +1,3 @@
-import type { Ino } from '../inode.js';
 import type { Backend } from './backend.js';
 import { StoreFS } from './store/fs.js';
 import { SimpleTransaction, type SimpleSyncStore } from './store/simple.js';
@@ -6,7 +5,7 @@ import { SimpleTransaction, type SimpleSyncStore } from './store/simple.js';
 /**
  * A simple in-memory store
  */
-export class InMemoryStore extends Map<Ino, Uint8Array> implements SimpleSyncStore {
+export class InMemoryStore extends Map<bigint, Uint8Array> implements SimpleSyncStore {
 	public constructor(public name: string = 'tmp') {
 		super();
 	}

package/src/backends/overlay.ts

@@ -159,7 +159,7 @@ export class UnmutexedOverlayFS extends FileSystem {
 			if (this._deletedFiles.has(path)) {
 				throw ErrnoError.With('ENOENT', path, 'stat');
 			}
-			const oldStat = new Stats(await this.readable.stat(path));
+			const oldStat = await this.readable.stat(path);
 			// Make the oldStat's mode writable.
 			oldStat.mode |= 0o222;
 			return oldStat;
@@ -174,7 +174,7 @@ export class UnmutexedOverlayFS extends FileSystem {
 			if (this._deletedFiles.has(path)) {
 				throw ErrnoError.With('ENOENT', path, 'stat');
 			}
-			const oldStat = new Stats(this.readable.statSync(path));
+			const oldStat = this.readable.statSync(path);
 			// Make the oldStat's mode writable.
 			oldStat.mode |= 0o222;
 			return oldStat;