@dcl/ecs 7.22.5-24836126953.commit-ddc8da1 → 7.22.5

package/dist/index.js

@@ -13,6 +13,7 @@ export * from './systems/assetLoad';
 export * from './systems/async-task';
 export * from './systems/tween';
 export * from './systems/triggerArea';
+export * from './systems/physics';
 export * from './engine/entity';
 export * from './components/types';
 // @internal
@@ -35,6 +36,8 @@ export const VirtualCamera = /* @__PURE__*/ components.VirtualCamera(engine);
 export const InputModifier = /* @__PURE__*/ components.InputModifier(engine);
 export const LightSource = /* @__PURE__*/ components.LightSource(engine);
 export const TriggerArea = /* @__PURE__*/ components.TriggerArea(engine);
+export const ParticleSystem = 
+/* @__PURE__*/ components.ParticleSystem(engine);
 /**
  * @alpha
  * This is going to be used for sync components through a server.
@@ -51,7 +54,6 @@ 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/runtime/helpers/index.d.ts

@@ -1,3 +1,4 @@
 export * from './coordinates';
 export * from './tree';
+export * from './vectors';
 export { createTimers, Timers, TimerId, TimerCallback } from './timers';

package/dist/runtime/helpers/index.js

@@ -1,3 +1,4 @@
 export * from './coordinates';
 export * from './tree';
+export * from './vectors';
 export { createTimers } from './timers';

package/dist/runtime/helpers/tree.d.ts

@@ -2,6 +2,12 @@ import { Entity } from '../../engine/entity';
 import { ComponentDefinition, IEngine } from '../../engine';
 import { Vector3Type } from '../../schemas/custom/Vector3';
 import { QuaternionType } from '../../schemas/custom/Quaternion';
+/**
+ * @public
+ * Rotate a vector by a quaternion
+ * Uses the formula: v' = q * v * q^(-1), optimized version
+ */
+export declare function rotateVectorByQuaternion(v: Vector3Type, q: QuaternionType): Vector3Type;
 /**
  * Get an iterator of entities that follow a tree structure for a component
  * @public

package/dist/runtime/helpers/tree.js

@@ -35,11 +35,11 @@ function multiplyQuaternions(q1, q2) {
     };
 }
 /**
- * @internal
+ * @public
  * Rotate a vector by a quaternion
  * Uses the formula: v' = q * v * q^(-1), optimized version
  */
