@dcl/ecs 7.1.12-4982829389.commit-f2f84bd → 7.1.12-4983011170.commit-adaaaa2

package/dist-cjs/serialization/crdt/putComponent.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PutComponentOperation = void 0;
+const crdtMessageProtocol_1 = require("./crdtMessageProtocol");
+const types_1 = require("./types");
+/**
+ * @public
+ */
+var PutComponentOperation;
+(function (PutComponentOperation) {
+    PutComponentOperation.MESSAGE_HEADER_LENGTH = 16;
+    /**
+     * Call this function for an optimal writing data passing the ByteBuffer
+     *  already allocated
+     */
+    function write(entity, timestamp, componentId, data, buf) {
+        // reserve the beginning
+        const startMessageOffset = buf.incrementWriteOffset(types_1.CRDT_MESSAGE_HEADER_LENGTH + PutComponentOperation.MESSAGE_HEADER_LENGTH);
+        // write body
+        buf.writeBuffer(data, false);
+        const messageLength = buf.currentWriteOffset() - startMessageOffset;
+        // Write CrdtMessage header
+        buf.setUint32(startMessageOffset, messageLength);
+        buf.setUint32(startMessageOffset + 4, types_1.CrdtMessageType.PUT_COMPONENT);
+        // Write ComponentOperation header
+        buf.setUint32(startMessageOffset + 8, entity);
+        buf.setUint32(startMessageOffset + 12, componentId);
+        buf.setUint32(startMessageOffset + 16, timestamp);
+        const newLocal = messageLength - PutComponentOperation.MESSAGE_HEADER_LENGTH - types_1.CRDT_MESSAGE_HEADER_LENGTH;
+        buf.setUint32(startMessageOffset + 20, newLocal);
+    }
+    PutComponentOperation.write = write;
+    function read(buf) {
+        const header = crdtMessageProtocol_1.CrdtMessageProtocol.readHeader(buf);
+        if (!header) {
+            return null;
+        }
+        if (header.type !== types_1.CrdtMessageType.PUT_COMPONENT) {
+            throw new Error('PutComponentOperation tried to read another message type.');
+        }
+        return {
+            ...header,
+            entityId: buf.readUint32(),
+            componentId: buf.readUint32(),
+            timestamp: buf.readUint32(),
+            data: buf.readBuffer()
+        };
+    }
+    PutComponentOperation.read = read;
+})(PutComponentOperation = exports.PutComponentOperation || (exports.PutComponentOperation = {}));

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

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

