@based/db 0.0.67 → 0.0.69

package/dist/src/native.js

@@ -100,6 +100,9 @@ const native = {
     membarSyncWrite: () => {
         db.membarSyncWrite();
     },
+    selvaStrerror: (err) => {
+        return db.selvaStrerror(err);
+    },
     colvecTest: (dbCtx, typeId, field, nodeId, len) => {
         return db.colvecTest(dbCtx, typeId, field, nodeId, len);
     }

package/dist/src/server/IoWorker.d.ts

@@ -3,6 +3,22 @@ import { DbServer } from './index.js';
 export declare class IoWorker extends DbWorker {
     constructor(address: BigInt, db: DbServer);
     handleMsg(_buf: any): void;
+    private cb;
+    /**
+     * Save given blocks and return errors and hashes in an array.
+     * @returns [[4 bytes err], [16 bytes hash]][] with the same length as blocks.
+     */
+    saveBlocks(blocks: {
+        filepath: string;
+        typeId: number;
+        start: number;
+    }[]): Promise<Uint8Array>;
     loadBlock(filepath: string): Promise<void>;
+    /**
+     * Save a block and discard it from memory "atomically".
+     * Note that this worker doesn't give any protection from other threads
+     * accessing the block concurrently, and it must be coordinated in the
+     * main thread.
+     */
     unloadBlock(filepath: string, typeId: number, start: number): Promise<Uint8Array>;
 }

package/dist/src/server/IoWorker.js

@@ -1,5 +1,6 @@
 import { DbWorker } from './workers/DbWorker.js';
 import { DECODER, readInt32 } from '@saulx/utils';
+import native from '../native.js';
 export class IoWorker extends DbWorker {
     constructor(address, db) {
         const onExit = (_code) => {
@@ -9,27 +10,55 @@ export class IoWorker extends DbWorker {
     }
     handleMsg(_buf) {
     }
+    cb = (resolve) => {
+        this.db.activeReaders++;
+        this.resolvers.push((r) => {
+            this.db.activeReaders--;
+            resolve(r);
+            //this.db.onQueryEnd()
+        });
+    };
+    /**
+     * Save given blocks and return errors and hashes in an array.
+     * @returns [[4 bytes err], [16 bytes hash]][] with the same length as blocks.
+     */
+    async saveBlocks(blocks) {
+        const job = {
+            type: 'save',
+            blocks,
+        };
+        this.channel.postMessage(job);
+        const resBufP = new Promise(this.cb);
+        resBufP.then(() => this.db.onQueryEnd());
+        return resBufP;
+    }
     async loadBlock(filepath) {
         const job = {
             type: 'load',
-            filepath
+            filepath,
         };
         const resBuf = await this.call(job);
         if (resBuf.length) {
             throw new Error(DECODER.decode(resBuf));
         }
     }
+    /**
+     * Save a block and discard it from memory "atomically".
+     * Note that this worker doesn't give any protection from other threads
+     * accessing the block concurrently, and it must be coordinated in the
+     * main thread.
+     */
     async unloadBlock(filepath, typeId, start) {
         const job = {
             type: 'unload',
             filepath,
             typeId,
-            start
+            start,
         };
         const resBuf = await this.call(job);
         const err = readInt32(resBuf, 0);
         if (err) {
-            throw new Error(`selva error: ${err}`);
+            throw new Error(native.selvaStrerror(err));
         }
         // Note that this shares the original buffer which may not be 100% optimal,
         // as the first 4 bytes are no longer needed.

package/dist/src/server/QueryWorker.js

@@ -8,11 +8,11 @@ export class QueryWorker extends DbWorker {
         super(address, db, onExit, 'query_worker.js');
     }
     handleMsg(_buf) {
-        this.db.processingQueries--;
+        this.db.activeReaders--;
         this.db.onQueryEnd();
     }
     callback = (resolve) => {
-        this.db.processingQueries++;
+        this.db.activeReaders++;
         this.resolvers.push(resolve);
     };
     getQueryBuf(buf) {

package/dist/src/server/blocks.d.ts

@@ -1,11 +1,13 @@
 import { SchemaTypeDef } from '@based/schema/def';
 import { DbServer } from './index.js';
+import { IoJobSave } from './workers/io_worker_types.js';
 /**
  * Save a block.
  */
 export declare function saveBlock(db: DbServer, typeId: number, start: number, end: number): void;
+export declare function saveBlocks(db: DbServer, blocks: IoJobSave['blocks']): Promise<void>;
 /**
- * Load a block (typically of a partial type) back to memory.
+ * Load an existing block (typically of a partial type) back to memory.
  */
 export declare function loadBlock(db: DbServer, def: SchemaTypeDef, start: number): Promise<void>;
 /**

package/dist/src/server/blocks.js

@@ -1,7 +1,8 @@
 import native from '../native.js';
 import { join } from 'node:path';
-import { equals } from '@saulx/utils';
+import { equals, readInt32 } from '@saulx/utils';
 import { VerifTree, destructureTreeKey, makeTreeKey, } from './tree.js';
+const SELVA_ENOENT = -8;
 /**
  * Save a block.
  */
@@ -11,20 +12,43 @@ export function saveBlock(db, typeId, start, end) {
     const file = VerifTree.blockSdbFile(typeId, start, end);
     const path = join(db.fileSystemPath, file);
     const err = native.saveBlock(path, typeId, start, db.dbCtxExternal, hash);
-    if (err == -8) {
-        // TODO ENOENT
+    if (err == SELVA_ENOENT) {
+        // Generally we don't nor can't remove blocks from verifTree before we
+        // attempt to access them.
         db.verifTree.remove(mtKey);
     }
     else if (err) {
-        // TODO print the error string
-        console.error(`Save ${typeId}:${start}-${end} failed: ${err}`);
+        db.emit('error', `Save ${typeId}:${start}-${end} failed: ${native.selvaStrerror(err)}`);
     }
     else {
         db.verifTree.update(mtKey, hash);
     }
 }
+export async function saveBlocks(db, blocks) {
+    const res = await db.ioWorker.saveBlocks(blocks);
+    if (res.byteOffset !== 0)
+        throw new Error('Unexpected offset');
+    // if (res.byteLength / 20 !== blocks.length) throw new Error('Invalid res size')
+    for (let i = 0; i < blocks.length; i++) {
+        const block = blocks[i];
+        const key = makeTreeKey(block.typeId, block.start);
+        const err = readInt32(res, i * 20);
+        const hash = new Uint8Array(res.buffer, i * 20 + 4, 16);
+        if (err === SELVA_ENOENT) {
+            // Generally we don't nor can't remove blocks from verifTree before we
+            // attempt to access them.
+            db.verifTree.remove(key);
+        }
+        else if (err) {
+            db.emit('error', `Save ${block.typeId}:${block.start} failed: ${native.selvaStrerror(err)}`);
+        }
+        else {
+            db.verifTree.update(key, hash);
+        }
+    }
+}
 /**
- * Load a block (typically of a partial type) back to memory.
+ * Load an existing block (typically of a partial type) back to memory.
  */
 export async function loadBlock(db, def, start) {
     const key = makeTreeKey(def.id, start);
@@ -72,7 +96,7 @@ export async function unloadBlock(db, def, start) {
     }
     catch (e) {
         // TODO Proper logging
-        // TODO err == -8 == SELVA_ENOENT => db.verifTree.remove(key) ??
+        // TODO SELVA_ENOENT => db.verifTree.remove(key) ??
         console.error(`Save ${typeId}:${start}-${end} failed`);
         console.error(e);
     }

package/dist/src/server/index.d.ts

@@ -26,7 +26,7 @@ export declare class DbServer extends DbShared {
     ioWorker: IoWorker;
     workers: QueryWorker[];
     availableWorkerIndex: number;
-    processingQueries: number;
+    activeReaders: number;
     modifyQueue: Uint8Array[];
     queryQueue: Map<Function, Uint8Array>;
     stopped: boolean;

package/dist/src/server/index.js

@@ -31,12 +31,12 @@ export class DbServer extends DbShared {
     migrating = null;
     saveInProgress = false;
     fileSystemPath;
-    verifTree;
+    verifTree; // should be updated only when saving/loading
     dirtyRanges = new Set();
     ioWorker;
     workers = [];
     availableWorkerIndex = -1;
-    processingQueries = 0; // semaphore for locking writes
+    activeReaders = 0; // processing queries or other DB reads
     modifyQueue = [];
     queryQueue = new Map();
     stopped; // = true does not work
@@ -58,7 +58,7 @@ export class DbServer extends DbShared {
         return start(this, opts);
     }
     save(opts) {
-        return save(this, false, opts?.forceFullDump ?? false);
+        return save(this, opts);
     }
     async loadBlock(typeName, nodeId) {
         const def = this.schemaTypesParsed[typeName];
@@ -68,10 +68,6 @@ export class DbServer extends DbShared {
         const typeId = def.id;
         const key = makeTreeKeyFromNodeId(typeId, def.blockCapacity, nodeId);
         const [, start] = destructureTreeKey(key);
-        const block = this.verifTree.getBlock(key);
-        if (!block) {
-            throw new Error('Block not found');
-        }
         await loadBlock(this, def, start);
     }
     async unloadBlock(typeName, nodeId) {
@@ -103,7 +99,7 @@ export class DbServer extends DbShared {
                             for (const lang in this.sortIndexes[type][field][start]) {
                                 const sortIndex = this.sortIndexes[type][field][start][lang];
                                 sortIndex.cnt /= 2;
-                                if (sortIndex.cnt < 1 && !this.processingQueries) {
+                                if (sortIndex.cnt < 1 && !this.activeReaders) {
                                     native.destroySortIndex(sortIndex.buf, this.dbCtxExternal);
                                     delete this.sortIndexes[type][field][start][lang];
                                 }
@@ -299,7 +295,7 @@ export class DbServer extends DbShared {
             def.lastId = lastId + offset;
             offsets[typeId] = offset;
         }
-        if (this.processingQueries) {
+        if (this.activeReaders) {
             this.modifyQueue.push(new Uint8Array(bufWithHash));
         }
         else {
@@ -387,7 +383,7 @@ export class DbServer extends DbShared {
                     const start = readUint16(sort, 3);
                     let sortIndex = this.getSortIndex(typeId, field, start, 0);
                     if (!sortIndex) {
-                        if (this.processingQueries) {
+                        if (this.activeReaders) {
                             return new Promise((resolve) => {
                                 this.addToQueryQueue(resolve, buf);
                             });
@@ -411,7 +407,7 @@ export class DbServer extends DbShared {
         }
     }
     onQueryEnd() {
-        if (this.processingQueries === 0) {
+        if (this.activeReaders === 0) {
             if (this.modifyQueue.length) {
                 const modifyQueue = this.modifyQueue;
                 this.modifyQueue = [];
@@ -454,6 +450,7 @@ export class DbServer extends DbShared {
                 await this.save();
             }
             await this.ioWorker.terminate();
+            this.ioWorker = null;
             await Promise.all(this.workers.map((worker) => worker.terminate()));
             this.workers = [];
             native.stop(this.dbCtxExternal);

package/dist/src/server/migrate/index.js

@@ -90,7 +90,7 @@ export const migrate = async (server, fromSchema, toSchema, transform) => {
     // Block handling
     let i = 0;
     let rangesToMigrate = [];
-    await save(server, false, false, true);
+    await save(server, { skipMigrationCheck: true });
     server.verifTree.foreachBlock((block) => {
         const [typeId, start] = destructureTreeKey(block.key);
         const def = server.schemaTypesParsedById[typeId];
@@ -103,13 +103,13 @@ export const migrate = async (server, fromSchema, toSchema, transform) => {
             break;
         }
         // block modifies
-        server.processingQueries++;
+        server.activeReaders++;
         const leafData = rangesToMigrate[i++];
         port1.postMessage(leafData);
         setToAwake(workerState, true);
         await waitUntilSleeping(workerState);
         // exec queued modifies
-        server.processingQueries--;
+        server.activeReaders--;
         server.onQueryEnd();
         if (i === rangesToMigrate.length) {
             if (server.dirtyRanges.size) {
@@ -149,14 +149,14 @@ export const migrate = async (server, fromSchema, toSchema, transform) => {
     // -----------------------------------------
     tmpDb.server.dbCtxExternal = fromCtx;
     // TODO makes this SYNC
-    const promises = server.workers.map((worker) => worker.updateCtx(toAddress));
+    const promises = [server.ioWorker, ...server.workers].map((worker) => worker.updateCtx(toAddress));
     promises.push(tmpDb.destroy(), worker.terminate());
     await Promise.all(promises);
     if (abort()) {
         return;
     }
     native.membarSyncRead();
-    await save(server, false, true, true);
+    await save(server, { forceFullDump: true, skipDirtyCheck: true, skipMigrationCheck: true });
     await writeSchemaFile(server, toSchema);
     server.migrating = 0;
     process.nextTick(() => server.emit('schema', server.schema));

package/dist/src/server/save.d.ts

@@ -19,5 +19,11 @@ export type Writelog = {
         [t: number]: RangeDump[];
     };
 };
-export declare function save<T extends boolean>(db: DbServer, sync?: T, forceFullDump?: boolean, skipMigrationCheck?: boolean): T extends true ? void : Promise<void>;
+type SaveOpts = {
+    forceFullDump?: boolean;
+    skipDirtyCheck?: boolean;
+    skipMigrationCheck?: boolean;
+};
+export declare function saveSync(db: DbServer, opts?: SaveOpts): void;
+export declare function save(db: DbServer, opts?: SaveOpts): Promise<void>;
 export {};

package/dist/src/server/save.js

@@ -3,7 +3,7 @@ import { isMainThread } from 'node:worker_threads';
 import { writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { VerifTree, destructureTreeKey, } from './tree.js';
-import { saveBlock, foreachBlock, foreachDirtyBlock, } from './blocks.js';
+import { saveBlock, foreachBlock, foreachDirtyBlock, saveBlocks, } from './blocks.js';
 import { writeFileSync } from 'node:fs';
 import { bufToHex } from '@saulx/utils';
 import { COMMON_SDB_FILE, WRITELOG_FILE } from '../types.js';
@@ -14,22 +14,56 @@ function hasPartialTypes(db) {
     }
     return res;
 }
-export function save(db, sync = false, forceFullDump = false, skipMigrationCheck = false) {
-    if (!(isMainThread && (db.dirtyRanges.size || forceFullDump))) {
-        return;
+function inhibitSave(db, { skipDirtyCheck, forceFullDump, skipMigrationCheck }) {
+    // RFE isMainThread needed??
+    if (!(isMainThread && (skipDirtyCheck || db.dirtyRanges.size || forceFullDump))) {
+        return true;
     }
     if (forceFullDump && hasPartialTypes(db)) {
         db.emit('error', 'forceFullDump is not allowed with partial types');
-        return;
+        return true;
     }
     if (db.migrating && !skipMigrationCheck) {
         db.emit('info', 'Block save db is migrating');
-        return;
+        return true;
     }
     if (db.saveInProgress) {
         db.emit('info', 'Already have a save in progress cancel save');
-        return;
+        return true;
+    }
+    return false;
+}
+function makeWritelog(db, ts) {
+    const types = {};
+    const rangeDumps = {};
+    for (const key in db.schemaTypesParsed) {
+        const { id, lastId, blockCapacity } = db.schemaTypesParsed[key];
+        types[id] = { lastId, blockCapacity };
+        rangeDumps[id] = [];
     }
+    db.verifTree.foreachBlock((block) => {
+        const [typeId, start] = destructureTreeKey(block.key);
+        const def = db.schemaTypesParsedById[typeId];
+        const end = start + def.blockCapacity - 1;
+        const data = {
+            file: db.verifTree.getBlockFile(block),
+            hash: bufToHex(block.hash),
+            start,
+            end,
+        };
+        rangeDumps[typeId].push(data);
+    });
+    return {
+        ts,
+        types,
+        commonDump: COMMON_SDB_FILE,
+        rangeDumps,
+        hash: bufToHex(db.verifTree.hash), // TODO `hash('hex')`
+    };
+}
+export function saveSync(db, opts = {}) {
+    if (inhibitSave(db, opts))
+        return;
     let ts = Date.now();
     db.saveInProgress = true;
     try {
@@ -39,7 +73,7 @@ export function save(db, sync = false, forceFullDump = false, skipMigrationCheck
             db.emit('error', `Save common failed: ${err}`);
             // Return ?
         }
-        if (forceFullDump) {
+        if (opts.forceFullDump) {
             // reset the state just in case
             db.verifTree = new VerifTree(db.schemaTypesParsed);
             // We use db.verifTree.types instead of db.schemaTypesParsed because it's
@@ -53,58 +87,81 @@ export function save(db, sync = false, forceFullDump = false, skipMigrationCheck
             foreachDirtyBlock(db, (_mtKey, typeId, start, end) => saveBlock(db, typeId, start, end));
         }
         db.dirtyRanges.clear();
-        const types = {};
-        const rangeDumps = {};
-        for (const key in db.schemaTypesParsed) {
-            const { id, lastId, blockCapacity } = db.schemaTypesParsed[key];
-            types[id] = { lastId, blockCapacity };
-            rangeDumps[id] = [];
-        }
-        db.verifTree.foreachBlock((block) => {
-            const [typeId, start] = destructureTreeKey(block.key);
-            const def = db.schemaTypesParsedById[typeId];
-            const end = start + def.blockCapacity - 1;
-            const data = {
-                file: db.verifTree.getBlockFile(block),
-                hash: bufToHex(block.hash),
-                start,
-                end,
-            };
-            rangeDumps[typeId].push(data);
-        });
-        const data = {
-            ts,
-            types,
-            commonDump: COMMON_SDB_FILE,
-            rangeDumps,
-            hash: bufToHex(db.verifTree.hash), // TODO `hash('hex')`
-        };
-        const filePath = join(db.fileSystemPath, WRITELOG_FILE);
+        const data = makeWritelog(db, ts);
         const content = JSON.stringify(data);
-        db.emit('info', `Save done took ${Date.now() - ts}ms`);
-        if (sync) {
-            db.saveInProgress = false;
-            return writeFileSync(filePath, content);
+        db.emit('info', `Save took ${Date.now() - ts}ms`);
+        db.saveInProgress = false;
+        return writeFileSync(join(db.fileSystemPath, WRITELOG_FILE), content);
+    }
+    catch (err) {
+        db.emit('error', `Save failed ${err.message}`);
+        db.saveInProgress = false;
+        throw err;
+    }
+}
+export async function save(db, opts = {}) {
+    if (inhibitSave(db, opts))
+        return;
+    let ts = Date.now();
+    db.saveInProgress = true;
+    try {
+        let err;
+        err = native.saveCommon(join(db.fileSystemPath, COMMON_SDB_FILE), db.dbCtxExternal);
+        if (err) {
+            db.emit('error', `Save common failed: ${err}`);
+            // Return ?
+        }
+        const blocks = [];
+        if (opts.forceFullDump) {
+            // reset the state just in case
+            db.verifTree = new VerifTree(db.schemaTypesParsed);
+            // We use db.verifTree.types instead of db.schemaTypesParsed because it's
+            // ordered.
+            for (const { typeId } of db.verifTree.types()) {
+                const def = db.schemaTypesParsedById[typeId];
+                foreachBlock(db, def, (start, end, _hash) => {
+                    const typeId = def.id;
+                    const file = VerifTree.blockSdbFile(typeId, start, end);
+                    const filepath = join(db.fileSystemPath, file);
+                    blocks.push({
+                        filepath,
+                        typeId,
+                        start,
+                    });
+                });
+            }
         }
         else {
-            return new Promise((resolve, reject) => {
-                return writeFile(filePath, content)
-                    .then((v) => {
-                    db.saveInProgress = false;
-                    resolve(v);
-                })
-                    .catch((err) => {
-                    db.emit('error', `Save: writing writeLog failed ${err.message}`);
-                    db.saveInProgress = false;
-                    reject(err);
+            foreachDirtyBlock(db, (_mtKey, typeId, start, end) => {
+                const file = VerifTree.blockSdbFile(typeId, start, end);
+                const filepath = join(db.fileSystemPath, file);
+                blocks.push({
+                    filepath,
+                    typeId,
+                    start
                 });
             });
         }
+        db.dirtyRanges.clear();
+        await saveBlocks(db, blocks);
+        try {
+            // Note that we assume here that verifTree didn't change before we call
+            // makeWritelog(). This is true as long as db.saveInProgress protects
+            // the verifTree from changes.
+            const data = makeWritelog(db, ts);
+            await writeFile(join(db.fileSystemPath, WRITELOG_FILE), JSON.stringify(data));
+        }
+        catch (err) {
+            db.emit('error', `Save: writing writeLog failed ${err.message}`);
+        }
+        db.emit('info', `Save took ${Date.now() - ts}ms`);
     }
     catch (err) {
         db.emit('error', `Save failed ${err.message}`);
-        db.saveInProgress = false;
         throw err;
     }
+    finally {
+        db.saveInProgress = false;
+    }
 }
 //# sourceMappingURL=save.js.map

package/dist/src/server/schema.d.ts

@@ -1,6 +1,6 @@
+import { StrictSchema } from '@based/schema';
 import { DbServer } from './index.js';
 import { DbSchema } from '../schema.js';
-import { StrictSchema } from '@based/schema';
 export declare const setSchemaOnServer: (server: DbServer, schema: DbSchema) => void;
 export declare const writeSchemaFile: (server: DbServer, schema: DbSchema) => Promise<void>;
 export declare const setNativeSchema: (server: DbServer, schema: DbSchema) => void;

package/dist/src/server/schema.js

@@ -1,12 +1,13 @@
 import { schemaToSelvaBuffer, updateTypeDefs } from '@based/schema/def';
+import { deepCopy, writeUint64 } from '@saulx/utils';
+import { getPropType, serialize } from '@based/schema';
 import { join } from 'node:path';
 import { writeFile } from 'node:fs/promises';
 import native from '../native.js';
 import { makeTreeKey } from './tree.js';
-import { deepCopy, writeUint64 } from '@saulx/utils';
 import { SCHEMA_FILE } from '../types.js';
+import { saveSync } from './save.js';
 import { hash } from '@saulx/hash';
-import { getPropType, serialize } from '@based/schema';
 export const setSchemaOnServer = (server, schema) => {
     const { schemaTypesParsed, schemaTypesParsedById } = updateTypeDefs(schema);
     server.schema = schema;
@@ -55,6 +56,9 @@ export const setNativeSchema = (server, schema) => {
         //server.verifTree = new VerifTree(.schemaTypesParsed)
     }
     server.verifTree.updateTypes(server.schemaTypesParsed);
+    if (server.fileSystemPath) {
+        saveSync(server, { skipDirtyCheck: true });
+    }
 };
 export const strictSchemaToDbSchema = (schema) => {
     // @ts-ignore

package/dist/src/server/start.js

@@ -7,11 +7,11 @@ import { join } from 'node:path';
 import { VerifTree, makeTreeKey } from './tree.js';
 import { foreachBlock } from './blocks.js';
 import exitHook from 'exit-hook';
-import { save } from './save.js';
+import { save, saveSync } from './save.js';
 import { deSerialize } from '@based/schema';
 import { BLOCK_CAPACITY_DEFAULT } from '@based/schema/def';
 import { bufToHex, equals, hexToBuf, wait } from '@saulx/utils';
-import { SCHEMA_FILE, WRITELOG_FILE } from '../types.js';
+import { SCHEMA_FILE, WRITELOG_FILE, SCHEMA_FILE_DEPRECATED } from '../types.js';
 import { setSchemaOnServer } from './schema.js';
 function startWorkers(db, opts) {
     const queryThreads = opts?.queryThreads ?? availableParallelism();
@@ -42,11 +42,17 @@ export async function start(db, opts) {
             console.error(e.message);
             throw e;
         }
-        const schema = await readFile(join(path, SCHEMA_FILE));
+        const schema = await readFile(join(path, SCHEMA_FILE)).catch(noop);
         if (schema) {
             const s = deSerialize(schema);
             setSchemaOnServer(db, s);
         }
+        else {
+            const schemaJson = await readFile(join(path, SCHEMA_FILE_DEPRECATED));
+            if (schemaJson) {
+                setSchemaOnServer(db, JSON.parse(schemaJson.toString()));
+            }
+        }
         // Load all range dumps
         for (const typeId in writelog.rangeDumps) {
             const dumps = writelog.rangeDumps[typeId];
@@ -111,7 +117,7 @@ export async function start(db, opts) {
             // in Node.js.
             signals.forEach((sig) => process.on(sig, blockSig));
             db.emit('info', `Exiting with signal: ${signal}`);
-            save(db, true);
+            saveSync(db);
             db.emit('info', 'Successfully saved.');
             signals.forEach((sig) => process.off(sig, blockSig));
         });
@@ -121,7 +127,7 @@ export async function start(db, opts) {
     // use timeout
     if (db.saveIntervalInSeconds > 0) {
         db.saveInterval ??= setInterval(() => {
-            void save(db);
+            save(db);
         }, db.saveIntervalInSeconds * 1e3);
     }
     if (db.schema) {

package/dist/src/server/tree.d.ts

@@ -6,8 +6,19 @@ export declare const makeTreeKeyFromNodeId: (typeId: number, blockCapacity: numb
 type Hash = Uint8Array;
 export type VerifBlock = {
     key: number;
+    /**
+     * Last acquired hash of the block.
+     * This is normally updated at load and save time but never during read/modify ops.
+     */
     hash: Hash;
+    /**
+     * If false the block is offloaded to fs;
+     * true doesn't necessarily mean that the block still exists because it could have been deleted.
+     */
     inmem: boolean;
+    /**
+     * If set, the block is being loaded and it can be awaited with this promise.
+     */
     loadPromise: null | Promise<void>;
 };
 export declare class VerifTree {

package/dist/src/server/tree.js

@@ -26,7 +26,6 @@ export class VerifTree {
             obj[typeId] = {
                 typeId,
                 blockCapacity: def.blockCapacity,
-                hash: new Uint8Array(HASH_SIZE),
                 blocks: [],
             };
             return obj;