@dcl/ecs 7.12.3-19242573384.commit-09d14b4 → 7.12.3-19269914897.commit-1299cf2

package/dist/runtime/initialization/index.js

@@ -10,6 +10,7 @@ import { createRaycastSystem } from '../../systems/raycast';
 import { createVideoEventsSystem } from '../../systems/videoEvents';
 import { createTweenSystem } from '../../systems/tween';
 import { pointerEventColliderChecker } from '../../systems/pointer-event-collider-checker';
+import { createTriggerAreaEventsSystem } from '../../systems/triggerArea';
 /**
  * @public
  * The engine is the part of the scene that sits in the middle and manages all of the other parts.
@@ -52,6 +53,11 @@ export const videoEventsSystem = /* @__PURE__ */ createVideoEventsSystem(engine)
  * Register callback functions to a particular entity on video events.
  */
 export const tweenSystem = createTweenSystem(engine);
+/**
+ * @public
+ * Register callback functions for trigger area results.
+ */
+export const triggerAreaEventsSystem = /* @__PURE__ */ createTriggerAreaEventsSystem(engine);
 /**
  * Adds pointer event collider system only in DEV env
  */

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

@@ -8,6 +8,8 @@ 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
  */
@@ -206,8 +208,6 @@ export function crdtSceneSystem(engine, onProcessEntityComponentChange) {
         // Send CRDT messages to transports
         const transportBuffer = new ReadWriteByteBuffer();
         for (const index in transports) {
-            // NetworkMessages can only have a MAX_SIZE of 13kb. So we need to send it in chunks.
-            const LIVEKIT_MAX_SIZE = 13;
             const __NetworkMessagesBuffer = [];
             const transportIndex = Number(index);
             const transport = transports[transportIndex];
@@ -218,9 +218,21 @@ export function crdtSceneSystem(engine, onProcessEntityComponentChange) {
             const buffer = new ReadWriteByteBuffer();
             // Then we send all the new crdtMessages that the transport needs to process
             for (const message of crdtMessages) {
-                if (isNetworkTransport && transportBuffer.toBinary().byteLength / 1024 > LIVEKIT_MAX_SIZE) {
-                    __NetworkMessagesBuffer.push(transportBuffer.toBinary());
-                    transportBuffer.resetBuffer();
+                // Check if adding this message would exceed the size limit
+                const currentBufferSize = transportBuffer.toBinary().byteLength;
+                const messageSize = message.messageBuffer.byteLength;
+                if (isNetworkTransport && (currentBufferSize + messageSize) / 1024 > LIVEKIT_MAX_SIZE) {
+                    // If the current buffer has content, save it as a chunk
+                    if (currentBufferSize > 0) {
+                        __NetworkMessagesBuffer.push(transportBuffer.toCopiedBinary());
+                        transportBuffer.resetBuffer();
+                    }
+                    // If the message itself is larger than the limit, we need to handle it specially
+                    // For now, we'll skip it to prevent infinite loops
+                    if (messageSize / 1024 > LIVEKIT_MAX_SIZE) {
+                        console.error(`Message too large (${messageSize} bytes), skipping message for entity ${message.entityId}`);
+                        continue;
+                    }
                 }
                 // Avoid echo messages
                 if (message.transportId === transportIndex)

package/dist/systems/triggerArea.d.ts

@@ -0,0 +1,50 @@
+import { DeepReadonlyObject, Entity } from '../engine';
+import { PBTriggerAreaResult } from '../components';
+/**
+ * @public
+ */
+export type TriggerAreaEventSystemCallback = (result: DeepReadonlyObject<PBTriggerAreaResult>) => void;
+/**
+ * @public
+ */
+export interface TriggerAreaEventsSystem {
+    /**
+     * @public
+     * Execute callback when an entity enters the Trigger Area
+     * @param entity - The entity that already has the TriggerArea component
+     * @param cb - Function to execute the 'Enter' type of result is detected
+     */
+    onTriggerEnter(entity: Entity, cb: TriggerAreaEventSystemCallback): void;
+    /**
+     * @public
+     * Remove the callback for Trigger Area 'Enter' type of result
+     * @param entity - Entity where the Trigger Area was attached
+     */
+    removeOnTriggerEnter(entity: Entity): void;
+    /**
+     * @public
+     * 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
+     */
+    onTriggerStay(entity: Entity, cb: TriggerAreaEventSystemCallback): void;
+    /**
+     * @public
+     * Remove the callback for Trigger Area 'Stay' type of result
+     * @param entity - Entity where the Trigger Area was attached
+     */
+    removeOnTriggerStay(entity: Entity): void;
+    /**
+     * @public
+     * Execute callback when an entity exits the Trigger Area
+     * @param entity - The entity that already has the TriggerArea component
+     * @param cb - Function to execute the 'Exit' type of result is detected
+     */
+    onTriggerExit(entity: Entity, cb: TriggerAreaEventSystemCallback): void;
+    /**
+     * @public
+     * Remove the callback for Trigger Area 'Exit' type of result
+     * @param entity - Entity where the Trigger Area was attached
+     */
+    removeOnTriggerExit(entity: Entity): void;
+}

package/dist/systems/triggerArea.js

@@ -0,0 +1,113 @@
+import * as components from '../components';
+import { EntityState } from '../engine/entity';
+/**
+ * @internal
+ */
+export function createTriggerAreaEventsSystem(engine) {
+    const triggerAreaResultComponent = components.TriggerAreaResult(engine);
+    const entitiesMap = new Map();
+    function hasCallbacksMap(entity) {
+        return entitiesMap.has(entity) && entitiesMap.get(entity) !== undefined;
+    }
+    function addEntityCallback(entity, triggerType, callback) {
+        if (hasCallbacksMap(entity)) {
+            entitiesMap.get(entity).triggerCallbackMap.set(triggerType, callback);
+        }
+        else {
+            entitiesMap.set(entity, {
+                triggerCallbackMap: new Map([[triggerType, callback]]),
+                lastConsumedTimestamp: -1
+            });
+        }
+    }
+    function removeEntityCallback(entity, triggerType) {
+        if (!entitiesMap.has(entity) || !entitiesMap.get(entity).triggerCallbackMap.has(triggerType))
+            return;
+        const triggerCallbackMap = entitiesMap.get(entity).triggerCallbackMap;
+        triggerCallbackMap.delete(triggerType);
+        // Remove entity if no more trigger callbacks are registered
+        if (triggerCallbackMap.size === 0)
+            entitiesMap.delete(entity);
+    }
+    function onTriggerEnter(entity, cb) {
+        addEntityCallback(entity, 0 /* TriggerAreaEventType.TAET_ENTER */, cb);
+    }
+    function removeOnTriggerEnter(entity) {
+        removeEntityCallback(entity, 0 /* TriggerAreaEventType.TAET_ENTER */);
+    }
+    function onTriggerStay(entity, cb) {
+        addEntityCallback(entity, 1 /* TriggerAreaEventType.TAET_STAY */, cb);
+    }
+    function removeOnTriggerStay(entity) {
+        removeEntityCallback(entity, 1 /* TriggerAreaEventType.TAET_STAY */);
+    }
+    function onTriggerExit(entity, cb) {
+        addEntityCallback(entity, 2 /* TriggerAreaEventType.TAET_EXIT */, cb);
+    }
+    function removeOnTriggerExit(entity) {
+        removeEntityCallback(entity, 2 /* TriggerAreaEventType.TAET_EXIT */);
+    }
+    engine.addSystem(function TriggerAreaResultSystem() {
+        const garbageEntries = [];
+        for (const [entity, data] of entitiesMap) {
+            if (engine.getEntityState(entity) === EntityState.Removed) {
+                garbageEntries.push(entity);
+                continue;
+            }
+            const result = triggerAreaResultComponent.get(entity);
+            // 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;
+            }
+            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
+        garbageEntries.forEach((garbageEntity) => entitiesMap.delete(garbageEntity));
+    });
+    return {
+        onTriggerEnter,
+        removeOnTriggerEnter,
+        onTriggerStay,
+        removeOnTriggerStay,
+        onTriggerExit,
+        removeOnTriggerExit
+    };
+}

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

@@ -0,0 +1,22 @@
+import { Entity, IEngine, LastWriteWinElementSetComponentDefinition } from '../../engine';
+import { ColliderLayer, PBTriggerArea } from '../generated/index.gen';
+/**
+ * @public
+ */
+export interface TriggerAreaComponentDefinitionExtended extends LastWriteWinElementSetComponentDefinition<PBTriggerArea> {
+    /**
+     * @public
+     * Set a box in the MeshCollider component
+     * @param entity - entity to create or replace the TriggerArea component
+     * @param collisionMask - the collision layers mask for the trigger to react, default: Player
+     */
+    setBox(entity: Entity, collisionMask?: ColliderLayer | ColliderLayer[]): void;
+    /**
+     * @public
+     * Set a sphere in the MeshCollider component
+     * @param entity - entity to create or replace the TriggerArea component
+     * @param collisionMask - the collision layers mask for the trigger to react, default: Player
+     */
+    setSphere(entity: Entity, collisionMask?: ColliderLayer | ColliderLayer[]): void;
+}
+export declare function defineTriggerAreaComponent(engine: Pick<IEngine, 'defineComponentFromSchema'>): TriggerAreaComponentDefinitionExtended;

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

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineTriggerAreaComponent = void 0;
+const index_gen_1 = require("../generated/index.gen");
+function defineTriggerAreaComponent(engine) {
+    const theComponent = (0, index_gen_1.TriggerArea)(engine);
+    function getCollisionMask(layers) {
+        if (Array.isArray(layers)) {
+            return layers.map((item) => item).reduce((prev, item) => prev | item, 0);
+        }
+        else if (layers) {
+            return layers;
+        }
+    }
+    return {
+        ...theComponent,
+        setBox(entity, collisionMask) {
+            theComponent.createOrReplace(entity, {
+                mesh: 0 /* TriggerAreaMeshType.TAMT_BOX */,
+                collisionMask: getCollisionMask(collisionMask)
+            });
+        },
+        setSphere(entity, collisionMask) {
+            theComponent.createOrReplace(entity, {
+                mesh: 1 /* TriggerAreaMeshType.TAMT_SPHERE */,
+                collisionMask: getCollisionMask(collisionMask)
+            });
+        }
+    };
+}
+exports.defineTriggerAreaComponent = defineTriggerAreaComponent;

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

@@ -1,5 +1,6 @@
-import { IEngine, LastWriteWinElementSetComponentDefinition } from '../../engine';
-import { PBTween, Move, Rotate, Scale, TextureMove } from '../generated/index.gen';
+import { Entity, IEngine, LastWriteWinElementSetComponentDefinition } from '../../engine';
+import { Quaternion, Vector2, Vector3 } from '../generated/pb/decentraland/common/vectors.gen';
+import { EasingFunction, Move, MoveContinuous, PBTween, Rotate, RotateContinuous, Scale, TextureMove, TextureMoveContinuous, TextureMovementType } from '../generated/index.gen';
 /**
  * @public
  */
@@ -9,17 +10,29 @@ export interface TweenHelper {
      */
     Move: (move: Move) => PBTween['mode'];
     /**
-     * @returns a move mode tween
+     * @returns a move-continuous mode tween
+     */
+    MoveContinuous: (move: MoveContinuous) => PBTween['mode'];
+    /**
+     * @returns a rotate mode tween
      */
     Rotate: (rotate: Rotate) => PBTween['mode'];
     /**
-     * @returns a move mode tween
+     * @returns a rotate-continuous mode tween
+     */
+    RotateContinuous: (rotate: RotateContinuous) => PBTween['mode'];
+    /**
+     * @returns a scale mode tween
      */
     Scale: (scale: Scale) => PBTween['mode'];
     /**
-     * @returns a texture move mode tween
+     * @returns a texture-move mode tween
      */
     TextureMove: (textureMove: TextureMove) => PBTween['mode'];
+    /**
+     * @returns a texture-move-continuous mode tween
+     */
+    TextureMoveContinuous: (textureMove: TextureMoveContinuous) => PBTween['mode'];
 }
 /**
  * @public
@@ -29,5 +42,81 @@ export interface TweenComponentDefinitionExtended extends LastWriteWinElementSet
      * Texture helpers with constructor
      */
     Mode: TweenHelper;
+    /**
+     * @public
+     *
+     * Creates or replaces a move tween component that animates an entity's position from start to end
+     * @param entity - entity to apply the tween to
+     * @param start - starting position vector
+     * @param end - ending position vector
+     * @param duration - duration of the tween in milliseconds
+     * @param easingFunction - easing function to use (defaults to EF_LINEAR)
+     */
+    setMove(entity: Entity, start: Vector3, end: Vector3, duration: number, easingFunction?: EasingFunction): void;
+    /**
+     * @public
+     *
+     * Creates or replaces a scale tween component that animates an entity's scale from start to end
+     * @param entity - entity to apply the tween to
+     * @param start - starting scale vector
+     * @param end - ending scale vector
+     * @param duration - duration of the tween in milliseconds
+     * @param easingFunction - easing function to use (defaults to EF_LINEAR)
+     */
+    setScale(entity: Entity, start: Vector3, end: Vector3, duration: number, easingFunction?: EasingFunction): void;
+    /**
+     * @public
+     *
+     * Creates or replaces a rotation tween component that animates an entity's rotation from start to end
+     * @param entity - entity to apply the tween to
+     * @param start - starting rotation quaternion
+     * @param end - ending rotation quaternion
+     * @param duration - duration of the tween in milliseconds
+     * @param easingFunction - easing function to use (defaults to EF_LINEAR)
+     */
+    setRotate(entity: Entity, start: Quaternion, end: Quaternion, duration: number, easingFunction?: EasingFunction): void;
+    /**
+     * @public
+     *
+     * Creates or replaces a texture move tween component that animates texture UV coordinates from start to end
+     * @param entity - entity to apply the tween to
+     * @param start - starting UV coordinates
+     * @param end - ending UV coordinates
+     * @param duration - duration of the tween in milliseconds
+     * @param movementType - type of texture movement (defaults to TMT_OFFSET)
+     * @param easingFunction - easing function to use (defaults to EF_LINEAR)
+     */
+    setTextureMove(entity: Entity, start: Vector2, end: Vector2, duration: number, movementType?: TextureMovementType, easingFunction?: EasingFunction): void;
+    /**
+     * @public
+     *
+     * Creates or replaces a continuous move tween component that moves an entity continuously in a direction
+     * @param entity - entity to apply the tween to
+     * @param direction - direction vector to move towards
+     * @param speed - speed of movement per second
+     * @param duration - duration of the tween in milliseconds (defaults to 0 for infinite)
+     */
+    setMoveContinuous(entity: Entity, direction: Vector3, speed: number, duration?: number): void;
+    /**
+     * @public
+     *
+     * Creates or replaces a continuous rotation tween component that rotates an entity continuously
+     * @param entity - entity to apply the tween to
+     * @param direction - rotation direction quaternion
+     * @param speed - speed of rotation per second
+     * @param duration - duration of the tween in milliseconds (defaults to 0 for infinite)
+     */
+    setRotateContinuous(entity: Entity, direction: Quaternion, speed: number, duration?: number): void;
+    /**
+     * @public
+     *
+     * Creates or replaces a continuous texture move tween component that moves texture UV coordinates continuously
+     * @param entity - entity to apply the tween to
+     * @param direction - direction vector for UV movement
+     * @param speed - speed of UV movement per second
+     * @param movementType - type of texture movement (defaults to TMT_OFFSET)
+     * @param duration - duration of the tween in milliseconds (defaults to 0 for infinite)
+     */
+    setTextureMoveContinuous(entity: Entity, direction: Vector2, speed: number, movementType?: TextureMovementType, duration?: number): void;
 }
 export declare function defineTweenComponent(engine: Pick<IEngine, 'defineComponentFromSchema'>): TweenComponentDefinitionExtended;

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

@@ -9,12 +9,24 @@ const TweenHelper = {
             move
         };
     },
+    MoveContinuous(moveContinuous) {
+        return {
+            $case: 'moveContinuous',
+            moveContinuous
+        };
+    },
     Rotate(rotate) {
         return {
             $case: 'rotate',
             rotate
         };
     },
+    RotateContinuous(rotateContinuous) {
+        return {
+            $case: 'rotateContinuous',
+            rotateContinuous
+        };
+    },
     Scale(scale) {
         return {
             $case: 'scale',
@@ -26,13 +38,119 @@ const TweenHelper = {
             $case: 'textureMove',
             textureMove
         };
+    },
+    TextureMoveContinuous(textureMoveContinuous) {
+        return {
+            $case: 'textureMoveContinuous',
+            textureMoveContinuous
+        };
     }
 };
 function defineTweenComponent(engine) {
     const theComponent = (0, index_gen_1.Tween)(engine);
     return {
         ...theComponent,
-        Mode: TweenHelper
+        Mode: TweenHelper,
+        setMove(entity, start, end, duration, easingFunction = 0 /* EasingFunction.EF_LINEAR */) {
+            theComponent.createOrReplace(entity, {
+                mode: {
+                    $case: 'move',
+                    move: {
+                        start,
+                        end
+                    }
+                },
+                duration,
+                easingFunction,
+                playing: true
+            });
+        },
+        setScale(entity, start, end, duration, easingFunction = 0 /* EasingFunction.EF_LINEAR */) {
+            theComponent.createOrReplace(entity, {
+                mode: {
+                    $case: 'scale',
+                    scale: {
+                        start,
+                        end
+                    }
+                },
+                duration,
+                easingFunction,
+                playing: true
+            });
+        },
+        setRotate(entity, start, end, duration, easingFunction = 0 /* EasingFunction.EF_LINEAR */) {
+            theComponent.createOrReplace(entity, {
+                mode: {
+                    $case: 'rotate',
+                    rotate: {
+                        start,
+                        end
+                    }
+                },
+                duration,
+                easingFunction,
+                playing: true
+            });
+        },
+        setTextureMove(entity, start, end, duration, movementType = 0 /* TextureMovementType.TMT_OFFSET */, easingFunction = 0 /* EasingFunction.EF_LINEAR */) {
+            theComponent.createOrReplace(entity, {
+                mode: {
+                    $case: 'textureMove',
+                    textureMove: {
+                        start,
+                        end,
+                        movementType
+                    }
+                },
+                duration,
+                easingFunction,
+                playing: true
+            });
+        },
+        setMoveContinuous(entity, direction, speed, duration = 0) {
+            theComponent.createOrReplace(entity, {
+                mode: {
+                    $case: 'moveContinuous',
+                    moveContinuous: {
+                        direction,
+                        speed
+                    }
+                },
+                duration,
+                easingFunction: 0 /* EasingFunction.EF_LINEAR */,
+                playing: true
+            });
+        },
+        setRotateContinuous(entity, direction, speed, duration = 0) {
+            theComponent.createOrReplace(entity, {
+                mode: {
+                    $case: 'rotateContinuous',
+                    rotateContinuous: {
+                        direction,
+                        speed
+                    }
+                },
+                duration,
+                easingFunction: 0 /* EasingFunction.EF_LINEAR */,
+                playing: true
+            });
+        },
+        setTextureMoveContinuous(entity, direction, speed, movementType = 0 /* TextureMovementType.TMT_OFFSET */, duration = 0) {
+            theComponent.createOrReplace(entity, {
+                mode: {
+                    $case: 'textureMoveContinuous',
+                    textureMoveContinuous: {
+                        direction,
+                        speed,
+                        movementType
+                    }
+                },
+                duration,
+                easingFunction: 0 /* EasingFunction.EF_LINEAR */,
+                playing: true
+            });
+        }
     };
 }
 exports.defineTweenComponent = defineTweenComponent;

package/dist-cjs/components/generated/CameraLayer.gen.js

@@ -6,7 +6,7 @@ const camera_layer_gen_1 = require("./pb/decentraland/sdk/components/camera_laye
  * @internal
  */
 exports.CameraLayerSchema = {
-    COMPONENT_ID: 1210,
+    COMPONENT_ID: 1211,
     serialize(value, builder) {
         const writer = camera_layer_gen_1.PBCameraLayer.encode(value);
         const buffer = new Uint8Array(writer.finish(), 0, writer.len);

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

@@ -17,7 +17,7 @@ exports.coreComponentMappings = {
     "core::AvatarModifierArea": 1070,
     "core::AvatarShape": 1080,
     "core::Billboard": 1090,
-    "core::CameraLayer": 1210,
+    "core::CameraLayer": 1211,
     "core::CameraLayers": 1208,
     "core::CameraMode": 1072,
     "core::CameraModeArea": 1071,

package/dist-cjs/components/generated/global.gen.d.ts

@@ -91,7 +91,7 @@ import { PBVisibilityComponent } from './pb/decentraland/sdk/components/visibili
 /** @public */ export declare const TextShape: LastWriteWinElementSetComponentDefinition<PBTextShape>;
 /** @public */ export declare const TextureCamera: LastWriteWinElementSetComponentDefinition<PBTextureCamera>;
 /** @public */ export declare const TriggerArea: LastWriteWinElementSetComponentDefinition<PBTriggerArea>;
-/** @public */ export declare const TriggerAreaResult: LastWriteWinElementSetComponentDefinition<PBTriggerAreaResult>;
+/** @public */ export declare const TriggerAreaResult: GrowOnlyValueSetComponentDefinition<PBTriggerAreaResult>;
 /** @public */ export declare const TweenSequence: LastWriteWinElementSetComponentDefinition<PBTweenSequence>;
 /** @public */ export declare const TweenState: LastWriteWinElementSetComponentDefinition<PBTweenState>;
 /** @public */ export declare const UiBackground: LastWriteWinElementSetComponentDefinition<PBUiBackground>;

package/dist-cjs/components/generated/index.gen.d.ts

@@ -161,7 +161,7 @@ export type GSetComponentGetter<T extends GrowOnlyValueSetComponentDefinition<an
 /** @public */ export declare const TextShape: LwwComponentGetter<LastWriteWinElementSetComponentDefinition<PBTextShape>>;
 /** @public */ export declare const TextureCamera: LwwComponentGetter<LastWriteWinElementSetComponentDefinition<PBTextureCamera>>;
 /** @public */ export declare const TriggerArea: LwwComponentGetter<LastWriteWinElementSetComponentDefinition<PBTriggerArea>>;
-/** @public */ export declare const TriggerAreaResult: LwwComponentGetter<LastWriteWinElementSetComponentDefinition<PBTriggerAreaResult>>;
+/** @public */ export declare const TriggerAreaResult: GSetComponentGetter<GrowOnlyValueSetComponentDefinition<PBTriggerAreaResult>>;
 /** @public */ export declare const Tween: LwwComponentGetter<LastWriteWinElementSetComponentDefinition<PBTween>>;
 /** @public */ export declare const TweenSequence: LwwComponentGetter<LastWriteWinElementSetComponentDefinition<PBTweenSequence>>;
 /** @public */ export declare const TweenState: LwwComponentGetter<LastWriteWinElementSetComponentDefinition<PBTweenState>>;
@@ -222,7 +222,7 @@ export declare const componentDefinitionByName: {
     "core::TextShape": LwwComponentGetter<LastWriteWinElementSetComponentDefinition<PBTextShape>>;
     "core::TextureCamera": LwwComponentGetter<LastWriteWinElementSetComponentDefinition<PBTextureCamera>>;
     "core::TriggerArea": LwwComponentGetter<LastWriteWinElementSetComponentDefinition<PBTriggerArea>>;
-    "core::TriggerAreaResult": LwwComponentGetter<LastWriteWinElementSetComponentDefinition<PBTriggerAreaResult>>;
+    "core::TriggerAreaResult": GSetComponentGetter<GrowOnlyValueSetComponentDefinition<PBTriggerAreaResult>>;
     "core::Tween": LwwComponentGetter<LastWriteWinElementSetComponentDefinition<PBTween>>;
     "core::TweenSequence": LwwComponentGetter<LastWriteWinElementSetComponentDefinition<PBTweenSequence>>;
     "core::TweenState": LwwComponentGetter<LastWriteWinElementSetComponentDefinition<PBTweenState>>;

package/dist-cjs/components/generated/index.gen.js

@@ -263,8 +263,10 @@ exports.TextureCamera = TextureCamera;
 /** @public */ const TriggerArea = engine => 
 /* @__PURE__ */ engine.defineComponentFromSchema("core::TriggerArea", TriggerArea_gen_1.TriggerAreaSchema);
 exports.TriggerArea = TriggerArea;
-/** @public */ const TriggerAreaResult = engine => 
-/* @__PURE__ */ engine.defineComponentFromSchema("core::TriggerAreaResult", TriggerAreaResult_gen_1.TriggerAreaResultSchema);
+/** @public */ const TriggerAreaResult = (engine) => /* @__PURE__ */ engine.defineValueSetComponentFromSchema("core::TriggerAreaResult", TriggerAreaResult_gen_1.TriggerAreaResultSchema, {
+    timestampFunction: (t) => t.timestamp,
+    maxElements: 100
+});
 exports.TriggerAreaResult = TriggerAreaResult;
 /** @public */ const Tween = engine => 
 /* @__PURE__ */ engine.defineComponentFromSchema("core::Tween", Tween_gen_1.TweenSchema);

package/dist-cjs/components/index.d.ts

@@ -19,6 +19,8 @@ import { INetowrkParentType } from './manual/NetworkParent';
 import { ISyncComponentsType } from './manual/SyncComponents';
 import { TransformComponentExtended } from './manual/Transform';
 import { LightSourceComponentDefinitionExtended } from './extended/LightSource';
+import { TriggerAreaComponentDefinitionExtended } from './extended/TriggerArea';
+import { TagsComponentDefinitionExtended } from './manual/Tags';
 export * from './generated/index.gen';
 export type { GrowOnlyValueSetComponentDefinition, GSetComponentGetter, LastWriteWinElementSetComponentDefinition, LwwComponentGetter };
 export declare const Transform: LwwComponentGetter<TransformComponentExtended>;
@@ -34,10 +36,12 @@ export declare const AvatarEquippedData: LwwComponentGetter<AvatarEquippedDataCo
 export declare const VirtualCamera: LwwComponentGetter<VirtualCameraComponentDefinitionExtended>;
 export declare const InputModifier: LwwComponentGetter<InputModifierComponentDefinitionExtended>;
 export declare const LightSource: LwwComponentGetter<LightSourceComponentDefinitionExtended>;
+export declare const TriggerArea: LwwComponentGetter<TriggerAreaComponentDefinitionExtended>;
 /**
  * @alpha
  */
 export declare const Name: (engine: Pick<IEngine, 'defineComponent'>) => LastWriteWinElementSetComponentDefinition<NameType>;
+export declare const Tags: (engine: Pick<IEngine, 'defineComponent'>) => TagsComponentDefinitionExtended;
 /**
  * @alpha
  */