-function rotateVectorByQuaternion(v, q) {
+export function rotateVectorByQuaternion(v, q) {
     // Extract quaternion components
     const qx = q.x, qy = q.y, qz = q.z, qw = q.w;
     // Calculate cross product terms (q.xyz × v) * 2

package/dist/runtime/helpers/vectors.d.ts

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

package/dist/runtime/helpers/vectors.js

@@ -0,0 +1,36 @@
+/**
+ * Lightweight Vector3 math utilities for internal use.
+ * Mirrors the subset of @dcl/ecs-math Vector3 API used by the physics helpers.
+ *
+ * TEMPORARY WORKAROUND: @dcl/ecs-math ships ESM-only, which breaks the dist-cjs build.
+ * The proper fix is to add a CJS build to @dcl/ecs-math upstream, then replace this
+ * file with `import { Vector3 } from '@dcl/ecs-math'`.
+ *
+ * @internal
+ */
+export const Vector3 = {
+    add(a, b) {
+        return { x: a.x + b.x, y: a.y + b.y, z: a.z + b.z };
+    },
+    subtract(a, b) {
+        return { x: a.x - b.x, y: a.y - b.y, z: a.z - b.z };
+    },
+    scale(v, s) {
+        return { x: v.x * s, y: v.y * s, z: v.z * s };
+    },
+    length(v) {
+        return Math.sqrt(v.x * v.x + v.y * v.y + v.z * v.z);
+    },
+    normalize(v) {
+        const len = Vector3.length(v);
+        if (len === 0)
+            return { x: 0, y: 0, z: 0 };
+        return { x: v.x / len, y: v.y / len, z: v.z / len };
+    },
+    equals(a, b) {
+        return a.x === b.x && a.y === b.y && a.z === b.z;
+    },
+    equalsToFloats(v, x, y, z) {
+        return v.x === x && v.y === y && v.z === z;
+    }
+};

package/dist/runtime/initialization/index.d.ts

@@ -12,6 +12,7 @@ import { AssetLoadLoadingStateSystem } from '../../systems/assetLoad';
 import { TweenSystem } from '../../systems/tween';
 import { TriggerAreaEventsSystem } from '../../systems/triggerArea';
 import { createTimers, Timers } from '../helpers/timers';
+import { PhysicsSystem } from '../../systems/physics';
 /**
  * @public
  * The engine is the part of the scene that sits in the middle and manages all of the other parts.
@@ -77,6 +78,12 @@ export { TriggerAreaEventsSystem };
  */
 export declare const timers: Timers;
 export { Timers, createTimers };
+/**
+ * @public
+ * Physics helpers for applying impulses and forces to the player.
+ */
+export declare const Physics: PhysicsSystem;
+export { PhysicsSystem };
 /**
  * @public
  * Runs an async function

package/dist/runtime/initialization/index.js

@@ -14,6 +14,7 @@ import { pointerEventColliderChecker } from '../../systems/pointer-event-collide
 import { createTriggerAreaEventsSystem } from '../../systems/triggerArea';
 import { createTimers } from '../helpers/timers';
 import { setGlobalPolyfill } from '../globals';
+import { createPhysicsSystem } from '../../systems/physics';
 /**
  * @public
  * The engine is the part of the scene that sits in the middle and manages all of the other parts.
@@ -77,6 +78,11 @@ setGlobalPolyfill('setTimeout', timers.setTimeout);
 setGlobalPolyfill('clearTimeout', timers.clearTimeout);
 setGlobalPolyfill('setInterval', timers.setInterval);
 setGlobalPolyfill('clearInterval', timers.clearInterval);
+/**
+ * @public
+ * Physics helpers for applying impulses and forces to the player.
+ */
+export const Physics = /* @__PURE__ */ createPhysicsSystem(engine);
 /**
  * Adds pointer event collider system only in DEV env
  */

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

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

package/dist/serialization/crdt/index.js

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

package/dist/serialization/crdt/network/utils.d.ts

@@ -0,0 +1,9 @@
+import { Entity } from '../../../engine';
+import { ReceiveMessage, TransformType } from '../../../runtime/types';
+import { ReceiveNetworkMessage } from '../../../systems/crdt/types';
+import { ByteBuffer } from '../../ByteBuffer';
+import { INetowrkEntityType } from '../../../components/types';
+export declare function isNetworkMessage(message: ReceiveMessage): message is ReceiveNetworkMessage;
+export declare function networkMessageToLocal(message: ReceiveNetworkMessage, localEntityId: Entity, buffer: ByteBuffer, destinationBuffer: ByteBuffer): void;
+export declare function localMessageToNetwork(message: ReceiveMessage, network: INetowrkEntityType, buffer: ByteBuffer, destinationBuffer: ByteBuffer): void;
+export declare function fixTransformParent(message: ReceiveMessage, transformValue?: TransformType, parent?: Entity): Uint8Array;

package/dist/serialization/crdt/network/utils.js

@@ -0,0 +1,60 @@
+import { ReadWriteByteBuffer } from '../../ByteBuffer';
+import { PutComponentOperation } from '../putComponent';
+import { CrdtMessageType } from '../types';
+import { DeleteComponent } from '../deleteComponent';
+import { DeleteEntity } from '../deleteEntity';
+import { PutNetworkComponentOperation } from './putComponentNetwork';
+import { DeleteComponentNetwork } from './deleteComponentNetwork';
+import { DeleteEntityNetwork } from './deleteEntityNetwork';
+import { TransformSchema } from '../../../components/manual/Transform';
+/* istanbul ignore next */
+export function isNetworkMessage(message) {
+    return [
+        CrdtMessageType.DELETE_COMPONENT_NETWORK,
+        CrdtMessageType.DELETE_ENTITY_NETWORK,
+        CrdtMessageType.PUT_COMPONENT_NETWORK
+    ].includes(message.type);
+}
+/* istanbul ignore next */
+export function networkMessageToLocal(message, localEntityId, buffer, destinationBuffer) {
+    const offset = buffer.currentWriteOffset();
+    if (message.type === CrdtMessageType.PUT_COMPONENT_NETWORK) {
+        PutComponentOperation.write(localEntityId, message.timestamp, message.componentId, message.data, buffer);
+    }
+    else if (message.type === CrdtMessageType.DELETE_COMPONENT_NETWORK) {
+        DeleteComponent.write(localEntityId, message.componentId, message.timestamp, buffer);
+    }
+    else if (message.type === CrdtMessageType.DELETE_ENTITY_NETWORK) {
+        DeleteEntity.write(localEntityId, buffer);
+    }
+    destinationBuffer.writeBuffer(buffer.buffer().subarray(offset, buffer.currentWriteOffset()), false);
+}
+/* istanbul ignore next */
+export function localMessageToNetwork(message, network, buffer, destinationBuffer) {
+    const offset = buffer.currentWriteOffset();
+    if (message.type === CrdtMessageType.PUT_COMPONENT) {
+        PutNetworkComponentOperation.write(network.entityId, message.timestamp, message.componentId, network.networkId, message.data, buffer);
+    }
+    else if (message.type === CrdtMessageType.DELETE_COMPONENT) {
+        DeleteComponentNetwork.write(network.entityId, message.componentId, message.timestamp, network.networkId, buffer);
+    }
+    else if (message.type === CrdtMessageType.DELETE_ENTITY) {
+        DeleteEntityNetwork.write(network.entityId, network.networkId, buffer);
+    }
+    destinationBuffer.writeBuffer(buffer.buffer().subarray(offset, buffer.currentWriteOffset()), false);
+}
+const buffer = new ReadWriteByteBuffer();
+/* istanbul ignore next */
+export function fixTransformParent(message, transformValue, parent) {
+    buffer.resetBuffer();
+    let transform = transformValue;
+    if (!transform && 'data' in message) {
+        transform = TransformSchema.deserialize(new ReadWriteByteBuffer(message.data));
+    }
+    if (!transform)
+        throw new Error('Invalid parent transform');
+    // Generate new transform raw data with the parent
+    const newTransform = { ...transform, parent };
+    TransformSchema.serialize(newTransform, buffer);
+    return buffer.toBinary();
+}

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

@@ -11,8 +11,7 @@ export declare enum CrdtMessageType {
     PUT_COMPONENT_NETWORK = 5,
     DELETE_COMPONENT_NETWORK = 6,
     DELETE_ENTITY_NETWORK = 7,
-    AUTHORITATIVE_PUT_COMPONENT = 8,
-    MAX_MESSAGE_TYPE = 9
+    MAX_MESSAGE_TYPE = 8
 }
 /**
  * Min length = 8 bytes
@@ -49,23 +48,6 @@ 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
  *
@@ -132,10 +114,6 @@ export type AppendValueMessage = CrdtMessageHeader & AppendValueMessageBody;
  * @public
  */
 export type PutComponentMessage = CrdtMessageHeader & PutComponentMessageBody;
-/**
- * @public
- */
-export type AuthoritativePutComponentMessage = CrdtMessageHeader & AuthoritativePutComponentMessageBody;
 /**
  * @public
  */
@@ -159,7 +137,7 @@ export type DeleteEntityNetworkMessage = CrdtMessageHeader & DeleteEntityNetwork
 /**
  * @public
  */
-export type CrdtMessage = PutComponentMessage | AuthoritativePutComponentMessage | DeleteComponentMessage | AppendValueMessage | DeleteEntityMessage | PutNetworkComponentMessage | DeleteComponentNetworkMessage | DeleteEntityNetworkMessage;
+export type CrdtMessage = PutComponentMessage | DeleteComponentMessage | AppendValueMessage | DeleteEntityMessage | PutNetworkComponentMessage | DeleteComponentNetworkMessage | DeleteEntityNetworkMessage;
 /**
  * @public
  */
@@ -167,7 +145,7 @@ export type CrdtNetworkMessageBody = PutNetworkComponentMessageBody | DeleteComp
 /**
  * @public
  */
-export type CrdtMessageBody = PutComponentMessageBody | AuthoritativePutComponentMessageBody | DeleteComponentMessageBody | DeleteEntityMessageBody | AppendValueMessageBody | CrdtNetworkMessageBody;
+export type CrdtMessageBody = PutComponentMessageBody | DeleteComponentMessageBody | DeleteEntityMessageBody | AppendValueMessageBody | CrdtNetworkMessageBody;
 export declare enum ProcessMessageResultType {
     /**
      * Typical message and new state set.

package/dist/serialization/crdt/types.js

@@ -13,9 +13,7 @@ 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";
-    // 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["MAX_MESSAGE_TYPE"] = 8] = "MAX_MESSAGE_TYPE";
 })(CrdtMessageType || (CrdtMessageType = {}));
 /**
  * @public

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

@@ -1,6 +1,7 @@
 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,17 +1,24 @@
 import { EntityState } from '../../engine/entity';
 import { ReadWriteByteBuffer } from '../../serialization/ByteBuffer';
-import { AppendValueOperation, CrdtMessageProtocol } from '../../serialization/crdt';
+import { AppendValueOperation, CrdtMessageProtocol, DeleteComponentNetwork, DeleteEntityNetwork } 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 = [];
-    // No network components needed - pure CRDT processing only
+    // Components that we used on this system
+    const NetworkEntity = defineNetworkEntity(engine);
+    const NetworkParent = defineNetworkParent(engine);
+    const Transform = defineTransform(engine);
     // 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.
@@ -36,20 +43,27 @@ 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.AUTHORITATIVE_PUT_COMPONENT) {
-                    message = AuthoritativePutComponentOperation.read(buffer);
+                else if (header.type === CrdtMessageType.PUT_COMPONENT_NETWORK) {
+                    message = PutNetworkComponentOperation.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 {
-                    // Unknown message, we skip it (including NETWORK messages)
+                    // consume the message
                     buffer.incrementReadOffset(header.length);
                 }
                 if (message) {
@@ -70,6 +84,22 @@ 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
@@ -78,52 +108,46 @@ export function crdtSceneSystem(engine, onProcessEntityComponentChange) {
         const messagesToProcess = getMessages(receivedMessages);
         const entitiesShouldBeCleaned = [];
         for (const msg of messagesToProcess) {
-            // Simple CRDT processing - no network logic
-            if (msg.type === CrdtMessageType.DELETE_ENTITY) {
-                entitiesShouldBeCleaned.push(msg.entityId);
+            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);
                 broadcastMessages.push(msg);
             }
             else {
-                const entityState = engine.entityContainer.getEntityState(msg.entityId);
-                // Skip updates from removed entities
+                const entityState = engine.entityContainer.getEntityState(entityId);
+                // Skip updates from removed entityes
                 if (entityState === EntityState.Removed)
                     continue;
-                // Entities with unknown state should update its entity state
+                // Entities with unknown entities should update its entity state
                 if (entityState === EntityState.Unknown) {
-                    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);
-                        }
+                    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);
                     }
-                    else {
-                        // Component not found - still broadcast for editor compatibility
-                        /* istanbul ignore next */
+                    const [conflictMessage, value] = component.updateFromCrdt({ ...msg, entityId });
+                    if (!conflictMessage) {
+                        // Add message to transport queue to be processed by others transports
                         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
@@ -137,17 +161,16 @@ export function crdtSceneSystem(engine, onProcessEntityComponentChange) {
         }
     }
     /**
-     * Simple CRDT message broadcasting - no network-specific logic
+     * Iterates the dirty map and generates crdt messages to be send
      */
     async function sendMessages(entitiesDeletedThisTick) {
-        // Get messages from broadcast queue and component updates
+        // CRDT Messages will be the merge between the recieved transport messages and the new crdt messages
         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();
-                // Only create messages if there's a transport that will handle it
+                // Avoid creating messages if there is no 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);
@@ -171,7 +194,7 @@ export function crdtSceneSystem(engine, onProcessEntityComponentChange) {
                 }
             }
         }
-        // Handle deleted entities
+        // After all updates, I execute the DeletedEntity messages
         for (const entityId of entitiesDeletedThisTick) {
             const offset = buffer.currentWriteOffset();
             DeleteEntity.write(entityId, buffer);
@@ -182,19 +205,87 @@ export function crdtSceneSystem(engine, onProcessEntityComponentChange) {
             });
             onProcessEntityComponentChange && onProcessEntityComponentChange(entityId, CrdtMessageType.DELETE_ENTITY);
         }
-        // Simple transport broadcasting - no network-specific transforms
-        for (const transport of transports) {
-            const transportBuffer = new ReadWriteByteBuffer();
+        // 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
             for (const message of crdtMessages) {
                 // Avoid echo messages
-                if (message.transportId === transports.indexOf(transport))
+                if (message.transportId === transportIndex)
                     continue;
-                // Check if transport wants this message
-                if (transport.filter(message)) {
-                    transportBuffer.writeBuffer(message.messageBuffer, false);
+                // Redundant message for the transport
+                if (!transport.filter(message))
+                    continue;
+                // 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;
+                    }
                 }
+                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);
+                    continue;
+                }
+                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());
             }
-            await transport.send(transportBuffer.toBinary());
+            const message = isNetworkTransport ? __NetworkMessagesBuffer : transportBuffer.toBinary();
+            await transport.send(message);
         }
     }
     /**