@dcl/playground-assets 7.0.6-4177592674.commit-39cdc99 → 7.0.6-4180146485.commit-9a7dde9

package/dist/index.js

@@ -11080,40 +11080,6 @@
 
     /* eslint-disable */
     function createBasePBPointerEventsResult() {
-        return { commands: [] };
-    }
-    /**
-     * @public
-     */
-    /**
-     * @internal
-     */
-    const PBPointerEventsResult = {
-        encode(message, writer = _m0.Writer.create()) {
-            for (const v of message.commands) {
-                PBPointerEventsResult_PointerCommand.encode(v, writer.uint32(10).fork()).ldelim();
-            }
-            return writer;
-        },
-        decode(input, length) {
-            const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
-            let end = length === undefined ? reader.len : reader.pos + length;
-            const message = createBasePBPointerEventsResult();
-            while (reader.pos < end) {
-                const tag = reader.uint32();
-                switch (tag >>> 3) {
-                    case 1:
-                        message.commands.push(PBPointerEventsResult_PointerCommand.decode(reader, reader.uint32()));
-                        break;
-                    default:
-                        reader.skipType(tag & 7);
-                        break;
-                }
-            }
-            return message;
-        },
-    };
-    function createBasePBPointerEventsResult_PointerCommand() {
         return { button: 0, hit: undefined, state: 0, timestamp: 0, analog: undefined };
     }
     /**
@@ -11122,7 +11088,7 @@
     /**
      * @internal
      */
