unreal-engine-mcp-server 0.4.7 → 0.5.0

package/CONTRIBUTING.md

@@ -0,0 +1,140 @@
+# Contributing to Unreal Engine MCP Server
+
+Thank you for your interest in contributing! This document provides guidelines and instructions for contributing.
+
+## 📋 Table of Contents
+
+- [Code of Conduct](#code-of-conduct)
+- [Getting Started](#getting-started)
+- [Development Workflow](#development-workflow)
+- [Pull Request Process](#pull-request-process)
+- [Coding Standards](#coding-standards)
+
+## Code of Conduct
+
+Please be respectful and constructive in all interactions. We're building something together.
+
+## Getting Started
+
+### Prerequisites
+
+- **Node.js** 18+ 
+- **Unreal Engine** 5.0-5.7 (for live testing)
+- **Git**
+
+### Setup
+
+1. Fork and clone the repository:
+   ```bash
+   git clone https://github.com/YOUR_USERNAME/unreal-engine-mcp-server.git
+   cd unreal-engine-mcp-server
+   ```
+
+2. Install dependencies:
+   ```bash
+   npm install
+   ```
+
+3. Build the project:
+   ```bash
+   npm run build
+   ```
+
+4. Run smoke tests (no Unreal needed):
+   ```bash
+   npm run test:smoke
+   ```
+
+## Development Workflow
+
+### Branch Naming
+
+Use descriptive branch names:
+- `feat/add-new-tool` - New features
+- `fix/connection-timeout` - Bug fixes
+- `docs/update-readme` - Documentation
+- `refactor/cleanup-bridge` - Code refactoring
+
+### Running Tests
+
+```bash
+# Smoke test (CI-compatible, no Unreal needed)
+npm run test:smoke
+
+# Live tests (requires Unreal Editor running with plugin)
+npm run test:all
+```
+
+### Building
+
+```bash
+npm run build        # Full build (TypeScript + WASM)
+npm run build:core   # TypeScript only
+npm run build:wasm   # WASM only (requires wasm-pack)
+```
+
+## Pull Request Process
+
+### Before Submitting
+
+1. ✅ Run `npm run lint` and fix any issues
+2. ✅ Run `npm run test:smoke` to verify basic functionality
+3. ✅ Update documentation if adding new features
+4. ✅ Update `CHANGELOG.md` under `[Unreleased]`
+
+### PR Title Format
+
+We use [Conventional Commits](https://www.conventionalcommits.org/). PR titles must follow this format:
+
+```
+<type>: <description>
+
+Examples:
+feat: add new animation blending tool
+fix: resolve WebSocket connection timeout
+docs: update installation instructions  
+refactor: simplify blueprint graph handler
+```
+
+**Types:** `feat`, `fix`, `docs`, `style`, `refactor`, `perf`, `test`, `build`, `ci`, `chore`, `revert`
+
+### Review Process
+
+1. All PRs require at least one approval
+2. CI must pass (lint, smoke test, CodeQL)
+3. Maintainers may request changes
+
+## Coding Standards
+
+### TypeScript
+
+- Use strict TypeScript (`strict: true`)
+- Prefer `async/await` over raw Promises
+- Use descriptive variable names
+- Add JSDoc comments for public APIs
+
+### C++ (Plugin)
+
+- Follow Unreal Engine coding standards
+- Use `UPROPERTY`/`UFUNCTION` macros appropriately
+- Keep thread safety in mind for async operations
+
+### File Organization
+
+```
+src/
+├── tools/           # MCP tool implementations
+├── automation/      # Unreal bridge logic
+├── utils/           # Shared utilities
+└── services/        # Background services
+
+Plugins/
+└── McpAutomationBridge/  # C++ Unreal plugin
+```
+
+## Questions?
+
+- Open a [Discussion](../../discussions) for questions
+- Open an [Issue](../../issues) for bugs or feature requests
+
+Thank you for contributing! 🎮

package/README.md

@@ -3,10 +3,10 @@
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 [![NPM Package](https://img.shields.io/npm/v/unreal-engine-mcp-server)](https://www.npmjs.com/package/unreal-engine-mcp-server)
 [![MCP SDK](https://img.shields.io/badge/MCP%20SDK-TypeScript-blue)](https://github.com/modelcontextprotocol/sdk)
-[![Unreal Engine](https://img.shields.io/badge/Unreal%20Engine-5.0--5.6-orange)](https://www.unrealengine.com/)
+[![Unreal Engine](https://img.shields.io/badge/Unreal%20Engine-5.0--5.7-orange)](https://www.unrealengine.com/)
 [![MCP Registry](https://img.shields.io/badge/MCP%20Registry-Published-green)](https://registry.modelcontextprotocol.io/)
 
-A comprehensive Model Context Protocol (MCP) server that enables AI assistants to control Unreal Engine via Remote Control API. Built with TypeScript and designed for game development automation.
+A comprehensive Model Context Protocol (MCP) server that enables AI assistants to control Unreal Engine through the native C++ Automation Bridge plugin. Built with TypeScript, C++, and Rust (WebAssembly) for ultra-high-performance game development automation.
 
 ## Features
 
@@ -15,50 +15,120 @@ A comprehensive Model Context Protocol (MCP) server that enables AI assistants t
 - **Actor Control** - Spawn, delete, and manipulate actors with physics
 - **Editor Control** - PIE sessions, camera, and viewport management
 - **Level Management** - Load/save levels, lighting, and environment building
-- **Animation & Physics** - Blueprints, state machines, ragdolls, constraints
+- **Animation & Physics** - Blueprints, state machines, ragdolls, constraints, vehicle setup
 - **Visual Effects** - Niagara particles, GPU simulations, procedural effects
 - **Sequencer** - Cinematics, camera animations, and timeline control
+- **Graph Editing** - Blueprint, Niagara, Material, and Behavior Tree graph manipulation
+- **World Partition** - Load cells, manage data layers
+- **Render Management** - Render targets, Nanite, Lumen
+- **Pipeline & Testing** - Run UBT, automated tests
+- **Observability** - Log streaming, gameplay debugger, insights, asset queries
 - **Console Commands** - Safe execution with dangerous command filtering
+- **GraphQL API** - Flexible data querying for assets, actors, and blueprints
+
+### High-Performance WebAssembly
+- **5-8x faster JSON parsing** - WASM-accelerated property parsing
+- **5-10x faster transform math** - Optimized 3D vector/matrix operations
+- **3-5x faster dependency resolution** - Rapid asset graph traversal
+- **Automatic fallbacks** - Works perfectly without WASM binary
+- **Performance monitoring** - Built-in metrics tracking
 
 ## Quick Start
 
 ### Prerequisites
 - Node.js 18+
-- Unreal Engine 5.0-5.6
+- Unreal Engine 5.0-5.7
 - Required UE Plugins (enable via **Edit ▸ Plugins**):
-  - **Remote Control API** – core Remote Control HTTP/WS endpoints
-  - **Remote Control Web Interface** – enables WebSocket bridge used by this server
-  - **Python Editor Script Plugin** – exposes Python runtime for automation
-  - **Editor Scripting Utilities** – unlocks Editor Actor/Asset subsystems used throughout the tools
-  - **Sequencer** *(built-in)* – keep enabled for cinematic tools
-  - **Level Sequence Editor** – required for `manage_sequence` operations
+  - **MCP Automation Bridge** – Native C++ WebSocket automation transport (ships inside `plugins/McpAutomationBridge`)
+  - **Editor Scripting Utilities** – Unlocks Editor Actor/Asset subsystems for native tool operations
+  - **Sequencer** *(built-in)* – Keep enabled for cinematic tools
+  - **Level Sequence Editor** – Required for `manage_sequence` operations
+  - **Control Rig** – Required for animation and physics tools
+  - **Subobject Data Interface** – Required for Blueprint component manipulation (UE 5.7+)
 
-> 💡 After toggling any plugin, restart the editor to finalize activation. Keep `Editor Scripting Utilities` and `Python Editor Script Plugin` enabled prior to connecting, otherwise many subsystem-based tools (actor spawning, audio, foliage, UI widgets) will refuse to run for safety.
+> 💡 After toggling any plugin, restart the editor to finalize activation. The MCP Automation Bridge provides all automation capabilities through native C++ handlers.
 
 ### Plugin feature map
 
 | Plugin | Location | Used By | Notes |
 |--------|----------|---------|-------|
-| Remote Control API | Developer Tools ▸ Remote Control | All tools | Provides HTTP/WS endpoints consumed by the MCP bridge |
-| Remote Control Web Interface | Developer Tools ▸ Remote Control | All tools | Enables persistent WebSocket session |
-| Python Editor Script Plugin | Scripting | Landscapes, lighting, audio, physics, sequences, UI | Required for every Python execution path |
-| Editor Scripting Utilities | Scripting | Actors, foliage, assets, landscapes, UI | Supplies Editor Actor/Asset subsystems in UE5.6 |
+| MCP Automation Bridge | Project Plugins ▸ MCP Automation Bridge | All automation operations | Primary C++ automation transport with native handlers |
+| Editor Scripting Utilities | Scripting | Asset/Actor subsystem operations | Supplies Editor Actor/Asset subsystems |
 | Sequencer | Built-in | Sequencer tools | Ensure not disabled in project settings |
-| Level Sequence Editor | Animation | Sequencer tools | Activate before calling `manage_sequence` operations |
+| Level Sequence Editor | Animation | Sequencer tools | Required for `manage_sequence` operations |
+| Control Rig | Animation | Animation/Physics tools | Required for `animation_physics` operations |
+| Subobject Data Interface | Scripting | Blueprint tools | Required for `manage_blueprint` component operations (UE 5.7+) |
 
-### Installation
+> Tools such as `physics.configureVehicle` accept an optional `pluginDependencies` array so you can list the specific Unreal plugins your project relies on (for example, Chaos Vehicles or third-party vehicle frameworks). When provided, the server will verify those plugins are active before running the configuration.
+
+### MCP Automation Bridge plugin
+- Location: `plugins/McpAutomationBridge`
+- Installation: copy the folder into your project's `Plugins/` directory and regenerate project files.
+- Sync helper: run `npm run automation:sync -- --engine "X:/Unreal_Engine/UE_5.6/Engine/Plugins" --project "X:/Newfolder(2)/Game/Unreal/Trial/Plugins" --clean-engine --clean-project` after repo updates to copy the latest bridge build into both plugin folders and strip legacy entries (such as `SupportedTargetPlatforms: ["Editor"]`) that trigger startup warnings.
+- Verification: run `node scripts/verify-automation-bridge.js --project "C:/Path/To/YourProject/Plugins" --config "C:/Path/To/YourProject/Config/DefaultEngine.ini"` to confirm the plugin files and automation bridge environment variables are in place before launching Unreal.
+- Configuration: enable **MCP Automation Bridge** in **Edit ▸ Plugins**, restart the editor, then set the endpoint/token under **Edit ▸ Project Settings ▸ Plugins ▸ MCP Automation Bridge**. The bridge ships with its own lightweight WebSocket client, so you no longer need the engine's WebSockets plugin enabled.
+- Startup: after configuration, the Output Log should show a successful connection and the `bridge_started` broadcast; `SendRawMessage` becomes available to Blueprint and C++ callers for manual testing.
+- Current scope: manages a WebSocket session to the Node MCP server (`ws://127.0.0.1:8091` by default), performs optional capability-token handshakes, dispatches inbound JSON to native C++ handlers, implements reconnect backoff, and responds to editor functions, property operations, blueprint actions, and more through native implementations.
+- Usage: all consolidated tools use the automation bridge for native C++ execution. Keep the plugin enabled for all workflows.
+- Diagnostics: the `ue://automation-bridge` MCP resource surfaces handshake timestamps, recent disconnects, pending automation requests, and whether the Node listener is running—handy when validating editor connectivity from a client.
+- Roadmap: expand the bridge with elevated actions (SCS authoring, typed property marshaling, modal mediation, asset workflows).
+
+### WebAssembly Performance (Optional)
 
-#### Option 1: NPM Package (Recommended)
+The MCP server includes WebAssembly acceleration for computationally intensive operations. WASM is **automatically used when available** and **gracefully falls back** to pure TypeScript when the bundle or toolchain is missing.
+
+**To enable full WASM acceleration (5–8x faster operations):**
 
 ```bash
-# Install globally
-npm install -g unreal-engine-mcp-server
+# 1. Install Rust toolchain and wasm-pack (once per machine)
+#    See https://rustup.rs for installing Rust.
+cargo install wasm-pack
+
+# 2. Build TypeScript + WASM bundle
+#    The build script always runs the TypeScript compiler and then
+#    optionally builds the WASM bundle. If wasm-pack is missing the
+#    build will succeed with a warning and the server will use
+#    TypeScript fallbacks.
+npm run build
+
+# 3. Ensure WASM is enabled (default is enabled if WASM_ENABLED is unset)
+#    In .env or your process environment:
+#    WASM_ENABLED=true
 
-# Or install locally in your project
-npm install unreal-engine-mcp-server
+# 4. Start the server or run tests – the logs will include a
+#    "WebAssembly module initialized successfully" message when the
+#    bundle is present and loaded.
+npm start
 ```
 
-#### Option 2: Clone and Build
+**Without WASM (still fully functional):**
+
+```bash
+# Disable WASM explicitly (optional)
+# In .env or environment:
+#   WASM_ENABLED=false
+
+npm start
+# Server will always use TypeScript implementations only.
+```
+
+When the WASM bundle is not present or `wasm-pack` is not installed:
+
+- `npm run build` prints a concise message:
+  > WASM build failed or wasm-pack missing; continuing with TypeScript-only build.
+- At runtime, the server attempts to load the bundle once. On `ERR_MODULE_NOT_FOUND`
+  it logs a single warning suggesting `npm run build`/`cargo install wasm-pack` and
+  permanently falls back to TypeScript for that process.
+
+WASM acceleration applies to:
+- JSON property parsing (5-8x faster)
+- Transform calculations (5-10x faster)
+- Vector/matrix math (5x faster)
+- Asset dependency resolution (3-5x faster)
+
+### Installation
+
+Clone and Build
 
 ```bash
 # Clone the repository
@@ -75,20 +145,7 @@ node dist/cli.js
 
 ### Unreal Engine Configuration
 
-Add to your project's `Config/DefaultEngine.ini`:
-
-```ini
-[/Script/PythonScriptPlugin.PythonScriptPluginSettings]
-bRemoteExecution=True
-bAllowRemotePythonExecution=True
-
-[/Script/RemoteControl.RemoteControlSettings]
-bAllowRemoteExecutionOfConsoleCommands=True
-bEnableRemoteExecution=True
-bAllowPythonExecution=True
-```
-
-Then enable Python execution in: Edit > Project Settings > Plugins > Remote Control
+No additional engine configuration required. The MCP Automation Bridge plugin handles all automation through native C++ code.
 
 ## MCP Client Configuration
 
@@ -103,10 +160,8 @@ Then enable Python execution in: Edit > Project Settings > Plugins > Remote Cont
       "command": "npx",
       "args": ["unreal-engine-mcp-server"],
       "env": {
-        "UE_HOST": "127.0.0.1",
-        "UE_RC_HTTP_PORT": "30010",
-        "UE_RC_WS_PORT": "30020",
-        "UE_PROJECT_PATH": "C:/Users/YourName/Documents/Unreal Projects/YourProject"
+        "UE_PROJECT_PATH": "C:/Users/YourName/Documents/Unreal Projects/YourProject",
+        "MCP_AUTOMATION_PORT": "8091"
       }
     }
   }
@@ -122,47 +177,63 @@ Then enable Python execution in: Edit > Project Settings > Plugins > Remote Cont
       "command": "node",
       "args": ["path/to/Unreal_mcp/dist/cli.js"],
       "env": {
-        "UE_HOST": "127.0.0.1",
-        "UE_RC_HTTP_PORT": "30010",
-        "UE_RC_WS_PORT": "30020",
-        "UE_PROJECT_PATH": "C:/Users/YourName/Documents/Unreal Projects/YourProject"
+        "UE_PROJECT_PATH": "C:/Users/YourName/Documents/Unreal Projects/YourProject",
+        "MCP_AUTOMATION_PORT": "8091"
       }
     }
   }
 }
 ```
 
-## Available Tools (13)
+## Available Tools (17)
 
 | Tool | Description |
 |------|-------------|
-| `manage_asset` | List, create materials, import assets |
-| `control_actor` | Spawn, delete actors, apply physics |
-| `control_editor` | PIE control, camera, view modes |
-| `manage_level` | Load/save levels, lighting |
-| `animation_physics` | Animation blueprints, ragdolls |
-| `create_effect` | Particles, Niagara, debug shapes |
-| `manage_blueprint` | Create blueprints, add components |
-| `build_environment` | Landscapes, terrain, foliage |
-| `system_control` | Profiling, quality, UI, screenshots, Output Log reading |
-| `console_command` | Direct console command execution |
-| `manage_rc` | Remote Control presets |
-| `manage_sequence` | Sequencer/cinematics |
-| `inspect` | Object introspection |
+| `manage_asset` | Assets, Materials, Render Targets, Behavior Trees |
+| `control_actor` | Spawn, delete, modify, physics |
+| `control_editor` | PIE, Camera, UI Input |
+| `manage_level` | Load/Save, World Partition |
+| `manage_lighting` | Spawn Lights, GI, Shadows, Build Lighting |
+| `manage_performance` | Profiling, Optimization, Scalability |
+| `animation_physics` | Animation BPs, Vehicles, Ragdolls |
+| `manage_effect` | Niagara, Particles, Debug Shapes |
+| `manage_blueprint` | Create, SCS, Graph Editing |
+| `manage_blueprint_graph` | Direct Blueprint Graph Manipulation |
+| `build_environment` | Landscape, Foliage, Procedural |
+| `system_control` | UBT, Tests, Logs, Project Settings, CVars |
+| `manage_sequence` | Sequencer/Cinematics |
+| `inspect` | Object Introspection |
+| `manage_audio` | Audio Assets & Components |
+| `manage_behavior_tree` | Behavior Tree Graph Editing |
+| `manage_input` | Enhanced Input Actions & Contexts |
+
+
+## Documentation
+
+- [Handler Mappings](docs/handler-mapping.md) - TypeScript to C++ routing guide
+- [GraphQL API](docs/GraphQL-API.md) - Query and mutation reference
+- [Automation Progress](docs/native-automation-progress.md) - Implementation status
 
 ## Key Features
 
-- **Graceful Degradation** - Server starts even without UE connection
-- **Auto-Reconnection** - Attempts reconnection every 10 seconds
-- **Connection Timeout** - 5-second timeout with configurable retries
-- **Non-Intrusive Health Checks** - Uses echo commands every 30 seconds
+- **Native C++ Automation** - All operations route through the MCP Automation Bridge plugin's native C++ handlers
+- **Graceful Degradation** - Server starts even without an active Unreal connection
+- **On-Demand Connection** - Retries automation handshakes with backoff instead of persistent polling
+- **Non-Intrusive Health Checks** - Uses echo commands every 30 seconds while connected
 - **Command Safety** - Blocks dangerous console commands
 - **Input Flexibility** - Vectors/rotators accept object or array format
 - **Asset Caching** - 10-second TTL for improved performance
+- **GraphQL** - Specialized endpoint for complex queries
+
+### Native C++ Architecture
+
+The server uses a 100% native C++ approach: all automation operations are implemented as native C++ handlers in the MCP Automation Bridge plugin (under `plugins/McpAutomationBridge/Source/`). This eliminates dependencies and provides better performance, reliability, and type safety.
+
+Configuration and runtime defaults are centralized in `src/constants.ts`. All operations route through the automation bridge's WebSocket protocol to native plugin handlers.
 
 ## Supported Asset Types
 
-Blueprints, Materials, Textures, Static/Skeletal Meshes, Levels, Sounds, Particles, Niagara Systems
+Blueprints, Materials, Textures, Static/Skeletal Meshes, Levels, Sounds, Particles, Niagara Systems, Behavior Trees
 
 ## Example Console Commands
 
@@ -171,18 +242,42 @@ Blueprints, Materials, Textures, Static/Skeletal Meshes, Levels, Sounds, Particl
 - **Gameplay**: `slomo 0.5`, `god`, `fly`
 - **Rendering**: `r.screenpercentage 50`, `r.vsync 0`
 
-## Configuration
+### Configuration
 
 ### Environment Variables
 
 ```env
-UE_HOST=127.0.0.1              # Unreal Engine host
-UE_RC_HTTP_PORT=30010          # Remote Control HTTP port
-UE_RC_WS_PORT=30020            # Remote Control WebSocket port
 UE_PROJECT_PATH="C:/Users/YourName/Documents/Unreal Projects/YourProject"  # Absolute path to your .uproject file
-LOG_LEVEL=info                 # debug | info | warn | error
+LOG_LEVEL=info                        # debug | info | warn | error
+
+# Automation bridge WebSocket client (Node -> Unreal editor)
+MCP_AUTOMATION_HOST=127.0.0.1         # Host/interface for the automation bridge connection
+MCP_AUTOMATION_PORT=8091              # Primary bridge port (must match the plugin's port)
+MCP_AUTOMATION_CLIENT_MODE=true       # Set to false to disable the automation bridge client
+MCP_AUTOMATION_CAPABILITY_TOKEN=      # Optional capability token for handshake security
+
+# Legacy/Alternative variables
+# MCP_AUTOMATION_WS_PORT=8090         # Fallback port if MCP_AUTOMATION_PORT is unset
+# MCP_AUTOMATION_BRIDGE_ENABLED=true  # Legacy alias for MCP_AUTOMATION_CLIENT_MODE
+
+# WebAssembly acceleration
+WASM_ENABLED=true                     # Default: enabled if unset; set false to force TS-only
+# Optional override when hosting the WASM bundle elsewhere:
+# WASM_PATH=file:///absolute/path/to/unreal_mcp_wasm.js
+
+# Timeouts / caching (advanced – safe defaults are baked in)
+MCP_AUTOMATION_REQUEST_TIMEOUT_MS=120000
+MCP_AUTOMATION_EVENT_TIMEOUT_MS=0
+ASSET_LIST_TTL_MS=10000
 ```
 
+Note on configuration precedence
+- The server uses `dotenv` to load `.env` for local development. A `.env.production` file is included as a reference for production deployments; copy values into your real environment or secret store as appropriate.
+- Environment variables (.env / system env) override the internal runtime defaults (for example, defaults in `src/index.ts`, `src/automation-bridge.ts`, and individual tool implementations). This lets you tune timeouts, logging, and WASM behavior without modifying source code. Keep secrets in `.env` or a secret manager — do not store secrets in source files.
+
+Mock mode
+
+
 ### Docker
 
 ```bash
@@ -200,7 +295,7 @@ docker run --rm -it mcp/server/unreal-engine-mcp-server:latest
 ## Development
 
 ```bash
-npm run build          # Build TypeScript
+npm run build          # Build TypeScript and (optionally) the WebAssembly bundle
 npm run lint           # Run ESLint
 npm run lint:fix       # Fix linting issues
 ```
@@ -214,4 +309,4 @@ Contributions welcome! Please:
 
 ## License
 
-MIT - See [LICENSE](LICENSE) file
+MIT - See [LICENSE](LICENSE) file

package/claude_desktop_config_example.json

@@ -2,13 +2,14 @@
   "mcpServers": {
     "unreal-engine": {
       "command": "node",
-      "args": ["PathToMCP\\UnrealMCP\\unreal-engine-mcp-server\\dist\\cli.js"],
+      "args": [
+        "PathToMCP\\UnrealMCP\\unreal-engine-mcp-server\\dist\\cli.js"
+      ],
       "env": {
-        "UE_HOST": "127.0.0.1",
-        "UE_RC_WS_PORT": "30020",
-        "UE_RC_HTTP_PORT": "30010",
-        "UE_PROJECT_PATH": "C:/Users/YourName/Documents/Unreal Projects/YourProject"
+        "UE_PROJECT_PATH": "C:/Users/YourName/Documents/Unreal Projects/YourProject",
+        "MCP_AUTOMATION_HOST": "127.0.0.1",
+        "MCP_AUTOMATION_PORT": "8091"
       }
     }
   }
-}
+}

package/dist/automation/bridge.d.ts

@@ -0,0 +1,50 @@
+import { EventEmitter } from 'node:events';
+import { AutomationBridgeOptions, AutomationBridgeStatus, AutomationBridgeMessage, AutomationBridgeResponseMessage, AutomationBridgeEvents } from './types.js';
+export declare class AutomationBridge extends EventEmitter {
+    private readonly host;
+    private readonly port;
+    private readonly ports;
+    private readonly negotiatedProtocols;
+    private readonly capabilityToken?;
+    private readonly enabled;
+    private readonly serverName;
+    private readonly serverVersion;
+    private readonly clientHost;
+    private readonly clientPort;
+    private readonly serverLegacyEnabled;
+    private readonly maxConcurrentConnections;
+    private connectionManager;
+    private requestTracker;
+    private handshakeHandler;
+    private messageHandler;
+    private log;
+    private lastHandshakeAt?;
+    private lastHandshakeMetadata?;
+    private lastHandshakeAck?;
+    private lastHandshakeFailure?;
+    private lastDisconnect?;
+    private lastError?;
+    private requestQueue;
+    private queuedRequestItems;
+    private connectionPromise?;
+    constructor(options?: AutomationBridgeOptions);
+    on<K extends keyof AutomationBridgeEvents>(event: K, listener: AutomationBridgeEvents[K]): this;
+    once<K extends keyof AutomationBridgeEvents>(event: K, listener: AutomationBridgeEvents[K]): this;
+    off<K extends keyof AutomationBridgeEvents>(event: K, listener: AutomationBridgeEvents[K]): this;
+    start(): void;
+    private startClient;
+    private handleClientConnection;
+    stop(): void;
+    isConnected(): boolean;
+    getStatus(): AutomationBridgeStatus;
+    sendAutomationRequest<T = AutomationBridgeResponseMessage>(action: string, payload?: Record<string, unknown>, options?: {
+        timeoutMs?: number;
+    }): Promise<T>;
+    private sendRequestInternal;
+    private processRequestQueue;
+    send(payload: AutomationBridgeMessage): boolean;
+    private broadcast;
+    private flushQueue;
+    private emitAutomation;
+}
+//# sourceMappingURL=bridge.d.ts.map