package/dist-cjs/serialization/crdt/types.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProcessMessageResultType = exports.CRDT_MESSAGE_HEADER_LENGTH = exports.CrdtMessageType = void 0;
+/**
+ * @public
+ */
+var CrdtMessageType;
+(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["APPEND_VALUE"] = 4] = "APPEND_VALUE";
+    CrdtMessageType[CrdtMessageType["MAX_MESSAGE_TYPE"] = 5] = "MAX_MESSAGE_TYPE";
+})(CrdtMessageType = exports.CrdtMessageType || (exports.CrdtMessageType = {}));
+/**
+ * @public
+ */
+exports.CRDT_MESSAGE_HEADER_LENGTH = 8;
+var ProcessMessageResultType;
+(function (ProcessMessageResultType) {
+    /**
+     * Typical message and new state set.
+     * @state CHANGE
+     * @reason Incoming message has a timestamp greater
+     */
+    ProcessMessageResultType[ProcessMessageResultType["StateUpdatedTimestamp"] = 1] = "StateUpdatedTimestamp";
+    /**
+     * Typical message when it is considered old.
+     * @state it does NOT CHANGE.
+     * @reason incoming message has a timestamp lower.
+     */
+    ProcessMessageResultType[ProcessMessageResultType["StateOutdatedTimestamp"] = 2] = "StateOutdatedTimestamp";
+    /**
+     * Weird message, same timestamp and data.
+     * @state it does NOT CHANGE.
+     * @reason consistent state between peers.
+     */
+    ProcessMessageResultType[ProcessMessageResultType["NoChanges"] = 3] = "NoChanges";
+    /**
+     * Less but typical message, same timestamp, resolution by data.
+     * @state it does NOT CHANGE.
+     * @reason incoming message has a LOWER data.
+     */
+    ProcessMessageResultType[ProcessMessageResultType["StateOutdatedData"] = 4] = "StateOutdatedData";
+    /**
+     * Less but typical message, same timestamp, resolution by data.
+     * @state CHANGE.
+     * @reason incoming message has a GREATER data.
+     */
+    ProcessMessageResultType[ProcessMessageResultType["StateUpdatedData"] = 5] = "StateUpdatedData";
+    /**
+     * Entity was previously deleted.
+     * @state it does NOT CHANGE.
+     * @reason The message is considered old.
+     */
+    ProcessMessageResultType[ProcessMessageResultType["EntityWasDeleted"] = 6] = "EntityWasDeleted";
+    /**
+     * Entity should be deleted.
+     * @state CHANGE.
+     * @reason the state is storing old entities
+     */
+    ProcessMessageResultType[ProcessMessageResultType["EntityDeleted"] = 7] = "EntityDeleted";
+})(ProcessMessageResultType = 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
+//

package/dist-cjs/systems/async-task.d.ts

@@ -0,0 +1 @@
+export type Task<T = unknown> = () => Promise<T>;

package/dist-cjs/systems/async-task.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTaskSystem = void 0;
+function getAndClean(value) {
+    const messagesToProcess = Array.from(value);
+    value.length = 0;
+    return messagesToProcess;
+}
+/**
+ * @internal
+ */
+function createTaskSystem(engine) {
+    const tasks = [];
+    async function runTask(task) {
+        try {
+            const resp = await task();
+            return resp;
+        }
+        catch (e) {
+            console.error(e);
+        }
+    }
+    function executeTasks() {
+        for (const task of getAndClean(tasks)) {
+            runTask(task).catch(console.error);
+        }
+    }
+    engine.addSystem(executeTasks);
+    return function (task) {
+        tasks.push(task);
+    };
+}
+exports.createTaskSystem = createTaskSystem;

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

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

package/dist-cjs/systems/crdt/gset.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createVersionGSet = void 0;
+/**
+ *
+ * @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;
+        }
+    };
+}
+exports.createVersionGSet = createVersionGSet;

package/dist-cjs/systems/crdt/index.d.ts

@@ -0,0 +1,7 @@
+import { Entity } from '../../engine/entity';
+import type { ComponentDefinition } from '../../engine';
+import { CrdtMessageType } from '../../serialization/crdt/types';
+/**
+ * @public
+ */
+export type OnChangeFunction = (entity: Entity, operation: CrdtMessageType, component?: ComponentDefinition<any>, componentValue?: any) => void;

package/dist-cjs/systems/crdt/index.js

@@ -0,0 +1,241 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.crdtSceneSystem = void 0;
+const entity_1 = require("../../engine/entity");
+const ByteBuffer_1 = require("../../serialization/ByteBuffer");
+const crdt_1 = require("../../serialization/crdt");
+const deleteComponent_1 = require("../../serialization/crdt/deleteComponent");
+const deleteEntity_1 = require("../../serialization/crdt/deleteEntity");
+const putComponent_1 = require("../../serialization/crdt/putComponent");
+const types_1 = require("../../serialization/crdt/types");
+/**
+ * @internal
+ */
+function crdtSceneSystem(engine, onProcessEntityComponentChange) {
+    const transports = [];
+    // 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.
+    const broadcastMessages = [];
+    // Messages receieved by a transport that were outdated. We need to correct them
+    const outdatedMessages = [];
+    /**
+     *
+     * @param transportId tranport id to identiy messages
+     * @returns a function to process received messages
+     */
+    function parseChunkMessage(transportId) {
+        /**
+         * Receives a chunk of binary messages and stores all the valid
+         * Component Operation Messages at messages queue
+         * @param chunkMessage A chunk of binary messages
+         */
+        return function parseChunkMessage(chunkMessage) {
+            const buffer = new ByteBuffer_1.ReadWriteByteBuffer(chunkMessage);
+            let header;
+            while ((header = crdt_1.CrdtMessageProtocol.getHeader(buffer))) {
+                const offset = buffer.currentReadOffset();
+                if (header.type === types_1.CrdtMessageType.DELETE_COMPONENT) {
+                    const message = deleteComponent_1.DeleteComponent.read(buffer);
+                    receivedMessages.push({
+                        ...message,
+                        transportId,
+                        messageBuffer: buffer.buffer().subarray(offset, buffer.currentReadOffset())
+                    });
+                }
+                else if (header.type === types_1.CrdtMessageType.PUT_COMPONENT) {
+                    const message = putComponent_1.PutComponentOperation.read(buffer);
+                    receivedMessages.push({
+                        ...message,
+                        transportId,
+                        messageBuffer: buffer.buffer().subarray(offset, buffer.currentReadOffset())
+                    });
+                }
+                else if (header.type === types_1.CrdtMessageType.DELETE_ENTITY) {
+                    const message = deleteEntity_1.DeleteEntity.read(buffer);
+                    receivedMessages.push({
+                        ...message,
+                        transportId,
+                        messageBuffer: buffer.buffer().subarray(offset, buffer.currentReadOffset())
+                    });
+                }
+                else if (header.type === types_1.CrdtMessageType.APPEND_VALUE) {
+                    const message = crdt_1.AppendValueOperation.read(buffer);
+                    receivedMessages.push({
+                        ...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
+        };
+    }
+    /**
+     * Return and clear the messaes queue
+     * @returns messages recieved by the transport to process on the next tick
+     */
+    function getMessages(value) {
+        const messagesToProcess = value.splice(0, value.length);
+        return messagesToProcess;
+    }
+    /**
+     * This fn will be called on every tick.
+     * Process all the messages queue received by the transport
+     */
+    async function receiveMessages() {
+        const messagesToProcess = getMessages(receivedMessages);
+        const bufferForOutdated = new ByteBuffer_1.ReadWriteByteBuffer();
+        const entitiesShouldBeCleaned = [];
+        for (const msg of messagesToProcess) {
+            if (msg.type === types_1.CrdtMessageType.DELETE_ENTITY) {
+                entitiesShouldBeCleaned.push(msg.entityId);
+            }
+            else {
+                const entityState = engine.entityContainer.getEntityState(msg.entityId);
+                // Skip updates from removed entityes
+                if (entityState === entity_1.EntityState.Removed)
+                    continue;
+                // Entities with unknown entities should update its entity state
+                if (entityState === entity_1.EntityState.Unknown) {
+                    engine.entityContainer.updateUsedEntity(msg.entityId);
+                }
+                const component = engine.getComponentOrNull(msg.componentId);
+                /* istanbul ignore else */
+                if (component) {
+                    const [conflictMessage, value] = component.updateFromCrdt(msg);
+                    if (conflictMessage) {
+                        const offset = bufferForOutdated.currentWriteOffset();
+                        if (conflictMessage.type === types_1.CrdtMessageType.PUT_COMPONENT) {
+                            putComponent_1.PutComponentOperation.write(msg.entityId, conflictMessage.timestamp, conflictMessage.componentId, conflictMessage.data, bufferForOutdated);
+                        }
+                        else if (conflictMessage.type === types_1.CrdtMessageType.DELETE_COMPONENT) {
+                            deleteComponent_1.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, value);
+                    }
+                }
+                else {
+                    // TODO: test this line, it is fundammental to make the editor work
+                    broadcastMessages.push(msg);
+                }
+            }
+        }
+        // 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 && outdatedMessages[i].type !== types_1.CrdtMessageType.DELETE_ENTITY) {
+                    outdatedMessages.splice(i, 1);
+                }
+            }
+            for (const definition of engine.componentsIter()) {
+                definition.entityDeleted(entity, false);
+            }
+            engine.entityContainer.updateRemovedEntity(entity);
+            onProcessEntityComponentChange && onProcessEntityComponentChange(entity, types_1.CrdtMessageType.DELETE_ENTITY);
+        }
+    }
+    /**
+     * Iterates the dirty map and generates crdt messages to be send
+     */
+    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 ByteBuffer_1.ReadWriteByteBuffer();
+        for (const component of engine.componentsIter()) {
+            for (const message of component.getCrdtUpdates()) {
+                const offset = buffer.currentWriteOffset();
+                // Avoid creating messages if there is no transport that will handle it
+                if (transports.some((t) => t.filter(message))) {
+                    if (message.type === types_1.CrdtMessageType.PUT_COMPONENT) {
+                        putComponent_1.PutComponentOperation.write(message.entityId, message.timestamp, message.componentId, message.data, buffer);
+                    }
+                    else if (message.type === types_1.CrdtMessageType.DELETE_COMPONENT) {
+                        deleteComponent_1.DeleteComponent.write(message.entityId, component.componentId, message.timestamp, buffer);
+                    }
+                    else if (message.type === types_1.CrdtMessageType.APPEND_VALUE) {
+                        crdt_1.AppendValueOperation.write(message.entityId, message.timestamp, message.componentId, message.data, buffer);
+                    }
+                    crdtMessages.push({
+                        ...message,
+                        messageBuffer: buffer.buffer().subarray(offset, buffer.currentWriteOffset())
+                    });
+                    if (onProcessEntityComponentChange) {
+                        const rawValue = message.type === types_1.CrdtMessageType.PUT_COMPONENT || message.type === types_1.CrdtMessageType.APPEND_VALUE
+                            ? component.get(message.entityId)
+                            : undefined;
+                        onProcessEntityComponentChange(message.entityId, message.type, component, rawValue);
+                    }
+                }
+            }
+        }
+        // After all updates, I execute the DeletedEntity messages
+        for (const entityId of entitiesDeletedThisTick) {
+            const offset = buffer.currentWriteOffset();
+            deleteEntity_1.DeleteEntity.write(entityId, buffer);
+            crdtMessages.push({
+                type: types_1.CrdtMessageType.DELETE_ENTITY,
+                entityId,
+                messageBuffer: buffer.buffer().subarray(offset, buffer.currentWriteOffset())
+            });
+            onProcessEntityComponentChange && onProcessEntityComponentChange(entityId, types_1.CrdtMessageType.DELETE_ENTITY);
+        }
+        // Send CRDT messages to transports
+        const transportBuffer = new ByteBuffer_1.ReadWriteByteBuffer();
+        for (const index in transports) {
+            const transportIndex = Number(index);
+            const transport = transports[transportIndex];
+            transportBuffer.resetBuffer();
+            // First we need to send all the messages that were outdated from a transport
+            // 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.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);
+                }
+            }
+            // Then we send all the new crdtMessages that the transport needs to process
+            for (const message of crdtMessages) {
+                if (message.transportId !== transportIndex && transport.filter(message)) {
+                    transportBuffer.writeBuffer(message.messageBuffer, false);
+                }
+            }
+            const message = transportBuffer.currentWriteOffset() ? transportBuffer.toBinary() : new Uint8Array([]);
+            await transport.send(message);
+        }
+    }
+    /**
+     * @public
+     * Add a transport to the crdt system
+     */
+    function addTransport(transport) {
+        const id = transports.push(transport) - 1;
+        transport.onmessage = parseChunkMessage(id);
+    }
+    return {
+        sendMessages,
+        receiveMessages,
+        addTransport
+    };
+}
+exports.crdtSceneSystem = crdtSceneSystem;

package/dist-cjs/systems/crdt/types.d.ts

@@ -0,0 +1,20 @@
+import { CrdtMessageBody } from '../../serialization/crdt/types';
+/**
+ * @public
+ */
+export type ReceiveMessage = CrdtMessageBody & {
+    transportId?: number;
+    messageBuffer: Uint8Array;
+};
+/**
+ * @public
+ */
+export type TransportMessage = Omit<ReceiveMessage, 'data'>;
+/**
+ * @public
+ */
+export type Transport = {
+    send(message: Uint8Array): Promise<void>;
+    onmessage?(message: Uint8Array): void;
+    filter(message: Omit<TransportMessage, 'messageBuffer'>): boolean;
+};

package/dist-cjs/systems/crdt/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });