@codehz/ecs 0.6.9 → 0.6.10

package/world.mjs

@@ -369,6 +369,7 @@ 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);
+const componentMerges = new Array(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
@@ -401,6 +402,7 @@ function component(nameOrOptions) {
 		if (options.exclusive) exclusiveFlags.set(id);
 		if (options.cascadeDelete) cascadeDeleteFlags.set(id);
 		if (options.dontFragment) dontFragmentFlags.set(id);
+		if (options.merge) componentMerges[id] = options.merge;
 	}
 	return id;
 }
@@ -419,6 +421,21 @@ function getComponentIdByName(name) {
 function getComponentNameById(id) {
 	return componentNames[id];
 }
+function getBaseComponentId(componentType) {
+	if (isComponentId(componentType)) return componentType;
+	const decoded = decodeRelationRaw(componentType);
+	if (decoded === null) return void 0;
+	return isValidComponentId(decoded.componentId) ? decoded.componentId : void 0;
+}
+/**
+* Get merge callback for a componentType (including relation component types).
+* Returns undefined if the base component has no merge callback.
+*/
+function getComponentMerge(componentType) {
+	const baseComponentId = getBaseComponentId(componentType);
+	if (baseComponentId === void 0) return void 0;
+	return componentMerges[baseComponentId];
+}
 /**
 * Check if a component is marked as exclusive
 * @param id The component ID
@@ -637,6 +654,8 @@ const MAX_COMMAND_ITERATIONS = 100;
 var CommandBuffer = class {
 	commands = [];
 	swapBuffer = [];
+	/** Reusable map to group commands by entity, avoids per-sync allocations */
+	entityCommands = /* @__PURE__ */ new Map();
 	executeEntityCommands;
 	/**
 	* Create a command buffer with an executor function
@@ -681,14 +700,16 @@ var CommandBuffer = class {
 			iterations++;
 			const currentCommands = this.commands;
 			this.commands = this.swapBuffer;
-			const entityCommands = /* @__PURE__ */ new Map();
+			const entityCommands = this.entityCommands;
 			for (const cmd of currentCommands) {
-				if (!entityCommands.has(cmd.entityId)) entityCommands.set(cmd.entityId, []);
-				entityCommands.get(cmd.entityId).push(cmd);
+				const existing = entityCommands.get(cmd.entityId);
+				if (existing !== void 0) existing.push(cmd);
+				else entityCommands.set(cmd.entityId, [cmd]);
 			}
 			currentCommands.length = 0;
 			this.swapBuffer = currentCommands;
 			for (const [entityId, commands] of entityCommands) this.executeEntityCommands(entityId, commands);
+			entityCommands.clear();
 		}
 	}
 	/**
@@ -746,6 +767,16 @@ function matchesFilter(archetype, filter) {
 	});
 }
 
+//#endregion
+//#region src/core/component-type-utils.ts
+/**
+* Normalize component type collections into a stable ascending order.
+* This keeps cache keys and archetype signatures deterministic.
+*/
+function normalizeComponentTypes(componentTypes) {
+	return [...componentTypes].sort((a, b) => a - b);
+}
+
 //#endregion
 //#region src/query/query.ts
 /**
@@ -765,7 +796,7 @@ var Query = class {
 	specificDontFragmentTypes;
 	constructor(world, componentTypes, filter = {}) {
 		this.world = world;
-		this.componentTypes = [...componentTypes].sort((a, b) => a - b);
+		this.componentTypes = normalizeComponentTypes(componentTypes);
 		this.filter = filter;
 		this.wildcardTypes = this.componentTypes.filter((ct) => getDetailedIdType(ct).type === "wildcard-relation");
 		this.specificDontFragmentTypes = this.componentTypes.filter((ct) => {
@@ -923,16 +954,6 @@ function getOrCompute(cache, key, compute) {
 	}
 	return value;
 }
-/**
-* Alias for getOrCompute - maintained for backwards compatibility
-* @deprecated Use getOrCompute instead
-*/
-const getOrComputeCache = getOrCompute;
-/**
-* Alias for getOrCompute - maintained for backwards compatibility
-* @deprecated Use getOrCompute instead
-*/
-const getOrCreateWithSideEffect = getOrCompute;
 
 //#endregion
 //#region src/core/types.ts
