jmri-client 3.5.3 → 3.6.0

package/dist/browser/jmri-client.js

@@ -618,6 +618,26 @@ function powerStateToString(state) {
       return "UNKNOWN";
   }
 }
+var TurnoutState = /* @__PURE__ */ ((TurnoutState2) => {
+  TurnoutState2[TurnoutState2["UNKNOWN"] = 0] = "UNKNOWN";
+  TurnoutState2[TurnoutState2["CLOSED"] = 2] = "CLOSED";
+  TurnoutState2[TurnoutState2["THROWN"] = 4] = "THROWN";
+  TurnoutState2[TurnoutState2["INCONSISTENT"] = 8] = "INCONSISTENT";
+  return TurnoutState2;
+})(TurnoutState || {});
+function turnoutStateToString(state) {
+  switch (state) {
+    case 2 /* CLOSED */:
+      return "CLOSED";
+    case 4 /* THROWN */:
+      return "THROWN";
+    case 8 /* INCONSISTENT */:
+      return "INCONSISTENT";
+    case 0 /* UNKNOWN */:
+    default:
+      return "UNKNOWN";
+  }
+}
 
 // src/mocks/mock-data.ts
 var mockData = {
@@ -803,6 +823,13 @@ var mockData = {
       }
     }
   },
+  "turnout": {
+    "list": [
+      { "type": "turnout", "data": { "name": "LT1", "userName": "Main Diverge", "state": 2 } },
+      { "type": "turnout", "data": { "name": "LT2", "userName": "Yard Lead", "state": 2 } },
+      { "type": "turnout", "data": { "name": "LT3", "userName": "Siding Entry", "state": 4 } }
+    ]
+  },
   "ping": {
     "type": "ping"
   },
