@dcl/ecs 7.23.2-25521226778.commit-1828100 → 7.23.2-25802088407.commit-15e8697

package/dist/systems/crdt/index.js

@@ -1,17 +1,24 @@
 import { EntityState } from '../../engine/entity';
 import { ReadWriteByteBuffer } from '../../serialization/ByteBuffer';
-import { AppendValueOperation, CrdtMessageProtocol } from '../../serialization/crdt';
+import { AppendValueOperation, CrdtMessageProtocol, DeleteComponentNetwork, DeleteEntityNetwork } from '../../serialization/crdt';
 import { DeleteComponent } from '../../serialization/crdt/deleteComponent';
 import { DeleteEntity } from '../../serialization/crdt/deleteEntity';
 import { PutComponentOperation } from '../../serialization/crdt/putComponent';
-import { AuthoritativePutComponentOperation } from '../../serialization/crdt/authoritativePutComponent';
 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
  */
 export function crdtSceneSystem(engine, onProcessEntityComponentChange) {
     const transports = [];
-    // No network components needed - pure CRDT processing only
+    // Components that we used on this system
+    const NetworkEntity = defineNetworkEntity(engine);
+    const NetworkParent = defineNetworkParent(engine);
+    const Transform = defineTransform(engine);
     // Messages that we received at transport.onMessage waiting to be processed
     const receivedMessages = [];
     // Messages already processed by the engine but that we need to broadcast to other transports.
@@ -36,20 +43,27 @@ export function crdtSceneSystem(engine, onProcessEntityComponentChange) {
                 if (header.type === CrdtMessageType.DELETE_COMPONENT) {
                     message = DeleteComponent.read(buffer);
                 }
+                else if (header.type === CrdtMessageType.DELETE_COMPONENT_NETWORK) {
+                    message = DeleteComponentNetwork.read(buffer);
+                }
                 else if (header.type === CrdtMessageType.PUT_COMPONENT) {
                     message = PutComponentOperation.read(buffer);
                 }
-                else if (header.type === CrdtMessageType.AUTHORITATIVE_PUT_COMPONENT) {
-                    message = AuthoritativePutComponentOperation.read(buffer);
+                else if (header.type === CrdtMessageType.PUT_COMPONENT_NETWORK) {
+                    message = PutNetworkComponentOperation.read(buffer);
                 }
                 else if (header.type === CrdtMessageType.DELETE_ENTITY) {
                     message = DeleteEntity.read(buffer);
                 }
+                else if (header.type === CrdtMessageType.DELETE_ENTITY_NETWORK) {
+                    message = DeleteEntityNetwork.read(buffer);
+                }
                 else if (header.type === CrdtMessageType.APPEND_VALUE) {
                     message = AppendValueOperation.read(buffer);
+                    // Unknown message, we skip it
                 }
                 else {
-                    // Unknown message, we skip it (including NETWORK messages)
+                    // consume the message
                     buffer.incrementReadOffset(header.length);
                 }
                 if (message) {
@@ -70,6 +84,22 @@ export function crdtSceneSystem(engine, onProcessEntityComponentChange) {
         const messagesToProcess = value.splice(0, value.length);
         return messagesToProcess;
     }
+    /**
+     * Find the local entityId associated to the network component message.
+     * It's a mapping Network -> to Local
+     * If it's not a network message, return the entityId received by the message
+     */
+    function findNetworkId(msg) {
+        const hasNetworkId = 'networkId' in msg;
+        if (hasNetworkId) {
+            for (const [entityId, network] of engine.getEntitiesWith(NetworkEntity)) {
+                if (network.networkId === msg.networkId && network.entityId === msg.entityId) {
+                    return { entityId, network };
+                }
+            }
+        }
+        return { entityId: msg.entityId };
+    }
     /**
      * This fn will be called on every tick.
      * Process all the messages queue received by the transport
@@ -78,52 +108,46 @@ export function crdtSceneSystem(engine, onProcessEntityComponentChange) {
         const messagesToProcess = getMessages(receivedMessages);
         const entitiesShouldBeCleaned = [];
         for (const msg of messagesToProcess) {
-            // Simple CRDT processing - no network logic
-            if (msg.type === CrdtMessageType.DELETE_ENTITY) {
-                entitiesShouldBeCleaned.push(msg.entityId);
+            let { entityId, network } = findNetworkId(msg);
+            // We receive a new Entity. Create the localEntity and map it to the NetworkEntity component
+            if (networkUtils.isNetworkMessage(msg) && !network) {
+                entityId = engine.addEntity();
+                network = { entityId: msg.entityId, networkId: msg.networkId };
+                NetworkEntity.createOrReplace(entityId, network);
+            }
+            if (msg.type === CrdtMessageType.DELETE_ENTITY || msg.type === CrdtMessageType.DELETE_ENTITY_NETWORK) {
+                entitiesShouldBeCleaned.push(entityId);
                 broadcastMessages.push(msg);
             }
             else {
-                const entityState = engine.entityContainer.getEntityState(msg.entityId);
-                // Skip updates from removed entities
+                const entityState = engine.entityContainer.getEntityState(entityId);
+                // Skip updates from removed entityes
                 if (entityState === EntityState.Removed)
                     continue;
-                // Entities with unknown state should update its entity state
+                // Entities with unknown entities should update its entity state
                 if (entityState === EntityState.Unknown) {
-                    engine.entityContainer.updateUsedEntity(msg.entityId);
-                }
-                // Only process component-related messages (not DELETE_ENTITY)
-                if ('componentId' in msg) {
-                    const component = engine.getComponentOrNull(msg.componentId);
-                    if (component) {
-                        // Handle authoritative messages differently - they force the state regardless of timestamp
-                        const tryUpdate = () => {
-                            try {
-                                return msg.type === CrdtMessageType.AUTHORITATIVE_PUT_COMPONENT
-                                    ? component.__forceUpdateFromCrdt(msg)
-                                    : component.updateFromCrdt(msg);
-                            }
-                            catch (e) {
-                                console.error('[receiveMessages] ERROR processing message', msg, e);
-                                return null;
-                            }
-                        };
-                        const result = tryUpdate();
-                        if (!result)
-                            continue;
-                        const [conflictMessage, value] = result;
-                        if (!conflictMessage) {
-                            // Add message to broadcast queue when no conflict
-                            broadcastMessages.push(msg);
-                            onProcessEntityComponentChange && onProcessEntityComponentChange(msg.entityId, msg.type, component, value);
-                        }
+                    engine.entityContainer.updateUsedEntity(entityId);
+                }
+                const component = engine.getComponentOrNull(msg.componentId);
+                /* istanbul ignore else */
+                if (component) {
+                    if (msg.type === CrdtMessageType.PUT_COMPONENT &&
+                        component.componentId === Transform.componentId &&
+                        NetworkEntity.has(entityId) &&
+                        NetworkParent.has(entityId)) {
+                        msg.data = networkUtils.fixTransformParent(msg);
                     }
-                    else {
-                        // Component not found - still broadcast for editor compatibility
-                        /* istanbul ignore next */
+                    const [conflictMessage, value] = component.updateFromCrdt({ ...msg, entityId });
+                    if (!conflictMessage) {
+                        // Add message to transport queue to be processed by others transports
                         broadcastMessages.push(msg);
+                        onProcessEntityComponentChange && onProcessEntityComponentChange(entityId, msg.type, component, value);
                     }
                 }
+                else {
+                    // TODO: test this line, it is fundammental to make the editor work
+                    broadcastMessages.push(msg);
+                }
             }
         }
         // the last stage of the syncrhonization is to delete the entities
@@ -137,17 +161,16 @@ export function crdtSceneSystem(engine, onProcessEntityComponentChange) {
         }
     }
     /**
-     * Simple CRDT message broadcasting - no network-specific logic
+     * Iterates the dirty map and generates crdt messages to be send
      */
     async function sendMessages(entitiesDeletedThisTick) {
-        // Get messages from broadcast queue and component updates
+        // CRDT Messages will be the merge between the recieved transport messages and the new crdt messages
         const crdtMessages = getMessages(broadcastMessages);
         const buffer = new ReadWriteByteBuffer();
-        // Generate CRDT messages from component updates
         for (const component of engine.componentsIter()) {
             for (const message of component.getCrdtUpdates()) {
                 const offset = buffer.currentWriteOffset();
-                // Only create messages if there's a transport that will handle it
+                // Avoid creating messages if there is no transport that will handle it
                 if (transports.some((t) => t.filter(message))) {
                     if (message.type === CrdtMessageType.PUT_COMPONENT) {
                         PutComponentOperation.write(message.entityId, message.timestamp, message.componentId, message.data, buffer);
@@ -171,7 +194,7 @@ export function crdtSceneSystem(engine, onProcessEntityComponentChange) {
                 }
             }
         }
-        // Handle deleted entities
+        // After all updates, I execute the DeletedEntity messages
         for (const entityId of entitiesDeletedThisTick) {
             const offset = buffer.currentWriteOffset();
             DeleteEntity.write(entityId, buffer);
@@ -182,19 +205,87 @@ export function crdtSceneSystem(engine, onProcessEntityComponentChange) {
             });
             onProcessEntityComponentChange && onProcessEntityComponentChange(entityId, CrdtMessageType.DELETE_ENTITY);
         }
-        // Simple transport broadcasting - no network-specific transforms
-        for (const transport of transports) {
-            const transportBuffer = new ReadWriteByteBuffer();
+        // Send CRDT messages to transports
+        const transportBuffer = new ReadWriteByteBuffer();
+        for (const index in transports) {
+            const __NetworkMessagesBuffer = [];
+            const transportIndex = Number(index);
+            const transport = transports[transportIndex];
+            const isRendererTransport = transport.type === 'renderer';
+            const isNetworkTransport = transport.type === 'network';
+            // Reset Buffer for each Transport
+            transportBuffer.resetBuffer();
+            const buffer = new ReadWriteByteBuffer();
+            // Then we send all the new crdtMessages that the transport needs to process
             for (const message of crdtMessages) {
                 // Avoid echo messages
-                if (message.transportId === transports.indexOf(transport))
+                if (message.transportId === transportIndex)
                     continue;
-                // Check if transport wants this message
-                if (transport.filter(message)) {
-                    transportBuffer.writeBuffer(message.messageBuffer, false);
+                // Redundant message for the transport
+                if (!transport.filter(message))
+                    continue;
+                // Check if adding this message would exceed the size limit
+                const currentBufferSize = transportBuffer.toBinary().byteLength;
+                const messageSize = message.messageBuffer.byteLength;
+                if (isNetworkTransport && (currentBufferSize + messageSize) / 1024 > 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;
+                    }
                 }
+                const { entityId } = findNetworkId(message);
+                const transformNeedsFix = 'componentId' in message &&
+                    message.componentId === Transform.componentId &&
+                    Transform.has(entityId) &&
+                    NetworkParent.has(entityId) &&
+                    NetworkEntity.has(entityId);
+                // If there was a LOCAL change in the transform. Add the parent to that transform
+                if (isRendererTransport && message.type === CrdtMessageType.PUT_COMPONENT && transformNeedsFix) {
+                    const parent = findNetworkId(NetworkParent.get(entityId));
+                    const transformData = networkUtils.fixTransformParent(message, Transform.get(entityId), parent.entityId);
+                    const offset = buffer.currentWriteOffset();
+                    PutComponentOperation.write(entityId, message.timestamp, message.componentId, transformData, buffer);
+                    transportBuffer.writeBuffer(buffer.buffer().subarray(offset, buffer.currentWriteOffset()), false);
+                    continue;
+                }
+                if (isRendererTransport && networkUtils.isNetworkMessage(message)) {
+                    // If it's the renderer transport and its a NetworkMessage, we need to fix the entityId field and convert it to a known Message.
+                    // PUT_NETWORK_COMPONENT -> PUT_COMPONENT
+                    let transformData = 'data' in message ? message.data : new Uint8Array();
+                    if (transformNeedsFix) {
+                        const parent = findNetworkId(NetworkParent.get(entityId));
+                        transformData = networkUtils.fixTransformParent(message, Transform.get(entityId), parent.entityId);
+                    }
+                    networkUtils.networkMessageToLocal({ ...message, data: transformData }, entityId, buffer, transportBuffer);
+                    // Iterate the next message
+                    continue;
+                }
+                // If its a network transport and its a PUT_COMPONENT that has a NetworkEntity component, we need to send this message
+                // through comms with the EntityID and NetworkID from ther NetworkEntity so everyone can recieve this message and map to their custom entityID.
+                if (isNetworkTransport && !networkUtils.isNetworkMessage(message)) {
+                    const networkData = NetworkEntity.getOrNull(message.entityId);
+                    // If it has networkData convert the message to PUT_NETWORK_COMPONENT.
+                    if (networkData) {
+                        networkUtils.localMessageToNetwork(message, networkData, buffer, transportBuffer);
+                        // Iterate the next message
+                        continue;
+                    }
+                }
+                // Common message
+                transportBuffer.writeBuffer(message.messageBuffer, false);
+            }
+            if (isNetworkTransport && transportBuffer.currentWriteOffset()) {
+                __NetworkMessagesBuffer.push(transportBuffer.toBinary());
             }
-            await transport.send(transportBuffer.toBinary());
+            const message = isNetworkTransport ? __NetworkMessagesBuffer : transportBuffer.toBinary();
+            await transport.send(message);
         }
     }
     /**

package/dist/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/index.d.ts

@@ -22,7 +22,6 @@ import { LightSourceComponentDefinitionExtended } from './extended/LightSource';
 import { TriggerAreaComponentDefinitionExtended } from './extended/TriggerArea';
 import { ParticleSystemComponentDefinitionExtended } from './extended/ParticleSystem';
 import { TagsComponentDefinitionExtended } from './manual/Tags';
-import { ICreatedByType } from './manual/CreatedBy';
 export * from './generated/index.gen';
 export type { GrowOnlyValueSetComponentDefinition, LastWriteWinElementSetComponentDefinition, LwwComponentGetter, GSetComponentGetter };
 export declare const Transform: LwwComponentGetter<TransformComponentExtended>;
@@ -56,9 +55,5 @@ export declare const NetworkEntity: (engine: Pick<IEngine, 'defineComponent'>) =
  * @alpha
  */
 export declare const NetworkParent: (engine: Pick<IEngine, 'defineComponent'>) => LastWriteWinElementSetComponentDefinition<INetowrkParentType>;
-/**
- * @public
- */
-export declare const CreatedBy: (engine: Pick<IEngine, 'defineComponent'>) => LastWriteWinElementSetComponentDefinition<ICreatedByType>;
 export { MediaState };
 export type { AudioAnalysisView };

package/dist-cjs/components/index.js

@@ -17,7 +17,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MediaState = exports.CreatedBy = exports.NetworkParent = exports.NetworkEntity = exports.SyncComponents = exports.Tags = exports.Name = exports.ParticleSystem = exports.TriggerArea = exports.LightSource = exports.InputModifier = exports.VirtualCamera = exports.Tween = exports.MeshCollider = exports.MeshRenderer = exports.AudioStream = exports.AudioAnalysis = exports.AudioSource = exports.Animator = exports.Material = exports.Transform = void 0;
+exports.MediaState = exports.NetworkParent = exports.NetworkEntity = exports.SyncComponents = exports.Tags = exports.Name = exports.ParticleSystem = exports.TriggerArea = exports.LightSource = exports.InputModifier = exports.VirtualCamera = exports.Tween = exports.MeshCollider = exports.MeshRenderer = exports.AudioStream = exports.AudioAnalysis = exports.AudioSource = exports.Animator = exports.Material = exports.Transform = void 0;
 const Animator_1 = require("./extended/Animator");
 const AudioSource_1 = require("./extended/AudioSource");
 const AudioAnalysis_1 = require("./extended/AudioAnalysis");
@@ -39,7 +39,6 @@ const LightSource_1 = require("./extended/LightSource");
 const TriggerArea_1 = require("./extended/TriggerArea");
 const ParticleSystem_1 = require("./extended/ParticleSystem");
 const Tags_1 = __importDefault(require("./manual/Tags"));
-const CreatedBy_1 = __importDefault(require("./manual/CreatedBy"));
 __exportStar(require("./generated/index.gen"), exports);
 /* @__PURE__ */
 const Transform = (engine) => (0, Transform_1.defineTransformComponent)(engine);
@@ -101,15 +100,12 @@ exports.SyncComponents = SyncComponents;
 /**
  * @alpha
  */
+/* @__PURE__ */
 const NetworkEntity = (engine) => (0, NetworkEntity_1.default)(engine);
 exports.NetworkEntity = NetworkEntity;
 /**
  * @alpha
  */
+/* @__PURE__ */
 const NetworkParent = (engine) => (0, NetworkParent_1.default)(engine);
 exports.NetworkParent = NetworkParent;
-/**
- * @public
- */
-const CreatedBy = (engine) => (0, CreatedBy_1.default)(engine);
-exports.CreatedBy = CreatedBy;

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

@@ -1,6 +1,5 @@
 import { LastWriteWinElementSetComponentDefinition, IEngine } from '../../engine';
 import { Entity } from '../../engine/entity';
-import type { ISchema } from '../../schemas/ISchema';
 import type { Vector3Type } from '../../schemas/custom/Vector3';
 /**
  * @public
@@ -25,10 +24,6 @@ export interface TransformComponentExtended extends TransformComponent {
      */
     localToWorldDirection(entity: Entity, localDirection: Vector3Type): Vector3Type;
 }
-/**
- * @public
- */
-export declare const COMPONENT_ID = 1;
 /**
  * @public
  */
@@ -51,10 +46,6 @@ export type TransformType = {
     };
     parent?: Entity;
 };
-/** @public */
-export declare const TRANSFORM_LENGTH = 44;
-/** @public */
-export declare const TransformSchema: ISchema<TransformType>;
 /**
  * @public
  */

package/dist-cjs/components/manual/Transform.js

@@ -29,12 +29,12 @@ exports.defineTransformComponent = exports.TransformSchema = exports.TRANSFORM_L
 // getters via __importStar in CJS), so by the time methods are called all exports are available.
 const treeHelpers = __importStar(require("../../runtime/helpers/tree"));
 /**
- * @public
+ * @internal
  */
 exports.COMPONENT_ID = 1;
-/** @public */
+/** @internal */
 exports.TRANSFORM_LENGTH = 44;
-/** @public */
+/** @internal */
 exports.TransformSchema = {
     serialize(value, builder) {
         const ptr = builder.incrementWriteOffset(exports.TRANSFORM_LENGTH);

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

@@ -13,7 +13,6 @@ export type { TagsComponentDefinitionExtended, TagsType } from './manual/Tags';
 export type { ISyncComponents, ISyncComponentsType } from './manual/SyncComponents';
 export type { INetowrkEntity, INetowrkEntityType } from './manual/NetworkEntity';
 export type { INetowrkParent, INetowrkParentType } from './manual/NetworkParent';
-export type { ICreatedBy, ICreatedByType } from './manual/CreatedBy';
 export type { InputModifierHelper, InputModifierComponentDefinitionExtended } from './extended/InputModifier';
 export type { LightSourceHelper, LightSourceComponentDefinitionExtended } from './extended/LightSource';
 export type { TriggerAreaComponentDefinitionExtended } from './extended/TriggerArea';