@nice2dev/game-engine 1.1.5 → 1.1.7

package/dist/types/editor/VRARMode.d.ts

@@ -0,0 +1,240 @@
+/**
+ * @file VRARMode.ts
+ * @description VR/AR Mode with WebXR integration and hand tracking
+ * PRO-1.4: Professional Editor Features
+ *
+ * Features:
+ * - WebXR session management
+ * - VR headset support
+ * - AR passthrough mode
+ * - Hand tracking
+ * - Controller input
+ * - Spatial anchors
+ * - Room-scale setup
+ * - Teleportation movement
+ * - Haptic feedback
+ * - Mixed reality support
+ */
+export type XRSessionMode = 'inline' | 'immersive-vr' | 'immersive-ar';
+export type XRReferenceSpaceType = 'viewer' | 'local' | 'local-floor' | 'bounded-floor' | 'unbounded';
+export type HandSide = 'left' | 'right';
+export type ControllerHandedness = 'none' | 'left' | 'right';
+export type InputSourceTargetRayMode = 'gaze' | 'tracked-pointer' | 'screen' | 'transient-pointer';
+export type JointName = 'wrist' | 'thumb-metacarpal' | 'thumb-phalanx-proximal' | 'thumb-phalanx-distal' | 'thumb-tip' | 'index-finger-metacarpal' | 'index-finger-phalanx-proximal' | 'index-finger-phalanx-intermediate' | 'index-finger-phalanx-distal' | 'index-finger-tip' | 'middle-finger-metacarpal' | 'middle-finger-phalanx-proximal' | 'middle-finger-phalanx-intermediate' | 'middle-finger-phalanx-distal' | 'middle-finger-tip' | 'ring-finger-metacarpal' | 'ring-finger-phalanx-proximal' | 'ring-finger-phalanx-intermediate' | 'ring-finger-phalanx-distal' | 'ring-finger-tip' | 'pinky-finger-metacarpal' | 'pinky-finger-phalanx-proximal' | 'pinky-finger-phalanx-intermediate' | 'pinky-finger-phalanx-distal' | 'pinky-finger-tip';
+export interface Vector3 {
+    x: number;
+    y: number;
+    z: number;
+}
+export interface Quaternion {
+    x: number;
+    y: number;
+    z: number;
+    w: number;
+}
+export interface Pose {
+    position: Vector3;
+    orientation: Quaternion;
+}
+export interface JointPose extends Pose {
+    radius: number;
+}
+export interface HandJoints {
+    wrist?: JointPose;
+    thumb: JointPose[];
+    index: JointPose[];
+    middle: JointPose[];
+    ring: JointPose[];
+    pinky: JointPose[];
+}
+export interface HandState {
+    side: HandSide;
+    joints: HandJoints;
+    isTracking: boolean;
+    pinchStrength: number;
+    gripStrength: number;
+}
+export interface ControllerState {
+    handedness: ControllerHandedness;
+    targetRayMode: InputSourceTargetRayMode;
+    pose?: Pose;
+    gripPose?: Pose;
+    buttons: ControllerButton[];
+    axes: number[];
+    isTracking: boolean;
+}
+export interface ControllerButton {
+    pressed: boolean;
+    touched: boolean;
+    value: number;
+}
+export interface HapticFeedback {
+    intensity: number;
+    duration: number;
+    startDelay?: number;
+}
+export interface SpatialAnchor {
+    id: string;
+    name: string;
+    pose: Pose;
+    createdAt: number;
+    persistent: boolean;
+    metadata?: Record<string, unknown>;
+}
+export interface RoomBoundary {
+    points: Vector3[];
+    height: number;
+}
+export interface XRSettings {
+    sessionMode: XRSessionMode;
+    referenceSpaceType: XRReferenceSpaceType;
+    requiredFeatures: string[];
+    optionalFeatures: string[];
+    framebufferScaleFactor: number;
+    depthSensing: boolean;
+    lightEstimation: boolean;
+    teleportEnabled: boolean;
+    continuousMovement: boolean;
+    snapTurnAngle: number;
+    vignetteOnMove: boolean;
+    handTrackingEnabled: boolean;
+    planeDetection: boolean;
+    hitTesting: boolean;
+    imageTracking: boolean;
+    roomScale: boolean;
+    boundaryVisible: boolean;
+}
+export type XRGesture = 'pinch' | 'grab' | 'point' | 'open_hand' | 'thumbs_up' | 'fist' | 'peace' | 'custom';
+export interface GestureDefinition {
+    id: string;
+    name: string;
+    type: XRGesture;
+    hand?: HandSide;
+    customChecker?: (hand: HandState) => boolean;
+}
+export interface TeleportTarget {
+    position: Vector3;
+    normal: Vector3;
+    valid: boolean;
+    surfaceType?: string;
+}
+export interface PlaneAnchor {
+    id: string;
+    pose: Pose;
+    polygon: Vector3[];
+    classification: 'floor' | 'wall' | 'ceiling' | 'table' | 'seat' | 'door' | 'window' | 'unknown';
+}
+export interface HitTestResult {
+    pose: Pose;
+    planeId?: string;
+}
+export interface ImageTarget {
+    id: string;
+    name: string;
+    widthInMeters: number;
+    imageData: ImageData | HTMLImageElement;
+    tracked: boolean;
+    pose?: Pose;
+}
+export declare const DEFAULT_XR_SETTINGS: XRSettings;
+export declare class VRARMode {
+    private xrSession;
+    private xrReferenceSpace;
+    private settings;
+    private isSupported;
+    private isSessionActive;
+    private frameId;
+    private controllers;
+    private hands;
+    private anchors;
+    private roomBoundary;
+    private detectedPlanes;
+    private teleportTarget;
+    private isTeleporting;
+    private imageTargets;
+    private registeredGestures;
+    private activeGestures;
+    private onSessionStarted?;
+    private onSessionEnded?;
+    private onFrame?;
+    private onControllerConnected?;
+    private onControllerDisconnected?;
+    private onHandTrackingUpdate?;
+    private onGestureDetected?;
+    private onGestureEnded?;
+    private onTeleport?;
+    private onPlaneDetected?;
+    private onImageTracked?;
+    private onAnchorAdded?;
+    private onAnchorRemoved?;
+    checkSupport(): Promise<{
+        vr: boolean;
+        ar: boolean;
+        handTracking: boolean;
+    }>;
+    isXRSupported(): boolean;
+    startSession(mode?: XRSessionMode): Promise<boolean>;
+    endSession(): Promise<void>;
+    private cleanup;
+    private setupSessionListeners;
+    private onXRFrame;
+    private updateInputSource;
+    private updateHandTracking;
+    private extractHandState;
+    private calculatePinchStrength;
+    private calculateGripStrength;
+    private distance;
+    private convertXRPose;
+    private onInputSourcesChange;
+    private onSelect;
+    private onSelectStart;
+    private onSelectEnd;
+    private onSqueeze;
+    private onSqueezeStart;
+    private onSqueezeEnd;
+    registerGesture(gesture: GestureDefinition): void;
+    unregisterGesture(gestureId: string): void;
+    private checkGestures;
+    private isGestureActive;
+    private updateTeleport;
+    setTeleportTarget(target: TeleportTarget): void;
+    private executeTeleport;
+    teleportTo(position: Vector3): void;
+    snapTurn(direction: 'left' | 'right'): void;
+    triggerHaptics(handedness: ControllerHandedness, feedback: HapticFeedback): void;
+    createAnchor(pose: Pose, name: string, persistent?: boolean, metadata?: Record<string, unknown>): Promise<SpatialAnchor | null>;
+    getAnchor(id: string): SpatialAnchor | undefined;
+    getAnchors(): SpatialAnchor[];
+    removeAnchor(id: string): boolean;
+    getDetectedPlanes(): PlaneAnchor[];
+    getPlanesByClassification(classification: PlaneAnchor['classification']): PlaneAnchor[];
+    addImageTarget(target: Omit<ImageTarget, 'tracked' | 'pose'>): void;
+    removeImageTarget(id: string): void;
+    getTrackedImages(): ImageTarget[];
+    getSession(): XRSession | null;
+    getReferenceSpace(): XRReferenceSpace | null;
+    isActive(): boolean;
+    getControllers(): ControllerState[];
+    getController(index: number): ControllerState | undefined;
+    getControllerByHandedness(handedness: ControllerHandedness): ControllerState | undefined;
+    getHand(side: HandSide): HandState | undefined;
+    getHands(): HandState[];
+    getRoomBoundary(): RoomBoundary | null;
+    getSettings(): XRSettings;
+    setSettings(settings: Partial<XRSettings>): void;
+    setOnSessionStarted(callback: () => void): void;
+    setOnSessionEnded(callback: () => void): void;
+    setOnFrame(callback: (time: number, frame: XRFrame) => void): void;
+    setOnControllerConnected(callback: (controller: ControllerState, index: number) => void): void;
+    setOnControllerDisconnected(callback: (index: number) => void): void;
+    setOnHandTrackingUpdate(callback: (hand: HandState) => void): void;
+    setOnGestureDetected(callback: (gesture: string, hand: HandSide) => void): void;
+    setOnGestureEnded(callback: (gesture: string, hand: HandSide) => void): void;
+    setOnTeleport(callback: (target: TeleportTarget) => void): void;
+    setOnPlaneDetected(callback: (plane: PlaneAnchor) => void): void;
+    setOnImageTracked(callback: (image: ImageTarget) => void): void;
+    setOnAnchorAdded(callback: (anchor: SpatialAnchor) => void): void;
+    setOnAnchorRemoved(callback: (anchorId: string) => void): void;
+}
+export declare function createVRARMode(): VRARMode;
+export declare function createDefaultGestures(): GestureDefinition[];

