@dcl/ecs 7.24.5-28985208893.commit-8caf648 → 7.24.5-29245621744.commit-336df45

package/dist/systems/events.js

@@ -18,14 +18,15 @@ export function createPointerEventsSystem(engine, inputSystem) {
         EventType[EventType["Up"] = 2] = "Up";
         EventType[EventType["HoverEnter"] = 3] = "HoverEnter";
         EventType[EventType["HoverLeave"] = 4] = "HoverLeave";
-        EventType[EventType["ProximityEnter"] = 5] = "ProximityEnter";
-        EventType[EventType["ProximityLeave"] = 6] = "ProximityLeave";
+        EventType[EventType["Drag"] = 5] = "Drag";
+        EventType[EventType["DragLocked"] = 6] = "DragLocked";
+        EventType[EventType["DragEnd"] = 7] = "DragEnd";
     })(EventType || (EventType = {}));
     const eventsMap = new Map();
     function getEvent(entity) {
         return eventsMap.get(entity) || eventsMap.set(entity, new Map()).get(entity);
     }
-    function setPointerEvent(entity, type, opts, interactionType = 0 /* InteractionType.CURSOR */) {
+    function setPointerEvent(entity, type, opts) {
         const pointerEvent = PointerEvents.getMutableOrNull(entity) || PointerEvents.create(entity);
         pointerEvent.pointerEvents.push({
             eventType: type,
@@ -35,19 +36,15 @@ export function createPointerEventsSystem(engine, inputSystem) {
                 showHighlight: opts.showHighlight,
                 hoverText: opts.hoverText,
                 maxDistance: opts.maxDistance,
-                maxPlayerDistance: opts.maxPlayerDistance,
-                priority: opts.priority
-            },
-            interactionType: interactionType ?? 0 /* InteractionType.CURSOR */
+                maxPlayerDistance: opts.maxPlayerDistance
+            }
         });
     }
