@based/db 0.0.66 → 0.0.68

package/dist/src/client/query/read/read.js

@@ -1,9 +1,10 @@
-import { ALIAS, ALIASES, BINARY, BOOLEAN, ENUM, INT16, INT32, INT8, NUMBER, STRING, TEXT, TIMESTAMP, UINT16, UINT32, UINT8, VECTOR, JSON, CARDINALITY, } from '@based/schema/def';
+import { ALIAS, ALIASES, BINARY, BOOLEAN, ENUM, INT16, INT32, INT8, NUMBER, STRING, TEXT, TIMESTAMP, UINT16, UINT32, UINT8, VECTOR, JSON, CARDINALITY, COLVEC, } from '@based/schema/def';
 import { QueryDefType } from '../types.js';
 import { read, readUtf8 } from '../../string.js';
 import { DECODER, readDoubleLE, readFloatLE, readInt16, readInt32, readUint16, readUint32, setByPath, } from '@saulx/utils';
 import { inverseLangMap } from '@based/schema';
 import { READ_EDGE, READ_ID, READ_REFERENCE, READ_REFERENCES, READ_AGGREGATION, } from '../types.js';
+import { AggregateType } from '../aggregates/types.js';
 const readAggregate = (q, result, offset, len) => {
     const results = {};
     if (q.aggregate.groupBy) {
@@ -21,24 +22,47 @@ const readAggregate = (q, result, offset, len) => {
                 i += 2;
             }
             else {
-                keyLen = readUint16(result, i);
-                i += 2;
-                key = DECODER.decode(result.subarray(i, i + keyLen));
-                i += keyLen;
+                if (q.aggregate.groupBy.typeIndex == ENUM) {
+                    i += 2;
+                    key = q.aggregate.groupBy.enum[result[i] - 1];
+                    i++;
+                }
+                else {
+                    keyLen = readUint16(result, i);
+                    i += 2;
+                    key = DECODER.decode(result.subarray(i, i + keyLen));
+                    i += keyLen;
+                }
             }
             const resultKey = (results[key] = {});
             for (const aggregatesArray of q.aggregate.aggregates.values()) {
                 for (const agg of aggregatesArray) {
-                    setByPath(resultKey, agg.propDef.path, readUint32(result, agg.resultPos + i));
+                    var val = undefined;
+                    if (agg.type === AggregateType.CARDINALITY ||
+                        agg.type === AggregateType.COUNT) {
+                        val = readUint32(result, agg.resultPos + i);
+                    }
+                    else {
+                        val = readDoubleLE(result, agg.resultPos + i);
+                    }
+                    setByPath(resultKey, agg.propDef.path, val);
                 }
             }
-            i += q.aggregate.totalResultsPos;
+            i += q.aggregate.totalResultsSize;
         }
     }
     else {
         for (const aggregatesArray of q.aggregate.aggregates.values()) {
             for (const agg of aggregatesArray) {
-                setByPath(results, agg.propDef.path, readUint32(result, agg.resultPos + offset));
+                var val = undefined;
+                if (agg.type === AggregateType.CARDINALITY ||
+                    agg.type === AggregateType.COUNT) {
+                    val = readUint32(result, agg.resultPos + offset);
+                }
+                else {
+                    val = readDoubleLE(result, agg.resultPos + offset);
+                }
+                setByPath(results, agg.propDef.path, val);
             }
         }
     }
@@ -172,13 +196,13 @@ const handleUndefinedProps = (id, q, item) => {
             if (prop.typeIndex === CARDINALITY) {
                 addField(prop, 0, item);
             }
-            else if (prop.typeIndex === TEXT && q.lang == 0) {
+            else if (prop.typeIndex === TEXT && q.lang.lang == 0) {
                 const lan = getEmptyField(prop, item);
                 const lang = q.include.langTextFields.get(prop.prop).codes;
                 if (lang.has(0)) {
                     for (const locale in q.schema.locales) {
                         if (lan[locale] == undefined) {
-                            lan[locale] = prop.default[locale] || '';
+                            lan[locale] = '';
                         }
                     }
                 }
@@ -186,23 +210,26 @@ const handleUndefinedProps = (id, q, item) => {
                     for (const code of lang) {
                         const locale = inverseLangMap.get(code);
                         if (!lan[locale]) {
-                            lan[locale] = prop.default[locale] || '';
+                            lan[locale] = '';
                         }
                     }
                 }
             }
-            else if (prop.typeIndex === BINARY) {
-                addField(prop, prop.default, item);
-            }
-            else if (prop.typeIndex === TEXT) {
+            // else if (prop.typeIndex === BINARY) {
+            //   addField(prop, prop.default, item)
+            // }
+            else if (prop.typeIndex === TEXT ||
+                prop.typeIndex === STRING ||
+                prop.typeIndex === ALIAS) {
                 addField(prop, '', item);
             }
-            else {
-                1;
-                if (prop.default !== undefined) {
-                    addField(prop, prop.default, item);
-                }
-            }
+            // else if (prop.typeIndex === JSON) {
+            //   // addField(prop, null, item)
+            // } else {
+            //   // if (prop.default !== undefined) {
+            //   //   addField(prop, '', item)
+            //   // }
+            // }
         }
     }
 };
