@dcl/ecs 7.24.5-29247185020.commit-e92dfe6 → 7.24.5-29264961047.commit-77493c3

package/dist/systems/physics.js

@@ -0,0 +1,18 @@
+import { createPhysicsImpulseHelper } from './physics-impulse';
+import { createPhysicsForceHelper } from './physics-force';
+export { KnockbackFalloff } from './physics-impulse';
+/**
+ * @internal
+ */
+export function createPhysicsSystem(engine) {
+    const impulse = createPhysicsImpulseHelper(engine);
+    const force = createPhysicsForceHelper(engine);
+    return {
+        applyImpulseToPlayer: impulse.applyImpulseToPlayer,
+        applyForceToPlayer: force.applyForceToPlayer,
+        removeForceFromPlayer: force.removeForceFromPlayer,
+        applyKnockbackToPlayer: impulse.applyKnockbackToPlayer,
+        applyForceToPlayerForDuration: force.applyForceToPlayerForDuration,
+        applyRepulsionForceToPlayer: force.applyRepulsionForceToPlayer
+    };
+}

package/dist/systems/raycast.d.ts

@@ -1,4 +1,4 @@
-import { RaycastQueryType, RaycastShape, PBRaycastResult } from '../components';
+import { RaycastQueryType, PBRaycastResult } from '../components';
 import { DeepReadonlyObject, Entity } from '../engine';
 import { Vector3 } from '../components/generated/pb/decentraland/common/vectors.gen';
 /**
@@ -14,8 +14,6 @@ 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,8 +58,6 @@ 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,6 +26,11 @@ 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,10 +1,57 @@
 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;
@@ -16,7 +63,8 @@ export function createTriggerAreaEventsSystem(engine) {
         else {
             entitiesMap.set(entity, {
                 triggerCallbackMap: new Map([[triggerType, callback]]),
-                lastConsumedTimestamp: -1
+                lastConsumedTimestamp: -1,
+                insideTriggerers: new Map()
             });
         }
     }
@@ -25,7 +73,9 @@ export function createTriggerAreaEventsSystem(engine) {
             return;
         const triggerCallbackMap = entitiesMap.get(entity).triggerCallbackMap;
         triggerCallbackMap.delete(triggerType);
-        // Remove entity if no more trigger callbacks are registered
+        // 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.
         if (triggerCallbackMap.size === 0)
             entitiesMap.delete(entity);
     }
@@ -55,51 +105,88 @@ export function createTriggerAreaEventsSystem(engine) {
                 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;
+            // -----------------------------------------------------------------------
+            // 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;
                 }
-                // 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;
+            // -----------------------------------------------------------------------
+            // 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));
                 }
             }
-            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/AudioAnalysis.d.ts

@@ -0,0 +1,55 @@
+import { Entity, IEngine } from '../../engine';
+import { LastWriteWinElementSetComponentDefinition } from '../../engine/component';
+import { PBAudioAnalysis, PBAudioAnalysisMode } from '../generated/pb/decentraland/sdk/components/audio_analysis.gen';
+export interface AudioAnalysisComponentDefinitionExtended extends LastWriteWinElementSetComponentDefinition<PBAudioAnalysis> {
+    /**
+     * Reads the component data of `entity` into the provided `out` view.
+     *
+     * @throws Error if the entity does not have an AudioAnalysis component.
+     * @param entity - The entity whose AudioAnalysis data will be read.
+     * @param out - An existing AudioAnalysisView to populate with the latest values.
+     */
+    readIntoView(entity: Entity, out: AudioAnalysisView): void;
+    /**
+     * Attempts to read the component data of `entity` into the provided `out` view.
+     *
+     * @returns `true` if the component exists and data was written into `out`,
+     *          `false` if the entity does not have an AudioAnalysis component.
+     * @param entity - The entity whose AudioAnalysis data will be read.
+     * @param out - An existing AudioAnalysisView to populate.
+     */
+    tryReadIntoView(entity: Entity, out: AudioAnalysisView): boolean;
+    /**
+     * Creates an AudioAnalysis component for the given `entity`.
+     *
+     * If a component already exists on the entity, this call fails (does not replace).
+     *
+     * @param entity - The entity to attach the component to.
+     * @param mode - Analysis mode. Defaults to `PBAudioAnalysisMode.MODE_LOGARITHMIC`.
+     * @param amplitudeGain - Optional amplitude gain multiplier.
+     * @param bandsGain - Optional gain multiplier applied to all frequency bands.
+     */
+    createAudioAnalysis(entity: Entity, mode?: PBAudioAnalysisMode, // default is PBAudioAnalysisMode.MODE_LOGARITHMIC
+    amplitudeGain?: number, bandsGain?: number): void;
+    /**
+     * Creates the AudioAnalysis component if missing, or replaces the existing one.
+     *
+     * @param entity - The target entity.
+     * @param mode - Analysis mode. Defaults to `PBAudioAnalysisMode.MODE_LOGARITHMIC`.
+     * @param amplitudeGain - Optional amplitude gain multiplier.
+     * @param bandsGain - Optional gain multiplier applied to the frequency bands.
+     */
+    createOrReplaceAudioAnalysis(entity: Entity, mode?: PBAudioAnalysisMode, // default is PBAudioAnalysisMode.MODE_LOGARITHMIC
+    amplitudeGain?: number, bandsGain?: number): void;
+}
+/**
+ * A read-only JavaScript-friendly view of AudioAnalysis ECS data.
+ *
+ * `amplitude` represents the aggregated signal strength.
+ * `bands` represents the processed frequency bands.
+ */
+export type AudioAnalysisView = {
+    amplitude: number;
+    bands: number[];
+};
+export declare function defineAudioAnalysisComponent(engine: Pick<IEngine, 'defineComponentFromSchema'>): AudioAnalysisComponentDefinitionExtended;

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

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineAudioAnalysisComponent = void 0;
+const index_gen_1 = require("../generated/index.gen");
+function defineAudioAnalysisComponent(engine) {
+    const theComponent = (0, index_gen_1.AudioAnalysis)(engine);
+    return {
+        ...theComponent,
+        readIntoView(entity, out) {
+            const audioAnalysis = theComponent.get(entity);
+            out.amplitude = audioAnalysis.amplitude;
+            out.bands[0] = audioAnalysis.band0;
+            out.bands[1] = audioAnalysis.band1;
+            out.bands[2] = audioAnalysis.band2;
+            out.bands[3] = audioAnalysis.band3;
+            out.bands[4] = audioAnalysis.band4;
+            out.bands[5] = audioAnalysis.band5;
+            out.bands[6] = audioAnalysis.band6;
+            out.bands[7] = audioAnalysis.band7;
+        },
+        tryReadIntoView(entity, out) {
+            const audioAnalysis = theComponent.getOrNull(entity);
+            if (!audioAnalysis)
+                return false;
+            out.amplitude = audioAnalysis.amplitude;
+            out.bands[0] = audioAnalysis.band0;
+            out.bands[1] = audioAnalysis.band1;
+            out.bands[2] = audioAnalysis.band2;
+            out.bands[3] = audioAnalysis.band3;
+            out.bands[4] = audioAnalysis.band4;
+            out.bands[5] = audioAnalysis.band5;
+            out.bands[6] = audioAnalysis.band6;
+            out.bands[7] = audioAnalysis.band7;
+            return true;
+        },
+        createAudioAnalysis(entity, mode, amplitudeGain, bandsGain) {
+            theComponent.create(entity, {
+                mode: mode || 1 /* PBAudioAnalysisMode.MODE_LOGARITHMIC */,
+                amplitudeGain: amplitudeGain ?? undefined,
+                bandsGain: bandsGain ?? undefined,
+                amplitude: 0,
+                band0: 0,
+                band1: 0,
+                band2: 0,
+                band3: 0,
+                band4: 0,
+                band5: 0,
+                band6: 0,
+                band7: 0
+            });
+        },
+        createOrReplaceAudioAnalysis(entity, mode, amplitudeGain, bandsGain) {
+            theComponent.createOrReplace(entity, {
+                mode: mode || 1 /* PBAudioAnalysisMode.MODE_LOGARITHMIC */,
+                amplitudeGain: amplitudeGain ?? undefined,
+                bandsGain: bandsGain ?? undefined,
+                amplitude: 0,
+                band0: 0,
+                band1: 0,
+                band2: 0,
+                band3: 0,
+                band4: 0,
+                band5: 0,
+                band6: 0,
+                band7: 0
+            });
+        }
+    };
+}
+exports.defineAudioAnalysisComponent = defineAudioAnalysisComponent;

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

