@dcl/ecs 7.20.2-22104870534.commit-0df3cc0 → 7.20.2-22169778016.commit-030cbfe

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

@@ -30,16 +30,12 @@ export function createDumpLwwFunctionFromCrdt(componentId, timestamps, schema, d
         }
     };
 }
-export function createUpdateLwwFromCrdt(componentId, timestamps, schema, data) {
+const __GLOBAL_ENTITY = '__GLOBAL_ENTITY';
+export function createCrdtRuleValidator(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
-      */
+     * Shared CRDT conflict resolution logic
+     * @public
+     */
     function crdtRuleForCurrentState(message) {
         const { entityId, timestamp } = message;
         const currentTimestamp = timestamps.get(entityId);
@@ -49,7 +45,6 @@ export function createUpdateLwwFromCrdt(componentId, timestamps, schema, data) {
         }
         // Outdated Message. Resend our state message through the wire.
         if (currentTimestamp > timestamp) {
-            // console.log('2', currentTimestamp, timestamp)
             return ProcessMessageResultType.StateOutdatedTimestamp;
         }
         // Deletes are idempotent
@@ -66,7 +61,6 @@ export function createUpdateLwwFromCrdt(componentId, timestamps, schema, data) {
             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;
         }
@@ -75,10 +69,36 @@ export function createUpdateLwwFromCrdt(componentId, timestamps, schema, data) {
             return ProcessMessageResultType.StateOutdatedData;
         }
         else {
-            // Curent data is lower
+            // Current data is lower
             return ProcessMessageResultType.StateUpdatedData;
         }
     }
+    return crdtRuleForCurrentState;
+}
+export function createForceUpdateLwwFromCrdt(componentId, timestamps, schema, data) {
+    /**
+     * Force update component state regardless of timestamp - used for server authoritative messages
+     */
+    return (msg) => {
+        console.log('[ BOEDO ] [ CASLA ] ', msg);
+        const buffer = new ReadWriteByteBuffer(msg.data);
+        const deserializedValue = schema.deserialize(buffer);
+        data.set(msg.entityId, deserializedValue);
+        timestamps.set(msg.entityId, msg.timestamp);
+        return [null, deserializedValue];
+    };
+}
+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
+      */
+    const crdtRuleForCurrentState = createCrdtRuleValidator(timestamps, schema, data);
     return (msg) => {
         /* istanbul ignore next */
         if (msg.type !== CrdtMessageType.PUT_COMPONENT &&
@@ -171,6 +191,7 @@ export function createComponentDefinitionFromSchema(componentName, componentId,
     const dirtyIterator = new Set();
     const timestamps = new Map();
     const onChangeCallbacks = new Map();
+    const validateCallbacks = new Map();
     return {
         get componentId() {
             return componentId;
@@ -262,7 +283,39 @@ export function createComponentDefinitionFromSchema(componentName, componentId,
         },
         getCrdtUpdates: createGetCrdtMessagesForLww(componentId, timestamps, dirtyIterator, schema, data),
         updateFromCrdt: createUpdateLwwFromCrdt(componentId, timestamps, schema, data),
+        __forceUpdateFromCrdt: createForceUpdateLwwFromCrdt(componentId, timestamps, schema, data),
+        __dry_run_updateFromCrdt: createCrdtRuleValidator(timestamps, schema, data),
         dumpCrdtStateToBuffer: createDumpLwwFunctionFromCrdt(componentId, timestamps, schema, data),
+        validateBeforeChange(entityOrCb, cb) {
+            if (arguments.length === 1) {
+                // Second overload: just callback (global validation)
+                validateCallbacks.set(__GLOBAL_ENTITY, entityOrCb);
+            }
+            else {
+                if (cb) {
+                    validateCallbacks.set(entityOrCb, cb);
+                }
+            }
+        },
+        __run_validateBeforeChange(entity, newValue, senderAddress, createdBy) {
+            const cb = entity && validateCallbacks.get(entity);
+            const globalCb = validateCallbacks.get(__GLOBAL_ENTITY);
+            const currentValue = data.get(entity);
+            const value = { entity, currentValue, newValue, senderAddress, createdBy };
+            const globalResult = globalCb?.(value) ?? true;
+            const entityResult = (globalResult && cb?.(value)) ?? true;
+            return globalResult && entityResult;
+        },
+        getCrdtState(entity) {
+            const componentData = data.get(entity);
+            const timestamp = timestamps.get(entity);
+            if (componentData && timestamp !== undefined) {
+                const buffer = new ReadWriteByteBuffer();
+                schema.serialize(deepReadonly(componentData), buffer);
+                return { data: buffer.toBinary(), timestamp };
+            }
+            return null;
+        },
         onChange(entity, cb) {
             const cbs = onChangeCallbacks.get(entity) ?? [];
             cbs.push(cb);

package/dist/index.d.ts

@@ -13,13 +13,12 @@ export * from './systems/tween';
 export * from './systems/triggerArea';
 export * from './engine/entity';
 export * from './components/types';
-import { MaterialComponentDefinitionExtended, MeshColliderComponentDefinitionExtended, MeshRendererComponentDefinitionExtended, TransformComponentExtended, AnimatorComponentDefinitionExtended, AudioSourceComponentDefinitionExtended, AudioAnalysisComponentDefinitionExtended, AudioStreamComponentDefinitionExtended, ISyncComponents, TweenComponentDefinitionExtended, INetowrkEntity, INetowrkParent, VirtualCameraComponentDefinitionExtended, InputModifierComponentDefinitionExtended, LightSourceComponentDefinitionExtended, TriggerAreaComponentDefinitionExtended } from './components/types';
+import { MaterialComponentDefinitionExtended, MeshColliderComponentDefinitionExtended, MeshRendererComponentDefinitionExtended, TransformComponentExtended, AnimatorComponentDefinitionExtended, AudioSourceComponentDefinitionExtended, AudioStreamComponentDefinitionExtended, ISyncComponents, TweenComponentDefinitionExtended, INetowrkEntity, INetowrkParent, VirtualCameraComponentDefinitionExtended, InputModifierComponentDefinitionExtended, LightSourceComponentDefinitionExtended, TriggerAreaComponentDefinitionExtended, ICreatedBy } from './components/types';
 import { NameComponent } from './components/manual/Name';
 import { TagsComponentDefinitionExtended } from './components/manual/Tags';
 export declare const Transform: TransformComponentExtended;
 export declare const Animator: AnimatorComponentDefinitionExtended;
 export declare const AudioSource: AudioSourceComponentDefinitionExtended;
-export declare const AudioAnalysis: AudioAnalysisComponentDefinitionExtended;
 export declare const AudioStream: AudioStreamComponentDefinitionExtended;
 export declare const Material: MaterialComponentDefinitionExtended;
 export declare const MeshRenderer: MeshRendererComponentDefinitionExtended;
@@ -47,6 +46,7 @@ export declare const NetworkEntity: INetowrkEntity;
  * Tag a entity to be syncronized through comms
  */
 export declare const NetworkParent: INetowrkParent;
+export declare const CreatedBy: ICreatedBy;
 export * from './components/generated/global.gen';
 export * from './components/generated/types.gen';
 export * from './serialization/crdt';

package/dist/index.js

@@ -23,7 +23,6 @@ import { engine } from './runtime/initialization';
 export const Transform = /* @__PURE__*/ components.Transform(engine);
 export const Animator = /* @__PURE__*/ components.Animator(engine);
 export const AudioSource = /* @__PURE__*/ components.AudioSource(engine);
-export const AudioAnalysis = /* @__PURE__*/ components.AudioAnalysis(engine);
 export const AudioStream = /* @__PURE__*/ components.AudioStream(engine);
 export const Material = /* @__PURE__*/ components.Material(engine);
 export const MeshRenderer = /* @__PURE__*/ components.MeshRenderer(engine);
@@ -51,6 +50,7 @@ export const NetworkEntity = /* @__PURE__*/ components.NetworkEntity(engine);
  * Tag a entity to be syncronized through comms
  */
 export const NetworkParent = /* @__PURE__*/ components.NetworkParent(engine);
+export const CreatedBy = /* @__PURE__*/ components.CreatedBy(engine);
 // export components for global engine
 export * from './components/generated/global.gen';
 export * from './components/generated/types.gen';

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

@@ -0,0 +1,15 @@
+import { Entity } from '../../engine/entity';
+import { ByteBuffer } from '../ByteBuffer';
+import { AuthoritativePutComponentMessage } from './types';
+/**
+ * @public
+ */
+export declare namespace AuthoritativePutComponentOperation {
+    const MESSAGE_HEADER_LENGTH = 16;
+    /**
+     * Call this function for an optimal writing data passing the ByteBuffer
+     *  already allocated
+     */
+    function write(entity: Entity, timestamp: number, componentId: number, data: Uint8Array, buf: ByteBuffer): void;
+    function read(buf: ByteBuffer): AuthoritativePutComponentMessage | null;
+}

package/dist/serialization/crdt/authoritativePutComponent.js

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

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

@@ -7,3 +7,4 @@ export * from './network/deleteComponentNetwork';
 export * from './network/deleteEntityNetwork';
 export * from './types';
 export * from './crdtMessageProtocol';
+export * from './authoritativePutComponent';

package/dist/serialization/crdt/index.js

@@ -7,3 +7,4 @@ export * from './network/deleteComponentNetwork';
 export * from './network/deleteEntityNetwork';
 export * from './types';
 export * from './crdtMessageProtocol';
+export * from './authoritativePutComponent';

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

@@ -11,7 +11,8 @@ export declare enum CrdtMessageType {
     PUT_COMPONENT_NETWORK = 5,
     DELETE_COMPONENT_NETWORK = 6,
     DELETE_ENTITY_NETWORK = 7,
-    MAX_MESSAGE_TYPE = 8
+    AUTHORITATIVE_PUT_COMPONENT = 8,
+    MAX_MESSAGE_TYPE = 9
 }
 /**
  * Min length = 8 bytes
@@ -48,6 +49,23 @@ export type PutNetworkComponentMessageBody = Omit<PutComponentMessageBody, 'type
     type: CrdtMessageType.PUT_COMPONENT_NETWORK;
     networkId: number;
 };
+/**
+ * Server authoritative message - identical to PutComponentMessageBody but with forced processing
+ * 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 (server's authoritative timestamp)
+ * @param data - Uint8[] data of component => length(4 bytes) + block of bytes[0..length-1]
+ * @public
+ */
+export type AuthoritativePutComponentMessageBody = {
+    type: CrdtMessageType.AUTHORITATIVE_PUT_COMPONENT;
+    entityId: Entity;
+    componentId: number;
+    timestamp: number;
+    data: Uint8Array;
+};
 /**
  * Min. length = header (8 bytes) + 16 bytes = 24 bytes
  *
@@ -114,6 +132,10 @@ export type AppendValueMessage = CrdtMessageHeader & AppendValueMessageBody;
  * @public
  */
 export type PutComponentMessage = CrdtMessageHeader & PutComponentMessageBody;
+/**
+ * @public
+ */
+export type AuthoritativePutComponentMessage = CrdtMessageHeader & AuthoritativePutComponentMessageBody;
 /**
  * @public
  */
@@ -137,7 +159,7 @@ export type DeleteEntityNetworkMessage = CrdtMessageHeader & DeleteEntityNetwork
 /**
  * @public
  */
-export type CrdtMessage = PutComponentMessage | DeleteComponentMessage | AppendValueMessage | DeleteEntityMessage | PutNetworkComponentMessage | DeleteComponentNetworkMessage | DeleteEntityNetworkMessage;
+export type CrdtMessage = PutComponentMessage | AuthoritativePutComponentMessage | DeleteComponentMessage | AppendValueMessage | DeleteEntityMessage | PutNetworkComponentMessage | DeleteComponentNetworkMessage | DeleteEntityNetworkMessage;
 /**
  * @public
  */
@@ -145,7 +167,7 @@ export type CrdtNetworkMessageBody = PutNetworkComponentMessageBody | DeleteComp
 /**
  * @public
  */
-export type CrdtMessageBody = PutComponentMessageBody | DeleteComponentMessageBody | DeleteEntityMessageBody | AppendValueMessageBody | CrdtNetworkMessageBody;
+export type CrdtMessageBody = PutComponentMessageBody | AuthoritativePutComponentMessageBody | DeleteComponentMessageBody | DeleteEntityMessageBody | AppendValueMessageBody | CrdtNetworkMessageBody;
 export declare enum ProcessMessageResultType {
     /**
      * Typical message and new state set.

package/dist/serialization/crdt/types.js

@@ -13,7 +13,9 @@ export var CrdtMessageType;
     CrdtMessageType[CrdtMessageType["PUT_COMPONENT_NETWORK"] = 5] = "PUT_COMPONENT_NETWORK";
     CrdtMessageType[CrdtMessageType["DELETE_COMPONENT_NETWORK"] = 6] = "DELETE_COMPONENT_NETWORK";
     CrdtMessageType[CrdtMessageType["DELETE_ENTITY_NETWORK"] = 7] = "DELETE_ENTITY_NETWORK";
-    CrdtMessageType[CrdtMessageType["MAX_MESSAGE_TYPE"] = 8] = "MAX_MESSAGE_TYPE";
+    // Server authoritative operation - forces component state regardless of timestamp
+    CrdtMessageType[CrdtMessageType["AUTHORITATIVE_PUT_COMPONENT"] = 8] = "AUTHORITATIVE_PUT_COMPONENT";
+    CrdtMessageType[CrdtMessageType["MAX_MESSAGE_TYPE"] = 9] = "MAX_MESSAGE_TYPE";
 })(CrdtMessageType || (CrdtMessageType = {}));
 /**
  * @public

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

@@ -1,7 +1,6 @@
 import { Entity } from '../../engine/entity';
 import type { ComponentDefinition } from '../../engine';
 import { CrdtMessageType } from '../../serialization/crdt/types';
-export declare const LIVEKIT_MAX_SIZE = 12;
 /**
  * @public
  */

package/dist/systems/crdt/index.js

@@ -1,24 +1,17 @@
 import { EntityState } from '../../engine/entity';
 import { ReadWriteByteBuffer } from '../../serialization/ByteBuffer';
-import { AppendValueOperation, CrdtMessageProtocol, DeleteComponentNetwork, DeleteEntityNetwork } 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';
+import { AuthoritativePutComponentOperation } from '../../serialization/crdt/authoritativePutComponent';
 import { CrdtMessageType } from '../../serialization/crdt/types';
-import { PutNetworkComponentOperation } from '../../serialization/crdt/network/putComponentNetwork';
-import { NetworkEntity as defineNetworkEntity, NetworkParent as defineNetworkParent, Transform as defineTransform } from '../../components';
-import * as networkUtils from '../../serialization/crdt/network/utils';
-// NetworkMessages can only have a MAX_SIZE of 12kb. So we need to send it in chunks.
-export const LIVEKIT_MAX_SIZE = 12;
 /**
  * @internal
  */
 export function crdtSceneSystem(engine, onProcessEntityComponentChange) {
     const transports = [];
-    // Components that we used on this system
-    const NetworkEntity = defineNetworkEntity(engine);
-    const NetworkParent = defineNetworkParent(engine);
-    const Transform = defineTransform(engine);
+    // No network components needed - pure CRDT processing only
     // 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.
@@ -43,27 +36,20 @@ export function crdtSceneSystem(engine, onProcessEntityComponentChange) {
                 if (header.type === CrdtMessageType.DELETE_COMPONENT) {
                     message = DeleteComponent.read(buffer);
                 }
-                else if (header.type === CrdtMessageType.DELETE_COMPONENT_NETWORK) {
-                    message = DeleteComponentNetwork.read(buffer);
-                }
                 else if (header.type === CrdtMessageType.PUT_COMPONENT) {
                     message = PutComponentOperation.read(buffer);
                 }
-                else if (header.type === CrdtMessageType.PUT_COMPONENT_NETWORK) {
-                    message = PutNetworkComponentOperation.read(buffer);
+                else if (header.type === CrdtMessageType.AUTHORITATIVE_PUT_COMPONENT) {
+                    message = AuthoritativePutComponentOperation.read(buffer);
                 }
                 else if (header.type === CrdtMessageType.DELETE_ENTITY) {
                     message = DeleteEntity.read(buffer);
                 }
-                else if (header.type === CrdtMessageType.DELETE_ENTITY_NETWORK) {
-                    message = DeleteEntityNetwork.read(buffer);
-                }
                 else if (header.type === CrdtMessageType.APPEND_VALUE) {
                     message = AppendValueOperation.read(buffer);
-                    // Unknown message, we skip it
                 }
                 else {
-                    // consume the message
+                    // Unknown message, we skip it (including NETWORK messages)
                     buffer.incrementReadOffset(header.length);
                 }
                 if (message) {
@@ -84,22 +70,6 @@ export function crdtSceneSystem(engine, onProcessEntityComponentChange) {
         const messagesToProcess = value.splice(0, value.length);
         return messagesToProcess;
     }
-    /**
-     * Find the local entityId associated to the network component message.
-     * It's a mapping Network -> to Local
-     * If it's not a network message, return the entityId received by the message
-     */
-    function findNetworkId(msg) {
-        const hasNetworkId = 'networkId' in msg;
-        if (hasNetworkId) {
-            for (const [entityId, network] of engine.getEntitiesWith(NetworkEntity)) {
-                if (network.networkId === msg.networkId && network.entityId === msg.entityId) {
-                    return { entityId, network };
-                }
-            }
-        }
-        return { entityId: msg.entityId };
-    }
     /**
      * This fn will be called on every tick.
      * Process all the messages queue received by the transport
@@ -108,46 +78,52 @@ export function crdtSceneSystem(engine, onProcessEntityComponentChange) {
         const messagesToProcess = getMessages(receivedMessages);
         const entitiesShouldBeCleaned = [];
         for (const msg of messagesToProcess) {
-            let { entityId, network } = findNetworkId(msg);
-            // We receive a new Entity. Create the localEntity and map it to the NetworkEntity component
-            if (networkUtils.isNetworkMessage(msg) && !network) {
-                entityId = engine.addEntity();
-                network = { entityId: msg.entityId, networkId: msg.networkId };
-                NetworkEntity.createOrReplace(entityId, network);
-            }
-            if (msg.type === CrdtMessageType.DELETE_ENTITY || msg.type === CrdtMessageType.DELETE_ENTITY_NETWORK) {
-                entitiesShouldBeCleaned.push(entityId);
+            // Simple CRDT processing - no network logic
+            if (msg.type === CrdtMessageType.DELETE_ENTITY) {
+                entitiesShouldBeCleaned.push(msg.entityId);
                 broadcastMessages.push(msg);
             }
             else {
-                const entityState = engine.entityContainer.getEntityState(entityId);
-                // Skip updates from removed entityes
+                const entityState = engine.entityContainer.getEntityState(msg.entityId);
+                // Skip updates from removed entities
                 if (entityState === EntityState.Removed)
                     continue;
-                // Entities with unknown entities should update its entity state
+                // Entities with unknown state should update its entity state
                 if (entityState === EntityState.Unknown) {
-                    engine.entityContainer.updateUsedEntity(entityId);
-                }
-                const component = engine.getComponentOrNull(msg.componentId);
-                /* istanbul ignore else */
-                if (component) {
-                    if (msg.type === CrdtMessageType.PUT_COMPONENT &&
-                        component.componentId === Transform.componentId &&
-                        NetworkEntity.has(entityId) &&
-                        NetworkParent.has(entityId)) {
-                        msg.data = networkUtils.fixTransformParent(msg);
+                    engine.entityContainer.updateUsedEntity(msg.entityId);
+                }
+                // Only process component-related messages (not DELETE_ENTITY)
+                if ('componentId' in msg) {
+                    const component = engine.getComponentOrNull(msg.componentId);
+                    if (component) {
+                        // Handle authoritative messages differently - they force the state regardless of timestamp
+                        const tryUpdate = () => {
+                            try {
+                                return msg.type === CrdtMessageType.AUTHORITATIVE_PUT_COMPONENT
+                                    ? component.__forceUpdateFromCrdt(msg)
+                                    : component.updateFromCrdt(msg);
+                            }
+                            catch (e) {
+                                console.error('[receiveMessages] ERROR processing message', msg, e);
+                                return null;
+                            }
+                        };
+                        const result = tryUpdate();
+                        if (!result)
+                            continue;
+                        const [conflictMessage, value] = result;
+                        if (!conflictMessage) {
+                            // Add message to broadcast queue when no conflict
+                            broadcastMessages.push(msg);
+                            onProcessEntityComponentChange && onProcessEntityComponentChange(msg.entityId, msg.type, component, value);
+                        }
                     }
-                    const [conflictMessage, value] = component.updateFromCrdt({ ...msg, entityId });
-                    if (!conflictMessage) {
-                        // Add message to transport queue to be processed by others transports
+                    else {
+                        // Component not found - still broadcast for editor compatibility
+                        /* istanbul ignore next */
                         broadcastMessages.push(msg);
-                        onProcessEntityComponentChange && onProcessEntityComponentChange(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
@@ -161,16 +137,17 @@ export function crdtSceneSystem(engine, onProcessEntityComponentChange) {
         }
     }
     /**
-     * Iterates the dirty map and generates crdt messages to be send
+     * Simple CRDT message broadcasting - no network-specific logic
      */
     async function sendMessages(entitiesDeletedThisTick) {
-        // CRDT Messages will be the merge between the recieved transport messages and the new crdt messages
+        // Get messages from broadcast queue and component updates
         const crdtMessages = getMessages(broadcastMessages);
         const buffer = new ReadWriteByteBuffer();
+        // Generate CRDT messages from component updates
         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
+                // Only create messages if there's a transport that will handle it
                 if (transports.some((t) => t.filter(message))) {
                     if (message.type === CrdtMessageType.PUT_COMPONENT) {
                         PutComponentOperation.write(message.entityId, message.timestamp, message.componentId, message.data, buffer);
@@ -194,7 +171,7 @@ export function crdtSceneSystem(engine, onProcessEntityComponentChange) {
                 }
             }
         }
-        // After all updates, I execute the DeletedEntity messages
+        // Handle deleted entities
         for (const entityId of entitiesDeletedThisTick) {
             const offset = buffer.currentWriteOffset();
             DeleteEntity.write(entityId, buffer);
@@ -205,87 +182,19 @@ export function crdtSceneSystem(engine, onProcessEntityComponentChange) {
             });
             onProcessEntityComponentChange && onProcessEntityComponentChange(entityId, CrdtMessageType.DELETE_ENTITY);
         }
-        // Send CRDT messages to transports
-        const transportBuffer = new ReadWriteByteBuffer();
-        for (const index in transports) {
-            const __NetworkMessagesBuffer = [];
-            const transportIndex = Number(index);
-            const transport = transports[transportIndex];
-            const isRendererTransport = transport.type === 'renderer';
-            const isNetworkTransport = transport.type === 'network';
-            // Reset Buffer for each Transport
-            transportBuffer.resetBuffer();
-            const buffer = new ReadWriteByteBuffer();
-            // Then we send all the new crdtMessages that the transport needs to process
+        // Simple transport broadcasting - no network-specific transforms
+        for (const transport of transports) {
+            const transportBuffer = new ReadWriteByteBuffer();
             for (const message of crdtMessages) {
-                // Check if adding this message would exceed the size limit
-                const currentBufferSize = transportBuffer.toBinary().byteLength;
-                const messageSize = message.messageBuffer.byteLength;
-                if (isNetworkTransport && (currentBufferSize + messageSize) / 1024 > LIVEKIT_MAX_SIZE) {
-                    // If the current buffer has content, save it as a chunk
-                    if (currentBufferSize > 0) {
-                        __NetworkMessagesBuffer.push(transportBuffer.toCopiedBinary());
-                        transportBuffer.resetBuffer();
-                    }
-                    // If the message itself is larger than the limit, we need to handle it specially
-                    // For now, we'll skip it to prevent infinite loops
-                    if (messageSize / 1024 > LIVEKIT_MAX_SIZE) {
-                        console.error(`Message too large (${messageSize} bytes), skipping message for entity ${message.entityId}`);
-                        continue;
-                    }
-                }
                 // Avoid echo messages
-                if (message.transportId === transportIndex)
-                    continue;
-                // Redundant message for the transport
-                if (!transport.filter(message))
-                    continue;
-                const { entityId } = findNetworkId(message);
-                const transformNeedsFix = 'componentId' in message &&
-                    message.componentId === Transform.componentId &&
-                    Transform.has(entityId) &&
-                    NetworkParent.has(entityId) &&
-                    NetworkEntity.has(entityId);
-                // If there was a LOCAL change in the transform. Add the parent to that transform
-                if (isRendererTransport && message.type === CrdtMessageType.PUT_COMPONENT && transformNeedsFix) {
-                    const parent = findNetworkId(NetworkParent.get(entityId));
-                    const transformData = networkUtils.fixTransformParent(message, Transform.get(entityId), parent.entityId);
-                    const offset = buffer.currentWriteOffset();
-                    PutComponentOperation.write(entityId, message.timestamp, message.componentId, transformData, buffer);
-                    transportBuffer.writeBuffer(buffer.buffer().subarray(offset, buffer.currentWriteOffset()), false);
+                if (message.transportId === transports.indexOf(transport))
                     continue;
+                // Check if transport wants this message
+                if (transport.filter(message)) {
+                    transportBuffer.writeBuffer(message.messageBuffer, false);
                 }
-                if (isRendererTransport && networkUtils.isNetworkMessage(message)) {
-                    // If it's the renderer transport and its a NetworkMessage, we need to fix the entityId field and convert it to a known Message.
-                    // PUT_NETWORK_COMPONENT -> PUT_COMPONENT
-                    let transformData = 'data' in message ? message.data : new Uint8Array();
-                    if (transformNeedsFix) {
-                        const parent = findNetworkId(NetworkParent.get(entityId));
-                        transformData = networkUtils.fixTransformParent(message, Transform.get(entityId), parent.entityId);
-                    }
-                    networkUtils.networkMessageToLocal({ ...message, data: transformData }, entityId, buffer, transportBuffer);
-                    // Iterate the next message
-                    continue;
-                }
-                // If its a network transport and its a PUT_COMPONENT that has a NetworkEntity component, we need to send this message
-                // through comms with the EntityID and NetworkID from ther NetworkEntity so everyone can recieve this message and map to their custom entityID.
-                if (isNetworkTransport && !networkUtils.isNetworkMessage(message)) {
-                    const networkData = NetworkEntity.getOrNull(message.entityId);
-                    // If it has networkData convert the message to PUT_NETWORK_COMPONENT.
-                    if (networkData) {
-                        networkUtils.localMessageToNetwork(message, networkData, buffer, transportBuffer);
-                        // Iterate the next message
-                        continue;
-                    }
-                }
-                // Common message
-                transportBuffer.writeBuffer(message.messageBuffer, false);
-            }
-            if (isNetworkTransport && transportBuffer.currentWriteOffset()) {
-                __NetworkMessagesBuffer.push(transportBuffer.toBinary());
             }
-            const message = isNetworkTransport ? __NetworkMessagesBuffer : transportBuffer.toBinary();
-            await transport.send(message);
+            await transport.send(transportBuffer.toBinary());
         }
     }
     /**

package/dist-cjs/components/generated/component-names.gen.js

@@ -9,7 +9,6 @@ exports.coreComponentMappings = {
     "core::Animator": 1042,
     "core::AssetLoad": 1213,
     "core::AssetLoadLoadingState": 1214,
-    "core::AudioAnalysis": 1212,
     "core::AudioEvent": 1105,
     "core::AudioSource": 1020,
     "core::AudioStream": 1021,
@@ -17,7 +16,6 @@ exports.coreComponentMappings = {
     "core::AvatarBase": 1087,
     "core::AvatarEmoteCommand": 1088,
     "core::AvatarEquippedData": 1091,
-    "core::AvatarLocomotionSettings": 1211,
     "core::AvatarModifierArea": 1070,
     "core::AvatarShape": 1080,
     "core::Billboard": 1090,