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

package/dist/components/index.d.ts

@@ -2,41 +2,42 @@ import { GrowOnlyValueSetComponentDefinition, LastWriteWinElementSetComponentDef
 import { IEngine } from '../engine/types';
 import { AnimatorComponentDefinitionExtended } from './extended/Animator';
 import { AudioSourceComponentDefinitionExtended } from './extended/AudioSource';
-import { AudioStreamComponentDefinitionExtended } from './extended/AudioStream';
-import { AvatarEquippedDataComponentDefinitionExtended } from './extended/AvatarEquippedData';
-import { AvatarShapeComponentDefinitionExtended } from './extended/AvatarShape';
-import { InputModifierComponentDefinitionExtended } from './extended/InputModifier';
+import { AudioAnalysisComponentDefinitionExtended } from './extended/AudioAnalysis';
+import type { AudioAnalysisView } from './extended/AudioAnalysis';
 import { MaterialComponentDefinitionExtended } from './extended/Material';
 import { MeshColliderComponentDefinitionExtended } from './extended/MeshCollider';
 import { MeshRendererComponentDefinitionExtended } from './extended/MeshRenderer';
 import { TweenComponentDefinitionExtended } from './extended/Tween';
-import { VirtualCameraComponentDefinitionExtended } from './extended/VirtualCamera';
-import { GSetComponentGetter, LwwComponentGetter } from './generated/index.gen';
-import { MediaState } from './generated/pb/decentraland/sdk/components/common/media_state.gen';
+import { LwwComponentGetter, GSetComponentGetter } from './generated/index.gen';
 import { NameType } from './manual/Name';
+import { ISyncComponentsType } from './manual/SyncComponents';
 import { INetowrkEntityType } from './manual/NetworkEntity';
 import { INetowrkParentType } from './manual/NetworkParent';
-import { ISyncComponentsType } from './manual/SyncComponents';
 import { TransformComponentExtended } from './manual/Transform';
+import { AudioStreamComponentDefinitionExtended } from './extended/AudioStream';
+import { MediaState } from './generated/pb/decentraland/sdk/components/common/media_state.gen';
+import { VirtualCameraComponentDefinitionExtended } from './extended/VirtualCamera';
+import { InputModifierComponentDefinitionExtended } from './extended/InputModifier';
 import { LightSourceComponentDefinitionExtended } from './extended/LightSource';
 import { TriggerAreaComponentDefinitionExtended } from './extended/TriggerArea';
+import { ParticleSystemComponentDefinitionExtended } from './extended/ParticleSystem';
 import { TagsComponentDefinitionExtended } from './manual/Tags';
 export * from './generated/index.gen';
-export type { GrowOnlyValueSetComponentDefinition, GSetComponentGetter, LastWriteWinElementSetComponentDefinition, LwwComponentGetter };
+export type { GrowOnlyValueSetComponentDefinition, LastWriteWinElementSetComponentDefinition, LwwComponentGetter, GSetComponentGetter };
 export declare const Transform: LwwComponentGetter<TransformComponentExtended>;
 export declare const Material: LwwComponentGetter<MaterialComponentDefinitionExtended>;
 export declare const Animator: LwwComponentGetter<AnimatorComponentDefinitionExtended>;
 export declare const AudioSource: LwwComponentGetter<AudioSourceComponentDefinitionExtended>;
+export declare const AudioAnalysis: LwwComponentGetter<AudioAnalysisComponentDefinitionExtended>;
 export declare const AudioStream: (engine: Pick<IEngine, 'defineComponentFromSchema' | 'defineValueSetComponentFromSchema'>) => AudioStreamComponentDefinitionExtended;
 export declare const MeshRenderer: LwwComponentGetter<MeshRendererComponentDefinitionExtended>;
 export declare const MeshCollider: LwwComponentGetter<MeshColliderComponentDefinitionExtended>;
 export declare const Tween: LwwComponentGetter<TweenComponentDefinitionExtended>;
-export declare const AvatarShape: LwwComponentGetter<AvatarShapeComponentDefinitionExtended>;
-export declare const AvatarEquippedData: LwwComponentGetter<AvatarEquippedDataComponentDefinitionExtended>;
 export declare const VirtualCamera: LwwComponentGetter<VirtualCameraComponentDefinitionExtended>;
 export declare const InputModifier: LwwComponentGetter<InputModifierComponentDefinitionExtended>;
 export declare const LightSource: LwwComponentGetter<LightSourceComponentDefinitionExtended>;
 export declare const TriggerArea: LwwComponentGetter<TriggerAreaComponentDefinitionExtended>;
+export declare const ParticleSystem: LwwComponentGetter<ParticleSystemComponentDefinitionExtended>;
 /**
  * @alpha
  */
@@ -55,3 +56,4 @@ export declare const NetworkEntity: (engine: Pick<IEngine, 'defineComponent'>) =
  */
 export declare const NetworkParent: (engine: Pick<IEngine, 'defineComponent'>) => LastWriteWinElementSetComponentDefinition<INetowrkParentType>;
 export { MediaState };
+export type { AudioAnalysisView };

package/dist/components/index.js

@@ -1,22 +1,22 @@
 import { defineAnimatorComponent } from './extended/Animator';
 import { defineAudioSourceComponent } from './extended/AudioSource';
-import { defineAudioStreamComponent } from './extended/AudioStream';
-import { defineAvatarEquippedDataComponent } from './extended/AvatarEquippedData';
-import { defineAvatarShapeComponent } from './extended/AvatarShape';
-import { defineInputModifierComponent } from './extended/InputModifier';
+import { defineAudioAnalysisComponent } from './extended/AudioAnalysis';
 import { defineMaterialComponent } from './extended/Material';
 import { defineMeshColliderComponent } from './extended/MeshCollider';
 import { defineMeshRendererComponent } from './extended/MeshRenderer';
 import { defineTweenComponent } from './extended/Tween';
-import { defineVirtualCameraComponent } from './extended/VirtualCamera';
-import { MediaState } from './generated/pb/decentraland/sdk/components/common/media_state.gen';
 import defineNameComponent from './manual/Name';
+import defineSyncComponent from './manual/SyncComponents';
 import defineNetworkEntity from './manual/NetworkEntity';
 import defineNetworkParent from './manual/NetworkParent';
-import defineSyncComponent from './manual/SyncComponents';
 import { defineTransformComponent } from './manual/Transform';
+import { defineAudioStreamComponent } from './extended/AudioStream';
+import { MediaState } from './generated/pb/decentraland/sdk/components/common/media_state.gen';
+import { defineVirtualCameraComponent } from './extended/VirtualCamera';
+import { defineInputModifierComponent } from './extended/InputModifier';
 import { defineLightSourceComponent } from './extended/LightSource';
 import { defineTriggerAreaComponent } from './extended/TriggerArea';
+import { defineParticleSystemComponent } from './extended/ParticleSystem';
 import defineTagsComponent from './manual/Tags';
 export * from './generated/index.gen';
 /* @__PURE__ */
@@ -28,6 +28,8 @@ export const Animator = (engine) => defineAnimatorComponent(engine);
 /* @__PURE__ */
 export const AudioSource = (engine) => defineAudioSourceComponent(engine);
 /* @__PURE__ */
+export const AudioAnalysis = (engine) => defineAudioAnalysisComponent(engine);
+/* @__PURE__ */
 export const AudioStream = (engine) => defineAudioStreamComponent(engine);
 /* @__PURE__ */
 export const MeshRenderer = (engine) => defineMeshRendererComponent(engine);
@@ -36,10 +38,6 @@ export const MeshCollider = (engine) => defineMeshColliderComponent(engine);
 /* @__PURE__ */
 export const Tween = (engine) => defineTweenComponent(engine);
 /* @__PURE__ */
-export const AvatarShape = (engine) => defineAvatarShapeComponent(engine);
-/* @__PURE__ */
-export const AvatarEquippedData = (engine) => defineAvatarEquippedDataComponent(engine);
-/* @__PURE__ */
 export const VirtualCamera = (engine) => defineVirtualCameraComponent(engine);
 /* @__PURE__*/
 export const InputModifier = (engine) => defineInputModifierComponent(engine);
@@ -47,6 +45,8 @@ export const InputModifier = (engine) => defineInputModifierComponent(engine);
 export const LightSource = (engine) => defineLightSourceComponent(engine);
 /* @__PURE__ */
 export const TriggerArea = (engine) => defineTriggerAreaComponent(engine);
+/* @__PURE__ */
+export const ParticleSystem = (engine) => defineParticleSystemComponent(engine);
 /**
  * @alpha
  */

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

@@ -1,5 +1,6 @@
 import { LastWriteWinElementSetComponentDefinition, IEngine } from '../../engine';
 import { Entity } from '../../engine/entity';
+import type { Vector3Type } from '../../schemas/custom/Vector3';
 /**
  * @public
  */
@@ -10,6 +11,18 @@ export type TransformComponent = LastWriteWinElementSetComponentDefinition<Trans
 export interface TransformComponentExtended extends TransformComponent {
     create(entity: Entity, val?: TransformTypeWithOptionals): TransformType;
     createOrReplace(entity: Entity, val?: TransformTypeWithOptionals): TransformType;
+    /**
+     * Transforms a direction vector from an entity's local coordinate space
+     * to world space, accounting for the full parent hierarchy.
+     *
+     * This applies only rotation (not translation or scale) — suitable for
+     * direction vectors like force/impulse directions.
+     *
+     * @param entity - The source entity whose local space defines the direction
+     * @param localDirection - Direction vector in the entity's local coordinates
+     * @returns The direction vector in world coordinates
+     */
+    localToWorldDirection(entity: Entity, localDirection: Vector3Type): Vector3Type;
 }
 /**
  * @public

package/dist/components/manual/Transform.js

@@ -1,3 +1,7 @@
+// Use import * to safely handle circular dependency (tree.ts → components → Transform.ts → tree.ts).
+// With import *, the namespace object's properties are resolved at access time (live bindings in ESM,
+// getters via __importStar in CJS), so by the time methods are called all exports are available.
+import * as treeHelpers from '../../runtime/helpers/tree';
 /**
  * @internal
  */
@@ -101,6 +105,10 @@ export function defineTransformComponent(engine) {
         },
         createOrReplace(entity, val) {
             return transformDef.createOrReplace(entity, TransformSchema.extend(val));
+        },
+        localToWorldDirection(entity, localDirection) {
+            const worldRotation = treeHelpers.getWorldRotation(engine, entity);
+            return treeHelpers.rotateVectorByQuaternion(localDirection, worldRotation);
         }
     };
 }

