@zenfs/core 1.8.8 → 1.9.0

package/dist/{backends/store → internal}/inode.js

@@ -37,8 +37,9 @@ var __setFunctionName = (this && this.__setFunctionName) || function (f, name, p
     return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name });
 };
 import { deserialize, pick, randomInt, sizeof, struct, types as t } from 'utilium';
-import { Stats } from '../../stats.js';
-import { size_max } from '../../vfs/constants.js';
+import { Stats } from '../stats.js';
+import { size_max } from '../vfs/constants.js';
+import { crit, debug } from './log.js';
 /**
  * Root inode
  * @hidden
@@ -132,17 +133,21 @@ let Inode = (() => {
                 return;
             }
             if (data.byteLength < 58) {
-                throw new RangeError('Can not create an inode from a buffer less than 58 bytes');
+                throw crit(new RangeError('Can not create an inode from a buffer less than 58 bytes'));
             }
             // Expand the buffer so it is the right size
-            if (data.byteLength < sz_inode) {
+            if (data.byteLength < __inode_sz) {
                 const buf = ArrayBuffer.isView(data) ? data.buffer : data;
-                const newBuffer = new Uint8Array(sz_inode);
+                const newBuffer = new Uint8Array(__inode_sz);
                 newBuffer.set(new Uint8Array(buf));
+                debug('Extending undersized buffer for inode');
                 data = newBuffer;
             }
             deserialize(this, data);
         }
+        toString() {
+            return `<Inode ${this.ino}>`;
+        }
         toJSON() {
             return pick(this, _inode_fields);
         }
@@ -221,4 +226,7 @@ let Inode = (() => {
     return Inode = _classThis;
 })();
 export { Inode };
-const sz_inode = sizeof(Inode);
+/**
+ * @internal @hidden
+ */
+export const __inode_sz = sizeof(Inode);

package/dist/internal/log.d.ts

@@ -0,0 +1,132 @@
+import { List } from 'utilium';
+import { ErrnoError } from './error.js';
+import type { FileSystem } from './filesystem.js';
+export declare const enum Level {
+    /** Emergency */
+    EMERG = 0,
+    /** Alert */
+    ALERT = 1,
+    /** Critical */
+    CRIT = 2,
+    /** Error */
+    ERR = 3,
+    /** Warning */
+    WARN = 4,
+    /** Notice */
+    NOTICE = 5,
+    /** Informational */
+    INFO = 6,
+    /** Debug */
+    DEBUG = 7
+}
+/** An object mapping log levels to a textual representation of them */
+export declare const levels: {
+    readonly 0: "emergency";
+    readonly 1: "alert";
+    readonly 2: "critical";
+    readonly 3: "error";
+    readonly 4: "warning";
+    readonly 5: "notice";
+    readonly 6: "info";
+    readonly 7: "debug";
+};
+export declare function levelOf(value: (typeof levels)[Level]): Level;
+/** A log entry */
+export interface Entry {
+    level: Level;
+    timestamp: Date;
+    elapsedMs: number;
+    message: string;
+}
+/** The list of log entries */
+export declare const entries: List<Entry>;
+export declare function log(level: Level, message: string): void;
+interface LogShortcutOptions {
+    fs?: FileSystem;
+}
+/** Shortcut for logging emergencies */
+export declare const emerg: <T extends {
+    toString(): string;
+} | ErrnoError>(message: T, options?: LogShortcutOptions) => T;
+/** Shortcut for logging alerts */
+export declare const alert: <T extends {
+    toString(): string;
+} | ErrnoError>(message: T, options?: LogShortcutOptions) => T;
+/** Shortcut for logging critical errors */
+export declare const crit: <T extends {
+    toString(): string;
+} | ErrnoError>(message: T, options?: LogShortcutOptions) => T;
+/** Shortcut for logging non-critical errors */
+export declare const err: <T extends {
+    toString(): string;
+} | ErrnoError>(message: T, options?: LogShortcutOptions) => T;
+/** Shortcut for logging warnings */
+export declare const warn: <T extends {
+    toString(): string;
+} | ErrnoError>(message: T, options?: LogShortcutOptions) => T;
+/** Shortcut for logging notices */
+export declare const notice: <T extends {
+    toString(): string;
+} | ErrnoError>(message: T, options?: LogShortcutOptions) => T;
+/** Shortcut for logging informational messages */
+export declare const info: <T extends {
+    toString(): string;
+} | ErrnoError>(message: T, options?: LogShortcutOptions) => T;
+/** Shortcut for logging debug messages */
+export declare const debug: <T extends {
+    toString(): string;
+} | ErrnoError>(message: T, options?: LogShortcutOptions) => T;
+/**
+ * Shortcut for logging usage of deprecated functions at runtime
+ * @param symbol The thing that is deprecated
+ * @internal @hidden
+ */
+export declare function log_deprecated(symbol: string): void;
+/**
+ * Various format functions included to make using the logger easier.
+ * These are not the only formats you can use.
+ */
+export declare const formats: {
+    /** Format with a timestamp and the level, colorized with ANSI escape codes */
+    readonly ansi_level: (this: void, entry: Entry) => string;
+    /**
+     * Format with a timestamp and colorize the message with ANSI escape codes.
+     * For EMERG and ALERT, the levels are included
+     */
+    readonly ansi_message: (this: void, entry: Entry) => string;
+    /** Uncolored format with a timestamp */
+    readonly default: (this: void, entry: Entry) => string;
+};
+export declare function format(entry: Entry): string;
+/** Whether log entries are being recorded */
+export declare let isEnabled: boolean;
+export interface LogConfiguration {
+    /**
+     * If false, log messages will not be recorded or outputted
+     * @default false
+     */
+    enabled?: boolean;
+    /**
+     * The minimum level needed to output a message
+     * @default Level.ALERT
+     */
+    level?: Level | (typeof levels)[Level];
+    /**
+     * Formats a log entry into a string
+     * @default `[${ms / 1000}] ${message}`
+     */
+    format?(this: void, entry: Entry): string;
+    /**
+     * Outputs a log message
+     * @default console.error()
+     */
+    output?(this: void, message: string): unknown;
+    /**
+     * If set, output() all current entries after `configure` is done
+     * @default false
+     */
+    dumpBacklog?: boolean;
+}
+/** Configure logging behavior */
+export declare function configure(options: LogConfiguration): void;
+export {};

