@based/db 0.0.66 → 0.0.68

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.loadBlock(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>;
+}

package/dist/src/server/{DbWorker.js → workers/DbWorker.js}

@@ -1,16 +1,14 @@
 import { MessageChannel, Worker } from 'node:worker_threads';
 import { fileURLToPath } from 'node:url';
 import { dirname, join } from 'node:path';
-import { readUint64 } from '@saulx/utils';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
-const workerPath = join(__dirname, 'worker.js');
 export class DbWorker {
-    constructor(address, db, workerIndex) {
+    constructor(address, db, onExit, workerName) {
         const { port1, port2 } = new MessageChannel();
         this.db = db;
         this.channel = port1;
-        this.worker = new Worker(workerPath, {
+        this.worker = new Worker(join(__dirname, workerName), {
             workerData: {
                 isDbWorker: true,
                 channel: port2,
@@ -41,12 +39,12 @@ export class DbWorker {
                     resolve(err);
                 }
                 this.resolvers = [];
-                this.db.workers[workerIndex] = new DbWorker(address, db, workerIndex);
+                onExit(code);
             }
         });
-        port1.on('message', (buf) => {
+        this.channel.on('message', (buf) => {
             this.resolvers.shift()(new Uint8Array(buf));
-            this.db.onQueryEnd();
+            this.handleMsg(buf);
         });
     }
     db;
@@ -54,21 +52,21 @@ export class DbWorker {
     worker;
     resolvers = [];
     readyPromise;
+    async terminate() {
+        return this.worker.terminate();
+    }
     callback = (resolve) => {
-        this.db.processingQueries++;
         this.resolvers.push(resolve);
     };
-    updateCtx(address) {
-        this.channel.postMessage(address);
+    /**
+     * Send msg to the worker thread and return a promise to the response.
+     */
+    call(msg) {
+        this.channel.postMessage(msg);
         return new Promise(this.callback);
     }
-    getQueryBuf(buf) {
-        const schemaChecksum = readUint64(buf, buf.byteLength - 8);
-        if (schemaChecksum !== this.db.schema?.hash) {
-            return Promise.resolve(new Uint8Array(1));
-        }
-        this.channel.postMessage(buf);
-        return new Promise(this.callback);
+    updateCtx(address) {
+        return this.call(address);
     }
 }
 //# sourceMappingURL=DbWorker.js.map

package/dist/src/server/workers/io_worker.js

@@ -0,0 +1,39 @@
+import { registerMsgHandler } from './worker.js';
+import { ENCODER, writeInt32 } from '@saulx/utils';
+import native from '../../native.js';
+function loadBlock(dbCtx, filepath) {
+    try {
+        native.loadBlock(filepath, dbCtx);
+    }
+    catch (e) {
+        // need to get rid of the shared buffer
+        return new Uint8Array(ENCODER.encode(e.toString())).buffer;
+    }
+    return null;
+}
+function unloadBlock(dbCtx, filepath, typeId, start) {
+    const buf = new ArrayBuffer(20); // [[4 bytes err], [16 bytes hash]]
+    const hash = new Uint8Array(buf, 4);
+    const err = native.saveBlock(filepath, typeId, start, dbCtx, hash);
+    if (err) {
+        const errCodeBuf = new Uint8Array(buf, 0, 4);
+        writeInt32(errCodeBuf, err, 0);
+    }
+    else {
+        native.delBlock(dbCtx, typeId, start);
+    }
+    return buf;
+}
+registerMsgHandler((dbCtx, msg) => {
+    if (typeof msg?.type === 'string') {
+        const job = msg;
+        if (job.type === 'load') {
+            return loadBlock(dbCtx, job.filepath);
+        }
+        else if (job.type === 'unload') {
+            return unloadBlock(dbCtx, job.filepath, job.typeId, job.start);
+        }
+    }
+    return null;
+});
+//# sourceMappingURL=io_worker.js.map

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

@@ -0,0 +1,12 @@
+type IoJobLoad = {
+    type: 'load';
+    filepath: string;
+};
+type IoJobUnload = {
+    type: 'unload';
+    filepath: string;
+    typeId: number;
+    start: number;
+};
+export type IoJob = IoJobLoad | IoJobUnload;
+export {};

package/dist/src/server/workers/io_worker_types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=io_worker_types.js.map

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

@@ -0,0 +1 @@
+export {};

package/dist/src/server/workers/query_worker.js

@@ -0,0 +1,4 @@
+import { registerMsgHandler } from './worker.js';
+import native from '../../native.js';
+registerMsgHandler((dbCtx, msg) => native.getQueryBuf(msg, dbCtx));
+//# sourceMappingURL=query_worker.js.map

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

@@ -0,0 +1 @@
+export declare function registerMsgHandler(onMsg: (dbCtx: any, msg: any) => Uint8Array<ArrayBufferLike> | ArrayBuffer | null): void;

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

@@ -0,0 +1,41 @@
+import { isMainThread, parentPort, workerData } from 'node:worker_threads';
+import native from '../../native.js';
+let dbCtx;
+let wCtx; // This must be held until the worker exits otherwise the ctx will be autofreed instantly
+if (isMainThread) {
+    console.warn(`running a worker in the mainthread - incorrect`);
+}
+else if (workerData?.isDbWorker) {
+    let { address } = workerData;
+    dbCtx = native.externalFromInt(address);
+    wCtx = native.workerCtxInit();
+}
+else {
+    console.info('incorrect worker db query');
+}
+export function registerMsgHandler(onMsg) {
+    if (!workerData?.isDbWorker) {
+        throw new Error('Not a DbWorker');
+    }
+    let { channel } = workerData;
+    const handleMsg = (msg) => {
+        try {
+            if (typeof msg === 'bigint') {
+                // it's a ctx address
+                dbCtx = native.externalFromInt(msg);
+                channel.postMessage(null);
+            }
+            else {
+                // a message to the worker handler
+                const arrayBuf = onMsg(dbCtx, msg);
+                channel.postMessage(arrayBuf, [arrayBuf]);
+            }
+        }
+        catch (e) {
+            channel.postMessage(e);
+        }
+    };
+    channel.on('message', handleMsg);
+    parentPort.postMessage('READY');
+}
+//# sourceMappingURL=worker.js.map

package/dist/src/shared/Emitter.d.ts

@@ -2,6 +2,7 @@ import { DbSchema } from '../schema.js';
 export type EventMap = {
     schema: DbSchema;
     info: string;
+    error: string;
 };
 export type Event = keyof EventMap;
 export type Listener<T> = (data: T) => void;

package/dist/src/types.d.ts

@@ -1,4 +1,4 @@
-export declare const SCHEMA_FILE = "schema.json";
+export declare const SCHEMA_FILE = "schema.bin";
 export declare const WRITELOG_FILE = "writelog.json";
 export declare const COMMON_SDB_FILE = "common.sdb";
 export type BasedDbOpts = {

package/dist/src/types.js

@@ -1,4 +1,4 @@
-export const SCHEMA_FILE = 'schema.json';
+export const SCHEMA_FILE = 'schema.bin';
 export const WRITELOG_FILE = 'writelog.json';
 export const COMMON_SDB_FILE = 'common.sdb';
 //# sourceMappingURL=types.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@based/db",
-  "version": "0.0.66",
+  "version": "0.0.68",
   "license": "MIT",
   "type": "module",
   "main": "./dist/src/index.js",
@@ -38,9 +38,9 @@
     "basedDbNative.cjs"
   ],
   "dependencies": {
-    "@based/schema": "5.0.0-alpha.20",
+    "@based/schema": "5.0.0-alpha.23",
     "@saulx/hash": "^3.0.0",
-    "@saulx/utils": "^6.7.0",
+    "@saulx/utils": "^6.7.2",
     "exit-hook": "^4.0.0",
     "picocolors": "^1.1.0",
     "@based/crc32c": "^1.0.0"