@codehz/ecs 0.3.11 → 0.3.13

package/index.mjs

@@ -1,3 +1,100 @@
+//#region src/bit-set.ts
+var BitSet = class {
+	data;
+	_length;
+	constructor(length) {
+		this._length = length;
+		const numWords = Math.ceil(length / 32);
+		this.data = new Uint32Array(numWords);
+	}
+	get length() {
+		return this._length;
+	}
+	has(index) {
+		if (index < 0 || index >= this._length) return false;
+		const word = index >>> 5;
+		const bit = index & 31;
+		return (this.data[word] >>> bit & 1) !== 0;
+	}
+	set(index) {
+		if (index < 0 || index >= this._length) return;
+		const word = index >>> 5;
+		const bit = index & 31;
+		this.data[word] |= 1 << bit;
+	}
+	clear(index) {
+		if (index < 0 || index >= this._length) return;
+		const word = index >>> 5;
+		const bit = index & 31;
+		this.data[word] &= ~(1 << bit);
+	}
+	setRange(lo, hi) {
+		if (lo > hi) return;
+		if (lo < 0) lo = 0;
+		if (hi >= this._length) hi = this._length - 1;
+		const firstWord = lo >>> 5;
+		const lastWord = hi >>> 5;
+		const loBit = lo & 31;
+		const hiBit = hi & 31;
+		const maskFor = (a, b) => {
+			const width = b - a + 1;
+			if (width <= 0) return 0;
+			if (width >= 32) return 4294967295;
+			return (1 << width) - 1 << a >>> 0;
+		};
+		if (firstWord === lastWord) {
+			const mask = maskFor(loBit, hiBit);
+			this.data[firstWord] = (this.data[firstWord] | mask) >>> 0;
+			return;
+		}
+		const firstMask = maskFor(loBit, 31);
+		this.data[firstWord] = (this.data[firstWord] | firstMask) >>> 0;
+		for (let w = firstWord + 1; w <= lastWord - 1; w++) this.data[w] = 4294967295;
+		const lastMask = maskFor(0, hiBit);
+		this.data[lastWord] = (this.data[lastWord] | lastMask) >>> 0;
+	}
+	anyClearInRange(lo, hi) {
+		if (lo > hi) return false;
+		if (lo < 0) lo = 0;
+		if (hi >= this._length) hi = this._length - 1;
+		const firstWord = lo >>> 5;
+		const lastWord = hi >>> 5;
+		const loBit = lo & 31;
+		const hiBit = hi & 31;
+		const maskFor = (a, b) => {
+			const width = b - a + 1;
+			if (width <= 0) return 0;
+			if (width >= 32) return 4294967295;
+			return (1 << width) - 1 << a >>> 0;
+		};
+		if (firstWord === lastWord) {
+			const mask = maskFor(loBit, hiBit);
+			return (this.data[firstWord] & mask) >>> 0 !== mask >>> 0;
+		}
+		const firstMask = maskFor(loBit, 31);
+		if ((this.data[firstWord] & firstMask) >>> 0 !== firstMask >>> 0) return true;
+		for (let w = firstWord + 1; w <= lastWord - 1; w++) if (this.data[w] !== 4294967295) return true;
+		const lastMask = maskFor(0, hiBit);
+		if ((this.data[lastWord] & lastMask) >>> 0 !== lastMask >>> 0) return true;
+		return false;
+	}
+	reset() {
+		this.data.fill(0);
+	}
+	*[Symbol.iterator]() {
+		for (let wordIndex = 0; wordIndex < this.data.length; wordIndex++) {
+			let word = this.data[wordIndex];
+			if (word === 0) continue;
+			const baseIndex = wordIndex * 32;
+			for (let bit = 0; bit < 32 && baseIndex + bit < this._length; bit++) {
+				if (word & 1) yield baseIndex + bit;
+				word >>>= 1;
+			}
+		}
+	}
+};
+
+//#endregion
 //#region src/entity.ts
 const COMPONENT_ID_MAX = 1023;
 const ENTITY_ID_START = 1024;
@@ -6,6 +103,25 @@ const ENTITY_ID_START = 1024;
 */
 const RELATION_SHIFT = 2 ** 42;
 const WILDCARD_TARGET_ID = 0;
