@codehz/ecs 0.3.12 → 0.3.13

package/index.d.mts

@@ -50,16 +50,6 @@ declare function isRelationId<T>(id: EntityId<T>): id is RelationId<T>;
  * Check if an ID is a wildcard relation id
  */
 declare function isWildcardRelationId<T>(id: EntityId<T>): id is WildcardRelationId<T>;
-/**
- * Decode a relation ID into component and target IDs
- * @param relationId The relation ID (must be negative)
- * @returns Object with componentId, targetId, and relation type
- */
-declare function decodeRelationId(relationId: RelationId<any>): {
-  componentId: ComponentId<any>;
-  targetId: EntityId<any>;
-  type: "entity" | "component" | "wildcard";
-};
 /**
  * Component options that define intrinsic properties
  */
@@ -649,9 +639,6 @@ declare class World<UpdateParams extends any[] = []> {
    * Remove all relations with the same base component (for exclusive relations)
    */
   private removeExclusiveRelations;
-  /**
-   * Check if a component type is a relation with the given base component
-   */
   private isRelationWithComponent;
   /**
    * Process a delete command, handling wildcard relations
@@ -680,13 +667,10 @@ declare class World<UpdateParams extends any[] = []> {
    */
   private updateEntityInSameArchetype;
   /**
-   * Check if changeset contains dontFragment relation changes
-   */
-  private hasDontFragmentChanges;
-  /**
-   * Remove and re-add entity with updated components (for dontFragment changes)
+   * Apply dontFragment relation changes directly to World's storage
+   * This is much more efficient than the removeEntity + addEntity approach
    */
-  private readdEntityWithUpdatedComponents;
+  private applyDontFragmentChanges;
   /**
    * Update entity reference tracking based on changeset
    */
@@ -785,5 +769,5 @@ type SerializedComponent = {
   value: any;
 };
 //#endregion
-export { type ComponentId, type ComponentOptions, type ComponentRelationId, type ComponentTuple, type ComponentType, type EntityId, type EntityRelationId, type LifecycleHook, Query, type RelationId, type SerializedWorld, type System, type WildcardRelationId, World, component, decodeRelationId, getComponentIdByName, getComponentNameById, isComponentId, isEntityId, isRelationId, isWildcardRelationId, relation };
+export { type ComponentId, type ComponentOptions, type ComponentRelationId, type ComponentTuple, type ComponentType, type EntityId, type EntityRelationId, type LifecycleHook, Query, type RelationId, type SerializedWorld, type System, type WildcardRelationId, World, component, getComponentIdByName, getComponentNameById, isComponentId, isEntityId, isRelationId, isWildcardRelationId, relation };
 //# sourceMappingURL=index.d.mts.map

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);
 	});
@@ -1333,8 +1513,7 @@ var World = class {
 			const componentReferences = Array.from(this.getEntityReferences(cur));
 			for (const [sourceEntityId, componentType] of componentReferences) {
 				if (!this.entityToArchetype.get(sourceEntityId)) continue;
-				const detailedType = getDetailedIdType(componentType);
-				if (detailedType.type === "entity-relation" && isCascadeDeleteComponent(detailedType.componentId)) {
+				if (isCascadeDeleteRelation(componentType)) {
 					if (!visited.has(sourceEntityId)) queue.push(sourceEntityId);
 					continue;
 				}
@@ -1381,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);
 	}
@@ -1499,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);
@@ -1579,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);
 	}
@@ -1598,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;
 					}
@@ -1653,16 +1827,16 @@ var World = class {
 		const sourceArchetype = this.entityToArchetype.get(entityId);
 		if (!sourceArchetype) return;
 		const changeset = new ComponentChangeset();
-		const detailedType = getDetailedIdType(componentType);
+		const componentId = getComponentIdFromRelationId(componentType);
 		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 = sourceArchetype.getEntity(entityId);
 			let hasOtherRelations = false;
 			if (entityData) for (const [otherComponentType] of entityData) {
 				if (otherComponentType === componentType) continue;
-				const otherDetailedType = getDetailedIdType(otherComponentType);
-				if ((otherDetailedType.type === "entity-relation" || otherDetailedType.type === "component-relation") && otherDetailedType.componentId === detailedType.componentId) {
+				if (otherComponentType === wildcardMarker) continue;
+				if (getComponentIdFromRelationId(otherComponentType) === componentId) {
 					hasOtherRelations = true;
 					break;
 				}
@@ -1706,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
@@ -1779,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;
@@ -1898,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);
 			}
@@ -1908,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);
 			}
@@ -1966,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