@homebridge-plugins/homebridge-eufy-security 4.6.0-beta.28 → 4.6.0-beta.29

package/.claude/skills/new-device-support/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: new-device-support
-description: Full workflow to add support for a new Eufy Security device type across eufy-security-client and homebridge-eufy-security. Covers exploration, implementation, build verification, and git/PR creation.
+description: Full workflow to add support for a new Eufy Security device type (cameras, locks, sensors, and other devices) across eufy-security-client and homebridge-eufy-security. Covers exploration, implementation, build verification, and git/PR creation.
 ---
 
 # Add New Eufy Security Device Support
@@ -11,13 +11,28 @@ Use `$ARGUMENTS` for the issue URL or device details.
 
 ## Phase 1 — Gather Information
 
-1. **Fetch the GitHub issue** (if URL provided) to extract: device name, model number (e.g. T86P2), device type number, raw properties JSON, firmware version, and any reference PRs.
-2. **Run the property mapping script**: Save the raw properties JSON to a temp file and run:
+1. **Fetch the GitHub issue** (if URL provided) to extract: device name, model number (e.g. T86P2), device type number, raw properties JSON, firmware version, and any reference PRs. Note: users on recent eufy-security-client versions see a structured "unknown device" debug message that includes raw properties in a format directly usable with the mapping script.
+2. **Check for existing upstream work** — before starting, search for PRs that already add this device:
    ```bash
-   node homebridge-eufy-security/.claude/skills/new-device-support/map-properties.mjs /tmp/<device>-raw-props.json
+   gh pr list --repo bropat/eufy-security-client --state all --search "<model> OR <device-type-number>" --limit 10
    ```
-   This maps each raw `param_type` to its `CommandType`/`ParamType` enum name, matching property constants, and which existing device types use them. It also outputs a suggested DeviceProperties block. Use this output to identify the closest existing device and plan the property mapping.
-3. **Ask the user** two questions:
+   If a PR exists: review its diff to see what's already implemented, what's missing (e.g. missing GenericTypeProperty label, incomplete DeviceCommands), and whether it's merged, open, or stale. If merged, the device may only need homebridge-eufy-security side changes. If open but incomplete, coordinate with the PR author or build on their work. If the PR has review comments, check for flagged issues.
+3. **Pre-flight checks** — before proceeding, confirm you have:
+   - Device type number (required — cannot proceed without it)
+   - Raw device properties JSON (required for accurate property mapping — if missing, ask the user to enable debug logging and re-export diagnostics)
+   - Model number / display name (needed for enum naming and documentation)
+   - If the device type number is completely unknown (not in any existing code), investigate: check the model number prefix pattern, look at raw properties to infer capabilities (camera properties? lock properties? sensor properties?), and check Eufy's product pages for the model.
+4. **Run the pre-implementation audit**: Before writing any code, run the audit script to see what already exists:
+   ```bash
+   node homebridge-eufy-security/.claude/skills/new-device-support/check-device.mjs <type-number> [--pr-search <model>]
+   ```
+   This checks all 6 registration points in types.ts, classification methods in device.ts, device-images.js, finds the closest existing devices by property overlap, and searches upstream PRs. Use its output to understand the starting point.
+5. **Run the property mapping script**: Save the raw properties JSON to a temp file and run:
+   ```bash
+   node homebridge-eufy-security/.claude/skills/new-device-support/map-properties.mjs /tmp/<device>-raw-props.json --closest
+   ```
+   This maps each raw `param_type` to its `CommandType`/`ParamType` enum name, matching property constants, and which existing device types use them. It also outputs a suggested DeviceProperties block. The `--closest` flag ranks existing devices by property overlap to identify the best base device.
+6. **Ask the user** two questions:
    - Image naming convention (check if images already exist or need renaming)
    - Enum name for the DeviceType (e.g. `CAMERA_4G_S330`)
 
@@ -25,12 +40,32 @@ Use `$ARGUMENTS` for the issue URL or device details.
 
 Create a detailed plan covering all files that need changes. The plan must be based on the actual raw device properties — never guess which properties a device supports.
 
+### Determine device category
+
+Before planning file changes, identify the device category — this determines which classification methods and accessory classes apply:
+
+- **Camera** (including doorbells, floodlights, indoor cameras, solo cameras, 4G cameras): uses `CameraAccessory` in the plugin. Classification methods: `isCamera()`, and optionally `isDoorbell()`, `isFloodLight()`, `isIndoorCamera()`, `isPanAndTiltCamera()`, `isOutdoorPanAndTiltCamera()`, `isSoloCameras()`, etc. Note: `isSoloCameras()` is a composite method that includes outdoor PTZ, wall light cams, and other standalone camera types.
+- **WallLightCam**: uses `CameraAccessory`. Classification: `isWallLightCam()`. This category is heavily referenced in `station.ts` (50+ references) for livestream, talkback, property handling, and command routing — expect substantial `station.ts` changes.
+- **GarageCamera**: uses `CameraAccessory`. Classification: `isGarageCamera()`. Has dedicated property variants (e.g. `DeviceWatermarkGarageCameraProperty`, `DeviceMotionDetectionSensitivityGarageCameraProperty`). Also has `isGarageCameraBySn()` for serial number matching.
+- **Lock** (BLE, WiFi, WiFi Video variants): uses `LockAccessory`. Classification methods: `isLock()`, `isLockWifi()`, `isLockBle()`, `isLockWifiVideo()`, etc. Locks have many specialized type guard methods (e.g. `isLockWifiT8531()`, `isLockWifiR10()`) — check existing patterns carefully. Locks may require changes in **three additional layers** beyond this skill's primary scope — flag these to the user:
+  - `src/mqtt/` — MQTT protocol for lock communication
+  - `src/p2p/session.ts` — P2P session initialization uses `Device.isLockWifi()` and `Device.isLockWifiNoFinger()` for lock sequence generation
+  - `src/http/station.ts` — lock-specific routing at station level
+- **Sensor** (entry sensor, motion sensor, PIR sensor): uses `EntrySensorAccessory` or `MotionSensorAccessory`. Classification: `isSensor()`, `isEntrySensor()`, `isMotionSensor()`. Note: `isSensor()` is static-only — no public instance method exists.
+- **SmartDrop**: uses `SmartDropAccessory`. Classification: `isSmartDrop()`. Also has `isSmartDropBySn()` for serial number matching.
+- **SmartSafe**: no HomeKit accessory currently. Classification: `isSmartSafe()`.
+- **Tracker/SmartTrack**: no HomeKit accessory currently. Classification: `isSmartTrack()`.
+- **Keypad**: no HomeKit accessory currently. Classification: `isKeyPad()`.
+- **WaterFreezeSensor**: no HomeKit accessory currently. Classification: check for `WATER_FREEZE_SENSOR_*` in DeviceType enum.
+- **Siren**: no HomeKit accessory currently. Classification: check for `SIREN_SENSOR_*` in DeviceType enum.
+- **New category**: if the device doesn't fit any existing category, a new accessory class is needed in `src/accessories/`, a new classification method, and a new `if` block in `register_device()`. Flag this to the user — it's a significantly larger task.
+
 ### Files to modify in eufy-security-client
 
 #### `src/http/types.ts` — 6 locations:
 
 1. **DeviceType enum**: Add `ENUM_NAME = <number>, //<model>` in numeric order