package/dist/types/editor/behavior-tree/BTDebugPanel.d.ts

@@ -0,0 +1,102 @@
+/**
+ * @file Behavior Tree Editor - Debug Panel
+ * @description Debug panel for runtime inspection and debugging
+ * PRO-1.4: Professional Editor Features
+ */
+import type { BTStatus } from '../../ai/BehaviorTree';
+import type { BTDebugState, BTWatchExpression, BTExecutionStep, BTDebugStatistics } from './types';
+export declare class BTDebugPanel {
+    private state;
+    private listeners;
+    onStartDebug?: () => void;
+    onStopDebug?: () => void;
+    onStepDebug?: () => void;
+    onPauseDebug?: () => void;
+    onResumeDebug?: () => void;
+    onAddBreakpoint?: (nodeId: string) => void;
+    onRemoveBreakpoint?: (nodeId: string) => void;
+    constructor();
+    private createInitialState;
+    /** Start debugging */
+    start(): void;
+    /** Stop debugging */
+    stop(): void;
+    /** Step one tick */
+    step(): void;
+    /** Pause execution */
+    pause(): void;
+    /** Resume execution */
+    resume(): void;
+    /** Toggle pause state */
+    togglePause(): void;
+    /** Update debug state from runtime */
+    updateState(updates: Partial<BTDebugState>): void;
+    /** Set current node being executed */
+    setCurrentNode(nodeId: string | undefined): void;
+    /** Update blackboard snapshot */
+    updateBlackboard(snapshot: Record<string, unknown>): void;
+    /** Record execution step */
+    recordStep(step: BTExecutionStep): void;
+    /** Update statistics */
+    updateStatistics(updates: Partial<BTDebugStatistics>): void;
+    /** Add breakpoint */
+    addBreakpoint(nodeId: string): void;
+    /** Remove breakpoint */
+    removeBreakpoint(nodeId: string): void;
+    /** Toggle breakpoint */
+    toggleBreakpoint(nodeId: string): void;
+    /** Clear all breakpoints */
+    clearBreakpoints(): void;
+    /** Check if node has breakpoint */
+    hasBreakpoint(nodeId: string): boolean;
+    /** Add watch expression */
+    addWatch(expression: string): BTWatchExpression;
+    /** Remove watch expression */
+    removeWatch(watchId: string): void;
+    /** Update watch expression */
+    updateWatch(watchId: string, expression: string): void;
+    /** Clear all watches */
+    clearWatches(): void;
+    /** Evaluate a watch expression */
+    private evaluateWatch;
+    /** Re-evaluate all watches */
+    evaluateWatches(): void;
+    /** Get execution history */
+    getHistory(): BTExecutionStep[];
+    /** Clear execution history */
+    clearHistory(): void;
+    /** Get history for specific node */
+    getNodeHistory(nodeId: string): BTExecutionStep[];
+    /** Get last N steps */
+    getRecentHistory(count?: number): BTExecutionStep[];
+    /** Get statistics */
+    getStatistics(): BTDebugStatistics;
+    /** Get node execution count */
+    getNodeExecutionCount(nodeId: string): number;
+    /** Get node failure count */
+    getNodeFailureCount(nodeId: string): number;
+    /** Get node success rate */
+    getNodeSuccessRate(nodeId: string): number;
+    /** Get full state */
+    getState(): BTDebugState;
+    /** Check if debugging */
+    isDebugging(): boolean;
+    /** Check if paused */
+    isPaused(): boolean;
+    /** Get current node */
+    getCurrentNodeId(): string | undefined;
+    /** Subscribe to state changes */
+    subscribe(listener: () => void): () => void;
+    private notifyListeners;
+}
+export declare function createBTDebugPanel(): BTDebugPanel;
+/** Get status display info */
+export declare function getStatusInfo(status: BTStatus): {
+    label: string;
+    color: string;
+    icon: string;
+};
+/** Format execution time */
+export declare function formatExecutionTime(ms: number): string;
+/** Format blackboard value for display */
+export declare function formatBlackboardValue(value: unknown): string;

