@dcl/ecs 7.27.1-33533530571.commit-451d001 → 7.27.1-33669021544.commit-a6216ed

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

@@ -1,20 +1,50 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.crdtSceneSystem = void 0;
+exports.crdtSceneSystem = exports.LIVEKIT_MAX_SIZE = void 0;
 const entity_1 = require("../../engine/entity");
 const ByteBuffer_1 = require("../../serialization/ByteBuffer");
 const crdt_1 = require("../../serialization/crdt");
 const deleteComponent_1 = require("../../serialization/crdt/deleteComponent");
 const deleteEntity_1 = require("../../serialization/crdt/deleteEntity");
 const putComponent_1 = require("../../serialization/crdt/putComponent");
-const authoritativePutComponent_1 = require("../../serialization/crdt/authoritativePutComponent");
 const types_1 = require("../../serialization/crdt/types");
+const putComponentNetwork_1 = require("../../serialization/crdt/network/putComponentNetwork");
+const components_1 = require("../../components");
+const networkUtils = __importStar(require("../../serialization/crdt/network/utils"));
+// NetworkMessages can only have a MAX_SIZE of 12kb. So we need to send it in chunks.
+exports.LIVEKIT_MAX_SIZE = 12;
 /**
  * @internal
  */
 function crdtSceneSystem(engine, onProcessEntityComponentChange) {
     const transports = [];
-    // No network components needed - pure CRDT processing only
+    // Components that we used on this system
+    const NetworkEntity = (0, components_1.NetworkEntity)(engine);
+    const NetworkParent = (0, components_1.NetworkParent)(engine);
+    const Transform = (0, components_1.Transform)(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.
@@ -39,20 +69,27 @@ function crdtSceneSystem(engine, onProcessEntityComponentChange) {
                 if (header.type === types_1.CrdtMessageType.DELETE_COMPONENT) {
                     message = deleteComponent_1.DeleteComponent.read(buffer);
                 }
+                else if (header.type === types_1.CrdtMessageType.DELETE_COMPONENT_NETWORK) {
+                    message = crdt_1.DeleteComponentNetwork.read(buffer);
+                }
                 else if (header.type === types_1.CrdtMessageType.PUT_COMPONENT) {
                     message = putComponent_1.PutComponentOperation.read(buffer);
                 }
-                else if (header.type === types_1.CrdtMessageType.AUTHORITATIVE_PUT_COMPONENT) {
-                    message = authoritativePutComponent_1.AuthoritativePutComponentOperation.read(buffer);
+                else if (header.type === types_1.CrdtMessageType.PUT_COMPONENT_NETWORK) {
+                    message = putComponentNetwork_1.PutNetworkComponentOperation.read(buffer);
                 }
                 else if (header.type === types_1.CrdtMessageType.DELETE_ENTITY) {
                     message = deleteEntity_1.DeleteEntity.read(buffer);
                 }
+                else if (header.type === types_1.CrdtMessageType.DELETE_ENTITY_NETWORK) {
+                    message = crdt_1.DeleteEntityNetwork.read(buffer);
+                }
                 else if (header.type === types_1.CrdtMessageType.APPEND_VALUE) {
                     message = crdt_1.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) {
@@ -74,12 +111,20 @@ function crdtSceneSystem(engine, onProcessEntityComponentChange) {
         return messagesToProcess;
     }
     /**
-     * Reserved-range entities (root/player/camera + avatars, entity number <
-     * RESERVED_STATIC_ENTITIES) are host-owned: only a transport flagged with
-     * `allowReservedEntities` (the host/renderer) may mutate or delete them.
+     * 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 isTrustedForReservedEntities(transportId) {
-        return transportId !== undefined && !!transports[transportId]?.allowReservedEntities;
+    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.
@@ -89,68 +134,46 @@ function crdtSceneSystem(engine, onProcessEntityComponentChange) {
         const messagesToProcess = getMessages(receivedMessages);
         const entitiesShouldBeCleaned = [];
         for (const msg of messagesToProcess) {
-            // Simple CRDT processing - no network logic
-            if (msg.type === types_1.CrdtMessageType.DELETE_ENTITY) {
-                // Reject an inbound DELETE_ENTITY on a reserved entity from an untrusted
-                // transport (a comms peer, or a scene-added transport). The allocator half
-                // is already guarded (engine.removeEntity is a no-op on this range); this
-                // closes the receive-side half.
-                const isReserved = engine.entityContainer.getEntityState(msg.entityId) === entity_1.EntityState.Reserved;
-                if (isReserved && !isTrustedForReservedEntities(msg.transportId)) {
-                    continue;
-                }
-                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 === types_1.CrdtMessageType.DELETE_ENTITY || msg.type === types_1.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 === entity_1.EntityState.Removed)
                     continue;
-                // Reject component operations (PUT/DELETE/APPEND, including AUTHORITATIVE_PUT
-                // which bypasses timestamps entirely) on reserved entities from untrusted
-                // transports. Dropping before updateFromCrdt keeps local LWW timestamps
-                // unpoisoned by forged high timestamps, and also prevents the
-                // unknown-component rebroadcast below from relaying forged reserved-entity
-                // data to other transports (including the renderer).
-                if (entityState === entity_1.EntityState.Reserved && !isTrustedForReservedEntities(msg.transportId))
-                    continue;
-                // Entities with unknown state should update its entity state
+                // Entities with unknown entities should update its entity state
                 if (entityState === entity_1.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 === types_1.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 === types_1.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
@@ -164,17 +187,16 @@ 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 ByteBuffer_1.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 === types_1.CrdtMessageType.PUT_COMPONENT) {
                         putComponent_1.PutComponentOperation.write(message.entityId, message.timestamp, message.componentId, message.data, buffer);
@@ -198,7 +220,7 @@ 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_1.DeleteEntity.write(entityId, buffer);
@@ -209,19 +231,87 @@ function crdtSceneSystem(engine, onProcessEntityComponentChange) {
             });
             onProcessEntityComponentChange && onProcessEntityComponentChange(entityId, types_1.CrdtMessageType.DELETE_ENTITY);
         }
-        // Simple transport broadcasting - no network-specific transforms
-        for (const transport of transports) {
-            const transportBuffer = new ByteBuffer_1.ReadWriteByteBuffer();
+        // Send CRDT messages to transports
+        const transportBuffer = new ByteBuffer_1.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 ByteBuffer_1.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;
+                // 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 > exports.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 > exports.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 === types_1.CrdtMessageType.PUT_COMPONENT && transformNeedsFix) {
+                    const parent = findNetworkId(NetworkParent.get(entityId));
+                    const transformData = networkUtils.fixTransformParent(message, Transform.get(entityId), parent.entityId);
+                    const offset = buffer.currentWriteOffset();
+                    putComponent_1.PutComponentOperation.write(entityId, message.timestamp, message.componentId, transformData, buffer);
+                    transportBuffer.writeBuffer(buffer.buffer().subarray(offset, buffer.currentWriteOffset()), false);
                     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());
             }
-            await transport.send(transportBuffer.toBinary());
+            const message = isNetworkTransport ? __NetworkMessagesBuffer : transportBuffer.toBinary();
+            await transport.send(message);
         }
     }
     /**

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

@@ -29,14 +29,4 @@ export type Transport = {
     onmessage?(message: Uint8Array): void;
     filter(message: Omit<TransportMessage, 'messageBuffer'>): boolean;
     type?: string;
-    /**
-     * Whether this transport is allowed to mutate reserved-range entities
-     * (root/player/camera + avatars, entity number below `RESERVED_STATIC_ENTITIES`).
-     * Only the trusted host/renderer transport sets this. An inbound DELETE_ENTITY
-     * or component operation (PUT_COMPONENT, DELETE_COMPONENT, APPEND_VALUE,
-     * AUTHORITATIVE_PUT_COMPONENT) on a reserved entity from a transport without
-     * this flag (a comms peer, or any scene-added transport) is rejected — see
-     * `receiveMessages`.
-     */
-    allowReservedEntities?: boolean;
 };

package/dist-cjs/systems/events.d.ts

@@ -48,6 +48,24 @@ export interface PointerEventsSystem {
      * @param entity - Entity where the callback was attached
      */
     removeOnPointerHoverLeave(entity: Entity): void;
+    /**
+     * @public
+     * Remove the callback for onPointerDrag event
+     * @param entity - Entity where the callback was attached
+     */
+    removeOnPointerDrag(entity: Entity): void;
+    /**
+     * @public
+     * Remove the callback for onPointerDragLocked event
+     * @param entity - Entity where the callback was attached
+     */
+    removeOnPointerDragLocked(entity: Entity): void;
+    /**
+     * @public
+     * Remove the callback for onPointerDragEnd event
+     * @param entity - Entity where the callback was attached
+     */
+    removeOnPointerDragEnd(entity: Entity): void;
     /**
      * @public
      * Remove the callback for onProximityDown event
@@ -126,6 +144,36 @@ export interface PointerEventsSystem {
         entity: Entity;
         opts?: Partial<EventSystemOptions>;
     }, cb: EventSystemCallback): void;
+    /**
+     * @public
+     * Execute callback while the user holds the button pressed and moves the pointer, having pressed it on the entity
+     * @param pointerData - Entity to attach the callback - Opts to trigger Feedback and Button
+     * @param cb - Function to execute on every drag update
+     */
+    onPointerDrag(pointerData: {
+        entity: Entity;
+        opts?: Partial<EventSystemOptions>;
+    }, cb: EventSystemCallback): void;
+    /**
+     * @public
+     * Same as onPointerDrag, but the cursor is locked in place for the duration of the drag
+     * @param pointerData - Entity to attach the callback - Opts to trigger Feedback and Button
+     * @param cb - Function to execute on every drag update
+     */
+    onPointerDragLocked(pointerData: {
+        entity: Entity;
+        opts?: Partial<EventSystemOptions>;
+    }, cb: EventSystemCallback): void;
+    /**
+     * @public
+     * Execute callback when the user releases the button after a drag that started on the entity
+     * @param pointerData - Entity to attach the callback - Opts to trigger Feedback and Button
+     * @param cb - Function to execute when the drag ends
+     */
+    onPointerDragEnd(pointerData: {
+        entity: Entity;
+        opts?: Partial<EventSystemOptions>;
+    }, cb: EventSystemCallback): void;
     /**
      * @public
      * Execute callback when the user presses the proximity button on the entity

package/dist-cjs/systems/events.js

@@ -47,6 +47,9 @@ function createPointerEventsSystem(engine, inputSystem) {
         EventType[EventType["HoverLeave"] = 4] = "HoverLeave";
         EventType[EventType["ProximityEnter"] = 5] = "ProximityEnter";
         EventType[EventType["ProximityLeave"] = 6] = "ProximityLeave";
+        EventType[EventType["Drag"] = 7] = "Drag";
+        EventType[EventType["DragLocked"] = 8] = "DragLocked";
+        EventType[EventType["DragEnd"] = 9] = "DragEnd";
     })(EventType || (EventType = {}));
     const eventsMap = new Map();
     function getEvent(entity) {
@@ -92,6 +95,15 @@ function createPointerEventsSystem(engine, inputSystem) {
         else if (eventType === EventType.ProximityLeave) {
             return 5 /* PointerEventType.PET_PROXIMITY_LEAVE */;
         }
+        else if (eventType === EventType.Drag) {
+            return 7 /* PointerEventType.PET_DRAG */;
+        }
+        else if (eventType === EventType.DragLocked) {
+            return 6 /* PointerEventType.PET_DRAG_LOCKED */;
+        }
+        else if (eventType === EventType.DragEnd) {
+            return 8 /* PointerEventType.PET_DRAG_END */;
+        }
         return 1 /* PointerEventType.PET_DOWN */;
     }
     function removeEvent(entity, type, interactionType = 0 /* InteractionType.CURSOR */) {
@@ -119,7 +131,10 @@ function createPointerEventsSystem(engine, inputSystem) {
                     eventType === EventType.HoverEnter ||
                     eventType === EventType.HoverLeave ||
                     eventType === EventType.ProximityEnter ||
-                    eventType === EventType.ProximityLeave) {
+                    eventType === EventType.ProximityLeave ||
+                    eventType === EventType.Drag ||
+                    eventType === EventType.DragLocked ||
+                    eventType === EventType.DragEnd) {
                     const command = inputSystem.getInputCommand(opts.button, getPointerEvent(eventType), entity);
                     if (command) {
                         (0, invariant_1.checkNotThenable)(cb(command), 'Event handler returned a thenable. Only synchronous functions are allowed');
@@ -166,6 +181,30 @@ function createPointerEventsSystem(engine, inputSystem) {
         getEvent(entity).set(EventType.HoverLeave, { cb, opts: options });
         setPointerEvent(entity, 3 /* PointerEventType.PET_HOVER_LEAVE */, options);
     };
+    const onPointerDrag = (...args) => {
+        const [data, cb] = args;
+        const { entity, opts } = data;
+        const options = (0, exports.getDefaultOpts)(opts);
+        removeEvent(entity, EventType.Drag);
+        getEvent(entity).set(EventType.Drag, { cb, opts: options });
+        setPointerEvent(entity, 7 /* PointerEventType.PET_DRAG */, options);
+    };
+    const onPointerDragLocked = (...args) => {
+        const [data, cb] = args;
+        const { entity, opts } = data;
+        const options = (0, exports.getDefaultOpts)(opts);
+        removeEvent(entity, EventType.DragLocked);
+        getEvent(entity).set(EventType.DragLocked, { cb, opts: options });
+        setPointerEvent(entity, 6 /* PointerEventType.PET_DRAG_LOCKED */, options);
+    };
+    const onPointerDragEnd = (...args) => {
+        const [data, cb] = args;
+        const { entity, opts } = data;
+        const options = (0, exports.getDefaultOpts)(opts);
+        removeEvent(entity, EventType.DragEnd);
+        getEvent(entity).set(EventType.DragEnd, { cb, opts: options });
+        setPointerEvent(entity, 8 /* PointerEventType.PET_DRAG_END */, options);
+    };
     const onProximityDown = (...args) => {
         const [data, cb] = args;
         const { entity, opts } = data;
@@ -214,6 +253,15 @@ function createPointerEventsSystem(engine, inputSystem) {
         removeOnPointerHoverLeave(entity) {
             removeEvent(entity, EventType.HoverLeave);
         },
+        removeOnPointerDrag(entity) {
+            removeEvent(entity, EventType.Drag);
+        },
+        removeOnPointerDragLocked(entity) {
+            removeEvent(entity, EventType.DragLocked);
+        },
+        removeOnPointerDragEnd(entity) {
+            removeEvent(entity, EventType.DragEnd);
+        },
         removeOnProximityDown(entity) {
             removeEvent(entity, EventType.Down, 1 /* InteractionType.PROXIMITY */);
         },
@@ -239,6 +287,9 @@ function createPointerEventsSystem(engine, inputSystem) {
         onPointerUp,
         onPointerHoverEnter,
         onPointerHoverLeave,
+        onPointerDrag,
+        onPointerDragLocked,
+        onPointerDragEnd,
         onProximityDown,
         onProximityUp,
         onProximityEnter,

package/dist-cjs/systems/raycast.d.ts

@@ -1,4 +1,4 @@
-import { RaycastQueryType, PBRaycastResult } from '../components';
+import { RaycastQueryType, RaycastShape, PBRaycastResult } from '../components';
 import { DeepReadonlyObject, Entity } from '../engine';
 import { Vector3 } from '../components/generated/pb/decentraland/common/vectors.gen';
 /**
@@ -14,6 +14,10 @@ export type RaycastSystemOptions = {
     queryType: RaycastQueryType;
     continuous?: boolean | undefined;
     collisionMask?: number | undefined;
+    /** shape to sweep along the ray, default RS_RAY (a point) */
+    shape?: RaycastShape | undefined;
+    /** include colliders from other scenes, default false */
+    includeWorld?: boolean | undefined;
 };
 export type LocalDirectionRaycastSystemOptions = {
     direction?: Vector3;

package/dist-cjs/systems/raycast.js

@@ -38,7 +38,9 @@ function createRaycastSystem(engine) {
         queryType: 0 /* RaycastQueryType.RQT_HIT_FIRST */,
         continuous: false,
         originOffset: { x: 0, y: 0, z: 0 },
-        collisionMask: 2 /* ColliderLayer.CL_PHYSICS */
+        collisionMask: 2 /* ColliderLayer.CL_PHYSICS */,
+        shape: 0 /* RaycastShape.RS_RAY */,
+        includeWorld: false
     };
     const getLocalDirectionRaycastDefaultOptions = (options = {}) => ({
         ...defaultOptions,
@@ -84,6 +86,8 @@ function createRaycastSystem(engine) {
             raycast.direction = raycastValue.directionRawValue;
             raycast.continuous = raycastValue.continuous;
             raycast.queryType = raycastValue.queryType;
+            raycast.shape = raycastValue.shape;
+            raycast.includeWorld = raycastValue.includeWorld;
             entitiesCallbackResultMap.set(entity, { callback: callback });
         };
         nextTickRaycasts.push(onNextTick);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@dcl/ecs",
   "description": "Decentraland ECS",
-  "version": "7.27.1-33533530571.commit-451d001",
+  "version": "7.27.1-33669021544.commit-a6216ed",
   "author": "DCL",
   "bugs": "https://github.com/decentraland/ecs/issues",
   "files": [
@@ -34,5 +34,5 @@
   "dependencies": {},
   "types": "./dist/index.d.ts",
   "typings": "./dist/index.d.ts",
-  "commit": "451d001304e4d3e8eecece568a58990d129e1000"
+  "commit": "a6216ed019b3e94bc687847a82d433d07c6e3e9d"
 }

package/dist/components/manual/CreatedBy.d.ts

@@ -1,9 +0,0 @@
-import { IEngine, LastWriteWinElementSetComponentDefinition } from '../../engine/types';
-export interface ICreatedByType {
-    address: string;
-}
-export type ICreatedBy = LastWriteWinElementSetComponentDefinition<ICreatedByType>;
-declare function defineCreatedBy(engine: Pick<IEngine, 'defineComponent'>): import("../../engine/types").MapComponentDefinition<import("../..").MapResult<{
-    address: import("../../schemas").ISchema<string>;
-}>>;
-export default defineCreatedBy;

package/dist/components/manual/CreatedBy.js

@@ -1,8 +0,0 @@
-import { Schemas } from '../../schemas';
-function defineCreatedBy(engine) {
-    const CreatedBy = engine.defineComponent('core-schema::Created-By', {
-        address: Schemas.String
-    });
-    return CreatedBy;
-}
-export default defineCreatedBy;

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

@@ -1,15 +0,0 @@
-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

@@ -1,47 +0,0 @@
-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 = {}));