@zenfs/core 1.9.5 → 1.10.0

package/dist/backends/fetch.d.ts

@@ -16,10 +16,10 @@ export interface FetchOptions extends SharedConfig {
      * Defaults to `index.json`.
      */
     index?: string | IndexData;
-    /** Used as the URL prefix for fetched files.
-     * Default: Fetch files relative to the index.
+    /**
+     * Used as the URL prefix for fetched files.
      */
-    baseUrl?: string;
+    baseUrl: string;
     /**
      * If true, enables writing to the remote (using post and delete)
      * @default false
@@ -56,7 +56,7 @@ declare const _Fetch: {
         };
         readonly baseUrl: {
             readonly type: "string";
-            readonly required: false;
+            readonly required: true;
         };
         readonly requestInit: {
             readonly type: "object";

package/dist/backends/fetch.js

@@ -88,7 +88,7 @@ const _Fetch = {
     name: 'Fetch',
     options: {
         index: { type: ['string', 'object'], required: false },
-        baseUrl: { type: 'string', required: false },
+        baseUrl: { type: 'string', required: true },
         requestInit: { type: 'object', required: false },
         remoteWrite: { type: 'boolean', required: false },
     },
@@ -97,7 +97,7 @@ const _Fetch = {
     },
     async create(options) {
         var _a;
-        const url = new URL(options.baseUrl || '');
+        const url = new URL(options.baseUrl);
         url.pathname = normalizePath(url.pathname);
         let baseUrl = url.toString();
         if (baseUrl.at(-1) == '/')

package/dist/backends/index.d.ts

@@ -4,6 +4,7 @@ export * from './memory.js';
 export * from './overlay.js';
 export * from './passthrough.js';
 export * from './port/fs.js';
+export * from './single_buffer.js';
 export * from './store/fs.js';
 export * from './store/map.js';
 export * from './store/store.js';

package/dist/backends/index.js

@@ -4,6 +4,7 @@ export * from './memory.js';
 export * from './overlay.js';
 export * from './passthrough.js';
 export * from './port/fs.js';
+export * from './single_buffer.js';
 export * from './store/fs.js';
 export * from './store/map.js';
 export * from './store/store.js';

package/dist/backends/memory.d.ts

@@ -1,3 +1,4 @@
+import type { UsageInfo } from '../internal/filesystem.js';
 import { StoreFS } from './store/fs.js';
 import { SyncMapTransaction, type SyncMapStore } from './store/map.js';
 /**
@@ -5,24 +6,45 @@ import { SyncMapTransaction, type SyncMapStore } from './store/map.js';
  * @category Stores and Transactions
  */
 export declare class InMemoryStore extends Map<number, Uint8Array> implements SyncMapStore {
+    readonly maxSize: number;
     readonly label?: string | undefined;
     readonly flags: readonly [];
     readonly name = "tmpfs";
-    constructor(label?: string | undefined);
+    constructor(maxSize?: number, label?: string | undefined);
     sync(): Promise<void>;
     transaction(): SyncMapTransaction;
+    get bytes(): number;
+    usage(): UsageInfo;
+}
+/**
+ * Options for an in-memory backend
+ * @category Backends and Configuration
+ */
+export interface InMemoryOptions {
+    /** The maximum size of the store. Defaults to 4 GiB */
+    maxSize?: number;
+    /** The label to use for the store and file system */
+    label?: string;
+    /** @deprecated use `label` */
+    name?: string;
 }
 declare const _InMemory: {
     readonly name: "InMemory";
     readonly options: {
+        readonly maxSize: {
+            readonly type: "number";
+            readonly required: false;
+        };
+        readonly label: {
+            readonly type: "string";
+            readonly required: false;
+        };
         readonly name: {
             readonly type: "string";
             readonly required: false;
         };
     };
-    readonly create: ({ name }: {
-        name?: string;
-    }) => StoreFS<InMemoryStore>;
+    readonly create: ({ maxSize, label, name }: InMemoryOptions) => StoreFS<InMemoryStore>;
 };
 type _InMemory = typeof _InMemory;
 export interface InMemory extends _InMemory {

package/dist/backends/memory.js

@@ -1,3 +1,4 @@
+import { size_max } from '../vfs/constants.js';
 import { StoreFS } from './store/fs.js';
 import { SyncMapTransaction } from './store/map.js';
 /**
@@ -5,8 +6,9 @@ import { SyncMapTransaction } from './store/map.js';
  * @category Stores and Transactions
  */
 export class InMemoryStore extends Map {
-    constructor(label) {
+    constructor(maxSize = size_max, label) {
         super();
+        this.maxSize = maxSize;
         this.label = label;
         this.flags = [];
         this.name = 'tmpfs';
@@ -15,14 +17,28 @@ export class InMemoryStore extends Map {
     transaction() {
         return new SyncMapTransaction(this);
     }
+    get bytes() {
+        let size = this.size * 4;
+        for (const data of this.values())
+            size += data.byteLength;
+        return size;
+    }
+    usage() {
+        return {
+            totalSpace: this.maxSize,
+            freeSpace: this.maxSize - this.bytes,
+        };
+    }
 }
 const _InMemory = {
     name: 'InMemory',
     options: {
+        maxSize: { type: 'number', required: false },
+        label: { type: 'string', required: false },
         name: { type: 'string', required: false },
     },
-    create({ name }) {
-        const fs = new StoreFS(new InMemoryStore(name));
+    create({ maxSize, label, name }) {
+        const fs = new StoreFS(new InMemoryStore(maxSize, label !== null && label !== void 0 ? label : name));
         fs.checkRootSync();
         return fs;
     },

package/dist/backends/overlay.d.ts

@@ -1,5 +1,5 @@
 import type { File } from '../internal/file.js';
-import type { CreationOptions } from '../internal/filesystem.js';
+import type { CreationOptions, UsageInfo } from '../internal/filesystem.js';
 import type { Stats } from '../stats.js';
 import type { InodeLike } from '../internal/inode.js';
 import { FileSystem } from '../internal/filesystem.js';
@@ -37,6 +37,10 @@ export declare class OverlayFS extends FileSystem {
     private _deleteLogError?;
     private _ready;
     constructor({ writable, readable }: OverlayOptions);
+    /**
+     * @todo Consider trying to track information on the writable as well
+     */
+    usage(): UsageInfo;
     sync(path: string, data: Uint8Array, stats: Readonly<InodeLike>): Promise<void>;
     syncSync(path: string, data: Uint8Array, stats: Readonly<InodeLike>): void;
     read(path: string, buffer: Uint8Array, offset: number, end: number): Promise<void>;

package/dist/backends/overlay.js

@@ -86,10 +86,16 @@ export class OverlayFS extends FileSystem {
         this.writable = writable;
         this.readable = readable;
         if (this.writable.attributes.has('no_write')) {
-            throw err(new ErrnoError(Errno.EINVAL, 'Writable file can not be written to'));
+            throw err(new ErrnoError(Errno.EINVAL, 'Writable file system can not be written to'));
         }
         this._ready = this._initialize();
     }
+    /**
+     * @todo Consider trying to track information on the writable as well
+     */
+    usage() {
+        return this.readable.usage();
+    }
     async sync(path, data, stats) {
         await this.copyForWrite(path);
         await this.writable.sync(path, data, stats);

package/dist/backends/passthrough.d.ts

@@ -1,6 +1,6 @@
 import type * as fs from 'node:fs';
 import { File } from '../internal/file.js';
-import { FileSystem } from '../internal/filesystem.js';
+import { FileSystem, type UsageInfo } from '../internal/filesystem.js';
 import type { InodeLike } from '../internal/inode.js';
 import { Stats } from '../stats.js';
 export type NodeFS = typeof fs;
@@ -16,6 +16,7 @@ export declare class PassthroughFS extends FileSystem {
     readonly nodeFS: NodeFS;
     readonly prefix: string;
     constructor(nodeFS: NodeFS, prefix: string);
+    usage(): UsageInfo;
     path(path: string): string;
     error(err: unknown, path: string): never;
     /**

package/dist/backends/passthrough.js

@@ -141,6 +141,13 @@ export class PassthroughFS extends FileSystem {
         this.nodeFS = nodeFS;
         this.prefix = prefix;
     }
+    usage() {
+        const info = this.nodeFS.statfsSync(this.prefix);
+        return {
+            totalSpace: info.bsize * info.blocks,
+            freeSpace: info.bsize * info.bfree,
+        };
+    }
     path(path) {
         return join(this.prefix, path.slice(1));
     }

package/dist/backends/single_buffer.d.ts

@@ -0,0 +1,149 @@
+import type { UsageInfo } from '../internal/filesystem.js';
+import { StoreFS } from './store/fs.js';
+import { SyncMapTransaction, type SyncMapStore } from './store/map.js';
+import type { Store } from './store/store.js';
+declare class MetadataEntry {
+    /** Inode or data ID */
+    id: number;
+    /** Reserved for 64-bit offset expansion */
+    protected offset_: number;
+    /** Offset into the buffer the data is stored at. */
+    offset: number;
+    /** The size of the data */
+    size: number;
+}
+/**
+ * A block of metadata for a single-buffer file system.
+ * This metadata maps IDs (for inodes and data) to actual offsets in the buffer.
+ * This is done since IDs are not guaranteed to be sequential.
+ */
+declare class MetadataBlock {
+    protected readonly superblock: SuperBlock;
+    offset: number;
+    constructor(superblock: SuperBlock, offset?: number);
+    /**
+     * The crc32c checksum for the metadata block.
+     * @privateRemarks Keep this first!
+     */
+    checksum: number;
+    /** The (last) time this metadata block was updated */
+    timestamp: number;
+    /** Reserved for 64-bit offset expansion */
+    protected previous_offset_: number;
+    /** Offset to the previous metadata block */
+    previous_offset: number;
+    protected _previous?: MetadataBlock;
+    get previous(): MetadataBlock | undefined;
+    /** Metadata entries. */
+    entries: MetadataEntry[];
+}
+/**
+ * The super block structure for a single-buffer file system
+ */
+declare class SuperBlock {
+    readonly store: SingleBufferStore;
+    constructor(store: SingleBufferStore);
+    /**
+     * The crc32c checksum for the super block.
+     * @privateRemarks Keep this first!
+     */
+    checksum: number;
+    /** Signature for the superblock. */
+    magic: number;
+    /** The version of the on-disk format */
+    version: number;
+    /** Which format of `Inode` is used */
+    inode_format: number;
+    /** Flags for the file system. Currently unused */
+    flags: number;
+    /** The number of used bytes, including the super block and metadata */
+    used_bytes: bigint;
+    /** The total size of the entire file system, including the super block and metadata */
+    total_bytes: bigint;
+    /** An ID for this file system */
+    id: bigint;
+    /**
+     * The size in bytes of a metadata block.
+     * Not currently configurable.
+     */
+    metadata_block_size: number;
+    /** Reserved for 64-bit offset expansion */
+    protected metadata_offset_: number;
+    /** Offset of the current metadata block */
+    metadata_offset: number;
+    metadata: MetadataBlock;
+    /** An optional label for the file system */
+    label: string;
+    /** Padded to 256 bytes */
+    _padding: number[];
+    /**
+     * Rotate out the current metadata block.
+     * Allocates a new metadata block, moves the current one to backup,
+     * and updates used_bytes accordingly.
+     * @returns the new metadata block
+     */
+    rotateMetadata(): MetadataBlock;
+    /**
+     * Checks to see if `length` bytes are unused, starting at `offset`.
+     * @internal Not for external use!
+     */
+    isUnused(offset: number, length: number): boolean;
+}
+/**
+ *
+ * @category Stores and Transactions
+ */
+export declare class SingleBufferStore implements SyncMapStore {
+    readonly flags: readonly [];
+    readonly name = "sbfs";
+    readonly id = 1935828595;
+    protected superblock: SuperBlock;
+    /**
+     * @internal @hidden
+     */
+    readonly _view: DataView;
+    /**
+     * @internal @hidden
+     */
+    readonly _buffer: Uint8Array;
+    constructor(buffer: ArrayBufferLike | ArrayBufferView);
+    /**
+     * Update a block's checksum and write it to the store's buffer.
+     * @internal @hidden
+     */
+    _write(value: SuperBlock | MetadataBlock): void;
+    keys(): Iterable<number>;
+    get(id: number): Uint8Array | undefined;
+    set(id: number, data: Uint8Array): void;
+    delete(id: number): void;
+    _fs?: StoreFS<Store> | undefined;
+    sync(): Promise<void>;
+    usage(): UsageInfo;
+    transaction(): SyncMapTransaction;
+}
+/**
+ * Options for the `SingleBuffer` backend
+ * @category Backends and Configuration
+ */
+export interface SingleBufferOptions {
+    buffer: ArrayBufferLike | ArrayBufferView;
+}
+declare const _SingleBuffer: {
+    readonly name: "SingleBuffer";
+    readonly options: {
+        readonly buffer: {
+            readonly type: "object";
+            readonly required: true;
+        };
+    };
+    readonly create: ({ buffer }: SingleBufferOptions) => StoreFS<SingleBufferStore>;
+};
+type _SingleBuffer = typeof _SingleBuffer;
+export interface SingleBuffer extends _SingleBuffer {
+}
+/**
+ * A backend that uses a single buffer for storing data
+ * @category Backends and Configuration
+ */
+export declare const SingleBuffer: SingleBuffer;
+export {};

package/dist/backends/single_buffer.js

@@ -0,0 +1,498 @@
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+var __setFunctionName = (this && this.__setFunctionName) || function (f, name, prefix) {
+    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, member, offsetof, serialize, sizeof, struct, types as t } from 'utilium';
+import { crc32c } from 'utilium/checksum.js';
+import { Errno, ErrnoError } from '../internal/error.js';
+import { _inode_version } from '../internal/inode.js';
+import { crit, warn } from '../internal/log.js';
+import { StoreFS } from './store/fs.js';
+import { SyncMapTransaction } from './store/map.js';
+let MetadataEntry = (() => {
+    var _a, _b, _c, _d;
+    let _classDecorators = [struct()];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _id_decorators;
+    let _id_initializers = [];
+    let _id_extraInitializers = [];
+    let _offset__decorators;
+    let _offset__initializers = [];
+    let _offset__extraInitializers = [];
+    let _offset_decorators;
+    let _offset_initializers = [];
+    let _offset_extraInitializers = [];
+    let _size_decorators;
+    let _size_initializers = [];
+    let _size_extraInitializers = [];
+    var MetadataEntry = _classThis = class {
+        constructor() {
+            /** Inode or data ID */
+            this.id = __runInitializers(this, _id_initializers, 0);
+            /** Reserved for 64-bit offset expansion */
+            this.offset_ = (__runInitializers(this, _id_extraInitializers), __runInitializers(this, _offset__initializers, 0));
+            /** Offset into the buffer the data is stored at. */
+            this.offset = (__runInitializers(this, _offset__extraInitializers), __runInitializers(this, _offset_initializers, 0));
+            /** The size of the data */
+            this.size = (__runInitializers(this, _offset_extraInitializers), __runInitializers(this, _size_initializers, 0));
+            __runInitializers(this, _size_extraInitializers);
+        }
+    };
+    __setFunctionName(_classThis, "MetadataEntry");
+    (() => {
+        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+        _id_decorators = [(_a = t).uint32.bind(_a)];
+        _offset__decorators = [(_b = t).uint32.bind(_b)];
+        _offset_decorators = [(_c = t).uint32.bind(_c)];
+        _size_decorators = [(_d = t).uint32.bind(_d)];
+        __esDecorate(null, null, _id_decorators, { kind: "field", name: "id", static: false, private: false, access: { has: obj => "id" in obj, get: obj => obj.id, set: (obj, value) => { obj.id = value; } }, metadata: _metadata }, _id_initializers, _id_extraInitializers);
+        __esDecorate(null, null, _offset__decorators, { kind: "field", name: "offset_", static: false, private: false, access: { has: obj => "offset_" in obj, get: obj => obj.offset_, set: (obj, value) => { obj.offset_ = value; } }, metadata: _metadata }, _offset__initializers, _offset__extraInitializers);
+        __esDecorate(null, null, _offset_decorators, { kind: "field", name: "offset", static: false, private: false, access: { has: obj => "offset" in obj, get: obj => obj.offset, set: (obj, value) => { obj.offset = value; } }, metadata: _metadata }, _offset_initializers, _offset_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, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+        MetadataEntry = _classThis = _classDescriptor.value;
+        if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        __runInitializers(_classThis, _classExtraInitializers);
+    })();
+    return MetadataEntry = _classThis;
+})();
+/**
+ * Number of entries per block of metadata
+ */
+const entries_per_block = 255;
+/**
+ * A block of metadata for a single-buffer file system.
+ * This metadata maps IDs (for inodes and data) to actual offsets in the buffer.
+ * This is done since IDs are not guaranteed to be sequential.
+ */
+let MetadataBlock = (() => {
+    var _a, _b, _c, _d;
+    let _classDecorators = [struct()];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _checksum_decorators;
+    let _checksum_initializers = [];
+    let _checksum_extraInitializers = [];
+    let _timestamp_decorators;
+    let _timestamp_initializers = [];
+    let _timestamp_extraInitializers = [];
+    let _previous_offset__decorators;
+    let _previous_offset__initializers = [];
+    let _previous_offset__extraInitializers = [];
+    let _previous_offset_decorators;
+    let _previous_offset_initializers = [];
+    let _previous_offset_extraInitializers = [];
+    let _entries_decorators;
+    let _entries_initializers = [];
+    let _entries_extraInitializers = [];
+    var MetadataBlock = _classThis = class {
+        constructor(superblock, offset = 0) {
+            this.superblock = superblock;
+            this.offset = offset;
+            /**
+             * The crc32c checksum for the metadata block.
+             * @privateRemarks Keep this first!
+             */
+            this.checksum = __runInitializers(this, _checksum_initializers, 0);
+            /** The (last) time this metadata block was updated */
+            this.timestamp = (__runInitializers(this, _checksum_extraInitializers), __runInitializers(this, _timestamp_initializers, Date.now()));
+            /** Reserved for 64-bit offset expansion */
+            this.previous_offset_ = (__runInitializers(this, _timestamp_extraInitializers), __runInitializers(this, _previous_offset__initializers, 0));
+            /** Offset to the previous metadata block */
+            this.previous_offset = (__runInitializers(this, _previous_offset__extraInitializers), __runInitializers(this, _previous_offset_initializers, 0));
+            this._previous = __runInitializers(this, _previous_offset_extraInitializers);
+            /** Metadata entries. */
+            this.entries = __runInitializers(this, _entries_initializers, Array.from({ length: entries_per_block }, () => new MetadataEntry()));
+            __runInitializers(this, _entries_extraInitializers);
+            this.superblock = superblock;
+            this.offset = offset;
+            if (!offset)
+                return; // fresh block
+            deserialize(this, superblock.store._buffer.subarray(offset, offset + sizeof(MetadataBlock)));
+            if (!checksumMatches(this))
+                throw crit(new ErrnoError(Errno.EIO, 'SingleBuffer: Checksum mismatch for metadata block at 0x' + offset.toString(16)));
+        }
+        get previous() {
+            var _a;
+            if (!this.previous_offset)
+                return;
+            (_a = this._previous) !== null && _a !== void 0 ? _a : (this._previous = new MetadataBlock(this.superblock, this.previous_offset));
+            return this._previous;
+        }
+    };
+    __setFunctionName(_classThis, "MetadataBlock");
+    (() => {
+        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+        _checksum_decorators = [(_a = t).uint32.bind(_a)];
+        _timestamp_decorators = [(_b = t).uint32.bind(_b)];
+        _previous_offset__decorators = [(_c = t).uint32.bind(_c)];
+        _previous_offset_decorators = [(_d = t).uint32.bind(_d)];
+        _entries_decorators = [member(MetadataEntry, entries_per_block)];
+        __esDecorate(null, null, _checksum_decorators, { kind: "field", name: "checksum", static: false, private: false, access: { has: obj => "checksum" in obj, get: obj => obj.checksum, set: (obj, value) => { obj.checksum = value; } }, metadata: _metadata }, _checksum_initializers, _checksum_extraInitializers);
+        __esDecorate(null, null, _timestamp_decorators, { kind: "field", name: "timestamp", static: false, private: false, access: { has: obj => "timestamp" in obj, get: obj => obj.timestamp, set: (obj, value) => { obj.timestamp = value; } }, metadata: _metadata }, _timestamp_initializers, _timestamp_extraInitializers);
+        __esDecorate(null, null, _previous_offset__decorators, { kind: "field", name: "previous_offset_", static: false, private: false, access: { has: obj => "previous_offset_" in obj, get: obj => obj.previous_offset_, set: (obj, value) => { obj.previous_offset_ = value; } }, metadata: _metadata }, _previous_offset__initializers, _previous_offset__extraInitializers);
+        __esDecorate(null, null, _previous_offset_decorators, { kind: "field", name: "previous_offset", static: false, private: false, access: { has: obj => "previous_offset" in obj, get: obj => obj.previous_offset, set: (obj, value) => { obj.previous_offset = value; } }, metadata: _metadata }, _previous_offset_initializers, _previous_offset_extraInitializers);
+        __esDecorate(null, null, _entries_decorators, { kind: "field", name: "entries", static: false, private: false, access: { has: obj => "entries" in obj, get: obj => obj.entries, set: (obj, value) => { obj.entries = value; } }, metadata: _metadata }, _entries_initializers, _entries_extraInitializers);
+        __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+        MetadataBlock = _classThis = _classDescriptor.value;
+        if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        __runInitializers(_classThis, _classExtraInitializers);
+    })();
+    return MetadataBlock = _classThis;
+})();
+const sb_magic = 0x7a2e7362; // 'z.sb'
+/**
+ * The super block structure for a single-buffer file system
+ */
+let SuperBlock = (() => {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+    let _classDecorators = [struct()];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _checksum_decorators;
+    let _checksum_initializers = [];
+    let _checksum_extraInitializers = [];
+    let _magic_decorators;
+    let _magic_initializers = [];
+    let _magic_extraInitializers = [];
+    let _version_decorators;
+    let _version_initializers = [];
+    let _version_extraInitializers = [];
+    let _inode_format_decorators;
+    let _inode_format_initializers = [];
+    let _inode_format_extraInitializers = [];
+    let _flags_decorators;
+    let _flags_initializers = [];
+    let _flags_extraInitializers = [];
+    let _used_bytes_decorators;
+    let _used_bytes_initializers = [];
+    let _used_bytes_extraInitializers = [];
+    let _total_bytes_decorators;
+    let _total_bytes_initializers = [];
+    let _total_bytes_extraInitializers = [];
+    let _id_decorators;
+    let _id_initializers = [];
+    let _id_extraInitializers = [];
+    let _metadata_block_size_decorators;
+    let _metadata_block_size_initializers = [];
+    let _metadata_block_size_extraInitializers = [];
+    let _metadata_offset__decorators;
+    let _metadata_offset__initializers = [];
+    let _metadata_offset__extraInitializers = [];
+    let _metadata_offset_decorators;
+    let _metadata_offset_initializers = [];
+    let _metadata_offset_extraInitializers = [];
+    let _label_decorators;
+    let _label_initializers = [];
+    let _label_extraInitializers = [];
+    let __padding_decorators;
+    let __padding_initializers = [];
+    let __padding_extraInitializers = [];
+    var SuperBlock = _classThis = class {
+        constructor(store) {
+            this.store = store;
+            /**
+             * The crc32c checksum for the super block.
+             * @privateRemarks Keep this first!
+             */
+            this.checksum = __runInitializers(this, _checksum_initializers, 0);
+            /** Signature for the superblock. */
+            this.magic = (__runInitializers(this, _checksum_extraInitializers), __runInitializers(this, _magic_initializers, sb_magic));
+            /** The version of the on-disk format */
+            this.version = (__runInitializers(this, _magic_extraInitializers), __runInitializers(this, _version_initializers, 1));
+            /** Which format of `Inode` is used */
+            this.inode_format = (__runInitializers(this, _version_extraInitializers), __runInitializers(this, _inode_format_initializers, _inode_version));
+            /** Flags for the file system. Currently unused */
+            this.flags = (__runInitializers(this, _inode_format_extraInitializers), __runInitializers(this, _flags_initializers, 0));
+            /** The number of used bytes, including the super block and metadata */
+            this.used_bytes = (__runInitializers(this, _flags_extraInitializers), __runInitializers(this, _used_bytes_initializers, BigInt(0)));
+            /** The total size of the entire file system, including the super block and metadata */
+            this.total_bytes = (__runInitializers(this, _used_bytes_extraInitializers), __runInitializers(this, _total_bytes_initializers, BigInt(0)));
+            /** An ID for this file system */
+            this.id = (__runInitializers(this, _total_bytes_extraInitializers), __runInitializers(this, _id_initializers, BigInt(0)));
+            /**
+             * The size in bytes of a metadata block.
+             * Not currently configurable.
+             */
+            this.metadata_block_size = (__runInitializers(this, _id_extraInitializers), __runInitializers(this, _metadata_block_size_initializers, sizeof(MetadataBlock)));
+            /** Reserved for 64-bit offset expansion */
+            this.metadata_offset_ = (__runInitializers(this, _metadata_block_size_extraInitializers), __runInitializers(this, _metadata_offset__initializers, 0));
+            /** Offset of the current metadata block */
+            this.metadata_offset = (__runInitializers(this, _metadata_offset__extraInitializers), __runInitializers(this, _metadata_offset_initializers, 0));
+            this.metadata = __runInitializers(this, _metadata_offset_extraInitializers);
+            /** An optional label for the file system */
+            this.label = __runInitializers(this, _label_initializers, '');
+            /** Padded to 256 bytes */
+            this._padding = (__runInitializers(this, _label_extraInitializers), __runInitializers(this, __padding_initializers, new Array(132).fill(0)));
+            __runInitializers(this, __padding_extraInitializers);
+            this.store = store;
+            if (store._view.getUint32(offsetof(SuperBlock, 'magic'), true) != sb_magic) {
+                warn('SingleBuffer: Invalid magic value. Assuming this is a fresh super block.');
+                this.metadata = new MetadataBlock(this);
+                this.used_bytes = BigInt(sizeof(SuperBlock) + sizeof(MetadataBlock));
+                this.total_bytes = BigInt(store._buffer.byteLength);
+                store._write(this);
+                store._write(this.metadata);
+                return;
+            }
+            deserialize(this, store._buffer.subarray(0, sizeof(SuperBlock)));
+            if (!checksumMatches(this))
+                throw crit(new ErrnoError(Errno.EIO, 'SingleBuffer: Checksum mismatch for super block!'));
+            this.metadata = new MetadataBlock(this, this.metadata_offset);
+        }
+        /**
+         * Rotate out the current metadata block.
+         * Allocates a new metadata block, moves the current one to backup,
+         * and updates used_bytes accordingly.
+         * @returns the new metadata block
+         */
+        rotateMetadata() {
+            const metadata = new MetadataBlock(this);
+            metadata.offset = Number(this.used_bytes);
+            metadata.previous_offset = this.metadata_offset;
+            this.metadata = metadata;
+            this.metadata_offset = metadata.offset;
+            this.store._write(metadata);
+            this.used_bytes += BigInt(sizeof(MetadataBlock));
+            this.store._write(this);
+            return metadata;
+        }
+        /**
+         * Checks to see if `length` bytes are unused, starting at `offset`.
+         * @internal Not for external use!
+         */
+        isUnused(offset, length) {
+            if (!length)
+                return true;
+            if (offset + length > this.total_bytes || offset < sizeof(SuperBlock))
+                return false;
+            for (let block = this.metadata; block; block = block.previous) {
+                if (offset < block.offset + sizeof(MetadataBlock) && offset + length > block.offset)
+                    return false;
+                for (const entry of block.entries) {
+                    if (!entry.offset)
+                        continue;
+                    if ((offset >= entry.offset && offset < entry.offset + entry.size)
+                        || (offset + length > entry.offset && offset + length <= entry.offset + entry.size)
+                        || (offset <= entry.offset && offset + length >= entry.offset + entry.size)) {
+                        return false;
+                    }
+                }
+            }
+            return true;
+        }
+    };
+    __setFunctionName(_classThis, "SuperBlock");
+    (() => {
+        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+        _checksum_decorators = [(_a = t).uint32.bind(_a)];
+        _magic_decorators = [(_b = t).uint32.bind(_b)];
+        _version_decorators = [(_c = t).uint16.bind(_c)];
+        _inode_format_decorators = [(_d = t).uint16.bind(_d)];
+        _flags_decorators = [(_e = t).uint32.bind(_e)];
+        _used_bytes_decorators = [(_f = t).uint64.bind(_f)];
+        _total_bytes_decorators = [(_g = t).uint64.bind(_g)];
+        _id_decorators = [(_h = t).uint128.bind(_h)];
+        _metadata_block_size_decorators = [(_j = t).uint32.bind(_j)];
+        _metadata_offset__decorators = [(_k = t).uint32.bind(_k)];
+        _metadata_offset_decorators = [(_l = t).uint32.bind(_l)];
+        _label_decorators = [t.char(64)];
+        __padding_decorators = [t.char(132)];
+        __esDecorate(null, null, _checksum_decorators, { kind: "field", name: "checksum", static: false, private: false, access: { has: obj => "checksum" in obj, get: obj => obj.checksum, set: (obj, value) => { obj.checksum = value; } }, metadata: _metadata }, _checksum_initializers, _checksum_extraInitializers);
+        __esDecorate(null, null, _magic_decorators, { kind: "field", name: "magic", static: false, private: false, access: { has: obj => "magic" in obj, get: obj => obj.magic, set: (obj, value) => { obj.magic = value; } }, metadata: _metadata }, _magic_initializers, _magic_extraInitializers);
+        __esDecorate(null, null, _version_decorators, { kind: "field", name: "version", static: false, private: false, access: { has: obj => "version" in obj, get: obj => obj.version, set: (obj, value) => { obj.version = value; } }, metadata: _metadata }, _version_initializers, _version_extraInitializers);
+        __esDecorate(null, null, _inode_format_decorators, { kind: "field", name: "inode_format", static: false, private: false, access: { has: obj => "inode_format" in obj, get: obj => obj.inode_format, set: (obj, value) => { obj.inode_format = value; } }, metadata: _metadata }, _inode_format_initializers, _inode_format_extraInitializers);
+        __esDecorate(null, null, _flags_decorators, { kind: "field", name: "flags", static: false, private: false, access: { has: obj => "flags" in obj, get: obj => obj.flags, set: (obj, value) => { obj.flags = value; } }, metadata: _metadata }, _flags_initializers, _flags_extraInitializers);
+        __esDecorate(null, null, _used_bytes_decorators, { kind: "field", name: "used_bytes", static: false, private: false, access: { has: obj => "used_bytes" in obj, get: obj => obj.used_bytes, set: (obj, value) => { obj.used_bytes = value; } }, metadata: _metadata }, _used_bytes_initializers, _used_bytes_extraInitializers);
+        __esDecorate(null, null, _total_bytes_decorators, { kind: "field", name: "total_bytes", static: false, private: false, access: { has: obj => "total_bytes" in obj, get: obj => obj.total_bytes, set: (obj, value) => { obj.total_bytes = value; } }, metadata: _metadata }, _total_bytes_initializers, _total_bytes_extraInitializers);
+        __esDecorate(null, null, _id_decorators, { kind: "field", name: "id", static: false, private: false, access: { has: obj => "id" in obj, get: obj => obj.id, set: (obj, value) => { obj.id = value; } }, metadata: _metadata }, _id_initializers, _id_extraInitializers);
+        __esDecorate(null, null, _metadata_block_size_decorators, { kind: "field", name: "metadata_block_size", static: false, private: false, access: { has: obj => "metadata_block_size" in obj, get: obj => obj.metadata_block_size, set: (obj, value) => { obj.metadata_block_size = value; } }, metadata: _metadata }, _metadata_block_size_initializers, _metadata_block_size_extraInitializers);
+        __esDecorate(null, null, _metadata_offset__decorators, { kind: "field", name: "metadata_offset_", static: false, private: false, access: { has: obj => "metadata_offset_" in obj, get: obj => obj.metadata_offset_, set: (obj, value) => { obj.metadata_offset_ = value; } }, metadata: _metadata }, _metadata_offset__initializers, _metadata_offset__extraInitializers);
+        __esDecorate(null, null, _metadata_offset_decorators, { kind: "field", name: "metadata_offset", static: false, private: false, access: { has: obj => "metadata_offset" in obj, get: obj => obj.metadata_offset, set: (obj, value) => { obj.metadata_offset = value; } }, metadata: _metadata }, _metadata_offset_initializers, _metadata_offset_extraInitializers);
+        __esDecorate(null, null, _label_decorators, { kind: "field", name: "label", static: false, private: false, access: { has: obj => "label" in obj, get: obj => obj.label, set: (obj, value) => { obj.label = value; } }, metadata: _metadata }, _label_initializers, _label_extraInitializers);
+        __esDecorate(null, null, __padding_decorators, { kind: "field", name: "_padding", static: false, private: false, access: { has: obj => "_padding" in obj, get: obj => obj._padding, set: (obj, value) => { obj._padding = value; } }, metadata: _metadata }, __padding_initializers, __padding_extraInitializers);
+        __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+        SuperBlock = _classThis = _classDescriptor.value;
+        if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        __runInitializers(_classThis, _classExtraInitializers);
+    })();
+    return SuperBlock = _classThis;
+})();
+function checksumMatches(value) {
+    const buffer = serialize(value);
+    const computed = crc32c(buffer.subarray(4)); // note we don't include the checksum when computing a new one.
+    return value.checksum === computed;
+}
+/**
+ *
+ * @category Stores and Transactions
+ */
+export class SingleBufferStore {
+    constructor(buffer) {
+        this.flags = [];
+        this.name = 'sbfs';
+        this.id = 0x73626673; // 'sbfs'
+        if (buffer.byteLength < sizeof(SuperBlock) + sizeof(MetadataBlock))
+            throw crit(new ErrnoError(Errno.EINVAL, 'SingleBuffer: Buffer is too small for a file system.'));
+        this._view = !ArrayBuffer.isView(buffer) ? new DataView(buffer) : new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+        this._buffer = !ArrayBuffer.isView(buffer) ? new Uint8Array(buffer) : new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+        this.superblock = new SuperBlock(this);
+    }
+    /**
+     * Update a block's checksum and write it to the store's buffer.
+     * @internal @hidden
+     */
+    _write(value) {
+        value.checksum = crc32c(serialize(value).subarray(4));
+        const offset = 'offset' in value ? value.offset : 0;
+        this._buffer.set(serialize(value), offset);
+    }
+    keys() {
+        const keys = new Set();
+        for (let block = this.superblock.metadata; block; block = block.previous) {
+            for (const entry of block.entries)
+                if (entry.offset)
+                    keys.add(entry.id);
+        }
+        return keys;
+    }
+    get(id) {
+        for (let block = this.superblock.metadata; block; block = block.previous) {
+            for (const entry of block.entries) {
+                if (entry.offset && entry.id == id) {
+                    return this._buffer.subarray(entry.offset, entry.offset + entry.size);
+                }
+            }
+        }
+    }
+    set(id, data) {
+        for (let block = this.superblock.metadata; block; block = block.previous) {
+            for (const entry of block.entries) {
+                if (!entry.offset || entry.id != id)
+                    continue;
+                if (data.length <= entry.size) {
+                    this._buffer.set(data, entry.offset);
+                    if (data.length < entry.size) {
+                        entry.size = data.length;
+                        this._write(block);
+                    }
+                    return;
+                }
+                if (this.superblock.isUnused(entry.offset, data.length)) {
+                    entry.size = data.length;
+                    this._buffer.set(data, entry.offset);
+                    this._write(block);
+                    return;
+                }
+                const used_bytes = Number(this.superblock.used_bytes);
+                for (let block = this.superblock.metadata; block; block = block.previous) {
+                    for (const entry of block.entries) {
+                        if (entry.offset != used_bytes)
+                            continue;
+                        entry.offset += data.length;
+                        this._write(block);
+                        break;
+                    }
+                }
+                entry.offset = used_bytes;
+                entry.size = data.length;
+                this._buffer.set(data, entry.offset);
+                this._write(block);
+                this.superblock.used_bytes += BigInt(data.length);
+                this._write(this.superblock);
+                return;
+            }
+        }
+        let entry = this.superblock.metadata.entries.find(e => !e.offset);
+        if (!entry) {
+            this.superblock.rotateMetadata();
+            entry = this.superblock.metadata.entries[0];
+        }
+        const offset = Number(this.superblock.used_bytes);
+        entry.id = id;
+        entry.offset = offset;
+        entry.size = data.length;
+        this._buffer.set(data, offset);
+        this.superblock.used_bytes += BigInt(data.length);
+        this._write(this.superblock.metadata);
+        this._write(this.superblock);
+    }
+    delete(id) {
+        for (let block = this.superblock.metadata; block; block = block.previous) {
+            for (const entry of block.entries) {
+                if (entry.id != id)
+                    continue;
+                entry.offset = 0;
+                entry.size = 0;
+                this._write(block);
+                return;
+            }
+        }
+    }
+    async sync() {
+        return;
+    }
+    usage() {
+        return {
+            totalSpace: Number(this.superblock.total_bytes),
+            freeSpace: Number(this.superblock.total_bytes - this.superblock.used_bytes),
+        };
+    }
+    transaction() {
+        return new SyncMapTransaction(this);
+    }
+}
+const _SingleBuffer = {
+    name: 'SingleBuffer',
+    options: {
+        buffer: { type: 'object', required: true },
+    },
+    create({ buffer }) {
+        const fs = new StoreFS(new SingleBufferStore(buffer));
+        fs.checkRootSync();
+        return fs;
+    },
+};
+/**
+ * A backend that uses a single buffer for storing data
+ * @category Backends and Configuration
+ */
+export const SingleBuffer = _SingleBuffer;

package/dist/backends/store/fs.d.ts

@@ -1,6 +1,6 @@
 import type { File } from '../../internal/file.js';
 import { Index } from '../../internal/file_index.js';
-import type { CreationOptions, PureCreationOptions } from '../../internal/filesystem.js';
+import type { CreationOptions, PureCreationOptions, UsageInfo } from '../../internal/filesystem.js';
 import { FileSystem } from '../../internal/filesystem.js';
 import { Inode, type InodeLike } from '../../internal/inode.js';
 import type { Stats } from '../../stats.js';
@@ -43,6 +43,10 @@ export declare class StoreFS<T extends Store = Store> extends FileSystem {
     protected _initialized: boolean;
     ready(): Promise<void>;
     constructor(store: T);
+    /**
+     * @experimental
+     */
+    usage(): UsageInfo;
     /**
      * Delete all contents stored in the file system.
      * @deprecated

package/dist/backends/store/fs.js

@@ -150,6 +150,16 @@ export class StoreFS extends FileSystem {
         store._fs = this;
         debug(this.name + ': supports features: ' + ((_b = this.store.flags) === null || _b === void 0 ? void 0 : _b.join(', ')));
     }
+    /**
+     * @experimental
+     */
+    usage() {
+        var _a, _b;
+        return (((_b = (_a = this.store).usage) === null || _b === void 0 ? void 0 : _b.call(_a)) || {
+            totalSpace: 0,
+            freeSpace: 0,
+        });
+    }
     /* node:coverage disable */
     /**
      * Delete all contents stored in the file system.

package/dist/backends/store/store.d.ts

@@ -1,6 +1,7 @@
 import { Resource } from 'utilium/cache.js';
 import '../../polyfills.js';
 import type { StoreFS } from './fs.js';
+import type { UsageInfo } from '../../internal/filesystem.js';
 /**
  * @category Stores and Transactions
  */
@@ -48,6 +49,10 @@ export interface Store {
      * Use for optimizations
      */
     readonly flags?: readonly StoreFlag[];
+    /**
+     * Usage information for the store
+     */
+    usage?(): UsageInfo;
     /**
      * @internal @hidden
      */

package/dist/internal/devices.js

@@ -244,7 +244,9 @@ export class DeviceFS extends StoreFS {
         debug('Added default devices.');
     }
     constructor() {
-        super(new InMemoryStore('devfs'));
+        // Please don't store your temporary files in /dev.
+        // If you do, you'll have up to 16 MiB
+        super(new InMemoryStore(0x1000000, 'devfs'));
         this.devices = new Map();
     }
     async rename(oldPath, newPath) {

package/dist/internal/file_index.d.ts

@@ -1,11 +1,13 @@
 import type { InodeLike } from './inode.js';
 import { Inode } from './inode.js';
+import type { UsageInfo } from './filesystem.js';
 /**
  * An Index in JSON form
  * @internal
  */
 export interface IndexData {
     version: number;
+    maxSize?: number;
     entries: Record<string, InodeLike>;
 }
 export declare const version = 1;
@@ -15,6 +17,7 @@ export declare const version = 1;
  * @internal
  */
 export declare class Index extends Map<string, Inode> {
+    maxSize: number;
     /**
      * Converts the index to JSON
      */
@@ -23,6 +26,11 @@ export declare class Index extends Map<string, Inode> {
      * Converts the index to a string
      */
     toString(): string;
+    /**
+     * Get the size in bytes of the index (including the size reported for each entry)
+     */
+    get byteSize(): number;
+    usage(): UsageInfo;
     pathOf(id: number): string | undefined;
     getByID(id: number): Inode | undefined;
     entryByID(id: number): {

package/dist/internal/file_index.js

@@ -1,9 +1,9 @@
 /* Note: this file is named file_index.ts because Typescript has special behavior regarding index.ts which can't be disabled. */
-import { isJSON, randomInt } from 'utilium';
+import { isJSON, randomInt, sizeof } from 'utilium';
 import { S_IFDIR, S_IFMT, size_max } from '../vfs/constants.js';
 import { basename, dirname } from '../vfs/path.js';
 import { Errno, ErrnoError } from './error.js';
-import { Inode } from './inode.js';
+import { __inode_sz, Inode } from './inode.js';
 export const version = 1;
 /**
  * An index of file metadata
@@ -11,12 +11,17 @@ export const version = 1;
  * @internal
  */
 export class Index extends Map {
+    constructor() {
+        super(...arguments);
+        this.maxSize = size_max;
+    }
     /**
      * Converts the index to JSON
      */
     toJSON() {
         return {
             version,
+            maxSize: this.maxSize,
             entries: Object.fromEntries([...this].map(([k, v]) => [k, v.toJSON()])),
         };
     }
@@ -26,6 +31,21 @@ export class Index extends Map {
     toString() {
         return JSON.stringify(this.toJSON());
     }
+    /**
+     * Get the size in bytes of the index (including the size reported for each entry)
+     */
+    get byteSize() {
+        let size = this.size * __inode_sz;
+        for (const entry of this.values())
+            size += entry.size;
+        return size;
+    }
+    usage() {
+        return {
+            totalSpace: this.maxSize,
+            freeSpace: this.maxSize - this.byteSize,
+        };
+    }
     pathOf(id) {
         for (const [path, inode] of this) {
             if (inode.ino == id || inode.data == id)

package/dist/internal/index_fs.d.ts

@@ -1,7 +1,7 @@
 import { Stats } from '../stats.js';
 import { type File } from './file.js';
 import { Index } from './file_index.js';
-import { FileSystem, type CreationOptions, type PureCreationOptions } from './filesystem.js';
+import { FileSystem, type CreationOptions, type PureCreationOptions, type UsageInfo } from './filesystem.js';
 import { Inode, type InodeLike } from './inode.js';
 /**
  * A file system that uses an `Index` for metadata.
@@ -11,6 +11,7 @@ import { Inode, type InodeLike } from './inode.js';
 export declare abstract class IndexFS extends FileSystem {
     readonly index: Index;
     constructor(id: number, name: string, index?: Index);
+    usage(): UsageInfo;
     /**
      * @deprecated
      */

package/dist/internal/index_fs.js

@@ -18,6 +18,9 @@ export class IndexFS extends FileSystem {
         super(id, name);
         this.index = index;
     }
+    usage() {
+        return this.index.usage();
+    }
     /* node:coverage disable */
     /**
      * @deprecated

package/dist/internal/inode.d.ts

@@ -21,6 +21,14 @@ export interface InodeLike extends StatsLike<number>, InodeFields {
  * @internal @hidden
  */
 export declare const _inode_fields: readonly ["ino", "data", "size", "mode", "flags", "nlink", "uid", "gid", "atimeMs", "birthtimeMs", "mtimeMs", "ctimeMs"];
+/**
+ * Represents which version of the `Inode` format we are on.
+ * 1. 58 bytes. The first member was called `ino` but used as the ID for data.
+ * 2. 66 bytes. Renamed the first member from `ino` to `data` and added a separate `ino` field
+ * 3. (current) 72 bytes. Changed the ID fields from 64 to 32 bits and added `flags`.
+ * @internal @hidden
+ */
+export declare const _inode_version = 3;
 /**
  * Generic inode definition that can easily be serialized.
  * @category Internals

package/dist/internal/inode.js

@@ -49,6 +49,14 @@ export const rootIno = 0;
  * @internal @hidden
  */
 export const _inode_fields = ['ino', 'data', 'size', 'mode', 'flags', 'nlink', 'uid', 'gid', 'atimeMs', 'birthtimeMs', 'mtimeMs', 'ctimeMs'];
+/**
+ * Represents which version of the `Inode` format we are on.
+ * 1. 58 bytes. The first member was called `ino` but used as the ID for data.
+ * 2. 66 bytes. Renamed the first member from `ino` to `data` and added a separate `ino` field
+ * 3. (current) 72 bytes. Changed the ID fields from 64 to 32 bits and added `flags`.
+ * @internal @hidden
+ */
+export const _inode_version = 3;
 /**
  * Generic inode definition that can easily be serialized.
  * @category Internals

package/dist/stats.js

@@ -233,11 +233,11 @@ export class BigIntStats extends StatsCommon {
  * @internal
  */
 export function isStatsEqual(left, right) {
-    return (left.size == right.size &&
-        +left.atime == +right.atime &&
-        +left.mtime == +right.mtime &&
-        +left.ctime == +right.ctime &&
-        left.mode == right.mode);
+    return (left.size == right.size
+        && +left.atime == +right.atime
+        && +left.mtime == +right.mtime
+        && +left.ctime == +right.ctime
+        && left.mode == right.mode);
 }
 /** @internal */
 export const ZenFsType = 0x7a656e6673; // 'z' 'e' 'n' 'f' 's'

package/dist/vfs/path.js

@@ -338,12 +338,12 @@ export function extname(path) {
             preDotState = -1;
         }
     }
-    if (startDot === -1 ||
-        end === -1 ||
+    if (startDot === -1
+        || end === -1
         // We saw a non-dot character immediately before the dot
-        preDotState === 0 ||
+        || preDotState === 0
         // The (right-most) trimmed path component is exactly '..'
-        (preDotState === 1 && startDot === end - 1 && startDot === startPart + 1)) {
+        || (preDotState === 1 && startDot === end - 1 && startDot === startPart + 1)) {
         return '';
     }
     return path.slice(startDot, end);
@@ -403,11 +403,11 @@ export function parse(path) {
     }
     if (end !== -1) {
         const start = startPart === 0 && isAbsolute ? 1 : startPart;
-        if (startDot === -1 ||
+        if (startDot === -1
             // We saw a non-dot character immediately before the dot
-            preDotState === 0 ||
+            || preDotState === 0
             // The (right-most) trimmed path component is exactly '..'
-            (preDotState === 1 && startDot === end - 1 && startDot === startPart + 1)) {
+            || (preDotState === 1 && startDot === end - 1 && startDot === startPart + 1)) {
             ret.base = ret.name = path.slice(start, end);
         }
         else {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@zenfs/core",
-	"version": "1.9.5",
+	"version": "1.10.0",
 	"description": "A filesystem, anywhere",
 	"funding": {
 		"type": "individual",
@@ -70,7 +70,7 @@
 		"buffer": "^6.0.3",
 		"eventemitter3": "^5.0.1",
 		"readable-stream": "^4.5.2",
-		"utilium": "^1.2.10"
+		"utilium": "^1.3.1"
 	},
 	"devDependencies": {
 		"@eslint/js": "^9.8.0",

package/tests/setup/single-buffer.ts

@@ -0,0 +1,9 @@
+import { SingleBuffer, configureSingle } from '../../dist/index.js';
+import { copySync, data } from '../setup.js';
+
+await configureSingle({
+	backend: SingleBuffer,
+	buffer: new ArrayBuffer(0x100000),
+});
+
+copySync(data);