@@ -8,11 +8,13 @@ export interface AudioSourceComponentDefinitionExtended extends LastWriteWinElem
     /**
      * @public
      *
-     * Set playing=true the sound `$name`
-     * @param entity - entity with AudioSource component
+     * 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)
      * @param src - the path to the sound to play
      * @param resetCursor - the sound starts at 0 or continues from the current cursor position
-     * @returns true in successful playing, false if it doesn't find the AudioSource component
+     * @returns always true; retained for backwards compatibility
      */
     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) {
-            // 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;
+            const existing = theComponent.getOrNull(entity);
+            theComponent.createOrReplace(entity, {
+                ...existing,
+                audioClipUrl: src,
+                playing: true,
+                currentTime: resetCursor ? 0 : existing?.currentTime ?? 0
+            });
             return true;
         },
         stopSound(entity, resetCursor = true) {

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

@@ -34,13 +34,5 @@ export interface MeshColliderComponentDefinitionExtended extends LastWriteWinEle
      * @param colliderMask - the set of layer where the collider reacts, default: Physics and Pointer
      */
     setSphere(entity: Entity, colliderLayers?: ColliderLayer | ColliderLayer[]): void;
-    /**
-     * @public
-     * Set a gltf internal mesh in the MeshCollider component
-     * @param entity - entity to create or replace the MeshRenderer component
-     * @param source - the path to the gltf
-     * @param meshName - the name of the mesh in the gltf
-     */
-    setGltfMesh(entity: Entity, source: string, meshName: string, colliderLayers?: ColliderLayer | ColliderLayer[]): void;
 }
 export declare function defineMeshColliderComponent(engine: Pick<IEngine, 'defineComponentFromSchema'>): MeshColliderComponentDefinitionExtended;

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

