@based/db 0.0.64 → 0.0.66

package/dist/lib/linux_x86_64/include/selva/db.h

@@ -42,24 +42,24 @@ SELVA_EXPORT
 int selva_dump_save_common(struct SelvaDb *db, const char *filename) __attribute__((nonnull));
 
 /**
- * Save a range of nodes from te.
+ * Save a nodes block starting from start.
  */
 SELVA_EXPORT
-int selva_dump_save_range(struct SelvaDb *db, struct SelvaTypeEntry *te, const char *filename, node_id_t start, node_id_t end, selva_hash128_t *range_hash_out) __attribute__((nonnull));
+int selva_dump_save_block(struct SelvaDb *db, struct SelvaTypeEntry *te, const char *filename, node_id_t start, selva_hash128_t *range_hash_out) __attribute__((nonnull));
 
 /**
  * **Usage:**
  * ```c
  * struct SelvaDb *db = selva_db_create();
  * selva_dump_load_common(db, filename_common);
- * selva_dump_load_range(db, filename_range_n);
+ * selva_dump_load_block(db, filename_range_n);
  *  ```
  */
 SELVA_EXPORT
 int selva_dump_load_common(struct SelvaDb *db, const char *filename, char *errlog_buf, size_t errlog_size) __attribute__((nonnull));
 
 SELVA_EXPORT
-int selva_dump_load_range(struct SelvaDb *db, const char *filename, char *errlog_buf, size_t errlog_size) __attribute__((nonnull));
+int selva_dump_load_block(struct SelvaDb *db, const char *filename, char *errlog_buf, size_t errlog_size) __attribute__((nonnull));
 
 /**
  * Find a type by type id.
@@ -83,6 +83,32 @@ inline block_id_t selva_get_block_capacity(const struct SelvaTypeEntry *te)
 ;
 #endif
 
+inline block_id_t selva_node_id2block_i3(block_id_t block_capacity, node_id_t node_id)
+{
+    assert(node_id > 0);
+    return ((node_id - 1) - ((node_id - 1) % block_capacity)) / block_capacity;
+}
+
+SELVA_EXPORT
+inline block_id_t selva_node_id2block_i(const struct SelvaTypeBlocks *blocks, node_id_t node_id)
+#ifndef __zig
+{
+    return selva_node_id2block_i3(blocks->block_capacity, node_id);
+}
+#else
+;
+#endif
+
+SELVA_EXPORT
+inline block_id_t selva_node_id2block_i2(const struct SelvaTypeEntry *te, node_id_t node_id)
+#ifndef __zig
+{
+    return selva_node_id2block_i(te->blocks, node_id);
+}
+#else
+;
+#endif
+
 /**
  * Get the node schema for type.
  */

package/dist/lib/linux_x86_64/include/selva/fields.h