package/dist/components/types.d.ts

@@ -1,12 +1,11 @@
 export type { AnimatorComponentDefinitionExtended } from './extended/Animator';
 export type { AudioSourceComponentDefinitionExtended } from './extended/AudioSource';
+export type { AudioAnalysisComponentDefinitionExtended, AudioAnalysisView } from './extended/AudioAnalysis';
 export type { AudioStreamComponentDefinitionExtended } from './extended/AudioStream';
 export type { MeshRendererComponentDefinitionExtended } from './extended/MeshRenderer';
 export type { MeshColliderComponentDefinitionExtended } from './extended/MeshCollider';
-export type { AvatarEquippedDataComponentDefinitionExtended, AvatarEquippedDataType } from './extended/AvatarEquippedData';
-export type { AvatarShapeComponentDefinitionExtended, AvatarShapeType } from './extended/AvatarShape';
 export type { TextureHelper, MaterialComponentDefinitionExtended, FlatTexture, ReadonlyFlatMaterial, ReadonlyFlatTexture, FlatMaterial } from './extended/Material';
-export type { TweenHelper, TweenComponentDefinitionExtended } from './extended/Tween';
+export type { TweenHelper, TweenComponentDefinitionExtended, SetMoveRotateScaleParams, MoveRotateScaleModeParams } from './extended/Tween';
 export type { CameraTransitionHelper, VirtualCameraComponentDefinitionExtended } from './extended/VirtualCamera';
 export type { TransformComponentExtended, TransformTypeWithOptionals } from './manual/Transform';
 export type { NameComponent, NameType } from './manual/Name';