@@ -1083,7 +1104,7 @@ var Archetype = class {
 	*/
 	componentDataSourcesCache = /* @__PURE__ */ new Map();
 	constructor(componentTypes, dontFragmentRelations) {
-		this.componentTypes = [...componentTypes].sort((a, b) => a - b);
+		this.componentTypes = normalizeComponentTypes(componentTypes);
 		this.componentTypeSet = new Set(this.componentTypes);
 		this.dontFragmentRelations = dontFragmentRelations;
 		for (const componentType of this.componentTypes) this.componentData.set(componentType, []);
@@ -1099,7 +1120,7 @@ var Archetype = class {
 	*/
 	matches(componentTypes) {
 		if (this.componentTypes.length !== componentTypes.length) return false;
-		const sortedTypes = [...componentTypes].sort((a, b) => a - b);
+		const sortedTypes = normalizeComponentTypes(componentTypes);
 		return this.componentTypes.every((type, index) => type === sortedTypes[index]);
 	}
 	addEntity(entityId, componentData) {
@@ -1134,6 +1155,9 @@ var Archetype = class {
 		if (dontFragmentData) for (const [componentType, data] of dontFragmentData) entityData.set(componentType, data);
 		return entityData;
 	}
+	getEntityDontFragmentRelations(entityId) {
+		return this.dontFragmentRelations.get(entityId);
+	}
 	dump() {
 		return this.entities.map((entity, i) => {
 			const components = /* @__PURE__ */ new Map();
@@ -1255,7 +1279,7 @@ var Archetype = class {
 	}
 	getCachedComponentDataSources(componentTypes) {
 		const cacheKey = buildCacheKey(componentTypes);
-		return getOrComputeCache(this.componentDataSourcesCache, cacheKey, () => componentTypes.map((compType) => this.getComponentDataSource(compType)));
+		return getOrCompute(this.componentDataSourcesCache, cacheKey, () => componentTypes.map((compType) => this.getComponentDataSource(compType)));
 	}
 	getComponentDataSource(compType) {
 		const optional = isOptionalEntityId(compType);
@@ -1412,6 +1436,12 @@ function processSetCommand(entityId, currentArchetype, componentType, component$
 			if (!currentArchetype.componentTypeSet.has(wildcardMarker)) changeset.set(wildcardMarker, void 0);
 		}
 	}
+	const merge = getComponentMerge(componentType);
+	if (merge !== void 0 && changeset.adds.has(componentType)) {
+		const prev = changeset.adds.get(componentType);
+		changeset.set(componentType, merge(prev, component$1));
+		return;
+	}
 	changeset.set(componentType, component$1);
 }
 function processDeleteCommand(entityId, currentArchetype, componentType, changeset) {
@@ -1427,10 +1457,9 @@ function removeMatchingRelations(entityId, archetype, baseComponentId, changeset
 		if (isWildcardRelationId(componentType)) continue;
 		if (getComponentIdFromRelationId(componentType) === baseComponentId) changeset.delete(componentType);
 	}
-	const entityData = archetype.getEntity(entityId);
-	if (entityData) for (const [componentType] of entityData) {
-		if (archetype.componentTypeSet.has(componentType)) continue;
-		if (getComponentIdFromRelationId(componentType) === baseComponentId) changeset.delete(componentType);
+	const dontFragmentData = archetype.getEntityDontFragmentRelations(entityId);
+	if (dontFragmentData) {
+		for (const componentType of dontFragmentData.keys()) if (getComponentIdFromRelationId(componentType) === baseComponentId) changeset.delete(componentType);
 	}
 }
 function removeWildcardRelations(entityId, currentArchetype, baseComponentId, changeset) {
@@ -1440,35 +1469,66 @@ function removeWildcardRelations(entityId, currentArchetype, baseComponentId, ch
 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) {
+	for (const otherComponentType of archetype.componentTypes) {
 		if (otherComponentType === removedComponentType) continue;
 		if (otherComponentType === wildcardMarker) continue;
 		if (changeset.removes.has(otherComponentType)) continue;
 		if (getComponentIdFromRelationId(otherComponentType) === componentId) return;
 	}
+	const dontFragmentData = archetype.getEntityDontFragmentRelations(entityId);
+	if (dontFragmentData) for (const otherComponentType of dontFragmentData.keys()) {
+		if (otherComponentType === removedComponentType) continue;
+		if (changeset.removes.has(otherComponentType)) continue;
+		if (getComponentIdFromRelationId(otherComponentType) === componentId) return;
+	}
 	changeset.delete(wildcardMarker);
 }
+function hasEntityComponent(archetype, entityId, componentType) {
+	if (archetype.componentTypeSet.has(componentType)) return true;
+	return archetype.getEntityDontFragmentRelations(entityId)?.has(componentType) ?? false;
+}
+function pruneMissingRemovals(changeset, archetype, entityId) {
+	let toPrune;
+	for (const componentType of changeset.removes) if (!hasEntityComponent(archetype, entityId, componentType)) {
+		if (toPrune === void 0) toPrune = [];
+		toPrune.push(componentType);
+	}
+	if (toPrune !== void 0) for (const componentType of toPrune) changeset.removes.delete(componentType);
+}
+function hasArchetypeStructuralChange(changeset, currentArchetype) {
+	for (const componentType of changeset.removes) if (!isDontFragmentRelation(componentType) && currentArchetype.componentTypeSet.has(componentType)) return true;
+	for (const componentType of changeset.adds.keys()) if (!isDontFragmentRelation(componentType) && !currentArchetype.componentTypeSet.has(componentType)) return true;
+	return false;
+}
+function buildFinalRegularComponentTypes(currentArchetype, changeset) {
+	const finalRegularTypes = new Set(currentArchetype.componentTypes);
+	for (const componentType of changeset.removes) if (!isDontFragmentRelation(componentType)) finalRegularTypes.delete(componentType);
+	for (const componentType of changeset.adds.keys()) if (!isDontFragmentRelation(componentType)) finalRegularTypes.add(componentType);
+	return Array.from(finalRegularTypes);
+}
 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))) return {
+	pruneMissingRemovals(changeset, currentArchetype, entityId);
+	if (hasArchetypeStructuralChange(changeset, currentArchetype)) return {
 		removedComponents,
-		newArchetype: moveEntityToNewArchetype(ctx, entityId, currentArchetype, finalComponentTypes, changeset, removedComponents, entityToArchetype)
+		newArchetype: moveEntityToNewArchetype(ctx, entityId, currentArchetype, buildFinalRegularComponentTypes(currentArchetype, changeset), changeset, removedComponents, entityToArchetype)
 	};
-	else updateEntityInSameArchetype(ctx, entityId, currentArchetype, changeset, removedComponents);
-	else updateEntityInSameArchetype(ctx, entityId, currentArchetype, changeset, removedComponents);
+	updateEntityInSameArchetype(ctx, entityId, currentArchetype, changeset, removedComponents);
 	return {
 		removedComponents,
 		newArchetype: currentArchetype
 	};
 }
+/**
+* Optimized variant of applyChangeset for when no lifecycle hooks are registered.
+* Skips creating the removedComponents map, reducing allocations in the hot path.
+*/
+function applyChangesetNoHooks(ctx, entityId, currentArchetype, changeset, entityToArchetype) {
+	pruneMissingRemovals(changeset, currentArchetype, entityId);
+	if (hasArchetypeStructuralChange(changeset, currentArchetype)) return moveEntityToNewArchetypeNoHooks(ctx, entityId, currentArchetype, buildFinalRegularComponentTypes(currentArchetype, changeset), changeset, entityToArchetype);
+	updateEntityInSameArchetypeNoHooks(ctx, entityId, currentArchetype, changeset);
+	return currentArchetype;
+}
 function moveEntityToNewArchetype(ctx, entityId, currentArchetype, finalComponentTypes, changeset, removedComponents, entityToArchetype) {
 	const newArchetype = ctx.ensureArchetype(finalComponentTypes);
 	const currentComponents = currentArchetype.removeEntity(entityId);
@@ -1484,6 +1544,28 @@ function updateEntityInSameArchetype(ctx, entityId, currentArchetype, changeset,
 		currentArchetype.set(entityId, componentType, component$1);
 	}
 }
+/**
+* No-hooks variant: moves entity to new archetype without collecting removed component data.
+* Only called from applyChangesetNoHooks when no lifecycle hooks are registered.
+*/
+function moveEntityToNewArchetypeNoHooks(ctx, entityId, currentArchetype, finalComponentTypes, changeset, entityToArchetype) {
+	const newArchetype = ctx.ensureArchetype(finalComponentTypes);
+	const currentComponents = currentArchetype.removeEntity(entityId);
+	newArchetype.addEntity(entityId, changeset.applyTo(currentComponents));
+	entityToArchetype.set(entityId, newArchetype);
+	return newArchetype;
+}
+/**
+* No-hooks variant: updates entity in same archetype without tracking removed component data.
+* Only called from applyChangesetNoHooks when no lifecycle hooks are registered.
+*/
+function updateEntityInSameArchetypeNoHooks(ctx, entityId, currentArchetype, changeset) {
+	applyDontFragmentChangesNoHooks(ctx.dontFragmentRelations, entityId, changeset);
+	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)) {
@@ -1504,6 +1586,23 @@ function applyDontFragmentChanges(dontFragmentRelations, entityId, changeset, re
 	}
 	if (entityRelations && entityRelations.size === 0) dontFragmentRelations.delete(entityId);
 }
+/**
+* No-hooks variant of applyDontFragmentChanges that skips tracking removed component data.
+*/
+function applyDontFragmentChangesNoHooks(dontFragmentRelations, entityId, changeset) {
+	let entityRelations = dontFragmentRelations.get(entityId);
+	for (const componentType of changeset.removes) if (isDontFragmentRelation(componentType)) {
+		if (entityRelations) entityRelations.delete(componentType);
+	}
+	for (const [componentType, component$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) {
@@ -1516,12 +1615,6 @@ function filterRegularComponentTypes(componentTypes) {
 	}
 	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
@@ -1794,9 +1887,23 @@ var World = class {
 	relationEntityIdsByTarget = /* @__PURE__ */ new Map();
 	queries = [];
 	queryCache = /* @__PURE__ */ new Map();
-	commandBuffer = new CommandBuffer((entityId, commands) => this.executeEntityCommands(entityId, commands));
 	legacyHooks = /* @__PURE__ */ new Map();
 	hooks = /* @__PURE__ */ new Set();
+	commandBuffer = new CommandBuffer((entityId, commands) => this.executeEntityCommands(entityId, commands));
+	_changeset = new ComponentChangeset();
+	/** Cached command processor context to avoid per-entity object allocation */
+	_commandCtx = {
+		dontFragmentRelations: this.dontFragmentRelations,
+		ensureArchetype: (ct) => this.ensureArchetype(ct)
+	};
+	/** Cached hooks context to avoid per-entity object allocation */
+	_hooksCtx = {
+		hooks: this.legacyHooks,
+		multiHooks: this.hooks,
+		has: (eid, ct) => this.has(eid, ct),
+		get: (eid, ct) => this.get(eid, ct),
+		getOptional: (eid, ct) => this.getOptional(eid, ct)
+	};
 	constructor(snapshot) {
 		if (snapshot && typeof snapshot === "object") this.deserializeSnapshot(snapshot);
 	}
@@ -1940,40 +2047,77 @@ var World = class {
 		if (this.isComponentEntityId(entityId)) return true;
 		return this.entityToArchetype.has(entityId);
 	}
-	set(entityId, componentTypeOrComponent, maybeComponent) {
+	assertEntityExists(entityId, label) {
+		if (!this.exists(entityId)) throw new Error(`${label} ${entityId} does not exist`);
+	}
+	assertComponentTypeValid(componentType) {
+		if (getDetailedIdType(componentType).type === "invalid") throw new Error(`Invalid component type: ${componentType}`);
+	}
+	assertSetComponentTypeValid(componentType) {
+		const detailedType = getDetailedIdType(componentType);
+		if (detailedType.type === "invalid") throw new Error(`Invalid component type: ${componentType}`);
+		if (detailedType.type === "wildcard-relation") throw new Error(`Cannot directly add wildcard relation components: ${componentType}`);
+	}
+	resolveSetOperation(entityId, componentTypeOrComponent, maybeComponent) {
 		if (maybeComponent === void 0 && componentTypeOrComponent !== void 0) {
-			const detailedType$1 = getDetailedIdType(entityId);
-			if (detailedType$1.type === "component" || detailedType$1.type === "component-relation") {
+			const detailedType = getDetailedIdType(entityId);
+			if (detailedType.type === "component" || detailedType.type === "component-relation") {
 				const componentId = entityId;
-				const component$2 = componentTypeOrComponent;
-				if (!this.exists(componentId)) throw new Error(`Component entity ${componentId} does not exist`);
-				const detailedComponentType = getDetailedIdType(componentId);
-				if (detailedComponentType.type === "invalid") throw new Error(`Invalid component type: ${componentId}`);
-				if (detailedComponentType.type === "wildcard-relation") throw new Error(`Cannot directly add wildcard relation components: ${componentId}`);
-				this.commandBuffer.set(componentId, componentId, component$2);
-				return;
+				this.assertEntityExists(componentId, "Component entity");
+				this.assertSetComponentTypeValid(componentId);
+				return {
+					entityId: componentId,
+					componentType: componentId,
+					component: componentTypeOrComponent
+				};
 			}
 		}
-		const entityIdArg = entityId;
+		const targetEntityId = entityId;
 		const componentType = componentTypeOrComponent;
-		const component$1 = maybeComponent;
-		if (!this.exists(entityIdArg)) throw new Error(`Entity ${entityIdArg} does not exist`);
-		const detailedType = getDetailedIdType(componentType);
-		if (detailedType.type === "invalid") throw new Error(`Invalid component type: ${componentType}`);
-		if (detailedType.type === "wildcard-relation") throw new Error(`Cannot directly add wildcard relation components: ${componentType}`);
-		this.commandBuffer.set(entityIdArg, componentType, component$1);
+		this.assertEntityExists(targetEntityId, "Entity");
+		this.assertSetComponentTypeValid(componentType);
+		return {
+			entityId: targetEntityId,
+			componentType,
+			component: maybeComponent
+		};
 	}
-	remove(entityId, componentType) {
+	resolveRemoveOperation(entityId, componentType) {
 		if (componentType === void 0) {
 			const componentId = entityId;
-			if (!this.exists(componentId)) throw new Error(`Component entity ${componentId} does not exist`);
-			this.commandBuffer.remove(componentId, componentId);
-			return;
+			this.assertEntityExists(componentId, "Component entity");
+			return {
+				entityId: componentId,
+				componentType: componentId
+			};
 		}
-		const entityIdArg = entityId;
-		if (!this.exists(entityIdArg)) throw new Error(`Entity ${entityIdArg} does not exist`);
-		if (getDetailedIdType(componentType).type === "invalid") throw new Error(`Invalid component type: ${componentType}`);
-		this.commandBuffer.remove(entityIdArg, componentType);
+		const targetEntityId = entityId;
+		this.assertEntityExists(targetEntityId, "Entity");
+		this.assertComponentTypeValid(componentType);
+		return {
+			entityId: targetEntityId,
+			componentType
+		};
+	}
+	getComponentEntityWildcardRelations(entityId, wildcardComponentType) {
+		const componentId = getComponentIdFromRelationId(wildcardComponentType);
+		const data = this.componentEntityComponents.get(entityId);
+		if (componentId === void 0 || !data) return [];
+		const relations = [];
+		for (const [key, value] of data.entries()) {
+			if (getComponentIdFromRelationId(key) !== componentId) continue;
+			const detailed = getDetailedIdType(key);
+			if (detailed.type === "entity-relation" || detailed.type === "component-relation") relations.push([detailed.targetId, value]);
+		}
+		return relations;
+	}
+	set(entityId, componentTypeOrComponent, maybeComponent) {
+		const { entityId: targetEntityId, componentType, component: component$1 } = this.resolveSetOperation(entityId, componentTypeOrComponent, maybeComponent);
+		this.commandBuffer.set(targetEntityId, componentType, component$1);
+	}
+	remove(entityId, componentType) {
+		const { entityId: targetEntityId, componentType: targetComponentType } = this.resolveRemoveOperation(entityId, componentType);
+		this.commandBuffer.remove(targetEntityId, targetComponentType);
 	}
 	/**
 	* Deletes an entity and all its components from the world.
@@ -2012,18 +2156,7 @@ var World = class {
 	}
 	get(entityId, componentType = entityId) {
 		if (this.isComponentEntityId(entityId)) {
-			if (isWildcardRelationId(componentType)) {
-				const componentId = getComponentIdFromRelationId(componentType);
-				const data$1 = this.componentEntityComponents.get(entityId);
-				const relations = [];
-				if (componentId !== void 0 && data$1) {
-					for (const [key, value] of data$1.entries()) if (getComponentIdFromRelationId(key) === componentId) {
-						const detailed = getDetailedIdType(key);
-						if (detailed.type === "entity-relation" || detailed.type === "component-relation") relations.push([detailed.targetId, value]);
-					}
-				}
-				return relations;
-			}
+			if (isWildcardRelationId(componentType)) return this.getComponentEntityWildcardRelations(entityId, componentType);
 			const data = this.componentEntityComponents.get(entityId);
 			if (!data || !data.has(componentType)) throw new Error(`Entity ${entityId} does not have component ${componentType}. Use has() to check component existence before calling get().`);
 			return data.get(componentType);
@@ -2040,15 +2173,7 @@ var World = class {
 	getOptional(entityId, componentType = entityId) {
 		if (this.isComponentEntityId(entityId)) {
 			if (isWildcardRelationId(componentType)) {
-				const componentId = getComponentIdFromRelationId(componentType);
-				if (componentId === void 0) return void 0;
-				const data$1 = this.componentEntityComponents.get(entityId);
-				if (!data$1) return void 0;
-				const relations = [];
-				for (const [key, value] of data$1.entries()) if (getComponentIdFromRelationId(key) === componentId) {
-					const detailed = getDetailedIdType(key);
-					if (detailed.type === "entity-relation" || detailed.type === "component-relation") relations.push([detailed.targetId, value]);
-				}
+				const relations = this.getComponentEntityWildcardRelations(entityId, componentType);
 				if (relations.length === 0) return void 0;
 				return { value: relations };
 			}
@@ -2190,7 +2315,7 @@ var World = class {
 	* });
 	*/
 	createQuery(componentTypes, filter = {}) {
-		const sortedTypes = [...componentTypes].sort((a, b) => a - b);
+		const sortedTypes = normalizeComponentTypes(componentTypes);
 		const filterKey = serializeQueryFilter(filter);
 		const key = `${this.createArchetypeSignature(sortedTypes)}${filterKey ? `|${filterKey}` : ""}`;
 		const cached = this.queryCache.get(key);
@@ -2308,6 +2433,11 @@ var World = class {
 		const archetypeLists = componentTypes.map((type) => this.archetypesByComponent.get(type) || []).sort((a, b) => a.length - b.length);
 		const shortest = archetypeLists[0];
 		if (shortest.length === 0) return [];
+		if (archetypeLists.length === 2) {
+			const second = archetypeLists[1];
+			const secondSet = new Set(second);
+			return shortest.filter((a) => secondSet.has(a));
+		}
 		let result = new Set(shortest);
 		for (let i = 1; i < archetypeLists.length; i++) {
 			const listSet = new Set(archetypeLists[i]);
@@ -2329,7 +2459,8 @@ var World = class {
 		}
 	}
 	executeEntityCommands(entityId, commands) {
-		const changeset = new ComponentChangeset();
+		const changeset = this._changeset;
+		changeset.clear();
 		if (this.isComponentEntityId(entityId)) {
 			this.executeComponentEntityCommands(entityId, commands);
 			return changeset;
@@ -2343,11 +2474,15 @@ var World = class {
 		processCommands(entityId, currentArchetype, commands, changeset, (eid, arch, compId) => {
 			if (isExclusiveComponent(compId)) removeMatchingRelations(eid, arch, compId, changeset);
 		});
-		const { removedComponents, newArchetype } = applyChangeset({
-			dontFragmentRelations: this.dontFragmentRelations,
-			ensureArchetype: (ct) => this.ensureArchetype(ct)
-		}, entityId, currentArchetype, changeset, this.entityToArchetype);
-		this.updateEntityReferences(entityId, changeset);
+		const hasHooks = this.legacyHooks.size > 0 || this.hooks.size > 0;
+		const hasEntityRefs = changeset.removes.size > 0 || changeset.adds.size > 0;
+		if (!hasHooks) {
+			applyChangesetNoHooks(this._commandCtx, entityId, currentArchetype, changeset, this.entityToArchetype);
+			if (hasEntityRefs) this.updateEntityReferences(entityId, changeset);
+			return changeset;
+		}
+		const { removedComponents, newArchetype } = applyChangeset(this._commandCtx, entityId, currentArchetype, changeset, this.entityToArchetype);
+		if (hasEntityRefs) this.updateEntityReferences(entityId, changeset);
 		triggerLifecycleHooks(this.createHooksContext(), entityId, changeset.adds, removedComponents, currentArchetype, newArchetype);
 		return changeset;
 	}
@@ -2356,27 +2491,32 @@ var World = class {
 			this.clearComponentEntityComponents(entityId);
 			return;
 		}
-		for (const command of commands) if (command.type === "set" && command.componentType) this.getComponentEntityComponents(entityId, true).set(command.componentType, command.component);
-		else if (command.type === "delete" && command.componentType) {
+		const pendingSetValues = /* @__PURE__ */ new Map();
+		for (const command of commands) if (command.type === "set" && command.componentType) {
+			const merge = getComponentMerge(command.componentType);
+			let nextValue = command.component;
+			if (merge !== void 0 && pendingSetValues.has(command.componentType)) nextValue = merge(pendingSetValues.get(command.componentType), command.component);
+			pendingSetValues.set(command.componentType, nextValue);
+			this.getComponentEntityComponents(entityId, true).set(command.componentType, nextValue);
+		} else if (command.type === "delete" && command.componentType) {
 			const data = this.componentEntityComponents.get(entityId);
-			if (!data) continue;
 			if (isWildcardRelationId(command.componentType)) {
 				const componentId = getComponentIdFromRelationId(command.componentType);
 				if (componentId !== void 0) {
-					for (const key of Array.from(data.keys())) if (getComponentIdFromRelationId(key) === componentId) data.delete(key);
+					if (data) {
+						for (const key of Array.from(data.keys())) if (getComponentIdFromRelationId(key) === componentId) data.delete(key);
+					}
+					for (const key of Array.from(pendingSetValues.keys())) if (getComponentIdFromRelationId(key) === componentId) pendingSetValues.delete(key);
 				}
-			} else data.delete(command.componentType);
-			if (data.size === 0) this.clearComponentEntityComponents(entityId);
+			} else {
+				data?.delete(command.componentType);
+				pendingSetValues.delete(command.componentType);
+			}
+			if (data?.size === 0) this.clearComponentEntityComponents(entityId);
 		}
 	}
 	createHooksContext() {
-		return {
-			hooks: this.legacyHooks,
-			multiHooks: this.hooks,
-			has: (eid, ct) => this.has(eid, ct),
-			get: (eid, ct) => this.get(eid, ct),
-			getOptional: (eid, ct) => this.getOptional(eid, ct)
-		};
+		return this._hooksCtx;
 	}
 	removeComponentImmediate(entityId, componentType, targetEntityId) {
 		const sourceArchetype = this.entityToArchetype.get(entityId);
@@ -2385,10 +2525,7 @@ var World = class {
 		changeset.delete(componentType);
 		maybeRemoveWildcardMarker(entityId, sourceArchetype, componentType, getComponentIdFromRelationId(componentType), changeset);
 		const removedComponent = sourceArchetype.get(entityId, componentType);
-		const { newArchetype } = applyChangeset({
-			dontFragmentRelations: this.dontFragmentRelations,
-			ensureArchetype: (ct) => this.ensureArchetype(ct)
-		}, entityId, sourceArchetype, changeset, this.entityToArchetype);
+		const { newArchetype } = applyChangeset(this._commandCtx, entityId, sourceArchetype, changeset, this.entityToArchetype);
 		untrackEntityReference(this.entityReferences, entityId, componentType, targetEntityId);
 		triggerLifecycleHooks(this.createHooksContext(), entityId, /* @__PURE__ */ new Map(), new Map([[componentType, removedComponent]]), sourceArchetype, newArchetype);
 	}
@@ -2403,9 +2540,9 @@ var World = class {
 		} else if (componentType >= ENTITY_ID_START) trackEntityReference(this.entityReferences, entityId, componentType, componentType);
 	}
 	ensureArchetype(componentTypes) {
-		const sortedTypes = filterRegularComponentTypes(componentTypes).sort((a, b) => a - b);
+		const sortedTypes = normalizeComponentTypes(filterRegularComponentTypes(componentTypes));
 		const hashKey = this.createArchetypeSignature(sortedTypes);
-		return getOrCreateWithSideEffect(this.archetypeBySignature, hashKey, () => this.createNewArchetype(sortedTypes));
+		return getOrCompute(this.archetypeBySignature, hashKey, () => this.createNewArchetype(sortedTypes));
 	}
 	createNewArchetype(componentTypes) {
 		const newArchetype = new Archetype(componentTypes, this.dontFragmentRelations);