homebridge-dihool-lifts 0.1.2 → 0.1.3

package/.release-please-manifest.json

@@ -1,3 +1,3 @@
 {
-  ".": "0.1.2"
+  ".": "0.1.3"
 }

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## [0.1.3](https://github.com/alampros/homebridge-dihool-lifts/compare/homebridge-dihool-lifts-v0.1.2...homebridge-dihool-lifts-v0.1.3) (2026-07-02)
+
+
+### Bug Fixes
+
+* mdns discovery state ([52f4bc8](https://github.com/alampros/homebridge-dihool-lifts/commit/52f4bc84f64f65f8ee36118f10ddb12f37a01732))
+* only calibrate at 0% — 100% uses timed stop ([f8145e1](https://github.com/alampros/homebridge-dihool-lifts/commit/f8145e144a1793f44a70b535d108c6c929e79cd5))
+
 ## [0.1.2](https://github.com/alampros/homebridge-dihool-lifts/compare/homebridge-dihool-lifts-v0.1.1...homebridge-dihool-lifts-v0.1.2) (2026-07-02)
 
 

package/dist/connection/ewelink-lan.d.ts

@@ -21,19 +21,29 @@ export declare class EWeLinkLAN {
      */
     getHosts(): Promise<Map<string, LanDeviceInfo>>;
     /**
-     * Parse a discovery response to extract device IDs and IPs.
+     * Process all record types from an mDNS response to extract device IPs
+     * and update the device map. Used by both initial discovery and the
+     * ongoing monitor.
      */
-    private processDiscoveryResponse;
+    private processResponseRecords;
+    /**
+     * Update a device's IP in the map (unless manually overridden).
+     */
+    private updateDeviceIp;
     /**
      * Start listening for mDNS state broadcasts from eWeLink devices.
      *
-     * Creates a persistent mDNS listener that decrypts TXT record
-     * payloads and emits 'update' events on state changes.
+     * Creates a persistent mDNS listener that:
+     * 1. Extracts device IPs from A/SRV records (keeping IPs fresh)
+     * 2. Decrypts TXT record payloads and emits state change events
      */
     startMonitor(): Promise<void>;
     /**
      * Send an encrypted command to a device over the LAN.
-     * Retries up to 10 times on ECONNRESET.
+     *
+     * If the device IP is unknown, fires a one-shot mDNS query and waits
+     * up to 3 seconds for discovery before giving up. Retries up to 10
+     * times on ECONNRESET.
      */
     sendUpdate(deviceId: string, params: DeviceParams): Promise<boolean>;
     /** Register a callback for device state updates. */
@@ -42,6 +52,11 @@ export declare class EWeLinkLAN {
     addDeviceToMap(deviceId: string, context: AccessoryContext): void;
     /** Stop mDNS monitoring and clean up. */
     closeConnection(): Promise<void>;
+    /**
+     * Fire a one-shot mDNS query to try to resolve a device's IP.
+     * Waits up to 3 seconds for a response.
+     */
+    private reQueryDevice;
     /**
      * Send an HTTP POST using node:http.
      *

package/dist/connection/ewelink-lan.js

@@ -43,38 +43,72 @@ export class EWeLinkLAN {
                 existing.ipOverride = true;
             }
         }
-        // Create a temporary mDNS instance for discovery
-        const mdns = multicastDns();
+        // Create a temporary mDNS instance for initial discovery
+        let mdns;
+        try {
+            mdns = multicastDns();
+        }
+        catch (err) {
+            this.log.warn('[LAN] Failed to create mDNS socket for discovery: %s', err instanceof Error ? err.message : String(err));
+            return this.deviceMap;
+        }
         await new Promise((resolve) => {
-            setTimeout(() => {
+            const cleanup = () => {
                 mdns.removeAllListeners('response');
+                mdns.removeAllListeners('error');
                 mdns.destroy();
                 resolve();
-            }, 5000);
+            };
+            const timer = setTimeout(cleanup, 5000);
+            mdns.on('error', (err) => {
+                this.log.warn('[LAN] mDNS discovery error: %s', err.message);
+                clearTimeout(timer);
+                cleanup();
+            });
             mdns.on('response', (response) => {
-                this.processDiscoveryResponse(response);
+                this.processResponseRecords(response);
             });
             // Query for eWeLink PTR records
             mdns.query([{ name: MDNS_PTR_NAME, type: 'PTR' }]);
         });
+        // Log what we found
+        const discovered = [...this.deviceMap.entries()]
+            .filter(([, info]) => info.ip)
+            .map(([id, info]) => `${id}@${info.ip}${info.ipOverride ? ' (manual)' : ''}`);
+        if (discovered.length > 0) {
+            this.log.info('[LAN] Discovered devices: %s', discovered.join(', '));
+        }
+        else {
+            this.log.warn('[LAN] No device IPs discovered via mDNS. Devices with manual IP overrides may still work.');
+        }
         return this.deviceMap;
     }
     /**
-     * Parse a discovery response to extract device IDs and IPs.
+     * Process all record types from an mDNS response to extract device IPs
+     * and update the device map. Used by both initial discovery and the
+     * ongoing monitor.
      */
-    processDiscoveryResponse(response) {
+    processResponseRecords(response) {
         const allRecords = [
             ...(response.answers ?? []),
             ...(response.additionals ?? []),
         ];
-        // Collect SRV/A records to map hostnames to IPs
+        // Collect A records: hostname → IP
         const hostToIp = new Map();
         for (const record of allRecords) {
             if (record.type === 'A') {
                 hostToIp.set(record.name, record.data);
             }
         }
-        // Look for PTR records pointing to eWeLink devices
+        // Collect SRV records: service name → target hostname
+        const srvTargets = new Map();
+        for (const record of allRecords) {
+            if (record.type === 'SRV') {
+                const srvData = record.data;
+                srvTargets.set(record.name, srvData.target);
+            }
+        }
+        // Process PTR records to find eWeLink devices
         for (const record of allRecords) {
             if (record.type === 'PTR' && record.name.includes('_ewelink')) {
                 const ptr = record.data;
@@ -83,52 +117,70 @@ export class EWeLinkLAN {
                     .replace(/^eWeLink_/, '');
                 if (!deviceId)
                     continue;
-                // Try to find the IP from SRV → A record chain
-                const srvRecord = allRecords.find((r) => r.type === 'SRV' && r.name === ptr);
+                // Resolve IP: PTR → SRV target → A record
                 let ip;
-                if (srvRecord && srvRecord.type === 'SRV') {
-                    const srvData = srvRecord.data;
-                    ip = hostToIp.get(srvData.target);
+                const srvTarget = srvTargets.get(ptr);
+                if (srvTarget) {
+                    ip = hostToIp.get(srvTarget);
                 }
-                // Fallback: check A records for the device hostname
+                // Fallback: check A records for the device hostname directly
                 if (!ip) {
-                    const deviceHost = `eWeLink_${deviceId}.local`;
-                    ip = hostToIp.get(deviceHost);
+                    ip = hostToIp.get(`eWeLink_${deviceId}.local`);
                 }
-                if (ip && !this.deviceMap.has(deviceId)) {
-                    this.deviceMap.set(deviceId, { ip, ipOverride: false });
-                    if (this.debug) {
-                        this.log.debug('[LAN] Discovered %s at %s', deviceId, ip);
-                    }
-                }
-                else if (ip) {
-                    const info = this.deviceMap.get(deviceId);
-                    if (!info.ipOverride) {
-                        info.ip = ip;
-                    }
+                if (ip) {
+                    this.updateDeviceIp(deviceId, ip);
                 }
             }
-            // Also extract device IDs from TXT records (which include the id field)
-            if (record.type === 'TXT' && record.name.includes('_ewelink')) {
-                const txt = this.parseTxtData(record.data);
-                if (txt?.id) {
-                    // We may not have the IP from this record alone, but we know the device exists
-                    if (!this.deviceMap.has(txt.id)) {
-                        this.deviceMap.set(txt.id, { ipOverride: false });
-                    }
-                }
+        }
+        // Also try to extract IPs from A records matching the eWeLink_<id>.local pattern
+        for (const [hostname, ip] of hostToIp) {
+            const match = hostname.match(/^eWeLink_(\w+)\.local$/);
+            if (match?.[1]) {
+                this.updateDeviceIp(match[1], ip);
             }
         }
     }
+    /**
+     * Update a device's IP in the map (unless manually overridden).
+     */
+    updateDeviceIp(deviceId, ip) {
+        const existing = this.deviceMap.get(deviceId);
+        if (!existing) {
+            this.deviceMap.set(deviceId, { ip, ipOverride: false });
+            this.log.info('[LAN] Discovered %s at %s', deviceId, ip);
+        }
+        else if (!existing.ipOverride && existing.ip !== ip) {
+            const oldIp = existing.ip;
+            existing.ip = ip;
+            this.log.info('[LAN] Updated %s: %s → %s', deviceId, oldIp ?? 'none', ip);
+        }
+        else if (!existing.ipOverride && !existing.ip) {
+            existing.ip = ip;
+            this.log.info('[LAN] Resolved %s at %s', deviceId, ip);
+        }
+    }
     /**
      * Start listening for mDNS state broadcasts from eWeLink devices.
      *
-     * Creates a persistent mDNS listener that decrypts TXT record
-     * payloads and emits 'update' events on state changes.
+     * Creates a persistent mDNS listener that:
+     * 1. Extracts device IPs from A/SRV records (keeping IPs fresh)
+     * 2. Decrypts TXT record payloads and emits state change events
      */
     async startMonitor() {
-        this.mdns = multicastDns();
+        try {
+            this.mdns = multicastDns();
+        }
+        catch (err) {
+            this.log.error('[LAN] Failed to create mDNS socket for monitoring: %s. LAN control will not work.', err instanceof Error ? err.message : String(err));
+            return;
+        }
+        this.mdns.on('error', (err) => {
+            this.log.warn('[LAN] mDNS monitor error: %s', err.message);
+        });
         this.mdns.on('response', (response) => {
+            // Always process A/SRV/PTR records to keep IPs current
+            this.processResponseRecords(response);
+            // Process TXT records for state updates
             const allRecords = [
                 ...(response.answers ?? []),
                 ...(response.additionals ?? []),
@@ -149,9 +201,6 @@ export class EWeLinkLAN {
                 if (txt.iv === info.lastIV)
                     continue;
                 info.lastIV = txt.iv;
-                // Update IP if it changed
-                // response object doesn't directly carry the sender IP in multicast-dns,
-                // but SRV/A records in additionals might
                 // Concatenate encrypted data fragments
                 const data = [txt.data1, txt.data2, txt.data3, txt.data4]
                     .filter(Boolean)
@@ -186,23 +235,33 @@ export class EWeLinkLAN {
                 this.emitter.emit('update', { deviceid: deviceId, params });
             }
         });
-        this.log.info('LAN monitoring started.');
+        this.log.info('[LAN] Monitoring started.');
     }
     /**
      * Send an encrypted command to a device over the LAN.
-     * Retries up to 10 times on ECONNRESET.
+     *
+     * If the device IP is unknown, fires a one-shot mDNS query and waits
+     * up to 3 seconds for discovery before giving up. Retries up to 10
+     * times on ECONNRESET.
      */
     async sendUpdate(deviceId, params) {
         const info = this.deviceMap.get(deviceId);
-        if (!info?.ip || !info?.lanKey) {
-            this.log.warn('[LAN] Cannot send to %s: ip=%s lanKey=%s', deviceId, info?.ip ?? 'none', info?.lanKey ? 'set' : 'none');
+        if (!info?.lanKey) {
+            this.log.warn('[LAN] Cannot send to %s: no lanKey', deviceId);
+            return false;
+        }
+        // If we don't have an IP, try a quick mDNS re-query
+        if (!info.ip) {
+            this.log.info('[LAN] No IP for %s — sending mDNS query...', deviceId);
+            await this.reQueryDevice(deviceId);
+        }
+        if (!info.ip) {
+            this.log.warn('[LAN] Cannot send to %s: ip not discovered', deviceId);
             return false;
         }
         const { encryptedData, iv } = this.encryptData(params, info.lanKey);
         const url = `http://${info.ip}:${EWELINK_LAN_PORT}/zeroconf/switches`;
-        if (this.debug) {
-            this.log.debug('[LAN] Sending to %s → %s', deviceId, url);
-        }
+        this.log.info('[LAN] Sending to %s → %s', deviceId, url);
         const body = JSON.stringify({
             deviceid: deviceId,
             data: encryptedData,
@@ -260,6 +319,31 @@ export class EWeLinkLAN {
         this.emitter.removeAllListeners();
     }
     // -- Private helpers --------------------------------------------------
+    /**
+     * Fire a one-shot mDNS query to try to resolve a device's IP.
+     * Waits up to 3 seconds for a response.
+     */
+    async reQueryDevice(deviceId) {
+        const mdns = this.mdns;
+        if (!mdns)
+            return;
+        return new Promise((resolve) => {
+            const timer = setTimeout(() => {
+                resolve();
+            }, 3000);
+            const onResponse = (response) => {
+                this.processResponseRecords(response);
+                const info = this.deviceMap.get(deviceId);
+                if (info?.ip) {
+                    clearTimeout(timer);
+                    mdns.removeListener('response', onResponse);
+                    resolve();
+                }
+            };
+            mdns.on('response', onResponse);
+            mdns.query([{ name: MDNS_PTR_NAME, type: 'PTR' }]);
+        });
+    }
     /**
      * Send an HTTP POST using node:http.
      *

package/dist/position-tracker.js

@@ -66,11 +66,10 @@ export class PositionTracker {
      */
     startMovement(target) {
         const clamped = clamp(target, 0, 100);
-        // If unknown position, only allow calibration moves (0 or 100)
+        // If unknown position, calibrate down to 0% (the only limit-switch endpoint)
         if (this.state.phase === 'unknown') {
-            const dir = clamped <= 50 ? 'down' : 'up';
-            this.log(`Position unknown, starting calibration ${dir}`);
-            return this.startCalibration(dir);
+            this.log('Position unknown, starting calibration down to 0%');
+            return this.startCalibration('down');
         }
         // If calibrating, ignore new commands
         if (this.state.phase === 'calibrating') {
@@ -88,8 +87,9 @@ export class PositionTracker {
         const travelTimeSec = direction === 'up'
             ? this.config.travelTimeUpSec
             : this.config.travelTimeDownSec;
-        // Is this a full-travel calibration move? (target is an endpoint)
-        const isCalibration = clamped === 0 || clamped === 100;
+        // Only 0% is a true calibration move (physical limit switch at bottom).
+        // 100% is a timed stop — the top is defined by travel time, not a switch.
+        const isCalibration = clamped === 0;
         const durationMs = isCalibration
             ? (travelTimeSec + this.config.calibrationExtraSec) * 1000
             : (travel / 100) * travelTimeSec * 1000;

package/package.json

@@ -2,7 +2,7 @@
   "name": "homebridge-dihool-lifts",
   "displayName": "Homebridge DIHOOL Lifts",
   "type": "module",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "Homebridge plugin to control DIHOOL IPS-S2 scissor lifts via the eWeLink LAN protocol.",
   "author": "Aaron Lampros",
   "license": "MIT",

package/src/connection/ewelink-lan.ts

@@ -59,37 +59,67 @@ export class EWeLinkLAN {
       }
     }
 
-    // Create a temporary mDNS instance for discovery
-    const mdns = multicastDns();
+    // Create a temporary mDNS instance for initial discovery
+    let mdns: ReturnType<typeof multicastDns>;
+    try {
+      mdns = multicastDns();
+    } catch (err) {
+      this.log.warn(
+        '[LAN] Failed to create mDNS socket for discovery: %s',
+        err instanceof Error ? err.message : String(err),
+      );
+      return this.deviceMap;
+    }
 
     await new Promise<void>((resolve) => {
-      setTimeout(() => {
+      const cleanup = () => {
         mdns.removeAllListeners('response');
+        mdns.removeAllListeners('error');
         mdns.destroy();
         resolve();
-      }, 5000);
+      };
+
+      const timer = setTimeout(cleanup, 5000);
+
+      mdns.on('error', (err: Error) => {
+        this.log.warn('[LAN] mDNS discovery error: %s', err.message);
+        clearTimeout(timer);
+        cleanup();
+      });
 
       mdns.on('response', (response) => {
-        this.processDiscoveryResponse(response);
+        this.processResponseRecords(response);
       });
 
       // Query for eWeLink PTR records
       mdns.query([{ name: MDNS_PTR_NAME, type: 'PTR' }]);
     });
 
+    // Log what we found
+    const discovered = [...this.deviceMap.entries()]
+      .filter(([, info]) => info.ip)
+      .map(([id, info]) => `${id}@${info.ip}${info.ipOverride ? ' (manual)' : ''}`);
+    if (discovered.length > 0) {
+      this.log.info('[LAN] Discovered devices: %s', discovered.join(', '));
+    } else {
+      this.log.warn('[LAN] No device IPs discovered via mDNS. Devices with manual IP overrides may still work.');
+    }
+
     return this.deviceMap;
   }
 
   /**
-   * Parse a discovery response to extract device IDs and IPs.
+   * Process all record types from an mDNS response to extract device IPs
+   * and update the device map. Used by both initial discovery and the
+   * ongoing monitor.
    */
-  private processDiscoveryResponse(response: multicastDns.ResponsePacket): void {
+  private processResponseRecords(response: multicastDns.ResponsePacket): void {
     const allRecords = [
       ...(response.answers ?? []),
       ...(response.additionals ?? []),
     ];
 
-    // Collect SRV/A records to map hostnames to IPs
+    // Collect A records: hostname → IP
     const hostToIp = new Map<string, string>();
     for (const record of allRecords) {
       if (record.type === 'A') {
@@ -97,7 +127,16 @@ export class EWeLinkLAN {
       }
     }
 
-    // Look for PTR records pointing to eWeLink devices
+    // Collect SRV records: service name → target hostname
+    const srvTargets = new Map<string, string>();
+    for (const record of allRecords) {
+      if (record.type === 'SRV') {
+        const srvData = record.data as { target: string };
+        srvTargets.set(record.name, srvData.target);
+      }
+    }
+
+    // Process PTR records to find eWeLink devices
     for (const record of allRecords) {
       if (record.type === 'PTR' && record.name.includes('_ewelink')) {
         const ptr = record.data as string;
@@ -107,58 +146,77 @@ export class EWeLinkLAN {
 
         if (!deviceId) continue;
 
-        // Try to find the IP from SRV → A record chain
-        const srvRecord = allRecords.find(
-          (r) => r.type === 'SRV' && r.name === ptr,
-        );
+        // Resolve IP: PTR → SRV target → A record
         let ip: string | undefined;
-        if (srvRecord && srvRecord.type === 'SRV') {
-          const srvData = srvRecord.data as { target: string };
-          ip = hostToIp.get(srvData.target);
+        const srvTarget = srvTargets.get(ptr);
+        if (srvTarget) {
+          ip = hostToIp.get(srvTarget);
         }
-
-        // Fallback: check A records for the device hostname
+        // Fallback: check A records for the device hostname directly
         if (!ip) {
-          const deviceHost = `eWeLink_${deviceId}.local`;
-          ip = hostToIp.get(deviceHost);
+          ip = hostToIp.get(`eWeLink_${deviceId}.local`);
         }
 
-        if (ip && !this.deviceMap.has(deviceId)) {
-          this.deviceMap.set(deviceId, { ip, ipOverride: false });
-          if (this.debug) {
-            this.log.debug('[LAN] Discovered %s at %s', deviceId, ip);
-          }
-        } else if (ip) {
-          const info = this.deviceMap.get(deviceId)!;
-          if (!info.ipOverride) {
-            info.ip = ip;
-          }
+        if (ip) {
+          this.updateDeviceIp(deviceId, ip);
         }
       }
+    }
 
-      // Also extract device IDs from TXT records (which include the id field)
-      if (record.type === 'TXT' && record.name.includes('_ewelink')) {
-        const txt = this.parseTxtData(record.data);
-        if (txt?.id) {
-          // We may not have the IP from this record alone, but we know the device exists
-          if (!this.deviceMap.has(txt.id)) {
-            this.deviceMap.set(txt.id, { ipOverride: false });
-          }
-        }
+    // Also try to extract IPs from A records matching the eWeLink_<id>.local pattern
+    for (const [hostname, ip] of hostToIp) {
+      const match = hostname.match(/^eWeLink_(\w+)\.local$/);
+      if (match?.[1]) {
+        this.updateDeviceIp(match[1], ip);
       }
     }
   }
 
+  /**
+   * Update a device's IP in the map (unless manually overridden).
+   */
+  private updateDeviceIp(deviceId: string, ip: string): void {
+    const existing = this.deviceMap.get(deviceId);
+    if (!existing) {
+      this.deviceMap.set(deviceId, { ip, ipOverride: false });
+      this.log.info('[LAN] Discovered %s at %s', deviceId, ip);
+    } else if (!existing.ipOverride && existing.ip !== ip) {
+      const oldIp = existing.ip;
+      existing.ip = ip;
+      this.log.info('[LAN] Updated %s: %s → %s', deviceId, oldIp ?? 'none', ip);
+    } else if (!existing.ipOverride && !existing.ip) {
+      existing.ip = ip;
+      this.log.info('[LAN] Resolved %s at %s', deviceId, ip);
+    }
+  }
+
   /**
    * Start listening for mDNS state broadcasts from eWeLink devices.
    *
-   * Creates a persistent mDNS listener that decrypts TXT record
-   * payloads and emits 'update' events on state changes.
+   * Creates a persistent mDNS listener that:
+   * 1. Extracts device IPs from A/SRV records (keeping IPs fresh)
+   * 2. Decrypts TXT record payloads and emits state change events
    */
   async startMonitor(): Promise<void> {
-    this.mdns = multicastDns();
+    try {
+      this.mdns = multicastDns();
+    } catch (err) {
+      this.log.error(
+        '[LAN] Failed to create mDNS socket for monitoring: %s. LAN control will not work.',
+        err instanceof Error ? err.message : String(err),
+      );
+      return;
+    }
+
+    this.mdns.on('error', (err: Error) => {
+      this.log.warn('[LAN] mDNS monitor error: %s', err.message);
+    });
 
     this.mdns.on('response', (response) => {
+      // Always process A/SRV/PTR records to keep IPs current
+      this.processResponseRecords(response);
+
+      // Process TXT records for state updates
       const allRecords = [
         ...(response.answers ?? []),
         ...(response.additionals ?? []),
@@ -179,10 +237,6 @@ export class EWeLinkLAN {
         if (txt.iv === info.lastIV) continue;
         info.lastIV = txt.iv;
 
-        // Update IP if it changed
-        // response object doesn't directly carry the sender IP in multicast-dns,
-        // but SRV/A records in additionals might
-
         // Concatenate encrypted data fragments
         const data = [txt.data1, txt.data2, txt.data3, txt.data4]
           .filter(Boolean)
@@ -226,26 +280,39 @@ export class EWeLinkLAN {
       }
     });
 
-    this.log.info('LAN monitoring started.');
+    this.log.info('[LAN] Monitoring started.');
   }
 
   /**
    * Send an encrypted command to a device over the LAN.
-   * Retries up to 10 times on ECONNRESET.
+   *
+   * If the device IP is unknown, fires a one-shot mDNS query and waits
+   * up to 3 seconds for discovery before giving up. Retries up to 10
+   * times on ECONNRESET.
    */
   async sendUpdate(deviceId: string, params: DeviceParams): Promise<boolean> {
     const info = this.deviceMap.get(deviceId);
-    if (!info?.ip || !info?.lanKey) {
-      this.log.warn('[LAN] Cannot send to %s: ip=%s lanKey=%s', deviceId, info?.ip ?? 'none', info?.lanKey ? 'set' : 'none');
+    if (!info?.lanKey) {
+      this.log.warn('[LAN] Cannot send to %s: no lanKey', deviceId);
+      return false;
+    }
+
+    // If we don't have an IP, try a quick mDNS re-query
+    if (!info.ip) {
+      this.log.info('[LAN] No IP for %s — sending mDNS query...', deviceId);
+      await this.reQueryDevice(deviceId);
+    }
+
+    if (!info.ip) {
+      this.log.warn('[LAN] Cannot send to %s: ip not discovered', deviceId);
       return false;
     }
 
     const { encryptedData, iv } = this.encryptData(params, info.lanKey);
     const url = `http://${info.ip}:${EWELINK_LAN_PORT}/zeroconf/switches`;
 
-    if (this.debug) {
-      this.log.debug('[LAN] Sending to %s → %s', deviceId, url);
-    }
+    this.log.info('[LAN] Sending to %s → %s', deviceId, url);
+
     const body = JSON.stringify({
       deviceid: deviceId,
       data: encryptedData,
@@ -316,6 +383,34 @@ export class EWeLinkLAN {
 
   // -- Private helpers --------------------------------------------------
 
+  /**
+   * Fire a one-shot mDNS query to try to resolve a device's IP.
+   * Waits up to 3 seconds for a response.
+   */
+  private async reQueryDevice(deviceId: string): Promise<void> {
+    const mdns = this.mdns;
+    if (!mdns) return;
+
+    return new Promise<void>((resolve) => {
+      const timer = setTimeout(() => {
+        resolve();
+      }, 3000);
+
+      const onResponse = (response: multicastDns.ResponsePacket) => {
+        this.processResponseRecords(response);
+        const info = this.deviceMap.get(deviceId);
+        if (info?.ip) {
+          clearTimeout(timer);
+          mdns.removeListener('response', onResponse);
+          resolve();
+        }
+      };
+
+      mdns.on('response', onResponse);
+      mdns.query([{ name: MDNS_PTR_NAME, type: 'PTR' }]);
+    });
+  }
+
   /**
    * Send an HTTP POST using node:http.
    *

package/src/position-tracker.test.ts

@@ -80,26 +80,27 @@ describe('PositionTracker', () => {
       expect(plan!.isCalibration).toBe(true);
     });
 
-    it('startMovement(100) from unknown state returns calibration plan going up', () => {
+    it('startMovement(100) from unknown state calibrates down first (not up)', () => {
       const { tracker } = createTracker(tempDir);
       const plan = tracker.startMovement(100);
       expect(plan).not.toBeNull();
-      expect(plan!.direction).toBe('up');
+      // Always calibrates down — 0% is the only limit-switch endpoint
+      expect(plan!.direction).toBe('down');
       expect(plan!.isCalibration).toBe(true);
     });
 
-    it('startMovement(50) from unknown defaults to calibration down (<= 50)', () => {
+    it('startMovement(50) from unknown calibrates down', () => {
       const { tracker } = createTracker(tempDir);
       const plan = tracker.startMovement(50);
       expect(plan).not.toBeNull();
       expect(plan!.direction).toBe('down');
     });
 
-    it('startMovement(51) from unknown defaults to calibration up (> 50)', () => {
+    it('startMovement(51) from unknown calibrates down', () => {
       const { tracker } = createTracker(tempDir);
       const plan = tracker.startMovement(51);
       expect(plan).not.toBeNull();
-      expect(plan!.direction).toBe('up');
+      expect(plan!.direction).toBe('down');
     });
 
     it('calibration plan duration equals (travelTime + calibrationExtra) * 1000', () => {
@@ -121,9 +122,10 @@ describe('PositionTracker', () => {
       expect(tracker.getCurrentPosition()).toBe(0);
     });
 
-    it('completeMovement() after calibration up sets position to 100 and phase to stopped', () => {
+    it('completeMovement() after startCalibration(up) sets position to 100', () => {
       const { tracker } = createTracker(tempDir);
-      tracker.startMovement(100);
+      // Use startCalibration directly — startMovement always calibrates down
+      tracker.startCalibration('up');
       tracker.completeMovement();
       expect(tracker.getState().phase).toBe('stopped');
       expect(tracker.getCurrentPosition()).toBe(100);
@@ -142,11 +144,12 @@ describe('PositionTracker', () => {
   // ========================================================================
 
   describe('basic movement', () => {
-    it('from position 0, startMovement(100) returns up plan with calibration duration and isCalibration=true', () => {
+    it('from position 0, startMovement(100) returns up plan with full travel duration (not calibration)', () => {
       const { tracker } = createTracker(tempDir);
       tracker.markCalibrated(0);
       const plan = tracker.startMovement(100);
-      expect(plan).toEqual({ direction: 'up', durationMs: 12000, isCalibration: true });
+      // 100% is NOT calibration — only 0% has a limit switch
+      expect(plan).toEqual({ direction: 'up', durationMs: 10000, isCalibration: false });
     });
 
     it('from position 0, startMovement(50) returns up plan with half duration and isCalibration=false', () => {
@@ -163,7 +166,7 @@ describe('PositionTracker', () => {
       expect(plan).toEqual({ direction: 'down', durationMs: 5000, isCalibration: false });
     });
 
-    it('from position 100, startMovement(0) returns down plan with isCalibration=true', () => {
+    it('from position 100, startMovement(0) returns down plan with calibration (limit switch at bottom)', () => {
       const { tracker } = createTracker(tempDir);
       tracker.markCalibrated(100);
       const plan = tracker.startMovement(0);
@@ -248,14 +251,15 @@ describe('PositionTracker', () => {
   // ========================================================================
 
   describe('asymmetric travel times', () => {
-    it('movement 0→100 uses up travel time plus calibration extra (12s)', () => {
+    it('movement 0→100 uses full up travel time (no calibration extra)', () => {
       const { tracker } = createTracker(tempDir, {
         travelTimeUpSec: 10,
         travelTimeDownSec: 5,
       });
       tracker.markCalibrated(0);
       const plan = tracker.startMovement(100);
-      expect(plan!.durationMs).toBe(12000);
+      // 100% is timed, not calibration — no extra time
+      expect(plan!.durationMs).toBe(10000);
     });
 
     it('movement 100→0 uses down travel time plus calibration extra (7s)', () => {
@@ -343,7 +347,7 @@ describe('PositionTracker', () => {
       expect(tracker.getState().phase).toBe('unknown');
     });
 
-    it('after interrupting calibration, next startMovement triggers fresh calibration', () => {
+    it('after interrupting calibration, next startMovement triggers fresh calibration down', () => {
       const { tracker, clock } = createTracker(tempDir);
       // Start calibration down
       tracker.startMovement(0);
@@ -353,11 +357,11 @@ describe('PositionTracker', () => {
       tracker.snapshotPosition();
       expect(tracker.getState().phase).toBe('unknown');
 
-      // Next move should trigger a new calibration
+      // Next move should trigger a new calibration (always down — only limit switch)
       const plan = tracker.startMovement(100);
       expect(plan).not.toBeNull();
       expect(plan!.isCalibration).toBe(true);
-      expect(plan!.direction).toBe('up');
+      expect(plan!.direction).toBe('down');
       expect(tracker.getState().phase).toBe('calibrating');
     });
   });
@@ -500,7 +504,7 @@ describe('PositionTracker', () => {
       const plan = tracker.startMovement(150);
       expect(plan).not.toBeNull();
       expect(plan!.direction).toBe('up');
-      expect(plan!.isCalibration).toBe(true);
+      expect(plan!.isCalibration).toBe(false); // 100% is timed, not calibration
     });
 
     it('position never goes below 0 during interpolation', () => {
@@ -597,7 +601,7 @@ describe('PositionTracker', () => {
     it('logs calibration start from unknown', () => {
       const { tracker, logs } = createTracker(tempDir);
       tracker.startMovement(0);
-      expect(logs.some((m) => m.includes('Position unknown') && m.includes('calibration down'))).toBe(true);
+      expect(logs.some((m) => m.includes('Position unknown') && m.includes('calibration down to 0%'))).toBe(true);
     });
 
     it('logs when ignoring command during calibration', () => {

package/src/position-tracker.ts

@@ -167,11 +167,10 @@ export class PositionTracker {
   startMovement(target: number): MovementPlan | null {
     const clamped = clamp(target, 0, 100);
 
-    // If unknown position, only allow calibration moves (0 or 100)
+    // If unknown position, calibrate down to 0% (the only limit-switch endpoint)
     if (this.state.phase === 'unknown') {
-      const dir: 'up' | 'down' = clamped <= 50 ? 'down' : 'up';
-      this.log(`Position unknown, starting calibration ${dir}`);
-      return this.startCalibration(dir);
+      this.log('Position unknown, starting calibration down to 0%');
+      return this.startCalibration('down');
     }
 
     // If calibrating, ignore new commands
@@ -194,8 +193,9 @@ export class PositionTracker {
       ? this.config.travelTimeUpSec
       : this.config.travelTimeDownSec;
 
-    // Is this a full-travel calibration move? (target is an endpoint)
-    const isCalibration = clamped === 0 || clamped === 100;
+    // Only 0% is a true calibration move (physical limit switch at bottom).
+    // 100% is a timed stop — the top is defined by travel time, not a switch.
+    const isCalibration = clamped === 0;
     const durationMs = isCalibration
       ? (travelTimeSec + this.config.calibrationExtraSec) * 1000
       : (travel / 100) * travelTimeSec * 1000;