package/dist/types/editor/behavior-tree/BTEditorCanvas.d.ts

@@ -0,0 +1,79 @@
+/**
+ * @file Behavior Tree Editor - Canvas
+ * @description Canvas component for visual editing of behavior trees
+ * PRO-1.4: Professional Editor Features
+ */
+import type { Vec2 } from '../../core/types';
+import type { BehaviorTreeEditor } from './BehaviorTreeEditor';
+import { BTEditorNodeRenderer, BTConnectionRenderer } from './BTEditorNode';
+import type { BTEditorConfig } from './types';
+export interface BTEditorCanvasState {
+    isDragging: boolean;
+    isPanning: boolean;
+    isBoxSelecting: boolean;
+    dragStartPosition: Vec2 | null;
+    dragStartNodePositions: Map<string, Vec2>;
+    boxSelectStart: Vec2 | null;
+    boxSelectEnd: Vec2 | null;
+    hoveredNodeId: string | null;
+    hoveredConnectionId: string | null;
+    contextMenuPosition: Vec2 | null;
+}
+export declare class BTEditorCanvas {
+    private canvas;
+    private ctx;
+    private editor;
+    private config;
+    private nodeRenderer;
+    private connectionRenderer;
+    private state;
+    private animationFrameId;
+    private resizeObserver;
+    onNodeClick?: (nodeId: string, event: MouseEvent) => void;
+    onNodeDoubleClick?: (nodeId: string, event: MouseEvent) => void;
+    onNodeContextMenu?: (nodeId: string, position: Vec2, event: MouseEvent) => void;
+    onConnectionContextMenu?: (connectionId: string, position: Vec2, event: MouseEvent) => void;
+    onCanvasContextMenu?: (position: Vec2, event: MouseEvent) => void;
+    onDrop?: (dataTransfer: DataTransfer, position: Vec2) => void;
+    constructor(canvas: HTMLCanvasElement, editor: BehaviorTreeEditor, config?: Partial<BTEditorConfig>);
+    /** Clean up resources */
+    dispose(): void;
+    private setupEventListeners;
+    private removeEventListeners;
+    private handleMouseDown;
+    private handleMouseMove;
+    private handleMouseUp;
+    private handleMouseLeave;
+    private handleWheel;
+    private handleDoubleClick;
+    private handleContextMenu;
+    private handleDragOver;
+    private handleDrop;
+    private handleKeyDown;
+    private startConnection;
+    private completeConnection;
+    private findNodeAtPosition;
+    private findConnectionAtPosition;
+    private updateHoverState;
+    private setupResizeObserver;
+    private resizeCanvas;
+    private startRenderLoop;
+    private render;
+    private renderGrid;
+    private renderBoxSelection;
+    private renderMinimap;
+    private getCanvasPosition;
+    private snapToGrid;
+    private normalizeRect;
+    /** Force redraw */
+    redraw(): void;
+    /** Get canvas element */
+    getCanvas(): HTMLCanvasElement;
+    /** Update configuration */
+    updateConfig(config: Partial<BTEditorConfig>): void;
+    /** Set custom node renderer */
+    setNodeRenderer(renderer: BTEditorNodeRenderer): void;
+    /** Set custom connection renderer */
+    setConnectionRenderer(renderer: BTConnectionRenderer): void;
+}
+export declare function createBTEditorCanvas(canvas: HTMLCanvasElement, editor: BehaviorTreeEditor, config?: Partial<BTEditorConfig>): BTEditorCanvas;

