@based/db 0.0.28 → 0.0.29

package/dist/src/server/index.js

@@ -4,14 +4,14 @@ import { rm, writeFile } from 'node:fs/promises';
 import { dirname, join } from 'node:path';
 import { getPropType, langCodesMap, } from '@based/schema';
 import { updateTypeDefs, schemaToSelvaBuffer, } from '@based/schema/def';
-import { hashEq } from './csmt/index.js';
 import { start } from './start.js';
-import { foreachDirtyBlock, makeCsmtKey, makeCsmtKeyFromNodeId, } from './tree.js';
+import { initCsmt, makeCsmtKey, makeCsmtKeyFromNodeId } from './tree.js';
 import { save } from './save.js';
 import { Worker, MessageChannel } from 'node:worker_threads';
 import { fileURLToPath } from 'node:url';
 import { setTimeout } from 'node:timers/promises';
 import { migrate } from './migrate/index.js';
+import { debugServer } from '../utils.js';
 export const SCHEMA_FILE = 'schema.json';
 export const WRITELOG_FILE = 'writelog.json';
 const __filename = fileURLToPath(import.meta.url);
@@ -45,10 +45,6 @@ export class DbWorker {
             transferList: [port2],
         });
         port1.on('message', (buf) => {
-            // TODO FIX TYPES CHECK IF THIS MAKES A COPY
-            // It's a copy, if you don't want a copy you'd need to make it an explicit view
-            // to the underlying buffer:
-            // new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength)
             this.resolvers.shift()(new Uint8Array(buf));
             this.db.onQueryEnd();
         });