@@ -380,7 +407,7 @@ export const readAllFields = (q, result, offset, end, item, id) => {
                     // do nothing
                 }
                 else {
-                    if (q.lang != 0) {
+                    if (q.lang.lang != 0) {
                         q.include.propsRead[index] = id;
                         addField(prop, read(result, i + 4, size, true), item);
                     }
@@ -403,7 +430,7 @@ export const readAllFields = (q, result, offset, end, item, id) => {
                     addField(prop, string, item);
                 }
             }
-            else if (prop.typeIndex == VECTOR) {
+            else if (prop.typeIndex == VECTOR || prop.typeIndex == COLVEC) {
                 q.include.propsRead[index] = id;
                 const size = readUint32(result, i);
                 const arr = new Float32Array(size / 4);

package/dist/src/client/query/registerQuery.js

@@ -16,6 +16,7 @@ export const registerQuery = (q) => {
         for (const command of commands) {
             q[command.method](...command.args);
         }
+        // locale first...
         if (!q.def.include.stringFields.size && !q.def.references.size) {
             includeField(q.def, '*');
         }

package/dist/src/client/query/search/index.d.ts

@@ -5,4 +5,4 @@ export type Search = string[] | {
 } | string;
 export declare const vectorSearch: (def: QueryDef, q: ArrayBufferView, field: string, opts: Omit<FilterOpts, "lowerCase">) => void;
 export declare const search: (def: QueryDef, q: string, s?: Search) => void;
-export declare const searchToBuffer: (search: QueryDefSearch) => Uint8Array;
+export declare const searchToBuffer: (search: QueryDefSearch) => Uint8Array<ArrayBuffer>;

package/dist/src/client/query/search/index.js

@@ -74,14 +74,16 @@ export const search = (def, q, s) => {
     }
     for (const key in s) {
         let prop = def.props[key];
-        let lang = def.lang;
+        let lang = def.lang.lang;
+        let fallback = def.lang.fallback;
         if (!prop) {
             if (key.includes('.')) {
                 const k = key.split('.');
                 prop = def.props[k.slice(0, -1).join('.')];
                 if (prop && prop.typeIndex === TEXT) {
                     lang = langCodesMap.get(k[k.length - 1]);
-                    // incorrect LANG
+                    fallback = [];
+                    // handle incorrect LANG
                 }
                 else {
                     prop = searchDoesNotExist(def, key, false);
@@ -94,11 +96,16 @@ export const search = (def, q, s) => {
         if (prop.typeIndex !== STRING && prop.typeIndex !== TEXT) {
             searchIncorrectType(def, prop);
         }
-        def.search.size += 6;
+        def.search.size += 10;
+        if (fallback.length > 3) {
+            // Max 4 lang fallback size (tmp)
+            console.warn('Search has a max of 4 lang fallbacks!');
+            fallback = fallback.slice(0, 3);
+        }
         def.search.fields.push({
             typeIndex: prop.typeIndex,
             weight: s[key],
-            lang,
+            lang: { lang, fallback },
             field: prop.prop,
             start: prop.start ?? 0, // also need lang ofc if you have start
         });
@@ -147,6 +154,8 @@ export const searchToBuffer = (search) => {
         | 2      | weight    | 1           | Field weight value                   |
         | 3      | start     | 2           | Start position in the query (u16)    |
         | 5      | lang      | 1           | Language identifier                  |
+        | 6      | fallbackL | 1           | Language fallback size               |
+        | 7      | fallback  | 3           | Language fallback                    |
     
         ### Notes:
         - The number of field entries is inferred from the total packet size.
@@ -162,15 +171,20 @@ export const searchToBuffer = (search) => {
             return a.weight - b.weight;
         });
         // @ts-ignore
-        for (let i = 0; i < search.fields.length * 6; i += 6) {
+        for (let i = 0; i < search.fields.length * 10; i += 10) {
             // @ts-ignore
-            const f = search.fields[Math.floor(i / 6)];
+            const f = search.fields[Math.floor(i / 10)];
             result[i + offset] = f.field;
             result[i + offset + 1] = f.typeIndex;
             result[i + offset + 2] = f.weight;
             result[i + offset + 3] = f.start;
             result[i + offset + 4] = f.start >>> 8;
-            result[i + offset + 5] = f.lang;
+            // fallback
+            result[i + offset + 5] = f.lang.lang;
+            result[i + offset + 6] = f.lang.fallback.length;
+            for (let j = 0; j < f.lang.fallback.length; j++) {
+                result[i + j + offset + 7] = f.lang.fallback[j];
+            }
         }
         return result;
     }

package/dist/src/client/query/sort.d.ts

@@ -1,3 +1,3 @@
 import { QueryDef, QueryDefSort } from './types.js';
-export declare const createSortBuffer: (sort: QueryDefSort) => Uint8Array;
+export declare const createSortBuffer: (sort: QueryDefSort) => Uint8Array<ArrayBuffer>;
 export declare const sort: (def: QueryDef, field: string, order?: "asc" | "desc") => void;

package/dist/src/client/query/toByteCode/default.d.ts

@@ -1,2 +1,2 @@
 import { QueryDef } from '../types.js';
-export declare const defaultQuery: (def: QueryDef, filterSize: number, sortSize: number, searchSize: number, sort: Uint8Array, search: Uint8Array) => Uint8Array;
+export declare const defaultQuery: (def: QueryDef, filterSize: number, sortSize: number, searchSize: number, sort: Uint8Array, search: Uint8Array) => Uint8Array<ArrayBuffer>;

package/dist/src/client/query/toByteCode/default.js

@@ -17,8 +17,6 @@ export const defaultQuery = (def, filterSize, sortSize, searchSize, sort, search
     buf[index++] = filterSize;
     buf[index++] = filterSize >>> 8;
     buf[index++] = filterSize && isSimpleMainFilter(def.filter) ? 1 : 0;
-    // if (filterSize && isSimpleMainFilter(def.filter)) {
-    // console.log('SIMPLE FILTER!')
     if (filterSize) {
         buf.set(filterToBuffer(def.filter), index);
         index += filterSize;

package/dist/src/client/query/toByteCode/toBuffer.js

@@ -14,7 +14,6 @@ const byteSize = (arr) => {
 export function defToBuffer(db, def) {
     const result = [];
     const include = includeToBuffer(db, def);
-    // ---------------------------------------
     def.references.forEach((ref) => {
         include.push(...defToBuffer(db, ref));
         if (ref.errors) {
@@ -46,7 +45,6 @@ export function defToBuffer(db, def) {
             buf[0] = 251 /* includeOp.REFERENCES_AGGREGATION */;
             buf[1] = sz;
             buf[2] = sz >>> 8;
-            // ---
             buf[3] = filterSize;
             buf[4] = filterSize >>> 8;
             buf[5] = def.range.offset;
@@ -62,8 +60,6 @@ export function defToBuffer(db, def) {
             buf[9 + 2 + filterSize] = def.target.propDef.prop; // refField
             const aggregateBuffer = aggregateToBuffer(def.aggregate);
             buf.set(aggregateBuffer, 9 + 3 + filterSize);
-            // buf[12 + filterSize] = aggregateSize
-            // buf[12 + 1 + filterSize] = aggregateSize >>> 8
             result.push(buf);
         }
         else {
@@ -92,8 +88,6 @@ export function defToBuffer(db, def) {
             buf.set(aggregateBuffer, 16 + filterSize);
             result.push(buf);
         }
-        // ignore this for now...
-        // result.push(...include)
         if (def.type === QueryDefType.Root) {
             const checksum = new Uint8Array(8);
             writeUint64(checksum, def.schemaChecksum ?? 0, 0);
@@ -175,7 +169,6 @@ export function defToBuffer(db, def) {
                 buf[idsSize + 13] = def.range.limit >>> 16;
                 buf[idsSize + 14] = def.range.limit >>> 24;
                 // if (filterSize && isSimpleMainFilter(def.filter)) {
-                // console.log('SIMPLE FILTER!')
                 buf[idsSize + 15] = filterSize;
                 buf[idsSize + 16] = filterSize >>> 8;
                 if (filterSize) {

package/dist/src/client/query/types.d.ts

@@ -1,4 +1,4 @@
-import { LangCode } from '@based/schema';
+import { LangCode, LangName } from '@based/schema';
 import { PropDef, PropDefEdge, SchemaTypeDef } from '@based/schema/def';
 import { FilterOpts } from './filter/types.js';
 import { QueryError } from './validation.js';
@@ -59,7 +59,10 @@ export type QueryDefSearch = {
         weight: number;
         field: number;
         start: number;
-        lang: LangCode;
+        lang: {
+            lang: LangCode;
+            fallback: LangCode[];
+        };
         typeIndex: number;
     }[];
 } | {
@@ -78,17 +81,23 @@ export type Aggregation = {
     type: AggregateType;
     propDef: PropDef;
     resultPos: number;
+    accumulatorPos: number;
 };
 export type QueryDefAggregation = {
     size: number;
     groupBy?: PropDef;
     aggregates: Map<number, Aggregation[]>;
-    totalResultsPos: number;
+    totalResultsSize: number;
+    totalAccumulatorSize: number;
 };
+export type LangFallback = LangName | false;
 export type QueryDefShared = {
     schemaChecksum?: number;
     errors: QueryError[];
-    lang: LangCode;
+    lang: {
+        lang: LangCode;
+        fallback: LangCode[];
+    };
     filter: QueryDefFilter;
     aggregate: null | QueryDefAggregation;
     search: null | QueryDefSearch;
@@ -99,9 +108,11 @@ export type QueryDefShared = {
         limit: number;
     };
     include: {
-        langTextFields: Map<number, {
+        langTextFields: Map<number, // prop name
+        {
             def: PropDef | PropDefEdge;
             codes: Set<LangCode>;
+            fallBacks: LangCode[];
         }>;
         stringFields: Set<string>;
         props: Map<number, PropDef | PropDefEdge>;

package/dist/src/client/query/validation.js

@@ -139,6 +139,28 @@ export const validateFilter = (def, prop, f) => {
             });
             return true;
         }
+        // map { id: } format for filter
+        const values = f[2];
+        if (Array.isArray(values)) {
+            let hasObject = false;
+            for (const v of values) {
+                if (typeof v === 'object' && 'id' in v) {
+                    hasObject = true;
+                    break;
+                }
+            }
+            if (hasObject) {
+                f[2] = values.map((v) => {
+                    if (typeof v === 'object' && 'id' in v) {
+                        return v.id;
+                    }
+                    return v;
+                });
+            }
+        }
+        else if (typeof values === 'object' && 'id' in values) {
+            f[2] = values.id;
+        }
         if (validateVal(def, f, prop.validation)) {
             return true;
         }
@@ -274,7 +296,7 @@ export const validateSort = (def, field, orderInput) => {
             return {
                 prop: EMPTY_ALIAS_PROP_DEF,
                 order,
-                lang: def.lang,
+                lang: def.lang?.lang,
             };
         }
     }
@@ -287,7 +309,7 @@ export const validateSort = (def, field, orderInput) => {
     }
     else if (type === TEXT) {
         if (lang === 0) {
-            lang = def.lang ?? 0;
+            lang = def.lang?.lang ?? 0;
             if (lang === 0) {
                 def.errors.push({
                     code: ERR_SORT_LANG,
@@ -445,6 +467,7 @@ export const EMPTY_SCHEMA_DEF = {
     propNames: new Uint8Array([]),
     idUint8: new Uint8Array([0, 0]),
     mainEmptyAllZeroes: true,
+    hasSeperateDefaults: false,
 };
 export const aggregationFieldDoesNotExist = (def, field) => {
     def.errors.push({

package/dist/src/client/xxHash64.d.ts

@@ -1 +1 @@
-export declare const xxHash64: (buf: Uint8Array, target?: Uint8Array, index?: number) => Uint8Array;
+export declare const xxHash64: (buf: Uint8Array, target?: Uint8Array, index?: number) => Uint8Array<ArrayBufferLike>;

package/dist/src/index.d.ts

@@ -12,7 +12,6 @@ export { DbClient, DbServer };
 export { xxHash64 } from './client/xxHash64.js';
 export { crc32 } from './client/crc32.js';
 export { default as createHash } from './server/dbHash.js';
-export * from './client/query/serialize.js';
 export * from './utils.js';
 export * from './client/query/query.js';
 export * from './client/query/BasedDbQuery.js';

package/dist/src/index.js

@@ -13,7 +13,6 @@ export { DbClient, DbServer };
 export { xxHash64 } from './client/xxHash64.js';
 export { crc32 } from './client/crc32.js';
 export { default as createHash } from './server/dbHash.js';
-export * from './client/query/serialize.js';
 export * from './utils.js';
 export * from './client/query/query.js';
 export * from './client/query/BasedDbQuery.js';

package/dist/src/native.d.ts

@@ -1,7 +1,5 @@
 declare const native: {
     threadCtx: any;
-    historyAppend(history: any, typeId: number, nodeId: number, dbCtx: any): any;
-    historyCreate(pathname: string, mainLen: number): any;
     workerCtxInit: () => void;
     externalFromInt(address: BigInt): any;
     intFromExternal(external: any): BigInt;
@@ -13,6 +11,7 @@ declare const native: {
     saveBlock: (path: string, typeCode: number, start: number, dbCtx: any, hashOut: Uint8Array) => number;
     loadCommon: (path: string, dbCtx: any) => void;
     loadBlock: (path: string, dbCtx: any) => void;
+    delBlock: (dbCtx: any, typeId: number, block: number) => void;
     updateSchemaType: (prefix: number, buf: Uint8Array, dbCtx: any) => any;
     getTypeInfo: (typeId: number, dbCtx: any) => any;
     getNodeRangeHash: (typeId: number, start: number, end: number, bufOut: Uint8Array, dbCtx: any) => any;
@@ -25,5 +24,6 @@ declare const native: {
     equals: (a: Uint8Array, b: Uint8Array) => boolean;
     membarSyncRead: () => void;
     membarSyncWrite: () => void;
+    colvecTest: (dbCtx: any, typeId: number, field: number, nodeId: number, len: number) => any;
 };
 export default native;

package/dist/src/native.js

@@ -17,13 +17,6 @@ function SelvaIoErrlogToString(buf) {
 // then add ThreadCtx to modify ctx and query ctx
 const native = {
     threadCtx: null, // add compressors here as well!
-    historyAppend(history, typeId, nodeId, dbCtx) {
-        return db.historyAppend(history, typeId, nodeId, dbCtx);
-    },
-    historyCreate(pathname, mainLen) {
-        const pathBuf = ENCODER.encode(pathname + '\0');
-        return db.historyCreate(pathBuf, mainLen + 16 - (mainLen % 16));
-    },
     workerCtxInit: () => {
         return db.workerCtxInit();
     },
@@ -65,9 +58,12 @@ const native = {
         const pathBuf = ENCODER.encode(path + '\0');
         const err = db.loadBlock(pathBuf, dbCtx, selvaIoErrlog);
         if (err) {
-            throw new Error(`Failed to load a range. selvaError: ${err} cause:\n${SelvaIoErrlogToString(selvaIoErrlog)}`);
+            throw new Error(`Failed to load a range "${path}". selvaError: ${err} cause:\n${SelvaIoErrlogToString(selvaIoErrlog)}`);
         }
     },
+    delBlock: (dbCtx, typeId, block) => {
+        db.delBlock(dbCtx, typeId, block);
+    },
     updateSchemaType: (prefix, buf, dbCtx) => {
         return db.updateSchema(prefix, buf, dbCtx);
     },
@@ -104,6 +100,9 @@ const native = {
     membarSyncWrite: () => {
         db.membarSyncWrite();
     },
+    colvecTest: (dbCtx, typeId, field, nodeId, len) => {
+        return db.colvecTest(dbCtx, typeId, field, nodeId, len);
+    }
 };
 global.__basedDb__native__ = native;
 export default native;

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

@@ -0,0 +1,8 @@
+import { DbWorker } from './workers/DbWorker.js';
+import { DbServer } from './index.js';
+export declare class IoWorker extends DbWorker {
+    constructor(address: BigInt, db: DbServer);
+    handleMsg(_buf: any): void;
+    loadBlock(filepath: string): Promise<void>;
+    unloadBlock(filepath: string, typeId: number, start: number): Promise<Uint8Array>;
+}

package/dist/src/server/IoWorker.js

@@ -0,0 +1,39 @@
+import { DbWorker } from './workers/DbWorker.js';
+import { DECODER, readInt32 } from '@saulx/utils';
+export class IoWorker extends DbWorker {
+    constructor(address, db) {
+        const onExit = (_code) => {
+            this.db.ioWorker = new IoWorker(address, db);
+        };
+        super(address, db, onExit, 'io_worker.js');
+    }
+    handleMsg(_buf) {
+    }
+    async loadBlock(filepath) {
+        const job = {
+            type: 'load',
+            filepath
+        };
+        const resBuf = await this.call(job);
+        if (resBuf.length) {
+            throw new Error(DECODER.decode(resBuf));
+        }
+    }
+    async unloadBlock(filepath, typeId, start) {
+        const job = {
+            type: 'unload',
+            filepath,
+            typeId,
+            start
+        };
+        const resBuf = await this.call(job);
+        const err = readInt32(resBuf, 0);
+        if (err) {
+            throw new Error(`selva error: ${err}`);
+        }
+        // Note that this shares the original buffer which may not be 100% optimal,
+        // as the first 4 bytes are no longer needed.
+        return new Uint8Array(resBuf.buffer, 4);
+    }
+}
+//# sourceMappingURL=IoWorker.js.map

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

@@ -0,0 +1,8 @@
+import { DbWorker } from './workers/DbWorker.js';
+import { DbServer } from './index.js';
+export declare class QueryWorker extends DbWorker {
+    constructor(address: BigInt, db: DbServer, workerIndex: number);
+    handleMsg(_buf: any): void;
+    protected callback: (resolve: (x: any) => any) => void;
+    getQueryBuf(buf: Uint8Array): Promise<Uint8Array>;
+}

package/dist/src/server/QueryWorker.js

@@ -0,0 +1,26 @@
+import { DbWorker } from './workers/DbWorker.js';
+import { readUint64 } from '@saulx/utils';
+export class QueryWorker extends DbWorker {
+    constructor(address, db, workerIndex) {
+        const onExit = (_code) => {
+            this.db.workers[workerIndex] = new QueryWorker(address, db, workerIndex);
+        };
+        super(address, db, onExit, 'query_worker.js');
+    }
+    handleMsg(_buf) {
+        this.db.processingQueries--;
+        this.db.onQueryEnd();
+    }
+    callback = (resolve) => {
+        this.db.processingQueries++;
+        this.resolvers.push(resolve);
+    };
+    getQueryBuf(buf) {
+        const schemaChecksum = readUint64(buf, buf.byteLength - 8);
+        if (schemaChecksum !== this.db.schema?.hash) {
+            return Promise.resolve(new Uint8Array(1));
+        }
+        return this.call(buf);
+    }
+}
+//# sourceMappingURL=QueryWorker.js.map

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

@@ -0,0 +1,24 @@
+import { SchemaTypeDef } from '@based/schema/def';
+import { DbServer } from './index.js';
+/**
+ * Save a block.
+ */
+export declare function saveBlock(db: DbServer, typeId: number, start: number, end: number): void;
+/**
+ * Load a block (typically of a partial type) back to memory.
+ */
+export declare function loadBlock(db: DbServer, def: SchemaTypeDef, start: number): Promise<void>;
+/**
+ * Save a block and remove it from memory.
+ */
+export declare function unloadBlock(db: DbServer, def: SchemaTypeDef, start: number): Promise<void>;
+/**
+ * Execute cb() for each block in memory.
+ */
+export declare function foreachBlock(db: DbServer, def: SchemaTypeDef, cb: (start: number, end: number, hash: Uint8Array) => void, includeEmptyBlocks?: boolean): void;
+/**
+ * Execute cb() for each dirty block.
+ * A dirty block is one that is changed in memory but not yet persisted in the
+ * file system.
+ */
+export declare function foreachDirtyBlock(db: DbServer, cb: (mtKey: number, typeId: number, start: number, end: number) => void): void;