@codehz/ecs 0.6.8 → 0.6.10

package/world.mjs

@@ -98,16 +98,15 @@ function decodeRelationId(relationId) {
 function getIdType(id) {
 	if (isComponentId(id)) return "component";
 	if (isEntityId(id)) return "entity";
-	if (id < 0) try {
-		const decoded = decodeRelationId(id);
-		if (decoded.type !== "wildcard" && !isEntityId(decoded.targetId) && !isComponentId(decoded.targetId)) return "invalid";
-		switch (decoded.type) {
-			case "entity": return "entity-relation";
-			case "component": return "component-relation";
-			case "wildcard": return "wildcard-relation";
-		}
-	} catch (_error) {
-		return "invalid";
+	if (id < 0) {
+		const decoded = decodeRelationRaw(id);
+		if (decoded === null) return "invalid";
+		const { componentId: rawComponentId, targetId: rawTargetId } = decoded;
+		if (!isValidComponentId(rawComponentId)) return "invalid";
+		if (rawTargetId === WILDCARD_TARGET_ID) return "wildcard-relation";
+		else if (isEntityId(rawTargetId)) return "entity-relation";
+		else if (isComponentId(rawTargetId)) return "component-relation";
+		else return "invalid";
 	}
 	return "invalid";
 }
@@ -119,28 +118,29 @@ function getIdType(id) {
 function getDetailedIdType(id) {
 	if (isComponentId(id)) return { type: "component" };
 	if (isEntityId(id)) return { type: "entity" };
-	if (id < 0) try {
-		const decoded = decodeRelationId(id);
-		if (decoded.type !== "wildcard" && !isEntityId(decoded.targetId) && !isComponentId(decoded.targetId)) return { type: "invalid" };
-		let type;
-		switch (decoded.type) {
-			case "entity":
-				type = "entity-relation";
-				break;
-			case "component":
-				type = "component-relation";
-				break;
-			case "wildcard":
-				type = "wildcard-relation";
-				break;
-		}
-		return {
-			type,
-			componentId: decoded.componentId,
-			targetId: decoded.targetId
+	if (id < 0) {
+		const decoded = decodeRelationRaw(id);
+		if (decoded === null) return { type: "invalid" };
+		const { componentId: rawComponentId, targetId: rawTargetId } = decoded;
+		if (!isValidComponentId(rawComponentId)) return { type: "invalid" };
+		const componentId = rawComponentId;
+		const targetId = rawTargetId;
+		if (targetId === WILDCARD_TARGET_ID) return {
+			type: "wildcard-relation",
+			componentId,
+			targetId
 		};
-	} catch (_error) {
-		return { type: "invalid" };
+		else if (isEntityId(targetId)) return {
+			type: "entity-relation",
+			componentId,
+			targetId
+		};
+		else if (isComponentId(targetId)) return {
+			type: "component-relation",
+			componentId,
+			targetId
+		};
+		else return { type: "invalid" };
 	}
 	return { type: "invalid" };
 }
@@ -175,17 +175,18 @@ function isEntityRelation(id) {
 */
 var EntityIdManager = class {
 	nextId = ENTITY_ID_START;
-	freelist = /* @__PURE__ */ new Set();
+	/**
+	* Free list uses a stack (LIFO) for better memory locality when reusing IDs.
+	* We use an array instead of a Set for significantly better performance.
+	*/
+	freelist = [];
 	/**
 	* Allocate a new entity ID
 	* Uses freelist if available, otherwise increments counter
 	*/
 	allocate() {
-		if (this.freelist.size > 0) {
-			const id = this.freelist.values().next().value;
-			this.freelist.delete(id);
-			return id;
-		} else {
+		if (this.freelist.length > 0) return this.freelist.pop();
+		else {
 			const id = this.nextId;
 			this.nextId++;
 			if (this.nextId >= Number.MAX_SAFE_INTEGER) throw new Error("Entity ID overflow: reached maximum safe integer");
@@ -199,13 +200,13 @@ var EntityIdManager = class {
 	deallocate(id) {
 		if (!isEntityId(id)) throw new Error("Can only deallocate valid entity IDs");
 		if (id >= this.nextId) throw new Error("Cannot deallocate an ID that was never allocated");
-		this.freelist.add(id);
+		this.freelist.push(id);
 	}
 	/**
 	* Get the current freelist size (for debugging/monitoring)
 	*/
 	getFreelistSize() {
-		return this.freelist.size;
+		return this.freelist.length;
 	}
 	/**
 	* Get the next ID that would be allocated (for debugging)
@@ -230,7 +231,7 @@ var EntityIdManager = class {
 	deserializeState(state) {
 		if (typeof state.nextId !== "number") throw new Error("Invalid state for EntityIdManager.deserializeState");
 		this.nextId = state.nextId;
-		this.freelist = new Set(state.freelist || []);
+		this.freelist = state.freelist || [];
 	}
 };
 /**
@@ -368,6 +369,7 @@ const componentNames = new Array(COMPONENT_ID_MAX + 1);
 const exclusiveFlags = new BitSet(COMPONENT_ID_MAX + 1);
 const cascadeDeleteFlags = new BitSet(COMPONENT_ID_MAX + 1);
 const dontFragmentFlags = new BitSet(COMPONENT_ID_MAX + 1);
+const componentMerges = new Array(COMPONENT_ID_MAX + 1);
 /**
 * Allocate a new component ID from the global allocator.
 * @param nameOrOptions Optional name for the component (for serialization/debugging) or options object
@@ -400,6 +402,7 @@ function component(nameOrOptions) {
 		if (options.exclusive) exclusiveFlags.set(id);
 		if (options.cascadeDelete) cascadeDeleteFlags.set(id);
 		if (options.dontFragment) dontFragmentFlags.set(id);
+		if (options.merge) componentMerges[id] = options.merge;
 	}
 	return id;
 }
@@ -418,6 +421,21 @@ function getComponentIdByName(name) {
 function getComponentNameById(id) {
 	return componentNames[id];
 }
+function getBaseComponentId(componentType) {
+	if (isComponentId(componentType)) return componentType;
+	const decoded = decodeRelationRaw(componentType);
+	if (decoded === null) return void 0;
+	return isValidComponentId(decoded.componentId) ? decoded.componentId : void 0;
+}
+/**
+* Get merge callback for a componentType (including relation component types).
+* Returns undefined if the base component has no merge callback.
+*/
+function getComponentMerge(componentType) {
+	const baseComponentId = getBaseComponentId(componentType);
+	if (baseComponentId === void 0) return void 0;
+	return componentMerges[baseComponentId];
+}
 /**
 * Check if a component is marked as exclusive
 * @param id The component ID
@@ -627,10 +645,17 @@ var ComponentChangeset = class {
 //#endregion
 //#region src/commands/command-buffer.ts
 /**
+* Maximum number of command buffer execution iterations to prevent infinite loops
+*/
+const MAX_COMMAND_ITERATIONS = 100;
+/**
 * Command buffer for deferred structural changes
 */
 var CommandBuffer = class {
 	commands = [];
+	swapBuffer = [];
+	/** Reusable map to group commands by entity, avoids per-sync allocations */
+	entityCommands = /* @__PURE__ */ new Map();
 	executeEntityCommands;
 	/**
 	* Create a command buffer with an executor function
@@ -669,19 +694,22 @@ var CommandBuffer = class {
 	* Execute all commands and clear the buffer
 	*/
 	execute() {
-		const MAX_ITERATIONS = 100;
 		let iterations = 0;
 		while (this.commands.length > 0) {
-			if (iterations >= MAX_ITERATIONS) throw new Error("Command execution exceeded maximum iterations, possible infinite loop");
+			if (iterations >= MAX_COMMAND_ITERATIONS) throw new Error("Command execution exceeded maximum iterations, possible infinite loop");
 			iterations++;
-			const currentCommands = [...this.commands];
-			this.commands = [];
-			const entityCommands = /* @__PURE__ */ new Map();
+			const currentCommands = this.commands;
+			this.commands = this.swapBuffer;
+			const entityCommands = this.entityCommands;
 			for (const cmd of currentCommands) {
-				if (!entityCommands.has(cmd.entityId)) entityCommands.set(cmd.entityId, []);
-				entityCommands.get(cmd.entityId).push(cmd);
+				const existing = entityCommands.get(cmd.entityId);
+				if (existing !== void 0) existing.push(cmd);
+				else entityCommands.set(cmd.entityId, [cmd]);
 			}
+			currentCommands.length = 0;
+			this.swapBuffer = currentCommands;
 			for (const [entityId, commands] of entityCommands) this.executeEntityCommands(entityId, commands);
+			entityCommands.clear();
 		}
 	}
 	/**
@@ -721,8 +749,8 @@ function matchesComponentTypes(archetype, componentTypes) {
 		});
 		else if ((detailedType.type === "entity-relation" || detailedType.type === "component-relation") && detailedType.componentId !== void 0 && isDontFragmentComponent(detailedType.componentId)) {
 			const wildcardMarker = relation(detailedType.componentId, "*");
-			return archetype.componentTypes.includes(wildcardMarker);
-		} else return archetype.componentTypes.includes(type);
+			return archetype.componentTypeSet.has(wildcardMarker);
+		} else return archetype.componentTypeSet.has(type);
 	});
 }
 /**
@@ -735,10 +763,20 @@ function matchesFilter(archetype, filter) {
 			if (!isRelationId(archetypeType)) return false;
 			return getComponentIdFromRelationId(archetypeType) === detailedType.componentId;
 		});
-		else return !archetype.componentTypes.includes(type);
+		else return !archetype.componentTypeSet.has(type);
 	});
 }
 
+//#endregion
+//#region src/core/component-type-utils.ts
+/**
+* Normalize component type collections into a stable ascending order.
+* This keeps cache keys and archetype signatures deterministic.
+*/
+function normalizeComponentTypes(componentTypes) {
+	return [...componentTypes].sort((a, b) => a - b);
+}
+
 //#endregion
 //#region src/query/query.ts
 /**
@@ -750,13 +788,15 @@ var Query = class {
 	filter;
 	cachedArchetypes = [];
 	isDisposed = false;
+	/** Cache key assigned by World for O(1) releaseQuery lookup */
+	_cacheKey;
 	/** Cached wildcard component types for faster entity filtering */
 	wildcardTypes;
 	/** Cached specific dontFragment relation types that need entity-level filtering */
 	specificDontFragmentTypes;
 	constructor(world, componentTypes, filter = {}) {
 		this.world = world;
-		this.componentTypes = [...componentTypes].sort((a, b) => a - b);
+		this.componentTypes = normalizeComponentTypes(componentTypes);
 		this.filter = filter;
 		this.wildcardTypes = this.componentTypes.filter((ct) => getDetailedIdType(ct).type === "wildcard-relation");
 		this.specificDontFragmentTypes = this.componentTypes.filter((ct) => {
@@ -903,10 +943,10 @@ var Query = class {
 * Get a value from cache or compute and cache it if not present
 * @param cache The cache map
 * @param key The cache key
-* @param compute Function to compute the value if not cached
+* @param compute Function to compute the value if not cached (may have side effects)
 * @returns The cached or computed value
 */
-function getOrComputeCache(cache, key, compute) {
+function getOrCompute(cache, key, compute) {
 	let value = cache.get(key);
 	if (value === void 0) {
 		value = compute();
@@ -914,21 +954,6 @@ function getOrComputeCache(cache, key, compute) {
 	}
 	return value;
 }
-/**
-* Get a value from cache or create and cache it if not present, allowing side effects during creation
-* @param cache The cache map
-* @param key The cache key
-* @param create Function to create the value if not cached (can have side effects)
-* @returns The cached or created value
-*/
-function getOrCreateWithSideEffect(cache, key, create) {
-	let value = cache.get(key);
-	if (value === void 0) {
-		value = create();
-		cache.set(key, value);
-	}
-	return value;
-}
 
 //#endregion
 //#region src/core/types.ts
@@ -939,6 +964,18 @@ function isOptionalEntityId(type) {
 //#endregion
 //#region src/core/archetype-helpers.ts
 /**
+* Check if a components map has any wildcard relations matching a component ID
+* @param components - Component entity's components map
+* @param wildcardComponentId - The component ID to match
+* @returns True if at least one matching relation exists
+*/
+function hasWildcardRelation(components, wildcardComponentId) {
+	for (const relId of components.keys()) if (isRelationId(relId)) {
+		if (getComponentIdFromRelationId(relId) === wildcardComponentId) return true;
+	}
+	return false;
+}
+/**
 * Check if a detailed type represents a relation (entity or component)
 */
 function isRelationType(detailedType) {
@@ -1036,6 +1073,10 @@ var Archetype = class {
 	*/
 	componentTypes;
 	/**
+	* Set version of componentTypes for O(1) lookups in hot paths
+	*/
+	componentTypeSet;
+	/**
 	* List of entities in this archetype
 	*/
 	entities = [];
@@ -1055,9 +1096,6 @@ var Archetype = class {
 	*/
 	dontFragmentRelations;
 	/**
-	* Cache for pre-computed component data sources to avoid repeated calculations
-	*/
-	/**
 	* Multi-hooks that match this archetype
 	*/
 	matchingMultiHooks = /* @__PURE__ */ new Set();
@@ -1066,16 +1104,23 @@ var Archetype = class {
 	*/
 	componentDataSourcesCache = /* @__PURE__ */ new Map();
 	constructor(componentTypes, dontFragmentRelations) {
-		this.componentTypes = [...componentTypes].sort((a, b) => a - b);
+		this.componentTypes = normalizeComponentTypes(componentTypes);
+		this.componentTypeSet = new Set(this.componentTypes);
 		this.dontFragmentRelations = dontFragmentRelations;
 		for (const componentType of this.componentTypes) this.componentData.set(componentType, []);
 	}
 	get size() {
 		return this.entities.length;
 	}
+	/**
+	* Check if the given component types match this archetype
+	* @param componentTypes - Component types to check (can be in any order)
+	* @returns true if the types match this archetype's component set
+	* @note This method handles unsorted input by internally sorting for comparison
+	*/
 	matches(componentTypes) {
 		if (this.componentTypes.length !== componentTypes.length) return false;
-		const sortedTypes = [...componentTypes].sort((a, b) => a - b);
+		const sortedTypes = normalizeComponentTypes(componentTypes);
 		return this.componentTypes.every((type, index) => type === sortedTypes[index]);
 	}
 	addEntity(entityId, componentData) {
@@ -1092,7 +1137,7 @@ var Archetype = class {
 	addDontFragmentRelations(entityId, componentData) {
 		const dontFragmentData = /* @__PURE__ */ new Map();
 		for (const [componentType, data] of componentData) {
-			if (this.componentTypes.includes(componentType)) continue;
+			if (this.componentTypeSet.has(componentType)) continue;
 			const detailedType = getDetailedIdType(componentType);
 			if (isRelationType(detailedType) && isDontFragmentComponent(detailedType.componentId)) dontFragmentData.set(componentType, data);
 		}
@@ -1110,6 +1155,9 @@ var Archetype = class {
 		if (dontFragmentData) for (const [componentType, data] of dontFragmentData) entityData.set(componentType, data);
 		return entityData;
 	}
+	getEntityDontFragmentRelations(entityId) {
+		return this.dontFragmentRelations.get(entityId);
+	}
 	dump() {
 		return this.entities.map((entity, i) => {
 			const components = /* @__PURE__ */ new Map();
@@ -1176,7 +1224,7 @@ var Archetype = class {
 		return relations;
 	}
 	getRegularComponent(entityId, index, componentType) {
-		if (this.componentTypes.includes(componentType)) {
+		if (this.componentTypeSet.has(componentType)) {
 			const data = this.getComponentData(componentType)[index];
 			if (data === MISSING_COMPONENT) throw new Error(`Component type ${componentType} not found for entity ${entityId}`);
 			return data;
@@ -1188,7 +1236,7 @@ var Archetype = class {
 	getOptional(entityId, componentType) {
 		const index = this.entityToIndex.get(entityId);
 		if (index === void 0) throw new Error(`Entity ${entityId} is not in this archetype`);
-		if (this.componentTypes.includes(componentType)) {
+		if (this.componentTypeSet.has(componentType)) {
 			const data = this.getComponentData(componentType)[index];
 			if (data === MISSING_COMPONENT) return void 0;
 			return { value: data };
@@ -1231,7 +1279,7 @@ var Archetype = class {
 	}
 	getCachedComponentDataSources(componentTypes) {
 		const cacheKey = buildCacheKey(componentTypes);
-		return getOrComputeCache(this.componentDataSourcesCache, cacheKey, () => componentTypes.map((compType) => this.getComponentDataSource(compType)));
+		return getOrCompute(this.componentDataSourcesCache, cacheKey, () => componentTypes.map((compType) => this.getComponentDataSource(compType)));
 	}
 	getComponentDataSource(compType) {
 		const optional = isOptionalEntityId(compType);
@@ -1376,8 +1424,8 @@ function decodeSerializedId(sid) {
 //#endregion
 //#region src/core/world-commands.ts
 function processCommands(entityId, currentArchetype, commands, changeset, handleExclusiveRelation) {
-	for (const command of commands) if (command.type === "set" && command.componentType) processSetCommand(entityId, currentArchetype, command.componentType, command.component, changeset, handleExclusiveRelation);
-	else if (command.type === "delete" && command.componentType) processDeleteCommand(entityId, currentArchetype, command.componentType, changeset);
+	for (const command of commands) if (command.type === "set") processSetCommand(entityId, currentArchetype, command.componentType, command.component, changeset, handleExclusiveRelation);
+	else if (command.type === "delete") processDeleteCommand(entityId, currentArchetype, command.componentType, changeset);
 }
 function processSetCommand(entityId, currentArchetype, componentType, component$1, changeset, handleExclusiveRelation) {
 	const componentId = getComponentIdFromRelationId(componentType);
@@ -1385,9 +1433,15 @@ function processSetCommand(entityId, currentArchetype, componentType, component$
 		handleExclusiveRelation(entityId, currentArchetype, componentId);
 		if (isDontFragmentComponent(componentId)) {
 			const wildcardMarker = relation(componentId, "*");
-			if (!currentArchetype.componentTypes.includes(wildcardMarker)) changeset.set(wildcardMarker, void 0);
+			if (!currentArchetype.componentTypeSet.has(wildcardMarker)) changeset.set(wildcardMarker, void 0);
 		}
 	}
+	const merge = getComponentMerge(componentType);
+	if (merge !== void 0 && changeset.adds.has(componentType)) {
+		const prev = changeset.adds.get(componentType);
+		changeset.set(componentType, merge(prev, component$1));
+		return;
+	}
 	changeset.set(componentType, component$1);
 }
 function processDeleteCommand(entityId, currentArchetype, componentType, changeset) {
@@ -1403,10 +1457,9 @@ function removeMatchingRelations(entityId, archetype, baseComponentId, changeset
 		if (isWildcardRelationId(componentType)) continue;
 		if (getComponentIdFromRelationId(componentType) === baseComponentId) changeset.delete(componentType);
 	}
-	const entityData = archetype.getEntity(entityId);
-	if (entityData) for (const [componentType] of entityData) {
-		if (archetype.componentTypes.includes(componentType)) continue;
-		if (getComponentIdFromRelationId(componentType) === baseComponentId) changeset.delete(componentType);
+	const dontFragmentData = archetype.getEntityDontFragmentRelations(entityId);
+	if (dontFragmentData) {
+		for (const componentType of dontFragmentData.keys()) if (getComponentIdFromRelationId(componentType) === baseComponentId) changeset.delete(componentType);
 	}
 }
 function removeWildcardRelations(entityId, currentArchetype, baseComponentId, changeset) {
@@ -1416,35 +1469,66 @@ function removeWildcardRelations(entityId, currentArchetype, baseComponentId, ch
 function maybeRemoveWildcardMarker(entityId, archetype, removedComponentType, componentId, changeset) {
 	if (componentId === void 0 || !isDontFragmentComponent(componentId)) return;
 	const wildcardMarker = relation(componentId, "*");
-	const entityData = archetype.getEntity(entityId);
-	if (!entityData) {
-		changeset.delete(wildcardMarker);
-		return;
-	}
-	for (const [otherComponentType] of entityData) {
+	for (const otherComponentType of archetype.componentTypes) {
 		if (otherComponentType === removedComponentType) continue;
 		if (otherComponentType === wildcardMarker) continue;
 		if (changeset.removes.has(otherComponentType)) continue;
 		if (getComponentIdFromRelationId(otherComponentType) === componentId) return;
 	}
+	const dontFragmentData = archetype.getEntityDontFragmentRelations(entityId);
+	if (dontFragmentData) for (const otherComponentType of dontFragmentData.keys()) {
+		if (otherComponentType === removedComponentType) continue;
+		if (changeset.removes.has(otherComponentType)) continue;
+		if (getComponentIdFromRelationId(otherComponentType) === componentId) return;
+	}
 	changeset.delete(wildcardMarker);
 }
+function hasEntityComponent(archetype, entityId, componentType) {
+	if (archetype.componentTypeSet.has(componentType)) return true;
+	return archetype.getEntityDontFragmentRelations(entityId)?.has(componentType) ?? false;
+}
+function pruneMissingRemovals(changeset, archetype, entityId) {
+	let toPrune;
+	for (const componentType of changeset.removes) if (!hasEntityComponent(archetype, entityId, componentType)) {
+		if (toPrune === void 0) toPrune = [];
+		toPrune.push(componentType);
+	}
+	if (toPrune !== void 0) for (const componentType of toPrune) changeset.removes.delete(componentType);
+}
+function hasArchetypeStructuralChange(changeset, currentArchetype) {
+	for (const componentType of changeset.removes) if (!isDontFragmentRelation(componentType) && currentArchetype.componentTypeSet.has(componentType)) return true;
+	for (const componentType of changeset.adds.keys()) if (!isDontFragmentRelation(componentType) && !currentArchetype.componentTypeSet.has(componentType)) return true;
+	return false;
+}
+function buildFinalRegularComponentTypes(currentArchetype, changeset) {
+	const finalRegularTypes = new Set(currentArchetype.componentTypes);
+	for (const componentType of changeset.removes) if (!isDontFragmentRelation(componentType)) finalRegularTypes.delete(componentType);
+	for (const componentType of changeset.adds.keys()) if (!isDontFragmentRelation(componentType)) finalRegularTypes.add(componentType);
+	return Array.from(finalRegularTypes);
+}
 function applyChangeset(ctx, entityId, currentArchetype, changeset, entityToArchetype) {
-	const currentEntityData = currentArchetype.getEntity(entityId);
-	const allCurrentComponentTypes = currentEntityData ? Array.from(currentEntityData.keys()) : currentArchetype.componentTypes;
-	const finalComponentTypes = changeset.getFinalComponentTypes(allCurrentComponentTypes);
 	const removedComponents = /* @__PURE__ */ new Map();
-	if (finalComponentTypes) if (!areComponentTypesEqual(filterRegularComponentTypes(allCurrentComponentTypes), filterRegularComponentTypes(finalComponentTypes))) return {
+	pruneMissingRemovals(changeset, currentArchetype, entityId);
+	if (hasArchetypeStructuralChange(changeset, currentArchetype)) return {
 		removedComponents,
-		newArchetype: moveEntityToNewArchetype(ctx, entityId, currentArchetype, finalComponentTypes, changeset, removedComponents, entityToArchetype)
+		newArchetype: moveEntityToNewArchetype(ctx, entityId, currentArchetype, buildFinalRegularComponentTypes(currentArchetype, changeset), changeset, removedComponents, entityToArchetype)
 	};
-	else updateEntityInSameArchetype(ctx, entityId, currentArchetype, changeset, removedComponents);
-	else updateEntityInSameArchetype(ctx, entityId, currentArchetype, changeset, removedComponents);
+	updateEntityInSameArchetype(ctx, entityId, currentArchetype, changeset, removedComponents);
 	return {
 		removedComponents,
 		newArchetype: currentArchetype
 	};
 }
+/**
+* Optimized variant of applyChangeset for when no lifecycle hooks are registered.
+* Skips creating the removedComponents map, reducing allocations in the hot path.
+*/
+function applyChangesetNoHooks(ctx, entityId, currentArchetype, changeset, entityToArchetype) {
+	pruneMissingRemovals(changeset, currentArchetype, entityId);
+	if (hasArchetypeStructuralChange(changeset, currentArchetype)) return moveEntityToNewArchetypeNoHooks(ctx, entityId, currentArchetype, buildFinalRegularComponentTypes(currentArchetype, changeset), changeset, entityToArchetype);
+	updateEntityInSameArchetypeNoHooks(ctx, entityId, currentArchetype, changeset);
+	return currentArchetype;
+}
 function moveEntityToNewArchetype(ctx, entityId, currentArchetype, finalComponentTypes, changeset, removedComponents, entityToArchetype) {
 	const newArchetype = ctx.ensureArchetype(finalComponentTypes);
 	const currentComponents = currentArchetype.removeEntity(entityId);
@@ -1460,6 +1544,28 @@ function updateEntityInSameArchetype(ctx, entityId, currentArchetype, changeset,
 		currentArchetype.set(entityId, componentType, component$1);
 	}
 }
+/**
+* No-hooks variant: moves entity to new archetype without collecting removed component data.
+* Only called from applyChangesetNoHooks when no lifecycle hooks are registered.
+*/
+function moveEntityToNewArchetypeNoHooks(ctx, entityId, currentArchetype, finalComponentTypes, changeset, entityToArchetype) {
+	const newArchetype = ctx.ensureArchetype(finalComponentTypes);
+	const currentComponents = currentArchetype.removeEntity(entityId);
+	newArchetype.addEntity(entityId, changeset.applyTo(currentComponents));
+	entityToArchetype.set(entityId, newArchetype);
+	return newArchetype;
+}
+/**
+* No-hooks variant: updates entity in same archetype without tracking removed component data.
+* Only called from applyChangesetNoHooks when no lifecycle hooks are registered.
+*/
+function updateEntityInSameArchetypeNoHooks(ctx, entityId, currentArchetype, changeset) {
+	applyDontFragmentChangesNoHooks(ctx.dontFragmentRelations, entityId, changeset);
+	for (const [componentType, component$1] of changeset.adds) {
+		if (isDontFragmentRelation(componentType)) continue;
+		currentArchetype.set(entityId, componentType, component$1);
+	}
+}
 function applyDontFragmentChanges(dontFragmentRelations, entityId, changeset, removedComponents) {
 	let entityRelations = dontFragmentRelations.get(entityId);
 	for (const componentType of changeset.removes) if (isDontFragmentRelation(componentType)) {
@@ -1480,6 +1586,23 @@ function applyDontFragmentChanges(dontFragmentRelations, entityId, changeset, re
 	}
 	if (entityRelations && entityRelations.size === 0) dontFragmentRelations.delete(entityId);
 }
+/**
+* No-hooks variant of applyDontFragmentChanges that skips tracking removed component data.
+*/
+function applyDontFragmentChangesNoHooks(dontFragmentRelations, entityId, changeset) {
+	let entityRelations = dontFragmentRelations.get(entityId);
+	for (const componentType of changeset.removes) if (isDontFragmentRelation(componentType)) {
+		if (entityRelations) entityRelations.delete(componentType);
+	}
+	for (const [componentType, component$1] of changeset.adds) if (isDontFragmentRelation(componentType)) {
+		if (!entityRelations) {
+			entityRelations = /* @__PURE__ */ new Map();
+			dontFragmentRelations.set(entityId, entityRelations);
+		}
+		entityRelations.set(componentType, component$1);
+	}
+	if (entityRelations && entityRelations.size === 0) dontFragmentRelations.delete(entityId);
+}
 function filterRegularComponentTypes(componentTypes) {
 	const regularTypes = [];
 	for (const componentType of componentTypes) {
@@ -1492,12 +1615,6 @@ function filterRegularComponentTypes(componentTypes) {
 	}
 	return regularTypes;
 }
-function areComponentTypesEqual(types1, types2) {
-	if (types1.length !== types2.length) return false;
-	const sorted1 = [...types1].sort((a, b) => a - b);
-	const sorted2 = [...types2].sort((a, b) => a - b);
-	return sorted1.every((v, i) => v === sorted2[i]);
-}
 
 //#endregion
 //#region src/core/world-hooks.ts
@@ -1579,11 +1696,11 @@ function triggerMultiComponentHooks(ctx, entityId, addedComponents, removedCompo
 }
 function entityHasAllComponents(ctx, entityId, requiredComponents) {
 	return requiredComponents.every((c) => {
-		if (isWildcardRelationId(c)) try {
-			const wildcardData = ctx.get(entityId, c);
+		if (isWildcardRelationId(c)) {
+			const wildcardResult = ctx.getOptional(entityId, c);
+			if (!wildcardResult) return false;
+			const wildcardData = wildcardResult.value;
 			return Array.isArray(wildcardData) && wildcardData.length > 0;
-		} catch {
-			return false;
 		}
 		return ctx.has(entityId, c);
 	});
@@ -1591,11 +1708,11 @@ function entityHasAllComponents(ctx, entityId, requiredComponents) {
 function entityHadAllComponentsBefore(ctx, entityId, requiredComponents, removedComponents) {
 	return requiredComponents.every((c) => {
 		if (anyComponentMatches(removedComponents, c)) return true;
-		if (isWildcardRelationId(c)) try {
-			const wildcardData = ctx.get(entityId, c);
+		if (isWildcardRelationId(c)) {
+			const wildcardResult = ctx.getOptional(entityId, c);
+			if (!wildcardResult) return false;
+			const wildcardData = wildcardResult.value;
 			return Array.isArray(wildcardData) && wildcardData.length > 0;
-		} catch {
-			return false;
 		}
 		return ctx.has(entityId, c);
 	});
@@ -1770,9 +1887,23 @@ var World = class {
 	relationEntityIdsByTarget = /* @__PURE__ */ new Map();
 	queries = [];
 	queryCache = /* @__PURE__ */ new Map();
-	commandBuffer = new CommandBuffer((entityId, commands) => this.executeEntityCommands(entityId, commands));
 	legacyHooks = /* @__PURE__ */ new Map();
 	hooks = /* @__PURE__ */ new Set();
+	commandBuffer = new CommandBuffer((entityId, commands) => this.executeEntityCommands(entityId, commands));
+	_changeset = new ComponentChangeset();
+	/** Cached command processor context to avoid per-entity object allocation */
+	_commandCtx = {
+		dontFragmentRelations: this.dontFragmentRelations,
+		ensureArchetype: (ct) => this.ensureArchetype(ct)
+	};
+	/** Cached hooks context to avoid per-entity object allocation */
+	_hooksCtx = {
+		hooks: this.legacyHooks,
+		multiHooks: this.hooks,
+		has: (eid, ct) => this.has(eid, ct),
+		get: (eid, ct) => this.get(eid, ct),
+		getOptional: (eid, ct) => this.getOptional(eid, ct)
+	};
 	constructor(snapshot) {
 		if (snapshot && typeof snapshot === "object") this.deserializeSnapshot(snapshot);
 	}
@@ -1879,8 +2010,9 @@ var World = class {
 	destroyEntityImmediate(entityId) {
 		const queue = [entityId];
 		const visited = /* @__PURE__ */ new Set();
-		while (queue.length > 0) {
-			const cur = queue.shift();
+		let queueIndex = 0;
+		while (queueIndex < queue.length) {
+			const cur = queue[queueIndex++];
 			if (visited.has(cur)) continue;
 			visited.add(cur);
 			const archetype = this.entityToArchetype.get(cur);
@@ -1915,40 +2047,77 @@ var World = class {
 		if (this.isComponentEntityId(entityId)) return true;
 		return this.entityToArchetype.has(entityId);
 	}
-	set(entityId, componentTypeOrComponent, maybeComponent) {
+	assertEntityExists(entityId, label) {
+		if (!this.exists(entityId)) throw new Error(`${label} ${entityId} does not exist`);
+	}
+	assertComponentTypeValid(componentType) {
+		if (getDetailedIdType(componentType).type === "invalid") throw new Error(`Invalid component type: ${componentType}`);
+	}
+	assertSetComponentTypeValid(componentType) {
+		const detailedType = getDetailedIdType(componentType);
+		if (detailedType.type === "invalid") throw new Error(`Invalid component type: ${componentType}`);
+		if (detailedType.type === "wildcard-relation") throw new Error(`Cannot directly add wildcard relation components: ${componentType}`);
+	}
+	resolveSetOperation(entityId, componentTypeOrComponent, maybeComponent) {
 		if (maybeComponent === void 0 && componentTypeOrComponent !== void 0) {
-			const detailedType$1 = getDetailedIdType(entityId);
-			if (detailedType$1.type === "component" || detailedType$1.type === "component-relation") {
+			const detailedType = getDetailedIdType(entityId);
+			if (detailedType.type === "component" || detailedType.type === "component-relation") {
 				const componentId = entityId;
-				const component$2 = componentTypeOrComponent;
-				if (!this.exists(componentId)) throw new Error(`Component entity ${componentId} does not exist`);
-				const detailedComponentType = getDetailedIdType(componentId);
-				if (detailedComponentType.type === "invalid") throw new Error(`Invalid component type: ${componentId}`);
-				if (detailedComponentType.type === "wildcard-relation") throw new Error(`Cannot directly add wildcard relation components: ${componentId}`);
-				this.commandBuffer.set(componentId, componentId, component$2);
-				return;
+				this.assertEntityExists(componentId, "Component entity");
+				this.assertSetComponentTypeValid(componentId);
+				return {
+					entityId: componentId,
+					componentType: componentId,
+					component: componentTypeOrComponent
+				};
 			}
 		}
-		const entityIdArg = entityId;
+		const targetEntityId = entityId;
 		const componentType = componentTypeOrComponent;
-		const component$1 = maybeComponent;
-		if (!this.exists(entityIdArg)) throw new Error(`Entity ${entityIdArg} does not exist`);
-		const detailedType = getDetailedIdType(componentType);
-		if (detailedType.type === "invalid") throw new Error(`Invalid component type: ${componentType}`);
-		if (detailedType.type === "wildcard-relation") throw new Error(`Cannot directly add wildcard relation components: ${componentType}`);
-		this.commandBuffer.set(entityIdArg, componentType, component$1);
+		this.assertEntityExists(targetEntityId, "Entity");
+		this.assertSetComponentTypeValid(componentType);
+		return {
+			entityId: targetEntityId,
+			componentType,
+			component: maybeComponent
+		};
 	}
-	remove(entityId, componentType) {
+	resolveRemoveOperation(entityId, componentType) {
 		if (componentType === void 0) {
 			const componentId = entityId;
-			if (!this.exists(componentId)) throw new Error(`Component entity ${componentId} does not exist`);
-			this.commandBuffer.remove(componentId, componentId);
-			return;
+			this.assertEntityExists(componentId, "Component entity");
+			return {
+				entityId: componentId,
+				componentType: componentId
+			};
 		}
-		const entityIdArg = entityId;
-		if (!this.exists(entityIdArg)) throw new Error(`Entity ${entityIdArg} does not exist`);
-		if (getDetailedIdType(componentType).type === "invalid") throw new Error(`Invalid component type: ${componentType}`);
-		this.commandBuffer.remove(entityIdArg, componentType);
+		const targetEntityId = entityId;
+		this.assertEntityExists(targetEntityId, "Entity");
+		this.assertComponentTypeValid(componentType);
+		return {
+			entityId: targetEntityId,
+			componentType
+		};
+	}
+	getComponentEntityWildcardRelations(entityId, wildcardComponentType) {
+		const componentId = getComponentIdFromRelationId(wildcardComponentType);
+		const data = this.componentEntityComponents.get(entityId);
+		if (componentId === void 0 || !data) return [];
+		const relations = [];
+		for (const [key, value] of data.entries()) {
+			if (getComponentIdFromRelationId(key) !== componentId) continue;
+			const detailed = getDetailedIdType(key);
+			if (detailed.type === "entity-relation" || detailed.type === "component-relation") relations.push([detailed.targetId, value]);
+		}
+		return relations;
+	}
+	set(entityId, componentTypeOrComponent, maybeComponent) {
+		const { entityId: targetEntityId, componentType, component: component$1 } = this.resolveSetOperation(entityId, componentTypeOrComponent, maybeComponent);
+		this.commandBuffer.set(targetEntityId, componentType, component$1);
+	}
+	remove(entityId, componentType) {
+		const { entityId: targetEntityId, componentType: targetComponentType } = this.resolveRemoveOperation(entityId, componentType);
+		this.commandBuffer.remove(targetEntityId, targetComponentType);
 	}
 	/**
 	* Deletes an entity and all its components from the world.
@@ -1975,39 +2144,27 @@ var World = class {
 				if (componentId === void 0) return false;
 				const data = this.componentEntityComponents.get(entityId);
 				if (!data) return false;
-				for (const key of data.keys()) if (getComponentIdFromRelationId(key) === componentId) return true;
-				return false;
+				return hasWildcardRelation(data, componentId);
 			}
 			return this.componentEntityComponents.get(entityId)?.has(componentType) ?? false;
 		}
 		const archetype = this.entityToArchetype.get(entityId);
 		if (!archetype) return false;
-		if (archetype.componentTypes.includes(componentType)) return true;
+		if (archetype.componentTypeSet.has(componentType)) return true;
 		if (isDontFragmentRelation(componentType)) return this.dontFragmentRelations.get(entityId)?.has(componentType) ?? false;
 		return false;
 	}
 	get(entityId, componentType = entityId) {
 		if (this.isComponentEntityId(entityId)) {
-			if (isWildcardRelationId(componentType)) {
-				const componentId = getComponentIdFromRelationId(componentType);
-				const data$1 = this.componentEntityComponents.get(entityId);
-				const relations = [];
-				if (componentId !== void 0 && data$1) {
-					for (const [key, value] of data$1.entries()) if (getComponentIdFromRelationId(key) === componentId) {
-						const detailed = getDetailedIdType(key);
-						if (detailed.type === "entity-relation" || detailed.type === "component-relation") relations.push([detailed.targetId, value]);
-					}
-				}
-				return relations;
-			}
+			if (isWildcardRelationId(componentType)) return this.getComponentEntityWildcardRelations(entityId, componentType);
 			const data = this.componentEntityComponents.get(entityId);
 			if (!data || !data.has(componentType)) throw new Error(`Entity ${entityId} does not have component ${componentType}. Use has() to check component existence before calling get().`);
 			return data.get(componentType);
 		}
 		const archetype = this.entityToArchetype.get(entityId);
 		if (!archetype) throw new Error(`Entity ${entityId} does not exist`);
-		if (componentType >= 0 || componentType % 2 ** 42 !== 0) {
-			const inArchetype = archetype.componentTypes.includes(componentType);
+		if (componentType >= 0 || componentType % RELATION_SHIFT !== 0) {
+			const inArchetype = archetype.componentTypeSet.has(componentType);
 			const hasDontFragment = isDontFragmentRelation(componentType);
 			if (!(inArchetype || hasDontFragment && this.dontFragmentRelations.get(entityId)?.has(componentType))) throw new Error(`Entity ${entityId} does not have component ${componentType}. Use has() to check component existence before calling get().`);
 		}
@@ -2016,15 +2173,7 @@ var World = class {
 	getOptional(entityId, componentType = entityId) {
 		if (this.isComponentEntityId(entityId)) {
 			if (isWildcardRelationId(componentType)) {
-				const componentId = getComponentIdFromRelationId(componentType);
-				if (componentId === void 0) return void 0;
-				const data$1 = this.componentEntityComponents.get(entityId);
-				if (!data$1) return void 0;
-				const relations = [];
-				for (const [key, value] of data$1.entries()) if (getComponentIdFromRelationId(key) === componentId) {
-					const detailed = getDetailedIdType(key);
-					if (detailed.type === "entity-relation" || detailed.type === "component-relation") relations.push([detailed.targetId, value]);
-				}
+				const relations = this.getComponentEntityWildcardRelations(entityId, componentType);
 				if (relations.length === 0) return void 0;
 				return { value: relations };
 			}
@@ -2166,7 +2315,7 @@ var World = class {
 	* });
 	*/
 	createQuery(componentTypes, filter = {}) {
-		const sortedTypes = [...componentTypes].sort((a, b) => a - b);
+		const sortedTypes = normalizeComponentTypes(componentTypes);
 		const filterKey = serializeQueryFilter(filter);
 		const key = `${this.createArchetypeSignature(sortedTypes)}${filterKey ? `|${filterKey}` : ""}`;
 		const cached = this.queryCache.get(key);
@@ -2175,6 +2324,7 @@ var World = class {
 			return cached.query;
 		}
 		const query = new Query(this, sortedTypes, filter);
+		query._cacheKey = key;
 		this.queryCache.set(key, {
 			query,
 			refCount: 1
@@ -2240,14 +2390,15 @@ var World = class {
 	* world.releaseQuery(query); // Optional cleanup
 	*/
 	releaseQuery(query) {
-		for (const [k, v] of this.queryCache.entries()) if (v.query === query) {
-			v.refCount--;
-			if (v.refCount <= 0) {
-				this.queryCache.delete(k);
-				this._unregisterQuery(query);
-				v.query._disposeInternal();
-			}
-			return;
+		const key = query._cacheKey;
+		if (!key) return;
+		const cached = this.queryCache.get(key);
+		if (!cached || cached.query !== query) return;
+		cached.refCount--;
+		if (cached.refCount <= 0) {
+			this.queryCache.delete(key);
+			this._unregisterQuery(query);
+			cached.query._disposeInternal();
 		}
 	}
 	/**
@@ -2279,8 +2430,21 @@ var World = class {
 	getArchetypesWithComponents(componentTypes) {
 		if (componentTypes.length === 0) return [...this.archetypes];
 		if (componentTypes.length === 1) return this.archetypesByComponent.get(componentTypes[0]) || [];
-		const archetypeLists = componentTypes.map((type) => this.archetypesByComponent.get(type) || []);
-		return archetypeLists[0].filter((archetype) => archetypeLists.slice(1).every((list) => list.includes(archetype)));
+		const archetypeLists = componentTypes.map((type) => this.archetypesByComponent.get(type) || []).sort((a, b) => a.length - b.length);
+		const shortest = archetypeLists[0];
+		if (shortest.length === 0) return [];
+		if (archetypeLists.length === 2) {
+			const second = archetypeLists[1];
+			const secondSet = new Set(second);
+			return shortest.filter((a) => secondSet.has(a));
+		}
+		let result = new Set(shortest);
+		for (let i = 1; i < archetypeLists.length; i++) {
+			const listSet = new Set(archetypeLists[i]);
+			for (const item of result) if (!listSet.has(item)) result.delete(item);
+			if (result.size === 0) return [];
+		}
+		return Array.from(result);
 	}
 	query(componentTypes, includeComponents) {
 		const matchingArchetypes = this.getMatchingArchetypes(componentTypes);
@@ -2295,7 +2459,8 @@ var World = class {
 		}
 	}
 	executeEntityCommands(entityId, commands) {
-		const changeset = new ComponentChangeset();
+		const changeset = this._changeset;
+		changeset.clear();
 		if (this.isComponentEntityId(entityId)) {
 			this.executeComponentEntityCommands(entityId, commands);
 			return changeset;
@@ -2309,11 +2474,15 @@ var World = class {
 		processCommands(entityId, currentArchetype, commands, changeset, (eid, arch, compId) => {
 			if (isExclusiveComponent(compId)) removeMatchingRelations(eid, arch, compId, changeset);
 		});
-		const { removedComponents, newArchetype } = applyChangeset({
-			dontFragmentRelations: this.dontFragmentRelations,
-			ensureArchetype: (ct) => this.ensureArchetype(ct)
-		}, entityId, currentArchetype, changeset, this.entityToArchetype);
-		this.updateEntityReferences(entityId, changeset);
+		const hasHooks = this.legacyHooks.size > 0 || this.hooks.size > 0;
+		const hasEntityRefs = changeset.removes.size > 0 || changeset.adds.size > 0;
+		if (!hasHooks) {
+			applyChangesetNoHooks(this._commandCtx, entityId, currentArchetype, changeset, this.entityToArchetype);
+			if (hasEntityRefs) this.updateEntityReferences(entityId, changeset);
+			return changeset;
+		}
+		const { removedComponents, newArchetype } = applyChangeset(this._commandCtx, entityId, currentArchetype, changeset, this.entityToArchetype);
+		if (hasEntityRefs) this.updateEntityReferences(entityId, changeset);
 		triggerLifecycleHooks(this.createHooksContext(), entityId, changeset.adds, removedComponents, currentArchetype, newArchetype);
 		return changeset;
 	}
@@ -2322,27 +2491,32 @@ var World = class {
 			this.clearComponentEntityComponents(entityId);
 			return;
 		}
-		for (const command of commands) if (command.type === "set" && command.componentType) this.getComponentEntityComponents(entityId, true).set(command.componentType, command.component);
-		else if (command.type === "delete" && command.componentType) {
+		const pendingSetValues = /* @__PURE__ */ new Map();
+		for (const command of commands) if (command.type === "set" && command.componentType) {
+			const merge = getComponentMerge(command.componentType);
+			let nextValue = command.component;
+			if (merge !== void 0 && pendingSetValues.has(command.componentType)) nextValue = merge(pendingSetValues.get(command.componentType), command.component);
+			pendingSetValues.set(command.componentType, nextValue);
+			this.getComponentEntityComponents(entityId, true).set(command.componentType, nextValue);
+		} else if (command.type === "delete" && command.componentType) {
 			const data = this.componentEntityComponents.get(entityId);
-			if (!data) continue;
 			if (isWildcardRelationId(command.componentType)) {
 				const componentId = getComponentIdFromRelationId(command.componentType);
 				if (componentId !== void 0) {
-					for (const key of Array.from(data.keys())) if (getComponentIdFromRelationId(key) === componentId) data.delete(key);
+					if (data) {
+						for (const key of Array.from(data.keys())) if (getComponentIdFromRelationId(key) === componentId) data.delete(key);
+					}
+					for (const key of Array.from(pendingSetValues.keys())) if (getComponentIdFromRelationId(key) === componentId) pendingSetValues.delete(key);
 				}
-			} else data.delete(command.componentType);
-			if (data.size === 0) this.clearComponentEntityComponents(entityId);
+			} else {
+				data?.delete(command.componentType);
+				pendingSetValues.delete(command.componentType);
+			}
+			if (data?.size === 0) this.clearComponentEntityComponents(entityId);
 		}
 	}
 	createHooksContext() {
-		return {
-			hooks: this.legacyHooks,
-			multiHooks: this.hooks,
-			has: (eid, ct) => this.has(eid, ct),
-			get: (eid, ct) => this.get(eid, ct),
-			getOptional: (eid, ct) => this.getOptional(eid, ct)
-		};
+		return this._hooksCtx;
 	}
 	removeComponentImmediate(entityId, componentType, targetEntityId) {
 		const sourceArchetype = this.entityToArchetype.get(entityId);
@@ -2351,10 +2525,7 @@ var World = class {
 		changeset.delete(componentType);
 		maybeRemoveWildcardMarker(entityId, sourceArchetype, componentType, getComponentIdFromRelationId(componentType), changeset);
 		const removedComponent = sourceArchetype.get(entityId, componentType);
-		const { newArchetype } = applyChangeset({
-			dontFragmentRelations: this.dontFragmentRelations,
-			ensureArchetype: (ct) => this.ensureArchetype(ct)
-		}, entityId, sourceArchetype, changeset, this.entityToArchetype);
+		const { newArchetype } = applyChangeset(this._commandCtx, entityId, sourceArchetype, changeset, this.entityToArchetype);
 		untrackEntityReference(this.entityReferences, entityId, componentType, targetEntityId);
 		triggerLifecycleHooks(this.createHooksContext(), entityId, /* @__PURE__ */ new Map(), new Map([[componentType, removedComponent]]), sourceArchetype, newArchetype);
 	}
@@ -2362,16 +2533,16 @@ var World = class {
 		for (const componentType of changeset.removes) if (isEntityRelation(componentType)) {
 			const targetId = getTargetIdFromRelationId(componentType);
 			untrackEntityReference(this.entityReferences, entityId, componentType, targetId);
-		} else if (componentType >= 1024) untrackEntityReference(this.entityReferences, entityId, componentType, componentType);
+		} else if (componentType >= ENTITY_ID_START) untrackEntityReference(this.entityReferences, entityId, componentType, componentType);
 		for (const [componentType] of changeset.adds) if (isEntityRelation(componentType)) {
 			const targetId = getTargetIdFromRelationId(componentType);
 			trackEntityReference(this.entityReferences, entityId, componentType, targetId);
-		} else if (componentType >= 1024) trackEntityReference(this.entityReferences, entityId, componentType, componentType);
+		} else if (componentType >= ENTITY_ID_START) trackEntityReference(this.entityReferences, entityId, componentType, componentType);
 	}
 	ensureArchetype(componentTypes) {
-		const sortedTypes = filterRegularComponentTypes(componentTypes).sort((a, b) => a - b);
+		const sortedTypes = normalizeComponentTypes(filterRegularComponentTypes(componentTypes));
 		const hashKey = this.createArchetypeSignature(sortedTypes);
-		return getOrCreateWithSideEffect(this.archetypeBySignature, hashKey, () => this.createNewArchetype(sortedTypes));
+		return getOrCompute(this.archetypeBySignature, hashKey, () => this.createNewArchetype(sortedTypes));
 	}
 	createNewArchetype(componentTypes) {
 		const newArchetype = new Archetype(componentTypes, this.dontFragmentRelations);
@@ -2395,7 +2566,7 @@ var World = class {
 				const componentId = getComponentIdFromRelationId(c);
 				return componentId !== void 0 && archetype.hasRelationWithComponentId(componentId);
 			}
-			return archetype.componentTypes.includes(c) || isDontFragmentRelation(c);
+			return archetype.componentTypeSet.has(c) || isDontFragmentRelation(c);
 		});
 	}
 	archetypeReferencesEntity(archetype, entityId) {