@dcl/ecs 7.0.6-4177592674.commit-39cdc99 → 7.0.6-4183962432.commit-2fbe270

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

@@ -0,0 +1,132 @@
+import { ReadWriteByteBuffer } from '../serialization/ByteBuffer';
+import { CrdtMessageType } from '../serialization/crdt';
+import { __DEV__ } from '../runtime/invariant';
+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
+ */
+export 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: 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 === CrdtMessageType.APPEND_VALUE) {
+                const buf = new ReadWriteByteBuffer(_body.data);
+                append(_body.entityId, schema.deserialize(buf));
+            }
+            return [null, undefined];
+        }
+    };
+    return ret;
+}

package/dist/engine/index.d.ts

@@ -1,9 +1,8 @@
 import { ByteBuffer } from '../serialization/ByteBuffer';
 import { OnChangeFunction } from '../systems/crdt';
-import { ComponentDefinition } from './component';
 import { Entity } from './entity';
 import { SystemItem } from './systems';
 export * from './input';
 export * from './readonly';
 export * from './types';
-export { Entity, ByteBuffer, ComponentDefinition, SystemItem, OnChangeFunction };
+export { Entity, ByteBuffer, SystemItem, OnChangeFunction };

package/dist/engine/index.js

@@ -3,9 +3,10 @@ import { componentNumberFromName } from '../components/component-number';
 import { checkNotThenable } from '../runtime/invariant';
 import { Schemas } from '../schemas';
 import { crdtSceneSystem } from '../systems/crdt';
-import { createComponentDefinitionFromSchema } from './component';
+import { createComponentDefinitionFromSchema } from './lww-element-set-component-definition';
 import { EntityContainer } from './entity';
 import { SystemContainer, SYSTEMS_REGULAR_PRIORITY } from './systems';
+import { createValueSetComponentDefinitionFromSchema } from './grow-only-value-set-component-definition';
 export * from './input';
 export * from './readonly';
 export * from './types';