@@ -93,11 +89,14 @@ export class DbServer {
     stopped;
     onSchemaChange;
     unlistenExit;
-    constructor({ path, maxModifySize = 100 * 1e3 * 1e3, onSchemaChange, }) {
+    constructor({ path, maxModifySize = 100 * 1e3 * 1e3, onSchemaChange, debug, }) {
         this.maxModifySize = maxModifySize;
         this.fileSystemPath = path;
         this.sortIndexes = {};
         this.onSchemaChange = onSchemaChange;
+        if (debug) {
+            debugServer(this);
+        }
     }
     #resizeModifyDirtyRanges() {
         let maxNrChanges = 0;
@@ -141,7 +140,7 @@ export class DbServer {
                             for (const lang in this.sortIndexes[type][field][start]) {
                                 const sortIndex = this.sortIndexes[type][field][start][lang];
                                 sortIndex.cnt /= 2;
-                                if (sortIndex.cnt < 1) {
+                                if (sortIndex.cnt < 1 && !this.processingQueries) {
                                     native.destroySortIndex(sortIndex.buf, this.dbCtxExternal);
                                     delete this.sortIndexes[type][field][start][lang];
                                 }
@@ -179,7 +178,7 @@ export class DbServer {
         if (sortIndex) {
             return sortIndex;
         }
-        const buf = new Uint8Array(8);
+        const buf = new Uint8Array(9);
         // size [2 type] [1 field]  [2 start] [2 len] [propIndex] [lang]
         // call createSortBuf here
         buf[0] = t.id;
@@ -208,7 +207,6 @@ export class DbServer {
         }
         let sortIndex = fields[prop.start];
         if (sortIndex) {
-            // [2 type] [1 field] [2 start] [1 lang]
             const buf = new Uint8Array(6);
             buf[0] = t.id;
             buf[1] = t.id >>> 8;
@@ -279,29 +277,6 @@ export class DbServer {
         fields[start][lang] = sortIndex;
         return sortIndex;
     }
-    updateMerkleTree() {
-        foreachDirtyBlock(this, (mtKey, typeId, start, end) => {
-            const oldLeaf = this.merkleTree.search(mtKey);
-            const hash = new Uint8Array(16);
-            native.getNodeRangeHash(typeId, start, end, hash, this.dbCtxExternal);
-            if (oldLeaf) {
-                if (hashEq(oldLeaf.hash, hash)) {
-                    return;
-                }
-                try {
-                    this.merkleTree.delete(mtKey);
-                }
-                catch (err) { }
-            }
-            const data = {
-                file: '', // not saved yet
-                typeId,
-                start,
-                end,
-            };
-            this.merkleTree.insert(mtKey, hash, data);
-        });
-    }
     setSchema(strictSchema, fromStart = false, transformFns) {
         if (!fromStart && Object.keys(this.schema.types).length > 0) {
             return this.migrateSchema(strictSchema, transformFns);
@@ -373,6 +348,7 @@ export class DbServer {
             }
             if (strictSchema.props) {
                 // insert a root node
+                // TODO fix this 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 buf = new Uint8Array(data.length + 2 + 8 + 4);
@@ -387,6 +363,7 @@ export class DbServer {
                 view.setUint32(buf.length - 4, data.length, true);
                 this.modify(buf);
             }
+            initCsmt(this);
         }
         this.onSchemaChange?.(this.schema);
         return this.schema;
@@ -401,7 +378,16 @@ export class DbServer {
             i += 2;
             const startId = readUint32LE(buf, i);
             const def = this.schemaTypesParsedById[typeId];
-            const offset = def.lastId - startId;
+            let offset = def.lastId - startId;
+            if (offset < 0) {
+                console.log('-----------------');
+                console.log(def.type, {
+                    offset,
+                    serverId: def.lastId,
+                    clientId: startId,
+                });
+                offset = 0;
+            }
             buf[i++] = offset;
             buf[i++] = offset >>> 8;
             buf[i++] = offset >>> 16;
@@ -411,6 +397,7 @@ export class DbServer {
             def.lastId = lastId + offset;
             offsets[typeId] = offset;
         }
+        // console.log('modify', this.processingQueries)
         if (this.processingQueries) {
             this.modifyQueue.push(new Uint8Array(buf));
         }
@@ -449,10 +436,17 @@ export class DbServer {
             this.dirtyRanges.add(key);
         }
     }
-    getQueryBuf(buf) {
+    addToQueryQueue(resolve, buf) {
+        if (this.queryQueue.size === 16777216) {
+            resolve(new Error('Query queue exceeded'));
+            return;
+        }
+        this.queryQueue.set(resolve, buf);
+    }
+    getQueryBuf(buf, fromQueue = false) {
         if (this.modifyQueue.length) {
             return new Promise((resolve) => {
-                this.queryQueue.set(resolve, buf);
+                this.addToQueryQueue(resolve, buf);
             });
         }
         else {
@@ -469,7 +463,7 @@ export class DbServer {
                     if (!sortIndex) {
                         if (this.processingQueries) {
                             return new Promise((resolve) => {
-                                this.queryQueue.set(resolve, buf);
+                                this.addToQueryQueue(resolve, buf);
                             });
                         }
                         sortIndex = this.createSortIndexBuffer(typeId, field, start, sort[sort.byteLength - 1]);
@@ -482,6 +476,9 @@ export class DbServer {
             else if (queryType == 1) {
                 // This will be more advanced - sometimes has indexes / sometimes not
             }
+            if (!fromQueue) {
+                native.expire(this.dbCtxExternal);
+            }
             this.availableWorkerIndex =
                 (this.availableWorkerIndex + 1) % this.workers.length;
             return this.workers[this.availableWorkerIndex].getQueryBuf(buf);
@@ -491,16 +488,19 @@ export class DbServer {
         this.processingQueries--;
         if (this.processingQueries === 0) {
             if (this.modifyQueue.length) {
-                for (const buf of this.modifyQueue) {
+                const modifyQueue = this.modifyQueue;
+                this.modifyQueue = [];
+                for (const buf of modifyQueue) {
                     this.#modify(buf);
                 }
-                this.modifyQueue = [];
             }
             if (this.queryQueue.size) {
-                for (const [resolve, buf] of this.queryQueue) {
-                    resolve(this.getQueryBuf(buf));
+                const queryQueue = this.queryQueue;
+                this.queryQueue = new Map();
+                native.expire(this.dbCtxExternal);
+                for (const [resolve, buf] of queryQueue) {
+                    resolve(this.getQueryBuf(buf, true));
                 }
-                this.queryQueue.clear();
             }
         }
     }
@@ -510,7 +510,7 @@ export class DbServer {
         }
         this.stopped = true;
         clearTimeout(this.cleanupTimer);
-        this?.unlistenExit();
+        this.unlistenExit();
         try {
             if (!noSave) {
                 await this.save();
@@ -518,7 +518,7 @@ export class DbServer {
             await Promise.all(this.workers.map(({ worker }) => worker.terminate()));
             this.workers = [];
             native.stop(this.dbCtxExternal);
-            await setTimeout();
+            await setTimeout(20);
         }
         catch (e) {
             this.stopped = false;

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

@@ -4,7 +4,7 @@ import { tmpdir } from 'os';
 import { Worker, MessageChannel, receiveMessageOnPort, } from 'node:worker_threads';
 import native from '../../native.js';
 import './worker.js';
-import { foreachDirtyBlock } from '../tree.js';
+import { destructureCsmtKey, foreachDirtyBlock, specialBlock } from '../tree.js';
 import { SCHEMA_FILE } from '../index.js';
 import { fileURLToPath } from 'url';
 import { deepMerge } from '@saulx/utils';
@@ -35,7 +35,7 @@ export const migrate = async (fromDbServer, toSchema, transform) => {
     fromDbServer.migrating = migrationId;
     const abort = () => fromDbServer.migrating !== migrationId;
     const toDb = new BasedDb({
-        path: join(tmpdir(), (~~Math.random()).toString(36)),
+        path: join(tmpdir(), (~~(Math.random() * 1e9)).toString(36)),
     });
     await toDb.start({ clean: true });
     if (abort()) {
@@ -43,6 +43,10 @@ export const migrate = async (fromDbServer, toSchema, transform) => {
         return fromDbServer.schema;
     }
     toSchema = await toDb.setSchema(toSchema);
+    if (abort()) {
+        await toDb.destroy();
+        return fromDbServer.schema;
+    }
     const fromSchema = fromDbServer.schema;
     const fromCtx = fromDbServer.dbCtxExternal;
     const toCtx = toDb.server.dbCtxExternal;
@@ -67,14 +71,18 @@ export const migrate = async (fromDbServer, toSchema, transform) => {
     worker.on('error', console.error);
     let i = 0;
     let ranges = [];
-    // fromDbServer.updateMerkleTree()
-    // fromDbServer.dirtyRanges.clear()
     await fromDbServer.save();
     fromDbServer.merkleTree.visitLeafNodes((leaf) => {
+        const [_typeId, start] = destructureCsmtKey(leaf.key);
+        if (start == specialBlock)
+            return; // skip the type specialBlock
         ranges.push(leaf.data);
     });
     await Atomics.waitAsync(atomics, 0, 1).value;
     while (i < ranges.length) {
+        if (abort()) {
+            break;
+        }
         // block modifies
         fromDbServer.processingQueries++;
         const leafData = ranges[i++];
@@ -86,38 +94,48 @@ export const migrate = async (fromDbServer, toSchema, transform) => {
         await Atomics.waitAsync(atomics, 0, 1).value;
         // exec queued modifies
         fromDbServer.onQueryEnd();
-        if (abort()) {
-            break;
-        }
-        if (i === ranges.length && fromDbServer.dirtyRanges.size) {
-            ranges = [];
-            i = 0;
-            foreachDirtyBlock(fromDbServer, (_mtKey, typeId, start, end) => {
-                ranges.push({
-                    typeId,
-                    start,
-                    end,
+        if (i === ranges.length) {
+            if (fromDbServer.dirtyRanges.size) {
+                ranges = [];
+                i = 0;
+                foreachDirtyBlock(fromDbServer, (_mtKey, typeId, start, end) => {
+                    ranges.push({
+                        typeId,
+                        start,
+                        end,
+                    });
                 });
-            });
-            fromDbServer.dirtyRanges.clear();
+                fromDbServer.dirtyRanges.clear();
+            }
         }
     }
-    if (!abort()) {
-        let msg;
-        let schema;
-        let schemaTypesParsed;
-        while ((msg = receiveMessageOnPort(port1))) {
-            ;
-            [schema, schemaTypesParsed] = msg.message;
-        }
-        fromDbServer.schema = deepMerge(toDb.server.schema, schema);
-        fromDbServer.schemaTypesParsed = deepMerge(toDb.server.schemaTypesParsed, schemaTypesParsed);
-        fromDbServer.dbCtxExternal = toCtx;
-        toDb.server.dbCtxExternal = fromCtx;
+    if (abort()) {
+        await Promise.all([toDb.destroy(), worker.terminate()]);
+        return fromDbServer.schema;
+    }
+    let msg;
+    let schema;
+    let schemaTypesParsed;
+    while ((msg = receiveMessageOnPort(port1))) {
+        ;
+        [schema, schemaTypesParsed] = msg.message;
     }
+    fromDbServer.dbCtxExternal = toCtx;
+    fromDbServer.sortIndexes = {};
+    fromDbServer.schema = deepMerge(toDb.server.schema, schema);
+    fromDbServer.schemaTypesParsed = deepMerge(toDb.server.schemaTypesParsed, schemaTypesParsed);
+    fromDbServer.schemaTypesParsedById = {};
+    for (const key in fromDbServer.schemaTypesParsed) {
+        const def = fromDbServer.schemaTypesParsed[key];
+        fromDbServer.schemaTypesParsedById[def.id] = def;
+    }
+    toDb.server.dbCtxExternal = fromCtx;
     const promises = fromDbServer.workers.map((worker) => worker.updateCtx(toAddress));
     promises.push(toDb.destroy(), worker.terminate(), fromDbServer.save({ forceFullDump: true }), writeFile(join(fromDbServer.fileSystemPath, SCHEMA_FILE), JSON.stringify(fromDbServer.schema)));
     await Promise.all(promises);
+    if (abort()) {
+        return fromDbServer.schema;
+    }
     fromDbServer.onSchemaChange?.(fromDbServer.schema);
     return fromDbServer.schema;
 };

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

@@ -66,7 +66,7 @@ else {
                 const nodes = fromDb
                     .query(type)
                     .include(include)
-                    .range(leafData.start - 1, leafData.end - leafData.start + 1)
+                    .range(leafData.start - 1, leafData.end - 1)
                     ._getSync(fromCtx);
                 for (const node of nodes) {
                     const res = typeTransformFn(node);
@@ -85,7 +85,7 @@ else {
                 const nodes = fromDb
                     .query(type)
                     .include(include)
-                    .range(leafData.start - 1, leafData.end - leafData.start + 1)
+                    .range(leafData.start - 1, leafData.end - 1)
                     ._getSync(fromCtx);
                 for (const node of nodes) {
                     toDb.create(type, node, { unsafe: true });

package/dist/src/server/save.js

@@ -2,18 +2,21 @@ 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, makeCsmtKey, } from './tree.js';
+import { destructureCsmtKey, foreachBlock, foreachDirtyBlock, initCsmt, makeCsmtKey, specialBlock, } from './tree.js';
 import { WRITELOG_FILE } from './index.js';
 import { writeFileSync } from 'node:fs';
 import { bufToHex } from '../utils.js';
-import { createTree } from './csmt/tree.js';
 const COMMON_SDB_FILE = 'common.sdb';
 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) {
+    if (err == -8) {
+        // TODO ENOENT
+        return '';
+    }
+    else if (err) {
         // TODO print the error string
         console.error(`Save ${typeId}:${start}-${end} failed: ${err}`);
         return null;
@@ -32,51 +35,58 @@ export function save(db, sync = false, forceFullDump = false) {
     }
     if (forceFullDump) {
         // We just rebuild the whole tree
-        db.merkleTree = createTree(db.createCsmtHashFun); // TODO This could be somewhere else.
+        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) {
-                    // The previous state should remain in the merkle tree for
-                    // load and sync purposes.
-                    return;
+                if (file === null) {
+                    throw new Error('full dump failed');
+                }
+                else {
+                    const data = {
+                        file,
+                        typeId,
+                        start,
+                        end,
+                    };
+                    db.merkleTree.insert(mtKey, hash, data);
                 }
-                const mtKey = makeCsmtKey(typeId, start);
-                const data = {
-                    file,
-                    typeId,
-                    start,
-                    end,
-                };
-                db.merkleTree.insert(mtKey, hash, data);
             });
         }
     }
     else {
         foreachDirtyBlock(db, (mtKey, typeId, start, end) => {
             const hash = new Uint8Array(16);
+            // TODO Don't save if empty
             const file = saveRange(db, typeId, start, end, hash);
-            if (!file) {
+            if (file === null) {
                 // The previous state should remain in the merkle tree for
                 // load and sync purposes.
                 return;
             }
-            const data = {
-                file,
-                typeId,
-                start,
-                end,
-            };
-            try {
-                db.merkleTree.delete(mtKey);
+            else if (file.length === 0) {
+                // The range is empty
             }
-            catch (err) {
-                // console.error({ err })
+            else {
+                const oldLeaf = db.merkleTree.search(mtKey);
+                if (oldLeaf) {
+                    oldLeaf.data.file = file;
+                    db.merkleTree.update(mtKey, hash);
+                }
+                else {
+                    const data = {
+                        file,
+                        typeId,
+                        start,
+                        end,
+                    };
+                    db.merkleTree.insert(mtKey, hash, data);
+                }
             }
-            db.merkleTree.insert(mtKey, hash, data);
         });
     }
     db.dirtyRanges.clear();
@@ -89,6 +99,8 @@ export function save(db, sync = false, forceFullDump = false) {
     }
     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}`);

package/dist/src/server/start.js

@@ -3,8 +3,8 @@ import { DbWorker, SCHEMA_FILE, WRITELOG_FILE } from './index.js';
 import native from '../native.js';
 import { rm, mkdir, readFile } from 'node:fs/promises';
 import { join } from 'node:path';
-import { createTree, hashEq } from './csmt/index.js';
-import { foreachBlock, makeCsmtKey } from './tree.js';
+import { hashEq } from './csmt/index.js';
+import { foreachBlock, initCsmt, makeCsmtKey } from './tree.js';
 import { availableParallelism } from 'node:os';
 import exitHook from 'exit-hook';
 import './worker.js';
@@ -28,7 +28,7 @@ export async function start(db, opts) {
             native.loadCommon(join(path, writelog.commonDump), db.dbCtxExternal);
         }
         catch (e) {
-            console.log(e.message);
+            console.error(e.message);
             throw e;
         }
         // Load all range dumps
@@ -40,7 +40,7 @@ export async function start(db, opts) {
                     native.loadRange(join(path, fname), db.dbCtxExternal);
                 }
                 catch (e) {
-                    console.log(e.message);
+                    console.error(e.message);
                 }
             }
         }
@@ -53,21 +53,9 @@ export async function start(db, opts) {
     catch (err) {
         // TODO In some cases we really should give up!
     }
-    // The merkle tree should be empty at start.
-    if (!db.merkleTree || db.merkleTree.getRoot()) {
-        db.merkleTree = createTree(db.createCsmtHashFun);
-    }
-    // FDN-791 CSMT is unstable (not history independent)
-    // For now we just sort the types to ensure that we always
-    // load in the same order.
-    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;
-    }, {});
-    for (const key in types) {
-        const def = types[key];
+    const csmtTypes = initCsmt(db);
+    for (const key in csmtTypes) {
+        const def = csmtTypes[key];
         const [total, lastId] = native.getTypeInfo(def.id, db.dbCtxExternal);
         def.total = total;
         def.lastId = writelog?.types[def.id]?.lastId || lastId;

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

@@ -6,8 +6,10 @@ export type CsmtNodeRange = {
     start: number;
     end: number;
 };
+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): void;
 export declare function foreachDirtyBlock(db: DbServer, cb: (mtKey: number, typeId: number, start: number, end: number) => void): Promise<void>;

package/dist/src/server/tree.js

@@ -1,4 +1,8 @@
 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) => [
     (key / 4294967296) | 0, // typeId
     (key >>> 31) * 2147483648 + (key & 0x7fffffff), // start_node_id
@@ -8,13 +12,41 @@ export const makeCsmtKeyFromNodeId = (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);
+        }
+        catch (_) { }
+    }
+    return types;
+}
 export function foreachBlock(db, def, cb) {
     const step = def.blockCapacity;
     for (let start = 1; start <= def.lastId; start += step) {
         const end = start + step - 1;
         const hash = new Uint8Array(16);
-        native.getNodeRangeHash(def.id, start, end, hash, db.dbCtxExternal);
-        cb(start, end, hash);
+        const res = native.getNodeRangeHash(def.id, start, end, hash, db.dbCtxExternal);
+        if (res) {
+            cb(start, end, hash);
+        }
     }
 }
 export async function foreachDirtyBlock(db, cb) {

package/dist/src/server/worker.js

@@ -8,7 +8,7 @@ else {
     let { address, channel } = workerData;
     let dbCtx = native.externalFromInt(address);
     workerCtx = native.workerCtxInit();
-    const transferList = new Array(1);
+    // const transferList = new Array(1)
     const handleMsg = (msg) => {
         try {
             if (typeof msg === 'bigint') {
@@ -19,8 +19,8 @@ else {
             }
             else {
                 const arrayBuf = native.getQueryBuf(msg, dbCtx);
-                transferList[0] = arrayBuf;
-                channel.postMessage(arrayBuf, transferList);
+                // transferList[0] = arrayBuf
+                channel.postMessage(arrayBuf, [arrayBuf]);
             }
         }
         catch (e) {

package/dist/src/utils.d.ts

@@ -1,10 +1,12 @@
+import { DbServer } from './server/index.js';
 export declare const DECODER: TextDecoder;
 export declare const ENCODER: TextEncoder;
+export declare const debugMode: (target: any, getInfo?: any) => void;
+export declare const debugServer: (server: DbServer) => void;
 export declare const equals: (aB: Uint8Array, bB: Uint8Array) => boolean;
 export declare function concatUint8Arr(bufs: Uint8Array[], totalByteLength?: number): Uint8Array;
 export declare const bufToHex: (a: Uint8Array) => string;
 export declare const hexToBuf: (s: string) => Uint8Array;
-export declare const base64encode: (a: Uint8Array, lineMax?: number) => string;
 export declare const readDoubleLE: (val: Uint8Array, offset: number) => number;
 export declare const readFloatLE: (val: Uint8Array, offset: number) => number;
 export declare const readUint32: (val: Uint8Array, offset: number) => number;