-    function removePointerEvent(entity, type, button, interactionType = 0 /* InteractionType.CURSOR */) {
+    function removePointerEvent(entity, type, button) {
         const pointerEvent = PointerEvents.getMutableOrNull(entity);
         if (!pointerEvent)
             return;
-        pointerEvent.pointerEvents = pointerEvent.pointerEvents.filter((pointer) => !(pointer.eventInfo?.button === button &&
-            pointer.eventType === type &&
-            pointer.interactionType === interactionType));
+        pointerEvent.pointerEvents = pointerEvent.pointerEvents.filter((pointer) => !(pointer.eventInfo?.button === button && pointer.eventType === type));
     }
     function getPointerEvent(eventType) {
         if (eventType === EventType.Up) {
@@ -59,117 +56,148 @@ export function createPointerEventsSystem(engine, inputSystem) {
         else if (eventType === EventType.HoverEnter) {
             return 2 /* PointerEventType.PET_HOVER_ENTER */;
         }
-        else if (eventType === EventType.ProximityEnter) {
-            return 4 /* PointerEventType.PET_PROXIMITY_ENTER */;
+        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.ProximityLeave) {
-            return 5 /* PointerEventType.PET_PROXIMITY_LEAVE */;
+        else if (eventType === EventType.DragEnd) {
+            return 8 /* PointerEventType.PET_DRAG_END */;
         }
         return 1 /* PointerEventType.PET_DOWN */;
     }
-    function removeEvent(entity, type, interactionType = 0 /* InteractionType.CURSOR */) {
+    function getEventType(pet) {
+        if (pet === 0 /* PointerEventType.PET_UP */) {
+            return EventType.Up;
+        }
+        else if (pet === 2 /* PointerEventType.PET_HOVER_ENTER */) {
+            return EventType.HoverEnter;
+        }
+        else if (pet === 3 /* PointerEventType.PET_HOVER_LEAVE */) {
+            return EventType.HoverLeave;
+        }
+        else if (pet === 7 /* PointerEventType.PET_DRAG */) {
+            return EventType.Drag;
+        }
+        else if (pet === 6 /* PointerEventType.PET_DRAG_LOCKED */) {
+            return EventType.DragLocked;
+        }
+        else if (pet === 8 /* PointerEventType.PET_DRAG_END */) {
+            return EventType.DragEnd;
+        }
+        else {
+            return EventType.Down;
+        }
+    }
+    function removeEvent(entity, type) {
         const event = getEvent(entity);
-        const pointerEvent = event.get(type);
-        if (pointerEvent?.opts.hoverText) {
-            removePointerEvent(entity, getPointerEvent(type), pointerEvent.opts.button);
+        const pointerEventList = event.get(type);
+        if (pointerEventList === undefined) {
+            return;
+        }
+        for (const button of pointerEventList.keys()) {
+            removePointerEvent(entity, getPointerEvent(type), button);
         }
         event.delete(type);
     }
     engine.addSystem(function EventSystem() {
-        for (const [entity, event] of eventsMap) {
+        if (eventsMap.size === 0) {
+            return;
+        }
+        for (const entity of eventsMap.keys()) {
             if (engine.getEntityState(entity) === EntityState.Removed) {
                 eventsMap.delete(entity);
+            }
+        }
+        for (const command of inputSystem.getInputCommands()) {
+            const entity = command.hit?.entityId;
+            if (entity === undefined) {
+                continue;
+            }
+            const entityMap = eventsMap.get(entity);
+            if (entityMap === undefined) {
                 continue;
             }
-            for (const [eventType, { cb, opts }] of event) {
-                if (eventType === EventType.Click) {
-                    const command = inputSystem.getClick(opts.button, entity);
-                    if (command)
-                        checkNotThenable(cb(command.up), 'Click event returned a thenable. Only synchronous functions are allowed');
+            const typeMap = entityMap.get(getEventType(command.state));
+            if (typeMap) {
+                const data = typeMap.get(command.button);
+                if (data) {
+                    checkNotThenable(data.cb(command), 'Event handler returned a thenable. Only synchronous functions are allowed');
                 }
-                if (eventType === EventType.Down ||
-                    eventType === EventType.Up ||
-                    eventType === EventType.HoverEnter ||
-                    eventType === EventType.HoverLeave ||
-                    eventType === EventType.ProximityEnter ||
-                    eventType === EventType.ProximityLeave) {
-                    const command = inputSystem.getInputCommand(opts.button, getPointerEvent(eventType), entity);
-                    if (command) {
-                        checkNotThenable(cb(command), 'Event handler returned a thenable. Only synchronous functions are allowed');
+                const anyData = typeMap.get(3 /* InputAction.IA_ANY */);
+                if (anyData) {
+                    checkNotThenable(anyData.cb(command), 'Event handler returned a thenable. Only synchronous functions are allowed');
+                }
+            }
+            // check clicks separately
+            if (command.state === 0 /* PointerEventType.PET_UP */) {
+                const clickMap = entityMap.get(EventType.Click);
+                if (clickMap) {
+                    const data = clickMap.get(command.button);
+                    if (data && inputSystem.getClick(command.button, entity)) {
+                        checkNotThenable(data.cb(command), 'Click event returned a thenable. Only synchronous functions are allowed');
+                    }
+                    const anyData = clickMap.get(3 /* InputAction.IA_ANY */);
+                    if (anyData && inputSystem.getClick(command.button, entity)) {
+                        checkNotThenable(anyData.cb(command), 'Event handler returned a thenable. Only synchronous functions are allowed');
                     }
                 }
             }
         }
     });
-    const onPointerDown = (...args) => {
-        const [data, cb, maybeOpts] = args;
-        if (typeof data === 'number') {
-            return onPointerDown({ entity: data, opts: maybeOpts ?? {} }, cb);
-        }
-        const { entity, opts } = data;
-        const options = getDefaultOpts(opts);
-        removeEvent(entity, EventType.Down);
-        getEvent(entity).set(EventType.Down, { cb, opts: options });
-        setPointerEvent(entity, 1 /* PointerEventType.PET_DOWN */, options);
-    };
-    const onPointerUp = (...args) => {
-        const [data, cb, maybeOpts] = args;
-        if (typeof data === 'number') {
-            return onPointerUp({ entity: data, opts: maybeOpts ?? {} }, cb);
-        }
-        const { entity, opts } = data;
-        const options = getDefaultOpts(opts);
-        removeEvent(entity, EventType.Up);
-        getEvent(entity).set(EventType.Up, { cb, opts: options });
-        setPointerEvent(entity, 0 /* PointerEventType.PET_UP */, options);
-    };
-    const onPointerHoverEnter = (...args) => {
-        const [data, cb] = args;
-        const { entity, opts } = data;
-        const options = getDefaultOpts(opts);
-        removeEvent(entity, EventType.HoverEnter);
-        getEvent(entity).set(EventType.HoverEnter, { cb, opts: options });
-        setPointerEvent(entity, 2 /* PointerEventType.PET_HOVER_ENTER */, options);
-    };
-    const onPointerHoverLeave = (...args) => {
-        const [data, cb] = args;
-        const { entity, opts } = data;
-        const options = getDefaultOpts(opts);
-        removeEvent(entity, EventType.HoverLeave);
-        getEvent(entity).set(EventType.HoverLeave, { cb, opts: options });
-        setPointerEvent(entity, 3 /* PointerEventType.PET_HOVER_LEAVE */, options);
-    };
-    const onProximityDown = (...args) => {
-        const [data, cb] = args;
-        const { entity, opts } = data;
-        const options = getDefaultOpts(opts);
-        removeEvent(entity, EventType.Down, 1 /* InteractionType.PROXIMITY */);
-        getEvent(entity).set(EventType.Down, { cb, opts: options });
-        setPointerEvent(entity, 1 /* PointerEventType.PET_DOWN */, options, 1 /* InteractionType.PROXIMITY */);
-    };
-    const onProximityUp = (...args) => {
-        const [data, cb] = args;
-        const { entity, opts } = data;
-        const options = getDefaultOpts(opts);
-        removeEvent(entity, EventType.Up, 1 /* InteractionType.PROXIMITY */);
-        getEvent(entity).set(EventType.Up, { cb, opts: options });
-        setPointerEvent(entity, 0 /* PointerEventType.PET_UP */, options, 1 /* InteractionType.PROXIMITY */);
-    };
-    const onProximityEnter = (...args) => {
-        const [data, cb] = args;
-        const { entity, opts } = data;
-        const options = getDefaultOpts(opts);
-        removeEvent(entity, EventType.ProximityEnter, 1 /* InteractionType.PROXIMITY */);
-        getEvent(entity).set(EventType.ProximityEnter, { cb, opts: options });
-        setPointerEvent(entity, 4 /* PointerEventType.PET_PROXIMITY_ENTER */, options, 1 /* InteractionType.PROXIMITY */);
-    };
-    const onProximityLeave = (...args) => {
-        const [data, cb] = args;
-        const { entity, opts } = data;
-        const options = getDefaultOpts(opts);
-        removeEvent(entity, EventType.ProximityLeave, 1 /* InteractionType.PROXIMITY */);
-        getEvent(entity).set(EventType.ProximityLeave, { cb, opts: options });
-        setPointerEvent(entity, 5 /* PointerEventType.PET_PROXIMITY_LEAVE */, options, 1 /* InteractionType.PROXIMITY */);
+    // return a function with the correct event type.
+    // we use onPointerDown as the "archetype" for the returned function, but it fits with
+    // all the onPointer* declarations
+    const onPointerFunction = (ty) => {
+        return (arg0, arg1, arg2) => {
+            let entity;
+            let optsList;
+            if (typeof arg0 === 'number') {
+                // called as onPointerDown(entity: Entity, cb: EventSystemCallback, opts?: Partial<EventSystemOptions>): void
+                entity = arg0;
+                const cb = arg1;
+                const opts = arg2;
+                optsList = [{ cb, ...getDefaultOpts(opts) }];
+            }
+            else if (typeof arg1 === 'function') {
+                // called as onPointerDown(pointerData: { entity: Entity; opts?: Partial<EventSystemOptions> }, cb: EventSystemCallback): void
+                const { entity: e, opts } = arg0;
+                const cb = arg1;
+                entity = e;
+                optsList = [{ cb, ...getDefaultOpts(opts) }];
+            }
+            else {
+                // called as onPointerDown(pointerData: { entity: Entity; optsList: EventSystemOptionsCallback[] }): void
+                const { entity: e, optsList: o } = arg0;
+                entity = e;
+                optsList = o;
+            }
+            const previous = getEvent(entity).get(ty) ?? new Map();
+            const callbacks = new Map();
+            for (const opts of optsList) {
+                const prevOpts = previous.get(opts.button);
+                if (prevOpts !== undefined) {
+                    if (prevOpts.hoverText !== opts.hoverText ||
+                        prevOpts.maxDistance !== opts.maxDistance ||
+                        prevOpts.showFeedback !== opts.showFeedback ||
+                        prevOpts.showHighlight !== opts.showHighlight) {
+                        removePointerEvent(entity, getPointerEvent(ty), opts.button);
+                        setPointerEvent(entity, getPointerEvent(ty), opts);
+                    }
+                }
+                else {
+                    setPointerEvent(entity, getPointerEvent(ty), opts);
+                }
+                callbacks.set(opts.button, opts);
+            }
+            for (const button of previous.keys()) {
+                if (!callbacks.has(button)) {
+                    removePointerEvent(entity, getPointerEvent(ty), button);
+                }
+            }
+            getEvent(entity).set(ty, callbacks);
+        };
     };
     return {
         removeOnClick(entity) {
@@ -187,34 +215,22 @@ export function createPointerEventsSystem(engine, inputSystem) {
         removeOnPointerHoverLeave(entity) {
             removeEvent(entity, EventType.HoverLeave);
         },
-        removeOnProximityDown(entity) {
-            removeEvent(entity, EventType.Down, 1 /* InteractionType.PROXIMITY */);
-        },
-        removeOnProximityUp(entity) {
-            removeEvent(entity, EventType.Up, 1 /* InteractionType.PROXIMITY */);
+        removeOnPointerDrag(entity) {
+            removeEvent(entity, EventType.Drag);
         },
-        removeOnProximityEnter(entity) {
-            removeEvent(entity, EventType.ProximityEnter, 1 /* InteractionType.PROXIMITY */);
+        removeOnPointerDragLocked(entity) {
+            removeEvent(entity, EventType.DragLocked);
         },
-        removeOnProximityLeave(entity) {
-            removeEvent(entity, EventType.ProximityLeave, 1 /* InteractionType.PROXIMITY */);
-        },
-        onClick(value, cb) {
-            const { entity } = value;
-            const options = getDefaultOpts(value.opts);
-            // Clear previous event with over feedback included
-            removeEvent(entity, EventType.Click);
-            // Set new event
-            getEvent(entity).set(EventType.Click, { cb, opts: options });
-            setPointerEvent(entity, 1 /* PointerEventType.PET_DOWN */, options);
+        removeOnPointerDragEnd(entity) {
+            removeEvent(entity, EventType.DragEnd);
         },
-        onPointerDown,
-        onPointerUp,
-        onPointerHoverEnter,
-        onPointerHoverLeave,
-        onProximityDown,
-        onProximityUp,
-        onProximityEnter,
-        onProximityLeave
+        onClick: onPointerFunction(EventType.Click),
+        onPointerDown: onPointerFunction(EventType.Down),
+        onPointerUp: onPointerFunction(EventType.Up),
+        onPointerHoverEnter: onPointerFunction(EventType.HoverEnter),
+        onPointerHoverLeave: onPointerFunction(EventType.HoverLeave),
+        onPointerDrag: onPointerFunction(EventType.Drag),
+        onPointerDragLocked: onPointerFunction(EventType.DragLocked),
+        onPointerDragEnd: onPointerFunction(EventType.DragEnd)
     };
 }

package/dist/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,8 @@ export type RaycastSystemOptions = {
     queryType: RaycastQueryType;
     continuous?: boolean | undefined;
     collisionMask?: number | undefined;
+    shape?: RaycastShape | undefined;
+    includeWorld?: boolean | undefined;
 };
 export type LocalDirectionRaycastSystemOptions = {
     direction?: Vector3;

package/dist/systems/raycast.js

@@ -58,6 +58,8 @@ export 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/dist/systems/triggerArea.d.ts

@@ -26,11 +26,6 @@ export interface TriggerAreaEventsSystem {
      * Execute callback when an entity stays in the Trigger Area
      * @param entity - The entity that already has the TriggerArea component
      * @param cb - Function to execute the 'Stay' type of result is detected
-     *
-     * Note: stay callbacks are synthesized by the SDK on every tick between a wire ENTER and a wire EXIT.
-     * Wire-level TAET_STAY events (still emitted by legacy Explorers) are ignored entirely — they neither
-     * fire callbacks nor mutate state. The SDK is the sole source of onTriggerStay dispatches, driven
-     * from the ENTER/EXIT state machine.
      */
     onTriggerStay(entity: Entity, cb: TriggerAreaEventSystemCallback): void;
     /**

package/dist/systems/triggerArea.js

@@ -1,57 +1,10 @@
 import * as components from '../components';
 import { EntityState } from '../engine/entity';
-/**
- * Builds a synthetic PBTriggerAreaResult for a per-tick onStay callback.
- *
- * Transform components are resolved at call time so that scene-owned entities report
- * up-to-date position/rotation/scale. For player-avatar triggerers (reserved entities
- * without a scene-side Transform), there is no scene Transform component, so the cached
- * values from the last ENTER or wire-STAY event are used as-is. These cached values may
- * be slightly stale for the current frame — this is expected and acceptable for the
- * avatar case.
- */
-function buildSyntheticStayResult(cached, triggerAreaEntity, triggererEntity, currentTimestamp, Transform) {
-    // Shallow-clone the trigger sub-object so we can mutate it.
-    const trigger = cached.trigger
-        ? {
-            entity: cached.trigger.entity,
-            layers: cached.trigger.layers,
-            position: cached.trigger.position ? { ...cached.trigger.position } : undefined,
-            rotation: cached.trigger.rotation ? { ...cached.trigger.rotation } : undefined,
-            scale: cached.trigger.scale ? { ...cached.trigger.scale } : undefined
-        }
-        : undefined;
-    // Build the cloned result with a forced TAET_STAY eventType and refreshed timestamp.
-    const result = {
-        triggeredEntity: cached.triggeredEntity,
-        triggeredEntityPosition: cached.triggeredEntityPosition ? { ...cached.triggeredEntityPosition } : undefined,
-        triggeredEntityRotation: cached.triggeredEntityRotation ? { ...cached.triggeredEntityRotation } : undefined,
-        eventType: 1 /* TriggerAreaEventType.TAET_STAY */,
-        timestamp: currentTimestamp,
-        trigger
-    };
-    // Refresh trigger-area entity transform when it is scene-owned.
-    const triggerAreaTransform = Transform.getOrNull(triggerAreaEntity);
-    if (triggerAreaTransform !== null) {
-        result.triggeredEntityPosition = { ...triggerAreaTransform.position };
-        result.triggeredEntityRotation = { ...triggerAreaTransform.rotation };
-    }
-    // Refresh triggerer transform when it is scene-owned.
-    // For player-avatar entities (reserved, no scene-side Transform) the cached values are kept.
-    const triggererTransform = Transform.getOrNull(triggererEntity);
-    if (triggererTransform !== null && result.trigger) {
-        result.trigger.position = { ...triggererTransform.position };
-        result.trigger.rotation = { ...triggererTransform.rotation };
-        result.trigger.scale = { ...triggererTransform.scale };
-    }
-    return result;
-}
 /**
  * @internal
  */
 export function createTriggerAreaEventsSystem(engine) {
     const triggerAreaResultComponent = components.TriggerAreaResult(engine);
-    const Transform = components.Transform(engine);
     const entitiesMap = new Map();
     function hasCallbacksMap(entity) {
         return entitiesMap.has(entity) && entitiesMap.get(entity) !== undefined;
@@ -63,8 +16,7 @@ export function createTriggerAreaEventsSystem(engine) {
         else {
             entitiesMap.set(entity, {
                 triggerCallbackMap: new Map([[triggerType, callback]]),
-                lastConsumedTimestamp: -1,
-                insideTriggerers: new Map()
+                lastConsumedTimestamp: -1
             });
         }
     }
@@ -73,9 +25,7 @@ export function createTriggerAreaEventsSystem(engine) {
             return;
         const triggerCallbackMap = entitiesMap.get(entity).triggerCallbackMap;
         triggerCallbackMap.delete(triggerType);
-        // Remove entity if no more trigger callbacks are registered.
-        // insideTriggerers is intentionally left populated so that re-subscription picks up
-        // in-flight sessions without missing the first synthesized onStay.
+        // Remove entity if no more trigger callbacks are registered
         if (triggerCallbackMap.size === 0)
             entitiesMap.delete(entity);
     }
@@ -105,88 +55,51 @@ export function createTriggerAreaEventsSystem(engine) {
                 continue;
             }
             const result = triggerAreaResultComponent.get(entity);
-            // -----------------------------------------------------------------------
-            // Pass 1: drain new GOVS events
-            // -----------------------------------------------------------------------
-            // The Explorer may be taking time before the result component is put.
-            if (result.size > 0) {
-                const values = Array.from(result.values());
-                // Determine starting index for new values (more than one could be added between System updates).
-                // Search backwards to find the anchor at lastConsumedTimestamp.
-                let startIndex = 0;
-                if (data.lastConsumedTimestamp >= 0) {
-                    const newestTimestamp = values[values.length - 1].timestamp;
-                    // If nothing new, skip processing.
-                    if (newestTimestamp > data.lastConsumedTimestamp) {
-                        // Find index of value with the lastConsumedTimestamp.
-                        let i = values.length - 2;
-                        while (i >= 0 && values[i].timestamp > data.lastConsumedTimestamp)
-                            i--;
-                        // Mark the following value index as the starting point to trigger all the new value callbacks.
-                        startIndex = i + 1;
-                    }
-                    else {
-                        // No new events — skip to Pass 2.
-                        startIndex = values.length;
-                    }
-                }
-                if (startIndex < values.length) {
-                    // Process new wire events in chronological order.
-                    for (let i = startIndex; i < values.length; i++) {
-                        const event = values[i];
-                        switch (event.eventType) {
-                            case 0 /* TriggerAreaEventType.TAET_ENTER */:
-                                // Update in-flight tracking before firing the callback.
-                                data.insideTriggerers.set(event.trigger.entity, {
-                                    triggeredEntity: event.triggeredEntity,
-                                    triggeredEntityPosition: event.triggeredEntityPosition
-                                        ? { ...event.triggeredEntityPosition }
-                                        : undefined,
-                                    triggeredEntityRotation: event.triggeredEntityRotation
-                                        ? { ...event.triggeredEntityRotation }
-                                        : undefined,
-                                    eventType: event.eventType,
-                                    timestamp: event.timestamp,
-                                    trigger: event.trigger
-                                        ? {
-                                            entity: event.trigger.entity,
-                                            layers: event.trigger.layers,
-                                            position: event.trigger.position ? { ...event.trigger.position } : undefined,
-                                            rotation: event.trigger.rotation ? { ...event.trigger.rotation } : undefined,
-                                            scale: event.trigger.scale ? { ...event.trigger.scale } : undefined
-                                        }
-                                        : undefined
-                                });
-                                if (data.triggerCallbackMap.has(0 /* TriggerAreaEventType.TAET_ENTER */)) {
-                                    data.triggerCallbackMap.get(0 /* TriggerAreaEventType.TAET_ENTER */)(event);
-                                }
-                                break;
-                            case 2 /* TriggerAreaEventType.TAET_EXIT */:
-                                data.insideTriggerers.delete(event.trigger.entity);
-                                if (data.triggerCallbackMap.has(2 /* TriggerAreaEventType.TAET_EXIT */)) {
-                                    data.triggerCallbackMap.get(2 /* TriggerAreaEventType.TAET_EXIT */)(event);
-                                }
-                                break;
-                            // Wire-level TAET_STAY and any unknown event types are ignored — no callback, no state mutation.
-                        }
-                    }
-                    data.lastConsumedTimestamp = values[values.length - 1].timestamp;
+            // The Explorer may be taking time before the result component is put
+            if (result.size === 0)
+                continue;
+            const values = Array.from(result.values());
+            // determine starting index for new values (more than one could be added between System updates)
+            // search backwards to find the anchor at lastConsumedTimestamp
+            let startIndex = 0;
+            if (data.lastConsumedTimestamp >= 0) {
+                const newestTimestamp = values[values.length - 1].timestamp;
+                // if nothing new, skip processing
+                if (newestTimestamp <= data.lastConsumedTimestamp) {
+                    continue;
                 }
+                // Find index of value with the lastConsumedTimestamp
+                let i = values.length - 2;
+                while (i >= 0 && values[i].timestamp > data.lastConsumedTimestamp)
+                    i--;
+                // Mark the following value index as the starting point to trigger all the new value callbacks
+                startIndex = i + 1;
             }
-            // -----------------------------------------------------------------------
-            // Pass 2: synthesize per-tick onStay callbacks
-            // -----------------------------------------------------------------------
-            // Only run if an onStay callback is registered and there are tracked triggerers.
-            if (data.triggerCallbackMap.has(1 /* TriggerAreaEventType.TAET_STAY */) &&
-                data.insideTriggerers.size > 0) {
-                const onStay = data.triggerCallbackMap.get(1 /* TriggerAreaEventType.TAET_STAY */);
-                const currentTimestamp = Date.now();
-                for (const [triggererEntity, cachedResult] of data.insideTriggerers) {
-                    onStay(buildSyntheticStayResult(cachedResult, entity, triggererEntity, currentTimestamp, Transform));
+            if (startIndex >= values.length)
+                continue;
+            // Trigger callbacks for all the new values
+            for (let i = startIndex; i < values.length; i++) {
+                switch (values[i].eventType) {
+                    case 0 /* TriggerAreaEventType.TAET_ENTER */:
+                        if (!data.triggerCallbackMap.has(0 /* TriggerAreaEventType.TAET_ENTER */))
+                            continue;
+                        data.triggerCallbackMap.get(0 /* TriggerAreaEventType.TAET_ENTER */)(values[i]);
+                        break;
+                    case 1 /* TriggerAreaEventType.TAET_STAY */:
+                        if (!data.triggerCallbackMap.has(1 /* TriggerAreaEventType.TAET_STAY */))
+                            continue;
+                        data.triggerCallbackMap.get(1 /* TriggerAreaEventType.TAET_STAY */)(values[i]);
+                        break;
+                    case 2 /* TriggerAreaEventType.TAET_EXIT */:
+                        if (!data.triggerCallbackMap.has(2 /* TriggerAreaEventType.TAET_EXIT */))
+                            continue;
+                        data.triggerCallbackMap.get(2 /* TriggerAreaEventType.TAET_EXIT */)(values[i]);
+                        break;
                 }
             }
+            data.lastConsumedTimestamp = values[values.length - 1].timestamp;
         }
-        // Clean up garbage entries.
+        // Clean up garbage entries
         garbageEntries.forEach((garbageEntity) => entitiesMap.delete(garbageEntity));
     });
     return {

package/dist-cjs/components/extended/AudioSource.d.ts

@@ -8,13 +8,11 @@ export interface AudioSourceComponentDefinitionExtended extends LastWriteWinElem
     /**
      * @public
      *
-     * Play the sound `src` on the given entity. Creates the AudioSource component
-     * if it does not yet exist. Always emits a CRDT PUT, so repeated calls with
-     * identical parameters reliably retrigger playback.
-     * @param entity - target entity (AudioSource will be created if missing)
+     * Set playing=true the sound `$name`
+     * @param entity - entity with AudioSource component
      * @param src - the path to the sound to play
      * @param resetCursor - the sound starts at 0 or continues from the current cursor position
-     * @returns always true; retained for backwards compatibility
+     * @returns true in successful playing, false if it doesn't find the AudioSource component
      */
     playSound(entity: Entity, src: string, resetCursor?: boolean): boolean;
     /**

package/dist-cjs/components/extended/AudioSource.js

@@ -7,13 +7,13 @@ function defineAudioSourceComponent(engine) {
     return {
         ...theComponent,
         playSound(entity, src, resetCursor = true) {
-            const existing = theComponent.getOrNull(entity);
-            theComponent.createOrReplace(entity, {
-                ...existing,
-                audioClipUrl: src,
-                playing: true,
-                currentTime: resetCursor ? 0 : existing?.currentTime ?? 0
-            });
+            // Get the mutable to modify
+            const audioSource = theComponent.getMutableOrNull(entity);
+            if (!audioSource)
+                return false;
+            audioSource.audioClipUrl = src;
+            audioSource.playing = true;
+            audioSource.currentTime = resetCursor ? 0 : audioSource.currentTime;
             return true;
         },
         stopSound(entity, resetCursor = true) {

package/dist-cjs/components/extended/AvatarEquippedData.d.ts

@@ -0,0 +1,10 @@
+import { IEngine, LastWriteWinElementSetComponentDefinition } from '../../engine';
+import { PBAvatarEquippedData } from '../generated/pb/decentraland/sdk/components/avatar_equipped_data.gen';
+/**
+ * @public
+ */
+export type AvatarEquippedDataComponentDefinitionExtended = LastWriteWinElementSetComponentDefinition<AvatarEquippedDataType>;
+export type AvatarEquippedDataType = Omit<PBAvatarEquippedData, 'forceRender'> & {
+    forceRender?: string[] | undefined;
+};
+export declare function defineAvatarEquippedDataComponent(engine: Pick<IEngine, 'defineComponentFromSchema'>): AvatarEquippedDataComponentDefinitionExtended;