@@ -841,6 +868,11 @@ var mockData = {
 var MockResponseManager = class {
   constructor(options = {}) {
     this.throttles = /* @__PURE__ */ new Map();
+    this.turnouts = /* @__PURE__ */ new Map([
+      ["LT1", 2 /* CLOSED */],
+      ["LT2", 2 /* CLOSED */],
+      ["LT3", 4 /* THROWN */]
+    ]);
     this.responseDelay = options.responseDelay ?? 50;
     this.powerState = options.initialPowerState ?? 4 /* OFF */;
   }
@@ -860,6 +892,8 @@ var MockResponseManager = class {
         return this.getRosterResponse(message);
       case "throttle":
         return this.getThrottleResponse(message);
+      case "turnout":
+        return this.getTurnoutResponse(message);
       case "ping":
         return this.getPingResponse();
       case "goodbye":
@@ -975,6 +1009,23 @@ var MockResponseManager = class {
       data: {}
     };
   }
+  /**
+   * Get turnout response
+   */
+  getTurnoutResponse(message) {
+    if (message.method === "list") {
+      return JSON.parse(JSON.stringify(mockData.turnout.list));
+    }
+    const name = message.data?.name;
+    if (!name) {
+      return { type: "turnout", data: { name: "", state: 0 /* UNKNOWN */ } };
+    }
+    if (message.method === "post" && message.data?.state !== void 0) {
+      this.turnouts.set(name, message.data.state);
+    }
+    const state = this.turnouts.get(name) ?? 0 /* UNKNOWN */;
+    return { type: "turnout", data: { name, state } };
+  }
   /**
    * Get ping response (pong)
    */
@@ -1005,12 +1056,23 @@ var MockResponseManager = class {
   getThrottles() {
     return this.throttles;
   }
+  /**
+   * Get all turnout states (for testing)
+   */
+  getTurnouts() {
+    return this.turnouts;
+  }
   /**
    * Reset all state (for testing)
    */
   reset() {
     this.powerState = 4 /* OFF */;
     this.throttles.clear();
+    this.turnouts = /* @__PURE__ */ new Map([
+      ["LT1", 2 /* CLOSED */],
+      ["LT2", 2 /* CLOSED */],
+      ["LT3", 4 /* THROWN */]
+    ]);
   }
   /**
    * Delay helper
@@ -1730,6 +1792,104 @@ var ThrottleManager = class extends import_index.default {
   }
 };
 
+// src/managers/turnout-manager.ts
+var TurnoutManager = class extends import_index.default {
+  constructor(client) {
+    super();
+    this.turnouts = /* @__PURE__ */ new Map();
+    this.client = client;
+    this.client.on("update", (message) => {
+      if (message.type === "turnout") {
+        this.handleTurnoutUpdate(message);
+      }
+    });
+  }
+  /**
+   * Get the current state of a turnout.
+   * Also registers a server-side listener so subsequent changes are pushed.
+   */
+  async getTurnout(name) {
+    const message = {
+      type: "turnout",
+      data: { name }
+    };
+    const response = await this.client.request(message);
+    const state = response.data?.state ?? 0 /* UNKNOWN */;
+    this.turnouts.set(name, state);
+    return state;
+  }
+  /**
+   * Set a turnout to the given state
+   */
+  async setTurnout(name, state) {
+    const message = {
+      type: "turnout",
+      method: "post",
+      data: { name, state }
+    };
+    await this.client.request(message);
+    const oldState = this.turnouts.get(name);
+    this.turnouts.set(name, state);
+    if (oldState !== state) {
+      this.emit("turnout:changed", name, state);
+    }
+  }
+  /**
+   * Throw a turnout (diverging route)
+   */
+  async throwTurnout(name) {
+    return this.setTurnout(name, 4 /* THROWN */);
+  }
+  /**
+   * Close a turnout (straight through / normal)
+   */
+  async closeTurnout(name) {
+    return this.setTurnout(name, 2 /* CLOSED */);
+  }
+  /**
+   * List all turnouts known to JMRI
+   */
+  async listTurnouts() {
+    const message = {
+      type: "turnout",
+      method: "list"
+    };
+    const response = await this.client.request(message);
+    const entries = Array.isArray(response) ? response.map((r) => r.data ?? r) : [];
+    for (const entry of entries) {
+      if (entry.name && entry.state !== void 0) {
+        this.turnouts.set(entry.name, entry.state);
+      }
+    }
+    return entries;
+  }
+  /**
+   * Get cached turnout state without a network request
+   */
+  getTurnoutState(name) {
+    return this.turnouts.get(name);
+  }
+  /**
+   * Get all cached turnout states
+   */
+  getCachedTurnouts() {
+    return new Map(this.turnouts);
+  }
+  /**
+   * Handle unsolicited turnout state updates from JMRI
+   */
+  handleTurnoutUpdate(message) {
+    const name = message.data?.name;
+    const state = message.data?.state;
+    if (!name || state === void 0) return;
+    const oldState = this.turnouts.get(name);
+    this.turnouts.set(name, state);
+    if (oldState !== state) {
+      this.emit("turnout:changed", name, state);
+    }
+  }
+};
+
 // src/types/client-options.ts
 var DEFAULT_CLIENT_OPTIONS = {
   host: "localhost",
@@ -1805,6 +1965,7 @@ var JmriClient = class extends import_index.default {
     this.powerManager = new PowerManager(this.wsClient);
     this.rosterManager = new RosterManager(this.wsClient);
     this.throttleManager = new ThrottleManager(this.wsClient);
+    this.turnoutManager = new TurnoutManager(this.wsClient);
     this.wsClient.on("connected", () => this.emit("connected"));
     this.wsClient.on("disconnected", (reason) => this.emit("disconnected", reason));
     this.wsClient.on(
@@ -1828,6 +1989,10 @@ var JmriClient = class extends import_index.default {
       "power:changed",
       (state) => this.emit("power:changed", state)
     );
+    this.turnoutManager.on(
+      "turnout:changed",
+      (name, state) => this.emit("turnout:changed", name, state)
+    );
     this.throttleManager.on(
       "throttle:acquired",
       (id) => this.emit("throttle:acquired", id)
@@ -1931,6 +2096,51 @@ var JmriClient = class extends import_index.default {
     return this.rosterManager.searchRoster(query);
   }
   // ============================================================================
+  // Turnout Control
+  // ============================================================================
+  /**
+   * Get the current state of a turnout
+   */
+  async getTurnout(name) {
+    return this.turnoutManager.getTurnout(name);
+  }
+  /**
+   * Set a turnout to the given state
+   */
+  async setTurnout(name, state) {
+    return this.turnoutManager.setTurnout(name, state);
+  }
+  /**
+   * Throw a turnout (diverging route)
+   */
+  async throwTurnout(name) {
+    return this.turnoutManager.throwTurnout(name);
+  }
+  /**
+   * Close a turnout (straight through / normal)
+   */
+  async closeTurnout(name) {
+    return this.turnoutManager.closeTurnout(name);
+  }
+  /**
+   * List all turnouts known to JMRI
+   */
+  async listTurnouts() {
+    return this.turnoutManager.listTurnouts();
+  }
+  /**
+   * Get cached turnout state without a network request
+   */
+  getTurnoutState(name) {
+    return this.turnoutManager.getTurnoutState(name);
+  }
+  /**
+   * Get all cached turnout states
+   */
+  getCachedTurnouts() {
+    return this.turnoutManager.getCachedTurnouts();
+  }
+  // ============================================================================
   // Throttle Control
   // ============================================================================
   /**
@@ -2030,9 +2240,11 @@ export {
   JmriClient,
   MockResponseManager,
   PowerState,
+  TurnoutState,
   isThrottleFunctionKey,
   isValidSpeed,
   mockData,
   mockResponseManager,
-  powerStateToString
+  powerStateToString,
+  turnoutStateToString
 };

package/dist/cjs/client.js

@@ -9,6 +9,7 @@ const websocket_client_js_1 = require("./core/websocket-client.js");
 const power_manager_js_1 = require("./managers/power-manager.js");
 const roster_manager_js_1 = require("./managers/roster-manager.js");
 const throttle_manager_js_1 = require("./managers/throttle-manager.js");
+const turnout_manager_js_1 = require("./managers/turnout-manager.js");
 const client_options_js_1 = require("./types/client-options.js");
 /**
  * JMRI WebSocket Client
@@ -41,6 +42,7 @@ class JmriClient extends eventemitter3_1.EventEmitter {
         this.powerManager = new power_manager_js_1.PowerManager(this.wsClient);
         this.rosterManager = new roster_manager_js_1.RosterManager(this.wsClient);
         this.throttleManager = new throttle_manager_js_1.ThrottleManager(this.wsClient);
+        this.turnoutManager = new turnout_manager_js_1.TurnoutManager(this.wsClient);
         // Forward events from WebSocket client
         this.wsClient.on('connected', () => this.emit('connected'));
         this.wsClient.on('disconnected', (reason) => this.emit('disconnected', reason));
@@ -54,6 +56,7 @@ class JmriClient extends eventemitter3_1.EventEmitter {
         this.wsClient.on('hello', (data) => this.emit('hello', data));
         // Forward events from managers
         this.powerManager.on('power:changed', (state) => this.emit('power:changed', state));
+        this.turnoutManager.on('turnout:changed', (name, state) => this.emit('turnout:changed', name, 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));
@@ -148,6 +151,51 @@ class JmriClient extends eventemitter3_1.EventEmitter {
         return this.rosterManager.searchRoster(query);
     }
     // ============================================================================
+    // Turnout Control
+    // ============================================================================
+    /**
+     * Get the current state of a turnout
+     */
+    async getTurnout(name) {
+        return this.turnoutManager.getTurnout(name);
+    }
+    /**
+     * Set a turnout to the given state
+     */
+    async setTurnout(name, state) {
+        return this.turnoutManager.setTurnout(name, state);
+    }
+    /**
+     * Throw a turnout (diverging route)
+     */
+    async throwTurnout(name) {
+        return this.turnoutManager.throwTurnout(name);
+    }
+    /**
+     * Close a turnout (straight through / normal)
+     */
+    async closeTurnout(name) {
+        return this.turnoutManager.closeTurnout(name);
+    }
+    /**
+     * List all turnouts known to JMRI
+     */
+    async listTurnouts() {
+        return this.turnoutManager.listTurnouts();
+    }
+    /**
+     * Get cached turnout state without a network request
+     */
+    getTurnoutState(name) {
+        return this.turnoutManager.getTurnoutState(name);
+    }
+    /**
+     * Get all cached turnout states
+     */
+    getCachedTurnouts() {
+        return this.turnoutManager.getCachedTurnouts();
+    }
+    // ============================================================================
     // Throttle Control
     // ============================================================================
     /**

package/dist/cjs/index.js

@@ -4,13 +4,14 @@
  * WebSocket client for JMRI with real-time updates and throttle control
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.mockData = exports.mockResponseManager = exports.MockResponseManager = exports.powerStateToString = exports.isValidSpeed = exports.isThrottleFunctionKey = exports.ConnectionState = exports.PowerState = exports.JmriClient = void 0;
+exports.mockData = exports.mockResponseManager = exports.MockResponseManager = exports.turnoutStateToString = exports.powerStateToString = exports.isValidSpeed = exports.isThrottleFunctionKey = exports.ConnectionState = exports.TurnoutState = exports.PowerState = exports.JmriClient = void 0;
 var client_js_1 = require("./client.js");
 Object.defineProperty(exports, "JmriClient", { enumerable: true, get: function () { return client_js_1.JmriClient; } });
 // Export types
 var index_js_1 = require("./types/index.js");
 // JMRI message types
 Object.defineProperty(exports, "PowerState", { enumerable: true, get: function () { return index_js_1.PowerState; } });
+Object.defineProperty(exports, "TurnoutState", { enumerable: true, get: function () { return index_js_1.TurnoutState; } });
 // Event types
 Object.defineProperty(exports, "ConnectionState", { enumerable: true, get: function () { return index_js_1.ConnectionState; } });
 // Export utility functions
@@ -19,6 +20,7 @@ Object.defineProperty(exports, "isThrottleFunctionKey", { enumerable: true, get:
 Object.defineProperty(exports, "isValidSpeed", { enumerable: true, get: function () { return throttle_js_1.isValidSpeed; } });
 var jmri_messages_js_1 = require("./types/jmri-messages.js");
 Object.defineProperty(exports, "powerStateToString", { enumerable: true, get: function () { return jmri_messages_js_1.powerStateToString; } });
+Object.defineProperty(exports, "turnoutStateToString", { enumerable: true, get: function () { return jmri_messages_js_1.turnoutStateToString; } });
 // Export mock system for testing and demo purposes
 var index_js_2 = require("./mocks/index.js");
 Object.defineProperty(exports, "MockResponseManager", { enumerable: true, get: function () { return index_js_2.MockResponseManager; } });

package/dist/cjs/managers/index.js

@@ -20,3 +20,4 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./power-manager.js"), exports);
 __exportStar(require("./roster-manager.js"), exports);
 __exportStar(require("./throttle-manager.js"), exports);
+__exportStar(require("./turnout-manager.js"), exports);

package/dist/cjs/managers/turnout-manager.js

@@ -0,0 +1,109 @@
+"use strict";
+/**
+ * Turnout (switch) manager
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TurnoutManager = void 0;
+const eventemitter3_1 = require("eventemitter3");
+const jmri_messages_js_1 = require("../types/jmri-messages.js");
+/**
+ * Manages JMRI turnout (track switch) state
+ */
+class TurnoutManager extends eventemitter3_1.EventEmitter {
+    constructor(client) {
+        super();
+        this.turnouts = new Map();
+        this.client = client;
+        this.client.on('update', (message) => {
+            if (message.type === 'turnout') {
+                this.handleTurnoutUpdate(message);
+            }
+        });
+    }
+    /**
+     * Get the current state of a turnout.
+     * Also registers a server-side listener so subsequent changes are pushed.
+     */
+    async getTurnout(name) {
+        const message = {
+            type: 'turnout',
+            data: { name }
+        };
+        const response = await this.client.request(message);
+        const state = response.data?.state ?? jmri_messages_js_1.TurnoutState.UNKNOWN;
+        this.turnouts.set(name, state);
+        return state;
+    }
+    /**
+     * Set a turnout to the given state
+     */
+    async setTurnout(name, state) {
+        const message = {
+            type: 'turnout',
+            method: 'post',
+            data: { name, state }
+        };
+        await this.client.request(message);
+        const oldState = this.turnouts.get(name);
+        this.turnouts.set(name, state);
+        if (oldState !== state) {
+            this.emit('turnout:changed', name, state);
+        }
+    }
+    /**
+     * Throw a turnout (diverging route)
+     */
+    async throwTurnout(name) {
+        return this.setTurnout(name, jmri_messages_js_1.TurnoutState.THROWN);
+    }
+    /**
+     * Close a turnout (straight through / normal)
+     */
+    async closeTurnout(name) {
+        return this.setTurnout(name, jmri_messages_js_1.TurnoutState.CLOSED);
+    }
+    /**
+     * List all turnouts known to JMRI
+     */
+    async listTurnouts() {
+        const message = {
+            type: 'turnout',
+            method: 'list'
+        };
+        const response = await this.client.request(message);
+        const entries = Array.isArray(response) ? response.map((r) => r.data ?? r) : [];
+        for (const entry of entries) {
+            if (entry.name && entry.state !== undefined) {
+                this.turnouts.set(entry.name, entry.state);
+            }
+        }
+        return entries;
+    }
+    /**
+     * Get cached turnout state without a network request
+     */
+    getTurnoutState(name) {
+        return this.turnouts.get(name);
+    }
+    /**
+     * Get all cached turnout states
+     */
+    getCachedTurnouts() {
+        return new Map(this.turnouts);
+    }
+    /**
+     * Handle unsolicited turnout state updates from JMRI
+     */
+    handleTurnoutUpdate(message) {
+        const name = message.data?.name;
+        const state = message.data?.state;
+        if (!name || state === undefined)
+            return;
+        const oldState = this.turnouts.get(name);
+        this.turnouts.set(name, state);
+        if (oldState !== state) {
+            this.emit('turnout:changed', name, state);
+        }
+    }
+}
+exports.TurnoutManager = TurnoutManager;

package/dist/cjs/mocks/mock-data.js

@@ -188,6 +188,13 @@ exports.mockData = {
             }
         }
     },
+    "turnout": {
+        "list": [
+            { "type": "turnout", "data": { "name": "LT1", "userName": "Main Diverge", "state": 2 } },
+            { "type": "turnout", "data": { "name": "LT2", "userName": "Yard Lead", "state": 2 } },
+            { "type": "turnout", "data": { "name": "LT3", "userName": "Siding Entry", "state": 4 } }
+        ]
+    },
     "ping": {
         "type": "ping"
     },

package/dist/cjs/mocks/mock-response-manager.js

@@ -13,6 +13,11 @@ const mock_data_js_1 = require("./mock-data.js");
 class MockResponseManager {
     constructor(options = {}) {
         this.throttles = new Map();
+        this.turnouts = new Map([
+            ['LT1', jmri_messages_js_1.TurnoutState.CLOSED],
+            ['LT2', jmri_messages_js_1.TurnoutState.CLOSED],
+            ['LT3', jmri_messages_js_1.TurnoutState.THROWN]
+        ]);
         this.responseDelay = options.responseDelay ?? 50;
         this.powerState = options.initialPowerState ?? jmri_messages_js_1.PowerState.OFF;
     }
@@ -34,6 +39,8 @@ class MockResponseManager {
                 return this.getRosterResponse(message);
             case 'throttle':
                 return this.getThrottleResponse(message);
+            case 'turnout':
+                return this.getTurnoutResponse(message);
             case 'ping':
                 return this.getPingResponse();
             case 'goodbye':
@@ -160,6 +167,26 @@ class MockResponseManager {
             data: {}
         };
     }
+    /**
+     * Get turnout response
+     */
+    getTurnoutResponse(message) {
+        // List all turnouts
+        if (message.method === 'list') {
+            return JSON.parse(JSON.stringify(mock_data_js_1.mockData.turnout.list));
+        }
+        const name = message.data?.name;
+        if (!name) {
+            return { type: 'turnout', data: { name: '', state: jmri_messages_js_1.TurnoutState.UNKNOWN } };
+        }
+        // Set turnout state
+        if (message.method === 'post' && message.data?.state !== undefined) {
+            this.turnouts.set(name, message.data.state);
+        }
+        // Get or confirm current state
+        const state = this.turnouts.get(name) ?? jmri_messages_js_1.TurnoutState.UNKNOWN;
+        return { type: 'turnout', data: { name, state } };
+    }
     /**
      * Get ping response (pong)
      */
@@ -190,12 +217,23 @@ class MockResponseManager {
     getThrottles() {
         return this.throttles;
     }
+    /**
+     * Get all turnout states (for testing)
+     */
+    getTurnouts() {
+        return this.turnouts;
+    }
     /**
      * Reset all state (for testing)
      */
     reset() {
         this.powerState = jmri_messages_js_1.PowerState.OFF;
         this.throttles.clear();
+        this.turnouts = new Map([
+            ['LT1', jmri_messages_js_1.TurnoutState.CLOSED],
+            ['LT2', jmri_messages_js_1.TurnoutState.CLOSED],
+            ['LT3', jmri_messages_js_1.TurnoutState.THROWN]
+        ]);
     }
     /**
      * Delay helper

package/dist/cjs/types/jmri-messages.js

@@ -4,8 +4,9 @@
  * Based on JMRI JSON protocol specification
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PowerState = void 0;
+exports.TurnoutState = exports.PowerState = void 0;
 exports.powerStateToString = powerStateToString;
+exports.turnoutStateToString = turnoutStateToString;
 /**
  * Power state values (from JMRI JSON protocol constants)
  * UNKNOWN = 0 (state cannot be determined)
@@ -35,3 +36,33 @@ function powerStateToString(state) {
             return 'UNKNOWN';
     }
 }
+/**
+ * Turnout state values (from JMRI JSON protocol constants)
+ * UNKNOWN = 0 (state cannot be determined)
+ * CLOSED = 2 (straight through / normal position)
+ * THROWN = 4 (diverging route position)
+ * INCONSISTENT = 8 (contradictory feedback state)
+ */
+var TurnoutState;
+(function (TurnoutState) {
+    TurnoutState[TurnoutState["UNKNOWN"] = 0] = "UNKNOWN";
+    TurnoutState[TurnoutState["CLOSED"] = 2] = "CLOSED";
+    TurnoutState[TurnoutState["THROWN"] = 4] = "THROWN";
+    TurnoutState[TurnoutState["INCONSISTENT"] = 8] = "INCONSISTENT";
+})(TurnoutState || (exports.TurnoutState = TurnoutState = {}));
+/**
+ * Convert TurnoutState enum to human-readable string
+ */
+function turnoutStateToString(state) {
+    switch (state) {
+        case TurnoutState.CLOSED:
+            return 'CLOSED';
+        case TurnoutState.THROWN:
+            return 'THROWN';
+        case TurnoutState.INCONSISTENT:
+            return 'INCONSISTENT';
+        case TurnoutState.UNKNOWN:
+        default:
+            return 'UNKNOWN';
+    }
+}

package/dist/esm/client.js

@@ -6,6 +6,7 @@ import { WebSocketClient } from './core/websocket-client.js';
 import { PowerManager } from './managers/power-manager.js';
 import { RosterManager } from './managers/roster-manager.js';
 import { ThrottleManager } from './managers/throttle-manager.js';
+import { TurnoutManager } from './managers/turnout-manager.js';
 import { mergeOptions } from './types/client-options.js';
 /**
  * JMRI WebSocket Client
@@ -38,6 +39,7 @@ export class JmriClient extends EventEmitter {
         this.powerManager = new PowerManager(this.wsClient);
         this.rosterManager = new RosterManager(this.wsClient);
         this.throttleManager = new ThrottleManager(this.wsClient);
+        this.turnoutManager = new TurnoutManager(this.wsClient);
         // Forward events from WebSocket client
         this.wsClient.on('connected', () => this.emit('connected'));
         this.wsClient.on('disconnected', (reason) => this.emit('disconnected', reason));
@@ -51,6 +53,7 @@ export class JmriClient extends EventEmitter {
         this.wsClient.on('hello', (data) => this.emit('hello', data));
         // Forward events from managers
         this.powerManager.on('power:changed', (state) => this.emit('power:changed', state));
+        this.turnoutManager.on('turnout:changed', (name, state) => this.emit('turnout:changed', name, 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));
@@ -145,6 +148,51 @@ export class JmriClient extends EventEmitter {
         return this.rosterManager.searchRoster(query);
     }
     // ============================================================================
+    // Turnout Control
+    // ============================================================================
+    /**
+     * Get the current state of a turnout
+     */
+    async getTurnout(name) {
+        return this.turnoutManager.getTurnout(name);
+    }
+    /**
+     * Set a turnout to the given state
+     */
+    async setTurnout(name, state) {
+        return this.turnoutManager.setTurnout(name, state);
+    }
+    /**
+     * Throw a turnout (diverging route)
+     */
+    async throwTurnout(name) {
+        return this.turnoutManager.throwTurnout(name);
+    }
+    /**
+     * Close a turnout (straight through / normal)
+     */
+    async closeTurnout(name) {
+        return this.turnoutManager.closeTurnout(name);
+    }
+    /**
+     * List all turnouts known to JMRI
+     */
+    async listTurnouts() {
+        return this.turnoutManager.listTurnouts();
+    }
+    /**
+     * Get cached turnout state without a network request
+     */
+    getTurnoutState(name) {
+        return this.turnoutManager.getTurnoutState(name);
+    }
+    /**
+     * Get all cached turnout states
+     */
+    getCachedTurnouts() {
+        return this.turnoutManager.getCachedTurnouts();
+    }
+    // ============================================================================
     // Throttle Control
     // ============================================================================
     /**

package/dist/esm/index.js

@@ -6,11 +6,11 @@ export { JmriClient } from './client.js';
 // Export types
 export { 
 // JMRI message types
-PowerState, 
+PowerState, TurnoutState, 
 // Event types
 ConnectionState } from './types/index.js';
 // Export utility functions
 export { isThrottleFunctionKey, isValidSpeed } from './types/throttle.js';
-export { powerStateToString } from './types/jmri-messages.js';
+export { powerStateToString, turnoutStateToString } from './types/jmri-messages.js';
 // Export mock system for testing and demo purposes
 export { MockResponseManager, mockResponseManager, mockData } from './mocks/index.js';

package/dist/esm/managers/index.js

@@ -4,3 +4,4 @@
 export * from './power-manager.js';
 export * from './roster-manager.js';
 export * from './throttle-manager.js';
+export * from './turnout-manager.js';

package/dist/esm/managers/turnout-manager.js

@@ -0,0 +1,105 @@
+/**
+ * Turnout (switch) manager
+ */
+import { EventEmitter } from 'eventemitter3';
+import { TurnoutState } from '../types/jmri-messages.js';
+/**
+ * Manages JMRI turnout (track switch) state
+ */
+export class TurnoutManager extends EventEmitter {
+    constructor(client) {
+        super();
+        this.turnouts = new Map();
+        this.client = client;
+        this.client.on('update', (message) => {
+            if (message.type === 'turnout') {
+                this.handleTurnoutUpdate(message);
+            }
+        });
+    }
+    /**
+     * Get the current state of a turnout.
+     * Also registers a server-side listener so subsequent changes are pushed.
+     */
+    async getTurnout(name) {
+        const message = {
+            type: 'turnout',
+            data: { name }
+        };
+        const response = await this.client.request(message);
+        const state = response.data?.state ?? TurnoutState.UNKNOWN;
+        this.turnouts.set(name, state);
+        return state;
+    }
+    /**
+     * Set a turnout to the given state
+     */
+    async setTurnout(name, state) {
+        const message = {
+            type: 'turnout',
+            method: 'post',
+            data: { name, state }
+        };
+        await this.client.request(message);
+        const oldState = this.turnouts.get(name);
+        this.turnouts.set(name, state);
+        if (oldState !== state) {
+            this.emit('turnout:changed', name, state);
+        }
+    }
+    /**
+     * Throw a turnout (diverging route)
+     */
+    async throwTurnout(name) {
+        return this.setTurnout(name, TurnoutState.THROWN);
+    }
+    /**
+     * Close a turnout (straight through / normal)
+     */
+    async closeTurnout(name) {
+        return this.setTurnout(name, TurnoutState.CLOSED);
+    }
+    /**
+     * List all turnouts known to JMRI
+     */
+    async listTurnouts() {
+        const message = {
+            type: 'turnout',
+            method: 'list'
+        };
+        const response = await this.client.request(message);
+        const entries = Array.isArray(response) ? response.map((r) => r.data ?? r) : [];
+        for (const entry of entries) {
+            if (entry.name && entry.state !== undefined) {
+                this.turnouts.set(entry.name, entry.state);
+            }
+        }
+        return entries;
+    }
+    /**
+     * Get cached turnout state without a network request
+     */
+    getTurnoutState(name) {
+        return this.turnouts.get(name);
+    }
+    /**
+     * Get all cached turnout states
+     */
+    getCachedTurnouts() {
+        return new Map(this.turnouts);
+    }
+    /**
+     * Handle unsolicited turnout state updates from JMRI
+     */
+    handleTurnoutUpdate(message) {
+        const name = message.data?.name;
+        const state = message.data?.state;
+        if (!name || state === undefined)
+            return;
+        const oldState = this.turnouts.get(name);
+        this.turnouts.set(name, state);
+        if (oldState !== state) {
+            this.emit('turnout:changed', name, state);
+        }
+    }
+}

package/dist/esm/mocks/mock-data.js

@@ -185,6 +185,13 @@ export const mockData = {
             }
         }
     },
+    "turnout": {
+        "list": [
+            { "type": "turnout", "data": { "name": "LT1", "userName": "Main Diverge", "state": 2 } },
+            { "type": "turnout", "data": { "name": "LT2", "userName": "Yard Lead", "state": 2 } },
+            { "type": "turnout", "data": { "name": "LT3", "userName": "Siding Entry", "state": 4 } }
+        ]
+    },
     "ping": {
         "type": "ping"
     },

package/dist/esm/mocks/mock-response-manager.js

@@ -2,7 +2,7 @@
  * Mock Response Manager
  * Generates mock JMRI responses for testing and demo purposes
  */
-import { PowerState } from '../types/jmri-messages.js';
+import { PowerState, TurnoutState } from '../types/jmri-messages.js';
 import { mockData } from './mock-data.js';
 /**
  * Manages mock responses for JMRI protocol
@@ -10,6 +10,11 @@ import { mockData } from './mock-data.js';
 export class MockResponseManager {
     constructor(options = {}) {
         this.throttles = new Map();
+        this.turnouts = new Map([
+            ['LT1', TurnoutState.CLOSED],
+            ['LT2', TurnoutState.CLOSED],
+            ['LT3', TurnoutState.THROWN]
+        ]);
         this.responseDelay = options.responseDelay ?? 50;
         this.powerState = options.initialPowerState ?? PowerState.OFF;
     }
@@ -31,6 +36,8 @@ export class MockResponseManager {
                 return this.getRosterResponse(message);
             case 'throttle':
                 return this.getThrottleResponse(message);
+            case 'turnout':
+                return this.getTurnoutResponse(message);
             case 'ping':
                 return this.getPingResponse();
             case 'goodbye':
@@ -157,6 +164,26 @@ export class MockResponseManager {
             data: {}
         };
     }
+    /**
+     * Get turnout response
+     */
+    getTurnoutResponse(message) {
+        // List all turnouts
+        if (message.method === 'list') {
+            return JSON.parse(JSON.stringify(mockData.turnout.list));
+        }
+        const name = message.data?.name;
+        if (!name) {
+            return { type: 'turnout', data: { name: '', state: TurnoutState.UNKNOWN } };
+        }
+        // Set turnout state
+        if (message.method === 'post' && message.data?.state !== undefined) {
+            this.turnouts.set(name, message.data.state);
+        }
+        // Get or confirm current state
+        const state = this.turnouts.get(name) ?? TurnoutState.UNKNOWN;
+        return { type: 'turnout', data: { name, state } };
+    }
     /**
      * Get ping response (pong)
      */
@@ -187,12 +214,23 @@ export class MockResponseManager {
     getThrottles() {
         return this.throttles;
     }
+    /**
+     * Get all turnout states (for testing)
+     */
+    getTurnouts() {
+        return this.turnouts;
+    }
     /**
      * Reset all state (for testing)
      */
     reset() {
         this.powerState = PowerState.OFF;
         this.throttles.clear();
+        this.turnouts = new Map([
+            ['LT1', TurnoutState.CLOSED],
+            ['LT2', TurnoutState.CLOSED],
+            ['LT3', TurnoutState.THROWN]
+        ]);
     }
     /**
      * Delay helper

package/dist/esm/types/jmri-messages.js

@@ -31,3 +31,33 @@ export function powerStateToString(state) {
             return 'UNKNOWN';
     }
 }
+/**
+ * Turnout state values (from JMRI JSON protocol constants)
+ * UNKNOWN = 0 (state cannot be determined)
+ * CLOSED = 2 (straight through / normal position)
+ * THROWN = 4 (diverging route position)
+ * INCONSISTENT = 8 (contradictory feedback state)
+ */
+export var TurnoutState;
+(function (TurnoutState) {
+    TurnoutState[TurnoutState["UNKNOWN"] = 0] = "UNKNOWN";
+    TurnoutState[TurnoutState["CLOSED"] = 2] = "CLOSED";
+    TurnoutState[TurnoutState["THROWN"] = 4] = "THROWN";
+    TurnoutState[TurnoutState["INCONSISTENT"] = 8] = "INCONSISTENT";
+})(TurnoutState || (TurnoutState = {}));
+/**
+ * Convert TurnoutState enum to human-readable string
+ */
+export function turnoutStateToString(state) {
+    switch (state) {
+        case TurnoutState.CLOSED:
+            return 'CLOSED';
+        case TurnoutState.THROWN:
+            return 'THROWN';
+        case TurnoutState.INCONSISTENT:
+            return 'INCONSISTENT';
+        case TurnoutState.UNKNOWN:
+        default:
+            return 'UNKNOWN';
+    }
+}

package/dist/types/client.d.ts

@@ -3,7 +3,7 @@
  */
 import { EventEmitter } from 'eventemitter3';
 import { PartialClientOptions } from './types/client-options.js';
-import { PowerState, RosterEntryWrapper } from './types/jmri-messages.js';
+import { PowerState, RosterEntryWrapper, TurnoutState, TurnoutData } from './types/jmri-messages.js';
 import { ConnectionState } from './types/events.js';
 import { ThrottleAcquireOptions, ThrottleFunctionKey, ThrottleState } from './types/throttle.js';
 /**
@@ -16,6 +16,7 @@ export declare class JmriClient extends EventEmitter {
     private powerManager;
     private rosterManager;
     private throttleManager;
+    private turnoutManager;
     /**
      * Create a new JMRI client
      *
@@ -82,6 +83,34 @@ export declare class JmriClient extends EventEmitter {
      * Search roster by partial name match
      */
     searchRoster(query: string): Promise<RosterEntryWrapper[]>;
+    /**
+     * Get the current state of a turnout
+     */
+    getTurnout(name: string): Promise<TurnoutState>;
+    /**
+     * Set a turnout to the given state
+     */
+    setTurnout(name: string, state: TurnoutState): Promise<void>;
+    /**
+     * Throw a turnout (diverging route)
+     */
+    throwTurnout(name: string): Promise<void>;
+    /**
+     * Close a turnout (straight through / normal)
+     */
+    closeTurnout(name: string): Promise<void>;
+    /**
+     * List all turnouts known to JMRI
+     */
+    listTurnouts(): Promise<TurnoutData[]>;
+    /**
+     * Get cached turnout state without a network request
+     */
+    getTurnoutState(name: string): TurnoutState | undefined;
+    /**
+     * Get all cached turnout states
+     */
+    getCachedTurnouts(): Map<string, TurnoutState>;
     /**
      * Acquire a throttle for a locomotive
      *

package/dist/types/index.d.ts

@@ -3,8 +3,8 @@
  * WebSocket client for JMRI with real-time updates and throttle control
  */
 export { JmriClient } from './client.js';
-export { JmriClientOptions, PartialClientOptions, ReconnectionOptions, HeartbeatOptions, MockOptions, PowerState, RosterEntry, JmriMessage, PowerMessage, ThrottleMessage, RosterMessage, ConnectionState, EventPayloads, ThrottleAcquireOptions, ThrottleFunctionKey, ThrottleState } from './types/index.js';
+export { JmriClientOptions, PartialClientOptions, ReconnectionOptions, HeartbeatOptions, MockOptions, PowerState, TurnoutState, RosterEntry, TurnoutData, JmriMessage, PowerMessage, TurnoutMessage, ThrottleMessage, RosterMessage, ConnectionState, EventPayloads, ThrottleAcquireOptions, ThrottleFunctionKey, ThrottleState } from './types/index.js';
 export { isThrottleFunctionKey, isValidSpeed } from './types/throttle.js';
-export { powerStateToString } from './types/jmri-messages.js';
+export { powerStateToString, turnoutStateToString } from './types/jmri-messages.js';
 export { MockResponseManager, mockResponseManager, mockData } from './mocks/index.js';
 export type { MockResponseManagerOptions } from './mocks/index.js';

package/dist/types/managers/index.d.ts

@@ -4,3 +4,4 @@
 export * from './power-manager.js';
 export * from './roster-manager.js';
 export * from './throttle-manager.js';
+export * from './turnout-manager.js';

package/dist/types/managers/turnout-manager.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Turnout (switch) manager
+ */
+import { EventEmitter } from 'eventemitter3';
+import { WebSocketClient } from '../core/websocket-client.js';
+import { TurnoutState, TurnoutData } from '../types/jmri-messages.js';
+/**
+ * Manages JMRI turnout (track switch) state
+ */
+export declare class TurnoutManager extends EventEmitter {
+    private client;
+    private turnouts;
+    constructor(client: WebSocketClient);
+    /**
+     * Get the current state of a turnout.
+     * Also registers a server-side listener so subsequent changes are pushed.
+     */
+    getTurnout(name: string): Promise<TurnoutState>;
+    /**
+     * Set a turnout to the given state
+     */
+    setTurnout(name: string, state: TurnoutState): Promise<void>;
+    /**
+     * Throw a turnout (diverging route)
+     */
+    throwTurnout(name: string): Promise<void>;
+    /**
+     * Close a turnout (straight through / normal)
+     */
+    closeTurnout(name: string): Promise<void>;
+    /**
+     * List all turnouts known to JMRI
+     */
+    listTurnouts(): Promise<TurnoutData[]>;
+    /**
+     * Get cached turnout state without a network request
+     */
+    getTurnoutState(name: string): TurnoutState | undefined;
+    /**
+     * Get all cached turnout states
+     */
+    getCachedTurnouts(): Map<string, TurnoutState>;
+    /**
+     * Handle unsolicited turnout state updates from JMRI
+     */
+    private handleTurnoutUpdate;
+}

package/dist/types/mocks/mock-data.d.ts

@@ -263,6 +263,30 @@ export declare const mockData: {
             };
         };
     };
+    readonly turnout: {
+        readonly list: readonly [{
+            readonly type: "turnout";
+            readonly data: {
+                readonly name: "LT1";
+                readonly userName: "Main Diverge";
+                readonly state: 2;
+            };
+        }, {
+            readonly type: "turnout";
+            readonly data: {
+                readonly name: "LT2";
+                readonly userName: "Yard Lead";
+                readonly state: 2;
+            };
+        }, {
+            readonly type: "turnout";
+            readonly data: {
+                readonly name: "LT3";
+                readonly userName: "Siding Entry";
+                readonly state: 4;
+            };
+        }];
+    };
     readonly ping: {
         readonly type: "ping";
     };

package/dist/types/mocks/mock-response-manager.d.ts

@@ -2,7 +2,7 @@
  * Mock Response Manager
  * Generates mock JMRI responses for testing and demo purposes
  */
-import { JmriMessage, PowerState } from '../types/jmri-messages.js';
+import { JmriMessage, PowerState, TurnoutState } from '../types/jmri-messages.js';
 export interface MockResponseManagerOptions {
     /**
      * Delay in milliseconds before returning responses (simulates network latency)
@@ -21,6 +21,7 @@ export declare class MockResponseManager {
     private responseDelay;
     private powerState;
     private throttles;
+    private turnouts;
     constructor(options?: MockResponseManagerOptions);
     /**
      * Get a mock response for a given message
@@ -42,6 +43,10 @@ export declare class MockResponseManager {
      * Get throttle response
      */
     private getThrottleResponse;
+    /**
+     * Get turnout response
+     */
+    private getTurnoutResponse;
     /**
      * Get ping response (pong)
      */
@@ -62,6 +67,10 @@ export declare class MockResponseManager {
      * Get all throttles (for testing)
      */
     getThrottles(): Map<string, any>;
+    /**
+     * Get all turnout states (for testing)
+     */
+    getTurnouts(): Map<string, TurnoutState>;
     /**
      * Reset all state (for testing)
      */

package/dist/types/types/events.d.ts

@@ -1,7 +1,7 @@
 /**
  * Event types for JmriClient EventEmitter
  */
-import { PowerState } from './jmri-messages.js';
+import { PowerState, TurnoutState } from './jmri-messages.js';
 import { ThrottleData } from './jmri-messages.js';
 /**
  * Connection states
@@ -23,6 +23,7 @@ export interface EventPayloads {
     'connectionStateChanged': ConnectionState;
     'error': Error;
     'power:changed': PowerState;
+    'turnout:changed': [name: string, state: TurnoutState];
     'throttle:acquired': string;
     'throttle:updated': [throttleId: string, data: ThrottleData];
     'throttle:released': string;

package/dist/types/types/jmri-messages.d.ts

@@ -149,6 +149,40 @@ export interface RosterMessage extends JmriMessage {
 export interface RosterData {
     [key: string]: RosterEntry;
 }
+/**
+ * Turnout state values (from JMRI JSON protocol constants)
+ * UNKNOWN = 0 (state cannot be determined)
+ * CLOSED = 2 (straight through / normal position)
+ * THROWN = 4 (diverging route position)
+ * INCONSISTENT = 8 (contradictory feedback state)
+ */
+export declare enum TurnoutState {
+    UNKNOWN = 0,
+    CLOSED = 2,
+    THROWN = 4,
+    INCONSISTENT = 8
+}
+/**
+ * Convert TurnoutState enum to human-readable string
+ */
+export declare function turnoutStateToString(state: TurnoutState): string;
+/**
+ * Turnout data structure
+ */
+export interface TurnoutData {
+    name: string;
+    userName?: string;
+    state?: TurnoutState;
+    inverted?: boolean;
+    feedback?: string;
+}
+/**
+ * Turnout message
+ */
+export interface TurnoutMessage extends JmriMessage {
+    type: 'turnout';
+    data?: TurnoutData;
+}
 /**
  * Ping message (heartbeat)
  */
@@ -197,4 +231,4 @@ export interface ErrorMessage extends JmriMessage {
 /**
  * Union type of all possible JMRI messages
  */
-export type AnyJmriMessage = PowerMessage | ThrottleMessage | RosterMessage | PingMessage | PongMessage | HelloMessage | GoodbyeMessage | ErrorMessage;
+export type AnyJmriMessage = PowerMessage | ThrottleMessage | RosterMessage | TurnoutMessage | PingMessage | PongMessage | HelloMessage | GoodbyeMessage | ErrorMessage;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jmri-client",
-  "version": "3.5.3",
+  "version": "3.6.0",
   "description": "WebSocket client for JMRI with real-time updates and throttle control - works in both Node.js and browsers",
   "main": "./dist/cjs/index.js",
   "module": "./dist/esm/index.js",