@@ -17,3 +16,4 @@ export type { INetowrkParent, INetowrkParentType } from './manual/NetworkParent'
 export type { InputModifierHelper, InputModifierComponentDefinitionExtended } from './extended/InputModifier';
 export type { LightSourceHelper, LightSourceComponentDefinitionExtended } from './extended/LightSource';
 export type { TriggerAreaComponentDefinitionExtended } from './extended/TriggerArea';
+export type { ParticleSystemHelper, ParticleSystemComponentDefinitionExtended, ParticleSystemBlendMode, ParticleSystemPlaybackState } from './extended/ParticleSystem';

package/dist/composite/index.d.ts

@@ -6,6 +6,7 @@ import { CompositeDefinition } from './proto/gen/composite.gen';
 export type { CompositeDefinition, ComponentData, CompositeComponent, CompositeComponent_DataEntry, InstanceCompositeOptions, CompositeProvider, CompositeRootType, CompositeResource };
 export { EntityMappingMode };
 export { getCompositeRootComponent };
+export { setCompositeProvider, getCompositeProvider } from './provider-registry';
 /**
  * @public
  * @deprecated composite is not being supported so far, please do not use this feature
@@ -31,14 +32,16 @@ export declare namespace Composite {
     /** @public */
     function toBinary(composite: Composite.Definition): Uint8Array;
     /**
-     * Instance a composite and returns its root entity
-     * @param compositeData - state serialized by the CRDT protocol
-     * @param getNextAvailableEntity - function that gives unused entities
-     * @param rootEntity - (optional) suggested mapped rootEntity for the composite
+     * Instance a composite and return its root entity.
+     * @param engine - the engine that will own the new entities
+     * @param compositeData - the composite resource to instance
+     * @param compositeProvider - provider used to resolve nested composite references
+     * @param options - instancing options (`rootEntity`, `entityMapping`, `alreadyRequestedSrc`)
+     * @returns the root entity of the instanced composite
      *
      * @public
      */
