@daneren2005/shared-memory-ecs 1.5.1 → 1.7.0

package/dist/systems/{component-system.d.ts → entity-worker-system.d.ts}

@@ -4,11 +4,11 @@ import type BaseEntity from '../entity';
 import type { BaseComponent, ComponentDefinitionMap, ComponentMap } from '../component-definition';
 import type { ComponentTypedArray } from '../memory-component';
 import System, { type SystemConfig } from './system';
-import ComponentWebWorker from './workers/component-web-worker';
-export default abstract class ComponentSystem<C extends ComponentMap, T extends EntityUpdateComponents<C>, W extends ComponentSystemWorld = ComponentSystemWorld, D = unknown> extends System<C> {
+import EntitySystemWebWorker from './workers/entity-system-web-worker';
+export default abstract class EntityWorkerSystem<C extends ComponentMap, T extends EntityUpdateComponents<C>, W extends EntityWorkerSystemWorld = EntityWorkerSystemWorld, D = unknown> extends System<C> {
     entities: Map<number, BaseEntity<C>>;
-    options: ComponentSystemConfig<C, T, W, D>;
-    worker: Worker | ComponentWebWorker<C, T, W, D>;
+    options: EntityWorkerSystemConfig<C, T, W, D>;
+    worker: Worker | EntitySystemWebWorker<C, T, W, D>;
     isWorkerThread: boolean;
     private initialized;
     private initPromise;
@@ -16,10 +16,12 @@ export default abstract class ComponentSystem<C extends ComponentMap, T extends
     private runCompletePromise;
     private isRunning;
     private generation;
-    private queryEntities;
+    protected queryEntities: {
+        [key: string]: Map<number, BaseEntity<C>>;
+    };
     private queryDeltas;
     addDataToWorld?(world: W): void;
-    constructor(world: BaseWorld<ComponentDefinitionMap, C>, options: ComponentSystemConfig<C, T, W, D>);
+    constructor(world: BaseWorld<ComponentDefinitionMap, C>, options: EntityWorkerSystemConfig<C, T, W, D>);
     private initWorker;
     init(): Promise<void> | void;
     finishLoading(): Promise<void>;
@@ -32,11 +34,11 @@ export default abstract class ComponentSystem<C extends ComponentMap, T extends
     private buildQueryDelta;
     private buildComponents;
     isEntityInSystem(entity: BaseEntity<C>): boolean;
-    private matchesQuery;
+    protected matchesQuery(entity: BaseEntity<C>, query: EntityWorkerSystemQuery<C>): boolean;
     private getQueryDelta;
     private markAdded;
     private markRemoved;
-    private updateEntityList;
+    protected updateEntityList(queryName: string, list: Map<number, BaseEntity<C>>, entity: BaseEntity<C>, shouldInclude: boolean): void;
     checkAddEntity(entity: BaseEntity<C>): boolean;
     removeEntity(entity: BaseEntity<C>): void;
     recheckMembership(): void;
@@ -52,15 +54,15 @@ export type EntityQueryComponents<C extends ComponentMap = ComponentMap> = {
         components: EntityUpdateComponents<C>;
     }>;
 };
-type EntityUpdateFunctionImpl<C extends ComponentMap, T extends EntityUpdateComponents<C>, W extends ComponentSystemWorld = ComponentSystemWorld> = (world: W, entityId: number, components: T, queries: EntityQueryComponents<C>, callbacks: ComponentSystemCallbacks<C>) => void;
-export type EntityUpdateFunction<C extends ComponentMap, T extends EntityUpdateComponents<C>, W extends ComponentSystemWorld = ComponentSystemWorld, D = unknown> = EntityUpdateFunctionImpl<C, T, W> & {
+type EntityUpdateFunctionImpl<C extends ComponentMap, T extends EntityUpdateComponents<C>, W extends EntityWorkerSystemWorld = EntityWorkerSystemWorld> = (world: W, entityId: number, components: T, queries: EntityQueryComponents<C>, callbacks: EntityWorkerSystemCallbacks<C>) => void;
+export type EntityUpdateFunction<C extends ComponentMap, T extends EntityUpdateComponents<C>, W extends EntityWorkerSystemWorld = EntityWorkerSystemWorld, D = unknown> = EntityUpdateFunctionImpl<C, T, W> & {
     preRun?: EntityUpdatePreRunFunction<C, T, W>;
     entityRemoved?: EntityRemovedFunction<C, W>;
     init?: EntityUpdateInitFunction<W, D>;
 };
-export type EntityUpdateInitFunction<W extends ComponentSystemWorld = ComponentSystemWorld, D = unknown> = (data: D | undefined) => Partial<W> | void;
-export type EntityUpdatePreRunFunction<C extends ComponentMap, T extends EntityUpdateComponents<C>, W extends ComponentSystemWorld = ComponentSystemWorld> = (world: W, entities: Array<UpdateEntityConfigObject<T>>, queries: EntityQueryComponents<C>, callbacks: ComponentSystemCallbacks<C>) => void;
-export type EntityRemovedFunction<C extends ComponentMap = ComponentMap, W extends ComponentSystemWorld = ComponentSystemWorld> = (world: W, entityId: number, callbacks: ComponentSystemCallbacks<C>) => void;
+export type EntityUpdateInitFunction<W extends EntityWorkerSystemWorld = EntityWorkerSystemWorld, D = unknown> = (data: D | undefined) => Partial<W> | void;
+export type EntityUpdatePreRunFunction<C extends ComponentMap, T extends EntityUpdateComponents<C>, W extends EntityWorkerSystemWorld = EntityWorkerSystemWorld> = (world: W, entities: Array<UpdateEntityConfigObject<T>>, queries: EntityQueryComponents<C>, callbacks: EntityWorkerSystemCallbacks<C>) => void;
+export type EntityRemovedFunction<C extends ComponentMap = ComponentMap, W extends EntityWorkerSystemWorld = EntityWorkerSystemWorld> = (world: W, entityId: number, callbacks: EntityWorkerSystemCallbacks<C>) => void;
 export type UpdateEntityConfig<T extends EntityUpdateComponents = EntityUpdateComponents> = number | UpdateEntityConfigObject<T>;
 export type UpdateEntityConfigObject<T extends EntityUpdateComponents> = {
     entityId: number;
@@ -74,48 +76,67 @@ export interface WorkerAllocator {
     allocateEid(): number;
     allocateComponentBlock(name: string, values: Array<number>): number;
 }
-export interface ComponentSystemWorld {
+export interface EntityWorkerSystemWorld {
     gameTime: number;
     elapsedTime: number;
     getString(pointer: number): string;
     heap?: MemoryHeap;
     allocate?: WorkerAllocator;
     buildEntityDescriptor?(config: WorkerCreateEntityConfig): WorkerCreatedEntity;
+    buildComponentDescriptor?(name: string, config: Record<string, unknown>): WorkerCreatedComponent;
 }
 export type WorkerCreateEntityConfig = {
     type: string;
+    class?: never;
 } & {
     [key: string]: unknown;
 };
 export interface WorkerCreatedEntity {
     eid: number;
     type: string;
+    class?: string;
     isStatic?: boolean;
     components: {
         [name: string]: number;
     };
 }
-export interface ComponentSystemCallbacks<C extends ComponentMap = ComponentMap> {
+export interface WorkerCreatedComponent {
+    name: string;
+    index: number;
+}
+export type WorkerComponentChange = {
+    type: 'add';
+    entityId: number;
+    component: WorkerCreatedComponent;
+} | {
+    type: 'remove';
+    entityId: number;
+    componentName: string;
+};
+export interface EntityWorkerSystemCallbacks<C extends ComponentMap = ComponentMap> {
     entityComponentChanged<K extends keyof C, P extends keyof C[K]>(entityId: number, componentName: K, prop: P, value: C[K][P]): void;
     emitEntityEvent(entityId: number, event: string, ...args: Array<unknown>): void;
     emitSystemEvent(event: string, entityId: number): void;
     entityDied(entityId: number): void;
     createEntity(entity: WorkerCreatedEntity): void;
+    addComponent(entityId: number, component: WorkerCreatedComponent): void;
+    removeComponent<K extends keyof C>(entityId: number, componentName: K): void;
 }
-export interface ComponentSystemQuery<C extends ComponentMap = ComponentMap> {
+export interface EntityWorkerSystemQuery<C extends ComponentMap = ComponentMap> {
     required: Array<keyof C>;
     optional?: Array<keyof C>;
     not?: Array<keyof C>;
     filter?: (entity: BaseEntity<C>) => boolean;
 }
-export interface ComponentSystemConfig<C extends ComponentMap, T extends EntityUpdateComponents<C>, W extends ComponentSystemWorld = ComponentSystemWorld, D = unknown> extends SystemConfig, ComponentSystemQuery<C> {
+export interface EntityWorkerSystemConfig<C extends ComponentMap, T extends EntityUpdateComponents<C>, W extends EntityWorkerSystemWorld = EntityWorkerSystemWorld, D = unknown> extends SystemConfig, EntityWorkerSystemQuery<C> {
     updateFunction: EntityUpdateFunction<C, T, W, D>;
     getWorker: () => Worker;
     forceMainThread?: boolean;
     getInitData?: () => D;
     createsEntities?: boolean;
+    addsComponents?: boolean;
     queries?: {
-        [key: string]: ComponentSystemQuery<C>;
+        [key: string]: EntityWorkerSystemQuery<C>;
     };
 }
 export type { BaseComponent };

package/dist/systems/system.d.ts

@@ -28,7 +28,7 @@ export interface SystemConfig {
     deltaBetweenRuns?: number;
     firstRun?: boolean;
 }
-export type SystemErrorPhase = 'preRun' | 'update' | 'entityRemoved' | 'run';
+export type SystemErrorPhase = 'preRun' | 'update' | 'entityRemoved' | 'run' | 'died';
 export interface SystemError {
     system: string;
     error: Error;

package/dist/systems/worker-system.d.ts

@@ -0,0 +1,22 @@
+import type BaseWorld from '../world';
+import type BaseEntity from '../entity';
+import type { ComponentDefinitionMap, ComponentMap } from '../component-definition';
+import type { SystemConfig } from './system';
+import EntityWorkerSystem, { type EntityWorkerSystemQuery, type EntityWorkerSystemWorld, type EntityUpdateComponents } from './entity-worker-system';
+import { type WorkerSystemRunFunction } from './workers/create-system-worker';
+export default class WorkerSystem<C extends ComponentMap, W extends EntityWorkerSystemWorld = EntityWorkerSystemWorld, D = unknown> extends EntityWorkerSystem<C, EntityUpdateComponents<C>, W, D> {
+    constructor(world: BaseWorld<ComponentDefinitionMap, C>, options: WorkerSystemConfig<C, W, D>);
+    checkAddEntity(entity: BaseEntity<C>): boolean;
+    shouldRun(): boolean;
+}
+export interface WorkerSystemConfig<C extends ComponentMap, W extends EntityWorkerSystemWorld = EntityWorkerSystemWorld, D = unknown> extends SystemConfig {
+    updateFunction: WorkerSystemRunFunction<C, W, D>;
+    getWorker: () => Worker;
+    forceMainThread?: boolean;
+    getInitData?: () => D;
+    createsEntities?: boolean;
+    queries?: {
+        [key: string]: EntityWorkerSystemQuery<C>;
+    };
+}
+export type { WorkerSystemRunFunction };

package/dist/systems/workers/apply-query-delta.d.ts

@@ -1,2 +1,2 @@
-import type { EntityUpdateComponents, QueryDelta, UpdateEntityConfigObject } from '../component-system';
+import type { EntityUpdateComponents, QueryDelta, UpdateEntityConfigObject } from '../entity-worker-system';
 export declare function applyQueryDelta<T extends EntityUpdateComponents>(list: Array<UpdateEntityConfigObject<T>>, delta: QueryDelta<T>): Array<UpdateEntityConfigObject<T>>;

package/dist/systems/workers/create-entity-system-worker.d.ts

@@ -0,0 +1,8 @@
+import type EntitySystemWorkerMessage from './entity-system-worker-message';
+import type { ComponentDefinitionMap, ComponentMap } from '../../component-definition';
+import type { EntityWorkerSystemWorld, EntityUpdateComponents, EntityUpdateFunction } from '../entity-worker-system';
+export interface EntitySystemWorkerScope {
+    onmessage: ((e: MessageEvent) => void) | null;
+    postMessage(message: EntitySystemWorkerMessage): void;
+}
+export default function createEntitySystemWorker<C extends ComponentMap, T extends EntityUpdateComponents<C>, W extends EntityWorkerSystemWorld = EntityWorkerSystemWorld, D = unknown>(scope: EntitySystemWorkerScope, updateFunction: EntityUpdateFunction<C, T, W, D>, definitions?: ComponentDefinitionMap): void;

package/dist/systems/workers/create-system-worker.d.ts

@@ -0,0 +1,9 @@
+import { type EntitySystemWorkerScope } from './create-entity-system-worker';
+import type { ComponentDefinitionMap, ComponentMap } from '../../component-definition';
+import type { EntityWorkerSystemCallbacks, EntityWorkerSystemWorld, EntityQueryComponents, EntityUpdateComponents, EntityUpdateFunction, EntityUpdateInitFunction, EntityRemovedFunction } from '../entity-worker-system';
+export type WorkerSystemRunFunction<C extends ComponentMap, W extends EntityWorkerSystemWorld = EntityWorkerSystemWorld, D = unknown> = ((world: W, queries: EntityQueryComponents<C>, callbacks: EntityWorkerSystemCallbacks<C>) => void) & {
+    init?: EntityUpdateInitFunction<W, D>;
+    entityRemoved?: EntityRemovedFunction<C, W>;
+};
+export declare function toEntityUpdateFunction<C extends ComponentMap, W extends EntityWorkerSystemWorld = EntityWorkerSystemWorld, D = unknown>(run: WorkerSystemRunFunction<C, W, D>): EntityUpdateFunction<C, EntityUpdateComponents<C>, W, D>;
+export default function createSystemWorker<C extends ComponentMap, W extends EntityWorkerSystemWorld = EntityWorkerSystemWorld, D = unknown>(scope: EntitySystemWorkerScope, runFunction: WorkerSystemRunFunction<C, W, D>, definitions?: ComponentDefinitionMap): void;

package/dist/systems/workers/entity-system-web-worker.d.ts

@@ -0,0 +1,18 @@
+import WebWorker from './web-worker';
+import type EntitySystemWorkerMessage from './entity-system-worker-message';
+import type BaseWorld from '../../world';
+import type { ComponentDefinitionMap, ComponentMap } from '../../component-definition';
+import type { EntityWorkerSystemWorld, EntityUpdateComponents, EntityUpdateFunction } from '../entity-worker-system';
+export default class EntitySystemWebWorker<C extends ComponentMap, T extends EntityUpdateComponents<C>, W extends EntityWorkerSystemWorld = EntityWorkerSystemWorld, D = unknown> extends WebWorker {
+    private updateFunction;
+    private entities;
+    private queryEntities;
+    private worldExtension;
+    private world;
+    private allocator;
+    private createsEntities;
+    private addsComponents;
+    constructor(updateFunction: EntityUpdateFunction<C, T, W, D>, world: BaseWorld<ComponentDefinitionMap, C>, createsEntities?: boolean, addsComponents?: boolean);
+    postMessage(message: EntitySystemWorkerMessage<W, D>): void;
+    onMessageTyped(message: EntitySystemWorkerMessage<W, D>): void;
+}

package/dist/systems/workers/{component-worker-message.d.ts → entity-system-worker-message.d.ts}

@@ -1,6 +1,7 @@
 import type { MemoryHeapMemory, GrowBufferData } from '@daneren2005/shared-memory-objects/memory-heap';
 import type { WorldSharedMemory } from '../../world';
-import type { ComponentSystemWorld, QueryDelta, WorkerCreatedEntity } from '../component-system';
+import type { EntityWorkerSystemWorld, QueryDelta, WorkerComponentChange, WorkerCreatedEntity } from '../entity-worker-system';
+import type { WorkerEntityClassRegistry } from '../../entity-class';
 interface InitMessage {
     type: 'init';
 }
@@ -15,6 +16,8 @@ interface LoadMessage<D = unknown> {
     factoryConfigs?: {
         [type: string]: Record<string, unknown>;
     };
+    factoryClasses?: WorkerEntityClassRegistry;
+    addsComponents?: boolean;
 }
 interface GrowBufferMessage {
     type: 'grow-buffer';
@@ -30,7 +33,7 @@ interface LoadedMessage {
 interface ResetMessage {
     type: 'reset';
 }
-interface RunUpdateMessage<W extends ComponentSystemWorld = ComponentSystemWorld> {
+interface RunUpdateMessage<W extends EntityWorkerSystemWorld = EntityWorkerSystemWorld> {
     type: 'run';
     generation: number;
     world: W;
@@ -59,7 +62,8 @@ interface EntityEventsMessage {
     events: Array<EntityEvent>;
     systemEvents: SystemEvents;
     created: Array<WorkerCreatedEntity>;
+    componentChanges: Array<WorkerComponentChange>;
     errors: Array<WorkerRunError>;
 }
-type ComponentWorkerMessage<W extends ComponentSystemWorld = ComponentSystemWorld, D = unknown> = InitMessage | InitCompleteMessage | LoadMessage<D> | LoadedMessage | ResetMessage | GrowBufferMessage | GrowBufferFromWorkerMessage | RunUpdateMessage<W> | EntityEventsMessage;
-export default ComponentWorkerMessage;
+type EntitySystemWorkerMessage<W extends EntityWorkerSystemWorld = EntityWorkerSystemWorld, D = unknown> = InitMessage | InitCompleteMessage | LoadMessage<D> | LoadedMessage | ResetMessage | GrowBufferMessage | GrowBufferFromWorkerMessage | RunUpdateMessage<W> | EntityEventsMessage;
+export default EntitySystemWorkerMessage;

package/dist/worker.d.ts

@@ -1,8 +1,12 @@
-export { default as createComponentWorker } from './systems/workers/create-component-worker';
-export type { ComponentWorkerScope } from './systems/workers/create-component-worker';
+export { default as createEntitySystemWorker } from './systems/workers/create-entity-system-worker';
+export type { EntitySystemWorkerScope } from './systems/workers/create-entity-system-worker';
+export { default as createSystemWorker } from './systems/workers/create-system-worker';
+export type { WorkerSystemRunFunction } from './systems/workers/create-system-worker';
 export { default as createEntityWorker } from './actions/create-entity-worker';
+export { default as addComponentWorker } from './actions/add-component-worker';
+export { default as removeComponentWorker } from './actions/remove-component-worker';
 export { default as killEntityWorker } from './actions/kill-entity-worker';
-export { DEAD_INDEX, TYPE_INDEX } from './entity-component';
-export type { default as ComponentWorkerMessage } from './systems/workers/component-worker-message';
-export type { EntityEvent, SystemEvents } from './systems/workers/component-worker-message';
-export type { ComponentSystemWorld, ComponentSystemCallbacks, WorkerAllocator, WorkerCreateEntityConfig, WorkerCreatedEntity, EntityUpdateComponents, EntityQueryComponents, EntityUpdateFunction, EntityUpdateInitFunction, EntityUpdatePreRunFunction, EntityRemovedFunction, UpdateEntityConfigObject, } from './systems/component-system';
+export { CLASS_INDEX, DEAD_INDEX, TYPE_INDEX } from './entity-component';
+export type { default as EntitySystemWorkerMessage } from './systems/workers/entity-system-worker-message';
+export type { EntityEvent, SystemEvents } from './systems/workers/entity-system-worker-message';
+export type { EntityWorkerSystemWorld, EntityWorkerSystemCallbacks, WorkerAllocator, WorkerCreateEntityConfig, WorkerCreatedEntity, WorkerCreatedComponent, WorkerComponentChange, EntityUpdateComponents, EntityQueryComponents, EntityUpdateFunction, EntityUpdateInitFunction, EntityUpdatePreRunFunction, EntityRemovedFunction, UpdateEntityConfigObject, } from './systems/entity-worker-system';

package/dist/worker.js

@@ -1,2 +1,2 @@
-import { i as e, n as t, o as n, r, t as i } from "./create-component-worker-BM942gjg.js";
-export { e as DEAD_INDEX, n as TYPE_INDEX, i as createComponentWorker, t as createEntityWorker, r as killEntityWorker };
+import { a as e, c as t, d as n, i as r, l as i, o as a, r as o, s, t as c } from "./create-system-worker-DURlIMia.js";
+export { t as CLASS_INDEX, i as DEAD_INDEX, n as TYPE_INDEX, e as addComponentWorker, o as createEntitySystemWorker, a as createEntityWorker, c as createSystemWorker, s as killEntityWorker, r as removeComponentWorker };

package/dist/world.d.ts

@@ -5,15 +5,15 @@ import type { SharedAllocatedMemory } from '@daneren2005/shared-memory-objects/a
 import type { SharedPoolMemory } from '@daneren2005/shared-memory-objects/shared-pool';
 import MemoryComponent from './memory-component';
 import ConstantStringCache from './constant-string-cache';
-import BaseEntity from './entity';
+import type BaseEntity from './entity';
 import type System from './systems/system';
-import type { WorkerCreatedEntity } from './systems/component-system';
+import type { WorkerCreatedEntity } from './systems/entity-worker-system';
 import type { ComponentDefinitionMap, ComponentMap, ComponentsOf, EntityConfigOf, RegisteredComponentDefinition, RegisteredComponentRegistry } from './component-definition';
 import { type EntityComponent } from './entity-component';
 import EntityFactory from './entity-factory';
-export interface WorldOptions<C extends ComponentMap = ComponentMap, Cfg = any> {
+export interface WorldOptions<C extends ComponentMap = ComponentMap, Cfg = any, E extends BaseEntity<C, Cfg> = BaseEntity<C, Cfg>> {
     heapSize?: number;
-    factory?: EntityFactory<C, Cfg>;
+    factory?: EntityFactory<C, Cfg, E>;
 }
 export interface WorldConfig<Cfg = any> {
     entities: Array<Cfg>;
@@ -27,15 +27,15 @@ export interface WorldSharedMemory {
     };
     eidCounter: SharedAllocatedMemory;
 }
-export default class BaseWorld<R extends ComponentDefinitionMap = ComponentDefinitionMap, C extends ComponentMap = ComponentsOf<R>, Cfg = EntityConfigOf<R>> extends EventEmitter {
+export default class BaseWorld<R extends ComponentDefinitionMap = ComponentDefinitionMap, C extends ComponentMap = ComponentsOf<R>, Cfg = EntityConfigOf<R>, E extends BaseEntity<C, Cfg> = BaseEntity<C, Cfg>> extends EventEmitter {
     heap: MemoryHeap;
     constantStrings: ConstantStringCache;
     private eidCounter;
     registry: RegisteredComponentRegistry<C> & {
         entity: RegisteredComponentDefinition<EntityComponent>;
     };
-    factory: EntityFactory<C, Cfg>;
-    entities: Map<number, BaseEntity<C, Cfg>>;
+    factory: EntityFactory<C, Cfg, E>;
+    entities: Map<number, E>;
     systems: Array<System<C>>;
     gameTime: number;
     playerTime: number;
@@ -45,21 +45,21 @@ export default class BaseWorld<R extends ComponentDefinitionMap = ComponentDefin
     pristine: boolean;
     private activeFreeBuffer;
     private nextFreeBuffer;
-    constructor(registry: R, options?: WorldOptions<C, Cfg>);
+    constructor(registry: R, options?: WorldOptions<C, Cfg, E>);
     allocateEid(): number;
     getSharedComponentMemory(): WorldSharedMemory;
     addGrownBuffer(data: GrowBufferData): void;
     private get needsSpareBuffer();
     init(): Promise<void>;
     private finishLoadingSystems;
-    addEntity(entity: BaseEntity<C, Cfg>, created?: boolean): BaseEntity<C, Cfg>;
-    loadEntity(config: Cfg, created?: boolean): BaseEntity<C, Cfg>;
-    adoptEntity(descriptor: WorkerCreatedEntity): BaseEntity<C, Cfg>;
+    addEntity(entity: E, created?: boolean): E;
+    loadEntity(config: Cfg, created?: boolean): E;
+    adoptEntity(descriptor: WorkerCreatedEntity): E;
     load(config: WorldConfig<Cfg>): void;
     clear(): Promise<void>;
-    removeEntity(entity: BaseEntity<C, Cfg>): void;
-    onEntityDied(entity: BaseEntity<C, Cfg>): void;
-    getEntityByEid(eid: number): BaseEntity<C, Cfg> | undefined;
+    removeEntity(entity: E): void;
+    onEntityDied(entity: E): void;
+    getEntityByEid(eid: number): E | undefined;
     deferComponentMemoryFree(memoryComponent: MemoryComponent, index: number, free?: () => void): void;
     notifySystemRunCompleted(system: System<C>): void;
     private processFreeBuffers;
@@ -77,8 +77,8 @@ export default class BaseWorld<R extends ComponentDefinitionMap = ComponentDefin
     private runUpdate;
     pause(): void;
     resume(): void;
-    addEntityToComponentSystem(entity: BaseEntity<C>, component: keyof C): void;
-    removeEntityFromComponentSystem(entity: BaseEntity<C>, component: keyof C): void;
-    private componentAffectsComponentSystem;
+    addEntityToEntityWorkerSystem(entity: BaseEntity<C>, component: keyof C): void;
+    removeEntityFromEntityWorkerSystem(entity: BaseEntity<C>, component: keyof C): void;
+    private componentAffectsEntityWorkerSystem;
     destroy(): void;
 }

package/package.json

@@ -2,7 +2,7 @@
 	"name": "@daneren2005/shared-memory-ecs",
 	"description": "A small, reusable Entity/Component/System core backed by shared memory.",
 	"author": "Scott Jackson",
-	"version": "1.5.1",
+	"version": "1.7.0",
 	"type": "module",
 	"sideEffects": false,
 	"repository": {
@@ -39,6 +39,7 @@
 		"lint": "cross-env NODE_ENV=production oxlint .",
 		"lint:fix": "cross-env NODE_ENV=production oxlint --fix .",
 		"test": "vitest run",
+		"bench": "vitest bench --run --config vitest.benchmark.config.ts",
 		"release": "semantic-release",
 		"prepare": "husky"
 	},