koota 0.0.3

package/dist/react.cjs

@@ -0,0 +1,111 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/react.ts
+var react_exports = {};
+__export(react_exports, {
+  WorldProvider: () => WorldProvider,
+  createActions: () => createActions,
+  useObserve: () => useObserve,
+  useQuery: () => useQuery,
+  useWorld: () => useWorld
+});
+module.exports = __toCommonJS(react_exports);
+
+// ../react/src/query/use-query.ts
+var import_react3 = require("react");
+
+// ../react/src/world/use-world.ts
+var import_react2 = require("react");
+
+// ../react/src/world/world-context.ts
+var import_react = require("react");
+var WorldContext = (0, import_react.createContext)(null);
+
+// ../react/src/world/use-world.ts
+function useWorld() {
+  const world = (0, import_react2.useContext)(WorldContext);
+  if (!world) throw new Error("Koota ECS: Hooks can only be used within the World component!");
+  return world;
+}
+
+// ../react/src/query/use-query.ts
+function useQuery(...parameters) {
+  const world = useWorld();
+  const [entities, setEntities] = (0, import_react3.useState)([]);
+  (0, import_react3.useEffect)(() => {
+    const unsubAdd = world.onAdd(parameters, (entity) => {
+      setEntities((v) => [...v, entity]);
+    });
+    const unsubRemove = world.onRemove(parameters, (entity) => {
+      setEntities((v) => v.filter((e) => e !== entity));
+    });
+    return () => {
+      unsubAdd();
+      unsubRemove();
+    };
+  }, [world, parameters]);
+  return entities;
+}
+
+// ../react/src/world/world-provider.tsx
+var import_jsx_runtime = require("react/jsx-runtime");
+function WorldProvider({ children, world }) {
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(WorldContext.Provider, { value: world, children });
+}
+
+// ../react/src/actions/create-actions.ts
+function createActions(actionSet) {
+  return Object.assign(
+    () => {
+      const world = useWorld();
+      return actionSet(world);
+    },
+    {
+      get: (world) => actionSet(world)
+    }
+  );
+}
+
+// ../react/src/trait/use-observe.tsx
+var import_react4 = require("react");
+function useObserve(entity, trait) {
+  const world = useWorld();
+  const [value, setValue] = (0, import_react4.useState)(() => {
+    if (entity.has(trait)) return entity.get(trait);
+    return void 0;
+  });
+  (0, import_react4.useEffect)(() => {
+    const unsub = world.onChange(trait, (e) => {
+      if (e === entity) setValue(e.get(trait));
+    });
+    return () => {
+      unsub();
+    };
+  }, [entity, trait]);
+  return value;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  WorldProvider,
+  createActions,
+  useObserve,
+  useQuery,
+  useWorld
+});

package/dist/react.d.cts

@@ -0,0 +1,19 @@
+import { Q as QueryParameter, W as World, T as Trait, j as Entity, d as TraitInstanceFromSchema, E as ExtractSchema } from './world-BRz2NI5_.cjs';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+
+declare function useQuery(...parameters: QueryParameter[]): number[];
+
+declare function WorldProvider({ children, world }: {
+    children: React.ReactNode;
+    world: World;
+}): react_jsx_runtime.JSX.Element;
+
+declare function useWorld(): World;
+
+declare function createActions<T extends Record<string, (...args: any[]) => any>>(actionSet: (world: World) => T): (() => T) & {
+    get: (world: World) => T;
+};
+
+declare function useObserve<T extends Trait>(entity: Entity, trait: T): TraitInstanceFromSchema<ExtractSchema<T>> | undefined;
+
+export { WorldProvider, createActions, useObserve, useQuery, useWorld };

package/dist/react.d.ts

