@relu-interactives/spatial-ecs 0.2.2

package/dist/System-rXAmagXA.d.ts

@@ -0,0 +1,659 @@
+import * as THREE from 'three';
+import { Vector3, Euler, EulerOrder, Quaternion } from 'three';
+import * as RAPIER from '@dimforge/rapier3d-compat';
+
+/**
+ * Marker base class for every ECS component. Subclass `Component` to declare
+ * a typed data container that systems can query.
+ *
+ * @remarks
+ * Components own state only — runtime behaviour belongs in {@link Behaviour}
+ * subclasses for user scripts. Keep fields plain (numbers, strings, vectors,
+ * asset URLs).
+ *
+ * @category Components
+ */
+declare class Component {
+}
+
+/**
+ * Records the parent entity id for hierarchical scene graphs. `null` means
+ * the entity is at the world root. The `ObjectManagementSystem` reconciles
+ * scene-graph parenting from this component each frame.
+ *
+ * @category Components
+ */
+declare class ParentId extends Component {
+    /** Parent entity id, or `null` for root-level entities. */
+    value: EntityId | null;
+    constructor(value?: EntityId | null);
+}
+
+/** Plain XYZ vector. All ECS transform fields use this shape rather than `THREE.Vector3` so they save cleanly with the project. */
+type Vec3$1 = {
+    /** X component. */
+    x: number;
+    /** Y component. */
+    y: number;
+    /** Z component. */
+    z: number;
+};
+/** Optional initial values passed to {@link TransformComponent}. Missing axes default to `0` for position/rotation and `1` for scale. */
+type TransformData = {
+    /** Initial position (defaults to `{ 0, 0, 0 }`). */
+    position?: Partial<Vec3$1>;
+    /** Initial rotation in **radians** (defaults to `{ 0, 0, 0 }`). */
+    rotation?: Partial<Vec3$1>;
+    /** Initial scale (defaults to `{ 1, 1, 1 }`). */
+    scale?: Partial<Vec3$1>;
+};
+type TransformInput = Vector3 | Euler | Quaternion;
+/**
+ * Position, rotation, and scale of an entity in its parent's local space.
+ *
+ * @remarks
+ * Rotation is stored in **radians** (Euler XYZ). The editor inspector converts
+ * to/from degrees for display — do not store degrees in this component.
+ * Mutations should go through the `setPosition` / `setRotation` / `setScale`
+ * helpers so dependent systems pick up the change.
+ *
+ * @category Components
+ */
+declare class TransformComponent extends Component {
+    /** Local position relative to the parent (or world if no parent). */
+    position: Vec3$1;
+    /** Local rotation as Euler XYZ in **radians**. */
+    rotation: Vec3$1;
+    /** Local scale factors per axis (`1` = identity). */
+    scale: Vec3$1;
+    constructor(data?: TransformData);
+    toPositionVector3(target?: Vector3): Vector3;
+    toRotationEuler(target?: Euler, order?: EulerOrder): Euler;
+    toRotationQuaternion(target?: Quaternion, order?: EulerOrder): Quaternion;
+    toScaleVector3(target?: Vector3): Vector3;
+    setPosition(input: TransformInput): this;
+    setScale(input: TransformInput): this;
+    setRotation(input: TransformInput, order?: EulerOrder): this;
+}
+
+/**
+ * Numeric identifier for an entity. Entities are pure ids — all data lives in
+ * components attached to the entity.
+ */
+type EntityId = number;
+/**
+ * Built-in entity kinds recognized by the ECS factory registry. Each kind
+ * maps to an object factory in `core/factories/objects/*` that creates the
+ * baseline component set.
+ */
+type EcsEntityKind = "cube" | "sphere" | "plane" | "capsule" | "cylinder" | "empty" | "model" | "image" | "imageTarget" | "sprite" | "audio" | "camera" | "video" | "ambientLight" | "directionalLight" | "pointLight" | "spotLight" | "areaLight";
+/** {@link EcsEntityKind} extended with editor-only utility entities (gizmos, helpers). */
+type EcsEntityEditorKind = EcsEntityKind | "editorUtility";
+/** Callback invoked when the selected entity changes. `null` indicates a deselection. */
+type SelectionListener = (entityId: EntityId | null) => void;
+type TextInput = string;
+type FloatInput = number;
+type ColorInput = string;
+type Vector2Input = {
+    x: number;
+    y: number;
+};
+type Vector3Input = {
+    x: number;
+    y: number;
+    z: number;
+};
+type SliderInput = {
+    min: number;
+    max: number;
+    step: number;
+    value: number;
+};
+type DropdownOption = {
+    label: string;
+    value: string | any;
+};
+type DropdownInput = {
+    options: DropdownOption[];
+    value: string | any;
+};
+type CheckboxInput = boolean;
+type ToggleInput = boolean;
+type AssetInput = {
+    path: string;
+    type: string;
+};
+type EntityInput = {
+    type: "entity";
+    value: EntityId | null;
+};
+type ComponentKind = "Animation" | "Audio" | "Camera" | "Environment" | "EntityType" | "Image" | "ImageTarget" | "ImageTargetAnchor" | "Light" | "Material" | "Mesh" | "MeshGeometry" | "Model" | "Name" | "Object3DRef" | "ParentId" | "Physics" | "Postprocessing" | "Script" | "Selectable" | "SelectionTransformState" | "Sprite" | "Transform" | "Video";
+/**
+ * Inspector field that lets the user drag an entity and optionally pick a
+ * component from it.
+ *
+ * The optional `componentKind` property narrows which component the inspector
+ * should auto-resolve or pre-filter to. When set, dropping an entity will
+ * immediately commit that component kind — skipping the dropdown entirely.
+ *
+ * @example
+ * // Unconstrained — shows a component-kind dropdown after entity drop
+ * anyRef: { type: "component", value: null } as ComponentInput
+ *
+ * // Constrained — auto-resolves to "Transform", no dropdown
+ * transform: { type: "component", componentKind: "Transform", value: null } as ComponentInput<Transform>
+ */
+type ComponentInput<T extends Component = Component> = {
+    type: "component";
+    /** Optional component-kind constraint. When provided, the inspector skips
+     * the dropdown and resolves directly to this kind. */
+    componentKind?: ComponentKind;
+    value: {
+        entityId: EntityId;
+        componentKind: ComponentKind;
+    } | null;
+    /** @internal used only for TypeScript type inference; not persisted. */
+    readonly _phantom?: T;
+};
+/**
+ * Lightweight, read-only view of an entity returned by `World.getEntityById`.
+ * Contains the entity id and its current component list at the moment of the
+ * lookup. Re-query each frame rather than caching across ticks.
+ */
+type WorldEntityView$1 = NonNullable<ReturnType<World["getEntityById"]>>;
+/**
+ * Result of a parent lookup. `parent` is `null` for entities at the root or
+ * for entities without a {@link ParentId} component.
+ */
+type ParentLookup = {
+    /** The entity's `ParentId` component, or `null` if it has none. */
+    parentIdComponent: ParentId | null;
+    /** The resolved parent entity view, or `null` if the entity is at the root. */
+    parent: WorldEntityView$1 | null;
+};
+/**
+ * Loose 3D vector accepted by raycast and other spatial helpers. Either a
+ * live `THREE.Vector3` or a plain `{ x, y, z }` object — both are normalized
+ * internally before use.
+ */
+type Vec3 = THREE.Vector3 | {
+    x: number;
+    y: number;
+    z: number;
+};
+/**
+ * Single hit returned by `World.raycast` / `World.raycastFrom`. Pairs the
+ * standard `THREE.Intersection` (`threeResult`) with the owning entity id
+ * (when the hit traces back to a registered ECS entity). `entityId` is
+ * `null` if the hit object is not part of any tracked entity (e.g. an
+ * editor helper).
+ */
+type IntersectionResult = {
+    /** The entity that owns the hit object, or `null` if untracked. */
+    entityId: EntityId | null;
+    /** The underlying three.js intersection record. */
+    threeResult: THREE.Intersection;
+};
+
+type ComponentClass<T extends Component> = new (...args: never[]) => T;
+type AnyComponent = Component;
+type WorldHistorySnapshot = {
+    selectedEntityId: EntityId | null;
+    entities: EntityId[];
+    nextEntityId: number;
+    components: Array<{
+        componentType: ComponentClass<AnyComponent>;
+        entries: Array<{
+            entityId: EntityId;
+            component: AnyComponent;
+        }>;
+    }>;
+};
+declare const DEBUG_CHANGE_IGNORED_SYSTEMS: Set<string>;
+type NormalizeContext = {
+    seen: WeakSet<object>;
+    depth: number;
+    maxDepth: number;
+};
+declare function normalizeDebugValue(value: unknown, ctx: NormalizeContext): unknown;
+declare function cloneHistoryValue<T>(value: T, seen?: WeakMap<object, unknown>): T;
+
+type CreatePayload = {
+    name?: string;
+    transform?: TransformData;
+    parentId?: EntityId | null;
+    path?: string;
+    options?: Record<string, unknown>;
+    camera?: Record<string, unknown>;
+    useWorldCamera?: boolean;
+};
+type CreateContext = {
+    world: World;
+    scene: THREE.Scene;
+    camera: THREE.PerspectiveCamera;
+    payload: CreatePayload;
+    isEditor?: boolean;
+};
+type EntityFactory = (context: CreateContext) => EntityId;
+type EcsComponentFactoryKind = "animation" | "audio" | "camera" | "environment" | "entityType" | "image" | "imageTargetAnchor" | "imageTarget" | "light" | "material" | "mesh" | "meshGeometry" | "model" | "name" | "object3DRef" | "parentId" | "physics" | "postprocessing" | "script" | "selectable" | "selectionTransformState" | "sprite" | "transform" | "video";
+type ComponentFactory = (world: World, entityId: EntityId, ...args: any[]) => unknown;
+declare class ObjectManagementSystem implements EcsSystem {
+    private readonly scene;
+    private readonly camera;
+    private readonly isEditor;
+    private readonly registry;
+    private readonly componentRegistry;
+    private readonly createQueue;
+    constructor(scene: THREE.Scene, camera: THREE.PerspectiveCamera, isEditor?: boolean);
+    register(kind: EcsEntityKind, factory: EntityFactory): void;
+    registerComponentFactory(kind: EcsComponentFactoryKind, factory: ComponentFactory): void;
+    getOrCreateAudioListener(): THREE.AudioListener;
+    isEditorMode(): boolean;
+    getComponentFactory(kind: EcsComponentFactoryKind): ComponentFactory | null;
+    createComponentNow(kind: EcsComponentFactoryKind, world: World, entityId: EntityId, ...args: any[]): unknown;
+    requestCreate(kind: EcsEntityKind, payload?: CreatePayload, onCreated?: (entityId: EntityId) => void): void;
+    createNow(kind: EcsEntityKind, world: World, payload?: CreatePayload): EntityId;
+    deleteEntity(world: World, entityId: EntityId): boolean;
+    setParent(world: World, entityId: EntityId, parentId: EntityId | null, options?: {
+        preserveWorldTransform?: boolean;
+    }): boolean;
+    private syncTransformComponentFromObject;
+    reconcileSceneFromWorld(world: World): void;
+    update(world: World): void;
+}
+
+declare const KeyboardKeys: {
+    readonly A: "a";
+    readonly B: "b";
+    readonly C: "c";
+    readonly D: "d";
+    readonly E: "e";
+    readonly F: "f";
+    readonly G: "g";
+    readonly H: "h";
+    readonly I: "i";
+    readonly J: "j";
+    readonly K: "k";
+    readonly L: "l";
+    readonly M: "m";
+    readonly N: "n";
+    readonly O: "o";
+    readonly P: "p";
+    readonly Q: "q";
+    readonly R: "r";
+    readonly S: "s";
+    readonly T: "t";
+    readonly U: "u";
+    readonly V: "v";
+    readonly W: "w";
+    readonly X: "x";
+    readonly Y: "y";
+    readonly Z: "z";
+    readonly Digit0: "0";
+    readonly Digit1: "1";
+    readonly Digit2: "2";
+    readonly Digit3: "3";
+    readonly Digit4: "4";
+    readonly Digit5: "5";
+    readonly Digit6: "6";
+    readonly Digit7: "7";
+    readonly Digit8: "8";
+    readonly Digit9: "9";
+    readonly Space: " ";
+    readonly Enter: "enter";
+    readonly Escape: "escape";
+    readonly Tab: "tab";
+    readonly Backspace: "backspace";
+    readonly Delete: "delete";
+    readonly Insert: "insert";
+    readonly Home: "home";
+    readonly End: "end";
+    readonly PageUp: "pageup";
+    readonly PageDown: "pagedown";
+    readonly ArrowUp: "arrowup";
+    readonly ArrowDown: "arrowdown";
+    readonly ArrowLeft: "arrowleft";
+    readonly ArrowRight: "arrowright";
+    readonly Shift: "shift";
+    readonly ShiftLeft: "shiftleft";
+    readonly ShiftRight: "shiftright";
+    readonly Control: "control";
+    readonly ControlLeft: "controlleft";
+    readonly ControlRight: "controlright";
+    readonly Alt: "alt";
+    readonly Meta: "meta";
+    readonly CapsLock: "capslock";
+    readonly NumLock: "numlock";
+    readonly ScrollLock: "scrolllock";
+    readonly Pause: "pause";
+    readonly PrintScreen: "printscreen";
+    readonly ContextMenu: "contextmenu";
+    readonly Minus: "-";
+    readonly Equal: "=";
+    readonly BracketLeft: "[";
+    readonly BracketRight: "]";
+    readonly Backslash: "\\";
+    readonly Semicolon: ";";
+    readonly Quote: "'";
+    readonly Backquote: "`";
+    readonly Comma: ",";
+    readonly Period: ".";
+    readonly Slash: "/";
+    readonly F1: "f1";
+    readonly F2: "f2";
+    readonly F3: "f3";
+    readonly F4: "f4";
+    readonly F5: "f5";
+    readonly F6: "f6";
+    readonly F7: "f7";
+    readonly F8: "f8";
+    readonly F9: "f9";
+    readonly F10: "f10";
+    readonly F11: "f11";
+    readonly F12: "f12";
+};
+type KeyboardKey = (typeof KeyboardKeys)[keyof typeof KeyboardKeys];
+
+type MouseButton = "left" | "middle" | "right";
+declare class InputSystem implements EcsSystem {
+    private readonly held;
+    private readonly down;
+    private readonly up;
+    private readonly pendingDown;
+    private readonly pendingUp;
+    private readonly heldMouse;
+    private readonly downMouse;
+    private readonly upMouse;
+    private readonly pendingMouseDown;
+    private readonly pendingMouseUp;
+    private scrollDeltaX;
+    private scrollDeltaY;
+    private pendingScrollDeltaX;
+    private pendingScrollDeltaY;
+    private mouseDeltaX;
+    private mouseDeltaY;
+    private pendingMouseDeltaX;
+    private pendingMouseDeltaY;
+    private mousePosition;
+    private pointerLockElement;
+    private pendingPointerLockRequest;
+    private resolvePointerBounds;
+    private onKeyDown;
+    private onKeyUp;
+    private onWindowBlur;
+    private onMouseDown;
+    private onMouseUp;
+    private onMouseWheel;
+    private onMouseMove;
+    private onPointerLockChange;
+    private onPointerLockError;
+    constructor();
+    setPointerLockElement(element: HTMLElement | null): void;
+    lockMousePointer(): boolean;
+    unlockMousePointer(): boolean;
+    isMousePointerLocked(): boolean;
+    getKey(key: KeyboardKey | string): boolean;
+    getKeyDown(key: KeyboardKey | string): boolean;
+    getKeyUp(key: KeyboardKey | string): boolean;
+    consumePressed(key: KeyboardKey | string): boolean;
+    getMouse(button: MouseButton | number | string): boolean;
+    getMouseDown(button: MouseButton | number | string): boolean;
+    getMouseUp(button: MouseButton | number | string): boolean;
+    getScrollClick(): boolean;
+    getScrollClickDown(): boolean;
+    getScrollClickUp(): boolean;
+    getScrollDelta(): {
+        x: number;
+        y: number;
+    };
+    consumeScrollDelta(): {
+        x: number;
+        y: number;
+    };
+    getMousePosition(): {
+        x: number;
+        y: number;
+    };
+    getMouseDelta(): {
+        x: number;
+        y: number;
+    };
+    consumeMouseDelta(): {
+        x: number;
+        y: number;
+    };
+    update(_world: World, _deltaTime: number): void;
+    dispose(): void;
+    private clearAll;
+}
+
+declare class RenderSystem implements EcsSystem {
+    private readonly renderer;
+    private readonly scene;
+    private readonly camera;
+    private readonly afterRender?;
+    constructor(renderer: THREE.WebGLRenderer, scene: THREE.Scene, camera: THREE.PerspectiveCamera, afterRender?: () => void);
+    update(_world: World): void;
+}
+
+declare class TransformSyncSystem implements EcsSystem {
+    update(world: World): void;
+}
+
+type StoreListener = () => void;
+type WorldFeatureFlags = {
+    supportSkybox?: boolean;
+    supportPostprocessing?: boolean;
+};
+type WorldEntityView = {
+    name: string;
+    entityId: number;
+    object: THREE.Object3D | null;
+    type: string;
+    components: Component[];
+};
+declare class World {
+    private nextEntityId;
+    private entities;
+    private systems;
+    private selectionListeners;
+    private storeListeners;
+    private scene;
+    private camera;
+    private renderer;
+    private readonly featureFlags;
+    private components;
+    private inputSystem;
+    private rapierModule;
+    private rapierModulePromise;
+    private physicsWorld;
+    private isEditor;
+    private paused;
+    constructor(options: {
+        scene: THREE.Scene;
+        camera: THREE.PerspectiveCamera;
+        renderer: THREE.WebGLRenderer;
+        featureFlags?: WorldFeatureFlags;
+    });
+    createEntity(): EntityId;
+    destroyEntity(entityId: EntityId): void;
+    private getSelectionState;
+    hasEntity(entityId: EntityId): boolean;
+    getEntities(): EntityId[];
+    getEntityCount(): number;
+    addComponent<T extends Component>(entityId: EntityId, component: T): void;
+    addComponents<T extends Component>(entityId: EntityId, components: T[]): void;
+    removeComponent<T extends Component>(entityId: EntityId, componentType: ComponentClass<T>): void;
+    getComponent<T extends Component>(entityId: EntityId, componentType: ComponentClass<T>): T | undefined;
+    hasComponent<T extends Component>(entityId: EntityId, componentType: ComponentClass<T>): boolean;
+    query(...componentTypes: ComponentClass<AnyComponent>[]): EntityId[];
+    /**
+     * Returns `true` if the entity is currently visible (its `Object3DRef.visibility`
+     * is `true`), or if the entity has no `Object3DRef` component (entities without a
+     * scene object are always considered active). Systems use this to skip per-entity
+     * updates for hidden objects.
+     */
+    isEntityVisible(entityId: EntityId): boolean;
+    getInputSystem(): EcsSystem | null;
+    getKeyDown(key: KeyboardKey): boolean;
+    getKeyUp(key: KeyboardKey): boolean;
+    getKey(key: KeyboardKey): boolean;
+    getMouse(button: MouseButton | number | string): boolean;
+    getMouseDown(button: MouseButton | number | string): boolean;
+    getMouseUp(button: MouseButton | number | string): boolean;
+    getScrollClick(): boolean;
+    getScrollClickDown(): boolean;
+    getScrollClickUp(): boolean;
+    getScrollDelta(): {
+        x: number;
+        y: number;
+    };
+    consumeScrollDelta(): {
+        x: number;
+        y: number;
+    };
+    getMousePosition(): {
+        x: number;
+        y: number;
+    };
+    getMouseDelta(): {
+        x: number;
+        y: number;
+    };
+    consumeMouseDelta(): {
+        x: number;
+        y: number;
+    };
+    getRapierModule(): Promise<typeof RAPIER>;
+    getPhysicsWorld(): RAPIER.World | null;
+    setPhysicsWorld(physicsWorld: RAPIER.World | null): void;
+    createPhysicsWorld(options?: {
+        gravity?: {
+            x?: number;
+            y?: number;
+            z?: number;
+        };
+    }): Promise<RAPIER.World | null>;
+    lockMousePointer(): boolean;
+    unlockMousePointer(): boolean;
+    isMousePointerLocked(): boolean;
+    getSystem<T extends EcsSystem>(system: T): T;
+    hasSystem<T extends EcsSystem>(system: T): boolean;
+    addSystem(system: EcsSystem): void;
+    addSystems(systems: EcsSystem[]): void;
+    setup({ systems, isEditor }: {
+        systems: EcsSystem[];
+        isEditor?: boolean;
+    }): {
+        objectManagementSystem: ObjectManagementSystem;
+        transformSyncSystem: TransformSyncSystem;
+        renderSystem: RenderSystem;
+    };
+    isEditorMode(): boolean;
+    /**
+     * Pauses world simulation. While paused, `update()` skips all system ticks so
+     * physics, animation, scripts, and rendering stop advancing. The last rendered
+     * frame remains frozen on-screen.
+     *
+     * Call {@link resume} to continue.
+     */
+    pause(): void;
+    /**
+     * Resumes world simulation after a previous {@link pause} call.
+     * Has no effect if the world is not paused.
+     */
+    resume(): void;
+    /**
+     * Returns `true` if the world is currently paused.
+     *
+     * @example
+     * ```ts
+     * if (this.world.isPaused()) {
+     *   this.world.resume();
+     * }
+     * ```
+     */
+    isPaused(): boolean;
+    getScene(): THREE.Scene;
+    getCamera(): THREE.PerspectiveCamera;
+    getRenderer(): THREE.WebGLRenderer;
+    update(deltaTime: number): void;
+    dispose(): void;
+    setSelectedEntity(entityId: EntityId | null): void;
+    getSelectedEntity(): EntityId | null;
+    private getEntityComponents;
+    private getEntityName;
+    private getEntityType;
+    private getObject3d;
+    private toEntityView;
+    getEntitiesByComponent(component: Component): WorldEntityView[];
+    getEntitiesByName(name: string): WorldEntityView[];
+    getEntityByName(name: string): WorldEntityView | null;
+    getEntityById(entityId: number): WorldEntityView | null;
+    /**
+     * Cast a ray from `origin` along `direction` and return every intersected
+     * entity-bound mesh, sorted by distance. Each result is a standard
+     * `THREE.Intersection` augmented with the owning `entityId` (or `null` if
+     * the hit object is not part of any tracked entity).
+     *
+     * @param origin - World-space origin of the ray (`THREE.Vector3` or
+     *   `{ x, y, z }`).
+     * @param direction - World-space direction of the ray. Will be normalized
+     *   internally; magnitude is ignored.
+     * @param near - Minimum hit distance from the origin. Defaults to `0`.
+     * @param far - Maximum hit distance from the origin. Defaults to `Infinity`.
+     *
+     * @example
+     * ```ts
+     * const hits = world.raycast(
+     *   { x: 0, y: 1, z: 0 },
+     *   { x: 0, y: 0, z: -1 },
+     * );
+     * if (hits[0]?.entityId !== null) {
+     *   console.log("hit entity", hits[0].entityId, "at", hits[0].point);
+     * }
+     * ```
+     */
+    raycast(origin: Vec3, direction: Vec3, near?: number, far?: number): IntersectionResult[];
+    /**
+     * Cast a ray from an entity's world-space position along its forward
+     * direction (the +Z axis of its world matrix). Returns intersected
+     * entity-bound meshes sorted by distance, with the source entity itself
+     * filtered out so the ray does not hit the caster.
+     *
+     * @param entityId - Entity to cast the ray from. Must have an `Object3DRef`.
+     * @param near - Minimum hit distance from the origin. Defaults to `0`.
+     * @param far - Maximum hit distance from the origin. Defaults to `Infinity`.
+     *
+     * @example
+     * ```ts
+     * const hits = world.raycastFrom(this.entityId, 0, 50);
+     * const closest = hits[0];
+     * if (closest && closest.entityId !== null) {
+     *   console.log("looking at", closest.entityId);
+     * }
+     * ```
+     */
+    raycastFrom(entityId: EntityId, near?: number, far?: number): IntersectionResult[];
+    private buildObjectToEntityMap;
+    private resolveEntityForObject;
+    private toIntersectionResult;
+    getEntityScript<T = unknown>(entityId: number): T | null;
+    getScripts<T = unknown>(className: string): T[];
+    getScript<T = unknown>(className: string): T | null;
+    getAllEntities(): WorldEntityView[];
+    onSelectionChanged(listener: SelectionListener): () => void;
+    subscribe(listener: StoreListener): () => void;
+    getDebugSnapshot(maxDepth?: number): unknown;
+    getDebugSignature(maxDepth?: number): string;
+    createHistorySnapshot(): WorldHistorySnapshot;
+    applyHistorySnapshot(snapshot: WorldHistorySnapshot): void;
+    private emitStoreChanged;
+}
+
+interface EcsSystem {
+    update(world: World, deltaTime: number): void;
+    dispose?(world: World): void;
+}
+
+export { type AssetInput as A, type WorldHistorySnapshot as B, Component as C, type DropdownInput as D, type EcsSystem as E, type FloatInput as F, cloneHistoryValue as G, normalizeDebugValue as H, InputSystem as I, type KeyboardKey as K, type MouseButton as M, ObjectManagementSystem as O, ParentId as P, RenderSystem as R, type SelectionListener as S, TransformComponent as T, type Vec3$1 as V, type WorldEntityView$1 as W, type TransformData as a, World as b, type ComponentClass as c, type ParentLookup as d, type EcsEntityKind as e, type CheckboxInput as f, type ColorInput as g, type ComponentFactory as h, type ComponentInput as i, type ComponentKind as j, type DropdownOption as k, type EcsComponentFactoryKind as l, type EcsEntityEditorKind as m, type EntityId as n, type EntityInput as o, type IntersectionResult as p, KeyboardKeys as q, type SliderInput as r, type TextInput as s, type ToggleInput as t, TransformSyncSystem as u, type Vec3 as v, type Vector2Input as w, type Vector3Input as x, type AnyComponent as y, DEBUG_CHANGE_IGNORED_SYSTEMS as z };