@holoscript/engine 6.0.3 → 6.0.4

package/dist/spatial/index.d.cts

@@ -0,0 +1,1545 @@
+import { EventEmitter } from 'events';
+
+/**
+ * Spatial Types for Agent Context Awareness
+ * Sprint 4 Priority 4 - Spatial Context Awareness
+ *
+ * Enables agents to understand and reason about spatial relationships
+ * in XR environments.
+ */
+/**
+ * 3D Vector representation
+ */
+interface Vector3 {
+    x: number;
+    y: number;
+    z: number;
+}
+/**
+ * 2D Vector for screen/UI space
+ */
+interface Vector2 {
+    x: number;
+    y: number;
+}
+/**
+ * Quaternion for rotation
+ */
+interface Quaternion {
+    x: number;
+    y: number;
+    z: number;
+    w: number;
+}
+/**
+ * Axis-aligned bounding box
+ */
+interface BoundingBox {
+    min: Vector3;
+    max: Vector3;
+}
+/**
+ * Oriented bounding box with rotation
+ */
+interface OrientedBoundingBox {
+    center: Vector3;
+    halfExtents: Vector3;
+    rotation: Quaternion;
+}
+/**
+ * Sphere bounds
+ */
+interface BoundingSphere {
+    center: Vector3;
+    radius: number;
+}
+/**
+ * Entity that exists in spatial space
+ */
+interface SpatialEntity {
+    id: string;
+    type: string;
+    position: Vector3;
+    rotation?: Quaternion;
+    bounds?: BoundingBox | BoundingSphere;
+    velocity?: Vector3;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Defined region in space
+ */
+interface Region {
+    id: string;
+    name: string;
+    type: 'box' | 'sphere' | 'polygon' | 'custom';
+    bounds: BoundingBox | BoundingSphere;
+    properties?: Record<string, unknown>;
+}
+/**
+ * Line of sight between two points
+ */
+interface SightLine {
+    from: Vector3;
+    to: Vector3;
+    blocked: boolean;
+    blockingEntity?: string;
+    distance: number;
+}
+/**
+ * Complete spatial context for an agent
+ */
+interface SpatialContext {
+    /** Agent's current position */
+    agentPosition: Vector3;
+    /** Agent's orientation */
+    agentRotation?: Quaternion;
+    /** Agent's bounding volume */
+    agentBounds?: BoundingBox;
+    /** Current velocity */
+    agentVelocity?: Vector3;
+    /** Entities within perception radius */
+    nearbyEntities: SpatialEntity[];
+    /** Regions the agent is currently in */
+    currentRegions: Region[];
+    /** All defined regions in the scene */
+    allRegions: Region[];
+    /** Computed sight lines to relevant entities */
+    sightLines: SightLine[];
+    /** Timestamp of context snapshot */
+    timestamp: number;
+    /** Update rate in Hz */
+    updateRate: number;
+}
+/**
+ * Event when entity enters perception radius
+ */
+interface EntityEnteredEvent {
+    type: 'entity_entered';
+    entity: SpatialEntity;
+    distance: number;
+    timestamp: number;
+}
+/**
+ * Event when entity exits perception radius
+ */
+interface EntityExitedEvent {
+    type: 'entity_exited';
+    entity: SpatialEntity;
+    timestamp: number;
+}
+/**
+ * Event when agent enters a region
+ */
+interface RegionEnteredEvent {
+    type: 'region_entered';
+    region: Region;
+    previousRegion?: Region;
+    timestamp: number;
+}
+/**
+ * Event when agent exits a region
+ */
+interface RegionExitedEvent {
+    type: 'region_exited';
+    region: Region;
+    timestamp: number;
+}
+/**
+ * Event when sight line to entity changes
+ */
+interface VisibilityChangedEvent {
+    type: 'visibility_changed';
+    entityId: string;
+    visible: boolean;
+    sightLine: SightLine;
+    timestamp: number;
+}
+/**
+ * Union of all spatial events
+ */
+type SpatialEvent = EntityEnteredEvent | EntityExitedEvent | RegionEnteredEvent | RegionExitedEvent | VisibilityChangedEvent;
+/**
+ * Configuration for spatial awareness
+ */
+interface SpatialAwarenessConfig {
+    /** How often to update spatial context (Hz) */
+    updateRate: number;
+    /** Maximum distance for entity perception (meters) */
+    perceptionRadius: number;
+    /** Maximum distance for visibility checks (meters) */
+    visibilityRadius: number;
+    /** Enable region tracking */
+    trackRegions: boolean;
+    /** Enable sight line computation */
+    computeSightLines: boolean;
+    /** Entity types to track (empty = all) */
+    entityTypeFilter: string[];
+    /** Minimum movement to trigger update (meters) */
+    movementThreshold: number;
+}
+/**
+ * Default spatial awareness configuration
+ */
+declare const DEFAULT_SPATIAL_CONFIG: SpatialAwarenessConfig;
+/**
+ * Calculate distance between two points
+ */
+declare function distance(a: Vector3, b: Vector3): number;
+/**
+ * Calculate squared distance (faster when comparing)
+ */
+declare function distanceSquared(a: Vector3, b: Vector3): number;
+/**
+ * Check if point is inside bounding box
+ */
+declare function isPointInBox(point: Vector3, box: BoundingBox): boolean;
+/**
+ * Check if point is inside sphere
+ */
+declare function isPointInSphere(point: Vector3, sphere: BoundingSphere): boolean;
+/**
+ * Get center of bounding box
+ */
+declare function getBoxCenter(box: BoundingBox): Vector3;
+/**
+ * Check if two bounding boxes overlap
+ */
+declare function boxesOverlap(a: BoundingBox, b: BoundingBox): boolean;
+/**
+ * Normalize a vector
+ */
+declare function normalize(v: Vector3): Vector3;
+/**
+ * Subtract two vectors
+ */
+declare function subtract(a: Vector3, b: Vector3): Vector3;
+/**
+ * Add two vectors
+ */
+declare function add(a: Vector3, b: Vector3): Vector3;
+/**
+ * Scale a vector
+ */
+declare function scale(v: Vector3, s: number): Vector3;
+/**
+ * Dot product of two vectors
+ */
+declare function dot(a: Vector3, b: Vector3): number;
+/**
+ * Cross product of two vectors
+ */
+declare function cross(a: Vector3, b: Vector3): Vector3;
+/**
+ * Linear interpolation between two vectors
+ */
+declare function lerp(a: Vector3, b: Vector3, t: number): Vector3;
+
+/**
+ * Spatial Query System
+ * Sprint 4 Priority 4 - Spatial Context Awareness
+ *
+ * Provides efficient spatial queries for finding entities based on
+ * distance, visibility, reachability, and region containment.
+ */
+
+/**
+ * Types of spatial queries
+ */
+type SpatialQueryType = 'nearest' | 'within' | 'visible' | 'reachable' | 'in_region' | 'by_type' | 'raycast';
+/**
+ * Base query interface
+ */
+interface SpatialQueryBase {
+    type: SpatialQueryType;
+    from: Vector3;
+    entityTypeFilter?: string[];
+    maxResults?: number;
+}
+/**
+ * Find nearest entities
+ */
+interface NearestQuery extends SpatialQueryBase {
+    type: 'nearest';
+    count?: number;
+}
+/**
+ * Find entities within radius
+ */
+interface WithinQuery extends SpatialQueryBase {
+    type: 'within';
+    radius: number;
+    includePartial?: boolean;
+}
+/**
+ * Find visible entities
+ */
+interface VisibleQuery extends SpatialQueryBase {
+    type: 'visible';
+    direction?: Vector3;
+    fov?: number;
+    maxDistance?: number;
+}
+/**
+ * Find reachable entities (pathfinding)
+ */
+interface ReachableQuery extends SpatialQueryBase {
+    type: 'reachable';
+    maxDistance?: number;
+    obstacles?: SpatialEntity[];
+}
+/**
+ * Find entities in a region
+ */
+interface InRegionQuery extends SpatialQueryBase {
+    type: 'in_region';
+    region: Region;
+}
+/**
+ * Find entities by type
+ */
+interface ByTypeQuery extends SpatialQueryBase {
+    type: 'by_type';
+    entityTypes: string[];
+    radius?: number;
+}
+/**
+ * Raycast query
+ */
+interface RaycastQuery extends SpatialQueryBase {
+    type: 'raycast';
+    direction: Vector3;
+    maxDistance: number;
+    hitFirst?: boolean;
+}
+/**
+ * Union of all query types
+ */
+type SpatialQuery = NearestQuery | WithinQuery | VisibleQuery | ReachableQuery | InRegionQuery | ByTypeQuery | RaycastQuery;
+/**
+ * Single query result with distance
+ */
+interface QueryResult {
+    entity: SpatialEntity;
+    distance: number;
+    direction?: Vector3;
+    sightLine?: SightLine;
+}
+/**
+ * Raycast hit result
+ */
+interface RaycastHit {
+    entity: SpatialEntity;
+    point: Vector3;
+    distance: number;
+    normal?: Vector3;
+}
+/**
+ * Executes spatial queries against a set of entities
+ */
+declare class SpatialQueryExecutor {
+    private entities;
+    private regions;
+    private spatialIndex;
+    constructor();
+    /**
+     * Update the entity set
+     */
+    updateEntities(entities: SpatialEntity[]): void;
+    /**
+     * Update regions
+     */
+    updateRegions(regions: Region[]): void;
+    /**
+     * Execute a spatial query
+     */
+    execute(query: SpatialQuery): QueryResult[];
+    /**
+     * Find nearest entities
+     */
+    private executeNearest;
+    /**
+     * Find entities within radius
+     */
+    private executeWithin;
+    /**
+     * Find visible entities
+     */
+    private executeVisible;
+    /**
+     * Find reachable entities (simplified - no full pathfinding)
+     */
+    private executeReachable;
+    /**
+     * Find entities in a region
+     */
+    private executeInRegion;
+    /**
+     * Find entities by type
+     */
+    private executeByType;
+    /**
+     * Execute raycast
+     */
+    private executeRaycast;
+    /**
+     * Check line of sight between two points
+     */
+    private checkSightLine;
+    /**
+     * Raycast against a single entity
+     */
+    private raycastEntity;
+    /**
+     * Get approximate radius of an entity
+     */
+    private getEntityRadius;
+    /**
+     * Check if point is in region
+     */
+    private isInRegion;
+}
+
+/**
+ * Spatial Context Provider
+ * Sprint 4 Priority 4 - Spatial Context Awareness
+ *
+ * Manages spatial context for agents, providing real-time updates about
+ * nearby entities, regions, and visibility.
+ */
+
+/**
+ * Events emitted by the spatial context provider
+ */
+interface SpatialContextProviderEvents {
+    'entity:entered': (agentId: string, event: SpatialEvent) => void;
+    'entity:exited': (agentId: string, event: SpatialEvent) => void;
+    'region:entered': (agentId: string, event: SpatialEvent) => void;
+    'region:exited': (agentId: string, event: SpatialEvent) => void;
+    'visibility:changed': (agentId: string, event: SpatialEvent) => void;
+    'context:updated': (agentId: string, context: SpatialContext) => void;
+}
+/**
+ * Provides spatial context to agents
+ */
+declare class SpatialContextProvider extends EventEmitter {
+    private agents;
+    private entities;
+    private regions;
+    private queryExecutor;
+    private updateInterval;
+    private isRunning;
+    constructor();
+    /**
+     * Start the spatial context provider
+     */
+    start(): void;
+    /**
+     * Stop the spatial context provider
+     */
+    stop(): void;
+    /**
+     * Manual update (for testing or custom update loops)
+     */
+    update(): void;
+    /**
+     * Register an agent for spatial awareness
+     */
+    registerAgent(agentId: string, position: Vector3, config?: Partial<SpatialAwarenessConfig>): void;
+    /**
+     * Unregister an agent
+     */
+    unregisterAgent(agentId: string): void;
+    /**
+     * Update agent position
+     */
+    updateAgentPosition(agentId: string, position: Vector3, velocity?: Vector3): void;
+    /**
+     * Get agent's current spatial context
+     */
+    getContext(agentId: string): SpatialContext | null;
+    /**
+     * Add or update an entity
+     */
+    setEntity(entity: SpatialEntity): void;
+    /**
+     * Remove an entity
+     */
+    removeEntity(entityId: string): void;
+    /**
+     * Batch update entities
+     */
+    setEntities(entities: SpatialEntity[]): void;
+    /**
+     * Get all entities
+     */
+    getEntities(): SpatialEntity[];
+    /**
+     * Add or update a region
+     */
+    setRegion(region: Region): void;
+    /**
+     * Remove a region
+     */
+    removeRegion(regionId: string): void;
+    /**
+     * Subscribe to region events for an agent
+     */
+    subscribeToRegion(agentId: string, regionId: string, callback: (event: SpatialEvent) => void): void;
+    /**
+     * Unsubscribe from region events
+     */
+    unsubscribeFromRegion(agentId: string, regionId: string): void;
+    /**
+     * Execute a spatial query
+     */
+    query(query: SpatialQuery): QueryResult[];
+    /**
+     * Find nearest entities to position
+     */
+    findNearest(from: Vector3, count?: number, typeFilter?: string[]): QueryResult[];
+    /**
+     * Find entities within radius
+     */
+    findWithin(from: Vector3, radius: number, typeFilter?: string[]): QueryResult[];
+    /**
+     * Find visible entities from position
+     */
+    findVisible(from: Vector3, direction?: Vector3, fov?: number, maxDistance?: number): QueryResult[];
+    /**
+     * Update context for a single agent
+     */
+    private updateAgentContext;
+    /**
+     * Find entities within radius of position
+     */
+    private findEntitiesInRadius;
+    /**
+     * Find regions containing position
+     */
+    private findRegionsContaining;
+    /**
+     * Check if position is in region
+     */
+    private isInRegion;
+    /**
+     * Check for entity enter/exit events
+     */
+    private checkEntityEvents;
+    /**
+     * Check for region enter/exit events
+     */
+    private checkRegionEvents;
+    /**
+     * Compute sight lines to entities
+     */
+    private computeSightLines;
+    /**
+     * Check if line between two points is blocked
+     */
+    private isLineBlocked;
+    /**
+     * Get entity radius
+     */
+    private getEntityRadius;
+    /**
+     * Dot product
+     */
+    private dot3;
+    /**
+     * Rebuild the query executor index
+     */
+    private rebuildQueryIndex;
+    /**
+     * Get minimum update interval
+     */
+    private getMinUpdateInterval;
+}
+
+/**
+ * Spatial Constraint Types for HoloScript Type System
+ *
+ * Defines compile-time spatial constraint trait extensions:
+ * - spatial_adjacent:            Two entities must be within a given distance threshold
+ * - spatial_contains:            One entity's bounds must fully enclose another
+ * - spatial_reachable:           An unobstructed path must exist between entities
+ * - spatial_temporal_adjacent:   Adjacency that must hold for N seconds (duration constraint)
+ * - spatial_temporal_reachable:  Reachability with moving obstacle velocity prediction
+ * - spatial_trajectory:          Path-based constraints over predicted entity motion
+ *
+ * These constraints are verified at compile time (static analysis of spatial
+ * declarations) and optionally enforced at runtime via the trait handlers.
+ *
+ * @module spatial/SpatialConstraintTypes
+ */
+
+/**
+ * Discriminant for the spatial constraint families.
+ *
+ * Includes the original three plus the spatiotemporal extensions:
+ * - spatial_temporal_adjacent: adjacency that must hold for a duration
+ * - spatial_temporal_reachable: reachability accounting for moving obstacles
+ * - spatial_trajectory: path-based constraints over predicted motion
+ */
+type SpatialConstraintKind = 'spatial_adjacent' | 'spatial_contains' | 'spatial_reachable' | 'spatial_temporal_adjacent' | 'spatial_temporal_reachable' | 'spatial_trajectory';
+/**
+ * Adjacency constraint: entities A and B must remain within `maxDistance`
+ * of each other. If `minDistance` is specified they must also be at least
+ * that far apart (useful for preventing overlap).
+ *
+ * HoloScript syntax:
+ * ```holoscript
+ * orb#shelf {
+ *   @spatial_adjacent(target: "book", maxDistance: 1.5m, axis: "xz")
+ * }
+ * ```
+ */
+interface SpatialAdjacentConstraint {
+    kind: 'spatial_adjacent';
+    /** Source entity that declares the constraint */
+    sourceId: string;
+    /** Target entity or entity type that must be adjacent */
+    targetId: string;
+    /** Maximum allowable distance (meters). Required. */
+    maxDistance: number;
+    /** Minimum allowable distance (meters). Defaults to 0. */
+    minDistance?: number;
+    /**
+     * Axis restriction for distance calculation.
+     * - 'xyz'  full 3D distance (default)
+     * - 'xz'   horizontal plane only (ignores y)
+     * - 'xy'   vertical plane only (ignores z)
+     * - 'x'|'y'|'z'  single axis
+     */
+    axis?: SpatialAxis;
+    /** Whether the constraint is bidirectional (default true) */
+    bidirectional?: boolean;
+    /** Human-readable label for error messages */
+    label?: string;
+}
+/**
+ * Configuration for the spatial_adjacent trait (parsed from HoloScript source).
+ */
+interface SpatialAdjacentConfig {
+    target: string;
+    maxDistance: number;
+    minDistance?: number;
+    axis?: SpatialAxis;
+    bidirectional?: boolean;
+    /** When true, emit warnings instead of errors at compile time */
+    soft?: boolean;
+    /** Runtime enforcement mode */
+    enforcement?: SpatialEnforcementMode;
+}
+/**
+ * Containment constraint: entity A's bounding volume must fully enclose
+ * entity B. Useful for zones, rooms, inventories, and UI containers.
+ *
+ * HoloScript syntax:
+ * ```holoscript
+ * orb#room {
+ *   @spatial_contains(target: "furniture", margin: 0.1m, strict: true)
+ * }
+ * ```
+ */
+interface SpatialContainsConstraint {
+    kind: 'spatial_contains';
+    /** The container entity */
+    containerId: string;
+    /** The entity that must be fully inside the container */
+    containedId: string;
+    /**
+     * Extra margin (meters) that must exist between the contained entity's
+     * bounds and the container's bounds. Defaults to 0.
+     */
+    margin?: number;
+    /**
+     * Strict mode: if true, the contained entity's full bounding volume
+     * must be inside. If false (default), only the center point is checked.
+     */
+    strict?: boolean;
+    /** Whether to also check child entities recursively */
+    recursive?: boolean;
+    /** Human-readable label for error messages */
+    label?: string;
+}
+/**
+ * Configuration for the spatial_contains trait.
+ */
+interface SpatialContainsConfig {
+    target: string;
+    margin?: number;
+    strict?: boolean;
+    recursive?: boolean;
+    /** When true, emit warnings instead of errors at compile time */
+    soft?: boolean;
+    /** Runtime enforcement mode */
+    enforcement?: SpatialEnforcementMode;
+}
+/**
+ * Reachability constraint: a clear (unobstructed) path must exist from
+ * entity A to entity B, considering obstacles and navigation meshes.
+ *
+ * HoloScript syntax:
+ * ```holoscript
+ * orb#npc {
+ *   @spatial_reachable(
+ *     target: "exit_door",
+ *     maxPathLength: 50m,
+ *     obstacles: ["wall", "barrier"],
+ *     algorithm: "navmesh"
+ *   )
+ * }
+ * ```
+ */
+interface SpatialReachableConstraint {
+    kind: 'spatial_reachable';
+    /** The starting entity */
+    sourceId: string;
+    /** The destination entity */
+    targetId: string;
+    /**
+     * Maximum allowable path length in meters.
+     * If the shortest unobstructed path exceeds this, the constraint fails.
+     */
+    maxPathLength?: number;
+    /**
+     * Entity types (or specific IDs) that are considered obstacles.
+     * If empty, only static colliders block reachability.
+     */
+    obstacleTypes?: string[];
+    /**
+     * Pathfinding algorithm hint.
+     * - 'line_of_sight' simple raycast (fast, conservative)
+     * - 'navmesh'       navigation mesh query (accurate)
+     * - 'astar'         grid-based A* (general purpose)
+     */
+    algorithm?: SpatialReachableAlgorithm;
+    /** Agent radius for path clearance (meters). Defaults to 0.5 */
+    agentRadius?: number;
+    /** Whether the constraint is bidirectional (default true) */
+    bidirectional?: boolean;
+    /** Human-readable label for error messages */
+    label?: string;
+}
+/**
+ * Configuration for the spatial_reachable trait.
+ */
+interface SpatialReachableConfig {
+    target: string;
+    maxPathLength?: number;
+    obstacleTypes?: string[];
+    algorithm?: SpatialReachableAlgorithm;
+    agentRadius?: number;
+    bidirectional?: boolean;
+    /** When true, emit warnings instead of errors at compile time */
+    soft?: boolean;
+    /** Runtime enforcement mode */
+    enforcement?: SpatialEnforcementMode;
+}
+/**
+ * Temporal adjacency constraint: entities A and B must remain within
+ * `maxDistance` for at least `minDuration` seconds. Optionally, the
+ * constraint only triggers a violation after the condition has been
+ * broken for `gracePeriod` seconds (hysteresis).
+ *
+ * HoloScript syntax:
+ * ```holoscript
+ * orb#guard {
+ *   @spatial_temporal_adjacent(
+ *     target: "prisoner",
+ *     maxDistance: 3m,
+ *     minDuration: 5s,
+ *     gracePeriod: 1s,
+ *     axis: "xz"
+ *   )
+ * }
+ * ```
+ */
+interface SpatialTemporalAdjacentConstraint {
+    kind: 'spatial_temporal_adjacent';
+    /** Source entity that declares the constraint */
+    sourceId: string;
+    /** Target entity or entity type that must be adjacent */
+    targetId: string;
+    /** Maximum allowable distance (meters). Required. */
+    maxDistance: number;
+    /** Minimum allowable distance (meters). Defaults to 0. */
+    minDistance?: number;
+    /**
+     * Minimum duration (seconds) the adjacency condition must hold
+     * continuously before the constraint is considered satisfied.
+     */
+    minDuration: number;
+    /**
+     * Grace period (seconds). After the adjacency condition breaks,
+     * wait this long before emitting a violation. Provides hysteresis
+     * to prevent flickering. Defaults to 0.
+     */
+    gracePeriod?: number;
+    /** Axis restriction for distance calculation. */
+    axis?: SpatialAxis;
+    /** Whether the constraint is bidirectional (default true) */
+    bidirectional?: boolean;
+    /** Human-readable label for error messages */
+    label?: string;
+}
+/**
+ * Configuration for the spatial_temporal_adjacent trait (parsed from HoloScript).
+ */
+interface SpatialTemporalAdjacentConfig {
+    target: string;
+    maxDistance: number;
+    minDistance?: number;
+    minDuration: number;
+    gracePeriod?: number;
+    axis?: SpatialAxis;
+    bidirectional?: boolean;
+    /** When true, emit warnings instead of errors at compile time */
+    soft?: boolean;
+    /** Runtime enforcement mode */
+    enforcement?: SpatialEnforcementMode;
+}
+/**
+ * Velocity-aware reachability constraint: checks whether a path exists
+ * from entity A to entity B, accounting for moving obstacles by predicting
+ * their positions `predictionHorizon` seconds into the future based on
+ * their current velocity vectors.
+ *
+ * HoloScript syntax:
+ * ```holoscript
+ * orb#drone {
+ *   @spatial_temporal_reachable(
+ *     target: "landing_pad",
+ *     maxPathLength: 100m,
+ *     predictionHorizon: 3s,
+ *     movingObstacles: ["vehicle", "drone"],
+ *     safetyMargin: 1.5m
+ *   )
+ * }
+ * ```
+ */
+interface SpatialTemporalReachableConstraint {
+    kind: 'spatial_temporal_reachable';
+    /** The starting entity */
+    sourceId: string;
+    /** The destination entity */
+    targetId: string;
+    /** Maximum allowable path length in meters. */
+    maxPathLength?: number;
+    /**
+     * How far into the future (seconds) to predict obstacle positions.
+     * Obstacle positions are extrapolated via position + velocity * t.
+     */
+    predictionHorizon: number;
+    /**
+     * Entity types (or specific IDs) treated as moving obstacles.
+     * Their velocity vectors are read from the spatial context.
+     */
+    movingObstacles?: string[];
+    /**
+     * Static obstacle types (no velocity prediction applied).
+     */
+    staticObstacles?: string[];
+    /**
+     * Safety margin (meters) to add around predicted obstacle positions.
+     * Accounts for velocity uncertainty. Defaults to 0.5.
+     */
+    safetyMargin?: number;
+    /** Pathfinding algorithm hint. */
+    algorithm?: SpatialReachableAlgorithm;
+    /** Agent radius for path clearance (meters). Defaults to 0.5 */
+    agentRadius?: number;
+    /** Whether the constraint is bidirectional (default true) */
+    bidirectional?: boolean;
+    /** Human-readable label for error messages */
+    label?: string;
+}
+/**
+ * Configuration for the spatial_temporal_reachable trait.
+ */
+interface SpatialTemporalReachableConfig {
+    target: string;
+    maxPathLength?: number;
+    predictionHorizon: number;
+    movingObstacles?: string[];
+    staticObstacles?: string[];
+    safetyMargin?: number;
+    algorithm?: SpatialReachableAlgorithm;
+    agentRadius?: number;
+    bidirectional?: boolean;
+    /** When true, emit warnings instead of errors at compile time */
+    soft?: boolean;
+    /** Runtime enforcement mode */
+    enforcement?: SpatialEnforcementMode;
+}
+/**
+ * Trajectory constraint: verifies that the predicted motion path of an
+ * entity satisfies spatial constraints. The trajectory is computed from
+ * position + velocity (and optional acceleration) over a time horizon,
+ * and can be checked against keep-in zones, keep-out zones, waypoints,
+ * and maximum deviation from a reference path.
+ *
+ * HoloScript syntax:
+ * ```holoscript
+ * orb#missile {
+ *   @spatial_trajectory(
+ *     mode: "keep_in",
+ *     region: "safe_corridor",
+ *     horizon: 5s,
+ *     sampleCount: 20,
+ *     maxDeviation: 2m
+ *   )
+ * }
+ * ```
+ */
+interface SpatialTrajectoryConstraint {
+    kind: 'spatial_trajectory';
+    /** The entity whose trajectory is being constrained */
+    sourceId: string;
+    /**
+     * Constraint mode:
+     * - 'keep_in':  trajectory must stay inside the region
+     * - 'keep_out': trajectory must avoid the region
+     * - 'follow':   trajectory must stay within maxDeviation of a reference path
+     * - 'waypoint': trajectory must pass through specified waypoints
+     */
+    mode: SpatialTrajectoryMode;
+    /**
+     * Region ID or entity ID that defines the spatial boundary
+     * (for keep_in and keep_out modes).
+     */
+    regionId?: string;
+    /**
+     * Time horizon (seconds) over which to predict the trajectory.
+     */
+    horizon: number;
+    /**
+     * Number of sample points along the trajectory to check.
+     * Higher values increase accuracy but cost more. Defaults to 10.
+     */
+    sampleCount?: number;
+    /**
+     * Maximum allowed deviation (meters) from a reference path
+     * (for 'follow' mode).
+     */
+    maxDeviation?: number;
+    /**
+     * Waypoints the trajectory must pass through (for 'waypoint' mode).
+     * Each waypoint has a position and an acceptance radius.
+     */
+    waypoints?: TrajectoryWaypoint[];
+    /**
+     * Reference path for 'follow' mode. An ordered list of points
+     * defining the ideal trajectory.
+     */
+    referencePath?: Vector3[];
+    /**
+     * Whether to account for acceleration (quadratic prediction)
+     * instead of linear velocity extrapolation. Defaults to false.
+     */
+    useAcceleration?: boolean;
+    /** Human-readable label for error messages */
+    label?: string;
+}
+/**
+ * A waypoint along a trajectory, with an acceptance radius.
+ */
+interface TrajectoryWaypoint {
+    position: Vector3;
+    /** Radius (meters) within which the trajectory is considered to pass through */
+    radius: number;
+    /** Optional label for diagnostics */
+    label?: string;
+}
+/**
+ * Trajectory constraint mode.
+ */
+type SpatialTrajectoryMode = 'keep_in' | 'keep_out' | 'follow' | 'waypoint';
+/**
+ * Configuration for the spatial_trajectory trait.
+ */
+interface SpatialTrajectoryConfig {
+    mode: SpatialTrajectoryMode;
+    regionId?: string;
+    horizon: number;
+    sampleCount?: number;
+    maxDeviation?: number;
+    waypoints?: TrajectoryWaypoint[];
+    referencePath?: Vector3[];
+    useAcceleration?: boolean;
+    /** When true, emit warnings instead of errors at compile time */
+    soft?: boolean;
+    /** Runtime enforcement mode */
+    enforcement?: SpatialEnforcementMode;
+}
+/**
+ * Axis filter for distance calculations.
+ */
+type SpatialAxis = 'xyz' | 'xz' | 'xy' | 'x' | 'y' | 'z';
+/**
+ * Pathfinding algorithm for reachability.
+ */
+type SpatialReachableAlgorithm = 'line_of_sight' | 'navmesh' | 'astar';
+/**
+ * How the constraint is enforced at runtime.
+ * - 'prevent'  block the violating action (e.g., prevent entity from moving out of range)
+ * - 'correct'  snap entity back to valid state
+ * - 'warn'     emit a runtime warning but allow the violation
+ * - 'none'     compile-time only, no runtime checks
+ */
+type SpatialEnforcementMode = 'prevent' | 'correct' | 'warn' | 'none';
+/**
+ * Union of all spatial constraints (including spatiotemporal extensions).
+ */
+type SpatialConstraint = SpatialAdjacentConstraint | SpatialContainsConstraint | SpatialReachableConstraint | SpatialTemporalAdjacentConstraint | SpatialTemporalReachableConstraint | SpatialTrajectoryConstraint;
+/**
+ * Severity level for spatial constraint diagnostics.
+ */
+type SpatialDiagnosticSeverity = 'error' | 'warning' | 'info';
+/**
+ * A single diagnostic produced by compile-time spatial constraint verification.
+ */
+interface SpatialConstraintDiagnostic {
+    /** Severity of the diagnostic */
+    severity: SpatialDiagnosticSeverity;
+    /** Diagnostic code (e.g., 'HSP030', 'HSP031', 'HSP032') */
+    code: string;
+    /** Human-readable error/warning message */
+    message: string;
+    /** Source line (1-indexed) where the constraint is declared */
+    line: number;
+    /** Source column (0-indexed) */
+    column: number;
+    /** The constraint kind that produced this diagnostic */
+    constraintKind: SpatialConstraintKind;
+    /** Source entity ID */
+    sourceId: string;
+    /** Target entity ID */
+    targetId: string;
+    /** Suggested fix(es) */
+    suggestions?: string[];
+}
+/**
+ * Result of compile-time spatial constraint verification.
+ */
+interface SpatialConstraintCheckResult {
+    /** Whether all constraints passed */
+    valid: boolean;
+    /** All diagnostics produced */
+    diagnostics: SpatialConstraintDiagnostic[];
+    /** Map of entity ID -> resolved spatial constraints */
+    constraintMap: Map<string, SpatialConstraint[]>;
+    /** Statistics */
+    stats: {
+        totalConstraints: number;
+        adjacentCount: number;
+        containsCount: number;
+        reachableCount: number;
+        temporalAdjacentCount: number;
+        temporalReachableCount: number;
+        trajectoryCount: number;
+        errorsCount: number;
+        warningsCount: number;
+    };
+}
+/**
+ * A spatial declaration extracted from HoloScript source during parsing.
+ * These are the "facts" the compile-time verifier reasons about.
+ */
+interface SpatialDeclaration {
+    /** Entity ID */
+    entityId: string;
+    /** Entity type (e.g., 'orb', 'agent', 'zone') */
+    entityType: string;
+    /** Declared static position (if known at compile time) */
+    position?: Vector3;
+    /** Declared bounds (if known at compile time) */
+    bounds?: BoundingBox | BoundingSphere;
+    /** Parent entity ID (for containment hierarchy) */
+    parentId?: string;
+    /** Region the entity is declared in */
+    regionId?: string;
+    /** All spatial constraints declared on this entity */
+    constraints: SpatialConstraint[];
+    /** Source line for error reporting */
+    line?: number;
+    /** Source column for error reporting */
+    column?: number;
+}
+/**
+ * Event emitted when a spatial constraint is violated at runtime.
+ */
+interface SpatialConstraintViolationEvent {
+    type: 'spatial_constraint_violation';
+    constraintKind: SpatialConstraintKind;
+    sourceId: string;
+    targetId: string;
+    message: string;
+    /** Current measured value (distance, overlap percentage, path length) */
+    currentValue: number;
+    /** Required threshold */
+    requiredValue: number;
+    timestamp: number;
+}
+/**
+ * Event emitted when a violated spatial constraint returns to valid state.
+ */
+interface SpatialConstraintResolvedEvent {
+    type: 'spatial_constraint_resolved';
+    constraintKind: SpatialConstraintKind;
+    sourceId: string;
+    targetId: string;
+    timestamp: number;
+}
+/**
+ * Union of all spatial constraint events.
+ */
+type SpatialConstraintEvent = SpatialConstraintViolationEvent | SpatialConstraintResolvedEvent;
+
+/**
+ * Spatial Constraint Validator
+ *
+ * Performs compile-time verification of spatial constraints declared in
+ * HoloScript source. Analyzes spatial declarations (positions, bounds,
+ * hierarchy) to detect constraint violations before runtime.
+ *
+ * Diagnostic codes:
+ *   HSP030 — spatial_adjacent violation
+ *   HSP031 — spatial_contains violation
+ *   HSP032 — spatial_reachable violation
+ *   HSP033 — spatial constraint target not found
+ *   HSP034 — spatial constraint circular reference
+ *   HSP035 — spatial constraint incompatible configuration
+ *   HSP036 — spatial_temporal_adjacent violation
+ *   HSP037 — spatial_temporal_reachable violation
+ *   HSP038 — spatial_trajectory violation
+ *
+ * @module spatial/SpatialConstraintValidator
+ */
+
+/**
+ * Compile-time spatial constraint validator.
+ *
+ * Given a set of spatial declarations (extracted from parsed HoloScript AST),
+ * validates all declared spatial constraints and reports diagnostics.
+ *
+ * @example
+ * ```typescript
+ * const validator = new SpatialConstraintValidator();
+ * const result = validator.validate(declarations);
+ * if (!result.valid) {
+ *   for (const diag of result.diagnostics) {
+ *     console.error(`[${diag.code}] ${diag.message}`);
+ *   }
+ * }
+ * ```
+ */
+declare class SpatialConstraintValidator {
+    private declarations;
+    private diagnostics;
+    private constraintMap;
+    /**
+     * Validate all spatial constraints across a set of declarations.
+     */
+    validate(declarations: SpatialDeclaration[]): SpatialConstraintCheckResult;
+    /**
+     * Validate a single constraint in isolation (useful for incremental checks).
+     */
+    validateSingle(source: SpatialDeclaration, constraint: SpatialConstraint, allDeclarations: SpatialDeclaration[]): SpatialConstraintDiagnostic[];
+    private resolveReferences;
+    private detectCircularReferences;
+    private validateAdjacent;
+    private validateContains;
+    /**
+     * Check that a point is inside the container bounds (with margin).
+     */
+    private validatePointContainment;
+    /**
+     * Strict containment: contained entity's full bounds must be inside container.
+     */
+    private validateStrictContainment;
+    /**
+     * Recursively check containment for child entities.
+     */
+    private validateRecursiveContainment;
+    private validateReachable;
+    /**
+     * Check line-of-sight between two points through known obstacles.
+     * Returns the ID of the first blocking obstacle, or null if clear.
+     */
+    private checkLineOfSight;
+    private validateTemporalAdjacent;
+    private validateTemporalReachable;
+    private validateTrajectory;
+    private validateCrossConstraintConsistency;
+    /**
+     * Reset all internal state for a new validation run.
+     */
+    private reset;
+    /**
+     * Add a diagnostic to the list.
+     */
+    private addDiagnostic;
+    /**
+     * Resolve a target ID to a declaration, including type-based matching.
+     */
+    private resolveTarget;
+    /**
+     * Get the target ID from any spatial constraint.
+     */
+    private getTargetId;
+    /**
+     * Compute distance along a specific axis filter.
+     */
+    computeAxisDistance(a: Vector3, b: Vector3, axis: SpatialAxis): number;
+    /**
+     * Convert any bounds type to a BoundingBox, optionally offset by position.
+     */
+    private toBoundingBox;
+    /**
+     * Ray-AABB intersection test.
+     */
+    private rayIntersectsBox;
+    /**
+     * Check if a point is within `extraRadius` of a bounding volume.
+     */
+    private isPointNearBounds;
+    /**
+     * Find all containers that declare spatial_contains with a given entity.
+     */
+    private findContainers;
+}
+
+/**
+ * OctreeSystem.ts
+ *
+ * Octree spatial partitioning: insert/remove objects,
+ * range queries, ray queries, and automatic subdivision.
+ *
+ * @module spatial
+ */
+interface OctreeEntry {
+    id: string;
+    x: number;
+    y: number;
+    z: number;
+    radius: number;
+}
+declare class OctreeSystem {
+    private root;
+    private maxEntriesPerNode;
+    private maxDepth;
+    private entryCount;
+    constructor(centerX: number, centerY: number, centerZ: number, halfSize: number);
+    insert(entry: OctreeEntry): boolean;
+    private insertIntoNode;
+    remove(id: string): boolean;
+    private removeFromNode;
+    queryRadius(x: number, y: number, z: number, radius: number): OctreeEntry[];
+    private queryRadiusNode;
+    private sphereOverlapsNode;
+    private subdivide;
+    private containsPoint;
+    getEntryCount(): number;
+    clear(): void;
+}
+
+/**
+ * OctreeLODSystem.ts
+ *
+ * Octree-based Level-of-Detail system for Gaussian Splatting scenes.
+ * Implements the Octree-GS approach (TPAMI 2025): anchor Gaussians assigned
+ * to octree levels with camera-distance LOD selection and budget-aware capping.
+ *
+ * Key design decisions:
+ *  - Anchor Gaussians are stored at the octree level matching their detail scale
+ *  - Camera distance determines which LOD levels contribute to rendering
+ *  - Power-law (Levy flight) transition thresholds replace linear spacing
+ *  - Budget enforcement drops deepest LOD levels first when over cap
+ *  - VR mode reserves fixed budget per avatar (W.034: 60K each, max 3)
+ *
+ * Research references:
+ *   W.032 - Octree-GS LOD (anchor-based level selection, TPAMI 2025)
+ *   W.034 - VR Gaussian budget (~180K total on Quest 3 at 72fps)
+ *   P.030.01 - Hierarchical LOD Gaussian Architecture pattern
+ *   P.030.05 - VR Gaussian Budget Management pattern
+ *
+ * @module spatial
+ */
+/**
+ * Gaussian anchor: a representative Gaussian at a specific octree level.
+ * At rendering time, only anchors from selected LOD levels are drawn.
+ */
+interface GaussianAnchor {
+    /** Unique identifier for this anchor Gaussian */
+    id: string;
+    /** World-space position (center of the Gaussian) */
+    x: number;
+    y: number;
+    z: number;
+    /** Gaussian scale (max axis determines effective radius for octree insertion) */
+    scale: number;
+    /** LOD level this anchor belongs to (0 = coarsest/root, higher = finer detail) */
+    lodLevel: number;
+    /** Number of Gaussians this anchor represents (for budget accounting) */
+    gaussianCount: number;
+    /** Optional: index into the original splat array for rendering */
+    splatIndex?: number;
+    /** V11: Perceptual importance (0-1, default 0.5). Higher = kept under budget pressure */
+    importance?: number;
+}
+/**
+ * Configuration for the octree LOD system.
+ */
+interface OctreeLODConfig {
+    /** Maximum octree depth (number of LOD levels). 4-8 typical for city-scale. */
+    maxDepth: number;
+    /**
+     * Power-law exponent for transition threshold spacing.
+     * Controls how distance thresholds grow with LOD level.
+     * - 1.0 = linear spacing (uniform)
+     * - 1.5 = moderate power-law (recommended for indoor/room-scale)
+     * - 2.0 = aggressive power-law (recommended for outdoor/city-scale)
+     * Levy flight research (W.030) suggests power-law distributions match
+     * natural depth trajectory patterns in camera movement.
+     */
+    powerLawExponent: number;
+    /** Base distance for LOD level 0 transition (in world units) */
+    baseDistance: number;
+    /** Maximum distance for the outermost LOD level (in world units) */
+    maxDistance: number;
+    /** VR mode: enable hard budget enforcement */
+    vrMode: boolean;
+    /** Total Gaussian budget (0 = unlimited). VR default: 180000 (Quest 3 at 72fps) */
+    gaussianBudget: number;
+    /** Per-avatar Gaussian reservation (0 = no avatar reservations) */
+    perAvatarReservation: number;
+    /** Maximum number of avatars with reserved budgets */
+    maxAvatars: number;
+    /** Maximum anchors per node before subdivision */
+    maxAnchorsPerNode: number;
+}
+/**
+ * Result of an LOD selection query: which levels and anchors to render.
+ */
+interface LODSelectionResult {
+    /** LOD levels selected for rendering (0 = coarsest, higher = finer) */
+    selectedLevels: number[];
+    /** Total Gaussians selected across all levels */
+    totalGaussians: number;
+    /** Whether the budget cap was applied (some levels were dropped) */
+    budgetCapped: boolean;
+    /** Number of LOD levels dropped due to budget cap */
+    levelsDropped: number;
+    /** Anchor Gaussians to render (flattened from selected levels) */
+    anchors: GaussianAnchor[];
+    /** Camera distance to scene center */
+    cameraDistance: number;
+    /** Computed transition thresholds (for debugging/visualization) */
+    thresholds: number[];
+    /** Available Gaussian budget after avatar reservations */
+    availableBudget: number;
+}
+/**
+ * Per-level statistics for the octree.
+ */
+interface LODLevelStats {
+    level: number;
+    anchorCount: number;
+    gaussianCount: number;
+    nodeCount: number;
+}
+/**
+ * Metrics snapshot for the entire OctreeLOD system.
+ */
+interface OctreeLODMetrics {
+    /** Total anchor count across all levels */
+    totalAnchors: number;
+    /** Total Gaussian count across all levels */
+    totalGaussians: number;
+    /** Per-level breakdown */
+    levels: LODLevelStats[];
+    /** Octree depth (actual, may be less than maxDepth) */
+    actualDepth: number;
+    /** Number of active avatar reservations */
+    activeAvatarReservations: number;
+    /** Total nodes in the octree */
+    totalNodes: number;
+}
+/**
+ * Octree-based Level-of-Detail system for Gaussian Splatting scenes.
+ *
+ * Architecture (based on Octree-GS, TPAMI 2025):
+ *
+ * 1. **Octree Construction**: Scene bounding box is recursively subdivided
+ *    into 8 children up to maxDepth levels. Each level corresponds to an
+ *    LOD level (depth 0 = coarsest overview, depth N = finest detail).
+ *
+ * 2. **Anchor Assignment**: Gaussian splats are assigned to the octree level
+ *    matching their detail scale. Coarse/large Gaussians go to shallow levels;
+ *    fine/small Gaussians go to deep levels. This is the "anchor" concept
+ *    from Octree-GS.
+ *
+ * 3. **LOD Selection**: Given a camera position, compute distance to each
+ *    octree voxel. Use power-law transition thresholds to determine which
+ *    LOD levels are active. Closer voxels activate deeper (finer) levels.
+ *
+ * 4. **Budget Enforcement**: Sum Gaussian counts across selected levels.
+ *    If total exceeds the budget, drop the deepest (finest) levels first.
+ *    This preserves scene overview while sacrificing fine detail under pressure.
+ *
+ * 5. **VR Mode**: Reserves fixed Gaussian budget per avatar (e.g., 60K each),
+ *    then allocates remaining budget to scene LOD selection.
+ *
+ * Usage:
+ * ```typescript
+ * const lod = new OctreeLODSystem({
+ *   maxDepth: 6,
+ *   powerLawExponent: 1.5,
+ *   baseDistance: 2.0,
+ *   maxDistance: 200.0,
+ *   vrMode: true,
+ *   gaussianBudget: 180000,
+ *   perAvatarReservation: 60000,
+ *   maxAvatars: 3,
+ * });
+ *
+ * // Build octree from scene bounds
+ * lod.initialize(0, 0, 0, 100); // center + halfSize
+ *
+ * // Insert anchor Gaussians at appropriate LOD levels
+ * lod.insertAnchor({ id: 'a0', x: 10, y: 0, z: 5, scale: 2.0, lodLevel: 0, gaussianCount: 500 });
+ * lod.insertAnchor({ id: 'a1', x: 10, y: 0, z: 5, scale: 0.1, lodLevel: 4, gaussianCount: 50 });
+ *
+ * // Select LOD levels for current camera
+ * const selection = lod.selectLOD(cameraX, cameraY, cameraZ);
+ * // selection.anchors contains the Gaussians to render this frame
+ * ```
+ */
+declare class OctreeLODSystem {
+    private root;
+    private config;
+    private thresholds;
+    private anchorCount;
+    private totalGaussianCount;
+    private activeAvatars;
+    private nodeCount;
+    /** Scene center for distance calculations */
+    private sceneCX;
+    private sceneCY;
+    private sceneCZ;
+    constructor(config?: Partial<OctreeLODConfig>);
+    /**
+     * Initialize the octree with scene bounds.
+     * Must be called before inserting anchors.
+     */
+    initialize(centerX: number, centerY: number, centerZ: number, halfSize: number): void;
+    /**
+     * Initialize from a bounding box (min/max corners).
+     */
+    initializeFromBounds(minX: number, minY: number, minZ: number, maxX: number, maxY: number, maxZ: number): void;
+    /**
+     * Compute power-law transition thresholds for LOD level selection.
+     *
+     * Power-law spacing (Levy flight-inspired, W.030):
+     *   threshold[i] = baseDistance * ((i + 1) / maxDepth) ^ exponent * (maxDistance / baseDistance)
+     *
+     * This produces thresholds that are tightly spaced near the camera
+     * (where detail matters most) and widely spaced at far distances
+     * (where coarse LOD suffices).
+     */
+    private computeThresholds;
+    /**
+     * Get the computed transition thresholds (read-only).
+     */
+    getThresholds(): readonly number[];
+    /**
+     * Insert an anchor Gaussian into the octree at its designated LOD level.
+     * Returns true if successfully inserted.
+     */
+    insertAnchor(anchor: GaussianAnchor): boolean;
+    private insertIntoNode;
+    /**
+     * Remove an anchor by ID.
+     */
+    removeAnchor(id: string): boolean;
+    private removeFromNode;
+    /**
+     * Bulk-insert anchors (more efficient than individual inserts for large scenes).
+     * Anchors are sorted by LOD level for efficient tree traversal.
+     */
+    bulkInsert(anchors: GaussianAnchor[]): number;
+    /**
+     * Select LOD levels and anchors to render based on camera position.
+     *
+     * Algorithm:
+     * 1. Compute camera distance to scene center
+     * 2. Walk thresholds to find the deepest (finest) LOD level visible
+     * 3. Select all levels from 0 (coarsest) through the deepest visible level
+     * 4. Collect anchors from selected levels
+     * 5. If budget mode, drop deepest levels until under budget
+     * 6. In VR mode, subtract avatar reservations from available budget
+     */
+    selectLOD(cameraX: number, cameraY: number, cameraZ: number, avatarCount?: number): LODSelectionResult;
+    /**
+     * Recursively collect anchors from the octree that belong to the selected levels.
+     */
+    private collectAnchors;
+    /**
+     * Set the number of active avatars (for VR budget reservation).
+     */
+    setActiveAvatars(count: number): void;
+    /**
+     * Get the number of active avatar reservations.
+     */
+    getActiveAvatars(): number;
+    /**
+     * Get the scene-available Gaussian budget after avatar reservations.
+     */
+    getAvailableSceneBudget(): number;
+    /**
+     * Compute the appropriate LOD level for a Gaussian based on its scale.
+     *
+     * Larger Gaussians (coarse detail) -> lower LOD levels (shallow octree nodes)
+     * Smaller Gaussians (fine detail) -> higher LOD levels (deep octree nodes)
+     *
+     * Uses logarithmic mapping: level = floor(log2(maxScale / scale))
+     * Clamped to [0, maxDepth-1].
+     */
+    computeLODLevelFromScale(scale: number, maxScaleInScene: number): number;
+    private createNode;
+    private subdivideNode;
+    private containsPoint;
+    /**
+     * Get comprehensive metrics about the octree state.
+     */
+    getMetrics(): OctreeLODMetrics;
+    private collectMetrics;
+    /**
+     * Get the total number of anchors.
+     */
+    getAnchorCount(): number;
+    /**
+     * Get the total Gaussian count across all anchors.
+     */
+    getTotalGaussianCount(): number;
+    /**
+     * Get the current configuration.
+     */
+    getConfig(): Readonly<OctreeLODConfig>;
+    /**
+     * Update configuration (recomputes thresholds).
+     */
+    updateConfig(config: Partial<OctreeLODConfig>): void;
+    /**
+     * Clear all anchors and reset the octree.
+     * Preserves configuration.
+     */
+    clear(): void;
+    /**
+     * Check if the system has been initialized.
+     */
+    isInitialized(): boolean;
+}
+
+export { type BoundingBox, type BoundingSphere, type ByTypeQuery, DEFAULT_SPATIAL_CONFIG, type EntityEnteredEvent, type EntityExitedEvent, type GaussianAnchor, type InRegionQuery, type LODLevelStats, type LODSelectionResult, type NearestQuery, type OctreeEntry, type OctreeLODConfig, type OctreeLODMetrics, OctreeLODSystem, OctreeSystem, type OrientedBoundingBox, type Quaternion, type QueryResult, type RaycastHit, type RaycastQuery, type ReachableQuery, type Region, type RegionEnteredEvent, type RegionExitedEvent, type SightLine, type SpatialAdjacentConfig, type SpatialAdjacentConstraint, type SpatialAwarenessConfig, type SpatialAxis, type SpatialConstraint, type SpatialConstraintCheckResult, type SpatialConstraintDiagnostic, type SpatialConstraintEvent, type SpatialConstraintKind, type SpatialConstraintResolvedEvent, SpatialConstraintValidator, type SpatialConstraintViolationEvent, type SpatialContainsConfig, type SpatialContainsConstraint, type SpatialContext, SpatialContextProvider, type SpatialContextProviderEvents, type SpatialDeclaration, type SpatialDiagnosticSeverity, type SpatialEnforcementMode, type SpatialEntity, type SpatialEvent, type SpatialQuery, type SpatialQueryBase, SpatialQueryExecutor, type SpatialQueryType, type SpatialReachableAlgorithm, type SpatialReachableConfig, type SpatialReachableConstraint, type SpatialTemporalAdjacentConfig, type SpatialTemporalAdjacentConstraint, type SpatialTemporalReachableConfig, type SpatialTemporalReachableConstraint, type SpatialTrajectoryConfig, type SpatialTrajectoryConstraint, type SpatialTrajectoryMode, type TrajectoryWaypoint, type Vector2, type Vector3, type VisibilityChangedEvent, type VisibleQuery, type WithinQuery, add, boxesOverlap, cross, distance, distanceSquared, dot, getBoxCenter, isPointInBox, isPointInSphere, lerp, normalize, scale, subtract };