@based/db 0.0.19 → 0.0.21

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

@@ -31,7 +31,7 @@ void selva_db_destroy(struct SelvaDb *db) __attribute__((nonnull));
  * @param type must not exist before.
  */
 SELVA_EXPORT
-int selva_db_schema_create(struct SelvaDb *db, node_type_t type, const char *schema_buf, size_t schema_len) __attribute__((nonnull));
+int selva_db_create_type(struct SelvaDb *db, node_type_t type, const char *schema_buf, size_t schema_len) __attribute__((nonnull));
 
 /**
  * Save the common/shared data of the database.
@@ -54,10 +54,10 @@ int selva_dump_save_range(struct SelvaDb *db, struct SelvaTypeEntry *te, const c
  *  ```
  */
 SELVA_EXPORT
-int selva_dump_load_common(struct SelvaDb *db, const char *filename) __attribute__((nonnull));
+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) __attribute__((nonnull));
+int selva_dump_load_range(struct SelvaDb *db, const char *filename, char *errlog_buf, size_t errlog_size) __attribute__((nonnull));
 
 /**
  * Find a type by type id.
@@ -75,28 +75,92 @@ struct SelvaTypeEntry *selva_get_type_by_node(const struct SelvaDb *db, struct S
  * Get the node schema for type.
  */
 SELVA_EXPORT
-const struct SelvaNodeSchema *selva_get_ns_by_te(const struct SelvaTypeEntry *te) __attribute__((nonnull, pure));
+__attribute__((nonnull, pure))
+inline const struct SelvaNodeSchema *selva_get_ns_by_te(const struct SelvaTypeEntry *te)
+#if !__zig
+{
+    return &te->ns;
+}
+#else
+;
+#endif
 
 SELVA_EXPORT
-const struct SelvaFieldSchema *get_fs_by_fields_schema_field(const struct SelvaFieldsSchema *fields_schema, field_t field) __attribute__((nonnull, pure));
+__attribute__((nonnull, pure))
+inline const struct SelvaFieldSchema *get_fs_by_fields_schema_field(const struct SelvaFieldsSchema *fields_schema, field_t field)
+#if !__zig
+{
+    if (field >= fields_schema->nr_fields) {
+        return nullptr;
+    }
+
+    return &fields_schema->field_schemas[field];
+}
+#else
+;
+#endif
 
 /**
  * Get the field schema for field.
  */
 SELVA_EXPORT
-const struct SelvaFieldSchema *selva_get_fs_by_ns_field(const struct SelvaNodeSchema *ns, field_t field) __attribute__((nonnull, pure));
+__attribute__((nonnull, pure))
+inline const struct SelvaFieldSchema *selva_get_fs_by_te_field(const struct SelvaTypeEntry *te, field_t field)
+#if !__zig
+{
+    return get_fs_by_fields_schema_field(&te->ns.fields_schema, field);
+}
+#else
+;
+#endif
 
 /**
  * Get the field schema for field.
  */
 SELVA_EXPORT
-const struct SelvaFieldSchema *selva_get_fs_by_node(struct SelvaDb *db, struct SelvaNode *node, field_t field) __attribute__((nonnull, pure));
+__attribute__((nonnull, pure))
+inline const struct SelvaFieldSchema *selva_get_fs_by_ns_field(const struct SelvaNodeSchema *ns, field_t field)
+#if !__zig
+{
+    return get_fs_by_fields_schema_field(&ns->fields_schema, field);
+}
+#else
+;
+#endif
+
+/**
+ * Get the field schema for field.
+ */
+SELVA_EXPORT
+__attribute__((nonnull, pure))
+inline const struct SelvaFieldSchema *selva_get_fs_by_node(struct SelvaDb *db, struct SelvaNode *node, field_t field)
+#if !__zig
+{
+    struct SelvaTypeEntry *type;
+
+    type = selva_get_type_by_node(db, node);
+    if (!type) {
+        return nullptr;
+    }
+
+    return selva_get_fs_by_ns_field(&type->ns, field);
+}
+#else
+;
+#endif
 
 SELVA_EXPORT
 #if __has_c_attribute(reproducible)
 [[reproducible]]
 #endif