package/dist/internal/log.js

@@ -0,0 +1,177 @@
+/* Logging utilities. The things in this file are named to work nicely when you import as a namespace. */
+import { List } from 'utilium';
+import { join } from '../vfs/path.js';
+import { ErrnoError } from './error.js';
+export var Level;
+(function (Level) {
+    /** Emergency */
+    Level[Level["EMERG"] = 0] = "EMERG";
+    /** Alert */
+    Level[Level["ALERT"] = 1] = "ALERT";
+    /** Critical */
+    Level[Level["CRIT"] = 2] = "CRIT";
+    /** Error */
+    Level[Level["ERR"] = 3] = "ERR";
+    /** Warning */
+    Level[Level["WARN"] = 4] = "WARN";
+    /** Notice */
+    Level[Level["NOTICE"] = 5] = "NOTICE";
+    /** Informational */
+    Level[Level["INFO"] = 6] = "INFO";
+    /** Debug */
+    Level[Level["DEBUG"] = 7] = "DEBUG";
+})(Level || (Level = {}));
+/** An object mapping log levels to a textual representation of them */
+export const levels = {
+    [Level.EMERG]: 'emergency',
+    [Level.ALERT]: 'alert',
+    [Level.CRIT]: 'critical',
+    [Level.ERR]: 'error',
+    [Level.WARN]: 'warning',
+    [Level.NOTICE]: 'notice',
+    [Level.INFO]: 'info',
+    [Level.DEBUG]: 'debug',
+};
+export function levelOf(value) {
+    return Object.values(levels).indexOf(value);
+}
+/** The list of log entries */
+export const entries = new List();
+export function log(level, message) {
+    if (!isEnabled)
+        return;
+    const entry = {
+        level,
+        message,
+        timestamp: new Date(),
+        elapsedMs: performance.now(),
+    };
+    entries.add(entry);
+    output(entry);
+}
+function _messageString(msg, options) {
+    var _a, _b;
+    if (!(msg instanceof ErrnoError))
+        return msg.toString();
+    const beforePath = msg.code + ': ' + msg.message;
+    if (!msg.path)
+        return beforePath;
+    const mountPoint = typeof options.fs == 'string' ? options.fs : ((_b = (_a = options.fs) === null || _a === void 0 ? void 0 : _a._mountPoint) !== null && _b !== void 0 ? _b : '<unknown>');
+    return beforePath + ': ' + join(mountPoint, msg.path);
+}
+function _shortcut(level) {
+    return function (message, options = {}) {
+        log(level, _messageString(message, options));
+        return message;
+    };
+}
+// Shortcuts
+/** Shortcut for logging emergencies */
+export const emerg = _shortcut(Level.EMERG);
+/** Shortcut for logging alerts */
+export const alert = _shortcut(Level.ALERT);
+/** Shortcut for logging critical errors */
+export const crit = _shortcut(Level.CRIT);
+/** Shortcut for logging non-critical errors */
+export const err = _shortcut(Level.ERR);
+/** Shortcut for logging warnings */
+export const warn = _shortcut(Level.WARN);
+/** Shortcut for logging notices */
+export const notice = _shortcut(Level.NOTICE);
+/** Shortcut for logging informational messages */
+export const info = _shortcut(Level.INFO);
+/** Shortcut for logging debug messages */
+export const debug = _shortcut(Level.DEBUG);
+/**
+ * Shortcut for logging usage of deprecated functions at runtime
+ * @param symbol The thing that is deprecated
+ * @internal @hidden
+ */
+export function log_deprecated(symbol) {
+    log(Level.WARN, symbol + ' is deprecated and should not be used.');
+}
+// Formatting and output
+/**
+ * @internal @hidden
+ */
+function ansi(text, format) {
+    return `\x1b[${format}m${text}\x1b[0m`;
+}
+function _prettyMs(entry, useANSI = false) {
+    const text = '[' + (entry.elapsedMs / 1000).toFixed(3).padStart(10) + '] ';
+    return useANSI ? ansi(text, '2;37') : text;
+}
+const _ansiLevelColor = {
+    [Level.EMERG]: '1;4;37;41',
+    [Level.ALERT]: '1;37;41',
+    [Level.CRIT]: '1;35',
+    [Level.ERR]: '1;31',
+    [Level.WARN]: '1;33',
+    [Level.NOTICE]: '1;36',
+    [Level.INFO]: '1;37',
+    [Level.DEBUG]: '0;2;37',
+};
+const _ansiMessageColor = {
+    [Level.EMERG]: '1;31',
+    [Level.ALERT]: '1;31',
+    [Level.CRIT]: '1;31',
+    [Level.ERR]: '31',
+    [Level.WARN]: '33',
+    [Level.NOTICE]: '1;37',
+    [Level.INFO]: '37',
+    [Level.DEBUG]: '2;37',
+};
+/**
+ * Various format functions included to make using the logger easier.
+ * These are not the only formats you can use.
+ */
+export const formats = {
+    /** Format with a timestamp and the level, colorized with ANSI escape codes */
+    ansi_level(entry) {
+        const levelText = ansi(levels[entry.level].toUpperCase(), _ansiLevelColor[entry.level]);
+        return [_prettyMs(entry, true), levelText, entry.message].join(' ');
+    },
+    /**
+     * Format with a timestamp and colorize the message with ANSI escape codes.
+     * For EMERG and ALERT, the levels are included
+     */
+    ansi_message(entry) {
+        let msg = _prettyMs(entry, true);
+        const isImportant = entry.level < Level.CRIT;
+        if (isImportant)
+            msg += ansi(levels[entry.level].toUpperCase(), _ansiLevelColor[entry.level]) + ': ';
+        msg += ansi(entry.message, _ansiMessageColor[entry.level]);
+        return msg;
+    },
+    /** Uncolored format with a timestamp */
+    default(entry) {
+        return `[${_prettyMs(entry)}] ${entry.message}`;
+    },
+};
+let _format = formats.default;
+export function format(entry) {
+    return _format(entry);
+}
+let _output = console.error;
+function output(entry) {
+    if (entry.level > minLevel)
+        return;
+    _output(format(entry));
+}
+let minLevel = Level.ALERT;
+// Configuration
+/** Whether log entries are being recorded */
+export let isEnabled = true;
+/** Configure logging behavior */
+export function configure(options) {
+    var _a, _b, _c, _d;
+    _format = (_a = options.format) !== null && _a !== void 0 ? _a : _format;
+    _output = (_b = options.output) !== null && _b !== void 0 ? _b : _output;
+    minLevel = typeof options.level == 'string' ? levelOf(options.level) : ((_c = options.level) !== null && _c !== void 0 ? _c : minLevel);
+    isEnabled = (_d = options.enabled) !== null && _d !== void 0 ? _d : isEnabled;
+    if (!options.dumpBacklog)
+        return;
+    for (const entry of entries) {
+        output(entry);
+    }
+}

