@based/db 0.0.64 → 0.0.67

package/dist/src/client/query/filter/primitiveFilter.d.ts

@@ -1,5 +1,4 @@
 import { PropDef, PropDefEdge } from '@based/schema/def';
 import { QueryDef, QueryDefFilter } from '../types.js';
 import { Filter } from './types.js';
-import { LangCode } from '@based/schema';
-export declare const primitiveFilter: (def: QueryDef, prop: PropDef | PropDefEdge, filter: Filter, conditions: QueryDefFilter, lang: LangCode) => number;
+export declare const primitiveFilter: (def: QueryDef, prop: PropDef | PropDefEdge, filter: Filter, conditions: QueryDefFilter, lang: QueryDef["lang"]) => number;

package/dist/src/client/query/include/props.js

@@ -69,9 +69,25 @@ export const includeProp = (def, prop) => {
     }
     if (prop.typeIndex === TEXT) {
         if (!def.include.langTextFields.has(prop.prop)) {
-            def.include.langTextFields.set(prop.prop, { def: prop, codes: new Set() });
+            def.include.langTextFields.set(prop.prop, {
+                def: prop,
+                codes: new Set(),
+                fallBacks: [],
+            });
+        }
+        const langs = def.include.langTextFields.get(prop.prop);
+        if (def.lang.fallback.length > 0) {
+            for (const fallback of def.lang.fallback) {
+                if (!langs.fallBacks.includes(fallback)) {
+                    langs.fallBacks.push(fallback);
+                }
+            }
+        }
+        const langCode = def.lang.lang ?? 0;
+        langs.codes.add(langCode);
+        if (langCode === 0 || langs.codes.size > 1) {
+            langs.fallBacks = [];
         }
-        def.include.langTextFields.get(prop.prop).codes.add(def.lang ?? 0);
     }
     else {
         if (prop.separate) {

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

@@ -56,21 +56,29 @@ export const includeToBuffer = (db, def) => {
         }
     }
     if (def.include.langTextFields.size) {
-        for (const [prop, { codes, def: propDef },] of def.include.langTextFields.entries()) {
+        for (const [prop, { codes, def: propDef, fallBacks },] of def.include.langTextFields.entries()) {
             def.include.propsRead[prop] = 0;
             if (codes.has(0)) {
-                const b = new Uint8Array(3);
+                const b = new Uint8Array(4);
                 b[0] = prop;
                 b[1] = propDef.typeIndex;
                 b[2] = 0;
+                b[3] = 0;
                 result.push(b);
             }
             else {
                 for (const code of codes) {
-                    const b = new Uint8Array(3);
+                    const fallBackSize = fallBacks.length;
+                    const b = new Uint8Array(4 + fallBackSize);
                     b[0] = prop;
                     b[1] = propDef.typeIndex;
                     b[2] = code;
+                    b[3] = fallBackSize;
+                    let i = 0;
+                    for (const fallback of fallBacks) {
+                        b[i + 4] = fallback;
+                        i++;
+                    }
                     result.push(b);
                 }
             }

package/dist/src/client/query/include/walk.js

@@ -55,7 +55,11 @@ export const walkDefs = (db, def, f) => {
                     return;
                 }
                 if (!def.include.langTextFields.has(t.prop)) {
-                    def.include.langTextFields.set(t.prop, { def: t, codes: new Set() });
+                    def.include.langTextFields.set(t.prop, {
+                        def: t,
+                        codes: new Set(),
+                        fallBacks: [],
+                    });
                 }
                 def.include.langTextFields.get(t.prop).codes.add(langCode);
                 return;

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

@@ -8,7 +8,10 @@ const createEmptySharedDef = (skipValidation) => {
         skipValidation,
         filter: { conditions: new Map(), size: 0 },
         range: { offset: 0, limit: 0 },
-        lang: langCodesMap.get('none'),
+        lang: {
+            lang: langCodesMap.get('none'),
+            fallback: [],
+        },
         include: {
             langTextFields: new Map(),
             stringFields: new Set(),

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

@@ -1,15 +1,17 @@
-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) {
         let i = offset;
         while (i < len) {
             let key = '';
+            let keyLen = 0;
             if (result[i] == 0) {
                 if (q.aggregate.groupBy.default) {
                     key = q.aggregate.groupBy.default;
@@ -17,24 +19,50 @@ const readAggregate = (q, result, offset, len) => {
                 else {
                     key = `$undefined`;
                 }
+                i += 2;
             }
             else {
-                key = DECODER.decode(result.subarray(i, i + 2));
+                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;
+                }
             }
-            i += 2;
             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);
             }
         }
     }
@@ -168,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] = '';
                         }
                     }
                 }
@@ -182,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)
+            //   // }
+            // }
         }
     }
 };
@@ -376,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);
                     }
