@dcl/playground-assets 7.0.6-4138167187.commit-c9d306a → 7.0.6-4153633895.commit-4aad233

package/dist/index.js

@@ -13011,7 +13011,8 @@
             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) {
@@ -13019,6 +13020,7 @@
                 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
             };
         }
@@ -13667,402 +13669,57 @@
         Schemas.Optional = IOptional;
     })(exports.Schemas || (exports.Schemas = {}));
 
-    var dist = {};
-
-    var gset = {};
-
-    var hasRequiredGset;
-
-    function requireGset () {
-    	if (hasRequiredGset) return gset;
-    	hasRequiredGset = 1;
-    	Object.defineProperty(gset, "__esModule", { value: true });
-    	gset.createVersionGSet = void 0;
-    	/**
-    	 *
-    	 * @returns a new GSet
-    	 */
-    	function createVersionGSet() {
-    	    const lastVersion = new Map();
-    	    return {
-    	        /**
-    	         *
-    	         * @param number
-    	         * @param version
-    	         * @returns
-    	         */
-    	        addTo(number, version) {
-    	            if (version < 0) {
-    	                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
-    	         */
-    	        get() {
-    	            const arr = [];
-    	            for (const [n, v] of lastVersion) {
-    	                for (let i = 0; i <= v; i++) {
-    	                    arr.push([n, i]);
-    	                }
-    	            }
-    	            return arr;
-    	        },
-    	        /**
-    	         * @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;
-    	        }
-    	    };
-    	}
-    	gset.createVersionGSet = createVersionGSet;
-    	
-    	return gset;
-    }
-
-    var types = {};
-
-    var hasRequiredTypes;
-
-    function requireTypes () {
-    	if (hasRequiredTypes) return types;
-    	hasRequiredTypes = 1;
-    	(function (exports) {
-    		Object.defineProperty(exports, "__esModule", { value: true });
-    		exports.ProcessMessageResultType = exports.CRDTMessageType = void 0;
-    		(function (CRDTMessageType) {
-    		    CRDTMessageType[CRDTMessageType["CRDTMT_PutComponentData"] = 1] = "CRDTMT_PutComponentData";
-    		    CRDTMessageType[CRDTMessageType["CRDTMT_DeleteEntity"] = 2] = "CRDTMT_DeleteEntity";
-    		})(exports.CRDTMessageType || (exports.CRDTMessageType = {}));
-    		(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";
-    		})(exports.ProcessMessageResultType || (exports.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
-    		//
-    		
-    } (types));
-    	return types;
-    }
-
-    var hasRequiredDist;
-
-    function requireDist () {
-    	if (hasRequiredDist) return dist;
-    	hasRequiredDist = 1;
-    	(function (exports) {
-    		var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    		    if (k2 === undefined) k2 = k;
-    		    var desc = Object.getOwnPropertyDescriptor(m, k);
-    		    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-    		      desc = { enumerable: true, get: function() { return m[k]; } };
-    		    }
-    		    Object.defineProperty(o, k2, desc);
-    		}) : (function(o, m, k, k2) {
-    		    if (k2 === undefined) k2 = k;
-    		    o[k2] = m[k];
-    		}));
-    		var __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {
-    		    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-    		};
-    		Object.defineProperty(exports, "__esModule", { value: true });
-    		exports.crdtProtocol = exports.stateIterator = exports.dataCompare = void 0;
-    		const gset_1 = requireGset();
-    		const types_1 = requireTypes();
-    		const globalBuffer = globalThis.Buffer;
-    		__exportStar(requireTypes(), exports);
-    		/**
-    		 * Compare raw data.
-    		 * @internal
-    		 * @returns 0 if is the same data, 1 if a > b, -1 if b > a
-    		 */
-    		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 (globalBuffer) {
-    		        /* istanbul ignore next */
-    		        if (a instanceof globalBuffer && b instanceof globalBuffer) {
-    		            /* istanbul ignore next */
-    		            return a.compare(b);
-    		        }
-    		    }
-    		    if (typeof a === 'string') {
-    		        return a.localeCompare(b);
-    		    }
-    		    return a > b ? 1 : -1;
-    		}
-    		exports.dataCompare = dataCompare;
-    		/**
-    		 * State iterator
-    		 * @internal
-    		 */
-    		function* stateIterator(state) {
-    		    for (const [componentId, value1] of state.components.entries()) {
-    		        for (const [entityId, value2] of value1.entries()) {
-    		            yield [componentId, entityId, value2];
-    		        }
-    		    }
-    		}
-    		exports.stateIterator = stateIterator;
-    		/**
-    		 * @public
-    		 * CRDT protocol.
-    		 * Stores the latest state, and decides whenever we have
-    		 * to process and store the new data in case its an update, or
-    		 * to discard and send our local value cause remote it's outdated.
-    		 */
-    		function crdtProtocol(entityUtils) {
-    		    /**
-    		     * Local state where we store the latest lamport timestamp
-    		     * and the raw data value
-    		     * @internal
-    		     */
-    		    const state = {
-    		        components: new Map(),
-    		        deletedEntities: (0, gset_1.createVersionGSet)()
-    		    };
-    		    /**
-    		     * We should call this fn in order to update the state
-    		     * @internal
-    		     */
-    		    function updateState(componentId, entityId, // todo: force type entity
-    		    data, remoteTimestamp) {
-    		        const componentIdValue = state.components.get(componentId);
-    		        const timestamp = Math.max(remoteTimestamp, componentIdValue?.get(entityId)?.timestamp || 0);
-    		        if (componentIdValue) {
-    		            componentIdValue.set(entityId, { timestamp, data });
-    		        }
-    		        else {
-    		            const componentIdValue = new Map();
-    		            componentIdValue.set(entityId, { timestamp, data });
-    		            state.components.set(componentId, componentIdValue);
-    		        }
-    		        return { timestamp, data };
-    		    }
-    		    /**
-    		     * Create an event for the specified key and store the new data and
-    		     * lamport timestmap incremented by one in the state.components.
-    		     * @public
-    		     */
-    		    function createComponentDataEvent(componentId, entityId, data) {
-    		        // Increment the timestamp
-    		        const timestamp = (state.components.get(componentId)?.get(entityId)?.timestamp || 0) + 1;
-    		        const msg = {
-    		            type: types_1.CRDTMessageType.CRDTMT_PutComponentData,
-    		            componentId,
-    		            entityId,
-    		            data,
-    		            timestamp
-    		        };
-    		        const res = processComponentDataMessage(msg);
-    		        if (res === types_1.ProcessMessageResultType.StateUpdatedTimestamp) {
-    		            return msg;
-    		        }
-    		        else {
-    		            return null;
-    		        }
-    		    }
-    		    /**
-    		     * Create an event for the specified key and store the new data and
-    		     * lamport timestmap incremented by one in the state.components.
-    		     * @public
-    		     */
-    		    function createDeleteEntityEvent(entityId) {
-    		        // Increment the timestamp
-    		        const message = {
-    		            type: types_1.CRDTMessageType.CRDTMT_DeleteEntity,
-    		            entityId
-    		        };
-    		        processDeleteEntityMessage(message);
-    		        return message;
-    		    }
-    		    /**
-    		     * 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 processComponentDataMessage(message) {
-    		        const [entityNumber, entityVersion] = entityUtils.fromEntityId(message.entityId);
-    		        if (state.deletedEntities.has(entityNumber, entityVersion)) {
-    		            return types_1.ProcessMessageResultType.EntityWasDeleted;
-    		        }
-    		        const { componentId, entityId, data, timestamp } = message;
-    		        const current = state.components.get(componentId)?.get(entityId);
-    		        // The received message is > than our current value, update our state.components.
-    		        if (!current || current.timestamp < timestamp) {
-    		            updateState(componentId, entityId, data, timestamp);
-    		            return types_1.ProcessMessageResultType.StateUpdatedTimestamp;
-    		        }
-    		        // Outdated Message. Resend our state message through the wire.
-    		        if (current.timestamp > timestamp) {
-    		            return types_1.ProcessMessageResultType.StateOutdatedTimestamp;
-    		        }
-    		        const currentDataGreater = dataCompare(current.data, data);
-    		        // Same data, same timestamp. Weirdo echo message.
-    		        if (currentDataGreater === 0) {
-    		            return types_1.ProcessMessageResultType.NoChanges;
-    		            // Current data is greater
-    		        }
-    		        else if (currentDataGreater > 0) {
-    		            return types_1.ProcessMessageResultType.StateOutdatedData;
-    		            // Curent data is lower
-    		        }
-    		        else {
-    		            updateState(componentId, entityId, data, timestamp);
-    		            return types_1.ProcessMessageResultType.StateUpdatedData;
-    		        }
-    		    }
-    		    /*
-    		     * @public
-    		     */
-    		    function processMessage(message) {
-    		        if (message.type === types_1.CRDTMessageType.CRDTMT_PutComponentData) {
-    		            return processComponentDataMessage(message);
-    		        }
-    		        else if (message.type === types_1.CRDTMessageType.CRDTMT_DeleteEntity) {
-    		            return processDeleteEntityMessage(message);
-    		        }
-    		        else {
-    		            return types_1.ProcessMessageResultType.NoChanges;
-    		        }
-    		    }
-    		    function processDeleteEntityMessage(message) {
-    		        const { entityId } = message;
-    		        const [entityNumber, entityVersion] = entityUtils.fromEntityId(message.entityId);
-    		        state.deletedEntities.addTo(entityNumber, entityVersion);
-    		        for (const [, payload] of state.components) {
-    		            payload.delete(entityId);
-    		        }
-    		        return types_1.ProcessMessageResultType.EntityDeleted;
-    		    }
-    		    /**
-    		     * Returns the current state
-    		     * @public
-    		     */
-    		    function getState() {
-    		        return state;
-    		    }
-    		    /**
-    		     * Returns the element state of a given element of the LWW-ElementSet
-    		     * @public
-    		     */
-    		    function getElementSetState(componentId, entityId) {
-    		        return state.components.get(componentId)?.get(entityId) || null;
-    		    }
-    		    return {
-    		        getElementSetState,
-    		        createComponentDataEvent,
-    		        createDeleteEntityEvent,
-    		        processMessage,
-    		        getState
-    		    };
-    		}
-    		exports.crdtProtocol = crdtProtocol;
-    		
-    } (dist));
-    	return dist;
+    /**
+     *
+     * @returns a new GSet
+     */
+    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;
+            }
+        };
     }
 