package/dist/mixins/async.d.ts

@@ -1,4 +1,4 @@
-import type { FileSystem } from '../filesystem.js';
+import type { FileSystem } from '../internal/filesystem.js';
 import type { _SyncFSKeys, AsyncFSMethods, Mixin } from './shared.js';
 /** @internal */
 export type AsyncOperation = {
@@ -25,4 +25,4 @@ export interface AsyncMixin extends Pick<FileSystem, Exclude<_SyncFSKeys, 'exist
  * 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, AsyncMixin>;
+export declare function Async<const T extends abstract new (...args: any[]) => FileSystem>(FS: T): Mixin<T, AsyncMixin>;

package/dist/mixins/async.js

@@ -51,8 +51,9 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 });
 import { StoreFS } from '../backends/store/fs.js';
-import { Errno, ErrnoError } from '../error.js';
-import { LazyFile, parseFlag } from '../file.js';
+import { Errno, ErrnoError } from '../internal/error.js';
+import { LazyFile, parseFlag } from '../internal/file.js';
+import { crit, err, notice } from '../internal/log.js';
 import { join } from '../vfs/path.js';
 /**
  * Async() implements synchronous methods on an asynchronous file system
@@ -73,29 +74,25 @@ export function Async(FS) {
             return this.done();
         }
         _async(promise) {
-            if (!this._promise) {
-                this._promise = promise;
-                return;
-            }
             this._promise = this._promise.then(() => promise);
         }
         constructor(...args) {
             super(...args);
+            this._promise = Promise.resolve();
             this._isInitialized = false;
             this._patchAsync();
         }
         async ready() {
             await super.ready();
             await this.queueDone();
-            if (this._isInitialized || this._disableSync) {
+            if (this._isInitialized || this.attributes.has('no_async'))
                 return;
-            }
             this.checkSync();
             await this._sync.ready();
             // optimization: for 2 storeFS', we copy at a lower abstraction level.
             if (this._sync instanceof StoreFS && this instanceof StoreFS) {
-                const sync = this._sync['store'].transaction();
-                const async = this['store'].transaction();
+                const sync = this._sync.transaction();
+                const async = this.transaction();
                 const promises = [];
                 for (const key of await async.keys()) {
                     promises.push(async.get(key).then(data => sync.setSync(key, data)));
@@ -110,15 +107,17 @@ export function Async(FS) {
             }
             catch (e) {
                 this._isInitialized = false;
-                throw e;
+                throw crit(e, { fs: this });
             }
         }
         checkSync(path, syscall) {
-            if (this._disableSync) {
-                throw new ErrnoError(Errno.ENOTSUP, 'Sync caching has been disabled for this async file system', path, syscall);
+            if (this.attributes.has('no_async')) {
+                throw crit(new ErrnoError(Errno.ENOTSUP, 'Sync preloading has been disabled for this async file system', path, syscall), {
+                    fs: this,
+                });
             }
             if (!this._sync) {
-                throw new ErrnoError(Errno.ENOTSUP, 'No sync cache is attached to this async file system', path, syscall);
+                throw crit(new ErrnoError(Errno.ENOTSUP, 'No sync cache is attached to this async file system', path, syscall), { fs: this });
             }
         }
         renameSync(oldPath, newPath) {
@@ -244,14 +243,18 @@ export function Async(FS) {
                 this[key] = async (...args) => {
                     var _a, _b;
                     const result = await originalMethod.apply(this, args);
-                    if (new Error().stack.includes(`at <computed> [as ${key}]`) || !this._isInitialized)
+                    if (new Error().stack.includes(`at <computed> [as ${key}]`))
                         return result;
+                    if (!this._isInitialized) {
+                        notice('Skipping sync cache update for Async#' + key);
+                        return result;
+                    }
                     try {
                         // @ts-expect-error 2556
                         (_b = (_a = this._sync) === null || _a === void 0 ? void 0 : _a[`${key}Sync`]) === null || _b === void 0 ? void 0 : _b.call(_a, ...args);
                     }
                     catch (e) {
-                        throw new ErrnoError(e.errno, e.message + ' (Out of sync!)', e.path, key);
+                        throw err(new ErrnoError(e.errno, e.message + ' (Out of sync!)', e.path, key), { fs: this });
                     }
                     return result;
                 };

package/dist/mixins/mutexed.d.ts

@@ -1,9 +1,9 @@
-import type { File } from '../file.js';
-import type { CreationOptions, FileSystem, FileSystemMetadata } from '../filesystem.js';
+import type { File } from '../internal/file.js';
+import type { CreationOptions, FileSystem, FileSystemMetadata, UsageInfo } from '../internal/filesystem.js';
+import type { InodeLike } from '../internal/inode.js';
 import type { Stats } from '../stats.js';
 import type { Concrete } from '../utils.js';
 import '../polyfills.js';
-import type { InodeLike } from '../backends/index.js';
 export declare class MutexLock {
     protected readonly previous?: MutexLock | undefined;
     protected current: PromiseWithResolvers<void>;
@@ -22,7 +22,13 @@ export declare class _MutexedFS<T extends FileSystem> implements FileSystem {
      * @internal
      */
     _fs: T;
