koota 0.5.2 → 0.5.3

package/README.md

@@ -398,7 +398,7 @@ world.set(Time, { current: performance.now() })
 
 ### Select traits on queries for updates
 
-Query filters entity results and `select` is used to choose what traits are fetched for `updateEach` and `useStore`. This can be useful if your query is wider than the data you want to modify.
+Query filters entity results and `select` is used to choose what traits are fetched for `updateEach` and `useStores`. This can be useful if your query is wider than the data you want to modify.
 
 ```js
 // The query finds all entities with Position, Velocity and Mass
@@ -414,11 +414,11 @@ world.query(Position, Velocity, Mass)
 
 ### Modifying trait stores directly
 
-For performance-critical operations, you can modify trait stores directly using the `useStore` hook. This approach bypasses some of the safety checks and event triggers, so use it with caution. All stores are structure of arrays for performance purposes.
+For performance-critical operations, you can modify trait stores directly using the `useStores` hook. This approach bypasses some of the safety checks and event triggers, so use it with caution. All stores are structure of arrays for performance purposes.
 
 ```js
 // Returns the SoA stores
-world.query(Position, Velocity).useStore(([position, velocity], entities) => {
+world.query(Position, Velocity).useStores(([position, velocity], entities) => {
   // Write our own loop over the stores
   for (let i = 0; i < entities.length; i++) {
     // Get the entity ID to use as the array index
@@ -748,7 +748,7 @@ const Attacker = trait<Pick<AttackerSchema, keyof AttackerSchema>>({
 
 #### Accessing the store directly
 
-The store can be accessed with `getStore`, but this low-level access is risky as it bypasses Koota's guard rails. However, this can be useful for debugging where direct introspection of the store is needed. For direct store mutations, use the [`useStore` API](#modifying-trait-stores-direclty) instead.
+The store can be accessed with `getStore`, but this low-level access is risky as it bypasses Koota's guard rails. However, this can be useful for debugging where direct introspection of the store is needed. For direct store mutations, use the [`useStores` API](#modifying-trait-stores-direclty) instead.
 
 ```js
 // Returns SoA or AoS depending on the trait
@@ -913,6 +913,40 @@ return (
 )
 ```
 
+### `useTag`
+
+Observes an entity, or world, for a tag and reactively updates when it is added or removed. Returns `true` when the tag is present or `false` when absent. Use this instead of `useTrait` for tags. For tracking the presence of non-tag traits, use `useHas`.
+
+```js
+const IsActive = trait()
+
+function ActiveIndicator({ entity }) {
+  // Returns true if the entity has the tag, false otherwise
+  const isActive = useTag(entity, IsActive)
+
+  if (!isActive) return null
+
+  return <div>🟢 Active</div>
+}
+```
+
+### `useHas`
+
+Observes an entity, or world, for any trait and reactively updates when it is added or removed. Returns `true` when the trait is present or `false` when absent. Unlike `useTrait`, this only tracks presence and not the trait's value.
+
+```js
+const Health = trait({ amount: 100 })
+
+function HealthIndicator({ entity }) {
+  // Returns true if the entity has the trait, false otherwise
+  const hasHealth = useHas(entity, Health)
+
+  if (!hasHealth) return null
+
+  return <div>❤️ Has Health</div>
+}
+```
+
 ### `useTraitEffect`
 
 Subscribes a callback to a trait on an entity. This callback fires as an effect whenever it is added, removed or changes value without rerendering.

package/dist/{chunk-BQ2FKEYY.js → chunk-ULRUABHP.js}

@@ -40,6 +40,18 @@ function unpackEntity(entity) {
     entityId: entity & ENTITY_ID_MASK
   };
 }
+var getEntityId = (
+  /* @inline @pure */
+  (entity) => entity & ENTITY_ID_MASK
+);
+var getEntityWorldId = (
+  /* @inline @pure */
+  (entity) => entity >>> WORLD_ID_SHIFT
+);
+var getEntityGeneration = (
+  /* @inline @pure */
+  (entity) => entity >>> GENERATION_SHIFT & GENERATION_MASK
+);
 var incrementGeneration = (entity) => entity & ~(GENERATION_MASK << GENERATION_SHIFT) | // Clear current generation bits
 ((entity >>> GENERATION_SHIFT & GENERATION_MASK) + 1 & GENERATION_MASK) << GENERATION_SHIFT;
 
@@ -139,25 +151,11 @@ function createChanged() {
 }
 function setChanged(world, entity, trait2) {
   const ctx = world[$internal];
-  let result_hasTrait_0_$f;
-  const ctx_0_$f = world[$internal];
-  const data_0_$f = ctx_0_$f.traitData.get(trait2);
-  if (!data_0_$f) {
-    result_hasTrait_0_$f = false;
-  } else {
-    const {
-      generationId,
-      bitflag
-    } = data_0_$f;
-    const eid_0_$f = entity & ENTITY_ID_MASK;
-    const mask_0_$f = ctx_0_$f.entityMasks[generationId][eid_0_$f];
-    result_hasTrait_0_$f = (mask_0_$f & bitflag) === bitflag;
-  }
-  if (!result_hasTrait_0_$f) return;
+  if (!hasTrait(world, entity, trait2)) return;
   if (!ctx.traitData.has(trait2)) registerTrait(world, trait2);
   const data = ctx.traitData.get(trait2);
   for (const changedMask of ctx.changedMasks.values()) {
-    const eid = entity & ENTITY_ID_MASK;
+    const eid = getEntityId(entity);
     const data2 = ctx.traitData.get(trait2);
     const {
       generationId,
@@ -350,21 +348,7 @@ function addTrait(world, entity, ...traits) {
     } else {
       trait2 = traits[i];
     }
-    let result_hasTrait_0_$f;
-    const ctx_0_$f = world[$internal];
-    const data_0_$f = ctx_0_$f.traitData.get(trait2);
-    if (!data_0_$f) {
-      result_hasTrait_0_$f = false;
-    } else {
-      const {
-        generationId: generationId2,
-        bitflag: bitflag2
-      } = data_0_$f;
-      const eid_0_$f = entity & ENTITY_ID_MASK;
-      const mask_0_$f = ctx_0_$f.entityMasks[generationId2][eid_0_$f];
-      result_hasTrait_0_$f = (mask_0_$f & bitflag2) === bitflag2;
-    }
-    if (result_hasTrait_0_$f) continue;
+    if (hasTrait(world, entity, trait2)) continue;
     const traitCtx = trait2[$internal];
     if (!ctx.traitData.has(trait2)) registerTrait(world, trait2);
     const data = ctx.traitData.get(trait2);
@@ -373,7 +357,7 @@ function addTrait(world, entity, ...traits) {
       bitflag,
       queries
     } = data;
-    const eid = entity & ENTITY_ID_MASK;
+    const eid = getEntityId(entity);
     ctx.entityMasks[generationId][eid] |= bitflag;
     for (const dirtyMask of ctx.dirtyMasks.values()) {
       if (!dirtyMask[generationId]) dirtyMask[generationId] = [];
@@ -429,21 +413,7 @@ function removeTrait(world, entity, ...traits) {
   for (let i = 0; i < traits.length; i++) {
     const trait2 = traits[i];
     const traitCtx = trait2[$internal];
-    let result_hasTrait_3_$f;
-    const ctx_3_$f = world[$internal];
-    const data_3_$f = ctx_3_$f.traitData.get(trait2);
-    if (!data_3_$f) {
-      result_hasTrait_3_$f = false;
-    } else {
-      const {
-        generationId: generationId2,
-        bitflag: bitflag2
-      } = data_3_$f;
-      const eid_3_$f = entity & ENTITY_ID_MASK;
-      const mask_3_$f = ctx_3_$f.entityMasks[generationId2][eid_3_$f];
-      result_hasTrait_3_$f = (mask_3_$f & bitflag2) === bitflag2;
-    }
-    if (!result_hasTrait_3_$f) continue;
+    if (!hasTrait(world, entity, trait2)) continue;
     const data = ctx.traitData.get(trait2);
     const {
       generationId,
@@ -453,7 +423,7 @@ function removeTrait(world, entity, ...traits) {
     for (const sub of data.removeSubscriptions) {
       sub(entity);
     }
-    const eid = entity & ENTITY_ID_MASK;
+    const eid = getEntityId(entity);
     ctx.entityMasks[generationId][eid] &= ~bitflag;
     for (const dirtyMask of ctx.dirtyMasks.values()) {
       dirtyMask[generationId][eid] |= bitflag;
@@ -472,7 +442,9 @@ function removeTrait(world, entity, ...traits) {
         ctx.relationTargetEntities.delete(entity);
       }
       const target = traitCtx.pairTarget;
-      removeTrait(world, entity, Pair(Wildcard, target));
+      if (!hasRelationToTarget(world, entity, target)) {
+        removeTrait(world, entity, Pair(Wildcard, target));
+      }
       const relation2 = traitCtx.relation;
       const otherTargets = getRelationTargets(world, relation2, entity);
       if (otherTargets.length === 0) {
@@ -488,6 +460,18 @@ function removeTrait(world, entity, ...traits) {
     }
   }
 }
+function hasTrait(world, entity, trait2) {
+  const ctx = world[$internal];
+  const data = ctx.traitData.get(trait2);
+  if (!data) return false;
+  const {
+    generationId,
+    bitflag
+  } = data;
+  const eid = getEntityId(entity);
+  const mask = ctx.entityMasks[generationId][eid];
+  return (mask & bitflag) === bitflag;
+}
 function getStore(world, trait2) {
   const ctx = world[$internal];
   const data = ctx.traitData.get(trait2);
@@ -495,34 +479,18 @@ function getStore(world, trait2) {
 }
 function setTrait(world, entity, trait2, value, triggerChanged = true) {
   const ctx = trait2[$internal];
-  const ctx_7_$f = world[$internal];
-  const data_7_$f = ctx_7_$f.traitData.get(trait2);
-  const store = data_7_$f.store;
-  const index = entity & ENTITY_ID_MASK;
+  const store = getStore(world, trait2);
+  const index = getEntityId(entity);
   value instanceof Function && (value = value(ctx.get(index, store)));
   ctx.set(index, store, value);
   triggerChanged && setChanged(world, entity, trait2);
 }
 function getTrait(world, entity, trait2) {
-  let result_hasTrait_9_$f;
-  const ctx_9_$f = world[$internal];
-  const data_9_$f = ctx_9_$f.traitData.get(trait2);
-  if (!data_9_$f) {
-    result_hasTrait_9_$f = false;
-  } else {
-    const {
-      generationId,
-      bitflag
-    } = data_9_$f;
-    const eid_9_$f = entity & ENTITY_ID_MASK;
-    const mask_9_$f = ctx_9_$f.entityMasks[generationId][eid_9_$f];
-    result_hasTrait_9_$f = (mask_9_$f & bitflag) === bitflag;
-  }
-  const result = result_hasTrait_9_$f;
+  const result = hasTrait(world, entity, trait2);
   if (!result) return void 0;
   const traitCtx = trait2[$internal];
-  const store = data_9_$f.store;
-  return traitCtx.get(entity & ENTITY_ID_MASK, store);
+  const store = getStore(world, trait2);
+  return traitCtx.get(getEntityId(entity), store);
 }
 
 // ../core/src/relation/relation.ts
@@ -568,6 +536,18 @@ var getRelationTargets = (world, relation2, entity) => {
   }
   return targets;
 };
+var hasRelationToTarget = (world, entity, target) => {
+  const ctx = world[$internal];
+  const traits = ctx.entityTraits.get(entity);
+  if (!traits) return false;
+  for (const trait2 of traits) {
+    const traitCtx = trait2[$internal];
+    if (traitCtx.isPairTrait && traitCtx.pairTarget === target && traitCtx.relation !== Wildcard) {
+      return true;
+    }
+  }
+  return false;
+};
 var Pair = (relation2, target) => {
   if (relation2 === void 0) throw Error("Relation is undefined");
   if (target === void 0) throw Error("Relation target is undefined");
@@ -673,28 +653,11 @@ function createQueryResult(world, entities, query) {
         const atomicSnapshots = [];
         const trackedIndices = [];
         const untrackedIndices = [];
-        for (let i_0_$f = 0; i_0_$f < traits.length; i_0_$f++) {
-          const trait_0_$f = traits[i_0_$f];
-          const hasTracked_0_$f = world[$internal].trackedTraits.has(trait_0_$f);
-          const hasChanged_0_$f = query.hasChangedModifiers && query.changedTraits.has(trait_0_$f);
-          if (hasTracked_0_$f || hasChanged_0_$f) {
-            trackedIndices.push(i_0_$f);
-          } else {
-            untrackedIndices.push(i_0_$f);
-          }
-        }
+        getTrackedTraits(traits, world, query, trackedIndices, untrackedIndices);
         for (let i = 0; i < entities.length; i++) {
           const entity = entities[i];
-          const eid = entity & ENTITY_ID_MASK;
-          for (let j_2_$f = 0; j_2_$f < traits.length; j_2_$f++) {
-            const trait_2_$f = traits[j_2_$f];
-            const ctx_2_$f = trait_2_$f[$internal];
-            const value_2_$f = ctx_2_$f.get(eid, stores[j_2_$f]);
-            state[j_2_$f] = value_2_$f;
-            atomicSnapshots[j_2_$f] = ctx_2_$f.type === "aos" ? {
-              ...value_2_$f
-            } : null;
-          }
+          const eid = getEntityId(entity);
+          createSnapshotsWithAtomic(eid, traits, stores, state, atomicSnapshots);
           callback(state, entity, i);
           if (!world.has(entity)) continue;
           for (let j = 0; j < trackedIndices.length; j++) {
@@ -731,16 +694,8 @@ function createQueryResult(world, entities, query) {
         const atomicSnapshots = [];
         for (let i = 0; i < entities.length; i++) {
           const entity = entities[i];
-          const eid = entity & ENTITY_ID_MASK;
-          for (let j_4_$f = 0; j_4_$f < traits.length; j_4_$f++) {
-            const trait_4_$f = traits[j_4_$f];
-            const ctx_4_$f = trait_4_$f[$internal];
-            const value_4_$f = ctx_4_$f.get(eid, stores[j_4_$f]);
-            state[j_4_$f] = value_4_$f;
-            atomicSnapshots[j_4_$f] = ctx_4_$f.type === "aos" ? {
-              ...value_4_$f
-            } : null;
-          }
+          const eid = getEntityId(entity);
+          createSnapshotsWithAtomic(eid, traits, stores, state, atomicSnapshots);
           callback(state, entity, i);
           if (!world.has(entity)) continue;
           for (let j = 0; j < traits.length; j++) {
@@ -766,13 +721,8 @@ function createQueryResult(world, entities, query) {
       } else if (options.changeDetection === "never") {
         for (let i = 0; i < entities.length; i++) {
           const entity = entities[i];
-          const eid = entity & ENTITY_ID_MASK;
-          for (let i_6_$f = 0; i_6_$f < traits.length; i_6_$f++) {
-            const trait_6_$f = traits[i_6_$f];
-            const ctx_6_$f = trait_6_$f[$internal];
-            const value_6_$f = ctx_6_$f.get(eid, stores[i_6_$f]);
-            state[i_6_$f] = value_6_$f;
-          }
+          const eid = getEntityId(entity);
+          createSnapshots(eid, traits, stores, state);
           callback(state, entity, i);
           if (!world.has(entity)) continue;
           for (let j = 0; j < traits.length; j++) {
@@ -791,44 +741,62 @@ function createQueryResult(world, entities, query) {
     select(...params) {
       traits.length = 0;
       stores.length = 0;
-      for (let i_7_$f = 0; i_7_$f < params.length; i_7_$f++) {
-        const param_7_$f = params[i_7_$f];
-        if (isModifier(param_7_$f)) {
-          if (param_7_$f.type === "not") {
-            continue;
-          } else {
-            const modifierTraits_7_$f = param_7_$f.traits;
-            for (const trait_7_$f of modifierTraits_7_$f) {
-              if (trait_7_$f[$internal].isTag) {
-                continue;
-              } else {
-                traits.push(trait_7_$f);
-                const ctx_8_$f = world[$internal];
-                const data_8_$f = ctx_8_$f.traitData.get(trait_7_$f);
-                stores.push(data_8_$f.store);
-              }
-            }
-          }
-        } else {
-          if (param_7_$f[$internal].isTag) {
-            continue;
-          } else {
-            traits.push(param_7_$f);
-            const ctx_9_$f = world[$internal];
-            const data_9_$f = ctx_9_$f.traitData.get(param_7_$f);
-            stores.push(data_9_$f.store);
-          }
-        }
-      }
+      getQueryStores(params, traits, stores, world);
       return results;
     },
-    sort(callback = (a, b) => (a & ENTITY_ID_MASK) - (b & ENTITY_ID_MASK)) {
+    sort(callback = (a, b) => getEntityId(a) - getEntityId(b)) {
       Array.prototype.sort.call(entities, callback);
       return results;
     }
   });
   return results;
 }
+function getTrackedTraits(traits, world, query, trackedIndices, untrackedIndices) {
+  for (let i = 0; i < traits.length; i++) {
+    const trait2 = traits[i];
+    const hasTracked = world[$internal].trackedTraits.has(trait2);
+    const hasChanged = query.hasChangedModifiers && query.changedTraits.has(trait2);
+    if (hasTracked || hasChanged) trackedIndices.push(i);
+    else untrackedIndices.push(i);
+  }
+}
+function createSnapshots(entityId, traits, stores, state) {
+  for (let i = 0; i < traits.length; i++) {
+    const trait2 = traits[i];
+    const ctx = trait2[$internal];
+    const value = ctx.get(entityId, stores[i]);
+    state[i] = value;
+  }
+}
+function createSnapshotsWithAtomic(entityId, traits, stores, state, atomicSnapshots) {
+  for (let j = 0; j < traits.length; j++) {
+    const trait2 = traits[j];
+    const ctx = trait2[$internal];
+    const value = ctx.get(entityId, stores[j]);
+    state[j] = value;
+    atomicSnapshots[j] = ctx.type === "aos" ? {
+      ...value
+    } : null;
+  }
+}
+function getQueryStores(params, traits, stores, world) {
+  for (let i = 0; i < params.length; i++) {
+    const param = params[i];
+    if (isModifier(param)) {
+      if (param.type === "not") continue;
+      const modifierTraits = param.traits;
+      for (const trait2 of modifierTraits) {
+        if (trait2[$internal].isTag) continue;
+        traits.push(trait2);
+        stores.push(getStore(world, trait2));
+      }
+    } else {
+      if (param[$internal].isTag) continue;
+      traits.push(param);
+      stores.push(getStore(world, param));
+    }
+  }
+}
 function createEmptyQueryResult() {
   const results = Object.assign([], {
     updateEach: () => results,
@@ -869,7 +837,7 @@ var allocateEntity = (index) => {
   if (index.aliveCount < index.dense.length) {
     const recycledEntity = incrementGeneration(index.dense[index.aliveCount]);
     index.dense[index.aliveCount] = recycledEntity;
-    index.sparse[recycledEntity & ENTITY_ID_MASK] = index.aliveCount;
+    index.sparse[getEntityId(recycledEntity)] = index.aliveCount;
     index.aliveCount++;
     return recycledEntity;
   }
@@ -881,92 +849,69 @@ var allocateEntity = (index) => {
   return entity;
 };
 var releaseEntity = (index, entity) => {
-  const id = entity & ENTITY_ID_MASK;
+  const id = getEntityId(entity);
   const denseIndex = index.sparse[id];
   if (denseIndex === void 0 || denseIndex >= index.aliveCount) return;
   const lastIndex = index.aliveCount - 1;
   const lastEntity = index.dense[lastIndex];
-  const lastId = lastEntity & ENTITY_ID_MASK;
+  const lastId = getEntityId(lastEntity);
   index.sparse[lastId] = denseIndex;
   index.dense[denseIndex] = lastEntity;
   index.sparse[id] = lastIndex;
   index.dense[lastIndex] = entity;
   index.aliveCount--;
 };
+var isEntityAlive = (
+  /* @inline @pure */
+  (index, entity) => {
+    const denseIndex = index.sparse[getEntityId(entity)];
+    if (denseIndex === void 0 || denseIndex >= index.aliveCount) return false;
+    const storedEntity = index.dense[denseIndex];
+    return getEntityGeneration(entity) === getEntityGeneration(storedEntity) && getEntityWorldId(entity) === index.worldId;
+  }
+);
 var getAliveEntities = (index) => {
   return index.dense.slice(0, index.aliveCount);
 };
 
 // ../core/src/entity/entity-methods-patch.ts
 Number.prototype.add = function(...traits) {
-  const worldId_0_$f = this >>> WORLD_ID_SHIFT;
-  return addTrait(universe.worlds[worldId_0_$f], this, ...traits);
+  return addTrait(getEntityWorld(this), this, ...traits);
 };
 Number.prototype.remove = function(...traits) {
-  const worldId_1_$f = this >>> WORLD_ID_SHIFT;
-  return removeTrait(universe.worlds[worldId_1_$f], this, ...traits);
+  return removeTrait(getEntityWorld(this), this, ...traits);
 };
 Number.prototype.has = function(trait2) {
-  let result_hasTrait_2_$f;
-  const worldId_3_$f = this >>> WORLD_ID_SHIFT;
-  const ctx_2_$f = universe.worlds[worldId_3_$f][$internal];
-  const data_2_$f = ctx_2_$f.traitData.get(trait2);
-  if (!data_2_$f) {
-    result_hasTrait_2_$f = false;
-  } else {
-    const {
-      generationId,
-      bitflag
-    } = data_2_$f;
-    const eid_2_$f = this & ENTITY_ID_MASK;
-    const mask_2_$f = ctx_2_$f.entityMasks[generationId][eid_2_$f];
-    result_hasTrait_2_$f = (mask_2_$f & bitflag) === bitflag;
-  }
-  return result_hasTrait_2_$f;
+  return hasTrait(getEntityWorld(this), this, trait2);
 };
 Number.prototype.destroy = function() {
-  const worldId_4_$f = this >>> WORLD_ID_SHIFT;
-  return destroyEntity(universe.worlds[worldId_4_$f], this);
+  return destroyEntity(getEntityWorld(this), this);
 };
 Number.prototype.changed = function(trait2) {
-  const worldId_5_$f = this >>> WORLD_ID_SHIFT;
-  return setChanged(universe.worlds[worldId_5_$f], this, trait2);
+  return setChanged(getEntityWorld(this), this, trait2);
 };
 Number.prototype.get = function(trait2) {
-  const worldId_6_$f = this >>> WORLD_ID_SHIFT;
-  return getTrait(universe.worlds[worldId_6_$f], this, trait2);
+  return getTrait(getEntityWorld(this), this, trait2);
 };
 Number.prototype.set = function(trait2, value, triggerChanged = true) {
-  const worldId_7_$f = this >>> WORLD_ID_SHIFT;
-  setTrait(universe.worlds[worldId_7_$f], this, trait2, value, triggerChanged);
+  setTrait(getEntityWorld(this), this, trait2, value, triggerChanged);
 };
 Number.prototype.targetsFor = function(relation2) {
-  const worldId_8_$f = this >>> WORLD_ID_SHIFT;
-  return getRelationTargets(universe.worlds[worldId_8_$f], relation2, this);
+  return getRelationTargets(getEntityWorld(this), relation2, this);
 };
 Number.prototype.targetFor = function(relation2) {
-  const worldId_9_$f = this >>> WORLD_ID_SHIFT;
-  return getRelationTargets(universe.worlds[worldId_9_$f], relation2, this)[0];
+  return getRelationTargets(getEntityWorld(this), relation2, this)[0];
 };
 Number.prototype.id = function() {
-  return this & ENTITY_ID_MASK;
+  return getEntityId(this);
 };
 Number.prototype.generation = function() {
-  return this >>> GENERATION_SHIFT & GENERATION_MASK;
+  return getEntityGeneration(this);
 };
 Number.prototype.isAlive = function() {
-  const worldId_12_$f = this >>> WORLD_ID_SHIFT;
-  const world = universe.worlds[worldId_12_$f];
+  const world = getEntityWorld(this);
   const entityIndex = world[$internal].entityIndex;
-  let result_isEntityAlive_13_$f;
-  const denseIndex_13_$f = entityIndex.sparse[this & ENTITY_ID_MASK];
-  if (denseIndex_13_$f === void 0 || denseIndex_13_$f >= entityIndex.aliveCount) {
-    result_isEntityAlive_13_$f = false;
-  } else {
-    const storedEntity_13_$f = entityIndex.dense[denseIndex_13_$f];
-    result_isEntityAlive_13_$f = (this >>> GENERATION_SHIFT & GENERATION_MASK) === (storedEntity_13_$f >>> GENERATION_SHIFT & GENERATION_MASK) && this >>> WORLD_ID_SHIFT === entityIndex.worldId;
-  }
-  return result_isEntityAlive_13_$f;
+  return isEntityAlive(entityIndex, this);
 };
 
 // ../core/src/entity/entity.ts
@@ -976,7 +921,7 @@ function createEntity(world, ...traits) {
   for (const query of ctx.notQueries) {
     const match = query.check(world, entity);
     if (match) query.add(entity);
-    query.resetTrackingBitmasks(entity & ENTITY_ID_MASK);
+    query.resetTrackingBitmasks(getEntityId(entity));
   }
   ctx.entityTraits.set(entity, /* @__PURE__ */ new Set());
   addTrait(world, entity, ...traits);
@@ -1023,12 +968,16 @@ function destroyEntity(world, entity) {
     const allQuery = ctx.queriesHashMap.get("");
     if (allQuery) allQuery.remove(world, currentEntity);
     ctx.entityTraits.delete(entity);
-    const eid = currentEntity & ENTITY_ID_MASK;
+    const eid = getEntityId(currentEntity);
     for (let i = 0; i < ctx.entityMasks.length; i++) {
       ctx.entityMasks[i][eid] = 0;
     }
   }
 }
+function getEntityWorld(entity) {
+  const worldId = getEntityWorldId(entity);
+  return universe.worlds[worldId];
+}
 
 // ../core/src/world/world.ts
 var World = class {
@@ -1093,29 +1042,7 @@ var World = class {
     return createEntity(this, ...traits);
   }
   has(target) {
-    let result_isEntityAlive_0_$f;
-    const denseIndex_0_$f = this[$internal].entityIndex.sparse[target & ENTITY_ID_MASK];
-    if (denseIndex_0_$f === void 0 || denseIndex_0_$f >= this[$internal].entityIndex.aliveCount) {
-      result_isEntityAlive_0_$f = false;
-    } else {
-      const storedEntity_0_$f = this[$internal].entityIndex.dense[denseIndex_0_$f];
-      result_isEntityAlive_0_$f = (target >>> GENERATION_SHIFT & GENERATION_MASK) === (storedEntity_0_$f >>> GENERATION_SHIFT & GENERATION_MASK) && target >>> WORLD_ID_SHIFT === this[$internal].entityIndex.worldId;
-    }
-    let result_hasTrait_1_$f;
-    const ctx_1_$f = this[$internal];
-    const data_1_$f = ctx_1_$f.traitData.get(target);
-    if (!data_1_$f) {
-      result_hasTrait_1_$f = false;
-    } else {
-      const {
-        generationId,
-        bitflag
-      } = data_1_$f;
-      const eid_1_$f = this[$internal].worldEntity & ENTITY_ID_MASK;
-      const mask_1_$f = ctx_1_$f.entityMasks[generationId][eid_1_$f];
-      result_hasTrait_1_$f = (mask_1_$f & bitflag) === bitflag;
-    }
-    return typeof target === "number" ? result_isEntityAlive_0_$f : result_hasTrait_1_$f;
+    return typeof target === "number" ? isEntityAlive(this[$internal].entityIndex, target) : hasTrait(this, this[$internal].worldEntity, target);
   }
   add(...traits) {
     addTrait(this, this[$internal].worldEntity, ...traits);
@@ -1160,6 +1087,10 @@ var World = class {
     ctx.changedMasks.clear();
     ctx.trackedTraits.clear();
     ctx.worldEntity = createEntity(this, IsExcluded);
+    for (const [hash, parameters] of universe.cachedQueries) {
+      const query = createQuery(this, parameters);
+      ctx.queriesHashMap.set(hash, query);
+    }
     for (const sub of ctx.resetSubscriptions) {
       sub(this);
     }
@@ -1314,7 +1245,7 @@ function checkQuery(world, query, entity, event) {
     generations
   } = query;
   const ctx = world[$internal];
-  const eid = entity & ENTITY_ID_MASK;
+  const eid = getEntityId(entity);
   if (query.traitData.all.length === 0) return false;
   for (let i = 0; i < generations.length; i++) {
     const generationId = generations[i];
@@ -1536,7 +1467,7 @@ function createQuery(world, parameters) {
       const changedMask = ctx.changedMasks.get(id);
       for (const entity of ctx.entityIndex.dense) {
         let allTraitsMatch = true;
-        const eid = entity & ENTITY_ID_MASK;
+        const eid = getEntityId(entity);
         for (const trait2 of traits) {
           const {
             generationId,
@@ -1576,35 +1507,7 @@ function createQuery(world, parameters) {
       }
     }
   }
-  for (let i_2_$f = 0; i_2_$f < parameters.length; i_2_$f++) {
-    const param_2_$f = parameters[i_2_$f];
-    if (isModifier(param_2_$f)) {
-      if (param_2_$f.type === "not") {
-        continue;
-      } else {
-        const modifierTraits_2_$f = param_2_$f.traits;
-        for (const trait_2_$f of modifierTraits_2_$f) {
-          if (trait_2_$f[$internal].isTag) {
-            continue;
-          } else {
-            query.resultTraits.push(trait_2_$f);
-            const ctx_3_$f = world[$internal];
-            const data_3_$f = ctx_3_$f.traitData.get(trait_2_$f);
-            query.resultStores.push(data_3_$f.store);
-          }
-        }
-      }
-    } else {
-      if (param_2_$f[$internal].isTag) {
-        continue;
-      } else {
-        query.resultTraits.push(param_2_$f);
-        const ctx_4_$f = world[$internal];
-        const data_4_$f = ctx_4_$f.traitData.get(param_2_$f);
-        query.resultStores.push(data_4_$f.store);
-      }
-    }
-  }
+  getQueryStores(parameters, query.resultTraits, query.resultStores, world);
   return query;
 }