@@ -0,0 +1,19 @@
+import { Q as QueryParameter, W as World, T as Trait, j as Entity, d as TraitInstanceFromSchema, E as ExtractSchema } from './world-BRz2NI5_.js';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+
+declare function useQuery(...parameters: QueryParameter[]): number[];
+
+declare function WorldProvider({ children, world }: {
+    children: React.ReactNode;
+    world: World;
+}): react_jsx_runtime.JSX.Element;
+
+declare function useWorld(): World;
+
+declare function createActions<T extends Record<string, (...args: any[]) => any>>(actionSet: (world: World) => T): (() => T) & {
+    get: (world: World) => T;
+};
+
+declare function useObserve<T extends Trait>(entity: Entity, trait: T): TraitInstanceFromSchema<ExtractSchema<T>> | undefined;
+
+export { WorldProvider, createActions, useObserve, useQuery, useWorld };

package/dist/react.js

@@ -0,0 +1,82 @@
+import "./chunk-AQ5VUG5P.js";
+
+// ../react/src/query/use-query.ts
+import { useEffect, useState } from "react";
+
+// ../react/src/world/use-world.ts
+import { useContext } from "react";
+
+// ../react/src/world/world-context.ts
+import { createContext } from "react";
+var WorldContext = createContext(null);
+
+// ../react/src/world/use-world.ts
+function useWorld() {
+  const world = useContext(WorldContext);
+  if (!world) throw new Error("Koota ECS: Hooks can only be used within the World component!");
+  return world;
+}
+
+// ../react/src/query/use-query.ts
+function useQuery(...parameters) {
+  const world = useWorld();
+  const [entities, setEntities] = useState([]);
+  useEffect(() => {
+    const unsubAdd = world.onAdd(parameters, (entity) => {
+      setEntities((v) => [...v, entity]);
+    });
+    const unsubRemove = world.onRemove(parameters, (entity) => {
+      setEntities((v) => v.filter((e) => e !== entity));
+    });
+    return () => {
+      unsubAdd();
+      unsubRemove();
+    };
+  }, [world, parameters]);
+  return entities;
+}
+
+// ../react/src/world/world-provider.tsx
+import { jsx } from "react/jsx-runtime";
+function WorldProvider({ children, world }) {
+  return /* @__PURE__ */ jsx(WorldContext.Provider, { value: world, children });
+}
+
+// ../react/src/actions/create-actions.ts
+function createActions(actionSet) {
+  return Object.assign(
+    () => {
+      const world = useWorld();
+      return actionSet(world);
+    },
+    {
+      get: (world) => actionSet(world)
+    }
+  );
+}
+
+// ../react/src/trait/use-observe.tsx
+import { useEffect as useEffect2, useState as useState2 } from "react";
+function useObserve(entity, trait) {
+  const world = useWorld();
+  const [value, setValue] = useState2(() => {
+    if (entity.has(trait)) return entity.get(trait);
+    return void 0;
+  });
+  useEffect2(() => {
+    const unsub = world.onChange(trait, (e) => {
+      if (e === entity) setValue(e.get(trait));
+    });
+    return () => {
+      unsub();
+    };
+  }, [entity, trait]);
+  return value;
+}
+export {
+  WorldProvider,
+  createActions,
+  useObserve,
+  useQuery,
+  useWorld
+};

package/dist/world-BRz2NI5_.d.cts

