@based/db 0.0.28 → 0.0.29

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

@@ -1,4 +1,4 @@
-import { MICRO_BUFFER } from '@based/schema/def';
+import { MICRO_BUFFER, isValidId, } from '@based/schema/def';
 import { startDrain, flushBuffer } from '../flushModify.js';
 import { setCursor } from './setCursor.js';
 import { modify } from './modify.js';
@@ -57,6 +57,9 @@ export const update = (db, type, id, obj, opts) => {
     if (!def) {
         throw new Error(`Unknown type: ${type}. Did you mean on of: ${Object.keys(db.schemaTypesParsed).join(', ')}`);
     }
+    if (!isValidId(id)) {
+        throw new Error(`Update ${id} is not a valid id`);
+    }
     const ctx = db.modifyCtx;
     const pos = ctx.len;
     const res = new ModifyState(def.id, id, db, getSubscriptionMarkers(db, def.id, id, false), opts, true);

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

@@ -2,14 +2,23 @@ import { UPDATE, RANGE_ERR, DELETE, } from './types.js';
 import { ModifyError } from './ModifyRes.js';
 import { setCursor } from './setCursor.js';
 function write(value, ctx, fieldSize) {
-    const size = Math.min(value.byteLength, fieldSize);
-    let tmp = size;
-    // 16-bits would be enough but the zig code now expects 32-bits
+    let size = Math.min(value.byteLength, fieldSize);
+    let padding = 0;
+    if (ctx.len % 4 != 0) {
+        padding = ctx.len % 4;
+    }
+    size -= padding;
+    let tmp = size + 4;
+    // 16-bits would be enough but the zig expects 32-bits
     ctx.buf[ctx.len++] = tmp;
     ctx.buf[ctx.len++] = tmp >>>= 8;
     ctx.buf[ctx.len++] = tmp >>>= 8;
     ctx.buf[ctx.len++] = tmp >>>= 8;
-    ctx.buf.set(new Uint8Array(value.buffer).subarray(0, size), ctx.len);
+    ctx.buf[ctx.len++] = padding;
+    ctx.buf[ctx.len++] = 0;
+    ctx.buf[ctx.len++] = 0;
+    ctx.buf[ctx.len++] = 0;
+    ctx.buf.set(new Uint8Array(value.buffer).subarray(0, size), ctx.len - padding);
     ctx.len += size;
 }
 export function writeVector(value, ctx, schema, t, parentId, modifyOp) {

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

@@ -28,7 +28,7 @@ export declare class BasedDbReferenceQuery extends QueryBranch<BasedDbReferenceQ
 declare class GetPromise extends Promise<BasedQueryResponse> {
     toObject(): Promise<any>;
     toJSON(): Promise<string>;
-    inspect(depth?: number): GetPromise;
+    inspect(depth?: number, raw?: boolean): GetPromise;
 }
 export declare class BasedDbQuery extends QueryBranch<BasedDbQuery> {
     #private;

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

@@ -188,8 +188,8 @@ class GetPromise extends Promise {
     toJSON() {
         return this.then(resToJSON);
     }
-    inspect(depth) {
-        return this.then((res) => new GetPromise((resolve) => resolve(res.inspect(depth))));
+    inspect(depth, raw) {
+        return this.then((res) => new GetPromise((resolve) => resolve(res.inspect(depth, raw))));
     }
 }
 export class BasedDbQuery extends QueryBranch {

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

@@ -15,7 +15,7 @@ export declare class BasedQueryResponse {
     debug(): this;
     node(index?: number): any;
     [Symbol.iterator](): Generator<Partial<Item>, void, unknown>;
-    inspect(depth?: number): this;
+    inspect(depth?: number, raw?: boolean): this;
     forEach(fn: (item: any, key: number) => void): void;
     map(fn: (item: any, key: number) => any): any[];
     get checksum(): number;

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

@@ -78,8 +78,13 @@ export class BasedQueryResponse {
             yield item;
         }
     }
-    inspect(depth = 2) {
-        console.log(this[inspect.custom](depth));
+    inspect(depth = 2, raw) {
+        if (raw) {
+            console.dir(this.toObject(), { depth });
+        }
+        else {
+            console.log(this[inspect.custom](depth));
+        }
         return this;
     }
     forEach(fn) {

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

@@ -1,4 +1,5 @@
 import { PropDef, PropDefEdge } from '@based/schema/def';
 import { FilterCtx } from './types.js';
+import { FilterCondition } from '../types.js';
 export declare const writeFixed: (prop: PropDef | PropDefEdge, buf: Uint8Array, value: any, size: number, offset: number) => void;
-export declare const createFixedFilterBuffer: (prop: PropDef | PropDefEdge, size: number, ctx: FilterCtx, value: any, sort: boolean) => Uint8Array;
+export declare const createFixedFilterBuffer: (prop: PropDef | PropDefEdge, size: number, ctx: FilterCtx, value: any, sort: boolean) => FilterCondition;

package/dist/src/client/query/filter/createFixedFilterBuffer.js

@@ -1,20 +1,7 @@
 import { BINARY, STRING, REFERENCES, } from '@based/schema/def';
-import { EQUAL, MODE_AND_FIXED, MODE_DEFAULT, MODE_OR_FIXED, } from './types.js';
+import { ALIGNMENT_NOT_SET, EQUAL, MODE_AND_FIXED, MODE_DEFAULT, MODE_OR_FIXED, } from './types.js';
 import { parseFilterValue } from './parseFilterValue.js';
 import { ENCODER } from '../../../utils.js';
-// -------------------------------------------
-// conditions normal
-// field, [size 2]
-// [or = 0] [size 2] [start 2], [op], value[size]
-// -------------------------------------------
-// conditions or fixed
-// field, [size 2]
-// [or = 1] [size 2] [start 2] [op], [repeat 2], value[size] value[size] value[size]
-// -------------------------------------------
-// conditions or variable
-// field, [size 2]
-// [or = 2] [size 2] [start 2], [op], [size 2], value[size], [size 2], value[size]
-// -------------------------------------------
 export const writeFixed = (prop, buf, value, size, offset) => {
     if (prop.typeIndex === BINARY || prop.typeIndex === STRING) {
         if (typeof value === 'string') {
@@ -32,7 +19,8 @@ export const writeFixed = (prop, buf, value, size, offset) => {
         buf[offset] = value;
     }
     else {
-        if (size === 8) { // RFE no int64 for u?
+        if (size === 8) {
+            // RFE no int64 for u? prob important to add...
             const view = new DataView(buf.buffer, buf.byteOffset);
             view.setFloat64(offset, value, true);
         }
@@ -51,17 +39,12 @@ export const writeFixed = (prop, buf, value, size, offset) => {
         }
     }
 };
-// Modes
-// default = 0,
-// orFixed = 1,
-// orVar = 2,
 export const createFixedFilterBuffer = (prop, size, ctx, value, sort) => {
-    let buf;
     const start = prop.start;
     if (Array.isArray(value)) {
-        // [or = 1] [size 2] [start 2] [op], [repeat 2], value[size] value[size] value[size]
         const len = value.length;
-        buf = new Uint8Array(10 + len * size);
+        // Add 8 extra bytes for alignment
+        const buf = new Uint8Array(18 + len * size);
         buf[0] = ctx.type;
         buf[1] =
             prop.typeIndex === REFERENCES && ctx.operation === EQUAL
@@ -73,14 +56,14 @@ export const createFixedFilterBuffer = (prop, size, ctx, value, sort) => {
         buf[5] = start;
         buf[6] = start >>> 8;
         buf[7] = ctx.operation;
-        // buf[7] = prop.typeIndex
         buf[8] = len;
         buf[9] = len >>> 8;
+        buf[10] = ALIGNMENT_NOT_SET;
         if (sort) {
             value = new Uint32Array(value.map((v) => parseFilterValue(prop, v)));
             value.sort();
             for (let i = 0; i < len; i++) {
-                const off = 10 + i * size;
+                const off = 18 + i * size;
                 const val = value[i];
                 buf[off] = val;
                 buf[off + 1] = val >>> 8;
@@ -90,13 +73,13 @@ export const createFixedFilterBuffer = (prop, size, ctx, value, sort) => {
         }
         else {
             for (let i = 0; i < len; i++) {
-                writeFixed(prop, buf, parseFilterValue(prop, value[i]), size, 10 + i * size);
+                writeFixed(prop, buf, parseFilterValue(prop, value[i]), size, 18 + i * size);
             }
         }
+        return buf;
     }
     else {
-        // [or = 0] [size 2] [start 2], [op], value[size]
-        buf = new Uint8Array(8 + size);
+        const buf = new Uint8Array(8 + size);
         buf[0] = ctx.type;
         buf[1] = MODE_DEFAULT;
         buf[2] = prop.typeIndex;
@@ -106,7 +89,7 @@ export const createFixedFilterBuffer = (prop, size, ctx, value, sort) => {
         buf[6] = start >>> 8;
         buf[7] = ctx.operation;
         writeFixed(prop, buf, parseFilterValue(prop, value), size, 8);
+        return buf;
     }
-    return buf;
 };
 //# sourceMappingURL=createFixedFilterBuffer.js.map

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

@@ -1,3 +1,4 @@
 import { PropDef, PropDefEdge } from '@based/schema/def';
 import { FilterCtx } from './types.js';
-export declare const createReferenceFilter: (prop: PropDef | PropDefEdge, ctx: FilterCtx, value: any) => Uint8Array;
+import { FilterCondition } from '../types.js';
+export declare const createReferenceFilter: (prop: PropDef | PropDefEdge, ctx: FilterCtx, value: any) => FilterCondition;

package/dist/src/client/query/filter/createReferenceFilter.js

@@ -1,23 +1,24 @@
-import { MODE_REFERENCE } from './types.js';
+import { ALIGNMENT_NOT_SET, MODE_REFERENCE } from './types.js';
 export const createReferenceFilter = (prop, ctx, value) => {
-    const len = Array.isArray(value) ? value.length : 1;
-    const buf = new Uint8Array(11 + len * 8);
+    const isArray = Array.isArray(value);
+    const len = isArray ? value.length : 1;
+    const buf = new Uint8Array(11 + (isArray ? 8 : 0) + len * 4);
     buf[0] = ctx.type;
     buf[1] = MODE_REFERENCE;
     buf[2] = prop.typeIndex;
-    buf[3] = 8;
-    buf[4] = 8 >>> 8;
+    // size (4)
+    buf[3] = 4;
+    buf[4] = 0;
     buf[5] = len;
     buf[6] = len >>> 8;
     buf[7] = ctx.operation;
-    // buf[7] = prop.typeIndex
-    // REF TYPE (only 1 exists now...)
     buf[8] = 0;
     buf[9] = prop.inverseTypeId;
     buf[10] = prop.inverseTypeId >>> 8;
-    if (Array.isArray(value)) {
+    if (isArray) {
+        buf[11] = ALIGNMENT_NOT_SET;
         for (let i = 0; i < len; i++) {
-            let off = 11 + i * 8;
+            let off = 19 + i * 4;
             const v = value[i];
             buf[off++] = v;
             buf[off++] = v >>> 8;

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

@@ -1,4 +1,5 @@
 import { PropDef, PropDefEdge } from '@based/schema/def';
 import { FilterCtx } from './types.js';
 import { LangCode } from '@based/schema';
-export declare const createVariableFilterBuffer: (value: any, prop: PropDef | PropDefEdge, ctx: FilterCtx, lang: LangCode) => Uint8Array;
+import { FilterCondition } from '../types.js';
+export declare const createVariableFilterBuffer: (value: any, prop: PropDef | PropDefEdge, ctx: FilterCtx, lang: LangCode) => FilterCondition;

package/dist/src/client/query/filter/createVariableFilterBuffer.js

@@ -6,7 +6,6 @@ import { ENCODER, concatUint8Arr } from '../../../utils.js';
 const DEFAULT_SCORE = new Uint8Array(new Float32Array([0.5]).buffer);
 const parseValue = (value, prop, ctx, lang) => {
     let val = value;
-    // TODO should we do .normalize('NFKD') for all strings?
     if (ctx.operation === HAS_TO_LOWER_CASE && typeof val === 'string') {
         val = val.toLowerCase();
     }
@@ -31,7 +30,7 @@ const parseValue = (value, prop, ctx, lang) => {
         !prop.separate ||
         ctx.operation !== EQUAL) {
         if (typeof val === 'string') {
-            val = ENCODER.encode(val);
+            val = ENCODER.encode(val.normalize('NFKD'));
         }
         if (prop.typeIndex === TEXT) {
             const tmp = new Uint8Array(val.byteLength + 1);
@@ -48,7 +47,7 @@ const parseValue = (value, prop, ctx, lang) => {
     }
     if (ctx.operation === LIKE && prop.typeIndex !== VECTOR) {
         const tmp = new Uint8Array(val.byteLength + 1);
-        tmp.set((val instanceof ArrayBuffer) ? new Uint8Array(val) : val);
+        tmp.set(val instanceof ArrayBuffer ? new Uint8Array(val) : val);
         tmp[tmp.byteLength - 1] = ctx.opts.score ?? 2;
         val = tmp;
     }
@@ -57,7 +56,7 @@ const parseValue = (value, prop, ctx, lang) => {
 export const createVariableFilterBuffer = (value, prop, ctx, lang) => {
     let mode = MODE_DEFAULT_VAR;
     let val;
-    let buf;
+    let parsedCondition;
     if (Array.isArray(value)) {
         if (ctx.operation !== EQUAL || !prop.separate) {
             mode = MODE_OR_VAR;
@@ -103,25 +102,24 @@ export const createVariableFilterBuffer = (value, prop, ctx, lang) => {
                     v[6] = len >>> 16;
                     v[7] = len >>> 24;
                     v[8] = val[val.length - 1];
-                    buf = writeVarFilter(mode, v, ctx, prop, 0, 0);
+                    parsedCondition = writeVarFilter(mode, v, ctx, prop, 0, 0);
                 }
                 else {
-                    buf = createFixedFilterBuffer(prop, 8, { operation: EQUAL_CRC32, type: ctx.type, opts: ctx.opts }, val, false);
+                    parsedCondition = createFixedFilterBuffer(prop, 8, { operation: EQUAL_CRC32, type: ctx.type, opts: ctx.opts }, val, false);
                 }
             }
             else {
                 if (val instanceof ArrayBuffer) {
                     val = new Uint8Array(val);
                 }
-                buf = writeVarFilter(mode, val, ctx, prop, 0, 0);
+                parsedCondition = writeVarFilter(mode, val, ctx, prop, 0, 0);
             }
         }
         else {
-            // RFE is val always an Uint8Array?
-            buf = writeVarFilter(mode, val, ctx, prop, prop.start, prop.len);
+            parsedCondition = writeVarFilter(mode, val, ctx, prop, prop.start, prop.len);
         }
     }
-    return buf;
+    return parsedCondition;
 };
 function writeVarFilter(mode, val, ctx, prop, start, len) {
     const size = val.byteLength;

package/dist/src/client/query/filter/parseFilterValue.js

@@ -1,6 +1,6 @@
 import { TIMESTAMP, ENUM, BOOLEAN, STRING, BINARY, TEXT, } from '@based/schema/def';
 import { crc32 } from '../../crc32.js';
-import { convertToTimestamp } from '../../timestamp.js';
+import { convertToTimestamp } from '@saulx/utils';
 import { ENCODER } from '../../../utils.js';
 // -------------------------------------------
 // conditions normal

package/dist/src/client/query/filter/primitiveFilter.js

@@ -6,10 +6,10 @@ import { createReferenceFilter } from './createReferenceFilter.js';
 import { validateFilter } from '../validation.js';
 export const primitiveFilter = (def, prop, filter, conditions, lang) => {
     if (validateFilter(def, prop, filter)) {
-        return;
+        return 0;
     }
     let [, ctx, value] = filter;
-    let buf;
+    let parsedCondition;
     const fieldIndexChar = prop.prop;
     const bufferMap = prop.__isEdge ? conditions.edges : conditions.conditions;
     if (ctx.operation === EXISTS) {
@@ -29,22 +29,22 @@ export const primitiveFilter = (def, prop, filter, conditions, lang) => {
     }
     const propSize = REVERSE_SIZE_MAP[prop.typeIndex];
     if (prop.typeIndex === REFERENCE) {
-        buf = createReferenceFilter(prop, ctx, value);
+        parsedCondition = createReferenceFilter(prop, ctx, value);
     }
     else if (prop.typeIndex === REFERENCES) {
         if (ctx.operation === EQUAL && !isArray) {
             value = [value];
         }
-        buf = createFixedFilterBuffer(prop, 4, ctx, value, !isNumerical(ctx.operation));
+        parsedCondition = createFixedFilterBuffer(prop, 4, ctx, value, !isNumerical(ctx.operation));
     }
     else if (prop.typeIndex === CARDINALITY) {
-        buf = createFixedFilterBuffer(prop, 2, ctx, value, false);
+        parsedCondition = createFixedFilterBuffer(prop, 2, ctx, value, false);
     }
     else if (propSize) {
-        buf = createFixedFilterBuffer(prop, propSize, ctx, value, false);
+        parsedCondition = createFixedFilterBuffer(prop, propSize, ctx, value, false);
     }
     else {
-        buf = createVariableFilterBuffer(value, prop, ctx, lang);
+        parsedCondition = createVariableFilterBuffer(value, prop, ctx, lang);
     }
     // ADD OR if array for value
     let arr = bufferMap.get(fieldIndexChar);
@@ -53,8 +53,8 @@ export const primitiveFilter = (def, prop, filter, conditions, lang) => {
         arr = [];
         bufferMap.set(fieldIndexChar, arr);
     }
-    size += buf.byteLength;
-    arr.push(buf);
+    size += parsedCondition.byteLength;
+    arr.push(parsedCondition);
     return size;
 };
 //# sourceMappingURL=primitiveFilter.js.map

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

@@ -1,19 +1,4 @@
 import { META_EDGE, META_EXISTS, META_OR_BRANCH, META_REFERENCE, TYPE_DEFAULT, TYPE_NEGATE, } from './types.js';
-// or
-// [meta = 253]  [size 2] [next 4]
-// -------------------------------------------
-// edge
-// [meta = 252] [size 2]
-// -------------------------------------------
-// ref
-// [meta = 254] [field] [typeId 2] [size 2]
-// -------------------------------------------
-// conditions normal
-// -------------------------------------------
-// conditions or fixed
-// -------------------------------------------
-// conditions or variable
-// -------------------------------------------
 const writeConditions = (result, k, offset, conditions) => {
     let lastWritten = offset;
     result[lastWritten] = k;

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

@@ -57,3 +57,4 @@ export declare const VECTOR_EUCLIDEAN_DIST = 3;
 export declare const getVectorFn: (optsFn?: FilterOpts["fn"]) => 0 | 1 | 2 | 3;
 export declare const toFilterCtx: (def: QueryDef, op: Operator, opts?: FilterOpts) => FilterCtx;
 export declare const operatorReverseMap: Record<OPERATOR, string>;
+export declare const ALIGNMENT_NOT_SET = 255;

package/dist/src/client/query/filter/types.js

@@ -142,4 +142,5 @@ export const operatorReverseMap = {
     [EQUAL_CRC32]: '= (crc32)',
     [EXISTS]: 'exists',
 };
+export const ALIGNMENT_NOT_SET = 255;
 //# sourceMappingURL=types.js.map

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

@@ -20,7 +20,6 @@ export const walkDefs = (db, def, f) => {
                     def.edges.lang = def.lang;
                 }
                 const edgeProp = def.edges.props[p];
-                // console.log(p, !!edgeProp, Object.keys(def.edges.props), def.target)
                 if (edgeProp.typeIndex === REFERENCE ||
                     edgeProp.typeIndex === REFERENCES) {
                     const refDef = createOrGetRefQueryDef(db, def.edges, edgeProp);

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

@@ -135,7 +135,7 @@ const handleUndefinedProps = (id, q, item) => {
     if (q.aggregation == 0 /* AggFlag.NONE */ || q.aggregation == null) {
         for (const k in q.include.propsRead) {
             if (q.include.propsRead[k] !== id) {
-                // Only relvant for seperate props
+                // Only relevant for seperate props
                 const prop = q.schema.reverseProps[k];
                 if (prop.typeIndex === CARDINALITY) {
                     addField(prop, 0, item);
@@ -159,6 +159,9 @@ const handleUndefinedProps = (id, q, item) => {
                         }
                     }
                 }
+                else if (prop.typeIndex === BINARY) {
+                    addField(prop, new Uint8Array(0), item);
+                }
                 else {
                     addField(prop, prop.typeIndex === JSON ? null : '', item);
                 }
@@ -314,9 +317,6 @@ export const readAllFields = (q, result, offset, end, item, id) => {
         }
         else {
             const prop = q.schema.reverseProps[index];
-            if (!prop) {
-                console.log({ prop: !!prop }, index);
-            }
             if (prop.typeIndex === CARDINALITY) {
                 q.include.propsRead[index] = id;
                 const size = readUint32(result, i);

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

@@ -12,8 +12,7 @@ export const vectorSearch = (def, q, field, opts) => {
     if (prop.typeIndex !== VECTOR) {
         searchIncorrectType(def, prop);
     }
-    // [isVec] [q len] [q len] [field] [fn] [score] [score] [score] [score] [q..]
-    let size = 9;
+    let size = 17;
     const vec = new Uint8Array(q.buffer, 0, q.byteLength);
     size += vec.byteLength;
     def.search = {
@@ -32,21 +31,17 @@ export const search = (def, q, s) => {
         searchIncorrecQueryValue(def, q);
         q = '';
     }
-    const x = q
-        .toLowerCase()
-        .normalize('NFKD')
-        .trim()
-        .split(' ')
-        .map((s) => `  ${s}`);
+    const x = q.toLowerCase().normalize('NFKD').trim().split(' ');
     for (const s of x) {
         if (s) {
             const buf = ENCODER.encode(s);
-            let len = buf.byteLength - 2;
-            buf[0] = len;
-            buf[1] = len >>> 8;
-            bufs.push(buf);
+            const lenBuf = new Uint8Array(2);
+            let len = buf.byteLength;
+            lenBuf[0] = len;
+            lenBuf[1] = len >>> 8;
+            bufs.push(lenBuf, buf);
             nrBlocks++;
-            totalByteLength += len + 2;
+            totalByteLength += buf.byteLength + 2;
         }
     }
     bufs.unshift(Uint8Array.from([nrBlocks]));
@@ -119,7 +114,8 @@ export const searchToBuffer = (search) => {
         | 3      | field    | 1            | Field identifier                                |
         | 4      | func     | 1            | Function identifier (enum)                      |
         | 5      | score    | 4            | Score value (f32)                               |
-        | 9      | query    | queryLen     | Query data (array of f32 values)                |
+        | 9      | align    | 8            | Space for alignment                             |
+        | 17     | query    | queryLen     | Query data (array of f32 values)                |
         */
         const result = new Uint8Array(search.size);
         result[0] = 1; // search.isVector 1
@@ -128,7 +124,7 @@ export const searchToBuffer = (search) => {
         result[3] = search.prop;
         result[4] = getVectorFn(search.opts.fn);
         result.set(new Uint8Array(new Float32Array([search.opts.score ?? 0.5]).buffer), 5);
-        result.set(search.query, 9);
+        result.set(search.query, 17);
         return result;
     }
     else {

package/dist/src/client/query/subscription/markers.js

@@ -95,7 +95,7 @@ const getFilterFields = (filter, results = {
         conditions.forEach((v, k) => {
             if (k === 0) {
                 for (const buf of v) {
-                    const x = buf[4] | buf[5] << 8;
+                    const x = buf[4] | (buf[5] << 8);
                     results.main.add(x);
                 }
             }
@@ -209,6 +209,5 @@ export const resetSubscriptionMarkers = (db) => {
 };
 export const deleteSubscriptionMarkers = (q) => {
     // derp
-    console.log('delete markers!');
 };
 //# sourceMappingURL=markers.js.map

package/dist/src/client/query/subscription/run.js

@@ -61,11 +61,9 @@ export const runSubscription = (subscription) => {
     }
 };
 export const startSubscription = (db) => {
-    console.log('start subscription');
     if (!db.subscriptionsInProgress) {
         db.subscriptionsInProgress = true;
         setTimeout(() => {
-            console.log('run it');
             db.subscriptionsToRun.forEach((s) => {
                 runSubscription(s);
             });

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

@@ -1,6 +1,4 @@
 export declare const MAX_IDS_PER_QUERY = 1000000;
 export declare const DEF_RANGE_PROP_LIMIT = 1000;
 export declare const DEF_RANGE_REF_LIMIT = 10000;
-export declare const MAX_ID = 4294967295;
 export declare const MIN_ID_VALUE = 1;
-export declare const MAX_ID_VALUE: number;

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

@@ -2,8 +2,6 @@
 export const MAX_IDS_PER_QUERY = 1e6; // Max number of IDs that can be queried at once
 export const DEF_RANGE_PROP_LIMIT = 1e3;
 export const DEF_RANGE_REF_LIMIT = 1e4;
-export const MAX_ID = 4294967295;
 // Data validation thresholds
 export const MIN_ID_VALUE = 1; // Minimum allowed value for an ID (id array stared)
-export const MAX_ID_VALUE = 2 ** 32 - 1; /// Maximum allowed value for an ID (Uint32)
 //# sourceMappingURL=thresholds.js.map