package/dist/types/editor/behavior-tree/BTEditorNode.d.ts

@@ -0,0 +1,57 @@
+/**
+ * @file Behavior Tree Editor - Editor Node
+ * @description Visual representation of a behavior tree node in the editor
+ * PRO-1.4: Professional Editor Features
+ */
+import type { Vec2 } from '../../core/types';
+import type { BTEditorNodeData, BTEditorConfig } from './types';
+import { BT_NODE_COLORS, BT_STATUS_COLORS } from './types';
+export interface BTEditorNodeRenderer {
+    /** Render the node to a canvas context */
+    render(ctx: CanvasRenderingContext2D, node: BTEditorNodeData, config: BTEditorConfig): void;
+    /** Check if point is inside node */
+    hitTest(point: Vec2, node: BTEditorNodeData): boolean;
+    /** Check if point is on input connector */
+    hitTestInput(point: Vec2, node: BTEditorNodeData, config: BTEditorConfig): boolean;
+    /** Check if point is on output connector */
+    hitTestOutput(point: Vec2, node: BTEditorNodeData, config: BTEditorConfig): boolean;
+    /** Get input connector position */
+    getInputPosition(node: BTEditorNodeData, config: BTEditorConfig): Vec2;
+    /** Get output connector position */
+    getOutputPosition(node: BTEditorNodeData, config: BTEditorConfig): Vec2;
+}
+export declare class DefaultBTNodeRenderer implements BTEditorNodeRenderer {
+    private connectorRadius;
+    private connectorHitRadius;
+    render(ctx: CanvasRenderingContext2D, node: BTEditorNodeData, config: BTEditorConfig): void;
+    hitTest(point: Vec2, node: BTEditorNodeData): boolean;
+    hitTestInput(point: Vec2, node: BTEditorNodeData, config: BTEditorConfig): boolean;
+    hitTestOutput(point: Vec2, node: BTEditorNodeData, config: BTEditorConfig): boolean;
+    getInputPosition(node: BTEditorNodeData, config: BTEditorConfig): Vec2;
+    getOutputPosition(node: BTEditorNodeData, _config: BTEditorConfig): Vec2;
+    private drawConnector;
+    private drawBadge;
+    private roundRect;
+    private truncateText;
+    private getCategoryIcon;
+}
+export interface BTConnectionRenderer {
+    /** Render connection */
+    render(ctx: CanvasRenderingContext2D, startPos: Vec2, endPos: Vec2, selected: boolean, active: boolean, config: BTEditorConfig): void;
+    /** Hit test connection */
+    hitTest(point: Vec2, startPos: Vec2, endPos: Vec2, config: BTEditorConfig): boolean;
+}
+export declare class DefaultBTConnectionRenderer implements BTConnectionRenderer {
+    render(ctx: CanvasRenderingContext2D, startPos: Vec2, endPos: Vec2, selected: boolean, active: boolean, config: BTEditorConfig): void;
+    hitTest(point: Vec2, startPos: Vec2, endPos: Vec2, config: BTEditorConfig): boolean;
+    private getBezierPoint;
+}
+export interface BTNodeTheme {
+    name: string;
+    colors: typeof BT_NODE_COLORS;
+    statusColors: typeof BT_STATUS_COLORS;
+}
+export declare const defaultTheme: BTNodeTheme;
+export declare const lightTheme: BTNodeTheme;
+export declare function createNodeRenderer(): BTEditorNodeRenderer;
+export declare function createConnectionRenderer(): BTConnectionRenderer;

