@dcl/playground-assets 7.1.3-4440802627.commit-29bc3e6 → 7.1.3-4448471926.commit-264de76

package/dist/index.js

@@ -9505,7 +9505,7 @@
             return message;
         },
     };
-    var tsProtoGlobalThis$1 = (() => {
+    var tsProtoGlobalThis$3 = (() => {
         if (typeof globalThis !== "undefined") {
             return globalThis;
         }
@@ -9522,7 +9522,7 @@
     })();
     function longToNumber$1(long) {
         if (long.gt(Number.MAX_SAFE_INTEGER)) {
-            throw new tsProtoGlobalThis$1.Error("Value is larger than Number.MAX_SAFE_INTEGER");
+            throw new tsProtoGlobalThis$3.Error("Value is larger than Number.MAX_SAFE_INTEGER");
         }
         return long.toNumber();
     }
@@ -11142,7 +11142,7 @@
             return message;
         },
     };
-    var tsProtoGlobalThis = (() => {
+    var tsProtoGlobalThis$2 = (() => {
         if (typeof globalThis !== "undefined") {
             return globalThis;
         }
@@ -11159,7 +11159,7 @@
     })();
     function longToNumber(long) {
         if (long.gt(Number.MAX_SAFE_INTEGER)) {
-            throw new tsProtoGlobalThis.Error("Value is larger than Number.MAX_SAFE_INTEGER");
+            throw new tsProtoGlobalThis$2.Error("Value is larger than Number.MAX_SAFE_INTEGER");
         }
         return long.toNumber();
     }
@@ -16277,41 +16277,680 @@
         Font[Font["F_MONOSPACE"] = 2] = "F_MONOSPACE";
     })(exports.Font || (exports.Font = {}));
 
+    /* eslint-disable */
+    /**
+     * `NullValue` is a singleton enumeration to represent the null value for the
+     * `Value` type union.
+     *
+     *  The JSON representation for `NullValue` is JSON `null`.
+     */
     /**
      * @public
-     * @deprecated composite is not being supported so far, please do not use this feature
      */
