Honor server-specified duration for Vibrate haptics commands

GamepadBackend and ButtplugWasmBackend previously ignored `duration` on
continuous (non-Position) actuator commands, so actuators ran until the
HapticsService auto-stop timer (default 30s) kicked in. Both backends
now schedule a per-actuator setTimeout to stop at the given ms; a new
actuate replaces the prior timer, and stop/disconnect/emergencyStop
clear them.

Also makes ButtplugWasmBackend.stop() a no-op when not connected (and
for unknown actuator IDs), matching HapticsService's own tolerance.
This fixes the `Uncaught (in promise) Error: ButtplugWasmBackend: not
connected` that fired every time the auto-stop timer ran against a
registered-but-not-connected WASM backend.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: daiverd

src/haptics/ButtplugWasmBackend.test.ts

@@ -459,8 +459,8 @@ describe("ButtplugWasmBackend", () => {
       expect(latestMockClient.stopAllDevices).toHaveBeenCalled();
     });
 
-    it("throws for an unknown actuator ID", async () => {
-      await expect(backend.stop(9999)).rejects.toThrow("unknown actuator 9999");
+    it("silently ignores an unknown actuator ID", async () => {
+      await expect(backend.stop(9999)).resolves.toBeUndefined();
     });
   });
 

src/haptics/ButtplugWasmBackend.ts

@@ -234,6 +234,8 @@ export class ButtplugWasmBackend
   private sensorMap = new Map<number, SensorMapping>();
   /** Maps sensor ID -> polling interval handle */
   private sensorSubscriptions = new Map<number, ReturnType<typeof setInterval>>();
+  /** Maps actuator ID -> pending auto-stop timer (for server-specified durations) */
+  private actuatorStopTimers = new Map<number, ReturnType<typeof setTimeout>>();
 
   constructor(deps: ButtplugWasmDeps) {
     super();
@@ -282,6 +284,9 @@ export class ButtplugWasmBackend
   async disconnect(): Promise<void> {
     if (!this.client) return;
 
+    // Cancel any pending auto-stop timers
+    this.clearAllActuatorStopTimers();
+
     // Stop all sensor subscriptions
     for (const [id] of this.sensorSubscriptions) {
       this.unsubscribeSensor(id);
@@ -373,6 +378,9 @@ export class ButtplugWasmBackend
 
     const { device, featureIndex, actuatorType } = mapping;
 
+    // Any new command cancels a pending duration-driven auto-stop
+    this.clearActuatorStopTimer(actuatorId);
+
     // Route commands through the appropriate v3 API:
     // - Scalar types (Vibrate, Oscillate, Constrict, Inflate) use device.scalar()
     //   with explicit Index and ActuatorType to target exact features
@@ -401,19 +409,50 @@ export class ButtplugWasmBackend
         break;
       }
     }
+
+    // For continuous (non-Position) actuators, honor server-specified duration
+    // by scheduling a stop after the given ms. Position encodes duration as the
+    // movement time, so it's excluded here.
+    if (
+      type !== "Position" &&
+      options?.duration !== undefined &&
+      options.duration > 0 &&
+      intensity > 0
+    ) {
+      const handle = setTimeout(() => {
+        this.actuatorStopTimers.delete(actuatorId);
+        // Best-effort stop; swallow errors if device is gone
+        void device.stop().catch(() => {});
+      }, options.duration);
+      this.actuatorStopTimers.set(actuatorId, handle);
+    }
+  }
+
+  private clearActuatorStopTimer(actuatorId: number): void {
+    const t = this.actuatorStopTimers.get(actuatorId);
+    if (t !== undefined) {
+      clearTimeout(t);
+      this.actuatorStopTimers.delete(actuatorId);
+    }
+  }
+
+  private clearAllActuatorStopTimers(): void {
+    for (const t of this.actuatorStopTimers.values()) {
+      clearTimeout(t);
+    }
+    this.actuatorStopTimers.clear();
   }
 
   async stop(actuatorId?: number): Promise<void> {
     if (actuatorId != null) {
+      this.clearActuatorStopTimer(actuatorId);
       const mapping = this.actuatorMap.get(actuatorId);
-      if (!mapping) {
-        throw new Error(`ButtplugWasmBackend: unknown actuator ${actuatorId}`);
-      }
+      if (!mapping) return;
       await mapping.device.stop();
     } else {
-      if (!this.client) {
-        throw new Error("ButtplugWasmBackend: not connected");
-      }
+      this.clearAllActuatorStopTimers();
+      // No client yet (lazy-registered backend not connected) → nothing to stop
+      if (!this.client) return;
       await this.client.stopAllDevices();
     }
   }