package/dist/types/editor/behavior-tree/BTEditorToolbar.d.ts

@@ -0,0 +1,74 @@
+/**
+ * @file Behavior Tree Editor - Toolbar
+ * @description Toolbar component for editor actions
+ * PRO-1.4: Professional Editor Features
+ */
+import type { BehaviorTreeEditor } from './BehaviorTreeEditor';
+import type { BTEditorMode } from './types';
+export interface BTToolbarAction {
+    id: string;
+    label: string;
+    icon: string;
+    shortcut?: string;
+    tooltip?: string;
+    disabled?: boolean;
+    active?: boolean;
+    group?: string;
+    execute: () => void;
+}
+export interface BTToolbarGroup {
+    id: string;
+    label?: string;
+    actions: BTToolbarAction[];
+}
+export declare class BTEditorToolbar {
+    private editor;
+    private customActions;
+    private listeners;
+    constructor(editor: BehaviorTreeEditor);
+    /** Get all toolbar groups */
+    getGroups(): BTToolbarGroup[];
+    private getFileGroup;
+    private getEditGroup;
+    private getViewGroup;
+    private getLayoutGroup;
+    private getDebugGroup;
+    private getCustomGroups;
+    private handleDelete;
+    onSave?: () => void;
+    onExport?: () => void;
+    onImport?: () => void;
+    onValidate?: (result: {
+        valid: boolean;
+        errors: string[];
+        warnings: string[];
+    }) => void;
+    private triggerSave;
+    private triggerExport;
+    private triggerImport;
+    private triggerValidation;
+    /** Add custom toolbar action */
+    addAction(action: BTToolbarAction): void;
+    /** Remove custom toolbar action */
+    removeAction(actionId: string): void;
+    /** Get action by ID */
+    getAction(actionId: string): BTToolbarAction | undefined;
+    /** Execute action by ID */
+    executeAction(actionId: string): void;
+    /** Get all keyboard shortcuts */
+    getShortcuts(): Map<string, BTToolbarAction>;
+    /** Handle keyboard shortcut */
+    handleShortcut(event: KeyboardEvent): boolean;
+    private formatShortcut;
+    /** Update toolbar state */
+    update(): void;
+    /** Get current mode */
+    getMode(): BTEditorMode;
+    /** Check if modified */
+    isModified(): boolean;
+    /** Subscribe to state changes */
+    subscribe(listener: () => void): () => void;
+    private notifyListeners;
+}
+export declare function createBTEditorToolbar(editor: BehaviorTreeEditor): BTEditorToolbar;
+export declare const TOOLBAR_ICONS: Record<string, string>;

