@dcl/playground-assets 7.0.6-3823801200.commit-32470bd → 7.0.6-3830539086.commit-6152fbd

package/dist/index.js

@@ -13130,6 +13130,80 @@
 
     var dist = {};
 
+    var gset = {};
+
+    var hasRequiredGset;
+
+    function requireGset () {
+    	if (hasRequiredGset) return gset;
+    	hasRequiredGset = 1;
+    	Object.defineProperty(gset, "__esModule", { value: true });
+    	gset.createGSet = void 0;
+    	/**
+    	 *
+    	 * @returns a new GSet
+    	 */
+    	function createGSet() {
+    	    const lastVersion = new Map();
+    	    return {
+    	        /**
+    	         *
+    	         * @param n
+    	         * @param v
+    	         * @returns
+    	         */
+    	        addTo(n, v) {
+    	            if (v < 0) {
+    	                return false;
+    	            }
+    	            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;
+    	            }
+    	            lastVersion.set(n, v);
+    	            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.createGSet = createGSet;
+    	
+    	return gset;
+    }
+
     var types = {};
 
     var hasRequiredTypes;
@@ -13137,8 +13211,71 @@
     function requireTypes () {
     	if (hasRequiredTypes) return types;
     	hasRequiredTypes = 1;
-    	Object.defineProperty(types, "__esModule", { value: true });
-    	
+    	(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;
     }
 
@@ -13163,46 +13300,57 @@
     		    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.sameData = void 0;
-    		__exportStar(requireTypes(), exports);
+    		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 sameData(a, b) {
+    		function dataCompare(a, b) {
     		    // At reference level
     		    if (a === b)
-    		        return true;
+    		        return 0;
+    		    if (a === null && b !== null)
+    		        return -1;
+    		    if (a !== null && b === null)
+    		        return 1;
     		    if (a instanceof Uint8Array && b instanceof Uint8Array) {
-    		        if (a.byteLength !== b.byteLength) {
-    		            return false;
-    		        }
-    		        for (let i = 0; i < a.byteLength; i++) {
-    		            if (a[i] !== b[i]) {
-    		                return false;
+    		        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;
     		            }
     		        }
-    		        return true;
+    		        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.equals(b);
+    		            return a.compare(b);
     		        }
     		    }
-    		    return false;
+    		    if (typeof a === 'string') {
+    		        return a.localeCompare(b);
+    		    }
+    		    return a > b ? 1 : -1;
     		}
-    		exports.sameData = sameData;
+    		exports.dataCompare = dataCompare;
     		/**
     		 * State iterator
     		 * @internal
     		 */
     		function* stateIterator(state) {
-    		    for (const [key1, value1] of state.entries()) {
-    		        for (const [key2, value2] of value1.entries()) {
-    		            yield [key1, key2, value2];
+    		    for (const [componentId, value1] of state.components.entries()) {
+    		        for (const [entityId, value2] of value1.entries()) {
+    		            yield [componentId, entityId, value2];
     		        }
     		    }
     		}
@@ -13214,40 +13362,70 @@
     		 * 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() {
+    		function crdtProtocol(entityUtils) {
     		    /**
     		     * Local state where we store the latest lamport timestamp
     		     * and the raw data value
     		     * @internal
     		     */
-    		    const state = new Map();
+    		    const state = {
+    		        components: new Map(),
+    		        deletedEntities: (0, gset_1.createGSet)()
+    		    };
     		    /**
     		     * We should call this fn in order to update the state
     		     * @internal
     		     */
-    		    function updateState(key1, key2, data, remoteTimestamp) {
-    		        const key1Value = state.get(key1);
-    		        const timestamp = Math.max(remoteTimestamp, key1Value?.get(key2)?.timestamp || 0);
-    		        if (key1Value) {
-    		            key1Value.set(key2, { timestamp, data });
+    		    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 newKey1Value = new Map();
-    		            newKey1Value.set(key2, { timestamp, data });
-    		            state.set(key1, newKey1Value);
+    		            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.
+    		     * 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 createEvent(key1, key2, data) {
+    		    function createDeleteEntityEvent(entityId) {
     		        // Increment the timestamp
-    		        const timestamp = (state.get(key1)?.get(key2)?.timestamp || 0) + 1;
-    		        updateState(key1, key2, data, timestamp);
-    		        return { key1, key2, data, 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
@@ -13258,42 +13436,59 @@
     		     * If it was an outdated message, then we return void
     		     * @public
     		     */
-    		    function processMessage(message) {
-    		        const { key1, key2, data, timestamp } = message;
-    		        const current = state.get(key1)?.get(key2);
-    		        // The received message is > than our current value, update our state.
+    		    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(key1, key2, data, timestamp);
-    		            return message;
+    		            updateState(componentId, entityId, data, timestamp);
+    		            return types_1.ProcessMessageResultType.StateUpdatedTimestamp;
     		        }
     		        // Outdated Message. Resend our state message through the wire.
     		        if (current.timestamp > timestamp) {
-    		            return {
-    		                key1,
-    		                key2,
-    		                data: current.data,
-    		                timestamp: current.timestamp
-    		            };
+    		            return types_1.ProcessMessageResultType.StateOutdatedData;
     		        }
+    		        const currentDataGreater = dataCompare(current.data, data);
     		        // Same data, same timestamp. Weirdo echo message.
-    		        if (sameData(current.data, data)) {
-    		            return message;
+    		        if (currentDataGreater === 0) {
+    		            return types_1.ProcessMessageResultType.NoChanges;
+    		            // Current data is greater
     		        }
-    		        // Race condition, same timestamp diff data.
-    		        function compareData(current, data) {
-    		            // Null value wins
-    		            return !current || current > data;
+    		        else if (currentDataGreater > 0) {
+    		            return types_1.ProcessMessageResultType.StateOutdatedData;
+    		            // Curent data is lower
     		        }
-    		        if (compareData(current.data, data)) {
-    		            return {
-    		                key1,
-    		                key2,
-    		                data: current.data,
-    		                timestamp: current.timestamp
-    		            };
+    		        else {
+    		            updateState(componentId, entityId, data, timestamp);
+    		            return types_1.ProcessMessageResultType.StateUpdatedData;
     		        }
-    		        updateState(key1, key2, data, timestamp).data;
-    		        return message;
+    		    }
+    		    /*
+    		     * @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
@@ -13306,12 +13501,13 @@
     		     * Returns the element state of a given element of the LWW-ElementSet
     		     * @public
     		     */
-    		    function getElementSetState(key1, key2) {
-    		        return state.get(key1)?.get(key2) || null;
+    		    function getElementSetState(componentId, entityId) {
+    		        return state.components.get(componentId)?.get(entityId) || null;
     		    }
     		    return {
     		        getElementSetState,
-    		        createEvent,
+    		        createComponentDataEvent,
+    		        createDeleteEntityEvent,
     		        processMessage,
     		        getState
     		    };
@@ -13324,6 +13520,171 @@
 
     var distExports = requireDist();
 
+    var typesExports = requireTypes();
+
+    var gsetExports = requireGset();
+
+    const MAX_U16 = 0xffff;
+    const MASK_UPPER_16_ON_32 = 0xffff0000;
+    const AMOUNT_VERSION_AVAILABLE = MAX_U16 + 1;
+    // This type matches with @dcl/crdt entity type.
+    /**
+     * @public This first 512 entities are reserved by the renderer
+     */
+    const RESERVED_STATIC_ENTITIES = 512;
+    /**
+     * @public
+     */
+    const MAX_ENTITY_NUMBER = MAX_U16;
+    exports.EntityUtils = void 0;
+    (function (EntityUtils) {
+        /**
+         * @returns [entityNumber, entityVersion]
+         */
+        function fromEntityId(entityId) {
+            return [
+                (entityId & MAX_U16) >>> 0,
+                (((entityId & MASK_UPPER_16_ON_32) >> 16) & MAX_U16) >>> 0
+            ];
+        }
+        EntityUtils.fromEntityId = fromEntityId;
+        /**
+         * @returns compound number from entityNumber and entityVerison
+         */
+        function toEntityId(entityNumber, entityVersion) {
+            return (((entityNumber & MAX_U16) | ((entityVersion & MAX_U16) << 16)) >>>
+                0);
+        }
+        EntityUtils.toEntityId = toEntityId;
+    })(exports.EntityUtils || (exports.EntityUtils = {}));
+    /**
+     * @public
+     */
+    exports.EntityState = void 0;
+    (function (EntityState) {
+        EntityState[EntityState["Unknown"] = 0] = "Unknown";
+        /**
+         * The entity was generated and added to the usedEntities set
+         */
+        EntityState[EntityState["UsedEntity"] = 1] = "UsedEntity";
+        /**
+         * The entity was removed from current engine or remotely
+         */
+        EntityState[EntityState["Removed"] = 2] = "Removed";
+        /**
+         * The entity is reserved number.
+         */
+        EntityState[EntityState["Reserved"] = 3] = "Reserved";
+    })(exports.EntityState || (exports.EntityState = {}));
+    function EntityContainer() {
+        let entityCounter = RESERVED_STATIC_ENTITIES;
+        const usedEntities = new Set();
+        let toRemoveEntities = [];
+        const removedEntities = gsetExports.createGSet();
+        function generateNewEntity() {
+            if (entityCounter > MAX_ENTITY_NUMBER - 1) {
+                throw new Error(`It fails trying to generate an entity out of range ${MAX_ENTITY_NUMBER}.`);
+            }
+            const entityNumber = entityCounter++;
+            const entityVersion = removedEntities.getMap().has(entityNumber)
+                ? removedEntities.getMap().get(entityNumber) + 1
+                : 0;
+            const entity = exports.EntityUtils.toEntityId(entityNumber, entityVersion);
+            usedEntities.add(entity);
+            return entity;
+        }
+        function generateEntity() {
+            // If all entities until `entityCounter` are being used, we need to generate another one
+            if (usedEntities.size + RESERVED_STATIC_ENTITIES >= entityCounter) {
+                return generateNewEntity();
+            }
+            for (const [number, version] of removedEntities.getMap()) {
+                if (version < MAX_U16) {
+                    const entity = exports.EntityUtils.toEntityId(number, version + 1);
+                    // If the entity is not being used, we can re-use it
+                    // If the entity was removed in this tick, we're not counting for the usedEntities, but we have it in the toRemoveEntityArray
+                    if (!usedEntities.has(entity) && !toRemoveEntities.includes(entity)) {
+                        usedEntities.add(entity);
+                        return entity;
+                    }
+                }
+            }
+            return generateNewEntity();
+        }
+        function removeEntity(entity) {
+            if (entity < RESERVED_STATIC_ENTITIES)
+                return false;
+            if (usedEntities.has(entity)) {
+                usedEntities.delete(entity);
+                toRemoveEntities.push(entity);
+            }
+            else {
+                updateRemovedEntity(entity);
+            }
+            return true;
+        }
+        function releaseRemovedEntities() {
+            const arr = toRemoveEntities;
+            toRemoveEntities = [];
+            for (const entity of arr) {
+                const [n, v] = exports.EntityUtils.fromEntityId(entity);
+                removedEntities.addTo(n, v);
+            }
+            return arr;
+        }
+        function updateRemovedEntity(entity) {
+            const [n, v] = exports.EntityUtils.fromEntityId(entity);
+            // Update the removed entities map
+            removedEntities.addTo(n, v);
+            // Remove the usedEntities if exist
+            for (let i = 0; i <= v; i++) {
+                usedEntities.delete(exports.EntityUtils.toEntityId(n, i));
+            }
+            return true;
+        }
+        function updateUsedEntity(entity) {
+            const [n, v] = exports.EntityUtils.fromEntityId(entity);
+            const removedVersion = removedEntities.getMap().get(n);
+            if (removedVersion !== undefined && removedVersion >= v) {
+                return false;
+            }
+            // Update
+            if (v > 0) {
+                for (let i = 0; i <= v - 1; i++) {
+                    usedEntities.delete(exports.EntityUtils.toEntityId(n, i));
+                }
+                removedEntities.addTo(n, v - 1);
+            }
+            usedEntities.add(entity);
+            return true;
+        }
+        function getEntityState(entity) {
+            const [n, v] = exports.EntityUtils.fromEntityId(entity);
+            if (n < RESERVED_STATIC_ENTITIES) {
+                return exports.EntityState.Reserved;
+            }
+            if (usedEntities.has(entity)) {
+                return exports.EntityState.UsedEntity;
+            }
+            const removedVersion = removedEntities.getMap().get(n);
+            if (removedVersion !== undefined && removedVersion >= v) {
+                return exports.EntityState.Removed;
+            }
+            return exports.EntityState.Unknown;
+        }
+        return {
+            generateEntity,
+            removeEntity,
+            getExistingEntities() {
+                return new Set(usedEntities);
+            },
+            getEntityState,
+            releaseRemovedEntities,
+            updateRemovedEntity,
+            updateUsedEntity
+        };
+    }
+
     var utf8Exports = requireUtf8();
 
     /**
@@ -13583,114 +13944,204 @@
         };
     }
 
-    /**
-     * The wire message is the top-level message that can be packed
-     *  inside it can contain a data with another structure or protocol
-     *
-     * Each wire message has three primitive property that it'll never change
-     *   ---> length        uint32 (message size up to 4,294,967,295)
-     *   ---> version       uint32 (for now just a number which is zero)
-     *   ---> message type  uint32
-     * The length indicates how many bytes are above self, the version in
-     * combination with message type defines the set of handlers that will be
-     * available to process the message
-     *
-     */
-    var WireMessage;
-    (function (WireMessage) {
-        let Enum;
-        (function (Enum) {
-            Enum[Enum["RESERVED"] = 0] = "RESERVED";
-            // Component Operation
-            Enum[Enum["PUT_COMPONENT"] = 1] = "PUT_COMPONENT";
-            Enum[Enum["DELETE_COMPONENT"] = 2] = "DELETE_COMPONENT";
-            Enum[Enum["MAX_MESSAGE_TYPE"] = 3] = "MAX_MESSAGE_TYPE";
-        })(Enum = WireMessage.Enum || (WireMessage.Enum = {}));
-        WireMessage.HEADER_LENGTH = 8;
-        /**
-         * Validate if the message incoming is completed
-         * @param buf - ByteBuffer
-         */
-        function validate(buf) {
-            const rem = buf.remainingBytes();
-            if (rem < WireMessage.HEADER_LENGTH) {
-                return false;
-            }
-            const messageLength = buf.getUint32(buf.currentReadOffset());
-            if (rem < messageLength) {
-                return false;
-            }
-            return true;
+    exports.CrdtMessageType = void 0;
+    (function (CrdtMessageType) {
+        CrdtMessageType[CrdtMessageType["RESERVED"] = 0] = "RESERVED";
+        // Component Operation
+        CrdtMessageType[CrdtMessageType["PUT_COMPONENT"] = 1] = "PUT_COMPONENT";
+        CrdtMessageType[CrdtMessageType["DELETE_COMPONENT"] = 2] = "DELETE_COMPONENT";
+        CrdtMessageType[CrdtMessageType["DELETE_ENTITY"] = 3] = "DELETE_ENTITY";
+        CrdtMessageType[CrdtMessageType["MAX_MESSAGE_TYPE"] = 4] = "MAX_MESSAGE_TYPE";
+    })(exports.CrdtMessageType || (exports.CrdtMessageType = {}));
+    const CRDT_MESSAGE_HEADER_LENGTH = 8;
+
+    exports.DeleteComponent = void 0;
+    (function (DeleteComponent) {
+        // TODO: change timestamp to 32 bit and remove buffer length (-8 bytes)
+        DeleteComponent.MESSAGE_HEADER_LENGTH = 20;
+        /**
+         * Write DeleteComponent message
+         */
+        function write(entity, componentId, timestamp, buf) {
+            // reserve the beginning
+            const messageLength = CRDT_MESSAGE_HEADER_LENGTH + DeleteComponent.MESSAGE_HEADER_LENGTH;
+            const startMessageOffset = buf.incrementWriteOffset(messageLength);
+            // Write CrdtMessage header
+            buf.setUint32(startMessageOffset, messageLength);
+            buf.setUint32(startMessageOffset + 4, exports.CrdtMessageType.DELETE_COMPONENT);
+            // Write ComponentOperation header
+            buf.setUint32(startMessageOffset + 8, entity);
+            buf.setUint32(startMessageOffset + 12, componentId);
+            // TODO: change timestamp to 32bit (-4 bytes)
+            buf.setUint64(startMessageOffset + 16, BigInt(timestamp));
+            // TODO: remove buffer length (-4 bytes)
+            buf.setUint32(startMessageOffset + 24, 0);
         }
-        WireMessage.validate = validate;
-        function readHeader(buf) {
-            if (!validate(buf)) {
+        DeleteComponent.write = write;
+        function read(buf) {
+            const header = CrdtMessageProtocol.readHeader(buf);
+            if (!header) {
                 return null;
             }
-            return {
-                length: buf.readUint32(),
-                type: buf.readUint32()
+            if (header.type !== exports.CrdtMessageType.DELETE_COMPONENT) {
+                throw new Error('DeleteComponentOperation tried to read another message type.');
+            }
+            const msg = {
+                ...header,
+                entityId: buf.readUint32(),
+                componentId: buf.readInt32(),
+                timestamp: Number(buf.readUint64())
             };
+            // TODO: remove buffer length
+            buf.incrementReadOffset(4);
+            return msg;
         }
-        WireMessage.readHeader = readHeader;
-        function getType(component, entity) {
-            return component.has(entity) ? Enum.PUT_COMPONENT : Enum.DELETE_COMPONENT;
-        }
-        WireMessage.getType = getType;
-    })(WireMessage || (WireMessage = {}));
-    var WireMessage$1 = WireMessage;
+        DeleteComponent.read = read;
+    })(exports.DeleteComponent || (exports.DeleteComponent = {}));
 
-    var ComponentOperation;
-    (function (ComponentOperation) {
-        ComponentOperation.MESSAGE_HEADER_LENGTH = 20;
+    exports.PutComponentOperation = void 0;
+    (function (PutComponentOperation) {
+        PutComponentOperation.MESSAGE_HEADER_LENGTH = 20;
         /**
          * Call this function for an optimal writing data passing the ByteBuffer
          *  already allocated
          */
-        function write(type, entity, timestamp, componentDefinition, buf) {
+        function write(entity, timestamp, componentDefinition, buf) {
             // reserve the beginning
-            const startMessageOffset = buf.incrementWriteOffset(WireMessage$1.HEADER_LENGTH + ComponentOperation.MESSAGE_HEADER_LENGTH);
+            const startMessageOffset = buf.incrementWriteOffset(CRDT_MESSAGE_HEADER_LENGTH + PutComponentOperation.MESSAGE_HEADER_LENGTH);
             // write body
-            if (type === WireMessage$1.Enum.PUT_COMPONENT) {
-                componentDefinition.writeToByteBuffer(entity, buf);
-            }
+            componentDefinition.writeToByteBuffer(entity, buf);
             const messageLength = buf.size() - startMessageOffset;
-            // Write WireMessage header
+            // Write CrdtMessage header
             buf.setUint32(startMessageOffset, messageLength);
-            buf.setUint32(startMessageOffset + 4, type);
+            buf.setUint32(startMessageOffset + 4, exports.CrdtMessageType.PUT_COMPONENT);
             // Write ComponentOperation header
             buf.setUint32(startMessageOffset + 8, entity);
             buf.setUint32(startMessageOffset + 12, componentDefinition._id);
             buf.setUint64(startMessageOffset + 16, BigInt(timestamp));
-            buf.setUint32(startMessageOffset + 24, messageLength - ComponentOperation.MESSAGE_HEADER_LENGTH - WireMessage$1.HEADER_LENGTH);
+            const newLocal = messageLength - PutComponentOperation.MESSAGE_HEADER_LENGTH - CRDT_MESSAGE_HEADER_LENGTH;
+            buf.setUint32(startMessageOffset + 24, newLocal);
         }
-        ComponentOperation.write = write;
+        PutComponentOperation.write = write;
         function read(buf) {
-            const header = WireMessage$1.readHeader(buf);
+            const header = CrdtMessageProtocol.readHeader(buf);
             if (!header) {
                 return null;
             }
-            const common = {
+            if (header.type !== exports.CrdtMessageType.PUT_COMPONENT) {
+                throw new Error('PutComponentOperation tried to read another message type.');
+            }
+            return {
                 ...header,
-                entity: buf.readUint32(),
+                entityId: buf.readUint32(),
                 componentId: buf.readInt32(),
-                timestamp: Number(buf.readUint64())
+                timestamp: Number(buf.readUint64()),
+                data: buf.readBuffer()
             };
-            if (header.type === WireMessage$1.Enum.DELETE_COMPONENT) {
-                return common;
+        }
+        PutComponentOperation.read = read;
+    })(exports.PutComponentOperation || (exports.PutComponentOperation = {}));
+
+    exports.DeleteEntity = void 0;
+    (function (DeleteEntity) {
+        DeleteEntity.MESSAGE_HEADER_LENGTH = 4;
+        function write(entity, buf) {
+            // Write CrdtMessage header
+            buf.writeUint32(CRDT_MESSAGE_HEADER_LENGTH + 4);
+            buf.writeUint32(exports.CrdtMessageType.DELETE_ENTITY);
+            // body
+            buf.writeUint32(entity);
+        }
+        DeleteEntity.write = write;
+        function read(buf) {
+            const header = CrdtMessageProtocol.readHeader(buf);
+            if (!header) {
+                return null;
+            }
+            if (header.type !== exports.CrdtMessageType.DELETE_ENTITY) {
+                throw new Error('DeleteComponentOperation tried to read another message type.');
             }
             return {
-                ...common,
-                data: buf.readBuffer()
+                ...header,
+                entityId: buf.readUint32()
+            };
+        }
+        DeleteEntity.read = read;
+    })(exports.DeleteEntity || (exports.DeleteEntity = {}));
+
+    exports.CrdtMessageProtocol = void 0;
+    (function (CrdtMessageProtocol) {
+        /**
+         * Validate if the message incoming is completed
+         * @param buf - ByteBuffer
+         */
+        function validate(buf) {
+            const rem = buf.remainingBytes();
+            if (rem < CRDT_MESSAGE_HEADER_LENGTH) {
+                return false;
+            }
+            const messageLength = buf.getUint32(buf.currentReadOffset());
+            if (rem < messageLength) {
+                return false;
+            }
+            return true;
+        }
+        CrdtMessageProtocol.validate = validate;
+        /**
+         * Get the current header, consuming the bytes involved.
+         * @param buf - ByteBuffer
+         * @returns header or null if there is no validated message
+         */
+        function readHeader(buf) {
+            if (!validate(buf)) {
+                return null;
+            }
+            return {
+                length: buf.readUint32(),
+                type: buf.readUint32()
             };
         }
-        ComponentOperation.read = read;
-    })(ComponentOperation || (ComponentOperation = {}));
+        CrdtMessageProtocol.readHeader = readHeader;
+        /**
+         * Get the current header, without consuming the bytes involved.
+         * @param buf - ByteBuffer
+         * @returns header or null if there is no validated message
+         */
+        function getHeader(buf) {
+            if (!validate(buf)) {
+                return null;
+            }
+            const currentOffset = buf.currentReadOffset();
+            return {
+                length: buf.getUint32(currentOffset),
+                type: buf.getUint32(currentOffset + 4)
+            };
+        }
+        CrdtMessageProtocol.getHeader = getHeader;
+        /**
+         * Consume the incoming message without processing it.
+         * @param buf - ByteBuffer
+         * @returns true in case of success or false if there is no valid message.
+         */
+        function consumeMessage(buf) {
+            const header = getHeader(buf);
+            if (!header) {
+                return false;
+            }
+            buf.incrementReadOffset(header.length);
+            return true;
+        }
+        CrdtMessageProtocol.consumeMessage = consumeMessage;
+    })(exports.CrdtMessageProtocol || (exports.CrdtMessageProtocol = {}));
+    var CrdtMessageProtocol = exports.CrdtMessageProtocol;
 
     function crdtSceneSystem(engine, onProcessEntityComponentChange) {
         const transports = [];
         // CRDT Client
-        const crdtClient = distExports.crdtProtocol();
+        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.
@@ -13712,21 +14163,47 @@
                 const buffer = createByteBuffer({
                     reading: { buffer: chunkMessage, currentOffset: 0 }
                 });
-                while (WireMessage$1.validate(buffer)) {
+                let header;
+                while ((header = CrdtMessageProtocol.getHeader(buffer))) {
                     const offset = buffer.currentReadOffset();
-                    const message = ComponentOperation.read(buffer);
-                    const { type, entity, componentId, data, timestamp } = message;
-                    receivedMessages.push({
-                        type,
-                        entity,
-                        componentId,
-                        data,
-                        timestamp,
-                        transportId,
-                        messageBuffer: buffer
-                            .buffer()
-                            .subarray(offset, buffer.currentReadOffset())
-                    });
+                    if (header.type === exports.CrdtMessageType.DELETE_COMPONENT) {
+                        const message = exports.DeleteComponent.read(buffer);
+                        receivedMessages.push({
+                            ...header,
+                            ...message,
+                            transportId,
+                            messageBuffer: buffer
+                                .buffer()
+                                .subarray(offset, buffer.currentReadOffset())
+                        });
+                    }
+                    else if (header.type === exports.CrdtMessageType.PUT_COMPONENT) {
+                        const message = exports.PutComponentOperation.read(buffer);
+                        receivedMessages.push({
+                            ...header,
+                            ...message,
+                            transportId,
+                            messageBuffer: buffer
+                                .buffer()
+                                .subarray(offset, buffer.currentReadOffset())
+                        });
+                    }
+                    else if (header.type === exports.CrdtMessageType.DELETE_ENTITY) {
+                        const message = exports.DeleteEntity.read(buffer);
+                        receivedMessages.push({
+                            ...header,
+                            ...message,
+                            transportId,
+                            messageBuffer: buffer
+                                .buffer()
+                                .subarray(offset, buffer.currentReadOffset())
+                        });
+                        // Unknown message, we skip it
+                    }
+                    else {
+                        // consume the message
+                        buffer.incrementReadOffset(header.length);
+                    }
                 }
                 // TODO: do something if buffler.len>0
             };
@@ -13746,54 +14223,107 @@
         async function receiveMessages() {
             const messagesToProcess = getMessages(receivedMessages);
             const bufferForOutdated = createByteBuffer();
-            for (const message of messagesToProcess) {
-                const { data, timestamp, componentId, entity, type } = message;
-                const crdtMessage = {
-                    key1: entity,
-                    key2: componentId,
-                    data: data || null,
-                    timestamp: timestamp
-                };
-                const component = engine.getComponentOrNull(componentId);
-                if (component?.isDirty(entity)) {
-                    crdtClient.createEvent(entity, component._id, component.toBinaryOrNull(entity)?.toBinary() || null);
-                }
-                const current = crdtClient.processMessage(crdtMessage);
-                if (!component) {
-                    continue;
-                }
-                // 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
-                if (crdtMessage !== current) {
-                    const offset = bufferForOutdated.currentWriteOffset();
-                    const type = WireMessage$1.getType(component, entity);
-                    const ts = current.timestamp;
-                    ComponentOperation.write(type, entity, ts, component, bufferForOutdated);
-                    outdatedMessages.push({
-                        ...message,
-                        timestamp: current.timestamp,
-                        messageBuffer: bufferForOutdated
-                            .buffer()
-                            .subarray(offset, bufferForOutdated.currentWriteOffset())
+            const entitiesShouldBeCleaned = [];
+            for (const msg of messagesToProcess) {
+                // TODO: emit delete entity to el onCrdtMessage
+                if (msg.type === exports.CrdtMessageType.DELETE_ENTITY) {
+                    crdtClient.processMessage({
+                        type: typesExports.CRDTMessageType.CRDTMT_DeleteEntity,
+                        entityId: msg.entityId
                     });
+                    entitiesShouldBeCleaned.push(msg.entityId);
                 }
                 else {
-                    // Add message to transport queue to be processed by others transports
-                    broadcastMessages.push(message);
-                    // Process CRDT Message
-                    if (type === WireMessage$1.Enum.DELETE_COMPONENT) {
-                        component.deleteFrom(entity, false);
+                    // TODO: emit pu/delete component to el onCrdtMessage
+                    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)
+                        continue;
+                    // Entities with unknown entities should update its entity state
+                    if (entityState === exports.EntityState.Unknown) {
+                        engine.entityContainer.updateUsedEntity(msg.entityId);
                     }
-                    else {
-                        const opts = {
-                            reading: { buffer: message.data, currentOffset: 0 }
-                        };
-                        const data = createByteBuffer(opts);
-                        component.upsertFromBinary(message.entity, data, false);
+                    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._id, msg.entityId, component.toBinaryOrNull(msg.entityId)?.toBinary() || null);
                     }
-                    onProcessEntityComponentChange &&
-                        onProcessEntityComponentChange(entity, component, type);
+                    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);
+                            }
+                            else {
+                                const opts = {
+                                    reading: { buffer: msg.data, currentOffset: 0 }
+                                };
+                                const data = createByteBuffer(opts);
+                                component.upsertFromBinary(msg.entityId, data, false);
+                            }
+                            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._id, 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:
+                    }
+                }
+            }
+            // TODO: emit delete entity to el onCrdtMessage
+            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) {
+                        outdatedMessages.splice(i, 1);
+                    }
+                }
+                for (const definition of engine.componentsIter()) {
+                    definition.deleteFrom(entity, false);
                 }
+                engine.entityContainer.updateRemovedEntity(entity);
+                onProcessEntityComponentChange &&
+                    onProcessEntityComponentChange(entity, exports.CrdtMessageType.DELETE_ENTITY);
             }
         }
         /**
@@ -13811,15 +14341,20 @@
                         entitySet = [];
                         dirtyMap.set(component, entitySet);
                     }
-                    entitySet.push(entity);
                     // 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
-                    crdtClient.createEvent(entity, component._id, componentValue);
-                    onProcessEntityComponentChange &&
-                        onProcessEntityComponentChange(entity, component, componentValue === null
-                            ? WireMessage$1.Enum.DELETE_COMPONENT
-                            : WireMessage$1.Enum.PUT_COMPONENT);
+                    // if update goes bad, the entity doesn't accept put anymore (it's added to deleted entities set)
+                    if (crdtClient.createComponentDataEvent(component._id, 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;
@@ -13827,7 +14362,7 @@
         /**
          * Iterates the dirty map and generates crdt messages to be send
          */
-        async function sendMessages(dirtyEntities) {
+        async function sendMessages(dirtyEntities, deletedEntities) {
             // CRDT Messages will be the merge between the recieved transport messages and the new crdt messages
             const crdtMessages = getMessages(broadcastMessages);
             const outdatedMessagesBkp = getMessages(outdatedMessages);
@@ -13837,19 +14372,26 @@
                     // Component will be always defined here since dirtyMap its an iterator of engine.componentsDefinition
                     const { timestamp } = crdtClient
                         .getState()
-                        .get(entity)
-                        .get(component._id);
+                        .components.get(component._id)
+                        .get(entity);
                     const offset = buffer.currentWriteOffset();
-                    const type = WireMessage$1.getType(component, entity);
+                    const type = component.has(entity)
+                        ? exports.CrdtMessageType.PUT_COMPONENT
+                        : exports.CrdtMessageType.DELETE_COMPONENT;
                     const transportMessage = {
                         type,
+                        entityId: entity,
                         componentId: component._id,
-                        entity,
                         timestamp
                     };
                     // Avoid creating messages if there is no transport that will handle it
                     if (transports.some((t) => t.filter(transportMessage))) {
-                        ComponentOperation.write(type, entity, timestamp, component, buffer);
+                        if (transportMessage.type === exports.CrdtMessageType.PUT_COMPONENT) {
+                            exports.PutComponentOperation.write(entity, timestamp, component, buffer);
+                        }
+                        else {
+                            exports.DeleteComponent.write(entity, component._id, timestamp, buffer);
+                        }
                         crdtMessages.push({
                             ...transportMessage,
                             messageBuffer: buffer
@@ -13859,6 +14401,19 @@
                     }
                 }
             }
+            // After all updates, I execute the DeletedEntity messages
+            for (const entityId of deletedEntities) {
+                crdtClient.createDeleteEntityEvent(entityId);
+                const offset = buffer.currentWriteOffset();
+                exports.DeleteEntity.write(entityId, buffer);
+                crdtMessages.push({
+                    type: exports.CrdtMessageType.DELETE_ENTITY,
+                    entityId,
+                    messageBuffer: buffer
+                        .buffer()
+                        .subarray(offset, buffer.currentWriteOffset())
+                });
+            }
             // Send CRDT messages to transports
             const transportBuffer = createByteBuffer();
             for (const index in transports) {
@@ -13869,8 +14424,11 @@
                 // So we can fix their crdt state
                 for (const message of outdatedMessagesBkp) {
                     if (message.transportId === transportIndex &&
+                        // TODO: This is an optimization, the state should converge anyway, whatever the message is sent.
                         // Avoid sending multiple messages for the same entity-componentId
-                        !crdtMessages.find((m) => m.entity === message.entity &&
+                        !crdtMessages.find((m) => m.entityId === message.entityId &&
+                            // TODO: as any, with multiple type of messages, it should have many checks before the check for similar messages
+                            m.componentId &&
                             m.componentId === message.componentId)) {
                         transportBuffer.writeBuffer(message.messageBuffer, false);
                     }
@@ -14058,79 +14616,6 @@
         };
     }
 
-    const MAX_U16 = 0xffff;
-    const MASK_UPPER_16_ON_32 = 0xffff0000;
-    const AMOUNT_VERSION_AVAILABLE = MAX_U16 + 1;
-    /**
-     * @public This first 512 entities are reserved by the renderer
-     */
-    const RESERVED_STATIC_ENTITIES = 512;
-    /**
-     * @public
-     */
-    const MAX_ENTITY_NUMBER = MAX_U16;
-    function EntityContainer() {
-        let entityCounter = RESERVED_STATIC_ENTITIES;
-        const usedEntities = new Set();
-        const removedEntities = new Map();
-        function entityVersion(entity) {
-            return (((entity & MASK_UPPER_16_ON_32) >> 16) & MAX_U16) >>> 0;
-        }
-        function entityNumber(entity) {
-            return (entity & MAX_U16) >>> 0;
-        }
-        function entityId(entityNumber, entityVersion) {
-            return (((entityNumber & MAX_U16) | ((entityVersion & MAX_U16) << 16)) >>>
-                0);
-        }
-        function generateNewEntity() {
-            if (entityCounter > MAX_ENTITY_NUMBER - 1) {
-                throw new Error(`It fails trying to generate an entity out of range ${MAX_ENTITY_NUMBER}.`);
-            }
-            const entity = entityCounter++;
-            usedEntities.add(entity);
-            return entity;
-        }
-        function generateEntity() {
-            if (usedEntities.size + RESERVED_STATIC_ENTITIES >= entityCounter) {
-                return generateNewEntity();
-            }
-            for (const [number, version] of removedEntities) {
-                if (version < MAX_U16) {
-                    const entity = entityId(number, version + 1);
-                    usedEntities.add(entity);
-                    removedEntities.delete(number);
-                    return entity;
-                }
-            }
-            return generateNewEntity();
-        }
-        function removeEntity(entity) {
-            const deleted = usedEntities.delete(entity);
-            if (deleted) {
-                removedEntities.set(entityNumber(entity), entityVersion(entity));
-            }
-            return deleted;
-        }
-        return {
-            generateEntity() {
-                return generateEntity();
-            },
-            removeEntity(entity) {
-                return removeEntity(entity);
-            },
-            entityExists(entity) {
-                return entity < RESERVED_STATIC_ENTITIES || usedEntities.has(entity);
-            },
-            getExistingEntities() {
-                return new Set(usedEntities);
-            },
-            entityVersion,
-            entityNumber,
-            entityId
-        };
-    }
-
     const SYSTEMS_REGULAR_PRIORITY = 100e3;
     function SystemContainer() {
         const systems = [];
@@ -14345,9 +14830,6 @@
             const entity = entityContainer.generateEntity();
             return entity;
         }
-        function entityExists(entity) {
-            return entityContainer.entityExists(entity);
-        }
         function removeEntity(entity) {
             for (const [, component] of componentsDefinition) {
                 if (component.has(entity)) {
@@ -14454,8 +14936,6 @@
             }
         }
         return {
-            entityExists,
-            componentsDefinition,
             addEntity,
             removeEntity,
             addSystem,
@@ -14469,6 +14949,7 @@
             removeComponentDefinition,
             removeEntityWithChildren,
             registerCustomComponent,
+            entityContainer,
             componentsIter
         };
     }
@@ -14485,8 +14966,9 @@
                 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();
-            await crdtSystem.sendMessages(dirtyEntities);
-            for (const [_componentId, definition] of engine.componentsDefinition) {
+            const deletedEntites = engine.entityContainer.releaseRemovedEntities();
+            await crdtSystem.sendMessages(dirtyEntities, deletedEntites);
+            for (const definition of engine.componentsIter()) {
                 definition.clearDirty();
             }
         }
@@ -14508,10 +14990,10 @@
             RootEntity: 0,
             PlayerEntity: 1,
             CameraEntity: 2,
-            entityExists: engine.entityExists,
+            getEntityState: engine.entityContainer.getEntityState,
             addTransport: crdtSystem.addTransport,
             getCrdtState: crdtSystem.getCrdt,
-            componentsDefinition: engine.componentsDefinition
+            entityContainer: engine.entityContainer
         };
     }
 
@@ -14597,7 +15079,7 @@
         // @internal
         engine.addSystem(function EventSystem() {
             for (const [entity, event] of eventsMap) {
-                if (!engine.entityExists(entity)) {
+                if (engine.getEntityState(entity) === exports.EntityState.Removed) {
                     eventsMap.delete(entity);
                     continue;
                 }
@@ -41150,7 +41632,9 @@
                 }
             },
             filter(message) {
-                if (!componentIds.includes(message.componentId)) {
+                if ((message.type === exports.CrdtMessageType.PUT_COMPONENT ||
+                    message.type === exports.CrdtMessageType.DELETE_COMPONENT) &&
+                    !componentIds.includes(message.componentId)) {
                     return false;
                 }
                 return !!message;
@@ -41178,6 +41662,7 @@
     exports.BorderRect = BorderRect;
     exports.Button = Button;
     exports.CANVAS_ROOT_ENTITY = CANVAS_ROOT_ENTITY;
+    exports.CRDT_MESSAGE_HEADER_LENGTH = CRDT_MESSAGE_HEADER_LENGTH;
     exports.CameraMode = CameraMode;
     exports.CameraModeArea = CameraModeArea;
     exports.DEG2RAD = DEG2RAD;