@@ -37,12 +37,6 @@ function defineMeshColliderComponent(engine) {
                 mesh: { $case: 'sphere', sphere: {} },
                 collisionMask: getCollisionMask(colliderLayers)
             });
-        },
-        setGltfMesh(entity, source, meshName, colliderLayers) {
-            theComponent.createOrReplace(entity, {
-                mesh: { $case: 'gltf', gltf: { gltfSrc: source, name: meshName } },
-                collisionMask: getCollisionMask(colliderLayers)
-            });
         }
     };
 }

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

@@ -32,13 +32,5 @@ export interface MeshRendererComponentDefinitionExtended extends LastWriteWinEle
      * @param entity - entity to create or replace the MeshRenderer component
      */
     setSphere(entity: Entity): void;
-    /**
-     * @public
-     * Set a gltf internal mesh in the MeshRenderer component
-     * @param entity - entity to create or replace the MeshRenderer component
-     * @param source - the path to the gltf
-     * @param meshName - the name of the mesh in the gltf
-     */
-    setGltfMesh(entity: Entity, source: string, meshName: string): void;
 }
 export declare function defineMeshRendererComponent(engine: Pick<IEngine, 'defineComponentFromSchema'>): MeshRendererComponentDefinitionExtended;

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

@@ -25,11 +25,6 @@ function defineMeshRendererComponent(engine) {
             theComponent.createOrReplace(entity, {
                 mesh: { $case: 'sphere', sphere: {} }
             });
-        },
-        setGltfMesh(entity, source, meshName) {
-            theComponent.createOrReplace(entity, {
-                mesh: { $case: 'gltf', gltf: { gltfSrc: source, name: meshName } }
-            });
         }
     };
 }

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

@@ -0,0 +1,24 @@
+import { IEngine, LastWriteWinElementSetComponentDefinition } from '../../engine';
+import { PBParticleSystem, PBParticleSystem_BlendMode, PBParticleSystem_PlaybackState, PBParticleSystem_Point, PBParticleSystem_Sphere, PBParticleSystem_Cone, PBParticleSystem_Box } from '../generated/index.gen';
+export { PBParticleSystem_BlendMode as ParticleSystemBlendMode, PBParticleSystem_PlaybackState as ParticleSystemPlaybackState };
+/**
+ * @public
+ */
+export interface ParticleSystemHelper {
+    /** Emit from a single point */
+    Point: (point?: PBParticleSystem_Point) => PBParticleSystem['shape'];
+    /** Emit from the surface or volume of a sphere */
+    Sphere: (sphere?: PBParticleSystem_Sphere) => PBParticleSystem['shape'];
+    /** Emit from the base of a cone, projecting outward */
+    Cone: (cone?: PBParticleSystem_Cone) => PBParticleSystem['shape'];
+    /** Emit from the surface or volume of a box */
+    Box: (box?: PBParticleSystem_Box) => PBParticleSystem['shape'];
+}
+/**
+ * @public
+ */
+export interface ParticleSystemComponentDefinitionExtended extends LastWriteWinElementSetComponentDefinition<PBParticleSystem> {
+    /** Helpers for constructing emitter shapes */
+    Shape: ParticleSystemHelper;
+}
+export declare function defineParticleSystemComponent(engine: Pick<IEngine, 'defineComponentFromSchema'>): ParticleSystemComponentDefinitionExtended;

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

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineParticleSystemComponent = exports.ParticleSystemPlaybackState = exports.ParticleSystemBlendMode = void 0;
+const index_gen_1 = require("../generated/index.gen");
+Object.defineProperty(exports, "ParticleSystemBlendMode", { enumerable: true, get: function () { return index_gen_1.PBParticleSystem_BlendMode; } });
+Object.defineProperty(exports, "ParticleSystemPlaybackState", { enumerable: true, get: function () { return index_gen_1.PBParticleSystem_PlaybackState; } });
+const ParticleSystemShapeHelper = {
+    Point(point = {}) {
+        return { $case: 'point', point };
+    },
+    Sphere(sphere = {}) {
+        return { $case: 'sphere', sphere };
+    },
+    Cone(cone = {}) {
+        return { $case: 'cone', cone };
+    },
+    Box(box = {}) {
+        return { $case: 'box', box };
+    }
+};
+function defineParticleSystemComponent(engine) {
+    const theComponent = (0, index_gen_1.ParticleSystem)(engine);
+    return {
+        ...theComponent,
+        Shape: ParticleSystemShapeHelper
+    };
+}
+exports.defineParticleSystemComponent = defineParticleSystemComponent;

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