+    get id(): number;
+    get name(): string;
+    get label(): string | undefined;
+    set label(value: string | undefined);
+    get attributes(): import("utilium").ConstMap<import("../internal/filesystem.js").FileSystemAttributes, keyof import("../internal/filesystem.js").FileSystemAttributes, void>;
     ready(): Promise<void>;
+    usage(): UsageInfo;
     metadata(): FileSystemMetadata;
     /**
      * The current locks

package/dist/mixins/mutexed.js

@@ -50,7 +50,8 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
     var e = new Error(message);
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 });
-import { ErrnoError } from '../error.js';
+import { ErrnoError } from '../internal/error.js';
+import { err } from '../internal/log.js';
 import '../polyfills.js';
 export class MutexLock {
     get isLocked() {
@@ -78,9 +79,27 @@ export class MutexLock {
  * @hidden
  */
 export class _MutexedFS {
+    get id() {
+        return this._fs.id;
+    }
+    get name() {
+        return this._fs.name;
+    }
+    get label() {
+        return this._fs.label;
+    }
+    set label(value) {
+        this._fs.label = value;
+    }
+    get attributes() {
+        return this._fs.attributes;
+    }
     async ready() {
         return await this._fs.ready();
     }
+    usage() {
+        return this._fs.usage();
+    }
     metadata() {
         return this._fs.metadata();
     }
@@ -105,7 +124,7 @@ export class _MutexedFS {
             if (lock.isLocked) {
                 const error = ErrnoError.With('EDEADLK', path, syscall);
                 error.stack += stack === null || stack === void 0 ? void 0 : stack.slice('Error'.length);
-                throw error;
+                throw err(error, { fs: this });
             }
         }, 5000);
         await (previous === null || previous === void 0 ? void 0 : previous.done());
