@rfranzoi/scrypted-mqtt-securitysystem 1.0.37 → 1.0.39

package/dist/main.nodejs.js

@@ -34029,7 +34029,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 // --- Preload: silenzia SOLO il warning facoltativo di sdk.json ---
-// Copre console.error e console.warn (alcune versioni usano warn).
 (() => {
     const swallow = (orig) => (...args) => {
         const txt = args.map(a => typeof a === 'string' ? a : (a?.message || '')).join(' ');
@@ -34040,36 +34039,73 @@ Object.defineProperty(exports, "__esModule", ({ value: true }));
     console.error = swallow(console.error.bind(console));
     console.warn = swallow(console.warn.bind(console));
 })();
-// Carica lo SDK (runtime only: niente import ESM per evitare che il bundler lo esegua prima del preload)
+// Runtime SDK via require (evita esecuzione anticipata del bundler)
 const sdk = __webpack_require__(/*! @scrypted/sdk */ "./node_modules/@scrypted/sdk/dist/src/index.js");
-// Valori runtime dal modulo SDK
-const { ScryptedDeviceBase, ScryptedDeviceType, ScryptedInterface, // enum (valori)
-SecuritySystemMode, // enum (valori)
-systemManager, } = sdk;
+const { ScryptedDeviceBase, ScryptedDeviceType, ScryptedInterface, SecuritySystemMode, systemManager, } = sdk;
 const mqtt_1 = __importDefault(__webpack_require__(/*! mqtt */ "./node_modules/mqtt/build/index.js"));
 /** utils */
+function normalize(s) { return (s || '').trim().toLowerCase(); }
 function truthy(v) {
     if (!v)
         return false;
-    const s = v.toString().trim().toLowerCase();
-    return s === '1' || s === 'true' || s === 'online' || s === 'yes' || s === 'on' || s === 'ok';
+    const s = normalize(v);
+    return s === '1' || s === 'true' || s === 'online' || s === 'yes' || s === 'on' || s === 'ok' || s === 'open';
 }
 function falsy(v) {
     if (!v)
         return false;
-    const s = v.toString().trim().toLowerCase();
-    return s === '0' || s === 'false' || s === 'offline' || s === 'no' || s === 'off';
+    const s = normalize(v);
+    return s === '0' || s === 'false' || s === 'offline' || s === 'no' || s === 'off' || s === 'closed' || s === 'close';
 }
-function normalize(s) { return (s || '').trim().toLowerCase(); }
 function clamp(n, min, max) { return Math.max(min, Math.min(max, n)); }
-/** Outgoing predefiniti (PAI-like). Chiavi numeriche per compatibilità enum */
+function deepEqual(a, b) { try {
+    return JSON.stringify(a) === JSON.stringify(b);
+}
+catch {
+    return a === b;
+} }
+/** Match topic con wildcard MQTT (+, #) oppure confronto esatto */
+function topicMatches(topic, pattern) {
+    if (!pattern)
+        return false;
+    if (pattern === topic)
+        return true;
+    if (!pattern.includes('+') && !pattern.includes('#'))
+        return false;
+    // Escapa tutto tranne '/'
+    const esc = pattern.replace(/[-/\\^$*?.()|[\]{}]/g, '\\$&');
+    const rx = '^' + esc
+        .replace(/\\\+/g, '[^/]+') // '+' => un segmento
+        .replace(/\\\#/g, '.+'); // '#" => qualsiasi suffisso
+    try {
+        return new RegExp(rx + '$').test(topic);
+    }
+    catch {
+        return false;
+    }
+}
+/** set + emit evento scrypted */
+function setAndEmit(dev, key, value, iface, log) {
+    if (dev[key] === value)
+        return;
+    dev[key] = value;
+    try {
+        dev.onDeviceEvent?.(iface, value);
+    }
+    catch { }
+    try {
+        if (log)
+            dev.console?.log?.(log);
+    }
+    catch { }
+}
+/** Outgoing predefiniti (PAI-like). Chiavi numeriche per compat enum */
 const DEFAULT_OUTGOING = {
     [SecuritySystemMode.Disarmed]: 'disarm',
     [SecuritySystemMode.HomeArmed]: 'arm_home',
     [SecuritySystemMode.AwayArmed]: 'arm_away',
     [SecuritySystemMode.NightArmed]: 'arm_night',
 };
-/** Parse incoming payload -> final mode (ignora transitori) */
 function payloadToMode(payload) {
     if (payload == null)
         return;
@@ -34092,159 +34128,148 @@ class BaseMqttSensor extends ScryptedDeviceBase {
         this.cfg = cfg;
     }
     handleMqtt(topic, payload) {
-        const p = payload?.toString() ?? '';
-        const np = normalize(p);
-        if (topic === this.cfg.topics.online) {
+        const raw = payload?.toString() ?? '';
+        const np = normalize(raw);
+        // Online
+        if (topicMatches(topic, this.cfg.topics.online)) {
             if (truthy(np) || np === 'online')
-                this.online = true;
-            if (falsy(np) || np === 'offline')
-                this.online = false;
+                setAndEmit(this, 'online', true, ScryptedInterface.Online, `[${this.name}] online=true`);
+            else if (falsy(np) || np === 'offline')
+                setAndEmit(this, 'online', false, ScryptedInterface.Online, `[${this.name}] online=false`);
         }
-        if (topic === this.cfg.topics.tamper) {
+        // Tamper
+        if (topicMatches(topic, this.cfg.topics.tamper)) {
             if (truthy(np) || ['tamper', 'intrusion', 'cover', 'motion', 'magnetic'].includes(np)) {
-                this.tampered = ['cover', 'intrusion', 'motion', 'magnetic'].find(x => x === np) || true;
+                const t = ['cover', 'intrusion', 'motion', 'magnetic'].find(x => x === np) || true;
+                setAndEmit(this, 'tampered', t, ScryptedInterface.TamperSensor, `[${this.name}] tampered=${t}`);
+            }
+            else if (falsy(np)) {
+                setAndEmit(this, 'tampered', false, ScryptedInterface.TamperSensor, `[${this.name}] tampered=false`);
             }
-            else if (falsy(np))
-                this.tampered = false;
         }
-        if (topic === this.cfg.topics.batteryLevel) {
-            const n = clamp(parseFloat(p), 0, 100);
+        // Battery
+        if (topicMatches(topic, this.cfg.topics.batteryLevel)) {
+            const n = clamp(parseFloat(raw), 0, 100);
             if (isFinite(n))
-                this.batteryLevel = n;
+                setAndEmit(this, 'batteryLevel', n, ScryptedInterface.Battery, `[${this.name}] batteryLevel=${n}`);
         }
-        else if (topic === this.cfg.topics.lowBattery && !this.cfg.topics.batteryLevel) {
-            this.batteryLevel = truthy(np) ? 10 : 100;
+        else if (topicMatches(topic, this.cfg.topics.lowBattery) && !this.cfg.topics.batteryLevel) {
+            const n = truthy(np) ? 10 : 100;
+            setAndEmit(this, 'batteryLevel', n, ScryptedInterface.Battery, `[${this.name}] batteryLevel=${n} (lowBattery)`);
         }
-        this.handlePrimary(topic, np, p);
+        // Primario
+        this.handlePrimary(topic, np, raw);
     }
 }
-/** === SENSORI CON PARSING ROBUSTO PER HOMEKIT === */
+/** === SENSORI: parsing robusto + eventi === */
 class ContactMqttSensor extends BaseMqttSensor {
     handlePrimary(topic, np, raw) {
-        if (topic !== this.cfg.topics.contact)
-            return;
-        // stringhe comuni
-        if (['open', 'opened', '1', 'true', 'on', 'yes'].includes(np)) {
-            this.entryOpen = true;
-            return;
-        }
-        if (['closed', 'close', '0', 'false', 'off', 'no', 'shut'].includes(np)) {
-            this.entryOpen = false;
+        if (!topicMatches(topic, this.cfg.topics.contact))
             return;
-        }
+        let val;
+        // stringhe comuni (True/False compresi via normalize)
+        if (['open', 'opened', '1', 'true', 'on', 'yes'].includes(np))
+            val = true;
+        else if (['closed', 'close', '0', 'false', 'off', 'no', 'shut'].includes(np))
+            val = false;
         // JSON comuni
-        try {
-            const j = JSON.parse(raw);
-            if (typeof j?.open === 'boolean') {
-                this.entryOpen = !!j.open;
-                return;
-            }
-            if (typeof j?.opened === 'boolean') {
-                this.entryOpen = !!j.opened;
-                return;
-            }
-            if (typeof j?.contact === 'boolean') {
-                this.entryOpen = !j.contact;
-                return;
-            } // contact:false => OPEN
-            if (typeof j?.state === 'string') {
-                const s = String(j.state).toLowerCase();
-                if (s === 'open') {
-                    this.entryOpen = true;
-                    return;
-                }
-                if (s === 'closed') {
-                    this.entryOpen = false;
-                    return;
+        if (val === undefined) {
+            try {
+                const j = JSON.parse(raw);
+                if (typeof j?.open === 'boolean')
+                    val = !!j.open;
+                else if (typeof j?.opened === 'boolean')
+                    val = !!j.opened;
+                else if (typeof j?.contact === 'boolean')
+                    val = !j.contact; // contact:false => aperto
+                else if (typeof j?.state === 'string') {
+                    const s = normalize(j.state);
+                    if (s === 'open')
+                        val = true;
+                    if (s === 'closed')
+                        val = false;
                 }
             }
+            catch { }
+        }
+        if (val !== undefined) {
+            setAndEmit(this, 'entryOpen', val, ScryptedInterface.EntrySensor, `[${this.name}] entryOpen=${val} (${topic})`);
+        }
+        else {
+            this.console?.debug?.(`Contact payload non gestito (${this.cfg.id}) topic=${topic} raw="${raw}"`);
         }
-        catch { }
-        this.console?.debug?.(`Contact payload non gestito (${this.cfg.id}): "${raw}"`);
     }
 }
 class MotionMqttSensor extends BaseMqttSensor {
     handlePrimary(topic, np, raw) {
-        if (topic !== this.cfg.topics.motion)
+        if (!topicMatches(topic, this.cfg.topics.motion))
             return;
-        if (['motion', 'detected', 'active', '1', 'true', 'on', 'yes'].includes(np)) {
-            this.motionDetected = true;
-            return;
-        }
-        if (['clear', 'inactive', 'no_motion', 'none', '0', 'false', 'off', 'no'].includes(np)) {
-            this.motionDetected = false;
-            return;
-        }
-        try {
-            const j = JSON.parse(raw);
-            if (typeof j?.motion === 'boolean') {
-                this.motionDetected = !!j.motion;
-                return;
-            }
-            if (typeof j?.occupancy === 'boolean') {
-                this.motionDetected = !!j.occupancy;
-                return;
-            }
-            if (typeof j?.presence === 'boolean') {
-                this.motionDetected = !!j.presence;
-                return;
-            }
-            if (typeof j?.state === 'string') {
-                const s = String(j.state).toLowerCase();
-                if (['on', 'motion', 'detected', 'active'].includes(s)) {
-                    this.motionDetected = true;
-                    return;
-                }
-                if (['off', 'clear', 'inactive'].includes(s)) {
-                    this.motionDetected = false;
-                    return;
+        let val;
+        if (['motion', 'detected', 'active', '1', 'true', 'on', 'yes'].includes(np))
+            val = true;
+        else if (['clear', 'inactive', 'no_motion', 'none', '0', 'false', 'off', 'no'].includes(np))
+            val = false;
+        if (val === undefined) {
+            try {
+                const j = JSON.parse(raw);
+                if (typeof j?.motion === 'boolean')
+                    val = !!j.motion;
+                else if (typeof j?.occupancy === 'boolean')
+                    val = !!j.occupancy;
+                else if (typeof j?.presence === 'boolean')
+                    val = !!j.presence;
+                else if (typeof j?.state === 'string') {
+                    const s = normalize(j.state);
+                    if (['on', 'motion', 'detected', 'active'].includes(s))
+                        val = true;
+                    if (['off', 'clear', 'inactive'].includes(s))
+                        val = false;
                 }
             }
+            catch { }
+        }
+        if (val !== undefined) {
+            setAndEmit(this, 'motionDetected', val, ScryptedInterface.MotionSensor, `[${this.name}] motionDetected=${val} (${topic})`);
+        }
+        else {
+            this.console?.debug?.(`Motion payload non gestito (${this.cfg.id}) topic=${topic} raw="${raw}"`);
         }
-        catch { }
-        this.console?.debug?.(`Motion payload non gestito (${this.cfg.id}): "${raw}"`);
     }
 }
 class OccupancyMqttSensor extends BaseMqttSensor {
     handlePrimary(topic, np, raw) {
-        if (topic !== this.cfg.topics.occupancy)
-            return;
-        if (['occupied', 'presence', 'present', '1', 'true', 'on', 'yes'].includes(np)) {
-            this.occupied = true;
+        if (!topicMatches(topic, this.cfg.topics.occupancy))
             return;
-        }
-        if (['unoccupied', 'vacant', 'absent', '0', 'false', 'off', 'no', 'clear'].includes(np)) {
-            this.occupied = false;
-            return;
-        }
-        try {
-            const j = JSON.parse(raw);
-            if (typeof j?.occupied === 'boolean') {
-                this.occupied = !!j.occupied;
-                return;
-            }
-            if (typeof j?.presence === 'boolean') {
-                this.occupied = !!j.presence;
-                return;
-            }
-            if (typeof j?.occupancy === 'boolean') {
-                this.occupied = !!j.occupancy;
-                return;
-            }
-            if (typeof j?.state === 'string') {
-                const s = String(j.state).toLowerCase();
-                if (['occupied', 'presence', 'present', 'on'].includes(s)) {
-                    this.occupied = true;
-                    return;
-                }
-                if (['vacant', 'absent', 'clear', 'off'].includes(s)) {
-                    this.occupied = false;
-                    return;
+        let val;
+        if (['occupied', 'presence', 'present', '1', 'true', 'on', 'yes'].includes(np))
+            val = true;
+        else if (['unoccupied', 'vacant', 'absent', '0', 'false', 'off', 'no', 'clear'].includes(np))
+            val = false;
+        if (val === undefined) {
+            try {
+                const j = JSON.parse(raw);
+                if (typeof j?.occupied === 'boolean')
+                    val = !!j.occupied;
+                else if (typeof j?.presence === 'boolean')
+                    val = !!j.presence;
+                else if (typeof j?.occupancy === 'boolean')
+                    val = !!j.occupancy;
+                else if (typeof j?.state === 'string') {
+                    const s = normalize(j.state);
+                    if (['occupied', 'presence', 'present', 'on'].includes(s))
+                        val = true;
+                    if (['vacant', 'absent', 'clear', 'off'].includes(s))
+                        val = false;
                 }
             }
+            catch { }
+        }
+        if (val !== undefined) {
+            setAndEmit(this, 'occupied', val, ScryptedInterface.OccupancySensor, `[${this.name}] occupied=${val} (${topic})`);
+        }
+        else {
+            this.console?.debug?.(`Occupancy payload non gestito (${this.cfg.id}) topic=${topic} raw="${raw}"`);
         }
-        catch { }
-        this.console?.debug?.(`Occupancy payload non gestito (${this.cfg.id}): "${raw}"`);
     }
 }
 /** ----------------- Main Plugin ----------------- */
@@ -34253,7 +34278,6 @@ class ParadoxMqttSecuritySystem extends ScryptedDeviceBase {
         super();
         this.sensorsCfg = [];
         this.devices = new Map();
-        // Evita loop di log: tenta una volta finché deviceManager non c’è, poi riprova su eventi utili.
         this.discoveryPostponed = false;
         // Tipo in UI (best-effort)
         setTimeout(() => {
@@ -34273,12 +34297,9 @@ class ParadoxMqttSecuritySystem extends ScryptedDeviceBase {
             ],
         };
         this.online = this.online ?? false;
-        // Config sensori e (tentativo) announce
         this.loadSensorsFromStorage();
-        this.safeDiscoverSensors(); // non spamma se deviceManager non c'è
-        // Connect MQTT
+        this.safeDiscoverSensors();
         this.connectMqtt().catch((e) => this.console.error('MQTT connect error:', e));
-        // Shutdown pulito
         try {
             process.once('SIGTERM', () => { try {
                 this.client?.end(true);
@@ -34322,12 +34343,11 @@ class ParadoxMqttSecuritySystem extends ScryptedDeviceBase {
         ];
         // Add Sensor
         out.push({ group: 'Add Sensor', key: 'new.id', title: 'New Sensor ID', placeholder: 'porta-ingresso', value: this.storage.getItem('new.id') || '' }, { group: 'Add Sensor', key: 'new.name', title: 'Name', placeholder: 'Porta Ingresso', value: this.storage.getItem('new.name') || '' }, { group: 'Add Sensor', key: 'new.kind', title: 'Type', value: this.storage.getItem('new.kind') || 'contact', choices: ['contact', 'motion', 'occupancy'] }, { group: 'Add Sensor', key: 'new.create', title: 'Create sensor', type: 'boolean', description: 'Toggle ON to create the sensor.' });
-        // Sensors esistenti
         for (const cfg of this.sensorsCfg) {
             const gid = `Sensor: ${cfg.name} [${cfg.id}]`;
             out.push({ group: gid, key: `sensor.${cfg.id}.name`, title: 'Name', value: cfg.name }, { group: gid, key: `sensor.${cfg.id}.kind`, title: 'Type', value: cfg.kind, choices: ['contact', 'motion', 'occupancy'] });
             if (cfg.kind === 'contact')
-                out.push({ group: gid, key: `sensor.${cfg.id}.topic.contact`, title: 'Contact State Topic', value: cfg.topics.contact || '' });
+                out.push({ group: gid, key: `sensor.${cfg.id}.topic.contact`, title: 'Contact State Topic', value: cfg.topics.contact || '', placeholder: 'paradox/states/zones/XYZ/open (supporta +/#)' });
             else if (cfg.kind === 'motion')
                 out.push({ group: gid, key: `sensor.${cfg.id}.topic.motion`, title: 'Motion Detected Topic', value: cfg.topics.motion || '' });
             else
@@ -34430,11 +34450,9 @@ class ParadoxMqttSecuritySystem extends ScryptedDeviceBase {
             this.sensorsCfg = [];
         }
     }
-    /** Annuncia i sensori SOLO se deviceManager è pronto. Niente loop infinito. */
     safeDiscoverSensors(triggeredByChange = false) {
         const dmAny = sdk?.deviceManager;
         if (!dmAny) {
-            // Posticipa una sola volta; poi riproviamo su connect MQTT e al primo messaggio
             if (!this.discoveryPostponed) {
                 this.console.log('Device discovery postponed: deviceManager not ready yet.');
                 this.discoveryPostponed = true;
@@ -34446,9 +34464,7 @@ class ParadoxMqttSecuritySystem extends ScryptedDeviceBase {
         if (triggeredByChange)
             this.console.log('Sensors discovered/updated.');
     }
-    /** discoverSensors con deviceManager garantito */
     discoverSensors(dmAny) {
-        // 1) Manifests
         const manifests = this.sensorsCfg.map(cfg => {
             const nativeId = `sensor:${cfg.id}`;
             const t = cfg.topics || {};
@@ -34465,15 +34481,11 @@ class ParadoxMqttSecuritySystem extends ScryptedDeviceBase {
                 interfaces.push(ScryptedInterface.Battery);
             return { nativeId, name: cfg.name, type: ScryptedDeviceType.Sensor, interfaces };
         });
-        // 2) Annuncio
-        if (typeof dmAny.onDevicesChanged === 'function') {
+        if (typeof dmAny.onDevicesChanged === 'function')
             dmAny.onDevicesChanged({ devices: manifests });
-        }
-        else if (typeof dmAny.onDeviceDiscovered === 'function') {
+        else if (typeof dmAny.onDeviceDiscovered === 'function')
             for (const m of manifests)
                 dmAny.onDeviceDiscovered(m);
-        }
-        // 3) Istanzia/aggiorna
         for (const cfg of this.sensorsCfg) {
             const nativeId = `sensor:${cfg.id}`;
             let dev = this.devices.get(nativeId);
@@ -34491,9 +34503,8 @@ class ParadoxMqttSecuritySystem extends ScryptedDeviceBase {
             }
             const hasBattery = !!(cfg.topics.batteryLevel || cfg.topics.lowBattery);
             if (hasBattery && dev.batteryLevel === undefined)
-                dev.batteryLevel = 100;
+                setAndEmit(dev, 'batteryLevel', 100, ScryptedInterface.Battery, `[${cfg.name}] batteryLevel=100 (default)`);
         }
-        // 4) Cleanup
         const announced = new Set(manifests.map(m => m.nativeId));
         for (const [nativeId] of this.devices) {
             if (!announced.has(nativeId)) {
@@ -34556,39 +34567,41 @@ class ParadoxMqttSecuritySystem extends ScryptedDeviceBase {
         const tOnline = this.storage.getItem('topicOnline') || '';
         client.on('connect', () => {
             this.console.log('MQTT connected');
-            this.online = true;
+            setAndEmit(this, 'online', true, ScryptedInterface.Online, `[Alarm] online=true`);
             if (subs.length)
                 client.subscribe(subs, { qos: 0 }, (err) => { if (err)
                     this.console.error('subscribe error', err); });
-            // Al primo connect riprova (silenziosamente) ad annunciare i sensori
             this.safeDiscoverSensors(true);
         });
         client.on('reconnect', () => this.console.log('MQTT reconnecting...'));
-        client.on('close', () => { this.console.log('MQTT closed'); this.online = false; });
+        client.on('close', () => { this.console.log('MQTT closed'); setAndEmit(this, 'online', false, ScryptedInterface.Online, `[Alarm] online=false`); });
         client.on('error', (e) => { this.console.error('MQTT error', e); });
         client.on('message', (topic, payload) => {
             try {
-                const p = payload?.toString() ?? '';
-                const np = normalize(p);
-                if (topic === tOnline) {
+                const raw = payload?.toString() ?? '';
+                const np = normalize(raw);
+                if (topicMatches(topic, tOnline)) {
                     if (truthy(np) || np === 'online')
-                        this.online = true;
-                    if (falsy(np) || np === 'offline')
-                        this.online = false;
+                        setAndEmit(this, 'online', true, ScryptedInterface.Online, `[Alarm] online=true (${topic})`);
+                    else if (falsy(np) || np === 'offline')
+                        setAndEmit(this, 'online', false, ScryptedInterface.Online, `[Alarm] online=false (${topic})`);
                     return;
                 }
-                if (topic === tTamper) {
-                    if (truthy(np) || ['tamper', 'intrusion', 'cover'].includes(np))
-                        this.tampered = ['cover', 'intrusion'].find(x => x === np) || true;
-                    else if (falsy(np))
-                        this.tampered = false;
+                if (topicMatches(topic, tTamper)) {
+                    if (truthy(np) || ['tamper', 'intrusion', 'cover'].includes(np)) {
+                        const t = ['cover', 'intrusion'].find(x => x === np) || true;
+                        setAndEmit(this, 'tampered', t, ScryptedInterface.TamperSensor, `[Alarm] tampered=${t} (${topic})`);
+                    }
+                    else if (falsy(np)) {
+                        setAndEmit(this, 'tampered', false, ScryptedInterface.TamperSensor, `[Alarm] tampered=false (${topic})`);
+                    }
                     return;
                 }
-                if (topic === tCurrent) {
+                if (topicMatches(topic, tCurrent)) {
                     const mode = payloadToMode(payload);
                     const isAlarm = ['alarm', 'triggered'].includes(np);
                     const current = this.securitySystemState || { mode: SecuritySystemMode.Disarmed };
-                    this.securitySystemState = {
+                    const newState = {
                         mode: mode ?? current.mode,
                         supportedModes: current.supportedModes ?? [
                             SecuritySystemMode.Disarmed,
@@ -34598,15 +34611,22 @@ class ParadoxMqttSecuritySystem extends ScryptedDeviceBase {
                         ],
                         triggered: isAlarm || undefined,
                     };
+                    if (!deepEqual(this.securitySystemState, newState)) {
+                        this.securitySystemState = newState;
+                        try {
+                            this.onDeviceEvent?.(ScryptedInterface.SecuritySystem, newState);
+                        }
+                        catch { }
+                        this.console.log(`[Alarm] currentState=${JSON.stringify(newState)} (${topic})`);
+                    }
                     return;
                 }
-                if (topic === tTarget) {
+                if (topicMatches(topic, tTarget)) {
                     this.pendingTarget = payloadToMode(payload);
-                    this.console.log('Target state reported:', p, '->', this.pendingTarget);
+                    this.console.log(`[Alarm] target reported: "${raw}" -> ${this.pendingTarget} (${topic})`);
                     return;
                 }
-                // Dispatch ai sensori
-                // (E prova ad annunciare se era stato posticipato e ora il manager è pronto)
+                // Sensors: se discovery rimandata, riprova
                 if (this.discoveryPostponed)
                     this.safeDiscoverSensors(true);
                 for (const dev of this.devices.values())

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rfranzoi/scrypted-mqtt-securitysystem",
-  "version": "1.0.37",
+  "version": "1.0.39",
   "description": "Scrypted plugin: Paradox Security System via MQTT (PAI/PAI-MQTT style).",
   "license": "MIT",
   "main": "dist/main.nodejs.js",