-enum SelvaFieldType selva_get_fs_type(const struct SelvaFieldSchema *fs);
+inline enum SelvaFieldType selva_get_fs_type(const struct SelvaFieldSchema *fs)
+#if !__zig
+{
+    return fs->type;
+}
+#else
+;
+#endif
 
 /**
  * Get the EdgeFieldConstraint from a ref field schema.
@@ -105,7 +169,17 @@ enum SelvaFieldType selva_get_fs_type(const struct SelvaFieldSchema *fs);
  * struct SelvaFieldSchema *dst_fs = selva_get_fs_by_node(db, dst, efc->inverse_field);
  */
 SELVA_EXPORT
-const struct EdgeFieldConstraint *selva_get_edge_field_constraint(const struct SelvaFieldSchema *fs) __attribute__((nonnull));
+__attribute__((nonnull))
+inline const struct EdgeFieldConstraint *selva_get_edge_field_constraint(const struct SelvaFieldSchema *fs)
+#if !__zig
+{
+    return (fs->type == SELVA_FIELD_TYPE_REFERENCE || fs->type == SELVA_FIELD_TYPE_REFERENCES)
+        ? &fs->edge_constraint
+        : nullptr;
+}
+#else
+;
+#endif
 
 SELVA_EXPORT
 const struct SelvaFieldsSchema *selva_get_edge_field_fields_schema(struct SelvaDb *db, const struct EdgeFieldConstraint *efc);
