@holoscript/engine 6.0.3 → 6.0.4

package/dist/index-CUl3QstQ.d.cts

@@ -0,0 +1,3006 @@
+import { HoloComposition, PhonemeTimestamp, Vector3, StateMachineNode, SemanticSOP, CulturalMemory, VREffect, NormViolation, EpisodicMemory, StigmergicTrace, CulturalNorm, NormProposal, NormEngine, RaycastHit, VRHand, TraitContext, HostCapabilities, HSPlusNode, ReactiveState, HSPlusAST } from '@holoscript/core';
+import * as THREE from 'three';
+
+/**
+ * RuntimeRegistry.ts
+ *
+ * Central registry for HoloScript runtime modules.
+ * Allows Hololand to discover and execute runtimes dynamically.
+ */
+
+interface RuntimeModule {
+    /** Runtime identifier */
+    id: string;
+    /** Runtime name */
+    name: string;
+    /** Runtime version */
+    version: string;
+    /** Supported composition types */
+    supportedTypes: string[];
+    /** Initialize runtime from composition */
+    initialize(composition: HoloComposition, config?: any): RuntimeExecutor;
+    /** Runtime capabilities */
+    capabilities: RuntimeCapabilities;
+    /** Runtime metadata */
+    metadata: RuntimeMetadata;
+}
+interface RuntimeExecutor {
+    /** Start execution */
+    start(): void;
+    /** Stop execution */
+    stop(): void;
+    /** Pause execution */
+    pause(): void;
+    /** Resume execution */
+    resume(): void;
+    /** Update runtime (called per frame) */
+    update(dt: number): void;
+    /** Get runtime statistics */
+    getStatistics(): any;
+    /** Get runtime state */
+    getState(): any;
+    /** Reset runtime */
+    reset(): void;
+}
+interface RuntimeCapabilities {
+    /** Physics simulation */
+    physics?: {
+        gravity: boolean;
+        collision: boolean;
+        constraints: boolean;
+        softBody: boolean;
+        fluids: boolean;
+    };
+    /** Rendering capabilities */
+    rendering?: {
+        particles: boolean;
+        lighting: boolean;
+        shadows: boolean;
+        postProcessing: boolean;
+    };
+    /** Interaction capabilities */
+    interaction?: {
+        userInput: boolean;
+        gestures: boolean;
+        voice: boolean;
+        haptics: boolean;
+    };
+    /** Platform support */
+    platforms?: string[];
+    /** Performance metrics */
+    performance?: {
+        maxEntities: number;
+        maxParticles: number;
+        targetFPS: number;
+    };
+}
+interface RuntimeMetadata {
+    /** Author */
+    author?: string;
+    /** Description */
+    description?: string;
+    /** Documentation URL */
+    documentation?: string;
+    /** Repository URL */
+    repository?: string;
+    /** License */
+    license?: string;
+    /** Tags */
+    tags?: string[];
+}
+/**
+ * Runtime Registry - Central registry for all HoloScript runtimes
+ */
+declare class RuntimeRegistryClass {
+    private runtimes;
+    /**
+     * Register a runtime module
+     */
+    register(runtime: RuntimeModule): void;
+    /**
+     * Unregister a runtime module
+     */
+    unregister(runtimeId: string): boolean;
+    /**
+     * Get runtime by ID
+     */
+    get(runtimeId: string): RuntimeModule | undefined;
+    /**
+     * Check if runtime is registered
+     */
+    has(runtimeId: string): boolean;
+    /**
+     * Get all registered runtimes
+     */
+    getAll(): RuntimeModule[];
+    /**
+     * Get runtime IDs
+     */
+    getIds(): string[];
+    /**
+     * Find runtimes by type
+     */
+    findByType(type: string): RuntimeModule[];
+    /**
+     * Find runtimes by capability
+     */
+    findByCapability(capability: string): RuntimeModule[];
+    /**
+     * Find runtimes by tag
+     */
+    findByTag(tag: string): RuntimeModule[];
+    /**
+     * Execute composition with appropriate runtime
+     */
+    execute(composition: HoloComposition, config?: any): RuntimeExecutor | null;
+    /**
+     * Get registry statistics
+     */
+    getStatistics(): {
+        totalRuntimes: number;
+        runtimes: {
+            id: string;
+            name: string;
+            version: string;
+            types: string[];
+            tags: string[];
+        }[];
+    };
+    /**
+     * Clear all runtimes (mainly for testing)
+     */
+    clear(): void;
+}
+declare const RuntimeRegistry: RuntimeRegistryClass;
+/**
+ * Decorator for registering runtime modules
+ */
+declare function registerRuntime(runtime: RuntimeModule): RuntimeModule;
+
+/**
+ * RuntimeRenderer.ts
+ *
+ * Abstract runtime renderer interface.
+ * Bridges HoloScript runtime physics → visual rendering backends.
+ */
+
+/**
+ * Renderable object in 3D space
+ */
+interface RenderableObject {
+    id: string;
+    type: string;
+    position: [number, number, number];
+    rotation?: [number, number, number];
+    scale?: [number, number, number];
+    geometry?: {
+        type: string;
+        size?: number | [number, number, number];
+        radius?: number;
+        height?: number;
+        segments?: number;
+    };
+    material?: {
+        type?: string;
+        color?: string;
+        roughness?: number;
+        metalness?: number;
+        opacity?: number;
+        transparent?: boolean;
+        [key: string]: unknown;
+    };
+    visible?: boolean;
+    castShadow?: boolean;
+    receiveShadow?: boolean;
+}
+/**
+ * Particle system configuration
+ */
+interface ParticleSystem {
+    id: string;
+    maxParticles: number;
+    positions: Float32Array;
+    velocities?: Float32Array;
+    colors?: Float32Array;
+    sizes?: Float32Array;
+    lifetimes?: Float32Array;
+    material?: {
+        type?: string;
+        color?: string;
+        size?: number;
+        opacity?: number;
+        blending?: string;
+    };
+}
+/**
+ * Light configuration
+ */
+interface RenderableLight {
+    id: string;
+    type: 'directional' | 'point' | 'spot' | 'hemisphere' | 'ambient' | 'area';
+    position?: [number, number, number];
+    color?: string;
+    intensity?: number;
+    castShadow?: boolean;
+    target?: [number, number, number];
+}
+/**
+ * Camera configuration
+ */
+interface RenderableCamera {
+    position: [number, number, number];
+    target: [number, number, number];
+    fov?: number;
+    aspect?: number;
+    near?: number;
+    far?: number;
+}
+/**
+ * Post-processing effects
+ */
+interface PostProcessingEffect {
+    type: string;
+    enabled: boolean;
+    params?: Record<string, unknown>;
+}
+/**
+ * Abstract Runtime Renderer
+ */
+interface RuntimeRenderer {
+    /**
+     * Initialize renderer with composition
+     */
+    initialize(composition: HoloComposition, config?: RendererConfig): void;
+    /**
+     * Start rendering loop
+     */
+    start(): void;
+    /**
+     * Stop rendering loop
+     */
+    stop(): void;
+    /**
+     * Update scene (called per frame)
+     */
+    update(deltaTime: number): void;
+    /**
+     * Render single frame
+     */
+    render(): void;
+    /**
+     * Add object to scene
+     */
+    addObject(object: RenderableObject): void;
+    /**
+     * Remove object from scene
+     */
+    removeObject(objectId: string): void;
+    /**
+     * Update object transform
+     */
+    updateObjectTransform(objectId: string, transform: {
+        position?: [number, number, number];
+        rotation?: [number, number, number];
+        scale?: [number, number, number];
+    }): void;
+    /**
+     * Add particle system
+     */
+    addParticleSystem(system: ParticleSystem): void;
+    /**
+     * Update particle system
+     */
+    updateParticleSystem(systemId: string, positions: Float32Array, colors?: Float32Array): void;
+    /**
+     * Remove particle system
+     */
+    removeParticleSystem(systemId: string): void;
+    /**
+     * Add light to scene
+     */
+    addLight(light: RenderableLight): void;
+    /**
+     * Update camera
+     */
+    updateCamera(camera: RenderableCamera): void;
+    /**
+     * Enable post-processing effect
+     */
+    enablePostProcessing(effect: PostProcessingEffect): void;
+    /**
+     * Get renderer statistics
+     */
+    getStatistics(): RendererStatistics;
+    /**
+     * Resize renderer
+     */
+    resize(width: number, height: number): void;
+    /**
+     * Dispose renderer and free resources
+     */
+    dispose(): void;
+}
+/**
+ * Renderer configuration
+ */
+interface RendererConfig {
+    canvas?: HTMLCanvasElement;
+    width?: number;
+    height?: number;
+    backgroundColor?: string;
+    antialias?: boolean;
+    shadows?: boolean;
+    physicallyCorrectLights?: boolean;
+    toneMapping?: string;
+    toneMappingExposure?: number;
+    outputEncoding?: string;
+    maxLights?: number;
+    debug?: boolean;
+}
+/**
+ * Renderer statistics
+ */
+interface RendererStatistics {
+    fps: number;
+    frameTime: number;
+    drawCalls: number;
+    triangles: number;
+    points: number;
+    lines: number;
+    objects: number;
+    lights: number;
+    textures: number;
+    programs: number;
+    memoryUsage?: {
+        geometries: number;
+        textures: number;
+    };
+}
+/**
+ * Base renderer implementation with common logic
+ */
+declare abstract class BaseRuntimeRenderer implements RuntimeRenderer {
+    protected composition?: HoloComposition;
+    protected config: RendererConfig;
+    protected isRunning: boolean;
+    protected objects: Map<string, RenderableObject>;
+    protected particleSystems: Map<string, ParticleSystem>;
+    protected lights: Map<string, RenderableLight>;
+    protected camera?: RenderableCamera;
+    constructor(config?: RendererConfig);
+    abstract initialize(composition: HoloComposition, config?: RendererConfig): void;
+    abstract start(): void;
+    abstract stop(): void;
+    abstract update(deltaTime: number): void;
+    abstract render(): void;
+    abstract addObject(object: RenderableObject): void;
+    abstract removeObject(objectId: string): void;
+    abstract updateObjectTransform(objectId: string, transform: {
+        position?: [number, number, number];
+        rotation?: [number, number, number];
+        scale?: [number, number, number];
+    }): void;
+    abstract addParticleSystem(system: ParticleSystem): void;
+    abstract updateParticleSystem(systemId: string, positions: Float32Array, colors?: Float32Array): void;
+    abstract removeParticleSystem(systemId: string): void;
+    abstract addLight(light: RenderableLight): void;
+    abstract updateCamera(camera: RenderableCamera): void;
+    abstract enablePostProcessing(effect: PostProcessingEffect): void;
+    abstract getStatistics(): RendererStatistics;
+    abstract resize(width: number, height: number): void;
+    abstract dispose(): void;
+}
+
+/**
+ * ThreeJSRenderer.ts
+ *
+ * Three.js implementation of RuntimeRenderer.
+ * Uses R3FCompiler's material presets and type mappings for runtime rendering.
+ */
+
+interface TransformSpec {
+    position?: [number, number, number];
+    rotation?: [number, number, number];
+    scale?: [number, number, number];
+}
+/**
+ * Three.js Runtime Renderer
+ *
+ * Renders HoloScript compositions using Three.js at runtime.
+ * Extracts rendering knowledge from R3FCompiler for direct execution.
+ */
+declare class ThreeJSRenderer extends BaseRuntimeRenderer {
+    private scene;
+    private renderer;
+    private activeCamera;
+    private meshes;
+    private particleGeometries;
+    private particleMeshes;
+    private lightObjects;
+    private animationFrameId?;
+    private clock;
+    private composer;
+    private renderPass;
+    private bloomPass;
+    private bokehPass;
+    private ssaoPass;
+    private enabledEffects;
+    private instancedMeshes;
+    private instanceMatrices;
+    private instanceCounts;
+    private maxInstancesPerType;
+    private enableInstancing;
+    private stats;
+    constructor(config?: RendererConfig);
+    /**
+     * Initialize renderer with composition
+     */
+    initialize(composition: HoloComposition, config?: RendererConfig): void;
+    /**
+     * Initialize Three.js scene (lazy loaded)
+     */
+    private initializeThreeJS;
+    /**
+     * Load composition into Three.js scene
+     */
+    private loadComposition;
+    /**
+     * Add default lighting to scene
+     */
+    private addDefaultLighting;
+    /**
+     * Start rendering loop
+     */
+    start(): void;
+    /**
+     * Stop rendering loop
+     */
+    stop(): void;
+    /**
+     * Animation loop
+     */
+    private animate;
+    /**
+     * Update scene
+     */
+    update(_deltaTime: number): void;
+    /**
+     * Render frame
+     */
+    render(): void;
+    /**
+     * Add object to scene
+     */
+    addObject(object: RenderableObject): void;
+    /**
+     * Create geometry from specification
+     */
+    private static getThreeLib;
+    private createGeometry;
+    /**
+     * Create material using R3FCompiler presets
+     */
+    private createMaterial;
+    /**
+     * Remove object from scene
+     */
+    removeObject(objectId: string): void;
+    /**
+     * Update object transform
+     */
+    updateObjectTransform(objectId: string, transform: TransformSpec): void;
+    /**
+     * Add particle system
+     */
+    addParticleSystem(system: ParticleSystem): void;
+    /**
+     * Update particle system
+     */
+    updateParticleSystem(systemId: string, positions: Float32Array, colors?: Float32Array): void;
+    /**
+     * Remove particle system
+     */
+    removeParticleSystem(systemId: string): void;
+    /**
+     * Add light to scene
+     */
+    addLight(light: RenderableLight): void;
+    /**
+     * Update camera
+     */
+    updateCamera(camera: RenderableCamera): void;
+    /**
+     * Initialize post-processing pipeline
+     */
+    private initializePostProcessing;
+    /**
+     * Enable post-processing effect
+     */
+    enablePostProcessing(effect: PostProcessingEffect): void;
+    /**
+     * Enable/disable frustum culling optimization
+     * Automatically enabled by Three.js, but can be toggled per object
+     */
+    enableFrustumCulling(enable: boolean): void;
+    /**
+     * Optimize geometry by merging vertices and reducing complexity
+     * This is a simple optimization that can reduce memory usage
+     */
+    optimizeGeometries(): void;
+    /**
+     * Set Level of Detail (LOD) for objects based on distance from camera
+     * Objects far from camera use simpler geometry
+     */
+    updateLOD(): void;
+    /**
+     * Enable automatic performance optimizations
+     * Runs optimization passes periodically
+     */
+    private performanceOptimizationFrame;
+    enableAutoOptimization(enable: boolean): void;
+    /**
+     * Get renderer statistics
+     */
+    getStatistics(): RendererStatistics;
+    /**
+     * Resize renderer
+     */
+    resize(width: number, height: number): void;
+    /**
+     * Dispose renderer and free resources
+     */
+    dispose(): void;
+}
+
+/**
+ * InstancedMeshManager.ts
+ *
+ * GPU instancing system for rendering massive numbers of similar objects.
+ * Reduces draw calls from 10,000 to ~10 for extreme performance.
+ *
+ * Performance Impact:
+ * - Without instancing: 1,000 objects = 1,000 draw calls = ~30 FPS
+ * - With instancing: 10,000 objects = ~10 draw calls = 60 FPS
+ */
+
+interface InstancedObjectData {
+    /** Unique instance ID */
+    id: string;
+    /** Position [x, y, z] */
+    position: [number, number, number];
+    /** Rotation [x, y, z] (Euler angles) */
+    rotation: [number, number, number];
+    /** Scale [x, y, z] */
+    scale: [number, number, number];
+    /** Color (hex string or RGB) */
+    color?: string | [number, number, number];
+    /** Custom user data */
+    userData?: any;
+}
+interface InstanceBatchConfig {
+    /** Geometry type */
+    geometryType: 'box' | 'sphere' | 'cylinder' | 'custom';
+    /** Geometry parameters (e.g., size for box) */
+    geometryParams?: any;
+    /** Material configuration */
+    material: {
+        type: 'standard' | 'basic' | 'physical';
+        color?: string;
+        metalness?: number;
+        roughness?: number;
+        emissive?: string;
+        opacity?: number;
+        transparent?: boolean;
+    };
+    /** Maximum instances this batch can hold */
+    maxInstances: number;
+    /** Custom geometry (if geometryType is 'custom') */
+    customGeometry?: THREE.BufferGeometry;
+}
+interface InstanceBatchStats {
+    /** Number of active instances */
+    activeCount: number;
+    /** Maximum capacity */
+    maxInstances: number;
+    /** Utilization percentage */
+    utilization: number;
+    /** Geometry type */
+    geometryType: string;
+    /** Material type */
+    materialType: string;
+}
+/**
+ * Manages multiple batches of instanced meshes
+ */
+declare class InstancedMeshManager {
+    private readonly batches;
+    private readonly instanceToBatch;
+    private batchCounter;
+    /**
+     * Create a batch key from config
+     */
+    private getBatchKey;
+    /**
+     * Create or get existing batch
+     */
+    private getOrCreateBatch;
+    /**
+     * Add instanced object
+     */
+    addInstance(data: InstancedObjectData, config: InstanceBatchConfig): boolean;
+    /**
+     * Update instance
+     */
+    updateInstance(id: string, data: Partial<InstancedObjectData>): boolean;
+    /**
+     * Remove instance
+     */
+    removeInstance(id: string): boolean;
+    /**
+     * Get all meshes for adding to scene
+     */
+    getMeshes(): THREE.InstancedMesh[];
+    /**
+     * Get overall statistics
+     */
+    getStats(): {
+        totalBatches: number;
+        totalInstances: number;
+        batches: Map<string, InstanceBatchStats>;
+    };
+    /**
+     * Clear all instances
+     */
+    clear(): void;
+    /**
+     * Dispose all resources
+     */
+    dispose(): void;
+}
+
+/**
+ * PostProcessingManager.ts
+ *
+ * Advanced post-processing effects for AAA-quality visuals.
+ * Includes SSAO, SSR, bloom, motion blur, TAA, and more.
+ *
+ * Visual Impact:
+ * - SSAO: Realistic ambient occlusion shadows
+ * - Bloom: Glowing lights and emissive materials
+ * - Motion Blur: Cinematic motion effects
+ * - TAA: Anti-aliasing with temporal filtering
+ * - Depth of Field: Camera focus effects
+ */
+
+type PostProcessingQuality = 'low' | 'medium' | 'high' | 'ultra';
+interface PostProcessingConfig {
+    /** Enable SSAO (Screen-Space Ambient Occlusion) */
+    ssao?: {
+        enabled: boolean;
+        radius?: number;
+        minDistance?: number;
+        maxDistance?: number;
+        intensity?: number;
+    };
+    /** Enable Bloom */
+    bloom?: {
+        enabled: boolean;
+        strength?: number;
+        radius?: number;
+        threshold?: number;
+    };
+    /** Enable TAA (Temporal Anti-Aliasing) */
+    taa?: {
+        enabled: boolean;
+        sampleLevel?: number;
+    };
+    /** Enable FXAA (Fast Approximate Anti-Aliasing) */
+    fxaa?: {
+        enabled: boolean;
+    };
+    /** Enable Motion Blur */
+    motionBlur?: {
+        enabled: boolean;
+        intensity?: number;
+        samples?: number;
+    };
+    /** Enable Depth of Field */
+    depthOfField?: {
+        enabled: boolean;
+        focusDistance?: number;
+        focalLength?: number;
+        bokehScale?: number;
+    };
+    /** Enable Vignette */
+    vignette?: {
+        enabled: boolean;
+        offset?: number;
+        darkness?: number;
+    };
+    /** Enable Film Grain */
+    filmGrain?: {
+        enabled: boolean;
+        intensity?: number;
+    };
+    /** Enable Chromatic Aberration */
+    chromaticAberration?: {
+        enabled: boolean;
+        offset?: number;
+    };
+    /** Overall quality preset */
+    quality?: PostProcessingQuality;
+}
+interface PostProcessingStats {
+    enabled: boolean;
+    activeEffects: number;
+    renderTime: number;
+    quality: PostProcessingQuality;
+}
+/**
+ * Manages post-processing effects for enhanced visuals
+ */
+declare class PostProcessingManager {
+    private composer;
+    private config;
+    private quality;
+    private enabled;
+    private renderTime;
+    private passes;
+    constructor(config?: PostProcessingConfig);
+    /**
+     * Merge user config with quality preset
+     */
+    private mergeWithPreset;
+    /**
+     * Initialize post-processing with renderer, scene, and camera
+     */
+    initialize(renderer: THREE.WebGLRenderer, scene: THREE.Scene, camera: THREE.Camera): void;
+    /**
+     * Add SSAO (Screen-Space Ambient Occlusion)
+     */
+    private addSSAO;
+    /**
+     * Add Bloom effect
+     */
+    private addBloom;
+    /**
+     * Add TAA (Temporal Anti-Aliasing)
+     */
+    private addTAA;
+    /**
+     * Add FXAA (Fast Approximate Anti-Aliasing)
+     */
+    private addFXAA;
+    /**
+     * Add Vignette effect
+     */
+    private addVignette;
+    /**
+     * Add Film Grain effect
+     */
+    private addFilmGrain;
+    /**
+     * Add Chromatic Aberration effect
+     */
+    private addChromaticAberration;
+    /**
+     * Render with post-processing
+     */
+    render(deltaTime?: number): void;
+    /**
+     * Update quality preset
+     */
+    setQuality(quality: PostProcessingQuality): void;
+    /**
+     * Enable/disable specific effect
+     */
+    setEffectEnabled(effectName: string, enabled: boolean): void;
+    /**
+     * Enable/disable all post-processing
+     */
+    setEnabled(enabled: boolean): void;
+    /**
+     * Get statistics
+     */
+    getStats(): PostProcessingStats;
+    /**
+     * Resize (call when renderer size changes)
+     */
+    setSize(width: number, height: number): void;
+    /**
+     * Dispose resources
+     */
+    dispose(): void;
+}
+
+/**
+ * ShaderOptimizationManager.ts
+ *
+ * Custom shader system for GPU-based performance optimizations.
+ * Provides highly optimized shaders for particles, meshes, and compute operations.
+ *
+ * Performance Benefits:
+ * - Custom particle shader: 3-5x faster than default PointsMaterial
+ * - Batched mesh shader: 2-3x faster rendering for similar objects
+ * - GPU-based physics: 10-20x faster than CPU calculations
+ * - Instanced rendering: Up to 100x reduction in draw calls
+ */
+
+/**
+ * High-performance particle shader with GPU-based size/color calculations
+ */
+declare const OptimizedParticleShader: {
+    uniforms: {
+        time: {
+            value: number;
+        };
+        pointSize: {
+            value: number;
+        };
+        cameraPosition: {
+            value: THREE.Vector3;
+        };
+        fadeDistance: {
+            value: number;
+        };
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};
+/**
+ * GPU-accelerated debris/fragment shader with LOD support
+ */
+declare const OptimizedDebrisShader: {
+    uniforms: {
+        time: {
+            value: number;
+        };
+        lightPosition: {
+            value: THREE.Vector3;
+        };
+        lightColor: {
+            value: THREE.Color;
+        };
+        ambientIntensity: {
+            value: number;
+        };
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};
+/**
+ * Batched mesh shader for rendering many similar objects efficiently
+ */
+declare const BatchedMeshShader: {
+    uniforms: {
+        diffuseMap: {
+            value: THREE.Texture | null;
+        };
+        lightPosition: {
+            value: THREE.Vector3;
+        };
+        tintColor: {
+            value: THREE.Color;
+        };
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};
+/**
+ * Water/fluid simulation shader (simplified for performance)
+ */
+declare const OptimizedFluidShader: {
+    uniforms: {
+        time: {
+            value: number;
+        };
+        flowSpeed: {
+            value: number;
+        };
+        waveHeight: {
+            value: number;
+        };
+        waterColor: {
+            value: THREE.Color;
+        };
+        opacity: {
+            value: number;
+        };
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};
+/**
+ * Terrain deformation shader
+ */
+declare const TerrainDeformationShader: {
+    uniforms: {
+        deformationMap: {
+            value: THREE.Texture | null;
+        };
+        heightScale: {
+            value: number;
+        };
+        baseColor: {
+            value: THREE.Color;
+        };
+        grassColor: {
+            value: THREE.Color;
+        };
+        rockColor: {
+            value: THREE.Color;
+        };
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};
+interface ShaderOptimizationConfig {
+    /** Enable custom particle shader */
+    useOptimizedParticles?: boolean;
+    /** Enable custom debris shader */
+    useOptimizedDebris?: boolean;
+    /** Enable batched mesh shader */
+    useBatchedMeshes?: boolean;
+    /** Enable fluid shader */
+    useFluidShader?: boolean;
+    /** Enable terrain deformation */
+    useTerrainDeformation?: boolean;
+}
+interface ShaderPerformanceStats {
+    shadersActive: number;
+    drawCalls: number;
+    triangles: number;
+    shaderCompileTime: number;
+}
+/**
+ * Manages shader-based optimizations for maximum performance
+ */
+declare class ShaderOptimizationManager {
+    private config;
+    private materials;
+    private compileTime;
+    constructor(config?: ShaderOptimizationConfig);
+    /**
+     * Create optimized particle material
+     */
+    createParticleMaterial(params?: {
+        pointSize?: number;
+        fadeDistance?: number;
+    }): THREE.ShaderMaterial;
+    /**
+     * Create optimized debris material
+     */
+    createDebrisMaterial(params?: {
+        lightPosition?: THREE.Vector3;
+        ambientIntensity?: number;
+    }): THREE.ShaderMaterial;
+    /**
+     * Create batched mesh material
+     */
+    createBatchedMeshMaterial(params?: {
+        diffuseMap?: THREE.Texture;
+        tintColor?: THREE.Color;
+    }): THREE.ShaderMaterial;
+    /**
+     * Create fluid shader material
+     */
+    createFluidMaterial(params?: {
+        flowSpeed?: number;
+        waveHeight?: number;
+        waterColor?: THREE.Color;
+        opacity?: number;
+    }): THREE.ShaderMaterial;
+    /**
+     * Create terrain deformation material
+     */
+    createTerrainMaterial(params?: {
+        deformationMap?: THREE.Texture;
+        heightScale?: number;
+        baseColor?: THREE.Color;
+    }): THREE.ShaderMaterial;
+    /**
+     * Update shader uniforms (call each frame)
+     */
+    update(_deltaTime: number): void;
+    /**
+     * Get performance statistics
+     */
+    getStats(): ShaderPerformanceStats;
+    /**
+     * Dispose all shader materials
+     */
+    dispose(): void;
+}
+
+/**
+ * SceneInspector.ts
+ *
+ * Comprehensive debugging and inspection system for HoloScript scenes.
+ * Provides visual debugging overlays, performance metrics, and scene exploration tools.
+ *
+ * Features:
+ * - Scene hierarchy visualization
+ * - Object property inspection
+ * - Performance metrics (FPS, draw calls, memory)
+ * - Visual debug overlays (bounding boxes, normals, wireframe)
+ * - Camera debugging
+ * - Particle system visualization
+ * - Physics debug rendering
+ */
+
+interface InspectorConfig {
+    /** Show FPS counter */
+    showFPS?: boolean;
+    /** Show memory usage */
+    showMemory?: boolean;
+    /** Show draw calls */
+    showDrawCalls?: boolean;
+    /** Show scene hierarchy */
+    showHierarchy?: boolean;
+    /** Show bounding boxes */
+    showBoundingBoxes?: boolean;
+    /** Show wireframe overlay */
+    showWireframe?: boolean;
+    /** Show normals */
+    showNormals?: boolean;
+    /** Show camera frustum */
+    showCameraFrustum?: boolean;
+    /** Show coordinate axes */
+    showAxes?: boolean;
+    /** Show grid */
+    showGrid?: boolean;
+}
+interface SceneStats {
+    fps: number;
+    frameTime: number;
+    objectCount: number;
+    triangleCount: number;
+    drawCalls: number;
+    memory: {
+        geometries: number;
+        textures: number;
+        total: number;
+    };
+    particleSystems: number;
+    activeLights: number;
+    cameras: number;
+}
+interface ObjectInfo {
+    name: string;
+    type: string;
+    uuid: string;
+    position: THREE.Vector3;
+    rotation: THREE.Euler;
+    scale: THREE.Vector3;
+    visible: boolean;
+    children: number;
+    triangles: number;
+}
+/**
+ * Scene Inspector for debugging and visualization
+ */
+declare class SceneInspector {
+    private config;
+    private scene;
+    private camera;
+    private renderer;
+    private boundingBoxHelpers;
+    private normalHelpers;
+    private axesHelper;
+    private gridHelper;
+    private cameraHelper;
+    private frameCount;
+    private lastTime;
+    private fps;
+    private frameTime;
+    private frameTimeSamples;
+    constructor(config?: InspectorConfig);
+    /**
+     * Attach inspector to a scene
+     */
+    attach(scene: THREE.Scene, camera: THREE.Camera, renderer: THREE.WebGLRenderer): void;
+    /**
+     * Detach inspector from scene
+     */
+    detach(): void;
+    /**
+     * Initialize debug overlay objects
+     */
+    private initializeDebugOverlays;
+    /**
+     * Clear all debug overlays
+     */
+    private clearDebugOverlays;
+    /**
+     * Update debug visualizations (call each frame)
+     */
+    update(): void;
+    /**
+     * Update performance metrics
+     */
+    private updatePerformanceMetrics;
+    /**
+     * Update debug overlay objects
+     */
+    private updateDebugOverlays;
+    /**
+     * Update bounding box helpers
+     */
+    private updateBoundingBoxes;
+    /**
+     * Clear bounding box helpers
+     */
+    private clearBoundingBoxes;
+    /**
+     * Update normal helpers
+     */
+    private updateNormals;
+    /**
+     * Clear normal helpers
+     */
+    private clearNormals;
+    /**
+     * Get comprehensive scene statistics
+     */
+    getStats(): SceneStats;
+    /**
+     * Get empty stats structure
+     */
+    private getEmptyStats;
+    /**
+     * Get scene hierarchy as tree structure
+     */
+    getSceneHierarchy(): ObjectInfo[];
+    /**
+     * Get detailed information about a specific object
+     */
+    getObjectInfo(object: THREE.Object3D): ObjectInfo;
+    /**
+     * Find object by UUID
+     */
+    findObject(uuid: string): THREE.Object3D | null;
+    /**
+     * Find objects by name
+     */
+    findObjectsByName(name: string): THREE.Object3D[];
+    /**
+     * Find objects by type
+     */
+    findObjectsByType(type: string): THREE.Object3D[];
+    /**
+     * Toggle debug feature
+     */
+    toggleFeature(feature: keyof InspectorConfig, enabled?: boolean): void;
+    /**
+     * Get current configuration
+     */
+    getConfig(): Required<InspectorConfig>;
+    /**
+     * Update configuration
+     */
+    setConfig(config: Partial<InspectorConfig>): void;
+    /**
+     * Export scene statistics as JSON
+     */
+    exportStats(): string;
+    /**
+     * Dispose inspector and cleanup
+     */
+    dispose(): void;
+}
+
+/**
+ * GameLoop.ts — Sprint 6
+ *
+ * A simple deterministic game loop using setInterval for portability
+ * across Node.js and browser environments. Exposes start/stop/pause/resume
+ * and calls the provided `onUpdate(deltaMs)` callback each tick.
+ *
+ * Design choices:
+ *  - Uses setInterval rather than requestAnimationFrame so tests can advance
+ *    time without requiring a browser runtime.
+ *  - `tickIntervalMs` defaults to 16ms (≈60 fps) but is overridable.
+ *  - `pause()` keeps the interval alive but skips the onUpdate call,
+ *    preserving the timing baseline so resume is seamless.
+ *  - `frame` is incremented every time onUpdate fires (not every tick).
+ */
+interface GameLoopOptions {
+    /** Called each tick with deltaMs since last tick (paused ticks are skipped). */
+    onUpdate: (deltaMs: number) => void | Promise<void>;
+    /**
+     * Interval between ticks in ms.
+     * @default 16   (approx. 60 fps)
+     */
+    tickIntervalMs?: number;
+    /**
+     * Alias for tickIntervalMs, derived from fps.
+     * If provided, takes precedence over tickIntervalMs.
+     */
+    targetFps?: number;
+}
+declare class GameLoop {
+    private _isRunning;
+    private _isPaused;
+    private _frame;
+    private _handle;
+    private _lastTime;
+    private readonly onUpdate;
+    private readonly intervalMs;
+    constructor(options: GameLoopOptions);
+    /** Whether the loop is currently running (not stopped). */
+    get isRunning(): boolean;
+    /** Whether the loop is paused (running but not ticking). */
+    get isPaused(): boolean;
+    /** Number of update calls since start() (skips paused frames). */
+    get frame(): number;
+    /**
+     * Start the game loop.
+     * If already running, this is a no-op.
+     */
+    start(): void;
+    /**
+     * Stop the game loop permanently.
+     * Resets frame counter and running state.
+     */
+    stop(): void;
+    /**
+     * Pause the loop. `isRunning` stays true but `onUpdate` is not called.
+     * The interval continues so resuming has minimal lag.
+     */
+    pause(): void;
+    /**
+     * Resume from a paused state. Resets the last-time baseline so the first
+     * resumed tick doesn't produce an artificially large delta.
+     */
+    resume(): void;
+    private _tick;
+}
+
+/**
+ * AssetPipeline.ts — Sprint 7
+ *
+ * A lightweight, type-keyed asset loading pipeline with:
+ *  - Per-type loader registration
+ *  - Content-addressable cache (type + path key)
+ *  - Failed-load exclusion from cache
+ *  - evict(), clear(), isLoaded(), loadedCount
+ *
+ * Designed for use in SceneRunner and test contexts where you need
+ * deterministic, promise-based asset loading with no framework dependencies.
+ */
+/** A loader function maps a path string → an arbitrary asset value. */
+type AssetLoader<T = unknown> = (path: string) => Promise<T>;
+declare class AssetPipeline {
+    private loaders;
+    private cache;
+    /** Register (or replace) a loader for an asset type. */
+    registerLoader<T>(type: string, loader: AssetLoader<T>): void;
+    /** Whether a loader is registered for the given type. */
+    hasLoader(type: string): boolean;
+    /**
+     * Load an asset by type and path.
+     *
+     * - Returns the cached asset if already loaded.
+     * - Calls the registered loader and caches the result.
+     * - Throws if no loader is registered for the type.
+     * - Does NOT cache failed loads, so a subsequent call may retry.
+     */
+    load<T = unknown>(type: string, path: string): Promise<T>;
+    /** Whether the asset at (type, path) is currently cached. */
+    isLoaded(type: string, path: string): boolean;
+    /** Remove a single asset from the cache. */
+    evict(type: string, path: string): void;
+    /** Remove all assets from the cache. */
+    clear(): void;
+    /** Number of currently cached assets. */
+    get loadedCount(): number;
+}
+
+/**
+ * HotReloadManager.ts — Sprint 8
+ *
+ * Manages live module reload with:
+ *  - Per-key watcher registration / deregistration
+ *  - State migration helper for preserving entity state across reloads
+ *  - Version tracking (increments per triggerReload call)
+ *  - Isolated watcher error handling (one failure does not block others)
+ *
+ * Design:
+ *  - `watch(key, fn)` registers a callback. Multiple watchers per key allowed.
+ *  - `triggerReload(key, content, oldState?)` calls each watcher in order.
+ *    If a watcher throws, `onError` is called and the next watcher still runs.
+ *  - `migrateState(old, newDefaults)` produces a merged state object:
+ *    fields present in newDefaults take their value from oldState (preserving
+ *    live game values), and any field in newDefaults not in oldState gets its
+ *    default value from newDefaults.
+ */
+type ReloadWatcher<TContent = unknown, TState = unknown> = (content: TContent, prevState: TState | undefined, meta: {
+    key: string;
+    version: number;
+}) => void;
+interface HotReloadManagerOptions {
+    onError?: (key: string, error: Error) => void;
+}
+declare class HotReloadManager {
+    private watchers;
+    private versions;
+    private readonly onError?;
+    constructor(options?: HotReloadManagerOptions);
+    /** Register a watcher for a module key. Returns an unsubscribe function. */
+    watch(key: string, fn: ReloadWatcher): () => void;
+    /** Remove a specific watcher. */
+    unwatch(key: string, fn: ReloadWatcher): void;
+    /** Remove ALL watchers for a key. */
+    unwatchAll(key: string): void;
+    /** Whether at least one watcher is registered for the key. */
+    isWatched(key: string): boolean;
+    /**
+     * Trigger a reload for the given key.
+     *
+     * @param key       Module identifier (file path, scene name, etc.)
+     * @param content   New module content (AST, raw code, etc.)
+     * @param oldState  Previous runtime state to pass to watchers for migration
+     */
+    triggerReload<TContent = unknown, TState = unknown>(key: string, content: TContent, oldState?: TState): void;
+    /**
+     * Produce a merged state after a reload.
+     *
+     * Strategy:
+     *  - Start with `newState` (the defaults from the new module).
+     *  - For each key in `newState`, if `oldState` also has that key, prefer
+     *    the old value (preserves live runtime values like hp, position, etc.).
+     *  - Keys in `oldState` NOT present in `newState` are discarded (the new
+     *    module removed that field).
+     *
+     * If `oldState` is null/undefined, returns `newState` unchanged.
+     */
+    migrateState<T extends Record<string, unknown>>(oldState: T | null | undefined, newState: T): T;
+    /** How many times triggerReload has been called for this key. */
+    version(key: string): number;
+}
+
+/**
+ * GameEngine — HoloScript+ Top-Level Runtime Facade
+ *
+ * Composes GameLoop + AssetPipeline + HotReloadManager into a
+ * single ergonomic entry point:
+ *
+ *   const engine = new GameEngine();
+ *   engine.addUpdateHandler('physics', myPhysicsFn);
+ *   engine.start();
+ *   // ...
+ *   engine.stop();
+ *
+ * The engine does NOT depend on a renderer or HoloScript parser directly —
+ * it provides lifecycle hooks so the caller can wire those in.
+ *
+ * @module runtime/GameEngine
+ * @version 1.0.0
+ */
+
+type UpdateHandler = (delta: number, frame: number) => void;
+type EnginePhase = 'idle' | 'running' | 'paused' | 'stopped';
+interface GameEngineOptions extends Omit<GameLoopOptions, 'onUpdate'> {
+    /** Enable hot-reload watcher integration. Default: false */
+    hotReload?: boolean;
+}
+interface EngineStats {
+    phase: EnginePhase;
+    frame: number;
+    fps: number;
+    assetCount: number;
+}
+declare class GameEngine {
+    readonly loop: GameLoop;
+    readonly assets: AssetPipeline;
+    readonly hotReload: HotReloadManager;
+    private _phase;
+    private _updateHandlers;
+    private _frame;
+    private _lastTickTime;
+    private _fps;
+    constructor(options?: GameEngineOptions);
+    /** Start the engine (and the internal game loop). */
+    start(): void;
+    /** Stop the engine permanently. */
+    stop(): void;
+    /** Pause the update loop (keep state intact). */
+    pause(): void;
+    /** Resume from paused state. */
+    resume(): void;
+    /**
+     * Register a named update handler that runs every tick.
+     * Multiple handlers run in insertion order.
+     */
+    addUpdateHandler(name: string, fn: UpdateHandler): void;
+    /** Remove a previously-registered update handler. */
+    removeUpdateHandler(name: string): boolean;
+    /** List all registered handler names. */
+    getHandlerNames(): string[];
+    /**
+     * Register a typed asset loader and return the engine (fluent API).
+     * Delegates to this.assets.registerLoader().
+     */
+    registerLoader<T = unknown>(type: string, loader: AssetLoader<T>): this;
+    /**
+     * Preload an asset by type and path. Resolves when loaded or throws.
+     * Delegates to this.assets.load().
+     */
+    preload<T = unknown>(type: string, path: string): Promise<T>;
+    /**
+     * Watch a module by key. On reload, the watcher fn is called.
+     * Returns an unsubscribe function.
+     */
+    watch(key: string, fn: ReloadWatcher): () => void;
+    /**
+     * Trigger a hot-reload for the given key.
+     */
+    reload<TContent = unknown, TState = unknown>(key: string, content: TContent, oldState?: TState): void;
+    get phase(): EnginePhase;
+    get frame(): number;
+    get fps(): number;
+    /** Snapshot of engine state for debugging/telemetry. */
+    getStats(): EngineStats;
+    private _onUpdate;
+}
+
+/**
+ * @holoscript/core Runtime Optimization
+ *
+ * Object pooling, lazy evaluation, memoization, caching
+ */
+/**
+ * Generic object pool for efficient memory reuse
+ */
+declare class ObjectPool<T> {
+    private factory;
+    private reset;
+    private _capacity;
+    private available;
+    private inUse;
+    private peakUsage;
+    constructor(factory: () => T, reset: (obj: T) => void, _capacity?: number);
+    /**
+     * Pre-allocate objects
+     */
+    private preallocate;
+    /**
+     * Acquire object from pool
+     */
+    acquire(): T;
+    /**
+     * Release object back to pool
+     */
+    release(obj: T): void;
+    /**
+     * Batch acquire
+     */
+    acquireBatch(count: number): T[];
+    /**
+     * Batch release
+     */
+    releaseBatch(objects: T[]): void;
+    /**
+     * Get pool statistics
+     */
+    getStats(): {
+        available: number;
+        inUse: number;
+        peakUsage: number;
+        utilization: number;
+    };
+    /**
+     * Clear pool
+     */
+    clear(): void;
+}
+/**
+ * Lazy evaluated value
+ */
+declare class Lazy<T> {
+    private compute;
+    private value;
+    private computed;
+    constructor(compute: () => T);
+    /**
+     * Get value (compute if needed)
+     */
+    get(): T;
+    /**
+     * Force re-computation
+     */
+    reset(): void;
+    /**
+     * Check if computed
+     */
+    isComputed(): boolean;
+}
+/**
+ * Memoization decorator
+ */
+declare function memoize<T extends (...args: any[]) => any>(fn: T, maxSize?: number): T;
+/**
+ * Memoized property decorator
+ */
+declare function MemoizedProperty(): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+/**
+ * Method memoization decorator
+ */
+declare function MethodMemoize(maxSize?: number): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+/**
+ * LRU Cache with maximum size
+ */
+declare class LRUCache<K, V> {
+    private maxSize;
+    private cache;
+    private accessOrder;
+    constructor(maxSize?: number);
+    /**
+     * Get value from cache
+     */
+    get(key: K): V | undefined;
+    /**
+     * Set value in cache
+     */
+    set(key: K, value: V): void;
+    /**
+     * Clear cache
+     */
+    clear(): void;
+    /**
+     * Get cache stats
+     */
+    getStats(): {
+        size: number;
+        maxSize: number;
+        utilization: number;
+    };
+}
+/**
+ * Batch processing for efficient bulk operations
+ */
+declare class Batcher<T, R> {
+    private processor;
+    private batchSize;
+    private flushIntervalMs;
+    private queue;
+    private processingTimeout;
+    constructor(processor: (batch: T[]) => Promise<R[]>, batchSize?: number, flushIntervalMs?: number);
+    /**
+     * Add item to batch
+     */
+    add(item: T): Promise<R>;
+    /**
+     * Flush batch
+     */
+    private flush;
+    /**
+     * Manually flush remaining items
+     */
+    flushAll(): Promise<R[]>;
+}
+/**
+ * Performance profiler with hot path tracking
+ */
+declare class PerformanceProfiler {
+    private measurements;
+    private activeTimers;
+    /**
+     * Start timing a function
+     */
+    startTimer(label: string): void;
+    /**
+     * End timing
+     */
+    endTimer(label: string): number;
+    /**
+     * Measure function execution
+     */
+    measure<T>(label: string, fn: () => Promise<T>): Promise<T>;
+    /**
+     * Get profiling report
+     */
+    getReport(): string;
+    /**
+     * Reset measurements
+     */
+    reset(): void;
+    /**
+     * Get hottest paths
+     */
+    getHotPaths(topN?: number): Array<[string, number]>;
+}
+declare function getGlobalProfiler(): PerformanceProfiler;
+
+/**
+ * @holoscript/core Voice Synthesizer Interface
+ *
+ * Defines the @builtin runtime interface for neural text-to-speech.
+ * Runtimes implement this to bridge with providers like ElevenLabs, Azure, or Coqui.
+ */
+/**
+ * Voice synthesizer configuration
+ */
+interface VoiceConfig {
+    /** Backend provider (e.g., 'elevenlabs', 'azure', 'coqui') */
+    backend: string;
+    /** API Key or local model path */
+    apiKey?: string;
+    modelPath?: string;
+    /** Default voice settings */
+    defaultVoiceId?: string;
+}
+/**
+ * Speech synthesis request
+ */
+interface VoiceRequest {
+    text: string;
+    voiceId?: string;
+    /** Emotion parameters (0-1 intensity) */
+    emotion?: {
+        type: 'angry' | 'sad' | 'excited' | 'friendly' | 'scared' | 'neutral';
+        intensity: number;
+    };
+    /** Prosody settings */
+    pitch?: number;
+    rate?: number;
+    volume?: number;
+}
+/**
+ * Available voice information
+ */
+interface VoiceInfo {
+    id: string;
+    name: string;
+    gender?: 'male' | 'female' | 'non-binary';
+    language: string;
+    provider: string;
+}
+/**
+ * VoiceSynthesizer @builtin Interface
+ */
+interface VoiceSynthesizer {
+    /** Initialize the synthesizer with config */
+    initialize(config: VoiceConfig): Promise<void>;
+    /**
+     * Generate audio buffer from text.
+     * Runtimes should handle the actual networking/synthesis.
+     */
+    generate(request: VoiceRequest): Promise<ArrayBuffer>;
+    /** List available voices */
+    getVoices(): Promise<VoiceInfo[]>;
+    /** Dispose resources */
+    dispose(): void;
+}
+/**
+ * Global registry for builtin VoiceSynthesizers
+ */
+declare const voiceSynthesizerRegistry: Map<string, VoiceSynthesizer>;
+/**
+ * Register a voice synthesizer implementation
+ */
+declare function registerVoiceSynthesizer(name: string, synthesizer: VoiceSynthesizer): void;
+/**
+ * Get a registered voice synthesizer
+ */
+declare function getVoiceSynthesizer(name: string): VoiceSynthesizer | undefined;
+
+/**
+ * @holoscript/core Base Voice Synthesizer
+ *
+ * Implements the VoiceSynthesizer interface with support for external providers
+ * and local phoneme/audio caching.
+ */
+
+declare class BaseVoiceSynthesizer implements VoiceSynthesizer {
+    private config?;
+    private cache;
+    private voices;
+    constructor();
+    initialize(config: VoiceConfig): Promise<void>;
+    generate(request: VoiceRequest): Promise<ArrayBuffer>;
+    getVoices(): Promise<VoiceInfo[]>;
+    dispose(): void;
+    private fetchElevenLabsVoices;
+    private fetchAzureVoices;
+    private callElevenLabs;
+    private callAzure;
+    private generateLocal;
+}
+
+/**
+ * Multimodal signals for emotion inference
+ */
+interface EmotionSignals {
+    /** Head stability (1.0 = stable, 0.0 = high jitter/shaking) */
+    headStability: number;
+    /** Dominant hand stability (1.0 = stable, 0.0 = tremors/jitter) */
+    handStability: number;
+    /** Interaction intensity (e.g., clicks per second, force of movement) */
+    interactionIntensity: number;
+    /** Task failure rate or repeated interaction patterns */
+    behavioralStressing: number;
+    /** Optional audio-derived stress (from VoiceSynthesizer/SpeechRecognizer) */
+    voiceStress?: number;
+}
+/**
+ * Result of emotion inference
+ */
+interface EmotionInference {
+    /** Frustration level (0.0 to 1.0) */
+    frustration: number;
+    /** Confusion/Uncertainty level (0.0 to 1.0) */
+    confusion: number;
+    /** User engagement/Focus level (0.0 to 1.0) */
+    engagement: number;
+    /** Predicted primary affective state */
+    primaryState: 'neutral' | 'happy' | 'angry' | 'sad' | 'scared' | 'confused' | 'frustrated';
+}
+/**
+ * Emotion detector configuration
+ */
+interface EmotionConfig {
+    /** Mode of detection (e.g., 'passive', 'active', 'calibrated') */
+    mode: string;
+    /** Model identifier or path */
+    modelId?: string;
+    /** Sensitivity adjustment (0.0 to 1.0) */
+    sensitivity?: number;
+}
+/**
+ * EmotionDetector @builtin Interface
+ */
+interface EmotionDetector {
+    /** Initialize the detector with config */
+    initialize(config: EmotionConfig): Promise<void>;
+    /**
+     * Infer emotional state from multimodal signals.
+     * This is typically called at a lower frequency than the main loop (e.g., 5Hz).
+     */
+    infer(signals: EmotionSignals): EmotionInference;
+    /** Dispose resources */
+    dispose(): void;
+}
+/**
+ * Global registry for builtin EmotionDetectors
+ */
+declare const emotionDetectorRegistry: Map<string, EmotionDetector>;
+/**
+ * Register an emotion detector implementation
+ */
+declare function registerEmotionDetector(name: string, detector: EmotionDetector): void;
+/**
+ * Get a registered emotion detector
+ */
+declare function getEmotionDetector(name: string): EmotionDetector | undefined;
+
+/**
+ * @holoscript/core Local Emotion Detector
+ *
+ * Implements multimodal emotion inference based on behavioral signals,
+ * head motion, and hand stability.
+ */
+
+declare class LocalEmotionDetector implements EmotionDetector {
+    private config?;
+    private headStabilityHistory;
+    private handStabilityHistory;
+    private readonly WINDOW_SIZE;
+    constructor();
+    initialize(config: EmotionConfig): Promise<void>;
+    infer(signals: EmotionSignals): EmotionInference;
+    dispose(): void;
+    private getAverage;
+}
+
+/**
+ * @holoscript/core Speech Recognizer Interface
+ *
+ * Defines the @builtin runtime interface for speech-to-text and phoneme recognition.
+ * Runtimes (WASM/Node.js) implement this to bridge with whisper.cpp or other providers.
+ */
+
+/**
+ * Speech recognition configuration
+ */
+interface SpeechRecognizerConfig {
+    /** Backend provider (e.g., 'whisper.cpp', 'web-speech') */
+    backend: string;
+    /** Model size/type (e.g., 'tiny', 'base', 'small') */
+    model?: string;
+    /** Enable phoneme-level timestamp output */
+    outputPhonemes?: boolean;
+    /** Recognition language (ISO code) */
+    language?: string;
+    /** Sampling rate (default 16000) */
+    sampleRate?: number;
+}
+/**
+ * Transcription result segment
+ */
+interface TranscriptionSegment {
+    text: string;
+    start: number;
+    end: number;
+    phonemes?: PhonemeTimestamp[];
+}
+/**
+ * SpeechRecognizer @builtin Interface
+ */
+interface SpeechRecognizer {
+    /** Initialize the recognizer with config */
+    initialize(config: SpeechRecognizerConfig): Promise<void>;
+    /**
+     * Transcribe an audio stream or buffer.
+     * Returns segments with optional phoneme-level timestamps.
+     */
+    transcribe(audio: ArrayBuffer | Blob | unknown, options?: {
+        phonemeMode?: boolean;
+        timestamps?: boolean;
+    }): Promise<TranscriptionSegment[]>;
+    /** Stop any active recognition */
+    stop(): void;
+    /** Dispose resources */
+    dispose(): void;
+}
+/**
+ * Global registry for builtin SpeechRecognizers
+ */
+declare const speechRecognizerRegistry: Map<string, SpeechRecognizer>;
+/**
+ * Register a speech recognizer implementation
+ */
+declare function registerSpeechRecognizer(name: string, recognizer: SpeechRecognizer): void;
+/**
+ * Get a registered speech recognizer
+ */
+declare function getSpeechRecognizer(name: string): SpeechRecognizer | undefined;
+
+/**
+ * @holoscript/core Mock Speech Recognizer
+ *
+ * Implements the SpeechRecognizer interface for testing and simulation.
+ * Returns dummy transcription segments with phoneme-level timestamps.
+ */
+
+declare class MockSpeechRecognizer implements SpeechRecognizer {
+    private config?;
+    constructor();
+    initialize(config: SpeechRecognizerConfig): Promise<void>;
+    transcribe(audio: ArrayBuffer | Blob | unknown, options?: {
+        phonemeMode?: boolean;
+        timestamps?: boolean;
+    }): Promise<TranscriptionSegment[]>;
+    stop(): void;
+    dispose(): void;
+    /**
+     * Generates dummy phonemes for a word
+     */
+    private generatePhonemes;
+}
+
+/**
+ * @holoscript/core Navigation Engine Interface
+ *
+ * Defines the @builtin runtime interface for GPU-accelerated pathfinding.
+ * Runtimes implement this to bridge with GPU-based flow field generators.
+ */
+
+/**
+ * Navigation engine configuration
+ */
+interface NavigationConfig {
+    /** Backend provider (e.g., 'gpu_flowfield', 'recast', 'custom') */
+    backend: string;
+    /** Dimensions of the navigation grid */
+    gridSize: [number, number, number];
+    /** Resolution of the grid (meters per cell) */
+    resolution: number;
+    /** Height of the navigation floor */
+    floorY?: number;
+}
+/**
+ * Destination for flow field generation
+ */
+interface NavDestination {
+    id: string;
+    position: Vector3;
+    radius?: number;
+}
+/**
+ * NavigationEngine @builtin Interface
+ */
+interface NavigationEngine {
+    /** Initialize the engine with config */
+    initialize(config: NavigationConfig): Promise<void>;
+    /**
+     * Generate or update a flow field for a destination.
+     * This triggers a GPU compute pass.
+     */
+    updateFlowField(destination: NavDestination): Promise<void>;
+    /**
+     * Sample the flow field at a given position.
+     * Return a direction vector pointing toward the destination.
+     */
+    sampleDirection(destinationId: string, position: Vector3): Vector3;
+    /** Update obstacles in the navigation grid */
+    updateObstacle(id: string, position: Vector3, size: Vector3, active: boolean): void;
+    /** Dispose resources */
+    dispose(): void;
+}
+/**
+ * Global registry for builtin NavigationEngines
+ */
+declare const navigationEngineRegistry: Map<string, NavigationEngine>;
+/**
+ * Register a navigation engine implementation
+ */
+declare function registerNavigationEngine(name: string, engine: NavigationEngine): void;
+/**
+ * Get a registered navigation engine
+ */
+declare function getNavigationEngine(name: string): NavigationEngine | undefined;
+
+/**
+ * @holoscript/core Physics Engine Interface
+ *
+ * Defines the @builtin runtime interface for GPU-accelerated mass physics.
+ * Runtimes implement this to bridge with WebGPU, PhysX, or Bullet backends.
+ */
+/**
+ * Physics engine configuration
+ */
+interface PhysicsConfig$1 {
+    /** Backend provider (e.g., 'webgpu', 'physx-gpu', 'bullet') */
+    backend: string;
+    /** Gravity vector */
+    gravity: [number, number, number];
+    /** Global simulation parameters */
+    parameters?: {
+        substeps?: number;
+        solverIterations?: number;
+        broadphase?: 'sap' | 'bvh' | 'grid';
+        gpuMemoryLimitMB?: number;
+    };
+}
+/**
+ * Rigid body properties
+ */
+interface BodyProps {
+    type: 'dynamic' | 'static' | 'kinematic';
+    mass: number;
+    position: [number, number, number];
+    rotation: [number, number, number, number];
+    velocity?: [number, number, number];
+    angularVelocity?: [number, number, number];
+    shape: 'box' | 'sphere' | 'capsule' | 'mesh';
+    shapeParams?: number[];
+    friction?: number;
+    restitution?: number;
+    linearDamping?: number;
+    angularDamping?: number;
+}
+/**
+ * Current state of a rigid body synced from GPU
+ */
+interface BodyState {
+    position: [number, number, number];
+    rotation: [number, number, number, number];
+    velocity: [number, number, number];
+    angularVelocity: [number, number, number];
+    isSleeping: boolean;
+}
+/**
+ * PhysicsEngine @builtin Interface
+ */
+interface PhysicsEngine {
+    /** Initialize the engine with config */
+    initialize(config: PhysicsConfig$1): Promise<void>;
+    /** Add a body to the simulation */
+    addBody(id: string, props: BodyProps): void;
+    /** Remove a body from the simulation */
+    removeBody(id: string): void;
+    /** Update body properties (e.g., teleport, change velocity) */
+    updateBody(id: string, props: Partial<BodyProps>): void;
+    /** Apply a force or impulse to a body */
+    applyForce(id: string, force: [number, number, number], point?: [number, number, number]): void;
+    /** Step the simulation */
+    step(dt: number): void;
+    /**
+     * Get the current state of all bodies.
+     * This is typically called once per frame to sync GPU state back to CPU objects.
+     */
+    getStates(): Record<string, BodyState>;
+    /** Dispose resources */
+    dispose(): void;
+}
+/**
+ * Global registry for builtin PhysicsEngines
+ */
+declare const physicsEngineRegistry: Map<string, PhysicsEngine>;
+/**
+ * Register a physics engine implementation
+ */
+declare function registerPhysicsEngine(name: string, engine: PhysicsEngine): void;
+/**
+ * Get a registered physics engine
+ */
+declare function getPhysicsEngine(name: string): PhysicsEngine | undefined;
+
+interface StateMachineInstance {
+    definition: StateMachineNode;
+    currentState: string;
+    context: Record<string, any>;
+}
+/** Hook executor function type */
+type HookExecutor = (code: string, context: Record<string, any>) => any;
+/**
+ * StateMachineInterpreter - Handles runtime execution of spatial state machines
+ */
+declare class StateMachineInterpreter {
+    private instances;
+    private hookExecutor;
+    /**
+     * Set the hook executor function (called by runtime during initialization)
+     */
+    setHookExecutor(executor: HookExecutor): void;
+    /**
+     * Initialize a new state machine instance
+     */
+    createInstance(id: string, definition: StateMachineNode, context: Record<string, any>): StateMachineInstance;
+    /**
+     * Process an event and trigger transitions
+     */
+    sendEvent(id: string, event: string): boolean;
+    /**
+     * Force transition to a specific state
+     */
+    transitionTo(id: string, targetStateName: string): void;
+    /**
+     * Execute code block using the registered hook executor
+     */
+    private executeHook;
+    getInstance(id: string): StateMachineInstance | undefined;
+    removeInstance(id: string): void;
+}
+declare const stateMachineInterpreter: StateMachineInterpreter;
+
+/**
+ * @fileoverview HoloLand Culture Runtime — Live Norm + Memory Engine
+ * @module @holoscript/core/runtime
+ *
+ * Wires the CulturalMemory and NormEngine into HoloLand's tick loop.
+ * Manages the full lifecycle of emergent culture within a running world:
+ *
+ * - Agent registration and norm adoption on join
+ * - Per-tick memory decay and trace evaporation
+ * - Effect-based norm compliance evaluation (real-time)
+ * - SOP consolidation on tick intervals
+ * - Cultural health monitoring for world operators
+ * - Event bus for culture-related notifications
+ *
+ * @version 1.0.0
+ */
+
+/** A culture event emitted by the runtime */
+interface CultureEvent {
+    type: 'violation' | 'norm_adopted' | 'norm_proposed' | 'sop_formed' | 'cultural_shift' | 'trace_reinforced';
+    agentId: string;
+    normId?: string;
+    details: string;
+    timestamp: number;
+    severity: 'info' | 'warning' | 'critical';
+}
+/** Culture runtime configuration */
+interface CultureRuntimeConfig {
+    /** Ticks between SOP consolidation runs */
+    consolidationInterval: number;
+    /** Ticks between adoption curve snapshots */
+    snapshotInterval: number;
+    /** Default norms all agents must adopt */
+    defaultNorms: string[];
+    /** Cultural health warning threshold (0-1) */
+    healthWarningThreshold: number;
+    /** Max events to retain */
+    maxEventHistory: number;
+    /** Enable auto-enforcement (block hard violations) */
+    autoEnforce: boolean;
+}
+/**
+ * CultureRuntime — manages emergent culture within a HoloLand world.
+ */
+declare class CultureRuntime {
+    private config;
+    private memory;
+    private norms;
+    private events;
+    private tickCount;
+    private agents;
+    private lastHealthScore;
+    constructor(config?: Partial<CultureRuntimeConfig>);
+    /**
+     * Agent joins the world.
+     */
+    agentJoin(agentId: string, adoptNorms?: string[]): void;
+    /**
+     * Agent leaves the world (consolidate their knowledge first).
+     */
+    agentLeave(agentId: string): SemanticSOP[];
+    /**
+     * Main tick: advance the culture simulation.
+     * Call this once per world tick.
+     */
+    tick(): {
+        decayed: ReturnType<CulturalMemory['tick']>;
+        events: CultureEvent[];
+    };
+    /**
+     * Evaluate an agent's intended effects against active norms.
+     * Called before allowing the agent to execute an action.
+     *
+     * @returns Whether the action is allowed (true) or blocked (false)
+     */
+    evaluateAction(agentId: string, effects: VREffect[], zoneId?: string): {
+        allowed: boolean;
+        violations: NormViolation[];
+        blocked: VREffect[];
+    };
+    /**
+     * Record an experience for an agent.
+     */
+    recordExperience(agentId: string, event: string, opts?: {
+        normId?: string;
+        valence?: number;
+        importance?: number;
+        participants?: string[];
+        tags?: string[];
+    }): EpisodicMemory;
+    /**
+     * Leave a trace in the world.
+     */
+    leaveTrace(agentId: string, zoneId: string, label: string, position: [number, number, number]): StigmergicTrace;
+    /**
+     * Perceive nearby traces.
+     */
+    perceiveTraces(zoneId: string, position: [number, number, number]): StigmergicTrace[];
+    /**
+     * Propose a new norm.
+     */
+    proposeNorm(agentId: string, norm: CulturalNorm): NormProposal;
+    /**
+     * Get cultural dashboard data.
+     */
+    dashboard(): {
+        health: number;
+        agents: number;
+        normStats: ReturnType<NormEngine['stats']>;
+        memoryStats: ReturnType<CulturalMemory['stats']>;
+        recentEvents: CultureEvent[];
+        tickCount: number;
+    };
+    /**
+     * Get event history.
+     */
+    getEvents(filter?: {
+        type?: CultureEvent['type'];
+        agentId?: string;
+    }): CultureEvent[];
+    /**
+     * Export full culture state (for world save).
+     */
+    exportState(): {
+        memory: ReturnType<CulturalMemory['exportState']>;
+        tickCount: number;
+    };
+    private emit;
+}
+
+/**
+ * MQTT Client for HoloScript IoT Integration
+ *
+ * Provides MQTT 3.1.1 and 5.0 protocol support for IoT device communication.
+ * Supports pub/sub patterns, QoS levels, and wildcard subscriptions.
+ *
+ * @version 1.0.0
+ */
+type QoS = 0 | 1 | 2;
+type MQTTVersion = '3.1.1' | '5.0';
+interface MQTTClientConfig {
+    /** Broker URL (e.g., mqtt://localhost:1883, wss://broker.example.com) */
+    broker: string;
+    /** Client ID (auto-generated if not provided) */
+    clientId?: string;
+    /** MQTT protocol version */
+    version?: MQTTVersion;
+    /** Username for authentication */
+    username?: string;
+    /** Password for authentication */
+    password?: string;
+    /** Keep-alive interval in seconds */
+    keepAlive?: number;
+    /** Clean session flag */
+    cleanSession?: boolean;
+    /** Reconnect options */
+    reconnect?: {
+        enabled: boolean;
+        maxAttempts?: number;
+        baseDelay?: number;
+        maxDelay?: number;
+    };
+    /** TLS/SSL options */
+    tls?: {
+        enabled: boolean;
+        rejectUnauthorized?: boolean;
+        ca?: string;
+        cert?: string;
+        key?: string;
+    };
+    /** Will message */
+    will?: {
+        topic: string;
+        payload: string | Buffer;
+        qos?: QoS;
+        retain?: boolean;
+    };
+}
+interface MQTTMessage {
+    topic: string;
+    payload: Buffer | string;
+    qos: QoS;
+    retain: boolean;
+    /** MQTT 5.0 properties */
+    properties?: {
+        payloadFormatIndicator?: number;
+        messageExpiryInterval?: number;
+        contentType?: string;
+        responseTopic?: string;
+        correlationData?: Buffer;
+        userProperties?: Record<string, string>;
+    };
+}
+interface MQTTSubscription {
+    topic: string;
+    qos: QoS;
+    /** No Local flag (MQTT 5.0) */
+    noLocal?: boolean;
+    /** Retain as Published flag (MQTT 5.0) */
+    retainAsPublished?: boolean;
+    /** Retain handling option (MQTT 5.0) */
+    retainHandling?: 0 | 1 | 2;
+}
+interface MQTTPublishOptions {
+    qos?: QoS;
+    retain?: boolean;
+    /** MQTT 5.0 properties */
+    properties?: MQTTMessage['properties'];
+}
+type MQTTClientState = 'disconnected' | 'connecting' | 'connected' | 'reconnecting' | 'closed';
+interface MQTTClientEvents {
+    connect: () => void;
+    disconnect: (reason?: string) => void;
+    reconnect: (attempt: number) => void;
+    message: (topic: string, message: MQTTMessage) => void;
+    error: (error: Error) => void;
+    offline: () => void;
+}
+declare class MQTTClient {
+    private config;
+    private state;
+    private subscriptions;
+    private messageQueue;
+    private reconnectAttempts;
+    private reconnectTimeout;
+    private eventHandlers;
+    private simulatedMode;
+    constructor(config: MQTTClientConfig);
+    /**
+     * Connect to the MQTT broker
+     */
+    connect(): Promise<void>;
+    /**
+     * Disconnect from the MQTT broker
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Get current connection state
+     */
+    getState(): MQTTClientState;
+    /**
+     * Check if connected
+     */
+    isConnected(): boolean;
+    /**
+     * Publish a message to a topic
+     */
+    publish(topic: string, payload: string | Buffer | object, options?: MQTTPublishOptions): Promise<void>;
+    /**
+     * Subscribe to a topic pattern
+     */
+    subscribe(topicOrSubscription: string | MQTTSubscription, handler: (message: MQTTMessage) => void): Promise<void>;
+    /**
+     * Unsubscribe from a topic
+     */
+    unsubscribe(topic: string, handler?: (message: MQTTMessage) => void): Promise<void>;
+    /**
+     * Get active subscriptions
+     */
+    getSubscriptions(): string[];
+    /**
+     * Register an event handler
+     */
+    on<K extends keyof MQTTClientEvents>(event: K, handler: MQTTClientEvents[K]): void;
+    /**
+     * Remove an event handler
+     */
+    off<K extends keyof MQTTClientEvents>(event: K, handler: MQTTClientEvents[K]): void;
+    /**
+     * Emit an event
+     */
+    private emit;
+    /**
+     * Check if a topic matches a subscription pattern
+     * Supports + (single-level) and # (multi-level) wildcards
+     */
+    static matchTopic(pattern: string, topic: string): boolean;
+    /**
+     * Parse message payload based on content type
+     */
+    static parsePayload(message: MQTTMessage): unknown;
+    private generateClientId;
+    private simulateConnect;
+    private simulatePublish;
+    private simulateSubscribe;
+    private simulateUnsubscribe;
+    private deliverMessage;
+    private scheduleReconnect;
+    private flushMessageQueue;
+    /**
+     * Inject a message for testing purposes
+     */
+    _injectMessage(topic: string, payload: string | Buffer | object): void;
+}
+/**
+ * Create an MQTT client
+ */
+declare function createMQTTClient(config: MQTTClientConfig): MQTTClient;
+/**
+ * Register a named MQTT client
+ */
+declare function registerMQTTClient(name: string, client: MQTTClient): void;
+/**
+ * Get a registered MQTT client
+ */
+declare function getMQTTClient(name: string): MQTTClient | undefined;
+/**
+ * Unregister an MQTT client
+ */
+declare function unregisterMQTTClient(name: string): void;
+
+/**
+ * TraitContextFactory
+ *
+ * Creates TraitContext objects backed by platform-provided APIs.
+ * This is the dependency-injection layer that connects HoloScript's 121 trait
+ * handlers to real platform services (audio, physics, haptics, accessibility, etc.)
+ *
+ * Without this factory, trait handlers receive no-op context and do nothing.
+ * With it, every trait handler in @holoscript/core actually executes against
+ * real platform services.
+ *
+ * Consuming platforms (e.g., Hololand, custom engines) implement the Provider
+ * interfaces and pass them to createTraitContextFactory().
+ *
+ * @module TraitContextFactory
+ */
+
+/** Implemented by platform physics engine */
+interface PhysicsProvider {
+    applyVelocity(nodeId: string, velocity: Vector3): void;
+    applyAngularVelocity(nodeId: string, angularVelocity: Vector3): void;
+    setKinematic(nodeId: string, kinematic: boolean): void;
+    raycast(origin: Vector3, direction: Vector3, maxDistance: number): RaycastHit | null;
+    getBodyPosition?(nodeId: string): Vector3 | null;
+    getBodyVelocity?(nodeId: string): Vector3 | null;
+}
+/** Implemented by platform spatial audio engine */
+interface AudioProvider {
+    playSound(source: string, options?: {
+        position?: Vector3;
+        volume?: number;
+        spatial?: boolean;
+    }): void;
+    updateSpatialSource?(nodeId: string, options: {
+        hrtfProfile?: string;
+        occlusion?: number;
+        reverbWet?: number;
+    }): void;
+    registerAmbisonicSource?(nodeId: string, order: number): void;
+    setAudioPortal?(portalId: string, targetZone: string, openingSize: number): void;
+    updateAudioMaterial?(nodeId: string, absorption: number, reflection: number): void;
+}
+/** Implemented by platform haptic engine */
+interface HapticsProvider {
+    pulse(hand: 'left' | 'right', intensity: number, duration?: number): void;
+    rumble(hand: 'left' | 'right', intensity: number): void;
+}
+/** Implemented by platform accessibility manager */
+interface AccessibilityProvider {
+    announce(text: string): void;
+    setScreenReaderFocus(nodeId: string): void;
+    setAltText(nodeId: string, text: string): void;
+    setHighContrast(enabled: boolean): void;
+}
+/** Implemented by WebXR session or platform gesture system */
+interface VRProvider {
+    getLeftHand(): VRHand | null;
+    getRightHand(): VRHand | null;
+    getHeadsetPosition(): Vector3;
+    getHeadsetRotation(): Vector3;
+    getPointerRay(hand: 'left' | 'right'): {
+        origin: Vector3;
+        direction: Vector3;
+    } | null;
+    getDominantHand(): VRHand | null;
+}
+/** Implemented by platform network layer for networked traits */
+interface NetworkProvider {
+    broadcastState(nodeId: string, state: Record<string, unknown>): void;
+    requestAuthority(nodeId: string): boolean;
+    onRemoteUpdate(nodeId: string, callback: (state: Record<string, unknown>) => void): void;
+}
+/** Implemented by platform renderer for volumetric/GPU traits */
+interface RendererProvider {
+    createGaussianSplat(nodeId: string, config: Record<string, unknown>): void;
+    createPointCloud(nodeId: string, config: Record<string, unknown>): void;
+    dispatchCompute(nodeId: string, shader: string, workgroups: number[]): void;
+    destroyRenderable(nodeId: string): void;
+}
+interface TraitContextFactoryConfig {
+    physics?: PhysicsProvider;
+    audio?: AudioProvider;
+    haptics?: HapticsProvider;
+    accessibility?: AccessibilityProvider;
+    vr?: VRProvider;
+    network?: NetworkProvider;
+    renderer?: RendererProvider;
+}
+declare class TraitContextFactory {
+    private physicsProvider;
+    private audioProvider;
+    private hapticsProvider;
+    private accessibilityProvider;
+    private vrProvider;
+    private networkProvider;
+    private rendererProvider;
+    private scaleMagnitude;
+    private globalState;
+    private eventListeners;
+    constructor(config?: TraitContextFactoryConfig);
+    setPhysicsProvider(provider: PhysicsProvider): void;
+    setAudioProvider(provider: AudioProvider): void;
+    setHapticsProvider(provider: HapticsProvider): void;
+    setAccessibilityProvider(provider: AccessibilityProvider): void;
+    setVRProvider(provider: VRProvider): void;
+    setNetworkProvider(provider: NetworkProvider): void;
+    setRendererProvider(provider: RendererProvider): void;
+    on(event: string, handler: (payload: unknown) => void): void;
+    off(event: string, handler: (payload: unknown) => void): void;
+    private emit;
+    /**
+     * Build a TraitContext backed by real providers.
+     * Pass this to VRTraitRegistry.attachTrait / updateTrait / handleEvent.
+     */
+    createContext(): TraitContext;
+    getNetworkProvider(): NetworkProvider | undefined;
+    getRendererProvider(): RendererProvider | undefined;
+    dispose(): void;
+}
+declare function createTraitContextFactory(config?: TraitContextFactoryConfig): TraitContextFactory;
+
+/**
+ * Runtime Profile Configuration
+ *
+ * Defines different runtime profiles for various deployment scenarios:
+ * - headless: Server-side execution without rendering (IoT, edge, testing)
+ * - minimal: Lightweight runtime with basic rendering
+ * - standard: Full runtime with all features
+ * - vr: Extended runtime with VR/XR support
+ *
+ * @version 1.0.0
+ */
+type RuntimeProfileName = 'headless' | 'minimal' | 'standard' | 'vr';
+interface RenderingConfig {
+    /** Enable visual rendering */
+    enabled: boolean;
+    /** Max FPS (0 = unlimited) */
+    maxFps?: number;
+    /** Enable shadows */
+    shadows?: boolean;
+    /** Enable post-processing */
+    postProcessing?: boolean;
+    /** Renderer type */
+    renderer?: 'webgl' | 'webgpu' | 'canvas2d' | 'none';
+}
+interface PhysicsConfig {
+    /** Enable physics simulation */
+    enabled: boolean;
+    /** Physics engine to use */
+    engine?: 'simple' | 'rapier' | 'cannon' | 'none';
+    /** Physics tick rate in Hz */
+    tickRate?: number;
+    /** Gravity vector [x, y, z] */
+    gravity?: [number, number, number];
+}
+interface AudioConfig {
+    /** Enable audio system */
+    enabled: boolean;
+    /** Enable spatial audio */
+    spatial?: boolean;
+    /** Max simultaneous sounds */
+    maxSounds?: number;
+}
+interface NetworkConfig {
+    /** Enable networking */
+    enabled: boolean;
+    /** Enable state sync */
+    stateSync?: boolean;
+    /** Sync interval in ms */
+    syncInterval?: number;
+    /** Enable WebRTC for P2P */
+    webrtc?: boolean;
+}
+interface InputConfig {
+    /** Enable input handling */
+    enabled: boolean;
+    /** Enable keyboard input */
+    keyboard?: boolean;
+    /** Enable mouse input */
+    mouse?: boolean;
+    /** Enable touch input */
+    touch?: boolean;
+    /** Enable gamepad input */
+    gamepad?: boolean;
+    /** Enable VR controller input */
+    vrControllers?: boolean;
+}
+interface ProtocolConfig {
+    /** Enable MQTT protocol */
+    mqtt?: boolean;
+    /** Enable WebSocket protocol */
+    websocket?: boolean;
+    /** Enable HTTP REST protocol */
+    http?: boolean;
+    /** Enable CoAP protocol (IoT) */
+    coap?: boolean;
+}
+interface RuntimeProfile {
+    /** Profile name */
+    name: RuntimeProfileName;
+    /** Profile description */
+    description: string;
+    /** Rendering configuration */
+    rendering: RenderingConfig;
+    /** Physics configuration */
+    physics: PhysicsConfig;
+    /** Audio configuration */
+    audio: AudioConfig;
+    /** Network configuration */
+    network: NetworkConfig;
+    /** Input configuration */
+    input: InputConfig;
+    /** Protocol bindings configuration */
+    protocols: ProtocolConfig;
+    /** Enable lifecycle hooks */
+    lifecycleHooks: boolean;
+    /** Enable state management */
+    stateManagement: boolean;
+    /** Enable event system */
+    events: boolean;
+    /** Enable trait system */
+    traits: boolean;
+    /** Target memory budget in MB (0 = unlimited) */
+    memoryBudget: number;
+    /** Startup timeout in ms */
+    startupTimeout: number;
+}
+/**
+ * Headless profile for server-side execution
+ * - No rendering, audio, or input
+ * - State management, events, traits enabled
+ * - IoT protocols enabled
+ * - Memory budget: 50MB
+ * - Startup time: <500ms
+ */
+declare const HEADLESS_PROFILE: RuntimeProfile;
+/**
+ * Minimal profile for lightweight browser execution
+ * - Basic 2D rendering
+ * - Simple physics
+ * - Limited audio
+ */
+declare const MINIMAL_PROFILE: RuntimeProfile;
+/**
+ * Standard profile for full browser execution
+ * - Full WebGL rendering
+ * - Full physics
+ * - Spatial audio
+ */
+declare const STANDARD_PROFILE: RuntimeProfile;
+/**
+ * VR profile for immersive XR applications
+ * - High-performance WebGL/WebGPU rendering
+ * - Full physics with haptics
+ * - Spatial audio
+ * - VR input support
+ */
+declare const VR_PROFILE: RuntimeProfile;
+/**
+ * Get a profile by name
+ */
+declare function getProfile(name: RuntimeProfileName): RuntimeProfile;
+/**
+ * Register a custom profile
+ */
+declare function registerProfile(name: string, profile: RuntimeProfile): void;
+/**
+ * Get all available profile names
+ */
+declare function getAvailableProfiles(): RuntimeProfileName[];
+/**
+ * Create a custom profile by merging with a base profile
+ */
+declare function createCustomProfile(base: RuntimeProfileName, overrides: Partial<RuntimeProfile>): RuntimeProfile;
+
+/**
+ * Headless Runtime
+ *
+ * Lightweight runtime for server-side execution, IoT devices, edge computing,
+ * and testing scenarios. No rendering, audio, or input - just state, events,
+ * and trait execution.
+ *
+ * Features:
+ * - State management with reactive updates
+ * - Event system for pub/sub
+ * - Trait system for behavior composition
+ * - Lifecycle hooks (on_mount, on_update, on_unmount)
+ * - MQTT/WebSocket protocol support
+ * - Memory-efficient (<50MB footprint)
+ * - Fast startup (<500ms)
+ *
+ * @version 1.0.0
+ */
+
+type LifecycleHandler = (...args: unknown[]) => void;
+interface HeadlessNodeInstance {
+    node: HSPlusNode;
+    lifecycleHandlers: Map<string, LifecycleHandler[]>;
+    children: HeadlessNodeInstance[];
+    parent: HeadlessNodeInstance | null;
+    destroyed: boolean;
+    data?: Record<string, unknown>;
+}
+/**
+ * Handler function for BT action dispatch via `runtime.registerAction()`.
+ * Called when the BehaviorTree's native action bridge emits `action:${name}`.
+ * Return true (success) or false (failure). Async handlers return a Promise.
+ */
+type ActionHandler = (params: Record<string, unknown>, blackboard: Record<string, unknown>, context: {
+    emit: (event: string, payload?: unknown) => void;
+    hostCapabilities?: HostCapabilities;
+}) => Promise<boolean> | boolean;
+interface HeadlessRuntimeOptions {
+    /** Runtime profile (defaults to HEADLESS_PROFILE) */
+    profile?: RuntimeProfile;
+    /** External state providers */
+    stateProviders?: Map<string, () => unknown>;
+    /** Update tick rate in Hz (default: 10) */
+    tickRate?: number;
+    /** Enable debug logging */
+    debug?: boolean;
+    /** Max instances limit (default: 1000) */
+    maxInstances?: number;
+    /** Custom builtins to inject */
+    builtins?: Record<string, unknown>;
+    /** Action dispatcher for BehaviorTreeTrait — maps BT action names to external handlers.
+     *  Return true (success), false (failure), or 'running' (async in progress).
+     *  The blackboard parameter is the BT's shared state for updating conditions. */
+    executeAction?: (owner: unknown, actionName: string, params: Record<string, unknown>, blackboard?: Record<string, unknown>) => boolean | 'running';
+    /** Optional capability adapter for host operations used by traits such as shell/file_system. */
+    hostCapabilities?: HostCapabilities;
+}
+interface HeadlessRuntimeStats {
+    /** Number of active node instances */
+    instanceCount: number;
+    /** Memory usage estimate in bytes */
+    memoryEstimate: number;
+    /** Total updates processed */
+    updateCount: number;
+    /** Total events emitted */
+    eventCount: number;
+    /** Uptime in milliseconds */
+    uptime: number;
+    /** Average tick duration in ms */
+    avgTickDuration: number;
+}
+declare class HeadlessRuntime {
+    private ast;
+    private profile;
+    private options;
+    state: ReactiveState<any>;
+    private evaluator;
+    private rootInstance;
+    private eventHandlers;
+    private updateInterval;
+    private startTime;
+    private lastTickTime;
+    private tickDurations;
+    private stats;
+    private running;
+    private builtins;
+    private actionRegistry;
+    private _routingEvent;
+    constructor(ast: HSPlusAST, options?: HeadlessRuntimeOptions);
+    private initializeState;
+    private createBuiltins;
+    /**
+     * Start the headless runtime
+     */
+    start(): void;
+    /**
+     * Stop the headless runtime
+     */
+    stop(): void;
+    /**
+     * Check if runtime is running
+     */
+    isRunning(): boolean;
+    private tick;
+    private updateStateProviders;
+    private updateInstance;
+    private instantiateNode;
+    private processDirectives;
+    private registerLifecycleHandler;
+    private callLifecycle;
+    private createTraitContext;
+    /**
+     * Route an event to trait onEvent() handlers on all node instances.
+     * This enables @shell, @file_system, @llm_agent and other traits to
+     * receive events in headless mode (previously only onUpdate/onAttach fired).
+     */
+    private routeEventToTraits;
+    private destroyInstance;
+    /**
+     * Get current state snapshot
+     */
+    getState(): Record<string, unknown>;
+    /**
+     * Update state
+     */
+    setState(updates: Partial<Record<string, unknown>>): void;
+    /**
+     * Get a state value
+     */
+    get<K extends string>(key: K): unknown;
+    /**
+     * Set a state value
+     */
+    set<K extends string>(key: K, value: unknown): void;
+    /**
+     * Emit an event
+     */
+    emit(event: string, payload?: unknown): void;
+    /**
+     * Register a named action handler for BehaviorTree's native action bridge.
+     * When a BT action node emits `action:${name}`, this handler is called
+     * and the result is sent back via `action:result`.
+     */
+    registerAction(name: string, handler: ActionHandler): void;
+    /**
+     * Subscribe to an event
+     */
+    on(event: string, handler: (payload: unknown) => void): () => void;
+    /**
+     * Subscribe to an event (fires once)
+     */
+    once(event: string, handler: (payload: unknown) => void): () => void;
+    /**
+     * Get runtime statistics
+     */
+    getStats(): HeadlessRuntimeStats;
+    /**
+     * Get runtime profile
+     */
+    getProfile(): RuntimeProfile;
+    /**
+     * Find a node by ID
+     */
+    findNode(id: string): HSPlusNode | null;
+    /**
+     * Execute a manual update tick
+     */
+    manualTick(delta?: number): void;
+    private estimateMemory;
+    private log;
+}
+/**
+ * Create a new headless runtime instance
+ */
+declare function createHeadlessRuntime(ast: HSPlusAST, options?: HeadlessRuntimeOptions): HeadlessRuntime;
+
+/**
+ * HoloScript Runtime System
+ *
+ * Central runtime registry and execution system for HoloScript compositions.
+ */
+
+type index_AccessibilityProvider = AccessibilityProvider;
+type index_ActionHandler = ActionHandler;
+type index_AssetLoader<T = unknown> = AssetLoader<T>;
+type index_AssetPipeline = AssetPipeline;
+declare const index_AssetPipeline: typeof AssetPipeline;
+type index_AudioConfig = AudioConfig;
+type index_AudioProvider = AudioProvider;
+type index_BaseRuntimeRenderer = BaseRuntimeRenderer;
+declare const index_BaseRuntimeRenderer: typeof BaseRuntimeRenderer;
+type index_BaseVoiceSynthesizer = BaseVoiceSynthesizer;
+declare const index_BaseVoiceSynthesizer: typeof BaseVoiceSynthesizer;
+declare const index_BatchedMeshShader: typeof BatchedMeshShader;
+type index_Batcher<T, R> = Batcher<T, R>;
+declare const index_Batcher: typeof Batcher;
+type index_BodyProps = BodyProps;
+type index_BodyState = BodyState;
+type index_CultureEvent = CultureEvent;
+type index_CultureRuntime = CultureRuntime;
+declare const index_CultureRuntime: typeof CultureRuntime;
+type index_CultureRuntimeConfig = CultureRuntimeConfig;
+type index_EmotionConfig = EmotionConfig;
+type index_EmotionDetector = EmotionDetector;
+type index_EmotionInference = EmotionInference;
+type index_EmotionSignals = EmotionSignals;
+type index_EnginePhase = EnginePhase;
+type index_EngineStats = EngineStats;
+type index_GameEngine = GameEngine;
+declare const index_GameEngine: typeof GameEngine;
+type index_GameEngineOptions = GameEngineOptions;
+type index_GameLoop = GameLoop;
+declare const index_GameLoop: typeof GameLoop;
+type index_GameLoopOptions = GameLoopOptions;
+declare const index_HEADLESS_PROFILE: typeof HEADLESS_PROFILE;
+type index_HapticsProvider = HapticsProvider;
+type index_HeadlessNodeInstance = HeadlessNodeInstance;
+type index_HeadlessRuntime = HeadlessRuntime;
+declare const index_HeadlessRuntime: typeof HeadlessRuntime;
+type index_HeadlessRuntimeOptions = HeadlessRuntimeOptions;
+type index_HeadlessRuntimeStats = HeadlessRuntimeStats;
+type index_HookExecutor = HookExecutor;
+type index_HotReloadManager = HotReloadManager;
+declare const index_HotReloadManager: typeof HotReloadManager;
+type index_HotReloadManagerOptions = HotReloadManagerOptions;
+type index_InputConfig = InputConfig;
+type index_InspectorConfig = InspectorConfig;
+type index_InstanceBatchConfig = InstanceBatchConfig;
+type index_InstanceBatchStats = InstanceBatchStats;
+type index_InstancedMeshManager = InstancedMeshManager;
+declare const index_InstancedMeshManager: typeof InstancedMeshManager;
+type index_InstancedObjectData = InstancedObjectData;
+type index_LRUCache<K, V> = LRUCache<K, V>;
+declare const index_LRUCache: typeof LRUCache;
+type index_Lazy<T> = Lazy<T>;
+declare const index_Lazy: typeof Lazy;
+type index_LocalEmotionDetector = LocalEmotionDetector;
+declare const index_LocalEmotionDetector: typeof LocalEmotionDetector;
+declare const index_MINIMAL_PROFILE: typeof MINIMAL_PROFILE;
+type index_MQTTClient = MQTTClient;
+declare const index_MQTTClient: typeof MQTTClient;
+type index_MQTTClientConfig = MQTTClientConfig;
+type index_MQTTClientEvents = MQTTClientEvents;
+type index_MQTTClientState = MQTTClientState;
+type index_MQTTMessage = MQTTMessage;
+type index_MQTTPublishOptions = MQTTPublishOptions;
+type index_MQTTSubscription = MQTTSubscription;
+type index_MQTTVersion = MQTTVersion;
+declare const index_MemoizedProperty: typeof MemoizedProperty;
+declare const index_MethodMemoize: typeof MethodMemoize;
+type index_MockSpeechRecognizer = MockSpeechRecognizer;
+declare const index_MockSpeechRecognizer: typeof MockSpeechRecognizer;
+type index_NavDestination = NavDestination;
+type index_NavigationConfig = NavigationConfig;
+type index_NavigationEngine = NavigationEngine;
+type index_NetworkConfig = NetworkConfig;
+type index_NetworkProvider = NetworkProvider;
+type index_ObjectInfo = ObjectInfo;
+type index_ObjectPool<T> = ObjectPool<T>;
+declare const index_ObjectPool: typeof ObjectPool;
+declare const index_OptimizedDebrisShader: typeof OptimizedDebrisShader;
+declare const index_OptimizedFluidShader: typeof OptimizedFluidShader;
+declare const index_OptimizedParticleShader: typeof OptimizedParticleShader;
+type index_ParticleSystem = ParticleSystem;
+type index_PerformanceProfiler = PerformanceProfiler;
+declare const index_PerformanceProfiler: typeof PerformanceProfiler;
+type index_PhysicsEngine = PhysicsEngine;
+type index_PhysicsProvider = PhysicsProvider;
+type index_PostProcessingConfig = PostProcessingConfig;
+type index_PostProcessingEffect = PostProcessingEffect;
+type index_PostProcessingManager = PostProcessingManager;
+declare const index_PostProcessingManager: typeof PostProcessingManager;
+type index_PostProcessingQuality = PostProcessingQuality;
+type index_PostProcessingStats = PostProcessingStats;
+type index_ProtocolConfig = ProtocolConfig;
+type index_QoS = QoS;
+type index_ReloadWatcher<TContent = unknown, TState = unknown> = ReloadWatcher<TContent, TState>;
+type index_RenderableCamera = RenderableCamera;
+type index_RenderableLight = RenderableLight;
+type index_RenderableObject = RenderableObject;
+type index_RendererConfig = RendererConfig;
+type index_RendererProvider = RendererProvider;
+type index_RendererStatistics = RendererStatistics;
+type index_RenderingConfig = RenderingConfig;
+type index_RuntimeCapabilities = RuntimeCapabilities;
+type index_RuntimeExecutor = RuntimeExecutor;
+type index_RuntimeMetadata = RuntimeMetadata;
+type index_RuntimeModule = RuntimeModule;
+type index_RuntimeProfile = RuntimeProfile;
+type index_RuntimeProfileName = RuntimeProfileName;
+declare const index_RuntimeRegistry: typeof RuntimeRegistry;
+type index_RuntimeRenderer = RuntimeRenderer;
+declare const index_STANDARD_PROFILE: typeof STANDARD_PROFILE;
+type index_SceneInspector = SceneInspector;
+declare const index_SceneInspector: typeof SceneInspector;
+type index_SceneStats = SceneStats;
+type index_ShaderOptimizationConfig = ShaderOptimizationConfig;
+type index_ShaderOptimizationManager = ShaderOptimizationManager;
+declare const index_ShaderOptimizationManager: typeof ShaderOptimizationManager;
+type index_ShaderPerformanceStats = ShaderPerformanceStats;
+type index_SpeechRecognizer = SpeechRecognizer;
+type index_SpeechRecognizerConfig = SpeechRecognizerConfig;
+type index_StateMachineInstance = StateMachineInstance;
+type index_StateMachineInterpreter = StateMachineInterpreter;
+declare const index_StateMachineInterpreter: typeof StateMachineInterpreter;
+declare const index_TerrainDeformationShader: typeof TerrainDeformationShader;
+type index_ThreeJSRenderer = ThreeJSRenderer;
+declare const index_ThreeJSRenderer: typeof ThreeJSRenderer;
+type index_TraitContextFactory = TraitContextFactory;
+declare const index_TraitContextFactory: typeof TraitContextFactory;
+type index_TraitContextFactoryConfig = TraitContextFactoryConfig;
+type index_TranscriptionSegment = TranscriptionSegment;
+type index_UpdateHandler = UpdateHandler;
+type index_VRProvider = VRProvider;
+declare const index_VR_PROFILE: typeof VR_PROFILE;
+type index_VoiceConfig = VoiceConfig;
+type index_VoiceInfo = VoiceInfo;
+type index_VoiceRequest = VoiceRequest;
+type index_VoiceSynthesizer = VoiceSynthesizer;
+declare const index_createCustomProfile: typeof createCustomProfile;
+declare const index_createHeadlessRuntime: typeof createHeadlessRuntime;
+declare const index_createMQTTClient: typeof createMQTTClient;
+declare const index_createTraitContextFactory: typeof createTraitContextFactory;
+declare const index_emotionDetectorRegistry: typeof emotionDetectorRegistry;
+declare const index_getAvailableProfiles: typeof getAvailableProfiles;
+declare const index_getEmotionDetector: typeof getEmotionDetector;
+declare const index_getGlobalProfiler: typeof getGlobalProfiler;
+declare const index_getMQTTClient: typeof getMQTTClient;
+declare const index_getNavigationEngine: typeof getNavigationEngine;
+declare const index_getPhysicsEngine: typeof getPhysicsEngine;
+declare const index_getProfile: typeof getProfile;
+declare const index_getSpeechRecognizer: typeof getSpeechRecognizer;
+declare const index_getVoiceSynthesizer: typeof getVoiceSynthesizer;
+declare const index_memoize: typeof memoize;
+declare const index_navigationEngineRegistry: typeof navigationEngineRegistry;
+declare const index_physicsEngineRegistry: typeof physicsEngineRegistry;
+declare const index_registerEmotionDetector: typeof registerEmotionDetector;
+declare const index_registerMQTTClient: typeof registerMQTTClient;
+declare const index_registerNavigationEngine: typeof registerNavigationEngine;
+declare const index_registerPhysicsEngine: typeof registerPhysicsEngine;
+declare const index_registerProfile: typeof registerProfile;
+declare const index_registerRuntime: typeof registerRuntime;
+declare const index_registerSpeechRecognizer: typeof registerSpeechRecognizer;
+declare const index_registerVoiceSynthesizer: typeof registerVoiceSynthesizer;
+declare const index_speechRecognizerRegistry: typeof speechRecognizerRegistry;
+declare const index_stateMachineInterpreter: typeof stateMachineInterpreter;
+declare const index_unregisterMQTTClient: typeof unregisterMQTTClient;
+declare const index_voiceSynthesizerRegistry: typeof voiceSynthesizerRegistry;
+declare namespace index {
+  export { type index_AccessibilityProvider as AccessibilityProvider, type index_ActionHandler as ActionHandler, type index_AssetLoader as AssetLoader, index_AssetPipeline as AssetPipeline, type index_AudioConfig as AudioConfig, type index_AudioProvider as AudioProvider, index_BaseRuntimeRenderer as BaseRuntimeRenderer, index_BaseVoiceSynthesizer as BaseVoiceSynthesizer, index_BatchedMeshShader as BatchedMeshShader, index_Batcher as Batcher, type index_BodyProps as BodyProps, type index_BodyState as BodyState, type index_CultureEvent as CultureEvent, index_CultureRuntime as CultureRuntime, type index_CultureRuntimeConfig as CultureRuntimeConfig, type index_EmotionConfig as EmotionConfig, type index_EmotionDetector as EmotionDetector, type index_EmotionInference as EmotionInference, type index_EmotionSignals as EmotionSignals, type index_EnginePhase as EnginePhase, type index_EngineStats as EngineStats, index_GameEngine as GameEngine, type index_GameEngineOptions as GameEngineOptions, index_GameLoop as GameLoop, type index_GameLoopOptions as GameLoopOptions, index_HEADLESS_PROFILE as HEADLESS_PROFILE, type index_HapticsProvider as HapticsProvider, type index_HeadlessNodeInstance as HeadlessNodeInstance, index_HeadlessRuntime as HeadlessRuntime, type index_HeadlessRuntimeOptions as HeadlessRuntimeOptions, type index_HeadlessRuntimeStats as HeadlessRuntimeStats, type index_HookExecutor as HookExecutor, index_HotReloadManager as HotReloadManager, type index_HotReloadManagerOptions as HotReloadManagerOptions, type index_InputConfig as InputConfig, type index_InspectorConfig as InspectorConfig, type index_InstanceBatchConfig as InstanceBatchConfig, type index_InstanceBatchStats as InstanceBatchStats, index_InstancedMeshManager as InstancedMeshManager, type index_InstancedObjectData as InstancedObjectData, index_LRUCache as LRUCache, index_Lazy as Lazy, index_LocalEmotionDetector as LocalEmotionDetector, index_MINIMAL_PROFILE as MINIMAL_PROFILE, index_MQTTClient as MQTTClient, type index_MQTTClientConfig as MQTTClientConfig, type index_MQTTClientEvents as MQTTClientEvents, type index_MQTTClientState as MQTTClientState, type index_MQTTMessage as MQTTMessage, type index_MQTTPublishOptions as MQTTPublishOptions, type index_MQTTSubscription as MQTTSubscription, type index_MQTTVersion as MQTTVersion, index_MemoizedProperty as MemoizedProperty, index_MethodMemoize as MethodMemoize, index_MockSpeechRecognizer as MockSpeechRecognizer, type index_NavDestination as NavDestination, type index_NavigationConfig as NavigationConfig, type index_NavigationEngine as NavigationEngine, type index_NetworkConfig as NetworkConfig, type index_NetworkProvider as NetworkProvider, type index_ObjectInfo as ObjectInfo, index_ObjectPool as ObjectPool, index_OptimizedDebrisShader as OptimizedDebrisShader, index_OptimizedFluidShader as OptimizedFluidShader, index_OptimizedParticleShader as OptimizedParticleShader, type index_ParticleSystem as ParticleSystem, index_PerformanceProfiler as PerformanceProfiler, type index_PhysicsEngine as PhysicsEngine, type index_PhysicsProvider as PhysicsProvider, type index_PostProcessingConfig as PostProcessingConfig, type index_PostProcessingEffect as PostProcessingEffect, index_PostProcessingManager as PostProcessingManager, type index_PostProcessingQuality as PostProcessingQuality, type index_PostProcessingStats as PostProcessingStats, type index_ProtocolConfig as ProtocolConfig, type index_QoS as QoS, type index_ReloadWatcher as ReloadWatcher, type index_RenderableCamera as RenderableCamera, type index_RenderableLight as RenderableLight, type index_RenderableObject as RenderableObject, type index_RendererConfig as RendererConfig, type index_RendererProvider as RendererProvider, type index_RendererStatistics as RendererStatistics, type index_RenderingConfig as RenderingConfig, type index_RuntimeCapabilities as RuntimeCapabilities, type index_RuntimeExecutor as RuntimeExecutor, type index_RuntimeMetadata as RuntimeMetadata, type index_RuntimeModule as RuntimeModule, type index_RuntimeProfile as RuntimeProfile, type index_RuntimeProfileName as RuntimeProfileName, index_RuntimeRegistry as RuntimeRegistry, type index_RuntimeRenderer as RuntimeRenderer, index_STANDARD_PROFILE as STANDARD_PROFILE, index_SceneInspector as SceneInspector, type index_SceneStats as SceneStats, type index_ShaderOptimizationConfig as ShaderOptimizationConfig, index_ShaderOptimizationManager as ShaderOptimizationManager, type index_ShaderPerformanceStats as ShaderPerformanceStats, type index_SpeechRecognizer as SpeechRecognizer, type index_SpeechRecognizerConfig as SpeechRecognizerConfig, type index_StateMachineInstance as StateMachineInstance, index_StateMachineInterpreter as StateMachineInterpreter, index_TerrainDeformationShader as TerrainDeformationShader, index_ThreeJSRenderer as ThreeJSRenderer, index_TraitContextFactory as TraitContextFactory, type index_TraitContextFactoryConfig as TraitContextFactoryConfig, type index_TranscriptionSegment as TranscriptionSegment, type index_UpdateHandler as UpdateHandler, type index_VRProvider as VRProvider, index_VR_PROFILE as VR_PROFILE, type index_VoiceConfig as VoiceConfig, type index_VoiceInfo as VoiceInfo, type index_VoiceRequest as VoiceRequest, type index_VoiceSynthesizer as VoiceSynthesizer, index_createCustomProfile as createCustomProfile, index_createHeadlessRuntime as createHeadlessRuntime, index_createMQTTClient as createMQTTClient, index_createTraitContextFactory as createTraitContextFactory, index_emotionDetectorRegistry as emotionDetectorRegistry, index_getAvailableProfiles as getAvailableProfiles, index_getEmotionDetector as getEmotionDetector, index_getGlobalProfiler as getGlobalProfiler, index_getMQTTClient as getMQTTClient, index_getNavigationEngine as getNavigationEngine, index_getPhysicsEngine as getPhysicsEngine, index_getProfile as getProfile, index_getSpeechRecognizer as getSpeechRecognizer, index_getVoiceSynthesizer as getVoiceSynthesizer, index_memoize as memoize, index_navigationEngineRegistry as navigationEngineRegistry, index_physicsEngineRegistry as physicsEngineRegistry, index_registerEmotionDetector as registerEmotionDetector, index_registerMQTTClient as registerMQTTClient, index_registerNavigationEngine as registerNavigationEngine, index_registerPhysicsEngine as registerPhysicsEngine, index_registerProfile as registerProfile, index_registerRuntime as registerRuntime, index_registerSpeechRecognizer as registerSpeechRecognizer, index_registerVoiceSynthesizer as registerVoiceSynthesizer, index_speechRecognizerRegistry as speechRecognizerRegistry, index_stateMachineInterpreter as stateMachineInterpreter, index_unregisterMQTTClient as unregisterMQTTClient, index_voiceSynthesizerRegistry as voiceSynthesizerRegistry };
+}
+
+export { MemoizedProperty as $, type AccessibilityProvider as A, BaseRuntimeRenderer as B, type CultureEvent as C, type HookExecutor as D, type EmotionConfig as E, HotReloadManager as F, GameEngine as G, HEADLESS_PROFILE as H, type HotReloadManagerOptions as I, type InputConfig as J, type InspectorConfig as K, type InstanceBatchConfig as L, type InstanceBatchStats as M, InstancedMeshManager as N, type InstancedObjectData as O, LRUCache as P, Lazy as Q, LocalEmotionDetector as R, MINIMAL_PROFILE as S, MQTTClient as T, type MQTTClientConfig as U, type MQTTClientEvents as V, type MQTTClientState as W, type MQTTMessage as X, type MQTTPublishOptions as Y, type MQTTSubscription as Z, type MQTTVersion as _, type ActionHandler as a, createMQTTClient as a$, MethodMemoize as a0, MockSpeechRecognizer as a1, type NavDestination as a2, type NavigationConfig as a3, type NavigationEngine as a4, type NetworkConfig as a5, type NetworkProvider as a6, type ObjectInfo as a7, ObjectPool as a8, OptimizedDebrisShader as a9, type RuntimeProfileName as aA, RuntimeRegistry as aB, type RuntimeRenderer as aC, STANDARD_PROFILE as aD, SceneInspector as aE, type SceneStats as aF, type ShaderOptimizationConfig as aG, ShaderOptimizationManager as aH, type ShaderPerformanceStats as aI, type SpeechRecognizer as aJ, type SpeechRecognizerConfig as aK, type StateMachineInstance as aL, StateMachineInterpreter as aM, TerrainDeformationShader as aN, ThreeJSRenderer as aO, TraitContextFactory as aP, type TraitContextFactoryConfig as aQ, type TranscriptionSegment as aR, type UpdateHandler as aS, type VRProvider as aT, VR_PROFILE as aU, type VoiceConfig as aV, type VoiceInfo as aW, type VoiceRequest as aX, type VoiceSynthesizer as aY, createCustomProfile as aZ, createHeadlessRuntime as a_, OptimizedFluidShader as aa, OptimizedParticleShader as ab, type ParticleSystem as ac, PerformanceProfiler as ad, type PhysicsEngine as ae, type PhysicsProvider as af, type PostProcessingConfig as ag, type PostProcessingEffect as ah, PostProcessingManager as ai, type PostProcessingQuality as aj, type PostProcessingStats as ak, type ProtocolConfig as al, type QoS as am, type ReloadWatcher as an, type RenderableCamera as ao, type RenderableLight as ap, type RenderableObject as aq, type RendererConfig as ar, type RendererProvider as as, type RendererStatistics as at, type RenderingConfig as au, type RuntimeCapabilities as av, type RuntimeExecutor as aw, type RuntimeMetadata as ax, type RuntimeModule as ay, type RuntimeProfile as az, type AssetLoader as b, createTraitContextFactory as b0, emotionDetectorRegistry as b1, getAvailableProfiles as b2, getEmotionDetector as b3, getGlobalProfiler as b4, getMQTTClient as b5, getNavigationEngine as b6, getPhysicsEngine as b7, getProfile as b8, getSpeechRecognizer as b9, getVoiceSynthesizer as ba, memoize as bb, navigationEngineRegistry as bc, physicsEngineRegistry as bd, registerEmotionDetector as be, registerMQTTClient as bf, registerNavigationEngine as bg, registerPhysicsEngine as bh, registerProfile as bi, registerRuntime as bj, registerSpeechRecognizer as bk, registerVoiceSynthesizer as bl, speechRecognizerRegistry as bm, stateMachineInterpreter as bn, unregisterMQTTClient as bo, voiceSynthesizerRegistry as bp, AssetPipeline as c, type AudioConfig as d, type AudioProvider as e, BaseVoiceSynthesizer as f, BatchedMeshShader as g, Batcher as h, index as i, type BodyProps as j, type BodyState as k, CultureRuntime as l, type CultureRuntimeConfig as m, type EmotionDetector as n, type EmotionInference as o, type EmotionSignals as p, type EnginePhase as q, type EngineStats as r, type GameEngineOptions as s, GameLoop as t, type GameLoopOptions as u, type HapticsProvider as v, type HeadlessNodeInstance as w, HeadlessRuntime as x, type HeadlessRuntimeOptions as y, type HeadlessRuntimeStats as z };