-    function compositeFromJson(jsonComposite) {
-        if (!jsonComposite)
-            throw new Error('Composite is not well defined');
-        if (!jsonComposite.id || typeof jsonComposite.id !== 'string')
-            throw new Error("Composite doesn't have a valid `id` field");
-        const compositeId = jsonComposite.id;
-        // TODO: Should be there a .version to identify the schema version?
-        if (!Array.isArray(jsonComposite.components))
-            throw new Error(`Composite '${compositeId}' fields 'components' is not an array`);
-        const composite = {
-            id: compositeId,
-            components: []
-        };
-        for (const component of jsonComposite.components) {
-            if (!component.name || typeof component.name !== 'string')
-                throw new Error(`Composite '${compositeId}': The component doesn't have a valid name`);
-            const componentName = component.name;
-            const componentData = new Map();
-            if (typeof component.data !== 'object' || Array.isArray(component.data))
-                throw new Error(`Composite '${compositeId}': Invalid data in component '${component.name}'`);
-            for (const [entityStr, data] of Object.entries(component.data)) {
-                const entity = parseInt(entityStr);
-                componentData.set(entity, data);
-            }
-            composite.components.push({
-                name: componentName,
-                data: componentData,
-                schema: component.schema
+    var NullValue;
+    (function (NullValue) {
+        /** NULL_VALUE - Null value. */
+        NullValue[NullValue["NULL_VALUE"] = 0] = "NULL_VALUE";
+    })(NullValue || (NullValue = {}));
+    /**
+     * @public
+     */
+    function nullValueFromJSON(object) {
+        switch (object) {
+            case 0:
+            case "NULL_VALUE":
+                return 0 /* NullValue.NULL_VALUE */;
+            default:
+                throw new tsProtoGlobalThis$1.Error("Unrecognized enum value " + object + " for enum NullValue");
+        }
+    }
+    /**
+     * @public
+     */
+    function nullValueToJSON(object) {
+        switch (object) {
+            case 0 /* NullValue.NULL_VALUE */:
+                return "NULL_VALUE";
+            default:
+                throw new tsProtoGlobalThis$1.Error("Unrecognized enum value " + object + " for enum NullValue");
+        }
+    }
+    function createBaseStruct() {
+        return { fields: new Map() };
+    }
+    /**
+     * @public
+     */
+    /**
+     * @internal
+     */
+    const Struct = {
+        encode(message, writer = _m0.Writer.create()) {
+            message.fields.forEach((value, key) => {
+                if (value !== undefined) {
+                    Struct_FieldsEntry.encode({ key: key, value }, 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 = createBaseStruct();
+            while (reader.pos < end) {
+                const tag = reader.uint32();
+                switch (tag >>> 3) {
+                    case 1:
+                        const entry1 = Struct_FieldsEntry.decode(reader, reader.uint32());
+                        if (entry1.value !== undefined) {
+                            message.fields.set(entry1.key, entry1.value);
+                        }
+                        break;
+                    default:
+                        reader.skipType(tag & 7);
+                        break;
+                }
+            }
+            return message;
+        },
+        fromJSON(object) {
+            return {
+                fields: isObject$1(object.fields)
+                    ? Object.entries(object.fields).reduce((acc, [key, value]) => {
+                        acc.set(key, value);
+                        return acc;
+                    }, new Map())
+                    : new Map(),
+            };
+        },
+        toJSON(message) {
+            const obj = {};
+            obj.fields = {};
+            if (message.fields) {
+                message.fields.forEach((v, k) => {
+                    obj.fields[k] = v;
+                });
+            }
+            return obj;
+        },
+        wrap(object) {
+            const struct = createBaseStruct();
+            if (object !== undefined) {
+                Object.keys(object).forEach((key) => {
+                    struct.fields.set(key, object[key]);
+                });
+            }
+            return struct;
+        },
+        unwrap(message) {
+            const object = {};
+            [...message.fields.keys()].forEach((key) => {
+                object[key] = message.fields.get(key);
+            });
+            return object;
+        },
+    };
+    function createBaseStruct_FieldsEntry() {
+        return { key: "", value: undefined };
+    }
+    /**
+     * @public
+     */
+    /**
+     * @internal
+     */
+    const Struct_FieldsEntry = {
+        encode(message, writer = _m0.Writer.create()) {
+            if (message.key !== "") {
+                writer.uint32(10).string(message.key);
+            }
+            if (message.value !== undefined) {
+                Value.encode(Value.wrap(message.value), writer.uint32(18).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 = createBaseStruct_FieldsEntry();
+            while (reader.pos < end) {
+                const tag = reader.uint32();
+                switch (tag >>> 3) {
+                    case 1:
+                        message.key = reader.string();
+                        break;
+                    case 2:
+                        message.value = Value.unwrap(Value.decode(reader, reader.uint32()));
+                        break;
+                    default:
+                        reader.skipType(tag & 7);
+                        break;
+                }
+            }
+            return message;
+        },
+        fromJSON(object) {
+            return { key: isSet$1(object.key) ? String(object.key) : "", value: isSet$1(object?.value) ? object.value : undefined };
+        },
+        toJSON(message) {
+            const obj = {};
+            message.key !== undefined && (obj.key = message.key);
+            message.value !== undefined && (obj.value = message.value);
+            return obj;
+        },
+    };
+    function createBaseValue() {
+        return { kind: undefined };
+    }
+    /**
+     * @public
+     */
+    /**
+     * @internal
+     */
+    const Value = {
+        encode(message, writer = _m0.Writer.create()) {
+            if (message.kind?.$case === "nullValue") {
+                writer.uint32(8).int32(message.kind.nullValue);
+            }
+            if (message.kind?.$case === "numberValue") {
+                writer.uint32(17).double(message.kind.numberValue);
+            }
+            if (message.kind?.$case === "stringValue") {
+                writer.uint32(26).string(message.kind.stringValue);
+            }
+            if (message.kind?.$case === "boolValue") {
+                writer.uint32(32).bool(message.kind.boolValue);
+            }
+            if (message.kind?.$case === "structValue") {
+                Struct.encode(Struct.wrap(message.kind.structValue), writer.uint32(42).fork()).ldelim();
+            }
+            if (message.kind?.$case === "listValue") {
+                ListValue.encode(ListValue.wrap(message.kind.listValue), writer.uint32(50).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 = createBaseValue();
+            while (reader.pos < end) {
+                const tag = reader.uint32();
+                switch (tag >>> 3) {
+                    case 1:
+                        message.kind = { $case: "nullValue", nullValue: reader.int32() };
+                        break;
+                    case 2:
+                        message.kind = { $case: "numberValue", numberValue: reader.double() };
+                        break;
+                    case 3:
+                        message.kind = { $case: "stringValue", stringValue: reader.string() };
+                        break;
+                    case 4:
+                        message.kind = { $case: "boolValue", boolValue: reader.bool() };
+                        break;
+                    case 5:
+                        message.kind = { $case: "structValue", structValue: Struct.unwrap(Struct.decode(reader, reader.uint32())) };
+                        break;
+                    case 6:
+                        message.kind = { $case: "listValue", listValue: ListValue.unwrap(ListValue.decode(reader, reader.uint32())) };
+                        break;
+                    default:
+                        reader.skipType(tag & 7);
+                        break;
+                }
+            }
+            return message;
+        },
+        fromJSON(object) {
+            return {
+                kind: isSet$1(object.nullValue)
+                    ? { $case: "nullValue", nullValue: nullValueFromJSON(object.nullValue) }
+                    : isSet$1(object.numberValue)
+                        ? { $case: "numberValue", numberValue: Number(object.numberValue) }
+                        : isSet$1(object.stringValue)
+                            ? { $case: "stringValue", stringValue: String(object.stringValue) }
+                            : isSet$1(object.boolValue)
+                                ? { $case: "boolValue", boolValue: Boolean(object.boolValue) }
+                                : isSet$1(object.structValue)
+                                    ? { $case: "structValue", structValue: object.structValue }
+                                    : isSet$1(object.listValue)
+                                        ? { $case: "listValue", listValue: [...object.listValue] }
+                                        : undefined,
+            };
+        },
+        toJSON(message) {
+            const obj = {};
+            message.kind?.$case === "nullValue" &&
+                (obj.nullValue = message.kind?.nullValue !== undefined ? nullValueToJSON(message.kind?.nullValue) : undefined);
+            message.kind?.$case === "numberValue" && (obj.numberValue = message.kind?.numberValue);
+            message.kind?.$case === "stringValue" && (obj.stringValue = message.kind?.stringValue);
+            message.kind?.$case === "boolValue" && (obj.boolValue = message.kind?.boolValue);
+            message.kind?.$case === "structValue" && (obj.structValue = message.kind?.structValue);
+            message.kind?.$case === "listValue" && (obj.listValue = message.kind?.listValue);
+            return obj;
+        },
+        wrap(value) {
+            const result = createBaseValue();
+            if (value === null) {
+                result.kind = { $case: "nullValue", nullValue: 0 /* NullValue.NULL_VALUE */ };
+            }
+            else if (typeof value === "boolean") {
+                result.kind = { $case: "boolValue", boolValue: value };
+            }
+            else if (typeof value === "number") {
+                result.kind = { $case: "numberValue", numberValue: value };
+            }
+            else if (typeof value === "string") {
+                result.kind = { $case: "stringValue", stringValue: value };
+            }
+            else if (Array.isArray(value)) {
+                result.kind = { $case: "listValue", listValue: value };
+            }
+            else if (typeof value === "object") {
+                result.kind = { $case: "structValue", structValue: value };
+            }
+            else if (typeof value !== "undefined") {
+                throw new Error("Unsupported any value type: " + typeof value);
+            }
+            return result;
+        },
+        unwrap(message) {
+            if (message.kind?.$case === "nullValue") {
+                return null;
+            }
+            else if (message.kind?.$case === "numberValue") {
+                return message.kind?.numberValue;
+            }
+            else if (message.kind?.$case === "stringValue") {
+                return message.kind?.stringValue;
+            }
+            else if (message.kind?.$case === "boolValue") {
+                return message.kind?.boolValue;
+            }
+            else if (message.kind?.$case === "structValue") {
+                return message.kind?.structValue;
+            }
+            else if (message.kind?.$case === "listValue") {
+                return message.kind?.listValue;
+            }
+            else {
+                return undefined;
+            }
+        },
+    };
+    function createBaseListValue() {
+        return { values: [] };
+    }
+    /**
+     * @public
+     */
+    /**
+     * @internal
+     */
+    const ListValue = {
+        encode(message, writer = _m0.Writer.create()) {
+            for (const v of message.values) {
+                Value.encode(Value.wrap(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 = createBaseListValue();
+            while (reader.pos < end) {
+                const tag = reader.uint32();
+                switch (tag >>> 3) {
+                    case 1:
+                        message.values.push(Value.unwrap(Value.decode(reader, reader.uint32())));
+                        break;
+                    default:
+                        reader.skipType(tag & 7);
+                        break;
+                }
+            }
+            return message;
+        },
+        fromJSON(object) {
+            return { values: Array.isArray(object?.values) ? [...object.values] : [] };
+        },
+        toJSON(message) {
+            const obj = {};
+            if (message.values) {
+                obj.values = message.values.map((e) => e);
+            }
+            else {
+                obj.values = [];
+            }
+            return obj;
+        },
+        wrap(value) {
+            const result = createBaseListValue();
+            result.values = value ?? [];
+            return result;
+        },
+        unwrap(message) {
+            return message.values;
+        },
+    };
+    var tsProtoGlobalThis$1 = (() => {
+        if (typeof globalThis !== "undefined") {
+            return globalThis;
+        }
+        if (typeof self !== "undefined") {
+            return self;
+        }
+        if (typeof window !== "undefined") {
+            return window;
+        }
+        if (typeof global !== "undefined") {
+            return global;
+        }
+        throw "Unable to locate global object";
+    })();
+    function isObject$1(value) {
+        return typeof value === "object" && value !== null;
+    }
+    function isSet$1(value) {
+        return value !== null && value !== undefined;
+    }
+
+    /* eslint-disable */
+    function createBaseComponentData() {
+        return { data: undefined };
+    }
+    /**
+     * @public
+     */
+    /**
+     * @internal
+     */
+    const ComponentData = {
+        encode(message, writer = _m0.Writer.create()) {
+            if (message.data?.$case === "json") {
+                Value.encode(Value.wrap(message.data.json), writer.uint32(10).fork()).ldelim();
+            }
+            if (message.data?.$case === "binary") {
+                writer.uint32(18).bytes(message.data.binary);
+            }
+            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 = createBaseComponentData();
+            while (reader.pos < end) {
+                const tag = reader.uint32();
+                switch (tag >>> 3) {
+                    case 1:
+                        message.data = { $case: "json", json: Value.unwrap(Value.decode(reader, reader.uint32())) };
+                        break;
+                    case 2:
+                        message.data = { $case: "binary", binary: reader.bytes() };
+                        break;
+                    default:
+                        reader.skipType(tag & 7);
+                        break;
+                }
+            }
+            return message;
+        },
+        fromJSON(object) {
+            return {
+                data: isSet(object.json)
+                    ? { $case: "json", json: object.json }
+                    : isSet(object.binary)
+                        ? { $case: "binary", binary: bytesFromBase64(object.binary) }
+                        : undefined,
+            };
+        },
+        toJSON(message) {
+            const obj = {};
+            message.data?.$case === "json" && (obj.json = message.data?.json);
+            message.data?.$case === "binary" &&
+                (obj.binary = message.data?.binary !== undefined ? base64FromBytes(message.data?.binary) : undefined);
+            return obj;
+        },
+    };
+    function createBaseCompositeComponent() {
+        return { name: "", jsonSchema: undefined, data: new Map() };
+    }
+    /**
+     * @public
+     */
+    /**
+     * @internal
+     */
+    const CompositeComponent = {
+        encode(message, writer = _m0.Writer.create()) {
+            if (message.name !== "") {
+                writer.uint32(10).string(message.name);
+            }
+            if (message.jsonSchema !== undefined) {
+                Value.encode(Value.wrap(message.jsonSchema), writer.uint32(18).fork()).ldelim();
+            }
+            message.data.forEach((value, key) => {
+                CompositeComponent_DataEntry.encode({ key: key, value }, writer.uint32(26).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 = createBaseCompositeComponent();
+            while (reader.pos < end) {
+                const tag = reader.uint32();
+                switch (tag >>> 3) {
+                    case 1:
+                        message.name = reader.string();
+                        break;
+                    case 2:
+                        message.jsonSchema = Value.unwrap(Value.decode(reader, reader.uint32()));
+                        break;
+                    case 3:
+                        const entry3 = CompositeComponent_DataEntry.decode(reader, reader.uint32());
+                        if (entry3.value !== undefined) {
+                            message.data.set(entry3.key, entry3.value);
+                        }
+                        break;
+                    default:
+                        reader.skipType(tag & 7);
+                        break;
+                }
+            }
+            return message;
+        },
+        fromJSON(object) {
+            return {
+                name: isSet(object.name) ? String(object.name) : "",
+                jsonSchema: isSet(object?.jsonSchema) ? object.jsonSchema : undefined,
+                data: isObject(object.data)
+                    ? Object.entries(object.data).reduce((acc, [key, value]) => {
+                        acc.set(Number(key), ComponentData.fromJSON(value));
+                        return acc;
+                    }, new Map())
+                    : new Map(),
+            };
+        },
+        toJSON(message) {
+            const obj = {};
+            message.name !== undefined && (obj.name = message.name);
+            message.jsonSchema !== undefined && (obj.jsonSchema = message.jsonSchema);
+            obj.data = {};
+            if (message.data) {
+                message.data.forEach((v, k) => {
+                    obj.data[k] = ComponentData.toJSON(v);
+                });
+            }
+            return obj;
+        },
+    };
+    function createBaseCompositeComponent_DataEntry() {
+        return { key: 0, value: undefined };
+    }
+    /**
+     * @public
+     */
+    /**
+     * @internal
+     */
+    const CompositeComponent_DataEntry = {
+        encode(message, writer = _m0.Writer.create()) {
+            if (message.key !== 0) {
+                writer.uint32(8).int32(message.key);
+            }
+            if (message.value !== undefined) {
+                ComponentData.encode(message.value, writer.uint32(18).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 = createBaseCompositeComponent_DataEntry();
+            while (reader.pos < end) {
+                const tag = reader.uint32();
+                switch (tag >>> 3) {
+                    case 1:
+                        message.key = reader.int32();
+                        break;
+                    case 2:
+                        message.value = ComponentData.decode(reader, reader.uint32());
+                        break;
+                    default:
+                        reader.skipType(tag & 7);
+                        break;
+                }
+            }
+            return message;
+        },
+        fromJSON(object) {
+            return {
+                key: isSet(object.key) ? Number(object.key) : 0,
+                value: isSet(object.value) ? ComponentData.fromJSON(object.value) : undefined,
+            };
+        },
+        toJSON(message) {
+            const obj = {};
+            message.key !== undefined && (obj.key = Math.round(message.key));
+            message.value !== undefined && (obj.value = message.value ? ComponentData.toJSON(message.value) : undefined);
+            return obj;
+        },
+    };
+    function createBaseComposite() {
+        return { id: "", components: [] };
+    }
+    /**
+     * @public
+     */
+    /**
+     * @internal
+     */
+    const Composite = {
+        encode(message, writer = _m0.Writer.create()) {
+            if (message.id !== "") {
+                writer.uint32(10).string(message.id);
+            }
+            for (const v of message.components) {
+                CompositeComponent.encode(v, writer.uint32(18).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 = createBaseComposite();
+            while (reader.pos < end) {
+                const tag = reader.uint32();
+                switch (tag >>> 3) {
+                    case 1:
+                        message.id = reader.string();
+                        break;
+                    case 2:
+                        message.components.push(CompositeComponent.decode(reader, reader.uint32()));
+                        break;
+                    default:
+                        reader.skipType(tag & 7);
+                        break;
+                }
+            }
+            return message;
+        },
+        fromJSON(object) {
+            return {
+                id: isSet(object.id) ? String(object.id) : "",
+                components: Array.isArray(object?.components)
+                    ? object.components.map((e) => CompositeComponent.fromJSON(e))
+                    : [],
+            };
+        },
+        toJSON(message) {
+            const obj = {};
+            message.id !== undefined && (obj.id = message.id);
+            if (message.components) {
+                obj.components = message.components.map((e) => e ? CompositeComponent.toJSON(e) : undefined);
+            }
+            else {
+                obj.components = [];
+            }
+            return obj;
+        },
+    };
+    var tsProtoGlobalThis = (() => {
+        if (typeof globalThis !== "undefined") {
+            return globalThis;
+        }
+        if (typeof self !== "undefined") {
+            return self;
+        }
+        if (typeof window !== "undefined") {
+            return window;
         }
-        return composite;
+        if (typeof global !== "undefined") {
+            return global;
+        }
+        throw "Unable to locate global object";
+    })();
+    function bytesFromBase64(b64) {
+        if (tsProtoGlobalThis.Buffer) {
+            return Uint8Array.from(tsProtoGlobalThis.Buffer.from(b64, "base64"));
+        }
+        else {
+            const bin = tsProtoGlobalThis.atob(b64);
+            const arr = new Uint8Array(bin.length);
+            for (let i = 0; i < bin.length; ++i) {
+                arr[i] = bin.charCodeAt(i);
+            }
+            return arr;
+        }
+    }
+    function base64FromBytes(arr) {
+        if (tsProtoGlobalThis.Buffer) {
+            return tsProtoGlobalThis.Buffer.from(arr).toString("base64");
+        }
+        else {
+            const bin = [];
+            arr.forEach((byte) => {
+                bin.push(String.fromCharCode(byte));
+            });
+            return tsProtoGlobalThis.btoa(bin.join(""));
+        }
+    }
+    function isObject(value) {
+        return typeof value === "object" && value !== null;
+    }
+    function isSet(value) {
+        return value !== null && value !== undefined;
+    }
+
+    /* @public @deprecated */
+    function compositeFromJson(object) {
+        return Composite.fromJSON(object);
+    }
+    /* @public @deprecated */
+    function compositeFromBinary(buffer) {
+        return Composite.decode(buffer);
     }
 
     /**
@@ -16332,8 +16971,47 @@
         });
     }
 
+    /**
+     * Return the component value from composite data
+     * @internal
+     */
+    function getComponentValue(componentDefinition, component) {
+        if (component.data?.$case === 'json') {
+            return component.data.json;
+        }
+        else {
+            return componentDefinition.schema.deserialize(new ReadWriteByteBuffer(component.data?.binary));
+        }
+    }
+    /**
+     * Return the component definition from composite info
+     * @internal
+     */
+    function getComponentDefinition(engine, component) {
+        const existingComponentDefinition = engine.getComponentOrNull(component.name);
+        if (!existingComponentDefinition) {
+            if (component.jsonSchema) {
+                return engine.defineComponentFromSchema(component.name, exports.Schemas.fromJson(component.jsonSchema));
+            }
+            else if (component.name.startsWith('core::')) {
+                if (component.name in componentDefinitionByName) {
+                    return componentDefinitionByName[component.name](engine);
+                }
+                else {
+                    throw new Error(`The core component ${component.name} was not found.`);
+                }
+            }
+            else {
+                throw new Error(`${component.name} is not defined and there is no schema to define it.`);
+            }
+        }
+        else {
+            return existingComponentDefinition;
+        }
+    }
     /**
      * Return the entity mapping or fail if there is no more
+     * @internal
      */
     function getEntityMapping(compositeEntity, mappedEntities, getNextAvailableEntity) {
         const existingEntity = mappedEntities.get(compositeEntity);
@@ -16380,7 +17058,7 @@
         const childrenComposite = compositeData.components.find((item) => item.name === CompositeRootComponent.componentName);
         if (childrenComposite) {
             for (const [entity, childComposite] of childrenComposite.data) {
-                const compositeRoot = childComposite;
+                const compositeRoot = getComponentValue(CompositeRootComponent, childComposite);
                 const composite = compositeProvider.getCompositeOrNull(compositeRoot.id);
                 if (composite) {
                     if (alreadyRequestedId.has(compositeRoot.id) || compositeRoot.id === compositeData.id) {
@@ -16398,32 +17076,13 @@
                 continue;
             // ## 3a ##
             // We find the component definition
-            let componentDefinition;
-            const existingComponentDefinition = engine.getComponentOrNull(component.name);
-            if (!existingComponentDefinition) {
-                if (component.schema) {
-                    componentDefinition = engine.defineComponentFromSchema(component.name, exports.Schemas.fromJson(component.schema));
-                }
-                else if (component.name.startsWith('core::')) {
-                    if (component.name in componentDefinitionByName) {
-                        componentDefinition = componentDefinitionByName[component.name](engine);
-                    }
-                    else {
-                        throw new Error(`The core component ${component.name} was not found.`);
-                    }
-                }
-                else {
-                    throw new Error(`${component.name} is not defined and there is no schema to define it.`);
-                }
-            }
-            else {
-                componentDefinition = existingComponentDefinition;
-            }
+            const componentDefinition = getComponentDefinition(engine, component);
             // ## 3b ##
             // Iterating over all the entities with this component and create the replica
             for (const [entity, compositeComponentValue] of component.data) {
+                const componentValueDeserialized = getComponentValue(componentDefinition, compositeComponentValue);
                 const targetEntity = getCompositeEntity(entity);
-                const componentValue = componentDefinition.create(targetEntity, compositeComponentValue);
+                const componentValue = componentDefinition.create(targetEntity, componentValueDeserialized);
                 // ## 3c ##
                 // All entities referenced in the composite probably has a different resolved EntityNumber
                 // We'll know with the mappedEntityes
@@ -43117,6 +43776,7 @@
     exports.CRDT_MESSAGE_HEADER_LENGTH = CRDT_MESSAGE_HEADER_LENGTH;
     exports.CameraMode = CameraMode;
     exports.CameraModeArea = CameraModeArea;
+    exports.Composite = Composite;
     exports.DEG2RAD = DEG2RAD;
     exports.Dropdown = Dropdown;
     exports.Engine = Engine;
@@ -43206,6 +43866,7 @@
     exports.VisibilityComponent = VisibilityComponent;
     exports.componentDefinitionByName = componentDefinitionByName;
     exports.components = index;
+    exports.compositeFromBinary = compositeFromBinary;
     exports.compositeFromJson = compositeFromJson;
     exports.createEthereumProvider = createEthereumProvider;
     exports.createInputSystem = createInputSystem;