@@ -64,6 +65,20 @@ function preEngine() {
         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');
@@ -159,6 +174,7 @@ function preEngine() {
         removeSystem,
         defineComponent,
         defineComponentFromSchema,
+        defineValueSetComponentFromSchema,
         getEntitiesWith,
         getComponent,
         getComponentOrNull,
@@ -194,6 +210,7 @@ export function Engine(options) {
         removeSystem: partialEngine.removeSystem,
         defineComponent: partialEngine.defineComponent,
         defineComponentFromSchema: partialEngine.defineComponentFromSchema,
+        defineValueSetComponentFromSchema: partialEngine.defineValueSetComponentFromSchema,
         registerComponentDefinition: partialEngine.registerComponentDefinition,
         getEntitiesWith: partialEngine.getEntitiesWith,
         getComponent: partialEngine.getComponent,

package/dist/engine/input.d.ts

@@ -1,6 +1,6 @@
 import { InputAction } from '../components/generated/pb/decentraland/sdk/components/common/input_action.gen';
 import { PointerEventType } from '../components/generated/pb/decentraland/sdk/components/pointer_events.gen';
-import { PBPointerEventsResult_PointerCommand } from '../components/generated/pb/decentraland/sdk/components/pointer_events_result.gen';
+import { PBPointerEventsResult } from '../components/generated/pb/decentraland/sdk/components/pointer_events_result.gen';
 import { Entity } from './entity';
 /**
  * @public
@@ -14,7 +14,7 @@ export type IInputSystem = {
      * @param entity - the entity to query, ignore for global
      * @returns boolean
      */
-    isTriggered: (inputAction: InputAction, pointerEventType: PointerEventType, entity?: Entity) => boolean;
+    isTriggered: (inputAction: InputAction, pointerEventType: PointerEventType, entity: Entity) => boolean;
     /**
      * @public
      * Check if an input action is currently being pressed.
@@ -30,5 +30,5 @@ export type IInputSystem = {
      * @param entity - the entity to query, ignore for global
      * @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_PointerCommand | null;
+    getInputCommand: (inputAction: InputAction, pointerEventType: PointerEventType, entity: Entity) => PBPointerEventsResult | null;
 };

package/dist/engine/input.js

@@ -1,5 +1,4 @@
 import * as components from '../components';
-import { Schemas } from '../schemas';
 const InputCommands = [
     0 /* InputAction.IA_POINTER */,
     1 /* InputAction.IA_PRIMARY */,
@@ -15,69 +14,71 @@ const InputCommands = [
     12 /* InputAction.IA_ACTION_5 */,
     13 /* InputAction.IA_ACTION_6 */
 ];
-const InternalInputStateSchema = {
-    timestampLastUpdate: Schemas.Number,
-    currentTimestamp: Schemas.Number,
-    buttonState: Schemas.Array(Schemas.Map({
-        value: Schemas.Boolean,
-        ts: Schemas.Number
-    }))
-};
-const TimestampUpdateSystemPriority = 1 << 20;
-const ButtonStateUpdateSystemPriority = 0;
+const InputStateUpdateSystemPriority = 1 << 20;
 /**
  * @internal
  */
 export function createInputSystem(engine) {
     const PointerEventsResult = components.PointerEventsResult(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);
@@ -90,18 +91,27 @@ export function createInputSystem(engine) {
         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;
@@ -122,34 +132,31 @@ export function createInputSystem(engine) {
         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
     };
 }

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

@@ -0,0 +1,6 @@
+import { ISchema } from '../schemas';
+import { PutComponentMessageBody, DeleteComponentMessageBody, CrdtMessageBody } from '../serialization/crdt';
+import { Entity } from './entity';
+export declare function incrementTimestamp(entity: Entity, timestamps: Map<Entity, number>): number;
+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>;

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

@@ -0,0 +1,229 @@
+import { ReadWriteByteBuffer } from '../serialization/ByteBuffer';
+import { ProcessMessageResultType, CrdtMessageType } from '../serialization/crdt';
+import { dataCompare } from '../systems/crdt/utils';
+import { deepReadonly } from './readonly';
+export function incrementTimestamp(entity, timestamps) {
+    const newTimestamp = (timestamps.get(entity) || 0) + 1;
+    timestamps.set(entity, newTimestamp);
+    return newTimestamp;
+}
+export 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.
+     * If they are equal, the bigger raw data wins.
+  
+      * Returns the recieved data if the lamport number was bigger than ours.
+      * If it was an outdated message, then we return void
+      * @public
+      */
+    function crdtRuleForCurrentState(message) {
+        const { entityId, timestamp } = message;
+        const currentTimestamp = timestamps.get(entityId);
+        // The received message is > than our current value, update our state.components.
+        if (currentTimestamp === undefined || currentTimestamp < timestamp) {
+            return ProcessMessageResultType.StateUpdatedTimestamp;
+        }
+        // Outdated Message. Resend our state message through the wire.
+        if (currentTimestamp > timestamp) {
+            // console.log('2', currentTimestamp, timestamp)
+            return ProcessMessageResultType.StateOutdatedTimestamp;
+        }
+        // Deletes are idempotent
+        if (message.type === CrdtMessageType.DELETE_COMPONENT && !data.has(entityId)) {
+            return ProcessMessageResultType.NoChanges;
+        }
+        let currentDataGreater = 0;
+        if (data.has(entityId)) {
+            const writeBuffer = new ReadWriteByteBuffer();
+            schema.serialize(data.get(entityId), writeBuffer);
+            currentDataGreater = dataCompare(writeBuffer.toBinary(), message.data || null);
+        }
+        else {
+            currentDataGreater = dataCompare(null, message.data);
+        }
+        // Same data, same timestamp. Weirdo echo message.
+        // console.log('3', currentDataGreater, writeBuffer.toBinary(), (message as any).data || null)
+        if (currentDataGreater === 0) {
+            return ProcessMessageResultType.NoChanges;
+        }
+        else if (currentDataGreater > 0) {
+            // Current data is greater
+            return ProcessMessageResultType.StateOutdatedData;
+        }
+        else {
+            // Curent data is lower
+            return ProcessMessageResultType.StateUpdatedData;
+        }
+    }
+    return (msg) => {
+        /* istanbul ignore next */
+        if (msg.type !== CrdtMessageType.PUT_COMPONENT && msg.type !== CrdtMessageType.DELETE_COMPONENT)
+            /* istanbul ignore next */
+            return [null, data.get(msg.entityId)];
+        const action = crdtRuleForCurrentState(msg);
+        const entity = msg.entityId;
+        switch (action) {
+            case ProcessMessageResultType.StateUpdatedData:
+            case ProcessMessageResultType.StateUpdatedTimestamp: {
+                timestamps.set(entity, msg.timestamp);
+                if (msg.type === CrdtMessageType.PUT_COMPONENT) {
+                    const buf = new ReadWriteByteBuffer(msg.data);
+                    data.set(entity, schema.deserialize(buf));
+                }
+                else {
+                    data.delete(entity);
+                }
+                return [null, data.get(entity)];
+            }
+            case ProcessMessageResultType.StateOutdatedTimestamp:
+            case ProcessMessageResultType.StateOutdatedData: {
+                if (data.has(entity)) {
+                    const writeBuffer = new ReadWriteByteBuffer();
+                    schema.serialize(data.get(entity), writeBuffer);
+                    return [
+                        {
+                            type: CrdtMessageType.PUT_COMPONENT,
+                            componentId,
+                            data: writeBuffer.toBinary(),
+                            entityId: entity,
+                            timestamp: timestamps.get(entity)
+                        },
+                        data.get(entity)
+                    ];
+                }
+                else {
+                    return [
+                        {
+                            type: CrdtMessageType.DELETE_COMPONENT,
+                            componentId,
+                            entityId: entity,
+                            timestamp: timestamps.get(entity)
+                        },
+                        undefined
+                    ];
+                }
+            }
+        }
+        return [null, data.get(entity)];
+    };
+}
+export function createGetCrdtMessagesForLww(componentId, timestamps, dirtyIterator, schema, data) {
+    return function* () {
+        for (const entity of dirtyIterator) {
+            const newTimestamp = incrementTimestamp(entity, timestamps);
+            if (data.has(entity)) {
+                const writeBuffer = new ReadWriteByteBuffer();
+                schema.serialize(data.get(entity), writeBuffer);
+                const msg = {
+                    type: CrdtMessageType.PUT_COMPONENT,
+                    componentId,
+                    entityId: entity,
+                    data: writeBuffer.toBinary(),
+                    timestamp: newTimestamp
+                };
+                yield msg;
+            }
+            else {
+                const msg = {
+                    type: CrdtMessageType.DELETE_COMPONENT,
+                    componentId,
+                    entityId: entity,
+                    timestamp: newTimestamp
+                };
+                yield msg;
+            }
+        }
+        dirtyIterator.clear();
+    };
+}
+/**
+ * @internal
+ */
+export function createComponentDefinitionFromSchema(componentName, componentId, schema) {
+    const data = new Map();
+    const dirtyIterator = new Set();
+    const timestamps = new Map();
+    return {
+        get componentId() {
+            return componentId;
+        },
+        get componentName() {
+            return componentName;
+        },
+        get componentType() {
+            // a getter is used here to prevent accidental changes
+            return 0 /* ComponentType.LastWriteWinElementSet */;
+        },
+        schema,
+        has(entity) {
+            return data.has(entity);
+        },
+        deleteFrom(entity, markAsDirty = true) {
+            const component = data.get(entity);
+            if (data.delete(entity) && markAsDirty) {
+                dirtyIterator.add(entity);
+            }
+            return component || null;
+        },
+        entityDeleted(entity, markAsDirty) {
+            if (data.delete(entity) && markAsDirty) {
+                dirtyIterator.add(entity);
+            }
+        },
+        getOrNull(entity) {
+            const component = data.get(entity);
+            return component ? deepReadonly(component) : null;
+        },
+        get(entity) {
+            const component = data.get(entity);
+            if (!component) {
+                throw new Error(`[getFrom] Component ${componentName} for entity #${entity} not found`);
+            }
+            return deepReadonly(component);
+        },
+        create(entity, value) {
+            const component = data.get(entity);
+            if (component) {
+                throw new Error(`[create] Component ${componentName} for ${entity} already exists`);
+            }
+            const usedValue = value === undefined ? schema.create() : schema.extend ? schema.extend(value) : value;
+            data.set(entity, usedValue);
+            dirtyIterator.add(entity);
+            return usedValue;
+        },
+        createOrReplace(entity, value) {
+            const usedValue = value === undefined ? schema.create() : schema.extend ? schema.extend(value) : value;
+            data.set(entity, usedValue);
+            dirtyIterator.add(entity);
+            return usedValue;
+        },
+        getMutableOrNull(entity) {
+            const component = data.get(entity);
+            if (!component) {
+                return null;
+            }
+            dirtyIterator.add(entity);
+            return component;
+        },
+        getMutable(entity) {
+            const component = this.getMutableOrNull(entity);
+            if (component === null) {
+                throw new Error(`[mutable] Component ${componentName} for ${entity} not found`);
+            }
+            return component;
+        },
+        *iterator() {
+            for (const [entity, component] of data) {
+                yield [entity, component];
+            }
+        },
+        *dirtyIterator() {
+            for (const entity of dirtyIterator) {
+                yield entity;
+            }
+        },
+        getCrdtUpdates: createGetCrdtMessagesForLww(componentId, timestamps, dirtyIterator, schema, data),
+        updateFromCrdt: createUpdateLwwFromCrdt(componentId, timestamps, schema, data)
+    };
+}

package/dist/engine/readonly.d.ts

@@ -2,7 +2,7 @@ import { ComponentDefinition } from './component';
 /**
  * @public
  */
-export type DeepReadonlyMap<K, V> = ReadonlyMap<DeepReadonly<K>, DeepReadonly<V>>;
+export type DeepReadonlyMap<K, V> = ReadonlyMap<K, DeepReadonly<V>>;
 /**
  * @public
  */
@@ -26,4 +26,4 @@ export type ReadonlyComponentSchema<T extends [ComponentDefinition<unknown>, ...
 /**
  * @public
  */
-export type DeepReadonly<T> = T extends ReadonlyPrimitive ? T : T extends Map<infer K, infer V> ? DeepReadonlyMap<K, V> : T extends Set<infer M> ? DeepReadonlySet<M> : DeepReadonlyObject<T>;
+export type DeepReadonly<T> = T extends ReadonlyPrimitive ? T : T extends Array<infer K> ? ReadonlyArray<DeepReadonly<K>> : T extends Map<infer K, infer V> ? DeepReadonlyMap<K, V> : T extends Set<infer M> ? DeepReadonlySet<M> : DeepReadonlyObject<T>;