@based/db 0.0.28 → 0.0.30

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

@@ -1,6 +1,6 @@
 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 { convertToTimestamp } from '@saulx/utils';
 import { getBuffer } from './binary.js';
 import { ModifyError } from './ModifyRes.js';
 import { RANGE_ERR } from './types.js';
@@ -10,6 +10,9 @@ map[BINARY] = (ctx, val, def) => {
     if (buf === undefined) {
         return new ModifyError(def, val);
     }
+    if (!def.validation(val, def)) {
+        return new ModifyError(def, val);
+    }
     const size = buf.byteLength;
     if (ctx.len + size + 1 > ctx.max) {
         return RANGE_ERR;
@@ -24,17 +27,27 @@ map[STRING] = (ctx, val, def) => {
     if (size + 1 > def.len) {
         return new ModifyError(def, val, `max length of ${def.len - 1},`);
     }
+    if (!def.validation(val, def)) {
+        return new ModifyError(def, val);
+    }
     if (ctx.len + size + 1 > ctx.max) {
         return RANGE_ERR;
     }
     ctx.buf[ctx.len++] = size;
     ctx.buf.set(valBuf, ctx.len);
-    ctx.len += size;
+    const fullSize = def.len - 1;
+    ctx.len += fullSize;
+    if (fullSize !== size) {
+        ctx.buf.fill(0, ctx.len - (fullSize - size), ctx.len);
+    }
 };
 map[BOOLEAN] = (ctx, val, def) => {
     if (ctx.len + 1 > ctx.max) {
         return RANGE_ERR;
     }
+    if (!def.validation(val, def)) {
+        return new ModifyError(def, val);
+    }
     if (val === null) {
         ctx.buf[ctx.len++] = 0;
     }
@@ -49,6 +62,9 @@ map[ENUM] = (ctx, val, def) => {
     if (ctx.len + 1 > ctx.max) {
         return RANGE_ERR;
     }
+    if (!def.validation(val, def)) {
+        return new ModifyError(def, val);
+    }
     if (val === null) {
         ctx.buf[ctx.len++] = 0;
     }
@@ -63,6 +79,9 @@ map[NUMBER] = (ctx, val, def) => {
     if (ctx.len + 8 > ctx.max) {
         return RANGE_ERR;
     }
+    if (!def.validation(val, def)) {
+        return new ModifyError(def, val);
+    }
     const view = new DataView(ctx.buf.buffer, ctx.buf.byteOffset + ctx.len, 8);
     ctx.len += 8;
     view.setFloat64(0, val, true);
@@ -72,14 +91,21 @@ map[TIMESTAMP] = (ctx, val, def) => {
     if (ctx.len + 8 > ctx.max) {
         return RANGE_ERR;
     }
+    if (!def.validation(parsedValue, def)) {
+        return new ModifyError(def, val);
+    }
     const view = new DataView(ctx.buf.buffer, ctx.buf.byteOffset + ctx.len, 8);
     ctx.len += 8;
     view.setFloat64(0, parsedValue, true);
+    const ts = view.getFloat64(0);
 };
 map[UINT32] = (ctx, val, def) => {
     if (ctx.len + 4 > ctx.max) {
         return RANGE_ERR;
     }
+    if (!def.validation(val, def)) {
+        return new ModifyError(def, val);
+    }
     ctx.buf[ctx.len++] = val;
     ctx.buf[ctx.len++] = val >>>= 8;
     ctx.buf[ctx.len++] = val >>>= 8;
@@ -89,6 +115,9 @@ map[UINT16] = (ctx, val, def) => {
     if (ctx.len + 2 > ctx.max) {
         return RANGE_ERR;
     }
+    if (!def.validation(val, def)) {
+        return new ModifyError(def, val);
+    }
     ctx.buf[ctx.len++] = val;
     ctx.buf[ctx.len++] = val >>>= 8;
 };
@@ -96,12 +125,18 @@ map[UINT8] = (ctx, val, def) => {
     if (ctx.len + 1 > ctx.max) {
         return RANGE_ERR;
     }
+    if (!def.validation(val, def)) {
+        return new ModifyError(def, val);
+    }
     ctx.buf[ctx.len++] = val;
 };
 map[INT32] = (ctx, val, def) => {
     if (ctx.len + 4 > ctx.max) {
         return RANGE_ERR;
     }
+    if (!def.validation(val, def)) {
+        return new ModifyError(def, val);
+    }
     ctx.buf[ctx.len++] = val;
     ctx.buf[ctx.len++] = val >>>= 8;
     ctx.buf[ctx.len++] = val >>>= 8;
@@ -111,6 +146,9 @@ map[INT16] = (ctx, val, def) => {
     if (ctx.len + 2 > ctx.max) {
         return RANGE_ERR;
     }
+    if (!def.validation(val, def)) {
+        return new ModifyError(def, val);
+    }
     ctx.buf[ctx.len++] = val;
     ctx.buf[ctx.len++] = val >>>= 8;
 };
@@ -118,12 +156,12 @@ map[INT8] = (ctx, val, def) => {
     if (ctx.len + 1 > ctx.max) {
         return RANGE_ERR;
     }
-    ctx.buf[ctx.len++] = val;
-};
-export const writeFixedValue = (ctx, val, def, pos) => {
     if (!def.validation(val, def)) {
         return new ModifyError(def, val);
     }
+    ctx.buf[ctx.len++] = val;
+};
+export const writeFixedValue = (ctx, val, def, pos) => {
     const len = ctx.len;
     ctx.len = pos;
     const res = map[def.typeIndex](ctx, val, def);
@@ -131,9 +169,6 @@ export const writeFixedValue = (ctx, val, def, pos) => {
     return res;
 };
 export const appendFixedValue = (ctx, val, def) => {
-    if (!def.validation(val, def)) {
-        return new ModifyError(def, val);
-    }
     return map[def.typeIndex](ctx, val, def);
 };
 //# sourceMappingURL=fixed.js.map

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

@@ -11,7 +11,6 @@ import { appendFixedValue, writeFixedValue } from './fixed.js';
 import { writeAlias } from './alias.js';
 import { writeHll } from './cardinality.js';
 import { writeVector } from './vector.js';
-import { checkSubscriptionMarkers } from '../query/subscription/index.js';
 import { writeJson } from './json.js';
 function _modify(ctx, res, obj, schema, mod, tree, overwrite, unsafe) {
     for (const key in obj) {
@@ -28,9 +27,6 @@ function _modify(ctx, res, obj, schema, mod, tree, overwrite, unsafe) {
             if (val === undefined) {
                 continue;
             }
-            if (res.subMarkers) {
-                checkSubscriptionMarkers(ctx.db, res.subMarkers, def);
-            }
             const type = def.typeIndex;
             if (def.separate) {
                 if (type === STRING) {
@@ -77,7 +73,6 @@ function _modify(ctx, res, obj, schema, mod, tree, overwrite, unsafe) {
                     ctx.lastMain = ctx.len;
                     ctx.buf.set(schema.mainEmpty, ctx.len);
                     ctx.len += schema.mainLen;
-                    // ctx.buf.fill(0, ctx.len, (ctx.len += schema.mainLen))
                 }
                 if (typeof val === 'object' && val !== null && 'increment' in val) {
                     err = writeFixedValue(ctx, val.increment, def, ctx.lastMain + def.start);

package/dist/src/client/modify/references/{appendRefs.d.ts → appendEdgeRefs.d.ts}

@@ -1,4 +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;
+export declare function appendEdgeRefs(t: PropDefEdge, ctx: ModifyCtx, value: any[]): ModifyErr;

package/dist/src/client/modify/references/{appendRefs.js → appendEdgeRefs.js}

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

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

@@ -6,7 +6,7 @@ import { getBuffer, writeBinaryRaw } from '../binary.js';
 import { ModifyError, ModifyState } from '../ModifyRes.js';
 import { DECREMENT, INCREMENT, RANGE_ERR, UPDATE, UPDATE_PARTIAL, } from '../types.js';
 import { appendFixedValue } from '../fixed.js';
-import { appendRefs } from './appendRefs.js';
+import { appendEdgeRefs } from './appendEdgeRefs.js';
 function valueOperation(value) {
     if (typeof value === 'object' && value !== null) {
         if (value.increment > 0) {
@@ -24,172 +24,194 @@ 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.separate === true) {
-                if (ctx.len + 2 > ctx.max) {
-                    return RANGE_ERR;
+    for (const key in ref) {
+        if (key === 'id' || key === '$index') {
+            continue;
+        }
+        const edge = t.edges?.[key];
+        if (!edge) {
+            return new ModifyError(t, key, `Does not exist`);
+        }
+        let value = ref[key];
+        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;
+                // add null
+                if (value === null) {
+                    size = 0;
                 }
-                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) {
-                        size = 0;
-                    }
-                    else {
-                        const buf = getBuffer(value);
-                        if (!buf) {
-                            return new ModifyError(edge, value);
-                        }
-                        size = buf.byteLength;
-                    }
-                    if (ctx.len + EDGE_HEADER_SIZE + size > ctx.max) {
-                        return RANGE_ERR;
-                    }
-                    ctx.buf[ctx.len++] = STRING;
-                    if (size) {
-                        writeBinaryRaw(value, ctx);
-                    }
-                    else {
-                        ctx.buf[ctx.len++] = 0;
-                        ctx.buf[ctx.len++] = 0;
-                        ctx.buf[ctx.len++] = 0;
-                        ctx.buf[ctx.len++] = 0;
+                else {
+                    const buf = getBuffer(value);
+                    if (!buf || !edge.validation(buf, edge)) {
+                        return new ModifyError(edge, value);
                     }
+                    size = buf.byteLength;
+                    value = buf;
+                }
+                if (ctx.len + EDGE_HEADER_SIZE + size > ctx.max) {
+                    return RANGE_ERR;
+                }
+                ctx.buf[ctx.len++] = STRING;
+                if (size) {
+                    writeBinaryRaw(value, ctx);
+                }
+                else {
+                    ctx.buf[ctx.len++] = 0;
+                    ctx.buf[ctx.len++] = 0;
+                    ctx.buf[ctx.len++] = 0;
+                    ctx.buf[ctx.len++] = 0;
                 }
-                else if (edge.typeIndex === STRING) {
-                    if (typeof value !== 'string') {
+            }
+            else if (edge.typeIndex === STRING) {
+                let size = 0;
+                // add null
+                if (value !== null) {
+                    if (!edge.validation(value, edge)) {
                         return new ModifyError(edge, value);
                     }
-                    if (ctx.len + EDGE_HEADER_SIZE + ENCODER.encode(value).byteLength >
-                        ctx.max) {
+                    const isBuffer = value instanceof Uint8Array;
+                    size = isBuffer
+                        ? value.byteLength
+                        : ENCODER.encode(value).byteLength + 6;
+                    if (ctx.len + EDGE_HEADER_SIZE + size > ctx.max) {
                         return RANGE_ERR;
                     }
                     ctx.buf[ctx.len++] = STRING;
-                    let size = write(ctx.buf, value, ctx.len + 4, edge.compression === 0);
-                    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;
-                    ctx.len += size;
+                    size = write(ctx.buf, value, ctx.len + 4, edge.compression === 0);
                 }
-                else if (edge.typeIndex === REFERENCE) {
-                    if (typeof value !== 'number') {
-                        if (value instanceof ModifyState) {
-                            value = value.tmpId;
-                        }
-                        else {
-                            return new ModifyError(edge, value);
-                        }
-                    }
-                    if (value > 0) {
-                        ctx.buf[ctx.len++] = REFERENCE;
-                        ctx.buf[ctx.len++] = value;
-                        ctx.buf[ctx.len++] = value >>>= 8;
-                        ctx.buf[ctx.len++] = value >>>= 8;
-                        ctx.buf[ctx.len++] = value >>>= 8;
+                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;
+                ctx.len += size;
+            }
+            else if (edge.typeIndex === REFERENCE) {
+                // add null
+                if (typeof value !== 'number') {
+                    if (value instanceof ModifyState) {
+                        value = value.tmpId;
                     }
                     else {
                         return new ModifyError(edge, value);
                     }
                 }
-                else if (edge.typeIndex === REFERENCES) {
-                    if (!Array.isArray(value)) {
-                        return new ModifyError(edge, value);
-                    }
-                    let size = value.length * 4;
-                    if (ctx.len + EDGE_HEADER_SIZE + size > ctx.max) {
-                        return RANGE_ERR;
-                    }
-                    ctx.buf[ctx.len++] = REFERENCES;
-                    ctx.buf[ctx.len++] = size;
-                    ctx.buf[ctx.len++] = size >>>= 8;
-                    ctx.buf[ctx.len++] = size >>>= 8;
-                    ctx.buf[ctx.len++] = size >>>= 8;
-                    appendRefs(edge, ctx, value);
+                if (!edge.validation(value, edge)) {
+                    return new ModifyError(edge, 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 + EDGE_HEADER_SIZE > ctx.max) {
-                        return RANGE_ERR;
-                    }
-                    ctx.buf[ctx.len++] = CARDINALITY;
-                    writeHllBuf(value, ctx, edge, size);
+                if (value > 0) {
+                    ctx.buf[ctx.len++] = REFERENCE;
+                    ctx.buf[ctx.len++] = value;
+                    ctx.buf[ctx.len++] = value >>>= 8;
+                    ctx.buf[ctx.len++] = value >>>= 8;
+                    ctx.buf[ctx.len++] = value >>>= 8;
+                }
+                else {
+                    return new ModifyError(edge, value);
                 }
             }
-            else {
-                const op = valueOperation(value);
-                if (op === 0) {
+            else if (edge.typeIndex === REFERENCES) {
+                // add null
+                if (!Array.isArray(value)) {
                     return new ModifyError(edge, value);
                 }
-                if (op != UPDATE) {
-                    hasIncr = true;
-                    value = value.increment;
+                let size = value.length * 4;
+                if (ctx.len + EDGE_HEADER_SIZE + size > ctx.max) {
+                    return RANGE_ERR;
                 }
-                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;
-                    }
-                    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;
-                    }
+                ctx.buf[ctx.len++] = REFERENCES;
+                ctx.buf[ctx.len++] = size;
+                ctx.buf[ctx.len++] = size >>>= 8;
+                ctx.buf[ctx.len++] = size >>>= 8;
+                ctx.buf[ctx.len++] = size >>>= 8;
+                const err = appendEdgeRefs(edge, ctx, value);
+                if (err) {
+                    return err;
+                }
+            }
+            else if (edge.typeIndex === CARDINALITY) {
+                // add null
+                if (!Array.isArray(value)) {
+                    value = [value];
+                }
+                const len = value.length;
+                let size = 4 + len * 8;
+                if (ctx.len + size + EDGE_HEADER_SIZE > ctx.max) {
+                    return RANGE_ERR;
+                }
+                ctx.buf[ctx.len++] = CARDINALITY;
+                writeHllBuf(value, ctx, edge, size);
+            }
+        }
+        else {
+            const op = valueOperation(value);
+            if (op === 0) {
+                return new ModifyError(edge, value);
+            }
+            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;
+                }
+                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 {
-                    mainSize += edge.len;
-                    if (!mainFields) {
-                        mainFields = [edge, value, op];
-                    }
-                    else {
-                        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;
-                            }
+                    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;
                         }
                     }
                 }
@@ -246,13 +268,6 @@ export function writeEdges(t, ref, ctx) {
             | 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) {
@@ -261,48 +276,40 @@ export function writeEdges(t, ref, ctx) {
             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;
+            const size = mainFieldsStartSize + t.edgeMainLen;
+            ctx.buf[ctx.len++] = size;
+            ctx.buf[ctx.len++] = size >>> 8;
+            ctx.buf[ctx.len++] = size >>> 16;
+            ctx.buf[ctx.len++] = size >>> 24;
+            ctx.buf[ctx.len++] = t.edgeMainLen;
+            ctx.buf[ctx.len++] = t.edgeMainLen >>> 8;
             // Index of start of fields
             const sIndex = ctx.len;
             ctx.len += mainFieldsStartSize;
-            // this has to be replaced
             // 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;
+                const sIndexI = i * 2 + sIndex;
+                ctx.buf[sIndexI] = edge.start;
+                ctx.buf[sIndexI + 1] = edge.start >>> 8;
+                ctx.buf[sIndexI + 2] = edge.len;
+                ctx.buf[sIndexI + 3] = edge.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;
-                }
+                // Add null support (defaults)
                 const err = appendFixedValue(ctx, value, edge);
                 if (err) {
                     return err;
                 }
             }
-            // Correction to reuse append fixed value
-            ctx.len += t.edgeMainLen - writtenFields;
+            // Correction append fixed value writes the len
+            ctx.len = startMain + t.edgeMainLen;
         }
     }
 }