@zenfs/core 1.7.2 → 1.8.0

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

@@ -0,0 +1,34 @@
+import type { File } from '../../file.js';
+import type { CreationOptions } from '../../filesystem.js';
+import { Stats } from '../../stats.js';
+import type { IndexData } from './file_index.js';
+import { Index } from './file_index.js';
+import { StoreFS } from './fs.js';
+import type { Store } from './store.js';
+/**
+ * Uses an `Index` for metadata.
+ *
+ * Implementors: You *must* populate the underlying store for read operations to work!
+ * @deprecated
+ */
+export declare abstract class IndexFS<T extends Store> extends StoreFS<T> {
+    private indexData;
+    protected readonly index: Index;
+    protected _isInitialized: boolean;
+    ready(): Promise<void>;
+    constructor(store: T, indexData: IndexData | Promise<IndexData>);
+    /**
+     * @deprecated
+     */
+    reloadFiles(): Promise<void>;
+    /**
+     * @deprecated
+     */
+    reloadFilesSync(): void;
+    stat(path: string): Promise<Stats>;
+    statSync(path: string): Stats;
+    createFile(path: string, flag: string, mode: number, options: CreationOptions): Promise<File>;
+    createFileSync(path: string, flag: string, mode: number, options: CreationOptions): File;
+    sync(path: string, data: Uint8Array, stats: Readonly<Stats>): Promise<void>;
+    syncSync(path: string, data: Uint8Array, stats: Readonly<Stats>): void;
+}

package/dist/backends/store/index_fs.js

@@ -0,0 +1,67 @@
+import { ErrnoError } from '../../error.js';
+import { PreloadFile } from '../../file.js';
+import { Stats } from '../../stats.js';
+import { S_IFREG } from '../../vfs/constants.js';
+import { Index } from './file_index.js';
+import { StoreFS } from './fs.js';
+/**
+ * Uses an `Index` for metadata.
+ *
+ * Implementors: You *must* populate the underlying store for read operations to work!
+ * @deprecated
+ */
+/* node:coverage disable */
+export class IndexFS extends StoreFS {
+    async ready() {
+        await super.ready();
+        if (this._isInitialized)
+            return;
+        this.index.fromJSON(await this.indexData);
+        this._isInitialized = true;
+    }
+    constructor(store, indexData) {
+        super(store);
+        this.indexData = indexData;
+        this.index = new Index();
+        this._isInitialized = false;
+    }
+    /**
+     * @deprecated
+     */
+    async reloadFiles() { }
+    /**
+     * @deprecated
+     */
+    reloadFilesSync() { }
+    stat(path) {
+        return Promise.resolve(this.statSync(path));
+    }
+    statSync(path) {
+        if (!this.index.has(path))
+            throw ErrnoError.With('ENOENT', path, 'stat');
+        return new Stats(this.index.get(path));
+    }
+    async createFile(path, flag, mode, options) {
+        const node = await this.commitNew(path, S_IFREG, { mode, ...options }, new Uint8Array(), 'createFile');
+        const file = new PreloadFile(this, path, flag, node.toStats(), new Uint8Array());
+        this.index.set(path, node);
+        return file;
+    }
+    createFileSync(path, flag, mode, options) {
+        const node = this.commitNewSync(path, S_IFREG, { mode, ...options }, new Uint8Array(), 'createFile');
+        const file = new PreloadFile(this, path, flag, node.toStats(), new Uint8Array());
+        this.index.set(path, node);
+        return file;
+    }
+    async sync(path, data, stats) {
+        var _a;
+        (_a = this.index.get(path)) === null || _a === void 0 ? void 0 : _a.update(stats);
+        await super.sync(path, data, stats);
+    }
+    syncSync(path, data, stats) {
+        var _a;
+        (_a = this.index.get(path)) === null || _a === void 0 ? void 0 : _a.update(stats);
+        super.syncSync(path, data, stats);
+    }
+}
+/* node:coverage enable */

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

@@ -1,17 +1,29 @@
 import { Stats, type StatsLike } from '../../stats.js';
 /**
- * Room inode
+ * Root inode
  * @hidden
  */
