@codehz/ecs 0.8.0 → 0.8.2

package/dist/builder.d.mts

@@ -561,15 +561,28 @@ interface LifecycleHookEntry {
 //#endregion
 //#region src/archetype/store.d.ts
 /**
- * Minimal interface for storing dontFragment relation data keyed by entity ID.
+ * Interface for storing dontFragment relation data.
  *
- * Using an interface here decouples `Archetype` (and `world-commands.ts`) from
- * the concrete `Map` used by `World`, making archetypes independently testable.
+ * Storage is now primarily keyed by relation ComponentId (the "kind" of relation)
+ * rather than by entity. This provides O(1) or near-O(1) answers for the hot
+ * wildcard-related paths (hasRelationWithComponentId, wildcard materialization
+ * during iteration, hook matching, etc.).
+ *
+ * A lightweight reverse index (entity -> Set of base ComponentIds) is maintained
+ * to efficiently support the infrequent "get all dontFragment data for this entity"
+ * operations (removeEntity, dump, getEntity, serialization).
+ *
+ * The interface no longer leaks internal Map structures. Callers work with
+ * semantic operations only.
  */
 interface DontFragmentStore {
-  get(entityId: EntityId): Map<EntityId<any>, any> | undefined;
-  set(entityId: EntityId, data: Map<EntityId<any>, any>): void;
-  delete(entityId: EntityId): void;
+  getValue(entityId: EntityId, relationType: EntityId<any>): any | undefined;
+  setValue(entityId: EntityId, relationType: EntityId<any>, data: any): void;
+  deleteValue(entityId: EntityId, relationType: EntityId<any>): boolean;
+  hasAnyForComponent(componentId: EntityId<any>): boolean;
+  getRelationsForComponent(entityId: EntityId, componentId: EntityId<any>): [target: EntityId, data: any][];
+  getAllForEntity(entityId: EntityId): Array<[relationType: EntityId<any>, data: any]>;
+  deleteEntity(entityId: EntityId): void;
 }
 //#endregion
 //#region src/archetype/archetype.d.ts
@@ -601,9 +614,9 @@ declare class Archetype {
    */
   private entityToIndex;
   /**
-   * DontFragmentStore for relation data keyed by entity ID.
-   * This allows entities with different relation targets to share the same archetype
-   * without migration overhead when entities change archetypes.
+   * DontFragmentStore (keyed primarily by relation ComponentId).
+   * Uses optimized RelationEntry (single/multi) for the common exclusive case.
+   * See store.ts for implementation details.
    */
   private dontFragmentRelations;
   /**
@@ -626,6 +639,12 @@ declare class Archetype {
   addEntity(entityId: EntityId, componentData: Map<EntityId<any>, any>): void;
   private addDontFragmentRelations;
   getEntity(entityId: EntityId): Map<EntityId<any>, any> | undefined;
+  /**
+   * Returns all dontFragment relations for the given entity as an array of tuples.
+   * This is a compatibility adapter during the store refactor.
+   *
+   * Prefer the new DontFragmentStore methods when possible.
+   */
   getEntityDontFragmentRelations(entityId: EntityId): Map<EntityId<any>, any> | undefined;
   dump(): Array<{
     entity: EntityId;

package/dist/world.mjs

@@ -695,17 +695,6 @@ function matchesRelationComponentId(componentType, componentId) {
 	return isRelationType(detailedType) && detailedType.componentId === componentId;
 }
 /**
-* Find all relations in dontFragment data that match a component ID
-*/
-function findMatchingDontFragmentRelations(dontFragmentData, componentId, relations = []) {
-	if (!dontFragmentData) return relations;
-	for (const [relType, data] of dontFragmentData) {
-		const relDetailed = getDetailedIdType(relType);
-		if (isRelationType(relDetailed) && relDetailed.componentId === componentId) relations.push([relDetailed.targetId, data]);
-	}
-	return relations;
-}
-/**
 * Build cache key for component types
 */
 function buildCacheKey(componentTypes) {
@@ -719,9 +708,10 @@ function getWildcardRelationDataSource(componentTypes, componentId, optional) {
 	return optional ? matchingRelations.length > 0 ? matchingRelations : void 0 : matchingRelations;
 }
 /**
-* Build wildcard relation value from matching relations
+* Build wildcard relation value from matching relations.
+* Now receives the DontFragmentStore directly for efficient per-component lookups.
 */
-function buildWildcardRelationValue(wildcardRelationType, matchingRelations, getDataAtIndex, dontFragmentData, entityId, optional) {
+function buildWildcardRelationValue(wildcardRelationType, matchingRelations, getDataAtIndex, dontFragmentStore, entityId, optional) {
 	const relations = [];
 	const targetComponentId = getComponentIdFromRelationId(wildcardRelationType);
 	for (const relType of matchingRelations || []) {
@@ -729,7 +719,10 @@ function buildWildcardRelationValue(wildcardRelationType, matchingRelations, get
 		const targetId = getTargetIdFromRelationId(relType);
 		relations.push([targetId, data === MISSING_COMPONENT ? void 0 : data]);
 	}
-	if (targetComponentId !== void 0) findMatchingDontFragmentRelations(dontFragmentData, targetComponentId, relations);
+	if (targetComponentId !== void 0) {
+		const dfMatches = dontFragmentStore.getRelationsForComponent(entityId, targetComponentId);
+		for (const m of dfMatches) relations.push(m);
+	}
 	if (relations.length === 0) {
 		if (!optional) {
 			const componentId = getComponentIdFromRelationId(wildcardRelationType);
@@ -757,7 +750,7 @@ function buildRegularComponentValue(dataSource, entityIndex, optional) {
 function buildSingleComponent(compType, dataSource, entityIndex, entityId, getComponentData, dontFragmentRelations) {
 	const optional = isOptionalEntityId(compType);
 	const actualType = optional ? compType.optional : compType;
-	if (getIdType(actualType) === "wildcard-relation") return buildWildcardRelationValue(actualType, dataSource, (relType) => getComponentData(relType)[entityIndex], dontFragmentRelations.get(entityId), entityId, optional);
+	if (getIdType(actualType) === "wildcard-relation") return buildWildcardRelationValue(actualType, dataSource, (relType) => getComponentData(relType)[entityIndex], dontFragmentRelations, entityId, optional);
 	else return buildRegularComponentValue(dataSource, entityIndex, optional);
 }
 //#endregion
@@ -794,9 +787,9 @@ var Archetype = class {
 	*/
 	entityToIndex = /* @__PURE__ */ new Map();
 	/**
-	* DontFragmentStore for relation data keyed by entity ID.
-	* This allows entities with different relation targets to share the same archetype
-	* without migration overhead when entities change archetypes.
+	* DontFragmentStore (keyed primarily by relation ComponentId).
+	* Uses optimized RelationEntry (single/multi) for the common exclusive case.
+	* See store.ts for implementation details.
 	*/
 	dontFragmentRelations;
 	/**
@@ -839,13 +832,11 @@ var Archetype = class {
 		this.addDontFragmentRelations(entityId, componentData);
 	}
 	addDontFragmentRelations(entityId, componentData) {
-		const dontFragmentData = /* @__PURE__ */ new Map();
 		for (const [componentType, data] of componentData) {
 			if (this.componentTypeSet.has(componentType)) continue;
 			const detailedType = getDetailedIdType(componentType);
-			if (isRelationType(detailedType) && isDontFragmentComponent(detailedType.componentId)) dontFragmentData.set(componentType, data);
+			if (isRelationType(detailedType) && isDontFragmentComponent(detailedType.componentId)) this.dontFragmentRelations.setValue(entityId, componentType, data);
 		}
-		if (dontFragmentData.size > 0) this.dontFragmentRelations.set(entityId, dontFragmentData);
 	}
 	getEntity(entityId) {
 		const index = this.entityToIndex.get(entityId);
@@ -855,12 +846,22 @@ var Archetype = class {
 			const data = this.getComponentData(componentType)[index];
 			entityData.set(componentType, data === MISSING_COMPONENT ? void 0 : data);
 		}
-		const dontFragmentData = this.dontFragmentRelations.get(entityId);
-		if (dontFragmentData) for (const [componentType, data] of dontFragmentData) entityData.set(componentType, data);
+		const dontFragmentTuples = this.dontFragmentRelations.getAllForEntity(entityId);
+		for (const [componentType, data] of dontFragmentTuples) entityData.set(componentType, data);
 		return entityData;
 	}
+	/**
+	* Returns all dontFragment relations for the given entity as an array of tuples.
+	* This is a compatibility adapter during the store refactor.
+	*
+	* Prefer the new DontFragmentStore methods when possible.
+	*/
 	getEntityDontFragmentRelations(entityId) {
-		return this.dontFragmentRelations.get(entityId);
+		const tuples = this.dontFragmentRelations.getAllForEntity(entityId);
+		if (tuples.length === 0) return void 0;
+		const map = /* @__PURE__ */ new Map();
+		for (const [relType, data] of tuples) map.set(relType, data);
+		return map;
 	}
 	dump() {
 		return this.entities.map((entity, i) => {
@@ -869,8 +870,8 @@ var Archetype = class {
 				const data = this.getComponentData(componentType)[i];
 				components.set(componentType, data === MISSING_COMPONENT ? void 0 : data);
 			}
-			const dontFragmentData = this.dontFragmentRelations.get(entity);
-			if (dontFragmentData) for (const [componentType, data] of dontFragmentData) components.set(componentType, data);
+			const dontFragmentTuples = this.dontFragmentRelations.getAllForEntity(entity);
+			for (const [componentType, data] of dontFragmentTuples) components.set(componentType, data);
 			return {
 				entity,
 				components
@@ -882,11 +883,9 @@ var Archetype = class {
 		if (index === void 0) return void 0;
 		const removedData = /* @__PURE__ */ new Map();
 		for (const componentType of this.componentTypes) removedData.set(componentType, this.getComponentData(componentType)[index]);
-		const dontFragmentData = this.dontFragmentRelations.get(entityId);
-		if (dontFragmentData) {
-			for (const [componentType, data] of dontFragmentData) removedData.set(componentType, data);
-			this.dontFragmentRelations.delete(entityId);
-		}
+		const dontFragmentTuples = this.dontFragmentRelations.getAllForEntity(entityId);
+		for (const [componentType, data] of dontFragmentTuples) removedData.set(componentType, data);
+		this.dontFragmentRelations.deleteEntity(entityId);
 		this.entityToIndex.delete(entityId);
 		const lastIndex = this.entities.length - 1;
 		if (index !== lastIndex) {
@@ -924,7 +923,10 @@ var Archetype = class {
 				}
 			}
 		}
-		if (componentId !== void 0) findMatchingDontFragmentRelations(this.dontFragmentRelations.get(entityId), componentId, relations);
+		if (componentId !== void 0) {
+			const matches = this.dontFragmentRelations.getRelationsForComponent(entityId, componentId);
+			for (const m of matches) relations.push(m);
+		}
 		return relations;
 	}
 	getRegularComponent(entityId, index, componentType) {
@@ -933,8 +935,7 @@ var Archetype = class {
 			if (data === MISSING_COMPONENT) throw new Error(`Component type ${componentType} not found for entity ${entityId}`);
 			return data;
 		}
-		const dontFragmentData = this.dontFragmentRelations.get(entityId);
-		if (dontFragmentData?.has(componentType)) return dontFragmentData.get(componentType);
+		if (this.dontFragmentRelations.getValue(entityId, componentType) !== void 0 || this.dontFragmentRelations.getAllForEntity(entityId).some(([t]) => t === componentType)) return this.dontFragmentRelations.getValue(entityId, componentType);
 		throw new Error(`Component type ${componentType} not found for entity ${entityId}`);
 	}
 	getOptional(entityId, componentType) {
@@ -945,8 +946,9 @@ var Archetype = class {
 			if (data === MISSING_COMPONENT) return void 0;
 			return { value: data };
 		}
-		const dontFragmentData = this.dontFragmentRelations.get(entityId);
-		if (dontFragmentData?.has(componentType)) return { value: dontFragmentData.get(componentType) };
+		const value = this.dontFragmentRelations.getValue(entityId, componentType);
+		if (value !== void 0) return { value };
+		if (this.dontFragmentRelations.getAllForEntity(entityId).some(([t]) => t === componentType)) return { value: this.dontFragmentRelations.getValue(entityId, componentType) };
 	}
 	set(entityId, componentType, data) {
 		const index = this.entityToIndex.get(entityId);
@@ -957,12 +959,7 @@ var Archetype = class {
 		}
 		const detailedType = getDetailedIdType(componentType);
 		if (isRelationType(detailedType) && isDontFragmentComponent(detailedType.componentId)) {
-			let dontFragmentData = this.dontFragmentRelations.get(entityId);
-			if (!dontFragmentData) {
-				dontFragmentData = /* @__PURE__ */ new Map();
-				this.dontFragmentRelations.set(entityId, dontFragmentData);
-			}
-			dontFragmentData.set(componentType, data);
+			this.dontFragmentRelations.setValue(entityId, componentType, data);
 			return;
 		}
 		throw new Error(`Component type ${componentType} is not in this archetype`);
@@ -1026,12 +1023,15 @@ var Archetype = class {
 	}
 	forEach(callback) {
 		for (let i = 0; i < this.entities.length; i++) {
+			const entity = this.entities[i];
 			const components = /* @__PURE__ */ new Map();
 			for (const componentType of this.componentTypes) {
 				const data = this.getComponentData(componentType)[i];
 				components.set(componentType, data === MISSING_COMPONENT ? void 0 : data);
 			}
-			callback(this.entities[i], components);
+			const dontFragmentTuples = this.dontFragmentRelations.getAllForEntity(entity);
+			for (const [componentType, data] of dontFragmentTuples) components.set(componentType, data);
+			callback(entity, components);
 		}
 	}
 	hasRelationWithComponentId(componentId) {
@@ -1039,32 +1039,165 @@ var Archetype = class {
 			const detailedType = getDetailedIdType(componentType);
 			if (isRelationType(detailedType) && detailedType.componentId === componentId) return true;
 		}
-		for (const entityId of this.entities) {
-			const entityDontFragmentRelations = this.dontFragmentRelations.get(entityId);
-			if (entityDontFragmentRelations) for (const relationType of entityDontFragmentRelations.keys()) {
-				const detailedType = getDetailedIdType(relationType);
-				if (isRelationType(detailedType) && detailedType.componentId === componentId) return true;
-			}
-		}
+		for (const entityId of this.entities) if (this.dontFragmentRelations.getRelationsForComponent(entityId, componentId).length > 0) return true;
 		return false;
 	}
 };
 //#endregion
 //#region src/archetype/store.ts
 /**
-* Default implementation backed by a plain `Map`.
-* Created once by `World` and shared with every `Archetype`.
+* Production implementation of DontFragmentStore.
+*
+* Internal layout (optimized):
+* - byComponent: baseComponentId → (entityId → RelationEntry)
+*   RelationEntry uses a single-value form for the common exclusive case (1 target),
+*   avoiding Map allocation entirely for the vast majority of dontFragment usage.
+* - entityIndex: entityId → Set<baseComponentId>
+*   Lightweight reverse index.
 */
 var DontFragmentStoreImpl = class {
-	data = /* @__PURE__ */ new Map();
-	get(entityId) {
-		return this.data.get(entityId);
+	/**
+	* Primary storage, keyed by the base relation component ID.
+	*/
+	byComponent = /* @__PURE__ */ new Map();
+	/**
+	* Reverse index: which base component kinds an entity participates in.
+	* Used only by the infrequent getAllForEntity / deleteEntity paths.
+	*/
+	entityIndex = /* @__PURE__ */ new Map();
+	getValue(entityId, relationType) {
+		const componentId = getComponentIdFromRelationId(relationType);
+		if (componentId === void 0) return void 0;
+		const entities = this.byComponent.get(componentId);
+		if (!entities) return void 0;
+		const entry = entities.get(entityId);
+		if (!entry) return void 0;
+		const targetId = getTargetIdFromRelationId(relationType);
+		if (entry.type === "single") return entry.target === targetId ? entry.data : void 0;
+		else {
+			const item = entry.targets.get(targetId);
+			return item ? item.data : void 0;
+		}
+	}
+	setValue(entityId, relationType, data) {
+		const componentId = getComponentIdFromRelationId(relationType);
+		if (componentId === void 0) throw new Error("setValue called with a non-relation type on DontFragmentStore");
+		let entities = this.byComponent.get(componentId);
+		if (!entities) {
+			entities = /* @__PURE__ */ new Map();
+			this.byComponent.set(componentId, entities);
+		}
+		const targetId = getTargetIdFromRelationId(relationType);
+		let entry = entities.get(entityId);
+		if (!entry) {
+			entry = {
+				type: "single",
+				relationType,
+				target: targetId,
+				data
+			};
+			entities.set(entityId, entry);
+		} else if (entry.type === "single") if (entry.target === targetId) {
+			entry.data = data;
+			entry.relationType = relationType;
+		} else {
+			const targets = /* @__PURE__ */ new Map();
+			targets.set(entry.target, {
+				relationType: entry.relationType,
+				data: entry.data
+			});
+			targets.set(targetId, {
+				relationType,
+				data
+			});
+			entities.set(entityId, {
+				type: "multi",
+				targets
+			});
+		}
+		else entry.targets.set(targetId, {
+			relationType,
+			data
+		});
+		let components = this.entityIndex.get(entityId);
+		if (!components) {
+			components = /* @__PURE__ */ new Set();
+			this.entityIndex.set(entityId, components);
+		}
+		components.add(componentId);
+	}
+	deleteValue(entityId, relationType) {
+		const componentId = getComponentIdFromRelationId(relationType);
+		if (componentId === void 0) return false;
+		const entities = this.byComponent.get(componentId);
+		if (!entities) return false;
+		const entry = entities.get(entityId);
+		if (!entry) return false;
+		const targetId = getTargetIdFromRelationId(relationType);
+		let existed = false;
+		if (entry.type === "single") {
+			if (entry.target === targetId) {
+				existed = true;
+				entities.delete(entityId);
+			}
+		} else {
+			existed = entry.targets.delete(targetId);
+			if (entry.targets.size === 0) entities.delete(entityId);
+			else if (entry.targets.size === 1) {
+				const [first] = entry.targets.entries();
+				const [t, item] = first;
+				entities.set(entityId, {
+					type: "single",
+					relationType: item.relationType,
+					target: t,
+					data: item.data
+				});
+			}
+		}
+		if (!entities.has(entityId) && entities.size === 0) this.byComponent.delete(componentId);
+		const components = this.entityIndex.get(entityId);
+		if (components && !entities.has(entityId)) {
+			components.delete(componentId);
+			if (components.size === 0) this.entityIndex.delete(entityId);
+		}
+		return existed;
 	}
-	set(entityId, data) {
-		this.data.set(entityId, data);
+	hasAnyForComponent(componentId) {
+		const entities = this.byComponent.get(componentId);
+		return entities !== void 0 && entities.size > 0;
 	}
-	delete(entityId) {
-		this.data.delete(entityId);
+	getRelationsForComponent(entityId, componentId) {
+		const result = [];
+		const entities = this.byComponent.get(componentId);
+		if (!entities) return result;
+		const entry = entities.get(entityId);
+		if (!entry) return result;
+		if (entry.type === "single") result.push([entry.target, entry.data]);
+		else for (const [target, item] of entry.targets) result.push([target, item.data]);
+		return result;
+	}
+	getAllForEntity(entityId) {
+		const components = this.entityIndex.get(entityId);
+		if (!components || components.size === 0) return [];
+		const result = [];
+		for (const componentId of components) {
+			const entry = this.byComponent.get(componentId)?.get(entityId);
+			if (entry) if (entry.type === "single") result.push([entry.relationType, entry.data]);
+			else for (const item of entry.targets.values()) result.push([item.relationType, item.data]);
+		}
+		return result;
+	}
+	deleteEntity(entityId) {
+		const components = this.entityIndex.get(entityId);
+		if (!components) return;
+		for (const componentId of components) {
+			const entities = this.byComponent.get(componentId);
+			if (entities) {
+				entities.delete(entityId);
+				if (entities.size === 0) this.byComponent.delete(componentId);
+			}
+		}
+		this.entityIndex.delete(entityId);
 	}
 };
 //#endregion
@@ -1789,6 +1922,10 @@ function maybeRemoveWildcardMarker(entityId, archetype, removedComponentType, co
 		if (changeset.removes.has(otherComponentType)) continue;
 		if (getComponentIdFromRelationId(otherComponentType) === componentId) return;
 	}
+	for (const addedType of changeset.adds.keys()) {
+		if (addedType === removedComponentType) continue;
+		if (getComponentIdFromRelationId(addedType) === componentId) return;
+	}
 	changeset.delete(wildcardMarker);
 }
 function hasEntityComponent(archetype, entityId, componentType) {
@@ -1835,40 +1972,20 @@ function applyChangeset(ctx, entityId, currentArchetype, changeset, entityToArch
 }
 /**
 * No-hooks variant of applyDontFragmentChanges that skips tracking removed component data.
+*
+* Rewritten for the new DontFragmentStore interface (ComponentId-primary storage).
 */
 function applyDontFragmentChanges(dontFragmentRelations, entityId, changeset, removedComponents) {
-	let entityRelations = 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, component] of changeset.adds) if (isDontFragmentRelation(componentType)) {
-		if (!entityRelations) {
-			entityRelations = /* @__PURE__ */ new Map();
-			dontFragmentRelations.set(entityId, entityRelations);
-		}
-		entityRelations.set(componentType, component);
+		const removedValue = dontFragmentRelations.getValue(entityId, componentType);
+		if (removedValue !== void 0 || dontFragmentRelations.getAllForEntity(entityId).some(([t]) => t === componentType)) removedComponents.set(componentType, removedValue);
+		dontFragmentRelations.deleteValue(entityId, componentType);
 	}
-	if (entityRelations && entityRelations.size === 0) dontFragmentRelations.delete(entityId);
+	for (const [componentType, component] of changeset.adds) if (isDontFragmentRelation(componentType)) dontFragmentRelations.setValue(entityId, componentType, component);
 }
 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] of changeset.adds) if (isDontFragmentRelation(componentType)) {
-		if (!entityRelations) {
-			entityRelations = /* @__PURE__ */ new Map();
-			dontFragmentRelations.set(entityId, entityRelations);
-		}
-		entityRelations.set(componentType, component);
-	}
-	if (entityRelations && entityRelations.size === 0) dontFragmentRelations.delete(entityId);
+	for (const componentType of changeset.removes) if (isDontFragmentRelation(componentType)) dontFragmentRelations.deleteValue(entityId, componentType);
+	for (const [componentType, component] of changeset.adds) if (isDontFragmentRelation(componentType)) dontFragmentRelations.setValue(entityId, componentType, component);
 }
 function filterRegularComponentTypes(componentTypes) {
 	const regularTypes = [];
@@ -2131,10 +2248,35 @@ var MultiMap = class {
 };
 //#endregion
 //#region src/world/references.ts
+/**
+* Record that `sourceEntityId` holds a reference to `targetEntityId` via the given component/relation.
+*
+* Called when an entity-valued component or an entity-relation is added to an entity.
+*
+* @param entityReferences - The shared reverse index map
+* @param sourceEntityId - The entity that contains the reference
+* @param componentType - The component type or encoded relation ID used for the reference
+* @param targetEntityId - The entity being referenced
+*
+* @internal
+*/
 function trackEntityReference(entityReferences, sourceEntityId, componentType, targetEntityId) {
 	if (!entityReferences.has(targetEntityId)) entityReferences.set(targetEntityId, new MultiMap());
 	entityReferences.get(targetEntityId).add(sourceEntityId, componentType);
 }
+/**
+* Remove the record that `sourceEntityId` references `targetEntityId` via the given component/relation.
+*
+* Called when an entity-valued component or entity-relation is removed (or during deletion).
+* Automatically prunes empty target entries from the map.
+*
+* @param entityReferences - The shared reverse index map
+* @param sourceEntityId - The entity that no longer holds the reference
+* @param componentType - The component type or encoded relation ID that was used
+* @param targetEntityId - The previously referenced entity
+*
+* @internal
+*/
 function untrackEntityReference(entityReferences, sourceEntityId, componentType, targetEntityId) {
 	const references = entityReferences.get(targetEntityId);
 	if (references) {
@@ -2142,6 +2284,19 @@ function untrackEntityReference(entityReferences, sourceEntityId, componentType,
 		if (references.keyCount === 0) entityReferences.delete(targetEntityId);
 	}
 }
+/**
+* Iterate over all (sourceEntityId, componentOrRelationId) pairs that currently reference the given target.
+*
+* Returns an empty iterable when the target has no incoming references.
+* The returned iterable yields `[source, componentType]` pairs suitable for cleanup decisions
+* (e.g. whether to cascade-delete the source or just remove the specific component/relation).
+*
+* @param entityReferences - The shared reverse index map
+* @param targetEntityId - The entity whose referrers we want to inspect
+* @returns Iterable of [sourceEntityId, componentOrRelationId]
+*
+* @internal
+*/
 function getEntityReferences(entityReferences, targetEntityId) {
 	return entityReferences.get(targetEntityId) ?? new MultiMap();
 }
@@ -2523,7 +2678,10 @@ var World = class {
 		const archetype = this.entityToArchetype.get(entityId);
 		if (!archetype) return false;
 		if (archetype.componentTypeSet.has(componentType)) return true;
-		if (isDontFragmentRelation(componentType)) return this.dontFragmentStore.get(entityId)?.has(componentType) ?? false;
+		if (isDontFragmentRelation(componentType)) {
+			if (this.dontFragmentStore.getValue(entityId, componentType) !== void 0) return true;
+			return this.dontFragmentStore.getAllForEntity(entityId).some(([t]) => t === componentType);
+		}
 		return false;
 	}
 	get(entityId, componentType = entityId) {
@@ -2536,7 +2694,7 @@ var World = class {
 		if (componentType >= 0 || componentType % RELATION_SHIFT !== 0) {
 			const inArchetype = archetype.componentTypeSet.has(componentType);
 			const hasDontFragment = isDontFragmentRelation(componentType);
-			if (!(inArchetype || hasDontFragment && this.dontFragmentStore.get(entityId)?.has(componentType))) throw new Error(`Entity ${entityId} does not have component ${componentType}. Use has() to check component existence before calling get().`);
+			if (!(inArchetype || hasDontFragment && (this.dontFragmentStore.getValue(entityId, componentType) !== void 0 || this.dontFragmentStore.getAllForEntity(entityId).some(([t]) => t === 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);
 	}