@@ -471,6 +510,7 @@ export class ButtplugWasmBackend
   // --- Safety ---
 
   async emergencyStop(): Promise<void> {
+    this.clearAllActuatorStopTimers();
     if (!this.client) return;
     await this.client.stopAllDevices();
   }

src/haptics/GamepadBackend.ts

@@ -29,6 +29,13 @@ interface TrackedGamepad {
   intensities: [number, number, number, number];
   // The setInterval ID for the vibration loop
   loopInterval: ReturnType<typeof setInterval> | null;
+  // Per-motor auto-stop timers (when server specifies duration)
+  stopTimers: [
+    ReturnType<typeof setTimeout> | null,
+    ReturnType<typeof setTimeout> | null,
+    ReturnType<typeof setTimeout> | null,
+    ReturnType<typeof setTimeout> | null,
+  ];
 }
 
 export class GamepadBackend
@@ -142,7 +149,7 @@ export class GamepadBackend
     actuatorId: number,
     type: HapticsActuatorType,
     intensity: number,
-    _options?: { duration?: number; clockwise?: boolean }
+    options?: { duration?: number; clockwise?: boolean }
   ): Promise<void> {
     if (type !== "Vibrate") return;
 
@@ -160,13 +167,29 @@ export class GamepadBackend
 
     // Start the vibration loop if not already running and any intensity > 0
     this.ensureLoop(tracked);
+
+    // A new command cancels any previous duration timer for this motor
+    this.clearStopTimer(tracked, motorOffset);
+
+    // If server specified a duration (ms), schedule this motor to stop
+    if (options?.duration !== undefined && options.duration > 0) {
+      tracked.stopTimers[motorOffset] = setTimeout(() => {
+        tracked.stopTimers[motorOffset] = null;
+        tracked.intensities[motorOffset] = 0;
+        if (tracked.intensities.every((v) => v === 0)) {
+          this.clearLoop(tracked);
+          void this.resetGamepad(tracked.gamepadIndex);
+        }
+      }, options.duration);
+    }
   }
 
   async stop(actuatorId?: number): Promise<void> {
     if (actuatorId === undefined) {
       // Stop all motors on all gamepads
       for (const tracked of this.gamepads.values()) {
         tracked.intensities = [0, 0, 0, 0];
+        this.clearAllStopTimers(tracked);
         this.clearLoop(tracked);
         await this.resetGamepad(tracked.gamepadIndex);
       }
@@ -177,6 +200,7 @@ export class GamepadBackend
       if (!tracked) return;
 
       tracked.intensities[motorOffset] = 0;
+      this.clearStopTimer(tracked, motorOffset);
 
       // If all intensities are zero, stop the loop and reset
       if (tracked.intensities.every((v) => v === 0)) {
@@ -202,6 +226,7 @@ export class GamepadBackend
     // Immediately clear all intervals and reset all gamepads
     for (const tracked of this.gamepads.values()) {
       tracked.intensities = [0, 0, 0, 0];
+      this.clearAllStopTimers(tracked);
       this.clearLoop(tracked);
       await this.resetGamepad(tracked.gamepadIndex);
     }
@@ -244,6 +269,7 @@ export class GamepadBackend
       hasTriggerRumble,
       intensities: [0, 0, 0, 0],
       loopInterval: null,
+      stopTimers: [null, null, null, null],
     });
 
     this.emit("devicechanged");
@@ -255,11 +281,26 @@ export class GamepadBackend
     if (!tracked) return;
 
     tracked.intensities = [0, 0, 0, 0];
+    this.clearAllStopTimers(tracked);
     this.clearLoop(tracked);
     this.gamepads.delete(gamepadIndex);
     this.emit("devicechanged");
   }
 
+  private clearStopTimer(tracked: TrackedGamepad, motorOffset: number): void {
+    const t = tracked.stopTimers[motorOffset];
+    if (t !== null) {
+      clearTimeout(t);
+      tracked.stopTimers[motorOffset] = null;
+    }
+  }
+
+  private clearAllStopTimers(tracked: TrackedGamepad): void {
+    for (let i = 0; i < 4; i++) {
+      this.clearStopTimer(tracked, i);
+    }
+  }
+
   private ensureLoop(tracked: TrackedGamepad): void {
     // If all zero, no need for a loop
     if (tracked.intensities.every((v) => v === 0)) {