-    function instance(engine: IEngine, compositeData: Composite.Resource, compositeProvider: CompositeProvider, options?: InstanceCompositeOptions): void;
+    function instance(engine: IEngine, compositeData: Composite.Resource, compositeProvider: CompositeProvider, options?: InstanceCompositeOptions): import("../engine").Entity;
     /**
      * Resolve and normalize a composite path
      * @param src - the source path

package/dist/composite/index.js

@@ -4,6 +4,7 @@ import { resolveComposite } from './path';
 import { CompositeDefinition } from './proto/gen/composite.gen';
 export { EntityMappingMode };
 export { getCompositeRootComponent };
+export { setCompositeProvider, getCompositeProvider } from './provider-registry';
 /**
  * @public
  * @deprecated composite is not being supported so far, please do not use this feature
@@ -31,15 +32,17 @@ export var Composite;
     }
     Composite.toBinary = toBinary;
     /**
-     * Instance a composite and returns its root entity
-     * @param compositeData - state serialized by the CRDT protocol
-     * @param getNextAvailableEntity - function that gives unused entities
-     * @param rootEntity - (optional) suggested mapped rootEntity for the composite
+     * Instance a composite and return its root entity.
+     * @param engine - the engine that will own the new entities
+     * @param compositeData - the composite resource to instance
+     * @param compositeProvider - provider used to resolve nested composite references
+     * @param options - instancing options (`rootEntity`, `entityMapping`, `alreadyRequestedSrc`)
+     * @returns the root entity of the instanced composite
      *
      * @public
      */
     /*#__PURE__*/ function instance(engine, compositeData, compositeProvider, options = {}) {
-        instanceComposite(engine, compositeData, compositeProvider, options);
+        return instanceComposite(engine, compositeData, compositeProvider, options);
     }
     Composite.instance = instance;
     /**

package/dist/composite/instance.d.ts

@@ -13,6 +13,11 @@ export type CompositeResource = {
  */
 export type CompositeProvider = {
     getCompositeOrNull(src: string): CompositeResource | null;
+    loadComposite?: (src: string) => Promise<CompositeResource>;
+    schemas?: Iterable<{
+        name: string;
+        jsonSchema: any;
+    }>;
 };
 /** @public */
 export declare enum EntityMappingMode {

package/dist/composite/instance.js

@@ -43,7 +43,7 @@ export function getComponentDefinition(engine, component) {
             return engine.defineComponentFromSchema(component.name, Schemas.fromJson(component.jsonSchema));
         }
         else {
-            throw new Error(`${component.name} is not defined and there is no schema to define it.`);
+            throw new Error(`Composite references undefined component "${component.name}". Ensure provider.schemas was registered pre-seal via setCompositeProvider().`);
         }
     }
     else {
@@ -84,6 +84,7 @@ export function instanceComposite(engine, compositeResource, compositeProvider,
     const compositeDirectoryPath = path.dirname(path.resolve(compositeResource.src));
     const TransformComponentNumber = componentNumberFromName('core::Transform');
     const CompositeRootComponent = getCompositeRootComponent(engine);
+    let hadNestedComposite = false;
     // Key => EntityNumber from the composite
     // Value => EntityNumber in current engine
     const mappedEntities = new Map();
@@ -99,23 +100,29 @@ export function instanceComposite(engine, compositeResource, compositeProvider,
     // If there are more composite inside this one, we instance first.
     // => This is not only a copy, we need to instance. Otherwise, we'd be missing that branches
     // => TODO: in the future, the instanciation is first, then the overides (to parameterize Composite, e.g. house with different wall colors)
-    const childrenComposite = compositeResource.composite.components.find((item) => item.name === CompositeRootComponent.componentName);
-    if (childrenComposite) {
-        for (const [childCompositeEntity, compositeRawData] of childrenComposite.data) {
-            const childComposite = getComponentValue(CompositeRootComponent, compositeRawData);
-            const childCompositePath = path.resolveComposite(childComposite.src, compositeDirectoryPath);
-            const childCompositeResource = compositeProvider.getCompositeOrNull(childCompositePath);
-            const targetEntity = getCompositeEntity(childCompositeEntity);
-            if (childCompositeResource) {
-                if (alreadyRequestedSrc.has(childCompositeResource.src) ||
-                    childCompositeResource.src === compositeResource.src) {
-                    throw new Error(`Composite ${compositeResource.src} has a recursive instanciation while try to instance ${childCompositeResource.src}. Previous instances: ${alreadyRequestedSrc.toString()}`);
+    if (CompositeRootComponent) {
+        const childrenComposite = compositeResource.composite.components.find((item) => item.name === CompositeRootComponent.componentName);
+        if (childrenComposite) {
+            for (const [childCompositeEntity, compositeRawData] of childrenComposite.data) {
+                const childComposite = getComponentValue(CompositeRootComponent, compositeRawData);
+                const childCompositePath = path.resolveComposite(childComposite.src, compositeDirectoryPath);
+                const childCompositeResource = compositeProvider.getCompositeOrNull(childCompositePath);
+                const targetEntity = getCompositeEntity(childCompositeEntity);
+                if (childCompositeResource) {
+                    if (alreadyRequestedSrc.has(childCompositeResource.src) ||
+                        childCompositeResource.src === compositeResource.src) {
+                        throw new Error(`Composite ${compositeResource.src} has a recursive instanciation while try to instance ${childCompositeResource.src}. Previous instances: ${alreadyRequestedSrc.toString()}`);
+                    }
+                    hadNestedComposite = true;
+                    instanceComposite(engine, childCompositeResource, compositeProvider, {
+                        rootEntity: targetEntity,
+                        alreadyRequestedSrc: new Set(alreadyRequestedSrc).add(childCompositeResource.src),
+                        entityMapping: entityMapping?.type === EntityMappingMode.EMM_NEXT_AVAILABLE ? entityMapping : undefined
+                    });
+                }
+                else {
+                    console.warn(`Composite "${compositeResource.src}" references missing nested composite "${childCompositePath}". Skipping; the spawned subtree will be incomplete.`);
                 }
-                instanceComposite(engine, childCompositeResource, compositeProvider, {
-                    rootEntity: targetEntity,
-                    alreadyRequestedSrc: new Set(alreadyRequestedSrc).add(childCompositeResource.src),
-                    entityMapping: entityMapping?.type === EntityMappingMode.EMM_NEXT_AVAILABLE ? entityMapping : undefined
-                });
             }
         }
     }
@@ -123,7 +130,7 @@ export function instanceComposite(engine, compositeResource, compositeProvider,
     // Then, we copy the all rest of the components (skipping the Composite ones)
     for (const component of compositeResource.composite.components) {
         // We already instanced the composite
-        if (component.name === CompositeRootComponent.componentName)
+        if (CompositeRootComponent && component.name === CompositeRootComponent.componentName)
             continue;
         // ## 3a ##
         // We find the component definition
@@ -159,13 +166,15 @@ export function instanceComposite(engine, compositeResource, compositeProvider,
             }
         }
     }
-    const composite = CompositeRootComponent.getMutableOrNull(compositeRootEntity) || CompositeRootComponent.create(compositeRootEntity);
-    for (const [entitySource, targetEntity] of mappedEntities) {
-        composite.entities.push({
-            src: entitySource,
-            dest: targetEntity
-        });
+    if (hadNestedComposite) {
+        const composite = CompositeRootComponent.getMutableOrNull(compositeRootEntity) || CompositeRootComponent.create(compositeRootEntity);
+        for (const [entitySource, targetEntity] of mappedEntities) {
+            composite.entities.push({
+                src: entitySource,
+                dest: targetEntity
+            });
+        }
+        composite.src = compositeResource.src;
     }
-    composite.src = compositeResource.src;
     return compositeRootEntity;
 }

package/dist/composite/provider-registry.d.ts

@@ -0,0 +1,15 @@
+import type { IEngine } from '../engine';
+import type { CompositeProvider } from './instance';
+/**
+ * Register the composite provider used to resolve composite files. Also registers
+ * any `provider.schemas` on the engine pre-seal so composites that reference those
+ * components can be instanced without further setup.
+ * @public
+ */
+export declare function setCompositeProvider(engine: IEngine, provider: CompositeProvider): void;
+/**
+ * Get the composite provider registered via setCompositeProvider. Returns null if
+ * no provider has been set.
+ * @public
+ */
+export declare function getCompositeProvider(): CompositeProvider | null;

package/dist/composite/provider-registry.js

@@ -0,0 +1,32 @@
+import { Schemas } from '../schemas';
+import { getCompositeRootComponent } from './components';
+let currentProvider = null;
+/**
+ * Register the composite provider used to resolve composite files. Also registers
+ * any `provider.schemas` on the engine pre-seal so composites that reference those
+ * components can be instanced without further setup.
+ * @public
+ */
+export function setCompositeProvider(engine, provider) {
+    currentProvider = provider;
+    // Define composite::root pre-seal. setCompositeProvider runs at module-load,
+    // so this guarantees the component exists before the engine seals — composites
+    // instanced at runtime (post-seal) would otherwise trip the seal when
+    // instanceComposite looks it up via getCompositeRootComponent.
+    getCompositeRootComponent(engine);
+    if (!provider.schemas)
+        return;
+    for (const { name, jsonSchema } of provider.schemas) {
+        if (engine.getComponentOrNull(name))
+            continue;
+        engine.defineComponentFromSchema(name, Schemas.fromJson(jsonSchema));
+    }
+}
+/**
+ * Get the composite provider registered via setCompositeProvider. Returns null if
+ * no provider has been set.
+ * @public
+ */
+export function getCompositeProvider() {
+    return currentProvider;
+}

package/dist/engine/entity.js

@@ -61,8 +61,10 @@ export var EntityState;
  */
 export function createEntityContainer(opts) {
     const reservedStaticEntities = opts?.reservedStaticEntities ?? RESERVED_STATIC_ENTITIES;
-    // Local entities counter
-    let entityCounter = reservedStaticEntities;
+    // If a build tool has set DCL_MAX_COMPOSITE_ENTITY (via esbuild define),
+    // start the counter past composite entities to prevent ID collisions.
+    const maxCompositeEntity = typeof DCL_MAX_COMPOSITE_ENTITY !== 'undefined' ? DCL_MAX_COMPOSITE_ENTITY : 0;
+    let entityCounter = Math.max(reservedStaticEntities, maxCompositeEntity > 0 ? maxCompositeEntity + 1 : 0);
     const usedEntities = new Set();
     let toRemoveEntities = [];
     const removedEntities = createVersionGSet();

package/dist/engine/grow-only-value-set-component-definition.js

@@ -12,7 +12,7 @@ function freezeSet(set) {
     return set;
 }
 function sortByTimestamp(a, b) {
-    return a.timestamp > b.timestamp ? 1 : -1;
+    return a.timestamp - b.timestamp;
 }
 /**
  * @internal

package/dist/engine/index.js

@@ -236,7 +236,7 @@ export function Engine(options) {
         const deletedEntites = partialEngine.entityContainer.releaseRemovedEntities();
         await crdtSystem.sendMessages(deletedEntites);
     }
-    return {
+    const engineInstance = {
         _id: Date.now(),
         addEntity: partialEngine.addEntity,
         removeEntity: partialEngine.removeEntity,
@@ -264,4 +264,5 @@ export function Engine(options) {
         addTransport: crdtSystem.addTransport,
         entityContainer: partialEngine.entityContainer
     };
+    return engineInstance;
 }

package/dist/engine/input.d.ts

@@ -32,12 +32,6 @@ export type IInputSystem = {
      * @returns the input command info or undefined if there is no command in the last tick-update
      */
     getInputCommand: (inputAction: InputAction, pointerEventType: PointerEventType, entity?: Entity) => PBPointerEventsResult | null;
-    /**
-     * @public
-     * Get an ordered iterator over events received within the current frame.
-     * @returns the iterator
-     */
-    getInputCommands: () => Generator<PBPointerEventsResult>;
 };
 /**
  * @public

package/dist/engine/input.js

@@ -12,7 +12,8 @@ const InputCommands = [
     10 /* InputAction.IA_ACTION_3 */,
     11 /* InputAction.IA_ACTION_4 */,
     12 /* InputAction.IA_ACTION_5 */,
-    13 /* InputAction.IA_ACTION_6 */
+    13 /* InputAction.IA_ACTION_6 */,
+    14 /* InputAction.IA_MODIFIER */
 ];
 const InputStateUpdateSystemPriority = 1 << 20;
 /**
@@ -118,8 +119,9 @@ export function createInputSystem(engine) {
         }
         if (!up || !down)
             return null;
-        // If the DOWN command has happen before the UP commands, it means that that a clicked has happen
-        if (down.timestamp < up.timestamp && timestampIsCurrentFrame(up.timestamp)) {
+        // If the DOWN command has happened before or at the same time as the UP command, a click has happened.
+        // Same-timestamp is possible when both events are produced within the same renderer tick.
+        if (down.timestamp <= up.timestamp && timestampIsCurrentFrame(up.timestamp)) {
             return { up, down };
         }
         return null;
@@ -185,17 +187,11 @@ export function createInputSystem(engine) {
     function isPressed(inputAction) {
         return globalState.buttonState.get(inputAction)?.state === 1 /* PointerEventType.PET_DOWN */;
     }
-    function* getInputCommands() {
-        for (let i = globalState.thisFrameCommands.length - 1; i >= 0; i--) {
-            yield globalState.thisFrameCommands[i];
-        }
-    }
     return {
         isPressed,
         getClick,
         getInputCommand,
         isClicked,
-        isTriggered,
-        getInputCommands
+        isTriggered
     };
 }

package/dist/engine/lww-element-set-component-definition.d.ts

@@ -4,5 +4,5 @@ import { PutComponentMessageBody, DeleteComponentMessageBody, CrdtMessageBody }
 import { Entity } from './entity';
 export declare function incrementTimestamp(entity: Entity, timestamps: Map<Entity, number>): number;
 export declare function createDumpLwwFunctionFromCrdt(componentId: number, timestamps: Map<Entity, number>, schema: Pick<ISchema<any>, 'serialize' | 'deserialize'>, data: Map<Entity, unknown>): (buffer: ByteBuffer, filterEntity?: ((entity: Entity) => boolean) | undefined) => void;
-export declare function createUpdateLwwFromCrdt(componentId: number, timestamps: Map<Entity, number>, schema: Pick<ISchema<any>, 'serialize' | 'deserialize'>, data: Map<Entity, unknown>): (msg: CrdtMessageBody) => [null | PutComponentMessageBody | DeleteComponentMessageBody, any];
-export declare function createGetCrdtMessagesForLww(componentId: number, timestamps: Map<Entity, number>, dirtyIterator: Set<Entity>, schema: Pick<ISchema<any>, 'serialize'>, data: Map<Entity, unknown>): () => Generator<PutComponentMessageBody | DeleteComponentMessageBody, void, unknown>;
+export declare function createUpdateLwwFromCrdt(componentId: number, timestamps: Map<Entity, number>, schema: Pick<ISchema<any>, 'serialize' | 'deserialize'>, data: Map<Entity, unknown>, lastSentData: Map<Entity, Uint8Array>): (msg: CrdtMessageBody) => [null | PutComponentMessageBody | DeleteComponentMessageBody, any];
+export declare function createGetCrdtMessagesForLww(componentId: number, timestamps: Map<Entity, number>, dirtyIterator: Set<Entity>, schema: Pick<ISchema<any>, 'serialize'>, data: Map<Entity, unknown>, lastSentData: Map<Entity, Uint8Array>): () => Generator<PutComponentMessageBody | DeleteComponentMessageBody, void, unknown>;

package/dist/engine/lww-element-set-component-definition.js

@@ -30,7 +30,7 @@ export function createDumpLwwFunctionFromCrdt(componentId, timestamps, schema, d
         }
     };
 }
-export function createUpdateLwwFromCrdt(componentId, timestamps, schema, data) {
+export function createUpdateLwwFromCrdt(componentId, timestamps, schema, data, lastSentData) {
     /**
      * Process the received message only if the lamport number recieved is higher
      * than the stored one. If its lower, we spread it to the network to correct the peer.
@@ -96,9 +96,11 @@ export function createUpdateLwwFromCrdt(componentId, timestamps, schema, data) {
                 if (msg.type === CrdtMessageType.PUT_COMPONENT || msg.type === CrdtMessageType.PUT_COMPONENT_NETWORK) {
                     const buf = new ReadWriteByteBuffer(msg.data);
                     data.set(entity, schema.deserialize(buf));
+                    lastSentData.set(entity, new Uint8Array(msg.data));
                 }
                 else {
                     data.delete(entity);
+                    lastSentData.delete(entity);
                 }
                 return [null, data.get(entity)];
             }
@@ -134,23 +136,34 @@ export function createUpdateLwwFromCrdt(componentId, timestamps, schema, data) {
         return [null, data.get(entity)];
     };
 }
-export function createGetCrdtMessagesForLww(componentId, timestamps, dirtyIterator, schema, data) {
+export function createGetCrdtMessagesForLww(componentId, timestamps, dirtyIterator, schema, data, lastSentData) {
     return function* () {
+        const writeBuffer = new ReadWriteByteBuffer();
         for (const entity of dirtyIterator) {
-            const newTimestamp = incrementTimestamp(entity, timestamps);
             if (data.has(entity)) {
-                const writeBuffer = new ReadWriteByteBuffer();
+                writeBuffer.resetBuffer();
                 schema.serialize(data.get(entity), writeBuffer);
+                // Compare against last-sent snapshot using the zero-copy subarray view.
+                // Only allocate a copy when bytes actually differ.
+                const previousBytes = lastSentData.get(entity);
+                if (previousBytes && dataCompare(writeBuffer.toBinary(), previousBytes) === 0) {
+                    continue;
+                }
+                const currentBytes = writeBuffer.toCopiedBinary();
+                const newTimestamp = incrementTimestamp(entity, timestamps);
+                lastSentData.set(entity, currentBytes);
                 const msg = {
                     type: CrdtMessageType.PUT_COMPONENT,
                     componentId,
                     entityId: entity,
-                    data: writeBuffer.toBinary(),
+                    data: currentBytes,
                     timestamp: newTimestamp
                 };
                 yield msg;
             }
             else {
+                lastSentData.delete(entity);
+                const newTimestamp = incrementTimestamp(entity, timestamps);
                 const msg = {
                     type: CrdtMessageType.DELETE_COMPONENT,
                     componentId,
@@ -170,6 +183,7 @@ export function createComponentDefinitionFromSchema(componentName, componentId,
     const data = new Map();
     const dirtyIterator = new Set();
     const timestamps = new Map();
+    const lastSentData = new Map();
     const onChangeCallbacks = new Map();
     return {
         get componentId() {
@@ -191,12 +205,14 @@ export function createComponentDefinitionFromSchema(componentName, componentId,
             if (data.delete(entity) && markAsDirty) {
                 dirtyIterator.add(entity);
             }
+            lastSentData.delete(entity);
             return component || null;
         },
         entityDeleted(entity, markAsDirty) {
             if (data.delete(entity) && markAsDirty) {
                 dirtyIterator.add(entity);
             }
+            lastSentData.delete(entity);
         },
         getOrNull(entity) {
             const component = data.get(entity);
@@ -223,6 +239,7 @@ export function createComponentDefinitionFromSchema(componentName, componentId,
             const usedValue = value === undefined ? schema.create() : schema.extend ? schema.extend(value) : value;
             data.set(entity, usedValue);
             dirtyIterator.add(entity);
+            lastSentData.delete(entity);
             return usedValue;
         },
         getMutableOrNull(entity) {
@@ -260,8 +277,8 @@ export function createComponentDefinitionFromSchema(componentName, componentId,
                 yield entity;
             }
         },
-        getCrdtUpdates: createGetCrdtMessagesForLww(componentId, timestamps, dirtyIterator, schema, data),
-        updateFromCrdt: createUpdateLwwFromCrdt(componentId, timestamps, schema, data),
+        getCrdtUpdates: createGetCrdtMessagesForLww(componentId, timestamps, dirtyIterator, schema, data, lastSentData),
+        updateFromCrdt: createUpdateLwwFromCrdt(componentId, timestamps, schema, data, lastSentData),
         dumpCrdtStateToBuffer: createDumpLwwFunctionFromCrdt(componentId, timestamps, schema, data),
         onChange(entity, cb) {
             const cbs = onChangeCallbacks.get(entity) ?? [];