@dcl/ecs 7.0.6-4137912823.commit-aa69b28 → 7.0.6-4153633895.commit-4aad233

package/dist/components/legacy/Transform.js

@@ -46,7 +46,8 @@ export const TransformSchema = {
         return {
             position: { x: 0, y: 0, z: 0 },
             scale: { x: 1, y: 1, z: 1 },
-            rotation: { x: 0, y: 0, z: 0, w: 1 }
+            rotation: { x: 0, y: 0, z: 0, w: 1 },
+            parent: 0
         };
     },
     extend(value) {
@@ -54,6 +55,7 @@ export const TransformSchema = {
             position: { x: 0, y: 0, z: 0 },
             scale: { x: 1, y: 1, z: 1 },
             rotation: { x: 0, y: 0, z: 0, w: 1 },
+            parent: 0,
             ...value
         };
     }

package/dist/engine/component.d.ts

@@ -1,4 +1,5 @@
-import { ByteBuffer } from '../serialization/ByteBuffer';
+import type { ISchema } from '../schemas/ISchema';
+import { CrdtMessageBody, DeleteComponentMessageBody, PutComponentMessageBody } from '../serialization/crdt';
 import { Entity } from './entity';
 import { DeepReadonly } from './readonly';
 /**
@@ -48,6 +49,14 @@ export interface ComponentDefinition<T> {
      * @param entity - Entity to delete the component from
      */
     deleteFrom(entity: Entity): T | null;
+    /**
+     * @public
+     * Marks the entity as deleted and signals it cannot be used ever again. It must
+     * clear the component internal state, produces a synchronization message to remove
+     * the component from the entity.
+     * @param entity - Entity to delete the component from
+     */
+    entityDeleted(entity: Entity, markAsDirty: boolean): void;
     /**
      * Get the mutable component of the entity, throw an error if the entity doesn't have the component.
      * - Internal comment: This method adds the &lt;entity,component&gt; to the list to be reviewed next frame
@@ -60,5 +69,21 @@ export interface ComponentDefinition<T> {
      * @param entity - Entity to get the component from
      */
     getMutableOrNull(entity: Entity): T | null;
-    writeToByteBuffer(entity: Entity, buffer: ByteBuffer): void;
+    /**
+     * This function receives a CRDT update and returns a touple with a "conflict
+     * resoluton" message, in case of the sender being updated or null in case of noop/accepted
+     * change. The second element of the touple is the modified/changed/deleted value.
+     * @public
+     */
+    updateFromCrdt(body: CrdtMessageBody): [null | PutComponentMessageBody | DeleteComponentMessageBody, T | null];
+    /**
+     * This function returns an iterable with all the CRDT updates that need to be
+     * broadcasted to other actors in the system. After returning, this function
+     * clears the internal dirty state. Updates are produced only once.
+     * @public
+     */
+    getCrdtUpdates(): Iterable<CrdtMessageBody>;
 }
+export declare function incrementTimestamp(entity: Entity, timestamps: Map<Entity, number>): number;
+export declare function createUpdateFromCrdt(componentId: number, timestamps: Map<Entity, number>, schema: Pick<ISchema<any>, 'serialize' | 'deserialize'>, data: Map<Entity, unknown>): (msg: CrdtMessageBody) => [null | PutComponentMessageBody | DeleteComponentMessageBody, any];
+export declare function createGetCrdtMessages(componentId: number, timestamps: Map<Entity, number>, dirtyIterator: Set<Entity>, schema: Pick<ISchema<any>, 'serialize'>, data: Map<Entity, unknown>): () => Generator<PutComponentMessageBody | DeleteComponentMessageBody, void, unknown>;

package/dist/engine/component.js

@@ -1,11 +1,149 @@
 import { ReadWriteByteBuffer } from '../serialization/ByteBuffer';
+import { CrdtMessageType, ProcessMessageResultType } from '../serialization/crdt';
+import { dataCompare } from '../systems/crdt/utils';
 import { deepReadonly } from './readonly';
