@zendrex/buttplug.js 0.1.0 → 0.1.1

package/dist/index.cjs

@@ -32,60 +32,24 @@ var index_exports = {};
 __export(index_exports, {
   ButtplugClient: () => ButtplugClient,
   ButtplugError: () => ButtplugError,
-  ClientMessageSchema: () => ClientMessageSchema,
   ConnectionError: () => ConnectionError,
-  DEFAULT_CLIENT_NAME: () => DEFAULT_CLIENT_NAME,
-  DEFAULT_PING_INTERVAL: () => DEFAULT_PING_INTERVAL,
-  DEFAULT_REQUEST_TIMEOUT: () => DEFAULT_REQUEST_TIMEOUT,
   Device: () => Device,
   DeviceError: () => DeviceError,
-  DeviceFeaturesSchema: () => DeviceFeaturesSchema,
   EASING_FUNCTIONS: () => EASING_FUNCTIONS,
   EASING_VALUES: () => EASING_VALUES,
   ErrorCode: () => ErrorCode,
-  FeatureValueSchema: () => FeatureValueSchema,
   HandshakeError: () => HandshakeError,
-  HwPositionOutputDataSchema: () => HwPositionOutputDataSchema,
   INPUT_TYPES: () => INPUT_TYPES,
-  INPUT_TYPE_VALUES: () => INPUT_TYPE_VALUES,
-  InputCommandTypeSchema: () => InputCommandTypeSchema,
-  InputDataSchema: () => InputDataSchema,
-  InputFeatureSchema: () => InputFeatureSchema,
-  InputReadingSchema: () => InputReadingSchema,
-  InputTypeSchema: () => InputTypeSchema,
-  KeyframeSchema: () => KeyframeSchema,
-  MAX_MESSAGE_ID: () => MAX_MESSAGE_ID,
   OUTPUT_TYPES: () => OUTPUT_TYPES,
-  OUTPUT_TYPE_VALUES: () => OUTPUT_TYPE_VALUES,
-  OutputCommandSchema: () => OutputCommandSchema,
-  OutputFeatureSchema: () => OutputFeatureSchema,
-  OutputTypeSchema: () => OutputTypeSchema,
   PRESETS: () => PRESETS,
   PRESET_NAMES: () => PRESET_NAMES,
-  PROTOCOL_VERSION_MAJOR: () => PROTOCOL_VERSION_MAJOR,
-  PROTOCOL_VERSION_MINOR: () => PROTOCOL_VERSION_MINOR,
-  PatternDescriptorSchema: () => PatternDescriptorSchema,
   PatternEngine: () => PatternEngine,
-  PingManager: () => PingManager,
-  PositionValueSchema: () => PositionValueSchema,
   ProtocolError: () => ProtocolError,
-  ReconnectDefaults: () => ReconnectDefaults,
-  ReconnectHandler: () => ReconnectHandler,
-  RotateWithDirectionOutputDataSchema: () => RotateWithDirectionOutputDataSchema,
-  RotationValueSchema: () => RotationValueSchema,
-  SensorValueSchema: () => SensorValueSchema,
-  ServerInfoSchema: () => ServerInfoSchema,
-  ServerMessageSchema: () => ServerMessageSchema,
-  SignedScalarOutputDataSchema: () => SignedScalarOutputDataSchema,
   TimeoutError: () => TimeoutError,
-  UnsignedScalarOutputDataSchema: () => UnsignedScalarOutputDataSchema,
-  WebSocketTransport: () => WebSocketTransport,
   consoleLogger: () => consoleLogger,
   formatError: () => formatError,
-  getLogger: () => getLogger,
   getPresetInfo: () => getPresetInfo,
-  noopLogger: () => noopLogger,
-  runWithLogger: () => runWithLogger
+  noopLogger: () => noopLogger
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -127,92 +91,6 @@ function createLogger(prefix) {
 }
 var consoleLogger = createLogger("buttplug");
 
-// src/lib/context.ts
-var currentLogger;
-function getLogger() {
-  return currentLogger ?? noopLogger;
-}
-function runWithLogger(logger, fn) {
-  const prev = currentLogger;
-  currentLogger = logger;
-  try {
-    return fn();
-  } finally {
-    currentLogger = prev;
-  }
-}
-
-// src/core/utils.ts
-function raceTimeout(promise, ms) {
-  return Promise.race([
-    promise,
-    new Promise((_, reject) => setTimeout(() => reject(new Error("Timeout")), ms))
-  ]);
-}
-function outputFeaturesEqual(a, b) {
-  const sortedA = [...a].sort((x, y) => x.index - y.index);
-  const sortedB = [...b].sort((x, y) => x.index - y.index);
-  for (const [i, ao] of sortedA.entries()) {
-    const bo = sortedB[i];
-    if (!bo || ao.type !== bo.type || ao.index !== bo.index || ao.description !== bo.description || ao.range[0] !== bo.range[0] || ao.range[1] !== bo.range[1] || ao.durationRange?.[0] !== bo.durationRange?.[0] || ao.durationRange?.[1] !== bo.durationRange?.[1]) {
-      return false;
-    }
-  }
-  return true;
-}
-function inputFeaturesEqual(a, b) {
-  const sortedA = [...a].sort((x, y) => x.index - y.index);
-  const sortedB = [...b].sort((x, y) => x.index - y.index);
-  for (const [i, ai] of sortedA.entries()) {
-    const bi = sortedB[i];
-    if (!bi || ai.type !== bi.type || ai.index !== bi.index || ai.description !== bi.description || ai.canRead !== bi.canRead || ai.canSubscribe !== bi.canSubscribe || ai.range[0] !== bi.range[0] || ai.range[1] !== bi.range[1]) {
-      return false;
-    }
-  }
-  return true;
-}
-function featuresEqual(a, b) {
-  if (a.outputs.length !== b.outputs.length || a.inputs.length !== b.inputs.length) {
-    return false;
-  }
-  return outputFeaturesEqual(a.outputs, b.outputs) && inputFeaturesEqual(a.inputs, b.inputs);
-}
-
-// src/core/device-reconciler.ts
-function reconcileDevices(options) {
-  const { currentDevices, incomingRaw, createDevice, callbacks } = options;
-  const logger = getLogger();
-  const incomingIndices = new Set(incomingRaw.map((d) => d.DeviceIndex));
-  const currentIndices = new Set(currentDevices.keys());
-  for (const index of currentIndices) {
-    if (!incomingIndices.has(index)) {
-      const device = currentDevices.get(index);
-      if (device) {
-        logger.debug(`Device removed: ${device.name} (index ${index})`);
-        currentDevices.delete(index);
-        callbacks.onRemoved(device);
-      }
-    }
-  }
-  for (const rawDevice of incomingRaw) {
-    if (currentIndices.has(rawDevice.DeviceIndex)) {
-      const existingDevice = currentDevices.get(rawDevice.DeviceIndex);
-      const newDevice = createDevice(rawDevice);
-      if (existingDevice && !featuresEqual(existingDevice.features, newDevice.features)) {
-        currentDevices.set(rawDevice.DeviceIndex, newDevice);
-        logger.debug(`Device updated: ${newDevice.name} (index ${newDevice.index})`);
-        callbacks.onUpdated(newDevice, existingDevice);
-      }
-    } else {
-      const device = createDevice(rawDevice);
-      currentDevices.set(rawDevice.DeviceIndex, device);
-      logger.debug(`Device added: ${device.name} (index ${device.index})`);
-      callbacks.onAdded(device);
-    }
-  }
-  callbacks.onList(Array.from(currentDevices.values()));
-}
-
 // src/lib/errors.ts
 var ErrorCode = {
   UNKNOWN: 0,
@@ -286,12 +164,82 @@ function formatError(err) {
   return err instanceof Error ? err.message : String(err);
 }
 
+// src/core/utils.ts
+function raceTimeout(promise, ms) {
+  return Promise.race([
+    promise,
+    new Promise((_, reject) => setTimeout(() => reject(new TimeoutError("raceTimeout", ms)), ms))
+  ]);
+}
+function outputFeaturesEqual(a, b) {
+  const sortedA = [...a].sort((x, y) => x.index - y.index);
+  const sortedB = [...b].sort((x, y) => x.index - y.index);
+  for (const [i, ao] of sortedA.entries()) {
+    const bo = sortedB[i];
+    if (!bo || ao.type !== bo.type || ao.index !== bo.index || ao.description !== bo.description || ao.range[0] !== bo.range[0] || ao.range[1] !== bo.range[1] || ao.durationRange?.[0] !== bo.durationRange?.[0] || ao.durationRange?.[1] !== bo.durationRange?.[1]) {
+      return false;
+    }
+  }
+  return true;
+}
+function inputFeaturesEqual(a, b) {
+  const sortedA = [...a].sort((x, y) => x.index - y.index);
+  const sortedB = [...b].sort((x, y) => x.index - y.index);
+  for (const [i, ai] of sortedA.entries()) {
+    const bi = sortedB[i];
+    if (!bi || ai.type !== bi.type || ai.index !== bi.index || ai.description !== bi.description || ai.canRead !== bi.canRead || ai.canSubscribe !== bi.canSubscribe || ai.range[0] !== bi.range[0] || ai.range[1] !== bi.range[1]) {
+      return false;
+    }
+  }
+  return true;
+}
+function featuresEqual(a, b) {
+  if (a.outputs.length !== b.outputs.length || a.inputs.length !== b.inputs.length) {
+    return false;
+  }
+  return outputFeaturesEqual(a.outputs, b.outputs) && inputFeaturesEqual(a.inputs, b.inputs);
+}
+
+// src/core/device-reconciler.ts
+function reconcileDevices(options) {
+  const { currentDevices, incomingRaw, createDevice, callbacks } = options;
+  const logger = options.logger ?? noopLogger;
+  const incomingIndices = new Set(incomingRaw.map((d) => d.DeviceIndex));
+  const currentIndices = new Set(currentDevices.keys());
+  for (const index of currentIndices) {
+    if (!incomingIndices.has(index)) {
+      const device = currentDevices.get(index);
+      if (device) {
+        logger.debug(`Device removed: ${device.name} (index ${index})`);
+        currentDevices.delete(index);
+        callbacks.onRemoved(device);
+      }
+    }
+  }
+  for (const rawDevice of incomingRaw) {
+    if (currentIndices.has(rawDevice.DeviceIndex)) {
+      const existingDevice = currentDevices.get(rawDevice.DeviceIndex);
+      const newDevice = createDevice(rawDevice);
+      if (existingDevice && !featuresEqual(existingDevice.features, newDevice.features)) {
+        currentDevices.set(rawDevice.DeviceIndex, newDevice);
+        logger.debug(`Device updated: ${newDevice.name} (index ${newDevice.index})`);
+        callbacks.onUpdated(newDevice, existingDevice);
+      }
+    } else {
+      const device = createDevice(rawDevice);
+      currentDevices.set(rawDevice.DeviceIndex, device);
+      logger.debug(`Device added: ${device.name} (index ${device.index})`);
+      callbacks.onAdded(device);
+    }
+  }
+  callbacks.onList(Array.from(currentDevices.values()));
+}
+
 // src/protocol/constants.ts
 var PROTOCOL_VERSION_MAJOR = 4;
 var PROTOCOL_VERSION_MINOR = 0;
 var DEFAULT_CLIENT_NAME = "buttplug.js";
 var DEFAULT_REQUEST_TIMEOUT = 1e4;
-var DEFAULT_PING_INTERVAL = 1e3;
 var MAX_MESSAGE_ID = 4294967295;
 
 // src/protocol/messages.ts
@@ -332,7 +280,7 @@ function createDisconnect(id) {
 }
 function createStopCmd(id, options) {
   if (options?.featureIndex !== void 0 && options.deviceIndex === void 0) {
-    throw new Error("StopCmd: featureIndex requires deviceIndex to be set");
+    throw new ProtocolError(ErrorCode.MESSAGE, "StopCmd: featureIndex requires deviceIndex to be set");
   }
   return {
     StopCmd: {
@@ -344,9 +292,6 @@ function createStopCmd(id, options) {
     }
   };
 }
-function serializeMessage(message) {
-  return JSON.stringify([message]);
-}
 function serializeMessages(messages) {
   return JSON.stringify(messages);
 }
@@ -649,11 +594,7 @@ var MessageRouter = class {
     this.#onInputReading = options.onInputReading;
     this.#onError = options.onError;
   }
-  /**
-   * Returns the next message ID, wrapping around at {@link MAX_MESSAGE_ID}.
-   *
-   * @returns A monotonically increasing ID for use in outgoing messages
-   */
+  /** Returns the next auto-incrementing message ID. */
   nextId() {
     this.#messageId = this.#messageId % MAX_MESSAGE_ID + 1;
     return this.#messageId;
@@ -681,6 +622,13 @@ var MessageRouter = class {
           this.#pending.delete(id);
           reject(new TimeoutError(`Request (ID ${id})`, this.#timeout));
         }, this.#timeout);
+        const existing = this.#pending.get(id);
+        if (existing) {
+          if (existing.timeout !== null) {
+            clearTimeout(existing.timeout);
+          }
+          existing.reject(new ProtocolError(ErrorCode.MESSAGE, `Request ${id} superseded by new request`));
+        }
         this.#pending.set(id, {
           resolve,
           reject: (err) => {
@@ -866,6 +814,7 @@ var SensorHandler = class {
    * @param key - Composite sensor key from {@link sensorKey}
    * @param callback - Function invoked with the sensor value on each reading
    * @param info - Device index, feature index, and input type for the sensor
+   * @throws {Error} if a subscription already exists for the given key
    */
   register(key, callback, info) {
     if (this.#subscriptions.has(key)) {
@@ -969,11 +918,7 @@ var SensorHandler = class {
 function validateRange(value, range) {
   const [min, max] = range;
   const rounded = Math.round(value);
-  const clamped = Math.max(min, Math.min(max, rounded));
-  if (rounded !== clamped) {
-    getLogger().debug(`Value ${value} clamped to ${clamped} (range [${min}, ${max}])`);
-  }
-  return clamped;
+  return Math.max(min, Math.min(max, rounded));
 }
 
 // src/builders/commands.ts
@@ -1006,12 +951,9 @@ function buildPositionMessages(options) {
       throw new DeviceError(deviceIndex, "Values array must not be empty");
     }
     for (const p of position) {
-      const feature = features[p.index];
+      const feature = features.find((f) => f.index === p.index);
       if (!feature) {
-        throw new DeviceError(
-          deviceIndex,
-          `Invalid position index ${p.index} (device has ${features.length} position feature(s))`
-        );
+        throw new DeviceError(deviceIndex, `Position feature index ${p.index} not found on device`);
       }
       messages.push(
         buildPositionMessage({
@@ -1039,12 +981,9 @@ function buildRotateMessages(options) {
       throw new DeviceError(deviceIndex, "Values array must not be empty");
     }
     for (const r of speed) {
-      const feature = features[r.index];
+      const feature = features.find((f) => f.index === r.index);
       if (!feature) {
-        throw new DeviceError(
-          deviceIndex,
-          `Invalid rotation index ${r.index} (device has ${features.length} rotation feature(s))`
-        );
+        throw new DeviceError(deviceIndex, `Rotation feature index ${r.index} not found on device`);
       }
       const validatedValue = validateRange(r.speed, feature.range);
       const command = rotationType === "RotateWithDirection" ? { RotateWithDirection: { Value: validatedValue, Clockwise: r.clockwise } } : { Rotate: { Value: validatedValue } };
@@ -1083,12 +1022,9 @@ function buildScalarOutputMessages(options) {
     }
     const messages2 = [];
     for (const entry of values) {
-      const feature = features[entry.index];
+      const feature = features.find((f) => f.index === entry.index);
       if (!feature) {
-        throw new DeviceError(
-          deviceIndex,
-          `Invalid ${errorLabel} index ${entry.index} (device has ${features.length} ${errorLabel} feature(s))`
-        );
+        throw new DeviceError(deviceIndex, `${errorLabel} feature index ${entry.index} not found on device`);
       }
       const validatedValue = validateRange(entry.value, feature.range);
       const id = client.nextId();
@@ -1172,11 +1108,10 @@ function getInputIndex(features) {
 }
 var KNOWN_OUTPUT_KEYS = new Set(OUTPUT_TYPES);
 var KNOWN_INPUT_KEYS = new Set(INPUT_TYPES);
-function collectOutputs(feature) {
+function collectOutputs(feature, logger) {
   if (!feature.Output) {
     return [];
   }
-  const logger = getLogger();
   const results = [];
   for (const key of Object.keys(feature.Output)) {
     if (!KNOWN_OUTPUT_KEYS.has(key)) {
@@ -1191,11 +1126,10 @@ function collectOutputs(feature) {
   }
   return results;
 }
-function collectInputs(feature) {
+function collectInputs(feature, logger) {
   if (!feature.Input) {
     return [];
   }
-  const logger = getLogger();
   const results = [];
   for (const key of Object.keys(feature.Input)) {
     if (!KNOWN_INPUT_KEYS.has(key)) {
@@ -1210,16 +1144,16 @@ function collectInputs(feature) {
   }
   return results;
 }
-function parseFeatures(raw) {
+function parseFeatures(raw, logger = noopLogger) {
   const outputs = [];
   const inputs = [];
   const features = raw.DeviceFeatures ?? {};
   const sortedFeatures = Object.values(features).sort((a, b) => a.FeatureIndex - b.FeatureIndex);
   for (const feature of sortedFeatures) {
-    for (const output of collectOutputs(feature)) {
+    for (const output of collectOutputs(feature, logger)) {
       outputs.push(output);
     }
-    for (const input of collectInputs(feature)) {
+    for (const input of collectInputs(feature, logger)) {
       inputs.push(input);
     }
   }
@@ -1272,8 +1206,8 @@ var Device = class {
   constructor(options) {
     this.#client = options.client;
     this.#raw = options.raw;
-    this.#logger = (options.logger ?? getLogger()).child("device");
-    this.#features = parseFeatures(options.raw);
+    this.#logger = (options.logger ?? noopLogger).child("device");
+    this.#features = parseFeatures(options.raw, this.#logger);
   }
   /**
    * Sets vibration intensity on all or individual motors.
@@ -1496,6 +1430,7 @@ var Device = class {
    *
    * @param type - The sensor type to unsubscribe from
    * @param sensorIndex - Index of the sensor if the device has multiple of the same type
+   * @throws {DeviceError} if the sensor does not exist at the given index
    */
   async unsubscribe(type, sensorIndex = 0) {
     const features = getInputsByType(this.#features, type);
@@ -1912,6 +1847,8 @@ var PingManager = class {
   #pingTimer = null;
   /** Tracks whether a ping request is currently awaiting a response. */
   #pingInFlight = false;
+  /** Whether the manager is in a stopped state. */
+  #stopped = true;
   /** Maximum time in ms the server allows between pings. */
   #maxPingTime = 0;
   constructor(options) {
@@ -1939,6 +1876,7 @@ var PingManager = class {
       this.#cancelPing(new TimeoutError("Ping", 0));
     }
     this.stop();
+    this.#stopped = false;
     this.#maxPingTime = maxPingTime;
     if (!this.#autoPing || maxPingTime <= 0) {
       return;
@@ -1961,6 +1899,7 @@ var PingManager = class {
   }
   /** Stops the ping timer and resets in-flight state. */
   stop() {
+    this.#stopped = true;
     if (this.#pingTimer !== null) {
       clearInterval(this.#pingTimer);
       this.#pingTimer = null;
@@ -1970,14 +1909,23 @@ var PingManager = class {
   }
   /** Sends a single ping and handles timeout or failure. */
   async #doPing() {
+    if (this.#stopped) {
+      return;
+    }
     this.#logger.debug("Sending ping");
     const maxPingTime = this.#maxPingTime || DEFAULT_PING_TIMEOUT_MS;
     const timer = setTimeout(() => {
+      if (this.#stopped) {
+        return;
+      }
       this.#cancelPing(new TimeoutError("Ping", maxPingTime));
     }, maxPingTime);
     try {
       await this.#sendPing();
     } catch (err) {
+      if (this.#stopped) {
+        return;
+      }
       const isTimeout = err instanceof TimeoutError;
       this.#logger.error(`Ping failed: ${formatError(err)}`);
       this.#onError(err instanceof Error ? err : new Error(String(err)));
@@ -2071,7 +2019,12 @@ var ReconnectHandler = class {
   /** Safely invokes a user callback, catching and logging any errors. */
   #safeCallback(name, fn) {
     try {
-      fn();
+      const result = fn();
+      if (result instanceof Promise) {
+        result.catch((err) => {
+          this.#logger.error(`Error in async ${name} callback: ${formatError(err)}`);
+        });
+      }
     } catch (err) {
       this.#logger.error(`Error in ${name} callback: ${formatError(err)}`);
     }
@@ -2146,6 +2099,7 @@ var ButtplugClient = class extends import_emittery.default {
   #serverInfo = null;
   #connectPromise = null;
   #isHandshaking = false;
+  #disconnecting = false;
   constructor(url, options = {}) {
     super();
     this.#url = url;
@@ -2157,9 +2111,10 @@ var ButtplugClient = class extends import_emittery.default {
       this.#messageRouter.handleMessage(data);
     });
     this.#transport.on("close", (_code, reason) => {
-      this.#safetyStop();
       this.#pingManager.stop();
-      this.emit("disconnected", { reason });
+      if (!this.#disconnecting) {
+        this.emit("disconnected", { reason });
+      }
     });
     this.#transport.on("error", (error) => {
       this.emit("error", { error });
@@ -2168,20 +2123,18 @@ var ButtplugClient = class extends import_emittery.default {
       send: (data) => this.#transport.send(data),
       timeout: options.requestTimeout,
       logger: this.#baseLogger,
-      onDeviceList: (devices) => runWithLogger(
-        this.#logger,
-        () => reconcileDevices({
-          currentDevices: this.#devices,
-          incomingRaw: devices,
-          createDevice: (raw) => new Device({ client: this, raw }),
-          callbacks: {
-            onAdded: (d) => this.emit("deviceAdded", { device: d }),
-            onRemoved: (d) => this.emit("deviceRemoved", { device: d }),
-            onUpdated: (d, old) => this.emit("deviceUpdated", { device: d, previousDevice: old }),
-            onList: (list) => this.emit("deviceList", { devices: list })
-          }
-        })
-      ),
+      onDeviceList: (devices) => reconcileDevices({
+        currentDevices: this.#devices,
+        incomingRaw: devices,
+        createDevice: (raw) => new Device({ client: this, raw, logger: this.#baseLogger }),
+        logger: this.#logger,
+        callbacks: {
+          onAdded: (d) => this.emit("deviceAdded", { device: d }),
+          onRemoved: (d) => this.emit("deviceRemoved", { device: d }),
+          onUpdated: (d, old) => this.emit("deviceUpdated", { device: d, previousDevice: old }),
+          onList: (list) => this.emit("deviceList", { devices: list })
+        }
+      }),
       onScanningFinished: () => {
         this.#scanning = false;
         this.emit("scanningFinished", void 0);
@@ -2282,34 +2235,45 @@ var ButtplugClient = class extends import_emittery.default {
    * @param reason - Optional human-readable reason for the disconnection
    */
   async disconnect(reason) {
-    if (this.#reconnectHandler?.active) {
-      this.#reconnectHandler.cancel();
+    this.#disconnecting = true;
+    try {
+      const disconnectReason = reason ?? "Client disconnected";
+      let emitted = false;
+      if (this.#reconnectHandler?.active) {
+        this.#reconnectHandler.cancel();
+        this.#pingManager.stop();
+        this.emit("disconnected", { reason: disconnectReason });
+        emitted = true;
+      }
+      if (!this.connected) {
+        return;
+      }
+      this.#logger.info(`Disconnecting${reason ? `: ${reason}` : ""}`);
       this.#pingManager.stop();
-      this.emit("disconnected", { reason: reason ?? "Client disconnected" });
-    }
-    if (!this.connected) {
-      return;
-    }
-    this.#logger.info(`Disconnecting${reason ? `: ${reason}` : ""}`);
-    this.#pingManager.stop();
-    this.#reconnectHandler?.cancel();
-    if (this.#serverInfo !== null && !this.#isHandshaking) {
-      try {
-        await raceTimeout(this.stopAll(), STOP_DEVICES_TIMEOUT_MS);
-      } catch {
-        this.#logger.warn("Stop all devices timed out during disconnect");
+      this.#reconnectHandler?.cancel();
+      if (this.#serverInfo !== null && !this.#isHandshaking) {
+        try {
+          await raceTimeout(this.stopAll(), STOP_DEVICES_TIMEOUT_MS);
+        } catch {
+          this.#logger.warn("Stop all devices timed out during disconnect");
+        }
+        try {
+          await raceTimeout(
+            this.#messageRouter.send(createDisconnect(this.#messageRouter.nextId())),
+            DISCONNECT_TIMEOUT_MS
+          );
+        } catch {
+          this.#logger.warn("Disconnect message failed or timed out");
+        }
       }
-      try {
-        await raceTimeout(
-          this.#messageRouter.send(createDisconnect(this.#messageRouter.nextId())),
-          DISCONNECT_TIMEOUT_MS
-        );
-      } catch {
-        this.#logger.warn("Disconnect message failed or timed out");
+      this.#messageRouter.cancelAll(new ConnectionError("Client disconnected"));
+      await this.#transport.disconnect();
+      if (!emitted) {
+        this.emit("disconnected", { reason: disconnectReason });
       }
+    } finally {
+      this.#disconnecting = false;
     }
-    this.#messageRouter.cancelAll(new ConnectionError("Client disconnected"));
-    await this.#transport.disconnect();
   }
   /**
    * Begins scanning for devices on the server.
@@ -2354,20 +2318,18 @@ var ButtplugClient = class extends import_emittery.default {
     for (const response of responses) {
       if (isDeviceList(response)) {
         const deviceList = getDeviceList(response);
-        runWithLogger(
-          this.#logger,
-          () => reconcileDevices({
-            currentDevices: this.#devices,
-            incomingRaw: Object.values(deviceList.Devices),
-            createDevice: (raw) => new Device({ client: this, raw }),
-            callbacks: {
-              onAdded: (d) => this.emit("deviceAdded", { device: d }),
-              onRemoved: (d) => this.emit("deviceRemoved", { device: d }),
-              onUpdated: (d, old) => this.emit("deviceUpdated", { device: d, previousDevice: old }),
-              onList: (list) => this.emit("deviceList", { devices: list })
-            }
-          })
-        );
+        reconcileDevices({
+          currentDevices: this.#devices,
+          incomingRaw: Object.values(deviceList.Devices),
+          createDevice: (raw) => new Device({ client: this, raw, logger: this.#baseLogger }),
+          logger: this.#logger,
+          callbacks: {
+            onAdded: (d) => this.emit("deviceAdded", { device: d }),
+            onRemoved: (d) => this.emit("deviceRemoved", { device: d }),
+            onUpdated: (d, old) => this.emit("deviceUpdated", { device: d, previousDevice: old }),
+            onList: (list) => this.emit("deviceList", { devices: list })
+          }
+        });
       }
     }
   }
@@ -2433,16 +2395,18 @@ var ButtplugClient = class extends import_emittery.default {
   get devices() {
     return Array.from(this.#devices.values());
   }
-  /** Best-effort StopCmd bypassing connection checks for safety-critical scenarios. */
-  #safetyStop() {
-    try {
-      if (this.#transport.state === "connected") {
-        const msg = createStopCmd(this.#messageRouter.nextId());
-        this.#transport.send(serializeMessage(msg));
-      }
-    } catch {
-      this.#logger.warn("Safety stop failed \u2014 transport may already be closed");
-    }
+  /**
+   * Disposes the client, clearing all event listeners and internal state.
+   *
+   * Callers should {@link disconnect} first if still connected.
+   * Subsequent usage of the client after disposal is undefined behavior.
+   */
+  dispose() {
+    this.clearListeners();
+    this.#pingManager.stop();
+    this.#sensorHandler.clear();
+    this.#reconnectHandler?.cancel();
+    this.#devices.clear();
   }
   /**
    * Validates connection state before performing an action.
@@ -2502,59 +2466,6 @@ var ButtplugClient = class extends import_emittery.default {
   }
 };
 
-// src/patterns/easing.ts
-var clamp = (t) => Math.min(1, Math.max(0, t));
-var linear = (t) => clamp(t);
-var easeIn = (t) => clamp(t) ** 3;
-var easeOut = (t) => 1 - (1 - clamp(t)) ** 3;
-var easeInOut = (t) => {
-  const c = clamp(t);
-  return c < 0.5 ? 4 * c ** 3 : 1 - (-2 * c + 2) ** 3 / 2;
-};
-var step = (t) => clamp(t) < 1 ? 0 : 1;
-var EASING_FUNCTIONS = {
-  linear,
-  easeIn,
-  easeOut,
-  easeInOut,
-  step
-};
-var ease = (t, easing) => {
-  const fn = EASING_FUNCTIONS[easing];
-  return fn ? fn(t) : clamp(t);
-};
-
-// src/patterns/types.ts
-var import_zod2 = require("zod");
-var EASING_VALUES = ["linear", "easeIn", "easeOut", "easeInOut", "step"];
-var EasingSchema = import_zod2.z.enum(EASING_VALUES);
-var KeyframeSchema = import_zod2.z.object({
-  value: import_zod2.z.number().min(0).max(1),
-  duration: import_zod2.z.number().int().nonnegative(),
-  easing: EasingSchema.optional()
-});
-var TrackSchema = import_zod2.z.object({
-  featureIndex: import_zod2.z.number().int().nonnegative(),
-  keyframes: import_zod2.z.array(KeyframeSchema).min(1),
-  clockwise: import_zod2.z.boolean().optional(),
-  outputType: OutputTypeSchema.optional()
-});
-var PRESET_NAMES = ["pulse", "wave", "ramp_up", "ramp_down", "heartbeat", "surge", "stroke"];
-var PresetPatternSchema = import_zod2.z.object({
-  type: import_zod2.z.literal("preset"),
-  preset: import_zod2.z.enum(PRESET_NAMES),
-  intensity: import_zod2.z.number().min(0).max(1).optional(),
-  speed: import_zod2.z.number().min(0.25).max(4).optional(),
-  loop: import_zod2.z.union([import_zod2.z.boolean(), import_zod2.z.number().int().positive()]).optional()
-});
-var CustomPatternSchema = import_zod2.z.object({
-  type: import_zod2.z.literal("custom"),
-  tracks: import_zod2.z.array(TrackSchema).min(1),
-  intensity: import_zod2.z.number().min(0).max(1).optional(),
-  loop: import_zod2.z.union([import_zod2.z.boolean(), import_zod2.z.number().int().positive()]).optional()
-});
-var PatternDescriptorSchema = import_zod2.z.discriminatedUnion("type", [PresetPatternSchema, CustomPatternSchema]);
-
 // src/patterns/presets.ts
 var MOTOR_OUTPUT_TYPES = ["Vibrate", "Rotate", "RotateWithDirection", "Oscillate", "Constrict"];
 var POSITION_OUTPUT_TYPES = ["Position", "HwPositionWithDuration"];
@@ -2662,6 +2573,28 @@ function getPresetInfo() {
   }));
 }
 
+// src/patterns/easing.ts
+var clamp = (t) => Math.min(1, Math.max(0, t));
+var linear = (t) => clamp(t);
+var easeIn = (t) => clamp(t) ** 3;
+var easeOut = (t) => 1 - (1 - clamp(t)) ** 3;
+var easeInOut = (t) => {
+  const c = clamp(t);
+  return c < 0.5 ? 4 * c ** 3 : 1 - (-2 * c + 2) ** 3 / 2;
+};
+var step = (t) => clamp(t) < 1 ? 0 : 1;
+var EASING_FUNCTIONS = {
+  linear,
+  easeIn,
+  easeOut,
+  easeInOut,
+  step
+};
+var ease = (t, easing) => {
+  const fn = EASING_FUNCTIONS[easing];
+  return fn ? fn(t) : clamp(t);
+};
+
 // src/patterns/scheduler.ts
 function interpolateKeyframes(keyframes, elapsed) {
   let accumulated = 0;
@@ -2702,8 +2635,14 @@ function buildScalarCommand(track, value) {
       return { Constrict: { Value: value } };
     case "Position":
       return { Position: { Value: value } };
+    case "Spray":
+      return { Spray: { Value: value } };
+    case "Temperature":
+      return { Temperature: { Value: value } };
+    case "Led":
+      return { Led: { Value: value } };
     default:
-      return { Vibrate: { Value: value } };
+      throw new DeviceError(0, `Unsupported output type in pattern: ${track.outputType}`);
   }
 }
 function getCycleDuration(tracks) {
@@ -2727,7 +2666,10 @@ function evaluateScalarTrack(state, track, elapsed, device, buildCommand, onErro
     return;
   }
   const command = buildCommand(track, mapped);
-  device.output({ featureIndex, command }).catch((err) => onError(state, err));
+  device.output({ featureIndex, command }).catch((err) => {
+    state.lastSentValues.delete(featureIndex);
+    onError(state, err);
+  });
   state.lastSentValues.set(featureIndex, mapped);
 }
 function evaluateHwPositionTrack(state, track, elapsed, device, onError) {
@@ -2854,6 +2796,37 @@ function resolveCustomTracks(device, descriptor) {
   return tracks;
 }
 
+// src/patterns/types.ts
+var import_zod2 = require("zod");
+var EASING_VALUES = ["linear", "easeIn", "easeOut", "easeInOut", "step"];
+var EasingSchema = import_zod2.z.enum(EASING_VALUES);
+var KeyframeSchema = import_zod2.z.object({
+  value: import_zod2.z.number().min(0).max(1),
+  duration: import_zod2.z.number().int().nonnegative(),
+  easing: EasingSchema.optional()
+});
+var TrackSchema = import_zod2.z.object({
+  featureIndex: import_zod2.z.number().int().nonnegative(),
+  keyframes: import_zod2.z.array(KeyframeSchema).min(1),
+  clockwise: import_zod2.z.boolean().optional(),
+  outputType: OutputTypeSchema.optional()
+});
+var PRESET_NAMES = ["pulse", "wave", "ramp_up", "ramp_down", "heartbeat", "surge", "stroke"];
+var PresetPatternSchema = import_zod2.z.object({
+  type: import_zod2.z.literal("preset"),
+  preset: import_zod2.z.enum(PRESET_NAMES),
+  intensity: import_zod2.z.number().min(0).max(1).optional(),
+  speed: import_zod2.z.number().min(0.25).max(4).optional(),
+  loop: import_zod2.z.union([import_zod2.z.boolean(), import_zod2.z.number().int().positive()]).optional()
+});
+var CustomPatternSchema = import_zod2.z.object({
+  type: import_zod2.z.literal("custom"),
+  tracks: import_zod2.z.array(TrackSchema).min(1),
+  intensity: import_zod2.z.number().min(0).max(1).optional(),
+  loop: import_zod2.z.union([import_zod2.z.boolean(), import_zod2.z.number().int().positive()]).optional()
+});
+var PatternDescriptorSchema = import_zod2.z.discriminatedUnion("type", [PresetPatternSchema, CustomPatternSchema]);
+
 // src/patterns/engine.ts
 var DEFAULT_TIMEOUT_MS = 18e5;
 var MIN_TICK_INTERVAL_MS = 50;
@@ -3019,7 +2992,8 @@ var PatternEngine = class {
     if (state.stopped) {
       return;
     }
-    const elapsed = performance.now() - state.startedAt;
+    const now = performance.now();
+    const elapsed = now - state.startedAt;
     const cycleDuration = getCycleDuration(state.tracks);
     const cycleElapsed = cycleDuration > 0 && elapsed >= cycleDuration ? cycleDuration : elapsed;
     const onError = (s, err) => this.#handleOutputError(s, err);
@@ -3043,9 +3017,9 @@ var PatternEngine = class {
         return;
       }
     }
-    const drift = performance.now() - state.expectedTickTime;
+    const drift = now - state.expectedTickTime;
     const nextDelay = Math.max(0, state.tickInterval - drift);
-    state.expectedTickTime = performance.now() + nextDelay;
+    state.expectedTickTime = now + nextDelay;
     state.timerId = setTimeout(() => this.#tick(state, device), nextDelay);
   }
   /** Builds a {@link PatternDescriptor} from the shorthand pattern argument and options. */
@@ -3101,12 +3075,7 @@ var PatternEngine = class {
     const device = this.#client.getDevice(state.deviceIndex);
     if (device) {
       for (const track of state.tracks) {
-        if (track.outputType === "Position" || track.outputType === "HwPositionWithDuration") {
-          device.stop({ featureIndex: track.featureIndex }).catch(noop);
-        } else {
-          const command = buildScalarCommand(track, track.range[0]);
-          device.output({ featureIndex: track.featureIndex, command }).catch(noop);
-        }
+        device.stop({ featureIndex: track.featureIndex }).catch(noop);
       }
     }
     if (complete) {
@@ -3119,58 +3088,22 @@ var PatternEngine = class {
 0 && (module.exports = {
   ButtplugClient,
   ButtplugError,
-  ClientMessageSchema,
   ConnectionError,
-  DEFAULT_CLIENT_NAME,
-  DEFAULT_PING_INTERVAL,
-  DEFAULT_REQUEST_TIMEOUT,
   Device,
   DeviceError,
-  DeviceFeaturesSchema,
   EASING_FUNCTIONS,
   EASING_VALUES,
   ErrorCode,
-  FeatureValueSchema,
   HandshakeError,
-  HwPositionOutputDataSchema,
   INPUT_TYPES,
-  INPUT_TYPE_VALUES,
-  InputCommandTypeSchema,
-  InputDataSchema,
-  InputFeatureSchema,
-  InputReadingSchema,
-  InputTypeSchema,
-  KeyframeSchema,
-  MAX_MESSAGE_ID,
   OUTPUT_TYPES,
-  OUTPUT_TYPE_VALUES,
-  OutputCommandSchema,
-  OutputFeatureSchema,
-  OutputTypeSchema,
   PRESETS,
   PRESET_NAMES,
-  PROTOCOL_VERSION_MAJOR,
-  PROTOCOL_VERSION_MINOR,
-  PatternDescriptorSchema,
   PatternEngine,
-  PingManager,
-  PositionValueSchema,
   ProtocolError,
-  ReconnectDefaults,
-  ReconnectHandler,
-  RotateWithDirectionOutputDataSchema,
-  RotationValueSchema,
-  SensorValueSchema,
-  ServerInfoSchema,
-  ServerMessageSchema,
-  SignedScalarOutputDataSchema,
   TimeoutError,
-  UnsignedScalarOutputDataSchema,
-  WebSocketTransport,
   consoleLogger,
   formatError,
-  getLogger,
   getPresetInfo,
-  noopLogger,
-  runWithLogger
+  noopLogger
 });