package/dist/types/editor/behavior-tree/BTNodePalette.d.ts

@@ -0,0 +1,72 @@
+/**
+ * @file Behavior Tree Editor - Node Palette
+ * @description Node palette for selecting and adding nodes to the behavior tree
+ * PRO-1.4: Professional Editor Features
+ */
+import type { BTNodeDefinition, BTNodeType } from '../../ai/BehaviorTree';
+import type { BTPaletteCategory, BTPaletteNode } from './types';
+export interface BTNodePaletteState {
+    searchQuery: string;
+    expandedCategories: Set<BTNodeType>;
+    favorites: Set<string>;
+    recentlyUsed: string[];
+    maxRecentlyUsed: number;
+}
+export declare class BTNodePalette {
+    private definitions;
+    private state;
+    private listeners;
+    onNodeDragStart?: (definition: BTNodeDefinition, event: DragEvent) => void;
+    onNodeAdd?: (definition: BTNodeDefinition) => void;
+    constructor();
+    /** Set available node definitions */
+    setDefinitions(definitions: BTNodeDefinition[]): void;
+    /** Get all definitions */
+    getDefinitions(): BTNodeDefinition[];
+    /** Get definition by type */
+    getDefinition(type: string): BTNodeDefinition | undefined;
+    /** Get categories with filtered nodes */
+    getCategories(): BTPaletteCategory[];
+    private createCategory;
+    private toPaletteNode;
+    private generateSearchTerms;
+    /** Update search query */
+    setSearchQuery(query: string): void;
+    /** Get current search query */
+    getSearchQuery(): string;
+    /** Check if definition matches search */
+    private matchesSearch;
+    /** Get filtered nodes across all categories */
+    getFilteredNodes(): BTPaletteNode[];
+    /** Toggle category expansion */
+    toggleCategory(category: BTNodeType): void;
+    /** Expand all categories */
+    expandAll(): void;
+    /** Collapse all categories */
+    collapseAll(): void;
+    /** Toggle favorite status */
+    toggleFavorite(type: string): void;
+    /** Check if node is favorite */
+    isFavorite(type: string): boolean;
+    /** Get favorite nodes */
+    getFavorites(): BTPaletteNode[];
+    private loadFavorites;
+    private saveFavorites;
+    /** Add to recently used */
+    addRecentlyUsed(type: string): void;
+    /** Get recently used nodes */
+    getRecentlyUsed(): BTPaletteNode[];
+    /** Clear recently used */
+    clearRecentlyUsed(): void;
+    private loadRecentlyUsed;
+    private saveRecentlyUsed;
+    /** Handle node drag start */
+    handleDragStart(type: string, event: DragEvent): void;
+    /** Handle node click (add node) */
+    handleNodeClick(type: string): void;
+    /** Subscribe to state changes */
+    subscribe(listener: () => void): () => void;
+    private notifyListeners;
+}
+export declare function createBTNodePalette(): BTNodePalette;
+export declare function getBuiltInNodeDefinitions(): Partial<BTNodeDefinition>[];

