@based/db 0.0.64 → 0.0.67

package/dist/src/server/save.js

@@ -2,30 +2,26 @@ import native from '../native.js';
 import { isMainThread } from 'node:worker_threads';
 import { writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
-import { destructureCsmtKey, foreachBlock, foreachDirtyBlock, initCsmt, makeCsmtKey, specialBlock, } from './tree.js';
+import { VerifTree, destructureTreeKey, } from './tree.js';
+import { saveBlock, foreachBlock, foreachDirtyBlock, } from './blocks.js';
 import { writeFileSync } from 'node:fs';
 import { bufToHex } from '@saulx/utils';
 import { COMMON_SDB_FILE, WRITELOG_FILE } from '../types.js';
-const block_sdb_file = (typeId, start, end) => `${typeId}_${start}_${end}.sdb`;
-function saveRange(db, typeId, start, end, hashOut) {
-    const file = block_sdb_file(typeId, start, end);
-    const path = join(db.fileSystemPath, file);
-    const err = native.saveRange(path, typeId, start, end, db.dbCtxExternal, hashOut);
-    if (err == -8) {
-        // TODO ENOENT
-        return ''; // empty range
+function hasPartialTypes(db) {
+    let res = false;
+    for (let id in db.schemaTypesParsedById) {
+        res = res || db.schemaTypesParsedById[id].partial;
     }
-    else if (err) {
-        // TODO print the error string
-        console.error(`Save ${typeId}:${start}-${end} failed: ${err}`);
-        return null;
-    }
-    return file;
+    return res;
 }
 export function save(db, sync = false, forceFullDump = false, skipMigrationCheck = false) {
     if (!(isMainThread && (db.dirtyRanges.size || forceFullDump))) {
         return;
     }
+    if (forceFullDump && hasPartialTypes(db)) {
+        db.emit('error', 'forceFullDump is not allowed with partial types');
+        return;
+    }
     if (db.migrating && !skipMigrationCheck) {
         db.emit('info', 'Block save db is migrating');
         return;
@@ -40,62 +36,21 @@ export function save(db, sync = false, forceFullDump = false, skipMigrationCheck
         let err;
         err = native.saveCommon(join(db.fileSystemPath, COMMON_SDB_FILE), db.dbCtxExternal);
         if (err) {
-            console.error(`Save common failed: ${err}`);
+            db.emit('error', `Save common failed: ${err}`);
             // Return ?
         }
         if (forceFullDump) {
-            // We just rebuild the whole tree
-            initCsmt(db);
-            for (const key in db.schemaTypesParsed) {
-                const def = db.schemaTypesParsed[key];
-                foreachBlock(db, def, (start, end, _hash) => {
-                    const typeId = def.id;
-                    const mtKey = makeCsmtKey(typeId, start);
-                    const hash = new Uint8Array(16);
-                    const file = saveRange(db, typeId, start, end, hash);
-                    if (file === null) {
-                        throw new Error('full dump failed');
-                    }
-                    else {
-                        const data = {
-                            file,
-                            typeId,
-                            start,
-                            end,
-                        };
-                        db.merkleTree.insert(mtKey, hash, data);
-                    }
-                });
+            // 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) => saveBlock(db, def.id, start, end));
             }
         }
         else {
-            void foreachDirtyBlock(db, (mtKey, typeId, start, end) => {
-                const hash = new Uint8Array(16);
-                const file = saveRange(db, typeId, start, end, hash);
-                if (file === null) {
-                    // The previous state should remain in the merkle tree for
-                    // load and sync purposes.
-                    return;
-                }
-                else {
-                    const oldLeaf = db.merkleTree.search(mtKey);
-                    // If (file.length === 0) then the range is empty but that's fine,
-                    // we'll keep them around for now to maintain the order of the tree.
-                    if (oldLeaf) {
-                        oldLeaf.data.file = file;
-                        db.merkleTree.update(mtKey, hash);
-                    }
-                    else {
-                        const data = {
-                            file,
-                            typeId,
-                            start,
-                            end,
-                        };
-                        db.merkleTree.insert(mtKey, hash, data);
-                    }
-                }
-            });
+            foreachDirtyBlock(db, (_mtKey, typeId, start, end) => saveBlock(db, typeId, start, end));
         }
         db.dirtyRanges.clear();
         const types = {};
@@ -105,22 +60,24 @@ export function save(db, sync = false, forceFullDump = false, skipMigrationCheck
             types[id] = { lastId, blockCapacity };
             rangeDumps[id] = [];
         }
-        db.merkleTree.visitLeafNodes((leaf) => {
-            const [typeId, start] = destructureCsmtKey(leaf.key);
-            if (start == specialBlock)
-                return; // skip the type specialBlock
-            const data = leaf.data;
-            if (start != data.start) {
-                console.error(`csmtKey start and range start mismatch: ${start} != ${data.start}`);
-            }
-            rangeDumps[typeId].push({ ...data, hash: bufToHex(leaf.hash) });
+        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.merkleTree.getRoot()?.hash ?? new Uint8Array(0)),
+            hash: bufToHex(db.verifTree.hash), // TODO `hash('hex')`
         };
         const filePath = join(db.fileSystemPath, WRITELOG_FILE);
         const content = JSON.stringify(data);
@@ -137,8 +94,7 @@ export function save(db, sync = false, forceFullDump = false, skipMigrationCheck
                     resolve(v);
                 })
                     .catch((err) => {
-                    console.error('Save: writing writeLog failed');
-                    db.emit('info', `Save: writing writeLog failed ${err.message}`);
+                    db.emit('error', `Save: writing writeLog failed ${err.message}`);
                     db.saveInProgress = false;
                     reject(err);
                 });
@@ -146,7 +102,7 @@ export function save(db, sync = false, forceFullDump = false, skipMigrationCheck
         }
     }
     catch (err) {
-        db.emit('info', `Save failed ${err.message}`);
+        db.emit('error', `Save failed ${err.message}`);
         db.saveInProgress = false;
         throw err;
     }

package/dist/src/server/schema.js

@@ -2,11 +2,11 @@ import { schemaToSelvaBuffer, updateTypeDefs } from '@based/schema/def';
 import { join } from 'node:path';
 import { writeFile } from 'node:fs/promises';
 import native from '../native.js';
-import { initCsmt, makeCsmtKey } from './tree.js';
+import { makeTreeKey } from './tree.js';
 import { deepCopy, writeUint64 } from '@saulx/utils';
 import { SCHEMA_FILE } from '../types.js';
 import { hash } from '@saulx/hash';
-import { getPropType } from '@based/schema';
+import { getPropType, serialize } from '@based/schema';
 export const setSchemaOnServer = (server, schema) => {
     const { schemaTypesParsed, schemaTypesParsedById } = updateTypeDefs(schema);
     server.schema = schema;
@@ -16,7 +16,7 @@ export const setSchemaOnServer = (server, schema) => {
 export const writeSchemaFile = async (server, schema) => {
     const schemaFilePath = join(server.fileSystemPath, SCHEMA_FILE);
     try {
-        await writeFile(schemaFilePath, JSON.stringify(schema));
+        await writeFile(schemaFilePath, serialize(schema));
     }
     catch (err) {
         throw new Error(`Error writing schema to a file path ${schemaFilePath}}`);
@@ -38,7 +38,7 @@ export const setNativeSchema = (server, schema) => {
     if (schema.types._root) {
         // TODO fix server add it in schema at least
         const data = [2, 1, 0, 0, 0, 1, 9, 1, 0, 0, 0, 7, 1, 0, 1];
-        const blockKey = makeCsmtKey(1, 1);
+        const blockKey = makeTreeKey(1, 1);
         const buf = new Uint8Array(8 + data.length + 2 + 8 + 4);
         const view = new DataView(buf.buffer, 0, buf.byteLength);
         // set schema hash
@@ -52,8 +52,9 @@ export const setNativeSchema = (server, schema) => {
         // add dataLen
         view.setUint32(buf.length - 4, data.length, true);
         server.modify(buf);
-        initCsmt(server);
+        //server.verifTree = new VerifTree(.schemaTypesParsed)
     }
+    server.verifTree.updateTypes(server.schemaTypesParsed);
 };
 export const strictSchemaToDbSchema = (schema) => {
     // @ts-ignore

package/dist/src/server/start.js

@@ -1,15 +1,27 @@
-import { DbWorker } from './DbWorker.js';
+import { availableParallelism } from 'node:os';
+import { QueryWorker } from './QueryWorker.js';
+import { IoWorker } from './IoWorker.js';
 import native from '../native.js';
 import { rm, mkdir, readFile } from 'node:fs/promises';
 import { join } from 'node:path';
-import { destructureCsmtKey, foreachBlock, initCsmt, makeCsmtKey, specialBlock, } from './tree.js';
-import { availableParallelism } from 'node:os';
+import { VerifTree, makeTreeKey } from './tree.js';
+import { foreachBlock } from './blocks.js';
 import exitHook from 'exit-hook';
 import { save } from './save.js';
-import { DEFAULT_BLOCK_CAPACITY } from '@based/schema/def';
-import { bufToHex, wait } from '@saulx/utils';
+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 { setSchemaOnServer } from './schema.js';
+function startWorkers(db, opts) {
+    const queryThreads = opts?.queryThreads ?? availableParallelism();
+    const address = native.intFromExternal(db.dbCtxExternal);
+    db.workers = [];
+    for (let i = 0; i < queryThreads; i++) {
+        db.workers.push(new QueryWorker(address, db, i));
+    }
+    db.ioWorker = new IoWorker(address, db);
+}
 export async function start(db, opts) {
     const path = db.fileSystemPath;
     const noop = () => { };
@@ -19,6 +31,7 @@ export async function start(db, opts) {
     await mkdir(path, { recursive: true }).catch(noop);
     db.dbCtxExternal = native.start();
     let writelog = null;
+    let partials = []; // Blocks that exists but were not loaded [key, hash]
     try {
         writelog = JSON.parse((await readFile(join(path, WRITELOG_FILE))).toString());
         // Load the common dump
@@ -29,81 +42,66 @@ export async function start(db, opts) {
             console.error(e.message);
             throw e;
         }
+        const schema = await readFile(join(path, SCHEMA_FILE));
+        if (schema) {
+            const s = deSerialize(schema);
+            setSchemaOnServer(db, s);
+        }
         // Load all range dumps
         for (const typeId in writelog.rangeDumps) {
             const dumps = writelog.rangeDumps[typeId];
+            const def = db.schemaTypesParsedById[typeId];
             for (const dump of dumps) {
                 const fname = dump.file;
                 if (fname?.length > 0) {
-                    try {
-                        native.loadRange(join(path, fname), db.dbCtxExternal);
+                    if (!def.partial) {
+                        try {
+                            // Can't use loadBlock() yet because verifTree is not avail
+                            native.loadBlock(join(path, fname), db.dbCtxExternal);
+                        }
+                        catch (e) {
+                            console.error(e.message);
+                        }
                     }
-                    catch (e) {
-                        console.error(e.message);
+                    else {
+                        partials.push([
+                            makeTreeKey(def.id, dump.start),
+                            hexToBuf(dump.hash),
+                        ]);
                     }
                 }
             }
         }
-        const schema = await readFile(join(path, SCHEMA_FILE));
-        if (schema) {
-            const s = JSON.parse(schema.toString());
-            setSchemaOnServer(db, s);
-        }
     }
     catch (err) {
         // TODO In some cases we really should give up!
     }
-    const csmtTypes = initCsmt(db);
-    for (const key in csmtTypes) {
-        const def = csmtTypes[key];
+    db.verifTree = new VerifTree(db.schemaTypesParsed);
+    for (const { typeId } of db.verifTree.types()) {
+        const def = db.schemaTypesParsedById[typeId];
         const [total, lastId] = native.getTypeInfo(def.id, db.dbCtxExternal);
         def.lastId = writelog?.types[def.id]?.lastId || lastId;
         def.blockCapacity =
-            writelog?.types[def.id]?.blockCapacity || DEFAULT_BLOCK_CAPACITY;
-        foreachBlock(db, def, (start, end, hash) => {
-            const mtKey = makeCsmtKey(def.id, start);
-            const file = writelog.rangeDumps[def.id]?.find((v) => v.start === start)?.file ||
-                '';
-            const data = {
-                file,
-                typeId: def.id,
-                start,
-                end,
-            };
-            db.merkleTree.insert(mtKey, hash, data);
-        }, true);
+            writelog?.types[def.id]?.blockCapacity ||
+                def.blockCapacity ||
+                BLOCK_CAPACITY_DEFAULT;
+        foreachBlock(db, def, (start, _end, hash) => {
+            const mtKey = makeTreeKey(def.id, start);
+            db.verifTree.update(mtKey, hash);
+        });
+    }
+    // Insert partials to make the hash match
+    for (const [key, hash] of partials) {
+        db.verifTree.update(key, hash, false);
     }
     if (writelog?.hash) {
-        // FIXME FDN-1301
-        //const oldHash = hexToBuf(writelog.hash)
-        //const newHash = db.merkleTree.getRoot()?.hash
-        //if (!hashEq(oldHash, newHash)) {
-        //  console.error(
-        //    `WARN: CSMT hash mismatch. expected: ${writelog.hash} actual: ${bufToHex(newHash)}`,
-        //  )
-        //}
-        const oldHashSet = new Set();
-        const newHashSet = new Set();
-        for (let k in writelog.rangeDumps)
-            writelog.rangeDumps[k].forEach(({ hash }) => oldHashSet.add(hash));
-        db.merkleTree.visitLeafNodes(({ key, hash }) => {
-            const [_typeId, start] = destructureCsmtKey(key);
-            if (start == specialBlock)
-                return; // skip the type specialBlock
-            newHashSet.add(bufToHex(hash));
-        });
-        const setEq = (a, b) => a.size === b.size && [...a].every((value) => b.has(value));
-        if (!setEq(oldHashSet, newHashSet)) {
-            console.error(`WARN: CSMT hash mismatch.`);
+        const oldHash = hexToBuf(writelog.hash);
+        const newHash = db.verifTree.hash;
+        if (!equals(oldHash, newHash)) {
+            console.error(`WARN: DB hash mismatch. expected: ${writelog.hash} actual: ${bufToHex(newHash)}`);
         }
     }
-    // start workers
-    const queryThreads = opts?.queryThreads ?? availableParallelism();
-    const address = native.intFromExternal(db.dbCtxExternal);
-    db.workers = [];
-    for (let i = 0; i < queryThreads; i++) {
-        db.workers.push(new DbWorker(address, db, i));
-    }
+    startWorkers(db, opts);
     if (!opts?.hosted) {
         db.unlistenExit = exitHook((signal) => {
             const blockSig = () => { };
@@ -118,9 +116,8 @@ export async function start(db, opts) {
             signals.forEach((sig) => process.off(sig, blockSig));
         });
     }
-    const d = performance.now();
     await Promise.all(db.workers.map(({ readyPromise }) => readyPromise));
-    db.emit('info', `Starting workers took ${d}ms`);
+    db.emit('info', 'All workers ready');
     // use timeout
     if (db.saveIntervalInSeconds > 0) {
         db.saveInterval ??= setInterval(() => {

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

@@ -1,15 +1,26 @@
-import { DbServer } from './index.js';
 import { SchemaTypeDef } from '@based/schema/def';
-export type CsmtNodeRange = {
-    file: string;
-    typeId: number;
-    start: number;
-    end: number;
+export declare const destructureTreeKey: (key: number) => number[];
+export declare const makeTreeKey: (typeId: number, start: number) => number;
+export declare const nodeId2Start: (blockCapacity: number, nodeId: number) => number;
+export declare const makeTreeKeyFromNodeId: (typeId: number, blockCapacity: number, nodeId: number) => number;
+type Hash = Uint8Array;
+export type VerifBlock = {
+    key: number;
+    hash: Hash;
+    inmem: boolean;
+    loadPromise: null | Promise<void>;
 };
-export declare const specialBlock = 2147483647;
-export declare const destructureCsmtKey: (key: number) => number[];
-export declare const makeCsmtKey: (typeId: number, start: number) => number;
-export declare const makeCsmtKeyFromNodeId: (typeId: number, blockCapacity: number, nodeId: number) => number;
-export declare function initCsmt(db: DbServer): {};
-export declare function foreachBlock(db: DbServer, def: SchemaTypeDef, cb: (start: number, end: number, hash: Uint8Array) => void, includeEmptyBlocks?: boolean): void;
-export declare function foreachDirtyBlock(db: DbServer, cb: (mtKey: number, typeId: number, start: number, end: number) => void): Promise<void>;
+export declare class VerifTree {
+    #private;
+    constructor(schemaTypesParsed: Record<string, SchemaTypeDef>);
+    types(): Generator<any, void, unknown>;
+    foreachBlock(cb: (block: VerifBlock) => void): void;
+    get hash(): Uint8Array;
+    update(key: number, hash: Hash, inmem?: boolean): void;
+    remove(key: number): void;
+    static blockSdbFile(typeId: number, start: number, end: number): string;
+    getBlock(key: number): VerifBlock;
+    getBlockFile(block: VerifBlock): string;
+    updateTypes(schemaTypesParsed: Record<string, SchemaTypeDef>): void;
+}
+export {};

package/dist/src/server/tree.js

@@ -1,80 +1,109 @@
-import native from '../native.js';
-import { createTree } from './csmt/tree.js';
-// This is a special start id set for every type to somewhat lock the order of the csmt.
-// While the id is valid, it's never a true start id of a block.
-export const specialBlock = 2147483647;
-export const destructureCsmtKey = (key) => [
+import createDbHash from './dbHash.js';
+export const destructureTreeKey = (key) => [
     (key / 4294967296) | 0, // typeId
     (key >>> 31) * 2147483648 + (key & 0x7fffffff), // start_node_id
 ];
-export const makeCsmtKey = (typeId, start) => typeId * 4294967296 + start;
-export const makeCsmtKeyFromNodeId = (typeId, blockCapacity, nodeId) => {
+export const makeTreeKey = (typeId, start) => typeId * 4294967296 + start;
+export const nodeId2Start = (blockCapacity, nodeId) => ((nodeId - +!(nodeId % blockCapacity)) / blockCapacity) | 0;
+const nodeId2BlockI = (nodeId, blockCapacity) => ((nodeId - 1) - ((nodeId - 1) % blockCapacity)) / blockCapacity;
+export const makeTreeKeyFromNodeId = (typeId, blockCapacity, nodeId) => {
     const tmp = nodeId - +!(nodeId % blockCapacity);
     return typeId * 4294967296 + ((tmp / blockCapacity) | 0) * blockCapacity + 1;
 };
-export function initCsmt(db) {
-    const types = Object.keys(db.schemaTypesParsed)
-        .sort((a, b) => db.schemaTypesParsed[a].id - db.schemaTypesParsed[b].id)
-        .reduce((obj, key) => {
-        obj[key] = db.schemaTypesParsed[key];
-        return obj;
-    }, {});
-    db.merkleTree = createTree(db.createCsmtHashFun);
-    // Insert specialBlocks for types.
-    // This should ensure that the insertion order of the actual node ranges is
-    // always deterministic.
-    for (const key in types) {
-        const { id: typeId } = types[key];
-        const data = {
-            file: '',
-            typeId: typeId,
-            start: 0,
-            end: 0,
-        };
-        try {
-            db.merkleTree.insert(makeCsmtKey(typeId, specialBlock), db.merkleTree.emptyHash, data);
+const HASH_SIZE = 16;
+export class VerifTree {
+    #types;
+    #h = createDbHash();
+    constructor(schemaTypesParsed) {
+        this.#types = VerifTree.#makeTypes(schemaTypesParsed);
+    }
+    static #makeTypes(schemaTypesParsed) {
+        return Object.preventExtensions(Object.keys(schemaTypesParsed)
+            .sort((a, b) => schemaTypesParsed[a].id - schemaTypesParsed[b].id)
+            .reduce((obj, key) => {
+            const def = schemaTypesParsed[key];
+            const typeId = def.id;
+            obj[typeId] = {
+                typeId,
+                blockCapacity: def.blockCapacity,
+                hash: new Uint8Array(HASH_SIZE),
+                blocks: [],
+            };
+            return obj;
+        }, {}));
+    }
+    *types() {
+        for (const k of Object.keys(this.#types)) {
+            yield this.#types[k];
         }
-        catch (_) { }
     }
-    return types;
-}
-export function foreachBlock(db, def, cb, includeEmptyBlocks = false) {
-    const step = def.blockCapacity;
-    for (let start = 1; start <= def.lastId; start += step) {
-        const end = start + step - 1;
-        const hash = new Uint8Array(16);
-        const res = native.getNodeRangeHash(def.id, start, end, hash, db.dbCtxExternal);
-        if (res || includeEmptyBlocks) {
-            cb(start, end, hash);
+    foreachBlock(cb) {
+        for (const k of Object.keys(this.#types)) {
+            const { blocks } = this.#types[k];
+            for (let block of blocks) {
+                if (block)
+                    cb(block);
+            }
         }
     }
-}
-export async function foreachDirtyBlock(db, cb) {
-    const typeIdMap = {};
-    for (const typeName in db.schemaTypesParsed) {
-        const type = db.schemaTypesParsed[typeName];
-        const typeId = type.id;
-        typeIdMap[typeId] = type;
+    get hash() {
+        this.#h.reset();
+        this.foreachBlock((block) => this.#h.update(block.hash));
+        return this.#h.digest();
+    }
+    update(key, hash, inmem = true) {
+        const [typeId, start] = destructureTreeKey(key);
+        const type = this.#types[typeId];
+        if (!type) {
+            throw new Error(`type ${typeId} not found`);
+        }
+        const blockI = nodeId2BlockI(start, type.blockCapacity);
+        const block = type.blocks[blockI] ?? (type.blocks[blockI] = Object.preventExtensions({ key, hash, inmem, loadPromise: null }));
+        block.hash = hash;
+        block.inmem = inmem;
+    }
+    remove(key) {
+        const [typeId, start] = destructureTreeKey(key);
+        const type = this.#types[typeId];
+        if (!type) {
+            throw new Error(`type ${typeId} not found`);
+        }
+        const blockI = nodeId2BlockI(start, type.blockCapacity);
+        delete type.blocks[blockI];
+    }
+    static blockSdbFile(typeId, start, end) {
+        return `${typeId}_${start}_${end}.sdb`;
+    }
+    getBlock(key) {
+        const [typeId, start] = destructureTreeKey(key);
+        const type = this.#types[typeId];
+        if (!type) {
+            throw new Error(`type ${typeId} not found`);
+        }
+        const blockI = nodeId2BlockI(start, type.blockCapacity);
+        return type.blocks[blockI];
     }
-    // FDN-791 CSMT is unstable (not history independent)
-    // For now we just sort the dirty data by type and start
-    // to make the insertion order more deterministic.
-    // This doesn't solve the issue completely because
-    // we might mess the order later with updates.
-    const dirty = [...db.dirtyRanges].sort((a, b) => {
-        const [aTypeId, aStart] = destructureCsmtKey(a);
-        const [bTypeId, bStart] = destructureCsmtKey(b);
-        const aId = typeIdMap[aTypeId].id;
-        const bId = typeIdMap[bTypeId].id;
-        const td = aId - bId;
-        if (td != 0)
-            return td;
-        return aStart - bStart;
-    });
-    for (const mtKey of dirty) {
-        const [typeId, start] = destructureCsmtKey(mtKey);
-        const end = start + typeIdMap[typeId].blockCapacity - 1;
-        cb(mtKey, typeId, start, end);
+    getBlockFile(block) {
+        const [typeId, start] = destructureTreeKey(block.key);
+        const type = this.#types[typeId];
+        if (!type) {
+            throw new Error(`type ${typeId} not found`);
+        }
+        const end = start + type.blockCapacity - 1;
+        return VerifTree.blockSdbFile(typeId, start, end);
+    }
+    updateTypes(schemaTypesParsed) {
+        const oldTypes = this.#types;
+        const newTypes = VerifTree.#makeTypes(schemaTypesParsed);
+        for (const k of Object.keys(oldTypes)) {
+            const oldType = oldTypes[k];
+            const newType = newTypes[k];
+            if (newType) {
+                newType.hash = oldType.hash;
+                newType.blocks = oldType.blocks;
+            }
+        }
+        this.#types = newTypes;
     }
 }
 //# sourceMappingURL=tree.js.map

package/dist/src/server/workers/DbWorker.d.ts

@@ -0,0 +1,17 @@
+import { DbServer } from '../index.js';
+export declare abstract class DbWorker {
+    constructor(address: BigInt, db: DbServer, onExit: (code: number) => void, workerName: string);
+    protected db: DbServer;
+    private channel;
+    private worker;
+    protected resolvers: ((x: any) => any)[];
+    readyPromise: Promise<true>;
+    terminate(): Promise<number>;
+    abstract handleMsg(buf: any): void;
+    protected callback: (resolve: (x: any) => any) => void;
+    /**
+     * Send msg to the worker thread and return a promise to the response.
+     */
+    protected call(msg: any): Promise<Uint8Array>;
+    updateCtx(address: BigInt): Promise<void>;
+}