@relu-interactives/spatial-ecs 0.2.2

package/dist/Video-ChKV1UI7.d.ts

@@ -0,0 +1,1261 @@
+import * as THREE from 'three';
+import { C as Component, e as EcsEntityKind, m as EcsEntityEditorKind, n as EntityId } from './System-rXAmagXA.js';
+import * as RAPIER from '@dimforge/rapier3d-compat';
+
+interface StateMachine {
+    name: string;
+    clip: THREE.AnimationClip;
+    clipId: string | null;
+    loop: boolean;
+    isPlaying: boolean;
+    isPaused: boolean;
+    onStart: () => void;
+    onPlaying: () => void;
+    onEnd: () => void;
+    play: () => void;
+    pause: () => void;
+    stop: () => void;
+}
+type AnimationStateCallbacks = {
+    onStart?: () => void;
+    onPlaying?: () => void;
+    onEnd?: () => void;
+};
+declare class AnimationStateMachine implements StateMachine {
+    name: string;
+    clip: THREE.AnimationClip;
+    clipId: string | null;
+    loop: boolean;
+    isPlaying: boolean;
+    isPaused: boolean;
+    private callbacks;
+    constructor(name: string, clip: THREE.AnimationClip, callbacks?: AnimationStateCallbacks, loop?: boolean, clipId?: string | null);
+    setCallbacks(callbacks: AnimationStateCallbacks): void;
+    setLoop(loop: boolean): void;
+    onStart(): void;
+    onPlaying(): void;
+    onEnd(): void;
+    play(): void;
+    pause(): void;
+    stop(): void;
+}
+declare class AnimationStateManager {
+    private readonly states;
+    private activeState;
+    addState(state: AnimationStateMachine): AnimationStateMachine;
+    createState(name: string, clip: THREE.AnimationClip, callbacks?: AnimationStateCallbacks, loop?: boolean, clipId?: string | null): AnimationStateMachine;
+    removeState(name: string): boolean;
+    getState(name: string): AnimationStateMachine | null;
+    hasState(name: string): boolean;
+    listStates(): AnimationStateMachine[];
+    getActiveState(): AnimationStateMachine | null;
+    switchState(name: string, autoPlay?: boolean): AnimationStateMachine | null;
+    playState(name?: string): boolean;
+    pauseState(name?: string): boolean;
+    stopState(name?: string): boolean;
+    clear(): void;
+}
+
+/** Initializer for {@link AnimationComponent}. */
+type AnimationComponentOptions = {
+    /** Initial set of clips imported from the entity's model. */
+    clips?: THREE.AnimationClip[];
+    /** URLs (or `localasset://` paths) of clips to load asynchronously and merge into the catalog. */
+    externalClipSources?: string[];
+    /** Name of the state to activate after construction. */
+    activeState?: string | null;
+    /** Whether playback starts paused. */
+    paused?: boolean;
+    /** Play the active clip in reverse. */
+    reverse?: boolean;
+    /** Time-scale multiplier (`1` = real-time). */
+    timeScale?: number;
+    /** Default cross-fade duration in seconds when switching states. */
+    crossFadeDuration?: number;
+    /** Predefined state machine entries (`name` -> clip binding). */
+    states?: Array<{
+        /** State name (must be unique). */
+        name: string;
+        /** Clip name to play in this state. */
+        clip: string;
+        /** Optional stable clip id used to disambiguate same-named clips. */
+        clipId?: string;
+        /** Loop the clip while in this state. */
+        loop?: boolean;
+    }>;
+};
+/** Catalog entry describing a clip available to the entity (from a model or an external source). */
+type AnimationClipCatalogEntry = {
+    /** Stable id used to reference the clip from state machines. */
+    id: string;
+    /** Internal clip name as stored on the `THREE.AnimationClip`. */
+    name: string;
+    /** Display label shown in the inspector. */
+    label: string;
+    /** Underlying three.js clip. */
+    clip: THREE.AnimationClip;
+    /** Where this clip came from. */
+    source: "model" | "external";
+    /** Source URL/path for `external` clips; `null` for clips imported from a model. */
+    sourceUrl: string | null;
+};
+type ImportedClipEntry = {
+    clip: THREE.AnimationClip;
+    sourceUrl: string | null;
+};
+/**
+ * Animation catalog and runtime state for an entity. Combines clips imported
+ * from a model with externally added clips, exposes a state machine for
+ * named transitions, and is queried each frame by the animation system to
+ * advance mixer time.
+ *
+ * @remarks
+ * Use the `addState` / `switchState` helpers rather than mutating the state
+ * machine directly so the animation system observes transitions.
+ *
+ * @category Components
+ */
+declare class AnimationComponent extends Component {
+    private modelClips;
+    private importedClips;
+    private clipById;
+    private clipEntriesById;
+    /** Combined ordered list of clips (model + external) currently loaded. */
+    clips: THREE.AnimationClip[];
+    /** Per-clip metadata used by the inspector. */
+    clipCatalog: AnimationClipCatalogEntry[];
+    /** Display names of clips available for state-machine bindings. */
+    availableClips: string[];
+    /** URLs/paths of external clip sources (saved with the project). */
+    externalClipSources: string[];
+    /** Whether playback is currently paused. */
+    paused: boolean;
+    /** Play the active clip in reverse. */
+    reverse: boolean;
+    /** Playback speed multiplier (`1` = real-time). */
+    timeScale: number;
+    /** Default cross-fade duration in seconds when switching states. */
+    crossFadeDuration: number;
+    /** All state-machine entries authored on this entity. */
+    states: AnimationStateMachine[];
+    /** State currently being played, or `null` if none. */
+    active: AnimationStateMachine | null;
+    /** Name of the {@link active} state, or `null` if none. */
+    activeStateName: string | null;
+    /** Manager that drives state transitions; mutate via {@link addState}/{@link switchState}. */
+    stateManager: AnimationStateManager;
+    constructor(options?: AnimationComponentOptions);
+    private refreshClipCatalog;
+    private refreshStateRefs;
+    private resolveClipRef;
+    setModelClips(clips: THREE.AnimationClip[]): void;
+    setImportedClips(clips: THREE.AnimationClip[] | ImportedClipEntry[]): void;
+    setExternalClipSources(sources: string[]): void;
+    addState(name: string, clipRef: string, loop?: boolean): AnimationStateMachine | null;
+    setStates(states: Array<{
+        name: string;
+        clip: string;
+        clipId?: string;
+        loop?: boolean;
+    }>): void;
+    getStateConfigs(): Array<{
+        name: string;
+        clip: string;
+        clipId: string | null;
+        loop: boolean;
+    }>;
+    setActiveState(name: string | null, autoPlay?: boolean): boolean;
+    removeState(name: string): boolean;
+    switchState(name: string, autoPlay?: boolean): boolean;
+    playState(name?: string): boolean;
+    pauseState(name?: string): boolean;
+    stopState(name?: string): boolean;
+}
+
+/** Runtime camera mode. `3d` is a free camera; `ar` is composited over a tracked image/face feed. */
+type CameraRuntimeType = "3d" | "ar";
+/** Projection model. */
+type CameraProjection = "perspective" | "orthographic";
+/** Optional initializer for {@link CameraComponent}. Any field omitted falls back to the defaults documented on the component. */
+type CameraComponentOptions = {
+    /** Pre-built three.js camera. When omitted the component creates one from {@link projection}. */
+    camera?: THREE.Camera;
+    /** Runtime camera mode. */
+    type?: CameraRuntimeType;
+    /** Mark this camera as the default camera the renderer uses. */
+    isDefault?: boolean;
+    /** Projection model. */
+    projection?: CameraProjection;
+    /** Vertical field of view in **degrees** (perspective only). */
+    fov?: number;
+    /** Near clip plane in world units. */
+    near?: number;
+    /** Far clip plane in world units. */
+    far?: number;
+    /** Left edge of the orthographic frustum in world units. */
+    left?: number;
+    /** Right edge of the orthographic frustum in world units. */
+    right?: number;
+    /** Top edge of the orthographic frustum in world units. */
+    top?: number;
+    /** Bottom edge of the orthographic frustum in world units. */
+    bottom?: number;
+    /** Zoom multiplier (`1` = no zoom). */
+    zoom?: number;
+};
+/**
+ * Camera entity state. Supports perspective and orthographic projections, a
+ * `3d` or `ar` runtime type, and an `isDefault` flag for the camera that the
+ * preview/editor renders through. Field-of-view, near/far, ortho frustum, and
+ * zoom are persisted; the live `THREE.Camera` is recreated when the project loads.
+ *
+ * @category Components
+ */
+declare class CameraComponent extends Component {
+    /** Live three.js camera. Recreated when the project loads to match {@link projection}. */
+    camera: THREE.Camera;
+    /** Runtime camera mode (`3d` or `ar`). */
+    type: CameraRuntimeType;
+    /** When `true`, this is the active rendering camera. Only one camera per scene should be the default. */
+    isDefault: boolean;
+    /** Active projection model (`perspective` or `orthographic`). */
+    projection: CameraProjection;
+    /** Vertical field of view in **degrees**. Used when {@link projection} is `perspective`. */
+    fov: number;
+    /** Near clip plane in world units. */
+    near: number;
+    /** Far clip plane in world units. */
+    far: number;
+    /** Left edge of the orthographic frustum (orthographic only). */
+    left: number;
+    /** Right edge of the orthographic frustum (orthographic only). */
+    right: number;
+    /** Top edge of the orthographic frustum (orthographic only). */
+    top: number;
+    /** Bottom edge of the orthographic frustum (orthographic only). */
+    bottom: number;
+    /** Zoom multiplier applied to the projection. */
+    zoom: number;
+    constructor(payload?: CameraComponentOptions);
+}
+
+/**
+ * @internal Default options applied when no override is provided.
+ */
+declare const DEFAULT_AUDIO_OPTIONS: {
+    autoplay: boolean;
+    loop: boolean;
+    pitch: number;
+    volume: number;
+    positional: boolean;
+    refDistance: number;
+    distanceModel: string;
+    rolloffFactor: number;
+};
+/**
+ * Plays an audio clip from `path`. Supports both global stereo (`positional:
+ * false`) and 3D positional audio with the configured distance model.
+ * Runtime fields (`object`, `audio`, `isPlaying`, `isPaused`) are recreated
+ * when the project loads and are never persisted to saved snapshots.
+ *
+ * @category Components
+ */
+declare class AudioComponent extends Component {
+    /** Source URL or `localasset://` path of the audio file. */
+    path: string;
+    /**
+     * Playback options.
+     *
+     * | Field | Default | Description |
+     * |---|---|---|
+     * | `autoplay` | `false` | Start playback as soon as the clip is loaded. |
+     * | `loop` | `false` | Loop playback indefinitely. |
+     * | `pitch` | `1` | Playback rate multiplier (`1` = normal speed/pitch). |
+     * | `volume` | `1` | Linear gain in `[0, 1]`. |
+     * | `positional` | `false` | When `true`, audio is spatialized using the entity's transform. |
+     * | `refDistance` | `1` | Distance at which volume is unattenuated (positional only). |
+     * | `distanceModel` | `"inverse"` | WebAudio distance model (`linear`, `inverse`, `exponential`). |
+     * | `rolloffFactor` | `1` | How quickly volume falls off past `refDistance`. |
+     */
+    options: typeof DEFAULT_AUDIO_OPTIONS;
+    /** Live three.js object hosting the audio (a parented `Audio`/`PositionalAudio`). `null` until built. */
+    object: THREE.Object3D | null;
+    /** Live three.js audio source. `null` until built. Recreated when the project loads. */
+    audio: THREE.Audio<GainNode> | THREE.PositionalAudio | null;
+    /**
+     * Whether the audio should be playing. Managed by `AudioSystem` in preview.
+     * Non-enumerable — not persisted to snapshots or save data.
+     * Set via {@link play} / {@link stop}.
+     */
+    isPlaying: boolean;
+    /**
+     * Whether the audio is paused mid-playback (position is preserved).
+     * Non-enumerable — not persisted to snapshots or save data.
+     * Set via {@link pause} / {@link play} / {@link stop}.
+     */
+    isPaused: boolean;
+    constructor(path: string, options?: Partial<typeof DEFAULT_AUDIO_OPTIONS>);
+    /**
+     * Signals `AudioSystem` to start (or resume) playback.
+     * Has no direct effect in the editor — `AudioSystem` drives the actual
+     * THREE.js call in preview.
+     */
+    play(): void;
+    /**
+     * Signals `AudioSystem` to pause playback, preserving the current position.
+     * Calling {@link play} afterwards resumes from where it paused.
+     * No-op if not currently playing.
+     */
+    pause(): void;
+    /**
+     * Signals `AudioSystem` to stop playback and reset the playback position.
+     */
+    stop(): void;
+}
+
+/** Skybox rendering modes. `none` disables skybox rendering entirely. */
+type EnvironmentSkyboxType = "gradient" | "color" | "image" | "none";
+/** Gradient distribution applied when {@link EnvironmentSkyboxState.type} is `"gradient"`. */
+type EnvironmentGradientEffect = "radial" | "linear" | "angular";
+/** Fog distance models. `none` disables fog. */
+type EnvironmentFogType = "linear" | "exponential" | "none";
+/** Skybox configuration. Only the fields relevant to {@link type} are read at render time. */
+type EnvironmentSkyboxState = {
+    /** Active skybox mode. */
+    type: EnvironmentSkyboxType;
+    /** Solid color used when {@link type} is `"color"`. `#rrggbb`. */
+    color: string;
+    /** URL or `localasset://` path of the equirectangular image used when {@link type} is `"image"`. */
+    imageUrl?: string;
+    /** Gradient parameters used when {@link type} is `"gradient"`. */
+    gradient: {
+        /** Ordered list of color stops as `#rrggbb` strings. */
+        colors: string[];
+        /** Gradient distribution. */
+        effect: EnvironmentGradientEffect;
+    };
+};
+/** Fog configuration. Mirrors three.js `Fog` / `FogExp2`. */
+type EnvironmentFogState = {
+    /** Active fog model. */
+    type: EnvironmentFogType;
+    /** Fog color as `#rrggbb`. */
+    color: string;
+    /** Linear-fog parameters used when {@link type} is `"linear"`. */
+    linear: {
+        /** Distance at which fog begins to take effect. */
+        near: number;
+        /** Distance at which fog reaches full opacity. */
+        far: number;
+    };
+    /** Exponential-fog parameters used when {@link type} is `"exponential"`. */
+    exponential: {
+        /** Density coefficient. Higher values produce thicker fog. */
+        density: number;
+    };
+};
+/** World gravity vector applied by the physics system, in world units per second squared. */
+type EnvironmentGravityState = {
+    /** Gravity along world X. */
+    x: number;
+    /** Gravity along world Y (negative pulls objects down). */
+    y: number;
+    /** Gravity along world Z. */
+    z: number;
+};
+/** Aggregated authoring state owned by {@link Environment}. */
+type EnvironmentState = {
+    /** Skybox configuration. */
+    skybox: EnvironmentSkyboxState;
+    /** Fog configuration. */
+    fog: EnvironmentFogState;
+    /** World gravity. */
+    gravity: EnvironmentGravityState;
+    /**
+     * Fixed timestep (seconds) used by the physics accumulator loop.
+     * Physics is stepped in fixed increments of this size each frame.
+     * Default is `0.02` (50 Hz).
+     */
+    fixedTimeStep: number;
+};
+declare const DEFAULT_ENVIRONMENT_STATE: EnvironmentState;
+/**
+ * Scene environment settings: skybox (gradient/color/image), fog
+ * (linear/exponential), and gravity vector for the physics world.
+ * Singleton-style — attached to one environment entity per scene.
+ *
+ * @category Components
+ */
+declare class Environment extends Component {
+    /** Aggregated environment authoring state (skybox, fog, gravity). Saved with the project. */
+    values: EnvironmentState;
+    constructor(values?: Partial<EnvironmentState>);
+}
+
+/** Aggregated post-processing effect chain authored on the scene environment. Each sub-effect has its own `enabled` flag plus per-effect parameters. */
+type PostprocessingState = {
+    /** Master toggle. When `false` no post-processing is applied even if individual effects are enabled. */
+    postEnabled: boolean;
+    /** Depth-of-field (bokeh) effect. */
+    dof: {
+        /** Enable the effect. */
+        enabled: boolean;
+        /** Distance to the focal plane in world units. */
+        focusDistance: number;
+        /** Lens focal length controlling depth-of-field strength. */
+        focalLength: number;
+        /** Bokeh blur kernel scale. */
+        bokehScale: number;
+    };
+    /** Bloom (HDR glow) effect. */
+    bloom: {
+        /** Enable the effect. */
+        enabled: boolean;
+        /** Strength of the bloom contribution. */
+        intensity: number;
+        /** Luminance threshold above which pixels bloom. */
+        threshold: number;
+        /** Blur radius applied to the bloom buffer. */
+        radius: number;
+    };
+    /** Vignette (corner darkening) effect. */
+    vignette: {
+        /** Enable the effect. */
+        enabled: boolean;
+        /** Distance from screen center where the vignette begins. */
+        offset: number;
+        /** Maximum darkness applied at screen edges. */
+        darkness: number;
+    };
+    /** Chromatic aberration (RGB channel offset) effect. */
+    chromAberration: {
+        /** Enable the effect. */
+        enabled: boolean;
+        /** Horizontal channel offset. */
+        offsetX: number;
+        /** Vertical channel offset. */
+        offsetY: number;
+    };
+    /** Film-noise overlay. */
+    noise: {
+        /** Enable the effect. */
+        enabled: boolean;
+        /** Opacity of the noise layer in `[0, 1]`. */
+        opacity: number;
+    };
+    /** Pixelation (mosaic) effect. */
+    pixelation: {
+        /** Enable the effect. */
+        enabled: boolean;
+        /** Pixel block size in screen pixels. */
+        granularity: number;
+    };
+    /** Tone-mapping exposure control. */
+    toneMapping: {
+        /** Enable the effect. */
+        enabled: boolean;
+        /** Exposure multiplier applied before tone-mapping. */
+        exposure: number;
+    };
+    /** Hue/saturation color grading. */
+    hueSaturation: {
+        /** Enable the effect. */
+        enabled: boolean;
+        /** Hue rotation in radians. */
+        hue: number;
+        /** Saturation offset (`0` = unchanged, `>0` = more saturated). */
+        saturation: number;
+    };
+    /** Sepia color grade. */
+    sepia: {
+        /** Enable the effect. */
+        enabled: boolean;
+        /** Blend strength between original and sepia in `[0, 1]`. */
+        intensity: number;
+    };
+    /** SMAA antialiasing pass. */
+    smaa: {
+        /** Enable the effect. */
+        enabled: boolean;
+    };
+    /** Screen-space ambient occlusion. */
+    ssao: {
+        /** Enable the effect. */
+        enabled: boolean;
+        /** Strength of the AO contribution. */
+        intensity: number;
+        /** Sampling radius in world units. */
+        radius: number;
+    };
+    /** Dot-screen (halftone) effect. */
+    dotScreen: {
+        /** Enable the effect. */
+        enabled: boolean;
+        /** Pattern scale (legacy field; use {@link scale} where available). */
+        dotScreenScale: number;
+        /** Pattern rotation in radians (legacy field; use {@link angle} where available). */
+        dotScreenAngle: number;
+        /** Pattern rotation in radians. */
+        angle?: number;
+        /** Pattern scale. */
+        scale?: number;
+        /** Three.js blend function override. */
+        blendFunction?: number;
+        /** Effect opacity in `[0, 1]`. */
+        opacity?: number;
+    };
+    /** Glitch effect (digital corruption simulation). */
+    glitch: {
+        /** Enable the effect. */
+        enabled: boolean;
+        /** Three.js blend function override. */
+        blendFunction?: number;
+        /** RGB channel offset applied during a glitch burst. */
+        chromaticAberrationOffset?: {
+            x: number;
+            y: number;
+        } | [number, number];
+        /** `[min, max]` delay (seconds) between glitch bursts. */
+        delay?: [number, number];
+        /** `[min, max]` duration (seconds) of each glitch burst. */
+        duration?: [number, number];
+        /** Glitch displacement strength (scalar or per-axis). */
+        strength?: number | {
+            x: number;
+            y: number;
+        };
+        /** Size of the displacement texture sampled by the glitch shader. */
+        dtSize?: number;
+        /** Fraction of columns affected during a glitch burst. */
+        columns?: number;
+        /** Ratio between weak and strong glitch bursts. */
+        ratio?: number;
+        /** Glitch mode label (matches the postprocessing library's mode enum). */
+        mode?: string;
+        /** Force the glitch to remain active. */
+        active?: boolean;
+    };
+};
+declare const DEFAULT_POSTPROCESSING_STATE: PostprocessingState;
+/**
+ * Postprocessing stack settings (depth-of-field, bloom, vignette, chromatic
+ * aberration, noise, pixelation, tone mapping, hue/saturation, sepia, SMAA,
+ * SSAO, dot-screen, glitch). The render system applies enabled effects in a
+ * `postprocessing`-library composer when `postEnabled` is `true`. Singleton-
+ * style — attached to one entity per scene.
+ *
+ * @category Components
+ */
+declare class Postprocessing extends Component {
+    /** Aggregated post-processing state. Saved with the project. */
+    values: PostprocessingState;
+    constructor(values?: Partial<PostprocessingState>);
+}
+
+type RapierRigidBody = RAPIER.RigidBody;
+type RapierCollider = RAPIER.Collider;
+/**
+ * Rigidbody body type:
+ * - `dynamic`: simulated by physics; affected by forces and gravity.
+ * - `fixed`: immovable static body.
+ * - `kinematicPosition`: moved by setting next position; ignores forces.
+ * - `kinematicVelocity`: moved by setting velocity; ignores forces.
+ */
+type RigidbodyType = "dynamic" | "fixed" | "kinematicPosition" | "kinematicVelocity";
+/** Authoring state for the rigidbody half of {@link PhysicsComponent}. Saved with the project. */
+type RigidbodyState = {
+    /** When `false`, the body is removed from physics simulation but kept in state. */
+    enabled: boolean;
+    /** Body type. See {@link RigidbodyType}. */
+    type: RigidbodyType;
+    /** Mass in kilograms. Only meaningful for `dynamic` bodies. */
+    mass: number;
+    /** Damping applied to linear velocity each step (`0` = none). */
+    linearDamping: number;
+    /** Damping applied to angular velocity each step (`0` = none). */
+    angularDamping: number;
+    /** Scale factor applied to world gravity for this body (`1` = full gravity, `0` = floating). */
+    gravityScale: number;
+    /** Allow the body to sleep when at rest to save simulation cost. */
+    canSleep: boolean;
+    /** Enable continuous collision detection to prevent tunneling for fast bodies. */
+    ccdEnabled: boolean;
+    /** Master toggle: when `true`, all linear motion is locked. */
+    lockTranslations: boolean;
+    /** Lock translation along world X. */
+    lockTranslationX: boolean;
+    /** Lock translation along world Y. */
+    lockTranslationY: boolean;
+    /** Lock translation along world Z. */
+    lockTranslationZ: boolean;
+    /** Master toggle: when `true`, all rotation is locked. */
+    lockRotations: boolean;
+    /** Lock rotation around world X. */
+    lockRotationX: boolean;
+    /** Lock rotation around world Y. */
+    lockRotationY: boolean;
+    /** Lock rotation around world Z. */
+    lockRotationZ: boolean;
+};
+declare const DEFAULT_RIGIDBODY_STATE: RigidbodyState;
+/** Collider primitive shape. `trimesh` derives geometry from the entity's mesh. */
+type ColliderShape = "cuboid" | "ball" | "capsule" | "cylinder" | "trimesh";
+/** Authoring state for the collider half of {@link PhysicsComponent}. Only the size fields relevant to {@link ColliderState.shape} are read at simulation time. */
+type ColliderState = {
+    /** When `false`, the collider is removed from physics simulation but kept in state. */
+    enabled: boolean;
+    /** Collider primitive shape. */
+    shape: ColliderShape;
+    /** Local offset of the collider relative to the entity's transform, in world units. */
+    offsetPosition: {
+        /** Offset along local X. */
+        x: number;
+        /** Offset along local Y. */
+        y: number;
+        /** Offset along local Z. */
+        z: number;
+    };
+    /** Local rotation offset in **radians** (Euler XYZ). */
+    offsetRotation: {
+        /** Rotation around local X (radians). */
+        x: number;
+        /** Rotation around local Y (radians). */
+        y: number;
+        /** Rotation around local Z (radians). */
+        z: number;
+    };
+    /** Half-extents for `cuboid` shape, in world units. */
+    size: {
+        /** Half-extent along X. */
+        x: number;
+        /** Half-extent along Y. */
+        y: number;
+        /** Half-extent along Z. */
+        z: number;
+    };
+    /** Radius for `ball`, `capsule`, and `cylinder` shapes. */
+    radius: number;
+    /** Height for `capsule` (segment length between caps) and `cylinder`. */
+    height: number;
+    /** Bounciness in `[0, 1]`. `0` is no bounce; `1` is perfectly elastic. */
+    restitution: number;
+    /** Surface friction coefficient. `0` is frictionless. */
+    friction: number;
+    /** When `true`, the collider reports overlaps but does not generate contact responses. */
+    isSensor: boolean;
+};
+declare const DEFAULT_COLLIDER_STATE: ColliderState;
+/** Combined authoring state for {@link PhysicsComponent}. Saved with the project. */
+type PhysicsState = {
+    /** Rigid body settings. */
+    rigidbody: RigidbodyState;
+    /** Collider settings. */
+    collider: ColliderState;
+};
+declare const DEFAULT_PHYSICS_STATE: PhysicsState;
+declare function normalizePhysicsState(value: {
+    rigidbody?: Partial<RigidbodyState>;
+    collider?: Partial<ColliderState>;
+} | undefined): PhysicsState;
+/**
+ * Unified physics component combining a Rapier rigid body and a Rapier
+ * collider into a single authoring and runtime container.
+ *
+ * Use `values.rigidbody` to configure body type, mass, damping, locks, etc.
+ * Use `values.collider` to configure collider shape, size, offset, material
+ * properties, and sensor mode.
+ *
+ * The runtime `rigidBody` and `collider` references are created by the physics
+ * system when the project loads and are `null` until physics is initialized.
+ *
+ * @category Components
+ */
+declare class PhysicsComponent extends Component {
+    /** Authoring state. Saved with the project. */
+    values: PhysicsState;
+    /** Live Rapier rigid body. `null` until physics is initialized. */
+    rigidBody: RapierRigidBody | null;
+    /** Live Rapier collider. `null` until physics is initialized. */
+    collider: RapierCollider | null;
+    constructor(values?: {
+        rigidbody?: Partial<RigidbodyState>;
+        collider?: Partial<ColliderState>;
+    });
+    /**
+     * Patch rigidbody and/or collider state. Each sub-object is deep-merged
+     * with the current values via the respective normalizer.
+     */
+    setValues(patch: {
+        rigidbody?: Partial<RigidbodyState>;
+        collider?: Partial<ColliderState>;
+    }): void;
+}
+
+/**
+ * Tags an entity with the kind it was created from (`cube`, `sphere`,
+ * `model`, `directionalLight`, etc.). Factories use this to drive
+ * kind-specific behavior; the editor inspector uses it to select component
+ * editors.
+ *
+ * @category Components
+ */
+declare class EntityType extends Component {
+    /** Kind tag identifying which factory created this entity (e.g. `cube`, `directionalLight`, `model`). */
+    value: EcsEntityKind | EcsEntityEditorKind;
+    constructor(value: EcsEntityKind | EcsEntityEditorKind);
+}
+
+/**
+ * Renders a 2D image as a textured quad in the scene. Width/height are in
+ * world units. Texture loading is handled by the image system, which
+ * populates {@link ImageComponent.texture} and {@link ImageComponent.object}
+ * asynchronously.
+ *
+ * @category Components
+ */
+declare class ImageComponent extends Component {
+    /** Source URL or `localasset://` path of the image file. */
+    path: string;
+    /** Width of the rendered quad in world units. */
+    width: number;
+    /** Height of the rendered quad in world units. */
+    height: number;
+    /** Loaded texture, populated asynchronously by the image system. `null` until loaded. */
+    texture: THREE.Texture | null;
+    /** Live three.js object representing the textured quad. `null` until built. */
+    object: THREE.Object3D | null;
+    constructor(path: string, width?: number, height?: number);
+}
+
+/** Single uploaded image used as input to the image-target compiler. */
+type ImageTargetReference = {
+    /** Stable target id assigned at compile time. Referenced by {@link ImageTargetAnchor.targetId}. */
+    id: number;
+    /** Source image URL or `localasset://` path. */
+    url: string;
+    /** Image width in pixels. */
+    width: number;
+    /** Image height in pixels. */
+    height: number;
+    /** Local directory the source image is stored in (desktop projects). */
+    storageDir?: string;
+    /** Local file name for the source image (desktop projects). */
+    fileName?: string;
+};
+/**
+ * Image-tracking target metadata used by AR projects. Holds the source images
+ * users uploaded plus the URL of the compiled `.mind` target file produced by
+ * the image-target compiler. Pair with {@link ImageTargetAnchor} on child
+ * entities that should appear when the target is detected.
+ *
+ * @category Components
+ */
+declare class ImageTarget extends Component {
+    /** Source images that were combined into the compiled `.mind` target. */
+    targets: ImageTargetReference[];
+    /** URL of the compiled `.mind` target file. Set after the image-target compiler finishes. */
+    compiledTargetUrl?: string;
+    /** Directory containing the compiled `.mind` file (desktop projects). */
+    compiledTargetDir?: string;
+    /** Optional preview texture used in the editor viewport. `null` when not assigned. */
+    texture: THREE.Texture | null;
+    /** Optional preview object placed in the editor viewport. `null` when not assigned. */
+    object: THREE.Object3D | null;
+    constructor(options?: {
+        targets?: ImageTargetReference[];
+        compiledTargetUrl?: string;
+        compiledTargetDir?: string;
+    }, texture?: THREE.Texture, object?: THREE.Object3D);
+}
+
+/** Optional initializer for {@link ImageTargetAnchor}. */
+type ImageTargetAnchorOptions = {
+    /** Id of the tracked target this anchor follows (matches `ImageTargetReference.id`). */
+    targetId?: number | null;
+    /** Optional canonical URL of the target image, used as a fallback identifier. */
+    targetUrl?: string;
+};
+/**
+ * Marks an entity as an anchor for an image-tracking target. The image
+ * tracking system reveals the entity when the referenced target is found and
+ * hides it when the target is lost.
+ *
+ * @category Components
+ */
+declare class ImageTargetAnchor extends Component {
+    /** Tracked target id this anchor follows. `null` when unbound. */
+    targetId: number | null;
+    /** Canonical target image URL, retained as a fallback identifier. */
+    targetUrl?: string;
+    constructor(options?: ImageTargetAnchorOptions);
+}
+
+/** Authoring state for {@link LightComponent}. Common fields apply to every light kind; the optional fields are only meaningful for specific kinds. */
+type LightValueState = {
+    /** Light color as `#rrggbb` hex string. */
+    color: string;
+    /** Light intensity multiplier (units depend on three.js physically-correct mode). */
+    intensity: number;
+    /** Whether the light casts shadows. */
+    castShadow: boolean;
+    /** Whether the light is frustum-culled when off-screen. */
+    frustumCulling: boolean;
+    /** Maximum range; `0` means infinite. (PointLight, SpotLight) */
+    distance?: number;
+    /** Falloff exponent for distance attenuation. (PointLight, SpotLight) */
+    decay?: number;
+    /** Cone half-angle in **radians**. (SpotLight) */
+    angle?: number;
+    /** Soft-edge factor in `[0, 1]`; `0` is a hard edge. (SpotLight) */
+    penumbra?: number;
+    /** Rectangle width in world units. (RectAreaLight) */
+    width?: number;
+    /** Rectangle height in world units. (RectAreaLight) */
+    height?: number;
+};
+/**
+ * Light source attached to an entity. `type` selects the underlying three.js
+ * light class (directional, point, spot, ambient, hemisphere, rect-area).
+ * `values` carries authoring state including color, intensity, and
+ * type-specific fields (distance, decay, angle, penumbra, width, height).
+ *
+ * @category Components
+ */
+declare class LightComponent extends Component {
+    /** Live three.js light placed in the scene. Recreated when the project loads. */
+    light: THREE.Light;
+    /** Three.js class name of the light (e.g. `"DirectionalLight"`, `"PointLight"`, `"SpotLight"`). */
+    type: string;
+    /** Serialized authoring state. Saved with the project. */
+    values: LightValueState;
+    constructor(light: THREE.Light);
+    setValues(patch: Partial<LightValueState>): void;
+}
+
+/** Supported material classes. Each maps to a three.js `Mesh*Material` type. */
+type MaterialTypeValue = "standard" | "basic" | "phong" | "physical";
+/** Texture sampling mode. `smooth` uses linear filtering; `sharp` uses nearest filtering for pixel-art look. */
+type TextureFilteringValue = "smooth" | "sharp";
+/** Authoring state for a single slot in {@link MaterialComponent.values}. Mirrors the live three.js material so it can be re-applied when the project loads. */
+type MaterialValueState = {
+    /** Underlying material class. */
+    type: MaterialTypeValue;
+    /** Base color as `#rrggbb` hex string. */
+    color: string;
+    /** PBR roughness in `[0, 1]`. */
+    roughness: number;
+    /** PBR metalness in `[0, 1]`. */
+    metalness: number;
+    /** Multiplier applied to the normal map (uniform on both axes). */
+    normalScale: number;
+    /** Surface opacity in `[0, 1]`. Combine with {@link transparent} to enable alpha. */
+    opacity: number;
+    /** Emissive color as `#rrggbb` hex string. */
+    emissive: string;
+    /** Emissive intensity multiplier. */
+    emissiveIntensity: number;
+    /** Three.js `Side` enum value (`FrontSide`, `BackSide`, or `DoubleSide`). */
+    side: number;
+    /** Three.js `Blending` enum value. */
+    blending: number;
+    /** Whether depth testing is enabled. */
+    depthTest: boolean;
+    /** Whether depth writes are enabled. */
+    depthWrite: boolean;
+    /** Render as wireframe. */
+    wireframe: boolean;
+    /** Enable transparency (must be `true` for {@link opacity} < 1 to render correctly). */
+    transparent: boolean;
+    /** Color/diffuse texture URL. */
+    textureMap?: string;
+    /** Alpha (transparency) texture URL. */
+    alphaTextureMap?: string;
+    /** Tangent-space normal map URL. */
+    normalMap?: string;
+    /** Roughness map URL (red channel). */
+    roughnessMap?: string;
+    /** Metalness map URL (red channel). */
+    metalnessMap?: string;
+    /** Ambient occlusion map URL. */
+    aoMap?: string;
+    /** Emissive color map URL. */
+    emissiveMap?: string;
+    /** Bump map URL (height-based shading approximation). */
+    bumpMap?: string;
+    /** Displacement map URL (geometric vertex offset). */
+    displacementMap?: string;
+    /** Pre-baked light map URL. */
+    lightMap?: string;
+    /** Environment reflection map URL. */
+    envMap?: string;
+    /** Texture sampling mode applied to the color map. */
+    textureFiltering: TextureFilteringValue;
+    /** Whether mipmaps are generated for texture maps. */
+    useMipmaps: boolean;
+};
+/**
+ * Material catalog for an entity. Tracks the live three.js materials
+ * (`materials`, `material`) plus serialized authoring state (`values[]`)
+ * mirrored from the inspector. Supports `standard`, `basic`, `phong`, and
+ * `physical` PBR types with optional texture map slots.
+ *
+ * @remarks
+ * Use `setMaterials`, `updateValue`, `setMaterialType`, `setTextureFiltering`,
+ * and `setUseMipmaps` to mutate state — these keep `values[]` and the live
+ * three.js materials in sync. Texture URLs use the `localasset://` protocol
+ * inside the editor.
+ *
+ * @category Components
+ */
+declare class MaterialComponent extends Component {
+    /** Live three.js materials currently bound to the entity's mesh (one per submesh). */
+    materials: THREE.Material[];
+    /** Convenience reference to `materials[0]`. `null` when no material is assigned. */
+    material: THREE.Material | null;
+    /** Serialized authoring state (one entry per material in {@link materials}). Saved with the project. */
+    values: MaterialValueState[];
+    constructor(materialOrMaterials?: THREE.Material | THREE.Material[]);
+    setMaterials(materialOrMaterials?: THREE.Material | THREE.Material[]): void;
+    updateValue(index: number, patch: Partial<MaterialValueState>): void;
+    resetValue(index: number): void;
+    setMaterialType(index: number, type: MaterialTypeValue): void;
+    setTextureFiltering(index: number, filtering: TextureFilteringValue): void;
+    setUseMipmaps(index: number, enabled: boolean): void;
+}
+
+/**
+ * Holds the live three.js `Object3D` for an entity that renders as a primitive
+ * mesh (cube, sphere, plane, capsule, cylinder). For loaded GLTF/GLB models
+ * see {@link ModelComponent}; for the editable geometry parameters see
+ * {@link MeshGeometryComponent}.
+ *
+ * @category Components
+ */
+declare class MeshComponent extends Component {
+    /** Underlying three.js mesh placed in the scene graph. */
+    mesh: THREE.Object3D;
+    constructor(mesh: THREE.Object3D);
+}
+
+/** Editable primitive kinds the mesh-geometry system can rebuild on the fly. `model` is a passthrough placeholder for entities that own a loaded GLTF/GLB instead. */
+type EditableMeshObjectKind = "capsule" | "cube" | "cylinder" | "model" | "plane" | "sphere";
+/** Box geometry parameters in world units. */
+type CubeMeshParameters = {
+    /** Box width along X. */
+    width: number;
+    /** Box height along Y. */
+    height: number;
+    /** Box depth along Z. */
+    depth: number;
+};
+/** Plane geometry parameters in world units. */
+type PlaneMeshParameters = {
+    /** Plane width along X. */
+    width: number;
+    /** Plane height along Y. */
+    height: number;
+};
+/** Radius-only primitive parameters (sphere). */
+type RadiusMeshParameters = {
+    /** Sphere radius in world units. */
+    radius: number;
+};
+/** Radius + height primitive parameters (capsule, cylinder). */
+type RadiusHeightMeshParameters = {
+    /** Radius of the cap/cylinder cross-section. */
+    radius: number;
+    /** Length of the straight section between caps (capsule) or full height (cylinder). */
+    height: number;
+};
+/** Empty parameter set for `model` entities. */
+type ModelMeshParameters = Record<string, never>;
+/** Map from {@link EditableMeshObjectKind} to its parameter shape. */
+type MeshGeometryParametersByKind = {
+    capsule: RadiusHeightMeshParameters;
+    cube: CubeMeshParameters;
+    cylinder: RadiusHeightMeshParameters;
+    model: ModelMeshParameters;
+    plane: PlaneMeshParameters;
+    sphere: RadiusMeshParameters;
+};
+type MeshGeometryParameters = MeshGeometryParametersByKind[EditableMeshObjectKind];
+declare const DEFAULT_MESH_GEOMETRY_PARAMETERS: MeshGeometryParametersByKind;
+/**
+ * Editable geometry parameters for primitive meshes (cube, sphere, plane,
+ * capsule, cylinder) and the placeholder for `model` entities. Holds the
+ * authoring values plus shadow casting/receiving flags. The mesh-geometry
+ * system rebuilds the underlying `BufferGeometry` when parameters change.
+ *
+ * @category Components
+ */
+declare class MeshGeometryComponent extends Component {
+    /** Primitive kind (`cube`, `sphere`, `plane`, `capsule`, `cylinder`) or `model` for loaded assets. */
+    readonly kind: EditableMeshObjectKind;
+    /** Three.js geometry class name (e.g. `"BoxGeometry"`, `"SphereGeometry"`). Derived from {@link kind}. */
+    readonly geometryType: string;
+    /** Editable parameters whose shape depends on {@link kind}. The mesh-geometry system rebuilds geometry when these change. */
+    parameters: MeshGeometryParameters;
+    /** Live three.js object whose geometry is being managed. `null` until the object is built. */
+    object: THREE.Object3D | null;
+    /** Human-readable model name shown in the inspector for `model` entities; empty for primitives. */
+    modelName: string;
+    /** Whether the mesh casts shadows in the renderer. */
+    castShadow: boolean;
+    /** Whether the mesh receives shadows in the renderer. */
+    receiveShadow: boolean;
+    constructor(kind: EditableMeshObjectKind, object: THREE.Object3D | null, parameters?: Partial<MeshGeometryParameters>, options?: {
+        modelName?: string;
+        castShadow?: boolean;
+        receiveShadow?: boolean;
+    });
+}
+
+/**
+ * References a GLTF/GLB asset loaded from `path`. The model loading system
+ * resolves the asset asynchronously and populates {@link ModelComponent.object}
+ * once available; loading is deferred-tolerant so the entity exists before
+ * the model finishes loading.
+ *
+ * @category Components
+ */
+declare class ModelComponent extends Component {
+    /** Source URL or `localasset://` path of the GLTF/GLB asset. */
+    path: string;
+    /** Loaded model object, populated asynchronously by the model loader. `null` until loaded. */
+    object: THREE.Object3D | null;
+    constructor(path: string);
+}
+
+/**
+ * Human-readable name for an entity. Shown in the editor hierarchy panel and
+ * preserved across save/reload.
+ *
+ * @category Components
+ */
+declare class Name extends Component {
+    /** Display name for the entity. Shown in the editor hierarchy. */
+    value: string;
+    constructor(value: string);
+}
+
+/**
+ * Wraps the live `THREE.Object3D` for an entity. Almost every entity that
+ * renders to the scene carries an `Object3DRef` so transform sync, selection,
+ * and parenting systems can manipulate the underlying object.
+ *
+ * @remarks
+ * The `object` reference may be replaced when assets finish loading. Read it
+ * fresh inside system/script hooks rather than caching it across frames.
+ *
+ * @category Components
+ */
+declare class Object3DRef extends Component {
+    /** Live three.js object placed in the scene graph. May be replaced when assets finish loading. */
+    object: THREE.Object3D;
+    /** Whether the object is currently visible. Mirrors `object.visible` and is preserved across reloads. */
+    visibility: boolean;
+    constructor(object: THREE.Object3D, visibility?: boolean);
+}
+
+/**
+ * One script attached to an entity. Multiple entries may target a single
+ * entity (different classes from the same or different files).
+ */
+type ScriptEntry = {
+    /** Owning entity id. */
+    entityId: number;
+    /** Class name exported by the script module (default export class name). */
+    className: string;
+    /** Compiled script URL (e.g. `localasset://.../scripts/foo.js`). */
+    scriptUrl: string;
+    /** When `false`, the script is skipped each frame. */
+    enabled: boolean;
+    /**
+     * When `true`, the script is executed inside the editor (not just at preview/runtime).
+     * Enables direct Three.js scene access via `this.world.getScene()` / `getCamera()` /
+     * `getRenderer()` for logic the editor's object palette cannot produce (custom shaders,
+     * procedural geometry, grass, etc.). Defaults to `false`.
+     */
+    executeInEditor?: boolean;
+    /** Inspector-bound payload exposed to the script as `this.data`. */
+    data: Record<string, unknown>;
+    /** Last load/runtime status reported by `ScriptBehaviourSystem`. */
+    runtimeState?: "idle" | "loading" | "ready" | "error";
+    /** Optional human-readable status message (e.g. compile/load error). */
+    runtimeMessage?: string;
+};
+/**
+ * Component holding the list of {@link ScriptEntry | scripts} attached to an
+ * entity. Loaded from the saved project; the runtime-side fields
+ * (`scriptInstance`, `scriptInstances`) are non-enumerable so they never leak
+ * into save data or undo history.
+ *
+ * @remarks
+ * Authored scripts subclass {@link Behaviour}.
+ *
+ * @category Components
+ */
+declare class ScriptComponent extends Component {
+    /** Authored script entries attached to the entity. Each entry references a class by name plus its inspector field overrides. Saved with the project. */
+    entries: ScriptEntry[];
+    /** First live behaviour instance after compile/load. Non-enumerable, so it does not appear in save data. `null` when no script is loaded. */
+    scriptInstance: unknown | null;
+    /** Map of `entityId` to its compiled behaviour instance (one entry per script bound to the entity). Non-enumerable, so it does not appear in save data. */
+    scriptInstances: Map<number, unknown>;
+    constructor(entries?: ScriptEntry[]);
+}
+
+/**
+ * Toggles whether the editor selection system can pick this entity. When
+ * `enabled` is `false`, the entity is excluded from raycast hit tests.
+ *
+ * @category Components
+ */
+declare class Selectable extends Component {
+    /** When `false`, the editor selection raycaster ignores this entity. */
+    enabled: boolean;
+    constructor(enabled?: boolean);
+}
+
+/**
+ * Camera-facing 2D sprite. Unlike {@link ImageComponent}, sprites use
+ * `THREE.Sprite` and always render as billboards.
+ *
+ * @category Components
+ */
+declare class SpriteComponent extends Component {
+    /** Source URL or `localasset://` path of the sprite image. */
+    path: string;
+    /** Width of the sprite in world units. */
+    width: number;
+    /** Height of the sprite in world units. */
+    height: number;
+    /** Loaded texture, populated asynchronously. `null` until loaded. */
+    texture: THREE.Texture | null;
+    /** Live `THREE.Sprite` placed in the scene. `null` until built. */
+    object: THREE.Sprite | null;
+    constructor(path: string, width?: number, height?: number);
+}
+
+/** Active gizmo mode in the editor. */
+type TransformModeValue = "translate" | "rotate" | "scale";
+/** Reference frame for the active gizmo. */
+type TransformSpaceValue = "world" | "local";
+/**
+ * Singleton-style component (attached once to a system entity) that mirrors
+ * the editor's current transform-gizmo state into the ECS world. Persisted in
+ * snapshots so undo/redo restores the exact gizmo configuration.
+ *
+ * @category Components
+ */
+declare class SelectionTransformState extends Component {
+    /** Active gizmo mode (`translate`, `rotate`, or `scale`). */
+    transform: TransformModeValue;
+    /** Reference frame for the gizmo (`world` or `local`). */
+    space: TransformSpaceValue;
+    /** Currently selected entity id, or `null` if nothing is selected. */
+    selectedEntityId: EntityId | null;
+    constructor(transform?: TransformModeValue, space?: TransformSpaceValue, selectedEntityId?: EntityId | null);
+}
+
+/**
+ * @internal Default options applied when no override is provided.
+ */
+declare const DEFAULT_VIDEO_OPTIONS: {
+    autoplay: boolean;
+    loop: boolean;
+    volume: number;
+    width: number;
+    height: number;
+    isGreenScreen: boolean;
+    backgroundColor: string;
+    similarity: number;
+    smoothness: number;
+    spill: number;
+    /** When `true`, the video's audio stream is spatialized using the entity's transform. */
+    positional: boolean;
+    /** Distance at which volume is unattenuated (positional only). */
+    refDistance: number;
+    /** WebAudio distance model (`linear`, `inverse`, `exponential`). Positional only. */
+    distanceModel: string;
+    /** How quickly volume falls off past `refDistance`. Positional only. */
+    rolloffFactor: number;
+};
+/**
+ * Plays a video file as a texture on a quad. Supports green-screen keying
+ * (`isGreenScreen`, `backgroundColor`, `similarity`, `smoothness`, `spill`).
+ * The video element, texture, and material are runtime-only and re-created
+ * when the project loads.
+ *
+ * @category Components
+ */
+declare class VideoComponent extends Component {
+    /** Source URL or `localasset://` path of the video file. */
+    path: string;
+    /**
+     * Playback + green-screen options.
+     *
+     * | Field | Default | Description |
+     * |---|---|---|
+     * | `autoplay` | `false` | Start playback as soon as the video is ready. |
+     * | `loop` | `true` | Loop playback indefinitely. |
+     * | `volume` | `1` | Linear gain in `[0, 1]`. |
+     * | `width` | `1` | Quad width in world units. |
+     * | `height` | `1` | Quad height in world units. |
+     * | `isGreenScreen` | `false` | Enable chroma keying using the fields below. |
+     * | `backgroundColor` | `"#00ff00"` | Color to key out (CSS color string). |
+     * | `similarity` | `0.4` | How close a pixel must be to the key to be removed (`0`–`1`). |
+     * | `smoothness` | `0.08` | Soft-edge thickness around the key threshold. |
+     * | `spill` | `0.12` | Amount of color spill suppression near edges. |
+     * | `positional` | `false` | When `true`, the video's audio stream is spatialized using the entity's 3D position. |
+     * | `refDistance` | `1` | Distance at which volume is unattenuated (positional only). |
+     * | `distanceModel` | `"inverse"` | WebAudio distance model (`linear`, `inverse`, `exponential`). Positional only. |
+     * | `rolloffFactor` | `1` | How quickly volume falls off past `refDistance`. Positional only. |
+     */
+    options: typeof DEFAULT_VIDEO_OPTIONS;
+    /** Live three.js object hosting the video quad. `null` until built. */
+    object: THREE.Object3D | null;
+    /** Underlying HTML video element. `null` until built. */
+    videoElement: HTMLVideoElement | null;
+    /** Three.js texture sampling the video element. `null` until built. */
+    texture: THREE.VideoTexture | null;
+    /** Material rendering the video texture (with green-screen shader when enabled). `null` until built. */
+    material: THREE.Material | null;
+    /**
+     * THREE.js audio node connected to this video's audio stream via
+     * `setMediaElementSource`. Present only in preview when the camera
+     * listener is available. `null` in editor mode.
+     */
+    audioNode: THREE.Audio<GainNode> | THREE.PositionalAudio | null;
+    /**
+     * Whether the video should be playing. Managed by `VideoSystem` in preview.
+     * Non-enumerable — not persisted to snapshots or save data.
+     * Set via {@link play} / {@link stop}.
+     */
+    isPlaying: boolean;
+    /**
+     * Whether the video is paused mid-playback (position is preserved).
+     * Non-enumerable — not persisted to snapshots or save data.
+     * Set via {@link pause} / {@link play} / {@link stop}.
+     */
+    isPaused: boolean;
+    constructor(path: string, options?: Partial<typeof DEFAULT_VIDEO_OPTIONS>);
+    /**
+     * Signals `VideoSystem` to start (or resume) playback.
+     * Has no direct effect in the editor — `VideoSystem` drives the actual
+     * HTML video element call in preview.
+     */
+    play(): void;
+    /**
+     * Signals `VideoSystem` to pause playback, preserving the current position.
+     * Calling {@link play} afterwards resumes from where it paused.
+     * No-op if not currently playing.
+     */
+    pause(): void;
+    /**
+     * Signals `VideoSystem` to stop playback and reset the playback position.
+     */
+    stop(): void;
+}
+
+export { Selectable as $, AnimationComponent as A, type MaterialTypeValue as B, CameraComponent as C, DEFAULT_COLLIDER_STATE as D, type EditableMeshObjectKind as E, type MaterialValueState as F, MeshComponent as G, MeshGeometryComponent as H, ImageComponent as I, type MeshGeometryParameters as J, type MeshGeometryParametersByKind as K, LightComponent as L, MaterialComponent as M, ModelComponent as N, Name as O, Object3DRef as P, PhysicsComponent as Q, type PhysicsState as R, type PlaneMeshParameters as S, Postprocessing as T, type PostprocessingState as U, type RadiusHeightMeshParameters as V, type RadiusMeshParameters as W, type RigidbodyState as X, type RigidbodyType as Y, ScriptComponent as Z, type ScriptEntry as _, type AnimationComponentOptions as a, SelectionTransformState as a0, SpriteComponent as a1, type TextureFilteringValue as a2, type TransformModeValue as a3, type TransformSpaceValue as a4, VideoComponent as a5, normalizePhysicsState as a6, type AnimationStateCallbacks as a7, AnimationStateMachine as a8, AnimationStateManager as a9, type StateMachine as aa, AudioComponent as b, type CameraComponentOptions as c, type CameraProjection as d, type CameraRuntimeType as e, type ColliderShape as f, type ColliderState as g, type CubeMeshParameters as h, DEFAULT_ENVIRONMENT_STATE as i, DEFAULT_MESH_GEOMETRY_PARAMETERS as j, DEFAULT_PHYSICS_STATE as k, DEFAULT_POSTPROCESSING_STATE as l, DEFAULT_RIGIDBODY_STATE as m, EntityType as n, Environment as o, type EnvironmentFogState as p, type EnvironmentFogType as q, type EnvironmentGradientEffect as r, type EnvironmentSkyboxState as s, type EnvironmentSkyboxType as t, type EnvironmentState as u, ImageTarget as v, ImageTargetAnchor as w, type ImageTargetAnchorOptions as x, type ImageTargetReference as y, type LightValueState as z };