@perplexdotgg/mecs 0.4.2 → 0.5.0

package/README.md

@@ -142,6 +142,9 @@ const queries = {
     without: ['localTransform'],
 
     // listeners can added now, or later (see the Queries docs below)
+    // note that in this context, the entity type doesn't have Entity methods that you've added
+    // if you need those, either ts-ignore when calling them here, or add listeners later in your system code using:
+    // Entity.queries().yourQueryKey.afterEntityAdded.addListener((entity) => { /* your code here will get the right entity type */ }))
     afterEntityAdded: (entity) => {
       // this is called when an entity newly matches this query
     },
@@ -154,7 +157,7 @@ const queries = {
     with: ['localTransform', 'globalTransform'],
     without: [],
   },
-} as const satisfies QueryMap<Entity, typeof components>;
+} as const satisfies QueryMap<typeof components>;
 
 // additional Entity class options, see "Entity Class Options" below
 const extraOptions = {};

package/build/index.d.ts

@@ -4,10 +4,18 @@ import { MonomorphInstance } from 'monomorph';
 import { NumberArray } from 'monomorph';
 import { PartialRecursive } from 'monomorph';
 import { PoolClass } from 'monomorph';
+import { PropertyDefinitionClassProperties } from 'monomorph';
+import { PropertyDefinitionReference } from 'monomorph';
+import { PropertyDefinitionReferenceList } from 'monomorph';
+import { ReferenceListClass } from 'monomorph';
 import { WithPool } from 'monomorph';
 