-    const PBPointerEventsResult_PointerCommand = {
+    const PBPointerEventsResult = {
         encode(message, writer = _m0.Writer.create()) {
             if (message.button !== 0) {
                 writer.uint32(8).int32(message.button);
@@ -11144,7 +11110,7 @@
         decode(input, length) {
             const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
             let end = length === undefined ? reader.len : reader.pos + length;
-            const message = createBasePBPointerEventsResult_PointerCommand();
+            const message = createBasePBPointerEventsResult();
             while (reader.pos < end) {
                 const tag = reader.uint32();
                 switch (tag >>> 3) {
@@ -12775,7 +12741,10 @@
     /** @public */  const MeshRenderer$2 = engine => engine.defineComponentFromSchema("core::MeshRenderer", MeshRendererSchema);
     /** @public */  const NftShape$1 = engine => engine.defineComponentFromSchema("core::NftShape", NftShapeSchema);
     /** @public */  const PointerEvents$1 = engine => engine.defineComponentFromSchema("core::PointerEvents", PointerEventsSchema);
-    /** @public */  const PointerEventsResult$1 = engine => engine.defineComponentFromSchema("core::PointerEventsResult", PointerEventsResultSchema);
+    /** @public */  const PointerEventsResult$1 = (engine) => engine.defineValueSetComponentFromSchema("core::PointerEventsResult", PointerEventsResultSchema, {
+        timestampFunction: (t) => t.timestamp,
+        maxElements: 100
+    });
     /** @public */  const PointerLock$1 = engine => engine.defineComponentFromSchema("core::PointerLock", PointerLockSchema);
     /** @public */  const Raycast$1 = engine => engine.defineComponentFromSchema("core::Raycast", RaycastSchema);
     /** @public */  const RaycastResult$1 = engine => engine.defineComponentFromSchema("core::RaycastResult", RaycastResultSchema);
@@ -13098,7 +13067,6 @@
         PBNftShape: PBNftShape,
         PBPointerEvents: PBPointerEvents,
         PBPointerEventsResult: PBPointerEventsResult,
-        PBPointerEventsResult_PointerCommand: PBPointerEventsResult_PointerCommand,
         PBPointerEvents_Entry: PBPointerEvents_Entry,
         PBPointerEvents_Info: PBPointerEvents_Info,
         PBPointerLock: PBPointerLock,
@@ -13239,8 +13207,13 @@
         return ((unsignedCRC32(bytes) + MAX_STATIC_COMPONENT) & 4294967295) >>> 0;
     }
 
+    /* istanbul ignore file */
+    const __DEV__ = (typeof DEBUG === 'boolean' && DEBUG) ||
+        (typeof process === 'object' &&
+            (process.env?.NODE_ENV !== 'production' || process.env?.NODE_ENV === 'development')) ||
+        false;
     function checkNotThenable(t, error) {
-        if (globalThis.DEBUG) {
+        if (__DEV__) {
             if (t && typeof t === 'object' && typeof t.then === 'function') {
                 throw new Error(error);
             }
@@ -14144,7 +14117,8 @@
         CrdtMessageType[CrdtMessageType["PUT_COMPONENT"] = 1] = "PUT_COMPONENT";
         CrdtMessageType[CrdtMessageType["DELETE_COMPONENT"] = 2] = "DELETE_COMPONENT";
         CrdtMessageType[CrdtMessageType["DELETE_ENTITY"] = 3] = "DELETE_ENTITY";
-        CrdtMessageType[CrdtMessageType["MAX_MESSAGE_TYPE"] = 4] = "MAX_MESSAGE_TYPE";
+        CrdtMessageType[CrdtMessageType["APPEND_VALUE"] = 4] = "APPEND_VALUE";
+        CrdtMessageType[CrdtMessageType["MAX_MESSAGE_TYPE"] = 5] = "MAX_MESSAGE_TYPE";
     })(exports.CrdtMessageType || (exports.CrdtMessageType = {}));
     /**
      * @public
@@ -14317,6 +14291,54 @@
         DeleteComponent.read = read;
     })(exports.DeleteComponent || (exports.DeleteComponent = {}));
 
+    /**
+     * @internal
+     */
+    exports.AppendValueOperation = void 0;
+    (function (AppendValueOperation) {
+        AppendValueOperation.MESSAGE_HEADER_LENGTH = 16;
+        /**
+         * Call this function for an optimal writing data passing the ByteBuffer
+         *  already allocated
+         */
+        function write(entity, timestamp, componentId, data, buf) {
+            // reserve the beginning
+            const startMessageOffset = buf.incrementWriteOffset(CRDT_MESSAGE_HEADER_LENGTH + AppendValueOperation.MESSAGE_HEADER_LENGTH);
+            // write body
+            buf.writeBuffer(data, false);
+            const messageLength = buf.currentWriteOffset() - startMessageOffset;
+            // Write CrdtMessage header
+            buf.setUint32(startMessageOffset, messageLength);
+            buf.setUint32(startMessageOffset + 4, exports.CrdtMessageType.APPEND_VALUE);
+            // Write ComponentOperation header
+            buf.setUint32(startMessageOffset + 8, entity);
+            buf.setUint32(startMessageOffset + 12, componentId);
+            buf.setUint32(startMessageOffset + 16, timestamp);
+            const newLocal = messageLength - AppendValueOperation.MESSAGE_HEADER_LENGTH - CRDT_MESSAGE_HEADER_LENGTH;
+            buf.setUint32(startMessageOffset + 20, newLocal);
+        }
+        AppendValueOperation.write = write;
+        function read(buf) {
+            const header = exports.CrdtMessageProtocol.readHeader(buf);
+            /* istanbul ignore if */
+            if (!header) {
+                return null;
+            }
+            /* istanbul ignore if */
+            if (header.type !== exports.CrdtMessageType.APPEND_VALUE) {
+                throw new Error('AppendValueOperation tried to read another message type.');
+            }
+            return {
+                ...header,
+                entityId: buf.readUint32(),
+                componentId: buf.readUint32(),
+                timestamp: buf.readUint32(),
+                data: buf.readBuffer()
+            };
+        }
+        AppendValueOperation.read = read;
+    })(exports.AppendValueOperation || (exports.AppendValueOperation = {}));
+
     /**
      * @internal
      */
@@ -14423,7 +14445,6 @@
                     if (header.type === exports.CrdtMessageType.DELETE_COMPONENT) {
                         const message = exports.DeleteComponent.read(buffer);
                         receivedMessages.push({
-                            ...header,
                             ...message,
                             transportId,
                             messageBuffer: buffer.buffer().subarray(offset, buffer.currentReadOffset())
@@ -14432,7 +14453,6 @@
                     else if (header.type === exports.CrdtMessageType.PUT_COMPONENT) {
                         const message = exports.PutComponentOperation.read(buffer);
                         receivedMessages.push({
-                            ...header,
                             ...message,
                             transportId,
                             messageBuffer: buffer.buffer().subarray(offset, buffer.currentReadOffset())
@@ -14441,7 +14461,14 @@
                     else if (header.type === exports.CrdtMessageType.DELETE_ENTITY) {
                         const message = exports.DeleteEntity.read(buffer);
                         receivedMessages.push({
-                            ...header,
+                            ...message,
+                            transportId,
+                            messageBuffer: buffer.buffer().subarray(offset, buffer.currentReadOffset())
+                        });
+                    }
+                    else if (header.type === exports.CrdtMessageType.APPEND_VALUE) {
+                        const message = exports.AppendValueOperation.read(buffer);
+                        receivedMessages.push({
                             ...message,
                             transportId,
                             messageBuffer: buffer.buffer().subarray(offset, buffer.currentReadOffset())
@@ -14487,13 +14514,13 @@
                     }
                     const component = engine.getComponentOrNull(msg.componentId);
                     if (component) {
-                        const [conflictMessage] = component.updateFromCrdt(msg);
+                        const [conflictMessage, value] = component.updateFromCrdt(msg);
                         if (conflictMessage) {
                             const offset = bufferForOutdated.currentWriteOffset();
                             if (conflictMessage.type === exports.CrdtMessageType.PUT_COMPONENT) {
                                 exports.PutComponentOperation.write(msg.entityId, conflictMessage.timestamp, conflictMessage.componentId, conflictMessage.data, bufferForOutdated);
                             }
-                            else {
+                            else if (conflictMessage.type === exports.CrdtMessageType.DELETE_COMPONENT) {
                                 exports.DeleteComponent.write(msg.entityId, component.componentId, conflictMessage.timestamp, bufferForOutdated);
                             }
                             outdatedMessages.push({
@@ -14504,7 +14531,7 @@
                         else {
                             // Add message to transport queue to be processed by others transports
                             broadcastMessages.push(msg);
-                            onProcessEntityComponentChange && onProcessEntityComponentChange(msg.entityId, msg.type, component);
+                            onProcessEntityComponentChange && onProcessEntityComponentChange(msg.entityId, msg.type, component, value);
                         }
                     }
                 }
@@ -14543,11 +14570,19 @@
                         else if (message.type === exports.CrdtMessageType.DELETE_COMPONENT) {
                             exports.DeleteComponent.write(message.entityId, component.componentId, message.timestamp, buffer);
                         }
+                        else if (message.type === exports.CrdtMessageType.APPEND_VALUE) {
+                            exports.AppendValueOperation.write(message.entityId, message.timestamp, message.componentId, message.data, buffer);
+                        }
                         crdtMessages.push({
                             ...message,
                             messageBuffer: buffer.buffer().subarray(offset, buffer.currentWriteOffset())
                         });
-                        onProcessEntityComponentChange && onProcessEntityComponentChange(message.entityId, message.type, component);
+                        if (onProcessEntityComponentChange) {
+                            const rawValue = message.type === exports.CrdtMessageType.PUT_COMPONENT || message.type === exports.CrdtMessageType.APPEND_VALUE
+                                ? component.get(message.entityId)
+                                : undefined;
+                            onProcessEntityComponentChange(message.entityId, message.type, component, rawValue);
+                        }
                     }
                 }
             }
@@ -14658,7 +14693,7 @@
         timestamps.set(entity, newTimestamp);
         return newTimestamp;
     }
-    function createUpdateFromCrdt(componentId, timestamps, schema, data) {
+    function createUpdateLwwFromCrdt(componentId, timestamps, schema, data) {
         /**
          * 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.
@@ -14759,7 +14794,7 @@
             return [null, data.get(entity)];
         };
     }
-    function createGetCrdtMessages(componentId, timestamps, dirtyIterator, schema, data) {
+    function createGetCrdtMessagesForLww(componentId, timestamps, dirtyIterator, schema, data) {
         return function* () {
             for (const entity of dirtyIterator) {
                 const newTimestamp = incrementTimestamp(entity, timestamps);
@@ -14802,12 +14837,11 @@
             get componentName() {
                 return componentName;
             },
-            default() {
-                return schema.create();
-            },
-            isDirty(entity) {
-                return dirtyIterator.has(entity);
+            get componentType() {
+                // a getter is used here to prevent accidental changes
+                return 0 /* ComponentType.LastWriteWinElementSet */;
             },
+            schema,
             has(entity) {
                 return data.has(entity);
             },
@@ -14875,20 +14909,8 @@
                     yield entity;
                 }
             },
-            getCrdtUpdates: createGetCrdtMessages(componentId, timestamps, dirtyIterator, schema, data),
-            toBinary(entity) {
-                const component = data.get(entity);
-                if (!component) {
-                    throw new Error(`[toBinary] Component ${componentName} for ${entity} not found`);
-                }
-                const writeBuffer = new ReadWriteByteBuffer();
-                schema.serialize(component, writeBuffer);
-                return writeBuffer;
-            },
-            updateFromCrdt: createUpdateFromCrdt(componentId, timestamps, schema, data),
-            deserialize(buffer) {
-                return schema.deserialize(buffer);
-            }
+            getCrdtUpdates: createGetCrdtMessagesForLww(componentId, timestamps, dirtyIterator, schema, data),
+            updateFromCrdt: createUpdateLwwFromCrdt(componentId, timestamps, schema, data)
         };
     }
 
@@ -14937,6 +14959,135 @@
         };
     }
 
+    const emptyReadonlySet = freezeSet(new Set());
+    function frozenError() {
+        throw new Error('The set is frozen');
+    }
+    function freezeSet(set) {
+        set.add = frozenError;
+        set.clear = frozenError;
+        return set;
+    }
+    function sortByTimestamp(a, b) {
+        return a.timestamp > b.timestamp ? 1 : -1;
+    }
+    /**
+     * @internal
+     */
+    function createValueSetComponentDefinitionFromSchema(componentName, componentId, schema, options) {
+        const data = new Map();
+        const dirtyIterator = new Set();
+        const queuedCommands = [];
+        // only sort the array if the latest (N) element has a timestamp <= N-1
+        function shouldSort(row) {
+            const len = row.raw.length;
+            if (len > 1 && row.raw[len - 1].timestamp <= row.raw[len - 2].timestamp) {
+                return true;
+            }
+            return false;
+        }
+        function gotUpdated(entity) {
+            const row = data.get(entity);
+            /* istanbul ignore else */
+            if (row) {
+                if (shouldSort(row)) {
+                    row.raw.sort(sortByTimestamp);
+                }
+                while (row.raw.length > options.maxElements) {
+                    row.raw.shift();
+                }
+                const frozenSet = freezeSet(new Set(row?.raw.map(($) => $.value)));
+                row.frozenSet = frozenSet;
+                return frozenSet;
+            }
+            else {
+                /* istanbul ignore next */
+                return emptyReadonlySet;
+            }
+        }
+        function append(entity, value) {
+            let row = data.get(entity);
+            if (!row) {
+                row = { raw: [], frozenSet: emptyReadonlySet };
+                data.set(entity, row);
+            }
+            const usedValue = schema.extend ? schema.extend(value) : value;
+            const timestamp = options.timestampFunction(usedValue);
+            if (__DEV__) {
+                // only freeze the objects in dev mode to warn the developers because
+                // it is an expensive operation
+                Object.freeze(usedValue);
+            }
+            row.raw.push({ value: usedValue, timestamp });
+            return { set: gotUpdated(entity), value: usedValue };
+        }
+        const ret = {
+            get componentId() {
+                return componentId;
+            },
+            get componentName() {
+                return componentName;
+            },
+            get componentType() {
+                // a getter is used here to prevent accidental changes
+                return 1 /* ComponentType.GrowOnlyValueSet */;
+            },
+            schema,
+            has(entity) {
+                return data.has(entity);
+            },
+            entityDeleted(entity) {
+                data.delete(entity);
+            },
+            get(entity) {
+                const values = data.get(entity);
+                if (values) {
+                    return values.frozenSet;
+                }
+                else {
+                    return emptyReadonlySet;
+                }
+            },
+            addValue(entity, rawValue) {
+                const { set, value } = append(entity, rawValue);
+                dirtyIterator.add(entity);
+                const buf = new ReadWriteByteBuffer();
+                schema.serialize(value, buf);
+                queuedCommands.push({
+                    componentId,
+                    data: buf.toBinary(),
+                    entityId: entity,
+                    timestamp: 0,
+                    type: exports.CrdtMessageType.APPEND_VALUE
+                });
+                return set;
+            },
+            *iterator() {
+                for (const [entity, component] of data) {
+                    yield [entity, component.frozenSet];
+                }
+            },
+            *dirtyIterator() {
+                for (const entity of dirtyIterator) {
+                    yield entity;
+                }
+            },
+            getCrdtUpdates() {
+                // return a copy of the commands, and then clear the local copy
+                dirtyIterator.clear();
+                return queuedCommands.splice(0, queuedCommands.length);
+            },
+            updateFromCrdt(_body) {
+                if (_body.type === exports.CrdtMessageType.APPEND_VALUE) {
+                    const buf = new ReadWriteByteBuffer(_body.data);
+                    append(_body.entityId, schema.deserialize(buf));
+                }
+                return [null, undefined];
+            }
+        };
+        return ret;
+    }
+
     const InputCommands = [
         0 /* InputAction.IA_POINTER */,
         1 /* InputAction.IA_PRIMARY */,
@@ -14952,69 +15103,71 @@
         12 /* InputAction.IA_ACTION_5 */,
         13 /* InputAction.IA_ACTION_6 */
     ];
-    const InternalInputStateSchema = {
-        timestampLastUpdate: exports.Schemas.Number,
-        currentTimestamp: exports.Schemas.Number,
-        buttonState: exports.Schemas.Array(exports.Schemas.Map({
-            value: exports.Schemas.Boolean,
-            ts: exports.Schemas.Number
-        }))
-    };
-    const TimestampUpdateSystemPriority = 1 << 20;
-    const ButtonStateUpdateSystemPriority = 0;
+    const InputStateUpdateSystemPriority = 1 << 20;
     /**
      * @internal
      */
     function createInputSystem(engine) {
         const PointerEventsResult = PointerEventsResult$1(engine);
-        const InternalInputStateComponent = engine.defineComponent('@dcl/sdk/InternalInputStateSchema', InternalInputStateSchema);
-        InternalInputStateComponent.create(engine.RootEntity, {
-            buttonState: Array.from({ length: InputCommands.length }, () => ({
-                ts: 0,
-                value: false
-            }))
-        });
-        function timestampUpdateSystem() {
-            const state = InternalInputStateComponent.get(engine.RootEntity);
-            if (state.currentTimestamp > state.timestampLastUpdate) {
-                InternalInputStateComponent.getMutable(engine.RootEntity).timestampLastUpdate = state.currentTimestamp;
-            }
-        }
-        function* commandIterator() {
-            for (const [, value] of engine.getEntitiesWith(PointerEventsResult)) {
-                yield* value.commands;
+        const globalState = {
+            previousFrameMaxTimestamp: 0,
+            currentFrameMaxTimestamp: 0,
+            buttonState: new Map()
+        };
+        function findLastAction(pointerEventType, inputAction, entity) {
+            const ascendingTimestampIterator = PointerEventsResult.get(entity);
+            for (const command of Array.from(ascendingTimestampIterator).reverse()) {
+                if (command.button === inputAction && command.state === pointerEventType) {
+                    return command;
+                }
             }
         }
-        function findLastAction(pointerEventType, inputAction, entity) {
-            let commandToReturn = undefined;
-            for (const command of commandIterator()) {
-                if (command.button === inputAction &&
-                    command.state === pointerEventType &&
-                    (!entity || (command.hit && entity === command.hit.entityId))) {
-                    if (!commandToReturn || command.timestamp >= commandToReturn.timestamp)
-                        commandToReturn = command;
+        function* findCommandsByActionDescending(inputAction, entity) {
+            const ascendingTimestampIterator = PointerEventsResult.get(entity);
+            for (const command of Array.from(ascendingTimestampIterator).reverse()) {
+                if (command.button === inputAction) {
+                    yield command;
                 }
             }
-            return commandToReturn;
         }
         function buttonStateUpdateSystem() {
-            const component = PointerEventsResult.getOrNull(engine.RootEntity);
-            if (!component)
-                return;
-            const state = InternalInputStateComponent.getMutable(engine.RootEntity);
-            for (const command of commandIterator()) {
-                if (command.timestamp > state.buttonState[command.button].ts) {
-                    if (command.state === 1 /* PointerEventType.PET_DOWN */) {
-                        state.buttonState[command.button].value = true;
+            // first store the previous' frame timestamp
+            let maxTimestamp = globalState.currentFrameMaxTimestamp;
+            globalState.previousFrameMaxTimestamp = maxTimestamp;
+            // then iterate over all new commands
+            for (const [, commands] of engine.getEntitiesWith(PointerEventsResult)) {
+                // TODO: adapt the gset component to have a cached "reversed" option by default
+                const arrayCommands = Array.from(commands);
+                for (let i = arrayCommands.length - 1; i >= 0; i--) {
+                    const command = arrayCommands[i];
+                    if (command.timestamp > maxTimestamp) {
+                        maxTimestamp = command.timestamp;
                     }
-                    else if (command.state === 0 /* PointerEventType.PET_UP */) {
-                        state.buttonState[command.button].value = false;
+                    if (command.state === 0 /* PointerEventType.PET_UP */ || command.state === 1 /* PointerEventType.PET_DOWN */) {
+                        const prevCommand = globalState.buttonState.get(command.button);
+                        if (!prevCommand || command.timestamp > prevCommand.timestamp) {
+                            globalState.buttonState.set(command.button, command);
+                        }
+                        else {
+                            // since we are iterating a descending array, we can early finish the
+                            // loop
+                            break;
+                        }
                     }
                 }
             }
+            // update current frame's max timestamp
+            globalState.currentFrameMaxTimestamp = maxTimestamp;
+        }
+        engine.addSystem(buttonStateUpdateSystem, InputStateUpdateSystemPriority, '@dcl/ecs#inputSystem');
+        function timestampIsCurrentFrame(timestamp) {
+            if (timestamp > globalState.previousFrameMaxTimestamp && timestamp <= globalState.currentFrameMaxTimestamp) {
+                return true;
+            }
+            else {
+                return false;
+            }
         }
-        engine.addSystem(buttonStateUpdateSystem, ButtonStateUpdateSystemPriority, '@dcl/ecs#buttonStateUpdateSystem');
-        engine.addSystem(timestampUpdateSystem, TimestampUpdateSystemPriority, '@dcl/ecs#timestampUpdateSystem');
         function getClick(inputAction, entity) {
             if (inputAction !== 3 /* InputAction.IA_ANY */) {
                 return findClick(inputAction, entity);
@@ -15027,18 +15180,27 @@
             return null;
         }
         function findClick(inputAction, entity) {
-            // We search the last DOWN command sorted by timestamp
-            const down = findLastAction(1 /* PointerEventType.PET_DOWN */, inputAction, entity);
-            // We search the last UP command sorted by timestamp
-            if (!down)
-                return null;
-            const up = findLastAction(0 /* PointerEventType.PET_UP */, inputAction, entity);
-            if (!up)
+            let down = null;
+            let up = null;
+            // We search the last UP & DOWN command sorted by timestamp descending
+            for (const it of findCommandsByActionDescending(inputAction, entity)) {
+                if (!up) {
+                    if (it.state === 0 /* PointerEventType.PET_UP */) {
+                        up = it;
+                        continue;
+                    }
+                }
+                else if (!down) {
+                    if (it.state === 1 /* PointerEventType.PET_DOWN */) {
+                        down = it;
+                        break;
+                    }
+                }
+            }
+            if (!up || !down)
                 return null;
-            const state = InternalInputStateComponent.get(engine.RootEntity);
             // If the DOWN command has happen before the UP commands, it means that that a clicked has happen
-            if (down.timestamp < up.timestamp && up.timestamp > state.timestampLastUpdate) {
-                InternalInputStateComponent.getMutable(engine.RootEntity).currentTimestamp = Math.max(up.timestamp, state.currentTimestamp);
+            if (down.timestamp < up.timestamp && timestampIsCurrentFrame(up.timestamp)) {
                 return { up, down };
             }
             return null;
@@ -15059,38 +15221,45 @@
             const command = findLastAction(pointerEventType, inputAction, entity);
             if (!command)
                 return null;
-            const state = InternalInputStateComponent.get(engine.RootEntity);
-            if (command.timestamp > state.timestampLastUpdate) {
-                InternalInputStateComponent.getMutable(engine.RootEntity).currentTimestamp = Math.max(command.timestamp, state.currentTimestamp);
+            if (timestampIsCurrentFrame(command.timestamp)) {
                 return command;
             }
             else {
                 return null;
             }
         }
+        // returns true if there was a DOWN (in any past frame), and then an UP in the last frame
         function isClicked(inputAction, entity) {
             return getClick(inputAction, entity) !== null;
         }
+        // returns true if the provided last action was triggered in the last frame
         function isTriggered(inputAction, pointerEventType, entity) {
-            return getInputCommand(inputAction, pointerEventType, entity) !== null;
+            const command = findLastAction(pointerEventType, inputAction, entity);
+            return (command && timestampIsCurrentFrame(command.timestamp)) || false;
         }
+        // returns the global state of the input. This global state is updated from the system
         function isPressed(inputAction) {
-            return InternalInputStateComponent.get(engine.RootEntity).buttonState[inputAction].value;
+            return globalState.buttonState.get(inputAction)?.state === 1 /* PointerEventType.PET_DOWN */;
         }
         return {
-            // @public
             isPressed,
-            // @internal
             getClick,
-            // @public
             getInputCommand,
-            // @internal
             isClicked,
-            // @public
             isTriggered
         };
     }
 
+    /**
+     * Component types are used to pick the wire protocol and the conflict resolution algorithm
+     * @public
+     */
+    exports.ComponentType = void 0;
+    (function (ComponentType) {
+        ComponentType[ComponentType["LastWriteWinElementSet"] = 0] = "LastWriteWinElementSet";
+        ComponentType[ComponentType["GrowOnlyValueSet"] = 1] = "GrowOnlyValueSet";
+    })(exports.ComponentType || (exports.ComponentType = {}));
+
     function preEngine() {
         const entityContainer = EntityContainer();
         const componentsDefinition = new Map();
@@ -15146,6 +15315,20 @@
             componentsDefinition.set(componentId, newComponent);
             return newComponent;
         }
+        function defineValueSetComponentFromSchema(componentName, schema, options) {
+            /* istanbul ignore next */
+            if (sealed)
+                throw new Error('Engine is already sealed. No components can be added at this stage');
+            const componentId = componentNumberFromName(componentName);
+            const prev = componentsDefinition.get(componentId);
+            if (prev) {
+                // TODO: assert spec === prev.spec
+                return prev;
+            }
+            const newComponent = createValueSetComponentDefinitionFromSchema(componentName, componentId, schema, options);
+            componentsDefinition.set(componentId, newComponent);
+            return newComponent;
+        }
         function defineComponent(componentName, mapSpec, constructorDefault) {
             if (sealed)
                 throw new Error('Engine is already sealed. No components can be added at this stage');
@@ -15241,6 +15424,7 @@
             removeSystem,
             defineComponent,
             defineComponentFromSchema,
+            defineValueSetComponentFromSchema,
             getEntitiesWith,
             getComponent,
             getComponentOrNull,
@@ -15276,6 +15460,7 @@
             removeSystem: partialEngine.removeSystem,
             defineComponent: partialEngine.defineComponent,
             defineComponentFromSchema: partialEngine.defineComponentFromSchema,
+            defineValueSetComponentFromSchema: partialEngine.defineValueSetComponentFromSchema,
             registerComponentDefinition: partialEngine.registerComponentDefinition,
             getEntitiesWith: partialEngine.getEntitiesWith,
             getComponent: partialEngine.getComponent,
@@ -42180,8 +42365,7 @@
                 }
             },
             filter(message) {
-                if ((message.type === exports.CrdtMessageType.PUT_COMPONENT || message.type === exports.CrdtMessageType.DELETE_COMPONENT) &&
-                    message.componentId > MAX_STATIC_COMPONENT) {
+                if (message.componentId > MAX_STATIC_COMPONENT) {
                     return false;
                 }
                 return !!message;
@@ -42268,7 +42452,6 @@
     exports.PBNftShape = PBNftShape;
     exports.PBPointerEvents = PBPointerEvents;
     exports.PBPointerEventsResult = PBPointerEventsResult;
-    exports.PBPointerEventsResult_PointerCommand = PBPointerEventsResult_PointerCommand;
     exports.PBPointerEvents_Entry = PBPointerEvents_Entry;
     exports.PBPointerEvents_Info = PBPointerEvents_Info;
     exports.PBPointerLock = PBPointerLock;
@@ -42312,19 +42495,15 @@
     exports.VideoTexture = VideoTexture;
     exports.VisibilityComponent = VisibilityComponent;
     exports.components = index;
-    exports.createComponentDefinitionFromSchema = createComponentDefinitionFromSchema;
     exports.createEthereumProvider = createEthereumProvider;
-    exports.createGetCrdtMessages = createGetCrdtMessages;
     exports.createInputSystem = createInputSystem;
     exports.createPointerEventSystem = createPointerEventSystem;
     exports.createReactBasedUiSystem = createReactBasedUiSystem;
     exports.createTaskSystem = createTaskSystem;
-    exports.createUpdateFromCrdt = createUpdateFromCrdt;
     exports.cyclicParentingChecker = cyclicParentingChecker;
     exports.deepReadonly = deepReadonly;
     exports.engine = engine;
     exports.executeTask = executeTask;
-    exports.incrementTimestamp = incrementTimestamp;
     exports.inputSystem = inputSystem;
     exports.isListener = isListener;
     exports.onCommsMessage = onCommsMessage;