@codehz/ecs 0.5.1 → 0.5.2

package/world.mjs

@@ -1,101 +1,4 @@
-//#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
+//#region src/core/entity-types.ts
 const COMPONENT_ID_MAX = 1023;
 const ENTITY_ID_START = 1024;
 /**
@@ -104,34 +7,11 @@ 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;
-	if (targetId === "*") actualTargetId = WILDCARD_TARGET_ID;
-	else {
-		if (!isEntityId(targetId) && !isComponentId(targetId)) throw new Error("Second argument must be a valid entity ID, component ID, or '*'");
-		actualTargetId = targetId;
-	}
-	return -(componentId * RELATION_SHIFT + actualTargetId);
-}
 /**
 * Check if an ID is a component ID
 */
@@ -150,6 +30,32 @@ function isEntityId(id) {
 function isRelationId(id) {
 	return id < 0;
 }
+
+//#endregion
+//#region src/core/entity-relation.ts
+/**
+* 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
+	};
+}
+function relation(componentId, targetId) {
+	if (!isComponentId(componentId)) throw new Error("First argument must be a valid component ID");
+	let actualTargetId;
+	if (targetId === "*") actualTargetId = WILDCARD_TARGET_ID;
+	else {
+		if (!isEntityId(targetId) && !isComponentId(targetId)) throw new Error("Second argument must be a valid entity ID, component ID, or '*'");
+		actualTargetId = targetId;
+	}
+	return -(componentId * RELATION_SHIFT + actualTargetId);
+}
 /**
 * Check if an ID is a wildcard relation id
 */
@@ -192,7 +98,7 @@ function decodeRelationId(relationId) {
 function getIdType(id) {
 	if (isComponentId(id)) return "component";
 	if (isEntityId(id)) return "entity";
-	if (isRelationId(id)) try {
+	if (id < 0) try {
 		const decoded = decodeRelationId(id);
 		if (decoded.type !== "wildcard" && !isEntityId(decoded.targetId) && !isComponentId(decoded.targetId)) return "invalid";
 		switch (decoded.type) {
@@ -213,7 +119,7 @@ function getIdType(id) {
 function getDetailedIdType(id) {
 	if (isComponentId(id)) return { type: "component" };
 	if (isEntityId(id)) return { type: "entity" };
-	if (isRelationId(id)) try {
+	if (id < 0) try {
 		const decoded = decodeRelationId(id);
 		if (decoded.type !== "wildcard" && !isEntityId(decoded.targetId) && !isComponentId(decoded.targetId)) return { type: "invalid" };
 		let type;
@@ -239,6 +145,32 @@ function getDetailedIdType(id) {
 	return { type: "invalid" };
 }
 /**
+* 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
+//#region src/core/entity-manager.ts
+/**
 * Entity ID Manager for automatic allocation and freelist recycling
 */
 var EntityIdManager = class {
@@ -330,80 +262,180 @@ var ComponentIdAllocator = class {
 		return this.nextId <= COMPONENT_ID_MAX;
 	}
 };
-const globalComponentIdAllocator = new ComponentIdAllocator();
-const ComponentIdForNames = /* @__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
-* @returns The allocated component ID
-* @example
-* // Just a name
-* const Position = component<Position>("Position");
-*
-* // With options
-* const ChildOf = component({ exclusive: true, cascadeDelete: true });
-*
-* // With name and options
-* const ChildOf = component({ name: "ChildOf", exclusive: true });
-*/
-function component(nameOrOptions) {
-	const id = globalComponentIdAllocator.allocate();
-	let name;
-	let options;
-	if (typeof nameOrOptions === "string") name = nameOrOptions;
-	else if (typeof nameOrOptions === "object" && nameOrOptions !== null) {
-		options = nameOrOptions;
-		name = options.name;
+
+//#endregion
+//#region src/utils/bit-set.ts
+var BitSet = class {
+	data;
+	_length;
+	constructor(length) {
+		this._length = length;
+		const numWords = Math.ceil(length / 32);
+		this.data = new Uint32Array(numWords);
 	}
-	if (name) {
-		if (ComponentIdForNames.has(name)) throw new Error(`Component name "${name}" is already registered`);
-		componentNames[id] = name;
-		ComponentIdForNames.set(name, id);
+	get length() {
+		return this._length;
 	}
-	if (options) {
-		if (options.exclusive) exclusiveFlags.set(id);
-		if (options.cascadeDelete) cascadeDeleteFlags.set(id);
-		if (options.dontFragment) dontFragmentFlags.set(id);
+	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;
 	}
-	return id;
-}
-/**
-* Get a component ID by its registered name
-* @param name The component name
-* @returns The component ID if found, undefined otherwise
-*/
-function getComponentIdByName(name) {
-	return ComponentIdForNames.get(name);
-}
-/** Get a component name by its ID
-* @param id The component ID
-* @returns The component name if found, undefined otherwise
-*/
-function getComponentNameById(id) {
-	return componentNames[id];
-}
-/**
-* Check if a component is marked as exclusive
-* @param id The component ID
-* @returns true if the component is exclusive, false otherwise
-*/
-function isExclusiveComponent(id) {
-	return exclusiveFlags.has(id);
-}
-/**
-* Check if a component is marked as dontFragment
-* @param id The component ID
-* @returns true if the component is dontFragment, false otherwise
-*/
-function isDontFragmentComponent(id) {
-	return dontFragmentFlags.has(id);
-}
-/**
-* Generic function to check relation flags with specific target conditions
+	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/core/component-registry.ts
+const globalComponentIdAllocator = new ComponentIdAllocator();
+const ComponentIdForNames = /* @__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
+* @returns The allocated component ID
+* @example
+* // Just a name
+* const Position = component<Position>("Position");
+*
+* // With options
+* const ChildOf = component({ exclusive: true, cascadeDelete: true });
+*
+* // With name and options
+* const ChildOf = component({ name: "ChildOf", exclusive: true });
+*/
+function component(nameOrOptions) {
+	const id = globalComponentIdAllocator.allocate();
+	let name;
+	let options;
+	if (typeof nameOrOptions === "string") name = nameOrOptions;
+	else if (typeof nameOrOptions === "object" && nameOrOptions !== null) {
+		options = nameOrOptions;
+		name = options.name;
+	}
+	if (name) {
+		if (ComponentIdForNames.has(name)) throw new Error(`Component name "${name}" is already registered`);
+		componentNames[id] = name;
+		ComponentIdForNames.set(name, id);
+	}
+	if (options) {
+		if (options.exclusive) exclusiveFlags.set(id);
+		if (options.cascadeDelete) cascadeDeleteFlags.set(id);
+		if (options.dontFragment) dontFragmentFlags.set(id);
+	}
+	return id;
+}
+/**
+* Get a component ID by its registered name
+* @param name The component name
+* @returns The component ID if found, undefined otherwise
+*/
+function getComponentIdByName(name) {
+	return ComponentIdForNames.get(name);
+}
+/** Get a component name by its ID
+* @param id The component ID
+* @returns The component name if found, undefined otherwise
+*/
+function getComponentNameById(id) {
+	return componentNames[id];
+}
+/**
+* Check if a component is marked as exclusive
+* @param id The component ID
+* @returns true if the component is exclusive, false otherwise
+*/
+function isExclusiveComponent(id) {
+	return exclusiveFlags.has(id);
+}
+/**
+* Check if a component is marked as dontFragment
+* @param id The component ID
+* @returns true if the component is dontFragment, false otherwise
+*/
+function isDontFragmentComponent(id) {
+	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
@@ -443,920 +475,803 @@ function isDontFragmentWildcard(id) {
 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
-//#region src/types.ts
-function isOptionalEntityId(type) {
-	return typeof type === "object" && type !== null && "optional" in type;
-}
+//#region src/core/builder.ts
+var EntityBuilder = class {
+	world;
+	components = [];
+	constructor(world) {
+		this.world = world;
+	}
+	with(componentId, value) {
+		this.components.push({
+			type: "component",
+			id: componentId,
+			value
+		});
+		return this;
+	}
+	withTag(componentId) {
+		this.components.push({
+			type: "component",
+			id: componentId,
+			value: void 0
+		});
+		return this;
+	}
+	withRelation(componentId, targetEntity, value) {
+		this.components.push({
+			type: "relation",
+			componentId,
+			targetId: targetEntity,
+			value
+		});
+		return this;
+	}
+	withRelationTag(componentId, targetEntity) {
+		this.components.push({
+			type: "relation",
+			componentId,
+			targetId: targetEntity,
+			value: void 0
+		});
+		return this;
+	}
+	/**
+	* Create an entity and enqueue components to be applied. This method
+	* does NOT call `world.sync()` automatically; callers must invoke
+	* `world.sync()` to apply deferred commands.
+	* (Previously auto-synced; now a breaking change — buildDeferred() removed.)
+	*/
+	build() {
+		const entity = this.world.new();
+		for (const def of this.components) if (def.type === "component") this.world.set(entity, def.id, def.value);
+		else {
+			const relationId = relation(def.componentId, def.targetId);
+			this.world.set(entity, relationId, def.value);
+		}
+		return entity;
+	}
+};
 
 //#endregion
-//#region src/utils.ts
-/**
-* Utility functions for ECS library
-*/
+//#region src/commands/changeset.ts
 /**
-* Get a value from cache or compute and cache it if not present
-* @param cache The cache map
-* @param key The cache key
-* @param compute Function to compute the value if not cached
-* @returns The cached or computed value
+* @internal Represents a set of component changes to be applied to an entity
 */
-function getOrComputeCache(cache, key, compute) {
-	let value = cache.get(key);
-	if (value === void 0) {
-		value = compute();
-		cache.set(key, value);
-	}
-	return value;
-}
-/**
-* Get a value from cache or create and cache it if not present, allowing side effects during creation
-* @param cache The cache map
-* @param key The cache key
-* @param create Function to create the value if not cached (can have side effects)
-* @returns The cached or created value
-*/
-function getOrCreateWithSideEffect(cache, key, create) {
-	let value = cache.get(key);
-	if (value === void 0) {
-		value = create();
-		cache.set(key, value);
-	}
-	return value;
-}
-
-//#endregion
-//#region src/archetype.ts
-/**
-* Special value to represent missing component data
-*/
-const MISSING_COMPONENT = Symbol("missing component");
-/**
-* Archetype class for ECS architecture
-* Represents a group of entities that share the same set of components
-* Optimized for fast iteration and component access
-*/
-var Archetype = class {
-	/**
-	* The component types that define this archetype
-	*/
-	componentTypes;
-	/**
-	* List of entities in this archetype
-	*/
-	entities = [];
-	/**
-	* Component data storage - maps component type to array of component data
-	* Each array index corresponds to the entity index in the entities array
-	*/
-	componentData = /* @__PURE__ */ new Map();
-	/**
-	* Reverse mapping from entity to its index in this archetype
-	*/
-	entityToIndex = /* @__PURE__ */ new Map();
-	/**
-	* Reference to dontFragment relations storage from World
-	* This allows entities with different relation targets to share the same archetype
-	* Stored in World to avoid migration overhead when entities change archetypes
-	*/
-	dontFragmentRelations;
+var ComponentChangeset = class {
+	adds = /* @__PURE__ */ new Map();
+	removes = /* @__PURE__ */ new Set();
 	/**
-	* Cache for pre-computed component data sources to avoid repeated calculations
-	* For regular components: data array
-	* For wildcards: matching relation types array
+	* Add a component to the changeset
 	*/
-	componentDataSourcesCache = /* @__PURE__ */ new Map();
+	set(componentType, component$1) {
+		this.adds.set(componentType, component$1);
+		this.removes.delete(componentType);
+	}
 	/**
-	* Create a new archetype with the specified component types
-	* @param componentTypes The component types that define this archetype
-	* @param dontFragmentRelations Reference to the World's dontFragmentRelations storage
+	* Remove a component from the changeset
 	*/
-	constructor(componentTypes, dontFragmentRelations) {
-		this.componentTypes = [...componentTypes].sort((a, b) => a - b);
-		this.dontFragmentRelations = dontFragmentRelations;
-		for (const componentType of this.componentTypes) this.componentData.set(componentType, []);
+	delete(componentType) {
+		this.removes.add(componentType);
+		this.adds.delete(componentType);
 	}
 	/**
-	* Get the number of entities in this archetype
+	* Check if the changeset has any changes
 	*/
-	get size() {
-		return this.entities.length;
+	hasChanges() {
+		return this.adds.size > 0 || this.removes.size > 0;
 	}
 	/**
-	* Check if this archetype matches the given component types
-	* @param componentTypes The component types to check
+	* Clear all changes
 	*/
-	matches(componentTypes) {
-		if (this.componentTypes.length !== componentTypes.length) return false;
-		const sortedTypes = [...componentTypes].sort((a, b) => a - b);
-		return this.componentTypes.every((type, index) => type === sortedTypes[index]);
+	clear() {
+		this.adds.clear();
+		this.removes.clear();
 	}
 	/**
-	* Add an entity to this archetype with initial component data
-	* @param entityId The entity to add
-	* @param componentData Map of component type to component data (includes both regular and dontFragment components)
+	* Merge another changeset into this one
 	*/
-	addEntity(entityId, componentData) {
-		if (this.entityToIndex.has(entityId)) throw new Error(`Entity ${entityId} is already in this archetype`);
-		const index = this.entities.length;
-		this.entities.push(entityId);
-		this.entityToIndex.set(entityId, index);
-		for (const componentType of this.componentTypes) {
-			const data = componentData.get(componentType);
-			this.getComponentData(componentType).push(!componentData.has(componentType) ? MISSING_COMPONENT : data);
+	merge(other) {
+		for (const [componentType, component$1] of other.adds) {
+			this.adds.set(componentType, component$1);
+			this.removes.delete(componentType);
 		}
-		const dontFragmentData = /* @__PURE__ */ new Map();
-		for (const [componentType, data] of componentData) {
-			if (this.componentTypes.includes(componentType)) continue;
-			const detailedType = getDetailedIdType(componentType);
-			if ((detailedType.type === "entity-relation" || detailedType.type === "component-relation") && isDontFragmentComponent(detailedType.componentId)) dontFragmentData.set(componentType, data);
+		for (const componentType of other.removes) {
+			this.removes.add(componentType);
+			this.adds.delete(componentType);
 		}
-		if (dontFragmentData.size > 0) this.dontFragmentRelations.set(entityId, dontFragmentData);
 	}
 	/**
-	* Get all component data for a specific entity
-	* @param entityId The entity to get data for
-	* @returns Map of component type to component data (includes both regular and dontFragment components)
+	* Apply the changeset to existing components and return the final state
 	*/
-	getEntity(entityId) {
-		const index = this.entityToIndex.get(entityId);
-		if (index === void 0) return;
-		const entityData = /* @__PURE__ */ new Map();
-		for (const componentType of this.componentTypes) {
-			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);
-		return entityData;
+	applyTo(existingComponents) {
+		for (const componentType of this.removes) existingComponents.delete(componentType);
+		for (const [componentType, component$1] of this.adds) existingComponents.set(componentType, component$1);
+		return existingComponents;
 	}
 	/**
-	* Dump all entities and their component data in this archetype
-	* @returns Array of objects with entity and component data (includes both regular and dontFragment components)
+	* Get the final component types after applying the changeset
+	* @param existingComponentTypes - The current component types on the entity
+	* @returns The final component types or undefined if no changes
 	*/
-	dump() {
-		const result = [];
-		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);
+	getFinalComponentTypes(existingComponentTypes) {
+		const finalComponentTypes = new Set(existingComponentTypes);
+		let changed = false;
+		for (const componentType of this.removes) {
+			if (!finalComponentTypes.has(componentType)) {
+				this.removes.delete(componentType);
+				continue;
 			}
-			const dontFragmentData = this.dontFragmentRelations.get(entity);
-			if (dontFragmentData) for (const [componentType, data] of dontFragmentData) components.set(componentType, data);
-			result.push({
-				entity,
-				components
-			});
+			changed = true;
+			finalComponentTypes.delete(componentType);
 		}
-		return result;
+		for (const componentType of this.adds.keys()) {
+			if (finalComponentTypes.has(componentType)) continue;
+			changed = true;
+			finalComponentTypes.add(componentType);
+		}
+		return changed ? Array.from(finalComponentTypes) : void 0;
 	}
+};
+
+//#endregion
+//#region src/commands/command-buffer.ts
+/**
+* Command buffer for deferred structural changes
+*/
+var CommandBuffer = class {
+	commands = [];
+	executeEntityCommands;
 	/**
-	* Remove an entity from this archetype
-	* @param entityId The entity to remove
-	* @returns The component data of the removed entity (includes both regular and dontFragment components)
+	* Create a command buffer with an executor function
 	*/
-	removeEntity(entityId) {
-		const index = this.entityToIndex.get(entityId);
-		if (index === void 0) return;
-		const removedData = /* @__PURE__ */ new Map();
-		for (const componentType of this.componentTypes) {
-			const dataArray = this.getComponentData(componentType);
-			removedData.set(componentType, dataArray[index]);
-		}
-		const dontFragmentData = this.dontFragmentRelations.get(entityId);
-		if (dontFragmentData) {
-			for (const [componentType, data] of dontFragmentData) removedData.set(componentType, data);
-			this.dontFragmentRelations.delete(entityId);
-		}
-		this.entityToIndex.delete(entityId);
-		const lastIndex = this.entities.length - 1;
-		if (index !== lastIndex) {
-			const lastEntity = this.entities[lastIndex];
-			this.entities[index] = lastEntity;
-			this.entityToIndex.set(lastEntity, index);
-			for (const componentType of this.componentTypes) {
-				const dataArray = this.getComponentData(componentType);
-				dataArray[index] = dataArray[lastIndex];
-			}
-		}
-		this.entities.pop();
-		for (const componentType of this.componentTypes) this.getComponentData(componentType).pop();
-		return removedData;
+	constructor(executeEntityCommands) {
+		this.executeEntityCommands = executeEntityCommands;
+	}
+	set(entityId, componentType, component$1) {
+		this.commands.push({
+			type: "set",
+			entityId,
+			componentType,
+			component: component$1
+		});
 	}
 	/**
-	* Check if an entity is in this archetype
-	* @param entityId The entity to check
+	* Remove a component from an entity (deferred)
 	*/
-	exists(entityId) {
-		return this.entityToIndex.has(entityId);
-	}
-	get(entityId, componentType) {
-		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 = getComponentIdFromRelationId(componentType);
-			const relations = [];
-			for (const relType of this.componentTypes) {
-				const relDetailed = getDetailedIdType(relType);
-				if ((relDetailed.type === "entity-relation" || relDetailed.type === "component-relation") && relDetailed.componentId === componentId) {
-					const dataArray = this.getComponentData(relType);
-					if (dataArray && dataArray[index] !== void 0) {
-						const data = dataArray[index];
-						relations.push([relDetailed.targetId, data === MISSING_COMPONENT ? void 0 : data]);
-					}
-				}
-			}
-			const dontFragmentData = this.dontFragmentRelations.get(entityId);
-			if (dontFragmentData) for (const [relType, data] of dontFragmentData) {
-				const relDetailed = getDetailedIdType(relType);
-				if ((relDetailed.type === "entity-relation" || relDetailed.type === "component-relation") && relDetailed.componentId === componentId) relations.push([relDetailed.targetId, data]);
-			}
-			return relations;
-		} else {
-			if (this.componentTypes.includes(componentType)) {
-				const data = this.getComponentData(componentType)[index];
-				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 && dontFragmentData.has(componentType)) return dontFragmentData.get(componentType);
-			throw new Error(`Component type ${componentType} not found for entity ${entityId}`);
-		}
+	remove(entityId, componentType) {
+		this.commands.push({
+			type: "delete",
+			entityId,
+			componentType
+		});
 	}
 	/**
-	* Get optional component data for a specific entity and component type
-	* @param entityId The entity
-	* @param componentType The component type
-	* @returns { value: T } if component exists, undefined otherwise
+	* Destroy an entity (deferred)
 	*/
-	getOptional(entityId, componentType) {
-		const index = this.entityToIndex.get(entityId);
-		if (index === void 0) throw new Error(`Entity ${entityId} is not in this archetype`);
-		if (this.componentTypes.includes(componentType)) {
-			const data = this.getComponentData(componentType)[index];
-			if (data === MISSING_COMPONENT) return;
-			return { value: data };
-		}
-		const dontFragmentData = this.dontFragmentRelations.get(entityId);
-		if (dontFragmentData && dontFragmentData.has(componentType)) return { value: dontFragmentData.get(componentType) };
+	delete(entityId) {
+		this.commands.push({
+			type: "destroy",
+			entityId
+		});
 	}
 	/**
-	* Set component data for a specific entity and component type
-	* @param entityId The entity
-	* @param componentType The component type
-	* @param data The component data
+	* Execute all commands and clear the buffer
 	*/
-	set(entityId, componentType, data) {
-		const index = this.entityToIndex.get(entityId);
-		if (index === void 0) throw new Error(`Entity ${entityId} is not in this archetype`);
-		if (this.componentData.has(componentType)) {
-			const dataArray = this.getComponentData(componentType);
-			dataArray[index] = data;
-			return;
-		}
-		const detailedType = getDetailedIdType(componentType);
-		if ((detailedType.type === "entity-relation" || detailedType.type === "component-relation") && isDontFragmentComponent(detailedType.componentId)) {
-			let dontFragmentData = this.dontFragmentRelations.get(entityId);
-			if (!dontFragmentData) {
-				dontFragmentData = /* @__PURE__ */ new Map();
-				this.dontFragmentRelations.set(entityId, dontFragmentData);
+	execute() {
+		const MAX_ITERATIONS = 100;
+		let iterations = 0;
+		while (this.commands.length > 0) {
+			if (iterations >= MAX_ITERATIONS) throw new Error("Command execution exceeded maximum iterations, possible infinite loop");
+			iterations++;
+			const currentCommands = [...this.commands];
+			this.commands = [];
+			const entityCommands = /* @__PURE__ */ new Map();
+			for (const cmd of currentCommands) {
+				if (!entityCommands.has(cmd.entityId)) entityCommands.set(cmd.entityId, []);
+				entityCommands.get(cmd.entityId).push(cmd);
 			}
-			dontFragmentData.set(componentType, data);
-			return;
+			for (const [entityId, commands] of entityCommands) this.executeEntityCommands(entityId, commands);
 		}
-		throw new Error(`Component type ${componentType} is not in this archetype`);
 	}
 	/**
-	* Get all entities in this archetype
+	* Get current commands (for testing)
 	*/
-	getEntities() {
-		return this.entities;
+	getCommands() {
+		return [...this.commands];
 	}
 	/**
-	* Get the mapping of entities to their indices in this archetype
-	*/
-	getEntityToIndexMap() {
-		return this.entityToIndex;
-	}
-	/**
-	* Get component data for all entities of a specific component type
-	* @param componentType The component type
-	*/
-	getComponentData(componentType) {
-		const data = this.componentData.get(componentType);
-		if (!data) throw new Error(`Component type ${componentType} is not in this archetype`);
-		return data;
-	}
-	/**
-	* Get optional component data for all entities of a specific component type
-	* @param componentType The component type
-	* @returns An array of component data or undefined if not present
-	*/
-	getOptionalComponentData(componentType) {
-		return this.componentData.get(componentType);
-	}
-	/**
-	* Helper: compute or return cached data sources for provided componentTypes
-	*/
-	getCachedComponentDataSources(componentTypes) {
-		const cacheKey = this.buildCacheKey(componentTypes);
-		return getOrComputeCache(this.componentDataSourcesCache, cacheKey, () => componentTypes.map((compType) => this.getComponentDataSource(compType)));
-	}
-	/**
-	* Build cache key for component types
-	*/
-	buildCacheKey(componentTypes) {
-		return componentTypes.map((id) => isOptionalEntityId(id) ? `opt(${id.optional})` : `${id}`).join(",");
-	}
-	/**
-	* Get data source for a single component type
+	* Clear all commands
 	*/
-	getComponentDataSource(compType) {
-		const optional = isOptionalEntityId(compType);
-		const actualType = optional ? compType.optional : compType;
-		const detailedType = getDetailedIdType(actualType);
-		if (detailedType.type === "wildcard-relation") return this.getWildcardRelationDataSource(detailedType.componentId, optional);
-		else return optional ? this.getOptionalComponentData(actualType) : this.getComponentData(actualType);
+	clear() {
+		this.commands = [];
 	}
-	/**
-	* Get data source for wildcard relations
-	*/
-	getWildcardRelationDataSource(componentId, optional) {
-		const matchingRelations = this.componentTypes.filter((ct) => {
-			const detailedCt = getDetailedIdType(ct);
-			return (detailedCt.type === "entity-relation" || detailedCt.type === "component-relation") && detailedCt.componentId === componentId;
+};
+
+//#endregion
+//#region src/query/filter.ts
+/**
+* Serialize a QueryFilter into a deterministic string suitable for cache keys.
+* Currently only serializes `negativeComponentTypes`.
+*/
+function serializeQueryFilter(filter = {}) {
+	const negative = (filter.negativeComponentTypes || []).slice().sort((a, b) => a - b);
+	if (negative.length === 0) return "";
+	return `neg:${negative.join(",")}`;
+}
+/**
+* Check if an archetype matches the given component types
+*/
+function matchesComponentTypes(archetype, componentTypes) {
+	return componentTypes.every((type) => {
+		const detailedType = getDetailedIdType(type);
+		if (detailedType.type === "wildcard-relation") return archetype.componentTypes.some((archetypeType) => {
+			if (!isRelationId(archetypeType)) return false;
+			return getComponentIdFromRelationId(archetypeType) === detailedType.componentId;
 		});
-		return optional ? matchingRelations.length > 0 ? matchingRelations : void 0 : matchingRelations;
-	}
-	/**
-	* Helper: build component tuples for a specific entity index using precomputed data sources
-	*/
-	buildComponentsForIndex(componentTypes, componentDataSources, entityIndex, entityId) {
-		return componentDataSources.map((dataSource, i) => {
-			const compType = componentTypes[i];
-			return this.buildSingleComponent(compType, dataSource, entityIndex, entityId);
+		else return archetype.componentTypes.includes(type);
+	});
+}
+/**
+* Check if an archetype matches the filter conditions (only filtering logic)
+*/
+function matchesFilter(archetype, filter) {
+	return (filter.negativeComponentTypes || []).every((type) => {
+		const detailedType = getDetailedIdType(type);
+		if (detailedType.type === "wildcard-relation") return !archetype.componentTypes.some((archetypeType) => {
+			if (!isRelationId(archetypeType)) return false;
+			return getComponentIdFromRelationId(archetypeType) === detailedType.componentId;
 		});
+		else return !archetype.componentTypes.includes(type);
+	});
+}
+
+//#endregion
+//#region src/query/query.ts
+/**
+* Query class for efficient entity queries with cached archetypes
+*/
+var Query = class {
+	world;
+	componentTypes;
+	filter;
+	cachedArchetypes = [];
+	isDisposed = false;
+	/** Cached wildcard component types for faster entity filtering */
+	wildcardTypes;
+	constructor(world, componentTypes, filter = {}) {
+		this.world = world;
+		this.componentTypes = [...componentTypes].sort((a, b) => a - b);
+		this.filter = filter;
+		this.wildcardTypes = this.componentTypes.filter((ct) => getDetailedIdType(ct).type === "wildcard-relation");
+		this.updateCache();
+		world._registerQuery(this);
 	}
 	/**
-	* Build a single component value from its data source
+	* Check if query is disposed and throw error if so
 	*/
-	buildSingleComponent(compType, dataSource, entityIndex, entityId) {
-		const optional = isOptionalEntityId(compType);
-		const actualType = optional ? compType.optional : compType;
-		if (getIdType(actualType) === "wildcard-relation") return this.buildWildcardRelationValue(actualType, dataSource, entityIndex, entityId, optional);
-		else return this.buildRegularComponentValue(dataSource, entityIndex, optional);
+	ensureNotDisposed() {
+		if (this.isDisposed) throw new Error("Query has been disposed");
 	}
 	/**
-	* Build wildcard relation value from matching relations
+	* Get all entities matching the query
 	*/
-	buildWildcardRelationValue(wildcardRelationType, dataSource, entityIndex, entityId, optional) {
-		const matchingRelations = dataSource || [];
-		const relations = [];
-		for (const relType of matchingRelations) {
-			const data = this.getComponentData(relType)[entityIndex];
-			const targetId = getTargetIdFromRelationId(relType);
-			relations.push([targetId, data === MISSING_COMPONENT ? void 0 : data]);
-		}
-		const targetComponentId = getComponentIdFromRelationId(wildcardRelationType);
-		const dontFragmentData = this.dontFragmentRelations.get(entityId);
-		if (dontFragmentData) for (const [relType, data] of dontFragmentData) {
-			const relDetailed = getDetailedIdType(relType);
-			if ((relDetailed.type === "entity-relation" || relDetailed.type === "component-relation") && relDetailed.componentId === targetComponentId) relations.push([relDetailed.targetId, data]);
-		}
-		if (relations.length === 0) {
-			if (!optional) {
-				const componentId = getComponentIdFromRelationId(wildcardRelationType);
-				throw new Error(`No matching relations found for mandatory wildcard relation component ${componentId} on entity ${entityId}`);
-			}
-			return;
+	getEntities() {
+		this.ensureNotDisposed();
+		if (this.wildcardTypes.length === 0) {
+			const result$1 = [];
+			for (const archetype of this.cachedArchetypes) result$1.push(...archetype.getEntities());
+			return result$1;
 		}
-		return optional ? { value: relations } : relations;
+		const result = [];
+		for (const archetype of this.cachedArchetypes) for (const entity of archetype.getEntities()) if (this.entityHasAllWildcards(archetype, entity)) result.push(entity);
+		return result;
 	}
 	/**
-	* Build regular component value from data source
+	* Check if entity has all required wildcard relations
 	*/
-	buildRegularComponentValue(dataSource, entityIndex, optional) {
-		if (dataSource === void 0) {
-			if (optional) return;
-			throw new Error(`Component data not found for mandatory component type`);
+	entityHasAllWildcards(archetype, entity) {
+		for (const wildcardType of this.wildcardTypes) {
+			const relations = archetype.get(entity, wildcardType);
+			if (!relations || relations.length === 0) return false;
 		}
-		const data = dataSource[entityIndex];
-		const result = data === MISSING_COMPONENT ? void 0 : data;
-		return optional ? { value: result } : result;
+		return true;
 	}
 	/**
-	* Get entities with their component data for specified component types
-	* Optimized for bulk component access with pre-computed indices
+	* Get entities with their component data
 	* @param componentTypes Array of component types to retrieve
 	* @returns Array of objects with entity and component data
 	*/
 	getEntitiesWithComponents(componentTypes) {
+		this.ensureNotDisposed();
 		const result = [];
-		this.forEachWithComponents(componentTypes, (entity, ...components) => {
-			result.push({
-				entity,
-				components
-			});
-		});
-		return result;
-	}
-	/**
-	* Iterate over entities with their component data for specified component types
-	* implemented as a generator returning each entity/components pair lazily
-	* @param componentTypes Array of component types to retrieve
-	*/
-	*iterateWithComponents(componentTypes) {
-		const componentDataSources = this.getCachedComponentDataSources(componentTypes);
-		for (let entityIndex = 0; entityIndex < this.entities.length; entityIndex++) {
-			const entity = this.entities[entityIndex];
-			yield [entity, ...this.buildComponentsForIndex(componentTypes, componentDataSources, entityIndex, entity)];
+		for (const archetype of this.cachedArchetypes) {
+			const entitiesWithData = archetype.getEntitiesWithComponents(componentTypes);
+			result.push(...entitiesWithData);
 		}
+		return result;
 	}
 	/**
-	* Iterate over entities with their component data for specified component types
-	* Optimized for bulk component access
+	* Iterate over entities with their component data
 	* @param componentTypes Array of component types to retrieve
 	* @param callback Function called for each entity with its components
 	*/
-	forEachWithComponents(componentTypes, callback) {
-		const componentDataSources = this.getCachedComponentDataSources(componentTypes);
-		for (let entityIndex = 0; entityIndex < this.entities.length; entityIndex++) {
-			const entity = this.entities[entityIndex];
-			callback(entity, ...this.buildComponentsForIndex(componentTypes, componentDataSources, entityIndex, entity));
-		}
+	forEach(componentTypes, callback) {
+		this.ensureNotDisposed();
+		for (const archetype of this.cachedArchetypes) archetype.forEachWithComponents(componentTypes, callback);
 	}
 	/**
-	* Iterate over all entities with their component data
-	* @param callback Function called for each entity with its component data
+	* Iterate over entities with their component data (generator)
+	* @param componentTypes Array of component types to retrieve
 	*/
-	forEach(callback) {
-		for (let i = 0; i < this.entities.length; 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);
-		}
+	*iterate(componentTypes) {
+		this.ensureNotDisposed();
+		for (const archetype of this.cachedArchetypes) yield* archetype.iterateWithComponents(componentTypes);
 	}
 	/**
-	* Check if any entity in this archetype has a relation matching the given component ID
-	* This includes both regular relations in componentTypes and dontFragment relations
-	* @param componentId The component ID to match
-	* @returns true if any entity has a matching relation
+	* Get component data arrays for all matching entities
+	* @param componentType The component type to retrieve
+	* @returns Array of component data for all matching entities
 	*/
-	hasRelationWithComponentId(componentId) {
-		for (const componentType of this.componentTypes) {
-			const detailedType = getDetailedIdType(componentType);
-			if ((detailedType.type === "entity-relation" || detailedType.type === "component-relation") && 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 ((detailedType.type === "entity-relation" || detailedType.type === "component-relation") && detailedType.componentId === componentId) return true;
-			}
-		}
-		return false;
+	getComponentData(componentType) {
+		this.ensureNotDisposed();
+		const result = [];
+		for (const archetype of this.cachedArchetypes) result.push(...archetype.getComponentData(componentType));
+		return result;
 	}
-};
-
-//#endregion
-//#region src/changeset.ts
-/**
-* @internal Represents a set of component changes to be applied to an entity
-*/
-var ComponentChangeset = class {
-	adds = /* @__PURE__ */ new Map();
-	removes = /* @__PURE__ */ new Set();
 	/**
-	* Add a component to the changeset
+	* Update the cached archetypes
+	* Called when new archetypes are created
 	*/
-	set(componentType, component$1) {
-		this.adds.set(componentType, component$1);
-		this.removes.delete(componentType);
+	updateCache() {
+		if (this.isDisposed) return;
+		this.cachedArchetypes = this.world.getMatchingArchetypes(this.componentTypes).filter((archetype) => matchesFilter(archetype, this.filter));
 	}
 	/**
-	* Remove a component from the changeset
+	* Check if a new archetype matches this query and add to cache if it does
 	*/
-	delete(componentType) {
-		this.removes.add(componentType);
-		this.adds.delete(componentType);
+	checkNewArchetype(archetype) {
+		if (this.isDisposed) return;
+		if (matchesComponentTypes(archetype, this.componentTypes) && matchesFilter(archetype, this.filter) && !this.cachedArchetypes.includes(archetype)) this.cachedArchetypes.push(archetype);
 	}
 	/**
-	* Check if the changeset has any changes
+	* Remove an archetype from the cached archetypes
 	*/
-	hasChanges() {
-		return this.adds.size > 0 || this.removes.size > 0;
+	removeArchetype(archetype) {
+		if (this.isDisposed) return;
+		const index = this.cachedArchetypes.indexOf(archetype);
+		if (index !== -1) this.cachedArchetypes.splice(index, 1);
 	}
 	/**
-	* Clear all changes
+	* Request disposal of this query.
+	* This will decrement the world's reference count for the query.
+	* The query will only be fully disposed when the ref count reaches zero.
 	*/
-	clear() {
-		this.adds.clear();
-		this.removes.clear();
+	dispose() {
+		this.world.releaseQuery(this);
 	}
 	/**
-	* Merge another changeset into this one
+	* Internal full dispose called by World when refCount reaches zero.
 	*/
-	merge(other) {
-		for (const [componentType, component$1] of other.adds) {
-			this.adds.set(componentType, component$1);
-			this.removes.delete(componentType);
-		}
-		for (const componentType of other.removes) {
-			this.removes.add(componentType);
-			this.adds.delete(componentType);
+	_disposeInternal() {
+		if (!this.isDisposed) {
+			this.world._unregisterQuery(this);
+			this.cachedArchetypes = [];
+			this.isDisposed = true;
 		}
 	}
 	/**
-	* Apply the changeset to existing components and return the final state
+	* Symbol.dispose implementation for automatic resource management
 	*/
-	applyTo(existingComponents) {
-		for (const componentType of this.removes) existingComponents.delete(componentType);
-		for (const [componentType, component$1] of this.adds) existingComponents.set(componentType, component$1);
-		return existingComponents;
+	[Symbol.dispose]() {
+		this.dispose();
 	}
 	/**
-	* Get the final component types after applying the changeset
-	* @param existingComponentTypes - The current component types on the entity
-	* @returns The final component types or undefined if no changes
+	* Check if the query has been disposed
 	*/
-	getFinalComponentTypes(existingComponentTypes) {
-		const finalComponentTypes = new Set(existingComponentTypes);
-		let changed = false;
-		for (const componentType of this.removes) {
-			if (!finalComponentTypes.has(componentType)) {
-				this.removes.delete(componentType);
-				continue;
-			}
-			changed = true;
-			finalComponentTypes.delete(componentType);
-		}
-		for (const componentType of this.adds.keys()) {
-			if (finalComponentTypes.has(componentType)) continue;
-			changed = true;
-			finalComponentTypes.add(componentType);
-		}
-		return changed ? Array.from(finalComponentTypes) : void 0;
+	get disposed() {
+		return this.isDisposed;
 	}
 };
 
 //#endregion
-//#region src/command-buffer.ts
+//#region src/utils/utils.ts
 /**
-* Command buffer for deferred structural changes
+* Utility functions for ECS library
 */
-var CommandBuffer = class {
-	commands = [];
-	executeEntityCommands;
-	/**
-	* Create a command buffer with an executor function
-	*/
-	constructor(executeEntityCommands) {
-		this.executeEntityCommands = executeEntityCommands;
-	}
-	set(entityId, componentType, component$1) {
-		this.commands.push({
-			type: "set",
-			entityId,
-			componentType,
-			component: component$1
-		});
-	}
-	/**
-	* Remove a component from an entity (deferred)
-	*/
-	remove(entityId, componentType) {
-		this.commands.push({
-			type: "delete",
-			entityId,
-			componentType
-		});
-	}
-	/**
-	* Destroy an entity (deferred)
-	*/
-	delete(entityId) {
-		this.commands.push({
-			type: "destroy",
-			entityId
-		});
-	}
-	/**
-	* Execute all commands and clear the buffer
-	*/
-	execute() {
-		const MAX_ITERATIONS = 100;
-		let iterations = 0;
-		while (this.commands.length > 0) {
-			if (iterations >= MAX_ITERATIONS) throw new Error("Command execution exceeded maximum iterations, possible infinite loop");
-			iterations++;
-			const currentCommands = [...this.commands];
-			this.commands = [];
-			const entityCommands = /* @__PURE__ */ new Map();
-			for (const cmd of currentCommands) {
-				if (!entityCommands.has(cmd.entityId)) entityCommands.set(cmd.entityId, []);
-				entityCommands.get(cmd.entityId).push(cmd);
-			}
-			for (const [entityId, commands] of entityCommands) this.executeEntityCommands(entityId, commands);
-		}
-	}
-	/**
-	* Get current commands (for testing)
-	*/
-	getCommands() {
-		return [...this.commands];
+/**
+* Get a value from cache or compute and cache it if not present
+* @param cache The cache map
+* @param key The cache key
+* @param compute Function to compute the value if not cached
+* @returns The cached or computed value
+*/
+function getOrComputeCache(cache, key, compute) {
+	let value = cache.get(key);
+	if (value === void 0) {
+		value = compute();
+		cache.set(key, value);
 	}
-	/**
-	* Clear all commands
-	*/
-	clear() {
-		this.commands = [];
+	return value;
+}
+/**
+* Get a value from cache or create and cache it if not present, allowing side effects during creation
+* @param cache The cache map
+* @param key The cache key
+* @param create Function to create the value if not cached (can have side effects)
+* @returns The cached or created value
+*/
+function getOrCreateWithSideEffect(cache, key, create) {
+	let value = cache.get(key);
+	if (value === void 0) {
+		value = create();
+		cache.set(key, value);
 	}
-};
+	return value;
+}
 
 //#endregion
-//#region src/multi-map.ts
-var MultiMap = class {
-	map = /* @__PURE__ */ new Map();
-	_valueCount = 0;
-	get valueCount() {
-		return this._valueCount;
-	}
-	get keyCount() {
-		return this.map.size;
-	}
-	hasKey(key) {
-		return this.map.has(key);
-	}
-	has(key, value) {
-		const set = this.map.get(key);
-		if (!set) return false;
-		if (arguments.length === 1) return true;
-		return set.has(value);
-	}
-	add(key, value) {
-		let set = this.map.get(key);
-		if (!set) {
-			set = /* @__PURE__ */ new Set();
-			this.map.set(key, set);
-		}
-		if (!set.has(value)) {
-			set.add(value);
-			this._valueCount++;
-		}
-	}
-	remove(key, value) {
-		const set = this.map.get(key);
-		if (!set) return false;
-		if (!set.has(value)) return false;
-		set.delete(value);
-		this._valueCount--;
-		if (set.size === 0) this.map.delete(key);
-		return true;
-	}
-	deleteKey(key) {
-		const set = this.map.get(key);
-		if (!set) return false;
-		this._valueCount -= set.size;
-		this.map.delete(key);
-		return true;
-	}
-	get(key) {
-		const set = this.map.get(key);
-		return set ? new Set(set) : /* @__PURE__ */ new Set();
-	}
-	*keys() {
-		yield* this.map.keys();
-	}
-	*values() {
-		for (const set of this.map.values()) for (const v of set) yield v;
-	}
-	[Symbol.iterator]() {
-		return this.entries();
-	}
-	*entries() {
-		for (const [k, set] of this.map.entries()) for (const v of set) yield [k, v];
-	}
-	clear() {
-		this.map.clear();
-		this._valueCount = 0;
-	}
-};
+//#region src/core/types.ts
+function isOptionalEntityId(type) {
+	return typeof type === "object" && type !== null && "optional" in type;
+}
 
 //#endregion
-//#region src/query-filter.ts
+//#region src/core/archetype-helpers.ts
 /**
-* Serialize a QueryFilter into a deterministic string suitable for cache keys.
-* Currently only serializes `negativeComponentTypes`.
+* Check if a detailed type represents a relation (entity or component)
 */
-function serializeQueryFilter(filter = {}) {
-	const negative = (filter.negativeComponentTypes || []).slice().sort((a, b) => a - b);
-	if (negative.length === 0) return "";
-	return `neg:${negative.join(",")}`;
+function isRelationType(detailedType) {
+	return detailedType.type === "entity-relation" || detailedType.type === "component-relation";
 }
 /**
-* Check if an archetype matches the given component types
+* Check if a component type matches a given component ID for relations
 */
-function matchesComponentTypes(archetype, componentTypes) {
-	return componentTypes.every((type) => {
-		const detailedType = getDetailedIdType(type);
-		if (detailedType.type === "wildcard-relation") return archetype.componentTypes.some((archetypeType) => {
-			if (!isRelationId(archetypeType)) return false;
-			return getComponentIdFromRelationId(archetypeType) === detailedType.componentId;
-		});
-		else return archetype.componentTypes.includes(type);
-	});
+function matchesRelationComponentId(componentType, componentId) {
+	const detailedType = getDetailedIdType(componentType);
+	return isRelationType(detailedType) && detailedType.componentId === componentId;
 }
 /**
-* Check if an archetype matches the filter conditions (only filtering logic)
+* Find all relations in dontFragment data that match a component ID
 */
-function matchesFilter(archetype, filter) {
-	return (filter.negativeComponentTypes || []).every((type) => {
-		const detailedType = getDetailedIdType(type);
-		if (detailedType.type === "wildcard-relation") return !archetype.componentTypes.some((archetypeType) => {
-			if (!isRelationId(archetypeType)) return false;
-			return getComponentIdFromRelationId(archetypeType) === detailedType.componentId;
-		});
-		else return !archetype.componentTypes.includes(type);
-	});
+function findMatchingDontFragmentRelations(dontFragmentData, componentId) {
+	const 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) {
+	return componentTypes.map((id) => isOptionalEntityId(id) ? `opt(${id.optional})` : `${id}`).join(",");
+}
+/**
+* Get data source for wildcard relations from component types
+*/
+function getWildcardRelationDataSource(componentTypes, componentId, optional) {
+	const matchingRelations = componentTypes.filter((ct) => matchesRelationComponentId(ct, componentId));
+	return optional ? matchingRelations.length > 0 ? matchingRelations : void 0 : matchingRelations;
+}
+/**
+* Build wildcard relation value from matching relations
+*/
+function buildWildcardRelationValue(wildcardRelationType, matchingRelations, getDataAtIndex, dontFragmentData, entityId, optional) {
+	const relations = [];
+	const targetComponentId = getComponentIdFromRelationId(wildcardRelationType);
+	for (const relType of matchingRelations || []) {
+		const data = getDataAtIndex(relType);
+		const targetId = getTargetIdFromRelationId(relType);
+		relations.push([targetId, data === MISSING_COMPONENT ? void 0 : data]);
+	}
+	if (targetComponentId !== void 0) relations.push(...findMatchingDontFragmentRelations(dontFragmentData, targetComponentId));
+	if (relations.length === 0) {
+		if (!optional) {
+			const componentId = getComponentIdFromRelationId(wildcardRelationType);
+			throw new Error(`No matching relations found for mandatory wildcard relation component ${componentId} on entity ${entityId}`);
+		}
+		return;
+	}
+	return optional ? { value: relations } : relations;
+}
+/**
+* Build regular component value from data source
+*/
+function buildRegularComponentValue(dataSource, entityIndex, optional) {
+	if (dataSource === void 0) {
+		if (optional) return void 0;
+		throw new Error(`Component data not found for mandatory component type`);
+	}
+	const data = dataSource[entityIndex];
+	const result = data === MISSING_COMPONENT ? void 0 : data;
+	return optional ? { value: result } : result;
+}
+/**
+* Build a single component value based on its type
+*/
+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);
+	else return buildRegularComponentValue(dataSource, entityIndex, optional);
 }
 
 //#endregion
-//#region src/query.ts
+//#region src/core/archetype.ts
 /**
-* Query class for efficient entity queries with cached archetypes
+* Special value to represent missing component data
 */
-var Query = class {
-	world;
+const MISSING_COMPONENT = Symbol("missing component");
+/**
+* Archetype class for ECS architecture
+* Represents a group of entities that share the same set of components
+* Optimized for fast iteration and component access
+*/
+var Archetype = class {
+	/**
+	* The component types that define this archetype
+	*/
 	componentTypes;
-	filter;
-	cachedArchetypes = [];
-	isDisposed = false;
-	constructor(world, componentTypes, filter = {}) {
-		this.world = world;
-		this.componentTypes = [...componentTypes].sort((a, b) => a - b);
-		this.filter = filter;
-		this.updateCache();
-		world._registerQuery(this);
-	}
 	/**
-	* Check if query is disposed and throw error if so
+	* List of entities in this archetype
 	*/
-	ensureNotDisposed() {
-		if (this.isDisposed) throw new Error("Query has been disposed");
-	}
+	entities = [];
 	/**
-	* Get all entities matching the query
+	* Component data storage - maps component type to array of component data
+	* Each array index corresponds to the entity index in the entities array
 	*/
-	getEntities() {
-		this.ensureNotDisposed();
-		const result = [];
-		if (this.componentTypes.some((ct) => {
-			return getDetailedIdType(ct).type === "wildcard-relation";
-		})) for (const archetype of this.cachedArchetypes) for (const entity of archetype.getEntities()) {
-			let hasAllRelations = true;
-			for (const componentType of this.componentTypes) if (getDetailedIdType(componentType).type === "wildcard-relation") {
-				const relations = archetype.get(entity, componentType);
-				if (!relations || relations.length === 0) {
-					hasAllRelations = false;
-					break;
+	componentData = /* @__PURE__ */ new Map();
+	/**
+	* Reverse mapping from entity to its index in this archetype
+	*/
+	entityToIndex = /* @__PURE__ */ new Map();
+	/**
+	* Reference to dontFragment relations storage from World
+	* This allows entities with different relation targets to share the same archetype
+	* Stored in World to avoid migration overhead when entities change archetypes
+	*/
+	dontFragmentRelations;
+	/**
+	* Cache for pre-computed component data sources to avoid repeated calculations
+	*/
+	componentDataSourcesCache = /* @__PURE__ */ new Map();
+	constructor(componentTypes, dontFragmentRelations) {
+		this.componentTypes = [...componentTypes].sort((a, b) => a - b);
+		this.dontFragmentRelations = dontFragmentRelations;
+		for (const componentType of this.componentTypes) this.componentData.set(componentType, []);
+	}
+	get size() {
+		return this.entities.length;
+	}
+	matches(componentTypes) {
+		if (this.componentTypes.length !== componentTypes.length) return false;
+		const sortedTypes = [...componentTypes].sort((a, b) => a - b);
+		return this.componentTypes.every((type, index) => type === sortedTypes[index]);
+	}
+	addEntity(entityId, componentData) {
+		if (this.entityToIndex.has(entityId)) throw new Error(`Entity ${entityId} is already in this archetype`);
+		const index = this.entities.length;
+		this.entities.push(entityId);
+		this.entityToIndex.set(entityId, index);
+		for (const componentType of this.componentTypes) {
+			const data = componentData.get(componentType);
+			this.getComponentData(componentType).push(!componentData.has(componentType) ? MISSING_COMPONENT : data);
+		}
+		this.addDontFragmentRelations(entityId, componentData);
+	}
+	addDontFragmentRelations(entityId, componentData) {
+		const dontFragmentData = /* @__PURE__ */ new Map();
+		for (const [componentType, data] of componentData) {
+			if (this.componentTypes.includes(componentType)) continue;
+			const detailedType = getDetailedIdType(componentType);
+			if (isRelationType(detailedType) && isDontFragmentComponent(detailedType.componentId)) dontFragmentData.set(componentType, data);
+		}
+		if (dontFragmentData.size > 0) this.dontFragmentRelations.set(entityId, dontFragmentData);
+	}
+	getEntity(entityId) {
+		const index = this.entityToIndex.get(entityId);
+		if (index === void 0) return void 0;
+		const entityData = /* @__PURE__ */ new Map();
+		for (const componentType of this.componentTypes) {
+			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);
+		return entityData;
+	}
+	dump() {
+		return this.entities.map((entity, 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);
+			}
+			const dontFragmentData = this.dontFragmentRelations.get(entity);
+			if (dontFragmentData) for (const [componentType, data] of dontFragmentData) components.set(componentType, data);
+			return {
+				entity,
+				components
+			};
+		});
+	}
+	removeEntity(entityId) {
+		const index = this.entityToIndex.get(entityId);
+		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);
+		}
+		this.entityToIndex.delete(entityId);
+		const lastIndex = this.entities.length - 1;
+		if (index !== lastIndex) {
+			const lastEntity = this.entities[lastIndex];
+			this.entities[index] = lastEntity;
+			this.entityToIndex.set(lastEntity, index);
+			for (const componentType of this.componentTypes) {
+				const dataArray = this.getComponentData(componentType);
+				dataArray[index] = dataArray[lastIndex];
+			}
+		}
+		this.entities.pop();
+		for (const componentType of this.componentTypes) this.getComponentData(componentType).pop();
+		return removedData;
+	}
+	exists(entityId) {
+		return this.entityToIndex.has(entityId);
+	}
+	get(entityId, componentType) {
+		const index = this.entityToIndex.get(entityId);
+		if (index === void 0) throw new Error(`Entity ${entityId} is not in this archetype`);
+		if (isWildcardRelationId(componentType)) return this.getWildcardRelations(entityId, index, componentType);
+		return this.getRegularComponent(entityId, index, componentType);
+	}
+	getWildcardRelations(entityId, index, componentType) {
+		const componentId = getComponentIdFromRelationId(componentType);
+		const relations = [];
+		for (const relType of this.componentTypes) {
+			const relDetailed = getDetailedIdType(relType);
+			if (isRelationType(relDetailed) && relDetailed.componentId === componentId) {
+				const dataArray = this.getComponentData(relType);
+				if (dataArray && dataArray[index] !== void 0) {
+					const data = dataArray[index];
+					relations.push([relDetailed.targetId, data === MISSING_COMPONENT ? void 0 : data]);
 				}
 			}
-			if (hasAllRelations) result.push(entity);
 		}
-		else for (const archetype of this.cachedArchetypes) result.push(...archetype.getEntities());
-		return result;
+		if (componentId !== void 0) relations.push(...findMatchingDontFragmentRelations(this.dontFragmentRelations.get(entityId), componentId));
+		return relations;
 	}
-	/**
-	* Get entities with their component data
-	* @param componentTypes Array of component types to retrieve
-	* @returns Array of objects with entity and component data
-	*/
-	getEntitiesWithComponents(componentTypes) {
-		this.ensureNotDisposed();
-		const result = [];
-		for (const archetype of this.cachedArchetypes) {
-			const entitiesWithData = archetype.getEntitiesWithComponents(componentTypes);
-			result.push(...entitiesWithData);
+	getRegularComponent(entityId, index, componentType) {
+		if (this.componentTypes.includes(componentType)) {
+			const data = this.getComponentData(componentType)[index];
+			if (data === MISSING_COMPONENT) throw new Error(`Component type ${componentType} not found for entity ${entityId}`);
+			return data;
 		}
-		return result;
+		const dontFragmentData = this.dontFragmentRelations.get(entityId);
+		if (dontFragmentData?.has(componentType)) return dontFragmentData.get(componentType);
+		throw new Error(`Component type ${componentType} not found for entity ${entityId}`);
 	}
-	/**
-	* Iterate over entities with their component data
-	* @param componentTypes Array of component types to retrieve
-	* @param callback Function called for each entity with its components
-	*/
-	forEach(componentTypes, callback) {
-		this.ensureNotDisposed();
-		for (const archetype of this.cachedArchetypes) archetype.forEachWithComponents(componentTypes, callback);
+	getOptional(entityId, componentType) {
+		const index = this.entityToIndex.get(entityId);
+		if (index === void 0) throw new Error(`Entity ${entityId} is not in this archetype`);
+		if (this.componentTypes.includes(componentType)) {
+			const data = this.getComponentData(componentType)[index];
+			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) };
+	}
+	set(entityId, componentType, data) {
+		const index = this.entityToIndex.get(entityId);
+		if (index === void 0) throw new Error(`Entity ${entityId} is not in this archetype`);
+		if (this.componentData.has(componentType)) {
+			this.getComponentData(componentType)[index] = data;
+			return;
+		}
+		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);
+			return;
+		}
+		throw new Error(`Component type ${componentType} is not in this archetype`);
 	}
-	/**
-	* Iterate over entities with their component data (generator)
-	* @param componentTypes Array of component types to retrieve
-	*/
-	*iterate(componentTypes) {
-		this.ensureNotDisposed();
-		for (const archetype of this.cachedArchetypes) yield* archetype.iterateWithComponents(componentTypes);
+	getEntities() {
+		return this.entities;
+	}
+	getEntityToIndexMap() {
+		return this.entityToIndex;
 	}
-	/**
-	* Get component data arrays for all matching entities
-	* @param componentType The component type to retrieve
-	* @returns Array of component data for all matching entities
-	*/
 	getComponentData(componentType) {
-		this.ensureNotDisposed();
-		const result = [];
-		for (const archetype of this.cachedArchetypes) result.push(...archetype.getComponentData(componentType));
-		return result;
+		const data = this.componentData.get(componentType);
+		if (!data) throw new Error(`Component type ${componentType} is not in this archetype`);
+		return data;
 	}
-	/**
-	* Update the cached archetypes
-	* Called when new archetypes are created
-	*/
-	updateCache() {
-		if (this.isDisposed) return;
-		this.cachedArchetypes = this.world.getMatchingArchetypes(this.componentTypes).filter((archetype) => matchesFilter(archetype, this.filter));
+	getOptionalComponentData(componentType) {
+		return this.componentData.get(componentType);
 	}
-	/**
-	* Check if a new archetype matches this query and add to cache if it does
-	*/
-	checkNewArchetype(archetype) {
-		if (this.isDisposed) return;
-		if (matchesComponentTypes(archetype, this.componentTypes) && matchesFilter(archetype, this.filter) && !this.cachedArchetypes.includes(archetype)) this.cachedArchetypes.push(archetype);
+	getCachedComponentDataSources(componentTypes) {
+		const cacheKey = buildCacheKey(componentTypes);
+		return getOrComputeCache(this.componentDataSourcesCache, cacheKey, () => componentTypes.map((compType) => this.getComponentDataSource(compType)));
 	}
-	/**
-	* Remove an archetype from the cached archetypes
-	*/
-	removeArchetype(archetype) {
-		if (this.isDisposed) return;
-		const index = this.cachedArchetypes.indexOf(archetype);
-		if (index !== -1) this.cachedArchetypes.splice(index, 1);
+	getComponentDataSource(compType) {
+		const optional = isOptionalEntityId(compType);
+		const actualType = optional ? compType.optional : compType;
+		if (getIdType(actualType) === "wildcard-relation") {
+			const componentId = getComponentIdFromRelationId(actualType);
+			return getWildcardRelationDataSource(this.componentTypes, componentId, optional);
+		}
+		return optional ? this.getOptionalComponentData(actualType) : this.getComponentData(actualType);
 	}
-	/**
-	* Dispose the query and disconnect from world
-	*/
-	/**
-	* Request disposal of this query.
-	* This will decrement the world's reference count for the query.
-	* The query will only be fully disposed when the ref count reaches zero.
-	*/
-	dispose() {
-		this.world.releaseQuery(this);
+	buildComponentsForIndex(componentTypes, componentDataSources, entityIndex, entityId) {
+		return componentDataSources.map((dataSource, i) => buildSingleComponent(componentTypes[i], dataSource, entityIndex, entityId, (type) => this.getComponentData(type), this.dontFragmentRelations));
 	}
-	/**
-	* Internal full dispose called by World when refCount reaches zero.
-	*/
-	_disposeInternal() {
-		if (!this.isDisposed) {
-			this.world._unregisterQuery(this);
-			this.cachedArchetypes = [];
-			this.isDisposed = true;
+	getEntitiesWithComponents(componentTypes) {
+		const result = [];
+		this.forEachWithComponents(componentTypes, (entity, ...components) => {
+			result.push({
+				entity,
+				components
+			});
+		});
+		return result;
+	}
+	*iterateWithComponents(componentTypes) {
+		const componentDataSources = this.getCachedComponentDataSources(componentTypes);
+		for (let entityIndex = 0; entityIndex < this.entities.length; entityIndex++) {
+			const entity = this.entities[entityIndex];
+			yield [entity, ...this.buildComponentsForIndex(componentTypes, componentDataSources, entityIndex, entity)];
 		}
 	}
-	/**
-	* Symbol.dispose implementation for automatic resource management
-	*/
-	[Symbol.dispose]() {
-		this.dispose();
+	forEachWithComponents(componentTypes, callback) {
+		const componentDataSources = this.getCachedComponentDataSources(componentTypes);
+		for (let entityIndex = 0; entityIndex < this.entities.length; entityIndex++) {
+			const entity = this.entities[entityIndex];
+			callback(entity, ...this.buildComponentsForIndex(componentTypes, componentDataSources, entityIndex, entity));
+		}
 	}
-	/**
-	* Check if the query has been disposed
-	*/
-	get disposed() {
-		return this.isDisposed;
+	forEach(callback) {
+		for (let i = 0; i < this.entities.length; 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);
+		}
+	}
+	hasRelationWithComponentId(componentId) {
+		for (const componentType of this.componentTypes) {
+			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;
+			}
+		}
+		return false;
 	}
 };
 
 //#endregion
-//#region src/world.ts
+//#region src/core/serialization.ts
 /**
 * Encode an internal EntityId into a SerializedEntityId for snapshots
 */
@@ -1432,77 +1347,302 @@ function decodeSerializedId(sid) {
 	}
 	throw new Error(`Invalid ID in snapshot: ${JSON.stringify(sid)}`);
 }
+
+//#endregion
+//#region src/core/world-commands.ts
+function processCommands(entityId, currentArchetype, commands, changeset, handleExclusiveRelation) {
+	for (const command of commands) if (command.type === "set" && command.componentType) processSetCommand(entityId, currentArchetype, command.componentType, command.component, changeset, handleExclusiveRelation);
+	else if (command.type === "delete" && command.componentType) processDeleteCommand(entityId, currentArchetype, command.componentType, changeset);
+}
+function processSetCommand(entityId, currentArchetype, componentType, component$1, changeset, handleExclusiveRelation) {
+	const componentId = getComponentIdFromRelationId(componentType);
+	if (componentId !== void 0) {
+		handleExclusiveRelation(entityId, currentArchetype, componentId);
+		if (isDontFragmentComponent(componentId)) {
+			const wildcardMarker = relation(componentId, "*");
+			if (!currentArchetype.componentTypes.includes(wildcardMarker)) changeset.set(wildcardMarker, void 0);
+		}
+	}
+	changeset.set(componentType, component$1);
+}
+function processDeleteCommand(entityId, currentArchetype, componentType, changeset) {
+	const componentId = getComponentIdFromRelationId(componentType);
+	if (isWildcardRelationId(componentType) && componentId !== void 0) removeWildcardRelations(entityId, currentArchetype, componentId, changeset);
+	else {
+		changeset.delete(componentType);
+		maybeRemoveWildcardMarker(entityId, currentArchetype, componentType, componentId, changeset);
+	}
+}
+function removeMatchingRelations(entityId, archetype, baseComponentId, changeset) {
+	for (const componentType of archetype.componentTypes) if (getComponentIdFromRelationId(componentType) === baseComponentId) changeset.delete(componentType);
+	const entityData = archetype.getEntity(entityId);
+	if (entityData) for (const [componentType] of entityData) {
+		if (archetype.componentTypes.includes(componentType)) continue;
+		if (getComponentIdFromRelationId(componentType) === baseComponentId) changeset.delete(componentType);
+	}
+}
+function removeWildcardRelations(entityId, currentArchetype, baseComponentId, changeset) {
+	removeMatchingRelations(entityId, currentArchetype, baseComponentId, changeset);
+	if (isDontFragmentComponent(baseComponentId)) changeset.delete(relation(baseComponentId, "*"));
+}
+function maybeRemoveWildcardMarker(entityId, archetype, removedComponentType, componentId, changeset) {
+	if (componentId === void 0 || !isDontFragmentComponent(componentId)) return;
+	const wildcardMarker = relation(componentId, "*");
+	const entityData = archetype.getEntity(entityId);
+	if (!entityData) {
+		changeset.delete(wildcardMarker);
+		return;
+	}
+	for (const [otherComponentType] of entityData) {
+		if (otherComponentType === removedComponentType) continue;
+		if (otherComponentType === wildcardMarker) continue;
+		if (changeset.removes.has(otherComponentType)) continue;
+		if (getComponentIdFromRelationId(otherComponentType) === componentId) return;
+	}
+	changeset.delete(wildcardMarker);
+}
+function applyChangeset(ctx, entityId, currentArchetype, changeset, entityToArchetype) {
+	const currentEntityData = currentArchetype.getEntity(entityId);
+	const allCurrentComponentTypes = currentEntityData ? Array.from(currentEntityData.keys()) : currentArchetype.componentTypes;
+	const finalComponentTypes = changeset.getFinalComponentTypes(allCurrentComponentTypes);
+	const removedComponents = /* @__PURE__ */ new Map();
+	if (finalComponentTypes) if (!areComponentTypesEqual(filterRegularComponentTypes(allCurrentComponentTypes), filterRegularComponentTypes(finalComponentTypes))) moveEntityToNewArchetype(ctx, entityId, currentArchetype, finalComponentTypes, changeset, removedComponents, entityToArchetype);
+	else updateEntityInSameArchetype(ctx, entityId, currentArchetype, changeset, removedComponents);
+	else updateEntityInSameArchetype(ctx, entityId, currentArchetype, changeset, removedComponents);
+	return removedComponents;
+}
+function moveEntityToNewArchetype(ctx, entityId, currentArchetype, finalComponentTypes, changeset, removedComponents, entityToArchetype) {
+	const newArchetype = ctx.ensureArchetype(finalComponentTypes);
+	const currentComponents = currentArchetype.removeEntity(entityId);
+	for (const componentType of changeset.removes) removedComponents.set(componentType, currentComponents.get(componentType));
+	newArchetype.addEntity(entityId, changeset.applyTo(currentComponents));
+	entityToArchetype.set(entityId, newArchetype);
+}
+function updateEntityInSameArchetype(ctx, entityId, currentArchetype, changeset, removedComponents) {
+	applyDontFragmentChanges(ctx.dontFragmentRelations, entityId, changeset, removedComponents);
+	for (const [componentType, component$1] of changeset.adds) {
+		if (isDontFragmentRelation(componentType)) continue;
+		currentArchetype.set(entityId, componentType, component$1);
+	}
+}
+function applyDontFragmentChanges(dontFragmentRelations, entityId, changeset, removedComponents) {
+	let entityRelations = dontFragmentRelations.get(entityId);
+	for (const componentType of changeset.removes) if (isDontFragmentRelation(componentType)) {
+		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$1] of changeset.adds) if (isDontFragmentRelation(componentType)) {
+		if (!entityRelations) {
+			entityRelations = /* @__PURE__ */ new Map();
+			dontFragmentRelations.set(entityId, entityRelations);
+		}
+		entityRelations.set(componentType, component$1);
+	}
+	if (entityRelations && entityRelations.size === 0) dontFragmentRelations.delete(entityId);
+}
+function filterRegularComponentTypes(componentTypes) {
+	const regularTypes = [];
+	for (const componentType of componentTypes) {
+		if (isDontFragmentWildcard(componentType)) {
+			regularTypes.push(componentType);
+			continue;
+		}
+		if (isDontFragmentRelation(componentType)) continue;
+		regularTypes.push(componentType);
+	}
+	return regularTypes;
+}
+function areComponentTypesEqual(types1, types2) {
+	if (types1.length !== types2.length) return false;
+	const sorted1 = [...types1].sort((a, b) => a - b);
+	const sorted2 = [...types2].sort((a, b) => a - b);
+	return sorted1.every((v, i) => v === sorted2[i]);
+}
+
+//#endregion
+//#region src/core/world-hooks.ts
+function triggerLifecycleHooks(ctx, entityId, addedComponents, removedComponents) {
+	invokeHooksForComponents(ctx.hooks, entityId, addedComponents, "on_set");
+	invokeHooksForComponents(ctx.hooks, entityId, removedComponents, "on_remove");
+	triggerMultiComponentHooks(ctx, entityId, addedComponents, removedComponents);
+}
+function invokeHooksForComponents(hooks, entityId, components, hookType) {
+	for (const [componentType, component$1] of components) {
+		const directHooks = hooks.get(componentType);
+		if (directHooks) for (const hook of directHooks) hook[hookType]?.(entityId, componentType, component$1);
+		const componentId = getComponentIdFromRelationId(componentType);
+		if (componentId !== void 0) {
+			const wildcardHooks = hooks.get(relation(componentId, "*"));
+			if (wildcardHooks) for (const hook of wildcardHooks) hook[hookType]?.(entityId, componentType, component$1);
+		}
+	}
+}
+function triggerMultiComponentHooks(ctx, entityId, addedComponents, removedComponents) {
+	for (const { componentTypes, requiredComponents, hook } of ctx.multiHooks) {
+		const anyRequiredAdded = requiredComponents.some((c) => addedComponents.has(c));
+		const anyRequiredRemoved = requiredComponents.some((c) => removedComponents.has(c));
+		if (anyRequiredAdded && hook.on_set && entityHasAllComponents(ctx, entityId, requiredComponents)) hook.on_set(entityId, componentTypes, collectMultiHookComponents(ctx, entityId, componentTypes));
+		if (anyRequiredRemoved && hook.on_remove && entityHadAllComponentsBefore(ctx, entityId, requiredComponents, removedComponents)) hook.on_remove(entityId, componentTypes, collectMultiHookComponentsWithRemoved(ctx, entityId, componentTypes, removedComponents));
+	}
+}
+function entityHasAllComponents(ctx, entityId, requiredComponents) {
+	return requiredComponents.every((c) => ctx.has(entityId, c));
+}
+function entityHadAllComponentsBefore(ctx, entityId, requiredComponents, removedComponents) {
+	return requiredComponents.every((c) => removedComponents.has(c) || ctx.has(entityId, c));
+}
+function collectMultiHookComponents(ctx, entityId, componentTypes) {
+	return componentTypes.map((ct) => isOptionalEntityId(ct) ? ctx.getOptional(entityId, ct.optional) : ctx.get(entityId, ct));
+}
+function collectMultiHookComponentsWithRemoved(ctx, entityId, componentTypes, removedComponents) {
+	return componentTypes.map((ct) => {
+		if (isOptionalEntityId(ct)) {
+			const optionalId = ct.optional;
+			return removedComponents.has(optionalId) ? { value: removedComponents.get(optionalId) } : ctx.getOptional(entityId, optionalId);
+		}
+		const compId = ct;
+		return removedComponents.has(compId) ? removedComponents.get(compId) : ctx.get(entityId, compId);
+	});
+}
+
+//#endregion
+//#region src/utils/multi-map.ts
+var MultiMap = class {
+	map = /* @__PURE__ */ new Map();
+	_valueCount = 0;
+	get valueCount() {
+		return this._valueCount;
+	}
+	get keyCount() {
+		return this.map.size;
+	}
+	hasKey(key) {
+		return this.map.has(key);
+	}
+	has(key, value) {
+		const set = this.map.get(key);
+		if (!set) return false;
+		if (arguments.length === 1) return true;
+		return set.has(value);
+	}
+	add(key, value) {
+		let set = this.map.get(key);
+		if (!set) {
+			set = /* @__PURE__ */ new Set();
+			this.map.set(key, set);
+		}
+		if (!set.has(value)) {
+			set.add(value);
+			this._valueCount++;
+		}
+	}
+	remove(key, value) {
+		const set = this.map.get(key);
+		if (!set) return false;
+		if (!set.has(value)) return false;
+		set.delete(value);
+		this._valueCount--;
+		if (set.size === 0) this.map.delete(key);
+		return true;
+	}
+	deleteKey(key) {
+		const set = this.map.get(key);
+		if (!set) return false;
+		this._valueCount -= set.size;
+		this.map.delete(key);
+		return true;
+	}
+	get(key) {
+		const set = this.map.get(key);
+		return set ? new Set(set) : /* @__PURE__ */ new Set();
+	}
+	*keys() {
+		yield* this.map.keys();
+	}
+	*values() {
+		for (const set of this.map.values()) for (const v of set) yield v;
+	}
+	[Symbol.iterator]() {
+		return this.entries();
+	}
+	*entries() {
+		for (const [k, set] of this.map.entries()) for (const v of set) yield [k, v];
+	}
+	clear() {
+		this.map.clear();
+		this._valueCount = 0;
+	}
+};
+
+//#endregion
+//#region src/core/world-references.ts
+function trackEntityReference(entityReferences, sourceEntityId, componentType, targetEntityId) {
+	if (!entityReferences.has(targetEntityId)) entityReferences.set(targetEntityId, new MultiMap());
+	entityReferences.get(targetEntityId).add(sourceEntityId, componentType);
+}
+function untrackEntityReference(entityReferences, sourceEntityId, componentType, targetEntityId) {
+	const references = entityReferences.get(targetEntityId);
+	if (references) {
+		references.remove(sourceEntityId, componentType);
+		if (references.keyCount === 0) entityReferences.delete(targetEntityId);
+	}
+}
+function getEntityReferences(entityReferences, targetEntityId) {
+	return entityReferences.get(targetEntityId) ?? new MultiMap();
+}
+
+//#endregion
+//#region src/core/world.ts
 /**
 * World class for ECS architecture
 * Manages entities and components
 */
 var World = class {
-	/** Manages allocation and deallocation of entity IDs */
 	entityIdManager = new EntityIdManager();
-	/** Array of all archetypes in the world */
 	archetypes = [];
-	/** Maps archetype signatures (component type signatures) to archetype instances */
 	archetypeBySignature = /* @__PURE__ */ new Map();
-	/** Maps entity IDs to their current archetype */
 	entityToArchetype = /* @__PURE__ */ new Map();
-	/** Maps component types to arrays of archetypes that contain them */
 	archetypesByComponent = /* @__PURE__ */ new Map();
-	/** Tracks which entities reference each entity as a component type */
 	entityReferences = /* @__PURE__ */ new Map();
-	/** Storage for dontFragment relations - maps entity ID to a map of relation type to component data */
 	dontFragmentRelations = /* @__PURE__ */ new Map();
-	/** Array of all active queries for archetype change notifications */
 	queries = [];
-	/** Cache for queries keyed by component types and filter signatures */
 	queryCache = /* @__PURE__ */ new Map();
-	/** Buffers structural changes for deferred execution */
 	commandBuffer = new CommandBuffer((entityId, commands) => this.executeEntityCommands(entityId, commands));
-	/** Stores lifecycle hooks for component and relation events */
 	hooks = /* @__PURE__ */ new Map();
-	/** Stores multi-component lifecycle hooks */
 	multiHooks = /* @__PURE__ */ new Set();
-	/**
-	* Create a new World.
-	* If an optional snapshot object is provided (previously produced by `world.serialize()`),
-	* the world will be restored from that snapshot. The snapshot may contain non-JSON values.
-	*/
-	constructor(snapshot) {
-		if (snapshot && typeof snapshot === "object") {
-			if (snapshot.entityManager) this.entityIdManager.deserializeState(snapshot.entityManager);
-			if (Array.isArray(snapshot.entities)) for (const entry of snapshot.entities) {
-				const entityId = decodeSerializedId(entry.id);
-				const componentsArray = entry.components || [];
-				const componentMap = /* @__PURE__ */ new Map();
-				const componentTypes = [];
-				for (const componentEntry of componentsArray) {
-					const componentType = decodeSerializedId(componentEntry.type);
-					componentMap.set(componentType, componentEntry.value);
-					componentTypes.push(componentType);
-				}
-				const archetype = this.ensureArchetype(componentTypes);
-				archetype.addEntity(entityId, componentMap);
-				this.entityToArchetype.set(entityId, archetype);
-				for (const compType of componentTypes) {
-					const detailedType = getDetailedIdType(compType);
-					if (detailedType.type === "entity-relation") {
-						const targetEntityId = detailedType.targetId;
-						this.trackEntityReference(entityId, compType, targetEntityId);
-					} else if (detailedType.type === "entity") this.trackEntityReference(entityId, compType, compType);
-				}
+	constructor(snapshot) {
+		if (snapshot && typeof snapshot === "object") this.deserializeSnapshot(snapshot);
+	}
+	deserializeSnapshot(snapshot) {
+		if (snapshot.entityManager) this.entityIdManager.deserializeState(snapshot.entityManager);
+		if (Array.isArray(snapshot.entities)) for (const entry of snapshot.entities) {
+			const entityId = decodeSerializedId(entry.id);
+			const componentsArray = entry.components || [];
+			const componentMap = /* @__PURE__ */ new Map();
+			const componentTypes = [];
+			for (const componentEntry of componentsArray) {
+				const componentType = decodeSerializedId(componentEntry.type);
+				componentMap.set(componentType, componentEntry.value);
+				componentTypes.push(componentType);
+			}
+			const archetype = this.ensureArchetype(componentTypes);
+			archetype.addEntity(entityId, componentMap);
+			this.entityToArchetype.set(entityId, archetype);
+			for (const compType of componentTypes) {
+				const detailedType = getDetailedIdType(compType);
+				if (detailedType.type === "entity-relation") trackEntityReference(this.entityReferences, entityId, compType, detailedType.targetId);
+				else if (detailedType.type === "entity") trackEntityReference(this.entityReferences, entityId, compType, compType);
 			}
 		}
 	}
-	/**
-	* Generate a signature string for component types array
-	* @returns A string signature for the component types
-	*/
 	createArchetypeSignature(componentTypes) {
 		return componentTypes.join(",");
 	}
-	/**
-	* Create a new entity
-	* @returns The ID of the newly created entity
-	*/
 	new() {
 		const entityId = this.entityIdManager.allocate();
 		let emptyArchetype = this.ensureArchetype([]);
@@ -1510,9 +1650,6 @@ var World = class {
 		this.entityToArchetype.set(entityId, emptyArchetype);
 		return entityId;
 	}
-	/**
-	* Destroy an entity and remove all its components (immediate execution)
-	*/
 	destroyEntityImmediate(entityId) {
 		const queue = [entityId];
 		const visited = /* @__PURE__ */ new Set();
@@ -1522,7 +1659,7 @@ var World = class {
 			visited.add(cur);
 			const archetype = this.entityToArchetype.get(cur);
 			if (!archetype) continue;
-			const componentReferences = Array.from(this.getEntityReferences(cur));
+			const componentReferences = Array.from(getEntityReferences(this.entityReferences, cur));
 			for (const [sourceEntityId, componentType] of componentReferences) {
 				if (!this.entityToArchetype.get(sourceEntityId)) continue;
 				if (isCascadeDeleteRelation(componentType)) {
@@ -1538,9 +1675,6 @@ var World = class {
 			this.entityIdManager.deallocate(cur);
 		}
 	}
-	/**
-	* Check if an entity exists
-	*/
 	exists(entityId) {
 		return this.entityToArchetype.has(entityId);
 	}
@@ -1551,23 +1685,14 @@ var World = class {
 		if (detailedType.type === "wildcard-relation") throw new Error(`Cannot directly add wildcard relation components: ${componentType}`);
 		this.commandBuffer.set(entityId, componentType, component$1);
 	}
-	/**
-	* Remove a component from an entity (deferred)
-	*/
 	remove(entityId, componentType) {
 		if (!this.exists(entityId)) throw new Error(`Entity ${entityId} does not exist`);
 		if (getDetailedIdType(componentType).type === "invalid") throw new Error(`Invalid component type: ${componentType}`);
 		this.commandBuffer.remove(entityId, componentType);
 	}
-	/**
-	* Destroy an entity and remove all its components (deferred)
-	*/
 	delete(entityId) {
 		this.commandBuffer.delete(entityId);
 	}
-	/**
-	* Check if an entity has a specific component
-	*/
 	has(entityId, componentType) {
 		const archetype = this.entityToArchetype.get(entityId);
 		if (!archetype) return false;
@@ -1585,16 +1710,10 @@ var World = class {
 		}
 		return archetype.get(entityId, componentType);
 	}
-	/**
-	* Get optional component data for a specific entity and component type
-	* @param entityId The entity
-	* @param componentType The component type
-	* @returns { value: T } if component exists, undefined otherwise
-	*/
 	getOptional(entityId, componentType) {
 		const archetype = this.entityToArchetype.get(entityId);
 		if (!archetype) throw new Error(`Entity ${entityId} does not exist`);
-		if (isWildcardRelationId(componentType)) return;
+		if (isWildcardRelationId(componentType)) return void 0;
 		return archetype.getOptional(entityId, componentType);
 	}
 	hook(componentTypesOrSingle, hook) {
@@ -1612,7 +1731,7 @@ var World = class {
 			if (multiHook.on_init !== void 0) {
 				const matchingArchetypes = this.getMatchingArchetypes(requiredComponents);
 				for (const archetype of matchingArchetypes) for (const entityId of archetype.getEntities()) {
-					const components = this.collectMultiHookComponents(entityId, componentTypes);
+					const components = collectMultiHookComponents(this.createHooksContext(), entityId, componentTypes);
 					multiHook.on_init(entityId, componentTypes, components);
 				}
 			}
@@ -1647,16 +1766,9 @@ var World = class {
 			}
 		}
 	}
-	/**
-	* Execute all deferred commands immediately
-	*/
 	sync() {
 		this.commandBuffer.execute();
 	}
-	/**
-	* Create a cached query for efficient entity lookups
-	* @returns A Query object for the specified component types and filter
-	*/
 	createQuery(componentTypes, filter = {}) {
 		const sortedTypes = [...componentTypes].sort((a, b) => a - b);
 		const filterKey = serializeQueryFilter(filter);
@@ -1673,19 +1785,9 @@ var World = class {
 		});
 		return query;
 	}
-	/**
-	* Create an EntityBuilder for convenient entity creation.
-	* @returns EntityBuilder
-	*/
 	spawn() {
 		return new EntityBuilder(this);
 	}
-	/**
-	* Spawn multiple entities using an EntityBuilder configuration callback
-	* @param count number of entities
-	* @param configure builder configuration callback
-	* @returns Created entity IDs
-	*/
 	spawnMany(count, configure) {
 		const entities = [];
 		for (let i = 0; i < count; i++) {
@@ -1694,23 +1796,13 @@ var World = class {
 		}
 		return entities;
 	}
-	/**
-	* @internal Register a query for archetype update notifications
-	*/
 	_registerQuery(query) {
 		this.queries.push(query);
 	}
-	/**
-	* @internal Unregister a query
-	*/
 	_unregisterQuery(query) {
 		const index = this.queries.indexOf(query);
 		if (index !== -1) this.queries.splice(index, 1);
 	}
-	/**
-	* Release a query reference obtained from createQuery.
-	* Decrements the refCount and fully disposes the query when it reaches zero.
-	*/
 	releaseQuery(query) {
 		for (const [k, v] of this.queryCache.entries()) if (v.query === query) {
 			v.refCount--;
@@ -1722,9 +1814,6 @@ var World = class {
 			return;
 		}
 	}
-	/**
-	* @internal Get archetypes that match specific component types (for internal use by queries)
-	*/
 	getMatchingArchetypes(componentTypes) {
 		if (componentTypes.length === 0) return [...this.archetypes];
 		const regularComponents = [];
@@ -1736,42 +1825,24 @@ var World = class {
 				relationId: componentType
 			});
 		} else regularComponents.push(componentType);
-		let matchingArchetypes = [];
-		if (regularComponents.length > 0) {
-			const sortedRegularTypes = [...regularComponents].sort((a, b) => a - b);
-			if (sortedRegularTypes.length === 1) {
-				const componentType = sortedRegularTypes[0];
-				matchingArchetypes = this.archetypesByComponent.get(componentType) || [];
-			} else {
-				const archetypeLists = sortedRegularTypes.map((type) => this.archetypesByComponent.get(type) || []);
-				const firstList = archetypeLists[0] || [];
-				const intersection = /* @__PURE__ */ new Set();
-				for (const archetype of firstList) {
-					let hasAllComponents = true;
-					for (let listIndex = 1; listIndex < archetypeLists.length; listIndex++) if (!archetypeLists[listIndex].includes(archetype)) {
-						hasAllComponents = false;
-						break;
-					}
-					if (hasAllComponents) intersection.add(archetype);
-				}
-				matchingArchetypes = Array.from(intersection);
-			}
-		} else matchingArchetypes = [...this.archetypes];
-		for (const wildcard of wildcardRelations) if (isDontFragmentComponent(wildcard.componentId)) {
-			const archetypesWithMarker = this.archetypesByComponent.get(wildcard.relationId) || [];
-			if (matchingArchetypes.length === 0) matchingArchetypes = archetypesWithMarker;
-			else matchingArchetypes = matchingArchetypes.filter((archetype) => archetypesWithMarker.includes(archetype));
-		} else matchingArchetypes = matchingArchetypes.filter((archetype) => archetype.hasRelationWithComponentId(wildcard.componentId));
+		let matchingArchetypes = this.getArchetypesWithComponents(regularComponents);
+		for (const { componentId, relationId } of wildcardRelations) {
+			const archetypesWithMarker = this.archetypesByComponent.get(relationId) || [];
+			matchingArchetypes = matchingArchetypes.length === 0 ? archetypesWithMarker : matchingArchetypes.filter((a) => archetypesWithMarker.includes(a) || a.hasRelationWithComponentId(componentId));
+		}
 		return matchingArchetypes;
 	}
+	getArchetypesWithComponents(componentTypes) {
+		if (componentTypes.length === 0) return [...this.archetypes];
+		if (componentTypes.length === 1) return this.archetypesByComponent.get(componentTypes[0]) || [];
+		const archetypeLists = componentTypes.map((type) => this.archetypesByComponent.get(type) || []);
+		return archetypeLists[0].filter((archetype) => archetypeLists.slice(1).every((list) => list.includes(archetype)));
+	}
 	query(componentTypes, includeComponents) {
 		const matchingArchetypes = this.getMatchingArchetypes(componentTypes);
 		if (includeComponents) {
 			const result = [];
-			for (const archetype of matchingArchetypes) {
-				const entitiesWithData = archetype.getEntitiesWithComponents(componentTypes);
-				result.push(...entitiesWithData);
-			}
+			for (const archetype of matchingArchetypes) result.push(...archetype.getEntitiesWithComponents(componentTypes));
 			return result;
 		} else {
 			const result = [];
@@ -1779,10 +1850,6 @@ var World = class {
 			return result;
 		}
 	}
-	/**
-	* @internal Execute commands for a single entity (for internal use by CommandBuffer)
-	* @returns ComponentChangeset describing the changes made
-	*/
 	executeEntityCommands(entityId, commands) {
 		const changeset = new ComponentChangeset();
 		if (commands.some((cmd) => cmd.type === "destroy")) {
@@ -1791,327 +1858,79 @@ var World = class {
 		}
 		const currentArchetype = this.entityToArchetype.get(entityId);
 		if (!currentArchetype) return changeset;
-		this.processCommands(entityId, currentArchetype, commands, changeset);
-		const removedComponents = this.applyChangeset(entityId, currentArchetype, changeset);
+		processCommands(entityId, currentArchetype, commands, changeset, (eid, arch, compId) => {
+			if (isExclusiveComponent(compId)) removeMatchingRelations(eid, arch, compId, changeset);
+		});
+		const removedComponents = applyChangeset({
+			dontFragmentRelations: this.dontFragmentRelations,
+			ensureArchetype: (ct) => this.ensureArchetype(ct)
+		}, entityId, currentArchetype, changeset, this.entityToArchetype);
 		this.updateEntityReferences(entityId, changeset);
-		this.triggerLifecycleHooks(entityId, changeset.adds, removedComponents);
+		triggerLifecycleHooks(this.createHooksContext(), entityId, changeset.adds, removedComponents);
 		return changeset;
 	}
-	/**
-	* Process commands and populate the changeset
-	*/
-	processCommands(entityId, currentArchetype, commands, changeset) {
-		for (const command of commands) if (command.type === "set" && command.componentType) this.processSetCommand(entityId, currentArchetype, command.componentType, command.component, changeset);
-		else if (command.type === "delete" && command.componentType) this.processDeleteCommand(entityId, currentArchetype, command.componentType, changeset);
-	}
-	/**
-	* Process a set command, handling exclusive relations
-	*/
-	processSetCommand(entityId, currentArchetype, componentType, component$1, changeset) {
-		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);
-	}
-	/**
-	* Remove all relations with the same base component (for exclusive relations)
-	*/
-	removeExclusiveRelations(entityId, currentArchetype, baseComponentId, changeset) {
-		for (const componentType of currentArchetype.componentTypes) if (this.isRelationWithComponent(componentType, baseComponentId)) changeset.delete(componentType);
-		const entityData = currentArchetype.getEntity(entityId);
-		if (entityData) for (const [componentType] of entityData) {
-			if (currentArchetype.componentTypes.includes(componentType)) continue;
-			if (this.isRelationWithComponent(componentType, baseComponentId)) changeset.delete(componentType);
-		}
-	}
-	isRelationWithComponent(componentType, baseComponentId) {
-		return getComponentIdFromRelationId(componentType) === baseComponentId;
-	}
-	/**
-	* Process a delete command, handling wildcard relations
-	*/
-	processDeleteCommand(entityId, currentArchetype, componentType, changeset) {
-		const componentId = getComponentIdFromRelationId(componentType);
-		if (isWildcardRelationId(componentType) && componentId !== void 0) this.removeWildcardRelations(entityId, currentArchetype, componentId, changeset);
-		else {
-			changeset.delete(componentType);
-			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;
-					if (getComponentIdFromRelationId(otherComponentType) === componentId) {
-						hasOtherRelations = true;
-						break;
-					}
-				}
-				if (!hasOtherRelations) changeset.delete(wildcardMarker);
-			}
-		}
-	}
-	/**
-	* Remove all relations matching a wildcard component ID
-	*/
-	removeWildcardRelations(entityId, currentArchetype, baseComponentId, changeset) {
-		for (const componentType of currentArchetype.componentTypes) if (this.isRelationWithComponent(componentType, baseComponentId)) changeset.delete(componentType);
-		const entityData = currentArchetype.getEntity(entityId);
-		if (entityData) for (const [componentType] of entityData) {
-			if (currentArchetype.componentTypes.includes(componentType)) continue;
-			if (this.isRelationWithComponent(componentType, baseComponentId)) changeset.delete(componentType);
-		}
-		if (isDontFragmentComponent(baseComponentId)) {
-			const wildcardMarker = relation(baseComponentId, "*");
-			changeset.delete(wildcardMarker);
-		}
+	createHooksContext() {
+		return {
+			hooks: this.hooks,
+			multiHooks: this.multiHooks,
+			has: (eid, ct) => this.has(eid, ct),
+			get: (eid, ct) => this.get(eid, ct),
+			getOptional: (eid, ct) => this.getOptional(eid, ct)
+		};
 	}
-	/**
-	* 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);
-		}
+		maybeRemoveWildcardMarker(entityId, sourceArchetype, componentType, getComponentIdFromRelationId(componentType), changeset);
 		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
-	*/
-	applyChangeset(entityId, currentArchetype, changeset) {
-		const currentEntityData = currentArchetype.getEntity(entityId);
-		const allCurrentComponentTypes = currentEntityData ? Array.from(currentEntityData.keys()) : currentArchetype.componentTypes;
-		const finalComponentTypes = changeset.getFinalComponentTypes(allCurrentComponentTypes);
-		const removedComponents = /* @__PURE__ */ new Map();
-		if (finalComponentTypes) {
-			const currentRegularTypes = this.filterRegularComponentTypes(allCurrentComponentTypes);
-			const finalRegularTypes = this.filterRegularComponentTypes(finalComponentTypes);
-			if (!this.areComponentTypesEqual(currentRegularTypes, finalRegularTypes)) this.moveEntityToNewArchetype(entityId, currentArchetype, finalComponentTypes, changeset, removedComponents);
-			else this.updateEntityInSameArchetype(entityId, currentArchetype, changeset, removedComponents);
-		} else this.updateEntityInSameArchetype(entityId, currentArchetype, changeset, removedComponents);
-		return removedComponents;
-	}
-	/**
-	* Move entity to a new archetype with updated components
-	*/
-	moveEntityToNewArchetype(entityId, currentArchetype, finalComponentTypes, changeset, removedComponents) {
-		const newArchetype = this.ensureArchetype(finalComponentTypes);
-		const currentComponents = currentArchetype.removeEntity(entityId);
-		for (const componentType of changeset.removes) removedComponents.set(componentType, currentComponents.get(componentType));
-		newArchetype.addEntity(entityId, changeset.applyTo(currentComponents));
-		this.entityToArchetype.set(entityId, newArchetype);
-	}
-	/**
-	* Update entity in same archetype (no archetype change needed)
-	*/
-	updateEntityInSameArchetype(entityId, currentArchetype, changeset, removedComponents) {
-		this.applyDontFragmentChanges(entityId, changeset, removedComponents);
-		for (const [componentType, component$1] of changeset.adds) {
-			if (isDontFragmentRelation(componentType)) continue;
-			currentArchetype.set(entityId, componentType, component$1);
-		}
-	}
-	/**
-	* Apply dontFragment relation changes directly to World's storage
-	* This is much more efficient than the removeEntity + addEntity approach
-	*/
-	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, component$1] of changeset.adds) if (isDontFragmentRelation(componentType)) {
-			if (!entityRelations) {
-				entityRelations = /* @__PURE__ */ new Map();
-				this.dontFragmentRelations.set(entityId, entityRelations);
-			}
-			entityRelations.set(componentType, component$1);
-		}
-		if (entityRelations && entityRelations.size === 0) this.dontFragmentRelations.delete(entityId);
+		applyChangeset({
+			dontFragmentRelations: this.dontFragmentRelations,
+			ensureArchetype: (ct) => this.ensureArchetype(ct)
+		}, entityId, sourceArchetype, changeset, this.entityToArchetype);
+		untrackEntityReference(this.entityReferences, entityId, componentType, targetEntityId);
+		triggerLifecycleHooks(this.createHooksContext(), entityId, /* @__PURE__ */ new Map(), new Map([[componentType, removedComponent]]));
 	}
-	/**
-	* Update entity reference tracking based on changeset
-	*/
 	updateEntityReferences(entityId, changeset) {
 		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);
+			untrackEntityReference(this.entityReferences, entityId, componentType, targetId);
+		} else if (componentType >= 1024) untrackEntityReference(this.entityReferences, 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);
+			trackEntityReference(this.entityReferences, entityId, componentType, targetId);
+		} else if (componentType >= 1024) trackEntityReference(this.entityReferences, entityId, componentType, componentType);
 	}
-	/**
-	* Get or create an archetype for the given component types
-	* Filters out dontFragment relations from the archetype signature
-	* @returns The archetype for the given component types (excluding dontFragment relations)
-	*/
 	ensureArchetype(componentTypes) {
-		const sortedTypes = this.filterRegularComponentTypes(componentTypes).sort((a, b) => a - b);
+		const sortedTypes = filterRegularComponentTypes(componentTypes).sort((a, b) => a - b);
 		const hashKey = this.createArchetypeSignature(sortedTypes);
 		return getOrCreateWithSideEffect(this.archetypeBySignature, hashKey, () => this.createNewArchetype(sortedTypes));
 	}
-	/**
-	* Compare two arrays of component types for equality (order-independent)
-	*/
-	areComponentTypesEqual(types1, types2) {
-		if (types1.length !== types2.length) return false;
-		const sorted1 = [...types1].sort((a, b) => a - b);
-		const sorted2 = [...types2].sort((a, b) => a - b);
-		return sorted1.every((v, i) => v === sorted2[i]);
-	}
-	/**
-	* Filter out dontFragment relations from component types, but keep wildcard markers
-	*/
-	filterRegularComponentTypes(componentTypes) {
-		const regularTypes = [];
-		for (const componentType of componentTypes) {
-			if (isDontFragmentWildcard(componentType)) {
-				regularTypes.push(componentType);
-				continue;
-			}
-			if (isDontFragmentRelation(componentType)) continue;
-			regularTypes.push(componentType);
-		}
-		return regularTypes;
-	}
-	/**
-	* Create a new archetype and register it with all tracking structures
-	*/
 	createNewArchetype(componentTypes) {
 		const newArchetype = new Archetype(componentTypes, this.dontFragmentRelations);
 		this.archetypes.push(newArchetype);
-		this.registerArchetypeInComponentIndex(newArchetype, componentTypes);
-		this.notifyQueriesOfNewArchetype(newArchetype);
-		return newArchetype;
-	}
-	/**
-	* Register archetype in the component-to-archetype index
-	*/
-	registerArchetypeInComponentIndex(archetype, componentTypes) {
 		for (const componentType of componentTypes) {
 			const archetypes = this.archetypesByComponent.get(componentType) || [];
-			archetypes.push(archetype);
+			archetypes.push(newArchetype);
 			this.archetypesByComponent.set(componentType, archetypes);
 		}
+		for (const query of this.queries) query.checkNewArchetype(newArchetype);
+		return newArchetype;
 	}
-	/**
-	* Notify all queries to check the new archetype
-	*/
-	notifyQueriesOfNewArchetype(archetype) {
-		for (const query of this.queries) query.checkNewArchetype(archetype);
-	}
-	/**
-	* Add a component reference to the reverse index when an entity is used as a component type
-	* @param sourceEntityId The entity that has the component
-	* @param componentType The component type (which may be an entity ID used as component type)
-	* @param targetEntityId The entity being used as component type
-	*/
-	trackEntityReference(sourceEntityId, componentType, targetEntityId) {
-		if (!this.entityReferences.has(targetEntityId)) this.entityReferences.set(targetEntityId, new MultiMap());
-		this.entityReferences.get(targetEntityId).add(sourceEntityId, componentType);
-	}
-	/**
-	* Remove a component reference from the reverse index
-	* @param sourceEntityId The entity that has the component
-	* @param componentType The component type
-	* @param targetEntityId The entity being used as component type
-	*/
-	untrackEntityReference(sourceEntityId, componentType, targetEntityId) {
-		const references = this.entityReferences.get(targetEntityId);
-		if (references) {
-			references.remove(sourceEntityId, componentType);
-			if (references.keyCount === 0) this.entityReferences.delete(targetEntityId);
-		}
-	}
-	/**
-	* Get all component references where a target entity is used as a component type
-	* @param targetEntityId The target entity
-	* @returns A MultiMap of sourceEntityId to componentTypes that reference the target entity
-	*/
-	getEntityReferences(targetEntityId) {
-		return this.entityReferences.get(targetEntityId) ?? new MultiMap();
-	}
-	/**
-	* Check if an archetype's signature references a specific entity
-	* (via entity-relation targeting the entity, or using entity as component type)
-	*/
 	archetypeReferencesEntity(archetype, entityId) {
-		for (const componentType of archetype.componentTypes) {
-			if (componentType === entityId) return true;
-			if (isEntityRelation(componentType)) {
-				if (getTargetIdFromRelationId(componentType) === entityId) return true;
-			}
-		}
-		return false;
+		return archetype.componentTypes.some((ct) => ct === entityId || isEntityRelation(ct) && getTargetIdFromRelationId(ct) === entityId);
 	}
-	/**
-	* Cleanup empty archetypes that reference a specific deleted entity
-	* Only removes archetypes whose component types reference the entity
-	*/
 	cleanupArchetypesReferencingEntity(entityId) {
 		for (let i = this.archetypes.length - 1; i >= 0; i--) {
 			const archetype = this.archetypes[i];
-			if (archetype.getEntities().length === 0 && this.archetypeReferencesEntity(archetype, entityId)) {
-				this.removeArchetypeFromList(archetype);
-				this.removeArchetypeFromSignatureMap(archetype);
-				this.removeArchetypeFromComponentIndex(archetype);
-				this.removeArchetypeFromQueries(archetype);
-			}
+			if (archetype.getEntities().length === 0 && this.archetypeReferencesEntity(archetype, entityId)) this.removeArchetype(archetype);
 		}
 	}
-	/**
-	* Remove archetype from the main archetypes list
-	*/
-	removeArchetypeFromList(archetype) {
+	removeArchetype(archetype) {
 		const index = this.archetypes.indexOf(archetype);
 		if (index !== -1) this.archetypes.splice(index, 1);
-	}
-	/**
-	* Remove archetype from the signature-to-archetype map
-	*/
-	removeArchetypeFromSignatureMap(archetype) {
-		const hashKey = this.createArchetypeSignature(archetype.componentTypes);
-		this.archetypeBySignature.delete(hashKey);
-	}
-	/**
-	* Remove archetype from the component-to-archetypes index
-	*/
-	removeArchetypeFromComponentIndex(archetype) {
+		this.archetypeBySignature.delete(this.createArchetypeSignature(archetype.componentTypes));
 		for (const componentType of archetype.componentTypes) {
 			const archetypes = this.archetypesByComponent.get(componentType);
 			if (archetypes) {
@@ -2122,119 +1941,8 @@ var World = class {
 				}
 			}
 		}
-	}
-	/**
-	* Remove archetype from all queries
-	*/
-	removeArchetypeFromQueries(archetype) {
 		for (const query of this.queries) query.removeArchetype(archetype);
 	}
-	/**
-	* Execute component lifecycle hooks for added and removed components
-	*/
-	triggerLifecycleHooks(entityId, addedComponents, removedComponents) {
-		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 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);
-			}
-		}
-		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 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);
-			}
-		}
-		this.triggerMultiComponentHooks(entityId, addedComponents, removedComponents);
-	}
-	/**
-	* Trigger multi-component hooks based on changes
-	*/
-	triggerMultiComponentHooks(entityId, addedComponents, removedComponents) {
-		for (const entry of this.multiHooks) {
-			const { componentTypes, requiredComponents, hook } = entry;
-			let anyRequiredAdded = false;
-			for (const reqComp of requiredComponents) if (addedComponents.has(reqComp)) {
-				anyRequiredAdded = true;
-				break;
-			}
-			let anyRequiredRemoved = false;
-			for (const reqComp of requiredComponents) if (removedComponents.has(reqComp)) {
-				anyRequiredRemoved = true;
-				break;
-			}
-			if (anyRequiredAdded && hook.on_set) {
-				if (this.entityHasAllComponents(entityId, requiredComponents)) {
-					const components = this.collectMultiHookComponents(entityId, componentTypes);
-					hook.on_set(entityId, componentTypes, components);
-				}
-			}
-			if (anyRequiredRemoved && hook.on_remove) {
-				if (this.entityHadAllComponentsBefore(entityId, requiredComponents, removedComponents)) {
-					const components = this.collectMultiHookComponentsWithRemoved(entityId, componentTypes, removedComponents);
-					hook.on_remove(entityId, componentTypes, components);
-				}
-			}
-		}
-	}
-	/**
-	* Check if entity currently has all required components
-	*/
-	entityHasAllComponents(entityId, requiredComponents) {
-		for (const reqComp of requiredComponents) if (!this.has(entityId, reqComp)) return false;
-		return true;
-	}
-	/**
-	* Check if entity had all required components before removal
-	*/
-	entityHadAllComponentsBefore(entityId, requiredComponents, removedComponents) {
-		for (const reqComp of requiredComponents) {
-			const wasRemoved = removedComponents.has(reqComp);
-			const stillHas = this.has(entityId, reqComp);
-			if (!wasRemoved && !stillHas) return false;
-		}
-		return true;
-	}
-	/**
-	* Collect component values for multi-component hook (current state)
-	*/
-	collectMultiHookComponents(entityId, componentTypes) {
-		const result = [];
-		for (const ct of componentTypes) if (isOptionalEntityId(ct)) {
-			const optionalId = ct.optional;
-			result.push(this.getOptional(entityId, optionalId));
-		} else result.push(this.get(entityId, ct));
-		return result;
-	}
-	/**
-	* Collect component values for multi-component hook with removed components (snapshot before removal)
-	*/
-	collectMultiHookComponentsWithRemoved(entityId, componentTypes, removedComponents) {
-		const result = [];
-		for (const ct of componentTypes) if (isOptionalEntityId(ct)) {
-			const optionalId = ct.optional;
-			if (removedComponents.has(optionalId)) result.push({ value: removedComponents.get(optionalId) });
-			else result.push(this.getOptional(entityId, optionalId));
-		} else {
-			const compId = ct;
-			if (removedComponents.has(compId)) result.push(removedComponents.get(compId));
-			else result.push(this.get(entityId, compId));
-		}
-		return result;
-	}
-	/**
-	* Convert the world into a plain snapshot object.
-	* This returns an in-memory structure and does not perform JSON stringification.
-	* Component values are stored as-is (they may be non-JSON-serializable).
-	*/
 	serialize() {
 		const entities = [];
 		for (const archetype of this.archetypes) {
@@ -2254,63 +1962,7 @@ var World = class {
 		};
 	}
 };
-var EntityBuilder = class {
-	world;
-	components = [];
-	constructor(world) {
-		this.world = world;
-	}
-	with(componentId, value) {
-		this.components.push({
-			type: "component",
-			id: componentId,
-			value
-		});
-		return this;
-	}
-	withTag(componentId) {
-		this.components.push({
-			type: "component",
-			id: componentId,
-			value: void 0
-		});
-		return this;
-	}
-	withRelation(componentId, targetEntity, value) {
-		this.components.push({
-			type: "relation",
-			componentId,
-			targetId: targetEntity,
-			value
-		});
-		return this;
-	}
-	withRelationTag(componentId, targetEntity) {
-		this.components.push({
-			type: "relation",
-			componentId,
-			targetId: targetEntity,
-			value: void 0
-		});
-		return this;
-	}
-	/**
-	* Create an entity and enqueue components to be applied. This method
-	* does NOT call `world.sync()` automatically; callers must invoke
-	* `world.sync()` to apply deferred commands.
-	* (Previously auto-synced; now a breaking change — buildDeferred() removed.)
-	*/
-	build() {
-		const entity = this.world.new();
-		for (const def of this.components) if (def.type === "component") this.world.set(entity, def.id, def.value);
-		else {
-			const relationId = relation(def.componentId, def.targetId);
-			this.world.set(entity, relationId, def.value);
-		}
-		return entity;
-	}
-};
 
 //#endregion
-export { decodeRelationId as a, isComponentId as c, isWildcardRelationId as d, relation as f, component as i, isEntityId as l, World as n, getComponentIdByName as o, Query as r, getComponentNameById as s, EntityBuilder as t, isRelationId as u };
+export { getComponentIdByName as a, isWildcardRelationId as c, isEntityId as d, isRelationId as f, component as i, relation as l, Query as n, getComponentNameById as o, EntityBuilder as r, decodeRelationId as s, World as t, isComponentId as u };
 //# sourceMappingURL=world.mjs.map