@@ -46,7 +46,7 @@ struct SelvaNodeReferences {
 };
 
 struct SelvaNodeWeakReference {
-    /* THe type can be found from the schema. */
+    /* The type can be found from the schema. */
 #if 0
     node_type_t dst_type;
 #endif
@@ -99,11 +99,15 @@ __purefn
 #endif
 size_t selva_fields_get_data_size(const struct SelvaFieldSchema *fs);
 
+SELVA_EXPORT
 #if __has_c_attribute(reproducible)
 [[reproducible]]
 #endif
 void *selva_fields_nfo2p(struct SelvaFields *fields, const struct SelvaFieldInfo *nfo);
 
+SELVA_EXPORT
+struct SelvaFields *selva_fields_node2fields(struct SelvaNode *node);
+
 void selva_fields_ensure_ref_meta(
         struct SelvaDb *db,
         struct SelvaNode *node,
@@ -118,19 +122,7 @@ SELVA_EXPORT
 int selva_fields_set(
         struct SelvaNode *node,
         const struct SelvaFieldSchema *fs,
-        const void *value, size_t len);
-
-/**
- * Set field value by a `fields` pointer.
- * @param fields can be either `node->fields` or any other `fields` structure
- *               associated with the given node (currently edge).
- */
-SELVA_EXPORT
-int fields_set2(
-        struct SelvaNode *node,
-        const struct SelvaFieldSchema *fs,
-        struct SelvaFields *fields,
-        const void *value, size_t len);
+        const void *value, size_t len) __attribute__((deprecated));
 
 SELVA_EXPORT
 int selva_fields_get_mutable_string(
@@ -163,10 +155,6 @@ struct selva_string *selva_fields_ensure_string2(
 
 /**
  * Set reference to fields.
- * @param dirty_nodes returns the nodes that were changed, apart from src and dst.
- *                    [n].id = 0 = nil;
- *                    [0] = the node src was pointing to previously (same type as dst);
- *                    [1] = the node dst was pointing to previously (same type as src).
  */
 SELVA_EXPORT
 int selva_fields_reference_set(
@@ -175,8 +163,9 @@ int selva_fields_reference_set(
         const struct SelvaFieldSchema *fs_src,
         struct SelvaNode * restrict dst,
         struct SelvaNodeReference **ref_out,
-        node_id_t dirty_nodes[static 2])
-    __attribute__((access(write_only, 5), access(write_only, 6)));
+        selva_dirty_node_cb_t dirty_cb,
+        void *dirty_ctx);
+    // __attribute__((access(write_only, 5), access(write_only, 6)));
 
 /**
  * @param index 0 = first; -1 = last.
@@ -241,7 +230,7 @@ int selva_fields_set_reference_meta(
         struct SelvaNode *node,
         struct SelvaNodeReference *ref,
         const struct EdgeFieldConstraint *efc,
-        field_t field,
+        const struct SelvaFieldSchema *efs,
         const void *value, size_t len);
 
 SELVA_EXPORT
@@ -267,7 +256,6 @@ SELVA_EXPORT
 int selva_fields_set_string(
         struct SelvaNode *node,
         const struct SelvaFieldSchema *fs,
-        struct SelvaFieldInfo *nfo,
         const char *str,
         size_t len);
 
@@ -304,6 +292,24 @@ int selva_fields_get_text(
         const char **str,
         size_t *len);
 
+SELVA_EXPORT
+int selva_fields_set_micro_buffer(struct SelvaFields *fields, const struct SelvaFieldSchema *fs, const void *value, size_t len);
+
+SELVA_EXPORT
+int selva_fields_set_micro_buffer2(struct SelvaNode *node, const struct SelvaFieldSchema *fs, const void *value, size_t len);
+
+SELVA_EXPORT
+int selva_fields_set_weak_reference(struct SelvaNode *node, const struct SelvaFieldSchema *fs, node_id_t dst);
+
+SELVA_EXPORT
+int selva_fields_set_weak_reference2(struct SelvaFields *fields, const struct SelvaFieldSchema *fs, node_id_t dst);
+
+SELVA_EXPORT
+int selva_fields_set_weak_references2(struct SelvaFields *fields, const struct SelvaFieldSchema *fs, node_id_t dst[], size_t nr_dsts);
+
+SELVA_EXPORT
+int selva_fields_set_weak_references(struct SelvaNode *node, const struct SelvaFieldSchema *fs, node_id_t dst[], size_t nr_dsts);
+
 SELVA_EXPORT
 struct SelvaNodeReference *selva_fields_get_reference(struct SelvaDb *db, struct SelvaNode *node, const struct SelvaFieldSchema *fs)
     __attribute__((nonnull));
@@ -313,11 +319,11 @@ struct SelvaNodeReferences *selva_fields_get_references(struct SelvaDb *db, stru
     __attribute__((nonnull));
 
 SELVA_EXPORT
-struct SelvaNodeWeakReference selva_fields_get_weak_reference(struct SelvaDb *db, struct SelvaFields *fields, field_t field)
+struct SelvaNodeWeakReference selva_fields_get_weak_reference(struct SelvaFields *fields, field_t field)
     __attribute__((nonnull));
 
 SELVA_EXPORT
-struct SelvaNodeWeakReferences selva_fields_get_weak_references(struct SelvaDb *db, struct SelvaFields *fields, field_t field)
+struct SelvaNodeWeakReferences selva_fields_get_weak_references(struct SelvaFields *fields, field_t field)
     __attribute__((nonnull));
 
 SELVA_EXPORT
@@ -339,6 +345,9 @@ SELVA_EXPORT
 struct selva_string *selva_fields_get_selva_string(struct SelvaNode *node, const struct SelvaFieldSchema *fs)
     __attribute__((nonnull));
 
+SELVA_EXPORT
+struct SelvaFieldInfo *selva_field_get_nfo(struct SelvaFields *fields, const struct SelvaFieldSchema *fs);
+
 SELVA_EXPORT
 struct SelvaFieldsPointer selva_fields_get_raw2(struct SelvaFields *fields, const struct SelvaFieldSchema *fs)
     __attribute__((nonnull));
@@ -375,6 +384,9 @@ SELVA_EXPORT
 void selva_fields_init(const struct SelvaFieldsSchema *schema, struct SelvaFields *fields)
     __attribute__((nonnull));
 
+void selva_fields_init_node(struct SelvaTypeEntry *te, struct SelvaNode *node)
+    __attribute__((nonnull));
+
 /**
  * Destroy all fields of a node.
  */

package/dist/lib/linux_x86_64/include/selva/hll.h

@@ -17,10 +17,12 @@ void hll_add(struct selva_string *hllss, uint64_t element);
 SELVA_EXPORT
 uint8_t *hll_count(struct selva_string *hllss);
 SELVA_EXPORT
-struct selva_string hll_array_union(struct selva_string *hll_array, size_t count);
+void hll_array_union(struct selva_string *res, struct selva_string *hll_array, size_t count);
+SELVA_EXPORT
+void hll_union(char*, size_t, const char*, size_t);
 
 // size_t actual_cols[13] = { 79, 159, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200 };
-// float raw_estimate_data[13][200] = 
+// float raw_estimate_data[13][200] =
 // {
 //     // precision 4
 //     { 11, 11.717, 12.207, 12.7896, 13.2882, 13.8204, 14.3772, 14.9342, 15.5202, 16.161, 16.7722,17.4636, 18.0396, 18.6766, 19.3566, 20.0454, 20.7936, 21.4856, 22.2666, 22.9946, 23.766,24.4692, 25.3638, 26.0764, 26.7864, 27.7602, 28.4814, 29.433, 30.2926, 31.0664, 31.9996,32.7956, 33.5366, 34.5894, 35.5738, 36.2698, 37.3682, 38.0544, 39.2342, 40.0108, 40.7966,41.9298, 42.8704, 43.6358, 44.5194, 45.773, 46.6772, 47.6174, 48.4888, 49.3304, 50.2506,51.4996, 52.3824, 53.3078, 54.3984, 55.5838, 56.6618, 57.2174, 58.3514, 59.0802, 60.1482,61.0376, 62.3598, 62.8078, 63.9744, 64.914, 65.781, 67.1806, 68.0594, 68.8446, 69.7928,70.8248, 71.8324, 72.8598, 73.6246, 74.7014, 75.393, 76.6708, 77.2394, },
@@ -78,4 +80,4 @@ struct selva_string hll_array_union(struct selva_string *hll_array, size_t count
 //     // precision 16
 //     { 47270, 46423.3584, 45585.7074, 44757.152, 43938.8416, 43130.9514, 42330.03, 41540.407,40759.6348, 39988.206, 39226.5144, 38473.2096, 37729.795, 36997.268, 36272.6448, 35558.665,34853.0248, 34157.4472, 33470.5204, 32793.5742, 32127.0194, 31469.4182, 30817.6136,30178.6968, 29546.8908, 28922.8544, 28312.271, 27707.0924, 27114.0326, 26526.692, 25948.6336,25383.7826, 24823.5998, 24272.2974, 23732.2572, 23201.4976, 22674.2796, 22163.6336, 21656.515,21161.7362, 20669.9368, 20189.4424, 19717.3358, 19256.3744, 18795.9638, 18352.197, 17908.5738,17474.391, 17052.918, 16637.2236, 16228.4602, 15823.3474, 15428.6974, 15043.0284, 14667.6278,14297.4588, 13935.2882, 13578.5402, 13234.6032, 12882.1578, 12548.0728, 12219.231, 11898.0072,11587.2626, 11279.9072, 10973.5048, 10678.5186, 10392.4876, 10105.2556, 9825.766, 9562.5444,9294.2222, 9038.2352, 8784.848, 8533.2644, 8301.7776, 8058.30859999999, 7822.94579999999,7599.11319999999, 7366.90779999999, 7161.217, 6957.53080000001, 6736.212, 6548.21220000001,6343.06839999999, 6156.28719999999, 5975.15419999999, 5791.75719999999, 5621.32019999999,5451.66, 5287.61040000001, 5118.09479999999, 4957.288, 4798.4246, 4662.17559999999,4512.05900000001, 4364.68539999999, 4220.77720000001, 4082.67259999999, 3957.19519999999,3842.15779999999, 3699.3328, 3583.01180000001, 3473.8964, 3338.66639999999, 3233.55559999999,3117.799, 3008.111, 2909.69140000001, 2814.86499999999, 2719.46119999999, 2624.742,2532.46979999999, 2444.7886, 2370.1868, 2272.45259999999, 2196.19260000001, 2117.90419999999,2023.2972, 1969.76819999999, 1885.58979999999, 1833.2824, 1733.91200000001, 1682.54920000001,1604.57980000001, 1556.11240000001, 1491.3064, 1421.71960000001, 1371.22899999999, 1322.1324,1264.7892, 1196.23920000001, 1143.8474, 1088.67240000001, 1073.60380000001, 1023.11660000001,959.036400000012, 927.433199999999, 906.792799999996, 853.433599999989, 841.873800000001,791.1054, 756.899999999994, 704.343200000003, 672.495599999995, 622.790399999998,611.254799999995, 567.283200000005, 519.406599999988, 519.188400000014, 495.312800000014,451.350799999986, 443.973399999988, 431.882199999993, 392.027000000002, 380.924200000009,345.128999999986, 298.901400000002, 287.771999999997, 272.625, 247.253000000026,222.490600000019, 223.590000000026, 196.407599999977, 176.425999999978, 134.725199999986,132.4804, 110.445599999977, 86.7939999999944, 56.7038000000175, 64.915399999998,38.3726000000024, 37.1606000000029, 46.170999999973, 49.1716000000015, 15.3362000000197,6.71639999997569,-34.8185999999987,-39.4476000000141, 12.6830000000191,-12.3331999999937,-50.6565999999875,-59.9538000000175,-65.1054000000004,-70.7576000000117,-106.325200000021,-126.852200000023,-110.227599999984,-132.885999999999,-113.897200000007,-142.713800000027,-151.145399999979,-150.799200000009,-177.756200000003,-156.036399999983,-182.735199999996,-177.259399999981,-198.663600000029,-174.577600000019,-193.84580000001, },
 // };
-#endif
+#endif

package/dist/lib/linux_x86_64/include/selva/membar.h

@@ -0,0 +1,23 @@
+/*
+ * Copyright (c) 2025 SAULX
+ * SPDX-License-Identifier: MIT
+ */
+#include "selva/_export.h"
+
+/**
+ * Read memory barrier.
+ * Call this function before read in case another thread has potentially
+ * written to the memory addresses the current thread is going to access.
+ */
+SELVA_EXPORT
+__attribute__((no_reorder))
+void membar_sync_read(void);
+
+/**
+ * Write memory barrier.
+ * Call this function after write to memory when another thread is expected to
+ * read the written data.
+ */
+SELVA_EXPORT
+__attribute__((no_reorder))
+void membar_sync_write(void);

package/dist/lib/linux_x86_64/include/selva/types.h

@@ -82,7 +82,7 @@ struct SelvaFieldsSchema {
         size_t len;
         size_t fixed_data_size;
     } field_map_template;
-    struct SelvaFieldSchema field_schemas[] __counted_by(nr_fields);
+    struct SelvaFieldSchema field_schemas[255];
 };
 
 struct SelvaNodeSchema {

package/dist/lib/linux_x86_64/include/selva/worker_ctx.h

@@ -1,13 +1,29 @@
 /*
- * Copyright (c) 2024 SAULX
+ * Copyright (c) 2024-2025 SAULX
  * SPDX-License-Identifier: MIT
  */
 #pragma once
 
 #include "selva/_export.h"
+#include "libdeflate.h"
 
 SELVA_EXPORT
-void worker_ctx_init();
+void worker_ctx_init(void);
 
 SELVA_EXPORT
-void worker_ctx_deinit();
+void worker_ctx_deinit(void);
+
+SELVA_EXPORT
+enum libdeflate_result worker_ctx_libdeflate_decompress(
+			      const void *in, size_t in_nbytes,
+			      void *out, size_t out_nbytes_avail,
+			      size_t *actual_out_nbytes_ret);
+
+SELVA_EXPORT
+enum libdeflate_result worker_ctx_libdeflate_decompress_stream(
+        const char *in_buf, size_t in_len,
+        libdeflate_decompress_stream_cb_t cb, void *ctx,
+        int *result);
+
+SELVA_EXPORT
+bool worker_ctx_libdeflate_block_state_growbuf(void);

package/dist/src/client/modify/fixed.js

@@ -98,7 +98,7 @@ map[TIMESTAMP] = (ctx, val, def) => {
     ctx.len += 8;
     // Todo use new utils and store as uint64
     view.setFloat64(0, parsedValue, true);
-    const ts = view.getFloat64(0);
+    // const ts = view.getFloat64(0)
 };
 map[UINT32] = (ctx, val, def) => {
     if (ctx.len + 4 > ctx.max) {

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

@@ -1,7 +1,7 @@
 import { QueryDef, QueryTarget, Operator, QueryByAliasObj } from './query.js';
 import { BasedQueryResponse } from './BasedIterable.js';
 import { Search } from './search/index.js';
-import { OnData, OnError, OnClose } from './subscription/index.js';
+import { OnData, OnError } from './subscription/index.js';
 import { DbClient } from '../index.js';
 import { LangName } from '@based/schema';
 import { FilterAst, FilterBranchFn, FilterOpts } from './filter/types.js';
@@ -25,6 +25,7 @@ export declare class QueryBranch<T> {
     groupBy(field: string): T;
     count(field?: string): T;
     sum(...fields: (string | string[])[]): T;
+    cardinality(...fields: (string | string[])[]): T;
     or(fn: FilterBranchFn): T;
     or(field: string, operator?: Operator | boolean, value?: any, opts?: FilterOpts): T;
     range(start: number, end?: number): T;
@@ -48,6 +49,6 @@ export declare class BasedDbQuery extends QueryBranch<BasedDbQuery> {
     buffer: Uint8Array;
     register(): void;
     locale(locale: LangName): this;
-    subscribe(onData: OnData, onError?: OnError): OnClose;
+    subscribe(onData: OnData, onError?: OnError): import("./subscription/types.js").OnClose;
     _getSync(dbCtxExternal: any): BasedQueryResponse;
 }

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

@@ -11,6 +11,7 @@ import { langCodesMap } from '@based/schema';
 import { convertFilter } from './filter/convertFilter.js';
 import { validateLocale, validateRange } from './validation.js';
 import { DEF_RANGE_PROP_LIMIT } from './thresholds.js';
+import { wait } from '@saulx/utils';
 import { displayTarget } from './display.js';
 import picocolors from 'picocolors';
 export class QueryBranch {
@@ -172,6 +173,22 @@ export class QueryBranch {
         // @ts-ignore
         return this;
     }
+    cardinality(...fields) {
+        if (fields.length === 0) {
+            throw new Error('Empty cardinality() called');
+        }
+        if (this.queryCommands) {
+            this.queryCommands.push({
+                method: 'cardinality',
+                args: fields,
+            });
+        }
+        else {
+            addAggregate(3 /* AggregateType.CARDINALITY */, this.def, fields);
+        }
+        // @ts-ignore
+        return this;
+    }
     or(field, operator, value, opts) {
         if (this.queryCommands) {
             this.queryCommands.push({
@@ -337,19 +354,13 @@ export class BasedDbQuery extends QueryBranch {
         const res = await this.db.hooks.getQueryBuf(buf);
         if (res.byteLength === 1) {
             if (res[0] === 0) {
-                if (this.def && this.def.schemaChecksum === this.db.schema?.hash) {
-                    // my schema did not change since last time, wait for the schema to change
-                    this.reset();
-                    this.db.emit('info', 'query get schema mismatch - awaiting new schema');
-                    await this.db.once('schema');
-                    return this.#getInternal(resolve, reject);
-                }
-                else {
-                    // its changed so lets send again
-                    this.db.emit('info', 'query get schema mismatch - got the same already');
-                    this.reset();
-                    return this.#getInternal(resolve, reject);
+                this.reset();
+                this.db.emit('info', 'query get schema mismatch - awaiting new schema (max 15s)');
+                const ok = await Promise.race([wait(15e3), this.db.once('schema')]);
+                if (!ok) {
+                    reject(new Error('schema mismath'));
                 }
+                return this.#getInternal(resolve, reject);
             }
             else {
                 reject(new Error('unexpected error'));

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

@@ -1,6 +1,7 @@
 export declare const enum AggregateType {
     SUM = 1,
-    COUNT = 2
+    COUNT = 2,
+    CARDINALITY = 3
 }
 export declare const enum GroupBy {
     NONE = 0,

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

@@ -10,6 +10,7 @@ const readAggregate = (q, result, offset, len) => {
         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,11 +18,14 @@ const readAggregate = (q, result, offset, len) => {
                 else {
                     key = `$undefined`;
                 }
+                i += 2;
             }
             else {
-                key = DECODER.decode(result.subarray(i, i + 2));
+                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) {
@@ -414,7 +418,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/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 });
@@ -451,4 +453,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/index.d.ts

@@ -19,7 +19,7 @@ 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/native.d.ts

@@ -1,4 +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;
@@ -9,9 +10,9 @@ 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;
     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 +23,7 @@ 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;
 };
 export default native;

package/dist/src/native.js

@@ -4,14 +4,19 @@ import db from '../../basedDbNative.cjs';
 const DECODER = new TextDecoder('utf-8');
 const ENCODER = new TextEncoder();
 const selvaIoErrlog = new Uint8Array(256);
-var compressor = db.createCompressor();
+var compressor = db.createCompressor(); // put on threadCtx
 var decompressor = db.createDecompressor();
 function SelvaIoErrlogToString(buf) {
     let i;
     let len = (i = buf.indexOf(0)) >= 0 ? i : buf.byteLength;
     return DECODER.decode(selvaIoErrlog.slice(0, len));
 }
+// add worker CTX HERE
+// then add it to every function
+// worker should allways be here
+// 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);
     },
@@ -45,9 +50,9 @@ const native = {
         const pathBuf = ENCODER.encode(path + '\0');
         return db.saveCommon(pathBuf, dbCtx);
     },
-    saveRange: (path, typeCode, start, end, dbCtx, hashOut) => {
+    saveBlock: (path, typeCode, start, dbCtx, hashOut) => {
         const pathBuf = ENCODER.encode(path + '\0');
-        return db.saveRange(pathBuf, typeCode, start, end, dbCtx, hashOut);
+        return db.saveBlock(pathBuf, typeCode, start, dbCtx, hashOut);
     },
     loadCommon: (path, dbCtx) => {
         const pathBuf = ENCODER.encode(path + '\0');
@@ -56,9 +61,9 @@ const native = {
             throw new Error(`Failed to load common. selvaError: ${err} cause:\n${SelvaIoErrlogToString(selvaIoErrlog)}`);
         }
     },
-    loadRange: (path, dbCtx) => {
+    loadBlock: (path, dbCtx) => {
         const pathBuf = ENCODER.encode(path + '\0');
-        const err = db.loadRange(pathBuf, dbCtx, selvaIoErrlog);
+        const err = db.loadBlock(pathBuf, dbCtx, selvaIoErrlog);
         if (err) {
             throw new Error(`Failed to load a range. selvaError: ${err} cause:\n${SelvaIoErrlogToString(selvaIoErrlog)}`);
         }
@@ -93,6 +98,12 @@ const native = {
     equals: (a, b) => {
         return !!db.equals(a, b);
     },
+    membarSyncRead: () => {
+        db.membarSyncRead();
+    },
+    membarSyncWrite: () => {
+        db.membarSyncWrite();
+    },
 };
 global.__basedDb__native__ = native;
 export default native;

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

@@ -5,9 +5,9 @@ export declare class DbWorker {
     db: DbServer;
     channel: MessagePort;
     worker: Worker;
-    resolvers: any[];
+    resolvers: ((x: any) => any)[];
     readyPromise: Promise<true>;
-    callback: (resolve: any) => void;
+    callback: (resolve: (x: any) => any) => void;
     updateCtx(address: BigInt): Promise<void>;
     getQueryBuf(buf: Uint8Array): Promise<Uint8Array>;
 }

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

@@ -17,6 +17,7 @@ export declare class DbServer extends DbShared {
     #private;
     modifyDirtyRanges: Float64Array;
     dbCtxExternal: any;
+    threadCtxExternal: any;
     migrating: number;
     saveInProgress: boolean;
     fileSystemPath: string;

package/dist/src/server/index.js

@@ -27,6 +27,7 @@ class SortIndex {
 export class DbServer extends DbShared {
     modifyDirtyRanges;
     dbCtxExternal; // pointer to zig dbCtx
+    threadCtxExternal; // pointer to zig dbCtx
     migrating = null;
     saveInProgress = false;
     fileSystemPath;
@@ -304,7 +305,7 @@ export class DbServer extends DbShared {
         }
         const view = new DataView(buf.buffer, buf.byteOffset);
         while (i < end) {
-            const key = view.getFloat64(i, true);
+            // const key = view.getFloat64(i, true)
             // These node ranges may not actually exist
             //this.dirtyRanges.add(key)
             i += 8;
@@ -333,6 +334,7 @@ export class DbServer extends DbShared {
             resolve(new Error('Query queue exceeded'));
             return;
         }
+        // TODO should we check here as well? Already will check in DbWorker
         const schemaChecksum = readUint64(buf, buf.byteLength - 8);
         if (schemaChecksum !== this.schema?.hash) {
             return Promise.resolve(new Uint8Array(1));

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

@@ -152,6 +152,7 @@ export const migrate = async (server, fromSchema, toSchema, transform) => {
     if (abort()) {
         return;
     }
+    native.membarSyncRead();
     await save(server, false, true, true);
     await writeSchemaFile(server, toSchema);
     server.migrating = 0;