@@ -119,7 +138,7 @@ export class _MutexedFS {
     lockSync(path, syscall) {
         var _a;
         if ((_a = this.currentLock) === null || _a === void 0 ? void 0 : _a.isLocked) {
-            throw ErrnoError.With('EBUSY', path, syscall);
+            throw err(ErrnoError.With('EBUSY', path, syscall), { fs: this });
         }
         return this.addLock();
     }

package/dist/mixins/readonly.d.ts

@@ -1,4 +1,4 @@
-import type { FileSystem, FileSystemMetadata } from '../filesystem.js';
+import type { FileSystem, FileSystemMetadata } from '../internal/filesystem.js';
 import type { StatsLike } from '../stats.js';
 import type { Mixin } from './shared.js';
 /**
@@ -26,4 +26,4 @@ export interface ReadonlyMixin {
 /**
  * Implements the non-readonly methods to throw `EROFS`
  */
-export declare function Readonly<T extends typeof FileSystem>(FS: T): Mixin<T, ReadonlyMixin>;
+export declare function Readonly<T extends abstract new (...args: any[]) => FileSystem>(FS: T): Mixin<T, ReadonlyMixin>;

package/dist/mixins/readonly.js

@@ -1,12 +1,13 @@
-import { Errno, ErrnoError } from '../error.js';
+import { Errno, ErrnoError } from '../internal/error.js';
 /**
  * Implements the non-readonly methods to throw `EROFS`
  */
 /* eslint-disable @typescript-eslint/require-await */
 export function Readonly(FS) {
     class ReadonlyFS extends FS {
-        metadata() {
-            return { ...super.metadata(), readonly: true };
+        constructor(...args) {
+            super(...args);
+            this.attributes.set('no_write');
         }
         async rename() {
             throw new ErrnoError(Errno.EROFS);

package/dist/mixins/shared.d.ts

@@ -1,5 +1,5 @@
 import type { ExtractProperties } from 'utilium';
-import type { FileSystem } from '../filesystem.js';
+import type { FileSystem } from '../internal/filesystem.js';
 /**
  * `TBase` with `TMixin` mixed-in.
  * @internal

package/dist/mixins/sync.d.ts

@@ -1,6 +1,6 @@
-import type { FileSystem } from '../filesystem.js';
+import type { FileSystem } from '../internal/filesystem.js';
 import type { AsyncFSMethods, Mixin } from './shared.js';
 /**
  * Implements the asynchronous API in terms of the synchronous API.
  */
-export declare function Sync<T extends typeof FileSystem>(FS: T): Mixin<T, AsyncFSMethods>;
+export declare function Sync<T extends abstract new (...args: any[]) => FileSystem>(FS: T): Mixin<T, AsyncFSMethods>;

package/dist/stats.d.ts

@@ -1,7 +1,7 @@
 import type * as Node from 'node:fs';
 import type { V_Context } from './context.js';
+import type { InodeFields, InodeLike } from './internal/inode.js';
 import * as c from './vfs/constants.js';
-import type { InodeFields, InodeLike } from './backends/store/inode.js';
 /**
  * Indicates the type of a file. Applied to 'mode'.
  */
@@ -57,6 +57,7 @@ export declare abstract class StatsCommon<T extends number | bigint> implements
     protected abstract _isBigint: T extends bigint ? true : false;
     protected _convert(arg: number | bigint | string | boolean): T;
     get blocks(): T;
+    set blocks(value: T);
     /**
      * Unix-style file mode (e.g. 0o644) that includes the type of the item.
      * Type of the item can be FILE, DIRECTORY, SYMLINK, or SOCKET
@@ -150,14 +151,12 @@ export declare abstract class StatsCommon<T extends number | bigint> implements
      * Change the mode of the file.
      * We use this helper function to prevent messing up the type of the file.
      * @internal @deprecated
-     * @todo [BREAKING] Remove
      */
     chmod(mode: number): void;
     /**
      * Change the owner user/group of the file.
      * This function makes sure it is a valid UID/GID (that is, a 32 unsigned int)
      * @internal @deprecated
-     * @todo [BREAKING] Remove
      */
     chown(uid: number, gid: number): void;
     get atimeNs(): bigint;

package/dist/stats.js

@@ -1,7 +1,8 @@
-import { credentials } from './credentials.js';
-import * as c from './vfs/constants.js';
 import { pick } from 'utilium';
-import { _inode_fields } from './backends/store/inode.js';
+import { credentials } from './internal/credentials.js';
+import { _inode_fields } from './internal/inode.js';
+import { log_deprecated } from './internal/log.js';
+import * as c from './vfs/constants.js';
 const n1000 = BigInt(1000);
 /**
  * Provides information about a particular entry in the file system.
@@ -14,6 +15,7 @@ export class StatsCommon {
     get blocks() {
         return this._convert(Math.ceil(Number(this.size) / 512));
     }
+    set blocks(value) { }
     get atime() {
         return new Date(Number(this.atimeMs));
     }
@@ -153,18 +155,18 @@ export class StatsCommon {
      * Change the mode of the file.
      * We use this helper function to prevent messing up the type of the file.
      * @internal @deprecated
-     * @todo [BREAKING] Remove
      */
     chmod(mode) {
+        log_deprecated('StatsCommon#chmod');
         this.mode = this._convert((this.mode & c.S_IFMT) | mode);
     }
     /**
      * Change the owner user/group of the file.
      * This function makes sure it is a valid UID/GID (that is, a 32 unsigned int)
      * @internal @deprecated
-     * @todo [BREAKING] Remove
      */
     chown(uid, gid) {
+        log_deprecated('StatsCommon#chown');
         uid = Number(uid);
         gid = Number(gid);
         if (!isNaN(uid) && 0 <= uid && uid < 2 ** 32) {