@@ -399,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);
@@ -414,7 +445,6 @@ export const readAllFields = (q, result, offset, end, item, id) => {
     handleUndefinedProps(id, q, item);
     return i - offset;
 };
-let cnt = 0;
 export const resultToObject = (q, result, end, offset = 0) => {
     if (q.aggregate) {
         return readAggregate(q, result, 0, result.byteLength - 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.d.ts

@@ -31,6 +31,7 @@ export declare const ERR_SEARCH_TYPE = 22;
 export declare const ERR_SEARCH_INCORRECT_VALUE = 23;
 export declare const ERR_SORT_LANG = 24;
 export declare const ERR_AGG_ENOENT = 25;
+export declare const ERR_AGG_TYPE = 26;
 declare const messages: {
     1: (p: any) => string;
     2: (p: any) => string;
@@ -57,6 +58,7 @@ declare const messages: {
     23: (p: any) => string;
     24: (p: any) => string;
     25: (p: any) => string;
+    26: (p: any) => string;
 };
 export type ErrorCode = keyof typeof messages;
 export declare const searchIncorrecQueryValue: (def: QueryDef, payload: any) => void;
@@ -85,4 +87,5 @@ export declare const ERROR_STRING: PropDef;
 export declare const ERROR_VECTOR: PropDef;
 export declare const EMPTY_SCHEMA_DEF: SchemaTypeDef;
 export declare const aggregationFieldDoesNotExist: (def: QueryDef, field: string) => void;
+export declare const aggregationFieldNotNumber: (def: QueryDef, field: string) => void;
 export {};

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

@@ -29,6 +29,7 @@ export const ERR_SEARCH_TYPE = 22;
 export const ERR_SEARCH_INCORRECT_VALUE = 23;
 export const ERR_SORT_LANG = 24;
 export const ERR_AGG_ENOENT = 25;
+export const ERR_AGG_TYPE = 26;
 const messages = {
     [ERR_TARGET_INVAL_TYPE]: (p) => `Type "${p}" does not exist`,
     [ERR_TARGET_INVAL_ALIAS]: (p) => {
@@ -61,6 +62,7 @@ const messages = {
     [ERR_SEARCH_INCORRECT_VALUE]: (p) => `Search: incorrect query on field "${safeStringify(p)}"`,
     [ERR_SORT_LANG]: (p) => `Sort: invalid lang`,
     [ERR_AGG_ENOENT]: (p) => `Field \"${p}\" in the aggregate function is invalid or unreacheable.`,
+    [ERR_AGG_TYPE]: (p) => `Aggregate: incorrect type "${p.path.join('.')}"`,
 };
 export const searchIncorrecQueryValue = (def, payload) => {
     def.errors.push({ code: ERR_SEARCH_INCORRECT_VALUE, payload });
@@ -137,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;
         }
@@ -272,7 +296,7 @@ export const validateSort = (def, field, orderInput) => {
             return {
                 prop: EMPTY_ALIAS_PROP_DEF,
                 order,
-                lang: def.lang,
+                lang: def.lang?.lang,
             };
         }
     }
@@ -285,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,
@@ -443,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({
@@ -451,4 +476,11 @@ export const aggregationFieldDoesNotExist = (def, field) => {
     });
     handleErrors(def);
 };
+export const aggregationFieldNotNumber = (def, field) => {
+    def.errors.push({
+        code: ERR_AGG_TYPE,
+        payload: field,
+    });
+    handleErrors(def);
+};
 //# sourceMappingURL=validation.js.map

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,14 +12,13 @@ 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';
 export * from './client/query/BasedIterable.js';
 export * from './server/save.js';
 export * from './hooks.js';
-export { getDefaultHooks };
+export { getDefaultHooks, BasedDbOpts };
 export declare class BasedDb extends Emitter {
     client: DbClient;
     server: DbServer;

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,6 +1,5 @@
 declare const native: {
-    historyAppend(history: any, typeId: number, nodeId: number, dbCtx: any): any;
-    historyCreate(pathname: string, mainLen: number): any;
+    threadCtx: any;
     workerCtxInit: () => void;
     externalFromInt(address: BigInt): any;
     intFromExternal(external: any): BigInt;
@@ -9,9 +8,10 @@ declare const native: {
     start: () => any;
     stop: (dbCtx: any) => any;
     saveCommon: (path: string, dbCtx: any) => number;
-    saveRange: (path: string, typeCode: number, start: number, end: number, dbCtx: any, hashOut: Uint8Array) => number;
+    saveBlock: (path: string, typeCode: number, start: number, dbCtx: any, hashOut: Uint8Array) => number;
     loadCommon: (path: string, dbCtx: any) => void;
-    loadRange: (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;
@@ -22,5 +22,8 @@ declare const native: {
     destroySortIndex: (buf: Uint8Array, dbCtx: any) => any;
     xxHash64: (buf: Uint8Array, target: Uint8Array, index: number) => any;
     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;