+/**
+* Internal function to decode a relation ID into raw component and target IDs
+* @param id The EntityId to decode
+* @returns Object with componentId and targetId, or null if not a relation
+*/
+function decodeRelationRaw(id) {
+	if (id >= 0) return null;
+	const absId = -id;
+	return {
+		componentId: Math.floor(absId / RELATION_SHIFT),
+		targetId: absId % RELATION_SHIFT
+	};
+}
+/**
+* Check if a component ID is valid (1-1023)
+*/
+function isValidComponentId(componentId) {
+	return componentId >= 1 && componentId <= COMPONENT_ID_MAX;
+}
 function relation(componentId, targetId) {
 	if (!isComponentId(componentId)) throw new Error("First argument must be a valid component ID");
 	let actualTargetId;
@@ -38,8 +154,8 @@ function isRelationId(id) {
 * Check if an ID is a wildcard relation id
 */
 function isWildcardRelationId(id) {
-	if (!isRelationId(id)) return false;
-	return -id % RELATION_SHIFT === WILDCARD_TARGET_ID;
+	const decoded = decodeRelationRaw(id);
+	return decoded !== null && decoded.targetId === WILDCARD_TARGET_ID;
 }
 /**
 * Decode a relation ID into component and target IDs
@@ -47,10 +163,12 @@ function isWildcardRelationId(id) {
 * @returns Object with componentId, targetId, and relation type
 */
 function decodeRelationId(relationId) {
-	if (!isRelationId(relationId)) throw new Error("ID is not a relation ID");
-	const absId = -relationId;
-	const componentId = Math.floor(absId / RELATION_SHIFT);
-	const targetId = absId % RELATION_SHIFT;
+	const decoded = decodeRelationRaw(relationId);
+	if (decoded === null) throw new Error("ID is not a relation ID");
+	const { componentId: rawComponentId, targetId: rawTargetId } = decoded;
+	if (!isValidComponentId(rawComponentId)) throw new Error("Invalid component ID in relation");
+	const componentId = rawComponentId;
+	const targetId = rawTargetId;
 	if (targetId === WILDCARD_TARGET_ID) return {
 		componentId,
 		targetId,
@@ -76,7 +194,7 @@ function getIdType(id) {
 	if (isEntityId(id)) return "entity";
 	if (isRelationId(id)) try {
 		const decoded = decodeRelationId(id);
-		if (!isComponentId(decoded.componentId) || decoded.type !== "wildcard" && !isEntityId(decoded.targetId) && !isComponentId(decoded.targetId)) return "invalid";
+		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";
@@ -97,7 +215,7 @@ function getDetailedIdType(id) {
 	if (isEntityId(id)) return { type: "entity" };
 	if (isRelationId(id)) try {
 		const decoded = decodeRelationId(id);
-		if (!isComponentId(decoded.componentId) || decoded.type !== "wildcard" && !isEntityId(decoded.targetId) && !isComponentId(decoded.targetId)) return { type: "invalid" };
+		if (decoded.type !== "wildcard" && !isEntityId(decoded.targetId) && !isComponentId(decoded.targetId)) return { type: "invalid" };
 		let type;
 		switch (decoded.type) {
 			case "entity":
@@ -213,9 +331,11 @@ var ComponentIdAllocator = class {
 	}
 };
 const globalComponentIdAllocator = new ComponentIdAllocator();
-const ComponentNames = /* @__PURE__ */ new Map();
 const ComponentIdForNames = /* @__PURE__ */ new Map();
-const ComponentOptions = /* @__PURE__ */ new Map();
+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);
 /**
 * Allocate a new component ID from the global allocator.
 * @param nameOrOptions Optional name for the component (for serialization/debugging) or options object
@@ -241,10 +361,14 @@ function component(nameOrOptions) {
 	}
 	if (name) {
 		if (ComponentIdForNames.has(name)) throw new Error(`Component name "${name}" is already registered`);
-		ComponentNames.set(id, name);
+		componentNames[id] = name;
 		ComponentIdForNames.set(name, id);
 	}
-	if (options) ComponentOptions.set(id, options);
+	if (options) {
+		if (options.exclusive) exclusiveFlags.set(id);
+		if (options.cascadeDelete) cascadeDeleteFlags.set(id);
+		if (options.dontFragment) dontFragmentFlags.set(id);
+	}
 	return id;
 }
 /**
@@ -260,7 +384,7 @@ function getComponentIdByName(name) {
 * @returns The component name if found, undefined otherwise
 */
 function getComponentNameById(id) {
-	return ComponentNames.get(id);
+	return componentNames[id];
 }
 /**
 * Check if a component is marked as exclusive
@@ -268,15 +392,7 @@ function getComponentNameById(id) {
 * @returns true if the component is exclusive, false otherwise
 */
 function isExclusiveComponent(id) {
-	return ComponentOptions.get(id)?.exclusive ?? false;
-}
-/**
-* Check if a component is marked as cascade delete
-* @param id The component ID
-* @returns true if the component is cascade delete, false otherwise
-*/
-function isCascadeDeleteComponent(id) {
-	return ComponentOptions.get(id)?.cascadeDelete ?? false;
+	return exclusiveFlags.has(id);
 }
 /**
 * Check if a component is marked as dontFragment
@@ -284,7 +400,71 @@ function isCascadeDeleteComponent(id) {
 * @returns true if the component is dontFragment, false otherwise
 */
 function isDontFragmentComponent(id) {
-	return ComponentOptions.get(id)?.dontFragment ?? false;
+	return dontFragmentFlags.has(id);
+}
+/**
+* Generic function to check relation flags with specific target conditions
+* @param id The entity/relation ID to check
+* @param flagBitSet The bitset for the flag
+* @param targetCondition Function to check target ID condition
+* @returns true if the condition is met, false otherwise
+*/
+function checkRelationFlag(id, flagBitSet, targetCondition) {
+	const decoded = decodeRelationRaw(id);
+	if (decoded === null) return false;
+	const { componentId, targetId } = decoded;
+	return isValidComponentId(componentId) && targetCondition(targetId) && flagBitSet.has(componentId);
+}
+/**
+* Check if a relation ID is a dontFragment relation (entity-relation or component-relation with dontFragment component)
+* This is an optimized function that avoids the overhead of getDetailedIdType
+* @param id The entity/relation ID to check
+* @returns true if this is a dontFragment relation, false otherwise
+*/
+function isDontFragmentRelation(id) {
+	return checkRelationFlag(id, dontFragmentFlags, (targetId) => targetId !== WILDCARD_TARGET_ID);
+}
+/**
+* Check if an ID is a wildcard relation with dontFragment component
+* This is an optimized function for filtering archetype component types
+* @param id The entity/relation ID to check
+* @returns true if this is a wildcard relation with dontFragment component, false otherwise
+*/
+function isDontFragmentWildcard(id) {
+	return checkRelationFlag(id, dontFragmentFlags, (targetId) => targetId === WILDCARD_TARGET_ID);
+}
+/**
+* Check if a relation ID is a cascade delete entity-relation
+* This is an optimized function that avoids the overhead of getDetailedIdType
+* Note: Cascade delete only applies to entity-relations (not component-relations or wildcards)
+* @param id The entity/relation ID to check
+* @returns true if this is an entity-relation with cascade delete, false otherwise
+*/
+function isCascadeDeleteRelation(id) {
+	return checkRelationFlag(id, cascadeDeleteFlags, (targetId) => targetId !== WILDCARD_TARGET_ID && targetId >= ENTITY_ID_START);
+}
+/**
+* Get the componentId from a relation ID without fully decoding the relation.
+* Returns undefined for non-relation IDs or invalid component IDs.
+*/
+function getComponentIdFromRelationId(id) {
+	const decoded = decodeRelationRaw(id);
+	if (decoded === null || !isValidComponentId(decoded.componentId)) return void 0;
+	return decoded.componentId;
+}
+/**
+* Get the targetId from a relation ID without fully decoding the relation.
+* Returns undefined for non-relation IDs.
+*/
+function getTargetIdFromRelationId(id) {
+	return decodeRelationRaw(id)?.targetId;
+}
+/**
+* Check if an ID is an entity-relation (relation targeting an entity, not a component or wildcard)
+*/
+function isEntityRelation(id) {
+	const decoded = decodeRelationRaw(id);
+	return decoded !== null && decoded.targetId >= ENTITY_ID_START;
 }
 
 //#endregion
@@ -500,7 +680,7 @@ var Archetype = class {
 		const index = this.entityToIndex.get(entityId);
 		if (index === void 0) throw new Error(`Entity ${entityId} is not in this archetype`);
 		if (isWildcardRelationId(componentType)) {
-			const componentId = decodeRelationId(componentType).componentId;
+			const componentId = getComponentIdFromRelationId(componentType);
 			const relations = [];
 			for (const relType of this.componentTypes) {
 				const relDetailed = getDetailedIdType(relType);
@@ -642,10 +822,10 @@ var Archetype = class {
 		const relations = [];
 		for (const relType of matchingRelations) {
 			const data = this.getComponentData(relType)[entityIndex];
-			const decodedRel = decodeRelationId(relType);
-			relations.push([decodedRel.targetId, data === MISSING_COMPONENT ? void 0 : data]);
+			const targetId = getTargetIdFromRelationId(relType);
+			relations.push([targetId, data === MISSING_COMPONENT ? void 0 : data]);
 		}
-		const targetComponentId = decodeRelationId(wildcardRelationType).componentId;
+		const targetComponentId = getComponentIdFromRelationId(wildcardRelationType);
 		const dontFragmentData = this.dontFragmentRelations.get(entityId);
 		if (dontFragmentData) for (const [relType, data] of dontFragmentData) {
 			const relDetailed = getDetailedIdType(relType);
@@ -653,8 +833,8 @@ var Archetype = class {
 		}
 		if (relations.length === 0) {
 			if (!optional) {
-				const wildcardDecoded = decodeRelationId(wildcardRelationType);
-				throw new Error(`No matching relations found for mandatory wildcard relation component ${wildcardDecoded.componentId} on entity ${entityId}`);
+				const componentId = getComponentIdFromRelationId(wildcardRelationType);
+				throw new Error(`No matching relations found for mandatory wildcard relation component ${componentId} on entity ${entityId}`);
 			}
 			return;
 		}
@@ -992,7 +1172,7 @@ function matchesComponentTypes(archetype, componentTypes) {
 		const detailedType = getDetailedIdType(type);
 		if (detailedType.type === "wildcard-relation") return archetype.componentTypes.some((archetypeType) => {
 			if (!isRelationId(archetypeType)) return false;
-			return decodeRelationId(archetypeType).componentId === detailedType.componentId;
+			return getComponentIdFromRelationId(archetypeType) === detailedType.componentId;
 		});
 		else return archetype.componentTypes.includes(type);
 	});
@@ -1005,7 +1185,7 @@ function matchesFilter(archetype, filter) {
 		const detailedType = getDetailedIdType(type);
 		if (detailedType.type === "wildcard-relation") return !archetype.componentTypes.some((archetypeType) => {
 			if (!isRelationId(archetypeType)) return false;
-			return decodeRelationId(archetypeType).componentId === detailedType.componentId;
+			return getComponentIdFromRelationId(archetypeType) === detailedType.componentId;
 		});
 		else return !archetype.componentTypes.includes(type);
 	});
@@ -1332,26 +1512,12 @@ var World = class {
 			if (!archetype) continue;
 			const componentReferences = Array.from(this.getEntityReferences(cur));
 			for (const [sourceEntityId, componentType] of componentReferences) {
-				const sourceArchetype = this.entityToArchetype.get(sourceEntityId);
-				if (!sourceArchetype) continue;
-				const detailedType = getDetailedIdType(componentType);
-				if (detailedType.type === "entity-relation" && isCascadeDeleteComponent(detailedType.componentId)) {
+				if (!this.entityToArchetype.get(sourceEntityId)) continue;
+				if (isCascadeDeleteRelation(componentType)) {
 					if (!visited.has(sourceEntityId)) queue.push(sourceEntityId);
 					continue;
 				}
-				const currentComponents = /* @__PURE__ */ new Map();
-				let removedComponent = sourceArchetype.get(sourceEntityId, componentType);
-				for (const archetypeComponentType of sourceArchetype.componentTypes) if (archetypeComponentType !== componentType) {
-					const componentData = sourceArchetype.get(sourceEntityId, archetypeComponentType);
-					currentComponents.set(archetypeComponentType, componentData);
-				}
-				const newArchetype = this.ensureArchetype(currentComponents.keys());
-				sourceArchetype.removeEntity(sourceEntityId);
-				if (sourceArchetype.getEntities().length === 0) this.cleanupEmptyArchetype(sourceArchetype);
-				newArchetype.addEntity(sourceEntityId, currentComponents);
-				this.entityToArchetype.set(sourceEntityId, newArchetype);
-				this.untrackEntityReference(sourceEntityId, componentType, cur);
-				this.triggerLifecycleHooks(sourceEntityId, /* @__PURE__ */ new Map(), new Map([[componentType, removedComponent]]));
+				this.removeComponentImmediate(sourceEntityId, componentType, cur);
 			}
 			this.entityReferences.delete(cur);
 			archetype.removeEntity(cur);
@@ -1394,18 +1560,16 @@ var World = class {
 		const archetype = this.entityToArchetype.get(entityId);
 		if (!archetype) return false;
 		if (archetype.componentTypes.includes(componentType)) return true;
-		const detailedType = getDetailedIdType(componentType);
-		if ((detailedType.type === "entity-relation" || detailedType.type === "component-relation") && isDontFragmentComponent(detailedType.componentId)) return this.dontFragmentRelations.get(entityId)?.has(componentType) ?? false;
+		if (isDontFragmentRelation(componentType)) return this.dontFragmentRelations.get(entityId)?.has(componentType) ?? false;
 		return false;
 	}
 	get(entityId, componentType) {
 		const archetype = this.entityToArchetype.get(entityId);
 		if (!archetype) throw new Error(`Entity ${entityId} does not exist`);
-		const detailedType = getDetailedIdType(componentType);
-		if (detailedType.type !== "wildcard-relation") {
+		if (componentType >= 0 || componentType % 2 ** 42 !== 0) {
 			const inArchetype = archetype.componentTypes.includes(componentType);
-			const isDontFragment = (detailedType.type === "entity-relation" || detailedType.type === "component-relation") && isDontFragmentComponent(detailedType.componentId);
-			if (!(inArchetype || isDontFragment && 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().`);
+			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().`);
 		}
 		return archetype.get(entityId, componentType);
 	}
@@ -1512,14 +1676,13 @@ var World = class {
 		if (componentTypes.length === 0) return [...this.archetypes];
 		const regularComponents = [];
 		const wildcardRelations = [];
-		for (const componentType of componentTypes) {
-			const detailedType = getDetailedIdType(componentType);
-			if (detailedType.type === "wildcard-relation") wildcardRelations.push({
-				componentId: detailedType.componentId,
+		for (const componentType of componentTypes) if (isWildcardRelationId(componentType)) {
+			const componentId = getComponentIdFromRelationId(componentType);
+			if (componentId !== void 0) wildcardRelations.push({
+				componentId,
 				relationId: componentType
 			});
-			else regularComponents.push(componentType);
-		}
+		} else regularComponents.push(componentType);
 		let matchingArchetypes = [];
 		if (regularComponents.length > 0) {
 			const sortedRegularTypes = [...regularComponents].sort((a, b) => a - b);
@@ -1592,11 +1755,13 @@ var World = class {
 	* Process a set command, handling exclusive relations
 	*/
 	processSetCommand(entityId, currentArchetype, componentType, component$1, changeset) {
-		const detailedType = getDetailedIdType(componentType);
-		if ((detailedType.type === "entity-relation" || detailedType.type === "component-relation") && isExclusiveComponent(detailedType.componentId)) this.removeExclusiveRelations(entityId, currentArchetype, detailedType.componentId, changeset);
-		if ((detailedType.type === "entity-relation" || detailedType.type === "component-relation") && isDontFragmentComponent(detailedType.componentId)) {
-			const wildcardMarker = relation(detailedType.componentId, "*");
-			if (!currentArchetype.componentTypes.includes(wildcardMarker)) changeset.set(wildcardMarker, void 0);
+		const componentId = getComponentIdFromRelationId(componentType);
+		if (componentId !== void 0) {
+			if (componentId !== void 0 && isExclusiveComponent(componentId)) this.removeExclusiveRelations(entityId, currentArchetype, componentId, changeset);
+			if (componentId !== void 0 && isDontFragmentComponent(componentId)) {
+				const wildcardMarker = relation(componentId, "*");
+				if (!currentArchetype.componentTypes.includes(wildcardMarker)) changeset.set(wildcardMarker, void 0);
+			}
 		}
 		changeset.set(componentType, component$1);
 	}
@@ -1611,30 +1776,26 @@ var World = class {
 			if (this.isRelationWithComponent(componentType, baseComponentId)) changeset.delete(componentType);
 		}
 	}
-	/**
-	* Check if a component type is a relation with the given base component
-	*/
 	isRelationWithComponent(componentType, baseComponentId) {
-		const detailedType = getDetailedIdType(componentType);
-		return (detailedType.type === "entity-relation" || detailedType.type === "component-relation") && detailedType.componentId === baseComponentId;
+		return getComponentIdFromRelationId(componentType) === baseComponentId;
 	}
 	/**
 	* Process a delete command, handling wildcard relations
 	*/
 	processDeleteCommand(entityId, currentArchetype, componentType, changeset) {
-		const detailedType = getDetailedIdType(componentType);
-		if (detailedType.type === "wildcard-relation") this.removeWildcardRelations(entityId, currentArchetype, detailedType.componentId, changeset);
+		const componentId = getComponentIdFromRelationId(componentType);
+		if (isWildcardRelationId(componentType) && componentId !== void 0) this.removeWildcardRelations(entityId, currentArchetype, componentId, changeset);
 		else {
 			changeset.delete(componentType);
-			if ((detailedType.type === "entity-relation" || detailedType.type === "component-relation") && isDontFragmentComponent(detailedType.componentId)) {
-				const wildcardMarker = relation(detailedType.componentId, "*");
+			if (componentId !== void 0 && isDontFragmentComponent(componentId)) {
+				const wildcardMarker = relation(componentId, "*");
 				const entityData = currentArchetype.getEntity(entityId);
 				let hasOtherRelations = false;
 				if (entityData) for (const [otherComponentType] of entityData) {
 					if (otherComponentType === componentType) continue;
+					if (otherComponentType === wildcardMarker) continue;
 					if (changeset.removes.has(otherComponentType)) continue;
-					const otherDetailedType = getDetailedIdType(otherComponentType);
-					if ((otherDetailedType.type === "entity-relation" || otherDetailedType.type === "component-relation") && otherDetailedType.componentId === detailedType.componentId) {
+					if (getComponentIdFromRelationId(otherComponentType) === componentId) {
 						hasOtherRelations = true;
 						break;
 					}
@@ -1659,6 +1820,35 @@ var World = class {
 		}
 	}
 	/**
+	* Remove a single component from an entity immediately, handling dontFragment relations correctly.
+	* Used by destroyEntityImmediate for non-cascade relation cleanup.
+	*/
+	removeComponentImmediate(entityId, componentType, targetEntityId) {
+		const sourceArchetype = this.entityToArchetype.get(entityId);
+		if (!sourceArchetype) return;
+		const changeset = new ComponentChangeset();
+		const componentId = getComponentIdFromRelationId(componentType);
+		changeset.delete(componentType);
+		if (componentId !== void 0 && isDontFragmentComponent(componentId)) {
+			const wildcardMarker = relation(componentId, "*");
+			const entityData = sourceArchetype.getEntity(entityId);
+			let hasOtherRelations = false;
+			if (entityData) for (const [otherComponentType] of entityData) {
+				if (otherComponentType === componentType) continue;
+				if (otherComponentType === wildcardMarker) continue;
+				if (getComponentIdFromRelationId(otherComponentType) === componentId) {
+					hasOtherRelations = true;
+					break;
+				}
+			}
+			if (!hasOtherRelations) changeset.delete(wildcardMarker);
+		}
+		const removedComponent = sourceArchetype.get(entityId, componentType);
+		this.applyChangeset(entityId, sourceArchetype, changeset);
+		this.untrackEntityReference(entityId, componentType, targetEntityId);
+		this.triggerLifecycleHooks(entityId, /* @__PURE__ */ new Map(), new Map([[componentType, removedComponent]]));
+	}
+	/**
 	* Apply changeset to entity, moving to new archetype if needed
 	* @returns Map of removed components with their data
 	*/
@@ -1690,53 +1880,48 @@ var World = class {
 	* Update entity in same archetype (no archetype change needed)
 	*/
 	updateEntityInSameArchetype(entityId, currentArchetype, changeset, removedComponents) {
-		const currentComponents = currentArchetype.getEntity(entityId);
-		const hasDontFragmentChanges = this.hasDontFragmentChanges(changeset);
-		if (hasDontFragmentChanges) for (const componentType of changeset.removes) {
-			const detailedType = getDetailedIdType(componentType);
-			if ((detailedType.type === "entity-relation" || detailedType.type === "component-relation") && isDontFragmentComponent(detailedType.componentId)) removedComponents.set(componentType, currentComponents.get(componentType));
+		this.applyDontFragmentChanges(entityId, changeset, removedComponents);
+		for (const [componentType, component$1] of changeset.adds) {
+			if (isDontFragmentRelation(componentType)) continue;
+			currentArchetype.set(entityId, componentType, component$1);
 		}
-		if (hasDontFragmentChanges) this.readdEntityWithUpdatedComponents(entityId, currentArchetype, currentComponents, changeset);
-		else for (const [componentType, component$1] of changeset.adds) currentArchetype.set(entityId, componentType, component$1);
 	}
 	/**
-	* Check if changeset contains dontFragment relation changes
+	* Apply dontFragment relation changes directly to World's storage
+	* This is much more efficient than the removeEntity + addEntity approach
 	*/
-	hasDontFragmentChanges(changeset) {
-		for (const componentType of changeset.removes) {
-			const detailedType = getDetailedIdType(componentType);
-			if ((detailedType.type === "entity-relation" || detailedType.type === "component-relation") && isDontFragmentComponent(detailedType.componentId)) return true;
+	applyDontFragmentChanges(entityId, changeset, removedComponents) {
+		let entityRelations = this.dontFragmentRelations.get(entityId);
+		for (const componentType of changeset.removes) if (isDontFragmentRelation(componentType)) {
+			if (entityRelations) {
+				const removedValue = entityRelations.get(componentType);
+				if (removedValue !== void 0 || entityRelations.has(componentType)) {
+					removedComponents.set(componentType, removedValue);
+					entityRelations.delete(componentType);
+				}
+			}
 		}
-		for (const [componentType] of changeset.adds) {
-			const detailedType = getDetailedIdType(componentType);
-			if ((detailedType.type === "entity-relation" || detailedType.type === "component-relation") && isDontFragmentComponent(detailedType.componentId)) return true;
+		for (const [componentType, component$1] of changeset.adds) if (isDontFragmentRelation(componentType)) {
+			if (!entityRelations) {
+				entityRelations = /* @__PURE__ */ new Map();
+				this.dontFragmentRelations.set(entityId, entityRelations);
+			}
+			entityRelations.set(componentType, component$1);
 		}
-		return false;
-	}
-	/**
-	* Remove and re-add entity with updated components (for dontFragment changes)
-	*/
-	readdEntityWithUpdatedComponents(entityId, archetype, currentComponents, changeset) {
-		const newComponents = /* @__PURE__ */ new Map();
-		for (const [ct, value] of currentComponents) if (!changeset.removes.has(ct)) newComponents.set(ct, value);
-		for (const [ct, value] of changeset.adds) newComponents.set(ct, value);
-		archetype.removeEntity(entityId);
-		archetype.addEntity(entityId, newComponents);
+		if (entityRelations && entityRelations.size === 0) this.dontFragmentRelations.delete(entityId);
 	}
 	/**
 	* Update entity reference tracking based on changeset
 	*/
 	updateEntityReferences(entityId, changeset) {
-		for (const componentType of changeset.removes) {
-			const detailedType = getDetailedIdType(componentType);
-			if (detailedType.type === "entity-relation") this.untrackEntityReference(entityId, componentType, detailedType.targetId);
-			else if (detailedType.type === "entity") this.untrackEntityReference(entityId, componentType, componentType);
-		}
-		for (const [componentType] of changeset.adds) {
-			const detailedType = getDetailedIdType(componentType);
-			if (detailedType.type === "entity-relation") this.trackEntityReference(entityId, componentType, detailedType.targetId);
-			else if (detailedType.type === "entity") this.trackEntityReference(entityId, componentType, componentType);
-		}
+		for (const componentType of changeset.removes) if (isEntityRelation(componentType)) {
+			const targetId = getTargetIdFromRelationId(componentType);
+			this.untrackEntityReference(entityId, componentType, targetId);
+		} else if (componentType >= 1024) this.untrackEntityReference(entityId, componentType, componentType);
+		for (const [componentType] of changeset.adds) if (isEntityRelation(componentType)) {
+			const targetId = getTargetIdFromRelationId(componentType);
+			this.trackEntityReference(entityId, componentType, targetId);
+		} else if (componentType >= 1024) this.trackEntityReference(entityId, componentType, componentType);
 	}
 	/**
 	* Get or create an archetype for the given component types
@@ -1763,12 +1948,11 @@ var World = class {
 	filterRegularComponentTypes(componentTypes) {
 		const regularTypes = [];
 		for (const componentType of componentTypes) {
-			const detailedType = getDetailedIdType(componentType);
-			if (detailedType.type === "wildcard-relation" && isDontFragmentComponent(detailedType.componentId)) {
+			if (isDontFragmentWildcard(componentType)) {
 				regularTypes.push(componentType);
 				continue;
 			}
-			if ((detailedType.type === "entity-relation" || detailedType.type === "component-relation") && isDontFragmentComponent(detailedType.componentId)) continue;
+			if (isDontFragmentRelation(componentType)) continue;
 			regularTypes.push(componentType);
 		}
 		return regularTypes;
@@ -1882,9 +2066,9 @@ var World = class {
 		for (const [componentType, component$1] of addedComponents) {
 			const directHooks = this.hooks.get(componentType);
 			if (directHooks) for (const lifecycleHook of directHooks) lifecycleHook.on_set?.(entityId, componentType, component$1);
-			const detailedType = getDetailedIdType(componentType);
-			if (detailedType.type === "entity-relation" || detailedType.type === "component-relation" || detailedType.type === "wildcard-relation") {
-				const wildcardRelationId = relation(detailedType.componentId, "*");
+			const componentId = getComponentIdFromRelationId(componentType);
+			if (componentId !== void 0) {
+				const wildcardRelationId = relation(componentId, "*");
 				const wildcardHooks = this.hooks.get(wildcardRelationId);
 				if (wildcardHooks) for (const lifecycleHook of wildcardHooks) lifecycleHook.on_set?.(entityId, componentType, component$1);
 			}
@@ -1892,9 +2076,9 @@ var World = class {
 		for (const [componentType, component$1] of removedComponents) {
 			const directHooks = this.hooks.get(componentType);
 			if (directHooks) for (const lifecycleHook of directHooks) lifecycleHook.on_remove?.(entityId, componentType, component$1);
-			const detailedType = getDetailedIdType(componentType);
-			if (detailedType.type === "entity-relation" || detailedType.type === "component-relation" || detailedType.type === "wildcard-relation") {
-				const wildcardRelationId = relation(detailedType.componentId, "*");
+			const componentId = getComponentIdFromRelationId(componentType);
+			if (componentId !== void 0) {
+				const wildcardRelationId = relation(componentId, "*");
 				const wildcardHooks = this.hooks.get(wildcardRelationId);
 				if (wildcardHooks) for (const hook of wildcardHooks) hook.on_remove?.(entityId, componentType, component$1);
 			}
@@ -1950,5 +2134,5 @@ var World = class {
 };
 
 //#endregion
-export { Query, World, component, decodeRelationId, getComponentIdByName, getComponentNameById, isComponentId, isEntityId, isRelationId, isWildcardRelationId, relation };
+export { Query, World, component, getComponentIdByName, getComponentNameById, isComponentId, isEntityId, isRelationId, isWildcardRelationId, relation };
 //# sourceMappingURL=index.mjs.map