@dcl/ecs 7.0.6-4177592674.commit-39cdc99 → 7.0.6-4180146485.commit-9a7dde9

package/dist/engine/lww-element-set-component-definition.d.ts

@@ -0,0 +1,6 @@
+import { ISchema } from '../schemas';
+import { PutComponentMessageBody, DeleteComponentMessageBody, CrdtMessageBody } from '../serialization/crdt';
+import { Entity } from './entity';
+export declare function incrementTimestamp(entity: Entity, timestamps: Map<Entity, number>): number;
+export declare function createUpdateLwwFromCrdt(componentId: number, timestamps: Map<Entity, number>, schema: Pick<ISchema<any>, 'serialize' | 'deserialize'>, data: Map<Entity, unknown>): (msg: CrdtMessageBody) => [null | PutComponentMessageBody | DeleteComponentMessageBody, any];
+export declare function createGetCrdtMessagesForLww(componentId: number, timestamps: Map<Entity, number>, dirtyIterator: Set<Entity>, schema: Pick<ISchema<any>, 'serialize'>, data: Map<Entity, unknown>): () => Generator<PutComponentMessageBody | DeleteComponentMessageBody, void, unknown>;

package/dist/engine/lww-element-set-component-definition.js

@@ -0,0 +1,229 @@
+import { ReadWriteByteBuffer } from '../serialization/ByteBuffer';
+import { ProcessMessageResultType, CrdtMessageType } from '../serialization/crdt';
+import { dataCompare } from '../systems/crdt/utils';
+import { deepReadonly } from './readonly';
+export function incrementTimestamp(entity, timestamps) {
+    const newTimestamp = (timestamps.get(entity) || 0) + 1;
+    timestamps.set(entity, newTimestamp);
+    return newTimestamp;
+}
+export function createUpdateLwwFromCrdt(componentId, timestamps, schema, data) {
+    /**
+     * Process the received message only if the lamport number recieved is higher
+     * than the stored one. If its lower, we spread it to the network to correct the peer.
+     * If they are equal, the bigger raw data wins.
+  
+      * Returns the recieved data if the lamport number was bigger than ours.
+      * If it was an outdated message, then we return void
+      * @public
+      */
+    function crdtRuleForCurrentState(message) {
+        const { entityId, timestamp } = message;
+        const currentTimestamp = timestamps.get(entityId);
+        // The received message is > than our current value, update our state.components.
+        if (currentTimestamp === undefined || currentTimestamp < timestamp) {
+            return ProcessMessageResultType.StateUpdatedTimestamp;
+        }
+        // Outdated Message. Resend our state message through the wire.
+        if (currentTimestamp > timestamp) {
+            // console.log('2', currentTimestamp, timestamp)
+            return ProcessMessageResultType.StateOutdatedTimestamp;
+        }
+        // Deletes are idempotent
+        if (message.type === CrdtMessageType.DELETE_COMPONENT && !data.has(entityId)) {
+            return ProcessMessageResultType.NoChanges;
+        }
+        let currentDataGreater = 0;
+        if (data.has(entityId)) {
+            const writeBuffer = new ReadWriteByteBuffer();
+            schema.serialize(data.get(entityId), writeBuffer);
+            currentDataGreater = dataCompare(writeBuffer.toBinary(), message.data || null);
+        }
+        else {
+            currentDataGreater = dataCompare(null, message.data);
+        }
+        // Same data, same timestamp. Weirdo echo message.
+        // console.log('3', currentDataGreater, writeBuffer.toBinary(), (message as any).data || null)
+        if (currentDataGreater === 0) {
+            return ProcessMessageResultType.NoChanges;
+        }
+        else if (currentDataGreater > 0) {
+            // Current data is greater
+            return ProcessMessageResultType.StateOutdatedData;
+        }
+        else {
+            // Curent data is lower
+            return ProcessMessageResultType.StateUpdatedData;
+        }
+    }
+    return (msg) => {
+        /* istanbul ignore next */
+        if (msg.type !== CrdtMessageType.PUT_COMPONENT && msg.type !== CrdtMessageType.DELETE_COMPONENT)
+            /* istanbul ignore next */
+            return [null, data.get(msg.entityId)];
+        const action = crdtRuleForCurrentState(msg);
+        const entity = msg.entityId;
+        switch (action) {
+            case ProcessMessageResultType.StateUpdatedData:
+            case ProcessMessageResultType.StateUpdatedTimestamp: {
+                timestamps.set(entity, msg.timestamp);
+                if (msg.type === CrdtMessageType.PUT_COMPONENT) {
+                    const buf = new ReadWriteByteBuffer(msg.data);
+                    data.set(entity, schema.deserialize(buf));
+                }
+                else {
+                    data.delete(entity);
+                }
+                return [null, data.get(entity)];
+            }
+            case ProcessMessageResultType.StateOutdatedTimestamp:
+            case ProcessMessageResultType.StateOutdatedData: {
+                if (data.has(entity)) {
+                    const writeBuffer = new ReadWriteByteBuffer();
+                    schema.serialize(data.get(entity), writeBuffer);
+                    return [
+                        {
+                            type: CrdtMessageType.PUT_COMPONENT,
+                            componentId,
+                            data: writeBuffer.toBinary(),
+                            entityId: entity,
+                            timestamp: timestamps.get(entity)
+                        },
+                        data.get(entity)
+                    ];
+                }
+                else {
+                    return [
+                        {
+                            type: CrdtMessageType.DELETE_COMPONENT,
+                            componentId,
+                            entityId: entity,
+                            timestamp: timestamps.get(entity)
+                        },
+                        undefined
+                    ];
+                }
+            }
+        }
+        return [null, data.get(entity)];
+    };
+}
+export function createGetCrdtMessagesForLww(componentId, timestamps, dirtyIterator, schema, data) {
+    return function* () {
+        for (const entity of dirtyIterator) {
+            const newTimestamp = incrementTimestamp(entity, timestamps);
+            if (data.has(entity)) {
+                const writeBuffer = new ReadWriteByteBuffer();
+                schema.serialize(data.get(entity), writeBuffer);
+                const msg = {
+                    type: CrdtMessageType.PUT_COMPONENT,
+                    componentId,
+                    entityId: entity,
+                    data: writeBuffer.toBinary(),
+                    timestamp: newTimestamp
+                };
+                yield msg;
+            }
+            else {
+                const msg = {
+                    type: CrdtMessageType.DELETE_COMPONENT,
+                    componentId,
+                    entityId: entity,
+                    timestamp: newTimestamp
+                };
+                yield msg;
+            }
+        }
+        dirtyIterator.clear();
+    };
+}
+/**
+ * @internal
+ */
+export function createComponentDefinitionFromSchema(componentName, componentId, schema) {
+    const data = new Map();
+    const dirtyIterator = new Set();
+    const timestamps = new Map();
+    return {
+        get componentId() {
+            return componentId;
+        },
+        get componentName() {
+            return componentName;
+        },
+        get componentType() {
+            // a getter is used here to prevent accidental changes
+            return 0 /* ComponentType.LastWriteWinElementSet */;
+        },
+        schema,
+        has(entity) {
+            return data.has(entity);
+        },
+        deleteFrom(entity, markAsDirty = true) {
+            const component = data.get(entity);
+            if (data.delete(entity) && markAsDirty) {
+                dirtyIterator.add(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;
+        },
+        get(entity) {
+            const component = data.get(entity);
+            if (!component) {
+                throw new Error(`[getFrom] Component ${componentName} for entity #${entity} not found`);
+            }
+            return deepReadonly(component);
+        },
+        create(entity, value) {
+            const component = data.get(entity);
+            if (component) {
+                throw new Error(`[create] Component ${componentName} for ${entity} already exists`);
+            }
+            const usedValue = value === undefined ? schema.create() : schema.extend ? schema.extend(value) : value;
+            data.set(entity, usedValue);
+            dirtyIterator.add(entity);
+            return usedValue;
+        },
+        createOrReplace(entity, value) {
+            const usedValue = value === undefined ? schema.create() : schema.extend ? schema.extend(value) : value;
+            data.set(entity, usedValue);
+            dirtyIterator.add(entity);
+            return usedValue;
+        },
+        getMutableOrNull(entity) {
+            const component = data.get(entity);
+            if (!component) {
+                return null;
+            }
+            dirtyIterator.add(entity);
+            return component;
+        },
+        getMutable(entity) {
+            const component = this.getMutableOrNull(entity);
+            if (component === null) {
+                throw new Error(`[mutable] Component ${componentName} for ${entity} not found`);
+            }
+            return component;
+        },
+        *iterator() {
+            for (const [entity, component] of data) {
+                yield [entity, component];
+            }
+        },
+        *dirtyIterator() {
+            for (const entity of dirtyIterator) {
+                yield entity;
+            }
+        },
+        getCrdtUpdates: createGetCrdtMessagesForLww(componentId, timestamps, dirtyIterator, schema, data),
+        updateFromCrdt: createUpdateLwwFromCrdt(componentId, timestamps, schema, data)
+    };
+}

package/dist/engine/readonly.d.ts

@@ -2,7 +2,7 @@ import { ComponentDefinition } from './component';
 /**
  * @public
  */
-export type DeepReadonlyMap<K, V> = ReadonlyMap<DeepReadonly<K>, DeepReadonly<V>>;
+export type DeepReadonlyMap<K, V> = ReadonlyMap<K, DeepReadonly<V>>;
 /**
  * @public
  */
@@ -26,4 +26,4 @@ export type ReadonlyComponentSchema<T extends [ComponentDefinition<unknown>, ...
 /**
  * @public
  */
-export type DeepReadonly<T> = T extends ReadonlyPrimitive ? T : T extends Map<infer K, infer V> ? DeepReadonlyMap<K, V> : T extends Set<infer M> ? DeepReadonlySet<M> : DeepReadonlyObject<T>;
+export type DeepReadonly<T> = T extends ReadonlyPrimitive ? T : T extends Array<infer K> ? ReadonlyArray<DeepReadonly<K>> : T extends Map<infer K, infer V> ? DeepReadonlyMap<K, V> : T extends Set<infer M> ? DeepReadonlySet<M> : DeepReadonlyObject<T>;

package/dist/engine/types.d.ts

@@ -1,25 +1,22 @@
 import type { ISchema } from '../schemas/ISchema';
 import { MapResult, Spec } from '../schemas/Map';
 import { Transport } from '../systems/crdt/types';
-import { ComponentDefinition } from './component';
+import { ComponentDefinition, GrowOnlyValueSetComponentDefinition, LastWriteWinElementSetComponentDefinition } from './component';
 import { Entity, EntityState } from './entity';
+import { ValueSetOptions } from './grow-only-value-set-component-definition';
 import { ReadonlyComponentSchema } from './readonly';
 import { SystemFn } from './systems';
+export * from './component';
+export { ValueSetOptions };
 /**
  * @public
  */
 export type Unpacked<T> = T extends (infer U)[] ? U : T;
-/**
- * @public
- */
-export type ComponentSchema<T extends [ComponentDefinition<any>, ...ComponentDefinition<any>[]]> = {
-    [K in keyof T]: T[K] extends ComponentDefinition<any> ? ReturnType<T[K]['getMutable']> : never;
-};
 /**
  * @public
  * Overrides component definition to support partial default values
  */
-export interface MapComponentDefinition<T> extends ComponentDefinition<T> {
+export interface MapComponentDefinition<T> extends LastWriteWinElementSetComponentDefinition<T> {
     /**
      * Add the current component to an entity, throw an error if the component already exists (use `createOrReplace` instead).
      * - Internal comment: This method adds the &lt;entity,component&gt; to the list to be reviewed next frame
@@ -128,7 +125,21 @@ export interface IEngine {
      * const StateComponent = engine.defineComponentFromSchema("my-lib::VisibleComponent", Schemas.Bool)
      * ```
      */
-    defineComponentFromSchema<T>(componentName: string, spec: ISchema<T>): ComponentDefinition<T>;
+    defineComponentFromSchema<T>(componentName: string, spec: ISchema<T>): LastWriteWinElementSetComponentDefinition<T>;
+    /**
+     * @public
+     * Defines a value set component.
+     * @param componentName - unique name to identify the component, a hash is calculated for it, it will fail if the hash has collisions.
+     * @param spec - An object with schema fields
+     * @returns The component definition
+     *
+     * @example
+     * ```ts
+     * const StateComponentId = 10023
+     * const StateComponent = engine.defineValueSetComponentFromSchema("my-lib::VisibleComponent", Schemas.Int)
+     * ```
+     */
+    defineValueSetComponentFromSchema<T>(componentName: string, spec: ISchema<T>, options: ValueSetOptions<T>): GrowOnlyValueSetComponentDefinition<T>;
     /**
      * @public
      * Get the component definition from the component id.

package/dist/engine/types.js

@@ -1 +1 @@
-export {};
+export * from './component';

package/dist/runtime/invariant.d.ts

@@ -1,3 +1,4 @@
 type K = unknown | Promise<unknown>;
+export declare const __DEV__: boolean;
 export declare function checkNotThenable<T extends K>(t: T, error: string): T;
 export {};

package/dist/runtime/invariant.js

@@ -1,5 +1,10 @@
+/* istanbul ignore file */
+export const __DEV__ = (typeof DEBUG === 'boolean' && DEBUG) ||
+    (typeof process === 'object' &&
+        (process.env?.NODE_ENV !== 'production' || process.env?.NODE_ENV === 'development')) ||
+    false;
 export function checkNotThenable(t, error) {
-    if (globalThis.DEBUG) {
+    if (__DEV__) {
         if (t && typeof t === 'object' && typeof t.then === 'function') {
             throw new Error(error);
         }

package/dist/runtime/types.d.ts

@@ -1,7 +1,6 @@
 export type { SystemFn } from '../engine/systems';
 export type { TransportMessage, ReceiveMessage, Transport } from '../systems/crdt/types';
-export { TransformType, TransformComponent } from '../components/legacy/Transform';
+export { TransformType, TransformComponent } from '../components/manual/Transform';
 export * from '../engine/component';
 export * from '../schemas/typing';
 export type { MapResult, Spec } from '../schemas/Map';
-export * from '../engine/component';

package/dist/runtime/types.js

@@ -1,3 +1,2 @@
 export * from '../engine/component';
 export * from '../schemas/typing';
-export * from '../engine/component';

package/dist/schemas/ISchema.d.ts

@@ -1,10 +1,11 @@
+import { DeepReadonly } from '../engine/readonly';
 import { ByteBuffer } from '../serialization/ByteBuffer';
 /**
  * @public
  */
 export interface ISchema<T = any> {
-    serialize(value: T, builder: ByteBuffer): void;
+    serialize(value: DeepReadonly<T>, builder: ByteBuffer): void;
     deserialize(reader: ByteBuffer): T;
     create(): T;
-    extend?: (base?: T) => T;
+    extend?: (base: Partial<DeepReadonly<T>> | undefined) => T;
 }

package/dist/schemas/Map.d.ts

@@ -18,4 +18,3 @@ export type MapResult<T extends Spec> = ToOptional<{
 export type MapResultWithOptional<T extends Spec> = ToOptional<{
     [K in keyof T]?: T[K] extends ISchema ? ReturnType<T[K]['deserialize']> : T[K] extends Spec ? MapResult<T[K]> : never;
 }>;
-export type MapSchemaType<T extends Spec> = ISchema<MapResult<T>>;

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

@@ -0,0 +1 @@
+export {};

package/dist/serialization/crdt/appendValue.js

@@ -0,0 +1,49 @@
+import { CrdtMessageProtocol } from './crdtMessageProtocol';
+import { CrdtMessageType, CRDT_MESSAGE_HEADER_LENGTH } from './types';
+/**
+ * @internal
+ */
+export var AppendValueOperation;
+(function (AppendValueOperation) {
+    AppendValueOperation.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(CRDT_MESSAGE_HEADER_LENGTH + AppendValueOperation.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, CrdtMessageType.APPEND_VALUE);
+        // Write ComponentOperation header
+        buf.setUint32(startMessageOffset + 8, entity);
+        buf.setUint32(startMessageOffset + 12, componentId);
+        buf.setUint32(startMessageOffset + 16, timestamp);
+        const newLocal = messageLength - AppendValueOperation.MESSAGE_HEADER_LENGTH - CRDT_MESSAGE_HEADER_LENGTH;
+        buf.setUint32(startMessageOffset + 20, newLocal);
+    }
+    AppendValueOperation.write = write;
+    function read(buf) {
+        const header = CrdtMessageProtocol.readHeader(buf);
+        /* istanbul ignore if */
+        if (!header) {
+            return null;
+        }
+        /* istanbul ignore if */
+        if (header.type !== CrdtMessageType.APPEND_VALUE) {
+            throw new Error('AppendValueOperation tried to read another message type.');
+        }
+        return {
+            ...header,
+            entityId: buf.readUint32(),
+            componentId: buf.readUint32(),
+            timestamp: buf.readUint32(),
+            data: buf.readBuffer()
+        };
+    }
+    AppendValueOperation.read = read;
+})(AppendValueOperation || (AppendValueOperation = {}));

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

@@ -1,4 +1,5 @@
 export * from './deleteComponent';
+export * from './appendValue';
 export * from './deleteEntity';
 export * from './putComponent';
 export * from './types';

package/dist/serialization/crdt/index.js

@@ -1,4 +1,5 @@
 export * from './deleteComponent';
+export * from './appendValue';
 export * from './deleteEntity';
 export * from './putComponent';
 export * from './types';

package/dist/serialization/crdt/message.js

@@ -3,6 +3,7 @@ import { CrdtMessageType } from './types';
 import { PutComponentOperation } from './putComponent';
 import { DeleteComponent } from './deleteComponent';
 import { DeleteEntity } from './deleteEntity';
+import { AppendValueOperation } from './appendValue';
 export function readMessage(buf) {
     const header = CrdtMessageProtocol.getHeader(buf);
     if (!header)
@@ -13,6 +14,9 @@ export function readMessage(buf) {
     else if (header.type === CrdtMessageType.DELETE_COMPONENT) {
         return DeleteComponent.read(buf);
     }
+    else if (header.type === CrdtMessageType.APPEND_VALUE) {
+        return AppendValueOperation.read(buf);
+    }
     else if (header.type === CrdtMessageType.DELETE_ENTITY) {
         return DeleteEntity.read(buf);
     }

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

@@ -7,7 +7,8 @@ export declare enum CrdtMessageType {
     PUT_COMPONENT = 1,
     DELETE_COMPONENT = 2,
     DELETE_ENTITY = 3,
-    MAX_MESSAGE_TYPE = 4
+    APPEND_VALUE = 4,
+    MAX_MESSAGE_TYPE = 5
 }
 /**
  * Min length = 8 bytes
@@ -40,6 +41,22 @@ export type PutComponentMessageBody = {
     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
@@ -60,6 +77,10 @@ export type DeleteEntityMessageBody = {
     type: CrdtMessageType.DELETE_ENTITY;
     entityId: Entity;
 };
+/**
+ * @public
+ */
+export type AppendValueMessage = CrdtMessageHeader & AppendValueMessageBody;
 /**
  * @public
  */
@@ -75,11 +96,11 @@ export type DeleteEntityMessage = CrdtMessageHeader & DeleteEntityMessageBody;
 /**
  * @public
  */
-export type CrdtMessage = PutComponentMessage | DeleteComponentMessage | DeleteEntityMessage;
+export type CrdtMessage = PutComponentMessage | DeleteComponentMessage | DeleteEntityMessage | AppendValueMessage;
 /**
  * @public
  */
-export type CrdtMessageBody = PutComponentMessageBody | DeleteComponentMessageBody | DeleteEntityMessageBody;
+export type CrdtMessageBody = PutComponentMessageBody | DeleteComponentMessageBody | DeleteEntityMessageBody | AppendValueMessageBody;
 export declare enum ProcessMessageResultType {
     /**
      * Typical message and new state set.

package/dist/serialization/crdt/types.js

@@ -8,7 +8,8 @@ export var CrdtMessageType;
     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";
+    CrdtMessageType[CrdtMessageType["APPEND_VALUE"] = 4] = "APPEND_VALUE";
+    CrdtMessageType[CrdtMessageType["MAX_MESSAGE_TYPE"] = 5] = "MAX_MESSAGE_TYPE";
 })(CrdtMessageType || (CrdtMessageType = {}));
 /**
  * @public

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

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

package/dist/systems/crdt/index.js

@@ -1,6 +1,6 @@
 import { EntityState } from '../../engine/entity';
 import { ReadWriteByteBuffer } from '../../serialization/ByteBuffer';
-import { CrdtMessageProtocol } from '../../serialization/crdt';
+import { AppendValueOperation, CrdtMessageProtocol } from '../../serialization/crdt';
 import { DeleteComponent } from '../../serialization/crdt/deleteComponent';
 import { DeleteEntity } from '../../serialization/crdt/deleteEntity';
 import { PutComponentOperation } from '../../serialization/crdt/putComponent';
@@ -35,7 +35,6 @@ export function crdtSceneSystem(engine, onProcessEntityComponentChange) {
                 if (header.type === CrdtMessageType.DELETE_COMPONENT) {
                     const message = DeleteComponent.read(buffer);
                     receivedMessages.push({
-                        ...header,
                         ...message,
                         transportId,
                         messageBuffer: buffer.buffer().subarray(offset, buffer.currentReadOffset())
@@ -44,7 +43,6 @@ export function crdtSceneSystem(engine, onProcessEntityComponentChange) {
                 else if (header.type === CrdtMessageType.PUT_COMPONENT) {
                     const message = PutComponentOperation.read(buffer);
                     receivedMessages.push({
-                        ...header,
                         ...message,
                         transportId,
                         messageBuffer: buffer.buffer().subarray(offset, buffer.currentReadOffset())
@@ -53,7 +51,14 @@ export function crdtSceneSystem(engine, onProcessEntityComponentChange) {
                 else if (header.type === CrdtMessageType.DELETE_ENTITY) {
                     const message = DeleteEntity.read(buffer);
                     receivedMessages.push({
-                        ...header,
+                        ...message,
+                        transportId,
+                        messageBuffer: buffer.buffer().subarray(offset, buffer.currentReadOffset())
+                    });
+                }
+                else if (header.type === CrdtMessageType.APPEND_VALUE) {
+                    const message = AppendValueOperation.read(buffer);
+                    receivedMessages.push({
                         ...message,
                         transportId,
                         messageBuffer: buffer.buffer().subarray(offset, buffer.currentReadOffset())
@@ -99,13 +104,13 @@ export function crdtSceneSystem(engine, onProcessEntityComponentChange) {
                 }
                 const component = engine.getComponentOrNull(msg.componentId);
                 if (component) {
-                    const [conflictMessage] = component.updateFromCrdt(msg);
+                    const [conflictMessage, value] = component.updateFromCrdt(msg);
                     if (conflictMessage) {
                         const offset = bufferForOutdated.currentWriteOffset();
                         if (conflictMessage.type === CrdtMessageType.PUT_COMPONENT) {
                             PutComponentOperation.write(msg.entityId, conflictMessage.timestamp, conflictMessage.componentId, conflictMessage.data, bufferForOutdated);
                         }
-                        else {
+                        else if (conflictMessage.type === CrdtMessageType.DELETE_COMPONENT) {
                             DeleteComponent.write(msg.entityId, component.componentId, conflictMessage.timestamp, bufferForOutdated);
                         }
                         outdatedMessages.push({
@@ -116,7 +121,7 @@ export function crdtSceneSystem(engine, onProcessEntityComponentChange) {
                     else {
                         // Add message to transport queue to be processed by others transports
                         broadcastMessages.push(msg);
-                        onProcessEntityComponentChange && onProcessEntityComponentChange(msg.entityId, msg.type, component);
+                        onProcessEntityComponentChange && onProcessEntityComponentChange(msg.entityId, msg.type, component, value);
                     }
                 }
             }
@@ -155,11 +160,19 @@ export function crdtSceneSystem(engine, onProcessEntityComponentChange) {
                     else if (message.type === CrdtMessageType.DELETE_COMPONENT) {
                         DeleteComponent.write(message.entityId, component.componentId, message.timestamp, buffer);
                     }
+                    else if (message.type === CrdtMessageType.APPEND_VALUE) {
+                        AppendValueOperation.write(message.entityId, message.timestamp, message.componentId, message.data, buffer);
+                    }
                     crdtMessages.push({
                         ...message,
                         messageBuffer: buffer.buffer().subarray(offset, buffer.currentWriteOffset())
                     });
-                    onProcessEntityComponentChange && onProcessEntityComponentChange(message.entityId, message.type, component);
+                    if (onProcessEntityComponentChange) {
+                        const rawValue = message.type === CrdtMessageType.PUT_COMPONENT || message.type === CrdtMessageType.APPEND_VALUE
+                            ? component.get(message.entityId)
+                            : undefined;
+                        onProcessEntityComponentChange(message.entityId, message.type, component, rawValue);
+                    }
                 }
             }
         }

package/dist/systems/events.d.ts

@@ -1,10 +1,10 @@
 import { InputAction } from '../components/generated/pb/decentraland/sdk/components/common/input_action.gen';
-import { PBPointerEventsResult_PointerCommand } from '../components/generated/pb/decentraland/sdk/components/pointer_events_result.gen';
+import { PBPointerEventsResult } from '../components/generated/pb/decentraland/sdk/components/pointer_events_result.gen';
 import { Entity } from '../engine/entity';
 /**
  * @public
  */
-export type EventSystemCallback = (event: PBPointerEventsResult_PointerCommand) => void;
+export type EventSystemCallback = (event: PBPointerEventsResult) => void;
 /**
  * @public
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dcl/ecs",
-  "version": "7.0.6-4177592674.commit-39cdc99",
+  "version": "7.0.6-4180146485.commit-9a7dde9",
   "description": "Decentraland ECS",
   "main": "./dist/index.js",
   "typings": "./dist/index.d.ts",
@@ -28,7 +28,7 @@
   },
   "dependencies": {
     "@dcl/js-runtime": "file:../js-runtime",
-    "@dcl/protocol": "1.0.0-4114477251.commit-ccb88d6"
+    "@dcl/protocol": "1.0.0-4177500465.commit-247c87f"
   },
   "files": [
     "dist",
@@ -40,5 +40,5 @@
     "displayName": "ECS",
     "tsconfig": "./tsconfig.json"
   },
-  "commit": "39cdc99ea857c63f707ec9188836116d838fa10e"
+  "commit": "9a7dde903f381c1778ec3c7519e4f312ab9b2ee3"
 }