int

Author: jerzakm

packages/core/src/entity/entity.ts

@@ -15,12 +15,12 @@ export function createEntity(world: World, ...traits: ConfigurableTrait[]): Enti
     const ctx = world[$internal];
     const entity = allocateEntity(ctx.entityIndex);
 
-    for (const query of ctx.notQueries) {
-        const match = query.check(world, entity);
-        if (match) query.add(entity);
-        // Reset all tracking bitmasks for the query.
-        query.resetTrackingBitmasks(getEntityId(entity));
-    }
+	for (let i = 0, len = ctx.notQueries.length; i < len; i++) {
+		const query = ctx.notQueries[i];
+		const match = query.check(world, entity);
+		if (match) query.add(entity);
+		query.resetTrackingBitmasks(getEntityId(entity));
+	}
 
     ctx.entityTraits.set(entity, new Set());
     addTrait(world, entity, ...traits);

packages/core/src/query/query.ts

@@ -36,9 +36,8 @@ export function runQuery<T extends QueryParameter[]>(
 ): QueryResult<T> {
     commitQueryRemovals(world);
 
-    // With hybrid bitmask strategy, query.entities is already incrementally maintained
-    // with both trait and relation filters applied. Just return the pre-filtered entities.
-    const entities = query.entities.dense.slice() as Entity[];
+	// query.entities.dense already returns a fresh copy, no need for extra .slice()
+	const entities = query.entities.dense as Entity[];
 
     // Clear so it can accumulate again.
     if (query.isTracking) {
@@ -85,13 +84,14 @@ export function commitQueryRemovals(world: World) {
     const ctx = world[$internal];
     if (!ctx.dirtyQueries.size) return;
 
-    for (const query of ctx.dirtyQueries) {
-        for (let i = query.toRemove.dense.length - 1; i >= 0; i--) {
-            const eid = query.toRemove.dense[i];
-            query.toRemove.remove(eid);
-            query.entities.remove(eid);
-        }
-    }
+	for (const query of ctx.dirtyQueries) {
+		const toRemoveDense = query.toRemove.dense;
+		for (let i = toRemoveDense.length - 1; i >= 0; i--) {
+			const eid = toRemoveDense[i];
+			query.toRemove.remove(eid);
+			query.entities.remove(eid);
+		}
+	}
 
     ctx.dirtyQueries.clear();
 }
@@ -315,19 +315,19 @@ export function createQueryInstance<T extends QueryParameter[]>(
     // Add to world
     ctx.queriesHashMap.set(query.hash, query);
 
-    // Register query with trait instances
-    if (query.isTracking) {
-        query.traitInstances.all.forEach((instance) => {
-            instance.trackingQueries.add(query);
-        });
-    } else {
-        query.traitInstances.all.forEach((instance) => {
-            instance.queries.add(query);
-        });
-    }
+	// Register query with trait instances
+	if (query.isTracking) {
+		for (let i = 0; i < query.traitInstances.all.length; i++) {
+			query.traitInstances.all[i].trackingQueries.push(query);
+		}
+	} else {
+		for (let i = 0; i < query.traitInstances.all.length; i++) {
+			query.traitInstances.all[i].queries.push(query);
+		}
+	}
 
     // Add to notQueries if has forbidden traits
-    if (query.traitInstances.forbidden.length > 0) ctx.notQueries.add(query);
+	if (query.traitInstances.forbidden.length > 0) ctx.notQueries.push(query);
 
     // Index queries with relation filters
     const hasRelationFilters = query.relationFilters && query.relationFilters.length > 0;
@@ -337,7 +337,7 @@ export function createQueryInstance<T extends QueryParameter[]>(
             const relationTrait = pair[$internal].relation[$internal].trait;
             const relationTraitInstance = getTraitInstance(ctx.traitInstances, relationTrait);
             if (relationTraitInstance) {
-                relationTraitInstance.relationQueries.add(query);
+			relationTraitInstance.relationQueries.push(query);
             }
         }
     }

packages/core/src/query/utils/tracking-cursor.ts

@@ -17,7 +17,7 @@ export function getTrackingCursor() {
 
 export function setTrackingMasks(world: World, id: number) {
     const ctx = world[$internal];
-    const snapshot = structuredClone(ctx.entityMasks);
+    const snapshot = ctx.entityMasks.map((mask) => Array.from(mask)) as number[][];
     ctx.trackingSnapshots.set(id, snapshot);
 
     // For dirty and changed masks, make clone of entity masks and set all bits to 0.

packages/core/src/relation/relation.ts

@@ -319,15 +319,15 @@ function updateQueriesForRelationChange(
 
     // Update queries indexed by this relation (much faster than iterating all queries)
     // All queries in relationQueries already filter by this relation
-    for (const query of traitData.relationQueries) {
-        // Re-check entity against query
-        const match = checkQueryWithRelations(world, query, entity);
-        if (match) {
-            query.add(entity);
-        } else {
-            query.remove(world, entity);
-        }
-    }
+	for (let i = 0, len = traitData.relationQueries.length; i < len; i++) {
+		const query = traitData.relationQueries[i];
+		const match = checkQueryWithRelations(world, query, entity);
+		if (match) {
+			query.add(entity);
+		} else {
+			query.remove(world, entity);
+		}
+	}
 }
 
 /** Swap-and-pop data arrays for non-exclusive relations */

packages/core/src/trait/trait.ts

@@ -33,6 +33,8 @@ import {
     validateSchema,
 } from '../storage';
 import type { World } from '../world';
+import { BitSet } from '../utils/bit-set';
+import { ensureEntityMaskSize } from '../world/utils/ensure-entity-mask-size';
 import { incrementWorldBitflag } from '../world/utils/increment-world-bit-flag';
 import { getTraitInstance, hasTraitInstance, setTraitInstance } from './trait-instance';
 import type {
@@ -100,11 +102,12 @@ export function registerTrait(world: World, trait: Trait) {
         bitflag: ctx.bitflag,
         trait,
         store: traitCtx.createStore(),
-        queries: new Set(),
-        trackingQueries: new Set(),
-        notQueries: new Set(),
-        relationQueries: new Set(),
+		queries: [],
+		trackingQueries: [],
+		notQueries: [],
+		relationQueries: [],
         schema: trait.schema,
+        entityBitSet: new BitSet(),
         changeSubscriptions: new Set(),
         addSubscriptions: new Set(),
         removeSubscriptions: new Set(),
@@ -453,37 +456,43 @@ export function getTrait(world: World, entity: Entity, trait: Trait | RelationPa
 
     // Add bitflag to entity bitmask
     const eid = getEntityId(entity);
+    ensureEntityMaskSize(ctx.entityMasks, generationId, eid);
     ctx.entityMasks[generationId][eid] |= bitflag;
+    instance.entityBitSet.add(eid);
 
     // Set the entity as dirty
     for (const dirtyMask of ctx.dirtyMasks.values()) {
         if (!dirtyMask[generationId]) dirtyMask[generationId] = [];
         dirtyMask[generationId][eid] |= bitflag;
     }
 
-    // Update non-tracking queries (no event data needed)
-    for (const query of queries) {
-        query.toRemove.remove(entity);
-        // Use checkQueryWithRelations if query has relation filters, otherwise use checkQuery
-        const match =
-            query.relationFilters && query.relationFilters.length > 0
-                ? checkQueryWithRelations(world, query, entity)
-                : query.check(world, entity);
-        if (match) query.add(entity);
-        else query.remove(world, entity);
-    }
-
-    // Update tracking queries (with event data)
-    for (const query of trackingQueries) {
-        query.toRemove.remove(entity);
-        // Use checkQueryTrackingWithRelations if query has relation filters, otherwise use checkQueryTracking
-        const match =
-            query.relationFilters && query.relationFilters.length > 0
-                ? checkQueryTrackingWithRelations(world, query, entity, 'add', generationId, bitflag)
-                : query.checkTracking(world, entity, 'add', generationId, bitflag);
-        if (match) query.add(entity);
-        else query.remove(world, entity);
-    }
+	// Update non-tracking queries (no event data needed)
+	// PERF: Use indexed loop instead of for...of to avoid iterator overhead
+	for (let qi = 0, qLen = queries.length; qi < qLen; qi++) {
+		const query = queries[qi];
+		query.toRemove.remove(entity);
+		// Use checkQueryWithRelations if query has relation filters, otherwise use checkQuery
+		const match =
+			query.relationFilters && query.relationFilters.length > 0
+				? checkQueryWithRelations(world, query, entity)
+				: query.check(world, entity);
+		if (match) query.add(entity);
+		else query.remove(world, entity);
+	}
+
+	// Update tracking queries (with event data)
+	// PERF: Use indexed loop instead of for...of to avoid iterator overhead
+	for (let qi = 0, qLen = trackingQueries.length; qi < qLen; qi++) {
+		const query = trackingQueries[qi];
+		query.toRemove.remove(entity);
+		// Use checkQueryTrackingWithRelations if query has relation filters, otherwise use checkQueryTracking
+		const match =
+			query.relationFilters && query.relationFilters.length > 0
+				? checkQueryTrackingWithRelations(world, query, entity, 'add', generationId, bitflag)
+				: query.checkTracking(world, entity, 'add', generationId, bitflag);
+		if (match) query.add(entity);
+		else query.remove(world, entity);
+	}
 
     // Add trait to entity internally
     ctx.entityTraits.get(entity)!.add(trait);
@@ -510,40 +519,41 @@ function removeTraitFromEntity(world: World, entity: Entity, trait: Trait): void
     // Remove bitflag from entity bitmask
     const eid = getEntityId(entity);
     ctx.entityMasks[generationId][eid] &= ~bitflag;
+    instance.entityBitSet.remove(eid);
 
     // Set the entity as dirty
     for (const dirtyMask of ctx.dirtyMasks.values()) {
         dirtyMask[generationId][eid] |= bitflag;
     }
 
-    // Update non-tracking queries
-    for (const query of queries) {
-        // Use checkQueryWithRelations if query has relation filters, otherwise use checkQuery
-        const match =
-            query.relationFilters && query.relationFilters.length > 0
-                ? checkQueryWithRelations(world, query, entity)
-                : query.check(world, entity);
-        if (match) query.add(entity);
-        else query.remove(world, entity);
-    }
-
-    // Update tracking queries (with event data)
-    for (const query of trackingQueries) {
-        // Use checkQueryTrackingWithRelations if query has relation filters, otherwise use checkQueryTracking
-        const match =
-            query.relationFilters && query.relationFilters.length > 0
-                ? checkQueryTrackingWithRelations(
-                      world,
-                      query,
-                      entity,
-                      'remove',
-                      generationId,
-                      bitflag
-                  )
-                : query.checkTracking(world, entity, 'remove', generationId, bitflag);
-        if (match) query.add(entity);
-        else query.remove(world, entity);
-    }
+	// Update non-tracking queries
+	for (let qi = 0, qLen = queries.length; qi < qLen; qi++) {
+		const query = queries[qi];
+		const match =
+			query.relationFilters && query.relationFilters.length > 0
+				? checkQueryWithRelations(world, query, entity)
+				: query.check(world, entity);
+		if (match) query.add(entity);
+		else query.remove(world, entity);
+	}
+
+	// Update tracking queries (with event data)
+	for (let qi = 0, qLen = trackingQueries.length; qi < qLen; qi++) {
+		const query = trackingQueries[qi];
+		const match =
+			query.relationFilters && query.relationFilters.length > 0
+				? checkQueryTrackingWithRelations(
+						world,
+						query,
+						entity,
+						'remove',
+						generationId,
+						bitflag
+					)
+				: query.checkTracking(world, entity, 'remove', generationId, bitflag);
+		if (match) query.add(entity);
+		else query.remove(world, entity);
+	}
 
     // Remove trait from entity internally
     ctx.entityTraits.get(entity)!.delete(trait);

packages/core/src/trait/types.ts

@@ -3,6 +3,7 @@ import type { Entity } from '../entity/types';
 import type { QueryInstance } from '../query/types';
 import type { Relation, RelationPair } from '../relation/types';
 import type { AoSFactory, Schema, Store, StoreType } from '../storage';
+import type { BitSet } from '../utils/bit-set';
 
 // Backwards-compatible alias (the trait "type" is the storage layout).
 export type TraitType = StoreType;
@@ -87,13 +88,12 @@ export interface TraitInstance<T extends Trait = Trait, S extends Schema = Extra
     trait: Trait;
     store: Store<S>;
     /** Non-tracking queries that include this trait */
-    queries: Set<QueryInstance>;
-    /** Tracking queries (Added/Removed/Changed) that include this trait */
-    trackingQueries: Set<QueryInstance>;
-    notQueries: Set<QueryInstance>;
-    /** Queries that filter by this relation (only for relation traits) */
-    relationQueries: Set<QueryInstance>;
+	queries: QueryInstance[];
+	trackingQueries: QueryInstance[];
+	notQueries: QueryInstance[];
+	relationQueries: QueryInstance[];
     schema: S;
+    entityBitSet: BitSet;
     changeSubscriptions: Set<(entity: Entity, target?: Entity) => void>;
     addSubscriptions: Set<(entity: Entity, target?: Entity) => void>;
     removeSubscriptions: Set<(entity: Entity, target?: Entity) => void>;