@georgeluo/ecs 0.1.0

package/dist/index.d.cts

@@ -0,0 +1,349 @@
+/**
+ * Entity identifiers represent concrete instances in the simulation.
+ * For the primitives checkpoint we model them as opaque numeric ids.
+ */
+type Entity = number;
+/**
+ * Utility factory to generate new entity identifiers. Concrete creation
+ * semantics live in the EntityManager; this helper exists to clarify
+ * the shape of an entity id for implementers.
+ */
+declare const createEntityId: (value: number) => Entity;
+
+/**
+ * Manages lifecycle of entities within the simulation. Responsible for
+ * allocating, tracking, and destroying entity identifiers.
+ */
+declare class EntityManager {
+    private nextId;
+    private readonly active;
+    /**
+     * Create and register a new entity identifier.
+     *
+     * @returns Entity id allocated for use in the environment.
+     */
+    create(): Entity;
+    /**
+     * Remove an entity and return whether it existed. This should trigger
+     * component cleanup via the ComponentManager (wired externally).
+     *
+     * @param entity Entity identifier to destroy.
+     */
+    remove(entity: Entity): boolean;
+    /**
+     * Indicates whether the manager currently tracks the entity.
+     *
+     * @param entity Entity identifier to inspect.
+     */
+    has(entity: Entity): boolean;
+    /**
+     * Provide a snapshot list of active entities. Higher level systems
+     * may use this to iterate over the environment.
+     */
+    list(): Entity[];
+    /**
+     * Iterate over all active entities without allocating an intermediate array.
+     */
+    forEach(callback: (entity: Entity) => void): void;
+}
+
+/**
+ * ComponentType describes the schema for a component instance. Concrete
+ * component implementations should extend this interface with strongly
+ * typed payloads.
+ */
+interface ComponentType<TPayload> {
+    /** Unique identifier for the component type at runtime. */
+    readonly id: string;
+    /** Human-readable description to aid discoverability. */
+    readonly description?: string;
+    /** Runtime guard to validate payload conformance when attaching components. */
+    validate(payload: TPayload): boolean;
+}
+/**
+ * Represents an instance of a component bound to an entity.
+ */
+interface ComponentInstance<TPayload> {
+    readonly type: ComponentType<TPayload>;
+    readonly payload: TPayload;
+}
+
+/**
+ * Maintains bidirectional lookups of entities and their components.
+ * Enforces the rule of one component per type per entity.
+ */
+declare class ComponentManager {
+    private readonly componentsByEntity;
+    private readonly entitiesByType;
+    /**
+     * Attach a component instance to an entity. Existing component of the same
+     * type should be replaced or rejected per implementation decision.
+     */
+    addComponent<T>(entity: Entity, type: ComponentType<T>, payload: T): void;
+    /**
+     * Remove all components for an entity, returning how many were removed.
+     */
+    removeAll(entity: Entity): number;
+    /**
+     * Remove a specific component from an entity.
+     */
+    removeComponent<T>(entity: Entity, type: ComponentType<T>): boolean;
+    /**
+     * Retrieve a component instance for the entity, if present.
+     */
+    getComponent<T>(entity: Entity, type: ComponentType<T>): ComponentInstance<T> | undefined;
+    /**
+     * Retrieve all components for the entity.
+     */
+    getComponents(entity: Entity): ComponentInstance<unknown>[];
+    /**
+     * Populate the provided array with the component instances for the entity,
+     * returning the number of components discovered. The target array is cleared
+     * before population to support buffer reuse.
+     */
+    collectComponents(entity: Entity, target: ComponentInstance<unknown>[]): number;
+    /**
+     * Retrieve entities that possess a component of the provided type.
+     */
+    getEntitiesWithComponent<T>(type: ComponentType<T>): Entity[];
+}
+
+interface TimePayload {
+    tick: number;
+}
+declare const TimeComponent: ComponentType<TimePayload>;
+
+/**
+ * Context passed into system lifecycle hooks.
+ */
+interface SystemContext {
+    entityManager: EntityManager;
+    componentManager: ComponentManager;
+}
+/**
+ * Base representation of a system within the ECS engine. Systems are
+ * stateless by design and mutate the environment via managers.
+ */
+declare abstract class System {
+    /** Optional hook invoked once when the system is added to the engine. */
+    initialize(_context: SystemContext): void;
+    /** Required update method executed each simulation tick. */
+    abstract update(context: SystemContext): void;
+    /** Optional hook invoked when the system is removed from the engine. */
+    destroy(_context: SystemContext): void;
+}
+
+declare class SystemManager {
+    private readonly systems;
+    private readonly context;
+    constructor(entityManager: EntityManager, componentManager: ComponentManager);
+    /** Register a system at the end of the execution order or specified index. */
+    addSystem(system: System, index?: number): void;
+    /** Remove a system and trigger destroy lifecycle hook. */
+    removeSystem(system: System): boolean;
+    /** Execute one update cycle across all systems in order. */
+    runCycle(): void;
+    /** Retrieve current ordered list of systems. */
+    getSystems(): System[];
+    /** Expose the context passed into systems (entity/component managers). */
+    getContext(): SystemContext;
+}
+
+declare class TimeSystem extends System {
+    private timeEntity;
+    initialize(context: SystemContext): void;
+    update(context: SystemContext): void;
+}
+
+interface InjectSystemPayload$1 {
+    system: System;
+}
+interface EjectSystemPayload$1 {
+    system?: System;
+    systemId?: string;
+}
+/**
+ * Base simulation player responsible for executing registered systems
+ * on a fixed interval. Subclasses can hook into the lifecycle to expose
+ * messaging or additional orchestration concerns.
+ */
+type PlayerState = 'running' | 'paused' | 'idle';
+interface PlayerStatus {
+    state: PlayerState;
+    tick: number;
+    systemCount: number;
+}
+declare class Player {
+    protected readonly systemManager: SystemManager;
+    protected readonly cycleIntervalMs: number;
+    protected tick: number;
+    private isRunning;
+    private cycleTimer;
+    private nextSystemId;
+    private readonly systemsById;
+    private readonly idsBySystem;
+    constructor(systemManager: SystemManager, cycleIntervalMs?: number);
+    start(): void;
+    pause(): void;
+    stop(): void;
+    injectSystem(payload: InjectSystemPayload$1): string;
+    ejectSystem(payload: EjectSystemPayload$1): boolean;
+    protected getContext(): SystemContext;
+    protected executeCycle(): void;
+    protected onBeforeCycle(_tick: number): void;
+    protected onAfterCycle(_tick: number, _context: SystemContext): void;
+    private ensureTimer;
+    private clearTimer;
+    protected resetEnvironment(): void;
+    private generateSystemId;
+    private cleanupSystemRegistry;
+    describe(): PlayerStatus;
+}
+
+type BusCallback<TMessage> = (message: TMessage) => void;
+declare class Bus<TMessage> {
+    private readonly subscribers;
+    private dispatchDepth;
+    subscribe(callback: BusCallback<TMessage>): () => void;
+    publish(message: TMessage): void;
+    private compact;
+}
+
+interface Frame {
+    tick: number;
+    entities: Record<string, unknown>;
+}
+
+declare class FrameFilter {
+    private readonly blacklist;
+    constructor(componentBlacklist?: string[]);
+    apply(frame: Frame): Frame;
+}
+
+type AcknowledgementStatus = 'success' | 'error';
+interface Acknowledgement {
+    messageId: string;
+    status: AcknowledgementStatus;
+    detail?: string;
+    systemId?: string;
+}
+
+interface Operation<TContext = SystemContext, TPayload = unknown> {
+    execute(context: TContext, payload: TPayload): Acknowledgement;
+}
+
+declare class MessageHandler<TContext = SystemContext, TPayload = unknown> {
+    private readonly operations;
+    constructor(operations: Operation<TContext, TPayload>[]);
+    handle(context: TContext, payload: TPayload): Acknowledgement;
+}
+
+declare class InboundHandlerRegistry<TContext = unknown> {
+    private readonly handlers;
+    constructor(handlers?: Map<string, MessageHandler<TContext, unknown>>);
+    register<TPayload>(type: string, handler: MessageHandler<TContext, TPayload>): void;
+    handle(type: string, context: TContext, payload: unknown): Acknowledgement | null;
+}
+
+type OutboundMessage$1 = Frame | Acknowledgement;
+declare class IOPlayer extends Player {
+    private readonly inbound;
+    private readonly outbound;
+    private readonly frameFilter;
+    private readonly handlers;
+    private readonly unsubscribeInbound;
+    private readonly componentBuffer;
+    constructor(systemManager: SystemManager, inbound: Bus<unknown>, outbound: Bus<OutboundMessage$1>, frameFilter: FrameFilter, handlers?: InboundHandlerRegistry<IOPlayer>, cycleIntervalMs?: number);
+    protected getInboundHandlers(): InboundHandlerRegistry<IOPlayer>;
+    protected onAfterCycle(tick: number, context: SystemContext): void;
+    protected handleInbound(message: unknown): void;
+    protected publishFrame(frame: Frame): void;
+    private createFrameSnapshot;
+    private collectComponents;
+}
+
+type OutboundMessage = Frame | Acknowledgement;
+declare const SimulationMessageType: {
+    readonly START: "start";
+    readonly PAUSE: "pause";
+    readonly STOP: "stop";
+    readonly INJECT_SYSTEM: "inject-system";
+    readonly EJECT_SYSTEM: "eject-system";
+};
+declare class SimulationPlayer extends IOPlayer {
+    private readonly componentTypes;
+    constructor(systemManager: SystemManager, inbound: Bus<unknown>, outbound: Bus<OutboundMessage>, frameFilter: FrameFilter, handlers?: InboundHandlerRegistry<IOPlayer>, cycleIntervalMs?: number);
+    registerComponent<T>(component: ComponentType<T>): void;
+    removeComponent(componentId: string): boolean;
+    getRegisteredComponents(): ComponentType<unknown>[];
+    private registerDefaultHandlers;
+}
+
+interface FrameRecord {
+    messageId?: string;
+    frame: Frame;
+}
+declare const EvaluationMessageType: {
+    readonly INJECT_FRAME: "inject-frame";
+};
+declare class EvaluationPlayer extends IOPlayer {
+    protected readonly frames: FrameRecord[];
+    private readonly componentTypes;
+    private readonly frameComponentType;
+    private lastFrameTick;
+    constructor(systemManager: SystemManager, inbound: Bus<unknown>, outbound: Bus<Frame | Acknowledgement>, frameFilter: FrameFilter, handlers?: InboundHandlerRegistry<EvaluationPlayer>, cycleIntervalMs?: number);
+    injectFrame(payload: FrameRecord): void;
+    getFrames(): FrameRecord[];
+    registerComponent<T>(component: ComponentType<T>): void;
+    removeComponent(componentId: string): boolean;
+    getRegisteredComponents(): ComponentType<unknown>[];
+    private resetIfNewRun;
+    private registerDefaultHandlers;
+}
+
+interface InjectFramePayload extends FrameRecord {
+    messageId: string;
+}
+declare class InjectFrame implements Operation<EvaluationPlayer, InjectFramePayload> {
+    execute(player: EvaluationPlayer, payload: InjectFramePayload): Acknowledgement;
+}
+
+interface StartPayload {
+    messageId: string;
+}
+declare class Start implements Operation<IOPlayer, StartPayload> {
+    execute(player: IOPlayer, payload: StartPayload): Acknowledgement;
+}
+
+interface PausePayload {
+    messageId: string;
+}
+declare class Pause implements Operation<IOPlayer, PausePayload> {
+    execute(player: IOPlayer, payload: PausePayload): Acknowledgement;
+}
+
+interface StopPayload {
+    messageId: string;
+}
+declare class Stop implements Operation<IOPlayer, StopPayload> {
+    execute(player: IOPlayer, payload: StopPayload): Acknowledgement;
+}
+
+interface InjectSystemPayload {
+    messageId: string;
+    system: System;
+}
+declare class InjectSystem implements Operation<IOPlayer, InjectSystemPayload> {
+    execute(player: IOPlayer, payload: InjectSystemPayload): Acknowledgement;
+}
+
+interface EjectSystemPayload {
+    messageId: string;
+    system?: System;
+    systemId?: string;
+}
+declare class EjectSystem implements Operation<IOPlayer, EjectSystemPayload> {
+    execute(player: IOPlayer, payload: EjectSystemPayload): Acknowledgement;
+}
+
+export { type Acknowledgement, type AcknowledgementStatus, Bus, type BusCallback, type ComponentInstance, ComponentManager, type ComponentType, EjectSystem, type EjectSystemPayload, type Entity, EntityManager, EvaluationMessageType, EvaluationPlayer, type Frame, FrameFilter, type FrameRecord, IOPlayer, InboundHandlerRegistry, InjectFrame, type InjectFramePayload, InjectSystem, type InjectSystemPayload, MessageHandler, type Operation, Pause, type PausePayload, Player, type PlayerState, type PlayerStatus, SimulationMessageType, SimulationPlayer, Start, type StartPayload, Stop, type StopPayload, System, type SystemContext, SystemManager, TimeComponent, type TimePayload, TimeSystem, createEntityId };

