@codehz/ecs 0.6.8 → 0.6.9

package/builder.d.mts

@@ -163,13 +163,21 @@ declare class ComponentChangeset {
 //#region src/commands/command-buffer.d.ts
 /**
  * Command for deferred execution
+ * Uses discriminated union for type safety
  */
-interface Command {
-  type: "set" | "delete" | "destroy";
+type Command = {
+  type: "set";
   entityId: EntityId;
-  componentType?: EntityId<any>;
-  component?: any;
-}
+  componentType: EntityId<any>;
+  component: any;
+} | {
+  type: "delete";
+  entityId: EntityId;
+  componentType: EntityId<any>;
+} | {
+  type: "destroy";
+  entityId: EntityId;
+};
 //#endregion
 //#region src/core/types.d.ts
 /**
@@ -181,7 +189,7 @@ interface LegacyLifecycleHook<T = unknown> {
    */
   on_init?: (entityId: EntityId, componentType: EntityId<T>, component: T) => void;
   /**
-   * Called when a component is added to an entity
+   * Called when a component is updated on an entity
    */
   on_set?: (entityId: EntityId, componentType: EntityId<T>, component: T) => void;
   /**
@@ -235,6 +243,10 @@ declare class Archetype {
    * The component types that define this archetype
    */
   readonly componentTypes: EntityId<any>[];
+  /**
+   * Set version of componentTypes for O(1) lookups in hot paths
+   */
+  readonly componentTypeSet: ReadonlySet<EntityId<any>>;
   /**
    * List of entities in this archetype
    */
@@ -254,9 +266,6 @@ declare class Archetype {
    * Stored in World to avoid migration overhead when entities change archetypes
    */
   private dontFragmentRelations;
-  /**
-   * Cache for pre-computed component data sources to avoid repeated calculations
-   */
   /**
    * Multi-hooks that match this archetype
    */
@@ -267,6 +276,12 @@ declare class Archetype {
   private componentDataSourcesCache;
   constructor(componentTypes: EntityId<any>[], dontFragmentRelations: Map<EntityId, Map<EntityId<any>, any>>);
   get size(): number;
+  /**
+   * 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: EntityId<any>[]): boolean;
   addEntity(entityId: EntityId, componentData: Map<EntityId<any>, any>): void;
   private addDontFragmentRelations;
@@ -320,6 +335,8 @@ declare class Query {
   private filter;
   private cachedArchetypes;
   private isDisposed;
+  /** Cache key assigned by World for O(1) releaseQuery lookup */
+  _cacheKey: string | undefined;
   /** Cached wildcard component types for faster entity filtering */
   private wildcardTypes;
   /** Cached specific dontFragment relation types that need entity-level filtering */
@@ -401,9 +418,16 @@ type SerializedEntityId = number | string | {
   component: string;
   target: number | string | "*";
 };
+/**
+ * Serialized state of EntityIdManager
+ */
+interface SerializedEntityIdManager {
+  nextId: number;
+  freelist?: number[];
+}
 type SerializedWorld = {
   version: number;
-  entityManager: any;
+  entityManager: SerializedEntityIdManager;
   entities: SerializedEntity[];
   componentEntities?: SerializedEntity[];
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codehz/ecs",
-  "version": "0.6.8",
+  "version": "0.6.9",
   "repository": {
     "url": "https://github.com/codehz/ecs"
   },

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
+		};
+		else if (isEntityId(targetId)) return {
+			type: "entity-relation",
+			componentId,
+			targetId
+		};
+		else if (isComponentId(targetId)) return {
+			type: "component-relation",
+			componentId,
+			targetId
 		};
-	} catch (_error) {
-		return { type: "invalid" };
+		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 || [];
 	}
 };
 /**
@@ -627,10 +628,15 @@ 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 = [];
 	executeEntityCommands;
 	/**
 	* Create a command buffer with an executor function
@@ -669,18 +675,19 @@ 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 currentCommands = this.commands;
+			this.commands = this.swapBuffer;
 			const entityCommands = /* @__PURE__ */ new Map();
 			for (const cmd of currentCommands) {
 				if (!entityCommands.has(cmd.entityId)) entityCommands.set(cmd.entityId, []);
 				entityCommands.get(cmd.entityId).push(cmd);
 			}
+			currentCommands.length = 0;
+			this.swapBuffer = currentCommands;
 			for (const [entityId, commands] of entityCommands) this.executeEntityCommands(entityId, commands);
 		}
 	}
@@ -721,8 +728,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,7 +742,7 @@ 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);
 	});
 }
 
@@ -750,6 +757,8 @@ 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 */
@@ -903,10 +912,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();
@@ -915,20 +924,15 @@ 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
+* Alias for getOrCompute - maintained for backwards compatibility
+* @deprecated Use getOrCompute instead
 */
-function getOrCreateWithSideEffect(cache, key, create) {
-	let value = cache.get(key);
-	if (value === void 0) {
-		value = create();
-		cache.set(key, value);
-	}
-	return value;
-}
+const getOrComputeCache = getOrCompute;
+/**
+* Alias for getOrCompute - maintained for backwards compatibility
+* @deprecated Use getOrCompute instead
+*/
+const getOrCreateWithSideEffect = getOrCompute;
 
 //#endregion
 //#region src/core/types.ts
@@ -939,6 +943,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 +1052,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 +1075,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();
@@ -1067,12 +1084,19 @@ var Archetype = class {
 	componentDataSourcesCache = /* @__PURE__ */ new Map();
 	constructor(componentTypes, dontFragmentRelations) {
 		this.componentTypes = [...componentTypes].sort((a, b) => a - b);
+		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);
@@ -1092,7 +1116,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);
 		}
@@ -1176,7 +1200,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 +1212,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 };
@@ -1376,8 +1400,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,7 +1409,7 @@ 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);
 		}
 	}
 	changeset.set(componentType, component$1);
@@ -1405,7 +1429,7 @@ function removeMatchingRelations(entityId, archetype, baseComponentId, changeset
 	}
 	const entityData = archetype.getEntity(entityId);
 	if (entityData) for (const [componentType] of entityData) {
-		if (archetype.componentTypes.includes(componentType)) continue;
+		if (archetype.componentTypeSet.has(componentType)) continue;
 		if (getComponentIdFromRelationId(componentType) === baseComponentId) changeset.delete(componentType);
 	}
 }
@@ -1579,11 +1603,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 +1615,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);
 	});
@@ -1879,8 +1903,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);
@@ -1975,14 +2000,13 @@ 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;
 	}
@@ -2006,8 +2030,8 @@ var World = class {
 		}
 		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().`);
 		}
@@ -2175,6 +2199,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 +2265,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 +2305,16 @@ 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 [];
+		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);
@@ -2362,11 +2396,11 @@ 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);
@@ -2395,7 +2429,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) {