@colyseus/schema 3.0.0-alpha.40 → 3.0.0-alpha.41

package/src/codegen/languages/csharp.ts

@@ -59,16 +59,9 @@ function generateClass(klass: Class, namespace: string) {
     return `${getCommentHeader()}
 
 using Colyseus.Schema;
-using Action = System.Action;
 ${namespace ? `\nnamespace ${namespace} {` : ""}
 ${indent}public partial class ${klass.name} : ${klass.extends} {
 ${klass.properties.map((prop) => generateProperty(prop, indent)).join("\n\n")}
-
-${indent}\t/*
-${indent}\t * Support for individual property change callbacks below...
-${indent}\t */
-
-${generateAllFieldCallbacks(klass, indent)}
 ${indent}}
 ${namespace ? "}" : ""}
 `;
@@ -119,7 +112,7 @@ function generateProperty(prop: Property, indent: string = "") {
             typeArgs += `, "${prop.childType}"`;
         }
 
-        initializer = `new ${langType}()`;
+        initializer = `null`;
 
     } else {
         langType = getType(prop);
@@ -147,45 +140,6 @@ ${namespace ? "}" : ""}
 `;
 }
 
-function generateAllFieldCallbacks(klass: Class, indent: string) {
-    //
-    // TODO: improve me. It would be great to generate less boilerplate in favor
-    // of a single implementation on C# Schema class itself.
-    //
-    const eventNames: string[] = [];
-    return `${klass.properties
-        .filter(prop => !prop.deprecated) // generate only for properties that haven't been deprecated.
-        .map(prop => {
-        const eventName = `__${prop.name}Change`;
-        eventNames.push(eventName);
-
-        const defaultNull = (prop.childType)
-            ? "null"
-            : `default(${getType(prop)})`;
-
-        return `\t${indent}protected event PropertyChangeHandler<${getType(prop)}> ${eventName};
-\t${indent}public Action On${capitalize(prop.name)}Change(PropertyChangeHandler<${getType(prop)}> __handler, bool __immediate = true) {
-\t${indent}\tif (__callbacks == null) { __callbacks = new SchemaCallbacks(); }
-\t${indent}\t__callbacks.AddPropertyCallback(nameof(this.${prop.name}));
-\t${indent}\t${eventName} += __handler;
-\t${indent}\tif (__immediate && this.${prop.name} != ${defaultNull}) { __handler(this.${prop.name}, ${defaultNull}); }
-\t${indent}\treturn () => {
-\t${indent}\t\t__callbacks.RemovePropertyCallback(nameof(${prop.name}));
-\t${indent}\t\t${eventName} -= __handler;
-\t${indent}\t};
-\t${indent}}`;
-    }).join("\n\n")}
-
-\t${indent}protected override void TriggerFieldChange(DataChange change) {
-\t${indent}\tswitch (change.Field) {
-${klass.properties.filter(prop => !prop.deprecated).map((prop, i) => {
-    return `\t${indent}\t\tcase nameof(${prop.name}): ${eventNames[i]}?.Invoke((${getType(prop)}) change.Value, (${getType(prop)}) change.PreviousValue); break;`;
-}).join("\n")}
-\t${indent}\t\tdefault: break;
-\t\t${indent}}
-\t${indent}}`;
-}
-
 function getChildType(prop: Property) {
     return typeMaps[prop.childType];
 }

package/src/decoder/DecodeOperation.ts

@@ -3,7 +3,7 @@ import { Metadata } from "../Metadata";
 import { Schema } from "../Schema";
 import type { Ref } from "../encoder/ChangeTree";
 import type { Decoder } from "./Decoder";
-import * as decode from "../encoding/decode";
+import { Iterator, decode } from "../encoding/decode";
 import { $childType, $deleteByIndex, $getByIndex } from "../types/symbols";
 
 import type { MapSchema } from "../types/custom/MapSchema";
@@ -28,7 +28,7 @@ export const DEFINITION_MISMATCH = -1;
 export type DecodeOperation<T extends Schema = any> = (
     decoder: Decoder<T>,
     bytes: Buffer,
-    it: decode.Iterator,
+    it: Iterator,
     ref: Ref,
     allChanges: DataChange[],
 ) => number | void;
@@ -40,7 +40,7 @@ export function decodeValue(
     index: number,
     type: any,
     bytes: Buffer,
-    it: decode.Iterator,
+    it: Iterator,
     allChanges: DataChange[],
 ) {
     const $root = decoder.root;
@@ -176,7 +176,7 @@ export function decodeValue(
 export const decodeSchemaOperation: DecodeOperation = function (
     decoder: Decoder<any>,
     bytes: Buffer,
-    it: decode.Iterator,
+    it: Iterator,
     ref: Ref,
     allChanges: DataChange[],
 ) {
@@ -225,7 +225,7 @@ export const decodeSchemaOperation: DecodeOperation = function (
 export const decodeKeyValueOperation: DecodeOperation = function (
     decoder: Decoder<any>,
     bytes: Buffer,
-    it: decode.Iterator,
+    it: Iterator,
     ref: Ref,
     allChanges: DataChange[]
 ) {
@@ -309,7 +309,7 @@ export const decodeKeyValueOperation: DecodeOperation = function (
 export const decodeArray: DecodeOperation = function (
     decoder: Decoder<any>,
     bytes: Buffer,
-    it: decode.Iterator,
+    it: Iterator,
     ref: ArraySchema,
     allChanges: DataChange[]
 ) {

package/src/decoder/Decoder.ts

@@ -2,7 +2,7 @@ import { TypeContext } from "../types/TypeContext";
 import { $changes, $childType, $decoder, $onDecodeEnd } from "../types/symbols";
 import { Schema } from "../Schema";
 
-import * as decode from "../encoding/decode";
+import { decode } from "../encoding/decode";
 import { OPERATION, SWITCH_TO_STRUCTURE, TYPE_ID } from '../encoding/spec';
 import type { Ref } from "../encoder/ChangeTree";
 import type { Iterator } from "../encoding/decode";
@@ -82,9 +82,9 @@ export class Decoder<T extends Schema = any> {
                 // keep skipping next bytes until reaches a known structure
                 // by local decoder.
                 //
-                const nextIterator: decode.Iterator = { offset: it.offset };
+                const nextIterator: Iterator = { offset: it.offset };
                 while (it.offset < totalBytes) {
-                    if (decode.switchStructureCheck(bytes, it)) {
+                    if (bytes[it.offset] === SWITCH_TO_STRUCTURE) {
                         nextIterator.offset = it.offset + 1;
                         if ($root.refs.has(decode.number(bytes, nextIterator))) {
                             break;

package/src/encoder/EncodeOperation.ts

@@ -1,7 +1,7 @@
 import { OPERATION } from "../encoding/spec";
 import { $changes, $childType, $getByIndex } from "../types/symbols";
 
-import * as encode from "../encoding/encode";
+import { encode } from "../encoding/encode";
 
 import type { ChangeTree, Ref } from "./ChangeTree";
 import type { Encoder } from "./Encoder";

package/src/encoder/Encoder.ts

@@ -2,7 +2,7 @@ import type { Schema } from "../Schema";
 import { TypeContext } from "../types/TypeContext";
 import { $changes, $encoder, $filter, $onEncodeEnd } from "../types/symbols";
 
-import * as encode from "../encoding/encode";
+import { encode } from "../encoding/encode";
 import type { Iterator } from "../encoding/decode";
 
 import { OPERATION, SWITCH_TO_STRUCTURE, TYPE_ID } from '../encoding/spec';

package/src/encoding/assert.ts

@@ -1,8 +1,8 @@
-import { Schema } from "../Schema";
-import { CollectionSchema } from "../types/custom/CollectionSchema";
-import { MapSchema } from "../types/custom/MapSchema";
-import { SetSchema } from "../types/custom/SetSchema";
-import { ArraySchema } from "../types/custom/ArraySchema";
+import type { Schema } from "../Schema";
+import type { CollectionSchema } from "../types/custom/CollectionSchema";
+import type { MapSchema } from "../types/custom/MapSchema";
+import type { SetSchema } from "../types/custom/SetSchema";
+import type { ArraySchema } from "../types/custom/ArraySchema";
 import type { Ref } from "../encoder/ChangeTree";
 
 export class EncodeSchemaError extends Error {}
@@ -28,6 +28,10 @@ export function assertType(value: any, type: string, klass: Schema, field: strin
                 console.log(`trying to encode "NaN" in ${klass.constructor.name}#${field}`);
             }
             break;
+        case "bigint64":
+        case "biguint64":
+            typeofTarget = "bigint";
+            break;
         case "string":
             typeofTarget = "string";
             allowNull = true;
@@ -35,6 +39,10 @@ export function assertType(value: any, type: string, klass: Schema, field: strin
         case "boolean":
             // boolean is always encoded as true/false based on truthiness
             return;
+        default:
+            // skip assertion for custom types
+            // TODO: allow custom types to define their own assertions
+            return;
     }
 
     if (typeof (value) !== typeofTarget && (!allowNull || (allowNull && value !== null))) {

package/src/encoding/decode.ts

@@ -21,7 +21,6 @@
  * SOFTWARE
  */
 
-import { SWITCH_TO_STRUCTURE } from "./spec";
 import type { BufferLike } from "./encode";
 
 /**
@@ -31,7 +30,17 @@ import type { BufferLike } from "./encode";
 
 export interface Iterator { offset: number; }
 
-export function utf8Read(bytes: BufferLike, it: Iterator, length: number) {
+// force little endian to facilitate decoding on multiple implementations
+const _isLittleEndian = true;  // new Uint16Array(new Uint8Array([1, 0]).buffer)[0] === 1;
+const _convoBuffer = new ArrayBuffer(8);
+
+const _int32 = new Int32Array(_convoBuffer);
+const _float32 = new Float32Array(_convoBuffer);
+const _float64 = new Float64Array(_convoBuffer);
+const _uint64 = new BigUint64Array(_convoBuffer);
+const _int64 = new BigInt64Array(_convoBuffer);
+
+function utf8Read(bytes: BufferLike, it: Iterator, length: number) {
   var string = '', chr = 0;
   for (var i = it.offset, end = it.offset + length; i < end; i++) {
     var byte = bytes[i];
@@ -76,72 +85,70 @@ export function utf8Read(bytes: BufferLike, it: Iterator, length: number) {
   return string;
 }
 
-export function int8 (bytes: BufferLike, it: Iterator) {
+function int8 (bytes: BufferLike, it: Iterator) {
     return uint8(bytes, it) << 24 >> 24;
 };
 
-export function uint8 (bytes: BufferLike, it: Iterator) {
+function uint8 (bytes: BufferLike, it: Iterator) {
     return bytes[it.offset++];
 };
 
-export function int16 (bytes: BufferLike, it: Iterator) {
+function int16 (bytes: BufferLike, it: Iterator) {
     return uint16(bytes, it) << 16 >> 16;
 };
 
-export function uint16 (bytes: BufferLike, it: Iterator) {
+function uint16 (bytes: BufferLike, it: Iterator) {
     return bytes[it.offset++] | bytes[it.offset++] << 8;
 };
 
-export function int32 (bytes: BufferLike, it: Iterator) {
+function int32 (bytes: BufferLike, it: Iterator) {
     return bytes[it.offset++] | bytes[it.offset++] << 8 | bytes[it.offset++] << 16 | bytes[it.offset++] << 24;
 };
 
-export function uint32 (bytes: BufferLike, it: Iterator) {
+function uint32 (bytes: BufferLike, it: Iterator) {
     return int32(bytes, it) >>> 0;
 };
 
-export function float32(bytes: BufferLike, it: Iterator) {
-  return readFloat32(bytes, it);
-}
+function float32 (bytes: BufferLike, it: Iterator) {
+    _int32[0] = int32(bytes, it);
+    return _float32[0];
+};
 
-export function float64(bytes: BufferLike, it: Iterator) {
-  return readFloat64(bytes, it);
-}
+function float64 (bytes: BufferLike, it: Iterator) {
+    _int32[_isLittleEndian ? 0 : 1] = int32(bytes, it);
+    _int32[_isLittleEndian ? 1 : 0] = int32(bytes, it);
+    return _float64[0];
+};
 
-export function int64(bytes: BufferLike, it: Iterator) {
+function int64(bytes: BufferLike, it: Iterator) {
   const low = uint32(bytes, it);
   const high = int32(bytes, it) * Math.pow(2, 32);
   return high + low;
 };
 
-export function uint64(bytes: BufferLike, it: Iterator) {
-  const low = uint32(bytes, it);
-  const high = uint32(bytes, it) * Math.pow(2, 32);
-  return high + low;
+function uint64(bytes: BufferLike, it: Iterator) {
+    const low = uint32(bytes, it);
+    const high = uint32(bytes, it) * Math.pow(2, 32);
+    return high + low;
 };
 
-// force little endian to facilitate decoding on multiple implementations
-const _isLittleEndian = true;  // new Uint16Array(new Uint8Array([1, 0]).buffer)[0] === 1;
-const _int32 = new Int32Array(2);
-const _float32 = new Float32Array(_int32.buffer);
-const _float64 = new Float64Array(_int32.buffer);
-
-export function readFloat32 (bytes: BufferLike, it: Iterator) {
+function bigint64(bytes: BufferLike, it: Iterator) {
     _int32[0] = int32(bytes, it);
-    return _float32[0];
-};
+    _int32[1] = int32(bytes, it);
+    return _int64[0];
+}
 
-export function readFloat64 (bytes: BufferLike, it: Iterator) {
-    _int32[_isLittleEndian ? 0 : 1] = int32(bytes, it);
-    _int32[_isLittleEndian ? 1 : 0] = int32(bytes, it);
-    return _float64[0];
-};
+function biguint64(bytes: BufferLike, it: Iterator) {
+    _int32[0] = int32(bytes, it);
+    _int32[1] = int32(bytes, it);
+    return _uint64[0];
+}
 
-export function boolean (bytes: BufferLike, it: Iterator) {
+function boolean (bytes: BufferLike, it: Iterator) {
     return uint8(bytes, it) > 0;
 };
 
-export function string (bytes: BufferLike, it: Iterator) {
+function string (bytes: BufferLike, it: Iterator) {
   const prefix = bytes[it.offset++];
   let length: number;
 
@@ -162,21 +169,7 @@ export function string (bytes: BufferLike, it: Iterator) {
   return utf8Read(bytes, it, length);
 }
 
-export function stringCheck(bytes: BufferLike, it: Iterator) {
-  const prefix = bytes[it.offset];
-  return (
-    // fixstr
-    (prefix < 0xc0 && prefix > 0xa0) ||
-    // str 8
-    prefix === 0xd9 ||
-    // str 16
-    prefix === 0xda ||
-    // str 32
-    prefix === 0xdb
-  );
-}
-
-export function number (bytes: BufferLike, it: Iterator) {
+function number (bytes: BufferLike, it: Iterator) {
   const prefix = bytes[it.offset++];
 
   if (prefix < 0x80) {
@@ -185,11 +178,11 @@ export function number (bytes: BufferLike, it: Iterator) {
 
   } else if (prefix === 0xca) {
     // float 32
-    return readFloat32(bytes, it);
+    return float32(bytes, it);
 
   } else if (prefix === 0xcb) {
     // float 64
-    return readFloat64(bytes, it);
+    return float64(bytes, it);
 
   } else if (prefix === 0xcc) {
     // uint 8
@@ -229,49 +222,21 @@ export function number (bytes: BufferLike, it: Iterator) {
   }
 };
 
-export function numberCheck (bytes: BufferLike, it: Iterator) {
-  const prefix = bytes[it.offset];
-  // positive fixint - 0x00 - 0x7f
-  // float 32        - 0xca
-  // float 64        - 0xcb
-  // uint 8          - 0xcc
-  // uint 16         - 0xcd
-  // uint 32         - 0xce
-  // uint 64         - 0xcf
-  // int 8           - 0xd0
-  // int 16          - 0xd1
-  // int 32          - 0xd2
-  // int 64          - 0xd3
-  return (
-    prefix < 0x80 ||
-    (prefix >= 0xca && prefix <= 0xd3)
-  );
-}
-
-export function arrayCheck (bytes: BufferLike, it: Iterator) {
-  return bytes[it.offset] < 0xa0;
-
-  // const prefix = bytes[it.offset] ;
-
-  // if (prefix < 0xa0) {
-  //   return prefix;
-
-  // // array
-  // } else if (prefix === 0xdc) {
-  //   it.offset += 2;
-
-  // } else if (0xdd) {
-  //   it.offset += 4;
-  // }
-
-  // return prefix;
-}
-
-export function switchStructureCheck(bytes: BufferLike, it: Iterator) {
-  return (
-      // previous byte should be `SWITCH_TO_STRUCTURE`
-      bytes[it.offset - 1] === SWITCH_TO_STRUCTURE &&
-      // next byte should be a number
-      (bytes[it.offset] < 0x80 || (bytes[it.offset] >= 0xca && bytes[it.offset] <= 0xd3))
-  );
+export const decode = {
+    utf8Read,
+    int8,
+    uint8,
+    int16,
+    uint16,
+    int32,
+    uint32,
+    float32,
+    float64,
+    int64,
+    uint64,
+    bigint64,
+    biguint64,
+    boolean,
+    string,
+    number,
 }

package/src/encoding/encode.ts

@@ -35,9 +35,17 @@ let textEncoder: TextEncoder;
 // @ts-ignore
 try { textEncoder = new TextEncoder(); } catch (e) { }
 
+// force little endian to facilitate decoding on multiple implementations
+const _isLittleEndian = true;  // new Uint16Array(new Uint8Array([1, 0]).buffer)[0] === 1;
+const _convoBuffer = new ArrayBuffer(8);
+const _int32 = new Int32Array(_convoBuffer);
+const _float32 = new Float32Array(_convoBuffer);
+const _float64 = new Float64Array(_convoBuffer);
+const _int64 = new BigInt64Array(_convoBuffer);
+
 const hasBufferByteLength = (typeof Buffer !== 'undefined' && Buffer.byteLength);
 
-export const utf8Length: (str: string, _?: any) => number = (hasBufferByteLength)
+const utf8Length: (str: string, _?: any) => number = (hasBufferByteLength)
     ? Buffer.byteLength // node
     : function (str: string, _?: any) {
         var c = 0, length = 0;
@@ -60,7 +68,7 @@ export const utf8Length: (str: string, _?: any) => number = (hasBufferByteLength
         return length;
     }
 
-export function utf8Write(view: BufferLike, str: string, it: Iterator) {
+function utf8Write(view: BufferLike, str: string, it: Iterator) {
   var c = 0;
   for (var i = 0, l = str.length; i < l; i++) {
     c = str.charCodeAt(i);
@@ -90,32 +98,32 @@ export function utf8Write(view: BufferLike, str: string, it: Iterator) {
   }
 }
 
-export function int8(bytes: BufferLike, value: number, it: Iterator) {
+function int8(bytes: BufferLike, value: number, it: Iterator) {
     bytes[it.offset++] = value & 255;
 };
 
-export function uint8(bytes: BufferLike, value: number, it: Iterator) {
+function uint8(bytes: BufferLike, value: number, it: Iterator) {
     bytes[it.offset++] = value & 255;
 };
 
-export function int16(bytes: BufferLike, value: number, it: Iterator) {
+function int16(bytes: BufferLike, value: number, it: Iterator) {
     bytes[it.offset++] = value & 255;
     bytes[it.offset++] = (value >> 8) & 255;
 };
 
-export function uint16(bytes: BufferLike, value: number, it: Iterator) {
+function uint16(bytes: BufferLike, value: number, it: Iterator) {
     bytes[it.offset++] = value & 255;
     bytes[it.offset++] = (value >> 8) & 255;
 };
 
-export function int32(bytes: BufferLike, value: number, it: Iterator) {
+function int32(bytes: BufferLike, value: number, it: Iterator) {
   bytes[it.offset++] = value & 255;
   bytes[it.offset++] = (value >> 8) & 255;
   bytes[it.offset++] = (value >> 16) & 255;
   bytes[it.offset++] = (value >> 24) & 255;
 };
 
-export function uint32(bytes: BufferLike, value: number, it: Iterator) {
+function uint32(bytes: BufferLike, value: number, it: Iterator) {
   const b4 = value >> 24;
   const b3 = value >> 16;
   const b2 = value >> 8;
@@ -126,50 +134,48 @@ export function uint32(bytes: BufferLike, value: number, it: Iterator) {
   bytes[it.offset++] = b4 & 255;
 };
 
-export function int64(bytes: BufferLike, value: number, it: Iterator) {
+function int64(bytes: BufferLike, value: number, it: Iterator) {
   const high = Math.floor(value / Math.pow(2, 32));
   const low = value >>> 0;
   uint32(bytes, low, it);
   uint32(bytes, high, it);
 };
 
-export function uint64(bytes: BufferLike, value: number, it: Iterator) {
+function uint64(bytes: BufferLike, value: number, it: Iterator) {
   const high = (value / Math.pow(2, 32)) >> 0;
   const low = value >>> 0;
   uint32(bytes, low, it);
   uint32(bytes, high, it);
 };
 
-export function float32(bytes: BufferLike, value: number, it: Iterator) {
-  writeFloat32(bytes, value, it);
+function bigint64(bytes: BufferLike, value: bigint, it: Iterator) {
+    _int64[0] = BigInt.asIntN(64, value);
+    int32(bytes, _int32[0], it);
+    int32(bytes, _int32[1], it);
 }
 
-export function float64(bytes: BufferLike, value: number, it: Iterator) {
-  writeFloat64(bytes, value, it);
+function biguint64(bytes: BufferLike, value: bigint, it: Iterator) {
+    _int64[0] = BigInt.asIntN(64, value);
+    int32(bytes, _int32[0], it);
+    int32(bytes, _int32[1], it);
 }
 
-// force little endian to facilitate decoding on multiple implementations
-const _isLittleEndian = true;  // new Uint16Array(new Uint8Array([1, 0]).buffer)[0] === 1;
-const _int32 = new Int32Array(2);
-const _float32 = new Float32Array(_int32.buffer);
-const _float64 = new Float64Array(_int32.buffer);
-
-export function writeFloat32(bytes: BufferLike, value: number, it: Iterator) {
+function float32(bytes: BufferLike, value: number, it: Iterator) {
   _float32[0] = value;
   int32(bytes, _int32[0], it);
-};
+}
 
-export function writeFloat64(bytes: BufferLike, value: number, it: Iterator) {
+function float64(bytes: BufferLike, value: number, it: Iterator) {
   _float64[0] = value;
   int32(bytes, _int32[_isLittleEndian ? 0 : 1], it);
   int32(bytes, _int32[_isLittleEndian ? 1 : 0], it);
-};
+}
 
-export function boolean(bytes: BufferLike, value: number, it: Iterator) {
+function boolean(bytes: BufferLike, value: number, it: Iterator) {
   bytes[it.offset++] = value ? 1 : 0; // uint8
 };
 
-export function string(bytes: BufferLike, value: string, it: Iterator) {
+function string(bytes: BufferLike, value: string, it: Iterator) {
   // encode `null` strings as empty.
   if (!value) { value = ""; }
 
@@ -207,7 +213,7 @@ export function string(bytes: BufferLike, value: string, it: Iterator) {
   return size + length;
 }
 
-export function number(bytes: BufferLike, value: number, it: Iterator) {
+function number(bytes: BufferLike, value: number, it: Iterator) {
   if (isNaN(value)) {
     return number(bytes, 0, it);
 
@@ -215,17 +221,19 @@ export function number(bytes: BufferLike, value: number, it: Iterator) {
     return number(bytes, (value > 0) ? Number.MAX_SAFE_INTEGER : -Number.MAX_SAFE_INTEGER, it);
 
   } else if (value !== (value|0)) {
+    if (Math.abs(value) <= 3.4028235e+38) { // range check
+        _float32[0] = value;
+        if (Math.abs(Math.abs(_float32[0]) - Math.abs(value)) < 1e-4) { // precision check; adjust 1e-n (n = precision) to in-/decrease acceptable precision loss
+            // now we know value is in range for f32 and has acceptable precision for f32
+            bytes[it.offset++] = 0xca;
+            float32(bytes, value, it);
+            return 5;
+        }
+    }
+
     bytes[it.offset++] = 0xcb;
-    writeFloat64(bytes, value, it);
+    float64(bytes, value, it);
     return 9;
-
-    // TODO: encode float 32?
-    // is it possible to differentiate between float32 / float64 here?
-
-    // // float 32
-    // bytes.push(0xca);
-    // writeFloat32(bytes, value);
-    // return 5;
   }
 
   if (value >= 0) {
@@ -296,3 +304,23 @@ export function number(bytes: BufferLike, value: number, it: Iterator) {
     return 9;
   }
 }
+
+export const encode = {
+    int8,
+    uint8,
+    int16,
+    uint16,
+    int32,
+    uint32,
+    int64,
+    uint64,
+    bigint64,
+    biguint64,
+    float32,
+    float64,
+    boolean,
+    string,
+    number,
+    utf8Write,
+    utf8Length,
+}

package/src/encoding/spec.ts

@@ -8,8 +8,8 @@ export enum OPERATION {
     ADD = 128,            // (10000000) add new structure/primitive
     REPLACE = 0,          // (00000001) replace structure/primitive
     DELETE = 64,          // (01000000) delete field
-    DELETE_AND_MOVE = 96, // () add new structure/primitive
-    MOVE_AND_ADD = 160,   // () add new structure/primitive
+    DELETE_AND_MOVE = 96, // () ArraySchema only
+    MOVE_AND_ADD = 160,   // () ArraySchema only
     DELETE_AND_ADD = 192, // (11000000) DELETE field, followed by an ADD
 
     /**
@@ -20,11 +20,8 @@ export enum OPERATION {
     /**
      * ArraySchema operations
      */
-    PUSH = 11,
-    UNSHIFT = 12,
     REVERSE = 15,
     MOVE = 32,
     DELETE_BY_REFID = 33, // This operation is only used at ENCODING time. During DECODING, DELETE_BY_REFID is converted to DELETE
     ADD_BY_REFID = 129,
-
 }

package/src/index.ts

@@ -14,8 +14,8 @@ export { CollectionSchema };
 import { SetSchema } from "./types/custom/SetSchema";
 export { SetSchema };
 
-import { registerType } from "./types/registry";
-export { registerType };
+import { registerType, defineCustomTypes } from "./types/registry";
+export { registerType, defineCustomTypes };
 
 registerType("map", { constructor: MapSchema });
 registerType("array", { constructor: ArraySchema });
@@ -27,10 +27,8 @@ export { dumpChanges } from "./utils";
 
 // Encoder / Decoder
 export { $track, $encoder, $decoder, $filter, $getByIndex, $deleteByIndex, $changes, $childType } from "./types/symbols";
-export type { Iterator } from "./encoding/decode";
-import * as encode from "./encoding/encode";
-import * as decode from "./encoding/decode";
-export { encode, decode };
+export { encode } from "./encoding/encode";
+export { decode, type Iterator } from "./encoding/decode";
 
 // Reflection
 export {