@holoscript/core 2.0.0 → 2.0.2

package/dist/index.d.cts

@@ -0,0 +1,2482 @@
+import { U as UI2DNode, P as Position2D, V as VoiceCommand$1, A as ASTNode, G as GestureData, S as SpatialPosition } from './types-D6g4ACjP.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, b as HologramProperties, H as HologramShape, s as HoverableTrait, v as ImportLoader, I as ImportNode, M as MethodNode, O as OrbNode, e as ParameterNode, J as ParticleSystem, r as PointableTrait, R as RotatableTrait, z as RuntimeContext, L as RuntimeSecurityLimits, t as ScalableTrait, K 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-D6g4ACjP.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 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 parsePinchGesture;
+    private parseSwipeGesture;
+    private parseRotateGesture;
+    private parseGrabGesture;
+    private tokenizeCommand;
+    private sanitizeTokens;
+    private parseExecuteCommand;
+    private parseDebugCommand;
+    private parseVisualizeCommand;
+    private parseGenericCommand;
+    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;
+}
+
+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 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;
+
+/**
+ * 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): any;
+    /**
+     * Create MaterialTrait from config
+     */
+    private createMaterialTrait;
+    /**
+     * Create LightingTrait from config
+     */
+    private createLightingTrait;
+    /**
+     * Create RenderingTrait from config
+     */
+    private createRenderingTrait;
+}
+
+/**
+ * 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.
+ *
+ * uaa2-service maintains its own evolved implementation for service-level enhancements.
+ * Core baseline: @holoscript/core
+ *
+ * @version 1.0.0
+ * @license MIT
+ */
+
+// =============================================================================
+// CORE TYPES
+// =============================================================================
+
+type Vector3$1 = [number, number, number];
+
+// =============================================================================
+// VR INTERACTION TYPES
+// =============================================================================
+
+/**
+ * Hand reference for VR interactions
+ */
+interface VRHand {
+  id: 'left' | 'right';
+  position: Vector3$1;
+  rotation: Vector3$1;
+  velocity: Vector3$1;
+  grip: number; // 0-1 grip strength
+  trigger: number; // 0-1 trigger pressure
+}
+
+// =============================================================================
+// VR INTERACTION TYPES
+// =============================================================================
+
+/**
+ * Hand reference for VR interactions
+ */
+interface VRHand {
+  id: 'left' | 'right';
+  position: Vector3$1;
+  rotation: Vector3$1;
+  velocity: Vector3$1;
+  grip: number; // 0-1 grip strength
+  trigger: number; // 0-1 trigger pressure
+}
+
+/**
+ * Velocity data for throw calculations
+ */
+interface ThrowVelocity {
+  direction: Vector3$1;
+  magnitude: number;
+  angularVelocity: Vector3$1;
+}
+
+/**
+ * Velocity data for throw calculations
+ */
+interface ThrowVelocity {
+  direction: Vector3$1;
+  magnitude: number;
+  angularVelocity: Vector3$1;
+}
+
+/**
+ * Collision event data
+ */
+interface CollisionEvent {
+  target: HSPlusNode;
+  point: Vector3$1;
+  normal: Vector3$1;
+  impulse: number;
+  relativeVelocity: Vector3$1;
+}
+
+/**
+ * Collision event data
+ */
+interface CollisionEvent {
+  target: HSPlusNode;
+  point: Vector3$1;
+  normal: Vector3$1;
+  impulse: number;
+  relativeVelocity: Vector3$1;
+}
+
+// =============================================================================
+// STATE MANAGEMENT
+// =============================================================================
+
+/**
+ * Reactive state declaration
+ */
+interface StateDeclaration {
+  [key: string]: unknown;
+}
+
+// =============================================================================
+// STATE MANAGEMENT
+// =============================================================================
+
+/**
+ * Reactive state declaration
+ */
+interface StateDeclaration {
+  [key: string]: unknown;
+}
+
+/**
+ * State proxy for reactive updates
+ */
+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;
+}
+
+/**
+ * State proxy for reactive updates
+ */
+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';
+
+// =============================================================================
+// 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 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';
+
+type ControllerHook =
+  | 'on_controller_button'
+  | 'on_trigger_hold'
+  | 'on_trigger_release'
+  | 'on_grip_hold'
+  | 'on_grip_release';
+
+// =============================================================================
+// 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: LifecycleHook | VRLifecycleHook | ControllerHook; params?: string[]; body: string }
+  | { type: 'trait'; name: VRTraitName; config: Record<string, unknown> };
+
+// =============================================================================
+// 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: LifecycleHook | VRLifecycleHook | ControllerHook; params?: string[]; body: string }
+  | { type: 'trait'; name: VRTraitName; config: Record<string, unknown> };
+
+type VRTraitName =
+  | 'grabbable'
+  | 'throwable'
+  | 'pointable'
+  | 'hoverable'
+  | 'scalable'
+  | 'rotatable'
+  | 'stackable'
+  | 'snappable'
+  | 'breakable';
+
+type VRTraitName =
+  | 'grabbable'
+  | 'throwable'
+  | 'pointable'
+  | 'hoverable'
+  | 'scalable'
+  | 'rotatable'
+  | 'stackable'
+  | 'snappable'
+  | 'breakable';
+
+interface HSPlusNode {
+  type: string;
+  id?: string;
+  properties: Record<string, unknown>;
+  directives: HSPlusDirective[];
+  children: HSPlusNode[];
+  traits: Map<VRTraitName, unknown>;
+  // Source location for debugging
+  loc?: {
+    start: { line: number; column: number };
+    end: { line: number; column: number };
+  };
+}
+
+interface HSPlusNode {
+  type: string;
+  id?: string;
+  properties: Record<string, unknown>;
+  directives: HSPlusDirective[];
+  children: HSPlusNode[];
+  traits: Map<VRTraitName, unknown>;
+  // Source location for debugging
+  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;
+}
+
+interface HSPlusAST {
+  version: '1.0';
+  root: HSPlusNode;
+  imports: Array<{ path: string; alias: string }>;
+  hasState: boolean;
+  hasVRTraits: boolean;
+  hasControlFlow: boolean;
+}
+
+interface HSPlusRuntime {
+  // Mount the scene
+  mount: (container: unknown) => void;
+
+  // Unmount and cleanup
+  unmount: () => void;
+
+  // Update with new data
+  updateData: (data: unknown) => void;
+
+  // Get current state
+  getState: () => StateDeclaration;
+
+  // Set state
+  setState: (updates: Partial<StateDeclaration>) => void;
+
+  // Emit event
+  emit: (event: string, payload?: unknown) => void;
+
+  // Subscribe to events
+  on: (event: string, handler: (payload: unknown) => void) => () => void;
+}
+
+interface HSPlusRuntime {
+  // Mount the scene
+  mount: (container: unknown) => void;
+
+  // Unmount and cleanup
+  unmount: () => void;
+
+  // Update with new data
+  updateData: (data: unknown) => void;
+
+  // Get current state
+  getState: () => StateDeclaration;
+
+  // Set state
+  setState: (updates: Partial<StateDeclaration>) => void;
+
+  // Emit event
+  emit: (event: string, payload?: unknown) => void;
+
+  // Subscribe to events
+  on: (event: string, handler: (payload: unknown) => void) => () => void;
+}
+
+/**
+ * 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;
+    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;
+}
+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): TraitHandler | undefined;
+    attachTrait(node: HSPlusNode, traitName: VRTraitName, config: unknown, context: TraitContext): void;
+    detachTrait(node: HSPlusNode, traitName: VRTraitName, context: TraitContext): void;
+    updateTrait(node: HSPlusNode, traitName: VRTraitName, context: TraitContext, delta: number): void;
+    handleEvent(node: HSPlusNode, traitName: VRTraitName, 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 mounted;
+    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;
+    private update;
+    private updateInstance;
+    private createTraitContext;
+    private destroyInstance;
+    updateData(data: unknown): void;
+    getState(): StateDeclaration;
+    setState(updates: Partial<StateDeclaration>): void;
+    emit(event: string, payload?: unknown): void;
+    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 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;
+
+/**
+ * @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 AIDriverConfig, AIDriverTrait, ASTNode, type AdaptiveQualitySettings, type AnalyticsExporter, type BatchingConfig, type BehaviorNode, type BehaviorState, BehaviorTreeRunner, type BenchmarkResult, type CompressionFormat, ConsoleLogger, type CullingConfig, type CullingMode, type DecisionMode, type DeviceCapabilities, type DeviceInfo, 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, HoloScript2DParser, type HoloScriptLogger, HoloScriptParser, HoloScriptPlusParser$1 as HoloScriptPlusParser, HoloScriptPlusRuntimeImpl, HoloScriptRuntime, HoloScriptPlusParser as HoloScriptTraitAnnotationParser, HololandGraphicsPipelineService, LIGHTING_PRESETS, type LODLevel, type LightSource, type LightType, LightingTrait, type LightingTraitAnnotation, type LodStrategy, MATERIAL_PRESETS, type MaterialAsset, type MaterialConfig, MaterialTrait, type MaterialTraitAnnotation, type MaterialType, type MemorySnapshot, type Metric, type MetricType, type NPCContext, type NPCGoal, NoOpLogger, type PBRMaterial, type PerformanceBudget, type PerformanceMetrics, type PerformanceProfile, type PerformanceRecommendation, PerformanceTelemetry, type PlatformConfig, PlatformPerformanceOptimizer, Position2D, ReactiveState, type RenderingOptimization, RenderingTrait, type RenderingTraitAnnotation, type SeverityLevel, type ShaderOptimization, type ShaderProgram, type ShadowConfig, type ShadowType, SpatialPosition, type TextureAsset, type TextureChannel, type TextureMap, type TextureOptimization, UI2DNode, VRTraitRegistry, VoiceCommand$1 as VoiceCommand, type VoiceInputConfig, type VoiceInputEvent, type VoiceInputMode, VoiceInputTrait, type VoiceRecognitionResult, bind, computed, createAIDriverTrait, createHoloScriptEnvironment, createLightingTrait, createMaterialTrait, createParser, createRenderingTrait, createState, createVoiceInputTrait, effect, enableConsoleLogging, getPerformanceTelemetry, isHoloScriptSupported, logger, parse as parseHoloScriptPlus, reactive, resetLogger, setHoloScriptLogger };