@based/db 0.0.64 → 0.0.67

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/flushModify.d.ts

@@ -7,6 +7,7 @@ export declare class ModifyCtx {
     id: number;
     hasSortField: number;
     hasSortText: number;
+    hasDefaults: number;
     ctx: {
         queue?: Map<(payload: any) => void, ModifyState>;
         offsets?: Record<number, number>;
@@ -26,7 +27,7 @@ export declare class ModifyCtx {
     markNodeDirty(schema: SchemaTypeDef, nodeId: number): void;
     markTypeDirty(schema: SchemaTypeDef): void;
     updateMax(): void;
-    getData(lastIds: Record<number, number>): Uint8Array;
+    getData(lastIds: Record<number, number>): Uint8Array<ArrayBufferLike>;
     reset(): void;
 }
 export declare const execCtxQueue: (resCtx: ModifyCtx["ctx"], error?: boolean) => void;

package/dist/src/client/flushModify.js

@@ -1,6 +1,6 @@
 import { writeUint64 } from '@saulx/utils';
 // TODO This definitely shouldn't be copy-pasted here from server/tree.ts
-const makeCsmtKeyFromNodeId = (typeId, blockCapacity, nodeId) => {
+const makeTreeKeyFromNodeId = (typeId, blockCapacity, nodeId) => {
     const tmp = nodeId - +!(nodeId % blockCapacity);
     return typeId * 4294967296 + ((tmp / blockCapacity) | 0) * blockCapacity + 1;
 };
@@ -16,6 +16,7 @@ export class ModifyCtx {
     id = -1;
     hasSortField = -1;
     hasSortText = -1;
+    hasDefaults = -1;
     ctx = {};
     payload;
     max;
@@ -30,7 +31,7 @@ export class ModifyCtx {
     dirtyRanges = new Set();
     dirtyTypes = new Map();
     markNodeDirty(schema, nodeId) {
-        const key = makeCsmtKeyFromNodeId(schema.id, schema.blockCapacity, nodeId);
+        const key = makeTreeKeyFromNodeId(schema.id, schema.blockCapacity, nodeId);
         if (this.dirtyRanges.has(key)) {
             return;
         }
@@ -77,9 +78,16 @@ export class ModifyCtx {
             data[i++] = lastId >>> 24;
         }
         const view = new DataView(data.buffer, data.byteOffset);
+        // this is a problem need to remove these dirtyRanges in general...
         for (let key of this.dirtyRanges) {
-            view.setFloat64(i, key, true);
-            i += 8;
+            if (i < view.byteLength - 8) {
+                view.setFloat64(i, key, true);
+                i += 8;
+            }
+            else {
+                console.warn('Dirty range does not fit - will remove this', this.dirtyRanges.size, i);
+                break;
+            }
         }
         const lenMinusSchemaHash = this.len - 8;
         data[i++] = lenMinusSchemaHash;

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

@@ -52,6 +52,7 @@ const appendCreate = (ctx, def, obj, res, unsafe) => {
             ctx.buf.set(def.mainEmpty, ctx.len);
             ctx.len += def.mainLen;
         }
+        // add text & string here
     }
     if (def.hasSeperateSort) {
         if (ctx.hasSortField !== def.seperateSort.size - 1) {
@@ -79,6 +80,16 @@ const appendCreate = (ctx, def, obj, res, unsafe) => {
         // add test for this
         ctx.hasSortField = -1;
     }
+    // if (def.hasSeperateDefaults) {
+    //   const buf = def.seperateDefaults.bufferTmp
+    //   if (ctx.hasDefaults !== def.seperateDefaults.props.size - 1) {
+    //     //
+    //   }
+    //   if (ctx.hasDefaults !== -1) {
+    //     buf.set(def.seperateTextSort.buffer, 0)
+    //   }
+    //   ctx.hasDefaults = -1
+    // }
     if (def.hasSeperateTextSort) {
         const buf = def.seperateTextSort.bufferTmp;
         if (ctx.hasSortText !== def.seperateTextSort.size - 1) {

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

@@ -8,6 +8,9 @@ export const deleteFn = (db, type, id, opts) => {
     if (!def) {
         throw new Error(`Unknown type: ${type}. Did you mean on of: ${Object.keys(db.schemaTypesParsed).join(', ')}`);
     }
+    if (def.insertOnly) {
+        throw new Error(`This type is insertOnly`);
+    }
     const ctx = db.modifyCtx;
     const res = new ModifyState(def.id, id, db, opts);
     const schema = db.schemaTypesParsed[type];

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/modify/modify.js

@@ -1,4 +1,4 @@
-import { isPropDef, REFERENCE, REFERENCES, STRING, TEXT, ALIAS, BINARY, CARDINALITY, VECTOR, MICRO_BUFFER, JSON, } from '@based/schema/def';
+import { isPropDef, REFERENCE, REFERENCES, STRING, TEXT, ALIAS, BINARY, CARDINALITY, VECTOR, MICRO_BUFFER, JSON, COLVEC, } from '@based/schema/def';
 import { ModifyError } from './ModifyRes.js';
 import { writeReference } from './references/reference.js';
 import { writeReferences } from './references/references.js';
@@ -50,7 +50,7 @@ function _modify(ctx, res, obj, schema, mod, tree, overwrite, unsafe) {
                 else if (type === CARDINALITY) {
                     err = writeHll(val, ctx, schema, def, res.tmpId, mod);
                 }
-                else if (type === VECTOR) {
+                else if (type === VECTOR || type === COLVEC) {
                     err = writeVector(val, ctx, schema, def, res.tmpId, mod);
                 }
                 else if (type === JSON) {

package/dist/src/client/modify/setCursor.d.ts

@@ -1,4 +1,5 @@
 import { ModifyCtx } from '../../index.js';
 import { SchemaTypeDef } from '@based/schema/def';
 import { ModifyOp } from './types.js';
-export declare const setCursor: (ctx: ModifyCtx, schema: SchemaTypeDef, field: number, typeIndex: number, id: number, modifyOp: ModifyOp, ignoreField?: boolean) => void;
+export declare const setCursor: (ctx: ModifyCtx, schema: SchemaTypeDef, field: number, // TODO pass propdef better
+typeIndex: number, id: number, modifyOp: ModifyOp, ignoreField?: boolean) => void;

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

@@ -1,7 +1,7 @@
-import { QueryDef, QueryTarget, Operator, QueryByAliasObj } from './query.js';
+import { QueryDef, QueryTarget, Operator, QueryByAliasObj, LangFallback } 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,12 @@ export declare class QueryBranch<T> {
     groupBy(field: string): T;
     count(field?: string): T;
     sum(...fields: (string | string[])[]): T;
+    cardinality(...fields: (string | string[])[]): T;
+    stddev(...fields: (string | string[])[]): T;
+    var(...fields: (string | string[])[]): T;
+    avg(...fields: (string | string[])[]): T;
+    max(...fields: (string | string[])[]): T;
+    min(...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;
@@ -47,7 +53,7 @@ export declare class BasedDbQuery extends QueryBranch<BasedDbQuery> {
     get(): GetPromise;
     buffer: Uint8Array;
     register(): void;
-    locale(locale: LangName): this;
-    subscribe(onData: OnData, onError?: OnError): OnClose;
+    locale(locale: LangName, fallBack?: LangFallback): this;
+    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 { AggregateType } from './aggregates/types.js';
 import { displayTarget } from './display.js';
 import picocolors from 'picocolors';
 export class QueryBranch {
@@ -151,7 +152,7 @@ export class QueryBranch {
         }
         else {
             const p = field.split('.');
-            addAggregate(2 /* AggregateType.COUNT */, this.def, p);
+            addAggregate(AggregateType.COUNT, this.def, p);
         }
         // @ts-ignore
         return this;
@@ -167,7 +168,103 @@ export class QueryBranch {
             });
         }
         else {
-            addAggregate(1 /* AggregateType.SUM */, this.def, fields);
+            addAggregate(AggregateType.SUM, this.def, fields);
+        }
+        // @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(AggregateType.CARDINALITY, this.def, fields);
+        }
+        // @ts-ignore
+        return this;
+    }
+    stddev(...fields) {
+        if (fields.length === 0) {
+            throw new Error('Empty standard deviation function called');
+        }
+        if (this.queryCommands) {
+            this.queryCommands.push({
+                method: 'stddev',
+                args: fields,
+            });
+        }
+        else {
+            addAggregate(AggregateType.STDDEV, this.def, fields);
+        }
+        // @ts-ignore
+        return this;
+    }
+    var(...fields) {
+        if (fields.length === 0) {
+            throw new Error('Empty variance function called');
+        }
+        if (this.queryCommands) {
+            this.queryCommands.push({
+                method: 'var',
+                args: fields,
+            });
+        }
+        else {
+            addAggregate(AggregateType.VARIANCE, this.def, fields);
+        }
+        // @ts-ignore
+        return this;
+    }
+    avg(...fields) {
+        if (fields.length === 0) {
+            throw new Error('Empty average function called');
+        }
+        if (this.queryCommands) {
+            this.queryCommands.push({
+                method: 'avg',
+                args: fields,
+            });
+        }
+        else {
+            addAggregate(AggregateType.AVERAGE, this.def, fields);
+        }
+        // @ts-ignore
+        return this;
+    }
+    max(...fields) {
+        if (fields.length === 0) {
+            throw new Error('Empty maximum function called');
+        }
+        if (this.queryCommands) {
+            this.queryCommands.push({
+                method: 'max',
+                args: fields,
+            });
+        }
+        else {
+            addAggregate(AggregateType.MAX, this.def, fields);
+        }
+        // @ts-ignore
+        return this;
+    }
+    min(...fields) {
+        if (fields.length === 0) {
+            throw new Error('Empty minimum function called');
+        }
+        if (this.queryCommands) {
+            this.queryCommands.push({
+                method: 'min',
+                args: fields,
+            });
+        }
+        else {
+            addAggregate(AggregateType.MIN, this.def, fields);
         }
         // @ts-ignore
         return this;
@@ -371,16 +468,28 @@ export class BasedDbQuery extends QueryBranch {
     register() {
         registerQuery(this);
     }
-    locale(locale) {
+    locale(locale, fallBack) {
         if (this.queryCommands) {
-            this.queryCommands.push({
+            this.queryCommands.unshift({
                 method: 'locale',
                 args: [locale],
             });
         }
         else {
+            if (fallBack === undefined) {
+                // Uses fallback from schema if available
+                const localeDescriptor = this.def.schema.locales[locale];
+                fallBack =
+                    typeof localeDescriptor === 'object'
+                        ? localeDescriptor.fallback || false
+                        : false;
+            }
             validateLocale(this.def, locale);
-            this.def.lang = langCodesMap.get(locale) ?? 0;
+            const fallBackCode = fallBack === false ? [] : [langCodesMap.get(fallBack)];
+            this.def.lang = {
+                lang: langCodesMap.get(locale) ?? 0,
+                fallback: fallBackCode,
+            };
         }
         return this;
     }
@@ -390,7 +499,6 @@ export class BasedDbQuery extends QueryBranch {
                 onData(res);
             }
             catch (err) {
-                // const t = displayTarget(this.def)
                 const def = this.def;
                 let name = picocolors.red(`QueryError[${displayTarget(def)}]\n`);
                 name += `  Error executing onData handler in subscription\n`;

package/dist/src/client/query/aggregates/aggregation.js

@@ -1,7 +1,9 @@
 import { writeUint16 } from '@saulx/utils';
 import { QueryDefType } from '../types.js';
+import { AggregateType } from './types.js';
 import { UINT32 } from '@based/schema/def';
 import { aggregationFieldDoesNotExist } from '../validation.js';
+import { aggregateTypeMap } from '../aggregates/types.js';
 export const aggregateToBuffer = (aggregates) => {
     const aggBuffer = new Uint8Array(aggregates.size);
     let i = 0;
@@ -21,7 +23,9 @@ export const aggregateToBuffer = (aggregates) => {
         aggBuffer[i] = 0 /* GroupBy.NONE */;
         i += 1;
     }
-    writeUint16(aggBuffer, aggregates.totalResultsPos, i);
+    writeUint16(aggBuffer, aggregates.totalResultsSize, i);
+    i += 2;
+    writeUint16(aggBuffer, aggregates.totalAccumulatorSize, i);
     i += 2;
     for (const [prop, aggregatesArray] of aggregates.aggregates.entries()) {
         aggBuffer[i] = prop;
@@ -39,6 +43,8 @@ export const aggregateToBuffer = (aggregates) => {
             i += 2;
             writeUint16(aggBuffer, agg.resultPos, i);
             i += 2;
+            writeUint16(aggBuffer, agg.accumulatorPos, i);
+            i += 2;
             size += i - startI;
         }
         writeUint16(aggBuffer, size, sizeIndex);
@@ -48,13 +54,13 @@ export const aggregateToBuffer = (aggregates) => {
 const ensureAggregate = (def) => {
     if (!def.aggregate) {
         def.aggregate = {
-            size: 3,
+            size: 5,
             aggregates: new Map(),
-            totalResultsPos: 0,
+            totalResultsSize: 0,
+            totalAccumulatorSize: 0,
         };
     }
 };
-// Group by is great for normal stuff as well (do later)
 export const groupBy = (def, field) => {
     const fieldDef = def.schema.props[field];
     if (!fieldDef) {
@@ -74,7 +80,7 @@ export const addAggregate = (type, def, fields) => {
             addAggregate(type, def, field);
         }
         else {
-            const fieldDef = type === 2 /* AggregateType.COUNT */
+            const fieldDef = type === AggregateType.COUNT
                 ? {
                     prop: 255,
                     path: [field],
@@ -98,13 +104,20 @@ export const addAggregate = (type, def, fields) => {
             aggregateField.push({
                 propDef: fieldDef,
                 type,
-                resultPos: def.aggregate.totalResultsPos,
+                resultPos: def.aggregate.totalResultsSize,
+                accumulatorPos: def.aggregate.totalAccumulatorSize,
             });
-            // IF FLOAT // NUMBER ETC USE 8!
-            // do this better
-            def.aggregate.totalResultsPos += 4;
+            const specificSizes = aggregateTypeMap.get(type);
+            if (specificSizes) {
+                def.aggregate.totalResultsSize += specificSizes.resultsSize;
+                def.aggregate.totalAccumulatorSize += specificSizes.accumulatorSize;
+            }
+            else {
+                def.aggregate.totalResultsSize += 8;
+                def.aggregate.totalAccumulatorSize += 8;
+            }
             // needs to add an extra field WRITE TO
-            def.aggregate.size += 6;
+            def.aggregate.size += 8;
         }
     }
 };
@@ -128,7 +141,7 @@ export const isRootCountOnly = (def, filterSize) => {
     if (aggs.length !== 1) {
         return false;
     }
-    if (aggs[0].type !== 2 /* AggregateType.COUNT */) {
+    if (aggs[0].type !== AggregateType.COUNT) {
         return false;
     }
     if (def.filter && def.filter.size > 0) {

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

@@ -1,7 +1,27 @@
-export declare const enum AggregateType {
+export declare enum AggregateType {
     SUM = 1,
-    COUNT = 2
+    COUNT = 2,
+    CARDINALITY = 3,
+    STDDEV = 4,
+    AVERAGE = 5,
+    VARIANCE = 6,
+    MAX = 7,
+    MIN = 8
 }
+export declare const enum AccumulatorSize {
+    SUM = 8,
+    COUNT = 4,
+    CARDINALITY = 254,// TODO: accordinly to sparse or dense modes
+    STDDEV = 24,// count (u64) + sum (f64) + sum_sq (f64) = 8 + 8 + 8 = 24
+    AVERAGE = 16,// count (u64) + sum (f64) = 16
+    VARIANCE = 24,// count (u64) + sum (f64) + sum_sq (f64) = 8 + 8 + 8 = 24
+    MAX = 8,
+    MIN = 8
+}
+export declare const aggregateTypeMap: Map<AggregateType, {
+    resultsSize: number;
+    accumulatorSize: number;
+}>;
 export declare const enum GroupBy {
     NONE = 0,
     HAS_GROUP = 255

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

@@ -1,2 +1,35 @@
-export {};
+export var AggregateType;
+(function (AggregateType) {
+    AggregateType[AggregateType["SUM"] = 1] = "SUM";
+    AggregateType[AggregateType["COUNT"] = 2] = "COUNT";
+    AggregateType[AggregateType["CARDINALITY"] = 3] = "CARDINALITY";
+    AggregateType[AggregateType["STDDEV"] = 4] = "STDDEV";
+    AggregateType[AggregateType["AVERAGE"] = 5] = "AVERAGE";
+    AggregateType[AggregateType["VARIANCE"] = 6] = "VARIANCE";
+    AggregateType[AggregateType["MAX"] = 7] = "MAX";
+    AggregateType[AggregateType["MIN"] = 8] = "MIN";
+})(AggregateType || (AggregateType = {}));
+export const aggregateTypeMap = new Map([
+    [
+        AggregateType.CARDINALITY,
+        { resultsSize: 4, accumulatorSize: 254 /* AccumulatorSize.CARDINALITY */ },
+    ],
+    [
+        AggregateType.COUNT,
+        { resultsSize: 4, accumulatorSize: 4 /* AccumulatorSize.COUNT */ },
+    ],
+    [
+        AggregateType.STDDEV,
+        { resultsSize: 8, accumulatorSize: 24 /* AccumulatorSize.STDDEV */ },
+    ],
+    [
+        AggregateType.AVERAGE,
+        { resultsSize: 8, accumulatorSize: 16 /* AccumulatorSize.AVERAGE */ },
+    ],
+    [
+        AggregateType.VARIANCE,
+        { resultsSize: 8, accumulatorSize: 24 /* AccumulatorSize.VARIANCE */ },
+    ],
+    // Othe types like MAX, MIN, SUM fall in the else case in aggregation.ts 8/8
+]);
 //# sourceMappingURL=types.js.map

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

@@ -1,6 +1,7 @@
 import picocolors from 'picocolors';
 import { BINARY, CARDINALITY, NUMBER, REFERENCE, REFERENCES, STRING, TEXT, TIMESTAMP, } from '@based/schema/def';
 import { ENCODER } from '@saulx/utils';
+import { AggregateType } from './aggregates/types.js';
 const decimals = (v) => ~~(v * 100) / 100;
 const sizeCalc = (size) => {
     if (size > 1e6) {
@@ -158,7 +159,10 @@ const inspectObject = (object, q, path, level, isLast, isFirst, isObject, depth)
             if (typeof v === 'number') {
                 if (q.aggregate) {
                     str += printNumber(v);
-                    str += picocolors.italic(picocolors.dim(` ${key.indexOf('count') >= 0 ? ' count' : ' sum'}`));
+                    // TBD: replace comptime const enum and reverse map it
+                    const [[__, akv], _] = q.aggregate.aggregates;
+                    const aggType = akv[0].type;
+                    str += picocolors.italic(picocolors.dim(` ${AggregateType[aggType].toLowerCase()}`));
                     str += ',\n';
                 }
                 else {
@@ -219,7 +223,9 @@ const inspectObject = (object, q, path, level, isLast, isFirst, isObject, depth)
                 if (typeof v === 'number') {
                     if (q.aggregate) {
                         str += printNumber(v);
-                        str += picocolors.italic(picocolors.dim(` ${key.indexOf('count') >= 0 ? ' count' : ' sum'}`));
+                        const [[__, akv], _] = q.aggregate.aggregates;
+                        const aggType = akv[0].type;
+                        str += picocolors.italic(picocolors.dim(` ${AggregateType[aggType].toLowerCase()}`));
                     }
                     else {
                         str += printNumber(v);

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

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

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

@@ -33,9 +33,15 @@ const parseValue = (value, prop, ctx, lang) => {
             val = ENCODER.encode(val.normalize('NFKD'));
         }
         if (prop.typeIndex === TEXT) {
-            const tmp = new Uint8Array(val.byteLength + 1);
+            // 1 + size
+            const fallbacksSize = lang.lang === 0 ? 0 : lang.fallback.length;
+            const tmp = new Uint8Array(val.byteLength + 2 + fallbacksSize);
             tmp.set(val);
-            tmp[tmp.byteLength - 1] = lang;
+            tmp[tmp.byteLength - 1] = fallbacksSize;
+            tmp[tmp.byteLength - 2] = lang.lang;
+            for (let i = 0; i < fallbacksSize; i++) {
+                tmp[tmp.byteLength - 2 - fallbacksSize + i] = lang.fallback[i];
+            }
             val = tmp;
         }
     }
@@ -90,9 +96,10 @@ export const createVariableFilterBuffer = (value, prop, ctx, lang) => {
                 prop.typeIndex !== ALIAS &&
                 prop.typeIndex !== VECTOR) {
                 if (prop.typeIndex === TEXT) {
-                    const crc = crc32(val.slice(0, -1));
-                    const len = val.byteLength - 1;
-                    const v = new Uint8Array(9);
+                    const fbLen = 2 + val[val.byteLength - 1];
+                    const crc = crc32(val.slice(0, -fbLen));
+                    const len = val.byteLength - fbLen;
+                    const v = new Uint8Array(8 + fbLen);
                     v[0] = crc;
                     v[1] = crc >>> 8;
                     v[2] = crc >>> 16;
@@ -101,11 +108,17 @@ export const createVariableFilterBuffer = (value, prop, ctx, lang) => {
                     v[5] = len >>> 8;
                     v[6] = len >>> 16;
                     v[7] = len >>> 24;
-                    v[8] = val[val.length - 1];
+                    for (let i = 0; i < fbLen; i++) {
+                        v[v.byteLength - (i + 1)] = val[val.byteLength - (i + 1)];
+                    }
                     parsedCondition = writeVarFilter(mode, v, ctx, prop, 0, 0);
                 }
                 else {
-                    parsedCondition = 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 {

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

@@ -22,7 +22,11 @@ const referencesFilter = (db, filter, schema, conditions, def) => {
                     if (edgeDef) {
                         conditions.edges ??= new Map();
                         size +=
-                            3 + primitiveFilter(def, edgeDef, filter, conditions, def.lang);
+                            3 +
+                                primitiveFilter(def, edgeDef, filter, conditions, {
+                                    lang: def.lang.lang,
+                                    fallback: [],
+                                });
                     }
                 }
             }
@@ -71,12 +75,18 @@ export const filterRaw = (db, filter, schema, conditions, def) => {
                     filterInvalidLang(def, field);
                     return 0;
                 }
-                return primitiveFilter(def, fieldDef, filter, conditions, code);
+                return primitiveFilter(def, fieldDef, filter, conditions, {
+                    lang: code,
+                    fallback: [],
+                });
             }
         }
         if (field === 'id') {
             fieldDef = ID_FIELD_DEF;
-            return primitiveFilter(def, fieldDef, filter, conditions, def.lang);
+            return primitiveFilter(def, fieldDef, filter, conditions, {
+                lang: def.lang.lang,
+                fallback: [], // only fallbacks for this
+            });
         }
         return referencesFilter(db, filter, schema, conditions, def);
     }