jmri-client 3.1.12-debug → 3.2.0

package/dist/browser/jmri-client.js

@@ -0,0 +1,1960 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// node_modules/eventemitter3/index.js
+var require_eventemitter3 = __commonJS({
+  "node_modules/eventemitter3/index.js"(exports, module) {
+    "use strict";
+    var has = Object.prototype.hasOwnProperty;
+    var prefix = "~";
+    function Events() {
+    }
+    if (Object.create) {
+      Events.prototype = /* @__PURE__ */ Object.create(null);
+      if (!new Events().__proto__) prefix = false;
+    }
+    function EE(fn, context, once) {
+      this.fn = fn;
+      this.context = context;
+      this.once = once || false;
+    }
+    function addListener(emitter, event, fn, context, once) {
+      if (typeof fn !== "function") {
+        throw new TypeError("The listener must be a function");
+      }
+      var listener = new EE(fn, context || emitter, once), evt = prefix ? prefix + event : event;
+      if (!emitter._events[evt]) emitter._events[evt] = listener, emitter._eventsCount++;
+      else if (!emitter._events[evt].fn) emitter._events[evt].push(listener);
+      else emitter._events[evt] = [emitter._events[evt], listener];
+      return emitter;
+    }
+    function clearEvent(emitter, evt) {
+      if (--emitter._eventsCount === 0) emitter._events = new Events();
+      else delete emitter._events[evt];
+    }
+    function EventEmitter2() {
+      this._events = new Events();
+      this._eventsCount = 0;
+    }
+    EventEmitter2.prototype.eventNames = function eventNames() {
+      var names = [], events, name;
+      if (this._eventsCount === 0) return names;
+      for (name in events = this._events) {
+        if (has.call(events, name)) names.push(prefix ? name.slice(1) : name);
+      }
+      if (Object.getOwnPropertySymbols) {
+        return names.concat(Object.getOwnPropertySymbols(events));
+      }
+      return names;
+    };
+    EventEmitter2.prototype.listeners = function listeners(event) {
+      var evt = prefix ? prefix + event : event, handlers = this._events[evt];
+      if (!handlers) return [];
+      if (handlers.fn) return [handlers.fn];
+      for (var i = 0, l = handlers.length, ee = new Array(l); i < l; i++) {
+        ee[i] = handlers[i].fn;
+      }
+      return ee;
+    };
+    EventEmitter2.prototype.listenerCount = function listenerCount(event) {
+      var evt = prefix ? prefix + event : event, listeners = this._events[evt];
+      if (!listeners) return 0;
+      if (listeners.fn) return 1;
+      return listeners.length;
+    };
+    EventEmitter2.prototype.emit = function emit(event, a1, a2, a3, a4, a5) {
+      var evt = prefix ? prefix + event : event;
+      if (!this._events[evt]) return false;
+      var listeners = this._events[evt], len = arguments.length, args, i;
+      if (listeners.fn) {
+        if (listeners.once) this.removeListener(event, listeners.fn, void 0, true);
+        switch (len) {
+          case 1:
+            return listeners.fn.call(listeners.context), true;
+          case 2:
+            return listeners.fn.call(listeners.context, a1), true;
+          case 3:
+            return listeners.fn.call(listeners.context, a1, a2), true;
+          case 4:
+            return listeners.fn.call(listeners.context, a1, a2, a3), true;
+          case 5:
+            return listeners.fn.call(listeners.context, a1, a2, a3, a4), true;
+          case 6:
+            return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true;
+        }
+        for (i = 1, args = new Array(len - 1); i < len; i++) {
+          args[i - 1] = arguments[i];
+        }
+        listeners.fn.apply(listeners.context, args);
+      } else {
+        var length = listeners.length, j;
+        for (i = 0; i < length; i++) {
+          if (listeners[i].once) this.removeListener(event, listeners[i].fn, void 0, true);
+          switch (len) {
+            case 1:
+              listeners[i].fn.call(listeners[i].context);
+              break;
+            case 2:
+              listeners[i].fn.call(listeners[i].context, a1);
+              break;
+            case 3:
+              listeners[i].fn.call(listeners[i].context, a1, a2);
+              break;
+            case 4:
+              listeners[i].fn.call(listeners[i].context, a1, a2, a3);
+              break;
+            default:
+              if (!args) for (j = 1, args = new Array(len - 1); j < len; j++) {
+                args[j - 1] = arguments[j];
+              }
+              listeners[i].fn.apply(listeners[i].context, args);
+          }
+        }
+      }
+      return true;
+    };
+    EventEmitter2.prototype.on = function on(event, fn, context) {
+      return addListener(this, event, fn, context, false);
+    };
+    EventEmitter2.prototype.once = function once(event, fn, context) {
+      return addListener(this, event, fn, context, true);
+    };
+    EventEmitter2.prototype.removeListener = function removeListener(event, fn, context, once) {
+      var evt = prefix ? prefix + event : event;
+      if (!this._events[evt]) return this;
+      if (!fn) {
+        clearEvent(this, evt);
+        return this;
+      }
+      var listeners = this._events[evt];
+      if (listeners.fn) {
+        if (listeners.fn === fn && (!once || listeners.once) && (!context || listeners.context === context)) {
+          clearEvent(this, evt);
+        }
+      } else {
+        for (var i = 0, events = [], length = listeners.length; i < length; i++) {
+          if (listeners[i].fn !== fn || once && !listeners[i].once || context && listeners[i].context !== context) {
+            events.push(listeners[i]);
+          }
+        }
+        if (events.length) this._events[evt] = events.length === 1 ? events[0] : events;
+        else clearEvent(this, evt);
+      }
+      return this;
+    };
+    EventEmitter2.prototype.removeAllListeners = function removeAllListeners(event) {
+      var evt;
+      if (event) {
+        evt = prefix ? prefix + event : event;
+        if (this._events[evt]) clearEvent(this, evt);
+      } else {
+        this._events = new Events();
+        this._eventsCount = 0;
+      }
+      return this;
+    };
+    EventEmitter2.prototype.off = EventEmitter2.prototype.removeListener;
+    EventEmitter2.prototype.addListener = EventEmitter2.prototype.on;
+    EventEmitter2.prefixed = prefix;
+    EventEmitter2.EventEmitter = EventEmitter2;
+    if ("undefined" !== typeof module) {
+      module.exports = EventEmitter2;
+    }
+  }
+});
+
+// node_modules/ws/browser.js
+var require_browser = __commonJS({
+  "node_modules/ws/browser.js"(exports, module) {
+    "use strict";
+    module.exports = function() {
+      throw new Error(
+        "ws does not work in the browser. Browser clients must use the native WebSocket object"
+      );
+    };
+  }
+});
+
+// node_modules/eventemitter3/index.mjs
+var import_index = __toESM(require_eventemitter3(), 1);
+
+// src/core/websocket-adapter.ts
+async function createWebSocketAdapter(url, protocols) {
+  const isBrowser = typeof window !== "undefined" && typeof window.WebSocket !== "undefined";
+  if (isBrowser) {
+    return new BrowserWebSocketAdapter(url, protocols);
+  } else {
+    return await NodeWebSocketAdapter.create(url, protocols);
+  }
+}
+var BrowserWebSocketAdapter = class extends import_index.default {
+  constructor(url, protocols) {
+    super();
+    this.ws = new WebSocket(url, protocols);
+    this.ws.onopen = () => {
+      this.emit("open");
+    };
+    this.ws.onmessage = (event) => {
+      this.emit("message", event.data);
+    };
+    this.ws.onerror = () => {
+      this.emit("error", new Error("WebSocket error"));
+    };
+    this.ws.onclose = (event) => {
+      this.emit("close", event.code, event.reason);
+    };
+  }
+  send(data) {
+    this.ws.send(data);
+  }
+  close(code, reason) {
+    this.ws.close(code, reason);
+  }
+  get readyState() {
+    return this.ws.readyState;
+  }
+};
+var NodeWebSocketAdapter = class _NodeWebSocketAdapter extends import_index.default {
+  constructor(ws) {
+    super();
+    this.ws = ws;
+    this.ws.on("open", () => {
+      this.emit("open");
+    });
+    this.ws.on("message", (data) => {
+      const message = typeof data === "string" ? data : data.toString();
+      this.emit("message", message);
+    });
+    this.ws.on("error", (error) => {
+      this.emit("error", error);
+    });
+    this.ws.on("close", (code, reason) => {
+      this.emit("close", code, reason);
+    });
+  }
+  static async create(url, protocols) {
+    const { default: WebSocket2 } = await Promise.resolve().then(() => __toESM(require_browser()));
+    const ws = new WebSocket2(url, protocols);
+    return new _NodeWebSocketAdapter(ws);
+  }
+  send(data) {
+    this.ws.send(data);
+  }
+  close(code, reason) {
+    this.ws.close(code, reason);
+  }
+  get readyState() {
+    return this.ws.readyState;
+  }
+};
+
+// src/types/events.ts
+var ConnectionState = /* @__PURE__ */ ((ConnectionState2) => {
+  ConnectionState2["DISCONNECTED"] = "disconnected";
+  ConnectionState2["CONNECTING"] = "connecting";
+  ConnectionState2["CONNECTED"] = "connected";
+  ConnectionState2["RECONNECTING"] = "reconnecting";
+  return ConnectionState2;
+})(ConnectionState || {});
+
+// src/utils/message-id.ts
+var MessageIdGenerator = class {
+  constructor() {
+    this.currentId = 0;
+    this.maxId = Number.MAX_SAFE_INTEGER;
+  }
+  /**
+   * Generate next sequential ID
+   * Wraps around at MAX_SAFE_INTEGER
+   */
+  next() {
+    this.currentId++;
+    if (this.currentId >= this.maxId) {
+      this.currentId = 1;
+    }
+    return this.currentId;
+  }
+  /**
+   * Reset ID counter to 0
+   */
+  reset() {
+    this.currentId = 0;
+  }
+  /**
+   * Get current ID without incrementing
+   */
+  current() {
+    return this.currentId;
+  }
+};
+
+// src/core/message-queue.ts
+var MessageQueue = class {
+  constructor(maxSize = 100) {
+    this.queue = [];
+    this.maxSize = maxSize;
+  }
+  /**
+   * Add message to queue
+   * If queue is full, oldest message is removed
+   */
+  enqueue(message) {
+    if (this.queue.length >= this.maxSize) {
+      this.queue.shift();
+    }
+    this.queue.push(message);
+  }
+  /**
+   * Get all queued messages and clear queue
+   */
+  flush() {
+    const messages = [...this.queue];
+    this.queue = [];
+    return messages;
+  }
+  /**
+   * Clear all queued messages without returning them
+   */
+  clear() {
+    this.queue = [];
+  }
+  /**
+   * Get number of queued messages
+   */
+  size() {
+    return this.queue.length;
+  }
+  /**
+   * Check if queue is empty
+   */
+  isEmpty() {
+    return this.queue.length === 0;
+  }
+  /**
+   * Check if queue is full
+   */
+  isFull() {
+    return this.queue.length >= this.maxSize;
+  }
+};
+
+// src/core/connection-state-manager.ts
+var VALID_TRANSITIONS = {
+  ["disconnected" /* DISCONNECTED */]: ["connecting" /* CONNECTING */],
+  ["connecting" /* CONNECTING */]: ["connected" /* CONNECTED */, "disconnected" /* DISCONNECTED */],
+  ["connected" /* CONNECTED */]: ["disconnected" /* DISCONNECTED */, "reconnecting" /* RECONNECTING */],
+  ["reconnecting" /* RECONNECTING */]: ["connecting" /* CONNECTING */, "connected" /* CONNECTED */, "disconnected" /* DISCONNECTED */]
+};
+var ConnectionStateManager = class extends import_index.default {
+  constructor() {
+    super(...arguments);
+    this.currentState = "disconnected" /* DISCONNECTED */;
+  }
+  /**
+   * Get current connection state
+   */
+  getState() {
+    return this.currentState;
+  }
+  /**
+   * Check if currently connected
+   */
+  isConnected() {
+    return this.currentState === "connected" /* CONNECTED */;
+  }
+  /**
+   * Check if currently connecting
+   */
+  isConnecting() {
+    return this.currentState === "connecting" /* CONNECTING */;
+  }
+  /**
+   * Check if currently disconnected
+   */
+  isDisconnected() {
+    return this.currentState === "disconnected" /* DISCONNECTED */;
+  }
+  /**
+   * Check if currently reconnecting
+   */
+  isReconnecting() {
+    return this.currentState === "reconnecting" /* RECONNECTING */;
+  }
+  /**
+   * Transition to new state
+   * Validates transition and emits event
+   */
+  transition(newState) {
+    const validTransitions = VALID_TRANSITIONS[this.currentState];
+    if (!validTransitions.includes(newState)) {
+      throw new Error(
+        `Invalid state transition: ${this.currentState} -> ${newState}`
+      );
+    }
+    const previousState = this.currentState;
+    this.currentState = newState;
+    this.emit("stateChanged", newState, previousState);
+  }
+  /**
+   * Force state without validation (use with caution)
+   */
+  forceState(newState) {
+    const previousState = this.currentState;
+    this.currentState = newState;
+    this.emit("stateChanged", newState, previousState);
+  }
+  /**
+   * Reset to disconnected state
+   */
+  reset() {
+    this.forceState("disconnected" /* DISCONNECTED */);
+  }
+};
+
+// src/core/heartbeat-manager.ts
+var HeartbeatManager = class extends import_index.default {
+  constructor(options) {
+    super();
+    this.isRunning = false;
+    this.options = options;
+  }
+  /**
+   * Start heartbeat monitoring
+   * @param sendPing - Callback to send ping message
+   */
+  start(sendPing) {
+    if (!this.options.enabled || this.isRunning) {
+      return;
+    }
+    this.isRunning = true;
+    this.pingInterval = setInterval(() => {
+      sendPing();
+      this.emit("pingSent");
+      this.pongTimeout = setTimeout(() => {
+        this.emit("timeout");
+      }, this.options.timeout);
+    }, this.options.interval);
+  }
+  /**
+   * Stop heartbeat monitoring
+   */
+  stop() {
+    this.isRunning = false;
+    if (this.pingInterval) {
+      clearInterval(this.pingInterval);
+      this.pingInterval = void 0;
+    }
+    if (this.pongTimeout) {
+      clearTimeout(this.pongTimeout);
+      this.pongTimeout = void 0;
+    }
+  }
+  /**
+   * Handle pong received from server
+   */
+  receivedPong() {
+    if (this.pongTimeout) {
+      clearTimeout(this.pongTimeout);
+      this.pongTimeout = void 0;
+    }
+    this.emit("pongReceived");
+  }
+  /**
+   * Check if heartbeat is running
+   */
+  running() {
+    return this.isRunning;
+  }
+  /**
+   * Update heartbeat options
+   */
+  updateOptions(options) {
+    const wasRunning = this.isRunning;
+    if (wasRunning) {
+      this.stop();
+    }
+    this.options = { ...this.options, ...options };
+  }
+};
+
+// src/utils/exponential-backoff.ts
+function calculateBackoffDelay(attempt, options) {
+  const exponentialDelay = options.initialDelay * Math.pow(options.multiplier, attempt - 1);
+  const cappedDelay = Math.min(exponentialDelay, options.maxDelay);
+  if (options.jitter) {
+    const jitterAmount = cappedDelay * 0.25;
+    const jitter = (Math.random() * 2 - 1) * jitterAmount;
+    return Math.max(0, Math.round(cappedDelay + jitter));
+  }
+  return Math.round(cappedDelay);
+}
+function shouldReconnect(attempt, maxAttempts) {
+  if (maxAttempts === 0) {
+    return true;
+  }
+  return attempt <= maxAttempts;
+}
+
+// src/core/reconnection-manager.ts
+var ReconnectionManager = class extends import_index.default {
+  constructor(options) {
+    super();
+    this.currentAttempt = 0;
+    this.isReconnecting = false;
+    this.options = options;
+  }
+  /**
+   * Start reconnection process
+   * @param reconnect - Callback to attempt reconnection
+   */
+  start(reconnect) {
+    if (!this.options.enabled || this.isReconnecting) {
+      return;
+    }
+    this.isReconnecting = true;
+    this.currentAttempt = 0;
+    this.scheduleNextAttempt(reconnect);
+  }
+  /**
+   * Schedule next reconnection attempt
+   */
+  scheduleNextAttempt(reconnect) {
+    this.currentAttempt++;
+    if (!shouldReconnect(this.currentAttempt, this.options.maxAttempts)) {
+      this.emit("maxAttemptsReached", this.currentAttempt - 1);
+      this.stop();
+      return;
+    }
+    const delay = calculateBackoffDelay(this.currentAttempt, this.options);
+    this.emit("attemptScheduled", this.currentAttempt, delay);
+    this.reconnectTimeout = setTimeout(async () => {
+      this.emit("attempting", this.currentAttempt);
+      try {
+        await reconnect();
+        this.stop();
+        this.emit("success", this.currentAttempt);
+      } catch (error) {
+        this.emit("failed", this.currentAttempt, error);
+        this.scheduleNextAttempt(reconnect);
+      }
+    }, delay);
+  }
+  /**
+   * Stop reconnection process
+   */
+  stop() {
+    this.isReconnecting = false;
+    if (this.reconnectTimeout) {
+      clearTimeout(this.reconnectTimeout);
+      this.reconnectTimeout = void 0;
+    }
+  }
+  /**
+   * Reset attempt counter
+   */
+  reset() {
+    this.stop();
+    this.currentAttempt = 0;
+  }
+  /**
+   * Check if currently reconnecting
+   */
+  reconnecting() {
+    return this.isReconnecting;
+  }
+  /**
+   * Get current attempt number
+   */
+  getAttempt() {
+    return this.currentAttempt;
+  }
+  /**
+   * Update reconnection options
+   */
+  updateOptions(options) {
+    this.options = { ...this.options, ...options };
+  }
+};
+
+// src/types/jmri-messages.ts
+var PowerState = /* @__PURE__ */ ((PowerState2) => {
+  PowerState2[PowerState2["ON"] = 2] = "ON";
+  PowerState2[PowerState2["OFF"] = 4] = "OFF";
+  PowerState2[PowerState2["UNKNOWN"] = 0] = "UNKNOWN";
+  return PowerState2;
+})(PowerState || {});
+
+// src/mocks/mock-data.ts
+var mockData = {
+  "hello": {
+    "type": "hello",
+    "data": {
+      "JMRI": "5.9.2",
+      "JSON": "5.0",
+      "Railroad": "Demo Railroad",
+      "node": "jmri-server",
+      "activeProfile": "Demo Profile"
+    }
+  },
+  "power": {
+    "get": {
+      "on": {
+        "type": "power",
+        "data": {
+          "state": 2
+        }
+      },
+      "off": {
+        "type": "power",
+        "data": {
+          "state": 4
+        }
+      }
+    },
+    "post": {
+      "success": {
+        "type": "power",
+        "data": {
+          "state": 2
+        }
+      }
+    }
+  },
+  "roster": {
+    "list": {
+      "type": "roster",
+      "data": {
+        "CSX754": {
+          "name": "CSX754",
+          "address": "754",
+          "isLongAddress": true,
+          "road": "CSX",
+          "number": "754",
+          "mfg": "Athearn",
+          "model": "GP38-2",
+          "comment": "Blue and yellow scheme",
+          "maxSpeed": 126,
+          "functionKeys": {
+            "F0": "Headlight",
+            "F1": "Bell",
+            "F2": "Horn",
+            "F3": "Air Release",
+            "F4": "Dynamic Brake"
+          }
+        },
+        "UP3985": {
+          "name": "UP3985",
+          "address": "3985",
+          "isLongAddress": true,
+          "road": "Union Pacific",
+          "number": "3985",
+          "mfg": "Rivarossi",
+          "model": "Challenger 4-6-6-4",
+          "comment": "Steam locomotive",
+          "maxSpeed": 126,
+          "functionKeys": {
+            "F0": "Headlight",
+            "F1": "Bell",
+            "F2": "Whistle",
+            "F3": "Steam",
+            "F4": "Coupler"
+          }
+        },
+        "BNSF5240": {
+          "name": "BNSF5240",
+          "address": "5240",
+          "isLongAddress": true,
+          "road": "BNSF",
+          "number": "5240",
+          "mfg": "Kato",
+          "model": "SD40-2",
+          "comment": "Heritage II paint",
+          "maxSpeed": 126,
+          "functionKeys": {
+            "F0": "Headlight",
+            "F1": "Bell",
+            "F2": "Horn",
+            "F3": "Dynamic Brake",
+            "F4": "Mars Light"
+          }
+        }
+      }
+    }
+  },
+  "throttle": {
+    "acquire": {
+      "success": {
+        "type": "throttle",
+        "data": {
+          "throttle": "{THROTTLE_ID}",
+          "address": "{ADDRESS}",
+          "speed": 0,
+          "forward": true,
+          "F0": false,
+          "F1": false,
+          "F2": false,
+          "F3": false,
+          "F4": false
+        }
+      }
+    },
+    "release": {
+      "success": {
+        "type": "throttle",
+        "data": {}
+      }
+    },
+    "control": {
+      "speed": {
+        "type": "throttle",
+        "data": {
+          "throttle": "{THROTTLE_ID}",
+          "speed": "{SPEED}"
+        }
+      },
+      "direction": {
+        "type": "throttle",
+        "data": {
+          "throttle": "{THROTTLE_ID}",
+          "forward": "{FORWARD}"
+        }
+      },
+      "function": {
+        "type": "throttle",
+        "data": {
+          "throttle": "{THROTTLE_ID}",
+          "{FUNCTION}": "{VALUE}"
+        }
+      }
+    }
+  },
+  "ping": {
+    "type": "ping"
+  },
+  "pong": {
+    "type": "pong"
+  },
+  "goodbye": {
+    "type": "goodbye"
+  },
+  "error": {
+    "throttleNotFound": {
+      "type": "error",
+      "data": {
+        "code": 404,
+        "message": "Throttle not found"
+      }
+    },
+    "invalidSpeed": {
+      "type": "error",
+      "data": {
+        "code": 400,
+        "message": "Invalid speed value"
+      }
+    },
+    "connectionError": {
+      "type": "error",
+      "data": {
+        "code": 500,
+        "message": "Connection error"
+      }
+    }
+  }
+};
+
+// src/mocks/mock-response-manager.ts
+var MockResponseManager = class {
+  constructor(options = {}) {
+    this.throttles = /* @__PURE__ */ new Map();
+    this.responseDelay = options.responseDelay ?? 50;
+    this.powerState = options.initialPowerState ?? 4 /* OFF */;
+  }
+  /**
+   * Get a mock response for a given message
+   */
+  async getMockResponse(message) {
+    if (this.responseDelay > 0) {
+      await this.delay(this.responseDelay);
+    }
+    switch (message.type) {
+      case "hello":
+        return this.getHelloResponse();
+      case "power":
+        return this.getPowerResponse(message);
+      case "roster":
+        return this.getRosterResponse(message);
+      case "throttle":
+        return this.getThrottleResponse(message);
+      case "ping":
+        return this.getPingResponse();
+      case "goodbye":
+        return this.getGoodbyeResponse();
+      default:
+        return null;
+    }
+  }
+  /**
+   * Get hello response (connection establishment)
+   */
+  getHelloResponse() {
+    return JSON.parse(JSON.stringify(mockData.hello));
+  }
+  /**
+   * Get power response
+   */
+  getPowerResponse(message) {
+    if (message.data?.state !== void 0) {
+      this.powerState = message.data.state;
+      return {
+        type: "power",
+        data: { state: this.powerState }
+      };
+    }
+    return {
+      type: "power",
+      data: { state: this.powerState }
+    };
+  }
+  /**
+   * Get roster response
+   */
+  getRosterResponse(message) {
+    if (message.type === "roster" && message.method === "list") {
+      return JSON.parse(JSON.stringify(mockData.roster.list));
+    }
+    return {
+      type: "roster",
+      method: "list",
+      data: {}
+    };
+  }
+  /**
+   * Get throttle response
+   */
+  getThrottleResponse(message) {
+    const data = message.data || {};
+    if (data.address !== void 0 && !data.throttle) {
+      const throttleId = data.name || `MOCK-${data.address}`;
+      const throttleState = {
+        throttle: throttleId,
+        address: data.address,
+        speed: 0,
+        forward: true,
+        F0: false,
+        F1: false,
+        F2: false,
+        F3: false,
+        F4: false
+      };
+      this.throttles.set(throttleId, throttleState);
+      return {
+        type: "throttle",
+        data: { ...throttleState }
+      };
+    }
+    if (data.release !== void 0 && data.throttle) {
+      this.throttles.delete(data.throttle);
+      return {
+        type: "throttle",
+        data: {}
+      };
+    }
+    if (data.throttle) {
+      const throttleState = this.throttles.get(data.throttle);
+      if (!throttleState) {
+        const newState = {
+          throttle: data.throttle,
+          address: 0,
+          speed: 0,
+          forward: true
+        };
+        this.throttles.set(data.throttle, newState);
+        return {
+          type: "throttle",
+          data: { ...newState }
+        };
+      }
+      if (data.speed !== void 0) {
+        throttleState.speed = data.speed;
+      }
+      if (data.forward !== void 0) {
+        throttleState.forward = data.forward;
+      }
+      for (let i = 0; i <= 28; i++) {
+        const key = `F${i}`;
+        if (data[key] !== void 0) {
+          throttleState[key] = data[key];
+        }
+      }
+      return {
+        type: "throttle",
+        data: {}
+      };
+    }
+    return {
+      type: "throttle",
+      data: {}
+    };
+  }
+  /**
+   * Get ping response (pong)
+   */
+  getPingResponse() {
+    return JSON.parse(JSON.stringify(mockData.pong));
+  }
+  /**
+   * Get goodbye response
+   */
+  getGoodbyeResponse() {
+    return JSON.parse(JSON.stringify(mockData.goodbye));
+  }
+  /**
+   * Get current power state
+   */
+  getPowerState() {
+    return this.powerState;
+  }
+  /**
+   * Set power state (for testing)
+   */
+  setPowerState(state) {
+    this.powerState = state;
+  }
+  /**
+   * Get all throttles (for testing)
+   */
+  getThrottles() {
+    return this.throttles;
+  }
+  /**
+   * Reset all state (for testing)
+   */
+  reset() {
+    this.powerState = 4 /* OFF */;
+    this.throttles.clear();
+  }
+  /**
+   * Delay helper
+   */
+  delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+};
+var mockResponseManager = new MockResponseManager({ responseDelay: 0 });
+
+// src/core/websocket-client.ts
+var WebSocketClient = class extends import_index.default {
+  constructor(options) {
+    super();
+    // Request/response tracking
+    this.pendingRequests = /* @__PURE__ */ new Map();
+    // Connection state
+    this.isManualDisconnect = false;
+    this.options = options;
+    this.url = `${options.protocol}://${options.host}:${options.port}/json/`;
+    this.messageIdGen = new MessageIdGenerator();
+    this.messageQueue = new MessageQueue(options.messageQueueSize);
+    this.stateManager = new ConnectionStateManager();
+    this.heartbeatManager = new HeartbeatManager(options.heartbeat);
+    this.reconnectionManager = new ReconnectionManager(options.reconnection);
+    if (options.mock.enabled) {
+      this.mockManager = new MockResponseManager({
+        responseDelay: options.mock.responseDelay
+      });
+    }
+    this.stateManager.on("stateChanged", (newState, prevState) => {
+      this.emit("connectionStateChanged", newState, prevState);
+    });
+    this.heartbeatManager.on("timeout", () => {
+      this.emit("heartbeat:timeout");
+      this.handleHeartbeatTimeout();
+    });
+    this.heartbeatManager.on("pingSent", () => {
+      this.emit("heartbeat:sent");
+    });
+    this.reconnectionManager.on("attemptScheduled", (attempt, delay) => {
+      this.emit("reconnecting", attempt, delay);
+    });
+    this.reconnectionManager.on("success", () => {
+      this.emit("reconnected");
+    });
+    this.reconnectionManager.on("maxAttemptsReached", (attempts) => {
+      this.emit("reconnectionFailed", attempts);
+    });
+    this.reconnectionManager.on("debug", (message) => {
+      this.emit("debug", message);
+    });
+  }
+  /**
+   * Connect to JMRI WebSocket server (or mock)
+   */
+  async connect() {
+    if (this.stateManager.isConnected() || this.stateManager.isConnecting()) {
+      return;
+    }
+    this.isManualDisconnect = false;
+    this.stateManager.transition("connecting" /* CONNECTING */);
+    if (this.mockManager) {
+      return this.connectMock();
+    }
+    return new Promise(async (resolve, reject) => {
+      try {
+        this.ws = await createWebSocketAdapter(this.url);
+        this.ws.on("open", () => {
+          this.handleOpen();
+          resolve();
+        });
+        this.ws.on("message", (data) => {
+          this.handleMessage(data);
+        });
+        this.ws.on("close", (code, reason) => {
+          if (this.stateManager.isConnecting()) {
+            this.stateManager.transition("disconnected" /* DISCONNECTED */);
+            const error = new Error(`WebSocket connection failed (code: ${code}${reason ? ", reason: " + reason : ""})`);
+            this.emit("error", error);
+            reject(error);
+            this.handleClose(code, reason);
+          } else {
+            this.handleClose(code, reason);
+          }
+        });
+        this.ws.on("error", (error) => {
+          this.emit("error", error);
+          if (this.stateManager.isConnecting()) {
+            this.stateManager.transition("disconnected" /* DISCONNECTED */);
+            reject(error);
+          }
+        });
+      } catch (error) {
+        this.stateManager.transition("disconnected" /* DISCONNECTED */);
+        reject(error);
+      }
+    });
+  }
+  /**
+   * Simulate connection in mock mode
+   */
+  async connectMock() {
+    await this.delay(10);
+    this.handleOpen();
+    const helloResponse = await this.mockManager.getMockResponse({ type: "hello" });
+    if (helloResponse) {
+      this.emit("message:received", helloResponse);
+    }
+  }
+  /**
+   * Disconnect from JMRI WebSocket server
+   */
+  async disconnect() {
+    if (this.stateManager.isDisconnected()) {
+      return;
+    }
+    this.isManualDisconnect = true;
+    this.reconnectionManager.stop();
+    this.heartbeatManager.stop();
+    if (this.stateManager.isConnected()) {
+      try {
+        await this.sendGoodbye();
+      } catch (error) {
+      }
+    }
+    if (this.ws) {
+      this.ws.close();
+      this.ws = void 0;
+    }
+    this.rejectAllPendingRequests(new Error("Client disconnected"));
+    if (!this.stateManager.isDisconnected()) {
+      this.stateManager.transition("disconnected" /* DISCONNECTED */);
+    }
+  }
+  /**
+   * Send message to JMRI (or mock)
+   */
+  send(message) {
+    if (!this.stateManager.isConnected()) {
+      this.messageQueue.enqueue(message);
+      return;
+    }
+    if (this.mockManager) {
+      this.emit("message:sent", message);
+      return;
+    }
+    if (!this.ws) {
+      throw new Error("WebSocket not initialized");
+    }
+    const json = JSON.stringify(message);
+    this.ws.send(json);
+    this.emit("message:sent", message);
+  }
+  /**
+   * Send request and wait for response (or get mock response)
+   */
+  async request(message, timeout) {
+    if (this.mockManager) {
+      const response = await this.mockManager.getMockResponse(message);
+      this.emit("message:sent", message);
+      if (response) {
+        this.emit("message:received", response);
+      }
+      return response;
+    }
+    const id = this.messageIdGen.next();
+    message.id = id;
+    return new Promise((resolve, reject) => {
+      const timeoutMs = timeout || this.options.requestTimeout;
+      const timeoutHandle = setTimeout(() => {
+        this.pendingRequests.delete(id);
+        reject(new Error(`Request timeout after ${timeoutMs}ms`));
+      }, timeoutMs);
+      const pendingRequest = {
+        resolve,
+        reject,
+        timeout: timeoutHandle,
+        messageType: message.type
+      };
+      if (message.type === "throttle" && message.data && "name" in message.data) {
+        pendingRequest.matchKey = message.data.name;
+      }
+      this.pendingRequests.set(id, pendingRequest);
+      try {
+        this.send(message);
+      } catch (error) {
+        this.pendingRequests.delete(id);
+        clearTimeout(timeoutHandle);
+        reject(error);
+      }
+    });
+  }
+  /**
+   * Get current connection state
+   */
+  getState() {
+    return this.stateManager.getState();
+  }
+  /**
+   * Check if connected
+   */
+  isConnected() {
+    return this.stateManager.isConnected();
+  }
+  /**
+   * Handle WebSocket open event
+   */
+  handleOpen() {
+    this.stateManager.transition("connected" /* CONNECTED */);
+    this.emit("connected");
+    if (this.options.heartbeat.enabled) {
+      this.heartbeatManager.start(() => this.sendPing());
+    }
+    const queuedMessages = this.messageQueue.flush();
+    for (const message of queuedMessages) {
+      this.send(message);
+    }
+  }
+  /**
+   * Handle WebSocket message event
+   */
+  handleMessage(data) {
+    try {
+      const message = JSON.parse(data);
+      this.emit("message:received", message);
+      if (message.type === "pong") {
+        this.heartbeatManager.receivedPong();
+        return;
+      }
+      if (message.type === "hello") {
+        this.emit("hello", message.data);
+        return;
+      }
+      if (message.id !== void 0) {
+        const pending = this.pendingRequests.get(message.id);
+        if (pending) {
+          clearTimeout(pending.timeout);
+          this.pendingRequests.delete(message.id);
+          pending.resolve(message);
+          return;
+        }
+      }
+      if (message.id === void 0) {
+        for (const [id, pending] of this.pendingRequests.entries()) {
+          if (pending.messageType === message.type) {
+            if (message.type === "throttle" && pending.matchKey) {
+              const throttleName = message.data?.throttle || message.data?.name;
+              if (throttleName === pending.matchKey) {
+                clearTimeout(pending.timeout);
+                this.pendingRequests.delete(id);
+                pending.resolve(message);
+                return;
+              }
+            } else {
+              clearTimeout(pending.timeout);
+              this.pendingRequests.delete(id);
+              pending.resolve(message);
+              return;
+            }
+          }
+        }
+      }
+      this.emit("update", message);
+    } catch (error) {
+      this.emit("error", new Error(`Failed to parse message: ${error}`));
+    }
+  }
+  /**
+   * Handle WebSocket close event
+   */
+  handleClose(code, reason) {
+    this.heartbeatManager.stop();
+    const wasConnected = this.stateManager.isConnected();
+    const isReconnecting = this.reconnectionManager.reconnecting();
+    if (this.stateManager.isConnected() || this.stateManager.isConnecting()) {
+      this.stateManager.transition("disconnected" /* DISCONNECTED */);
+    }
+    this.emit("disconnected", reason || `Connection closed (code: ${code})`);
+    this.rejectAllPendingRequests(new Error("Connection closed"));
+    if (!this.isManualDisconnect && (wasConnected || isReconnecting) && this.options.reconnection.enabled) {
+      this.stateManager.forceState("reconnecting" /* RECONNECTING */);
+      this.reconnectionManager.start(() => this.connect());
+    }
+  }
+  /**
+   * Handle heartbeat timeout
+   */
+  handleHeartbeatTimeout() {
+    if (this.ws) {
+      this.ws.close();
+    }
+  }
+  /**
+   * Send ping message
+   */
+  sendPing() {
+    this.send({ type: "ping" });
+  }
+  /**
+   * Send goodbye message
+   */
+  async sendGoodbye() {
+    const message = { type: "goodbye" };
+    this.send(message);
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+  /**
+   * Reject all pending requests
+   */
+  rejectAllPendingRequests(error) {
+    for (const pending of this.pendingRequests.values()) {
+      clearTimeout(pending.timeout);
+      pending.reject(error);
+    }
+    this.pendingRequests.clear();
+  }
+  /**
+   * Delay helper
+   */
+  delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+};
+
+// src/managers/power-manager.ts
+var PowerManager = class extends import_index.default {
+  constructor(client) {
+    super();
+    this.currentState = 0 /* UNKNOWN */;
+    this.client = client;
+    this.client.on("update", (message) => {
+      if (message.type === "power") {
+        this.handlePowerUpdate(message);
+      }
+    });
+  }
+  /**
+   * Get current track power state
+   */
+  async getPower() {
+    const message = {
+      type: "power"
+    };
+    const response = await this.client.request(message);
+    if (response.data?.state !== void 0) {
+      this.currentState = response.data.state;
+    }
+    return this.currentState;
+  }
+  /**
+   * Set track power state
+   */
+  async setPower(state) {
+    const message = {
+      type: "power",
+      method: "post",
+      data: { state }
+    };
+    await this.client.request(message);
+    const oldState = this.currentState;
+    this.currentState = state;
+    if (oldState !== this.currentState) {
+      this.emit("power:changed", this.currentState);
+    }
+  }
+  /**
+   * Turn track power on
+   */
+  async powerOn() {
+    await this.setPower(2 /* ON */);
+  }
+  /**
+   * Turn track power off
+   */
+  async powerOff() {
+    await this.setPower(4 /* OFF */);
+  }
+  /**
+   * Get cached power state (no network request)
+   */
+  getCachedState() {
+    return this.currentState;
+  }
+  /**
+   * Handle unsolicited power updates from JMRI
+   */
+  handlePowerUpdate(message) {
+    if (message.data?.state !== void 0) {
+      const oldState = this.currentState;
+      this.currentState = message.data.state;
+      if (oldState !== this.currentState) {
+        this.emit("power:changed", this.currentState);
+      }
+    }
+  }
+};
+
+// src/managers/roster-manager.ts
+var RosterManager = class {
+  constructor(client) {
+    this.rosterCache = /* @__PURE__ */ new Map();
+    this.client = client;
+  }
+  /**
+   * Get all roster entries
+   */
+  async getRoster() {
+    const message = {
+      type: "roster",
+      method: "list"
+    };
+    const response = await this.client.request(message);
+    if (response.data) {
+      this.updateCache(response.data);
+    }
+    return Array.from(this.rosterCache.values());
+  }
+  /**
+   * Get roster entry by name
+   */
+  async getRosterEntryByName(name) {
+    if (this.rosterCache.has(name)) {
+      return this.rosterCache.get(name);
+    }
+    await this.getRoster();
+    return this.rosterCache.get(name);
+  }
+  /**
+   * Get roster entry by address
+   */
+  async getRosterEntryByAddress(address) {
+    if (this.rosterCache.size === 0) {
+      await this.getRoster();
+    }
+    const addressStr = address.toString();
+    for (const entry of this.rosterCache.values()) {
+      if (entry.address === addressStr) {
+        return entry;
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Search roster by partial name match
+   */
+  async searchRoster(query) {
+    if (this.rosterCache.size === 0) {
+      await this.getRoster();
+    }
+    const lowerQuery = query.toLowerCase();
+    const results = [];
+    for (const entry of this.rosterCache.values()) {
+      if (entry.name.toLowerCase().includes(lowerQuery) || entry.address.includes(query) || entry.road?.toLowerCase().includes(lowerQuery) || entry.number?.includes(query)) {
+        results.push(entry);
+      }
+    }
+    return results;
+  }
+  /**
+   * Get cached roster (no network request)
+   */
+  getCachedRoster() {
+    return Array.from(this.rosterCache.values());
+  }
+  /**
+   * Clear roster cache
+   */
+  clearCache() {
+    this.rosterCache.clear();
+  }
+  /**
+   * Update internal cache from roster data
+   */
+  updateCache(rosterData) {
+    this.rosterCache.clear();
+    for (const [name, entry] of Object.entries(rosterData)) {
+      this.rosterCache.set(name, entry);
+    }
+  }
+};
+
+// src/types/throttle.ts
+function isThrottleFunctionKey(key) {
+  return /^F([0-9]|1[0-9]|2[0-8])$/.test(key);
+}
+function isValidSpeed(speed) {
+  return typeof speed === "number" && speed >= 0 && speed <= 1;
+}
+
+// src/managers/throttle-manager.ts
+var ThrottleManager = class extends import_index.default {
+  constructor(client) {
+    super();
+    this.throttles = /* @__PURE__ */ new Map();
+    this.client = client;
+    this.clientId = `jmri-client-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+    this.client.on("update", (message) => {
+      if (message.type === "throttle") {
+        this.handleThrottleUpdate(message);
+      }
+    });
+    this.client.on("disconnected", () => {
+      this.handleDisconnect();
+    });
+  }
+  /**
+   * Acquire a throttle for a locomotive
+   */
+  async acquireThrottle(options) {
+    const throttleName = `${this.clientId}-${options.address}`;
+    const message = {
+      type: "throttle",
+      data: {
+        name: throttleName,
+        address: options.address
+      }
+    };
+    const response = await this.client.request(message);
+    const throttleId = response.data?.throttle || throttleName;
+    if (!throttleId) {
+      throw new Error("Failed to acquire throttle: no throttle ID returned");
+    }
+    const state = {
+      id: throttleId,
+      address: options.address,
+      speed: 0,
+      forward: true,
+      functions: /* @__PURE__ */ new Map(),
+      acquired: true
+    };
+    this.throttles.set(throttleId, state);
+    this.emit("throttle:acquired", throttleId);
+    return throttleId;
+  }
+  /**
+   * Release a throttle
+   */
+  async releaseThrottle(throttleId) {
+    const state = this.throttles.get(throttleId);
+    if (!state) {
+      throw new Error(`Throttle not found: ${throttleId}`);
+    }
+    const message = {
+      type: "throttle",
+      data: {
+        throttle: throttleId,
+        release: null
+      }
+    };
+    await this.client.request(message);
+    this.throttles.delete(throttleId);
+    this.emit("throttle:released", throttleId);
+  }
+  /**
+   * Set throttle speed (0.0 to 1.0)
+   */
+  async setSpeed(throttleId, speed) {
+    const state = this.throttles.get(throttleId);
+    if (!state) {
+      throw new Error(`Throttle not found: ${throttleId}`);
+    }
+    if (!isValidSpeed(speed)) {
+      throw new Error(`Invalid speed: ${speed}. Must be between 0.0 and 1.0`);
+    }
+    const message = {
+      type: "throttle",
+      data: {
+        throttle: throttleId,
+        speed
+      }
+    };
+    this.client.send(message);
+    state.speed = speed;
+    this.emit("throttle:updated", throttleId, { speed });
+  }
+  /**
+   * Set throttle direction
+   */
+  async setDirection(throttleId, forward) {
+    const state = this.throttles.get(throttleId);
+    if (!state) {
+      throw new Error(`Throttle not found: ${throttleId}`);
+    }
+    const message = {
+      type: "throttle",
+      data: {
+        throttle: throttleId,
+        forward
+      }
+    };
+    this.client.send(message);
+    state.forward = forward;
+    this.emit("throttle:updated", throttleId, { forward });
+  }
+  /**
+   * Set throttle function (F0-F28)
+   */
+  async setFunction(throttleId, functionKey, value) {
+    const state = this.throttles.get(throttleId);
+    if (!state) {
+      throw new Error(`Throttle not found: ${throttleId}`);
+    }
+    if (!isThrottleFunctionKey(functionKey)) {
+      throw new Error(`Invalid function key: ${functionKey}`);
+    }
+    const data = {
+      throttle: throttleId,
+      [functionKey]: value
+    };
+    const message = {
+      type: "throttle",
+      data
+    };
+    this.client.send(message);
+    state.functions.set(functionKey, value);
+    this.emit("throttle:updated", throttleId, { [functionKey]: value });
+  }
+  /**
+   * Emergency stop for a throttle (speed to 0)
+   */
+  async emergencyStop(throttleId) {
+    await this.setSpeed(throttleId, 0);
+  }
+  /**
+   * Set throttle to idle (speed to 0, maintain direction)
+   */
+  async idle(throttleId) {
+    await this.setSpeed(throttleId, 0);
+  }
+  /**
+   * Get throttle state
+   */
+  getThrottleState(throttleId) {
+    return this.throttles.get(throttleId);
+  }
+  /**
+   * Get all throttle IDs
+   */
+  getThrottleIds() {
+    return Array.from(this.throttles.keys());
+  }
+  /**
+   * Get all throttle states
+   */
+  getAllThrottles() {
+    return Array.from(this.throttles.values());
+  }
+  /**
+   * Release all throttles
+   */
+  async releaseAllThrottles() {
+    const throttleIds = this.getThrottleIds();
+    for (const throttleId of throttleIds) {
+      try {
+        await this.releaseThrottle(throttleId);
+      } catch (error) {
+        this.emit("error", error);
+      }
+    }
+  }
+  /**
+   * Handle unsolicited throttle updates from JMRI
+   */
+  handleThrottleUpdate(message) {
+    const throttleId = message.data?.throttle;
+    if (!throttleId) {
+      return;
+    }
+    const state = this.throttles.get(throttleId);
+    if (!state) {
+      this.emit("throttle:lost", throttleId);
+      return;
+    }
+    if (message.data.speed !== void 0) {
+      state.speed = message.data.speed;
+    }
+    if (message.data.forward !== void 0) {
+      state.forward = message.data.forward;
+    }
+    for (let i = 0; i <= 28; i++) {
+      const key = `F${i}`;
+      if (message.data[key] !== void 0) {
+        state.functions.set(key, message.data[key]);
+      }
+    }
+    this.emit("throttle:updated", throttleId, message.data);
+  }
+  /**
+   * Handle disconnect - mark all throttles as not acquired
+   */
+  handleDisconnect() {
+    for (const state of this.throttles.values()) {
+      state.acquired = false;
+    }
+  }
+};
+
+// src/types/client-options.ts
+var DEFAULT_CLIENT_OPTIONS = {
+  host: "localhost",
+  port: 12080,
+  protocol: "ws",
+  autoConnect: true,
+  reconnection: {
+    enabled: true,
+    maxAttempts: 0,
+    // infinite
+    initialDelay: 1e3,
+    maxDelay: 3e4,
+    multiplier: 1.5,
+    jitter: true
+  },
+  heartbeat: {
+    enabled: true,
+    interval: 3e4,
+    timeout: 5e3
+  },
+  messageQueueSize: 100,
+  requestTimeout: 1e4,
+  mock: {
+    enabled: false,
+    responseDelay: 50
+  }
+};
+function mergeOptions(userOptions) {
+  const options = { ...DEFAULT_CLIENT_OPTIONS };
+  if (!userOptions) {
+    return options;
+  }
+  if (userOptions.host !== void 0) options.host = userOptions.host;
+  if (userOptions.port !== void 0) options.port = userOptions.port;
+  if (userOptions.protocol !== void 0) options.protocol = userOptions.protocol;
+  if (userOptions.autoConnect !== void 0) options.autoConnect = userOptions.autoConnect;
+  if (userOptions.messageQueueSize !== void 0) options.messageQueueSize = userOptions.messageQueueSize;
+  if (userOptions.requestTimeout !== void 0) options.requestTimeout = userOptions.requestTimeout;
+  if (userOptions.reconnection) {
+    options.reconnection = { ...DEFAULT_CLIENT_OPTIONS.reconnection, ...userOptions.reconnection };
+  }
+  if (userOptions.heartbeat) {
+    options.heartbeat = { ...DEFAULT_CLIENT_OPTIONS.heartbeat, ...userOptions.heartbeat };
+  }
+  if (userOptions.mock) {
+    options.mock = { ...DEFAULT_CLIENT_OPTIONS.mock, ...userOptions.mock };
+  }
+  return options;
+}
+
+// src/client.ts
+var JmriClient = class extends import_index.default {
+  /**
+   * Create a new JMRI client
+   *
+   * @param options - Client configuration options
+   *
+   * @example
+   * ```typescript
+   * const client = new JmriClient({
+   *   host: 'jmri.local',
+   *   port: 12080
+   * });
+   *
+   * client.on('connected', () => console.log('Connected!'));
+   * client.on('power:changed', (state) => console.log('Power:', state));
+   * ```
+   */
+  constructor(options) {
+    super();
+    this.options = mergeOptions(options);
+    this.wsClient = new WebSocketClient(this.options);
+    this.powerManager = new PowerManager(this.wsClient);
+    this.rosterManager = new RosterManager(this.wsClient);
+    this.throttleManager = new ThrottleManager(this.wsClient);
+    this.wsClient.on("connected", () => this.emit("connected"));
+    this.wsClient.on("disconnected", (reason) => this.emit("disconnected", reason));
+    this.wsClient.on(
+      "reconnecting",
+      (attempt, delay) => this.emit("reconnecting", attempt, delay)
+    );
+    this.wsClient.on("reconnected", () => this.emit("reconnected"));
+    this.wsClient.on(
+      "reconnectionFailed",
+      (attempts) => this.emit("reconnectionFailed", attempts)
+    );
+    this.wsClient.on(
+      "connectionStateChanged",
+      (state) => this.emit("connectionStateChanged", state)
+    );
+    this.wsClient.on("error", (error) => this.emit("error", error));
+    this.wsClient.on("heartbeat:sent", () => this.emit("heartbeat:sent"));
+    this.wsClient.on("heartbeat:timeout", () => this.emit("heartbeat:timeout"));
+    this.powerManager.on(
+      "power:changed",
+      (state) => this.emit("power:changed", state)
+    );
+    this.throttleManager.on(
+      "throttle:acquired",
+      (id) => this.emit("throttle:acquired", id)
+    );
+    this.throttleManager.on(
+      "throttle:updated",
+      (id, data) => this.emit("throttle:updated", id, data)
+    );
+    this.throttleManager.on(
+      "throttle:released",
+      (id) => this.emit("throttle:released", id)
+    );
+    this.throttleManager.on(
+      "throttle:lost",
+      (id) => this.emit("throttle:lost", id)
+    );
+    if (this.options.autoConnect) {
+      this.connect().catch((error) => {
+        this.emit("error", error);
+      });
+    }
+  }
+  /**
+   * Connect to JMRI server
+   */
+  async connect() {
+    return this.wsClient.connect();
+  }
+  /**
+   * Disconnect from JMRI server
+   * Releases all throttles and closes connection
+   */
+  async disconnect() {
+    await this.throttleManager.releaseAllThrottles();
+    return this.wsClient.disconnect();
+  }
+  /**
+   * Get current connection state
+   */
+  getConnectionState() {
+    return this.wsClient.getState();
+  }
+  /**
+   * Check if connected to JMRI
+   */
+  isConnected() {
+    return this.wsClient.isConnected();
+  }
+  // ============================================================================
+  // Power Control
+  // ============================================================================
+  /**
+   * Get current track power state
+   */
+  async getPower() {
+    return this.powerManager.getPower();
+  }
+  /**
+   * Set track power state
+   */
+  async setPower(state) {
+    return this.powerManager.setPower(state);
+  }
+  /**
+   * Turn track power on
+   */
+  async powerOn() {
+    return this.powerManager.powerOn();
+  }
+  /**
+   * Turn track power off
+   */
+  async powerOff() {
+    return this.powerManager.powerOff();
+  }
+  // ============================================================================
+  // Roster Management
+  // ============================================================================
+  /**
+   * Get all roster entries
+   */
+  async getRoster() {
+    return this.rosterManager.getRoster();
+  }
+  /**
+   * Get roster entry by name
+   */
+  async getRosterEntryByName(name) {
+    return this.rosterManager.getRosterEntryByName(name);
+  }
+  /**
+   * Get roster entry by address
+   */
+  async getRosterEntryByAddress(address) {
+    return this.rosterManager.getRosterEntryByAddress(address);
+  }
+  /**
+   * Search roster by partial name match
+   */
+  async searchRoster(query) {
+    return this.rosterManager.searchRoster(query);
+  }
+  // ============================================================================
+  // Throttle Control
+  // ============================================================================
+  /**
+   * Acquire a throttle for a locomotive
+   *
+   * @param options - Throttle acquisition options
+   * @returns Throttle ID for use in other throttle methods
+   *
+   * @example
+   * ```typescript
+   * const throttleId = await client.acquireThrottle({ address: 3 });
+   * await client.setThrottleSpeed(throttleId, 0.5); // Half speed
+   * ```
+   */
+  async acquireThrottle(options) {
+    return this.throttleManager.acquireThrottle(options);
+  }
+  /**
+   * Release a throttle
+   */
+  async releaseThrottle(throttleId) {
+    return this.throttleManager.releaseThrottle(throttleId);
+  }
+  /**
+   * Set throttle speed (0.0 to 1.0)
+   *
+   * @param throttleId - Throttle ID from acquireThrottle
+   * @param speed - Speed value between 0.0 (stopped) and 1.0 (full speed)
+   */
+  async setThrottleSpeed(throttleId, speed) {
+    return this.throttleManager.setSpeed(throttleId, speed);
+  }
+  /**
+   * Set throttle direction
+   *
+   * @param throttleId - Throttle ID from acquireThrottle
+   * @param forward - True for forward, false for reverse
+   */
+  async setThrottleDirection(throttleId, forward) {
+    return this.throttleManager.setDirection(throttleId, forward);
+  }
+  /**
+   * Set throttle function (F0-F28)
+   *
+   * @param throttleId - Throttle ID from acquireThrottle
+   * @param functionKey - Function key (F0-F28)
+   * @param value - True to activate, false to deactivate
+   *
+   * @example
+   * ```typescript
+   * await client.setThrottleFunction(throttleId, 'F0', true);  // Headlight on
+   * await client.setThrottleFunction(throttleId, 'F2', true);  // Horn
+   * ```
+   */
+  async setThrottleFunction(throttleId, functionKey, value) {
+    return this.throttleManager.setFunction(throttleId, functionKey, value);
+  }
+  /**
+   * Emergency stop for a throttle (speed to 0)
+   */
+  async emergencyStop(throttleId) {
+    return this.throttleManager.emergencyStop(throttleId);
+  }
+  /**
+   * Set throttle to idle (speed to 0, maintain direction)
+   */
+  async idleThrottle(throttleId) {
+    return this.throttleManager.idle(throttleId);
+  }
+  /**
+   * Get throttle state
+   */
+  getThrottleState(throttleId) {
+    return this.throttleManager.getThrottleState(throttleId);
+  }
+  /**
+   * Get all throttle IDs
+   */
+  getThrottleIds() {
+    return this.throttleManager.getThrottleIds();
+  }
+  /**
+   * Get all throttle states
+   */
+  getAllThrottles() {
+    return this.throttleManager.getAllThrottles();
+  }
+  /**
+   * Release all throttles
+   */
+  async releaseAllThrottles() {
+    return this.throttleManager.releaseAllThrottles();
+  }
+};
+export {
+  ConnectionState,
+  JmriClient,
+  MockResponseManager,
+  PowerState,
+  isThrottleFunctionKey,
+  isValidSpeed,
+  mockData,
+  mockResponseManager
+};
+//# sourceMappingURL=jmri-client.js.map