koota 0.2.3 → 0.3.1

package/dist/react.cjs

@@ -3,10 +3,6 @@ var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __typeError = (msg) => {
-  throw TypeError(msg);
-};
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -20,25 +16,11 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
-var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
-var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
-var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
-var __privateWrapper = (obj, member, setter, getter) => ({
-  set _(value) {
-    __privateSet(obj, member, value, setter);
-  },
-  get _() {
-    return __privateGet(obj, member, getter);
-  }
-});
 
 // src/react.ts
 var react_exports = {};
 __export(react_exports, {
   WorldProvider: () => WorldProvider,
-  getDefaultWorld: () => getDefaultWorld,
   useActions: () => useActions,
   useQuery: () => useQuery,
   useQueryFirst: () => useQueryFirst,
@@ -103,7 +85,7 @@ var universe = {
   cachedQueries: /* @__PURE__ */ new Map(),
   worldIndex: createWorldIndex(),
   reset: () => {
-    universe.worlds = new Array(WORLD_ID_BITS ** 2);
+    universe.worlds = new Array(WORLD_ID_BITS ** 2).fill(null);
     universe.cachedQueries = /* @__PURE__ */ new Map();
     universe.worldIndex = createWorldIndex();
   }
@@ -115,9 +97,9 @@ var ModifierData = class {
     this.type = type;
     this.id = id;
     this.traits = traits;
-    __publicField(this, "traitIds");
     this.traitIds = traits.map((trait2) => trait2[$internal].id);
   }
+  traitIds;
 };
 
 // ../core/src/query/utils/tracking-cursor.ts
@@ -198,8 +180,9 @@ function getRelationTrait(relation2, traitFactory, pairsMap, target) {
 }
 var getRelationTargets = (world, relation2, entity) => {
   const ctx = world[$internal];
-  const traits = ctx.entityTraits.get(entity) || [];
+  const traits = ctx.entityTraits.get(entity);
   const targets = [];
+  if (!traits) return targets;
   for (const trait2 of traits) {
     const traitCtx = trait2[$internal];
     if (traitCtx.relation === relation2 && traitCtx.pairTarget !== Wildcard) {
@@ -231,15 +214,15 @@ var incrementWorldBitflag = (world) => {
 
 // ../core/src/trait/trait-data.ts
 var TraitData = class {
+  generationId;
+  bitflag;
+  trait;
+  store;
+  queries;
+  notQueries;
+  schema;
+  changedSubscriptions;
   constructor(world, trait2) {
-    __publicField(this, "generationId");
-    __publicField(this, "bitflag");
-    __publicField(this, "trait");
-    __publicField(this, "store");
-    __publicField(this, "queries");
-    __publicField(this, "notQueries");
-    __publicField(this, "schema");
-    __publicField(this, "changedSubscriptions");
     const ctx = world[$internal];
     const traitCtx = trait2[$internal];
     this.generationId = ctx.entityMasks.length - 1;
@@ -572,47 +555,47 @@ var getAliveEntities = (index) => {
 // ../core/src/entity/entity-methods-patch.ts
 Number.prototype.add = function(...traits) {
   const worldId = this >>> WORLD_ID_SHIFT;
-  const world = universe.worlds[worldId];
+  const world = universe.worlds[worldId].deref();
   return addTrait(world, this, ...traits);
 };
 Number.prototype.remove = function(...traits) {
   const worldId = this >>> WORLD_ID_SHIFT;
-  const world = universe.worlds[worldId];
+  const world = universe.worlds[worldId].deref();
   return removeTrait(world, this, ...traits);
 };
 Number.prototype.has = function(trait2) {
   const worldId = this >>> WORLD_ID_SHIFT;
-  const world = universe.worlds[worldId];
+  const world = universe.worlds[worldId].deref();
   return hasTrait(world, this, trait2);
 };
 Number.prototype.destroy = function() {
   const worldId = this >>> WORLD_ID_SHIFT;
-  const world = universe.worlds[worldId];
+  const world = universe.worlds[worldId].deref();
   return destroyEntity(world, this);
 };
 Number.prototype.changed = function(trait2) {
   const worldId = this >>> WORLD_ID_SHIFT;
-  const world = universe.worlds[worldId];
+  const world = universe.worlds[worldId].deref();
   return setChanged(world, this, trait2);
 };
 Number.prototype.get = function(trait2) {
   const worldId = this >>> WORLD_ID_SHIFT;
-  const world = universe.worlds[worldId];
+  const world = universe.worlds[worldId].deref();
   return getTrait(world, this, trait2);
 };
 Number.prototype.set = function(trait2, value, triggerChanged = true) {
   const worldId = this >>> WORLD_ID_SHIFT;
-  const world = universe.worlds[worldId];
+  const world = universe.worlds[worldId].deref();
   setTrait(world, this, trait2, value, triggerChanged);
 };
 Number.prototype.targetsFor = function(relation2) {
   const worldId = this >>> WORLD_ID_SHIFT;
-  const world = universe.worlds[worldId];
+  const world = universe.worlds[worldId].deref();
   return getRelationTargets(world, relation2, this);
 };
 Number.prototype.targetFor = function(relation2) {
   const worldId = this >>> WORLD_ID_SHIFT;
-  const world = universe.worlds[worldId];
+  const world = universe.worlds[worldId].deref();
   return getRelationTargets(world, relation2, this)[0];
 };
 Number.prototype.id = function() {
@@ -621,7 +604,7 @@ Number.prototype.id = function() {
 };
 Number.prototype.isAlive = function() {
   const worldId = this >>> WORLD_ID_SHIFT;
-  const world = universe.worlds[worldId];
+  const world = universe.worlds[worldId].deref();
   return isEntityAlive(world[$internal].entityIndex, this);
 };
 
@@ -687,57 +670,51 @@ function destroyEntity(world, entity) {
 }
 
 // ../core/src/utils/sparse-set.ts
-var _dense, _sparse, _cursor;
 var SparseSet = class {
-  constructor() {
-    __privateAdd(this, _dense, []);
-    __privateAdd(this, _sparse, []);
-    __privateAdd(this, _cursor, 0);
-  }
+  #dense = [];
+  #sparse = [];
+  #cursor = 0;
   has(val) {
-    const index = __privateGet(this, _sparse)[val];
-    return index < __privateGet(this, _cursor) && __privateGet(this, _dense)[index] === val;
+    const index = this.#sparse[val];
+    return index < this.#cursor && this.#dense[index] === val;
   }
   add(val) {
     if (this.has(val)) return;
-    __privateGet(this, _sparse)[val] = __privateGet(this, _cursor);
-    __privateGet(this, _dense)[__privateWrapper(this, _cursor)._++] = val;
+    this.#sparse[val] = this.#cursor;
+    this.#dense[this.#cursor++] = val;
   }
   remove(val) {
     if (!this.has(val)) return;
-    const index = __privateGet(this, _sparse)[val];
-    __privateWrapper(this, _cursor)._--;
-    const swapped = __privateGet(this, _dense)[__privateGet(this, _cursor)];
+    const index = this.#sparse[val];
+    this.#cursor--;
+    const swapped = this.#dense[this.#cursor];
     if (swapped !== val) {
-      __privateGet(this, _dense)[index] = swapped;
-      __privateGet(this, _sparse)[swapped] = index;
+      this.#dense[index] = swapped;
+      this.#sparse[swapped] = index;
     }
   }
   clear() {
-    for (let i = 0; i < __privateGet(this, _cursor); i++) {
-      __privateGet(this, _sparse)[__privateGet(this, _dense)[i]] = 0;
+    for (let i = 0; i < this.#cursor; i++) {
+      this.#sparse[this.#dense[i]] = 0;
     }
-    __privateSet(this, _cursor, 0);
+    this.#cursor = 0;
   }
   sort() {
-    __privateGet(this, _dense).sort((a, b) => a - b);
-    for (let i = 0; i < __privateGet(this, _dense).length; i++) {
-      __privateGet(this, _sparse)[__privateGet(this, _dense)[i]] = i;
+    this.#dense.sort((a, b) => a - b);
+    for (let i = 0; i < this.#dense.length; i++) {
+      this.#sparse[this.#dense[i]] = i;
     }
   }
   getIndex(val) {
-    return __privateGet(this, _sparse)[val];
+    return this.#sparse[val];
   }
   get dense() {
-    return __privateGet(this, _dense).slice(0, __privateGet(this, _cursor));
+    return this.#dense.slice(0, this.#cursor);
   }
   get sparse() {
-    return __privateGet(this, _sparse);
+    return this.#sparse;
   }
 };
-_dense = new WeakMap();
-_sparse = new WeakMap();
-_cursor = new WeakMap();
 
 // ../core/src/query/utils/create-query-hash.ts
 var sortedIDs = new Float32Array(1024);
@@ -767,22 +744,22 @@ var createQueryHash = (parameters) => {
 // ../core/src/query/query.ts
 var IsExcluded = trait();
 var Query = class {
+  version = 0;
+  world;
+  parameters;
+  hash;
+  traits = [];
+  traitData = { required: [], forbidden: [], or: [], added: [], removed: [], changed: [], all: [] };
+  bitmasks = [];
+  generations;
+  entities = new SparseSet();
+  isTracking = false;
+  hasChangedModifiers = false;
+  changedTraits = /* @__PURE__ */ new Set();
+  toRemove = new SparseSet();
+  addSubscriptions = /* @__PURE__ */ new Set();
+  removeSubscriptions = /* @__PURE__ */ new Set();
   constructor(world, parameters = []) {
-    __publicField(this, "version", 0);
-    __publicField(this, "world");
-    __publicField(this, "parameters");
-    __publicField(this, "hash");
-    __publicField(this, "traits", []);
-    __publicField(this, "traitData", { required: [], forbidden: [], or: [], added: [], removed: [], changed: [], all: [] });
-    __publicField(this, "bitmasks", []);
-    __publicField(this, "generations");
-    __publicField(this, "entities", new SparseSet());
-    __publicField(this, "isTracking", false);
-    __publicField(this, "hasChangedModifiers", false);
-    __publicField(this, "changedTraits", /* @__PURE__ */ new Set());
-    __publicField(this, "toRemove", new SparseSet());
-    __publicField(this, "addSubscriptions", /* @__PURE__ */ new Set());
-    __publicField(this, "removeSubscriptions", /* @__PURE__ */ new Set());
     this.world = world;
     this.parameters = parameters;
     const ctx = world[$internal];
@@ -1192,6 +1169,10 @@ function createQueryResult(query, world, params) {
       stores.length = 0;
       getQueryStores(params2, traits, stores, world);
       return results;
+    },
+    sort(callback = (a, b) => getEntityId(a) - getEntityId(b)) {
+      Array.prototype.sort.call(entities, callback);
+      return results;
     }
   });
   return results;
@@ -1216,50 +1197,50 @@ function getQueryStores(params, traits, stores, world) {
 }
 
 // ../core/src/world/world.ts
-var _a, _id, _isInitialized;
-_a = $internal;
 var World = class {
-  constructor(...traits) {
-    __privateAdd(this, _id, allocateWorldId(universe.worldIndex));
-    __publicField(this, _a, {
-      entityIndex: createEntityIndex(__privateGet(this, _id)),
-      entityMasks: [[]],
-      entityTraits: /* @__PURE__ */ new Map(),
-      bitflag: 1,
-      traitData: /* @__PURE__ */ new Map(),
-      queries: /* @__PURE__ */ new Set(),
-      queriesHashMap: /* @__PURE__ */ new Map(),
-      notQueries: /* @__PURE__ */ new Set(),
-      dirtyQueries: /* @__PURE__ */ new Set(),
-      relationTargetEntities: /* @__PURE__ */ new Set(),
-      dirtyMasks: /* @__PURE__ */ new Map(),
-      trackingSnapshots: /* @__PURE__ */ new Map(),
-      changedMasks: /* @__PURE__ */ new Map(),
-      worldEntity: null,
-      trackedTraits: /* @__PURE__ */ new Set()
-    });
-    __privateAdd(this, _isInitialized, false);
-    __publicField(this, "traits", /* @__PURE__ */ new Set());
-    this.init(...traits);
-  }
+  #id = allocateWorldId(universe.worldIndex);
+  [$internal] = {
+    entityIndex: createEntityIndex(this.#id),
+    entityMasks: [[]],
+    entityTraits: /* @__PURE__ */ new Map(),
+    bitflag: 1,
+    traitData: /* @__PURE__ */ new Map(),
+    queries: /* @__PURE__ */ new Set(),
+    queriesHashMap: /* @__PURE__ */ new Map(),
+    notQueries: /* @__PURE__ */ new Set(),
+    dirtyQueries: /* @__PURE__ */ new Set(),
+    relationTargetEntities: /* @__PURE__ */ new Set(),
+    dirtyMasks: /* @__PURE__ */ new Map(),
+    trackingSnapshots: /* @__PURE__ */ new Map(),
+    changedMasks: /* @__PURE__ */ new Map(),
+    worldEntity: null,
+    trackedTraits: /* @__PURE__ */ new Set(),
+    resetSubscriptions: /* @__PURE__ */ new Set()
+  };
   get id() {
-    return __privateGet(this, _id);
+    return this.#id;
   }
+  #isInitialized = false;
   get isInitialized() {
-    return __privateGet(this, _isInitialized);
+    return this.#isInitialized;
   }
   get entities() {
     return getAliveEntities(this[$internal].entityIndex);
   }
+  traits = /* @__PURE__ */ new Set();
+  constructor(...traits) {
+    this.init(...traits);
+  }
   init(...traits) {
     const ctx = this[$internal];
-    if (__privateGet(this, _isInitialized)) return;
-    __privateSet(this, _isInitialized, true);
-    universe.worlds[__privateGet(this, _id)] = this;
+    if (this.#isInitialized) return;
+    this.#isInitialized = true;
+    universe.worlds[this.#id] = new WeakRef(this);
     const cursor2 = getTrackingCursor();
     for (let i = 0; i < cursor2; i++) {
       setTrackingMasks(this, i);
     }
+    if (!ctx.traitData.has(IsExcluded)) registerTrait(this, IsExcluded);
     for (const [hash, parameters] of universe.cachedQueries) {
       const query = new Query(this, parameters);
       ctx.queriesHashMap.set(hash, query);
@@ -1289,15 +1270,15 @@ var World = class {
     this[$internal].worldEntity = null;
     this.entities.forEach((entity) => destroyEntity(this, entity));
     this.reset();
-    __privateSet(this, _isInitialized, false);
-    releaseWorldId(universe.worldIndex, __privateGet(this, _id));
-    universe.worlds.splice(universe.worlds.indexOf(this), 1);
+    this.#isInitialized = false;
+    releaseWorldId(universe.worldIndex, this.#id);
+    universe.worlds[this.#id] = null;
   }
   reset() {
     const ctx = this[$internal];
-    ctx.entityIndex = createEntityIndex(__privateGet(this, _id));
+    this.entities.forEach((entity) => destroyEntity(this, entity));
+    ctx.entityIndex = createEntityIndex(this.#id);
     ctx.entityTraits.clear();
-    ctx.notQueries.clear();
     ctx.entityMasks = [[]];
     ctx.bitflag = 1;
     ctx.traitData.clear();
@@ -1305,12 +1286,16 @@ var World = class {
     ctx.queries.clear();
     ctx.queriesHashMap.clear();
     ctx.dirtyQueries.clear();
+    ctx.notQueries.clear();
     ctx.relationTargetEntities.clear();
     ctx.trackingSnapshots.clear();
     ctx.dirtyMasks.clear();
     ctx.changedMasks.clear();
     ctx.trackedTraits.clear();
     ctx.worldEntity = createEntity(this, IsExcluded);
+    for (const sub of ctx.resetSubscriptions) {
+      sub(this);
+    }
   }
   query(...args) {
     const ctx = this[$internal];
@@ -1362,21 +1347,21 @@ var World = class {
     ctx.trackedTraits.add(trait2);
     return () => {
       data.changedSubscriptions.delete(callback);
-      ctx.trackedTraits.delete(trait2);
+      if (data.changedSubscriptions.size === 0) ctx.trackedTraits.delete(trait2);
     };
   }
 };
-_id = new WeakMap();
-_isInitialized = new WeakMap();
-function createWorld(...traits) {
-  return new World(...traits);
-}
+var worldFinalizer = new FinalizationRegistry((worldId) => {
+  universe.worlds[worldId] = null;
+  releaseWorldId(universe.worldIndex, worldId);
+});
 
 // ../core/src/query/utils/cache-query.ts
 function cacheQuery(...parameters) {
   const hash = createQueryHash(parameters);
-  for (const world of universe.worlds) {
-    if (!world) continue;
+  for (const worldRef of universe.worlds) {
+    if (!worldRef) continue;
+    const world = worldRef.deref();
     const ctx = world[$internal];
     if (!ctx.queriesHashMap.has(hash)) {
       const query = new Query(world, parameters);
@@ -1387,6 +1372,9 @@ function cacheQuery(...parameters) {
   return hash;
 }
 
+// ../core/src/query/types.ts
+var $parameters = Symbol();
+
 // ../react/src/hooks/use-query.ts
 var import_react3 = require("react");
 
@@ -1397,41 +1385,48 @@ var import_react2 = require("react");
 var import_react = require("react");
 var WorldContext = (0, import_react.createContext)(null);
 
-// ../react/src/world/default-world.ts
-var defaultWorld = createWorld();
-var getDefaultWorld = () => defaultWorld;
-
 // ../react/src/world/use-world.ts
 function useWorld() {
-  const world = (0, import_react2.useContext)(WorldContext) ?? defaultWorld;
+  const world = (0, import_react2.useContext)(WorldContext);
+  if (!world) {
+    throw new Error("Koota: useWorld must be used within a WorldProvider");
+  }
   return world;
 }
 
 // ../react/src/hooks/use-query.ts
 function useQuery(...parameters) {
   const world = useWorld();
-  const [hash, initialVersion] = (0, import_react3.useMemo)(() => {
+  const [version, setVersion] = (0, import_react3.useState)(0);
+  const [hash, initialQueryVersion] = (0, import_react3.useMemo)(() => {
     const hash2 = cacheQuery(...parameters);
     const query = world[$internal].queriesHashMap.get(hash2);
     return [hash2, query.version];
-  }, [parameters]);
-  const [entities, setEntities] = (0, import_react3.useState)(() => world.query(hash));
+  }, [parameters, world]);
+  const [entities, setEntities] = (0, import_react3.useState)(() => world.query(hash).sort());
   (0, import_react3.useEffect)(() => {
     const unsubAdd = world.onAdd(parameters, () => {
-      setEntities(world.query(hash));
+      setEntities(world.query(hash).sort());
     });
     const unsubRemove = world.onRemove(parameters, () => {
-      setEntities(world.query(hash));
+      setEntities(world.query(hash).sort());
     });
     const query = world[$internal].queriesHashMap.get(hash);
-    if (query.version !== initialVersion) {
-      setEntities(world.query(hash));
+    if (query.version !== initialQueryVersion) {
+      setEntities(world.query(hash).sort());
     }
     return () => {
       unsubAdd();
       unsubRemove();
     };
-  }, [world, hash]);
+  }, [world, hash, version]);
+  (0, import_react3.useEffect)(() => {
+    const handler = () => setVersion((v) => v + 1);
+    world[$internal].resetSubscriptions.add(handler);
+    return () => {
+      world[$internal].resetSubscriptions.delete(handler);
+    };
+  }, [world]);
   return entities;
 }
 
@@ -1532,7 +1527,6 @@ function useTraitEffect(target, trait2, callback) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   WorldProvider,
-  getDefaultWorld,
   useActions,
   useQuery,
   useQueryFirst,

package/dist/react.d.cts

@@ -1,4 +1,4 @@
-import { Q as QueryParameter, o as QueryResult, W as World, T as Trait, k as Entity, g as TraitInstance } from './world-CHO2npCL.cjs';
+import { Q as QueryParameter, p as QueryResult, W as World, T as Trait, l as Entity, h as TraitInstance } from './world-BYe3z9dR.cjs';
 import * as react_jsx_runtime from 'react/jsx-runtime';
 
 declare function useQuery<T extends QueryParameter[]>(...parameters: T): QueryResult<T>;
@@ -18,6 +18,4 @@ declare function useQueryFirst<T extends QueryParameter[]>(...parameters: T): En
 
 declare function useTraitEffect<T extends Trait>(target: Entity | World, trait: T, callback: (value: TraitInstance<T> | undefined) => void): void;
 
-declare const getDefaultWorld: () => World;
-
-export { WorldProvider, getDefaultWorld, useActions, useQuery, useQueryFirst, useTrait, useTraitEffect, useWorld };
+export { WorldProvider, useActions, useQuery, useQueryFirst, useTrait, useTraitEffect, useWorld };

package/dist/react.d.ts

@@ -1,4 +1,4 @@
-import { Q as QueryParameter, o as QueryResult, W as World, T as Trait, k as Entity, g as TraitInstance } from './world-CHO2npCL.js';
+import { Q as QueryParameter, p as QueryResult, W as World, T as Trait, l as Entity, h as TraitInstance } from './world-BYe3z9dR.js';
 import * as react_jsx_runtime from 'react/jsx-runtime';
 
 declare function useQuery<T extends QueryParameter[]>(...parameters: T): QueryResult<T>;
@@ -18,6 +18,4 @@ declare function useQueryFirst<T extends QueryParameter[]>(...parameters: T): En
 
 declare function useTraitEffect<T extends Trait>(target: Entity | World, trait: T, callback: (value: TraitInstance<T> | undefined) => void): void;
 
-declare const getDefaultWorld: () => World;
-
-export { WorldProvider, getDefaultWorld, useActions, useQuery, useQueryFirst, useTrait, useTraitEffect, useWorld };
+export { WorldProvider, useActions, useQuery, useQueryFirst, useTrait, useTraitEffect, useWorld };

package/dist/react.js

@@ -1,8 +1,7 @@
 import {
   $internal,
-  cacheQuery,
-  createWorld
-} from "./chunk-ZHBGFPP2.js";
+  cacheQuery
+} from "./chunk-OAPTAVXT.js";
 
 // ../react/src/hooks/use-query.ts
 import { useEffect, useMemo, useState } from "react";
@@ -14,41 +13,48 @@ import { useContext } from "react";
 import { createContext } from "react";
 var WorldContext = createContext(null);
 
-// ../react/src/world/default-world.ts
-var defaultWorld = createWorld();
-var getDefaultWorld = () => defaultWorld;
-
 // ../react/src/world/use-world.ts
 function useWorld() {
-  const world = useContext(WorldContext) ?? defaultWorld;
+  const world = useContext(WorldContext);
+  if (!world) {
+    throw new Error("Koota: useWorld must be used within a WorldProvider");
+  }
   return world;
 }
 
 // ../react/src/hooks/use-query.ts
 function useQuery(...parameters) {
   const world = useWorld();
-  const [hash, initialVersion] = useMemo(() => {
+  const [version, setVersion] = useState(0);
+  const [hash, initialQueryVersion] = useMemo(() => {
     const hash2 = cacheQuery(...parameters);
     const query = world[$internal].queriesHashMap.get(hash2);
     return [hash2, query.version];
-  }, [parameters]);
-  const [entities, setEntities] = useState(() => world.query(hash));
+  }, [parameters, world]);
+  const [entities, setEntities] = useState(() => world.query(hash).sort());
   useEffect(() => {
     const unsubAdd = world.onAdd(parameters, () => {
-      setEntities(world.query(hash));
+      setEntities(world.query(hash).sort());
     });
     const unsubRemove = world.onRemove(parameters, () => {
-      setEntities(world.query(hash));
+      setEntities(world.query(hash).sort());
     });
     const query = world[$internal].queriesHashMap.get(hash);
-    if (query.version !== initialVersion) {
-      setEntities(world.query(hash));
+    if (query.version !== initialQueryVersion) {
+      setEntities(world.query(hash).sort());
     }
     return () => {
       unsubAdd();
       unsubRemove();
     };
-  }, [world, hash]);
+  }, [world, hash, version]);
+  useEffect(() => {
+    const handler = () => setVersion((v) => v + 1);
+    world[$internal].resetSubscriptions.add(handler);
+    return () => {
+      world[$internal].resetSubscriptions.delete(handler);
+    };
+  }, [world]);
   return entities;
 }
 
@@ -148,7 +154,6 @@ function useTraitEffect(target, trait, callback) {
 }
 export {
   WorldProvider,
-  getDefaultWorld,
   useActions,
   useQuery,
   useQueryFirst,

package/dist/{world-CHO2npCL.d.cts → world-BYe3z9dR.d.cts}

@@ -138,6 +138,7 @@ type QueryResult<T extends QueryParameter[] = QueryParameter[]> = readonly Entit
     updateEach: (callback: (state: InstancesFromParameters<T>, entity: Entity, index: number) => void, options?: QueryResultOptions) => QueryResult<T>;
     useStores: (callback: (stores: StoresFromParameters<T>, entities: readonly Entity[]) => void) => QueryResult<T>;
     select<U extends QueryParameter[]>(...params: U): QueryResult<U>;
+    sort(callback?: (a: Entity, b: Entity) => number): QueryResult<T>;
 };
 type UnwrapModifierData<T> = T extends ModifierData<infer C> ? C : never;
 type StoresFromParameters<T extends QueryParameter[]> = T extends [infer First, ...infer Rest] ? [
@@ -152,6 +153,10 @@ type InstancesFromParameters<T extends QueryParameter[]> = T extends [
     ...(Rest extends QueryParameter[] ? InstancesFromParameters<Rest> : [])
 ] : [];
 type IsNotModifier<T> = T extends ModifierData<any, infer TType> ? TType extends 'not' ? true : false : false;
+declare const $parameters: unique symbol;
+type QueryHash<T extends QueryParameter[]> = string & {
+    readonly [$parameters]: T;
+};
 
 declare class Query {
     version: number;
@@ -217,6 +222,7 @@ declare class World {
         changedMasks: Map<number, number[][]>;
         worldEntity: Entity;
         trackedTraits: Set<Trait>;
+        resetSubscriptions: Set<(world: World) => void>;
     };
     get id(): number;
     get isInitialized(): boolean;
@@ -233,7 +239,7 @@ declare class World {
     set<T extends Trait>(trait: T, value: TraitValue<ExtractSchema<T>>): void;
     destroy(): void;
     reset(): void;
-    query<T extends QueryParameter[]>(key: string): QueryResult<T>;
+    query<T extends QueryParameter[]>(key: QueryHash<T>): QueryResult<T>;
     query<T extends QueryParameter[]>(...parameters: T): QueryResult<T>;
     queryFirst(key: string): Entity | undefined;
     queryFirst(...parameters: QueryParameter[]): Entity | undefined;
@@ -243,4 +249,4 @@ declare class World {
 }
 declare function createWorld(...traits: ConfigurableTrait[]): World;
 
-export { $internal as $, type AoSFactory as A, type ConfigurableTrait as C, type ExtractSchema as E, type IsTag as I, ModifierData as M, type Norm as N, type QueryParameter as Q, type Relation as R, type Schema as S, type Trait as T, World as W, type RelationTarget as a, type WildcardRelation as b, createWorld as c, type TraitType as d, type TraitValue as e, type TraitTuple as f, type TraitInstance as g, type Store as h, type ExtractStore as i, type ExtractIsTag as j, type Entity as k, type QueryModifier as l, type QuerySubscriber as m, type QueryResultOptions as n, type QueryResult as o, type StoresFromParameters as p, type InstancesFromParameters as q, type IsNotModifier as r };
+export { $internal as $, type AoSFactory as A, type ConfigurableTrait as C, type ExtractSchema as E, type IsTag as I, ModifierData as M, type Norm as N, type QueryParameter as Q, type Relation as R, type Schema as S, type Trait as T, World as W, type QueryHash as a, type RelationTarget as b, type WildcardRelation as c, createWorld as d, type TraitType as e, type TraitValue as f, type TraitTuple as g, type TraitInstance as h, type Store as i, type ExtractStore as j, type ExtractIsTag as k, type Entity as l, type QueryModifier as m, type QuerySubscriber as n, type QueryResultOptions as o, type QueryResult as p, type StoresFromParameters as q, type InstancesFromParameters as r, type IsNotModifier as s };