+export function incrementTimestamp(entity, timestamps) {
+    const newTimestamp = (timestamps.get(entity) || 0) + 1;
+    timestamps.set(entity, newTimestamp);
+    return newTimestamp;
+}
+export function createUpdateFromCrdt(componentId, timestamps, schema, data) {
+    /**
+     * Process the received message only if the lamport number recieved is higher
+     * than the stored one. If its lower, we spread it to the network to correct the peer.
+     * If they are equal, the bigger raw data wins.
+  
+      * Returns the recieved data if the lamport number was bigger than ours.
+      * If it was an outdated message, then we return void
+      * @public
+      */
+    function crdtRuleForCurrentState(message) {
+        const { entityId, timestamp } = message;
+        const currentTimestamp = timestamps.get(entityId);
+        // The received message is > than our current value, update our state.components.
+        if (currentTimestamp === undefined || currentTimestamp < timestamp) {
+            return ProcessMessageResultType.StateUpdatedTimestamp;
+        }
+        // Outdated Message. Resend our state message through the wire.
+        if (currentTimestamp > timestamp) {
+            // console.log('2', currentTimestamp, timestamp)
+            return ProcessMessageResultType.StateOutdatedTimestamp;
+        }
+        // Deletes are idempotent
+        if (message.type === CrdtMessageType.DELETE_COMPONENT && !data.has(entityId)) {
+            return ProcessMessageResultType.NoChanges;
+        }
+        let currentDataGreater = 0;
+        if (data.has(entityId)) {
+            const writeBuffer = new ReadWriteByteBuffer();
+            schema.serialize(data.get(entityId), writeBuffer);
+            currentDataGreater = dataCompare(writeBuffer.toBinary(), message.data || null);
+        }
+        else {
+            currentDataGreater = dataCompare(null, message.data);
+        }
+        // Same data, same timestamp. Weirdo echo message.
+        // console.log('3', currentDataGreater, writeBuffer.toBinary(), (message as any).data || null)
+        if (currentDataGreater === 0) {
+            return ProcessMessageResultType.NoChanges;
+        }
+        else if (currentDataGreater > 0) {
+            // Current data is greater
+            return ProcessMessageResultType.StateOutdatedData;
+        }
+        else {
+            // Curent data is lower
+            return ProcessMessageResultType.StateUpdatedData;
+        }
+    }
+    return (msg) => {
+        /* istanbul ignore next */
+        if (msg.type !== CrdtMessageType.PUT_COMPONENT && msg.type !== CrdtMessageType.DELETE_COMPONENT)
+            /* istanbul ignore next */
+            return [null, data.get(msg.entityId)];
+        const action = crdtRuleForCurrentState(msg);
+        const entity = msg.entityId;
+        switch (action) {
+            case ProcessMessageResultType.StateUpdatedData:
+            case ProcessMessageResultType.StateUpdatedTimestamp: {
+                timestamps.set(entity, msg.timestamp);
+                if (msg.type === CrdtMessageType.PUT_COMPONENT) {
+                    const buf = new ReadWriteByteBuffer(msg.data);
+                    data.set(entity, schema.deserialize(buf));
+                }
+                else {
+                    data.delete(entity);
+                }
+                return [null, data.get(entity)];
+            }
+            case ProcessMessageResultType.StateOutdatedTimestamp:
+            case ProcessMessageResultType.StateOutdatedData: {
+                if (data.has(entity)) {
+                    const writeBuffer = new ReadWriteByteBuffer();
+                    schema.serialize(data.get(entity), writeBuffer);
+                    return [
+                        {
+                            type: CrdtMessageType.PUT_COMPONENT,
+                            componentId,
+                            data: writeBuffer.toBinary(),
+                            entityId: entity,
+                            timestamp: timestamps.get(entity)
+                        },
+                        data.get(entity)
+                    ];
+                }
+                else {
+                    return [
+                        {
+                            type: CrdtMessageType.DELETE_COMPONENT,
+                            componentId,
+                            entityId: entity,
+                            timestamp: timestamps.get(entity)
+                        },
+                        undefined
+                    ];
+                }
+            }
+        }
+        return [null, data.get(entity)];
+    };
+}
+export function createGetCrdtMessages(componentId, timestamps, dirtyIterator, schema, data) {
+    return function* () {
+        for (const entity of dirtyIterator) {
+            const newTimestamp = incrementTimestamp(entity, timestamps);
+            if (data.has(entity)) {
+                const writeBuffer = new ReadWriteByteBuffer();
+                schema.serialize(data.get(entity), writeBuffer);
+                const msg = {
+                    type: CrdtMessageType.PUT_COMPONENT,
+                    componentId,
+                    entityId: entity,
+                    data: writeBuffer.toBinary(),
+                    timestamp: newTimestamp
+                };
+                yield msg;
+            }
+            else {
+                const msg = {
+                    type: CrdtMessageType.DELETE_COMPONENT,
+                    componentId,
+                    entityId: entity,
+                    timestamp: newTimestamp
+                };
+                yield msg;
+            }
+        }
+        dirtyIterator.clear();
+    };
+}
 /**
  * @internal
  */
 export function createComponentDefinitionFromSchema(componentName, componentId, schema) {
     const data = new Map();
     const dirtyIterator = new Set();
+    const timestamps = new Map();
     return {
         get componentId() {
             return componentId;
@@ -24,15 +162,16 @@ export function createComponentDefinitionFromSchema(componentName, componentId,
         },
         deleteFrom(entity, markAsDirty = true) {
             const component = data.get(entity);
-            data.delete(entity);
-            if (markAsDirty) {
+            if (data.delete(entity) && markAsDirty) {
                 dirtyIterator.add(entity);
             }
-            else {
-                dirtyIterator.delete(entity);
-            }
             return component || null;
         },
+        entityDeleted(entity, markAsDirty) {
+            if (data.delete(entity) && markAsDirty) {
+                dirtyIterator.add(entity);
+            }
+        },
         getOrNull(entity) {
             const component = data.get(entity);
             return component ? deepReadonly(component) : null;
@@ -85,6 +224,7 @@ export function createComponentDefinitionFromSchema(componentName, componentId,
                 yield entity;
             }
         },
+        getCrdtUpdates: createGetCrdtMessages(componentId, timestamps, dirtyIterator, schema, data),
         toBinary(entity) {
             const component = data.get(entity);
             if (!component) {
@@ -94,45 +234,9 @@ export function createComponentDefinitionFromSchema(componentName, componentId,
             schema.serialize(component, writeBuffer);
             return writeBuffer;
         },
-        toBinaryOrNull(entity) {
-            const component = data.get(entity);
-            if (!component) {
-                return null;
-            }
-            const writeBuffer = new ReadWriteByteBuffer();
-            schema.serialize(component, writeBuffer);
-            return writeBuffer;
-        },
-        writeToByteBuffer(entity, buffer) {
-            const component = data.get(entity);
-            if (!component) {
-                throw new Error(`[writeToByteBuffer] Component ${componentName} for entity #${entity} not found`);
-            }
-            schema.serialize(component, buffer);
-        },
-        updateFromBinary(entity, buffer, markAsDirty = true) {
-            const component = data.get(entity);
-            if (!component) {
-                throw new Error(`[updateFromBinary] Component ${componentName} for ${entity} not found`);
-            }
-            return this.upsertFromBinary(entity, buffer, markAsDirty);
-        },
-        upsertFromBinary(entity, buffer, markAsDirty = true) {
-            const newValue = schema.deserialize(buffer);
-            data.set(entity, newValue);
-            if (markAsDirty) {
-                dirtyIterator.add(entity);
-            }
-            else {
-                dirtyIterator.delete(entity);
-            }
-            return newValue;
-        },
+        updateFromCrdt: createUpdateFromCrdt(componentId, timestamps, schema, data),
         deserialize(buffer) {
             return schema.deserialize(buffer);
-        },
-        clearDirty() {
-            dirtyIterator.clear();
         }
     };
 }

package/dist/engine/entity.js

@@ -1,4 +1,4 @@
-import { createGSet } from '@dcl/crdt/dist/gset';
+import { createVersionGSet } from '../systems/crdt/gset';
 /**
  * @internal
  */
@@ -64,7 +64,7 @@ export function EntityContainer() {
     let entityCounter = RESERVED_STATIC_ENTITIES;
     const usedEntities = new Set();
     let toRemoveEntities = [];
-    const removedEntities = createGSet();
+    const removedEntities = createVersionGSet();
     function generateNewEntity() {
         if (entityCounter > MAX_ENTITY_NUMBER - 1) {
             throw new Error(`It fails trying to generate an entity out of range ${MAX_ENTITY_NUMBER}.`);
@@ -109,10 +109,12 @@ export function EntityContainer() {
     }
     function releaseRemovedEntities() {
         const arr = toRemoveEntities;
-        toRemoveEntities = [];
-        for (const entity of arr) {
-            const [n, v] = EntityUtils.fromEntityId(entity);
-            removedEntities.addTo(n, v);
+        if (arr.length) {
+            toRemoveEntities = [];
+            for (const entity of arr) {
+                const [n, v] = EntityUtils.fromEntityId(entity);
+                removedEntities.addTo(n, v);
+            }
         }
         return arr;
     }
@@ -128,10 +130,9 @@ export function EntityContainer() {
     }
     function updateUsedEntity(entity) {
         const [n, v] = EntityUtils.fromEntityId(entity);
-        const removedVersion = removedEntities.getMap().get(n);
-        if (removedVersion !== undefined && removedVersion >= v) {
+        // if the entity was removed then abort fast
+        if (removedEntities.has(n, v))
             return false;
-        }
         // Update
         if (v > 0) {
             for (let i = 0; i <= v - 1; i++) {

package/dist/engine/index.js

@@ -26,9 +26,7 @@ function preEngine() {
     }
     function removeEntity(entity) {
         for (const [, component] of componentsDefinition) {
-            if (component.has(entity)) {
-                component.deleteFrom(entity);
-            }
+            component.entityDeleted(entity, true);
         }
         return entityContainer.removeEntity(entity);
     }
@@ -184,12 +182,9 @@ export function Engine(options) {
             const ret = system.fn(dt);
             checkNotThenable(ret, `A system (${system.name || 'anonymous'}) returned a thenable. Systems cannot be async functions. Documentation: https://dcl.gg/sdk/sync-systems`);
         }
-        const dirtyEntities = crdtSystem.updateState();
+        // get the deleted entities to send the DeleteEntity CRDT commands
         const deletedEntites = partialEngine.entityContainer.releaseRemovedEntities();
-        await crdtSystem.sendMessages(dirtyEntities, deletedEntites);
-        for (const definition of partialEngine.componentsIter()) {
-            definition.clearDirty();
-        }
+        await crdtSystem.sendMessages(deletedEntites);
     }
     return {
         addEntity: partialEngine.addEntity,
@@ -212,7 +207,6 @@ export function Engine(options) {
         CameraEntity: 2,
         getEntityState: partialEngine.entityContainer.getEntityState,
         addTransport: crdtSystem.addTransport,
-        getCrdtState: crdtSystem.getCrdt,
         entityContainer: partialEngine.entityContainer
     };
 }

package/dist/serialization/crdt/putComponent.js

@@ -10,18 +10,18 @@ export var PutComponentOperation;
      * Call this function for an optimal writing data passing the ByteBuffer
      *  already allocated
      */
-    function write(entity, timestamp, componentDefinition, buf) {
+    function write(entity, timestamp, componentId, data, buf) {
         // reserve the beginning
         const startMessageOffset = buf.incrementWriteOffset(CRDT_MESSAGE_HEADER_LENGTH + PutComponentOperation.MESSAGE_HEADER_LENGTH);
         // write body
-        componentDefinition.writeToByteBuffer(entity, buf);
+        buf.writeBuffer(data, false);
         const messageLength = buf.currentWriteOffset() - startMessageOffset;
         // Write CrdtMessage header
         buf.setUint32(startMessageOffset, messageLength);
         buf.setUint32(startMessageOffset + 4, CrdtMessageType.PUT_COMPONENT);
         // Write ComponentOperation header
         buf.setUint32(startMessageOffset + 8, entity);
-        buf.setUint32(startMessageOffset + 12, componentDefinition.componentId);
+        buf.setUint32(startMessageOffset + 12, componentId);
         buf.setUint32(startMessageOffset + 16, timestamp);
         const newLocal = messageLength - PutComponentOperation.MESSAGE_HEADER_LENGTH - CRDT_MESSAGE_HEADER_LENGTH;
         buf.setUint32(startMessageOffset + 20, newLocal);

package/dist/serialization/crdt/types.d.ts

@@ -1,4 +1,4 @@
-import { Entity } from '../../engine/entity';
+import { Entity, uint32 } from '../../engine/entity';
 /**
  * @public
  */
@@ -9,6 +9,21 @@ export declare enum CrdtMessageType {
     DELETE_ENTITY = 3,
     MAX_MESSAGE_TYPE = 4
 }
+/**
+ * Min length = 8 bytes
+ * All message length including
+ * @param length - uint32 the length of all message (including the header)
+ * @param type - define the function which handles the data
+ * @public
+ */
+export type CrdtMessageHeader = {
+    length: uint32;
+    type: uint32;
+};
+/**
+ * @public
+ */
+export declare const CRDT_MESSAGE_HEADER_LENGTH = 8;
 /**
  * Min. length = header (8 bytes) + 16 bytes = 24 bytes
  *
@@ -45,7 +60,67 @@ export type DeleteEntityMessageBody = {
     type: CrdtMessageType.DELETE_ENTITY;
     entityId: Entity;
 };
+/**
+ * @public
+ */
+export type PutComponentMessage = CrdtMessageHeader & PutComponentMessageBody;
+/**
+ * @public
+ */
+export type DeleteComponentMessage = CrdtMessageHeader & DeleteComponentMessageBody;
+/**
+ * @public
+ */
+export type DeleteEntityMessage = CrdtMessageHeader & DeleteEntityMessageBody;
+/**
+ * @public
+ */
+export type CrdtMessage = PutComponentMessage | DeleteComponentMessage | DeleteEntityMessage;
 /**
  * @public
  */
 export type CrdtMessageBody = PutComponentMessageBody | DeleteComponentMessageBody | DeleteEntityMessageBody;
+export declare enum ProcessMessageResultType {
+    /**
+     * Typical message and new state set.
+     * @state CHANGE
+     * @reason Incoming message has a timestamp greater
+     */
+    StateUpdatedTimestamp = 1,
+    /**
+     * Typical message when it is considered old.
+     * @state it does NOT CHANGE.
+     * @reason incoming message has a timestamp lower.
+     */
+    StateOutdatedTimestamp = 2,
+    /**
+     * Weird message, same timestamp and data.
+     * @state it does NOT CHANGE.
+     * @reason consistent state between peers.
+     */
+    NoChanges = 3,
+    /**
+     * Less but typical message, same timestamp, resolution by data.
+     * @state it does NOT CHANGE.
+     * @reason incoming message has a LOWER data.
+     */
+    StateOutdatedData = 4,
+    /**
+     * Less but typical message, same timestamp, resolution by data.
+     * @state CHANGE.
+     * @reason incoming message has a GREATER data.
+     */
+    StateUpdatedData = 5,
+    /**
+     * Entity was previously deleted.
+     * @state it does NOT CHANGE.
+     * @reason The message is considered old.
+     */
+    EntityWasDeleted = 6,
+    /**
+     * Entity should be deleted.
+     * @state CHANGE.
+     * @reason the state is storing old entities
+     */
+    EntityDeleted = 7
+}

package/dist/serialization/crdt/types.js

@@ -11,6 +11,63 @@ export var CrdtMessageType;
     CrdtMessageType[CrdtMessageType["MAX_MESSAGE_TYPE"] = 4] = "MAX_MESSAGE_TYPE";
 })(CrdtMessageType || (CrdtMessageType = {}));
 /**
- * @internal
+ * @public
  */
 export const CRDT_MESSAGE_HEADER_LENGTH = 8;
+export var ProcessMessageResultType;
+(function (ProcessMessageResultType) {
+    /**
+     * Typical message and new state set.
+     * @state CHANGE
+     * @reason Incoming message has a timestamp greater
+     */
+    ProcessMessageResultType[ProcessMessageResultType["StateUpdatedTimestamp"] = 1] = "StateUpdatedTimestamp";
+    /**
+     * Typical message when it is considered old.
+     * @state it does NOT CHANGE.
+     * @reason incoming message has a timestamp lower.
+     */
+    ProcessMessageResultType[ProcessMessageResultType["StateOutdatedTimestamp"] = 2] = "StateOutdatedTimestamp";
+    /**
+     * Weird message, same timestamp and data.
+     * @state it does NOT CHANGE.
+     * @reason consistent state between peers.
+     */
+    ProcessMessageResultType[ProcessMessageResultType["NoChanges"] = 3] = "NoChanges";
+    /**
+     * Less but typical message, same timestamp, resolution by data.
+     * @state it does NOT CHANGE.
+     * @reason incoming message has a LOWER data.
+     */
+    ProcessMessageResultType[ProcessMessageResultType["StateOutdatedData"] = 4] = "StateOutdatedData";
+    /**
+     * Less but typical message, same timestamp, resolution by data.
+     * @state CHANGE.
+     * @reason incoming message has a GREATER data.
+     */
+    ProcessMessageResultType[ProcessMessageResultType["StateUpdatedData"] = 5] = "StateUpdatedData";
+    /**
+     * Entity was previously deleted.
+     * @state it does NOT CHANGE.
+     * @reason The message is considered old.
+     */
+    ProcessMessageResultType[ProcessMessageResultType["EntityWasDeleted"] = 6] = "EntityWasDeleted";
+    /**
+     * Entity should be deleted.
+     * @state CHANGE.
+     * @reason the state is storing old entities
+     */
+    ProcessMessageResultType[ProcessMessageResultType["EntityDeleted"] = 7] = "EntityDeleted";
+})(ProcessMessageResultType || (ProcessMessageResultType = {}));
+// we receive LWW, v=6, we have v=5 => we receive with delay the deleteEntity(v=5)
+//   => we should generate the deleteEntity message effects internally with deleteEntity(v=5),
+//       but don't resend the deleteEntity
+//          - (CRDT) addDeletedEntitySet v=5 (with crdt state cleaning) and then LWW v=6
+//          - (engine) engine.deleteEntity v=5
+// we receive LWW, v=7, we have v=5 => we receive with delay the deleteEntity(v=5), deleteEntity(v=6), ..., N
+//   => we should generate the deleteEntity message effects internally with deleteEntity(v=5),
+//       but don't resend the deleteEntity
+//          - (CRDT) addDeletedEntitySet v=5 (with crdt state cleaning) and then LWW v=6
+//          - (engine) engine.deleteEntity v=5
+// msg delete entity: it only should be sent by deleter
+//

package/dist/systems/crdt/gset.d.ts

@@ -0,0 +1,29 @@
+/**
+ * This Grow-only set is a implementation with a memory optimization.
+ *
+ * Each number has a version, no matter how the final compound number is mixed.
+ *
+ * The function `add` isn't defined (for this implementation), instead, the addTo is: add all versions of a number `n` until (and including) `v`.
+ *
+ */
+export type OptimizedGrowonlySet = {
+    /**
+     * @public
+     *
+     * @param n
+     * @param v
+     * @returns
+     */
+    addTo(n: number, v: number): boolean;
+    /**
+     * @public
+     *
+     * @returns the set with [number, version] of each value
+     */
+    has(n: number, v: number): boolean;
+};
+/**
+ *
+ * @returns a new GSet
+ */
+export declare function createVersionGSet(): OptimizedGrowonlySet;

package/dist/systems/crdt/gset.js

@@ -0,0 +1,50 @@
+/**
+ *
+ * @returns a new GSet
+ */
+export function createVersionGSet() {
+    const lastVersion = new Map();
+    return {
+        /**
+         *
+         * @param number
+         * @param version
+         * @returns
+         */
+        addTo(number, version) {
+            /* istanbul ignore next */
+            if (version < 0) {
+                /* istanbul ignore next */
+                return false;
+            }
+            const currentValue = lastVersion.get(number);
+            // If the version is >=, it means the value it's already in the set
+            if (currentValue !== undefined && currentValue >= version) {
+                return true;
+            }
+            lastVersion.set(number, version);
+            return true;
+        },
+        /**
+         * @returns the set with [number, version] of each value
+         */
+        has(n, v) {
+            const currentValue = lastVersion.get(n);
+            // If the version is >=, it means the value it's already in the set
+            if (currentValue !== undefined && currentValue >= v) {
+                return true;
+            }
+            return false;
+        },
+        /**
+         * Warning: this function returns the reference to the internal map,
+         *  if you need to mutate some value, make a copy.
+         * For optimization purpose the copy isn't made here.
+         *
+         * @returns the map of number to version
+         */
+        getMap() {
+            return lastVersion;
+        }
+    };
+}

package/dist/systems/crdt/index.js

@@ -1,6 +1,4 @@
-import { crdtProtocol } from '@dcl/crdt';
-import { CRDTMessageType, ProcessMessageResultType } from '@dcl/crdt/dist/types';
-import { EntityState, EntityUtils } from '../../engine/entity';
+import { EntityState } from '../../engine/entity';
 import { ReadWriteByteBuffer } from '../../serialization/ByteBuffer';
 import { CrdtMessageProtocol } from '../../serialization/crdt';
 import { DeleteComponent } from '../../serialization/crdt/deleteComponent';
@@ -12,11 +10,6 @@ import { CrdtMessageType } from '../../serialization/crdt/types';
  */
 export function crdtSceneSystem(engine, onProcessEntityComponentChange) {
     const transports = [];
-    // CRDT Client
-    const crdtClient = crdtProtocol({
-        toEntityId: EntityUtils.toEntityId,
-        fromEntityId: EntityUtils.fromEntityId
-    });
     // Messages that we received at transport.onMessage waiting to be processed
     const receivedMessages = [];
     // Messages already processed by the engine but that we need to broadcast to other transports.
@@ -93,20 +86,9 @@ export function crdtSceneSystem(engine, onProcessEntityComponentChange) {
         const entitiesShouldBeCleaned = [];
         for (const msg of messagesToProcess) {
             if (msg.type === CrdtMessageType.DELETE_ENTITY) {
-                crdtClient.processMessage({
-                    type: CRDTMessageType.CRDTMT_DeleteEntity,
-                    entityId: msg.entityId
-                });
                 entitiesShouldBeCleaned.push(msg.entityId);
             }
             else {
-                const crdtMessage = {
-                    type: CRDTMessageType.CRDTMT_PutComponentData,
-                    entityId: msg.entityId,
-                    componentId: msg.componentId,
-                    data: msg.type === CrdtMessageType.PUT_COMPONENT ? msg.data : null,
-                    timestamp: msg.timestamp
-                };
                 const entityState = engine.entityContainer.getEntityState(msg.entityId);
                 // Skip updates from removed entityes
                 if (entityState === EntityState.Removed)
@@ -116,146 +98,73 @@ export function crdtSceneSystem(engine, onProcessEntityComponentChange) {
                     engine.entityContainer.updateUsedEntity(msg.entityId);
                 }
                 const component = engine.getComponentOrNull(msg.componentId);
-                // The state isn't updated because the dirty was set
-                //  out of the block of systems update between `receiveMessage` and `updateState`
-                if (component?.isDirty(msg.entityId)) {
-                    crdtClient.createComponentDataEvent(component.componentId, msg.entityId, component.toBinaryOrNull(msg.entityId)?.toBinary() || null);
-                }
-                const processResult = crdtClient.processMessage(crdtMessage);
-                if (!component) {
-                    continue;
-                }
-                switch (processResult) {
-                    case ProcessMessageResultType.StateUpdatedTimestamp:
-                    case ProcessMessageResultType.StateUpdatedData:
-                        // Add message to transport queue to be processed by others transports
-                        broadcastMessages.push(msg);
-                        // Process CRDT Message
-                        if (msg.type === CrdtMessageType.DELETE_COMPONENT) {
-                            component.deleteFrom(msg.entityId, false);
+                if (component) {
+                    const [conflictMessage] = component.updateFromCrdt(msg);
+                    if (conflictMessage) {
+                        const offset = bufferForOutdated.currentWriteOffset();
+                        if (conflictMessage.type === CrdtMessageType.PUT_COMPONENT) {
+                            PutComponentOperation.write(msg.entityId, conflictMessage.timestamp, conflictMessage.componentId, conflictMessage.data, bufferForOutdated);
                         }
                         else {
-                            const data = new ReadWriteByteBuffer(msg.data);
-                            component.upsertFromBinary(msg.entityId, data, false);
+                            DeleteComponent.write(msg.entityId, component.componentId, conflictMessage.timestamp, bufferForOutdated);
                         }
+                        outdatedMessages.push({
+                            ...msg,
+                            messageBuffer: bufferForOutdated.buffer().subarray(offset, bufferForOutdated.currentWriteOffset())
+                        });
+                    }
+                    else {
+                        // Add message to transport queue to be processed by others transports
+                        broadcastMessages.push(msg);
                         onProcessEntityComponentChange && onProcessEntityComponentChange(msg.entityId, msg.type, component);
-                        break;
-                    // CRDT outdated message. Resend this message to the transport
-                    // To do this we add this message to a queue that will be processed at the end of the update tick
-                    case ProcessMessageResultType.StateOutdatedData:
-                    case ProcessMessageResultType.StateOutdatedTimestamp:
-                        const current = crdtClient.getState().components.get(msg.componentId)?.get(msg.entityId);
-                        if (current) {
-                            const offset = bufferForOutdated.currentWriteOffset();
-                            const ts = current.timestamp;
-                            if (component.has(msg.entityId)) {
-                                PutComponentOperation.write(msg.entityId, ts, component, bufferForOutdated);
-                            }
-                            else {
-                                DeleteComponent.write(msg.entityId, component.componentId, ts, bufferForOutdated);
-                            }
-                            outdatedMessages.push({
-                                ...msg,
-                                messageBuffer: bufferForOutdated.buffer().subarray(offset, bufferForOutdated.currentWriteOffset())
-                            });
-                        }
-                        break;
-                    case ProcessMessageResultType.NoChanges:
-                    case ProcessMessageResultType.EntityDeleted:
-                    case ProcessMessageResultType.EntityWasDeleted:
-                    default:
-                        break;
+                    }
                 }
             }
         }
+        // the last stage of the syncrhonization is to delete the entities
         for (const entity of entitiesShouldBeCleaned) {
             // If we tried to resend outdated message and the entity was deleted before, we avoid sending them.
             for (let i = outdatedMessages.length - 1; i >= 0; i--) {
-                if (outdatedMessages[i].entityId === entity) {
+                if (outdatedMessages[i].entityId === entity && outdatedMessages[i].type !== CrdtMessageType.DELETE_ENTITY) {
                     outdatedMessages.splice(i, 1);
                 }
             }
             for (const definition of engine.componentsIter()) {
-                definition.deleteFrom(entity, false);
+                definition.entityDeleted(entity, false);
             }
             engine.entityContainer.updateRemovedEntity(entity);
             onProcessEntityComponentChange && onProcessEntityComponentChange(entity, CrdtMessageType.DELETE_ENTITY);
         }
     }
-    /**
-     * Updates CRDT state of the current engine dirty components
-     *
-     * TODO: optimize this function allocations using a bitmap
-     * TODO: unify this function with sendMessages
-     */
-    function updateState() {
-        const dirtyMap = new Map();
-        for (const component of engine.componentsIter()) {
-            let entitySet = null;
-            for (const entity of component.dirtyIterator()) {
-                if (!entitySet) {
-                    entitySet = [];
-                    dirtyMap.set(component, entitySet);
-                }
-                // TODO: reuse shared writer to prevent extra allocations of toBinary
-                const componentValue = component.toBinaryOrNull(entity)?.toBinary() ?? null;
-                // TODO: do not emit event if componentValue equals the value didn't change
-                // if update goes bad, the entity doesn't accept put anymore (it's added to deleted entities set)
-                if (crdtClient.createComponentDataEvent(component.componentId, entity, componentValue) === null) {
-                    component.deleteFrom(entity, false);
-                }
-                else {
-                    entitySet.push(entity);
-                    onProcessEntityComponentChange &&
-                        onProcessEntityComponentChange(entity, componentValue === null ? CrdtMessageType.DELETE_COMPONENT : CrdtMessageType.PUT_COMPONENT, component);
-                }
-            }
-        }
-        return dirtyMap;
-    }
     /**
      * Iterates the dirty map and generates crdt messages to be send
      */
-    async function sendMessages(dirtyEntities, deletedEntities) {
+    async function sendMessages(entitiesDeletedThisTick) {
         // CRDT Messages will be the merge between the recieved transport messages and the new crdt messages
         const crdtMessages = getMessages(broadcastMessages);
         const outdatedMessagesBkp = getMessages(outdatedMessages);
         const buffer = new ReadWriteByteBuffer();
-        for (const [component, entities] of dirtyEntities) {
-            for (const entity of entities) {
-                // Component will be always defined here since dirtyMap its an iterator of engine.componentsDefinition
-                const { timestamp } = crdtClient
-                    .getState()
-                    .components.get(component.componentId)
-                    .get(entity);
+        for (const component of engine.componentsIter()) {
+            for (const message of component.getCrdtUpdates()) {
                 const offset = buffer.currentWriteOffset();
-                const type = component.has(entity)
-                    ? CrdtMessageType.PUT_COMPONENT
-                    : CrdtMessageType.DELETE_COMPONENT;
-                const transportMessage = {
-                    type,
-                    entityId: entity,
-                    componentId: component.componentId,
-                    timestamp
-                };
                 // Avoid creating messages if there is no transport that will handle it
-                if (transports.some((t) => t.filter(transportMessage))) {
-                    if (transportMessage.type === CrdtMessageType.PUT_COMPONENT) {
-                        PutComponentOperation.write(entity, timestamp, component, buffer);
+                if (transports.some((t) => t.filter(message))) {
+                    if (message.type === CrdtMessageType.PUT_COMPONENT) {
+                        PutComponentOperation.write(message.entityId, message.timestamp, message.componentId, message.data, buffer);
                     }
-                    else {
-                        DeleteComponent.write(entity, component.componentId, timestamp, buffer);
+                    else if (message.type === CrdtMessageType.DELETE_COMPONENT) {
+                        DeleteComponent.write(message.entityId, component.componentId, message.timestamp, buffer);
                     }
                     crdtMessages.push({
-                        ...transportMessage,
+                        ...message,
                         messageBuffer: buffer.buffer().subarray(offset, buffer.currentWriteOffset())
                     });
+                    onProcessEntityComponentChange && onProcessEntityComponentChange(message.entityId, message.type, component);
                 }
             }
         }
         // After all updates, I execute the DeletedEntity messages
-        for (const entityId of deletedEntities) {
-            crdtClient.createDeleteEntityEvent(entityId);
+        for (const entityId of entitiesDeletedThisTick) {
             const offset = buffer.currentWriteOffset();
             DeleteEntity.write(entityId, buffer);
             crdtMessages.push({
@@ -263,6 +172,7 @@ export function crdtSceneSystem(engine, onProcessEntityComponentChange) {
                 entityId,
                 messageBuffer: buffer.buffer().subarray(offset, buffer.currentWriteOffset())
             });
+            onProcessEntityComponentChange && onProcessEntityComponentChange(entityId, CrdtMessageType.DELETE_ENTITY);
         }
         // Send CRDT messages to transports
         const transportBuffer = new ReadWriteByteBuffer();
@@ -301,18 +211,9 @@ export function crdtSceneSystem(engine, onProcessEntityComponentChange) {
         const id = transports.push(transport) - 1;
         transport.onmessage = parseChunkMessage(id);
     }
-    /**
-     * @public
-     * @returns returns the crdt state
-     */
-    function getCrdt() {
-        return crdtClient.getState();
-    }
     return {
-        getCrdt,
         sendMessages,
         receiveMessages,
-        addTransport,
-        updateState
+        addTransport
     };
 }

package/dist/systems/crdt/utils.js

@@ -9,3 +9,33 @@ export var CrdtUtils;
     })(SynchronizedEntityType = CrdtUtils.SynchronizedEntityType || (CrdtUtils.SynchronizedEntityType = {}));
 })(CrdtUtils || (CrdtUtils = {}));
 export default CrdtUtils;
+/**
+ * Compare raw data.
+ * @internal
+ * @returns 0 if is the same data, 1 if a > b, -1 if b > a
+ */
+export function dataCompare(a, b) {
+    // At reference level
+    if (a === b)
+        return 0;
+    if (a === null && b !== null)
+        return -1;
+    if (a !== null && b === null)
+        return 1;
+    if (a instanceof Uint8Array && b instanceof Uint8Array) {
+        let res;
+        const n = a.byteLength > b.byteLength ? b.byteLength : a.byteLength;
+        for (let i = 0; i < n; i++) {
+            res = a[i] - b[i];
+            if (res !== 0) {
+                return res > 0 ? 1 : -1;
+            }
+        }
+        res = a.byteLength - b.byteLength;
+        return res > 0 ? 1 : res < 0 ? -1 : 0;
+    }
+    if (typeof a === 'string') {
+        return a.localeCompare(b);
+    }
+    return a > b ? 1 : -1;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dcl/ecs",
-  "version": "7.0.6-4137912823.commit-aa69b28",
+  "version": "7.0.6-4153633895.commit-4aad233",
   "description": "Decentraland ECS",
   "main": "./dist/index.js",
   "typings": "./dist/index.d.ts",
@@ -27,7 +27,6 @@
     "ts-proto": "^1.112.0"
   },
   "dependencies": {
-    "@dcl/crdt": "7.0.6-4137912823.commit-aa69b28",
     "@dcl/js-runtime": "file:../js-runtime",
     "@dcl/protocol": "1.0.0-4114477251.commit-ccb88d6"
   },
@@ -41,5 +40,5 @@
     "displayName": "ECS",
     "tsconfig": "./tsconfig.json"
   },
-  "commit": "aa69b2868fae613a7b33b2f40e3f8eb689992c22"
+  "commit": "4aad23359bad8cca4eebdf0c1a236a725d82b32d"
 }