-    var distExports = requireDist();
-
-    var typesExports = requireTypes();
-
-    var gsetExports = requireGset();
-
     /**
      * @internal
      */
@@ -14128,7 +13785,7 @@
         let entityCounter = RESERVED_STATIC_ENTITIES;
         const usedEntities = new Set();
         let toRemoveEntities = [];
-        const removedEntities = gsetExports.createVersionGSet();
+        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}.`);
@@ -14173,10 +13830,12 @@
         }
         function releaseRemovedEntities() {
             const arr = toRemoveEntities;
-            toRemoveEntities = [];
-            for (const entity of arr) {
-                const [n, v] = exports.EntityUtils.fromEntityId(entity);
-                removedEntities.addTo(n, v);
+            if (arr.length) {
+                toRemoveEntities = [];
+                for (const entity of arr) {
+                    const [n, v] = exports.EntityUtils.fromEntityId(entity);
+                    removedEntities.addTo(n, v);
+                }
             }
             return arr;
         }
@@ -14192,10 +13851,9 @@
         }
         function updateUsedEntity(entity) {
             const [n, v] = exports.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++) {
@@ -14489,9 +14147,66 @@
         CrdtMessageType[CrdtMessageType["MAX_MESSAGE_TYPE"] = 4] = "MAX_MESSAGE_TYPE";
     })(exports.CrdtMessageType || (exports.CrdtMessageType = {}));
     /**
-     * @internal
+     * @public
      */
     const CRDT_MESSAGE_HEADER_LENGTH = 8;
+    exports.ProcessMessageResultType = void 0;
+    (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";
+    })(exports.ProcessMessageResultType || (exports.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
+    //
 
     /**
      * @internal
@@ -14642,18 +14357,18 @@
          * 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, exports.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);
@@ -14683,11 +14398,6 @@
      */
     function crdtSceneSystem(engine, onProcessEntityComponentChange) {
         const transports = [];
-        // CRDT Client
-        const crdtClient = distExports.crdtProtocol({
-            toEntityId: exports.EntityUtils.toEntityId,
-            fromEntityId: exports.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.
@@ -14764,20 +14474,9 @@
             const entitiesShouldBeCleaned = [];
             for (const msg of messagesToProcess) {
                 if (msg.type === exports.CrdtMessageType.DELETE_ENTITY) {
-                    crdtClient.processMessage({
-                        type: typesExports.CRDTMessageType.CRDTMT_DeleteEntity,
-                        entityId: msg.entityId
-                    });
                     entitiesShouldBeCleaned.push(msg.entityId);
                 }
                 else {
-                    const crdtMessage = {
-                        type: typesExports.CRDTMessageType.CRDTMT_PutComponentData,
-                        entityId: msg.entityId,
-                        componentId: msg.componentId,
-                        data: msg.type === exports.CrdtMessageType.PUT_COMPONENT ? msg.data : null,
-                        timestamp: msg.timestamp
-                    };
                     const entityState = engine.entityContainer.getEntityState(msg.entityId);
                     // Skip updates from removed entityes
                     if (entityState === exports.EntityState.Removed)
@@ -14787,144 +14486,73 @@
                         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 typesExports.ProcessMessageResultType.StateUpdatedTimestamp:
-                        case typesExports.ProcessMessageResultType.StateUpdatedData:
-                            // Add message to transport queue to be processed by others transports
-                            broadcastMessages.push(msg);
-                            // Process CRDT Message
-                            if (msg.type === exports.CrdtMessageType.DELETE_COMPONENT) {
-                                component.deleteFrom(msg.entityId, false);
+                    if (component) {
+                        const [conflictMessage] = component.updateFromCrdt(msg);
+                        if (conflictMessage) {
+                            const offset = bufferForOutdated.currentWriteOffset();
+                            if (conflictMessage.type === exports.CrdtMessageType.PUT_COMPONENT) {
+                                exports.PutComponentOperation.write(msg.entityId, conflictMessage.timestamp, conflictMessage.componentId, conflictMessage.data, bufferForOutdated);
                             }
                             else {
-                                const data = new ReadWriteByteBuffer(msg.data);
-                                component.upsertFromBinary(msg.entityId, data, false);
+                                exports.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 typesExports.ProcessMessageResultType.StateOutdatedData:
-                        case typesExports.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)) {
-                                    exports.PutComponentOperation.write(msg.entityId, ts, component, bufferForOutdated);
-                                }
-                                else {
-                                    exports.DeleteComponent.write(msg.entityId, component.componentId, ts, bufferForOutdated);
-                                }
-                                outdatedMessages.push({
-                                    ...msg,
-                                    messageBuffer: bufferForOutdated.buffer().subarray(offset, bufferForOutdated.currentWriteOffset())
-                                });
-                            }
-                            break;
-                        case typesExports.ProcessMessageResultType.NoChanges:
-                        case typesExports.ProcessMessageResultType.EntityDeleted:
-                        case typesExports.ProcessMessageResultType.EntityWasDeleted:
+                        }
                     }
                 }
             }
+            // 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 !== exports.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, exports.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 ? exports.CrdtMessageType.DELETE_COMPONENT : exports.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)
-                        ? exports.CrdtMessageType.PUT_COMPONENT
-                        : exports.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 === exports.CrdtMessageType.PUT_COMPONENT) {
-                            exports.PutComponentOperation.write(entity, timestamp, component, buffer);
+                    if (transports.some((t) => t.filter(message))) {
+                        if (message.type === exports.CrdtMessageType.PUT_COMPONENT) {
+                            exports.PutComponentOperation.write(message.entityId, message.timestamp, message.componentId, message.data, buffer);
                         }
-                        else {
-                            exports.DeleteComponent.write(entity, component.componentId, timestamp, buffer);
+                        else if (message.type === exports.CrdtMessageType.DELETE_COMPONENT) {
+                            exports.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();
                 exports.DeleteEntity.write(entityId, buffer);
                 crdtMessages.push({
@@ -14932,6 +14560,7 @@
                     entityId,
                     messageBuffer: buffer.buffer().subarray(offset, buffer.currentWriteOffset())
                 });
+                onProcessEntityComponentChange && onProcessEntityComponentChange(entityId, exports.CrdtMessageType.DELETE_ENTITY);
             }
             // Send CRDT messages to transports
             const transportBuffer = new ReadWriteByteBuffer();
@@ -14970,22 +14599,53 @@
             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
         };
     }
 
+    var CrdtUtils;
+    (function (CrdtUtils) {
+        (function (SynchronizedEntityType) {
+            // synchronizes entities with the NetworkSynchronized component only, used for networked games
+            SynchronizedEntityType[SynchronizedEntityType["NETWORKED"] = 0] = "NETWORKED";
+            // synchronizes entities needed by the renderer
+            SynchronizedEntityType[SynchronizedEntityType["RENDERER"] = 1] = "RENDERER";
+        })(CrdtUtils.SynchronizedEntityType || (CrdtUtils.SynchronizedEntityType = {}));
+    })(CrdtUtils || (CrdtUtils = {}));
+    /**
+     * Compare raw data.
+     * @internal
+     * @returns 0 if is the same data, 1 if a > b, -1 if b > a
+     */
+    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;
+    }
+
     /**
      * @internal
      */
@@ -14993,12 +14653,148 @@
         return Object.freeze({ ...val });
     }
 
+    function incrementTimestamp(entity, timestamps) {
+        const newTimestamp = (timestamps.get(entity) || 0) + 1;
+        timestamps.set(entity, newTimestamp);
+        return newTimestamp;
+    }
+    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 exports.ProcessMessageResultType.StateUpdatedTimestamp;
+            }
+            // Outdated Message. Resend our state message through the wire.
+            if (currentTimestamp > timestamp) {
+                // console.log('2', currentTimestamp, timestamp)
+                return exports.ProcessMessageResultType.StateOutdatedTimestamp;
+            }
+            // Deletes are idempotent
+            if (message.type === exports.CrdtMessageType.DELETE_COMPONENT && !data.has(entityId)) {
+                return exports.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 exports.ProcessMessageResultType.NoChanges;
+            }
+            else if (currentDataGreater > 0) {
+                // Current data is greater
+                return exports.ProcessMessageResultType.StateOutdatedData;
+            }
+            else {
+                // Curent data is lower
+                return exports.ProcessMessageResultType.StateUpdatedData;
+            }
+        }
+        return (msg) => {
+            /* istanbul ignore next */
+            if (msg.type !== exports.CrdtMessageType.PUT_COMPONENT && msg.type !== exports.CrdtMessageType.DELETE_COMPONENT)
+                /* istanbul ignore next */
+                return [null, data.get(msg.entityId)];
+            const action = crdtRuleForCurrentState(msg);
+            const entity = msg.entityId;
+            switch (action) {
+                case exports.ProcessMessageResultType.StateUpdatedData:
+                case exports.ProcessMessageResultType.StateUpdatedTimestamp: {
+                    timestamps.set(entity, msg.timestamp);
+                    if (msg.type === exports.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 exports.ProcessMessageResultType.StateOutdatedTimestamp:
+                case exports.ProcessMessageResultType.StateOutdatedData: {
+                    if (data.has(entity)) {
+                        const writeBuffer = new ReadWriteByteBuffer();
+                        schema.serialize(data.get(entity), writeBuffer);
+                        return [
+                            {
+                                type: exports.CrdtMessageType.PUT_COMPONENT,
+                                componentId,
+                                data: writeBuffer.toBinary(),
+                                entityId: entity,
+                                timestamp: timestamps.get(entity)
+                            },
+                            data.get(entity)
+                        ];
+                    }
+                    else {
+                        return [
+                            {
+                                type: exports.CrdtMessageType.DELETE_COMPONENT,
+                                componentId,
+                                entityId: entity,
+                                timestamp: timestamps.get(entity)
+                            },
+                            undefined
+                        ];
+                    }
+                }
+            }
+            return [null, data.get(entity)];
+        };
+    }
+    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: exports.CrdtMessageType.PUT_COMPONENT,
+                        componentId,
+                        entityId: entity,
+                        data: writeBuffer.toBinary(),
+                        timestamp: newTimestamp
+                    };
+                    yield msg;
+                }
+                else {
+                    const msg = {
+                        type: exports.CrdtMessageType.DELETE_COMPONENT,
+                        componentId,
+                        entityId: entity,
+                        timestamp: newTimestamp
+                    };
+                    yield msg;
+                }
+            }
+            dirtyIterator.clear();
+        };
+    }
     /**
      * @internal
      */
     function createComponentDefinitionFromSchema(componentName, componentId, schema) {
         const data = new Map();
         const dirtyIterator = new Set();
+        const timestamps = new Map();
         return {
             get componentId() {
                 return componentId;
@@ -15017,15 +14813,16 @@
             },
             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;
@@ -15078,6 +14875,7 @@
                     yield entity;
                 }
             },
+            getCrdtUpdates: createGetCrdtMessages(componentId, timestamps, dirtyIterator, schema, data),
             toBinary(entity) {
                 const component = data.get(entity);
                 if (!component) {
@@ -15087,45 +14885,9 @@
                 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();
             }
         };
     }
@@ -15346,9 +15108,7 @@
         }
         function removeEntity(entity) {
             for (const [, component] of componentsDefinition) {
-                if (component.has(entity)) {
-                    component.deleteFrom(entity);
-                }
+                component.entityDeleted(entity, true);
             }
             return entityContainer.removeEntity(entity);
         }
@@ -15504,12 +15264,9 @@
                 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,
@@ -15532,7 +15289,6 @@
             CameraEntity: 2,
             getEntityState: partialEngine.entityContainer.getEntityState,
             addTransport: crdtSystem.addTransport,
-            getCrdtState: crdtSystem.getCrdt,
             entityContainer: partialEngine.entityContainer
         };
     }
@@ -42525,14 +42281,17 @@
     exports.components = index;
     exports.createComponentDefinitionFromSchema = createComponentDefinitionFromSchema;
     exports.createEthereumProvider = createEthereumProvider;
+    exports.createGetCrdtMessages = createGetCrdtMessages;
     exports.createInputSystem = createInputSystem;
     exports.createPointerEventSystem = createPointerEventSystem;
     exports.createReactBasedUiSystem = createReactBasedUiSystem;
     exports.createTaskSystem = createTaskSystem;
+    exports.createUpdateFromCrdt = createUpdateFromCrdt;
     exports.cyclicParentingChecker = cyclicParentingChecker;
     exports.deepReadonly = deepReadonly;
     exports.engine = engine;
     exports.executeTask = executeTask;
+    exports.incrementTimestamp = incrementTimestamp;
     exports.inputSystem = inputSystem;
     exports.isListener = isListener;
     exports.onCommsMessage = onCommsMessage;