@zenfs/core 2.6.2 → 2.6.4

package/README.md

@@ -2,7 +2,7 @@
 
 ZenFS is a cross-platform library that emulates the [Node.js filesystem API](http://nodejs.org/api/fs.html).
 It works using a system of backends, which are used by ZenFS to store and retrieve data.
-ZenFS can also integrate with other tools.
+ZenFS should cover the full API surface of the latest Node.js version, though complex changes may lag a little bit.
 
 ## Backends
 

package/dist/backends/single_buffer.js

@@ -320,7 +320,7 @@ const sb_magic = 0x62732e7a; // 'z.sb'
  * Shortcut for minor perf. bump
  * @internal
  */
-const usedBytes = 2;
+const kUsedBytes = 2;
 /**
  * The super block structure for a single-buffer file system
  */
@@ -502,16 +502,34 @@ let SuperBlock = (() => {
          * @returns the new metadata block
          */
         rotateMetadata() {
-            const padding = this.used_bytes % BigInt(4);
-            Atomics.add(this, usedBytes, padding);
-            const offset = Number(Atomics.add(this, usedBytes, BigInt(sizeof(MetadataBlock))));
-            const metadata = new MetadataBlock(this.buffer, offset);
-            metadata.previous_offset = this.metadata_offset;
+            const alignment = BigInt(Int32Array.BYTES_PER_ELEMENT), blockSize = BigInt(sizeof(MetadataBlock));
+            let used = Atomics.load(this, kUsedBytes), offset;
+            // Padding and block space must be reserved together because other writers can advance used_bytes at any time.
+            for (;;) {
+                const padding = (alignment - (used % alignment)) % alignment;
+                offset = used + padding;
+                const next = offset + blockSize;
+                if (next > this.total_bytes)
+                    throw err(withErrno('ENOSPC', 'sbfs: not enough space for a new metadata block'));
+                const observed = Atomics.compareExchange(this, kUsedBytes, used, next);
+                if (observed === used)
+                    break;
+                used = observed;
+            }
+            const metadata = new MetadataBlock(this.buffer, Number(offset));
+            const offsets = new Uint32Array(this.buffer, this.byteOffset, sizeof(SuperBlock) / Uint32Array.BYTES_PER_ELEMENT);
+            let previous = Atomics.load(offsets, kMetadataOffset);
+            for (;;) {
+                metadata.previous_offset = previous;
+                _update(metadata);
+                const observed = Atomics.compareExchange(offsets, kMetadataOffset, previous, metadata.byteOffset);
+                if (observed === previous)
+                    break;
+                previous = observed;
+            }
             this.metadata = metadata;
-            this.metadata_offset = metadata.byteOffset;
-            _update(metadata);
             _update(this);
-            debug(`sbfs: rotated metadata block at ${hex(metadata.previous_offset)} with new block at ${hex(offset)}`);
+            debug(`sbfs: rotated metadata block at ${hex(metadata.previous_offset)} with new block at ${hex(metadata.byteOffset)}`);
             return metadata;
         }
         /**
@@ -545,6 +563,11 @@ let SuperBlock = (() => {
     return SuperBlock = _classThis;
 })();
 export { SuperBlock };
+/**
+ * Index of `SuperBlock.metadata_offset` in a `Uint32Array` view of the super block.
+ * @internal
+ */
+const kMetadataOffset = offsetof(SuperBlock, 'metadata_offset') / Uint32Array.BYTES_PER_ELEMENT;
 /**
  * Compute the checksum for a super block or metadata block.
  * Note we don't include the checksum when computing a new one.
@@ -635,7 +658,7 @@ export class SingleBufferStore extends BufferView {
                             _update(block);
                             return;
                         }
-                        entry.offset = Number(Atomics.add(this.superblock, usedBytes, BigInt(data.length)));
+                        entry.offset = Number(Atomics.add(this.superblock, kUsedBytes, BigInt(data.length)));
                         entry.size = data.length;
                         this._u8.set(data, entry.offset);
                         _update(block);
@@ -657,7 +680,7 @@ export class SingleBufferStore extends BufferView {
                 entry = this.superblock.metadata.items[0];
             }
             const lock = __addDisposableResource(env_1, this.superblock.metadata.lock(), false);
-            const offset = Number(Atomics.add(this.superblock, usedBytes, BigInt(data.length)));
+            const offset = Number(Atomics.add(this.superblock, kUsedBytes, BigInt(data.length)));
             entry.id = id;
             entry.offset = offset;
             entry.size = data.length;

package/dist/context.js

@@ -24,6 +24,7 @@ export function bindContext(init = {}) {
     const bound = Object.assign(ctx, {
         fs: {
             ...bindFunctions(fs, ctx),
+            Utf8Stream: fs.Utf8Stream._withContext(ctx),
             promises: bindFunctions(fs.promises, ctx),
             xattr: bindFunctions(xattr, ctx),
         },

package/dist/internal/contexts.d.ts

@@ -14,7 +14,7 @@ declare const kIsContext: unique symbol;
  * @category Contexts
  */
 export interface FSContext {
-    /** The unique ID of the context */
+    /** Brand */
     readonly [kIsContext]: boolean;
     /** The unique ID of the context */
     readonly id: number;
@@ -35,6 +35,8 @@ export interface FSContext {
     /** The child contexts */
     readonly children: FSContext[];
 }
+export declare function isContext(obj: unknown): obj is FSContext;
+export declare function assertContext(ctx: unknown): asserts ctx is FSContext;
 /**
  * maybe an FS context
  */

package/dist/internal/contexts.js

@@ -1,9 +1,18 @@
 import { createCredentials } from './credentials.js';
+import { warn } from 'kerium/log';
+import { withErrno } from 'kerium';
 /**
  * Symbol used for context branding
  * @internal @hidden
  */
 const kIsContext = Symbol('ZenFSContext');
+export function isContext(obj) {
+    return typeof obj === 'object' && obj !== null && kIsContext in obj;
+}
+export function assertContext(ctx) {
+    if (!isContext(ctx))
+        throw warn(withErrno('EINVAL', 'Invalid context provided'));
+}
 /**
  * The default/global context.
  * @internal @hidden
@@ -20,7 +29,7 @@ export const defaultContext = {
     children: [],
 };
 export function contextOf($) {
-    return typeof $ === 'object' && $ !== null && kIsContext in $ ? $ : defaultContext;
+    return isContext($) ? $ : defaultContext;
 }
 // 0 is reserved for the global/default context
 let _nextId = 1;
@@ -33,6 +42,7 @@ let _nextId = 1;
  * This exists so that `kIsContext` is not exported and to make sure the context is "secure".
  */
 export function createChildContext(parent, init = {}) {
+    assertContext(parent);
     const { root = parent.root, pwd = parent.pwd, credentials = structuredClone(parent.credentials) } = init;
     const ctx = {
         [kIsContext]: true,

package/dist/internal/inode.d.ts

@@ -243,6 +243,8 @@ export declare function isFIFO(metadata: {
 export declare function hasAccess($: V_Context, inode: Pick<InodeLike, 'mode' | 'uid' | 'gid'>, access: number): boolean;
 /**
  * @hidden @internal
+ *
+ * @todo https://github.com/nodejs/node/pull/58836 support -1 for `*chown`
  */
 export declare function _chown(stats: Partial<InodeLike>, uid: number, gid: number): boolean;
 export {};

package/dist/internal/inode.js

@@ -662,6 +662,8 @@ export function hasAccess($, inode, access) {
 }
 /**
  * @hidden @internal
+ *
+ * @todo https://github.com/nodejs/node/pull/58836 support -1 for `*chown`
  */
 export function _chown(stats, uid, gid) {
     let valid = true;

package/dist/internal/rpc.d.ts

@@ -1,12 +1,12 @@
 import type { ExceptionJSON } from 'kerium';
-import type { TransferListItem } from 'node:worker_threads';
+import type { Transferable } from 'node:worker_threads';
 import type { WithOptional } from 'utilium';
 import type { Backend, FilesystemOf } from '../backends/backend.js';
 import type { PortFS } from '../backends/port.js';
 import type { CreationOptions, FileSystem, UsageInfo } from '../internal/filesystem.js';
 import '../polyfills.js';
 export interface WebMessagePort {
-    postMessage(value: unknown, transfer?: TransferListItem[]): void;
+    postMessage(value: unknown, transfer?: Transferable[]): void;
     addEventListener(type: 'message', listener: (ev: {
         data: any;
     }) => void): void;
@@ -15,7 +15,7 @@ export interface WebMessagePort {
     }) => void): void;
 }
 export interface NodeMessagePort {
-    postMessage(value: unknown, transfer?: TransferListItem[]): void;
+    postMessage(value: unknown, transfer?: Transferable[]): void;
     on(type: 'message', listener: (ev: any) => void): void;
     off(type: 'message', listener: (ev: any) => void): void;
 }
@@ -24,7 +24,7 @@ export type Channel = NodeMessagePort | WebMessagePort | WebSocket;
 export interface Port<T extends Channel = Channel> {
     readonly channel: T;
     /** Send a request */
-    send<M extends Message>(message: M, transfer?: TransferListItem[]): void;
+    send<M extends Message>(message: M, transfer?: Transferable[]): void;
     /** Add a response handler */
     addHandler<M extends Message>(handler: (message: M) => void): void;
     /** Remove a response handler */

package/dist/node/async.d.ts

@@ -22,11 +22,21 @@ export declare function exists(this: V_Context, path: fs.PathLike, cb?: (exists:
 export declare function stat(this: V_Context, path: fs.PathLike, callback: Callback<[Stats]>): void;
 export declare function stat(this: V_Context, path: fs.PathLike, options: {
     bigint?: false;
+    throwIfNoEntry?: true;
 }, callback: Callback<[Stats]>): void;
 export declare function stat(this: V_Context, path: fs.PathLike, options: {
     bigint: true;
+    throwIfNoEntry?: true;
 }, callback: Callback<[BigIntStats]>): void;
-export declare function stat(this: V_Context, path: fs.PathLike, options: fs.StatOptions, callback: Callback<[Stats] | [BigIntStats]>): void;
+export declare function stat(this: V_Context, path: fs.PathLike, options: {
+    bigint?: false;
+    throwIfNoEntry: false;
+}, callback: Callback<[Stats | undefined]>): void;
+export declare function stat(this: V_Context, path: fs.PathLike, options: {
+    bigint: true;
+    throwIfNoEntry: false;
+}, callback: Callback<[BigIntStats | undefined]>): void;
+export declare function stat(this: V_Context, path: fs.PathLike, options: fs.StatOptions, callback: Callback<[Stats | BigIntStats | undefined]>): void;
 /**
  * Asynchronous `lstat`.
  * `lstat()` is identical to `stat()`, except that if path is a symbolic link,

package/dist/node/async.js

@@ -148,47 +148,26 @@ fdatasync;
 export function write(fd, data, cbPosOff, cbLenEnc, cbPosEnc, cb = nop) {
     let buffer, offset, length, position, encoding;
     const handle = new promises.FileHandle(this, fd);
+    const _cb = ([cbPosOff, cbLenEnc, cbPosEnc].find(arg => typeof arg === 'function') ?? cb);
     if (typeof data === 'string') {
-        // Signature 1: (fd, string, [position?, [encoding?]], cb?)
-        encoding = 'utf8';
-        switch (typeof cbPosOff) {
-            case 'function':
-                // (fd, string, cb)
-                cb = cbPosOff;
-                break;
-            case 'number':
-                // (fd, string, position, encoding?, cb?)
-                position = cbPosOff;
-                encoding = typeof cbLenEnc === 'string' ? cbLenEnc : 'utf8';
-                cb = typeof cbPosEnc === 'function' ? cbPosEnc : cb;
-                break;
-            default:
-                // ...try to find the callback and get out of here!
-                cb = (typeof cbLenEnc === 'function' ? cbLenEnc : typeof cbPosEnc === 'function' ? cbPosEnc : cb);
-                cb(withErrno('EINVAL'));
-                return;
-        }
-        buffer = Buffer.from(data);
+        // (fd, string, [position?, [encoding?]], cb?)
+        position = typeof cbPosOff === 'number' ? cbPosOff : null;
+        encoding = typeof cbLenEnc === 'string' ? cbLenEnc : 'utf8';
+        buffer = Buffer.from(data, encoding);
         offset = 0;
-        length = buffer.length;
-        const _cb = cb;
-        handle
-            .write(buffer, offset, length, position)
-            .then(({ bytesWritten }) => _cb(null, bytesWritten, buffer.toString(encoding)))
-            .catch(_cb);
+        length = buffer.byteLength;
     }
     else {
-        // Signature 2: (fd, buffer, offset, length, position?, cb?)
-        buffer = Buffer.from(data.buffer);
-        offset = cbPosOff;
-        length = cbLenEnc;
+        // (fd, buffer, [offset?, [length?, [position?]]], cb?)
+        buffer = Buffer.from(data.buffer, data.byteOffset, data.byteLength);
+        offset = typeof cbPosOff === 'number' ? cbPosOff : 0;
+        length = typeof cbLenEnc === 'number' ? cbLenEnc : buffer.byteLength - offset;
         position = typeof cbPosEnc === 'number' ? cbPosEnc : null;
-        const _cb = (typeof cbPosEnc === 'function' ? cbPosEnc : cb);
-        void handle
-            .write(buffer, offset, length, position)
-            .then(({ bytesWritten }) => _cb(null, bytesWritten, buffer))
-            .catch(_cb);
     }
+    handle
+        .write(buffer, offset, length, position)
+        .then(({ bytesWritten }) => _cb(null, bytesWritten, typeof data === 'string' ? data : buffer))
+        .catch(_cb);
 }
 write;
 /**

package/dist/node/index.d.ts

@@ -6,3 +6,4 @@ export { BigIntStatsFs, Stats, StatsFs } from './stats.js';
 export type { StatsLike } from './stats.js';
 export * from './streams.js';
 export * from './sync.js';
+export { Utf8Stream } from './utf8stream.js';

package/dist/node/index.js

@@ -6,3 +6,4 @@ export * as promises from './promises.js';
 export { BigIntStatsFs, Stats, StatsFs } from './stats.js';
 export * from './streams.js';
 export * from './sync.js';
+export { Utf8Stream } from './utf8stream.js';

package/dist/node/promises.d.ts

@@ -180,11 +180,25 @@ export declare function rename(this: V_Context, oldPath: fs.PathLike, newPath: f
  * Test whether or not `path` exists by checking with the file system.
  */
 export declare function exists(this: V_Context, path: fs.PathLike): Promise<boolean>;
-export declare function stat(this: V_Context, path: fs.PathLike, options: fs.BigIntOptions): Promise<BigIntStats>;
-export declare function stat(this: V_Context, path: fs.PathLike, options?: {
+export declare function stat(this: V_Context, path: fs.PathLike, options: fs.BigIntOptions & {
+    throwIfNoEntry?: true;
+}): Promise<BigIntStats>;
+export declare function stat(this: V_Context, path: fs.PathLike, options?: fs.StatOptions & {
     bigint?: false;
+    throwIfNoEntry?: true;
 }): Promise<Stats>;
-export declare function stat(this: V_Context, path: fs.PathLike, options?: fs.StatOptions): Promise<Stats | BigIntStats>;
+export declare function stat(this: V_Context, path: fs.PathLike, options: fs.StatOptions & {
+    bigint?: false;
+    throwIfNoEntry: false;
+}): Promise<Stats | undefined>;
+export declare function stat(this: V_Context, path: fs.PathLike, options: fs.StatOptions & {
+    bigint: true;
+    throwIfNoEntry: false;
+}): Promise<BigIntStats | undefined>;
+export declare function stat(this: V_Context, path: fs.PathLike, options: fs.StatOptions & {
+    throwIfNoEntry?: true;
+}): Promise<Stats | BigIntStats>;
+export declare function stat(this: V_Context, path: fs.PathLike, options?: fs.StatOptions): Promise<Stats | BigIntStats | undefined>;
 /**
  * `lstat`.
  * `lstat()` is identical to `stat()`, except that if path is a symbolic link,

package/dist/node/promises.js

@@ -54,10 +54,11 @@ import { Buffer } from 'buffer';
 import { Exception, rethrow, UV } from 'kerium';
 import { encodeUTF8 } from 'utilium';
 import * as constants from '../constants.js';
+import { contextOf } from '../internal/contexts.js';
 import { hasAccess, InodeFlags, isDirectory } from '../internal/inode.js';
-import { dirname, join, matchesGlob, resolve } from '../path.js';
+import { dirname, join, matchesGlob, relative, resolve } from '../path.js';
 import '../polyfills.js';
-import { _tempDirName, globToRegex, normalizeMode, normalizeOptions, normalizePath, normalizeTime, validateFD } from '../utils.js';
+import { _isNoEntry, _tempDirName, globToRegex, normalizeMode, normalizeOptions, normalizePath, normalizeTime, validateFD } from '../utils.js';
 import * as _async from '../vfs/async.js';
 import { checkAccess } from '../vfs/config.js';
 import { deleteFD, fromFD, toFD } from '../vfs/file.js';
@@ -541,7 +542,15 @@ export async function exists(path) {
     }
 }
 export async function stat(path, options) {
-    const stats = await _async.stat.call(this, path, false);
+    let stats;
+    try {
+        stats = await _async.stat.call(this, path, false);
+    }
+    catch (e) {
+        if (options?.throwIfNoEntry === false && _isNoEntry(e))
+            return;
+        throw e;
+    }
     return options?.bigint ? new BigIntStats(stats) : new Stats(stats);
 }
 stat;
@@ -1113,8 +1122,10 @@ export async function statfs(path, opts) {
 }
 export function glob(pattern, opt) {
     pattern = Array.isArray(pattern) ? pattern : [pattern];
-    const { cwd = '/', withFileTypes = false, exclude = () => false } = opt || {};
-    const normalizedPatterns = pattern.map(p => p.replace(/^\/+/g, ''));
+    const $ = contextOf(this);
+    const { cwd = $.pwd, withFileTypes = false, exclude = () => false, followSymlinks = false } = opt || {};
+    const base = resolve.call($, cwd instanceof URL ? cwd.pathname : cwd);
+    const normalizedPatterns = pattern.map(p => (p.startsWith('/') ? relative.call($, base, p) : p));
     const hasGlobStar = normalizedPatterns.some(p => p.includes('**'));
     const patternBases = normalizedPatterns.map(p => {
         const firstGlob = p.search(/[*?[\]{]/);
@@ -1124,23 +1135,28 @@ export function glob(pattern, opt) {
         return lastSlash === -1 ? '' : p.slice(0, lastSlash);
     });
     const regexPatterns = normalizedPatterns.map(globToRegex);
+    async function shouldDescend(path, relativePath) {
+        const isNamed = patternBases.some(base => relativePath === base || base.startsWith(relativePath + '/'));
+        const inScope = hasGlobStar || isNamed;
+        const stats = await lstat.call($, path);
+        if (!stats.isSymbolicLink())
+            return inScope && stats.isDirectory();
+        return inScope && (followSymlinks || isNamed) && !!(await stat.call($, path, { throwIfNoEntry: false }))?.isDirectory();
+    }
     async function* recursiveList(dir) {
-        const entries = await readdir(dir, { withFileTypes, encoding: 'utf8' });
+        const entries = await readdir.call($, dir, { withFileTypes, encoding: 'utf8' });
         for (const entry of entries) {
             const fullPath = join(dir, withFileTypes ? entry.name : entry);
-            if (typeof exclude != 'function' ? exclude.some(p => matchesGlob(p, fullPath)) : exclude((withFileTypes ? entry : fullPath)))
+            const relPath = relative.call($, base, fullPath);
+            if (typeof exclude != 'function' ? exclude.some(p => matchesGlob(p, relPath)) : exclude((withFileTypes ? entry : relPath)))
                 continue;
-            const relativePath = fullPath.replace(/^\/+/g, '');
-            if ((await stat(fullPath)).isDirectory()) {
-                if (hasGlobStar || patternBases.some(base => relativePath === base || base.startsWith(relativePath + '/'))) {
-                    yield* recursiveList(fullPath);
-                }
-            }
-            if (regexPatterns.some(rx => rx.test(relativePath))) {
-                yield withFileTypes ? entry : relativePath;
+            if (await shouldDescend(fullPath, relPath))
+                yield* recursiveList(fullPath);
+            if (regexPatterns.some(rx => rx.test(relPath))) {
+                yield withFileTypes ? entry : relPath;
             }
         }
     }
-    return recursiveList(cwd instanceof URL ? cwd.pathname : cwd);
+    return recursiveList(base);
 }
 glob;

package/dist/node/stats.d.ts

@@ -91,24 +91,32 @@ export declare abstract class StatsCommon<T extends number | bigint> implements
     atimeMs: T;
     get atime(): Date;
     set atime(value: Date);
+    get atimeInstant(): Temporal.Instant;
+    set atimeInstant(value: Temporal.Instant);
     /**
      * Time of last modification, since epoch
      */
     mtimeMs: T;
     get mtime(): Date;
     set mtime(value: Date);
+    get mtimeInstant(): Temporal.Instant;
+    set mtimeInstant(value: Temporal.Instant);
     /**
      * Time of last time file status was changed, since epoch
      */
     ctimeMs: T;
     get ctime(): Date;
     set ctime(value: Date);
+    get ctimeInstant(): Temporal.Instant;
+    set ctimeInstant(value: Temporal.Instant);
     /**
      * Time of file creation, since epoch
      */
     birthtimeMs: T;
     get birthtime(): Date;
     set birthtime(value: Date);
+    get birthtimeInstant(): Temporal.Instant;
+    set birthtimeInstant(value: Temporal.Instant);
     /**
      * Size of the item in bytes.
      * For directories/symlinks, this is normally the size of the struct that represents the item.
@@ -193,6 +201,8 @@ export declare class StatsFs implements Node.StatsFsBase<number> {
     bavail: number;
     /** Total file nodes in file system. */
     files: number;
+    /** Fundamental file system block size. */
+    frsize: number;
     /** Free file nodes in file system. */
     ffree: number;
 }
@@ -212,6 +222,8 @@ export declare class BigIntStatsFs implements Node.StatsFsBase<bigint> {
     bavail: bigint;
     /** Total file nodes in file system. */
     files: bigint;
+    /** Fundamental file system block size. */
+    frsize: bigint;
     /** Free file nodes in file system. */
     ffree: bigint;
 }

package/dist/node/stats.js

@@ -1,7 +1,8 @@
 import { pick } from 'utilium';
-import { _inode_fields, hasAccess } from '../internal/inode.js';
 import * as c from '../constants.js';
-const n1000 = BigInt(1000);
+import { _inode_fields, hasAccess } from '../internal/inode.js';
+import { _temporal } from '../utils.js';
+const _nsMultiplier = BigInt(1_000_000);
 /**
  * Provides information about a particular entry in the file system.
  * Common code used by both Stats and BigIntStats.
@@ -56,6 +57,12 @@ export class StatsCommon {
     set atime(value) {
         this.atimeMs = this._convert(value.getTime());
     }
+    get atimeInstant() {
+        return _temporal().Instant.fromEpochMilliseconds(Number(this.atimeMs));
+    }
+    set atimeInstant(value) {
+        this.atimeMs = this._convert(value.epochMilliseconds);
+    }
     /**
      * Time of last modification, since epoch
      */
@@ -66,6 +73,12 @@ export class StatsCommon {
     set mtime(value) {
         this.mtimeMs = this._convert(value.getTime());
     }
+    get mtimeInstant() {
+        return _temporal().Instant.fromEpochMilliseconds(Number(this.mtimeMs));
+    }
+    set mtimeInstant(value) {
+        this.mtimeMs = this._convert(value.epochMilliseconds);
+    }
     /**
      * Time of last time file status was changed, since epoch
      */
@@ -76,6 +89,12 @@ export class StatsCommon {
     set ctime(value) {
         this.ctimeMs = this._convert(value.getTime());
     }
+    get ctimeInstant() {
+        return _temporal().Instant.fromEpochMilliseconds(Number(this.ctimeMs));
+    }
+    set ctimeInstant(value) {
+        this.ctimeMs = this._convert(value.epochMilliseconds);
+    }
     /**
      * Time of file creation, since epoch
      */
@@ -86,6 +105,12 @@ export class StatsCommon {
     set birthtime(value) {
         this.birthtimeMs = this._convert(value.getTime());
     }
+    get birthtimeInstant() {
+        return _temporal().Instant.fromEpochMilliseconds(Number(this.birthtimeMs));
+    }
+    set birthtimeInstant(value) {
+        this.birthtimeMs = this._convert(value.epochMilliseconds);
+    }
     /**
      * Size of the item in bytes.
      * For directories/symlinks, this is normally the size of the struct that represents the item.
@@ -156,16 +181,16 @@ export class StatsCommon {
         return hasAccess(context, this._isBigint ? new Stats(this) : this, mode);
     }
     get atimeNs() {
-        return BigInt(this.atimeMs) * n1000;
+        return BigInt(this.atimeMs) * _nsMultiplier;
     }
     get mtimeNs() {
-        return BigInt(this.mtimeMs) * n1000;
+        return BigInt(this.mtimeMs) * _nsMultiplier;
     }
     get ctimeNs() {
-        return BigInt(this.ctimeMs) * n1000;
+        return BigInt(this.ctimeMs) * _nsMultiplier;
     }
     get birthtimeNs() {
-        return BigInt(this.birthtimeMs) * n1000;
+        return BigInt(this.birthtimeMs) * _nsMultiplier;
     }
 }
 /**
@@ -218,6 +243,8 @@ export class StatsFs {
     bavail = 0;
     /** Total file nodes in file system. */
     files = c.size_max;
+    /** Fundamental file system block size. */
+    frsize = 4096;
     /** Free file nodes in file system. */
     ffree = c.size_max;
 }
@@ -237,6 +264,8 @@ export class BigIntStatsFs {
     bavail = BigInt(0);
     /** Total file nodes in file system. */
     files = BigInt(c.size_max);
+    /** Fundamental file system block size. */
+    frsize = BigInt(4096);
     /** Free file nodes in file system. */
     ffree = BigInt(c.size_max);
 }

package/dist/node/sync.d.ts

@@ -10,23 +10,51 @@ export declare function renameSync(this: V_Context, oldPath: fs.PathLike, newPat
  * Test whether or not `path` exists by checking with the file system.
  */
 export declare function existsSync(this: V_Context, path: fs.PathLike): boolean;
-export declare function statSync(this: V_Context, path: fs.PathLike, options?: {
-    bigint?: boolean;
+export declare function statSync(this: V_Context, path: fs.PathLike, options?: fs.StatOptions & {
+    bigint?: false;
+    throwIfNoEntry?: true;
 }): Stats;
-export declare function statSync(this: V_Context, path: fs.PathLike, options: {
+export declare function statSync(this: V_Context, path: fs.PathLike, options: fs.StatOptions & {
     bigint: true;
+    throwIfNoEntry?: true;
 }): BigIntStats;
+export declare function statSync(this: V_Context, path: fs.PathLike, options: fs.StatOptions & {
+    bigint?: false;
+    throwIfNoEntry: false;
+}): Stats | undefined;
+export declare function statSync(this: V_Context, path: fs.PathLike, options: fs.StatOptions & {
+    bigint: true;
+    throwIfNoEntry: false;
+}): BigIntStats | undefined;
+export declare function statSync(this: V_Context, path: fs.PathLike, options: fs.StatOptions & {
+    throwIfNoEntry?: true;
+}): Stats | BigIntStats;
+export declare function statSync(this: V_Context, path: fs.PathLike, options?: fs.StatOptions): Stats | BigIntStats | undefined;
 /**
  * Synchronous `lstat`.
  * `lstat()` is identical to `stat()`, except that if path is a symbolic link,
  * then the link itself is stat-ed, not the file that it refers to.
  */
-export declare function lstatSync(this: V_Context, path: fs.PathLike, options?: {
-    bigint?: boolean;
+export declare function lstatSync(this: V_Context, path: fs.PathLike, options?: fs.StatOptions & {
+    bigint?: false;
+    throwIfNoEntry?: true;
 }): Stats;
-export declare function lstatSync(this: V_Context, path: fs.PathLike, options: {
+export declare function lstatSync(this: V_Context, path: fs.PathLike, options: fs.StatOptions & {
     bigint: true;
+    throwIfNoEntry?: true;
 }): BigIntStats;
+export declare function lstatSync(this: V_Context, path: fs.PathLike, options: fs.StatOptions & {
+    bigint?: false;
+    throwIfNoEntry: false;
+}): Stats | undefined;
+export declare function lstatSync(this: V_Context, path: fs.PathLike, options: fs.StatOptions & {
+    bigint: true;
+    throwIfNoEntry: false;
+}): BigIntStats | undefined;
+export declare function lstatSync(this: V_Context, path: fs.PathLike, options: fs.StatOptions & {
+    throwIfNoEntry?: true;
+}): Stats | BigIntStats;
+export declare function lstatSync(this: V_Context, path: fs.PathLike, options?: fs.StatOptions): Stats | BigIntStats | undefined;
 export declare function truncateSync(this: V_Context, path: fs.PathLike, len?: number | null): void;
 export declare function unlinkSync(this: V_Context, path: fs.PathLike): void;
 /**
@@ -94,7 +122,7 @@ export declare function fdatasyncSync(this: V_Context, fd: number): void;
  */
 export declare function writeSync(this: V_Context, fd: number, data: ArrayBufferView, offset?: number | null, length?: number | null, position?: number | null): number;
 export declare function writeSync(this: V_Context, fd: number, data: string, position?: number | null, encoding?: BufferEncoding | null): number;
-export declare function readSync(this: V_Context, fd: number, buffer: ArrayBufferView, options?: fs.ReadSyncOptions): number;
+export declare function readSync(this: V_Context, fd: number, buffer: ArrayBufferView, options?: fs.ReadOptions): number;
 export declare function readSync(this: V_Context, fd: number, buffer: ArrayBufferView, offset: number, length: number, position?: fs.ReadPosition | null): number;
 export declare function fchownSync(this: V_Context, fd: number, uid: number, gid: number): void;
 export declare function fchmodSync(this: V_Context, fd: number, mode: number | string): void;
@@ -246,7 +274,7 @@ export declare function statfsSync(this: V_Context, path: fs.PathLike, options?:
 /**
  * Retrieves the files matching the specified pattern.
  */
-export declare function globSync(pattern: string | readonly string[]): string[];
-export declare function globSync(pattern: string | readonly string[], options: fs.GlobOptionsWithFileTypes): Dirent[];
-export declare function globSync(pattern: string | readonly string[], options: fs.GlobOptionsWithoutFileTypes): string[];
-export declare function globSync(pattern: string | readonly string[], options: fs.GlobOptions): Dirent[] | string[];
+export declare function globSync(this: V_Context, pattern: string | readonly string[]): string[];
+export declare function globSync(this: V_Context, pattern: string | readonly string[], options: fs.GlobOptionsWithFileTypes): Dirent[];
+export declare function globSync(this: V_Context, pattern: string | readonly string[], options: fs.GlobOptionsWithoutFileTypes): string[];
+export declare function globSync(this: V_Context, pattern: string | readonly string[], options: fs.GlobOptions): Dirent[] | string[];