@based/db 0.0.21 → 0.0.23

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

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

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

@@ -2,6 +2,7 @@ import { RANGE_ERR, CREATE } from './types.js';
 import { ModifyError } from './ModifyRes.js';
 import { setCursor } from './setCursor.js';
 import { xxHash64 } from '../xxHash64.js';
+import { ENCODER } from '../../utils.js';
 export function writeHll(value, ctx, def, t, parentId, modifyOp) {
     if (!value) {
         return new ModifyError(t, value);
@@ -31,14 +32,15 @@ function addHll(value, ctx, def, t, parentId, modifyOp) {
     writeHllBuf(value, ctx, t, len);
 }
 export function writeHllBuf(value, ctx, t, len) {
-    ctx.buf.writeUint32LE(len, ctx.len);
-    ctx.len += 4;
+    ctx.buf[ctx.len++] = len;
+    ctx.buf[ctx.len++] = len >>> 8;
+    ctx.buf[ctx.len++] = len >>> 16;
+    ctx.buf[ctx.len++] = len >>> 24;
     for (let val of value) {
         if (typeof val === 'string') {
-            xxHash64(new TextEncoder().encode(val), ctx.buf, ctx.len);
+            xxHash64(ENCODER.encode(val), ctx.buf, ctx.len);
         }
-        else if ((val instanceof Buffer || val instanceof Uint8Array) &&
-            val.byteLength === 8) {
+        else if ((val instanceof Uint8Array) && val.byteLength === 8) {
             ctx.buf.set(val, ctx.len);
         }
         else {

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

@@ -1,5 +1,5 @@
 import { MICRO_BUFFER } from '@based/schema/def';
-import { startDrain, flushBuffer } from '../operations.js';
+import { startDrain, flushBuffer } from '../flushModify.js';
 import { setCursor } from './setCursor.js';
 import { modify } from './modify.js';
 import { ModifyState } from './ModifyRes.js';
@@ -102,7 +102,9 @@ const appendCreate = (ctx, def, obj, res, unsafe) => {
 export function create(db, type, obj, opts) {
     const def = db.schemaTypesParsed[type];
     if (!def) {
-        throw new Error(`Unknown type: ${type}. Did you mean on of: ${Object.keys(db.schemaTypesParsed).join(', ')}`);
+        throw new Error(
+        // fix this with promise
+        `Unknown type: ${type}. Did you mean on of: ${Object.keys(db.schemaTypesParsed).join(', ')}`);
     }
     let id;
     if ('id' in obj) {
@@ -110,6 +112,7 @@ export function create(db, type, obj, opts) {
             id = obj.id;
         }
         else {
+            // fix this with promise
             throw Error('create with "id" is not allowed');
         }
     }
@@ -121,7 +124,7 @@ export function create(db, type, obj, opts) {
     const pos = ctx.len;
     const err = appendCreate(ctx, def, obj, res, opts?.unsafe);
     if (err) {
-        ctx.prefix0 = -1; // force a new cursor
+        ctx.prefix0 = -1; // Force a new cursor
         ctx.len = pos;
         if (err === RANGE_ERR) {
             if (pos === 0) {
@@ -130,9 +133,11 @@ export function create(db, type, obj, opts) {
             flushBuffer(db);
             return db.create(type, obj, opts);
         }
-        res.error = err;
+        // res.error = err
         // @ts-ignore
-        return res;
+        // return Promise.reject(err)
+        // return res
+        throw err;
     }
     if (!db.isDraining) {
         startDrain(db);

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

@@ -1,2 +1,4 @@
 import { DbClient } from '../index.js';
-export declare const deleteFn: (db: DbClient, type: string, id: number) => boolean;
+import { ModifyRes } from './ModifyRes.js';
+import { ModifyOpts } from './types.js';
+export declare const deleteFn: (db: DbClient, type: string, id: number, opts?: ModifyOpts) => ModifyRes;

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

@@ -1,12 +1,18 @@
-import { flushBuffer, startDrain } from '../operations.js';
+import { flushBuffer, startDrain } from '../flushModify.js';
+import { getSubscriptionMarkers } from '../query/subscription/markers.js';
+import { ModifyState } from './ModifyRes.js';
 import { setCursor } from './setCursor.js';
-import { UPDATE, DELETE_SORT_INDEX, DELETE_NODE } 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) => {
+export const deleteFn = (db, type, id, opts) => {
+    const def = db.schemaTypesParsed[type];
+    if (!def) {
+        throw new Error(`Unknown type: ${type}. Did you mean on of: ${Object.keys(db.schemaTypesParsed).join(', ')}`);
+    }
     const ctx = db.modifyCtx;
+    const res = new ModifyState(def.id, id, db, getSubscriptionMarkers(db, def.id, id, true), opts);
     const schema = db.schemaTypesParsed[type];
     const separate = schema.separate;
-    // TODO: pretty slow actually
     if (separate) {
         const size = 11 /* SIZE.DEFAULT_CURSOR */ + 2 + separate.length * 12;
         if (ctx.len + size > ctx.max) {
@@ -33,6 +39,7 @@ export const deleteFn = (db, type, id) => {
     if (!db.isDraining) {
         startDrain(db);
     }
-    return true;
+    // @ts-ignore
+    return res;
 };
 //# sourceMappingURL=delete.js.map

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

@@ -1,5 +1,5 @@
 import { MICRO_BUFFER } from '@based/schema/def';
-import { startDrain, flushBuffer } from '../operations.js';
+import { startDrain, flushBuffer } from '../flushModify.js';
 import { setCursor } from './setCursor.js';
 import { EXPIRE } from './types.js';
 export function expire(db, type, id, seconds) {

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

@@ -1,3 +1,4 @@
+import { ENCODER } from '../../index.js';
 import { BINARY, BOOLEAN, ENUM, INT16, INT32, INT8, NUMBER, STRING, TIMESTAMP, UINT16, UINT32, UINT8, } from '@based/schema/def';
 import { convertToTimestamp } from '../timestamp.js';
 import { getBuffer } from './binary.js';
@@ -24,7 +25,8 @@ map[STRING] = (ctx, val, def) => {
         }
         val = '';
     }
-    const size = Buffer.byteLength(val, 'utf8');
+    const valBuf = ENCODER.encode(val);
+    const size = valBuf.byteLength;
     if (size + 1 > def.len) {
         return new ModifyError(def, val, `max length of ${def.len - 1},`);
     }
@@ -32,7 +34,8 @@ map[STRING] = (ctx, val, def) => {
         return RANGE_ERR;
     }
     ctx.buf[ctx.len++] = size;
-    ctx.len += ctx.buf.write(val, ctx.len, 'utf8');
+    ctx.buf.set(valBuf, ctx.len);
+    ctx.len += size;
 };
 map[BOOLEAN] = (ctx, val, def) => {
     if (ctx.len + 1 > ctx.max) {
@@ -69,7 +72,9 @@ map[NUMBER] = (ctx, val, def) => {
     if (ctx.len + 8 > ctx.max) {
         return RANGE_ERR;
     }
-    ctx.len = ctx.buf.writeDoubleLE(val, ctx.len);
+    const view = new DataView(ctx.buf.buffer, ctx.buf.byteOffset + ctx.len, 8);
+    ctx.len += 8;
+    view.setFloat64(0, val, true);
 };
 map[TIMESTAMP] = (ctx, val, def) => {
     const parsedValue = convertToTimestamp(val);
@@ -79,7 +84,9 @@ map[TIMESTAMP] = (ctx, val, def) => {
     if (ctx.len + 8 > ctx.max) {
         return RANGE_ERR;
     }
-    ctx.len = ctx.buf.writeDoubleLE(parsedValue, ctx.len);
+    const view = new DataView(ctx.buf.buffer, ctx.buf.byteOffset + ctx.len, 8);
+    ctx.len += 8;
+    view.setFloat64(0, parsedValue, true);
 };
 map[UINT32] = (ctx, val, def) => {
     if (typeof val !== 'number') {

package/dist/src/client/modify/references/appendRefs.d.ts

@@ -0,0 +1,4 @@
+import { PropDefEdge } from '@based/schema/def';
+import { ModifyCtx } from '../../flushModify.js';
+import { ModifyErr } from '../types.js';
+export declare function appendRefs(t: PropDefEdge, ctx: ModifyCtx, value: any[]): ModifyErr;

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

@@ -0,0 +1,27 @@
+import { ModifyState, ModifyError } from '../ModifyRes.js';
+export function appendRefs(t, ctx, value) {
+    for (let i = 0; i < value.length; i++) {
+        let id = value[i];
+        if (typeof id !== 'number') {
+            if (id instanceof ModifyState) {
+                if (id.error) {
+                    return id.error;
+                }
+                id = id.tmpId;
+            }
+            else {
+                return new ModifyError(t, value);
+            }
+        }
+        if (id > 0) {
+            ctx.buf[ctx.len++] = id;
+            ctx.buf[ctx.len++] = id >>>= 8;
+            ctx.buf[ctx.len++] = id >>>= 8;
+            ctx.buf[ctx.len++] = id >>>= 8;
+        }
+        else {
+            return new ModifyError(t, value);
+        }
+    }
+}
+//# sourceMappingURL=appendRefs.js.map

package/dist/src/client/modify/references/edge.d.ts

@@ -2,5 +2,4 @@ import { ModifyCtx } from '../../../index.js';
 import { PropDef } from '@based/schema/def';
 import { ModifyErr } from '../types.js';
 import { RefModifyOpts } from './references.js';
-export declare function getEdgeSize(t: PropDef, ref: RefModifyOpts): number;
 export declare function writeEdges(t: PropDef, ref: RefModifyOpts, ctx: ModifyCtx): ModifyErr;

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

@@ -1,65 +1,50 @@
-import { BINARY, CARDINALITY, REFERENCE, REFERENCES, STRING, } from '@based/schema/def';
+import { ENCODER } from '../../../index.js';
+import { BINARY, MICRO_BUFFER, 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';
+import { DECREMENT, INCREMENT, RANGE_ERR, UPDATE, UPDATE_PARTIAL, } from '../types.js';
 import { appendFixedValue } from '../fixed.js';
-export function getEdgeSize(t, ref) {
-    let size = 0;
-    for (const key in t.edges) {
-        if (key in ref) {
-            const edge = t.edges[key];
-            const value = ref[key];
-            if (edge.len === 0) {
-                if (edge.typeIndex === STRING) {
-                    size += Buffer.byteLength(value) + 4;
-                }
-                else if (edge.typeIndex === REFERENCE) {
-                    size += 4;
-                }
-                else if (edge.typeIndex === REFERENCES) {
-                    size += value.length * 4 + 4;
-                }
-            }
-            else {
-                size += edge.len;
-            }
-        }
-    }
-    return size;
-}
-function appendRefs(t, ctx, value) {
-    for (let i = 0; i < value.length; i++) {
-        let id = value[i];
-        if (typeof id !== 'number') {
-            if (id instanceof ModifyState) {
-                if (id.error) {
-                    return id.error;
-                }
-                id = id.tmpId;
-            }
-            else {
-                return new ModifyError(t, value);
-            }
-        }
-        if (id > 0) {
-            ctx.buf[ctx.len++] = id;
-            ctx.buf[ctx.len++] = id >>>= 8;
-            ctx.buf[ctx.len++] = id >>>= 8;
-            ctx.buf[ctx.len++] = id >>>= 8;
+import { appendRefs } from './appendRefs.js';
+function valueOperation(value) {
+    if (typeof value === 'object' && value !== null) {
+        if (value.increment > 0) {
+            return INCREMENT;
         }
-        else {
-            return new ModifyError(t, value);
+        else if (value.increment < 0) {
+            return DECREMENT;
         }
+        return 0;
     }
+    return UPDATE;
 }
+const EDGE_HEADER_SIZE = 5;
 export function writeEdges(t, ref, ctx) {
+    let mainFields;
+    let mainSize = 0;
+    let hasIncr = false;
     for (const key in t.edges) {
         if (key in ref) {
             const edge = t.edges[key];
             let value = ref[key];
-            if (edge.len === 0) {
+            if (edge.separate === true) {
+                if (ctx.len + 2 > ctx.max) {
+                    return RANGE_ERR;
+                }
+                ctx.buf[ctx.len++] = UPDATE;
+                ctx.buf[ctx.len++] = edge.prop;
+                /*
+                  Seperate fields:
+        
+                  | Offset  | Field       | Size (bytes)| Description                           |
+                  |---------|-------------|-------------|---------------------------------------|
+                  | 0       | modify op   | 1           | Modify operation identifier           |
+                  | 1       | prop        | 1           | Field identifier                      |
+                  | 2       | type        | 1           | Indicates MICRO_BUFFER type           |
+                  | 3       | size        | 4           | Size of the data in bytes             |
+                  | 7       | data        | Variable    | Content                               |
+                */
                 if (edge.typeIndex === BINARY) {
                     let size = 0;
                     if (value === null) {
@@ -72,10 +57,9 @@ export function writeEdges(t, ref, ctx) {
                         }
                         size = buf.byteLength;
                     }
-                    if (ctx.len + 6 + size > ctx.max) {
+                    if (ctx.len + EDGE_HEADER_SIZE + size > ctx.max) {
                         return RANGE_ERR;
                     }
-                    ctx.buf[ctx.len++] = edge.prop;
                     ctx.buf[ctx.len++] = STRING;
                     if (size) {
                         writeBinaryRaw(value, ctx);
@@ -91,10 +75,9 @@ export function writeEdges(t, ref, ctx) {
                     if (typeof value !== 'string') {
                         return new ModifyError(edge, value);
                     }
-                    if (ctx.len + 6 + Buffer.byteLength(value) > ctx.max) {
+                    if (ctx.len + EDGE_HEADER_SIZE + ENCODER.encode(value).byteLength > ctx.max) {
                         return RANGE_ERR;
                     }
-                    ctx.buf[ctx.len++] = edge.prop;
                     ctx.buf[ctx.len++] = STRING;
                     let size = write(ctx.buf, value, ctx.len + 4, edge.compression === 0);
                     let sizeU32 = size;
@@ -114,7 +97,6 @@ export function writeEdges(t, ref, ctx) {
                         }
                     }
                     if (value > 0) {
-                        ctx.buf[ctx.len++] = edge.prop;
                         ctx.buf[ctx.len++] = REFERENCE;
                         ctx.buf[ctx.len++] = value;
                         ctx.buf[ctx.len++] = value >>>= 8;
@@ -130,10 +112,9 @@ export function writeEdges(t, ref, ctx) {
                         return new ModifyError(edge, value);
                     }
                     let size = value.length * 4;
-                    if (ctx.len + 6 + size > ctx.max) {
+                    if (ctx.len + EDGE_HEADER_SIZE + size > ctx.max) {
                         return RANGE_ERR;
                     }
-                    ctx.buf[ctx.len++] = edge.prop;
                     ctx.buf[ctx.len++] = REFERENCES;
                     ctx.buf[ctx.len++] = size;
                     ctx.buf[ctx.len++] = size >>>= 8;
@@ -147,40 +128,179 @@ export function writeEdges(t, ref, ctx) {
                     }
                     const len = value.length;
                     let size = 4 + len * 8;
-                    if (ctx.len + size + 11 > ctx.max) {
+                    if (ctx.len + size + EDGE_HEADER_SIZE > 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) {
-                    return RANGE_ERR;
+                const op = valueOperation(value);
+                if (op === 0) {
+                    return new ModifyError(edge, value);
                 }
-                if (typeof value === 'object' && value !== null) {
-                    if (value.increment > 0) {
-                        ctx.buf[ctx.len++] = 0;
-                        ctx.buf[ctx.len++] = INCREMENT;
-                        value = value.increment;
+                if (op != UPDATE) {
+                    hasIncr = true;
+                    value = value.increment;
+                }
+                if (!hasIncr && t.edgeMainLen == edge.len) {
+                    /*
+                    Full main update:
+          
+                    | Offset  | Field       | Size (bytes)| Description                           |
+                    |---------|-------------|-------------|---------------------------------------|
+                    | 0       | modify op   | 1           | Modify operation identifier           |
+                    | 1       | prop        | 1           | Field identifier (0)                  |
+                    | 2       | type        | 1           | Indicates MICRO_BUFFER type           |
+                    | 3       | mainSize    | 4           | Size of the main data in bytes        |
+                    | 7       | main buffer | Variable    | Main data content                     |
+                    */
+                    if (ctx.len + 7 + edge.len > ctx.max) {
+                        return RANGE_ERR;
                     }
-                    else if (value.increment < 0) {
-                        ctx.buf[ctx.len++] = 0;
-                        ctx.buf[ctx.len++] = DECREMENT;
-                        value = -value.increment;
+                    ctx.buf[ctx.len++] = UPDATE;
+                    ctx.buf[ctx.len++] = 0;
+                    ctx.buf[ctx.len++] = MICRO_BUFFER;
+                    const size = edge.len;
+                    let sizeU32 = size;
+                    ctx.buf[ctx.len++] = sizeU32;
+                    ctx.buf[ctx.len++] = sizeU32 >>>= 8;
+                    ctx.buf[ctx.len++] = sizeU32 >>>= 8;
+                    ctx.buf[ctx.len++] = sizeU32 >>>= 8;
+                    const err = appendFixedValue(ctx, value, edge);
+                    if (err) {
+                        return err;
+                    }
+                }
+                else {
+                    mainSize += edge.len;
+                    if (!mainFields) {
+                        mainFields = [edge, value, op];
                     }
                     else {
-                        return new ModifyError(edge, value);
+                        const len = mainFields.length;
+                        for (let i = 0; i < len; i += 3) {
+                            if (edge.start < mainFields[i].start) {
+                                mainFields.splice(i, 0, edge, value, op);
+                                break;
+                            }
+                            else if (mainFields[len - i - 3].start < edge.start) {
+                                mainFields.splice(len - i, 0, edge, value, op);
+                                break;
+                            }
+                        }
                     }
                 }
-                ctx.buf[ctx.len++] = edge.prop;
-                ctx.buf[ctx.len++] = edge.typeIndex;
+            }
+        }
+    }
+    if (mainFields) {
+        // Single field in main buffer can immediately setup the main buffer
+        if (!hasIncr && mainSize === t.edgeMainLen) {
+            /*
+            Full main update:
+      
+            | Offset  | Field       | Size (bytes)| Description                           |
+            |---------|-------------|-------------|---------------------------------------|
+            | 0       | modify op   | 1           | Modify operation identifier           |
+            | 1       | prop        | 1           | Field identifier (0)                  |
+            | 2       | type        | 1           | Indicates MICRO_BUFFER type           |
+            | 3       | mainSize    | 4           | Size of the main data in bytes        |
+            | 7       | main buffer | Variable    | Main data content                     |
+            */
+            if (ctx.len + 7 + mainSize > ctx.max) {
+                return RANGE_ERR;
+            }
+            ctx.buf[ctx.len++] = UPDATE;
+            ctx.buf[ctx.len++] = 0;
+            ctx.buf[ctx.len++] = MICRO_BUFFER;
+            let sizeU32 = mainSize;
+            ctx.buf[ctx.len++] = sizeU32;
+            ctx.buf[ctx.len++] = sizeU32 >>>= 8;
+            ctx.buf[ctx.len++] = sizeU32 >>>= 8;
+            ctx.buf[ctx.len++] = sizeU32 >>>= 8;
+            for (let i = 0; i < mainFields.length; i += 3) {
+                const edge = mainFields[i];
+                const err = appendFixedValue(ctx, mainFields[i + 1], edge);
+                if (err) {
+                    return err;
+                }
+            }
+        }
+        else {
+            /*
+            Partial main update:
+      
+            | Offset  | Field       | Size (bytes)| Description                          |
+            |---------|-------------|-------------|--------------------------------------|
+            | 0       | modify op   | 1           | Modify operation identifier          |
+            | 1       | prop        | 1           | Field identifier (0 in this case)    |
+            | 2       | type        | 1           | Indicates MICRO_BUFFER type          |
+            | 3       | size        | 4           | Total size of the payload            |
+            | 7       | mainSize    | 2           | Length of the main data block        |
+            | 9       | start       | 2           | Start position of first section      |
+            | 11      | len         | 2           | Length of first section              |
+            | 12      | field op    | 1           | Field operation type e.g. INCREMENT  |
+            | 13      | propType    | 1           | Prop typeIndex                       |
+            | ...     | ...         | ...         | Additional (start, len) pairs        |
+            | X       | main        | len         | Actual main content                  |
+      
+            ### Notes:
+            - The number of `(start, len, operation)` pairs is not explicitly stored
+              but **derived** from the structure.
+            - Parsing logic must determine the end of pairs by computing:
+              `Pairs End Offset = (size - mainSize)`
+              Sections are processed until the `MAIN` data block begins.
+            */
+            const mainFieldsStartSize = mainFields.length * 2;
+            if (ctx.len + 7 + mainSize + mainFieldsStartSize > ctx.max) {
+                return RANGE_ERR;
+            }
+            ctx.buf[ctx.len++] = UPDATE_PARTIAL;
+            ctx.buf[ctx.len++] = 0;
+            ctx.buf[ctx.len++] = MICRO_BUFFER;
+            let sizeU32 = mainFieldsStartSize + t.edgeMainLen;
+            ctx.buf[ctx.len++] = sizeU32;
+            ctx.buf[ctx.len++] = sizeU32 >>>= 8;
+            ctx.buf[ctx.len++] = sizeU32 >>>= 8;
+            ctx.buf[ctx.len++] = sizeU32 >>>= 8;
+            let mainTotal = t.edgeMainLen;
+            ctx.buf[ctx.len++] = mainTotal;
+            ctx.buf[ctx.len++] = mainTotal >>>= 8;
+            // Index of start of fields
+            const sIndex = ctx.len;
+            ctx.len += mainFieldsStartSize;
+            // Add zeroes
+            ctx.buf.fill(0, ctx.len, ctx.len + t.edgeMainLen);
+            // Keep track of written bytes from append fixed
+            let writtenFields = 0;
+            // do this different...
+            let startMain = ctx.len;
+            for (let i = 0; i < mainFields.length; i += 3) {
+                const edge = mainFields[i];
+                const value = mainFields[i + 1];
+                const op = mainFields[i + 2];
+                const sIndexI = i + sIndex;
+                let start = edge.start;
+                ctx.buf[sIndexI] = start;
+                ctx.buf[sIndexI + 1] = start >>>= 8;
+                let len = edge.len;
+                ctx.buf[sIndexI + 2] = len;
+                ctx.buf[sIndexI + 3] = len >>>= 8;
+                ctx.buf[sIndexI + 4] = op;
+                ctx.buf[sIndexI + 5] = edge.typeIndex;
+                ctx.len = startMain + edge.start;
+                if (edge.start + edge.len > writtenFields) {
+                    writtenFields = edge.start + edge.len;
+                }
                 const err = appendFixedValue(ctx, value, edge);
                 if (err) {
                     return err;
                 }
             }
+            // Correction to reuse append fixed value
+            ctx.len += t.edgeMainLen - writtenFields;
         }
     }
 }

package/dist/src/client/modify/references/getEdgeSize.d.ts

@@ -0,0 +1,3 @@
+import { PropDef } from '@based/schema/def';
+import { RefModifyOpts } from './references.js';
+export declare function getEdgeSize(t: PropDef, ref: RefModifyOpts): number;

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

@@ -0,0 +1,27 @@
+import { STRING, REFERENCE, REFERENCES } from '@based/schema/def';
+import { ENCODER } from '../../../utils.js';
+export function getEdgeSize(t, ref) {
+    let size = 0;
+    for (const key in t.edges) {
+        if (key in ref) {
+            const edge = t.edges[key];
+            const value = ref[key];
+            if (edge.len === 0) {
+                if (edge.typeIndex === STRING) {
+                    size += ENCODER.encode(value).byteLength + 4;
+                }
+                else if (edge.typeIndex === REFERENCE) {
+                    size += 4;
+                }
+                else if (edge.typeIndex === REFERENCES) {
+                    size += value.length * 4 + 4;
+                }
+            }
+            else {
+                size += edge.len;
+            }
+        }
+    }
+    return size;
+}
+//# sourceMappingURL=getEdgeSize.js.map