+declare type BivariantCallback<T> = {
+    bivarianceHack(arg: T): void;
+}["bivarianceHack"];
+
 export declare type ComponentConfig<ComponentType, ComponentInputType extends any = InputType<ComponentType> extends never ? ComponentType : InputType<ComponentType>> = {
-    monomorphClass?: ComponentType extends MonomorphClass<any, any, any> ? ComponentType : ComponentType extends MonomorphInstance<infer P, infer I> ? MonomorphClass<P, I, ComponentType> : never;
+    monomorphClass?: ComponentType extends LazyWrapper<infer MC extends MonomorphClass<any, any, any>> ? LazyWrapper<MC> : ComponentType extends MonomorphClass<any, any, any> ? ComponentType : ComponentType extends MonomorphInstance<infer P, infer I> ? MonomorphClass<P, I, ComponentType> : never;
     afterComponentAdded?: (componentInstance: ComponentType extends abstract new (...args: any) => any ? InstanceType<ComponentType> : ComponentType, entity: any, componentKey: string) => void;
     afterComponentAddedCode?: string | ComponentConfigFunction<ComponentType, ComponentInputType>;
     beforeComponentRemoved?: (componentInstance: ComponentType extends abstract new (...args: any) => any ? InstanceType<ComponentType> : ComponentType, entity: any, componentKey: string) => void;
@@ -40,26 +48,36 @@ export declare type ComponentConfigFunction<ComponentType, ComponentInputType> =
 
 export declare type ComponentInput<X> = X extends MonomorphClass<infer P, infer I, infer M> ? M extends MonomorphInstance<infer iP, infer iI> ? InputType<M> : never : X extends ComponentConfig<infer CT, infer I> ? I : X;
 
+declare type ComponentInputResolved<CC, CM extends ComponentMap> = ResolveEntityInputListItems<ComponentInput<ExtractMonomorphClass<CC>>, CM>;
+
 export declare type ComponentMap = Record<string, ComponentConfig<any, any> | MonomorphClass<any, any, any> | LazyWrapper<MonomorphClass<any, any, any>> | ComponentConfig<MonomorphClass<any, any, any>, any> | ComponentConfig<LazyWrapper<MonomorphClass<any, any, any>>, any>>;
 
-declare type ComponentMapClassProperties<CM> = {
-    [K in keyof CM as LowercaseFirstLetter<K>]?: ExtractMonomorphClass<CM[K]> extends MonomorphClass<infer P, infer I, infer M> ? M : ExtractMonomorphClass<CM[K]>;
+declare type ComponentMapClassProperties<CM extends ComponentMap> = {
+    [K in keyof CM as LowercaseFirstLetter<K>]?: ExtractMonomorphClass<CM[K]> extends MonomorphClass<infer P, infer I, infer M> ? ResolveEntityRefs<M, CM> : ExtractMonomorphClass<CM[K]>;
 };
 
 export declare type ComponentMapInput<CM extends ComponentMap> = Partial<{
-    [K in keyof CM as LowercaseFirstLetter<K>]: ComponentInput<ExtractMonomorphClass<CM[K]>>;
+    [K in keyof CM as LowercaseFirstLetter<K>]: ResolveEntityInput<ComponentInput<ExtractMonomorphClass<CM[K]>>, CM>;
+}>;
+
+declare type ComponentMapInputListItems<CM extends ComponentMap> = Partial<{
+    [K in keyof CM as LowercaseFirstLetter<K>]: ResolveEntityInputListItems<ComponentInput<ExtractMonomorphClass<CM[K]>>, CM>;
 }>;
 
-export declare function createEntityClass<C>(options?: EntityCodeGenerationOptions): <CM extends ComponentMap, QM extends QueryMap<C, CM>, I extends ComponentMapInput<CM> = ComponentMapInput<CM>>(componentMap: CM, queries?: QM) => EntityClassWithStatics<C, CM, QM, I>;
+declare type ComponentTypeFromMonomorphClass<T> = T extends MonomorphClass<infer P, any, any> ? PropertyDefinitionClassProperties<P> : never;
 
-export declare type CreateEntityFunction<C, CM extends ComponentMap, I extends ComponentMapInput<CM>> = (data?: I, updateQueryMemberships?: boolean, pool?: EntityPoolClass<C>) => EntityInstanceWithPool<CM, I, C>;
+export declare function createEntityClass<C>(options?: EntityCodeGenerationOptions): <CM extends ComponentMap, QM extends QueryMap<CM>, I extends ComponentMapInput<CM> = ComponentMapInput<CM>>(componentMap: CM, queries?: QM) => EntityClassWithStatics<C, CM, QM, I>;
 
-declare type ElementOfArray<T> = T extends (infer E)[] ? E : never;
+export declare function createEntityClass(options?: EntityCodeGenerationOptions): <CM extends ComponentMap, QM extends QueryMap<CM>, I extends ComponentMapInput<CM> = ComponentMapInput<CM>>(componentMap: CM, queries?: QM) => EntityClassWithStatics<EntityInstance<CM, I>, CM, QM, I>;
+
+export declare type CreateEntityFunction<C, CM extends ComponentMap, I extends ComponentMapInput<CM>> = <T extends EntityConstructor<any, any, I, CM>>(this: T, data?: I, updateQueryMemberships?: boolean, pool?: EntityPoolClass<InstanceType<T>>) => EntityInstanceWithPool<CM, I, InstanceType<T>>;
+
+declare type ElementOfReadonlyArray<T> = T extends ReadonlyArray<infer E> ? E : never;
 
 declare interface EntityBaseProperties<CM extends ComponentMap, I extends any = ComponentMapInput<CM>> {
     componentMap: CM;
     __typescriptOnlyInputType: I;
-    addComponent: <CCK extends LowercaseFirstLetter<keyof CM>, CC extends CM[OriginalComponentKey<CCK, CM>] = CM[OriginalComponentKey<CCK, CM>]>(...a: (undefined extends ComponentInput<ExtractMonomorphClass<CC>> ? [key: CCK, data?: ComponentInput<ExtractMonomorphClass<CC>>, updateQueryMemberships?: boolean] : [key: CCK, data: ComponentInput<ExtractMonomorphClass<CC>>, updateQueryMemberships?: boolean])) => void;
+    addComponent: <CCK extends LowercaseFirstLetter<keyof CM>, CC extends CM[OriginalComponentKey<CCK, CM>] = CM[OriginalComponentKey<CCK, CM>]>(...a: (undefined extends NoInfer<ComponentInputResolved<CC, CM>> ? [key: CCK, data?: NoInfer<ComponentInputResolved<CC, CM>>, updateQueryMemberships?: boolean] : [key: CCK, data: NoInfer<ComponentInputResolved<CC, CM>>, updateQueryMemberships?: boolean])) => void;
     removeComponent: <CCK extends LowercaseFirstLetter<keyof CM>>(key: CCK, updateQueryMemberships?: boolean) => void;
     hasComponent: <CCK extends LowercaseFirstLetter<keyof CM>>(key: CCK) => boolean;
     clone(): this;
@@ -68,9 +86,9 @@ declare interface EntityBaseProperties<CM extends ComponentMap, I extends any =
     isDestroyed(): boolean;
 }
 
-export declare type EntityClass<CM extends ComponentMap, I extends ComponentMapInput<CM> = ComponentMapInput<CM>, QM extends QueryMap<any, CM> = QueryMap<any, CM>, E extends EntityInstance<CM, I> = EntityInstance<CM, I>> = EntityConstructor<QM, E, I, CM>;
+export declare type EntityClass<CM extends ComponentMap, I extends ComponentMapInput<CM> = ComponentMapInput<CM>, QM extends QueryMap<CM> = QueryMap<CM>, E extends EntityInstance<CM, I> = EntityInstance<CM, I>> = EntityConstructor<QM, E, I, CM>;
 
-export declare type EntityClassWithStatics<C, CM extends ComponentMap, QM extends QueryMap<C, CM>, I extends ComponentMapInput<CM> = ComponentMapInput<CM>> = EntityClass<CM, I, QM> & {
+export declare type EntityClassWithStatics<C, CM extends ComponentMap, QM extends QueryMap<CM>, I extends ComponentMapInput<CM> = ComponentMapInput<CM>> = EntityClass<CM, I, QM> & {
     create: CreateEntityFunction<C, CM, I>;
     Pool: NoInfer<EntityPoolClass<C>>;
 };
@@ -96,11 +114,13 @@ declare type EntityCodeGenerationOptions = {
     skipSafetyChecks?: boolean;
 };
 
-export declare interface EntityConstructor<QM extends QueryMap<any, CM>, E extends EntityInstance<CM, I>, I extends any, CM extends ComponentMap> {
-    new (data: I, index?: number, pool?: EntityPoolClass<E>, updateQueryMemberships?: boolean): E;
+export declare interface EntityConstructor<QM extends QueryMap<CM>, E extends EntityInstance<CM, I>, I extends any, CM extends ComponentMap> {
+    new (data: I, poolIndex?: number, pool?: EntityPoolClass<E>, updateQueryMemberships?: boolean): E;
     componentMap: CM;
+    __lazyReferenceTarget?: E;
     __typescriptOnlyInputType: I;
-    pool: EntityPoolClass<E>;
+    pool: PoolCallable<E>;
+    queries: QueriesCallable<E, QM, CM>;
     componentsWithEntities: {
         [K in keyof CM as ExtractMonomorphClass<CM[K]> extends MonomorphClass<infer P, infer I, infer M> ? LowercaseFirstLetter<K> : never]: {
             [Symbol.iterator](): IterableIterator<[WithPool<InstanceType<ExtractMonomorphClass<CM[K]>>>, E]>;
@@ -109,24 +129,17 @@ export declare interface EntityConstructor<QM extends QueryMap<any, CM>, E exten
     components: {
         [K in keyof CM as ExtractMonomorphClass<CM[K]> extends MonomorphClass<infer P, infer I, infer M> ? LowercaseFirstLetter<K> : never]: PoolClass<ExtractMonomorphClass<CM[K]>>;
     };
-    queries: {
-        [K in keyof QM]: {
-            afterEntityAdded: {
-                addListener(listener: (entity: E) => void): void;
-                removeListener(listener: (entity: E) => void): void;
-            };
-            beforeEntityRemoved: {
-                addListener(listener: (entity: E) => void): void;
-                removeListener(listener: (entity: E) => void): void;
-            };
-            [Symbol.iterator](): IterableIterator<WithComponent<E, ElementOfArray<QM[K]['with']> extends LowercaseFirstLetter<keyof E["componentMap"]> ? ElementOfArray<QM[K]['with']> : never>>;
-        };
-    };
 }
 
+declare type EntityConstructorLike = abstract new (...args: any[]) => any;
+
+declare type EntityFor<CM extends ComponentMap> = EntityInstance<CM, any>;
+
 export declare type EntityInput<X extends ComponentMap | EntityClass<any, any, any, any> | EntityInstanceWithPool<any, any, any> | EntityInstance<any, any>> = Writeable<X extends ComponentMap ? ComponentMapInput<X> : X extends EntityConstructor<infer QM, infer E, infer I, infer CM> ? I : X extends EntityInstanceWithPool<infer CM, infer I, infer E> ? I : X extends EntityInstance<infer CM, infer I> ? I : never>;
 
-export declare type EntityInstance<CM extends ComponentMap, I extends any = ComponentMapInput<CM>> = ComponentMapClassProperties<CM> & EntityBaseProperties<CM, I>;
+declare type EntityInputListItems<E> = E extends ComponentMap ? ComponentMapInputListItems<E> : E extends EntityConstructor<any, any, any, infer CM> ? ComponentMapInputListItems<CM> : E extends EntityInstance<infer CM, any> ? ComponentMapInputListItems<CM> : E extends EntityInstanceWithPool<infer CM, any, any> ? ComponentMapInputListItems<CM> : EntityInput<NoInfer<E>>;
+
+export declare type EntityInstance<CM extends ComponentMap, I extends any = ComponentMapInput<CM>> = ComponentMapClassProperties<NoInfer<CM>> & EntityBaseProperties<CM, I>;
 
 export declare type EntityInstanceWithPool<CM extends ComponentMap, I extends ComponentMapInput<CM>, E> = NoInfer<E & {
     pool: EntityPoolClass<E> | null;
@@ -159,6 +172,65 @@ export declare interface EntityPoolClass<M> {
     fromArrayOnlyReferences(array: NumberArray, references?: any, startOffset?: number, classConstructor?: new (...args: any[]) => M): number;
 }
 
+declare type EntityPoolInput = {
+    array: unknown[];
+    freeIndices: number[];
+    maxLength: number;
+    length: number;
+    [Symbol.iterator](): IterableIterator<any>;
+    create?(data?: any): any;
+};
+
+declare type EntityQueries<E, QM extends QueryMap<CM>, CM extends ComponentMap> = E extends {
+    componentMap: any;
+} ? ({
+    [K in keyof QM]: {
+        afterEntityAdded: {
+            addListener(listener: BivariantCallback<WithComponent<E, ElementOfReadonlyArray<QM[K]['with']> extends LowercaseFirstLetter<keyof E["componentMap"]> ? ElementOfReadonlyArray<QM[K]['with']> : never>>): void;
+            removeListener(listener: BivariantCallback<E>): void;
+        };
+        beforeEntityRemoved: {
+            addListener(listener: BivariantCallback<WithComponent<E, ElementOfReadonlyArray<QM[K]['with']> extends LowercaseFirstLetter<keyof E["componentMap"]> ? ElementOfReadonlyArray<QM[K]['with']> : never>>): void;
+            removeListener(listener: BivariantCallback<E>): void;
+        };
+        [Symbol.iterator](): IterableIterator<WithComponent<E, ElementOfReadonlyArray<QM[K]['with']> extends LowercaseFirstLetter<keyof E["componentMap"]> ? ElementOfReadonlyArray<QM[K]['with']> : never>>;
+    };
+} & {
+    [key: string]: any;
+}) : never;
+
+declare const EntityRefBrand: unique symbol;
+
+export declare function EntityReference(fn: () => any): PropertyDefinitionReference<EntitySelfRef | null, true>;
+
+export declare function EntityReference<E>(fn: () => any): PropertyDefinitionReference<LazyEntityReferenceTarget<E> | null, true>;
+
+export declare function EntityReference<C extends EntityConstructorLike>(fn: () => C): PropertyDefinitionReference<LazyEntityReferenceTarget<C> | null, true>;
+
+export declare function EntityReferenceList(fn: () => any): PropertyDefinitionReferenceList<EntitySelfRef, EntitySelfRefListInput>;
+
+export declare function EntityReferenceList<E>(fn: () => any): PropertyDefinitionReferenceList<LazyEntityReferenceTarget<E>, EntitySelfRefListInput>;
+
+export declare function EntityReferenceList<C extends EntityConstructorLike>(fn: () => C): PropertyDefinitionReferenceList<LazyEntityReferenceTarget<C>, EntitySelfRefListInput>;
+
+export declare type EntityReferenceListInput<E> = EntityReferenceListInputBase<EntityInputListItems<NoInfer<E>>>;
+
+declare type EntityReferenceListInputBase<TItems = unknown> = {
+    pool: EntityPoolInput;
+    items?: TItems[];
+    maxLength?: number;
+};
+
+declare const EntityRefListBrand: unique symbol;
+
+declare type EntitySelfRef = {
+    [EntityRefBrand]?: true;
+};
+
+declare type EntitySelfRefListInput = {
+    [EntityRefListBrand]?: true;
+};
+
 export declare type ExtractMonomorphClass<CC> = CC extends {
     monomorphClass?: infer MC extends MonomorphClass<any, any, any>;
 } ? MC : CC extends ({
@@ -169,9 +241,20 @@ export declare type ExtractMonomorphClass<CC> = CC extends {
     fnInArray: [() => infer MC extends MonomorphClass<any, any, any>];
 } ? MC : CC;
 
-export declare function getEntityClassCode<C, CM extends ComponentMap>(componentMap: CM, queries?: QueryMap<C, CM>, options?: EntityCodeGenerationOptions): string;
+export declare function getEntityClassCode<C, CM extends ComponentMap>(componentMap: CM, queries?: QueryMap<CM>, options?: EntityCodeGenerationOptions): string;
+
+export declare function LazyComponent<CT = undefined, MC extends MonomorphClass<any, any, any> = MonomorphClass<any, any, any>>(componentFn: () => MC): LazyComponentWrapper<MC, CT>;
+
+declare type LazyComponentResolvedType<MC extends MonomorphClass<any, any, any>, CT> = CT extends undefined ? ComponentTypeFromMonomorphClass<MC> : CT;
+
+declare type LazyComponentWrapper<MC extends MonomorphClass<any, any, any>, CT> = {
+    fnInArray: [() => MC];
+    componentType: Writeable<LazyComponentResolvedType<MC, CT>>;
+};
 
-export declare function LazyComponent<F extends () => T, T>(componentFn: F): LazyWrapper<ReturnType<F>>;
+export declare type LazyEntityReferenceTarget<T> = {
+    __lazyReferenceTarget?: NoInfer<T>;
+};
 
 export declare type LazyMonomorphComponentConfig<MC extends MonomorphClass<any, any, any>> = ComponentConfig<LazyWrapper<MC>, InputType<InstanceType<MC>>>;
 
@@ -185,21 +268,53 @@ export declare type MonomorphComponentConfig<MC extends MonomorphClass<any, any,
 
 declare type OriginalComponentKey<CCK extends LowercaseFirstLetter<keyof CM>, CM extends ComponentMap> = CCK extends keyof CM ? CCK : UppercaseFirstLetter<CCK>;
 
-export declare type QueryConfig<C, CM extends ComponentMap> = {
-    with?: LowercaseFirstLetter<keyof CM>[];
-    without?: LowercaseFirstLetter<keyof CM>[];
-    afterEntityAdded?: (entity: C) => void;
-    beforeEntityRemoved?: (entity: C) => void;
+declare type PoolCallable<E> = EntityPoolClass<E> & {
+    <Self extends abstract new (...args: any) => any>(this: Self): EntityPoolClass<InstanceType<Self>>;
+};
+
+declare type QueriesCallable<E, QM extends QueryMap<CM>, CM extends ComponentMap> = EntityQueries<E, QM, CM> & {
+    <Self extends abstract new (...args: any) => any>(this: Self): EntityQueries<InstanceType<Self>, QM, CM>;
 };
 
-export declare type QueryMap<C, CM extends ComponentMap> = Record<string, QueryConfig<C, CM>>;
+export declare type QueryConfig<CM extends ComponentMap> = {
+    with?: ReadonlyArray<LowercaseFirstLetter<keyof CM>>;
+    without?: ReadonlyArray<LowercaseFirstLetter<keyof CM>>;
+    afterEntityAdded?: (entity: EntityInstance<CM>) => void;
+    beforeEntityRemoved?: (entity: EntityInstance<CM>) => void;
+};
+
+export declare type QueryMap<CM extends ComponentMap> = Record<string, QueryConfig<CM>>;
+
+declare type ResolveEntityInput<T, CM extends ComponentMap> = T extends object ? {
+    [K in keyof T]: ResolveEntityInputValue<T[K], CM>;
+} : ResolveEntityInputValue<T, CM>;
+
+declare type ResolveEntityInputListItems<T, CM extends ComponentMap> = T extends object ? {
+    [K in keyof T]: ResolveEntityInputValueListItems<T[K], CM>;
+} : ResolveEntityInputValueListItems<T, CM>;
+
+declare type ResolveEntityInputValue<T, CM extends ComponentMap> = T extends any ? (UnwrapLazyEntityReferenceTarget<T> extends EntitySelfRef ? EntityFor<CM> : UnwrapLazyEntityReferenceTarget<T> extends EntitySelfRefListInput ? EntityReferenceListInput<EntityFor<CM>> : UnwrapEntityTarget<T> extends ReferenceListClass<infer M> ? EntityReferenceListInput<UnwrapEntityTarget<M>> : UnwrapEntityTarget<T>) : never;
+
+declare type ResolveEntityInputValueListItems<T, CM extends ComponentMap> = T extends any ? (UnwrapLazyEntityReferenceTarget<T> extends EntitySelfRef ? EntityFor<CM> : UnwrapLazyEntityReferenceTarget<T> extends EntitySelfRefListInput ? EntityReferenceListInputBase : T extends EntityReferenceListInputBase<any> ? EntityReferenceListInputBase : UnwrapEntityTarget<T> extends ReferenceListClass<any> ? EntityReferenceListInputBase : UnwrapEntityTarget<T>) : never;
+
+declare type ResolveEntityRefs<T, CM extends ComponentMap> = T extends object ? {
+    [K in keyof T]: ResolveEntityRefValue<T[K], CM>;
+} : ResolveEntityRefValue<T, CM>;
+
+declare type ResolveEntityRefValue<T, CM extends ComponentMap> = [
+T
+] extends [any] ? (UnwrapLazyEntityReferenceTarget<T> extends EntitySelfRef ? EntityFor<CM> : T extends ReferenceListClass<infer M> ? (UnwrapLazyEntityReferenceTarget<M> extends EntitySelfRef ? ReferenceListClass<EntityFor<CM>> : ReferenceListClass<UnwrapEntityTarget<M>>) : UnwrapEntityTarget<T>) : never;
+
+declare type UnwrapEntityTarget<T> = UnwrapLazyEntityReferenceTarget<T> extends EntityConstructor<any, infer E, any, any> ? E : UnwrapLazyEntityReferenceTarget<T> extends EntityConstructor<any, any, any, any> ? InstanceType<UnwrapLazyEntityReferenceTarget<T>> : UnwrapLazyEntityReferenceTarget<T>;
+
+declare type UnwrapLazyEntityReferenceTarget<T> = T extends LazyEntityReferenceTarget<infer U> ? U : T;
 
 declare type UppercaseFirstLetter<S> = S extends `${infer FirstLetter}${infer Rest}` ? `${Uppercase<FirstLetter>}${Rest}` : S;
 
 export declare type WithComponent<C extends {
     componentMap: any;
-}, KCM extends LowercaseFirstLetter<keyof C['componentMap']>> = Writeable<Omit<C, KCM> & {
-    [K in KCM as LowercaseFirstLetter<K>]-?: Exclude<C[K extends keyof C ? K : never], undefined | null>;
+}, KCM extends LowercaseFirstLetter<keyof C['componentMap']>> = Writeable<C & {
+    [K in KCM]-?: NonNullable<C[K extends keyof C ? K : never]>;
 }>;
 
 declare type Writeable<T> = {

package/build/mecs.js

@@ -1,5 +1,43 @@
+// @__NO_SIDE_EFFECTS__
+function LazyReferenceType(fn, readOnly) {
+  return {
+    monomorph: {
+      serializedSize: 2,
+      fnInArray: [fn],
+      theClass: null
+    },
+    propertyType: 4,
+    optional: true,
+    defaultValue: null,
+    readOnly
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function LazyReferenceListType(fn, readOnly) {
+  return {
+    monomorph: {
+      serializedSize: 2,
+      // @ts-ignore
+      fnInArray: [fn],
+      theClass: null
+    },
+    propertyType: 7,
+    optional: true,
+    defaultValue: void 0,
+    readOnly
+  };
+}
 function LazyComponent(componentFn) {
-  return { fnInArray: [componentFn] };
+  return {
+    fnInArray: [componentFn],
+    componentType: void 0
+  };
+}
+function EntityReference(fn) {
+  return /* @__PURE__ */ LazyReferenceType(fn ?? (() => null));
+}
+function EntityReferenceList(fn) {
+  return /* @__PURE__ */ LazyReferenceListType(fn ?? (() => null));
 }
 function lowercaseFirstLetter(str) {
   return str.charAt(0).toLowerCase() + str.slice(1);
@@ -182,7 +220,7 @@ function getEntityClassCode(componentMap, queries, options) {
             return {
               next() {
                 ${""}
-                while (index < (${componentKey}Pool.length + ${componentKey}Pool.freeIndices.length) && (!${componentKey}PoolArray[index] || (${componentKey}PoolArray[index].version & 1) === 1)) {
+                while (index < (${componentKey}Pool.length + ${componentKey}Pool.freeIndices.length) && (!${componentKey}PoolArray[index] || (${componentKey}PoolArray[index].poolVersion & 1) === 1)) {
                   index++;
                 }
 
@@ -208,7 +246,7 @@ function getEntityClassCode(componentMap, queries, options) {
         (data, entity, componentKey, updateQueryMemberships) => {
           entity.componentFlags |= ${componentFlagValue}n;
           entity.${componentKey} = ${resolvedMonomorphClass}.create(${processedDataCode}, ${componentKey}Pool);
-          ${componentKey}ComponentToEntity[entity.${componentKey}.index] = entity;
+          ${componentKey}ComponentToEntity[entity.${componentKey}.poolIndex] = entity;
 
           ${afterComponentAddedCode}
 
@@ -225,7 +263,7 @@ function getEntityClassCode(componentMap, queries, options) {
 
           ${beforeComponentRemovedCode}
 
-          ${componentKey}ComponentToEntity[instance.index] = null;
+          ${componentKey}ComponentToEntity[instance.poolIndex] = null;
           instance.destroy();
 
           ${""}
@@ -323,12 +361,8 @@ function getEntityClassCode(componentMap, queries, options) {
       }
     }
     queryListenerCode += `
-      const queryEntityAddedListeners${queryIndex} = [
-        ${queryConfig.afterEntityAdded ? "queryMap." + queryName + ".afterEntityAdded" : ""}
-      ];
-      const queryEntityRemovedListeners${queryIndex} = [
-        ${queryConfig.beforeEntityRemoved ? "queryMap." + queryName + ".beforeEntityRemoved" : ""}
-      ];
+      const queryEntityAddedListeners${queryIndex} = [];
+      const queryEntityRemovedListeners${queryIndex} = [];
 
       function afterEntityAdded${queryIndex} (entity) {
         for (const listener of queryEntityAddedListeners${queryIndex}) {
@@ -499,7 +533,7 @@ function getEntityClassCode(componentMap, queries, options) {
       return {
         next() {
           ${""}
-          while (index < (pool.length + pool.freeIndices.length) && (!array[index] || (array[index].version & 1) === 1)) {
+          while (index < (pool.length + pool.freeIndices.length) && (!array[index] || (array[index].poolVersion & 1) === 1)) {
             index++;
           }
 
@@ -544,7 +578,7 @@ function getEntityClassCode(componentMap, queries, options) {
           poolItem = poolArray[arrayOfIndices[index]];
 
           ${""}
-          while (index < arrayOfIndices.length && (((poolItem.version & 1) === 1) || poolItem.version !== arrayOfVersions[index])) {
+          while (index < arrayOfIndices.length && (((poolItem.poolVersion & 1) === 1) || poolItem.poolVersion !== arrayOfVersions[index])) {
             if (fixDestroyed) {
               if (index < arrayOfIndices.length - 1) {
                 arrayOfIndices[index] = arrayOfIndices[arrayOfIndices.length - 1];
@@ -576,9 +610,9 @@ function getEntityClassCode(componentMap, queries, options) {
     }
 
     const theClass = class {
-      constructor(data, index = 0, updateQueryMemberships = true, pool = this.constructor.pool) {
-        this.index = index;
-        this.version = 0; ${""}
+      constructor(data, poolIndex = 0, updateQueryMemberships = true, pool = this.constructor.pool) {
+        this.poolIndex = poolIndex;
+        this.poolVersion = 0; ${""}
         this.pool = pool;
         this.queryIndices = new Array(${queryIndex}).fill(-1);
         this.componentFlags = 0n; ${""}
@@ -637,14 +671,14 @@ function getEntityClassCode(componentMap, queries, options) {
 
       destroy(updateQueryMemberships = true) {
         ${destroyCode}
-        if (this.version & 1 === 1) {
+        if (this.poolVersion & 1 === 1) {
           ${""}
           return;
         }
-        this.version++; // becomes odd, meaning deleted
+        this.poolVersion++; // becomes odd, meaning deleted
         if (this.pool) {
           this.pool.length--;
-          this.pool.freeIndices.push(this.index);
+          this.pool.freeIndices.push(this.poolIndex);
         }
       }
 
@@ -691,8 +725,8 @@ function getEntityClassCode(componentMap, queries, options) {
                 throw new Error("Could not add instance to reference list, instance does not belong to the same pool as the reference list");
               }
               const length = this.length;
-              this.arrayOfIndices[length] = instance.index;
-              this.arrayOfVersions[length] = instance.version;
+              this.arrayOfIndices[length] = instance.poolIndex;
+              this.arrayOfVersions[length] = instance.poolVersion;
               return length;
             }
 
@@ -703,7 +737,7 @@ function getEntityClassCode(componentMap, queries, options) {
               let poolItem = this.pool.array[this.arrayOfIndices[index]];
 
               if (fixDestroyed) {
-                while (index < this.arrayOfIndices.length && ((poolItem.version & 1) === 1 || poolItem.version !== this.arrayOfVersions[index])) {
+                while (index < this.arrayOfIndices.length && ((poolItem.poolVersion & 1) === 1 || poolItem.poolVersion !== this.arrayOfVersions[index])) {
                   if (index < this.arrayOfIndices.length - 1) {
                     this.arrayOfIndices[index] = this.arrayOfIndices[this.arrayOfIndices.length - 1];
                     this.arrayOfVersions[index] = this.arrayOfVersions[this.arrayOfVersions.length - 1];
@@ -717,7 +751,7 @@ function getEntityClassCode(componentMap, queries, options) {
                     return null;
                   }
                 }
-              } else if ((poolItem.version & 1) === 1 || poolItem.version !== this.arrayOfVersions[index]) {
+              } else if ((poolItem.poolVersion & 1) === 1 || poolItem.poolVersion !== this.arrayOfVersions[index]) {
                 return null;
               }
 
@@ -726,7 +760,7 @@ function getEntityClassCode(componentMap, queries, options) {
 
             remove(instance) {
               for (let i = 0; i < this.arrayOfIndices.length; i++) {
-                if (this.arrayOfIndices[i] === instance.index && this.arrayOfVersions[i] === instance.version) {
+                if (this.arrayOfIndices[i] === instance.poolIndex && this.arrayOfVersions[i] === instance.poolVersion) {
                   if (i < this.arrayOfIndices.length - 1) {
                     this.arrayOfIndices[i] = this.arrayOfIndices[this.arrayOfIndices.length - 1];
                     this.arrayOfVersions[i] = this.arrayOfVersions[this.arrayOfVersions.length - 1];
@@ -757,8 +791,8 @@ function getEntityClassCode(componentMap, queries, options) {
             create(data) {
               const instance = this.classConstructor.create(data, this.pool);
               const length = this.length;
-              this.arrayOfIndices[length] = instance.index;
-              this.arrayOfVersions[length] = instance.version;
+              this.arrayOfIndices[length] = instance.poolIndex;
+              this.arrayOfVersions[length] = instance.poolVersion;
               return instance;
             }
 
@@ -784,7 +818,23 @@ function getEntityClassCode(componentMap, queries, options) {
         if (!this.dynamicPoolInstance) {
           this.dynamicPoolInstance = new this.Pool();
         }
-        return this.dynamicPoolInstance;
+        if (!this.dynamicPoolCallable) {
+          const poolInstance = this.dynamicPoolInstance;
+          const callable = new Proxy(function () { return poolInstance; }, {
+            get(_target, prop) {
+              if (prop in poolInstance) {
+                return poolInstance[prop];
+              }
+              return undefined;
+            },
+            set(_target, prop, value) {
+              poolInstance[prop] = value;
+              return true;
+            },
+          });
+          this.dynamicPoolCallable = callable;
+        }
+        return this.dynamicPoolCallable;
       }
 
       static get Pool() {
@@ -829,8 +879,8 @@ function getEntityClassCode(componentMap, queries, options) {
                   array[offset++] = -1;
                   continue;
                 }
-                array[offset++] = instance.version;
-                if (instance.version & 1) {${""}
+                array[offset++] = instance.poolVersion;
+                if (instance.poolVersion & 1) {${""}
                   continue;
                 }
                 offset = instance.toArray(array, offset, skipPoolReferences);
@@ -857,11 +907,11 @@ function getEntityClassCode(componentMap, queries, options) {
 
 
               for (let i = 0; i < usedLength; i++) {
-                const version = arrayOfData[offset++];
+                const poolVersion = arrayOfData[offset++];
 
-                if (version & 1) {
+                if (poolVersion & 1) {
                   if (this.array[i]) {
-                    this.array[i].version = version;
+                    this.array[i].poolVersion = poolVersion;
                   }
                   continue;
                 }
@@ -872,7 +922,7 @@ function getEntityClassCode(componentMap, queries, options) {
                   this.array[i] = new classConstructor(undefined, i, this);
                 }
 
-                this.array[i].version = version;
+                this.array[i].poolVersion = poolVersion;
 
                 offset = this.array[i].fromArray(arrayOfData, references, offset);
               }
@@ -897,11 +947,11 @@ function getEntityClassCode(componentMap, queries, options) {
               }
 
               for (let i = 0; i < usedLength; i++) {
-                const version = arrayOfData[offset++];
+                const poolVersion = arrayOfData[offset++];
 
-                if (version & 1) {
+                if (poolVersion & 1) {
                   if (this.array[i]) {
-                    this.array[i].version = version;
+                    this.array[i].poolVersion = poolVersion;
                   }
                   continue;
                 }
@@ -912,7 +962,7 @@ function getEntityClassCode(componentMap, queries, options) {
                   this.array[i] = new classConstructor(undefined, i, this);
                 }
 
-                this.array[i].version = version;
+                this.array[i].poolVersion = poolVersion;
 
                 offset = this.array[i].fromArrayNoReferences(arrayOfData, offset);
               }
@@ -937,11 +987,11 @@ function getEntityClassCode(componentMap, queries, options) {
               }
 
               for (let i = 0; i < usedLength; i++) {
-                const version = arrayOfData[offset++];
+                const poolVersion = arrayOfData[offset++];
 
-                if (version & 1) {
+                if (poolVersion & 1) {
                   if (this.array[i]) {
-                    this.array[i].version = version;
+                    this.array[i].poolVersion = poolVersion;
                   }
                   continue;
                 }
@@ -952,7 +1002,7 @@ function getEntityClassCode(componentMap, queries, options) {
                   this.array[i] = new classConstructor(undefined, i, this);
                 }
 
-                this.array[i].version = version;
+                this.array[i].poolVersion = poolVersion;
 
                 offset = this.array[i].fromArrayOnlyReferences(arrayOfData, references, offset);
               }
@@ -967,7 +1017,19 @@ function getEntityClassCode(componentMap, queries, options) {
 
     }
 
-    theClass.queries = queries;
+    const queriesCallable = new Proxy(function () { return queriesCallable; }, {
+      get(_target, prop) {
+        if (prop in queries) {
+          return queries[prop];
+        }
+        return undefined;
+      },
+      set(_target, prop, value) {
+        queries[prop] = value;
+        return true;
+      },
+    });
+    theClass.queries = queriesCallable;
     theClass.componentToEntity = componentToEntity;
     theClass.componentIndices = componentIndices;
     theClass.components = componentPools;
@@ -980,7 +1042,7 @@ function getEntityClassCode(componentMap, queries, options) {
         const index = pool.freeIndices.pop();
         pool.length++;
         const instance = pool.array[index];
-        instance.version++; ${""}
+        instance.poolVersion++; ${""}
         instance.reset(data, updateQueryMemberships, pool);
         return instance;
       } else {
@@ -993,12 +1055,12 @@ function getEntityClassCode(componentMap, queries, options) {
 
     theClass.Reference = class {
       constructor(reference) {
-        if (reference && !(reference.version & 1)) {
+        if (reference && !(reference.poolVersion & 1)) {
           this.reference = reference;
-          this.version = reference.version;
+          this.poolVersion = reference.poolVersion;
         } else {
           this.reference = null;
-          this.version = -1;
+          this.poolVersion = -1;
         }
       }
     }
@@ -1014,6 +1076,8 @@ function createEntityClass(options) {
   return (componentMap, queries) => new Function("componentMap", "queryMap", getEntityClassCode(componentMap, queries, options))(componentMap, queries);
 }
 export {
+  EntityReference,
+  EntityReferenceList,
   LazyComponent,
   createEntityClass,
   getEntityClassCode

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@perplexdotgg/mecs",
-  "version": "0.4.2",
+  "version": "0.5.0",
   "description": "MECS - Monomorph ECS - A high-performance Entity Component System for TypeScript and JavaScript projects, designed for games and simulations.",
   "repository": {
     "type": "git",
@@ -28,7 +28,7 @@
     "bench": "vitest bench"
   },
   "peerDependencies": {
-    "monomorph": "^1.5.6"
+    "monomorph": "^2.1.0"
   },
   "peerDependenciesMeta": {
     "monomorph": {
@@ -37,7 +37,7 @@
   },
   "devDependencies": {
     "@types/node": "^25.0.1",
-    "monomorph": "^1.5.6",
+    "monomorph": "^2.1.0",
     "ts-node": "^10.9.2",
     "tslib": "^2.8.1",
     "typescript": "^5.9.3",