package/dist/index.d.ts

@@ -0,0 +1,349 @@
+/**
+ * Entity identifiers represent concrete instances in the simulation.
+ * For the primitives checkpoint we model them as opaque numeric ids.
+ */
+type Entity = number;
+/**
+ * Utility factory to generate new entity identifiers. Concrete creation
+ * semantics live in the EntityManager; this helper exists to clarify
+ * the shape of an entity id for implementers.
+ */
+declare const createEntityId: (value: number) => Entity;
+
+/**
+ * Manages lifecycle of entities within the simulation. Responsible for
+ * allocating, tracking, and destroying entity identifiers.
+ */
+declare class EntityManager {
+    private nextId;
+    private readonly active;
+    /**
+     * Create and register a new entity identifier.
+     *
+     * @returns Entity id allocated for use in the environment.
+     */
+    create(): Entity;
+    /**
+     * Remove an entity and return whether it existed. This should trigger
+     * component cleanup via the ComponentManager (wired externally).
+     *
+     * @param entity Entity identifier to destroy.
+     */
+    remove(entity: Entity): boolean;
+    /**
+     * Indicates whether the manager currently tracks the entity.
+     *
+     * @param entity Entity identifier to inspect.
+     */
+    has(entity: Entity): boolean;
+    /**
+     * Provide a snapshot list of active entities. Higher level systems
+     * may use this to iterate over the environment.
+     */
+    list(): Entity[];
+    /**
+     * Iterate over all active entities without allocating an intermediate array.
+     */
+    forEach(callback: (entity: Entity) => void): void;
+}
+
+/**
+ * ComponentType describes the schema for a component instance. Concrete
+ * component implementations should extend this interface with strongly
+ * typed payloads.
+ */
+interface ComponentType<TPayload> {
+    /** Unique identifier for the component type at runtime. */
+    readonly id: string;
+    /** Human-readable description to aid discoverability. */
+    readonly description?: string;
+    /** Runtime guard to validate payload conformance when attaching components. */
+    validate(payload: TPayload): boolean;
+}
+/**
+ * Represents an instance of a component bound to an entity.
+ */
+interface ComponentInstance<TPayload> {
+    readonly type: ComponentType<TPayload>;
+    readonly payload: TPayload;
+}
+
+/**
+ * Maintains bidirectional lookups of entities and their components.
+ * Enforces the rule of one component per type per entity.
+ */
+declare class ComponentManager {
+    private readonly componentsByEntity;
+    private readonly entitiesByType;
+    /**
+     * Attach a component instance to an entity. Existing component of the same
+     * type should be replaced or rejected per implementation decision.
+     */
+    addComponent<T>(entity: Entity, type: ComponentType<T>, payload: T): void;
+    /**
+     * Remove all components for an entity, returning how many were removed.
+     */
+    removeAll(entity: Entity): number;
+    /**
+     * Remove a specific component from an entity.
+     */
+    removeComponent<T>(entity: Entity, type: ComponentType<T>): boolean;
+    /**
+     * Retrieve a component instance for the entity, if present.
+     */
+    getComponent<T>(entity: Entity, type: ComponentType<T>): ComponentInstance<T> | undefined;
+    /**
+     * Retrieve all components for the entity.
+     */
+    getComponents(entity: Entity): ComponentInstance<unknown>[];
+    /**
+     * Populate the provided array with the component instances for the entity,
+     * returning the number of components discovered. The target array is cleared
+     * before population to support buffer reuse.
+     */
+    collectComponents(entity: Entity, target: ComponentInstance<unknown>[]): number;
+    /**
+     * Retrieve entities that possess a component of the provided type.
+     */
+    getEntitiesWithComponent<T>(type: ComponentType<T>): Entity[];
+}
+
+interface TimePayload {
+    tick: number;
+}
+declare const TimeComponent: ComponentType<TimePayload>;
+
+/**
+ * Context passed into system lifecycle hooks.
+ */
+interface SystemContext {
+    entityManager: EntityManager;
+    componentManager: ComponentManager;
+}
+/**
+ * Base representation of a system within the ECS engine. Systems are
+ * stateless by design and mutate the environment via managers.
+ */
+declare abstract class System {
+    /** Optional hook invoked once when the system is added to the engine. */
+    initialize(_context: SystemContext): void;
+    /** Required update method executed each simulation tick. */
+    abstract update(context: SystemContext): void;
+    /** Optional hook invoked when the system is removed from the engine. */
+    destroy(_context: SystemContext): void;
+}
+
+declare class SystemManager {
+    private readonly systems;
+    private readonly context;
+    constructor(entityManager: EntityManager, componentManager: ComponentManager);
+    /** Register a system at the end of the execution order or specified index. */
+    addSystem(system: System, index?: number): void;
+    /** Remove a system and trigger destroy lifecycle hook. */
+    removeSystem(system: System): boolean;
+    /** Execute one update cycle across all systems in order. */
+    runCycle(): void;
+    /** Retrieve current ordered list of systems. */
+    getSystems(): System[];
+    /** Expose the context passed into systems (entity/component managers). */
+    getContext(): SystemContext;
+}
+
+declare class TimeSystem extends System {
+    private timeEntity;
+    initialize(context: SystemContext): void;
+    update(context: SystemContext): void;
+}
+
+interface InjectSystemPayload$1 {
+    system: System;
+}
+interface EjectSystemPayload$1 {
+    system?: System;
+    systemId?: string;
+}
+/**
+ * Base simulation player responsible for executing registered systems
+ * on a fixed interval. Subclasses can hook into the lifecycle to expose
+ * messaging or additional orchestration concerns.
+ */
+type PlayerState = 'running' | 'paused' | 'idle';
+interface PlayerStatus {
+    state: PlayerState;
+    tick: number;
+    systemCount: number;
+}
+declare class Player {
+    protected readonly systemManager: SystemManager;
+    protected readonly cycleIntervalMs: number;
+    protected tick: number;
+    private isRunning;
+    private cycleTimer;
+    private nextSystemId;
+    private readonly systemsById;
+    private readonly idsBySystem;
+    constructor(systemManager: SystemManager, cycleIntervalMs?: number);
+    start(): void;
+    pause(): void;
+    stop(): void;
+    injectSystem(payload: InjectSystemPayload$1): string;
+    ejectSystem(payload: EjectSystemPayload$1): boolean;
+    protected getContext(): SystemContext;
+    protected executeCycle(): void;
+    protected onBeforeCycle(_tick: number): void;
+    protected onAfterCycle(_tick: number, _context: SystemContext): void;
+    private ensureTimer;
+    private clearTimer;
+    protected resetEnvironment(): void;
+    private generateSystemId;
+    private cleanupSystemRegistry;
+    describe(): PlayerStatus;
+}
+
+type BusCallback<TMessage> = (message: TMessage) => void;
+declare class Bus<TMessage> {
+    private readonly subscribers;
+    private dispatchDepth;
+    subscribe(callback: BusCallback<TMessage>): () => void;
+    publish(message: TMessage): void;
+    private compact;
+}
+
+interface Frame {
+    tick: number;
+    entities: Record<string, unknown>;
+}
+
+declare class FrameFilter {
+    private readonly blacklist;
+    constructor(componentBlacklist?: string[]);
+    apply(frame: Frame): Frame;
+}
+
+type AcknowledgementStatus = 'success' | 'error';
+interface Acknowledgement {
+    messageId: string;
+    status: AcknowledgementStatus;
+    detail?: string;
+    systemId?: string;
+}
+
+interface Operation<TContext = SystemContext, TPayload = unknown> {
+    execute(context: TContext, payload: TPayload): Acknowledgement;
+}
+
+declare class MessageHandler<TContext = SystemContext, TPayload = unknown> {
+    private readonly operations;
+    constructor(operations: Operation<TContext, TPayload>[]);
+    handle(context: TContext, payload: TPayload): Acknowledgement;
+}
+
+declare class InboundHandlerRegistry<TContext = unknown> {
+    private readonly handlers;
+    constructor(handlers?: Map<string, MessageHandler<TContext, unknown>>);
+    register<TPayload>(type: string, handler: MessageHandler<TContext, TPayload>): void;
+    handle(type: string, context: TContext, payload: unknown): Acknowledgement | null;
+}
+
+type OutboundMessage$1 = Frame | Acknowledgement;
+declare class IOPlayer extends Player {
+    private readonly inbound;
+    private readonly outbound;
+    private readonly frameFilter;
+    private readonly handlers;
+    private readonly unsubscribeInbound;
+    private readonly componentBuffer;
+    constructor(systemManager: SystemManager, inbound: Bus<unknown>, outbound: Bus<OutboundMessage$1>, frameFilter: FrameFilter, handlers?: InboundHandlerRegistry<IOPlayer>, cycleIntervalMs?: number);
+    protected getInboundHandlers(): InboundHandlerRegistry<IOPlayer>;
+    protected onAfterCycle(tick: number, context: SystemContext): void;
+    protected handleInbound(message: unknown): void;
+    protected publishFrame(frame: Frame): void;
+    private createFrameSnapshot;
+    private collectComponents;
+}
+
+type OutboundMessage = Frame | Acknowledgement;
+declare const SimulationMessageType: {
+    readonly START: "start";
+    readonly PAUSE: "pause";
+    readonly STOP: "stop";
+    readonly INJECT_SYSTEM: "inject-system";
+    readonly EJECT_SYSTEM: "eject-system";
+};
+declare class SimulationPlayer extends IOPlayer {
+    private readonly componentTypes;
+    constructor(systemManager: SystemManager, inbound: Bus<unknown>, outbound: Bus<OutboundMessage>, frameFilter: FrameFilter, handlers?: InboundHandlerRegistry<IOPlayer>, cycleIntervalMs?: number);
+    registerComponent<T>(component: ComponentType<T>): void;
+    removeComponent(componentId: string): boolean;
+    getRegisteredComponents(): ComponentType<unknown>[];
+    private registerDefaultHandlers;
+}
+
+interface FrameRecord {
+    messageId?: string;
+    frame: Frame;
+}
+declare const EvaluationMessageType: {
+    readonly INJECT_FRAME: "inject-frame";
+};
+declare class EvaluationPlayer extends IOPlayer {
+    protected readonly frames: FrameRecord[];
+    private readonly componentTypes;
+    private readonly frameComponentType;
+    private lastFrameTick;
+    constructor(systemManager: SystemManager, inbound: Bus<unknown>, outbound: Bus<Frame | Acknowledgement>, frameFilter: FrameFilter, handlers?: InboundHandlerRegistry<EvaluationPlayer>, cycleIntervalMs?: number);
+    injectFrame(payload: FrameRecord): void;
+    getFrames(): FrameRecord[];
+    registerComponent<T>(component: ComponentType<T>): void;
+    removeComponent(componentId: string): boolean;
+    getRegisteredComponents(): ComponentType<unknown>[];
+    private resetIfNewRun;
+    private registerDefaultHandlers;
+}
+
+interface InjectFramePayload extends FrameRecord {
+    messageId: string;
+}
+declare class InjectFrame implements Operation<EvaluationPlayer, InjectFramePayload> {
+    execute(player: EvaluationPlayer, payload: InjectFramePayload): Acknowledgement;
+}
+
+interface StartPayload {
+    messageId: string;
+}
+declare class Start implements Operation<IOPlayer, StartPayload> {
+    execute(player: IOPlayer, payload: StartPayload): Acknowledgement;
+}
+
+interface PausePayload {
+    messageId: string;
+}
+declare class Pause implements Operation<IOPlayer, PausePayload> {
+    execute(player: IOPlayer, payload: PausePayload): Acknowledgement;
+}
+
+interface StopPayload {
+    messageId: string;
+}
+declare class Stop implements Operation<IOPlayer, StopPayload> {
+    execute(player: IOPlayer, payload: StopPayload): Acknowledgement;
+}
+
+interface InjectSystemPayload {
+    messageId: string;
+    system: System;
+}
+declare class InjectSystem implements Operation<IOPlayer, InjectSystemPayload> {
+    execute(player: IOPlayer, payload: InjectSystemPayload): Acknowledgement;
+}
+
+interface EjectSystemPayload {
+    messageId: string;
+    system?: System;
+    systemId?: string;
+}
+declare class EjectSystem implements Operation<IOPlayer, EjectSystemPayload> {
+    execute(player: IOPlayer, payload: EjectSystemPayload): Acknowledgement;
+}
+
+export { type Acknowledgement, type AcknowledgementStatus, Bus, type BusCallback, type ComponentInstance, ComponentManager, type ComponentType, EjectSystem, type EjectSystemPayload, type Entity, EntityManager, EvaluationMessageType, EvaluationPlayer, type Frame, FrameFilter, type FrameRecord, IOPlayer, InboundHandlerRegistry, InjectFrame, type InjectFramePayload, InjectSystem, type InjectSystemPayload, MessageHandler, type Operation, Pause, type PausePayload, Player, type PlayerState, type PlayerStatus, SimulationMessageType, SimulationPlayer, Start, type StartPayload, Stop, type StopPayload, System, type SystemContext, SystemManager, TimeComponent, type TimePayload, TimeSystem, createEntityId };