@holoscript/framework 6.0.3

package/dist/ai/index.d.ts

@@ -0,0 +1,1753 @@
+import { HSPlusCompileResult } from '@holoscript/core';
+
+/**
+ * @holoscript/core AI Adapter Interface
+ *
+ * Provider-agnostic AI integration for HoloScript.
+ * Users can implement this interface to integrate any AI service.
+ *
+ * @example
+ * ```typescript
+ * import { AIAdapter, registerAIAdapter } from '@holoscript/core';
+ *
+ * // Implement your own adapter
+ * class MyOpenAIAdapter implements AIAdapter {
+ *   async generateHoloScript(prompt: string) {
+ *     const response = await openai.chat.completions.create({...});
+ *     return { holoScript: response.choices[0].message.content };
+ *   }
+ * }
+ *
+ * // Register it
+ * registerAIAdapter(new MyOpenAIAdapter());
+ * ```
+ */
+/**
+ * Result of HoloScript generation from natural language
+ */
+interface GenerateResult {
+    /** Generated HoloScript code */
+    holoScript: string;
+    /** Confidence score (0-1) */
+    confidence?: number;
+    /** Estimated object count */
+    objectCount?: number;
+    /** Any warnings or suggestions */
+    warnings?: string[];
+    /** Provider-specific metadata */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Result of HoloScript explanation
+ */
+interface ExplainResult {
+    /** Human-readable explanation */
+    explanation: string;
+    /** Line-by-line breakdown */
+    breakdown?: Array<{
+        line: number;
+        code: string;
+        description: string;
+    }>;
+}
+/**
+ * Result of HoloScript optimization
+ */
+interface OptimizeResult {
+    /** Optimized HoloScript code */
+    holoScript: string;
+    /** What was improved */
+    improvements: string[];
+    /** Performance metrics comparison */
+    metrics?: {
+        before: {
+            polygons?: number;
+            nodes?: number;
+        };
+        after: {
+            polygons?: number;
+            nodes?: number;
+        };
+    };
+}
+/**
+ * Result of HoloScript validation/fixing
+ */
+interface FixResult {
+    /** Fixed HoloScript code */
+    holoScript: string;
+    /** Issues that were fixed */
+    fixes: Array<{
+        line: number;
+        issue: string;
+        fix: string;
+    }>;
+    /** Issues that couldn't be fixed automatically */
+    remaining?: string[];
+}
+/**
+ * Generation options
+ */
+interface GenerateOptions {
+    /** Style hint: modern, classic, minimal, realistic */
+    style?: 'modern' | 'classic' | 'minimal' | 'realistic';
+    /** Complexity level */
+    complexity?: 'low' | 'medium' | 'high';
+    /** Include physics simulation */
+    includePhysics?: boolean;
+    /** Target platform for optimization */
+    targetPlatform?: 'mobile' | 'desktop' | 'vr' | 'ar';
+    /** Maximum tokens/length */
+    maxTokens?: number;
+    /** Temperature for generation (0-1) */
+    temperature?: number;
+    /** Additional context about the world */
+    context?: string;
+}
+/**
+ * AI Adapter Interface
+ *
+ * Implement this interface to integrate any AI provider with HoloScript.
+ * All methods are optional - implement only what your provider supports.
+ */
+interface AIAdapter {
+    /** Unique identifier for this adapter */
+    readonly id: string;
+    /** Human-readable name */
+    readonly name: string;
+    /** Whether the adapter is ready to use */
+    isReady(): boolean | Promise<boolean>;
+    /**
+     * Generate HoloScript from natural language
+     * @param prompt User's natural language description
+     * @param options Generation options
+     */
+    generateHoloScript?(prompt: string, options?: GenerateOptions): Promise<GenerateResult>;
+    /**
+     * Explain what HoloScript code does
+     * @param holoScript The code to explain
+     */
+    explainHoloScript?(holoScript: string): Promise<ExplainResult>;
+    /**
+     * Optimize HoloScript for a target platform
+     * @param holoScript The code to optimize
+     * @param target Target platform
+     */
+    optimizeHoloScript?(holoScript: string, target: 'mobile' | 'desktop' | 'vr' | 'ar'): Promise<OptimizeResult>;
+    /**
+     * Fix errors in HoloScript code
+     * @param holoScript The code to fix
+     * @param errors Error messages from parser/validator
+     */
+    fixHoloScript?(holoScript: string, errors: string[]): Promise<FixResult>;
+    /**
+     * Complete HoloScript code (autocomplete)
+     * @param holoScript Partial code
+     * @param cursorPosition Position of cursor
+     */
+    completeHoloScript?(holoScript: string, cursorPosition: number): Promise<string[]>;
+    /**
+     * Chat with AI about HoloScript code
+     * @param message User message
+     * @param holoScript Current code context
+     * @param history Previous messages
+     */
+    chat?(message: string, holoScript?: string, history?: Array<{
+        role: 'user' | 'assistant';
+        content: string;
+    }>): Promise<string>;
+    /**
+     * Get vector embeddings for text
+     * @param text Text to embed
+     */
+    getEmbeddings?(text: string | string[]): Promise<number[][]>;
+}
+/**
+ * Register an AI adapter
+ * @param adapter The adapter to register
+ * @param setAsDefault Whether to set as the default adapter
+ */
+declare function registerAIAdapter(adapter: AIAdapter, setAsDefault?: boolean): void;
+/**
+ * Get an AI adapter by ID
+ * @param id Adapter ID
+ */
+declare function getAIAdapter(id: string): AIAdapter | undefined;
+/**
+ * Get the default AI adapter
+ */
+declare function getDefaultAIAdapter(): AIAdapter | null;
+/**
+ * Set the default AI adapter
+ * @param id Adapter ID
+ */
+declare function setDefaultAIAdapter(id: string): boolean;
+/**
+ * List all registered adapters
+ */
+declare function listAIAdapters(): Array<{
+    id: string;
+    name: string;
+}>;
+/**
+ * Unregister an AI adapter
+ * @param id Adapter ID
+ */
+declare function unregisterAIAdapter(id: string): boolean;
+/**
+ * Generate HoloScript from natural language using the default adapter
+ */
+declare function generateHoloScript$1(prompt: string, options?: GenerateOptions): Promise<GenerateResult>;
+/**
+ * Explain HoloScript code using the default adapter
+ */
+declare function explainHoloScript(holoScript: string): Promise<ExplainResult>;
+/**
+ * Optimize HoloScript using the default adapter
+ */
+declare function optimizeHoloScript(holoScript: string, target: 'mobile' | 'desktop' | 'vr' | 'ar'): Promise<OptimizeResult>;
+/**
+ * Fix HoloScript errors using the default adapter
+ */
+declare function fixHoloScript(holoScript: string, errors: string[]): Promise<FixResult>;
+
+/**
+ * @holoscript/core - Built-in AI Adapters
+ *
+ * Ready-to-use adapters for popular AI providers.
+ * Users just need to provide their API key.
+ */
+
+interface OpenAIAdapterConfig {
+    apiKey: string;
+    model?: string;
+    baseUrl?: string;
+    organization?: string;
+}
+declare class OpenAIAdapter implements AIAdapter {
+    readonly id = "openai";
+    readonly name = "OpenAI";
+    private config;
+    private model;
+    constructor(config: OpenAIAdapterConfig);
+    isReady(): boolean;
+    generateHoloScript(prompt: string, options?: GenerateOptions): Promise<GenerateResult>;
+    explainHoloScript(holoScript: string): Promise<ExplainResult>;
+    optimizeHoloScript(holoScript: string, target: 'mobile' | 'desktop' | 'vr' | 'ar'): Promise<OptimizeResult>;
+    fixHoloScript(holoScript: string, errors: string[]): Promise<FixResult>;
+    chat(message: string, holoScript?: string, history?: Array<{
+        role: 'user' | 'assistant';
+        content: string;
+    }>): Promise<string>;
+    private buildSystemPrompt;
+    private extractCode;
+    private callAPI;
+    getEmbeddings(text: string | string[]): Promise<number[][]>;
+}
+interface AnthropicAdapterConfig {
+    apiKey: string;
+    model?: string;
+}
+declare class AnthropicAdapter implements AIAdapter {
+    readonly id = "anthropic";
+    readonly name = "Anthropic Claude";
+    private config;
+    private model;
+    constructor(config: AnthropicAdapterConfig);
+    isReady(): boolean;
+    generateHoloScript(prompt: string, options?: GenerateOptions): Promise<GenerateResult>;
+    explainHoloScript(holoScript: string): Promise<ExplainResult>;
+    optimizeHoloScript(holoScript: string, target: 'mobile' | 'desktop' | 'vr' | 'ar'): Promise<OptimizeResult>;
+    fixHoloScript(holoScript: string, errors: string[]): Promise<FixResult>;
+    chat(message: string, holoScript?: string, history?: Array<{
+        role: 'user' | 'assistant';
+        content: string;
+    }>): Promise<string>;
+    private extractCode;
+    private callAPI;
+    getEmbeddings(text: string | string[]): Promise<number[][]>;
+}
+interface OllamaAdapterConfig {
+    baseUrl?: string;
+    model?: string;
+}
+declare class OllamaAdapter implements AIAdapter {
+    readonly id = "ollama";
+    readonly name = "Ollama (Local)";
+    private baseUrl;
+    private model;
+    constructor(config?: OllamaAdapterConfig);
+    isReady(): Promise<boolean>;
+    generateHoloScript(prompt: string, _options?: GenerateOptions): Promise<GenerateResult>;
+    explainHoloScript(holoScript: string): Promise<ExplainResult>;
+    optimizeHoloScript(holoScript: string, target: 'mobile' | 'desktop' | 'vr' | 'ar'): Promise<OptimizeResult>;
+    fixHoloScript(holoScript: string, errors: string[]): Promise<FixResult>;
+    chat(message: string, holoScript?: string, history?: Array<{
+        role: 'user' | 'assistant';
+        content: string;
+    }>): Promise<string>;
+    private callAPIWithErrorHandling;
+    private extractCode;
+    private callAPI;
+    getEmbeddings(text: string | string[]): Promise<number[][]>;
+}
+interface LMStudioAdapterConfig {
+    baseUrl?: string;
+    model?: string;
+}
+/**
+ * LM Studio adapter - uses OpenAI-compatible API running locally
+ */
+declare class LMStudioAdapter implements AIAdapter {
+    readonly id = "lmstudio";
+    readonly name = "LM Studio (Local)";
+    private openaiAdapter;
+    constructor(config?: LMStudioAdapterConfig);
+    isReady(): boolean;
+    generateHoloScript(prompt: string, options?: GenerateOptions): Promise<GenerateResult>;
+    explainHoloScript(holoScript: string): Promise<ExplainResult>;
+    optimizeHoloScript(holoScript: string, target: 'mobile' | 'desktop' | 'vr' | 'ar'): Promise<OptimizeResult>;
+    fixHoloScript(holoScript: string, errors: string[]): Promise<FixResult>;
+    chat(message: string, holoScript?: string, history?: Array<{
+        role: 'user' | 'assistant';
+        content: string;
+    }>): Promise<string>;
+}
+/**
+ * Create and register an OpenAI adapter
+ */
+declare function useOpenAI(config: OpenAIAdapterConfig): OpenAIAdapter;
+/**
+ * Create and register an Anthropic adapter
+ */
+declare function useAnthropic(config: AnthropicAdapterConfig): AnthropicAdapter;
+/**
+ * Create and register an Ollama adapter (local)
+ */
+declare function useOllama(config?: OllamaAdapterConfig): OllamaAdapter;
+/**
+ * Create and register an LM Studio adapter (local)
+ */
+declare function useLMStudio(config?: LMStudioAdapterConfig): LMStudioAdapter;
+interface GeminiAdapterConfig {
+    apiKey: string;
+    model?: string;
+    /** Embedding model (default: text-embedding-004) */
+    embeddingModel?: string;
+}
+declare class GeminiAdapter implements AIAdapter {
+    readonly id = "gemini";
+    readonly name = "Google Gemini";
+    private config;
+    private model;
+    private embeddingModel;
+    constructor(config: GeminiAdapterConfig);
+    isReady(): boolean;
+    generateHoloScript(prompt: string, options?: GenerateOptions): Promise<GenerateResult>;
+    explainHoloScript(holoScript: string): Promise<ExplainResult>;
+    optimizeHoloScript(holoScript: string, target: 'mobile' | 'desktop' | 'vr' | 'ar'): Promise<OptimizeResult>;
+    fixHoloScript(holoScript: string, errors: string[]): Promise<FixResult>;
+    chat(message: string, holoScript?: string, history?: Array<{
+        role: 'user' | 'assistant';
+        content: string;
+    }>): Promise<string>;
+    getEmbeddings(text: string | string[]): Promise<number[][]>;
+    private extractCode;
+    private callAPI;
+}
+interface XAIAdapterConfig {
+    apiKey: string;
+    model?: string;
+}
+declare class XAIAdapter implements AIAdapter {
+    readonly id = "xai";
+    readonly name = "xAI Grok";
+    private config;
+    private model;
+    constructor(config: XAIAdapterConfig);
+    isReady(): boolean;
+    generateHoloScript(prompt: string, _options?: GenerateOptions): Promise<GenerateResult>;
+    explainHoloScript(holoScript: string): Promise<ExplainResult>;
+    optimizeHoloScript(holoScript: string, target: 'mobile' | 'desktop' | 'vr' | 'ar'): Promise<OptimizeResult>;
+    fixHoloScript(holoScript: string, errors: string[]): Promise<FixResult>;
+    chat(message: string, holoScript?: string, history?: Array<{
+        role: 'user' | 'assistant';
+        content: string;
+    }>): Promise<string>;
+    private extractCode;
+    private callAPI;
+}
+interface TogetherAdapterConfig {
+    apiKey: string;
+    model?: string;
+}
+declare class TogetherAdapter implements AIAdapter {
+    readonly id = "together";
+    readonly name = "Together AI";
+    private config;
+    private model;
+    constructor(config: TogetherAdapterConfig);
+    getEmbeddings(text: string | string[]): Promise<number[][]>;
+    isReady(): boolean;
+    generateHoloScript(prompt: string, _options?: GenerateOptions): Promise<GenerateResult>;
+    explainHoloScript(holoScript: string): Promise<ExplainResult>;
+    optimizeHoloScript(holoScript: string, target: 'mobile' | 'desktop' | 'vr' | 'ar'): Promise<OptimizeResult>;
+    fixHoloScript(holoScript: string, errors: string[]): Promise<FixResult>;
+    chat(message: string, holoScript?: string, history?: Array<{
+        role: 'user' | 'assistant';
+        content: string;
+    }>): Promise<string>;
+    private extractCode;
+    private callAPI;
+}
+interface FireworksAdapterConfig {
+    apiKey: string;
+    model?: string;
+}
+declare class FireworksAdapter implements AIAdapter {
+    readonly id = "fireworks";
+    readonly name = "Fireworks AI";
+    private config;
+    private model;
+    constructor(config: FireworksAdapterConfig);
+    isReady(): boolean;
+    generateHoloScript(prompt: string, _options?: GenerateOptions): Promise<GenerateResult>;
+    explainHoloScript(holoScript: string): Promise<ExplainResult>;
+    optimizeHoloScript(holoScript: string, target: 'mobile' | 'desktop' | 'vr' | 'ar'): Promise<OptimizeResult>;
+    fixHoloScript(holoScript: string, errors: string[]): Promise<FixResult>;
+    chat(message: string, holoScript?: string, history?: Array<{
+        role: 'user' | 'assistant';
+        content: string;
+    }>): Promise<string>;
+    private extractCode;
+    private callAPI;
+    getEmbeddings(text: string | string[]): Promise<number[][]>;
+}
+interface NVIDIAAdapterConfig {
+    apiKey: string;
+    model?: string;
+    baseUrl?: string;
+}
+declare class NVIDIAAdapter implements AIAdapter {
+    readonly id = "nvidia";
+    readonly name = "NVIDIA NIM";
+    private config;
+    private model;
+    private baseUrl;
+    constructor(config: NVIDIAAdapterConfig);
+    isReady(): boolean;
+    generateHoloScript(prompt: string, _options?: GenerateOptions): Promise<GenerateResult>;
+    explainHoloScript(holoScript: string): Promise<ExplainResult>;
+    optimizeHoloScript(holoScript: string, target: 'mobile' | 'desktop' | 'vr' | 'ar'): Promise<OptimizeResult>;
+    fixHoloScript(holoScript: string, errors: string[]): Promise<FixResult>;
+    chat(message: string, holoScript?: string, history?: Array<{
+        role: 'user' | 'assistant';
+        content: string;
+    }>): Promise<string>;
+    private extractCode;
+    private callAPI;
+    getEmbeddings(text: string | string[]): Promise<number[][]>;
+}
+/**
+ * Create and register a Gemini adapter
+ */
+declare function useGemini(config: GeminiAdapterConfig): GeminiAdapter;
+/**
+ * Create and register an xAI (Grok) adapter
+ */
+declare function useXAI(config: XAIAdapterConfig): XAIAdapter;
+/** Alias for useXAI */
+declare const useGrok: typeof useXAI;
+/**
+ * Create and register a Together AI adapter
+ */
+declare function useTogether(config: TogetherAdapterConfig): TogetherAdapter;
+/**
+ * Create and register a Fireworks AI adapter
+ */
+declare function useFireworks(config: FireworksAdapterConfig): FireworksAdapter;
+/**
+ * Create and register an NVIDIA NIM adapter
+ */
+declare function useNVIDIA(config: NVIDIAAdapterConfig): NVIDIAAdapter;
+
+/**
+ * SemanticSearchService
+ *
+ * Provides vector-based search for HoloScript traits.
+ */
+
+interface SearchResult<T> {
+    item: T;
+    score: number;
+}
+declare class SemanticSearchService<T extends {
+    name: string;
+    description: string;
+}> {
+    private adapter;
+    private items;
+    private embeddings;
+    constructor(adapter: AIAdapter, items: T[]);
+    /**
+     * Pre-calculate embeddings for all items
+     */
+    initialize(): Promise<void>;
+    /**
+     * Search for items similar to the query
+     */
+    search(query: string, limit?: number): Promise<SearchResult<T>[]>;
+    /**
+     * Calculate cosine similarity between two vectors
+     */
+    private cosineSimilarity;
+}
+
+/**
+ * BTNodes.ts
+ *
+ * Behavior tree node types: composite (sequence, selector, parallel),
+ * decorator (inverter, repeater, guard), leaf (action, condition, wait).
+ *
+ * @module ai
+ */
+type BTStatus = 'success' | 'failure' | 'running' | 'ready';
+interface BTContext$1 {
+    blackboard: {
+        get: (key: string) => unknown;
+        set: (key: string, value: unknown) => void;
+    };
+    deltaTime: number;
+    entity: string;
+}
+declare abstract class BTNode {
+    name: string;
+    status: BTStatus;
+    children: BTNode[];
+    constructor(name: string);
+    abstract tick(ctx: BTContext$1): BTStatus;
+    reset(): void;
+}
+declare class SequenceNode extends BTNode {
+    private currentIndex;
+    constructor(name: string, children: BTNode[]);
+    tick(ctx: BTContext$1): BTStatus;
+    reset(): void;
+}
+declare class SelectorNode extends BTNode {
+    private currentIndex;
+    constructor(name: string, children: BTNode[]);
+    tick(ctx: BTContext$1): BTStatus;
+    reset(): void;
+}
+declare class ParallelNode extends BTNode {
+    private requiredSuccesses;
+    constructor(name: string, children: BTNode[], requiredSuccesses?: number);
+    tick(ctx: BTContext$1): BTStatus;
+}
+declare class InverterNode extends BTNode {
+    constructor(name: string, child: BTNode);
+    tick(ctx: BTContext$1): BTStatus;
+}
+declare class RepeaterNode extends BTNode {
+    private maxRepeats;
+    private count;
+    constructor(name: string, child: BTNode, repeats?: number);
+    tick(ctx: BTContext$1): BTStatus;
+    reset(): void;
+}
+declare class GuardNode extends BTNode {
+    private condition;
+    constructor(name: string, condition: (ctx: BTContext$1) => boolean, child: BTNode);
+    tick(ctx: BTContext$1): BTStatus;
+}
+declare class ActionNode extends BTNode {
+    private action;
+    constructor(name: string, action: (ctx: BTContext$1) => BTStatus);
+    tick(ctx: BTContext$1): BTStatus;
+}
+declare class ConditionNode extends BTNode {
+    private condition;
+    constructor(name: string, condition: (ctx: BTContext$1) => boolean);
+    tick(ctx: BTContext$1): BTStatus;
+}
+declare class WaitNode extends BTNode {
+    private duration;
+    private elapsed;
+    constructor(name: string, seconds: number);
+    tick(ctx: BTContext$1): BTStatus;
+    reset(): void;
+}
+
+declare class Blackboard {
+    private data;
+    private observers;
+    private scopes;
+    private history;
+    private maxHistory;
+    set(key: string, value: unknown, scope?: string): void;
+    get<T = unknown>(key: string): T | undefined;
+    has(key: string): boolean;
+    delete(key: string): boolean;
+    getByScope(scope: string): Map<string, unknown>;
+    clearScope(scope: string): number;
+    getScopes(): string[];
+    observe(key: string, callback: (key: string, value: unknown, old: unknown) => void): void;
+    observeAll(callback: (key: string, value: unknown, old: unknown) => void): void;
+    private notifyObservers;
+    getEntryCount(): number;
+    getKeys(): string[];
+    getVersion(key: string): number;
+    getHistory(): typeof this.history;
+    clear(): void;
+    toJSON(): Record<string, unknown>;
+    fromJSON(data: Record<string, unknown>, scope?: string): void;
+}
+
+/**
+ * BehaviorTree.ts
+ *
+ * Behavior tree runner: tick-based evaluation, status propagation,
+ * subtree mounting, conditional abort, and debug tracing.
+ *
+ * @module ai
+ */
+
+interface BTContext {
+    blackboard: Blackboard;
+    deltaTime: number;
+    entity: string;
+}
+interface BTTreeDef {
+    id: string;
+    root: BTNode;
+    context: BTContext;
+    status: BTStatus;
+    tickCount: number;
+    aborted: boolean;
+}
+declare class BehaviorTree {
+    private trees;
+    private subtrees;
+    private debugTrace;
+    private tracing;
+    createTree(id: string, root: BTNode, entity: string, blackboard?: Blackboard): BTTreeDef;
+    removeTree(id: string): boolean;
+    getTree(id: string): BTTreeDef | undefined;
+    registerSubtree(name: string, root: BTNode): void;
+    getSubtree(name: string): BTNode | undefined;
+    tick(id: string, dt: number): BTStatus;
+    tickAll(dt: number): void;
+    private tickNode;
+    abort(id: string): void;
+    enableTracing(): void;
+    disableTracing(): void;
+    getTrace(): typeof this.debugTrace;
+    clearTrace(): void;
+    getTreeCount(): number;
+    getStatus(id: string): BTStatus;
+}
+
+/**
+ * StateMachine.ts
+ *
+ * Hierarchical state machine: states with enter/exit/update hooks,
+ * transitions with guards, sub-state machines, and event dispatch.
+ *
+ * @module ai
+ */
+type StateAction = (context: Record<string, unknown>) => void;
+type GuardFn = (context: Record<string, unknown>) => boolean;
+interface StateConfig {
+    id: string;
+    onEnter?: StateAction;
+    onExit?: StateAction;
+    onUpdate?: StateAction;
+    parent?: string;
+}
+interface TransitionConfig {
+    from: string;
+    to: string;
+    event: string;
+    guard?: GuardFn;
+    action?: StateAction;
+}
+declare class StateMachine {
+    private states;
+    private transitions;
+    private currentStateId;
+    private context;
+    private history;
+    private maxHistory;
+    addState(config: StateConfig): void;
+    removeState(id: string): void;
+    setInitialState(id: string): void;
+    getCurrentState(): string | null;
+    addTransition(config: TransitionConfig): void;
+    send(event: string): boolean;
+    private getTransitionsFor;
+    private getStateChain;
+    update(): void;
+    setContext(key: string, value: unknown): void;
+    getContext(key: string): unknown;
+    getStateCount(): number;
+    getHistory(): string[];
+    isInState(id: string): boolean;
+    getChildStates(parentId: string): string[];
+}
+
+/**
+ * SteeringBehavior — Seek/flee/arrive/wander/avoid with weighted blending
+ *
+ * @version 1.0.0
+ */
+interface Vec2 {
+    x: number;
+    z: number;
+}
+type SteeringType = 'seek' | 'flee' | 'arrive' | 'wander' | 'avoid' | 'pursue' | 'evade';
+interface SteeringAgent$1 {
+    position: Vec2;
+    velocity: Vec2;
+    maxSpeed: number;
+    maxForce: number;
+    mass: number;
+}
+interface SteeringOutput {
+    force: Vec2;
+    type: SteeringType;
+    weight: number;
+}
+declare class SteeringBehavior {
+    /**
+     * Seek — steer toward a target
+     */
+    static seek(agent: SteeringAgent$1, target: Vec2): Vec2;
+    /**
+     * Flee — steer away from a target
+     */
+    static flee(agent: SteeringAgent$1, target: Vec2): Vec2;
+    /**
+     * Arrive — seek with deceleration near target
+     */
+    static arrive(agent: SteeringAgent$1, target: Vec2, slowRadius?: number): Vec2;
+    /**
+     * Wander — random jitter-based steering
+     */
+    static wander(agent: SteeringAgent$1, wanderRadius?: number, wanderDistance?: number, jitter?: number): Vec2;
+    /**
+     * Obstacle avoidance
+     */
+    static avoid(agent: SteeringAgent$1, obstacles: {
+        position: Vec2;
+        radius: number;
+    }[], lookAhead?: number): Vec2;
+    /**
+     * Blend multiple steering outputs by weight
+     */
+    static blend(outputs: SteeringOutput[], maxForce: number): Vec2;
+}
+
+/**
+ * SteeringBehaviors.ts
+ *
+ * Autonomous agent steering: seek, flee, arrive, wander,
+ * flock (separation/alignment/cohesion), and obstacle avoidance.
+ *
+ * @module ai
+ */
+interface SteeringAgent {
+    position: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    velocity: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    maxSpeed: number;
+    maxForce: number;
+    mass: number;
+}
+interface FlockConfig {
+    separationWeight: number;
+    alignmentWeight: number;
+    cohesionWeight: number;
+    neighborRadius: number;
+}
+interface ObstacleCircle {
+    center: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    radius: number;
+}
+type Vec3 = {
+    x: number;
+    y: number;
+    z: number;
+};
+declare class SteeringBehaviors {
+    static seek(agent: SteeringAgent, target: Vec3): Vec3;
+    static flee(agent: SteeringAgent, threat: Vec3): Vec3;
+    static arrive(agent: SteeringAgent, target: Vec3, slowRadius: number): Vec3;
+    static wander(agent: SteeringAgent, circleDistance: number, circleRadius: number, angleJitter: number, currentAngle: number): {
+        force: Vec3;
+        newAngle: number;
+    };
+    static flock(agent: SteeringAgent, neighbors: SteeringAgent[], config: FlockConfig): Vec3;
+    private static separation;
+    private static alignment;
+    private static cohesion;
+    static obstacleAvoidance(agent: SteeringAgent, obstacles: ObstacleCircle[], lookAhead: number): Vec3;
+    static applyForce(agent: SteeringAgent, force: Vec3, dt: number): void;
+    private static sub;
+    private static add;
+    private static scale;
+    private static vecLength;
+    private static distance;
+    private static normalize;
+    private static truncate;
+}
+
+/**
+ * NavMesh — Navigation mesh with polygon walk and path smoothing
+ *
+ * @version 1.0.0
+ */
+interface NavPolygon {
+    id: number;
+    vertices: {
+        x: number;
+        z: number;
+    }[];
+    neighbors: number[];
+    center: {
+        x: number;
+        z: number;
+    };
+    walkable: boolean;
+    cost: number;
+}
+interface NavPath {
+    waypoints: {
+        x: number;
+        z: number;
+    }[];
+    totalCost: number;
+    polygonIds: number[];
+}
+declare class NavMesh {
+    private polygons;
+    private nextId;
+    /**
+     * Add a navigation polygon
+     */
+    addPolygon(vertices: {
+        x: number;
+        z: number;
+    }[], walkable?: boolean, cost?: number): number;
+    /**
+     * Connect two polygons as neighbors
+     */
+    connect(a: number, b: number): boolean;
+    /**
+     * Find path using A*
+     */
+    findPath(startPoly: number, endPoly: number): NavPath | null;
+    /**
+     * Smooth a path using string-pulling (funnel algorithm simplified)
+     */
+    smoothPath(path: NavPath): NavPath;
+    private reconstructPath;
+    private heuristic;
+    getPolygon(id: number): NavPolygon | undefined;
+    getPolygonCount(): number;
+    setWalkable(id: number, walkable: boolean): void;
+}
+
+/**
+ * PerceptionSystem.ts
+ *
+ * AI perception: sight/hearing/smell sense cones, stimulus memory,
+ * priority scoring, and detection events.
+ *
+ * @module ai
+ */
+type SenseType = 'sight' | 'hearing' | 'smell';
+interface Stimulus {
+    id: string;
+    type: SenseType;
+    sourceId: string;
+    position: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    intensity: number;
+    timestamp: number;
+    data?: unknown;
+}
+interface SenseConfig {
+    type: SenseType;
+    range: number;
+    fov: number;
+    sensitivity: number;
+}
+interface PerceivedStimulus extends Stimulus {
+    awareness: number;
+    lastSeen: number;
+}
+declare class PerceptionSystem {
+    private entities;
+    private stimuli;
+    registerEntity(id: string, senses: SenseConfig[], memoryDuration?: number): void;
+    setEntityTransform(entityId: string, position: {
+        x: number;
+        y: number;
+        z: number;
+    }, facing: {
+        x: number;
+        y: number;
+        z: number;
+    }): void;
+    addStimulus(stimulus: Stimulus): void;
+    removeStimulus(id: string): void;
+    update(time: number): void;
+    getPerceivedStimuli(entityId: string): PerceivedStimulus[];
+    getHighestPriority(entityId: string): PerceivedStimulus | null;
+    isAwareOf(entityId: string, stimulusId: string): boolean;
+    getStimulusCount(): number;
+}
+
+/**
+ * InfluenceMap.ts
+ *
+ * Grid-based influence map: propagation, decay, multi-layer
+ * support, and spatial queries.
+ *
+ * @module ai
+ */
+interface InfluenceConfig {
+    width: number;
+    height: number;
+    cellSize: number;
+    decayRate: number;
+    propagationRate: number;
+    maxValue: number;
+}
+declare class InfluenceMap {
+    private layers;
+    private config;
+    constructor(config: InfluenceConfig);
+    addLayer(name: string): void;
+    removeLayer(name: string): void;
+    getLayerNames(): string[];
+    setInfluence(layer: string, gx: number, gy: number, value: number): void;
+    addInfluence(layer: string, gx: number, gy: number, value: number): void;
+    stampRadius(layer: string, cx: number, cy: number, radius: number, value: number): void;
+    update(): void;
+    getInfluence(layer: string, gx: number, gy: number): number;
+    getInfluenceAtWorld(layer: string, wx: number, wy: number): number;
+    getMaxCell(layer: string): {
+        x: number;
+        y: number;
+        value: number;
+    };
+    clear(layer: string): void;
+    clearAll(): void;
+}
+
+/**
+ * UtilityAI.ts
+ *
+ * Utility-based AI: action scoring with consideration curves,
+ * weighted selection, cooldowns, and action history.
+ *
+ * @module ai
+ */
+type CurveType = 'linear' | 'quadratic' | 'logistic' | 'step';
+interface Consideration {
+    name: string;
+    input: () => number;
+    curve: CurveType;
+    weight: number;
+    invert: boolean;
+}
+interface UtilityAction {
+    id: string;
+    name: string;
+    considerations: Consideration[];
+    cooldown: number;
+    lastExecuted: number;
+    bonus: number;
+    execute: () => void;
+}
+declare class UtilityAI {
+    private actions;
+    private history;
+    private maxHistory;
+    private currentTime;
+    addAction(action: UtilityAction): void;
+    removeAction(id: string): void;
+    scoreAction(action: UtilityAction): number;
+    scoreAll(): Array<{
+        actionId: string;
+        score: number;
+    }>;
+    selectBest(): UtilityAction | null;
+    executeBest(): string | null;
+    setTime(time: number): void;
+    getHistory(): {
+        actionId: string;
+        score: number;
+        timestamp: number;
+    }[];
+    getActionCount(): number;
+}
+
+/**
+ * BehaviorSelector.ts
+ *
+ * Behavior selection: weighted random, priority-based, and
+ * conditional behavior picking with fallbacks and lockout timers.
+ *
+ * @module ai
+ */
+interface Behavior {
+    id: string;
+    name: string;
+    weight: number;
+    priority: number;
+    condition?: () => boolean;
+    action: () => void;
+    lockoutMs: number;
+    lastExecuted: number;
+}
+type SelectionMode = 'priority' | 'weighted' | 'sequential';
+declare class BehaviorSelector {
+    private behaviors;
+    private mode;
+    private currentIndex;
+    private currentTime;
+    private fallback;
+    private history;
+    private maxHistory;
+    constructor(mode?: SelectionMode);
+    addBehavior(behavior: Behavior): void;
+    removeBehavior(id: string): void;
+    setFallback(behavior: Behavior): void;
+    setMode(mode: SelectionMode): void;
+    select(): Behavior | null;
+    private getAvailable;
+    private selectByPriority;
+    private selectByWeight;
+    private selectSequential;
+    execute(): string | null;
+    setTime(time: number): void;
+    getBehaviorCount(): number;
+    getHistory(): {
+        behaviorId: string;
+        timestamp: number;
+    }[];
+}
+
+/**
+ * GoalPlanner.ts
+ *
+ * GOAP-style goal planner: goal states, actions with preconditions
+ * and effects, backward chaining plan generation, and plan execution.
+ *
+ * @module ai
+ */
+type WorldState = Map<string, boolean>;
+interface PlanAction {
+    id: string;
+    name: string;
+    cost: number;
+    preconditions: Map<string, boolean>;
+    effects: Map<string, boolean>;
+    execute: () => void;
+}
+interface Goal {
+    id: string;
+    name: string;
+    conditions: Map<string, boolean>;
+    priority: number;
+}
+interface Plan {
+    actions: PlanAction[];
+    totalCost: number;
+    goalId: string;
+}
+declare class GoalPlanner {
+    private actions;
+    private goals;
+    addAction(action: PlanAction): void;
+    addGoal(goal: Goal): void;
+    removeAction(id: string): void;
+    removeGoal(id: string): void;
+    plan(currentState: WorldState): Plan | null;
+    private findPlan;
+    private satisfiesGoal;
+    private preconditionsMet;
+    private stateKey;
+    executePlan(plan: Plan): void;
+    getActionCount(): number;
+    getGoalCount(): number;
+}
+
+/**
+ * Generation Analytics & Metrics
+ *
+ * Tracks and analyzes generation metrics:
+ * - Success rates by adapter
+ * - Confidence score distributions
+ * - Code quality metrics
+ * - Performance metrics
+ * - User patterns and trends
+ */
+interface GenerationMetrics {
+    promptLength: number;
+    codeLength: number;
+    confidence: number;
+    parseSuccess: boolean;
+    errorCount: number;
+    wasFixed: boolean;
+    responseTimeMs: number;
+    attemptsNeeded: number;
+    adapterName: string;
+    timestamp: Date;
+    platform?: string;
+}
+interface MetricsAggregate {
+    totalGenerations: number;
+    successRate: number;
+    avgConfidence: number;
+    avgResponseTime: number;
+    avgErrorCount: number;
+    avgAttemptsNeeded: number;
+    mostCommonAdapter: string;
+    mostCommonPlatform: string;
+}
+interface AdapterMetrics {
+    name: string;
+    generationCount: number;
+    successRate: number;
+    avgConfidence: number;
+    avgResponseTime: number;
+    bestFor: string[];
+    reliabilityScore: number;
+}
+interface TimeSeriesMetrics {
+    timestamp: Date;
+    successRate: number;
+    avgConfidence: number;
+    avgResponseTime: number;
+    generationCount: number;
+}
+declare class GenerationAnalytics {
+    private metrics;
+    private timeSeriesWindow;
+    /**
+     * Record a generation metric
+     */
+    recordMetric(metric: GenerationMetrics): void;
+    /**
+     * Get all metrics
+     */
+    getAllMetrics(): GenerationMetrics[];
+    /**
+     * Clear metrics
+     */
+    clearMetrics(): void;
+    /**
+     * Get aggregate metrics
+     */
+    getAggregateMetrics(): MetricsAggregate;
+    /**
+     * Get metrics by adapter
+     */
+    getMetricsByAdapter(adapterName: string): AdapterMetrics;
+    /**
+     * Get all adapter metrics
+     */
+    getAllAdapterMetrics(): AdapterMetrics[];
+    /**
+     * Get confidence distribution
+     */
+    getConfidenceDistribution(): {
+        range: string;
+        count: number;
+        percentage: number;
+    }[];
+    /**
+     * Get error patterns
+     */
+    getErrorPatterns(): {
+        errorType: string;
+        frequency: number;
+        percentage: number;
+    }[];
+    /**
+     * Get response time distribution
+     */
+    getResponseTimeDistribution(): {
+        range: string;
+        count: number;
+        percentage: number;
+    }[];
+    /**
+     * Get time series metrics for a window
+     */
+    getTimeSeries(windowMs?: number): TimeSeriesMetrics[];
+    /**
+     * Get recommendations based on metrics
+     */
+    getRecommendations(): string[];
+    /**
+     * Export metrics as JSON
+     */
+    exportMetrics(): string;
+    /**
+     * Create a detailed report
+     */
+    generateReport(): string;
+}
+/**
+ * Quick analytics creation
+ */
+declare function createAnalytics(): GenerationAnalytics;
+
+/**
+ * Generation Cache System
+ *
+ * Caches generated HoloScript code to avoid redundant API calls.
+ * Implements LRU (Least Recently Used) eviction policy.
+ *
+ * Features:
+ * - Prompt-based caching (hash of prompt + adapter)
+ * - TTL (Time-To-Live) support
+ * - Statistics tracking
+ * - Serialization for persistence
+ */
+interface CacheEntry {
+    prompt: string;
+    code: string;
+    confidence: number;
+    timestamp: number;
+    ttl?: number;
+    hits: number;
+    adapterName: string;
+}
+interface CacheStats {
+    totalHits: number;
+    totalMisses: number;
+    hitRate: number;
+    entriesCount: number;
+    maxSize: number;
+    averageHitCount: number;
+}
+declare class GenerationCache {
+    private cache;
+    private maxSize;
+    private ttlMs;
+    private hits;
+    private misses;
+    constructor(options?: {
+        maxSize?: number;
+        ttlMs?: number;
+    });
+    /**
+     * Generate cache key from prompt and adapter
+     */
+    private generateKey;
+    /**
+     * Get cached code if available and valid
+     */
+    get(prompt: string, adapterName: string): CacheEntry | null;
+    /**
+     * Store generated code in cache
+     */
+    set(prompt: string, code: string, confidence: number, adapterName: string): void;
+    /**
+     * Evict least recently used entry
+     */
+    private evictLRU;
+    /**
+     * Clear entire cache
+     */
+    clear(): void;
+    /**
+     * Get cache statistics
+     */
+    getStats(): CacheStats;
+    /**
+     * Export cache as JSON
+     */
+    serialize(): string;
+    /**
+     * Import cache from JSON
+     */
+    deserialize(json: string): void;
+    /**
+     * Get all cache entries
+     */
+    getEntries(): CacheEntry[];
+    /**
+     * Remove specific entry
+     */
+    remove(prompt: string, adapterName: string): boolean;
+    /**
+     * Get cache size in bytes (approximate)
+     */
+    getSize(): number;
+}
+interface CachedGenerationResult {
+    code: string;
+    confidence: number;
+    fromCache: boolean;
+    cacheAge?: number;
+}
+/**
+ * Wrap generation with caching
+ */
+declare function cachedGenerate(prompt: string, adapterName: string, cache: GenerationCache, generator: () => Promise<{
+    holoScript: string;
+    aiConfidence: number;
+}>): Promise<CachedGenerationResult>;
+
+interface GenerationConfig {
+    /** Maximum attempts to generate valid code */
+    maxAttempts: number;
+    /** Target platform for optimization */
+    targetPlatform: 'mobile' | 'desktop' | 'vr' | 'ar';
+    /** Auto-fix errors if generation is invalid */
+    autoFix: boolean;
+    /** Minimum confidence threshold (0-1) */
+    minConfidence: number;
+}
+interface GeneratedCode {
+    /** The generated HoloScript code */
+    holoScript: string;
+    /** Confidence score from AI (0-1) */
+    aiConfidence: number;
+    /** Parse result */
+    parseResult: HSPlusCompileResult;
+    /** Was auto-fixed */
+    wasFixed: boolean;
+    /** Number of attempts before success */
+    attempts: number;
+    /** Explanation of generated code */
+    explanation?: string;
+}
+interface GenerationHistory {
+    /** Prompt that was used */
+    prompt: string;
+    /** Generated code */
+    generated: GeneratedCode;
+    /** Timestamp */
+    timestamp: Date;
+    /** Attempt number in session */
+    sessionAttempt: number;
+}
+interface GenerationSession {
+    /** Unique session ID */
+    sessionId: string;
+    /** All generations in this session */
+    history: GenerationHistory[];
+    /** AI adapter used */
+    adapter: AIAdapter;
+    /** Configuration */
+    config: GenerationConfig;
+}
+declare class HoloScriptGenerator {
+    private parser;
+    private currentSession?;
+    private sessionCounter;
+    private cache;
+    private analytics;
+    private cacheEnabled;
+    constructor(enableCache?: boolean);
+    /**
+     * Create a new generation session
+     */
+    createSession(adapter: AIAdapter, config?: Partial<GenerationConfig>): GenerationSession;
+    /**
+     * Generate HoloScript from a natural language prompt
+     */
+    generate(prompt: string, session?: GenerationSession): Promise<GeneratedCode>;
+    /**
+     * Optimize generated code for a target platform
+     */
+    optimize(code: string, targetPlatform: 'mobile' | 'desktop' | 'vr' | 'ar', session?: GenerationSession): Promise<GeneratedCode>;
+    /**
+     * Fix invalid HoloScript code
+     */
+    fix(code: string, session?: GenerationSession): Promise<GeneratedCode>;
+    /**
+     * Explain generated code
+     */
+    explain(code: string, session?: GenerationSession): Promise<string>;
+    /**
+     * Multi-turn conversation for iterative code generation
+     */
+    chat(message: string, session?: GenerationSession, history?: Array<{
+        role: 'user' | 'assistant';
+        content: string;
+    }>): Promise<string>;
+    /**
+     * Get current generation session
+     */
+    getCurrentSession(): GenerationSession | undefined;
+    /**
+     * Get generation history
+     */
+    getHistory(session?: GenerationSession): GenerationHistory[];
+    /**
+     * Clear history
+     */
+    clearHistory(session?: GenerationSession): void;
+    /**
+     * Get statistics for a session
+     */
+    getStats(session?: GenerationSession): {
+        totalGenerations: number;
+        successCount: number;
+        fixedCount: number;
+        avgAttempts: number;
+        avgConfidence: number;
+        successRate: number;
+    } | null;
+    /**
+     * Get cache statistics
+     */
+    getCacheStats(): CacheStats;
+    /**
+     * Get analytics metrics
+     */
+    getAnalytics(): {
+        aggregateMetrics: MetricsAggregate;
+        adapterMetrics: AdapterMetrics[];
+        confidenceDistribution: {
+            range: string;
+            count: number;
+            percentage: number;
+        }[];
+        responseTimeDistribution: {
+            range: string;
+            count: number;
+            percentage: number;
+        }[];
+        errorPatterns: {
+            errorType: string;
+            frequency: number;
+            percentage: number;
+        }[];
+        recommendations: string[];
+    };
+    /**
+     * Generate analytics report
+     */
+    generateReport(): string;
+}
+/**
+ * Quick generation helper
+ */
+declare function generateHoloScript(prompt: string, adapter: AIAdapter, config?: Partial<GenerationConfig>): Promise<GeneratedCode>;
+/**
+ * Batch generation helper
+ */
+declare function generateBatch(prompts: string[], adapter: AIAdapter, config?: Partial<GenerationConfig>): Promise<GeneratedCode[]>;
+/**
+ * Validate batch of generated code
+ */
+declare function validateBatch(codes: string[]): Array<{
+    code: string;
+    valid: boolean;
+    errors: number;
+}>;
+
+/**
+ * HoloScript AI Training Data Generator
+ *
+ * Generates diverse HoloScript examples for AI model training.
+ * Creates input/output pairs covering all language features.
+ *
+ * @version 1.0.0
+ */
+interface TrainingExample {
+    id: string;
+    category: TrainingCategory;
+    description: string;
+    holoScript: string;
+    expectedOutput?: {
+        type: 'r3f' | 'visionos' | 'usda';
+        snippet?: string;
+    };
+    tags: string[];
+    complexity: 'basic' | 'intermediate' | 'advanced';
+}
+type TrainingCategory = 'geometry' | 'materials' | 'physics' | 'interactions' | 'audio' | 'ui' | 'composition' | 'state' | 'logic' | 'traits' | 'animations' | 'ar_vr' | 'accessibility';
+interface GeneratorOptions {
+    count?: number;
+    categories?: TrainingCategory[];
+    complexityFilter?: ('basic' | 'intermediate' | 'advanced')[];
+    includeExpectedOutput?: boolean;
+}
+declare class TrainingDataGenerator {
+    private allExamples;
+    constructor();
+    /**
+     * Generate training examples based on options
+     */
+    generate(options?: GeneratorOptions): TrainingExample[];
+    /**
+     * Generate all examples
+     */
+    generateAll(): TrainingExample[];
+    /**
+     * Get examples by category
+     */
+    getByCategory(category: TrainingCategory): TrainingExample[];
+    /**
+     * Get examples by complexity
+     */
+    getByComplexity(complexity: 'basic' | 'intermediate' | 'advanced'): TrainingExample[];
+    /**
+     * Get examples by tag
+     */
+    getByTag(tag: string): TrainingExample[];
+    /**
+     * Get category statistics
+     */
+    getStats(): Record<TrainingCategory, number>;
+    /**
+     * Export as JSON for training
+     */
+    exportJSON(): string;
+    /**
+     * Export as JSONL (one JSON per line)
+     */
+    exportJSONL(): string;
+    private shuffleArray;
+}
+declare const ALL_CATEGORIES: TrainingCategory[];
+declare function createTrainingDataGenerator(): TrainingDataGenerator;
+
+/**
+ * Prompt Templates System
+ *
+ * Provides pre-built prompt templates for common HoloScript generation tasks.
+ * Supports:
+ * - Variable interpolation
+ * - Context-aware suggestions
+ * - Template composition
+ * - Custom template creation
+ */
+interface PromptTemplate {
+    id: string;
+    name: string;
+    description: string;
+    category: string;
+    template: string;
+    variables: string[];
+    examples: string[];
+    bestFor: string;
+}
+interface TemplateContext {
+    [key: string]: string | number | boolean;
+}
+declare class PromptTemplateSystem {
+    private customTemplates;
+    /**
+     * Get all available templates
+     */
+    getAvailableTemplates(): PromptTemplate[];
+    /**
+     * Get templates by category
+     */
+    getTemplatesByCategory(category: string): PromptTemplate[];
+    /**
+     * Get a specific template
+     */
+    getTemplate(id: string): PromptTemplate | null;
+    /**
+     * Create a prompt from template with context
+     */
+    createPrompt(templateId: string, context: TemplateContext): string;
+    /**
+     * Validate context against template
+     */
+    validateContext(templateId: string, context: TemplateContext): {
+        valid: boolean;
+        missing: string[];
+    };
+    /**
+     * Register custom template
+     */
+    registerTemplate(template: PromptTemplate): void;
+    /**
+     * Get template suggestions for a category
+     */
+    suggestTemplates(category: string, query?: string): PromptTemplate[];
+    /**
+     * Get all categories
+     */
+    getCategories(): string[];
+    /**
+     * Create a batch of prompts from templates
+     */
+    createBatch(templates: Array<{
+        templateId: string;
+        context: TemplateContext;
+    }>): string[];
+}
+/**
+ * Quick prompt creation helpers
+ */
+declare const QuickPrompts: {
+    /**
+     * Create prompt for a simple object
+     */
+    object(geometry: string, color: string, position: [number, number, number]): string;
+    /**
+     * Create prompt for an interactive object
+     */
+    interactive(color: string, geometry: string, interaction: string, purpose: string): string;
+    /**
+     * Create prompt for a physics object
+     */
+    physics(geometry: string, physics_type: string, mass: number, restitution: number): string;
+    /**
+     * Create prompt for a player controller
+     */
+    player(geometry: string, movement_type: string, health: number, abilities: string): string;
+    /**
+     * Create prompt for networked object
+     */
+    networked(object_type: string, synced_properties: string, sync_rate: number): string;
+};
+
+/**
+ * AICopilot.ts
+ *
+ * Editor-aware AI assistant that bridges the existing AIAdapter/HoloScriptGenerator
+ * infrastructure with the runtime and editor for real-time AI assistance.
+ *
+ * @module ai
+ */
+
+interface CopilotContext {
+    /** Currently selected entity type/id */
+    selectedEntity?: {
+        id: string;
+        type: string;
+        properties?: Record<string, unknown>;
+    };
+    /** Current scene node types */
+    sceneNodeTypes?: string[];
+    /** Active state keys */
+    stateKeys?: string[];
+    /** Recent user actions */
+    recentActions?: string[];
+}
+interface CopilotSuggestion {
+    type: 'modify' | 'create' | 'explain' | 'fix';
+    description: string;
+    holoScript?: string;
+    confidence: number;
+}
+interface CopilotResponse {
+    text: string;
+    suggestions: CopilotSuggestion[];
+    generatedCode?: GeneratedCode;
+    error?: string;
+}
+interface CopilotMessage {
+    role: 'user' | 'assistant';
+    content: string;
+    timestamp: number;
+}
+declare class AICopilot {
+    private adapter;
+    private generator;
+    private history;
+    private context;
+    constructor(adapter?: AIAdapter);
+    setAdapter(adapter: AIAdapter): void;
+    getAdapter(): AIAdapter | null;
+    isReady(): boolean;
+    updateContext(context: Partial<CopilotContext>): void;
+    getContext(): CopilotContext;
+    /**
+     * Generate HoloScript from a natural language prompt.
+     * Uses the full HoloScriptGenerator pipeline (generate → validate → auto-fix).
+     */
+    generateFromPrompt(prompt: string, options?: Partial<GenerateOptions>): Promise<CopilotResponse>;
+    /**
+     * Suggest modifications for the currently selected entity.
+     */
+    suggestFromSelection(): Promise<CopilotResponse>;
+    /**
+     * Explain the current scene in natural language.
+     */
+    explainScene(sceneCode: string): Promise<CopilotResponse>;
+    /**
+     * Auto-fix runtime errors using the AI adapter.
+     */
+    autoFix(code: string, errors: string[]): Promise<CopilotResponse>;
+    /**
+     * Chat with the AI about HoloScript code (multi-turn conversation).
+     */
+    chat(message: string): Promise<CopilotResponse>;
+    getHistory(): CopilotMessage[];
+    clearHistory(): void;
+    private addMessage;
+}
+
+/**
+ * AI Output Validator
+ *
+ * Validates AI-generated HoloScript code before execution.
+ * Catches structural errors, dangerous patterns, and excessive complexity.
+ *
+ * @module ai
+ */
+interface ValidationIssue {
+    severity: 'error' | 'warning' | 'info';
+    message: string;
+    line?: number;
+    rule: string;
+}
+interface ValidationResult {
+    valid: boolean;
+    issues: ValidationIssue[];
+    confidence: number;
+    stats: {
+        lineCount: number;
+        traitCount: number;
+        dangerousPatternCount: number;
+        maxNesting: number;
+    };
+}
+interface ValidatorConfig {
+    maxLines: number;
+    maxNesting: number;
+    maxTraits: number;
+    allowedTraits?: string[];
+    blockDangerousPatterns: boolean;
+}
+/**
+ * Validate AI-generated code for safety and correctness.
+ */
+declare function validateAIOutput(code: string, config?: Partial<ValidatorConfig>): ValidationResult;
+/**
+ * Quick check — returns true if code passes all error-level checks.
+ */
+declare function isAISafe(code: string, config?: Partial<ValidatorConfig>): boolean;
+
+export { type AIAdapter, AICopilot, ALL_CATEGORIES, ActionNode, AnthropicAdapter, type AnthropicAdapterConfig, BTNode, type BTStatus, type BTContext as BTTreeContext, type BTTreeDef, BehaviorSelector, BehaviorTree, Blackboard, ConditionNode, type ExplainResult, FireworksAdapter, type FireworksAdapterConfig, type FixResult, GeminiAdapter, type GeminiAdapterConfig, type GenerateOptions, type GenerateResult, GenerationAnalytics, GenerationCache, GoalPlanner, type GuardFn, GuardNode, HoloScriptGenerator, InfluenceMap, InverterNode, LMStudioAdapter, type LMStudioAdapterConfig, NVIDIAAdapter, type NVIDIAAdapterConfig, NavMesh, OllamaAdapter, type OllamaAdapterConfig, OpenAIAdapter, type OpenAIAdapterConfig, type OptimizeResult, ParallelNode, PerceptionSystem, type PromptTemplate, PromptTemplateSystem, QuickPrompts, RepeaterNode, type SearchResult, SelectorNode, SemanticSearchService, SequenceNode, type StateAction, type StateConfig, StateMachine, SteeringBehavior, SteeringBehaviors, type TemplateContext, TogetherAdapter, type TogetherAdapterConfig, TrainingDataGenerator, type TransitionConfig, UtilityAI, WaitNode, XAIAdapter, type XAIAdapterConfig, cachedGenerate, createAnalytics, createTrainingDataGenerator, explainHoloScript, fixHoloScript, generateBatch, generateHoloScript$1 as generateHoloScript, generateHoloScript as generateHoloScriptWithAdapter, getAIAdapter, getDefaultAIAdapter, isAISafe, listAIAdapters, optimizeHoloScript, registerAIAdapter, setDefaultAIAdapter, unregisterAIAdapter, useAnthropic, useFireworks, useGemini, useGrok, useLMStudio, useNVIDIA, useOllama, useOpenAI, useTogether, useXAI, validateAIOutput, validateBatch };