@@ -8,14 +8,14 @@ export interface TriggerAreaComponentDefinitionExtended extends LastWriteWinElem
      * @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
+     * @param collisionMask - the collision layers mask for the trigger to react, default: CL_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
+     * @param collisionMask - the collision layers mask for the trigger to react, default: CL_PLAYER
      */
     setSphere(entity: Entity, collisionMask?: ColliderLayer | ColliderLayer[]): void;
 }

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

@@ -1,6 +1,38 @@
 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
+ * Partial params for Tween.Mode.MoveRotateScale(). At least one of position, rotation, or scale must be provided.
+ * Use this when building a mode for Tween.createOrReplace() or TweenSequence (e.g. only positionStart/positionEnd).
+ */
+export interface MoveRotateScaleModeParams {
+    /** Position tween (start → end). Optional. */
+    position?: {
+        start: Vector3;
+        end: Vector3;
+    };
+    /** Rotation tween (start → end). Optional. */
+    rotation?: {
+        start: Quaternion;
+        end: Quaternion;
+    };
+    /** Scale tween (start → end). Optional. */
+    scale?: {
+        start: Vector3;
+        end: Vector3;
+    };
+}
+/**
+ * @public
+ * Parameters for setMoveRotateScale. At least one of position, rotation, or scale must be provided.
+ */
+export interface SetMoveRotateScaleParams extends MoveRotateScaleModeParams {
+    /** Duration of the tween in milliseconds. */
+    duration: number;
+    /** Easing function (defaults to EF_LINEAR). */
+    easingFunction?: EasingFunction;
+}
 /**
  * @public
  */
@@ -33,13 +65,18 @@ export interface TweenHelper {
      * @returns a texture-move-continuous mode tween
      */
     TextureMoveContinuous: (textureMove: TextureMoveContinuous) => PBTween['mode'];
+    /**
+     * @returns a move-rotate-scale mode tween
+     * @param params - partial transform (at least one of position, rotation, scale); omit axes you don't need
+     */
+    MoveRotateScale: (params: MoveRotateScaleModeParams) => PBTween['mode'];
 }
 /**
  * @public
  */
 export interface TweenComponentDefinitionExtended extends LastWriteWinElementSetComponentDefinition<PBTween> {
     /**
-     * Texture helpers with constructor
+     * Helpers with constructor
      */
     Mode: TweenHelper;
     /**
@@ -118,5 +155,15 @@ export interface TweenComponentDefinitionExtended extends LastWriteWinElementSet
      * @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;
+    /**
+     * @public
+     *
+     * Creates or replaces a move-rotate-scale tween component that simultaneously animates
+     * an entity's position, rotation, and/or scale from start to end. Provide only the
+     * properties you need (at least one of position, rotation, or scale).
+     * @param entity - entity to apply the tween to
+     * @param params - object with optional position, rotation, scale (each with start/end), duration, and optional easingFunction
+     */
+    setMoveRotateScale(entity: Entity, params: SetMoveRotateScaleParams): void;
 }
 export declare function defineTweenComponent(engine: Pick<IEngine, 'defineComponentFromSchema'>): TweenComponentDefinitionExtended;