-2. **GenericTypeProperty states**: Add `<number>: "<Display Name> (<Model>)"` in numeric order
+2. **GenericTypeProperty `states` field**: Add `<number>: "<Display Name> (<Model>)"` inside the `states` object in numeric order. **WARNING**: This is one of the most commonly forgotten steps. Missing this label causes the device to display as a raw number in downstream UIs (see upstream PR #828 where 5 device types had missing labels).
 3. **DeviceProperties**: Add `[DeviceType.ENUM_NAME]` block. Always starts with `...GenericDeviceProperties`. Map each raw param_type to its corresponding `PropertyName.*` property constant. Base on the closest existing device but only include properties that match the raw data.
 4. **StationProperties**: Add `[DeviceType.ENUM_NAME]` block if device can act as its own station (solo cameras, integrated devices). Use `...BaseStationProperties` plus station-specific properties.
 5. **DeviceCommands**: Add `[DeviceType.ENUM_NAME]` array. Commands depend on device capabilities (livestream, talkback, pan/tilt, download, snooze, preset positions, calibrate, alarm).
@@ -38,14 +73,24 @@ Create a detailed plan covering all files that need changes. The plan must be ba
 
 #### `src/http/device.ts` — Classification methods:
 
-Add the new device type to all applicable static classification methods. Common ones:
+Add the new device type to all applicable static classification methods. There are two kinds:
+
+**Broad classification methods** (add device to these as applicable):
 - `isCamera()` — if it's a camera/doorbell/floodlight
-- `hasBattery()` — if battery-powered
+- `hasBattery()` — if battery-powered (critical — omitting this means no battery service in HomeKit)
 - `isPanAndTiltCamera()` — if has PTZ
-- `isOutdoorPanAndTiltCamera()` — if outdoor PTZ (this feeds into `isSoloCameras()`)
-- `isFloodLight()`, `isIndoorCamera()`, `isDoorbell()`, etc. — as applicable
+- `isOutdoorPanAndTiltCamera()` — if outdoor PTZ (included by `isSoloCameras()`)
+- `isSoloCameras()` — composite method aggregating solo/standalone camera types
+- `isFloodLight()`, `isIndoorCamera()`, `isDoorbell()`, `isWallLightCam()`, `isGarageCamera()` — as applicable
+- `isLock()`, `isLockWifi()`, `isLockBle()`, `isLockWifiNoFinger()` — if it's a lock variant
+- `isSensor()`, `isEntrySensor()`, `isMotionSensor()` — if it's a sensor
+- `isSmartDrop()`, `isSmartSafe()`, `isSmartTrack()`, `isKeyPad()` — as applicable
+
+Note: Not all broad methods have public instance counterparts (e.g. `isSensor()` is static-only). Don't create instance methods where none exist for the pattern.
+
+**`isSupported()` check**: After adding to `DeviceProperties` map, `Device.isSupported(type)` automatically returns `true` (it checks `DeviceProperties[type] !== undefined`). This is the foundation of device registration — if `DeviceProperties` entry is missing, the device is silently unsupported regardless of all other registrations.
 
-Add a **new static type guard method** and matching **instance method**:
+Add a **new dedicated type guard method** (static + instance pair):
 ```typescript
 static isNewDevice(type: number): boolean {
   //<Model>
@@ -57,9 +102,12 @@ public isNewDevice(): boolean {
 }
 ```
 
-Update serial number checks if applicable:
+Update serial number checks if applicable (all are static-only, no instance methods):
 - `isIntegratedDeviceBySn()` — add `sn.startsWith("<model>")` if the device is integrated/standalone
 - `isSoloCameraBySn()` — add `sn.startsWith("<model>")` if it's a solo camera
+- `isSmartDropBySn()` — add if it's a SmartDrop variant
+- `isGarageCameraBySn()` — add if it's a garage camera variant
+- `isFloodlightBySn()` — add if it's a floodlight variant
 
 #### `src/http/station.ts`:
 
@@ -67,7 +115,7 @@ Update serial number checks if applicable:
 
 #### `src/push/service.ts`:
 
-- If the device is 4G LTE or needs special push notification handling, expand the normalization block (~line 768) to include the new type guard.
+- If the device is 4G LTE or needs special push notification handling, expand the normalization block (line 768) to include the new type guard.
 
 #### `docs/supported_devices.md`:
 
@@ -79,6 +127,10 @@ Use `:wrench:` for initial support.
 
 ### Files to modify in homebridge-eufy-security
 
+#### `src/platform.ts` — `register_device()`:
+
+Verify the new device type is handled by `register_device()`. This method uses independent `if` blocks (not `else if`) to map device types to accessory classes. If the device is a camera, it falls through to the camera path. If it's a lock, sensor, or SmartDrop, it hits those specific checks. If it's a new category that doesn't match any existing check, the device won't get an accessory — flag this to the user.
+
 #### `homebridge-ui/public/utils/device-images.js`:
 
 Add a case in the `getImage()` switch:
@@ -95,11 +147,33 @@ case <type_number>: return '<image_large>.png';
 
 Execute the plan. Key implementation notes:
 
-- **Property mapping**: Use the output from `map-properties.mjs` (Phase 1) as the primary guide. When multiple property constants match the same `param_type` (e.g. `DeviceWatermarkProperty` vs `DeviceWatermarkSoloWiredDoorbellProperty`), pick the variant used by the closest existing device. Check the "Used by DeviceTypes" column in the script output.
+- **Property mapping**: Use the output from `map-properties.mjs` (Phase 1) as the primary guide. Many property constants have large variant families (e.g. `DeviceMotionDetection*` has 40+ variants, `DeviceFloodlightLight*` has 12+, `DeviceVideoRecordingQuality*` has 11+). When multiple constants match the same `param_type`, pick the variant used by the closest existing device — check the "Used by DeviceTypes" column in the script output and the `--closest` flag results.
 - **Companion custom properties**: Some properties have required companions with `custom_*` keys that never appear in raw device data (they're populated at runtime). The script detects these and marks them with `⚠ companion`. Always include them — omitting a companion breaks functionality silently. Key pairs: `DeviceRTSPStream` → `DeviceRTSPStreamUrl`, `DeviceWifiRSSI` → `DeviceWifiSignalLevel`, `DeviceCellularRSSI` → `DeviceCellularSignalLevel`.
 - **Insert in order**: When adding to enums, switch statements, or `if` chains, maintain numeric ordering by device type number.
 - **Audio recording property**: Different device families use different audio recording property constants (e.g. `DeviceAudioRecordingProperty`, `DeviceAudioRecordingStarlight4gLTEProperty`). Match the closest existing device.
 
+### Registration verification checklist
+
+After implementing all changes, run the post-implementation verification script:
+```bash
+node homebridge-eufy-security/.claude/skills/new-device-support/verify-device.mjs <ENUM_NAME>
+```
+This automatically checks all required registration points and reports PASS/FAIL:
+
+1. `DeviceType` enum definition
+2. `GenericTypeProperty` states
+3. `DeviceProperties` map
+4. `DeviceCommands` map
+5. `StationProperties` map (if device acts as its own station — reported as WARN if missing)
+6. `StationCommands` map (if device has station properties — reported as WARN if missing)
+7. Dedicated type guard method (static + instance) in device.ts
+8. Broad classification methods (isCamera, isLock, etc.) in device.ts
+9. `docs/supported_devices.md` entry (reported as WARN if missing)
+10. `*BySn` serial number methods (reported as WARN if missing — not all devices need these)
+11. device-images.js case in homebridge-eufy-security
+
+The script exits with code 1 if any required checks fail. A device type that is defined in the enum but missing from DeviceProperties will silently fall back to GenericDeviceProperties with only ~3 basic properties (name, model, serial). This is the most common implementation error — see upstream issue #853 where LOCK_85V0 was added to the enum but never registered in the lookup maps.
+
 ## Phase 4 — Build & Lint Verification
 
 Run build and lint for both repos. Note: eufy-security-client lint may fail due to a pre-existing `jiti` library issue unrelated to our changes — the TypeScript build succeeding is sufficient validation.
@@ -126,6 +200,12 @@ Follow CLAUDE.md Git Workflow for commit messages, branch naming, and PR body fo
 
 1. Branch from current beta: `git checkout -b feat/<device-slug>`
 2. Stage: `homebridge-ui/public/utils/device-images.js` + any added image
+3. PR to current beta branch:
+   ```bash
+   gh pr create --base beta-<current-version> \
+     --title "feat: add <Device Name> (<Model>) image" \
+     --body-file /tmp/pr-body-<branch>.md
+   ```
 
 ### Cross-referencing
 

package/.claude/skills/new-device-support/check-device.mjs

@@ -0,0 +1,363 @@
+#!/usr/bin/env node
+/**
+ * check-device.mjs
+ *
+ * Pre-implementation audit for a new device type. Checks what already exists
+ * in the codebase and what's missing before starting work.
+ *
+ * Usage:
+ *   node check-device.mjs <device-type-number> [--pr-search <model>]
+ *
+ * Example:
+ *   node check-device.mjs 105
+ *   node check-device.mjs 203 --pr-search T85V0
+ *
+ * Output: status report showing what exists, what's missing, closest device,
+ * and upstream PR search results.
+ */
+
+import { readFileSync, existsSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+import { execSync } from "child_process";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+const CLIENT_ROOT = join(__dirname, "..", "..", "..", "..", "eufy-security-client");
+const HB_ROOT = join(__dirname, "..", "..", "..");
+const TYPES_HTTP = join(CLIENT_ROOT, "src", "http", "types.ts");
+const DEVICE_TS = join(CLIENT_ROOT, "src", "http", "device.ts");
+const STATION_TS = join(CLIENT_ROOT, "src", "http", "station.ts");
+const PUSH_SERVICE = join(CLIENT_ROOT, "src", "push", "service.ts");
+const DEVICE_IMAGES = join(HB_ROOT, "homebridge-ui", "public", "utils", "device-images.js");
+
+const typeNumber = parseInt(process.argv[2]);
+if (isNaN(typeNumber)) {
+  console.error("Usage: check-device.mjs <device-type-number> [--pr-search <model>]");
+  console.error("Example: check-device.mjs 105");
+  process.exit(1);
+}
+
+let prSearchTerm = null;
+const prIdx = process.argv.indexOf("--pr-search");
+if (prIdx !== -1 && process.argv[prIdx + 1]) {
+  prSearchTerm = process.argv[prIdx + 1];
+}
+
+const httpSource = readFileSync(TYPES_HTTP, "utf-8");
+const deviceSource = readFileSync(DEVICE_TS, "utf-8");
+
+// ── Check 1: DeviceType enum ───────────────────────────────────────────────
+
+function checkDeviceTypeEnum(source, typeNum) {
+  const re = new RegExp(`^\\s*(\\w+)\\s*=\\s*${typeNum}\\s*[,/]`, "m");
+  const match = source.match(re);
+  return match ? match[1] : null;
+}
+
+const enumName = checkDeviceTypeEnum(httpSource, typeNumber);
+
+// ── Check 2: GenericTypeProperty states ─────────────────────────────────────
+
+function checkGenericTypePropertyStates(source, typeNum) {
+  const gtpMatch = source.match(/export\s+const\s+GenericTypeProperty[\s\S]*?states:\s*\{([\s\S]*?)\}/);
+  if (!gtpMatch) return null;
+  const statesBody = gtpMatch[1];
+  const entryRe = new RegExp(`${typeNum}:\\s*"([^"]+)"`);
+  const match = statesBody.match(entryRe);
+  return match ? match[1] : null;
+}
+
+const gtpLabel = checkGenericTypePropertyStates(httpSource, typeNumber);
+
+// ── Check 3: DeviceProperties ──────────────────────────────────────────────
+
+function checkLookupMap(source, mapName, enumN) {
+  if (!enumN) return false;
+  const dpStart = source.indexOf(`export const ${mapName}`);
+  if (dpStart === -1) return false;
+  // Find next export const to bound the search
+  const nextExport = source.indexOf("export const ", dpStart + 20);
+  const section = source.slice(dpStart, nextExport === -1 ? undefined : nextExport);
+  return section.includes(`[DeviceType.${enumN}]`);
+}
+
+const inDeviceProperties = checkLookupMap(httpSource, "DeviceProperties", enumName);
+const inStationProperties = checkLookupMap(httpSource, "StationProperties", enumName);
+const inDeviceCommands = checkLookupMap(httpSource, "DeviceCommands", enumName);
+const inStationCommands = checkLookupMap(httpSource, "StationCommands", enumName);
+
+// ── Check 4: Classification methods in device.ts ───────────────────────────
+
+function findClassificationMethods(source, enumN) {
+  if (!enumN) return { inMethods: [], hasTypeGuard: false, hasInstanceMethod: false };
+
+  const inMethods = [];
+  // Find all static isXxx() methods and check if they reference this enum
+  const methodRegex = /static\s+(is\w+)\s*\(\s*type:\s*number\s*\)[\s\S]*?\n\s*\}/g;
+  let m;
+  while ((m = methodRegex.exec(source)) !== null) {
+    const methodName = m[1];
+    const methodBody = m[0];
+    if (methodBody.includes(`DeviceType.${enumN}`)) {
+      inMethods.push(methodName);
+    }
+  }
+
+  // Check for dedicated type guard (single-enum return)
+  const hasTypeGuard = inMethods.some((name) => {
+    const singleCheck = new RegExp(`static\\s+${name}\\s*\\(\\s*type:\\s*number\\s*\\)[^}]*return\\s+DeviceType\\.${enumN}\\s*==\\s*type`, "s");
+    return singleCheck.test(source);
+  });
+
+  // If type guard exists, instance method likely does too
+  const hasInstanceMethod = hasTypeGuard;
+
+  return { inMethods, hasTypeGuard, hasInstanceMethod };
+}
+
+const classInfo = findClassificationMethods(deviceSource, enumName);
+
+// ── Check 5: device-images.js ──────────────────────────────────────────────
+
+function checkDeviceImages(typeNum) {
+  if (!existsSync(DEVICE_IMAGES)) return null;
+  const source = readFileSync(DEVICE_IMAGES, "utf-8");
+  const re = new RegExp(`case\\s+${typeNum}:\\s*return\\s+'([^']+)'`);
+  const match = source.match(re);
+  return match ? match[1] : null;
+}
+
+const imageName = checkDeviceImages(typeNumber);
+
+// ── Check 6: station.ts integration ─────────────────────────────────────────
+
+function checkStationIntegration(enumN) {
+  if (!enumN || !existsSync(STATION_TS)) return { referenced: false, methods: [] };
+  const source = readFileSync(STATION_TS, "utf-8");
+  const referenced = source.includes(`DeviceType.${enumN}`);
+  // Also check via classification methods
+  const methods = [];
+  const methodRefs = source.match(/Device\.(is\w+)\(/g);
+  if (methodRefs) {
+    const uniqueMethods = [...new Set(methodRefs.map((m) => m.match(/Device\.(is\w+)/)[1]))];
+    for (const method of uniqueMethods) {
+      const re = new RegExp(`static\\s+${method}\\s*\\(\\s*type:\\s*number\\s*\\)[\\s\\S]*?\\n\\s*\\}`, "g");
+      const match = deviceSource.match(re);
+      if (match && match[0].includes(`DeviceType.${enumN}`)) {
+        methods.push(method);
+      }
+    }
+  }
+  return { referenced, methods };
+}
+
+const stationInfo = checkStationIntegration(enumName);
+
+// ── Check 6b: push/service.ts normalization ─────────────────────────────────
+
+function checkPushService(enumN) {
+  if (!enumN || !existsSync(PUSH_SERVICE)) return false;
+  const source = readFileSync(PUSH_SERVICE, "utf-8");
+  return source.includes(`DeviceType.${enumN}`);
+}
+
+const inPushService = checkPushService(enumName);
+
+// ── Check 7: Find closest device by property overlap ───────────────────────
+
+function findClosestDevice(source, enumN) {
+  if (!enumN || !inDeviceProperties) return null;
+
+  // Parse DeviceProperties section
+  const dpStart = source.indexOf("export const DeviceProperties");
+  const dpEnd = source.indexOf("export const StationProperties");
+  if (dpStart === -1) return null;
+  const dpSection = source.slice(dpStart, dpEnd === -1 ? undefined : dpEnd);
+
+  // Extract property sets for each device
+  const deviceProps = new Map();
+  const blockRegex = /\[DeviceType\.(\w+)\]\s*:\s*\{([\s\S]*?)\}/g;
+  let m;
+  while ((m = blockRegex.exec(dpSection)) !== null) {
+    const dt = m[1];
+    const body = m[2];
+    const props = new Set();
+    const propRef = /\[PropertyName\.(\w+)\]/g;
+    let pm;
+    while ((pm = propRef.exec(body)) !== null) {
+      props.add(pm[1]);
+    }
+    deviceProps.set(dt, props);
+  }
+
+  const targetProps = deviceProps.get(enumN);
+  if (!targetProps || targetProps.size === 0) return null;
+
+  // Jaccard similarity
+  const similarities = [];
+  for (const [dt, props] of deviceProps) {
+    if (dt === enumN) continue;
+    const intersection = new Set([...targetProps].filter((p) => props.has(p)));
+    const union = new Set([...targetProps, ...props]);
+    const jaccard = union.size > 0 ? intersection.size / union.size : 0;
+    if (jaccard > 0.3) {
+      similarities.push({
+        device: dt,
+        jaccard: Math.round(jaccard * 100),
+        shared: intersection.size,
+        total: union.size,
+        targetOnly: [...targetProps].filter((p) => !props.has(p)).length,
+        otherOnly: [...props].filter((p) => !targetProps.has(p)).length,
+      });
+    }
+  }
+
+  similarities.sort((a, b) => b.jaccard - a.jaccard);
+  return similarities.slice(0, 5);
+}
+
+const closestDevices = findClosestDevice(httpSource, enumName);
+
+// ── Check 7: Upstream PR search ────────────────────────────────────────────
+
+// Sanitize shell arguments to prevent command injection
+function shellEscape(str) {
+  return "'" + String(str).replace(/'/g, "'\\''") + "'";
+}
+
+function searchUpstreamPRs(searchTerm) {
+  if (!searchTerm) return null;
+  try {
+    const result = execSync(
+      `gh pr list --repo bropat/eufy-security-client --state all --search ${shellEscape(searchTerm)} --limit 5 --json number,title,state,mergedAt 2>/dev/null`,
+      { encoding: "utf-8", timeout: 10000 }
+    );
+    return JSON.parse(result);
+  } catch {
+    return null;
+  }
+}
+
+// Also search by type number (typeNum is validated as integer, but escape for safety)
+function searchByTypeNumber(typeNum) {
+  try {
+    const result = execSync(
+      `gh pr list --repo bropat/eufy-security-client --state all --search ${shellEscape(String(typeNum))} --limit 5 --json number,title,state,mergedAt 2>/dev/null`,
+      { encoding: "utf-8", timeout: 10000 }
+    );
+    return JSON.parse(result);
+  } catch {
+    return null;
+  }
+}
+
+const prsByModel = prSearchTerm ? searchUpstreamPRs(prSearchTerm) : null;
+const prsByType = searchByTypeNumber(typeNumber);
+
+// ── Output ─────────────────────────────────────────────────────────────────
+
+const W = 80;
+const PASS = "FOUND";
+const FAIL = "MISSING";
+const NA = "N/A";
+
+console.log("=".repeat(W));
+console.log(`Device Type Audit: ${typeNumber}${enumName ? ` (${enumName})` : ""}`);
+console.log("=".repeat(W));
+console.log();
+
+// Registration status
+console.log("REGISTRATION STATUS");
+console.log("-".repeat(W));
+const checks = [
+  ["DeviceType enum", enumName ? `${PASS} — ${enumName}` : FAIL],
+  ["GenericTypeProperty states", gtpLabel ? `${PASS} — "${gtpLabel}"` : FAIL],
+  ["DeviceProperties map", inDeviceProperties ? PASS : FAIL],
+  ["StationProperties map", inStationProperties ? PASS : `${FAIL} (may not be needed)`],
+  ["DeviceCommands map", inDeviceCommands ? PASS : FAIL],
+  ["StationCommands map", inStationCommands ? PASS : `${FAIL} (may not be needed)`],
+];
+
+for (const [label, status] of checks) {
+  const icon = status.startsWith(PASS) ? "+" : status === NA ? " " : "-";
+  console.log(`  [${icon}] ${label.padEnd(30)} ${status}`);
+}
+
+console.log();
+
+// Classification methods
+console.log("CLASSIFICATION METHODS");
+console.log("-".repeat(W));
+if (classInfo.inMethods.length > 0) {
+  console.log(`  Included in ${classInfo.inMethods.length} method(s):`);
+  for (const m of classInfo.inMethods) {
+    console.log(`    - ${m}()`);
+  }
+  console.log(`  Dedicated type guard: ${classInfo.hasTypeGuard ? "YES" : "NO"}`);
+} else if (enumName) {
+  console.log("  Not included in any classification methods");
+} else {
+  console.log("  Cannot check — device type not in enum");
+}
+console.log();
+
+// Device images
+console.log("PLUGIN UI");
+console.log("-".repeat(W));
+console.log(`  device-images.js: ${imageName ? `${PASS} — ${imageName}` : FAIL}`);
+console.log();
+
+// Station & push integration
+console.log("INTEGRATION POINTS");
+console.log("-".repeat(W));
+if (stationInfo.referenced) {
+  console.log(`  station.ts: directly referenced`);
+} else if (stationInfo.methods.length > 0) {
+  console.log(`  station.ts: indirectly via ${stationInfo.methods.join(", ")}()`);
+} else {
+  console.log(`  station.ts: not referenced (may need integration for standalone/integrated devices)`);
+}
+console.log(`  push/service.ts: ${inPushService ? "referenced (has push normalization)" : "not referenced (normal for most devices)"}`);
+console.log();
+
+// Closest device
+if (closestDevices && closestDevices.length > 0) {
+  console.log("CLOSEST EXISTING DEVICES (by property overlap)");
+  console.log("-".repeat(W));
+  console.log("  Device".padEnd(40) + "Similarity  Shared  Target-only  Other-only");
+  for (const d of closestDevices) {
+    console.log(
+      `  ${d.device.padEnd(38)} ${String(d.jaccard + "%").padEnd(11)} ${String(d.shared).padEnd(7)} ${String(d.targetOnly).padEnd(12)} ${d.otherOnly}`
+    );
+  }
+  console.log();
+}
+
+// Upstream PRs
+const allPRs = new Map();
+if (prsByModel) for (const pr of prsByModel) allPRs.set(pr.number, pr);
+if (prsByType) for (const pr of prsByType) allPRs.set(pr.number, pr);
+
+if (allPRs.size > 0) {
+  console.log("UPSTREAM PRs (bropat/eufy-security-client)");
+  console.log("-".repeat(W));
+  for (const pr of allPRs.values()) {
+    const state = pr.mergedAt ? "MERGED" : pr.state;
+    console.log(`  #${pr.number} [${state}] ${pr.title}`);
+  }
+  console.log();
+}
+
+// Summary
+console.log("=".repeat(W));
+const missing = checks.filter(([, s]) => s.startsWith(FAIL) && !s.includes("may not")).length;
+const total = 4; // Required: enum, GTP, DeviceProperties, DeviceCommands
+if (missing === 0) {
+  console.log("STATUS: All required registrations present. Device may only need homebridge-side work.");
+} else if (missing === total) {
+  console.log("STATUS: Device is completely new. Full implementation needed across both repos.");
+} else {
+  console.log(`STATUS: Partially implemented. ${missing} required registration(s) missing.`);
+}
+console.log("=".repeat(W));

package/.claude/skills/new-device-support/map-properties.mjs

@@ -6,13 +6,18 @@
  * to the corresponding property constants in eufy-security-client.
  *
  * Usage:
- *   node map-properties.mjs <raw-properties.json>
- *   cat raw.json | node map-properties.mjs
+ *   node map-properties.mjs <raw-properties.json> [--closest]
+ *   cat raw.json | node map-properties.mjs [--closest]
  *
  * The input JSON should be the rawProperties object from a device dump,
  * e.g. { "1101": { "value": 100 }, "1013": { "value": 1 }, ... }
  * or an array of { "param_type": 1101, "param_value": "..." } objects.
  *
+ * Options:
+ *   --closest   Find the closest existing devices by Jaccard similarity
+ *               on resolved PropertyName overlap. Useful to identify which
+ *               existing device to base the DeviceProperties block on.
+ *
  * Output: a table mapping each param_type to its CommandType/ParamType enum name
  * and all property constants that use that key.
  */
@@ -122,14 +127,17 @@ function parsePropertyConstants(source) {
     props.push({ constName, key, keyRaw, propertyName, spreadFrom });
   }
 
-  // Resolve spreads: if a property has no key but spreads from another, inherit
+  // Resolve spreads: inherit missing fields from parent property
   const byName = new Map(props.map((p) => [p.constName, p]));
   for (const prop of props) {
-    if (prop.key === null && prop.spreadFrom) {
+    if (prop.spreadFrom) {
       const parent = byName.get(prop.spreadFrom);
       if (parent) {
-        prop.key = parent.key;
-        if (!prop.keyRaw) prop.keyRaw = `(spread from ${prop.spreadFrom}) ${parent.keyRaw}`;
+        if (prop.key === null) {
+          prop.key = parent.key;
+          if (!prop.keyRaw) prop.keyRaw = `(spread from ${prop.spreadFrom}) ${parent.keyRaw}`;
+        }
+        // Always inherit propertyName from parent when missing, even if key is overridden
         if (!prop.propertyName) prop.propertyName = parent.propertyName;
       }
     }
@@ -182,7 +190,7 @@ const propUsage = parseDevicePropertiesUsage(httpSource);
 // ── Step 4: Read and parse input JSON ──────────────────────────────────────
 
 let inputData;
-const inputFile = process.argv[2];
+const inputFile = process.argv.slice(2).find((a) => !a.startsWith("-"));
 if (inputFile) {
   inputData = readFileSync(inputFile, "utf-8");
 } else {
@@ -332,9 +340,12 @@ console.log("=".repeat(80));
 const seen = new Set();
 const companionsAdded = [];
 for (const m of matched) {
-  for (let i = 0; i < m.constNames.length; i++) {
-    const pn = m.propertyNames[0]; // Use first PropertyName
-    const cn = m.constNames[i];
+  // Use original props lookup to get correct constName → propertyName mapping
+  // (the deduplicated m.propertyNames array loses the index association with m.constNames)
+  const propsForKey = keyToProps.get(m.paramType) || [];
+  for (const prop of propsForKey) {
+    const pn = prop.propertyName;
+    const cn = prop.constName;
     if (pn && !seen.has(pn)) {
       seen.add(pn);
       console.log(`  [${pn}]: ${cn},`);
@@ -359,3 +370,81 @@ if (companionsAdded.length > 0) {
     console.log(`  ${c.constName}: ${c.reason}`);
   }
 }
+
+// ── Step 7: Closest device detection (--closest flag) ───────────────────────
+
+if (process.argv.includes("--closest")) {
+  // Collect the set of PropertyName values from the matched raw properties
+  const targetPropNames = new Set();
+  for (const m of matched) {
+    for (const pn of m.propertyNames) {
+      if (pn) targetPropNames.add(pn);
+    }
+  }
+
+  if (targetPropNames.size === 0) {
+    console.log("\nCannot compute closest device — no PropertyName matches found.");
+  } else {
+    // Parse DeviceProperties blocks to get property sets per device type
+    const dpStart = httpSource.indexOf("export const DeviceProperties");
+    const dpEnd = httpSource.indexOf("export const StationProperties");
+    if (dpStart !== -1) {
+      const dpSection = httpSource.slice(dpStart, dpEnd === -1 ? undefined : dpEnd);
+
+      const devicePropSets = new Map(); // DeviceType name → Set of PropertyName references
+      const blockRegex = /\[DeviceType\.(\w+)\]\s*:\s*\{([\s\S]*?)\}/g;
+      let bm;
+      while ((bm = blockRegex.exec(dpSection)) !== null) {
+        const dt = bm[1];
+        const body = bm[2];
+        const props = new Set();
+        // Extract property constants used, then resolve to PropertyName
+        const refRegex = /:\s*(\w+Property)/g;
+        let rm;
+        while ((rm = refRegex.exec(body)) !== null) {
+          const constName = rm[1];
+          const prop = allProps.find((p) => p.constName === constName);
+          if (prop && prop.propertyName) props.add(prop.propertyName);
+        }
+        devicePropSets.set(dt, props);
+      }
+
+      // Jaccard similarity
+      const similarities = [];
+      for (const [dt, props] of devicePropSets) {
+        const intersection = new Set([...targetPropNames].filter((p) => props.has(p)));
+        const union = new Set([...targetPropNames, ...props]);
+        const jaccard = union.size > 0 ? intersection.size / union.size : 0;
+        if (jaccard > 0.2) {
+          similarities.push({
+            device: dt,
+            jaccard: Math.round(jaccard * 100),
+            shared: intersection.size,
+            targetOnly: [...targetPropNames].filter((p) => !props.has(p)).length,
+            otherOnly: [...props].filter((p) => !targetPropNames.has(p)).length,
+          });
+        }
+      }
+
+      similarities.sort((a, b) => b.jaccard - a.jaccard);
+      const top = similarities.slice(0, 8);
+
+      console.log();
+      console.log("=".repeat(80));
+      console.log("CLOSEST EXISTING DEVICES (by property overlap with raw data)");
+      console.log("=".repeat(80));
+      if (top.length === 0) {
+        console.log("  No devices with >20% property overlap found.");
+      } else {
+        console.log("  " + "Device".padEnd(38) + "Similarity  Shared  Target-only  Other-only");
+        for (const d of top) {
+          console.log(
+            `  ${d.device.padEnd(38)} ${String(d.jaccard + "%").padEnd(11)} ${String(d.shared).padEnd(7)} ${String(d.targetOnly).padEnd(12)} ${d.otherOnly}`
+          );
+        }
+        console.log();
+        console.log(`  Recommended base: ${top[0].device} (${top[0].jaccard}% overlap)`);
+      }
+    }
+  }
+}

package/.claude/skills/new-device-support/verify-device.mjs

@@ -0,0 +1,272 @@
+#!/usr/bin/env node
+/**
+ * verify-device.mjs
+ *
+ * Post-implementation verification script. Checks that a device type is fully
+ * wired into all required registration points after implementation.
+ *
+ * Usage:
+ *   node verify-device.mjs <ENUM_NAME>
+ *
+ * Example:
+ *   node verify-device.mjs CAMERA_4G_S330
+ *   node verify-device.mjs INDOOR_PT_CAMERA_E30
+ *
+ * Output: PASS/FAIL per check, with a final summary.
+ */
+
+import { readFileSync, existsSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+const CLIENT_ROOT = join(__dirname, "..", "..", "..", "..", "eufy-security-client");
+const HB_ROOT = join(__dirname, "..", "..", "..");
+const TYPES_HTTP = join(CLIENT_ROOT, "src", "http", "types.ts");
+const DEVICE_TS = join(CLIENT_ROOT, "src", "http", "device.ts");
+const DEVICE_IMAGES = join(HB_ROOT, "homebridge-ui", "public", "utils", "device-images.js");
+const SUPPORTED_DEVICES = join(CLIENT_ROOT, "docs", "supported_devices.md");
+
+const enumName = process.argv[2];
+if (!enumName || enumName.startsWith("-")) {
+  console.error("Usage: verify-device.mjs <ENUM_NAME>");
+  console.error("Example: verify-device.mjs CAMERA_4G_S330");
+  process.exit(1);
+}
+
+const httpSource = readFileSync(TYPES_HTTP, "utf-8");
+const deviceSource = readFileSync(DEVICE_TS, "utf-8");
+
+// ── Extract type number from enum ───────────────────────────────────────────
+
+function getTypeNumber(source, enumN) {
+  const re = new RegExp(`^\\s*${enumN}\\s*=\\s*(\\d+)`, "m");
+  const match = source.match(re);
+  return match ? parseInt(match[1]) : null;
+}
+
+const typeNumber = getTypeNumber(httpSource, enumName);
+
+// ── Check functions ─────────────────────────────────────────────────────────
+
+function checkEnumExists(source, enumN) {
+  const re = new RegExp(`^\\s*${enumN}\\s*=\\s*\\d+`, "m");
+  return re.test(source);
+}
+
+function checkGenericTypePropertyStates(source, typeNum) {
+  if (!typeNum) return { pass: false, detail: "no type number" };
+  const gtpMatch = source.match(/export\s+const\s+GenericTypeProperty[\s\S]*?states:\s*\{([\s\S]*?)\}/);
+  if (!gtpMatch) return { pass: false, detail: "GenericTypeProperty not found" };
+  const re = new RegExp(`${typeNum}:\\s*"`);
+  const found = re.test(gtpMatch[1]);
+  return { pass: found, detail: found ? "label present" : "missing label entry" };
+}
+
+function checkLookupMap(source, mapName, enumN) {
+  const dpStart = source.indexOf(`export const ${mapName}`);
+  if (dpStart === -1) return { pass: false, detail: `${mapName} not found` };
+  const nextExport = source.indexOf("export const ", dpStart + 20);
+  const section = source.slice(dpStart, nextExport === -1 ? undefined : nextExport);
+  const found = section.includes(`[DeviceType.${enumN}]`);
+  return { pass: found, detail: found ? "entry present" : "missing entry" };
+}
+
+function checkTypeGuard(source, enumN) {
+  // Look for a static method that returns DeviceType.ENUM == type
+  const re = new RegExp(`static\\s+(is\\w+)\\s*\\(\\s*type:\\s*number\\s*\\)[^}]*DeviceType\\.${enumN}`, "g");
+  const methods = [];
+  let m;
+  while ((m = re.exec(source)) !== null) {
+    methods.push(m[1]);
+  }
+  return {
+    pass: methods.length > 0,
+    detail: methods.length > 0 ? `found: ${methods.join(", ")}()` : "no type guard method references this enum",
+  };
+}
+
+function checkInstanceMethod(source, enumN) {
+  // Find methods from the type guard check, then look for matching instance methods
+  const staticRe = new RegExp(`static\\s+(is\\w+)\\s*\\(\\s*type:\\s*number\\s*\\)[^}]*DeviceType\\.${enumN}`, "g");
+  const staticMethods = [];
+  let m;
+  while ((m = staticRe.exec(source)) !== null) {
+    staticMethods.push(m[1]);
+  }
+
+  const instanceMethods = [];
+  for (const methodName of staticMethods) {
+    const instanceRe = new RegExp(`public\\s+${methodName}\\s*\\(\\s*\\)\\s*:\\s*boolean`);
+    if (instanceRe.test(source)) {
+      instanceMethods.push(methodName);
+    }
+  }
+
+  return {
+    pass: instanceMethods.length > 0,
+    detail: instanceMethods.length > 0
+      ? `found: ${instanceMethods.join(", ")}()`
+      : staticMethods.length > 0
+        ? `static ${staticMethods.join(", ")}() found but missing instance method(s)`
+        : "no type guard found",
+  };
+}
+
+function checkClassificationMethods(source, enumN) {
+  // Check broad classification methods (isCamera, isLock, isSensor, etc.)
+  const broadMethods = [
+    "isCamera", "isLock", "isSensor", "isKeyPad", "isSmartDrop",
+    "isSmartSafe", "isSmartTrack", "hasBattery", "isFloodLight",
+    "isIndoorCamera", "isDoorbell", "isPanAndTiltCamera",
+    "isSoloCameras", "isLockWifi", "isLockBle", "isEntrySensor",
+    "isMotionSensor",
+  ];
+  const included = [];
+  for (const method of broadMethods) {
+    const re = new RegExp(`static\\s+${method}\\s*\\(\\s*type:\\s*number\\s*\\)[\\s\\S]*?\\n\\s*\\}`, "g");
+    const match = source.match(re);
+    if (match && match[0].includes(`DeviceType.${enumN}`)) {
+      included.push(method);
+    }
+  }
+  return {
+    pass: included.length > 0,
+    detail: included.length > 0
+      ? `in ${included.length} method(s): ${included.join(", ")}`
+      : "not in any broad classification method",
+  };
+}
+
+function checkDeviceImages(typeNum) {
+  if (!typeNum) return { pass: false, detail: "no type number" };
+  if (!existsSync(DEVICE_IMAGES)) return { pass: false, detail: "device-images.js not found" };
+  const source = readFileSync(DEVICE_IMAGES, "utf-8");
+  const re = new RegExp(`case\\s+${typeNum}:`);
+  const found = re.test(source);
+  return { pass: found, detail: found ? "case present" : "missing case" };
+}
+
+function checkSupportedDevicesDocs(enumN) {
+  if (!existsSync(SUPPORTED_DEVICES)) return { pass: false, detail: "supported_devices.md not found" };
+  const source = readFileSync(SUPPORTED_DEVICES, "utf-8");
+  // Check for the enum name or the display name pattern
+  const found = source.includes(enumN) || (typeNumber && new RegExp(`type\\s+${typeNumber}|${typeNumber}\\)`).test(source));
+  // Also check for model number pattern from enum comment (e.g. "CAMERA_4G_S330 = 111, //T86P2")
+  const enumLine = httpSource.match(new RegExp(`${enumN}\\s*=\\s*\\d+.*?//\\s*(\\S+)`));
+  const model = enumLine ? enumLine[1] : null;
+  const modelFound = model && source.includes(model);
+  if (modelFound) return { pass: true, detail: `model ${model} found in docs` };
+  if (found) return { pass: true, detail: "entry found in docs" };
+  return { pass: false, detail: model ? `model ${model} not found` : "not found in docs" };
+}
+
+function checkBySn(source, enumN) {
+  // Check if this device is referenced in any *BySn method
+  // First get the model prefix from the enum comment
+  const enumLine = httpSource.match(new RegExp(`${enumN}\\s*=\\s*\\d+.*?//\\s*(\\S+)`));
+  const model = enumLine ? enumLine[1] : null;
+  if (!model) return { pass: false, detail: "cannot determine model prefix from enum comment" };
+
+  const bySnMethods = ["isIntegratedDeviceBySn", "isSoloCameraBySn", "isSmartDropBySn", "isGarageCameraBySn", "isFloodlightBySn"];
+  const found = [];
+  for (const method of bySnMethods) {
+    const re = new RegExp(`static\\s+${method}\\s*\\([^)]*\\)[\\s\\S]*?\\n\\s*\\}`, "g");
+    const match = source.match(re);
+    if (match && match[0].includes(`"${model}"`)) {
+      found.push(method);
+    }
+  }
+  return {
+    pass: found.length > 0,
+    detail: found.length > 0
+      ? `in ${found.join(", ")}()`
+      : `model ${model} not in any *BySn method (may not be needed)`,
+  };
+}
+
+// ── Run all checks ──────────────────────────────────────────────────────────
+
+const W = 80;
+console.log("=".repeat(W));
+console.log(`Post-Implementation Verification: ${enumName}${typeNumber ? ` (type ${typeNumber})` : ""}`);
+console.log("=".repeat(W));
+console.log();
+
+if (!typeNumber) {
+  console.log(`FATAL: ${enumName} not found in DeviceType enum. Cannot proceed.`);
+  process.exit(1);
+}
+
+const results = [];
+
+function run(label, check, required = true) {
+  const icon = check.pass ? "+" : required ? "-" : "~";
+  const status = check.pass ? "PASS" : required ? "FAIL" : "WARN";
+  results.push({ label, ...check, required, status });
+  console.log(`  [${icon}] ${label.padEnd(35)} ${status.padEnd(6)} ${check.detail}`);
+}
+
+console.log("EUFY-SECURITY-CLIENT (src/http/types.ts)");
+console.log("-".repeat(W));
+run("DeviceType enum", { pass: checkEnumExists(httpSource, enumName), detail: `${enumName} = ${typeNumber}` });
+run("GenericTypeProperty states", checkGenericTypePropertyStates(httpSource, typeNumber));
+run("DeviceProperties map", checkLookupMap(httpSource, "DeviceProperties", enumName));
+run("DeviceCommands map", checkLookupMap(httpSource, "DeviceCommands", enumName));
+run("StationProperties map", checkLookupMap(httpSource, "StationProperties", enumName), false);
+run("StationCommands map", checkLookupMap(httpSource, "StationCommands", enumName), false);
+console.log();
+
+console.log("EUFY-SECURITY-CLIENT (src/http/device.ts)");
+console.log("-".repeat(W));
+run("Dedicated type guard (static)", checkTypeGuard(deviceSource, enumName));
+run("Instance method", checkInstanceMethod(deviceSource, enumName));
+run("Classification methods", checkClassificationMethods(deviceSource, enumName));
+console.log();
+
+console.log("EUFY-SECURITY-CLIENT (docs)");
+console.log("-".repeat(W));
+run("docs/supported_devices.md", checkSupportedDevicesDocs(enumName), false);
+console.log();
+
+console.log("EUFY-SECURITY-CLIENT (serial number methods)");
+console.log("-".repeat(W));
+run("*BySn serial number methods", checkBySn(deviceSource, enumName), false);
+console.log();
+
+console.log("HOMEBRIDGE-EUFY-SECURITY");
+console.log("-".repeat(W));
+run("device-images.js", checkDeviceImages(typeNumber));
+console.log();
+
+// ── Summary ─────────────────────────────────────────────────────────────────
+
+const failed = results.filter((r) => r.status === "FAIL");
+const warned = results.filter((r) => r.status === "WARN");
+const passed = results.filter((r) => r.status === "PASS");
+
+console.log("=".repeat(W));
+if (failed.length === 0) {
+  console.log(`ALL REQUIRED CHECKS PASSED (${passed.length} pass, ${warned.length} warn)`);
+  if (warned.length > 0) {
+    console.log("Warnings (optional):");
+    for (const w of warned) {
+      console.log(`  - ${w.label}: ${w.detail}`);
+    }
+  }
+} else {
+  console.log(`${failed.length} REQUIRED CHECK(S) FAILED:`);
+  for (const f of failed) {
+    console.log(`  - ${f.label}: ${f.detail}`);
+  }
+  if (warned.length > 0) {
+    console.log(`\n${warned.length} warning(s):`);
+    for (const w of warned) {
+      console.log(`  - ${w.label}: ${w.detail}`);
+    }
+  }
+}
+console.log("=".repeat(W));
+
+process.exit(failed.length > 0 ? 1 : 0);

package/dist/version.js

@@ -1,2 +1,2 @@
-export const LIB_VERSION = "4.6.0-beta.28";
+export const LIB_VERSION = "4.6.0-beta.29";
 //# sourceMappingURL=version.js.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "displayName": "Homebridge Eufy Security",
   "name": "@homebridge-plugins/homebridge-eufy-security",
-  "version": "4.6.0-beta.28",
+  "version": "4.6.0-beta.29",
   "description": "Control Eufy Security from homebridge.",
   "type": "module",
   "license": "Apache-2.0",