-export declare const rootIno: 0n;
+export declare const rootIno = 0;
+export interface InodeFields {
+    data?: number;
+    flags?: number;
+}
+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"];
 /**
  * Generic inode definition that can easily be serialized.
  * @internal
  * @todo [BREAKING] Remove 58 byte Inode upgrade path
  */
-export declare class Inode implements StatsLike {
-    constructor(buffer?: ArrayBufferLike | ArrayBufferView);
-    data: bigint;
+export declare class Inode implements InodeLike {
+    constructor(data?: ArrayBufferLike | ArrayBufferView | Readonly<InodeLike>);
+    data: number;
+    /** For future use */
+    __data_old: number;
     size: number;
     mode: number;
     nlink: number;
@@ -21,7 +33,13 @@ export declare class Inode implements StatsLike {
     birthtimeMs: number;
     mtimeMs: number;
     ctimeMs: number;
-    ino: bigint;
+    ino: number;
+    /** For future use */
+    __ino_old: number;
+    flags: number;
+    /** For future use */
+    __padding: number;
+    toJSON(): InodeLike;
     /**
      * Handy function that converts the Inode to a Node Stats object.
      */
@@ -34,7 +52,7 @@ export declare class Inode implements StatsLike {
      *   metadata changes locally -- typically in a Stats object.
      * - Program closes file. File object's metadata changes are synced with the
      *   file system.
-     * @return True if any changes have occurred.
+     * @returns whether any changes have occurred.
      */
-    update(stats: Readonly<Stats>): boolean;
+    update(data?: Partial<Readonly<InodeLike>>): boolean;
 }

package/dist/backends/store/inode.js

@@ -36,21 +36,25 @@ var __setFunctionName = (this && this.__setFunctionName) || function (f, name, p
     if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : "";
     return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name });
 };
-import { deserialize, sizeof, struct, types as t } from 'utilium';
+import { deserialize, pick, randomInt, sizeof, struct, types as t } from 'utilium';
 import { Stats } from '../../stats.js';
-import { randomBigInt } from '../../utils.js';
+import { size_max } from '../../vfs/constants.js';
 /**
- * Room inode
+ * Root inode
  * @hidden
  */
-export const rootIno = BigInt(0);
+export const rootIno = 0;
+/**
+ * @internal @hidden
+ */
+export const _inode_fields = ['ino', 'data', 'size', 'mode', 'flags', 'nlink', 'uid', 'gid', 'atimeMs', 'birthtimeMs', 'mtimeMs', 'ctimeMs'];
 /**
  * Generic inode definition that can easily be serialized.
  * @internal
  * @todo [BREAKING] Remove 58 byte Inode upgrade path
  */
 let Inode = (() => {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q;
     let _classDecorators = [struct()];
     let _classDescriptor;
     let _classExtraInitializers = [];
@@ -58,6 +62,9 @@ let Inode = (() => {
     let _data_decorators;
     let _data_initializers = [];
     let _data_extraInitializers = [];
+    let ___data_old_decorators;
+    let ___data_old_initializers = [];
+    let ___data_old_extraInitializers = [];
     let _size_decorators;
     let _size_initializers = [];
     let _size_extraInitializers = [];
@@ -88,52 +95,56 @@ let Inode = (() => {
     let _ino_decorators;
     let _ino_initializers = [];
     let _ino_extraInitializers = [];
+    let ___ino_old_decorators;
+    let ___ino_old_initializers = [];
+    let ___ino_old_extraInitializers = [];
+    let _flags_decorators;
+    let _flags_initializers = [];
+    let _flags_extraInitializers = [];
+    let ___padding_decorators;
+    let ___padding_initializers = [];
+    let ___padding_extraInitializers = [];
     var Inode = _classThis = class {
-        constructor(buffer) {
-            this.data = __runInitializers(this, _data_initializers, void 0);
-            this.size = (__runInitializers(this, _data_extraInitializers), __runInitializers(this, _size_initializers, void 0));
-            this.mode = (__runInitializers(this, _size_extraInitializers), __runInitializers(this, _mode_initializers, void 0));
-            this.nlink = (__runInitializers(this, _mode_extraInitializers), __runInitializers(this, _nlink_initializers, void 0));
-            this.uid = (__runInitializers(this, _nlink_extraInitializers), __runInitializers(this, _uid_initializers, void 0));
-            this.gid = (__runInitializers(this, _uid_extraInitializers), __runInitializers(this, _gid_initializers, void 0));
-            this.atimeMs = (__runInitializers(this, _gid_extraInitializers), __runInitializers(this, _atimeMs_initializers, void 0));
-            this.birthtimeMs = (__runInitializers(this, _atimeMs_extraInitializers), __runInitializers(this, _birthtimeMs_initializers, void 0));
-            this.mtimeMs = (__runInitializers(this, _birthtimeMs_extraInitializers), __runInitializers(this, _mtimeMs_initializers, void 0));
-            this.ctimeMs = (__runInitializers(this, _mtimeMs_extraInitializers), __runInitializers(this, _ctimeMs_initializers, void 0));
-            this.ino = (__runInitializers(this, _ctimeMs_extraInitializers), __runInitializers(this, _ino_initializers, void 0));
-            __runInitializers(this, _ino_extraInitializers);
-            if (buffer) {
-                const sz_inode = sizeof(Inode);
-                const oldSize = sz_inode - sizeof('uint64');
-                if (buffer.byteLength < oldSize) {
-                    throw new RangeError(`Can not create an inode from a buffer less than ${oldSize} bytes`);
-                }
-                // Expand the buffer so it is the right size
-                if (buffer.byteLength < sz_inode) {
-                    const newBuffer = new Uint8Array(sz_inode);
-                    const buf = ArrayBuffer.isView(buffer) ? buffer.buffer : buffer;
-                    // Fill the new buffer with current data
-                    newBuffer.set(new Uint8Array(buf));
-                    /* 	Add a random ino.
-                        This will be different from the actual one,
-                        but `ino` isn't used anywhere so it should be fine.
-                    */
-                    new DataView(newBuffer.buffer).setBigUint64(sz_inode - 1, randomBigInt());
-                    buffer = newBuffer;
-                }
-                deserialize(this, buffer);
+        constructor(data) {
+            this.data = __runInitializers(this, _data_initializers, randomInt(0, size_max));
+            /** For future use */
+            this.__data_old = (__runInitializers(this, _data_extraInitializers), __runInitializers(this, ___data_old_initializers, 0));
+            this.size = (__runInitializers(this, ___data_old_extraInitializers), __runInitializers(this, _size_initializers, 4096));
+            this.mode = (__runInitializers(this, _size_extraInitializers), __runInitializers(this, _mode_initializers, 0));
+            this.nlink = (__runInitializers(this, _mode_extraInitializers), __runInitializers(this, _nlink_initializers, 1));
+            this.uid = (__runInitializers(this, _nlink_extraInitializers), __runInitializers(this, _uid_initializers, 0));
+            this.gid = (__runInitializers(this, _uid_extraInitializers), __runInitializers(this, _gid_initializers, 0));
+            this.atimeMs = (__runInitializers(this, _gid_extraInitializers), __runInitializers(this, _atimeMs_initializers, Date.now()));
+            this.birthtimeMs = (__runInitializers(this, _atimeMs_extraInitializers), __runInitializers(this, _birthtimeMs_initializers, Date.now()));
+            this.mtimeMs = (__runInitializers(this, _birthtimeMs_extraInitializers), __runInitializers(this, _mtimeMs_initializers, Date.now()));
+            this.ctimeMs = (__runInitializers(this, _mtimeMs_extraInitializers), __runInitializers(this, _ctimeMs_initializers, Date.now()));
+            this.ino = (__runInitializers(this, _ctimeMs_extraInitializers), __runInitializers(this, _ino_initializers, randomInt(0, size_max)));
+            /** For future use */
+            this.__ino_old = (__runInitializers(this, _ino_extraInitializers), __runInitializers(this, ___ino_old_initializers, 0));
+            this.flags = (__runInitializers(this, ___ino_old_extraInitializers), __runInitializers(this, _flags_initializers, 0));
+            /** For future use */
+            this.__padding = (__runInitializers(this, _flags_extraInitializers), __runInitializers(this, ___padding_initializers, 0));
+            __runInitializers(this, ___padding_extraInitializers);
+            if (!data)
+                return;
+            if (!('byteLength' in data)) {
+                Object.assign(this, data);
                 return;
             }
-            // set defaults on a fresh inode
-            this.ino = randomBigInt();
-            this.data = randomBigInt();
-            this.nlink = 1;
-            this.size = 4096;
-            const now = Date.now();
-            this.atimeMs = now;
-            this.mtimeMs = now;
-            this.ctimeMs = now;
-            this.birthtimeMs = now;
+            if (data.byteLength < 58) {
+                throw 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) {
+                const buf = ArrayBuffer.isView(data) ? data.buffer : data;
+                const newBuffer = new Uint8Array(sz_inode);
+                newBuffer.set(new Uint8Array(buf));
+                data = newBuffer;
+            }
+            deserialize(this, data);
+        }
+        toJSON() {
+            return pick(this, _inode_fields);
         }
         /**
          * Handy function that converts the Inode to a Node Stats object.
@@ -149,40 +160,21 @@ let Inode = (() => {
          *   metadata changes locally -- typically in a Stats object.
          * - Program closes file. File object's metadata changes are synced with the
          *   file system.
-         * @return True if any changes have occurred.
+         * @returns whether any changes have occurred.
          */
-        update(stats) {
+        update(data) {
+            if (!data)
+                return false;
             let hasChanged = false;
-            if (this.size !== stats.size) {
-                this.size = stats.size;
-                hasChanged = true;
-            }
-            if (this.mode !== stats.mode) {
-                this.mode = stats.mode;
-                hasChanged = true;
-            }
-            if (this.nlink !== stats.nlink) {
-                this.nlink = stats.nlink;
-                hasChanged = true;
-            }
-            if (this.uid !== stats.uid) {
-                this.uid = stats.uid;
-                hasChanged = true;
-            }
-            if (this.gid !== stats.gid) {
-                this.gid = stats.gid;
-                hasChanged = true;
-            }
-            if (this.atimeMs !== stats.atimeMs) {
-                this.atimeMs = stats.atimeMs;
-                hasChanged = true;
-            }
-            if (this.mtimeMs !== stats.mtimeMs) {
-                this.mtimeMs = stats.mtimeMs;
-                hasChanged = true;
-            }
-            if (this.ctimeMs !== stats.ctimeMs) {
-                this.ctimeMs = stats.ctimeMs;
+            for (const key of _inode_fields) {
+                if (data[key] === undefined)
+                    continue;
+                // When multiple StoreFSes are used in a single stack, the differing IDs end up here.
+                if (key == 'ino' || key == 'data')
+                    continue;
+                if (this[key] === data[key])
+                    continue;
+                this[key] = data[key];
                 hasChanged = true;
             }
             return hasChanged;
@@ -191,18 +183,23 @@ let Inode = (() => {
     __setFunctionName(_classThis, "Inode");
     (() => {
         const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
-        _data_decorators = [(_a = t).uint64.bind(_a)];
-        _size_decorators = [(_b = t).uint32.bind(_b)];
-        _mode_decorators = [(_c = t).uint16.bind(_c)];
-        _nlink_decorators = [(_d = t).uint32.bind(_d)];
-        _uid_decorators = [(_e = t).uint32.bind(_e)];
-        _gid_decorators = [(_f = t).uint32.bind(_f)];
-        _atimeMs_decorators = [(_g = t).float64.bind(_g)];
-        _birthtimeMs_decorators = [(_h = t).float64.bind(_h)];
-        _mtimeMs_decorators = [(_j = t).float64.bind(_j)];
-        _ctimeMs_decorators = [(_k = t).float64.bind(_k)];
-        _ino_decorators = [(_l = t).uint64.bind(_l)];
+        _data_decorators = [(_a = t).uint32.bind(_a)];
+        ___data_old_decorators = [(_b = t).uint32.bind(_b)];
+        _size_decorators = [(_c = t).uint32.bind(_c)];
+        _mode_decorators = [(_d = t).uint16.bind(_d)];
+        _nlink_decorators = [(_e = t).uint32.bind(_e)];
+        _uid_decorators = [(_f = t).uint32.bind(_f)];
+        _gid_decorators = [(_g = t).uint32.bind(_g)];
+        _atimeMs_decorators = [(_h = t).float64.bind(_h)];
+        _birthtimeMs_decorators = [(_j = t).float64.bind(_j)];
+        _mtimeMs_decorators = [(_k = t).float64.bind(_k)];
+        _ctimeMs_decorators = [(_l = t).float64.bind(_l)];
+        _ino_decorators = [(_m = t).uint32.bind(_m)];
+        ___ino_old_decorators = [(_o = t).uint32.bind(_o)];
+        _flags_decorators = [(_p = t).uint32.bind(_p)];
+        ___padding_decorators = [(_q = t).uint16.bind(_q)];
         __esDecorate(null, null, _data_decorators, { kind: "field", name: "data", static: false, private: false, access: { has: obj => "data" in obj, get: obj => obj.data, set: (obj, value) => { obj.data = value; } }, metadata: _metadata }, _data_initializers, _data_extraInitializers);
+        __esDecorate(null, null, ___data_old_decorators, { kind: "field", name: "__data_old", static: false, private: false, access: { has: obj => "__data_old" in obj, get: obj => obj.__data_old, set: (obj, value) => { obj.__data_old = value; } }, metadata: _metadata }, ___data_old_initializers, ___data_old_extraInitializers);
         __esDecorate(null, null, _size_decorators, { kind: "field", name: "size", static: false, private: false, access: { has: obj => "size" in obj, get: obj => obj.size, set: (obj, value) => { obj.size = value; } }, metadata: _metadata }, _size_initializers, _size_extraInitializers);
         __esDecorate(null, null, _mode_decorators, { kind: "field", name: "mode", static: false, private: false, access: { has: obj => "mode" in obj, get: obj => obj.mode, set: (obj, value) => { obj.mode = value; } }, metadata: _metadata }, _mode_initializers, _mode_extraInitializers);
         __esDecorate(null, null, _nlink_decorators, { kind: "field", name: "nlink", static: false, private: false, access: { has: obj => "nlink" in obj, get: obj => obj.nlink, set: (obj, value) => { obj.nlink = value; } }, metadata: _metadata }, _nlink_initializers, _nlink_extraInitializers);
@@ -213,6 +210,9 @@ let Inode = (() => {
         __esDecorate(null, null, _mtimeMs_decorators, { kind: "field", name: "mtimeMs", static: false, private: false, access: { has: obj => "mtimeMs" in obj, get: obj => obj.mtimeMs, set: (obj, value) => { obj.mtimeMs = value; } }, metadata: _metadata }, _mtimeMs_initializers, _mtimeMs_extraInitializers);
         __esDecorate(null, null, _ctimeMs_decorators, { kind: "field", name: "ctimeMs", static: false, private: false, access: { has: obj => "ctimeMs" in obj, get: obj => obj.ctimeMs, set: (obj, value) => { obj.ctimeMs = value; } }, metadata: _metadata }, _ctimeMs_initializers, _ctimeMs_extraInitializers);
         __esDecorate(null, null, _ino_decorators, { kind: "field", name: "ino", static: false, private: false, access: { has: obj => "ino" in obj, get: obj => obj.ino, set: (obj, value) => { obj.ino = value; } }, metadata: _metadata }, _ino_initializers, _ino_extraInitializers);
+        __esDecorate(null, null, ___ino_old_decorators, { kind: "field", name: "__ino_old", static: false, private: false, access: { has: obj => "__ino_old" in obj, get: obj => obj.__ino_old, set: (obj, value) => { obj.__ino_old = value; } }, metadata: _metadata }, ___ino_old_initializers, ___ino_old_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, ___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);
         Inode = _classThis = _classDescriptor.value;
         if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
@@ -221,3 +221,4 @@ let Inode = (() => {
     return Inode = _classThis;
 })();
 export { Inode };
+const sz_inode = sizeof(Inode);

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

@@ -3,10 +3,10 @@ import { SyncTransaction, type Store } from './store.js';
  * An interface for simple synchronous stores that don't have special support for transactions and such.
  */
 export interface SimpleSyncStore extends Store {
-    keys(): Iterable<bigint>;
-    get(id: bigint): Uint8Array | undefined;
-    set(id: bigint, data: Uint8Array): void;
-    delete(id: bigint): void;
+    keys(): Iterable<number>;
+    get(id: number): Uint8Array | undefined;
+    set(id: number, data: Uint8Array, isMetadata?: boolean): void;
+    delete(id: number): void;
 }
 /**
  * An interface for simple asynchronous stores that don't have special support for transactions and such.
@@ -14,15 +14,15 @@ export interface SimpleSyncStore extends Store {
  */
 export declare abstract class SimpleAsyncStore implements SimpleSyncStore {
     abstract name: string;
-    protected cache: Map<bigint, Uint8Array>;
+    protected cache: Map<number, Uint8Array>;
     protected queue: Set<Promise<unknown>>;
-    protected abstract entries(): Promise<Iterable<[bigint, Uint8Array]>>;
-    keys(): Iterable<bigint>;
-    get(id: bigint): Uint8Array | undefined;
-    set(id: bigint, data: Uint8Array): void;
-    protected abstract _set(ino: bigint, data: Uint8Array): Promise<void>;
-    delete(id: bigint): void;
-    protected abstract _delete(ino: bigint): Promise<void>;
+    protected abstract entries(): Promise<Iterable<[number, Uint8Array]>>;
+    keys(): Iterable<number>;
+    get(id: number): Uint8Array | undefined;
+    set(id: number, data: Uint8Array): void;
+    protected abstract _set(ino: number, data: Uint8Array): Promise<void>;
+    delete(id: number): void;
+    protected abstract _delete(ino: number): Promise<void>;
     clearSync(): void;
     abstract clear(): Promise<void>;
     sync(): Promise<void>;
@@ -38,16 +38,16 @@ export declare class SimpleTransaction extends SyncTransaction<SimpleSyncStore>
      * Stores data in the keys we modify prior to modifying them.
      * Allows us to roll back commits.
      */
-    protected originalData: Map<bigint, Uint8Array | void>;
+    protected originalData: Map<number, Uint8Array | void>;
     /**
      * List of keys modified in this transaction, if any.
      */
-    protected modifiedKeys: Set<bigint>;
+    protected modifiedKeys: Set<number>;
     protected store: SimpleSyncStore;
-    keysSync(): Iterable<bigint>;
-    getSync(id: bigint): Uint8Array;
-    setSync(id: bigint, data: Uint8Array): void;
-    removeSync(id: bigint): void;
+    keysSync(): Iterable<number>;
+    getSync(id: number): Uint8Array;
+    setSync(id: number, data: Uint8Array, isMetadata?: boolean): void;
+    removeSync(id: number): void;
     commitSync(): void;
     abortSync(): void;
     /**
@@ -56,10 +56,10 @@ export declare class SimpleTransaction extends SyncTransaction<SimpleSyncStore>
      * prevent needless `get` requests if the program modifies the data later
      * on during the transaction.
      */
-    protected stashOldValue(id: bigint, value?: Uint8Array): void;
+    protected stashOldValue(id: number, value?: Uint8Array): void;
     /**
      * Marks `ino` as modified, and stashes its value if it has not been
      * stashed already.
      */
-    protected markModified(id: bigint): void;
+    protected markModified(id: number): void;
 }

package/dist/backends/store/simple.js

@@ -66,9 +66,9 @@ export class SimpleTransaction extends SyncTransaction {
         this.stashOldValue(id, val);
         return val;
     }
-    setSync(id, data) {
+    setSync(id, data, isMetadata) {
         this.markModified(id);
-        return this.store.set(id, data);
+        return this.store.set(id, data, isMetadata);
     }
     removeSync(id) {
         this.markModified(id);
@@ -78,9 +78,8 @@ export class SimpleTransaction extends SyncTransaction {
         this.done = true;
     }
     abortSync() {
-        if (!this.done) {
+        if (this.done)
             return;
-        }
         // Rollback old values.
         for (const key of this.modifiedKeys) {
             const value = this.originalData.get(key);

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

@@ -37,45 +37,45 @@ export declare abstract class Transaction<T extends Store = Store> {
     /**
      * Gets all of the keys
      */
-    abstract keys(): Promise<Iterable<bigint>>;
+    abstract keys(): Promise<Iterable<number>>;
     /**
      * Gets all of the keys
      */
-    abstract keysSync(): Iterable<bigint>;
+    abstract keysSync(): Iterable<number>;
     /**
      * Retrieves data.
      * @param id The key to look under for data.
      */
-    abstract get(id: bigint): Promise<Uint8Array>;
+    abstract get(id: number): Promise<Uint8Array>;
     /**
      * Retrieves data.
      * Throws an error if an error occurs or if the key does not exist.
      * @param id The key to look under for data.
      * @return The data stored under the key, or undefined if not present.
      */
-    abstract getSync(id: bigint): Uint8Array;
+    abstract getSync(id: number): Uint8Array;
     /**
      * Adds the data to the store under an id. Overwrites any existing data.
      * @param id The key to add the data under.
      * @param data The data to add to the store.
      */
-    abstract set(id: bigint, data: Uint8Array): Promise<void>;
+    abstract set(id: number, data: Uint8Array, isMetadata?: boolean): Promise<void>;
     /**
      * Adds the data to the store under and id.
      * @param id The key to add the data under.
      * @param data The data to add to the store.
      */
-    abstract setSync(id: bigint, data: Uint8Array): void;
+    abstract setSync(id: number, data: Uint8Array, isMetadata?: boolean): void;
     /**
      * Deletes the data at `ino`.
      * @param id The key to delete from the store.
      */
-    abstract remove(id: bigint): Promise<void>;
+    abstract remove(id: number): Promise<void>;
     /**
      * Deletes the data at `ino`.
      * @param id The key to delete from the store.
      */
-    abstract removeSync(id: bigint): void;
+    abstract removeSync(id: number): void;
     /**
      * Commits the transaction.
      */
@@ -99,10 +99,10 @@ export declare abstract class Transaction<T extends Store = Store> {
  * Transaction that implements asynchronous operations with synchronous ones
  */
 export declare abstract class SyncTransaction<T extends Store = Store> extends Transaction<T> {
-    keys(): Promise<Iterable<bigint>>;
-    get(id: bigint): Promise<Uint8Array>;
-    set(id: bigint, data: Uint8Array): Promise<void>;
-    remove(id: bigint): Promise<void>;
+    keys(): Promise<Iterable<number>>;
+    get(id: number): Promise<Uint8Array>;
+    set(id: number, data: Uint8Array, isMetadata?: boolean): Promise<void>;
+    remove(id: number): Promise<void>;
     commit(): Promise<void>;
     abort(): Promise<void>;
 }

package/dist/backends/store/store.js

@@ -12,15 +12,13 @@ export class Transaction {
         this.done = false;
     }
     async [Symbol.asyncDispose]() {
-        if (this.done) {
+        if (this.done)
             return;
-        }
         await this.abort();
     }
     [Symbol.dispose]() {
-        if (this.done) {
+        if (this.done)
             return;
-        }
         this.abortSync();
     }
 }
@@ -35,8 +33,8 @@ export class SyncTransaction extends Transaction {
     async get(id) {
         return this.getSync(id);
     }
-    async set(id, data) {
-        return this.setSync(id, data);
+    async set(id, data, isMetadata) {
+        return this.setSync(id, data, isMetadata);
     }
     async remove(id) {
         return this.removeSync(id);