package/dist/types/editor/behavior-tree/BTPropertyPanel.d.ts

@@ -0,0 +1,66 @@
+/**
+ * @file Behavior Tree Editor - Property Panel
+ * @description Property panel for editing selected node properties
+ * PRO-1.4: Professional Editor Features
+ */
+import type { BTNodeDefinition, BTPropertyDef } from '../../ai/BehaviorTree';
+import type { BTEditorNodeData, BTBlackboardKeyDef } from './types';
+export interface BTPropertyValue {
+    name: string;
+    value: unknown;
+    definition?: BTPropertyDef;
+    error?: string;
+    modified: boolean;
+}
+export interface BTPropertyPanelState {
+    selectedNode: BTEditorNodeData | null;
+    nodeDefinition: BTNodeDefinition | null;
+    properties: BTPropertyValue[];
+    blackboardKeys: BTBlackboardKeyDef[];
+    collapsed: boolean;
+}
+export declare class BTPropertyPanel {
+    private state;
+    private listeners;
+    onPropertyChange?: (nodeId: string, property: string, value: unknown) => void;
+    onNameChange?: (nodeId: string, name: string) => void;
+    onCommentChange?: (nodeId: string, comment: string) => void;
+    constructor();
+    /** Set the selected node */
+    setSelectedNode(node: BTEditorNodeData | null, definition: BTNodeDefinition | null): void;
+    /** Get selected node */
+    getSelectedNode(): BTEditorNodeData | null;
+    /** Set blackboard keys for key selection */
+    setBlackboardKeys(keys: BTBlackboardKeyDef[]): void;
+    private buildProperties;
+    /** Update property value */
+    setProperty(name: string, value: unknown): void;
+    /** Reset property to default */
+    resetProperty(name: string): void;
+    /** Set node name */
+    setName(name: string): void;
+    /** Set node comment */
+    setComment(comment: string): void;
+    private validateProperty;
+    /** Validate all properties */
+    validateAll(): boolean;
+    /** Get current state */
+    getState(): BTPropertyPanelState;
+    /** Toggle collapsed state */
+    toggleCollapsed(): void;
+    /** Subscribe to state changes */
+    subscribe(listener: () => void): () => void;
+    private notifyListeners;
+}
+export interface BTPropertyEditorProps<T = unknown> {
+    value: T;
+    definition: BTPropertyDef;
+    onChange: (value: T) => void;
+    error?: string;
+    disabled?: boolean;
+}
+/** Get editor type for property */
+export declare function getPropertyEditorType(definition: BTPropertyDef): string;
+export declare function createBTPropertyPanel(): BTPropertyPanel;
+export declare function formatPropertyValue(value: unknown, definition?: BTPropertyDef): string;
+export declare function parsePropertyValue(input: string, definition: BTPropertyDef): unknown;