@@ -0,0 +1,229 @@
+declare const $internal: unique symbol;
+
+type RelationTarget = number | string;
+type Relation<T> = T & {
+    [$internal]: {
+        pairsMap: Map<number | string, T>;
+        createTrait: () => T;
+        exclusive: boolean;
+        autoRemoveTarget: boolean;
+    };
+} & ((target: RelationTarget) => T);
+
+type IsEmpty<T> = T extends Record<string, never> ? true : false;
+
+type Trait<TSchema extends Schema = any, TStore = Store<TSchema>, TTag extends boolean = IsEmpty<TSchema>> = {
+    schema: TSchema;
+    [$internal]: {
+        set: (index: number, store: TStore, values: Partial<TraitInstanceFromSchema<TSchema>>) => void;
+        fastSet: (index: number, store: TStore, values: Partial<TraitInstanceFromSchema<TSchema>>) => void;
+        fastSetWithChangeDetection: (index: number, store: TStore, values: Partial<TraitInstanceFromSchema<TSchema>>) => boolean;
+        get: (index: number, store: TStore) => TraitInstanceFromSchema<TSchema>;
+        stores: TStore[];
+        id: number;
+        createStore: () => TStore;
+        isPairTrait: boolean;
+        relation: Relation<any> | null;
+        pairTarget: RelationTarget | null;
+        isTag: TTag;
+    };
+} & ((params: Partial<TraitInstanceFromSchema<TSchema>>) => [Trait<TSchema, TStore>, Partial<TSchema>]);
+type TraitTuple<T extends Trait = Trait> = [
+    T,
+    T extends Trait<infer S, any> ? Partial<TraitInstanceFromSchema<S>> : never
+];
+type ConfigurableTrait<T extends Trait = Trait> = T | TraitTuple<T>;
+type TraitInstanceFromSchema<T extends Schema> = {
+    [P in keyof T]: T[P] extends (...args: any[]) => any ? ReturnType<T[P]> : T[P];
+};
+type TraitInstance<T extends Trait> = {
+    [P in keyof T['schema']]: T['schema'][P] extends (...args: any[]) => any ? ReturnType<T['schema'][P]> : T['schema'][P];
+};
+type Schema = {
+    [key: string]: number | string | boolean | any[] | object | null | undefined;
+};
+type Store<T extends Schema = any> = {
+    [P in keyof T]: T[P] extends (...args: any[]) => any ? ReturnType<T[P]>[] : T[P][];
+};
+type Norm<T extends Schema> = {
+    [K in keyof T]: T[K] extends boolean ? boolean : T[K];
+};
+type TraitSnapshot<T extends Trait> = T extends Trait<infer S, any> ? TraitInstanceFromSchema<S> : never;
+type ExtractSchema<T extends Trait> = T extends Trait<infer S, any> ? S : never;
+type ExtractStore<T extends Trait> = T extends Trait<any, infer S> ? S : never;
+type ExtractStores<T extends [Trait, ...Trait[]]> = T extends [infer C] ? C extends Trait<any, Store<any>> ? ExtractStore<C> : never : {
+    [K in keyof T]: ExtractStore<T[K]>;
+};
+type IsTag<T extends Trait> = T extends Trait<any, any, infer Tag> ? Tag : false;
+
+type Entity = number & {
+    add: (...traits: ConfigurableTrait[]) => void;
+    remove: (...traits: Trait[]) => void;
+    has: (trait: Trait) => boolean;
+    destroy: () => void;
+    changed: (trait: Trait) => void;
+    set: <T extends Trait>(trait: T, value: Partial<TraitInstanceFromSchema<ExtractSchema<T>>>, flagChanged?: boolean) => void;
+    get: <T extends Trait>(trait: T) => TraitInstanceFromSchema<ExtractSchema<T>>;
+    targetFor: <T>(relation: Relation<T>) => Entity | undefined;
+    targetsFor: <T>(relation: Relation<T>) => Entity[];
+    id: () => number;
+};
+
+type EntityIndex = {
+    /** The number of currently alive entities. */
+    aliveCount: number;
+    /** Array of packed entities, densely packed. */
+    dense: Entity[];
+    /** Sparse array mapping entity IDs to their index in the dense array. */
+    sparse: number[];
+    /** The highest entity ID that has been assigned. */
+    maxId: number;
+    /** The current world ID. */
+    worldId: number;
+};
+
+declare class SparseSet {
+    #private;
+    has(val: number): boolean;
+    add(val: number): void;
+    remove(val: number): void;
+    clear(): void;
+    sort(): void;
+    getIndex(val: number): number;
+    get dense(): number[];
+    get sparse(): number[];
+}
+
+declare class ModifierData<TTrait extends Trait[] = Trait[], TType extends string = string> {
+    type: TType;
+    id: number;
+    traits: TTrait;
+    traitIds: number[];
+    constructor(type: TType, id: number, traits: TTrait);
+}
+
+type QueryModifier = (...components: Trait[]) => ModifierData;
+type QueryParameter = Trait | ReturnType<QueryModifier>;
+type QuerySubscriber = (entity: Entity) => void;
+type QueryResultOptions = {
+    passive?: boolean;
+};
+type QueryResult<T extends QueryParameter[]> = readonly Entity[] & {
+    updateEach: (callback: (state: SnapshotFromParameters<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>;
+};
+type UnwrapModifierData<T> = T extends ModifierData<infer C> ? C : never;
+type StoresFromParameters<T extends QueryParameter[]> = T extends [infer First, ...infer Rest] ? [
+    ...(First extends Trait ? [ExtractStore<First>] : First extends ModifierData<any> ? StoresFromParameters<UnwrapModifierData<First>> : []),
+    ...(Rest extends QueryParameter[] ? StoresFromParameters<Rest> : [])
+] : [];
+type SnapshotFromParameters<T extends QueryParameter[]> = T extends [
+    infer First,
+    ...infer Rest
+] ? [
+    ...(First extends Trait ? IsTag<First> extends false ? [TraitSnapshot<First>] : [] : First extends ModifierData<any> ? IsNotModifier<First> extends true ? [] : SnapshotFromParameters<UnwrapModifierData<First>> : []),
+    ...(Rest extends QueryParameter[] ? SnapshotFromParameters<Rest> : [])
+] : [];
+type IsNotModifier<T> = T extends ModifierData<any, infer TType> ? TType extends 'not' ? true : false : false;
+
+declare class Query {
+    world: World;
+    parameters: QueryParameter[];
+    hash: string;
+    traits: Trait[];
+    traitData: {
+        required: TraitData[];
+        forbidden: TraitData[];
+        or: TraitData[];
+        added: TraitData[];
+        removed: TraitData[];
+        changed: TraitData[];
+        all: TraitData[];
+    };
+    bitmasks: {
+        required: number;
+        forbidden: number;
+        or: number;
+        added: number;
+        removed: number;
+        changed: number;
+        addedTracker: number[];
+        removedTracker: number[];
+        changedTracker: number[];
+    }[];
+    generations: number[];
+    entities: SparseSet;
+    isTracking: boolean;
+    hasChangedModifiers: boolean;
+    toRemove: SparseSet;
+    addSubscriptions: Set<QuerySubscriber>;
+    removeSubscriptions: Set<QuerySubscriber>;
+    constructor(world: World, parameters?: QueryParameter[]);
+    run(world: World): Entity[];
+    add(entity: Entity): void;
+    remove(world: World, entity: Entity): void;
+    check(world: World, entity: Entity, event?: {
+        type: 'add' | 'remove' | 'change';
+        traitData: TraitData;
+    }): boolean;
+    commitRemovals(world: World): void;
+    resetTrackingBitmasks(eid: number): void;
+}
+
+declare class TraitData<T extends Trait = Trait, S extends Schema = ExtractSchema<T>> {
+    generationId: number;
+    bitflag: number;
+    trait: Trait;
+    store: Store<S>;
+    queries: Set<Query>;
+    notQueries: Set<Query>;
+    schema: S;
+    changedSubscriptions: Set<(entity: Entity) => void>;
+    constructor(world: World, trait: T);
+}
+
+declare class World {
+    #private;
+    [$internal]: {
+        entityIndex: EntityIndex;
+        entityMasks: number[][];
+        entityTraits: Map<number, Set<Trait>>;
+        bitflag: number;
+        traitData: Map<Trait, TraitData<Trait, any>>;
+        queries: Set<Query>;
+        queriesHashMap: Map<string, Query>;
+        notQueries: Set<Query>;
+        dirtyQueries: Set<Query>;
+        relationTargetEntities: Set<RelationTarget>;
+        dirtyMasks: Map<number, number[][]>;
+        trackingSnapshots: Map<number, number[][]>;
+        changedMasks: Map<number, number[][]>;
+        worldEntity: Entity;
+    };
+    get id(): number;
+    get isInitialized(): boolean;
+    get entities(): Entity[];
+    traits: Set<Trait>;
+    constructor(...traits: ConfigurableTrait[]);
+    init(...traits: ConfigurableTrait[]): void;
+    spawn(...traits: ConfigurableTrait[]): Entity;
+    has(entity: Entity): boolean;
+    has(trait: Trait): boolean;
+    add(...traits: ConfigurableTrait[]): void;
+    remove(...traits: Trait[]): void;
+    get<T extends Trait>(trait: T): TraitInstanceFromSchema<ExtractSchema<T>>;
+    set<T extends Trait>(trait: T, value: Partial<TraitInstanceFromSchema<ExtractSchema<T>>>): void;
+    destroy(): void;
+    reset(): void;
+    query<T extends QueryParameter[]>(key: string): QueryResult<T>;
+    query<T extends QueryParameter[]>(...parameters: T): QueryResult<T>;
+    queryFirst(key: string): Entity | undefined;
+    queryFirst(...parameters: QueryParameter[]): Entity | undefined;
+    onAdd(parameters: QueryParameter[], callback: (entity: Entity) => void): () => boolean;
+    onRemove(parameters: QueryParameter[], callback: (entity: Entity) => void): () => boolean;
+    onChange(trait: Trait, callback: (entity: Entity) => void): () => boolean;
+}
+declare function createWorld(...traits: ConfigurableTrait[]): World;
+
+export { $internal as $, 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 TraitTuple as b, createWorld as c, type TraitInstanceFromSchema as d, type TraitInstance as e, type Store as f, type TraitSnapshot as g, type ExtractStore as h, type ExtractStores as i, type Entity as j, type QueryModifier as k, type QuerySubscriber as l, type QueryResultOptions as m, type QueryResult as n, type StoresFromParameters as o, type SnapshotFromParameters as p, type IsNotModifier as q };

package/dist/world-BRz2NI5_.d.ts

@@ -0,0 +1,229 @@
+declare const $internal: unique symbol;
+
+type RelationTarget = number | string;
+type Relation<T> = T & {
+    [$internal]: {
+        pairsMap: Map<number | string, T>;
+        createTrait: () => T;
+        exclusive: boolean;
+        autoRemoveTarget: boolean;
+    };
+} & ((target: RelationTarget) => T);
+
+type IsEmpty<T> = T extends Record<string, never> ? true : false;
+
+type Trait<TSchema extends Schema = any, TStore = Store<TSchema>, TTag extends boolean = IsEmpty<TSchema>> = {
+    schema: TSchema;
+    [$internal]: {
+        set: (index: number, store: TStore, values: Partial<TraitInstanceFromSchema<TSchema>>) => void;
+        fastSet: (index: number, store: TStore, values: Partial<TraitInstanceFromSchema<TSchema>>) => void;
+        fastSetWithChangeDetection: (index: number, store: TStore, values: Partial<TraitInstanceFromSchema<TSchema>>) => boolean;
+        get: (index: number, store: TStore) => TraitInstanceFromSchema<TSchema>;
+        stores: TStore[];
+        id: number;
+        createStore: () => TStore;
+        isPairTrait: boolean;
+        relation: Relation<any> | null;
+        pairTarget: RelationTarget | null;
+        isTag: TTag;
+    };
+} & ((params: Partial<TraitInstanceFromSchema<TSchema>>) => [Trait<TSchema, TStore>, Partial<TSchema>]);
+type TraitTuple<T extends Trait = Trait> = [
+    T,
+    T extends Trait<infer S, any> ? Partial<TraitInstanceFromSchema<S>> : never
+];
+type ConfigurableTrait<T extends Trait = Trait> = T | TraitTuple<T>;
+type TraitInstanceFromSchema<T extends Schema> = {
+    [P in keyof T]: T[P] extends (...args: any[]) => any ? ReturnType<T[P]> : T[P];
+};
+type TraitInstance<T extends Trait> = {
+    [P in keyof T['schema']]: T['schema'][P] extends (...args: any[]) => any ? ReturnType<T['schema'][P]> : T['schema'][P];
+};
+type Schema = {
+    [key: string]: number | string | boolean | any[] | object | null | undefined;
+};
+type Store<T extends Schema = any> = {
+    [P in keyof T]: T[P] extends (...args: any[]) => any ? ReturnType<T[P]>[] : T[P][];
+};
+type Norm<T extends Schema> = {
+    [K in keyof T]: T[K] extends boolean ? boolean : T[K];
+};
+type TraitSnapshot<T extends Trait> = T extends Trait<infer S, any> ? TraitInstanceFromSchema<S> : never;
+type ExtractSchema<T extends Trait> = T extends Trait<infer S, any> ? S : never;
+type ExtractStore<T extends Trait> = T extends Trait<any, infer S> ? S : never;
+type ExtractStores<T extends [Trait, ...Trait[]]> = T extends [infer C] ? C extends Trait<any, Store<any>> ? ExtractStore<C> : never : {
+    [K in keyof T]: ExtractStore<T[K]>;
+};
+type IsTag<T extends Trait> = T extends Trait<any, any, infer Tag> ? Tag : false;
+
+type Entity = number & {
+    add: (...traits: ConfigurableTrait[]) => void;
+    remove: (...traits: Trait[]) => void;
+    has: (trait: Trait) => boolean;
+    destroy: () => void;
+    changed: (trait: Trait) => void;
+    set: <T extends Trait>(trait: T, value: Partial<TraitInstanceFromSchema<ExtractSchema<T>>>, flagChanged?: boolean) => void;
+    get: <T extends Trait>(trait: T) => TraitInstanceFromSchema<ExtractSchema<T>>;
+    targetFor: <T>(relation: Relation<T>) => Entity | undefined;
+    targetsFor: <T>(relation: Relation<T>) => Entity[];
+    id: () => number;
+};
+
+type EntityIndex = {
+    /** The number of currently alive entities. */
+    aliveCount: number;
+    /** Array of packed entities, densely packed. */
+    dense: Entity[];
+    /** Sparse array mapping entity IDs to their index in the dense array. */
+    sparse: number[];
+    /** The highest entity ID that has been assigned. */
+    maxId: number;
+    /** The current world ID. */
+    worldId: number;
+};
+
+declare class SparseSet {
+    #private;
+    has(val: number): boolean;
+    add(val: number): void;
+    remove(val: number): void;
+    clear(): void;
+    sort(): void;
+    getIndex(val: number): number;
+    get dense(): number[];
+    get sparse(): number[];
+}
+
+declare class ModifierData<TTrait extends Trait[] = Trait[], TType extends string = string> {
+    type: TType;
+    id: number;
+    traits: TTrait;
+    traitIds: number[];
+    constructor(type: TType, id: number, traits: TTrait);
+}
+
+type QueryModifier = (...components: Trait[]) => ModifierData;
+type QueryParameter = Trait | ReturnType<QueryModifier>;
+type QuerySubscriber = (entity: Entity) => void;
+type QueryResultOptions = {
+    passive?: boolean;
+};
+type QueryResult<T extends QueryParameter[]> = readonly Entity[] & {
+    updateEach: (callback: (state: SnapshotFromParameters<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>;
+};
+type UnwrapModifierData<T> = T extends ModifierData<infer C> ? C : never;
+type StoresFromParameters<T extends QueryParameter[]> = T extends [infer First, ...infer Rest] ? [
+    ...(First extends Trait ? [ExtractStore<First>] : First extends ModifierData<any> ? StoresFromParameters<UnwrapModifierData<First>> : []),
+    ...(Rest extends QueryParameter[] ? StoresFromParameters<Rest> : [])
+] : [];
+type SnapshotFromParameters<T extends QueryParameter[]> = T extends [
+    infer First,
+    ...infer Rest
+] ? [
+    ...(First extends Trait ? IsTag<First> extends false ? [TraitSnapshot<First>] : [] : First extends ModifierData<any> ? IsNotModifier<First> extends true ? [] : SnapshotFromParameters<UnwrapModifierData<First>> : []),
+    ...(Rest extends QueryParameter[] ? SnapshotFromParameters<Rest> : [])
+] : [];
+type IsNotModifier<T> = T extends ModifierData<any, infer TType> ? TType extends 'not' ? true : false : false;
+
+declare class Query {
+    world: World;
+    parameters: QueryParameter[];
+    hash: string;
+    traits: Trait[];
+    traitData: {
+        required: TraitData[];
+        forbidden: TraitData[];
+        or: TraitData[];
+        added: TraitData[];
+        removed: TraitData[];
+        changed: TraitData[];
+        all: TraitData[];
+    };
+    bitmasks: {
+        required: number;
+        forbidden: number;
+        or: number;
+        added: number;
+        removed: number;
+        changed: number;
+        addedTracker: number[];
+        removedTracker: number[];
+        changedTracker: number[];
+    }[];
+    generations: number[];
+    entities: SparseSet;
+    isTracking: boolean;
+    hasChangedModifiers: boolean;
+    toRemove: SparseSet;
+    addSubscriptions: Set<QuerySubscriber>;
+    removeSubscriptions: Set<QuerySubscriber>;
+    constructor(world: World, parameters?: QueryParameter[]);
+    run(world: World): Entity[];
+    add(entity: Entity): void;
+    remove(world: World, entity: Entity): void;
+    check(world: World, entity: Entity, event?: {
+        type: 'add' | 'remove' | 'change';
+        traitData: TraitData;
+    }): boolean;
+    commitRemovals(world: World): void;
+    resetTrackingBitmasks(eid: number): void;
+}
+
+declare class TraitData<T extends Trait = Trait, S extends Schema = ExtractSchema<T>> {
+    generationId: number;
+    bitflag: number;
+    trait: Trait;
+    store: Store<S>;
+    queries: Set<Query>;
+    notQueries: Set<Query>;
+    schema: S;
+    changedSubscriptions: Set<(entity: Entity) => void>;
+    constructor(world: World, trait: T);
+}
+
+declare class World {
+    #private;
+    [$internal]: {
+        entityIndex: EntityIndex;
+        entityMasks: number[][];
+        entityTraits: Map<number, Set<Trait>>;
+        bitflag: number;
+        traitData: Map<Trait, TraitData<Trait, any>>;
+        queries: Set<Query>;
+        queriesHashMap: Map<string, Query>;
+        notQueries: Set<Query>;
+        dirtyQueries: Set<Query>;
+        relationTargetEntities: Set<RelationTarget>;
+        dirtyMasks: Map<number, number[][]>;
+        trackingSnapshots: Map<number, number[][]>;
+        changedMasks: Map<number, number[][]>;
+        worldEntity: Entity;
+    };
+    get id(): number;
+    get isInitialized(): boolean;
+    get entities(): Entity[];
+    traits: Set<Trait>;
+    constructor(...traits: ConfigurableTrait[]);
+    init(...traits: ConfigurableTrait[]): void;
+    spawn(...traits: ConfigurableTrait[]): Entity;
+    has(entity: Entity): boolean;
+    has(trait: Trait): boolean;
+    add(...traits: ConfigurableTrait[]): void;
+    remove(...traits: Trait[]): void;
+    get<T extends Trait>(trait: T): TraitInstanceFromSchema<ExtractSchema<T>>;
+    set<T extends Trait>(trait: T, value: Partial<TraitInstanceFromSchema<ExtractSchema<T>>>): void;
+    destroy(): void;
+    reset(): void;
+    query<T extends QueryParameter[]>(key: string): QueryResult<T>;
+    query<T extends QueryParameter[]>(...parameters: T): QueryResult<T>;
+    queryFirst(key: string): Entity | undefined;
+    queryFirst(...parameters: QueryParameter[]): Entity | undefined;
+    onAdd(parameters: QueryParameter[], callback: (entity: Entity) => void): () => boolean;
+    onRemove(parameters: QueryParameter[], callback: (entity: Entity) => void): () => boolean;
+    onChange(trait: Trait, callback: (entity: Entity) => void): () => boolean;
+}
+declare function createWorld(...traits: ConfigurableTrait[]): World;
+
+export { $internal as $, 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 TraitTuple as b, createWorld as c, type TraitInstanceFromSchema as d, type TraitInstance as e, type Store as f, type TraitSnapshot as g, type ExtractStore as h, type ExtractStores as i, type Entity as j, type QueryModifier as k, type QuerySubscriber as l, type QueryResultOptions as m, type QueryResult as n, type StoresFromParameters as o, type SnapshotFromParameters as p, type IsNotModifier as q };