@holoscript/core 2.0.1 → 2.1.0

package/dist/index.d.cts

@@ -0,0 +1,4093 @@
+import { U as UI2DNode, P as Position2D, V as VoiceCommand$1, A as ASTNode, G as GestureData, S as SpatialPosition } from './types-4h8cbtF_.cjs';
+export { o as CollisionEvent, k as Color, C as ConnectionNode, D as Duration, B as ExecutionResult, E as ExportNode, u as ForEachLoopNode, F as ForLoopNode, f as GateNode, h as GenericASTNode, c as GestureType, p as GrabbableTrait, d as HandType, J as HoloScriptValue, b as HologramProperties, H as HologramShape, s as HoverableTrait, v as ImportLoader, I as ImportNode, M as MethodNode, O as OrbNode, e as ParameterNode, K as ParticleSystem, r as PointableTrait, R as RotatableTrait, z as RuntimeContext, N as RuntimeSecurityLimits, t as ScalableTrait, L as SecurityConfig, a as Size2D, g as StreamNode, n as ThrowVelocity, q as ThrowableTrait, l as Transform, T as TransformationNode, x as UIElementType, y as UIStyle, m as VRHand, w as VariableDeclarationNode, j as Vector2, i as Vector3, W as WhileLoopNode } from './types-4h8cbtF_.cjs';
+import { HoloScriptRuntime } from './runtime.cjs';
+export { HoloScriptCodeParser, ParseError, ParseResult } from './parser.cjs';
+export { HoloScriptTypeChecker, TypeCheckResult, TypeDiagnostic, TypeInfo, createTypeChecker } from './type-checker.cjs';
+export { Breakpoint, DebugEvent, DebugState, HoloScriptDebugger, StackFrame, StepMode, createDebugger } from './debugger.cjs';
+
+/**
+ * HoloScript+ Researcher & Viralist Traits
+ *
+ * Extended trait system for content creators, researchers, and viral content production.
+ * These traits enable recording, analytics, social sharing, effects, and AI-powered features.
+ *
+ * @version 2.0.0
+ * @license MIT
+ */
+
+
+
+// =============================================================================
+// MEDIA PRODUCTION TRAITS
+// =============================================================================
+
+/**
+ * @recordable - Capture scene/viewport for viral clips
+ */
+interface RecordableTrait {
+  /** Capture mode - 360 panoramic, viewport only, or fixed camera angle */
+  capture_mode?: '360' | 'viewport' | 'fixed_camera' | 'follow_target';
+
+  /** Output resolution */
+  resolution?: Vector2;
+
+  /** Frames per second */
+  fps?: 30 | 60 | 120;
+
+  /** Output format */
+  format?: 'mp4' | 'webm' | 'gif' | 'png_sequence';
+
+  /** Maximum recording duration */
+  max_duration?: Duration;
+
+  /** Include audio in recording */
+  include_audio?: boolean;
+
+  /** Auto-start recording on scene load */
+  auto_record?: boolean;
+
+  /** Hotkey to toggle recording */
+  hotkey?: string;
+
+  /** Watermark configuration */
+  watermark?: {
+    image?: string;
+    position?: 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right';
+    opacity?: number;
+  };
+
+  /** Quality preset */
+  quality?: 'low' | 'medium' | 'high' | 'ultra';
+
+  /** Enable highlight detection for auto-clipping */
+  highlight_detection?: boolean;
+}
+
+/**
+ * @streamable - Live streaming to platforms
+ */
+interface StreamableTrait {
+  /** Target platform */
+  platform?: 'twitch' | 'youtube' | 'kick' | 'custom';
+
+  /** Custom RTMP URL for streaming */
+  rtmp_url?: string;
+
+  /** Stream key (should be env variable reference) */
+  stream_key_env?: string;
+
+  /** Bitrate in kbps */
+  bitrate?: number;
+
+  /** Resolution */
+  resolution?: Vector2;
+
+  /** Enable chat overlay */
+  chat_overlay?: boolean;
+
+  /** Viewer count display */
+  show_viewer_count?: boolean;
+
+  /** Auto-start streaming */
+  auto_start?: boolean;
+
+  /** Low latency mode */
+  low_latency?: boolean;
+}
+
+/**
+ * @camera - Virtual camera control for cinematic shots
+ */
+interface CameraTrait {
+  /** Camera movement mode */
+  mode?: 'static' | 'orbit' | 'dolly' | 'crane' | 'handheld' | 'follow' | 'first_person';
+
+  /** Target object to follow/orbit */
+  target?: string;
+
+  /** Orbit distance from target */
+  orbit_distance?: number;
+
+  /** Auto-rotate around target */
+  auto_rotate?: boolean;
+
+  /** Rotation speed (degrees per second) */
+  rotation_speed?: number;
+
+  /** Smooth follow interpolation */
+  smooth_follow?: boolean;
+
+  /** Follow smoothness (0-1) */
+  follow_smoothness?: number;
+
+  /** Camera shake intensity */
+  shake_intensity?: number;
+
+  /** Shake frequency */
+  shake_frequency?: number;
+
+  /** Field of view */
+  fov?: number;
+
+  /** Depth of field settings */
+  depth_of_field?: {
+    enabled?: boolean;
+    focus_distance?: number;
+    aperture?: number;
+    blur_intensity?: number;
+  };
+
+  /** Cinematic bars (letterbox) */
+  letterbox?: boolean;
+
+  /** Letterbox ratio */
+  aspect_ratio?: '16:9' | '21:9' | '2.35:1' | 'custom';
+
+  /** Path following */
+  path?: Vector3$1[];
+
+  /** Path animation duration */
+  path_duration?: Duration;
+
+  /** Path easing */
+  path_easing?: 'linear' | 'ease-in' | 'ease-out' | 'ease-in-out';
+}
+
+/**
+ * @video - Video playback in scene
+ */
+interface VideoTrait {
+  /** Video source URL */
+  source: string;
+
+  /** Auto-play on load */
+  autoplay?: boolean;
+
+  /** Loop video */
+  loop?: boolean;
+
+  /** Muted by default */
+  muted?: boolean;
+
+  /** Volume (0-1) */
+  volume?: number;
+
+  /** Spatial audio for video */
+  spatial?: boolean;
+
+  /** Playback controls visible */
+  controls?: boolean;
+
+  /** Projection type */
+  projection?: 'flat' | '360' | '180' | 'dome';
+
+  /** Chroma key (green screen) */
+  chroma_key?: {
+    enabled?: boolean;
+    color?: Color$1;
+    threshold?: number;
+  };
+}
+
+// =============================================================================
+// ANALYTICS & RESEARCH TRAITS
+// =============================================================================
+
+/**
+ * @trackable - User engagement tracking
+ */
+interface TrackableTrait {
+  /** Events to track */
+  track_events?: Array<'grab' | 'look' | 'interact' | 'hover' | 'click' | 'proximity' | 'time_spent'>;
+
+  /** Enable heatmap generation */
+  heatmap?: boolean;
+
+  /** Heatmap resolution */
+  heatmap_resolution?: 'low' | 'medium' | 'high';
+
+  /** Session recording */
+  session_recording?: boolean;
+
+  /** Track gaze/eye direction */
+  gaze_tracking?: boolean;
+
+  /** Minimum dwell time to count as engagement (ms) */
+  dwell_threshold?: number;
+
+  /** Export format for analytics data */
+  export_format?: 'json' | 'csv' | 'parquet';
+
+  /** Real-time analytics endpoint */
+  realtime_endpoint?: string;
+
+  /** Batch analytics endpoint */
+  batch_endpoint?: string;
+
+  /** Anonymous tracking (no user IDs) */
+  anonymous?: boolean;
+
+  /** GDPR compliance mode */
+  gdpr_compliant?: boolean;
+
+  /** Custom event properties */
+  custom_properties?: Record<string, unknown>;
+}
+
+/**
+ * @survey - In-VR research surveys
+ */
+interface SurveyTrait {
+  /** Survey questions */
+  questions: SurveyQuestion[];
+
+  /** When to trigger survey */
+  trigger?: 'on_enter' | 'on_exit' | 'after_task' | 'timed' | 'manual';
+
+  /** Delay before showing (for timed trigger) */
+  delay?: Duration;
+
+  /** Survey title */
+  title?: string;
+
+  /** Survey description */
+  description?: string;
+
+  /** Submit endpoint */
+  submit_endpoint?: string;
+
+  /** Allow skip */
+  skippable?: boolean;
+
+  /** Show progress indicator */
+  show_progress?: boolean;
+
+  /** Randomize question order */
+  randomize?: boolean;
+
+  /** Thank you message after completion */
+  thank_you_message?: string;
+
+  /** Reward for completion */
+  completion_reward?: {
+    type?: 'badge' | 'item' | 'points';
+    value?: string | number;
+  };
+}
+
+interface SurveyQuestion {
+  /** Question type */
+  type: 'rating' | 'choice' | 'multi_choice' | 'open' | 'slider' | 'likert' | 'nps';
+
+  /** Question text */
+  text: string;
+
+  /** Question ID for data export */
+  id?: string;
+
+  /** Required question */
+  required?: boolean;
+
+  /** Options for choice questions */
+  options?: string[];
+
+  /** Scale for rating/slider questions */
+  scale?: number;
+
+  /** Min/max labels for scales */
+  scale_labels?: { min?: string; max?: string };
+
+  /** Conditional display based on previous answer */
+  show_if?: { question_id: string; answer: string | number };
+}
+
+/**
+ * @abtest - A/B testing framework
+ */
+interface ABTestTrait {
+  /** Test name/ID */
+  test_id: string;
+
+  /** Variant configurations */
+  variants: Record<string, Record<string, unknown>>;
+
+  /** Traffic split percentages */
+  split?: Record<string, number>;
+
+  /** Metric to track for success */
+  track_metric?: 'engagement_time' | 'conversion' | 'completion' | 'custom';
+
+  /** Custom metric name */
+  custom_metric?: string;
+
+  /** Minimum sample size before concluding */
+  min_sample_size?: number;
+
+  /** Statistical significance threshold */
+  significance_threshold?: number;
+
+  /** Sticky assignment (same user always sees same variant) */
+  sticky?: boolean;
+
+  /** Analytics endpoint */
+  analytics_endpoint?: string;
+}
+
+/**
+ * @heatmap - Spatial engagement heatmap
+ */
+interface HeatmapTrait {
+  /** Heatmap type */
+  type?: 'position' | 'gaze' | 'interaction' | 'time_spent';
+
+  /** Resolution of the heatmap grid */
+  resolution?: number;
+
+  /** Color gradient */
+  colors?: Color$1[];
+
+  /** Opacity */
+  opacity?: number;
+
+  /** Real-time visualization */
+  realtime?: boolean;
+
+  /** Export heatmap data */
+  export?: boolean;
+
+  /** 3D volumetric heatmap */
+  volumetric?: boolean;
+
+  /** Decay rate for time-based heatmaps */
+  decay_rate?: number;
+}
+
+// =============================================================================
+// SOCIAL & VIRAL TRAITS
+// =============================================================================
+
+/**
+ * @shareable - Social sharing capabilities
+ */
+interface ShareableTrait {
+  /** Target platforms */
+  platforms?: Array<'twitter' | 'tiktok' | 'instagram' | 'discord' | 'facebook' | 'linkedin' | 'reddit' | 'clipboard'>;
+
+  /** Auto-generate clip on share */
+  auto_clip?: {
+    enabled?: boolean;
+    duration?: number;
+    trigger?: 'highlight' | 'manual' | 'interval';
+  };
+
+  /** Watermark on shared content */
+  watermark?: string;
+
+  /** Caption template (supports variables) */
+  caption_template?: string;
+
+  /** Hashtags to include */
+  hashtags?: string[];
+
+  /** Share button visibility */
+  share_button?: {
+    visible?: boolean;
+    position?: Vector3$1;
+    style?: 'minimal' | 'full' | 'floating';
+  };
+
+  /** Track shares */
+  track_shares?: boolean;
+
+  /** Referral tracking */
+  referral_tracking?: boolean;
+}
+
+/**
+ * @embeddable - Generate embed codes
+ */
+interface EmbeddableTrait {
+  /** Allow iframe embedding */
+  iframe_allowed?: boolean;
+
+  /** Minimum embed width */
+  min_width?: number;
+
+  /** Minimum embed height */
+  min_height?: number;
+
+  /** Responsive sizing */
+  responsive?: boolean;
+
+  /** Allowed domains for embedding */
+  allowed_domains?: string[];
+
+  /** Controls to show in embed */
+  controls?: Array<'fullscreen' | 'vr_toggle' | 'mute' | 'share'>;
+
+  /** Auto-play in embed */
+  autoplay?: boolean;
+
+  /** Show branding */
+  show_branding?: boolean;
+}
+
+/**
+ * @qr - Generate QR codes
+ */
+interface QRTrait {
+  /** Content for QR code (URL, text, etc.) */
+  content: string;
+
+  /** QR code size in world units */
+  size?: number;
+
+  /** Error correction level */
+  error_correction?: 'L' | 'M' | 'Q' | 'H';
+
+  /** Foreground color */
+  foreground_color?: Color$1;
+
+  /** Background color */
+  background_color?: Color$1;
+
+  /** Include logo in center */
+  logo?: string;
+
+  /** Dynamic content (updates on state change) */
+  dynamic?: boolean;
+
+  /** Track scans */
+  track_scans?: boolean;
+}
+
+/**
+ * @collaborative - Real-time co-editing
+ */
+interface CollaborativeTrait {
+  /** Maximum simultaneous editors */
+  max_editors?: number;
+
+  /** Permission model */
+  permission_model?: 'owner' | 'open' | 'invite' | 'role_based';
+
+  /** Sync mode */
+  sync_mode?: 'realtime' | 'turn_based' | 'async';
+
+  /** Show other users' cursors */
+  show_cursors?: boolean;
+
+  /** Cursor colors for different users */
+  cursor_colors?: Color$1[];
+
+  /** Voice chat for collaborators */
+  voice_chat?: boolean;
+
+  /** Text chat */
+  text_chat?: boolean;
+
+  /** Conflict resolution strategy */
+  conflict_resolution?: 'last_write_wins' | 'merge' | 'manual';
+
+  /** Version history */
+  version_history?: boolean;
+
+  /** Undo/redo sync */
+  sync_undo?: boolean;
+}
+
+// =============================================================================
+// EFFECTS & POLISH TRAITS
+// =============================================================================
+
+/**
+ * @particle - Particle system
+ */
+interface ParticleTrait {
+  /** Particle emission type */
+  type?: 'burst' | 'continuous' | 'trail';
+
+  /** Emitter shape */
+  shape?: 'point' | 'sphere' | 'box' | 'cone' | 'circle' | 'edge' | 'mesh';
+
+  /** Emission rate (particles per second) */
+  rate?: number;
+
+  /** Burst count (for burst type) */
+  burst_count?: number;
+
+  /** Particle lifetime */
+  lifetime?: Duration;
+
+  /** Lifetime randomness (0-1) */
+  lifetime_randomness?: number;
+
+  /** Start size */
+  start_size?: number;
+
+  /** End size */
+  end_size?: number;
+
+  /** Size randomness */
+  size_randomness?: number;
+
+  /** Start color */
+  start_color?: Color$1;
+
+  /** End color */
+  end_color?: Color$1;
+
+  /** Color over lifetime gradient */
+  color_over_lifetime?: Color$1[];
+
+  /** Start velocity */
+  velocity?: Vector3$1;
+
+  /** Velocity randomness */
+  velocity_randomness?: number;
+
+  /** Gravity effect */
+  gravity?: number;
+
+  /** Particle texture/sprite */
+  texture?: string;
+
+  /** Blend mode */
+  blend_mode?: 'additive' | 'alpha' | 'multiply';
+
+  /** Max particles */
+  max_particles?: number;
+
+  /** Collision with scene */
+  collision?: boolean;
+
+  /** Inherit velocity from parent */
+  inherit_velocity?: boolean;
+
+  /** World or local space */
+  simulation_space?: 'world' | 'local';
+}
+
+/**
+ * @transition - Scene/object transitions
+ */
+interface TransitionTrait {
+  /** Enter transition effect */
+  enter?: 'fade' | 'zoom' | 'portal' | 'dissolve' | 'slide' | 'flip' | 'morph' | 'glitch';
+
+  /** Exit transition effect */
+  exit?: 'fade' | 'shrink' | 'portal' | 'dissolve' | 'slide' | 'flip' | 'explode';
+
+  /** Transition duration */
+  duration?: Duration;
+
+  /** Transition easing */
+  easing?: 'linear' | 'ease-in' | 'ease-out' | 'ease-in-out' | 'bounce' | 'elastic';
+
+  /** Delay before transition */
+  delay?: Duration;
+
+  /** Transition direction (for slide) */
+  direction?: 'up' | 'down' | 'left' | 'right';
+
+  /** Portal color (for portal transition) */
+  portal_color?: Color$1;
+
+  /** Stagger children transitions */
+  stagger?: Duration;
+
+  /** Stagger order */
+  stagger_order?: 'forward' | 'reverse' | 'random';
+}
+
+/**
+ * @filter - Post-processing effects
+ */
+interface FilterTrait {
+  /** Bloom effect */
+  bloom?: {
+    enabled?: boolean;
+    intensity?: number;
+    threshold?: number;
+    radius?: number;
+  };
+
+  /** Vignette effect */
+  vignette?: {
+    enabled?: boolean;
+    intensity?: number;
+    smoothness?: number;
+  };
+
+  /** Color grading preset */
+  color_grading?: 'none' | 'cinematic' | 'vibrant' | 'noir' | 'vintage' | 'cyberpunk' | 'warm' | 'cool';
+
+  /** Custom LUT texture */
+  lut?: string;
+
+  /** Chromatic aberration */
+  chromatic_aberration?: {
+    enabled?: boolean;
+    intensity?: number;
+  };
+
+  /** Film grain */
+  grain?: {
+    enabled?: boolean;
+    intensity?: number;
+    size?: number;
+  };
+
+  /** Motion blur */
+  motion_blur?: {
+    enabled?: boolean;
+    intensity?: number;
+    samples?: number;
+  };
+
+  /** Ambient occlusion */
+  ambient_occlusion?: {
+    enabled?: boolean;
+    intensity?: number;
+    radius?: number;
+  };
+
+  /** Pixelation */
+  pixelate?: {
+    enabled?: boolean;
+    size?: number;
+  };
+
+  /** Custom shader */
+  custom_shader?: string;
+}
+
+/**
+ * @trail - Motion trail effect
+ */
+interface TrailTrait {
+  /** Trail length (number of points) */
+  length?: number;
+
+  /** Trail width */
+  width?: number;
+
+  /** Width curve over length */
+  width_curve?: number[];
+
+  /** Trail color */
+  color?: Color$1;
+
+  /** Color gradient over length */
+  color_gradient?: Color$1[];
+
+  /** Trail fade */
+  fade?: boolean;
+
+  /** Fade curve */
+  fade_curve?: number[];
+
+  /** Emit when moving threshold */
+  emit_threshold?: number;
+
+  /** Trail texture */
+  texture?: string;
+
+  /** Minimum vertex distance */
+  min_vertex_distance?: number;
+
+  /** Auto-destruct when stopped */
+  auto_destruct?: boolean;
+}
+
+// =============================================================================
+// AUDIO TRAITS
+// =============================================================================
+
+/**
+ * @spatial_audio - 3D positional audio
+ */
+interface SpatialAudioTrait {
+  /** Audio source URL */
+  source: string;
+
+  /** Volume (0-1) */
+  volume?: number;
+
+  /** Pitch */
+  pitch?: number;
+
+  /** Loop audio */
+  loop?: boolean;
+
+  /** Spatial blend (0 = 2D, 1 = 3D) */
+  spatial_blend?: number;
+
+  /** Distance falloff type */
+  falloff?: 'linear' | 'logarithmic' | 'custom';
+
+  /** Minimum distance for falloff */
+  min_distance?: number;
+
+  /** Maximum distance for falloff */
+  max_distance?: number;
+
+  /** Reverb zone */
+  reverb?: {
+    enabled?: boolean;
+    preset?: 'room' | 'hall' | 'cave' | 'outdoor' | 'underwater';
+    wet_level?: number;
+  };
+
+  /** Doppler effect */
+  doppler?: number;
+
+  /** Spread angle (degrees) */
+  spread?: number;
+
+  /** Occlusion (sound blocked by objects) */
+  occlusion?: boolean;
+}
+
+/**
+ * @voice - Voice chat
+ */
+interface VoiceTrait {
+  /** Voice chat mode */
+  mode?: 'proximity' | 'global' | 'channel' | 'team';
+
+  /** Spatial voice positioning */
+  spatial?: boolean;
+
+  /** Push-to-talk */
+  push_to_talk?: boolean;
+
+  /** Push-to-talk key */
+  ptt_key?: string;
+
+  /** Voice activation threshold */
+  activation_threshold?: number;
+
+  /** Echo cancellation */
+  echo_cancellation?: boolean;
+
+  /** Noise suppression */
+  noise_suppression?: boolean;
+
+  /** Auto gain control */
+  auto_gain?: boolean;
+
+  /** Channel name (for channel mode) */
+  channel?: string;
+
+  /** Maximum distance for proximity mode */
+  proximity_distance?: number;
+
+  /** Voice indicator visible */
+  show_indicator?: boolean;
+}
+
+/**
+ * @reactive_audio - Audio-reactive visuals
+ */
+interface ReactiveAudioTrait {
+  /** Audio source */
+  source?: 'microphone' | 'audio_element' | 'system' | 'custom';
+
+  /** Audio element ID (for audio_element source) */
+  audio_element?: string;
+
+  /** Number of frequency bands to analyze */
+  frequency_bands?: number;
+
+  /** FFT size */
+  fft_size?: 256 | 512 | 1024 | 2048 | 4096;
+
+  /** Smoothing time constant */
+  smoothing?: number;
+
+  /** Beat detection */
+  beat_detection?: boolean;
+
+  /** Beat threshold */
+  beat_threshold?: number;
+
+  /** Min decibels */
+  min_decibels?: number;
+
+  /** Max decibels */
+  max_decibels?: number;
+
+  /** Frequency range to analyze */
+  frequency_range?: { min?: number; max?: number };
+}
+
+// =============================================================================
+// AI & GENERATIVE TRAITS
+// =============================================================================
+
+/**
+ * @narrator - AI narration
+ */
+interface NarratorTrait {
+  /** Voice preset */
+  voice?: 'alloy' | 'echo' | 'fable' | 'onyx' | 'nova' | 'shimmer' | 'custom';
+
+  /** Custom voice ID */
+  custom_voice_id?: string;
+
+  /** Narration script */
+  script?: string;
+
+  /** Dynamic script (generated from context) */
+  dynamic_script?: boolean;
+
+  /** Script generation prompt */
+  script_prompt?: string;
+
+  /** Trigger condition */
+  trigger?: 'on_enter' | 'on_approach' | 'on_interact' | 'on_event' | 'manual';
+
+  /** Trigger distance (for on_approach) */
+  trigger_distance?: number;
+
+  /** Subtitles display */
+  subtitles?: boolean;
+
+  /** Subtitle style */
+  subtitle_style?: {
+    position?: 'top' | 'bottom' | 'floating';
+    font_size?: number;
+    background?: boolean;
+  };
+
+  /** Speed */
+  speed?: number;
+
+  /** Language */
+  language?: string;
+
+  /** Queue multiple narrations */
+  queue?: boolean;
+
+  /** Interruptible */
+  interruptible?: boolean;
+}
+
+/**
+ * @responsive - AI conversational responses
+ */
+interface ResponsiveTrait {
+  /** AI personality description */
+  personality?: string;
+
+  /** System prompt */
+  system_prompt?: string;
+
+  /** Knowledge base reference */
+  knowledge_base?: string;
+
+  /** Model to use */
+  model?: 'gpt-4' | 'claude' | 'gemini' | 'local' | 'custom';
+
+  /** Custom model endpoint */
+  custom_endpoint?: string;
+
+  /** Voice enabled for responses */
+  voice_enabled?: boolean;
+
+  /** Voice preset */
+  voice?: string;
+
+  /** Listen for voice input */
+  voice_input?: boolean;
+
+  /** Max response tokens */
+  max_tokens?: number;
+
+  /** Temperature */
+  temperature?: number;
+
+  /** Context window (conversation history) */
+  context_messages?: number;
+
+  /** Response format */
+  response_format?: 'text' | 'json' | 'action';
+
+  /** Available actions the AI can trigger */
+  available_actions?: string[];
+
+  /** Fallback response */
+  fallback?: string;
+}
+
+/**
+ * @procedural - Procedural generation
+ */
+interface ProceduralTrait {
+  /** Generation algorithm */
+  algorithm?: 'perlin' | 'simplex' | 'voronoi' | 'wave_function_collapse' | 'l_system' | 'custom';
+
+  /** Random seed */
+  seed?: number;
+
+  /** Generation parameters */
+  params?: Record<string, number>;
+
+  /** Regeneration trigger */
+  regenerate_on?: 'click' | 'timer' | 'state_change' | 'manual';
+
+  /** Timer interval for regeneration */
+  regenerate_interval?: Duration;
+
+  /** Animate generation */
+  animate?: boolean;
+
+  /** Animation duration */
+  animation_duration?: Duration;
+
+  /** LOD (level of detail) */
+  lod?: number;
+
+  /** Bounds for generation */
+  bounds?: { min: Vector3$1; max: Vector3$1 };
+
+  /** Tile seamlessly */
+  tileable?: boolean;
+}
+
+/**
+ * @captioned - Auto-captions for media
+ */
+interface CaptionedTrait {
+  /** Caption source */
+  source?: 'auto' | 'file' | 'api';
+
+  /** Caption file URL (for file source) */
+  caption_file?: string;
+
+  /** Language */
+  language?: string;
+
+  /** Auto-translate to other languages */
+  translate?: string[];
+
+  /** Caption style */
+  style?: {
+    position?: 'top' | 'bottom' | 'auto';
+    font_size?: 'small' | 'medium' | 'large';
+    background?: boolean;
+    background_color?: Color$1;
+    text_color?: Color$1;
+  };
+
+  /** Word-by-word highlighting */
+  highlight_words?: boolean;
+
+  /** Speaker identification */
+  speaker_labels?: boolean;
+
+  /** Profanity filter */
+  profanity_filter?: boolean;
+}
+
+// =============================================================================
+// TIMELINE & SEQUENCING TRAITS
+// =============================================================================
+
+/**
+ * @timeline - Animation timeline
+ */
+interface TimelineTrait {
+  /** Total duration */
+  duration: Duration;
+
+  /** Loop timeline */
+  loop?: boolean;
+
+  /** Loop count (0 = infinite) */
+  loop_count?: number;
+
+  /** Playback speed */
+  speed?: number;
+
+  /** Auto-play */
+  autoplay?: boolean;
+
+  /** Delay before starting */
+  delay?: Duration;
+
+  /** Pause on hover */
+  pause_on_hover?: boolean;
+
+  /** Allow seeking */
+  seekable?: boolean;
+
+  /** Show playback controls */
+  controls?: boolean;
+
+  /** Trigger condition to start */
+  trigger?: 'immediate' | 'on_enter' | 'on_interact' | 'manual';
+}
+
+/**
+ * @choreography - Sequenced multi-object animations
+ */
+interface ChoreographyTrait {
+  /** Objects to choreograph */
+  objects: string[];
+
+  /** Sequence of actions */
+  sequence: ChoreographyStep[];
+
+  /** Sync to audio track */
+  sync_to?: string;
+
+  /** BPM for music sync */
+  bpm?: number;
+
+  /** Loop choreography */
+  loop?: boolean;
+
+  /** Formation presets */
+  formation?: 'line' | 'circle' | 'grid' | 'v_shape' | 'custom';
+
+  /** Formation spacing */
+  spacing?: number;
+}
+
+interface ChoreographyStep {
+  /** Time offset */
+  time: Duration;
+
+  /** Action to perform */
+  action: string;
+
+  /** Action parameters */
+  params?: Record<string, unknown>;
+
+  /** Which objects (indices or 'all') */
+  targets?: number[] | 'all';
+
+  /** Stagger delay between objects */
+  stagger?: Duration;
+}
+
+/**
+ * HoloScript+ Type Definitions
+ *
+ * Enhanced HoloScript with VR interactions, state management, and TypeScript interop.
+ * Backward compatible with original HoloScript - new features are opt-in via @ directives.
+ */
+
+
+
+type Vector3$1 = [number, number, number];
+type Vector2 = [number, number];
+type Color$1 = string;
+type Duration = `${number}${'ms' | 's' | 'm'}`;
+
+/**
+ * VR interaction types
+ */
+interface VRHand {
+  id: 'left' | 'right';
+  position: Vector3$1;
+  rotation: Vector3$1;
+  velocity: Vector3$1;
+  grip: number;
+  trigger: number;
+}
+
+interface ThrowVelocity {
+  direction: Vector3$1;
+  magnitude: number;
+  angularVelocity: Vector3$1;
+}
+
+interface CollisionEvent {
+  target: HSPlusNode;
+  point: Vector3$1;
+  normal: Vector3$1;
+  impulse: number;
+  relativeVelocity: Vector3$1;
+}
+
+interface StackableTrait {
+  stack_axis?: 'x' | 'y' | 'z';
+  stack_offset?: number;
+  max_stack?: number;
+  snap_distance?: number;
+}
+
+interface SnappableTrait {
+  snap_points?: Vector3$1[];
+  snap_distance?: number;
+  snap_rotation?: boolean;
+  magnetic?: boolean;
+}
+
+interface BreakableTrait {
+  break_velocity?: number;
+  fragments?: number;
+  fragment_mesh?: string;
+  sound_on_break?: string;
+  respawn?: boolean;
+  respawn_delay?: Duration;
+}
+
+/**
+ * @stretchable - Deformable mesh manipulation for molding, building atoms, and creative sculpting
+ *
+ * Use cases:
+ * - Atomic/molecular building (stretch bonds between atoms)
+ * - Clay/putty sculpting
+ * - Elastic objects that deform under force
+ * - Scientific visualization of molecular structures
+ *
+ * @example
+ * ```holoscript
+ * sphere#atom @stretchable(mode: "bond", snap_to: "atoms", elasticity: 0.8) {
+ *   color: "#ff0000"
+ *   @on_stretch(delta) => update_bond_visualization(delta)
+ * }
+ * ```
+ */
+interface StretchableTrait {
+  /** Stretch mode: 'free' | 'axis' | 'bond' | 'surface' | 'volume' */
+  mode?: 'free' | 'axis' | 'bond' | 'surface' | 'volume';
+  /** Which axis/axes to allow stretching on */
+  axis?: 'x' | 'y' | 'z' | 'xy' | 'xz' | 'yz' | 'all';
+  /** Minimum stretch factor (0.1 = can shrink to 10%) */
+  min_stretch?: number;
+  /** Maximum stretch factor (10 = can grow to 1000%) */
+  max_stretch?: number;
+  /** Elasticity - how much it snaps back (0 = permanent, 1 = fully elastic) */
+  elasticity?: number;
+  /** Snap distance for connecting to other stretchable objects */
+  snap_distance?: number;
+  /** Object types/tags this can snap/bond to */
+  snap_to?: string | string[];
+  /** Whether to preserve volume when stretching (like clay) */
+  preserve_volume?: boolean;
+  /** Resolution of deformation mesh (higher = smoother but more expensive) */
+  mesh_resolution?: number;
+  /** Haptic feedback intensity when stretching */
+  haptic_feedback?: number;
+  /** Sound to play while stretching */
+  stretch_sound?: string;
+  /** Visual indicator for stretch limits */
+  show_stretch_limits?: boolean;
+  /** Color gradient for stretch visualization (cold to hot) */
+  stretch_colors?: [Color$1, Color$1];
+  /** Whether two hands are required to stretch */
+  two_handed?: boolean;
+  /** Bond type for molecular building: 'single' | 'double' | 'triple' | 'ionic' */
+  bond_type?: 'single' | 'double' | 'triple' | 'ionic' | 'hydrogen' | 'custom';
+  /** Visual style for bonds */
+  bond_style?: 'stick' | 'ball-stick' | 'space-fill' | 'wireframe';
+}
+
+/**
+ * @moldable - Advanced sculpting trait for clay-like deformation
+ *
+ * @example
+ * ```holoscript
+ * mesh#clay @moldable(tool: "fingers", softness: 0.7) {
+ *   @on_sculpt(region, pressure) => update_mesh(region, pressure)
+ * }
+ * ```
+ */
+interface MoldableTrait {
+  /** Sculpting tool type */
+  tool?: 'fingers' | 'brush' | 'knife' | 'smooth' | 'pinch' | 'inflate';
+  /** How soft/deformable the material is (0 = hard, 1 = very soft) */
+  softness?: number;
+  /** Brush/tool radius */
+  tool_radius?: number;
+  /** Pressure sensitivity multiplier */
+  pressure_sensitivity?: number;
+  /** Whether to enable symmetry sculpting */
+  symmetry?: boolean | 'x' | 'y' | 'z';
+  /** Maximum deformation depth */
+  max_depth?: number;
+  /** Enable undo history */
+  undo_enabled?: boolean;
+  /** Number of undo steps to keep */
+  undo_steps?: number;
+  /** Auto-smooth after sculpting */
+  auto_smooth?: boolean;
+  /** Material properties for rendering */
+  material?: 'clay' | 'metal' | 'organic' | 'crystal';
+}
+
+// ============================================================================
+// HUMANOID / AVATAR TRAITS - Building human-like features
+// ============================================================================
+
+/**
+ * @skeleton - Rigging and skeletal system for humanoid characters
+ *
+ * @example
+ * ```holoscript
+ * avatar#player @skeleton(type: "humanoid", ik_enabled: true) {
+ *   @on_pose_change(pose) => sync_animation(pose)
+ * }
+ * ```
+ */
+interface SkeletonTrait {
+  /** Skeleton type preset */
+  type?: 'humanoid' | 'quadruped' | 'bird' | 'spider' | 'custom';
+  /** Enable inverse kinematics */
+  ik_enabled?: boolean;
+  /** IK targets for limbs */
+  ik_targets?: {
+    left_hand?: string;
+    right_hand?: string;
+    left_foot?: string;
+    right_foot?: string;
+    head?: string;
+    spine?: string;
+  };
+  /** Bone constraints */
+  constraints?: Record<string, { min: Vector3$1; max: Vector3$1 }>;
+  /** Root bone name */
+  root_bone?: string;
+  /** Enable physics-based secondary motion (hair, cloth, etc.) */
+  secondary_motion?: boolean;
+  /** Retargeting source for animations */
+  retarget_source?: string;
+}
+
+/**
+ * @body - Body configuration for humanoid avatars
+ *
+ * @example
+ * ```holoscript
+ * avatar#custom @body(preset: "athletic", height: 1.8, proportions: "realistic") {
+ *   skin_tone: "#e8beac"
+ *   body_type: "mesomorph"
+ * }
+ * ```
+ */
+interface BodyTrait {
+  /** Body preset */
+  preset?: 'default' | 'athletic' | 'slim' | 'heavy' | 'child' | 'elderly' | 'custom';
+  /** Height in meters */
+  height?: number;
+  /** Body proportions style */
+  proportions?: 'realistic' | 'stylized' | 'cartoon' | 'chibi' | 'heroic';
+  /** Body type/somatotype */
+  body_type?: 'ectomorph' | 'mesomorph' | 'endomorph' | 'average';
+  /** Muscle definition (0-1) */
+  muscle_definition?: number;
+  /** Body fat percentage visual (0-1) */
+  body_fat?: number;
+  /** Shoulder width multiplier */
+  shoulder_width?: number;
+  /** Hip width multiplier */
+  hip_width?: number;
+  /** Limb length multipliers */
+  limb_proportions?: {
+    arms?: number;
+    legs?: number;
+    torso?: number;
+    neck?: number;
+  };
+  /** Gender presentation */
+  gender_expression?: 'masculine' | 'feminine' | 'androgynous' | 'neutral';
+  /** Age appearance (affects skin, posture, etc.) */
+  apparent_age?: number;
+}
+
+/**
+ * @face - Facial features and structure
+ *
+ * @example
+ * ```holoscript
+ * head#playerHead @face(shape: "oval", ethnicity_blend: ["european", "asian"]) {
+ *   eye_color: "#3b7a57"
+ *   @expressive(auto_blink: true, lip_sync: true)
+ * }
+ * ```
+ */
+interface FaceTrait {
+  /** Face shape preset */
+  shape?: 'oval' | 'round' | 'square' | 'heart' | 'oblong' | 'diamond' | 'triangle';
+  /** Ethnicity blend for facial features (can mix multiple) */
+  ethnicity_blend?: string[];
+  /** Eye settings */
+  eyes?: {
+    shape?: 'almond' | 'round' | 'hooded' | 'monolid' | 'upturned' | 'downturned';
+    color?: Color$1;
+    size?: number;
+    spacing?: number;
+    iris_detail?: 'simple' | 'detailed' | 'realistic';
+    heterochromia?: boolean;
+    secondary_color?: Color$1;
+  };
+  /** Nose settings */
+  nose?: {
+    shape?: 'straight' | 'roman' | 'button' | 'aquiline' | 'flat' | 'upturned';
+    width?: number;
+    length?: number;
+    bridge_height?: number;
+  };
+  /** Mouth/lips settings */
+  mouth?: {
+    shape?: 'thin' | 'full' | 'bow' | 'wide' | 'small';
+    width?: number;
+    lip_thickness?: { upper: number; lower: number };
+  };
+  /** Jaw and chin */
+  jaw?: {
+    width?: number;
+    chin_shape?: 'pointed' | 'rounded' | 'square' | 'cleft';
+    chin_prominence?: number;
+  };
+  /** Cheekbone prominence */
+  cheekbones?: number;
+  /** Brow settings */
+  brow?: {
+    thickness?: number;
+    arch?: number;
+    spacing?: number;
+  };
+  /** Ear settings */
+  ears?: {
+    size?: number;
+    shape?: 'attached' | 'free' | 'pointed' | 'rounded';
+    protrusion?: number;
+  };
+  /** Forehead height */
+  forehead_height?: number;
+  /** Facial hair (for applicable characters) */
+  facial_hair?: {
+    type?: 'none' | 'stubble' | 'beard' | 'mustache' | 'goatee' | 'full';
+    density?: number;
+    color?: Color$1;
+    style?: string;
+  };
+  /** Skin details */
+  skin?: {
+    tone?: Color$1;
+    texture?: 'smooth' | 'normal' | 'rough' | 'weathered';
+    freckles?: number;
+    moles?: Array<{ position: Vector2; size: number }>;
+    wrinkles?: number;
+    pores?: number;
+    subsurface_scattering?: number;
+  };
+}
+
+/**
+ * @expressive - Facial expressions and emotion system
+ *
+ * @example
+ * ```holoscript
+ * avatar#npc @expressive(blend_shapes: true, micro_expressions: true) {
+ *   @on_emotion_change(emotion) => play_expression(emotion)
+ * }
+ * ```
+ */
+interface ExpressiveTrait {
+  /** Enable blend shape morphs */
+  blend_shapes?: boolean;
+  /** Emotion presets available */
+  emotions?: Array<'happy' | 'sad' | 'angry' | 'surprised' | 'disgusted' | 'fearful' | 'neutral' | 'contempt'>;
+  /** Custom blend shape mappings */
+  blend_shape_map?: Record<string, string>;
+  /** Auto-blink behavior */
+  auto_blink?: boolean;
+  /** Blink frequency (per minute) */
+  blink_rate?: number;
+  /** Enable micro-expressions for realism */
+  micro_expressions?: boolean;
+  /** Eye movement behavior */
+  eye_behavior?: {
+    look_at_target?: boolean;
+    saccades?: boolean;
+    pupil_dilation?: boolean;
+  };
+  /** Lip sync configuration */
+  lip_sync?: boolean | {
+    method?: 'viseme' | 'phoneme' | 'ai';
+    smoothing?: number;
+    exaggeration?: number;
+  };
+  /** Breathing animation */
+  breathing?: boolean;
+  /** Current emotion state */
+  default_emotion?: string;
+  /** Emotion transition speed */
+  transition_speed?: number;
+}
+
+/**
+ * @hair - Hair and hairstyle system
+ *
+ * @example
+ * ```holoscript
+ * hair#playerHair @hair(style: "long_wavy", physics: true) {
+ *   color: "#2c1810"
+ *   highlights: "#4a3728"
+ * }
+ * ```
+ */
+interface HairTrait {
+  /** Hair style preset */
+  style?: string; // 'short' | 'medium' | 'long' | 'buzz' | 'bald' | 'afro' | 'braids' | 'ponytail' | etc.
+  /** Primary hair color */
+  color?: Color$1;
+  /** Highlight/secondary color */
+  highlights?: Color$1;
+  /** Hair texture */
+  texture?: 'straight' | 'wavy' | 'curly' | 'coily' | 'kinky';
+  /** Hair thickness/density */
+  density?: number;
+  /** Strand thickness */
+  thickness?: number;
+  /** Hair length (0-1 normalized) */
+  length?: number;
+  /** Enable physics simulation */
+  physics?: boolean;
+  /** Physics stiffness */
+  stiffness?: number;
+  /** Wind/movement response */
+  wind_response?: number;
+  /** Hair shine/specular */
+  shine?: number;
+  /** Render method */
+  render_method?: 'cards' | 'strands' | 'mesh';
+  /** LOD levels for performance */
+  lod_levels?: number;
+}
+
+/**
+ * @clothing - Clothing and outfit system
+ *
+ * @example
+ * ```holoscript
+ * outfit#casual @clothing(type: "full_body", physics: "cloth") {
+ *   style: "casual_modern"
+ *   fit: "relaxed"
+ * }
+ * ```
+ */
+interface ClothingTrait {
+  /** Clothing slot type */
+  type?: 'full_body' | 'top' | 'bottom' | 'shoes' | 'accessory' | 'hat' | 'glasses' | 'jewelry';
+  /** Clothing style category */
+  style?: string;
+  /** Fit type */
+  fit?: 'tight' | 'fitted' | 'relaxed' | 'loose' | 'oversized';
+  /** Primary color/material */
+  color?: Color$1;
+  /** Material type */
+  material?: 'cotton' | 'silk' | 'leather' | 'denim' | 'wool' | 'synthetic' | 'metal';
+  /** Physics simulation type */
+  physics?: 'none' | 'cloth' | 'rigid' | 'soft_body';
+  /** Cloth simulation settings */
+  cloth_settings?: {
+    stiffness?: number;
+    damping?: number;
+    collision_margin?: number;
+    wind_response?: number;
+  };
+  /** Layer order (for layered clothing) */
+  layer?: number;
+  /** Body parts this hides/masks */
+  masks_body?: string[];
+  /** Pattern/texture overlay */
+  pattern?: string;
+}
+
+/**
+ * @hands - Detailed hand configuration and gestures
+ *
+ * @example
+ * ```holoscript
+ * hands#playerHands @hands(tracking: "full", gestures: true) {
+ *   @on_gesture(type) => handle_gesture(type)
+ * }
+ * ```
+ */
+interface HandsTrait {
+  /** Hand tracking mode */
+  tracking?: 'controller' | 'skeletal' | 'full' | 'none';
+  /** Enable gesture recognition */
+  gestures?: boolean;
+  /** Available gestures */
+  gesture_set?: Array<'point' | 'fist' | 'open' | 'pinch' | 'thumbs_up' | 'peace' | 'ok' | 'custom'>;
+  /** Custom gesture definitions */
+  custom_gestures?: Record<string, unknown>;
+  /** Finger curl tracking precision */
+  finger_precision?: 'low' | 'medium' | 'high';
+  /** Hand size multiplier */
+  size?: number;
+  /** Nail appearance */
+  nails?: {
+    length?: 'short' | 'medium' | 'long';
+    shape?: 'square' | 'rounded' | 'pointed' | 'almond';
+    color?: Color$1;
+  };
+  /** Skin details for hands */
+  skin_detail?: 'low' | 'medium' | 'high';
+  /** Ring/jewelry attachment points */
+  accessory_slots?: string[];
+}
+
+/**
+ * @voice - Voice and speech synthesis for characters
+ *
+ * @example
+ * ```holoscript
+ * avatar#assistant @voice(type: "synthesis", voice_id: "aria") {
+ *   @on_speak(text) => animate_lip_sync(text)
+ * }
+ * ```
+ */
+interface CharacterVoiceTrait {
+  /** Voice type */
+  type?: 'recorded' | 'synthesis' | 'clone' | 'realtime';
+  /** Voice ID for synthesis */
+  voice_id?: string;
+  /** Voice preset characteristics */
+  preset?: 'male_deep' | 'male_tenor' | 'female_alto' | 'female_soprano' | 'child' | 'robot' | 'custom';
+  /** Pitch adjustment (-1 to 1) */
+  pitch?: number;
+  /** Speaking rate (0.5 to 2) */
+  rate?: number;
+  /** Voice warmth/coldness */
+  warmth?: number;
+  /** Breathiness */
+  breathiness?: number;
+  /** Accent/dialect */
+  accent?: string;
+  /** Language */
+  language?: string;
+  /** Enable emotion in voice */
+  emotional?: boolean;
+  /** SSML support */
+  ssml_enabled?: boolean;
+}
+
+/**
+ * @locomotion - Movement and animation system
+ *
+ * @example
+ * ```holoscript
+ * avatar#player @locomotion(style: "realistic", root_motion: true) {
+ *   walk_speed: 1.4
+ *   run_speed: 5.0
+ * }
+ * ```
+ */
+interface LocomotionTrait {
+  /** Movement style */
+  style?: 'realistic' | 'stylized' | 'robotic' | 'floaty' | 'heavy';
+  /** Use root motion from animations */
+  root_motion?: boolean;
+  /** Walking speed (m/s) */
+  walk_speed?: number;
+  /** Running speed (m/s) */
+  run_speed?: number;
+  /** Jump height (m) */
+  jump_height?: number;
+  /** Turn speed (degrees/second) */
+  turn_speed?: number;
+  /** Acceleration */
+  acceleration?: number;
+  /** Enable procedural foot placement (IK) */
+  foot_ik?: boolean;
+  /** Terrain adaptation */
+  terrain_adaptation?: boolean;
+  /** Idle animations */
+  idle_variations?: number;
+  /** Breathing motion in idle */
+  idle_breathing?: boolean;
+  /** Weight shift in idle */
+  weight_shift?: boolean;
+  /** Stamina system */
+  stamina?: {
+    max?: number;
+    drain_rate?: number;
+    recovery_rate?: number;
+  };
+}
+
+/**
+ * @poseable - Manual posing system for characters
+ *
+ * @example
+ * ```holoscript
+ * avatar#model @poseable(mode: "ik", snap_to_presets: true) {
+ *   @on_pose_save(pose) => save_to_library(pose)
+ * }
+ * ```
+ */
+interface PoseableTrait {
+  /** Posing mode */
+  mode?: 'fk' | 'ik' | 'hybrid';
+  /** Enable preset pose snapping */
+  snap_to_presets?: boolean;
+  /** Preset poses available */
+  presets?: string[];
+  /** Symmetry posing */
+  symmetry?: boolean;
+  /** Pin/lock specific bones */
+  pinned_bones?: string[];
+  /** Enable physics preview */
+  physics_preview?: boolean;
+  /** Pose blending between presets */
+  blend_enabled?: boolean;
+  /** Save custom poses */
+  custom_poses?: Record<string, unknown>;
+}
+
+/**
+ * @morph - Shape morphing and body customization
+ *
+ * @example
+ * ```holoscript
+ * avatar#custom @morph(targets: ["body_shape", "face_detail"]) {
+ *   @on_morph_change(target, value) => update_avatar(target, value)
+ * }
+ * ```
+ */
+interface MorphTrait {
+  /** Available morph targets */
+  targets?: string[];
+  /** Morph target values (0-1) */
+  values?: Record<string, number>;
+  /** Morph presets */
+  presets?: Record<string, Record<string, number>>;
+  /** Enable real-time preview */
+  realtime_preview?: boolean;
+  /** Morph transition speed */
+  transition_speed?: number;
+  /** Clamp values to valid ranges */
+  clamp_values?: boolean;
+  /** Linked morphs (one affects another) */
+  linked_morphs?: Record<string, string[]>;
+}
+
+interface NetworkedTrait {
+  sync_mode?: 'reliable' | 'unreliable' | 'state-only';
+  authority?: 'client' | 'server' | 'owner';
+  sync_interval?: number;
+  interpolated?: boolean;
+}
+
+interface ProactiveTrait {
+  intelligence_tier?: 'basic' | 'advanced' | 'quantum';
+  observation_range?: number;
+  learning_rate?: number;
+  auto_suggest?: boolean;
+  context_window?: number;
+}
+
+/**
+ * State Management
+ */
+interface StateDeclaration {
+  [key: string]: unknown;
+}
+
+interface ReactiveState$1<T extends StateDeclaration> {
+  get<K extends keyof T>(key: K): T[K];
+  set<K extends keyof T>(key: K, value: T[K]): void;
+  subscribe(callback: (state: T) => void): () => void;
+}
+
+/**
+ * Lifecycle Hooks
+ */
+type LifecycleHook = 'on_mount' | 'on_unmount' | 'on_update' | 'on_data_update';
+type VRLifecycleHook = 'on_grab' | 'on_release' | 'on_hover_enter' | 'on_hover_exit' | 'on_point_enter' | 'on_point_exit' | 'on_collision' | 'on_trigger_enter' | 'on_trigger_exit' | 'on_click' | 'on_double_click';
+type ControllerHook = 'on_controller_button' | 'on_trigger_hold' | 'on_trigger_release' | 'on_grip_hold' | 'on_grip_release';
+
+// Media Production Hooks
+type MediaLifecycleHook = 'on_record_start' | 'on_record_stop' | 'on_record_pause' | 'on_stream_start' | 'on_stream_stop' | 'on_viewer_join' | 'on_viewer_leave' | 'on_chat_message' | 'on_camera_switch' | 'on_video_end' | 'on_video_error';
+
+// Analytics Hooks
+type AnalyticsLifecycleHook = 'on_track_event' | 'on_survey_start' | 'on_survey_complete' | 'on_survey_skip' | 'on_variant_assigned' | 'on_conversion' | 'on_hotspot_detected';
+
+// Social Hooks
+type SocialLifecycleHook = 'on_share' | 'on_share_complete' | 'on_embed' | 'on_scan' | 'on_user_join' | 'on_user_leave' | 'on_draw_stroke' | 'on_object_lock' | 'on_object_unlock';
+
+// Effects Hooks
+type EffectsLifecycleHook = 'on_particle_spawn' | 'on_particle_death' | 'on_transition_start' | 'on_transition_complete' | 'on_filter_change';
+
+// Audio Hooks
+type AudioLifecycleHook = 'on_audio_start' | 'on_audio_end' | 'on_voice_command' | 'on_speech_start' | 'on_speech_end' | 'on_beat' | 'on_frequency_peak';
+
+// AI Hooks
+type AILifecycleHook = 'on_narration_start' | 'on_narration_end' | 'on_user_question' | 'on_response_ready' | 'on_emotion_change' | 'on_generation_complete';
+
+// Timeline Hooks
+type TimelineLifecycleHook = 'on_timeline_start' | 'on_timeline_complete' | 'on_keyframe_hit' | 'on_keyframe_add' | 'on_beat_sync' | 'on_move_complete';
+
+// Combined hook type for all lifecycle hooks
+type AllLifecycleHooks =
+  | LifecycleHook
+  | VRLifecycleHook
+  | ControllerHook
+  | MediaLifecycleHook
+  | AnalyticsLifecycleHook
+  | SocialLifecycleHook
+  | EffectsLifecycleHook
+  | AudioLifecycleHook
+  | AILifecycleHook
+  | TimelineLifecycleHook;
+
+/**
+ * AST Node Types
+ */
+type HSPlusDirective =
+  | { type: 'state'; body: StateDeclaration }
+  | { type: 'for'; variable: string; iterable: string; body: HSPlusNode[] }
+  | { type: 'if'; condition: string; body: HSPlusNode[]; else?: HSPlusNode[] }
+  | { type: 'import'; path: string; alias: string }
+  | { type: 'lifecycle'; hook: AllLifecycleHooks; params?: string[]; body: string }
+  | { type: 'trait'; name: VRTraitName$1; config: Record<string, unknown> }
+  | { type: 'external_api'; url: string; method?: string; interval?: string }
+  | { type: 'generate'; prompt: string; context?: string; target?: string };
+
+type VRTraitName$1 =
+  // Core VR Interaction Traits
+  | 'grabbable'
+  | 'throwable'
+  | 'pointable'
+  | 'hoverable'
+  | 'scalable'
+  | 'rotatable'
+  | 'stackable'
+  | 'snappable'
+  | 'breakable'
+  | 'stretchable'
+  | 'moldable'
+  // Humanoid/Avatar Traits
+  | 'skeleton'
+  | 'body'
+  | 'face'
+  | 'expressive'
+  | 'hair'
+  | 'clothing'
+  | 'hands'
+  | 'character_voice'
+  | 'locomotion'
+  | 'poseable'
+  | 'morph'
+  | 'networked'
+  | 'proactive'
+  // Media Production Traits
+  | 'recordable'
+  | 'streamable'
+  | 'camera'
+  | 'video'
+  // Analytics & Research Traits
+  | 'trackable'
+  | 'survey'
+  | 'abtest'
+  | 'heatmap'
+  // Social & Viral Traits
+  | 'shareable'
+  | 'embeddable'
+  | 'qr'
+  | 'collaborative'
+  // Effects Traits
+  | 'particle'
+  | 'transition'
+  | 'filter'
+  | 'trail'
+  // Audio Traits
+  | 'spatial_audio'
+  | 'voice'
+  | 'reactive_audio'
+  // AI & Generative Traits
+  | 'narrator'
+  | 'responsive'
+  | 'procedural'
+  | 'captioned'
+  // Timeline & Choreography Traits
+  | 'timeline'
+  | 'choreography';
+
+interface HSPlusNode {
+  type: string;
+  id?: string;
+  properties: Record<string, unknown>;
+  directives: HSPlusDirective[];
+  children: HSPlusNode[];
+  traits: Map<VRTraitName$1, unknown>;
+  loc?: {
+    start: { line: number; column: number };
+    end: { line: number; column: number };
+  };
+}
+
+interface HSPlusAST {
+  version: '1.0';
+  root: HSPlusNode;
+  imports: Array<{ path: string; alias: string }>;
+  hasState: boolean;
+  hasVRTraits: boolean;
+  hasControlFlow: boolean;
+}
+
+// Supporting types for builtins
+interface RecordingClip {
+  id: string;
+  duration: number;
+  format: string;
+  url: string;
+  thumbnail?: string;
+}
+
+interface ShareContent {
+  title?: string;
+  description?: string;
+  url?: string;
+  media?: string;
+}
+
+interface ShareResult {
+  success: boolean;
+  platform: string;
+  shareUrl?: string;
+  error?: string;
+}
+
+interface ParticleConfig {
+  type: string;
+  rate?: number;
+  color?: Color$1 | Color$1[];
+  size?: number;
+  lifetime?: number;
+}
+
+interface HSPlusRuntime {
+  mount: (container: unknown) => void;
+  unmount: () => void;
+  updateData: (data: unknown) => void;
+  getState: () => StateDeclaration;
+  setState: (updates: Partial<StateDeclaration>) => void;
+  emit: (event: string, payload?: unknown) => void;
+  updateEntity: (id: string, properties: Partial<Record<string, unknown>>) => boolean;
+  on: (event: string, handler: (payload: unknown) => void) => () => void;
+}
+
+/**
+ * HoloScript 2D Parser Extension
+ *
+ * Adds support for 2D UI elements to HoloScript for desktop/mobile apps.
+ * Works alongside 3D VR syntax for hybrid applications.
+ */
+
+declare class HoloScript2DParser {
+    private uiElements;
+    /**
+     * Parse 2D UI element from HoloScript code
+     */
+    parse2DElement(code: string, depth?: number): UI2DNode | null;
+    private splitIntoLogicalBlocks;
+    /**
+     * Parse voice command for 2D UI creation
+     */
+    parse2DVoiceCommand(command: string): UI2DNode | null;
+    /**
+     * Parse gesture for 2D UI interaction
+     */
+    parse2DGesture(gestureType: string, position: Position2D): UI2DNode | null;
+    private createQuick2DElement;
+    private isValidUIElementType;
+    private parsePropertyValue;
+    private getDefaultProperties;
+    getUIElements(): Map<string, UI2DNode>;
+    findElement(name: string): UI2DNode | null;
+    clear(): void;
+}
+
+/**
+ * HoloScript Parser
+ *
+ * Parses voice commands, gestures, and code into HoloScript AST.
+ * Supports both 3D VR and 2D UI elements.
+ */
+
+declare class HoloScriptParser {
+    private ast;
+    private parser2D;
+    constructor();
+    /**
+     * Parse voice command into AST nodes
+     */
+    parseVoiceCommand(command: VoiceCommand$1): ASTNode[];
+    private parse2DUICommand;
+    /**
+     * Parse gesture input
+     */
+    parseGesture(gesture: GestureData): ASTNode[];
+    private parseCreateCommand;
+    private parseConnectCommand;
+    private createOrbNode;
+    private createFunctionNode;
+    private createGateNode;
+    private createStreamNode;
+    private createGenericNode;
+    private createServerNode;
+    private createDatabaseNode;
+    private createFetchNode;
+    private parsePinchGesture;
+    private parseSwipeGesture;
+    private parseRotateGesture;
+    private parseGrabGesture;
+    private tokenizeCommand;
+    private sanitizeTokens;
+    private parseExecuteCommand;
+    private parseDebugCommand;
+    private parseVisualizeCommand;
+    private parseGenericCommand;
+    private parseComposition;
+    private parseEnvironment;
+    private parseTemplate;
+    private parseGlobalHandler;
+    private parseScale;
+    private parseFocus;
+    private parseStateDirective;
+    private extractDirectives;
+    private isTrait;
+    private isLifecycleHook;
+    private parseLiteral;
+    private parseProperties;
+    private findClosingBrace;
+    getAST(): ASTNode[];
+    addNode(node: ASTNode): void;
+    clear(): void;
+    findNode(name: string): ASTNode | null;
+    getNodesAtPosition(position: SpatialPosition, radius?: number): ASTNode[];
+    parse2DCode(code: string): UI2DNode | null;
+    get2DParser(): HoloScript2DParser;
+}
+
+declare const VR_TRAITS: readonly ["grabbable", "throwable", "pointable", "hoverable", "scalable", "rotatable", "stackable", "snappable", "breakable", "stretchable", "moldable", "skeleton", "body", "face", "expressive", "hair", "clothing", "hands", "character_voice", "locomotion", "poseable", "morph", "networked", "proactive", "recordable", "streamable", "camera", "video", "trackable", "survey", "abtest", "heatmap", "shareable", "embeddable", "qr", "collaborative", "particle", "transition", "filter", "trail", "spatial_audio", "voice", "reactive_audio", "narrator", "responsive", "procedural", "captioned", "timeline", "choreography"];
+type VRTraitName = typeof VR_TRAITS[number];
+declare const LIFECYCLE_HOOKS: readonly ["on_mount", "on_unmount", "on_update", "on_data_update", "on_grab", "on_release", "on_hover_enter", "on_hover_exit", "on_point_enter", "on_point_exit", "on_collision", "on_trigger_enter", "on_trigger_exit", "on_click", "on_double_click", "on_controller_button", "on_trigger_hold", "on_trigger_release", "on_grip_hold", "on_grip_release", "on_stretch", "on_sculpt", "on_pose_change", "on_expression_change", "on_gesture", "on_speak", "on_pose_save", "on_morph_change", "on_record_start", "on_record_stop", "on_record_pause", "on_stream_start", "on_stream_stop", "on_viewer_join", "on_viewer_leave", "on_chat_message", "on_camera_switch", "on_video_end", "on_video_error", "on_track_event", "on_survey_start", "on_survey_complete", "on_survey_skip", "on_variant_assigned", "on_conversion", "on_hotspot_detected", "on_share", "on_share_complete", "on_embed", "on_scan", "on_user_join", "on_user_leave", "on_draw_stroke", "on_object_lock", "on_object_unlock", "on_particle_spawn", "on_particle_death", "on_transition_start", "on_transition_complete", "on_filter_change", "on_audio_start", "on_audio_end", "on_voice_command", "on_speech_start", "on_speech_end", "on_beat", "on_frequency_peak", "on_narration_start", "on_narration_end", "on_user_question", "on_response_ready", "on_emotion_change", "on_generation_complete", "on_timeline_start", "on_timeline_complete", "on_keyframe_hit", "on_keyframe_add", "on_beat_sync", "on_move_complete"];
+type LifecycleHookName = typeof LIFECYCLE_HOOKS[number];
+
+/**
+ * HoloScript Validator
+ * Performs static analysis on HoloScript code to detect syntax and semantic errors.
+ */
+interface ValidationError {
+    line: number;
+    column: number;
+    message: string;
+    severity: 'error' | 'warning';
+}
+declare class HoloScriptValidator {
+    private parser;
+    private static VALID_DIRECTIVES;
+    private static VALID_KEYWORDS;
+    constructor();
+    /**
+     * Validates source code and returns a list of errors.
+     */
+    validate(code: string): ValidationError[];
+}
+
+interface HSPlusCompileResult {
+    success: boolean;
+    code?: string;
+    sourceMap?: any;
+    errors: Array<{
+        message: string;
+        line: number;
+        column: number;
+    }>;
+    ast?: any;
+    compiledExpressions?: any;
+    requiredCompanions?: string[];
+    features?: any;
+    warnings?: any[];
+    [key: string]: any;
+}
+interface HSPlusParserOptions {
+    sourceMap?: boolean;
+    strict?: boolean;
+    enableTypeScriptImports?: boolean;
+    enableVRTraits?: boolean;
+}
+
+/**
+ * HoloScript+ Parser
+ *
+ * Parses HoloScript+ source code into an AST with support for:
+ * - Standard HoloScript syntax (backward compatible)
+ * - @ directive parsing for VR traits, state, control flow
+ * - Expression interpolation with ${...}
+ * - TypeScript companion imports
+ *
+ * @version 1.0.0
+ */
+
+declare class HoloScriptPlusParser$1 {
+    private tokens;
+    private pos;
+    private options;
+    private errors;
+    private warnings;
+    private imports;
+    private hasState;
+    private hasVRTraits;
+    private hasControlFlow;
+    private compiledExpressions;
+    constructor(options?: HSPlusParserOptions);
+    parse(source: string): HSPlusCompileResult;
+    private parseDocument;
+    private parseNode;
+    private parseDirective;
+    private parsePropsBlock;
+    private parseDialogBlock;
+    private parseTraitConfig;
+    private parseStateBlock;
+    private parseControlFlowBody;
+    private parseCodeBlock;
+    private parseInlineExpression;
+    private parseValue;
+    private parseArray;
+    private parseObject;
+    private current;
+    private check;
+    private advance;
+    private expect;
+    private skipNewlines;
+    private error;
+    private warn;
+}
+declare function createParser(options?: HSPlusParserOptions): HoloScriptPlusParser$1;
+declare function parse(source: string, options?: HSPlusParserOptions): HSPlusCompileResult;
+
+/**
+ * @holoscript/core Material Trait
+ *
+ * Enables advanced material and shader properties for photorealistic rendering
+ * Supports PBR (Physically Based Rendering) workflows
+ */
+type MaterialType = 'pbr' | 'standard' | 'unlit' | 'transparent' | 'custom';
+type TextureChannel = 'baseColor' | 'normalMap' | 'roughnessMap' | 'metallicMap' | 'ambientOcclusionMap' | 'emissionMap' | 'heightMap';
+/**
+ * Texture map configuration
+ */
+interface TextureMap {
+    /** Texture path or URL */
+    path: string;
+    /** Channel this texture maps to */
+    channel: TextureChannel;
+    /** UV scale (tiling) */
+    scale?: {
+        x: number;
+        y: number;
+    };
+    /** UV offset */
+    offset?: {
+        x: number;
+        y: number;
+    };
+    /** Texture filtering: linear, nearest, anisotropic */
+    filter?: 'linear' | 'nearest' | 'anisotropic';
+    /** Anisotropic level (1-16) */
+    anisotropy?: number;
+}
+/**
+ * PBR Material properties
+ */
+interface PBRMaterial {
+    /** Base color in linear space [0-1] */
+    baseColor: {
+        r: number;
+        g: number;
+        b: number;
+        a?: number;
+    };
+    /** Metallic value 0-1 */
+    metallic: number;
+    /** Roughness value 0-1 */
+    roughness: number;
+    /** Ambient occlusion 0-1 */
+    ambientOcclusion?: number;
+    /** Emission color and intensity */
+    emission?: {
+        color: {
+            r: number;
+            g: number;
+            b: number;
+        };
+        intensity: number;
+    };
+    /** Normal map strength */
+    normalStrength?: number;
+    /** Parallax/height map strength */
+    parallaxHeight?: number;
+    /** Index of refraction for transmission */
+    ior?: number;
+    /** Transmission amount for transparent materials */
+    transmission?: number;
+}
+/**
+ * Material configuration
+ */
+interface MaterialConfig {
+    /** Material type */
+    type: MaterialType;
+    /** Material name for reuse */
+    name?: string;
+    /** PBR properties (for PBR materials) */
+    pbr?: PBRMaterial;
+    /** Texture maps */
+    textures?: TextureMap[];
+    /** Double-sided rendering */
+    doubleSided?: boolean;
+    /** Blend mode for transparency */
+    blendMode?: 'opaque' | 'blend' | 'additive' | 'multiply';
+    /** Custom shader code/reference */
+    customShader?: {
+        vertex?: string;
+        fragment?: string;
+        shaderLanguage?: 'glsl' | 'hlsl' | 'shadergraph';
+    };
+    /** GPU memory optimization hints */
+    optimization?: {
+        /** Stream textures if needed */
+        streamTextures?: boolean;
+        /** Compress textures */
+        compression?: 'none' | 'dxt' | 'astc' | 'basis';
+        /** Instance this material */
+        instanced?: boolean;
+        /** LOD bias for texture streaming */
+        lodBias?: number;
+    };
+}
+/**
+ * MaterialTrait - Enables photorealistic material rendering
+ */
+declare class MaterialTrait {
+    private material;
+    private textureCache;
+    constructor(config: MaterialConfig);
+    /**
+     * Get material properties
+     */
+    getMaterial(): MaterialConfig;
+    /**
+     * Update material property
+     */
+    setProperty<K extends keyof MaterialConfig>(key: K, value: MaterialConfig[K]): void;
+    /**
+     * Get PBR properties
+     */
+    getPBRProperties(): PBRMaterial | undefined;
+    /**
+     * Update PBR material
+     */
+    updatePBR(pbr: Partial<PBRMaterial>): void;
+    /**
+     * Add texture map
+     */
+    addTexture(texture: TextureMap): void;
+    /**
+     * Get all textures
+     */
+    getTextures(): TextureMap[];
+    /**
+     * Clear texture cache (for memory optimization)
+     */
+    clearTextureCache(): void;
+    /**
+     * Get shader code if custom
+     */
+    getCustomShader(): {
+        vertex?: string;
+        fragment?: string;
+        shaderLanguage?: "glsl" | "hlsl" | "shadergraph";
+    } | undefined;
+    /**
+     * Set custom shader
+     */
+    setCustomShader(shader: MaterialConfig['customShader']): void;
+    /**
+     * Get optimization hints
+     */
+    getOptimization(): MaterialConfig['optimization'];
+    /**
+     * Enable/disable texture streaming
+     */
+    setTextureStreaming(enabled: boolean): void;
+    /**
+     * Set texture compression
+     */
+    setCompression(compression: 'none' | 'dxt' | 'astc' | 'basis'): void;
+    /**
+     * Enable material instancing for performance
+     */
+    setInstanced(instanced: boolean): void;
+    /**
+     * Dispose and cleanup
+     */
+    dispose(): void;
+}
+/**
+ * HoloScript+ @material trait factory
+ */
+declare function createMaterialTrait(config: MaterialConfig): MaterialTrait;
+/**
+ * Preset materials for common use cases
+ */
+declare const MATERIAL_PRESETS: {
+    /** Shiny metal */
+    chrome: () => MaterialConfig;
+    /** Rough plastic */
+    plastic: () => MaterialConfig;
+    /** Wood texture */
+    wood: () => MaterialConfig;
+    /** Glass */
+    glass: () => MaterialConfig;
+    /** Emissive (glowing) */
+    emissive: () => MaterialConfig;
+    /** Skin material */
+    skin: () => MaterialConfig;
+};
+
+/**
+ * @holoscript/core Lighting Trait
+ *
+ * Enables dynamic lighting with support for multiple light types,
+ * shadows, and global illumination
+ */
+type LightType = 'directional' | 'point' | 'spot' | 'area' | 'probe';
+type ShadowType = 'none' | 'hard' | 'soft' | 'raytraced';
+/**
+ * Color definition
+ */
+interface Color {
+    r: number;
+    g: number;
+    b: number;
+    a?: number;
+}
+/**
+ * Vector3 position or direction
+ */
+interface Vector3 {
+    x: number;
+    y: number;
+    z: number;
+}
+/**
+ * Shadow configuration
+ */
+interface ShadowConfig {
+    /** Shadow type */
+    type: ShadowType;
+    /** Shadow map resolution */
+    resolution?: number;
+    /** Shadow bias to prevent artifacts */
+    bias?: number;
+    /** Softness/blur radius */
+    softness?: number;
+    /** Max shadow distance */
+    maxDistance?: number;
+    /** Cascade levels for directional lights */
+    cascades?: number;
+}
+/**
+ * Light source definition
+ */
+interface LightSource {
+    /** Light type */
+    type: LightType;
+    /** Light name */
+    name?: string;
+    /** Position in world space */
+    position?: Vector3;
+    /** Direction (for directional/spot) */
+    direction?: Vector3;
+    /** Color */
+    color: Color;
+    /** Intensity/brightness 0-1+ */
+    intensity: number;
+    /** Attenuation range (point/spot) */
+    range?: number;
+    /** Spot angle in degrees */
+    spotAngle?: number;
+    /** Inner spot angle */
+    innerSpotAngle?: number;
+    /** Shadow configuration */
+    shadow?: ShadowConfig;
+    /** Light cookie/projection */
+    cookie?: string;
+    /** Enable volumetric fog interaction */
+    volumetric?: boolean;
+    /** Light priority for batching */
+    priority?: number;
+}
+/**
+ * Global illumination configuration
+ */
+interface GlobalIlluminationConfig {
+    /** Enable global illumination */
+    enabled: boolean;
+    /** Intensity multiplier */
+    intensity?: number;
+    /** Sky color for ambient light */
+    skyColor?: Color;
+    /** Sky intensity */
+    skyIntensity?: number;
+    /** Ground color for ambient light */
+    groundColor?: Color;
+    /** Ground intensity */
+    groundIntensity?: number;
+    /** Use light probes */
+    probes?: boolean;
+    /** Indirect diffuse intensity */
+    indirectDiffuse?: number;
+    /** Indirect specular intensity */
+    indirectSpecular?: number;
+    /** Ambient occlusion intensity */
+    aoIntensity?: number;
+    /** Use screen-space AO */
+    screenSpaceAO?: boolean;
+}
+/**
+ * LightingTrait - Manages dynamic lighting and illumination
+ */
+declare class LightingTrait {
+    private lights;
+    private globalIllumination;
+    private lightIdCounter;
+    constructor(config?: GlobalIlluminationConfig);
+    /**
+     * Add a light to the scene
+     */
+    addLight(light: LightSource): string;
+    /**
+     * Get light by ID
+     */
+    getLight(id: string): LightSource | undefined;
+    /**
+     * Get all lights
+     */
+    getLights(): LightSource[];
+    /**
+     * Get lights by type
+     */
+    getLightsByType(type: LightType): LightSource[];
+    /**
+     * Update light properties
+     */
+    updateLight(id: string, updates: Partial<LightSource>): boolean;
+    /**
+     * Remove light
+     */
+    removeLight(id: string): boolean;
+    /**
+     * Clear all lights
+     */
+    clearLights(): void;
+    /**
+     * Get global illumination config
+     */
+    getGlobalIllumination(): GlobalIlluminationConfig;
+    /**
+     * Update global illumination
+     */
+    updateGlobalIllumination(updates: Partial<GlobalIlluminationConfig>): void;
+    /**
+     * Enable/disable GI
+     */
+    setGIEnabled(enabled: boolean): void;
+    /**
+     * Set ambient light colors (skybox mode)
+     */
+    setAmbientLight(skyColor: Color, groundColor: Color, intensity?: number): void;
+    /**
+     * Enable/disable screen-space ambient occlusion
+     */
+    setScreenSpaceAO(enabled: boolean, intensity?: number): void;
+    /**
+     * Create directional light (sun)
+     */
+    createDirectionalLight(direction: Vector3, color: Color, intensity?: number, castShadows?: boolean): string;
+    /**
+     * Create point light
+     */
+    createPointLight(position: Vector3, color: Color, intensity: number, range: number, castShadows?: boolean): string;
+    /**
+     * Create spot light
+     */
+    createSpotLight(position: Vector3, direction: Vector3, color: Color, intensity: number, range: number, spotAngle?: number, castShadows?: boolean): string;
+    /**
+     * Create area light for soft lighting
+     */
+    createAreaLight(position: Vector3, color: Color, intensity: number, width: number, height: number): string;
+    /**
+     * Get shadow-casting lights
+     */
+    getShadowCastingLights(): LightSource[];
+    /**
+     * Get light count by type
+     */
+    getLightCount(): {
+        [key in LightType]: number;
+    };
+    /**
+     * Estimate light impact for performance optimization
+     */
+    getPerformanceImpact(): {
+        totalLights: number;
+        shadowCasters: number;
+        estimatedGPUCost: 'low' | 'medium' | 'high';
+    };
+    /**
+     * Get scene complexity info
+     */
+    getSceneInfo(): string;
+    /**
+     * Dispose and cleanup
+     */
+    dispose(): void;
+}
+/**
+ * HoloScript+ @lighting trait factory
+ */
+declare function createLightingTrait(config?: GlobalIlluminationConfig): LightingTrait;
+/**
+ * Preset lighting configurations
+ */
+declare const LIGHTING_PRESETS: {
+    /** Neutral studio lighting */
+    studio: () => GlobalIlluminationConfig;
+    /** Bright outdoor lighting */
+    outdoor: () => GlobalIlluminationConfig;
+    /** Dim interior lighting */
+    interior: () => GlobalIlluminationConfig;
+    /** Night scene */
+    night: () => GlobalIlluminationConfig;
+    /** Sunset/golden hour */
+    sunset: () => GlobalIlluminationConfig;
+};
+
+/**
+ * @holoscript/core Rendering Trait
+ *
+ * Enables GPU optimization directives, level of detail management,
+ * and rendering performance tuning
+ */
+type CullingMode = 'none' | 'back' | 'front' | 'both';
+type LodStrategy = 'automatic' | 'manual' | 'disabled';
+type GPUResourceTier = 'low' | 'medium' | 'high' | 'ultra';
+/**
+ * Level of Detail configuration
+ */
+interface LODLevel {
+    /** LOD level (0 = highest detail) */
+    level: number;
+    /** Screen-relative size threshold for this LOD */
+    screenRelativeSize: number;
+    /** Polygon reduction ratio (0-1) */
+    polygonReduction?: number;
+    /** Disable features at this LOD */
+    disabledFeatures?: ('shadows' | 'normals' | 'specular' | 'animation')[];
+    /** Texture resolution multiplier (0.25 = 1/4 resolution) */
+    textureScale?: number;
+}
+/**
+ * Culling configuration
+ */
+interface CullingConfig {
+    /** Face culling mode */
+    mode: CullingMode;
+    /** Frustum culling */
+    frustum?: boolean;
+    /** Occlusion culling */
+    occlusion?: boolean;
+    /** Occlusion query distance in units */
+    occlusionDistance?: number;
+    /** Hierarchical Z-buffer culling */
+    hierarchicalZ?: boolean;
+}
+/**
+ * Batching configuration
+ */
+interface BatchingConfig {
+    /** Static batching (for non-moving objects) */
+    static?: boolean;
+    /** Dynamic batching */
+    dynamic?: boolean;
+    /** Max batch size in vertices */
+    maxBatchSize?: number;
+    /** GPU instancing */
+    instancing?: boolean;
+    /** Instancing buffer size */
+    maxInstanceCount?: number;
+}
+/**
+ * Texture optimization
+ */
+interface TextureOptimization {
+    /** Enable texture streaming */
+    streaming?: boolean;
+    /** Streaming budget in MB */
+    streamingBudget?: number;
+    /** Virtual texture paging */
+    virtualTexturing?: boolean;
+    /** Texture compression */
+    compression?: 'none' | 'dxt' | 'astc' | 'basis' | 'auto';
+    /** Mipmap generation */
+    mipmaps?: boolean;
+    /** Max texture resolution */
+    maxResolution?: 256 | 512 | 1024 | 2048 | 4096;
+}
+/**
+ * Shader optimization
+ */
+interface ShaderOptimization {
+    /** Shader LOD bias */
+    lodBias?: number;
+    /** Use simplified shaders for distant objects */
+    simplifiedShaders?: boolean;
+    /** Compile shader variants for performance */
+    variants?: {
+        [key: string]: {
+            enabled: boolean;
+            cost?: 'low' | 'medium' | 'high';
+        };
+    };
+}
+/**
+ * Rendering optimization hints
+ */
+interface RenderingOptimization {
+    /** LOD strategy */
+    lodStrategy?: LodStrategy;
+    /** LOD levels */
+    lodLevels?: LODLevel[];
+    /** Culling configuration */
+    culling?: CullingConfig;
+    /** Batching configuration */
+    batching?: BatchingConfig;
+    /** Texture optimization */
+    textures?: TextureOptimization;
+    /** Shader optimization */
+    shaders?: ShaderOptimization;
+    /** Target GPU tier */
+    targetGPUTier?: GPUResourceTier;
+    /** Fixed time-step rendering (for VR/AR) */
+    fixedTimestep?: number;
+    /** Enable adaptive quality */
+    adaptiveQuality?: boolean;
+    /** Target frame rate */
+    targetFrameRate?: number;
+}
+/**
+ * RenderingTrait - Manages GPU optimization and rendering performance
+ */
+declare class RenderingTrait {
+    private optimization;
+    constructor(config?: RenderingOptimization);
+    /**
+     * Get rendering optimization config
+     */
+    getOptimization(): RenderingOptimization;
+    /**
+     * Update rendering configuration
+     */
+    updateOptimization(updates: Partial<RenderingOptimization>): void;
+    /**
+     * Setup LOD levels (3 levels is typical)
+     */
+    setupLODLevels(strategy?: LodStrategy): void;
+    /**
+     * Get LOD levels
+     */
+    getLODLevels(): LODLevel[];
+    /**
+     * Configure culling
+     */
+    setCulling(config: Partial<CullingConfig>): void;
+    /**
+     * Enable frustum culling
+     */
+    setFrustumCulling(enabled: boolean): void;
+    /**
+     * Enable occlusion culling
+     */
+    setOcclusionCulling(enabled: boolean, distance?: number): void;
+    /**
+     * Configure batching
+     */
+    setBatching(config: Partial<BatchingConfig>): void;
+    /**
+     * Enable GPU instancing
+     */
+    setInstancing(enabled: boolean, maxInstances?: number): void;
+    /**
+     * Configure texture optimization
+     */
+    setTextureOptimization(config: Partial<TextureOptimization>): void;
+    /**
+     * Enable texture streaming
+     */
+    setTextureStreaming(enabled: boolean, budgetMB?: number): void;
+    /**
+     * Set texture compression
+     */
+    setTextureCompression(compression: 'none' | 'dxt' | 'astc' | 'basis' | 'auto'): void;
+    /**
+     * Set max texture resolution
+     */
+    setMaxTextureResolution(resolution: 256 | 512 | 1024 | 2048 | 4096): void;
+    /**
+     * Configure shader optimization
+     */
+    setShaderOptimization(config: Partial<ShaderOptimization>): void;
+    /**
+     * Set target GPU tier
+     */
+    setTargetGPUTier(tier: GPUResourceTier): void;
+    /**
+     * Enable adaptive quality (adjust based on frame rate)
+     */
+    setAdaptiveQuality(enabled: boolean, targetFrameRate?: number): void;
+    /**
+     * Set fixed timestep for VR/AR
+     */
+    setFixedTimestep(timestep: number): void;
+    /**
+     * Get rendering preset for quality level
+     */
+    getPresetForQuality(quality: 'low' | 'medium' | 'high' | 'ultra'): RenderingOptimization;
+    /**
+     * Apply quality preset
+     */
+    applyQualityPreset(quality: 'low' | 'medium' | 'high' | 'ultra'): void;
+    /**
+     * Estimate GPU memory usage
+     */
+    estimateGPUMemory(): {
+        textureMemory: number;
+        vertexBuffers: number;
+        estimatedTotal: number;
+    };
+    /**
+     * Get rendering statistics/info
+     */
+    getInfo(): string;
+    /**
+     * Optimize for VR/AR (fixed timestep, fast culling)
+     */
+    optimizeForVRAR(targetFPS?: number): void;
+    /**
+     * Optimize for mobile (lower resources)
+     */
+    optimizeForMobile(): void;
+    /**
+     * Optimize for desktop (higher resources)
+     */
+    optimizeForDesktop(): void;
+    /**
+     * Dispose and cleanup
+     */
+    dispose(): void;
+}
+/**
+ * HoloScript+ @rendering trait factory
+ */
+declare function createRenderingTrait(config?: RenderingOptimization): RenderingTrait;
+
+/**
+ * HoloScriptPlus Parser - Extended DSL with Trait Annotations
+ *
+ * Extends HoloScript with support for:
+ * - @material trait annotations for PBR materials
+ * - @lighting trait annotations for dynamic lighting
+ * - @rendering trait annotations for GPU optimization
+ *
+ * Syntax:
+ * orb#sphere {
+ *   @material { type: pbr, metallic: 0.5, roughness: 0.4 }
+ *   @lighting { preset: studio, shadows: true }
+ *   @rendering { quality: high, lod: true }
+ * }
+ */
+
+interface TraitAnnotation {
+    type: 'material' | 'lighting' | 'rendering';
+    config: Record<string, unknown>;
+    line?: number;
+    column?: number;
+}
+interface MaterialTraitAnnotation extends TraitAnnotation {
+    type: 'material';
+    config: {
+        type?: string;
+        pbr?: {
+            baseColor?: {
+                r: number;
+                g: number;
+                b: number;
+            };
+            metallic?: number;
+            roughness?: number;
+            ambientOcclusion?: number;
+            emission?: {
+                r: number;
+                g: number;
+                b: number;
+            };
+            emissionStrength?: number;
+        };
+        textures?: Array<{
+            path: string;
+            channel: string;
+        }>;
+        compression?: 'none' | 'dxt' | 'astc' | 'basis';
+        instancing?: boolean;
+        streaming?: boolean;
+    };
+}
+interface LightingTraitAnnotation extends TraitAnnotation {
+    type: 'lighting';
+    config: {
+        preset?: 'studio' | 'outdoor' | 'interior' | 'night' | 'sunset';
+        lights?: Array<{
+            type: 'directional' | 'point' | 'spot' | 'area' | 'ambient';
+            position?: {
+                x: number;
+                y: number;
+                z: number;
+            };
+            direction?: {
+                x: number;
+                y: number;
+                z: number;
+            };
+            color?: {
+                r: number;
+                g: number;
+                b: number;
+            };
+            intensity?: number;
+            range?: number;
+            shadows?: boolean;
+        }>;
+        globalIllumination?: {
+            skyColor?: {
+                r: number;
+                g: number;
+                b: number;
+            };
+            groundColor?: {
+                r: number;
+                g: number;
+                b: number;
+            };
+            probes?: number;
+        };
+        shadows?: boolean;
+        ao?: boolean;
+    };
+}
+interface RenderingTraitAnnotation extends TraitAnnotation {
+    type: 'rendering';
+    config: {
+        quality?: 'low' | 'medium' | 'high' | 'ultra';
+        platform?: 'mobile' | 'vr' | 'desktop';
+        lod?: boolean;
+        culling?: boolean;
+        batching?: boolean;
+        instancing?: boolean;
+        maxTextureResolution?: number;
+        compression?: 'none' | 'dxt' | 'astc' | 'basis';
+        targetFPS?: number;
+    };
+}
+type AnyTraitAnnotation = MaterialTraitAnnotation | LightingTraitAnnotation | RenderingTraitAnnotation;
+interface GraphicsConfiguration {
+    material?: MaterialTraitAnnotation['config'];
+    lighting?: LightingTraitAnnotation['config'];
+    rendering?: RenderingTraitAnnotation['config'];
+}
+declare class HoloScriptPlusParser {
+    private baseParser;
+    constructor();
+    /**
+     * Parse HoloScript+ code with trait annotations
+     */
+    parse(code: string): ASTNode[];
+    /**
+     * Enhance AST nodes with trait annotations
+     */
+    private enhanceWithTraits;
+    /**
+     * Enhance OrbNode with trait annotations
+     */
+    private enhanceOrbNodeWithTraits;
+    /**
+     * Extract trait annotations from code
+     */
+    extractTraitAnnotations(code: string, _orbLine?: number): AnyTraitAnnotation[];
+    /**
+     * Parse object literal from string
+     * Supports nested objects and arrays
+     */
+    parseObjectLiteral(str: string): Record<string, unknown>;
+    /**
+     * Parse individual values
+     */
+    parseValue(str: string): unknown;
+    /**
+     * Build GraphicsConfiguration from trait annotations
+     */
+    buildGraphicsConfig(traits: AnyTraitAnnotation[]): GraphicsConfiguration;
+    /**
+     * Validate trait annotation configuration
+     */
+    validateTraitAnnotation(trait: AnyTraitAnnotation): {
+        valid: boolean;
+        errors: string[];
+    };
+    /**
+     * Validate material trait configuration
+     */
+    private validateMaterialTrait;
+    /**
+     * Validate lighting trait configuration
+     */
+    private validateLightingTrait;
+    /**
+     * Validate rendering trait configuration
+     */
+    private validateRenderingTrait;
+    /**
+     * Get trait annotations as graphics traits
+     */
+    createGraphicsTraits(config: GraphicsConfiguration): {
+        material: MaterialTrait | null;
+        lighting: LightingTrait | null;
+        rendering: RenderingTrait | null;
+    };
+    /**
+     * Create MaterialTrait from config
+     */
+    private createMaterialTrait;
+    /**
+     * Create LightingTrait from config
+     */
+    private createLightingTrait;
+    /**
+     * Create RenderingTrait from config
+     */
+    private createRenderingTrait;
+}
+
+/**
+ * VR Trait System
+ *
+ * Implements VR interaction traits for HoloScript+ objects:
+ * - @grabbable - Hand grab interactions
+ * - @throwable - Physics-based throwing
+ * - @pointable - Laser pointer interactions
+ * - @hoverable - Hover state and highlights
+ * - @scalable - Two-handed scaling
+ * - @rotatable - Rotation interactions
+ * - @stackable - Stacking behavior
+ * - @snappable - Snap-to-point behavior
+ * - @breakable - Destruction on impact
+ *
+ * @version 1.0.0
+ */
+
+interface TraitHandler<TConfig = unknown> {
+    name: VRTraitName$1;
+    defaultConfig: TConfig;
+    onAttach?: (node: HSPlusNode, config: TConfig, context: TraitContext) => void;
+    onDetach?: (node: HSPlusNode, config: TConfig, context: TraitContext) => void;
+    onUpdate?: (node: HSPlusNode, config: TConfig, context: TraitContext, delta: number) => void;
+    onEvent?: (node: HSPlusNode, config: TConfig, context: TraitContext, event: TraitEvent) => void;
+}
+interface TraitContext {
+    vr: VRContext;
+    physics: PhysicsContext;
+    audio: AudioContext;
+    haptics: HapticsContext;
+    emit: (event: string, payload?: unknown) => void;
+    getState: () => Record<string, unknown>;
+    setState: (updates: Record<string, unknown>) => void;
+    getScaleMultiplier: () => number;
+    setScaleContext: (magnitude: string) => void;
+}
+interface VRContext {
+    hands: {
+        left: VRHand | null;
+        right: VRHand | null;
+    };
+    headset: {
+        position: Vector3$1;
+        rotation: Vector3$1;
+    };
+    getPointerRay: (hand: 'left' | 'right') => {
+        origin: Vector3$1;
+        direction: Vector3$1;
+    } | null;
+    getDominantHand: () => VRHand | null;
+}
+interface PhysicsContext {
+    applyVelocity: (node: HSPlusNode, velocity: Vector3$1) => void;
+    applyAngularVelocity: (node: HSPlusNode, angularVelocity: Vector3$1) => void;
+    setKinematic: (node: HSPlusNode, kinematic: boolean) => void;
+    raycast: (origin: Vector3$1, direction: Vector3$1, maxDistance: number) => RaycastHit | null;
+}
+interface RaycastHit {
+    node: HSPlusNode;
+    point: Vector3$1;
+    normal: Vector3$1;
+    distance: number;
+}
+interface AudioContext {
+    playSound: (source: string, options?: {
+        position?: Vector3$1;
+        volume?: number;
+        spatial?: boolean;
+    }) => void;
+}
+interface HapticsContext {
+    pulse: (hand: 'left' | 'right', intensity: number, duration?: number) => void;
+    rumble: (hand: 'left' | 'right', intensity: number) => void;
+}
+type TraitEvent = {
+    type: 'grab_start';
+    hand: VRHand;
+} | {
+    type: 'grab_end';
+    hand: VRHand;
+    velocity: ThrowVelocity;
+} | {
+    type: 'hover_enter';
+    hand: VRHand;
+} | {
+    type: 'hover_exit';
+    hand: VRHand;
+} | {
+    type: 'point_enter';
+    hand: VRHand;
+} | {
+    type: 'point_exit';
+    hand: VRHand;
+} | {
+    type: 'collision';
+    data: CollisionEvent;
+} | {
+    type: 'trigger_enter';
+    other: HSPlusNode;
+} | {
+    type: 'trigger_exit';
+    other: HSPlusNode;
+} | {
+    type: 'click';
+    hand: VRHand;
+} | {
+    type: 'scale_start';
+    hands: {
+        left: VRHand;
+        right: VRHand;
+    };
+} | {
+    type: 'scale_update';
+    scale: number;
+} | {
+    type: 'scale_end';
+    finalScale: number;
+} | {
+    type: 'rotate_start';
+    hand: VRHand;
+} | {
+    type: 'rotate_update';
+    rotation: Vector3$1;
+} | {
+    type: 'rotate_end';
+    finalRotation: Vector3$1;
+};
+declare class VRTraitRegistry {
+    private handlers;
+    constructor();
+    register<T>(handler: TraitHandler<T>): void;
+    getHandler(name: VRTraitName$1): TraitHandler | undefined;
+    attachTrait(node: HSPlusNode, traitName: VRTraitName$1, config: unknown, context: TraitContext): void;
+    detachTrait(node: HSPlusNode, traitName: VRTraitName$1, context: TraitContext): void;
+    updateTrait(node: HSPlusNode, traitName: VRTraitName$1, context: TraitContext, delta: number): void;
+    handleEvent(node: HSPlusNode, traitName: VRTraitName$1, context: TraitContext, event: TraitEvent): void;
+    updateAllTraits(node: HSPlusNode, context: TraitContext, delta: number): void;
+    handleEventForAllTraits(node: HSPlusNode, context: TraitContext, event: TraitEvent): void;
+}
+
+/**
+ * HoloScript+ Runtime Engine
+ *
+ * Executes parsed HoloScript+ AST with:
+ * - Control flow (@for, @if) evaluation
+ * - Lifecycle hook management
+ * - VR trait integration
+ * - Reactive state binding
+ * - TypeScript companion integration
+ *
+ * @version 1.0.0
+ */
+
+interface RuntimeOptions {
+    renderer?: Renderer;
+    vrEnabled?: boolean;
+    companions?: Record<string, Record<string, (...args: unknown[]) => unknown>>;
+}
+interface Renderer {
+    createElement(type: string, properties: Record<string, unknown>): unknown;
+    updateElement(element: unknown, properties: Record<string, unknown>): void;
+    appendChild(parent: unknown, child: unknown): void;
+    removeChild(parent: unknown, child: unknown): void;
+    destroy(element: unknown): void;
+}
+declare class HoloScriptPlusRuntimeImpl implements HSPlusRuntime {
+    private ast;
+    private options;
+    private state;
+    private evaluator;
+    private builtins;
+    private traitRegistry;
+    private rootInstance;
+    private eventHandlers;
+    private templates;
+    private updateLoopId;
+    private lastUpdateTime;
+    private companions;
+    private networkSync;
+    private mounted;
+    private scaleMultiplier;
+    vrContext: {
+        hands: {
+            left: VRHand | null;
+            right: VRHand | null;
+        };
+        headset: {
+            position: Vector3$1;
+            rotation: Vector3$1;
+        };
+        controllers: {
+            left: unknown;
+            right: unknown;
+        };
+    };
+    constructor(ast: HSPlusAST, options?: RuntimeOptions);
+    private initializeState;
+    private loadImports;
+    mount(container: unknown): void;
+    unmount(): void;
+    private instantiateNode;
+    private processDirectives;
+    private registerLifecycleHandler;
+    private processControlFlow;
+    private cloneNodeWithContext;
+    private interpolateString;
+    private interpolateProperties;
+    private evaluateExpression;
+    private evaluateProperties;
+    private callLifecycle;
+    private startUpdateLoop;
+    private stopUpdateLoop;
+    update(delta: number): void;
+    private updateInstance;
+    private syncAvatarParts;
+    private generatedNodes;
+    private processGenerateDirectives;
+    private apiPollingTimers;
+    private updateExternalApis;
+    private executeExternalApi;
+    private parseDurationToMs;
+    private createTraitContext;
+    private destroyInstance;
+    updateData(data: unknown): void;
+    getState(): StateDeclaration;
+    getVariable(name: string): unknown;
+    setVariable(name: string, value: unknown): void;
+    getContext(): any;
+    reset(): void;
+    updateAnimations(): void;
+    updateParticles(delta: number): void;
+    getHologramStates(): Map<string, any>;
+    setState(updates: Partial<StateDeclaration>): void;
+    emit(event: string, payload?: unknown): void;
+    updateEntity(id: string, properties: Partial<Record<string, unknown>>): boolean;
+    on(event: string, handler: (payload: unknown) => void): () => void;
+    updateVRContext(context: typeof this.vrContext): void;
+    handleVREvent(event: TraitEvent, node: HSPlusNode): void;
+    private findInstance;
+    registerTemplate(name: string, node: HSPlusNode): void;
+    spawnTemplate(name: string, position: Vector3$1): HSPlusNode;
+    destroyNode(node: HSPlusNode): void;
+}
+
+/**
+ * Reactive State System for HoloScript+
+ *
+ * Provides reactive state management with:
+ * - Proxy-based reactivity
+ * - Computed properties
+ * - Effect system for side effects
+ * - Batched updates for performance
+ *
+ * @version 1.0.0
+ */
+
+type Subscriber<T> = (state: T, changedKey?: keyof T) => void;
+type UnsubscribeFunc = () => void;
+type EffectFunc = () => void | (() => void);
+type ComputedFunc<T> = () => T;
+interface EffectOptions {
+    immediate?: boolean;
+    deep?: boolean;
+}
+declare class ReactiveState<T extends StateDeclaration> implements ReactiveState$1<T> {
+    private state;
+    private proxy;
+    private subscribers;
+    private computedCache;
+    private watchCleanups;
+    constructor(initialState: T);
+    get<K extends keyof T>(key: K): T[K];
+    set<K extends keyof T>(key: K, value: T[K]): void;
+    update(updates: Partial<T>): void;
+    subscribe(callback: Subscriber<T>): UnsubscribeFunc;
+    private notifySubscribers;
+    computed<R>(key: string, getter: ComputedFunc<R>): R;
+    watch<K extends keyof T>(key: K, handler: (newValue: T[K], oldValue: T[K]) => void, options?: EffectOptions): UnsubscribeFunc;
+    watchEffect(effect: EffectFunc, _options?: EffectOptions): UnsubscribeFunc;
+    getSnapshot(): T;
+    reset(newState?: T): void;
+    destroy(): void;
+}
+declare function createState<T extends StateDeclaration>(initialState: T): ReactiveState<T>;
+declare function reactive<T extends object>(target: T): T;
+declare function effect(fn: EffectFunc, _options?: EffectOptions): UnsubscribeFunc;
+declare function computed<T>(getter: ComputedFunc<T>): {
+    readonly value: T;
+};
+interface StateBinding<T> {
+    get: () => T;
+    set: (value: T) => void;
+    subscribe: (callback: (value: T) => void) => UnsubscribeFunc;
+}
+declare function bind<T extends StateDeclaration, K extends keyof T>(state: ReactiveState<T>, key: K): StateBinding<T[K]>;
+
+/**
+ * @holoscript/core VoiceInput Trait
+ *
+ * Enables voice-driven interactions for HoloScript+ objects
+ * Integrates speech recognition with confidence-based command parsing
+ */
+type VoiceInputMode = 'continuous' | 'push-to-talk' | 'always-listening';
+type ConfidenceThreshold = number;
+/**
+ * Voice input configuration for HoloScript+ objects
+ */
+interface VoiceInputConfig {
+    /** Speech recognition mode */
+    mode: VoiceInputMode;
+    /** Minimum confidence level (0-1) to trigger command */
+    confidenceThreshold: ConfidenceThreshold;
+    /** Languages supported (BCP 47 codes) */
+    languages?: string[];
+    /** Commands this object responds to */
+    commands?: VoiceCommand[];
+    /** Enable speech-to-text display */
+    showTranscript?: boolean;
+    /** Audio feedback (beep on recognition) */
+    audioFeedback?: boolean;
+    /** Max command processing time (ms) */
+    timeout?: number;
+}
+/**
+ * Voice command definition
+ */
+interface VoiceCommand {
+    /** Primary trigger phrase */
+    phrase: string;
+    /** Alternative phrases (fuzzy matching) */
+    aliases?: string[];
+    /** Confidence threshold for this specific command */
+    confidence?: number;
+    /** Action to execute */
+    action: string;
+    /** Parameters extracted from command */
+    params?: Record<string, string>;
+}
+/**
+ * Voice recognition result
+ */
+interface VoiceRecognitionResult {
+    /** Transcribed text */
+    transcript: string;
+    /** Confidence (0-1) */
+    confidence: number;
+    /** Is final result or interim? */
+    isFinal: boolean;
+    /** Language detected */
+    language: string;
+    /** Matched command if any */
+    matchedCommand?: VoiceCommand;
+    /** Timestamp */
+    timestamp: number;
+}
+/**
+ * Voice input event
+ */
+interface VoiceInputEvent {
+    type: 'start' | 'interim' | 'final' | 'error' | 'timeout';
+    result: VoiceRecognitionResult;
+    hologramId: string;
+}
+/**
+ * VoiceInputTrait - Enables speech recognition on HoloScript+ objects
+ */
+declare class VoiceInputTrait {
+    private config;
+    private recognition;
+    private isListening;
+    private listeners;
+    private interimTranscript;
+    private commandCache;
+    constructor(config: VoiceInputConfig);
+    /**
+     * Initialize Web Speech API
+     */
+    private initializeRecognition;
+    /**
+     * Setup Web Speech API event handlers
+     */
+    private setupRecognitionHandlers;
+    /**
+     * Process voice command with fuzzy matching
+     */
+    private processVoiceCommand;
+    /**
+     * Fuzzy string matching (simple Levenshtein-like approach)
+     */
+    private fuzzyMatch;
+    /**
+     * Build command index for faster lookup
+     */
+    private buildCommandCache;
+    /**
+     * Start listening for voice input
+     */
+    startListening(): void;
+    /**
+     * Stop listening for voice input
+     */
+    stopListening(): void;
+    /**
+     * Toggle listening state
+     */
+    toggleListening(): void;
+    /**
+     * Add command listener
+     */
+    on(listener: (event: VoiceInputEvent) => void): void;
+    /**
+     * Remove command listener
+     */
+    off(listener: (event: VoiceInputEvent) => void): void;
+    /**
+     * Emit voice event to all listeners
+     */
+    private emitEvent;
+    /**
+     * Play audio feedback beep
+     */
+    private playBeep;
+    /**
+     * Get current listening state
+     */
+    isActive(): boolean;
+    /**
+     * Dispose and cleanup
+     */
+    dispose(): void;
+}
+/**
+ * HoloScript+ @voice_input trait factory
+ */
+declare function createVoiceInputTrait(config: VoiceInputConfig): VoiceInputTrait;
+
+/**
+ * @holoscript/core AI-Driven NPC Trait
+ *
+ * Enables intelligent NPC behaviors using behavior trees and goal planning
+ * Integrates with Infinity Assistant service for agent-based decision making
+ */
+type BehaviorState = 'idle' | 'moving' | 'acting' | 'talking' | 'reacting';
+type DecisionMode = 'reactive' | 'goal-driven' | 'learning' | 'hybrid';
+/**
+ * Behavior tree node
+ */
+interface BehaviorNode {
+    id: string;
+    type: 'sequence' | 'selector' | 'parallel' | 'action' | 'condition';
+    children?: BehaviorNode[];
+    action?: (context: NPCContext) => Promise<boolean>;
+    condition?: (context: NPCContext) => boolean;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * NPC Context for behavior execution
+ */
+interface NPCContext {
+    npcId: string;
+    position: [number, number, number];
+    rotation: [number, number, number];
+    targetId?: string;
+    targetPosition?: [number, number, number];
+    memory: Map<string, unknown>;
+    state: BehaviorState;
+    energy: number;
+    mood: number;
+    perception: {
+        nearbyEntities: string[];
+        visibleEntities: string[];
+        hearableVoice?: string;
+    };
+    dialogue?: {
+        lastSaid?: string;
+        lastHeard?: string;
+        conversationHistory: Array<{
+            speaker: string;
+            text: string;
+        }>;
+    };
+}
+/**
+ * Goal for GOAP-style planning
+ */
+interface NPCGoal {
+    id: string;
+    name: string;
+    priority: number;
+    preconditions: Map<string, unknown>;
+    effects: Map<string, unknown>;
+    cost: number;
+    timeoutMs?: number;
+}
+/**
+ * AI-Driven NPC configuration
+ */
+interface AIDriverConfig {
+    /** NPC identifier */
+    npcId: string;
+    /** Decision making mode */
+    decisionMode: DecisionMode;
+    /** Base behavior tree */
+    behaviorTree?: BehaviorNode;
+    /** Available goals */
+    goals?: NPCGoal[];
+    /** Personality traits */
+    personality?: {
+        sociability: number;
+        aggression: number;
+        curiosity: number;
+        loyalty: number;
+    };
+    /** Response to stimuli */
+    stimuliThresholds?: {
+        hearing: number;
+        sight: number;
+        touch: number;
+    };
+    /** Learning config */
+    enableLearning?: boolean;
+    learningRate?: number;
+    /** Infinity Assistant integration */
+    agentId?: string;
+}
+/**
+ * Behavior tree runner
+ */
+declare class BehaviorTreeRunner {
+    private rootNode;
+    constructor(rootNode: BehaviorNode);
+    tick(context: NPCContext): Promise<boolean>;
+    private executeNode;
+}
+/**
+ * Goal-Oriented Action Planning (GOAP)
+ */
+declare class GOAPPlanner {
+    private goals;
+    constructor(goals: NPCGoal[]);
+    /**
+     * Plan a sequence of actions to reach goal
+     */
+    planGoal(currentState: Map<string, unknown>, _goal: NPCGoal): NPCGoal[];
+    private canAchieve;
+}
+/**
+ * AIDriverTrait - Enables intelligent NPC behaviors
+ */
+declare class AIDriverTrait {
+    private config;
+    private context;
+    private behaviorRunner;
+    private goapPlanner;
+    private updateInterval;
+    private learningModel;
+    constructor(config: AIDriverConfig);
+    /**
+     * Start NPC AI loop
+     */
+    startAI(): void;
+    /**
+     * Stop NPC AI loop
+     */
+    stopAI(): void;
+    /**
+     * Main AI tick
+     */
+    private tick;
+    /**
+     * Reactive decision: immediate response to stimuli
+     */
+    private reactiveDecision;
+    /**
+     * Goal-driven decision: plan towards objectives
+     */
+    private goalDrivenDecision;
+    /**
+     * Learning decision: adapt behavior from experience
+     */
+    private learningDecision;
+    /**
+     * Hybrid decision: combination of reactive and goal-driven
+     */
+    private hybridDecision;
+    /**
+     * Build world state for planning
+     */
+    private buildWorldState;
+    /**
+     * Update learning model from interactions
+     */
+    private updateLearningModel;
+    /**
+     * Calculate immediate reward
+     */
+    private calculateReward;
+    /**
+     * Set NPC position
+     */
+    setPosition(position: [number, number, number]): void;
+    /**
+     * Update perception (nearby entities, visible targets)
+     */
+    updatePerception(nearbyEntities: string[], visibleEntities: string[]): void;
+    /**
+     * Add dialogue to conversation history
+     */
+    speak(text: string): void;
+    /**
+     * Receive dialogue from another entity
+     */
+    hear(speaker: string, text: string): void;
+    /**
+     * Get current NPC context
+     */
+    getContext(): Readonly<NPCContext>;
+    /**
+     * Dispose and cleanup
+     */
+    dispose(): void;
+}
+/**
+ * HoloScript+ @ai_driven trait factory
+ */
+declare function createAIDriverTrait(config: AIDriverConfig): AIDriverTrait;
+
+/**
+ * @holoscript/core Performance Telemetry
+ *
+ * Real-time performance monitoring, profiling, and metrics collection
+ * Exports metrics to analytics platforms and provides performance budgets
+ */
+type MetricType = 'gauge' | 'counter' | 'histogram' | 'timer';
+type SeverityLevel = 'info' | 'warning' | 'critical';
+/**
+ * Performance metric
+ */
+interface Metric {
+    name: string;
+    type: MetricType;
+    value: number;
+    timestamp: number;
+    tags?: Record<string, string>;
+    unit?: string;
+}
+/**
+ * Performance budget threshold
+ */
+interface PerformanceBudget {
+    metricName: string;
+    maxValue: number;
+    severity: SeverityLevel;
+    enabled: boolean;
+}
+/**
+ * Frame timing information
+ */
+interface FrameTiming {
+    frameNumber: number;
+    fps: number;
+    frameDuration: number;
+    cpuTime: number;
+    gpuTime: number;
+    renderTime: number;
+    logicTime: number;
+    timestamp: number;
+}
+/**
+ * Memory snapshot
+ */
+interface MemorySnapshot {
+    usedJSHeapSize: number;
+    totalJSHeapSize: number;
+    jsHeapSizeLimit: number;
+    objectCount: number;
+    gcEventsSinceLastSnapshot: number;
+    timestamp: number;
+}
+/**
+ * Performance analytics exporter
+ */
+interface AnalyticsExporter {
+    export(metrics: Metric[]): Promise<void>;
+    flush(): Promise<void>;
+}
+/**
+ * PerformanceTelemetry - Monitor and analyze runtime performance
+ */
+declare class PerformanceTelemetry {
+    private metrics;
+    private budgets;
+    private frameTimings;
+    private memorySnapshots;
+    private exporters;
+    private frameCounter;
+    private lastFrameTime;
+    private frameTimes;
+    private maxFrameHistory;
+    private monitoringEnabled;
+    private exportInterval;
+    private exportIntervalMs;
+    constructor();
+    /**
+     * Initialize default performance budgets
+     */
+    private initializeDefaultBudgets;
+    /**
+     * Start performance monitoring
+     */
+    startMonitoring(): void;
+    /**
+     * Stop performance monitoring
+     */
+    stopMonitoring(): void;
+    /**
+     * Record frame timing
+     */
+    recordFrame(cpuTime: number, gpuTime: number, renderTime: number, logicTime: number): void;
+    /**
+     * Record custom metric
+     */
+    recordMetric(metric: Omit<Metric, 'timestamp'> & {
+        timestamp?: number;
+    }): void;
+    /**
+     * Record memory snapshot
+     */
+    recordMemorySnapshot(): void;
+    /**
+     * Check frame metrics against budgets
+     */
+    private checkBudgets;
+    /**
+     * Emit budget violation warning
+     */
+    private emitBudgetViolation;
+    /**
+     * Set or update performance budget
+     */
+    setBudget(budget: PerformanceBudget): void;
+    /**
+     * Get average FPS over recent frames
+     */
+    getAverageFPS(): number;
+    /**
+     * Get memory usage stats
+     */
+    getMemoryStats(): {
+        used: number;
+        total: number;
+        limit: number;
+        percentage: number;
+    };
+    /**
+     * Get recent frame timings
+     */
+    getRecentFrameTimings(count?: number): FrameTiming[];
+    /**
+     * Add analytics exporter
+     */
+    addExporter(exporter: AnalyticsExporter): void;
+    /**
+     * Export all metrics to registered exporters
+     */
+    exportMetrics(): Promise<void>;
+    /**
+     * Generate performance report
+     */
+    generateReport(): string;
+    /**
+     * Dispose and cleanup
+     */
+    dispose(): void;
+}
+/**
+ * Get or create telemetry instance
+ */
+declare function getPerformanceTelemetry(): PerformanceTelemetry;
+
+/**
+ * Hololand Graphics Pipeline Service
+ *
+ * Core service for managing graphics rendering pipeline in Hololand.
+ * Integrates HoloScript graphics traits with Hololand's rendering backend.
+ *
+ * Responsibilities:
+ * - Material management and asset pipeline
+ * - Light management and shadow mapping
+ * - GPU memory optimization
+ * - Performance monitoring and profiling
+ * - Cross-platform optimization (mobile/VR/desktop)
+ */
+
+interface GPUMemoryEstimate {
+    textureMemory: number;
+    geometryMemory: number;
+    bufferMemory: number;
+    estimatedTotal: number;
+    budget: number;
+    utilization: number;
+}
+interface MaterialAsset {
+    id: string;
+    name: string;
+    material: MaterialTrait;
+    shaders: ShaderProgram[];
+    textures: TextureAsset[];
+    instances: number;
+    gpuMemory: number;
+    lastUsed: number;
+}
+interface TextureAsset {
+    id: string;
+    path: string;
+    format: 'RGBA8' | 'RGB565' | 'BC1' | 'BC3' | 'ASTC' | 'PVRTC';
+    width: number;
+    height: number;
+    mipLevels: number;
+    gpuMemory: number;
+    loaded: boolean;
+}
+interface ShaderProgram {
+    id: string;
+    name: string;
+    vertexShader: string;
+    fragmentShader: string;
+    uniforms: Record<string, string>;
+    compiled: boolean;
+    compilationTime: number;
+}
+interface PerformanceMetrics {
+    drawCalls: number;
+    trianglesRendered: number;
+    gpuFrameTime: number;
+    cpuFrameTime: number;
+    fps: number;
+    gpuMemoryUsed: number;
+    textureBinds: number;
+    shaderSwitches: number;
+    batchCount: number;
+}
+type Platform = 'mobile' | 'vr' | 'desktop';
+interface PlatformConfig {
+    platform: Platform;
+    maxGPUMemory: number;
+    maxDrawCalls: number;
+    maxTextureResolution: number;
+    targetFPS: number;
+    shadowQuality: 'none' | 'low' | 'medium' | 'high';
+    textureCompression: 'none' | 'dxt' | 'astc' | 'basis';
+    instancingEnabled: boolean;
+    maxLights: number;
+    maxShadowCasters: number;
+}
+declare class HololandGraphicsPipelineService {
+    private materialCache;
+    private textureCache;
+    private shaderCache;
+    private platformConfig;
+    private metrics;
+    private memoryUsed;
+    constructor(platform?: Platform);
+    /**
+     * Initialize graphics pipeline with configuration
+     */
+    initialize(config: GraphicsConfiguration): void;
+    /**
+     * Initialize materials from configuration
+     */
+    private initializeMaterials;
+    /**
+     * Initialize lighting from configuration
+     */
+    private initializeLighting;
+    /**
+     * Initialize rendering from configuration
+     */
+    private initializeRendering;
+    /**
+     * Create material asset from configuration
+     */
+    private createMaterialAsset;
+    /**
+     * Generate shaders from material configuration
+     */
+    private generateShaders;
+    /**
+     * Generate PBR shader program
+     */
+    private generatePBRShader;
+    /**
+     * Load textures from configuration
+     */
+    private loadTexturesFromConfig;
+    /**
+     * Select appropriate texture format based on compression type
+     */
+    private selectTextureFormat;
+    /**
+     * Estimate texture memory usage
+     */
+    private estimateTextureMemory;
+    /**
+     * Estimate material GPU memory
+     */
+    private estimateMaterialMemory;
+    /**
+     * Compile shader program
+     */
+    private compileShader;
+    /**
+     * Load texture into GPU memory
+     */
+    private loadTexture;
+    /**
+     * Setup shadow mapping
+     */
+    private setupShadowMapping;
+    /**
+     * Get shadow map resolution for quality level
+     */
+    /**
+     * Setup global illumination
+     */
+    private setupGlobalIllumination;
+    /**
+     * Apply quality preset
+     */
+    private applyQualityPreset;
+    /**
+     * Enable LOD system
+     */
+    private enableLOD;
+    /**
+     * Enable culling
+     */
+    private enableCulling;
+    /**
+     * Get platform-specific configuration
+     */
+    private getPlatformConfig;
+    /**
+     * Initialize performance metrics
+     */
+    private initializeMetrics;
+    /**
+     * Get current GPU memory estimate
+     */
+    getGPUMemoryEstimate(): GPUMemoryEstimate;
+    /**
+     * Get performance metrics
+     */
+    getPerformanceMetrics(): PerformanceMetrics;
+    /**
+     * Set memory budget
+     */
+    setMemoryBudget(budget: number): void;
+    /**
+     * Optimize for specific platform
+     */
+    optimizePlatform(platform: Platform): void;
+}
+
+/**
+ * Platform Performance Optimization System
+ *
+ * Provides adaptive quality and performance tuning for:
+ * - Mobile devices (battery/bandwidth constrained)
+ * - VR/AR platforms (latency-critical, 90 FPS required)
+ * - Desktop (quality-focused, high resolution)
+ *
+ * Features:
+ * - Automatic quality adjustment based on device
+ * - Performance profiling and analysis
+ * - Bottleneck detection and mitigation
+ * - Cross-platform benchmark testing
+ */
+interface DeviceInfo {
+    platform: 'mobile' | 'vr' | 'desktop';
+    gpuVendor: string;
+    gpuModel: string;
+    gpuMemory: number;
+    cpuCores: number;
+    ramTotal: number;
+    screenResolution: {
+        width: number;
+        height: number;
+    };
+    refreshRate: number;
+    isLowPowerMode?: boolean;
+}
+interface DeviceCapabilities {
+    maxTextureResolution: number;
+    supportsCompression: boolean;
+    compressionFormats: string[];
+    maxSimultaneousLights: number;
+    shadowsSupported: boolean;
+    computeShaderSupported: boolean;
+    rayTracingSupported: boolean;
+    estimatedMemory: number;
+}
+interface PerformanceProfile {
+    device: DeviceInfo;
+    capabilities: DeviceCapabilities;
+    targetFPS: number;
+    qualityLevel: 'low' | 'medium' | 'high' | 'ultra';
+    adaptiveQuality: boolean;
+    fpsTarget: number;
+    fpsMin: number;
+    cpuBudget: number;
+    gpuBudget: number;
+}
+interface BenchmarkResult {
+    testName: string;
+    platform: string;
+    fps: number;
+    gpuFrameTime: number;
+    cpuFrameTime: number;
+    gpuMemoryUsed: number;
+    trianglesPerSecond: number;
+    drawCallsPerSecond: number;
+    qualityLevel: string;
+    passed: boolean;
+}
+interface AdaptiveQualitySettings {
+    enabled: boolean;
+    checkInterval: number;
+    fpsDeltaThreshold: number;
+    memoryThreshold: number;
+    temperatureThreshold?: number;
+}
+type CompressionFormat = 'none' | 'lz4' | 'zstd' | 'bc1' | 'bc7' | 'astc' | 'etc2' | 'pvrtc';
+interface PerformanceRecommendation {
+    category: 'texture' | 'geometry' | 'shader' | 'memory' | 'rendering';
+    priority: 'low' | 'medium' | 'high' | 'critical';
+    recommendation: string;
+    expectedImprovement: number;
+    estimatedCost: string;
+}
+declare class PlatformPerformanceOptimizer {
+    private deviceInfo;
+    private capabilities;
+    private profile;
+    private adaptiveSettings;
+    private currentFPS;
+    private frameHistory;
+    private lastAdaptTime;
+    constructor(device: DeviceInfo);
+    /**
+     * Detect device capabilities
+     */
+    private detectCapabilities;
+    /**
+     * Create performance profile for device
+     */
+    private createProfile;
+    /**
+     * Get adaptive quality settings for platform
+     */
+    private getAdaptiveSettings;
+    /**
+     * Optimize for device - returns recommended rendering settings
+     */
+    optimizeForDevice(): any;
+    /**
+     * Select best compression format for platform
+     */
+    private selectCompression;
+    /**
+     * Update frame metrics for adaptive quality
+     */
+    updateFrameMetrics(fps: number, gpuMemoryUsed: number, gpuFrameTime: number): void;
+    /**
+     * Check and adapt quality settings
+     */
+    private checkAndAdapt;
+    /**
+     * Degrade quality for better performance
+     */
+    private degradeQuality;
+    /**
+     * Improve quality for better visuals
+     */
+    private improveQuality;
+    /**
+     * Get average FPS from history
+     */
+    private getAverageFPS;
+    /**
+     * Run performance benchmark
+     */
+    runBenchmark(name: string, renderFunc: (iterations: number) => Promise<{
+        fps: number;
+        gpuTime: number;
+        cpuTime: number;
+        triangles: number;
+        drawCalls: number;
+    }>): Promise<BenchmarkResult>;
+    /**
+     * Get benchmark iterations based on platform
+     */
+    private getBenchmarkIterations;
+    /**
+     * Get current performance profile
+     */
+    getProfile(): PerformanceProfile;
+    /**
+     * Get optimization recommendations
+     */
+    getRecommendations(): string[];
+}
+
+/**
+ * @holoscript/core Logger
+ *
+ * Simple pluggable logger for HoloScript
+ */
+interface HoloScriptLogger {
+    debug(message: string, meta?: Record<string, unknown>): void;
+    info(message: string, meta?: Record<string, unknown>): void;
+    warn(message: string, meta?: Record<string, unknown>): void;
+    error(message: string, meta?: Record<string, unknown>): void;
+}
+declare class NoOpLogger implements HoloScriptLogger {
+    debug(): void;
+    info(): void;
+    warn(): void;
+    error(): void;
+}
+declare class ConsoleLogger implements HoloScriptLogger {
+    debug(message: string, meta?: Record<string, unknown>): void;
+    info(message: string, meta?: Record<string, unknown>): void;
+    warn(message: string, meta?: Record<string, unknown>): void;
+    error(message: string, meta?: Record<string, unknown>): void;
+}
+declare function setHoloScriptLogger(logger: HoloScriptLogger): void;
+declare function enableConsoleLogging(): void;
+declare function resetLogger(): void;
+declare const logger: HoloScriptLogger;
+
+/**
+ * @holoscript/core
+ *
+ * HoloScript+ - VR language with declarative syntax, state management, and VR interactions.
+ * Enhanced version of HoloScript with:
+ * - VR interaction traits (@grabbable, @throwable, @hoverable, etc.)
+ * - Reactive state management (@state { ... })
+ * - Control flow (@for, @if directives)
+ * - TypeScript companion imports
+ * - Expression interpolation ${...}
+ *
+ * Fully backward compatible with original HoloScript syntax.
+ *
+ * @example
+ * ```typescript
+ * import { HoloScriptPlusParser, HoloScriptPlusRuntime } from '@holoscript/core';
+ *
+ * const parser = new HoloScriptPlusParser();
+ * const result = parser.parse(`
+ *   orb#myOrb {
+ *     position: [0, 0, 0]
+ *     @grabbable(snap_to_hand: true)
+ *     @throwable(bounce: true)
+ *   }
+ * `);
+ *
+ * const runtime = new HoloScriptPlusRuntime(result.ast);
+ * await runtime.mount(document.body);
+ * ```
+ *
+ * @packageDocumentation
+ */
+
+declare const HOLOSCRIPT_VERSION = "1.0.0-alpha.1";
+declare const HOLOSCRIPT_SUPPORTED_PLATFORMS: readonly ["WebXR", "Oculus Quest", "HTC Vive", "Valve Index", "Apple Vision Pro", "Windows Mixed Reality"];
+declare const HOLOSCRIPT_VOICE_COMMANDS: readonly ["create orb [name]", "summon function [name]", "connect [from] to [to]", "execute [function]", "debug program", "visualize [data]", "gate [condition]", "stream [source] through [transformations]", "create button [name]", "add textinput [name]", "create panel [name]", "add slider [name]"];
+declare const HOLOSCRIPT_GESTURES: readonly ["pinch - create object", "swipe - connect objects", "rotate - modify properties", "grab - select object", "spread - expand view", "fist - execute action"];
+declare const HOLOSCRIPT_DEMO_SCRIPTS: {
+    readonly helloWorld: "orb greeting {\n  message: \"Hello, HoloScript World!\"\n  color: \"#00ffff\"\n  glow: true\n}\n\nfunction displayGreeting() {\n  show greeting\n}";
+    readonly aiAgent: "orb agentCore {\n  personality: \"helpful\"\n  capabilities: [\"conversation\", \"problem_solving\", \"learning\"]\n  energy: 100\n}\n\nfunction processQuery(query: string): string {\n  analyze query\n  generate response\n  return response\n}";
+    readonly neuralNetwork: "orb inputLayer { neurons: 784 }\norb hiddenLayer { neurons: 128 }\norb outputLayer { neurons: 10 }\n\nconnect inputLayer to hiddenLayer as \"weights\"\nconnect hiddenLayer to outputLayer as \"weights\"\n\nfunction trainNetwork(data: array): object {\n  forward_pass data\n  calculate_loss\n  backward_pass\n  update_weights\n  return metrics\n}";
+    readonly loginForm: "button loginBtn {\n  text: \"Login\"\n  x: 100\n  y: 150\n  width: 200\n  height: 40\n  onClick: handleLogin\n}\n\ntextinput usernameInput {\n  placeholder: \"Username\"\n  x: 100\n  y: 50\n  width: 200\n  height: 36\n}\n\ntextinput passwordInput {\n  placeholder: \"Password\"\n  x: 100\n  y: 100\n  width: 200\n  height: 36\n}";
+    readonly dashboard: "panel sidebar {\n  x: 0\n  y: 0\n  width: 200\n  height: 600\n  backgroundColor: \"#2c3e50\"\n}\n\ntext title {\n  content: \"Dashboard\"\n  x: 220\n  y: 20\n  fontSize: 24\n  color: \"#34495e\"\n}\n\nbutton refreshBtn {\n  text: \"Refresh Data\"\n  x: 220\n  y: 60\n  onClick: refreshData\n}";
+};
+/**
+ * Create a pre-configured HoloScript environment
+ */
+declare function createHoloScriptEnvironment(): {
+    parser: HoloScriptParser;
+    runtime: HoloScriptRuntime;
+    version: string;
+};
+/**
+ * Check if the current environment supports VR/XR
+ */
+declare function isHoloScriptSupported(): boolean;
+
+export { type ABTestTrait, type AIDriverConfig, AIDriverTrait, type AILifecycleHook, ASTNode, type AdaptiveQualitySettings, type AllLifecycleHooks, type AnalyticsExporter, type AnalyticsLifecycleHook, type AudioLifecycleHook, type BatchingConfig, type BehaviorNode, type BehaviorState, BehaviorTreeRunner, type BenchmarkResult, type BodyTrait, type BreakableTrait, type CameraTrait, type CaptionedTrait, type CharacterVoiceTrait, type ChoreographyTrait, type ClothingTrait, type CollaborativeTrait, type CompressionFormat, ConsoleLogger, type CullingConfig, type CullingMode, type DecisionMode, type DeviceCapabilities, type DeviceInfo, type EffectsLifecycleHook, type EmbeddableTrait, type ExpressiveTrait, type FaceTrait, type FilterTrait, type FrameTiming, GOAPPlanner, type GPUMemoryEstimate, type GPUResourceTier, GestureData, type GlobalIlluminationConfig, type GraphicsConfiguration, HOLOSCRIPT_DEMO_SCRIPTS, HOLOSCRIPT_GESTURES, HOLOSCRIPT_SUPPORTED_PLATFORMS, HOLOSCRIPT_VERSION, HOLOSCRIPT_VOICE_COMMANDS, type HairTrait, type HandsTrait, type HeatmapTrait, HoloScript2DParser, type HoloScriptLogger, HoloScriptParser, HoloScriptPlusParser$1 as HoloScriptPlusParser, HoloScriptPlusRuntimeImpl, HoloScriptRuntime, HoloScriptPlusParser as HoloScriptTraitAnnotationParser, HoloScriptValidator, HololandGraphicsPipelineService, LIFECYCLE_HOOKS, LIGHTING_PRESETS, type LODLevel, type LifecycleHookName, type LightSource, type LightType, LightingTrait, type LightingTraitAnnotation, type LocomotionTrait, type LodStrategy, MATERIAL_PRESETS, type MaterialAsset, type MaterialConfig, MaterialTrait, type MaterialTraitAnnotation, type MaterialType, type MediaLifecycleHook, type MemorySnapshot, type Metric, type MetricType, type MoldableTrait, type MorphTrait, type NPCContext, type NPCGoal, type NarratorTrait, type NetworkedTrait, NoOpLogger, type PBRMaterial, type ParticleConfig, type ParticleTrait, type PerformanceBudget, type PerformanceMetrics, type PerformanceProfile, type PerformanceRecommendation, PerformanceTelemetry, type PlatformConfig, PlatformPerformanceOptimizer, type PoseableTrait, Position2D, type ProactiveTrait, type ProceduralTrait, type QRTrait, type ReactiveAudioTrait, ReactiveState, type RecordableTrait, type RecordingClip, type RenderingOptimization, RenderingTrait, type RenderingTraitAnnotation, type ResponsiveTrait, type SeverityLevel, type ShaderOptimization, type ShaderProgram, type ShadowConfig, type ShadowType, type ShareContent, type ShareResult, type ShareableTrait, type SkeletonTrait, type SnappableTrait, type SocialLifecycleHook, type SpatialAudioTrait, SpatialPosition, type StackableTrait, type StreamableTrait, type StretchableTrait, type SurveyTrait, type TextureAsset, type TextureChannel, type TextureMap, type TextureOptimization, type TimelineLifecycleHook, type TimelineTrait, type TrackableTrait, type TrailTrait, type TransitionTrait, UI2DNode, type VRTraitName, VRTraitRegistry, VR_TRAITS, type ValidationError, type VideoTrait, VoiceCommand$1 as VoiceCommand, type VoiceInputConfig, type VoiceInputEvent, type VoiceInputMode, VoiceInputTrait, type VoiceRecognitionResult, type VoiceTrait, bind, computed, createAIDriverTrait, createHoloScriptEnvironment, createLightingTrait, createMaterialTrait, createParser, createRenderingTrait, createState, createVoiceInputTrait, effect, enableConsoleLogging, getPerformanceTelemetry, isHoloScriptSupported, logger, parse as parseHoloScriptPlus, reactive, resetLogger, setHoloScriptLogger };