@@ -173,6 +247,11 @@ struct SelvaNode *selva_prev_node(struct SelvaTypeEntry *type, struct SelvaNode
 SELVA_EXPORT
 struct SelvaNode *selva_next_node(struct SelvaTypeEntry *type, struct SelvaNode *node) __attribute__((nonnull));
 
+/**
+ * \addtogroup db_cursor
+ * @{
+ */
+
 /**
  * Create a new cursor pointing to node.
  * If the node is deleted later then the cursor is updated to point to the next
@@ -205,6 +284,10 @@ void selva_cursor_del(struct SelvaTypeEntry *type, cursor_id_t id) __attribute__
 SELVA_EXPORT
 size_t selva_cursor_count(const struct SelvaTypeEntry *type) __attribute__((nonnull));
 
+/**
+ * @}
+ */
+
 /**
  * Total count of nodes of type.
  */

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

@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2025 SAULX
+ * SPDX-License-Identifier: MIT
+ */
+#pragma once
+
+#include <stddef.h>
+#include "selva/_export.h"
+
+/**
+ * Fast buffer equals comparison.
+ * @param a is an array of length len.
+ * @param b is an array of length len.
+ * @param len length of a and b in bytes, must be greater than 0.
+ * @returns true if a and b contains the same byte sequence; Otherwise false.
+ */
+SELVA_EXPORT
+bool fast_memcmp(const void *restrict a, const void *restrict b, size_t len);

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

@@ -58,30 +58,21 @@ struct SelvaNodeWeakReferences {
     struct SelvaNodeWeakReference *refs __pcounted_by(nr_refs);
 };
 
-struct SelvaFieldsAny {
-    enum SelvaFieldType type; /*!< Type of the value. */
-    union {
-        bool boolean; /*!< SELVA_FIELD_TYPE_BOOLEAN */
-        double number; /*!< SELVA_FIELD_TYPE_NUMBER */
-        int64_t timestamp; /*!< SELVA_FIELD_TYPE_TIMESTAMP, should fit time_t */
-        struct selva_string *string; /*!< SELVA_FIELD_TYPE_STRING */
-        int8_t int8; /* SELVA_FIELD_TYPE_INT8 */
-        uint8_t uint8; /*!< SELVA_FIELD_TYPE_UINT8 */
-        int16_t int16; /*!< SELVA_FIELD_TYPE_INT16 */
-        uint16_t uint16; /*!< SELVA_FIELD_TYPE_UINT16 */
-        int32_t int32; /*!< SELVA_FIELD_TYPE_INT32 */
-        uint32_t uint32; /*!< SELVA_FIELD_TYPE_UINT32 */
-        int64_t int64; /* SELVA_FIELD_TYPE_INT64 */
-        uint64_t uint64; /*!< SELVA_FIELD_TYPE_UINT64 */
-        uint8_t enu; /*!< SELVA_FIELD_TYPE_ENUM */
-#if 0
-        struct SelvaTextField *text; /*!< SELVA_FIELD_TYPE_TEXT */
-        struct SelvaNodeReference *reference; /*!< SELVA_FIELD_TYPE_REFERENCE */
-        struct SelvaNodeReferences *references; /*!< SELVA_FIELD_TYPE_REFERENCES */
-        struct SelvaNodeWeakReference weak_reference; /*!< SELVA_FIELD_TYPE_WEAK_REFERENCE */
-        struct SelvaNodeWeakReferences weak_references; /*!< SELVA_FIELD_TYPE_WEAK_REFERENCES */
-#endif
-    };
+/**
+ * Type helper to determine the size of statically (constant/fixed) sized fields.
+ */
+union SelvaStaticFields {
+    bool boolean; /*!< SELVA_FIELD_TYPE_BOOLEAN */
+    double number; /*!< SELVA_FIELD_TYPE_NUMBER */
+    struct selva_string *string; /*!< SELVA_FIELD_TYPE_STRING */
+    int8_t int8; /* SELVA_FIELD_TYPE_INT8 */
+    uint8_t uint8; /*!< SELVA_FIELD_TYPE_UINT8 */
+    int16_t int16; /*!< SELVA_FIELD_TYPE_INT16 */
+    uint16_t uint16; /*!< SELVA_FIELD_TYPE_UINT16 */
+    int32_t int32; /*!< SELVA_FIELD_TYPE_INT32 */
+    uint32_t uint32; /*!< SELVA_FIELD_TYPE_UINT32 */
+    uint8_t enu; /*!< SELVA_FIELD_TYPE_ENUM */
+    struct SelvaNodeWeakReference weak_reference; /*!< SELVA_FIELD_TYPE_WEAK_REFERENCE */
 };
 
 struct SelvaFieldsPointer {
@@ -121,7 +112,6 @@ int selva_fields_get_mutable_string(
     __attribute__((access(write_only, 4)));
 
 /*
- * TODO prefix with selva_
  * TODO Document diff to get_mutable_string
  */
 SELVA_EXPORT
@@ -130,6 +120,15 @@ struct selva_string *selva_fields_ensure_string(
         const struct SelvaFieldSchema *fs,
         size_t initial_len);
 
+SELVA_EXPORT
+struct selva_string *selva_fields_ensure_string2(
+        struct SelvaDb *db,
+        struct SelvaNode *node,
+        const struct EdgeFieldConstraint *efc,
+        struct SelvaNodeReference *ref,
+        const struct SelvaFieldSchema *fs,
+        size_t initial_len);
+
 SELVA_EXPORT
 int selva_fields_reference_set(
         struct SelvaDb *db,
@@ -267,16 +266,16 @@ int selva_fields_get_text(
         size_t *len);
 
 SELVA_EXPORT
-struct SelvaNodeReference *selva_fields_get_reference(struct SelvaNode *node, field_t field);
+struct SelvaNodeReference *selva_fields_get_reference(struct SelvaDb *db, struct SelvaNode *node, field_t field);
 
 SELVA_EXPORT
-struct SelvaNodeReferences *selva_fields_get_references(struct SelvaNode *node, field_t field);
+struct SelvaNodeReferences *selva_fields_get_references(struct SelvaDb *db, struct SelvaNode *node, field_t field);
 
 SELVA_EXPORT
-struct SelvaNodeWeakReference selva_fields_get_weak_reference(struct SelvaFields *fields, field_t field);
+struct SelvaNodeWeakReference selva_fields_get_weak_reference(struct SelvaDb *db, struct SelvaFields *fields, field_t field);
 
 SELVA_EXPORT
-struct SelvaNodeWeakReferences selva_fields_get_weak_references(struct SelvaFields *fields, field_t field);
+struct SelvaNodeWeakReferences selva_fields_get_weak_references(struct SelvaDb *db, struct SelvaFields *fields, field_t field);
 
 SELVA_EXPORT
 struct SelvaNode *selva_fields_resolve_weak_reference(
@@ -284,6 +283,9 @@ struct SelvaNode *selva_fields_resolve_weak_reference(
         const struct SelvaFieldSchema *fs,
         const struct SelvaNodeWeakReference *weak_ref);
 
+SELVA_EXPORT
+struct selva_string *selva_fields_get_selva_string3(struct SelvaNodeReference *ref, const struct SelvaFieldSchema *fs);
+
 SELVA_EXPORT
 struct selva_string *selva_fields_get_selva_string2(struct SelvaFields *fields, const struct SelvaFieldSchema *fs);
 
@@ -326,9 +328,6 @@ void selva_fields_init(const struct SelvaFieldsSchema *schema, struct SelvaField
 SELVA_EXPORT
 void selva_fields_destroy(struct SelvaDb *db, struct SelvaNode *node);
 
-SELVA_EXPORT
-int selva_fields_get_text_crc(const struct SelvaNode *node, const struct SelvaFieldSchema *fs, enum selva_lang_code lang, uint32_t *crc);
-
 SELVA_EXPORT
 void selva_fields_hash_update(struct XXH3_state_s *hash_state, struct SelvaDb *db, const struct SelvaFieldsSchema *schema, const struct SelvaFields *fields);
 

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

@@ -23,23 +23,13 @@ struct SelvaFieldsSchema;
 
 enum SelvaFieldType {
     SELVA_FIELD_TYPE_NULL = 0,
-    SELVA_FIELD_TYPE_TIMESTAMP = 1,
-#if 0
-    SELVA_FIELD_TYPE_SPARE1 = 2,
-    SELVA_FIELD_TYPE_SPARE2 = 3,
-#endif
     SELVA_FIELD_TYPE_NUMBER = 4,
-#if 0
-    SELVA_FIELD_TYPE_SPARE3 = 5,
-#endif
     SELVA_FIELD_TYPE_INT8 = 20,
     SELVA_FIELD_TYPE_UINT8 = 6,
     SELVA_FIELD_TYPE_INT16 = 21,
     SELVA_FIELD_TYPE_UINT16 = 22,
     SELVA_FIELD_TYPE_INT32 = 23,
     SELVA_FIELD_TYPE_UINT32 = 7,
-    SELVA_FIELD_TYPE_INT64 = 24,
-    SELVA_FIELD_TYPE_UINT64 = 8,
     SELVA_FIELD_TYPE_BOOLEAN = 9,
     SELVA_FIELD_TYPE_ENUM = 10,
     SELVA_FIELD_TYPE_STRING = 11,

package/dist/src/client/bitWise.js

@@ -79,5 +79,4 @@ export const concatUint8Arr = (arrs) => {
     });
     return result;
 };
-const textDecoder = new TextDecoder('utf-8');
 //# sourceMappingURL=bitWise.js.map

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

@@ -1 +1 @@
-export declare const crc32: (buf: Buffer) => any;
+export declare const crc32: (buf: Uint8Array) => any;

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

@@ -5,7 +5,7 @@ export function writeAlias(value, ctx, def, t, parentId, modifyOp) {
     if (typeof value === 'string') {
         if (value.length === 0) {
             if (modifyOp === UPDATE) {
-                if (ctx.len + 11 > ctx.max) {
+                if (ctx.len + 11 /* SIZE.DEFAULT_CURSOR */ > ctx.max) {
                     return RANGE_ERR;
                 }
                 setCursor(ctx, def, t.prop, t.typeIndex, parentId, modifyOp);
@@ -14,7 +14,7 @@ export function writeAlias(value, ctx, def, t, parentId, modifyOp) {
         }
         else {
             let size = Buffer.byteLength(value, 'utf8');
-            if (ctx.len + 15 + size > ctx.max) {
+            if (ctx.len + 11 /* SIZE.DEFAULT_CURSOR */ + 5 + size > ctx.max) {
                 // 5 compression size
                 return RANGE_ERR;
             }
@@ -33,7 +33,7 @@ export function writeAlias(value, ctx, def, t, parentId, modifyOp) {
     }
     else if (value === null) {
         if (modifyOp === UPDATE) {
-            if (ctx.len + 11 > ctx.max) {
+            if (ctx.len + 11 /* SIZE.DEFAULT_CURSOR */ + 1 > ctx.max) {
                 return RANGE_ERR;
             }
             setCursor(ctx, def, t.prop, t.typeIndex, parentId, modifyOp);

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

@@ -1,6 +1,6 @@
 import { ModifyCtx } from '../../index.js';
 import { PropDef, SchemaTypeDef } from '@based/schema/def';
 import { ModifyOp, ModifyErr } from './types.js';
-export declare function getBuffer(value: any): Buffer;
+export declare function getBuffer(value: any): Uint8Array | undefined;
 export declare function writeBinaryRaw(value: Buffer, ctx: ModifyCtx): void;
 export declare function writeBinary(value: any, ctx: ModifyCtx, schema: SchemaTypeDef, t: PropDef, parentId: number, modifyOp: ModifyOp): ModifyErr;

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

@@ -1,18 +1,19 @@
-import { UPDATE, RANGE_ERR, DELETE } from './types.js';
+import { UPDATE, RANGE_ERR, DELETE, } from './types.js';
 import { ModifyError } from './ModifyRes.js';
 import { setCursor } from './setCursor.js';
 import native from '../../native.js';
+const ENCODER = new TextEncoder();
 export function getBuffer(value) {
     if (typeof value === 'object') {
-        if (value instanceof Buffer) {
+        if (value instanceof Uint8Array) {
             return value;
         }
         if (value.buffer instanceof ArrayBuffer) {
-            return Buffer.from(value.buffer);
+            return new Uint8Array(value.buffer, 0, value.byteLength);
         }
     }
     else if (typeof value === 'string') {
-        return Buffer.from(value);
+        return ENCODER.encode(value);
     }
 }
 export function writeBinaryRaw(value, ctx) {
@@ -45,7 +46,7 @@ export function writeBinary(value, ctx, schema, t, parentId, modifyOp) {
     }
     if (size === 0) {
         if (modifyOp === UPDATE) {
-            if (ctx.len + 11 > ctx.max) {
+            if (ctx.len + 11 /* SIZE.DEFAULT_CURSOR */ + 1 > ctx.max) {
                 return RANGE_ERR;
             }
             setCursor(ctx, schema, t.prop, t.typeIndex, parentId, modifyOp);
@@ -53,7 +54,7 @@ export function writeBinary(value, ctx, schema, t, parentId, modifyOp) {
         }
     }
     else {
-        if (ctx.len + 15 + size > ctx.max) {
+        if (ctx.len + 11 /* SIZE.DEFAULT_CURSOR */ + 5 + size > ctx.max) {
             return RANGE_ERR;
         }
         setCursor(ctx, schema, t.prop, t.typeIndex, parentId, modifyOp);

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

@@ -1,4 +1,6 @@
 import { ModifyCtx } from '../../index.js';
 import { SchemaTypeDef, PropDef } from '@based/schema/def';
 import { ModifyOp, ModifyErr } from './types.js';
-export declare function writeHll(value: string | null | Buffer | Array<string | Buffer>, ctx: ModifyCtx, def: SchemaTypeDef, t: PropDef, parentId: number, modifyOp: ModifyOp): ModifyErr;
+import { ModifyError } from './ModifyRes.js';
+export declare function writeHll(value: string | null | Buffer | Uint8Array | Array<string | Buffer | Uint8Array>, ctx: ModifyCtx, def: SchemaTypeDef, t: PropDef, parentId: number, modifyOp: ModifyOp): ModifyErr;
+export declare function writeHllBuf(value: (string | Buffer | Uint8Array)[], ctx: ModifyCtx, t: PropDef, len: number): ModifyError;

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

@@ -7,7 +7,7 @@ export function writeHll(value, ctx, def, t, parentId, modifyOp) {
         return new ModifyError(t, value);
     }
     if (value === null) {
-        // Future hll_reset frunction
+        // Future hll_reset function
         return;
     }
     else if (!Array.isArray(value)) {
@@ -23,18 +23,22 @@ export function writeHll(value, ctx, def, t, parentId, modifyOp) {
 function addHll(value, ctx, def, t, parentId, modifyOp) {
     const len = value.length;
     let size = 4 + len * 8;
-    if (ctx.len + size + 11 > ctx.max) {
+    if (ctx.len + size + 11 /* SIZE.DEFAULT_CURSOR */ > ctx.max) {
         return RANGE_ERR;
     }
     setCursor(ctx, def, t.prop, t.typeIndex, parentId, modifyOp);
     ctx.buf[ctx.len++] = modifyOp;
+    writeHllBuf(value, ctx, t, len);
+}
+export function writeHllBuf(value, ctx, t, len) {
     ctx.buf.writeUint32LE(len, ctx.len);
     ctx.len += 4;
     for (let val of value) {
         if (typeof val === 'string') {
-            xxHash64(Buffer.from(val), ctx.buf, ctx.len);
+            xxHash64(new TextEncoder().encode(val), ctx.buf, ctx.len);
         }
-        else if (val instanceof Buffer && val.byteLength === 8) {
+        else if ((val instanceof Buffer || val instanceof Uint8Array) &&
+            val.byteLength === 8) {
             ctx.buf.set(val, ctx.len);
         }
         else {

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

@@ -3,7 +3,7 @@ import { startDrain, flushBuffer } from '../operations.js';
 import { setCursor } from './setCursor.js';
 import { modify } from './modify.js';
 import { ModifyState } from './ModifyRes.js';
-import { CREATE, RANGE_ERR, ADD_EMPTY_SORT, } from './types.js';
+import { CREATE, RANGE_ERR, ADD_EMPTY_SORT, ADD_EMPTY_SORT_TEXT, } from './types.js';
 import { writeFixedValue } from './fixed.js';
 import { getSubscriptionMarkers } from '../query/subscription/index.js';
 const appendCreate = (ctx, def, obj, res, unsafe) => {
@@ -13,7 +13,7 @@ const appendCreate = (ctx, def, obj, res, unsafe) => {
         return err;
     }
     if (ctx.len === len || def.mainLen === 0) {
-        if (ctx.len + 10 > ctx.max) {
+        if (ctx.len + 11 /* SIZE.DEFAULT_CURSOR */ > ctx.max) {
             return RANGE_ERR;
         }
         setCursor(ctx, def, 0, MICRO_BUFFER, res.tmpId, CREATE);
@@ -47,7 +47,7 @@ const appendCreate = (ctx, def, obj, res, unsafe) => {
             let sizepos = ctx.len;
             ctx.len += 2;
             for (const { prop } of def.seperateSort.props) {
-                if (def.seperateSort.bufferTmp[prop] === 1) {
+                if (def.seperateSort.bufferTmp[prop] === 0) {
                     if (ctx.len + 1 > ctx.max) {
                         return RANGE_ERR;
                     }
@@ -59,8 +59,44 @@ const appendCreate = (ctx, def, obj, res, unsafe) => {
             ctx.buf[sizepos] = size >>>= 8;
         }
         if (ctx.hasSortField !== -1) {
-            def.seperateSort.buffer.set(def.seperateSort.bufferTmp);
+            def.seperateSort.bufferTmp.set(def.seperateSort.buffer, 0);
         }
+        // add test for this
+        ctx.hasSortField = -1;
+    }
+    if (def.hasSeperateTextSort) {
+        const buf = def.seperateTextSort.bufferTmp;
+        if (ctx.hasSortText !== def.seperateTextSort.size - 1) {
+            if (ctx.len + 3 > ctx.max) {
+                return RANGE_ERR;
+            }
+            ctx.buf[ctx.len++] = ADD_EMPTY_SORT_TEXT;
+            let sizepos = ctx.len;
+            ctx.len += 2;
+            const amount = def.localeSize + 1;
+            const len = amount * def.seperateTextSort.props.length;
+            for (const { prop } of def.seperateTextSort.props) {
+                const index = prop * amount;
+                if (buf[index] !== 0) {
+                    ctx.buf[ctx.len++] = prop;
+                    ctx.buf[ctx.len++] = buf[index];
+                    for (let i = index + 1; i < len + index; i++) {
+                        const lang = buf[i];
+                        if (lang !== 0) {
+                            ctx.buf[ctx.len++] = lang;
+                        }
+                    }
+                }
+            }
+            let size = ctx.len - sizepos - 2;
+            ctx.buf[sizepos++] = size;
+            ctx.buf[sizepos] = size >>>= 8;
+            // [size][size] [prop][len][lang][lang]
+        }
+        if (ctx.hasSortText !== -1) {
+            buf.set(def.seperateTextSort.buffer, 0);
+        }
+        ctx.hasSortText = -1;
     }
 };
 export function create(db, type, obj, opts) {
@@ -89,7 +125,7 @@ export function create(db, type, obj, opts) {
         ctx.len = pos;
         if (err === RANGE_ERR) {
             if (pos === 0) {
-                throw new Error('out of range');
+                throw new Error('!No range available');
             }
             flushBuffer(db);
             return db.create(type, obj, opts);

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

@@ -1,33 +1,34 @@
 import { flushBuffer, startDrain } from '../operations.js';
 import { setCursor } from './setCursor.js';
-import { UPDATE } from './types.js';
+import { UPDATE, DELETE_SORT_INDEX, DELETE_NODE } from './types.js';
 import { MICRO_BUFFER } from '@based/schema/def';
 export const deleteFn = (db, type, id) => {
     const ctx = db.modifyCtx;
     const schema = db.schemaTypesParsed[type];
     const separate = schema.separate;
+    // TODO: pretty slow actually
     if (separate) {
-        const size = 12 + separate.length * 12;
+        const size = 11 /* SIZE.DEFAULT_CURSOR */ + 2 + separate.length * 12;
         if (ctx.len + size > ctx.max) {
             flushBuffer(db);
             return deleteFn(db, type, id);
         }
         setCursor(ctx, schema, 0, MICRO_BUFFER, id, UPDATE);
-        ctx.buf[ctx.len++] = 4;
+        ctx.buf[ctx.len++] = DELETE_SORT_INDEX;
         for (const s of separate) {
             setCursor(ctx, schema, s.prop, s.typeIndex, id, UPDATE);
-            ctx.buf[ctx.len++] = 4;
+            ctx.buf[ctx.len++] = DELETE_SORT_INDEX;
         }
-        ctx.buf[ctx.len++] = 10;
+        ctx.buf[ctx.len++] = DELETE_NODE;
     }
     else {
-        if (ctx.len + 12 > ctx.max) {
+        if (ctx.len + 11 /* SIZE.DEFAULT_CURSOR */ + 2 > ctx.max) {
             flushBuffer(db);
             return deleteFn(db, type, id);
         }
         setCursor(ctx, schema, 0, MICRO_BUFFER, id, UPDATE);
-        ctx.buf[ctx.len++] = 4;
-        ctx.buf[ctx.len++] = 10;
+        ctx.buf[ctx.len++] = DELETE_SORT_INDEX;
+        ctx.buf[ctx.len++] = DELETE_NODE;
     }
     if (!db.isDraining) {
         startDrain(db);

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

@@ -8,7 +8,7 @@ export function expire(db, type, id, seconds) {
         throw new Error(`Unknown type: ${type}. Did you mean on of: ${Object.keys(db.schemaTypesParsed).join(', ')}`);
     }
     const ctx = db.modifyCtx;
-    if (ctx.len + 8 + 1 + 4 > ctx.max) {
+    if (ctx.len + 11 /* SIZE.DEFAULT_CURSOR */ + 5 > ctx.max) {
         flushBuffer(db);
         return expire(db, type, id, seconds);
     }

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

@@ -34,7 +34,7 @@ function _modify(ctx, res, obj, schema, mod, tree, overwrite, unsafe) {
                     err = writeString(0, val, ctx, schema, def, res.tmpId, mod);
                 }
                 else if (type === TEXT) {
-                    err = writeText(val, ctx, schema, def, res, mod);
+                    err = writeText(val, ctx, schema, def, res, res.tmpId, mod);
                 }
                 else if (type === REFERENCE) {
                     err = writeReference(val, ctx, schema, def, res, mod);
@@ -59,7 +59,7 @@ function _modify(ctx, res, obj, schema, mod, tree, overwrite, unsafe) {
                 }
             }
             else if (overwrite) {
-                if (ctx.len + 15 + schema.mainLen > ctx.max) {
+                if (ctx.len + 11 /* SIZE.DEFAULT_CURSOR */ + 5 + schema.mainLen > ctx.max) {
                     return RANGE_ERR;
                 }
                 setCursor(ctx, schema, def.prop, MICRO_BUFFER, res.tmpId, mod, true);
@@ -87,7 +87,7 @@ function _modify(ctx, res, obj, schema, mod, tree, overwrite, unsafe) {
                     if (increment === 0) {
                         continue;
                     }
-                    if (ctx.len + 10 > ctx.max) {
+                    if (ctx.len + 11 /* SIZE.DEFAULT_CURSOR */ > ctx.max) {
                         return RANGE_ERR;
                     }
                     setCursor(ctx, schema, def.prop, MICRO_BUFFER, res.tmpId, mod);

package/dist/src/client/modify/references/edge.js

@@ -1,5 +1,6 @@
-import { BINARY, REFERENCE, REFERENCES, STRING, } from '@based/schema/def';
+import { BINARY, CARDINALITY, REFERENCE, REFERENCES, STRING, } from '@based/schema/def';
 import { write } from '../../string.js';
+import { writeHllBuf } from '../cardinality.js';
 import { getBuffer, writeBinaryRaw } from '../binary.js';
 import { ModifyError, ModifyState } from '../ModifyRes.js';
 import { DECREMENT, INCREMENT, RANGE_ERR } from '../types.js';
@@ -140,6 +141,19 @@ export function writeEdges(t, ref, ctx) {
                     ctx.buf[ctx.len++] = size >>>= 8;
                     appendRefs(edge, ctx, value);
                 }
+                else if (edge.typeIndex === CARDINALITY) {
+                    if (!Array.isArray(value)) {
+                        value = [value];
+                    }
+                    const len = value.length;
+                    let size = 4 + len * 8;
+                    if (ctx.len + size + 11 > ctx.max) {
+                        return RANGE_ERR;
+                    }
+                    ctx.buf[ctx.len++] = edge.prop;
+                    ctx.buf[ctx.len++] = CARDINALITY;
+                    writeHllBuf(value, ctx, t, size);
+                }
             }
             else {
                 if (ctx.len + 2 > ctx.max) {

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

@@ -20,8 +20,6 @@ typeIndex, id, modifyOp, ignoreField) => {
         ctx.buf[ctx.len++] = SWITCH_FIELD; // switch field
         ctx.buf[ctx.len++] = field; // actual field
         ctx.buf[ctx.len++] = typeIndex;
-        // field === 0 ? MICRO_BUFFER : schema.reverseProps[field].typeIndex
-        // add start and len if its main
         ctx.field = field;
     }
     if (ctx.id !== id) {