iobroker.eos-admin 7.9.76 → 7.9.79

package/adminWww/js/eos-manual-write-policy.js

@@ -1,75 +1,129 @@
-/* NexoWatt EOS manual datapoint write policy v7.9.76 */
+/* NexoWatt EOS manual datapoint write policy v7.9.79 */
 (function (root, factory) {
     'use strict';
     const api = factory();
     if (typeof module === 'object' && module.exports) module.exports = api;
     if (!root) return;
 
-    root.NEXOWATT_EOS_MANUAL_WRITE_POLICY_VERSION = 'v76-universal-manual-write';
+    root.NEXOWATT_EOS_MANUAL_WRITE_POLICY_VERSION = 'v79-direct-control-runtime-fix';
+    root.NEXOWATT_EOS_MANUAL_WRITE_POLICY = api;
     root.NEXOWATT_EOS_GET_WRITE_BEHAVIOR = api.getWriteBehavior;
+    root.NEXOWATT_EOS_GET_DIRECT_WRITE_VALUE = api.getDirectWriteValue;
+    root.NEXOWATT_EOS_RESOLVE_DIRECT_WRITE_VALUE = api.resolveDirectWriteValue;
+    root.NEXOWATT_EOS_GET_EXPERT_ONLY_REASON = api.getExpertOnlyReason;
     root.NEXOWATT_EOS_IS_EXPERT_ONLY_STATE = api.isExpertOnlyState;
     root.NEXOWATT_EOS_COERCE_BOOLEAN = api.toBoolean;
+    root.NEXOWATT_EOS_PREPARE_MANUAL_EDITOR = api.prepareEditor;
+    root.NEXOWATT_EOS_PARSE_MANUAL_VALUE = api.parseEditorValue;
     root.NEXOWATT_EOS_WRITE_MANUAL_STATE = api.writeManualState;
-    root.NEXOWATT_EOS_RESOLVE_EDITOR_TYPE = api.resolveEditorType;
-    root.NEXOWATT_EOS_PREPARE_EDITOR_VALUE = api.prepareEditorValue;
-    root.NEXOWATT_EOS_COERCE_WRITE_VALUE = api.coerceWriteValue;
-    root.NEXOWATT_EOS_GET_DIRECT_WRITE_VALUE = api.getDirectWriteValue;
-    root.NEXOWATT_EOS_GET_WRITE_LABEL = api.getWriteLabel;
-    root.NEXOWATT_EOS_NORMALIZE_STATES = api.normalizeStates;
 })(typeof window !== 'undefined' ? window : typeof globalThis !== 'undefined' ? globalThis : null, function () {
     'use strict';
 
-    // Manual writes are serialized per datapoint. A second command is queued
-    // instead of being silently dropped while the previous write is pending.
-    const writeQueues = new Map();
+    const pendingWrites = new Map();
 
     const normalizeText = value => String(value == null ? '' : value)
         .normalize('NFKD')
         .replace(/[\u0300-\u036f]/g, '')
-        .toLowerCase()
-        .trim();
+        .toLowerCase();
 
     const flattenTranslatedText = value => {
         if (value == null) return '';
         if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') return String(value);
-        if (typeof value === 'object') return Object.values(value).map(flattenTranslatedText).filter(Boolean).join(' ');
+        if (Array.isArray(value)) return value.map(flattenTranslatedText).join(' ');
+        if (typeof value === 'object') return Object.values(value).map(flattenTranslatedText).join(' ');
         return '';
     };
 
-    const getCommon = obj => (obj && obj.common && typeof obj.common === 'object' ? obj.common : {});
-    const getNative = obj => (obj && obj.native && typeof obj.native === 'object' ? obj.native : {});
+    const normalizeCommonType = (obj, value) => {
+        const common = obj && obj.common ? obj.common : {};
+        const type = Array.isArray(common.type) ? common.type[0] : common.type;
+        if (['number', 'string', 'boolean', 'array', 'object', 'mixed', 'file', 'json'].includes(type)) return type;
+        if (Array.isArray(value)) return 'array';
+        if (value && typeof value === 'object') return 'object';
+        if (typeof value === 'number') return 'number';
+        if (typeof value === 'boolean') return 'boolean';
+        return 'string';
+    };
 
-    const getExplicitValue = (obj, name) => {
-        const common = getCommon(obj);
-        const native = getNative(obj);
+    const normalizeStates = states => {
+        if (!states) return [];
+        if (Array.isArray(states)) return states.map((label, index) => ({ key: String(index), label: String(label) }));
+        if (typeof states === 'string') {
+            return states
+                .split(';')
+                .map(part => part.trim())
+                .filter(Boolean)
+                .map(part => {
+                    const index = part.indexOf(':');
+                    return index === -1
+                        ? { key: part, label: part }
+                        : { key: part.slice(0, index).trim(), label: part.slice(index + 1).trim() };
+                });
+        }
+        if (typeof states === 'object') {
+            return Object.entries(states).map(([key, label]) => ({ key, label: flattenTranslatedText(label) || key }));
+        }
+        return [];
+    };
+
+    const getExplicitExpertOnly = obj => {
+        const common = obj && obj.common ? obj.common : {};
+        const native = obj && obj.native ? obj.native : {};
         const custom = common.custom || {};
         const candidates = [
-            common[name],
-            native[name],
-            native.nexowatt && native.nexowatt[name],
-            custom.nexowatt && custom.nexowatt[name],
-            custom['nexowatt.eos'] && custom['nexowatt.eos'][name],
-            custom['eos-admin'] && custom['eos-admin'][name],
+            common.manualWriteExpertOnly,
+            common.expertOnly,
+            native.manualWriteExpertOnly,
+            native.nexowatt && native.nexowatt.manualWriteExpertOnly,
+            custom.nexowatt && custom.nexowatt.manualWriteExpertOnly,
+            custom['nexowatt.eos'] && custom['nexowatt.eos'].manualWriteExpertOnly,
+            custom['eos-admin'] && custom['eos-admin'].manualWriteExpertOnly,
         ];
         for (const value of candidates) {
-            if (value !== undefined) return value;
+            if (typeof value === 'boolean') return value;
         }
         return undefined;
     };
 
-    const getExplicitExpertOnly = obj => {
-        const candidates = [getExplicitValue(obj, 'manualWriteExpertOnly'), getExplicitValue(obj, 'expertOnly')];
-        for (const value of candidates) {
-            if (typeof value === 'boolean') return value;
+    const getExplicitManualValue = (obj, name) => {
+        const common = obj && obj.common ? obj.common : {};
+        const native = obj && obj.native ? obj.native : {};
+        const custom = common.custom || {};
+        const sources = [
+            common,
+            native,
+            native.nexowatt || {},
+            custom.nexowatt || {},
+            custom['nexowatt.eos'] || {},
+            custom['eos-admin'] || {},
+        ];
+        for (const source of sources) {
+            if (source && Object.prototype.hasOwnProperty.call(source, name)) {
+                return { found: true, value: source[name] };
+            }
         }
-        return undefined;
+        return { found: false, value: undefined };
     };
 
-    const isExpertOnlyState = (id, obj) => {
+    const getExplicitBinaryOptions = obj => {
+        const off = getExplicitManualValue(obj, 'manualFalseValue');
+        const on = getExplicitManualValue(obj, 'manualTrueValue');
+        return off.found && on.found ? { off: off.value, on: on.value } : null;
+    };
+
+    const isInactiveTriggerValue = value => {
+        if (value == null || value === false || value === 0) return true;
+        if (typeof value !== 'string') return false;
+        const normalized = normalizeText(value).trim();
+        return ['', 'false', '0', 'off', 'no', 'nein', 'disabled', 'inactive', 'closed', 'stop', 'aus', 'null', '(null)'].includes(normalized);
+    };
+
+    const getExpertOnlyReason = (id, obj) => {
         const explicit = getExplicitExpertOnly(obj);
-        if (explicit !== undefined) return explicit;
+        if (explicit === true) return 'explicit';
+        if (explicit === false) return '';
 
-        const common = getCommon(obj);
+        const common = obj && obj.common ? obj.common : {};
         const role = normalizeText(common.role);
         const text = normalizeText([
             id,
@@ -80,10 +134,10 @@
         ].join(' '));
         const compact = text.replace(/[^a-z0-9]+/g, '');
 
-        // Conservative safety policy for commands that can reset equipment,
-        // open contactors or materially change charging/power/current limits.
-        if (/^(?:level\.)?(?:power|current)(?:\.|$)/.test(role)) return true;
-        if (/^(?:value\.)?(?:power|current)\.setpoint(?:\.|$)/.test(role)) return true;
+        // High-confidence safety classes only. Normal setpoints such as room
+        // temperatures remain available outside expert mode.
+        if (/^(?:level\.)?(?:power|current)(?:\.|$)/.test(role)) return 'power-or-current-command';
+        if (/^(?:value\.)?(?:power|current)\.(?:setpoint|limit|target|command)(?:\.|$)/.test(role)) return 'power-or-current-command';
 
         const exactRiskTokens = [
             'hardreset', 'softreset', 'factoryreset', 'factorydefault', 'reboot', 'restartdevice', 'shutdown',
@@ -95,332 +149,286 @@
             'ladeleistung', 'entladeleistung', 'ladestrom', 'stromlimit', 'leistungsgrenze',
             'leistungssollwert', 'einspeiselimit', 'ruecksetzen', 'neustart',
         ];
-        if (exactRiskTokens.some(token => compact.includes(token))) return true;
+        if (exactRiskTokens.some(token => compact.includes(token))) return 'safety-command';
 
         const powerCommand = /(?:charge|charging|discharge|export|feedin|grid|netz|pv|lade|entlade|einspeise)[\s._/-]{0,6}(?:power|current|leistung|strom).{0,28}(?:limit|setpoint|target|command|override|control|grenze|soll|vorgabe)/;
         const inversePowerCommand = /(?:limit|setpoint|target|command|override|control|grenze|soll|vorgabe).{0,28}(?:charge|charging|discharge|export|feedin|grid|netz|pv|lade|entlade|einspeise|power|current|leistung|strom)/;
-        return powerCommand.test(text) || inversePowerCommand.test(text);
+        if (powerCommand.test(text) || inversePowerCommand.test(text)) return 'power-or-current-command';
+        return '';
     };
 
+    const isExpertOnlyState = (id, obj) => Boolean(getExpertOnlyReason(id, obj));
+
     const toBoolean = value => {
         if (value === true || value === 1) return true;
         if (value === false || value === 0 || value == null) return false;
-        const normalized = normalizeText(value);
-        if (['true', '1', 'on', 'yes', 'ja', 'enabled', 'enable', 'active', 'start', 'open', 'ein', 'an'].includes(normalized)) return true;
-        if (['false', '0', 'off', 'no', 'nein', 'disabled', 'disable', 'inactive', 'stop', 'closed', 'aus', '', 'null', '(null)'].includes(normalized)) return false;
+        const normalized = normalizeText(value).trim();
+        if (['true', '1', 'on', 'yes', 'ja', 'enabled', 'active', 'open', 'start', 'ein'].includes(normalized)) return true;
+        if (['false', '0', 'off', 'no', 'nein', 'disabled', 'inactive', 'closed', 'stop', 'aus', '', 'null', '(null)'].includes(normalized)) return false;
         return Boolean(value);
     };
 
-    const normalizeSingleCommonType = value => {
-        const type = normalizeText(value);
-        if (type === 'int' || type === 'integer' || type === 'float' || type === 'double') return 'number';
-        if (type === 'bool') return 'boolean';
-        if (type === 'object' || type === 'array') return type;
-        if (type === 'json') return 'json';
-        if (type === 'number' || type === 'boolean' || type === 'string' || type === 'mixed' || type === 'file') return type;
-        return '';
-    };
-
-    const normalizeCommonType = value => {
-        if (Array.isArray(value)) {
-            const types = [...new Set(value.map(normalizeSingleCommonType).filter(Boolean))];
-            return types.length === 1 ? types[0] : types.length ? 'mixed' : '';
+    const parseNumber = value => {
+        if (typeof value === 'number') {
+            if (!Number.isFinite(value)) throw new Error('Ungültiger Zahlenwert');
+            return value;
         }
-        return normalizeSingleCommonType(value);
-    };
-
-    const inferPrimitiveType = value => {
-        if (Array.isArray(value)) return 'array';
-        if (value !== null && typeof value === 'object') return 'object';
-        if (typeof value === 'boolean') return 'boolean';
-        if (typeof value === 'number') return 'number';
-        if (typeof value === 'string') return 'string';
-        return '';
+        const normalized = String(value == null ? '' : value).trim().replace(',', '.');
+        if (!normalized) throw new Error('Zahlenwert fehlt');
+        const parsed = Number(normalized);
+        if (!Number.isFinite(parsed)) throw new Error(`Ungültiger Zahlenwert: ${value}`);
+        return parsed;
     };
 
-    const normalizeStates = states => {
-        if (!states) return null;
-        if (Array.isArray(states)) {
-            const result = {};
-            states.forEach((value, index) => { result[String(index)] = flattenTranslatedText(value); });
-            return result;
-        }
-        if (typeof states === 'string') {
-            const result = {};
-            states.split(/[;,]/).map(part => part.trim()).filter(Boolean).forEach(part => {
-                const separator = part.includes(':') ? ':' : part.includes('=') ? '=' : '';
-                if (!separator) return;
-                const index = part.indexOf(separator);
-                const key = part.slice(0, index).trim();
-                const label = part.slice(index + 1).trim();
-                if (key) result[key] = label || key;
-            });
-            return Object.keys(result).length ? result : null;
-        }
-        if (typeof states === 'object') {
-            const result = {};
-            Object.keys(states).forEach(key => { result[String(key)] = flattenTranslatedText(states[key]); });
-            return result;
+    const parseJson = value => {
+        if (value && typeof value === 'object') return value;
+        const text = String(value == null ? '' : value).trim();
+        if (!text) throw new Error('JSON-Wert fehlt');
+        try {
+            return JSON.parse(text);
+        } catch (error) {
+            throw new Error(`Ungültiges JSON: ${error && error.message ? error.message : error}`);
         }
-        return null;
-    };
-
-    const resolveEditorType = (obj, currentValue, states) => {
-        const common = getCommon(obj);
-        const normalizedStates = normalizeStates(states || common.states);
-        if (normalizedStates && Object.keys(normalizedStates).length) return 'states';
-
-        const declared = normalizeCommonType(common.type);
-        if (declared === 'file') return 'file';
-        if (declared === 'object' || declared === 'array' || declared === 'json') return 'json';
-        if (declared === 'number' || declared === 'boolean' || declared === 'string') return declared;
-
-        const candidate = currentValue !== undefined && currentValue !== null ? currentValue : common.def;
-        const inferred = inferPrimitiveType(candidate);
-        if (inferred === 'object' || inferred === 'array') return 'json';
-        if (inferred) return inferred;
-        return 'string';
     };
 
-    const stringifyJsonValue = value => {
-        if (typeof value === 'string') {
+    const castStateKey = (key, type) => {
+        if (type === 'number') return parseNumber(key);
+        if (type === 'boolean') return toBoolean(key);
+        if (type === 'mixed') {
+            const text = String(key).trim();
+            if (/^(true|false|on|off|yes|no|ja|nein|1|0)$/i.test(text)) return toBoolean(text);
+            if (/^[+-]?(?:\d+\.?\d*|\.\d+)$/.test(text.replace(',', '.'))) return parseNumber(text);
             try {
-                return JSON.stringify(JSON.parse(value), null, 2);
+                if (/^[\[{]/.test(text)) return JSON.parse(text);
             } catch {
-                return value;
+                // keep as text
             }
+            return text;
         }
-        if (value === undefined || value === null) return '';
-        try {
-            return JSON.stringify(value, null, 2);
-        } catch {
-            return String(value);
-        }
-    };
-
-    const isNumberInRange = (value, common) => {
-        if (value === '') return false;
-        const number = Number(typeof value === 'string' ? value.trim().replace(',', '.') : value);
-        if (!Number.isFinite(number)) return false;
-        if (typeof common.min === 'number' && number < common.min) return false;
-        if (typeof common.max === 'number' && number > common.max) return false;
-        return true;
+        return String(key);
     };
 
-    const prepareEditorValue = (obj, currentValue, states) => {
-        const common = getCommon(obj);
-        const type = resolveEditorType(obj, currentValue, states);
-        const hasCurrentValue = currentValue !== undefined && currentValue !== null;
-        const hasDefault = common.def !== undefined && common.def !== null;
-        let value = hasCurrentValue ? currentValue : hasDefault ? common.def : undefined;
-        let valid = true;
-
-        if (type === 'number') {
-            if (value === undefined || value === '') {
-                value = '';
-                valid = false;
-            } else {
-                const normalized = typeof value === 'string' ? value.trim().replace(',', '.') : value;
-                const parsed = Number(normalized);
-                if (Number.isFinite(parsed)) {
-                    value = parsed;
-                    valid = isNumberInRange(parsed, common);
-                } else {
-                    value = String(value);
-                    valid = false;
-                }
-            }
-        } else if (type === 'boolean') {
-            value = toBoolean(value);
-        } else if (type === 'json') {
-            const declared = normalizeCommonType(common.type);
-            if (value === undefined) value = declared === 'array' ? '[]' : declared === 'object' ? '{}' : '';
-            value = stringifyJsonValue(value);
+    const sameValue = (left, right) => {
+        if (Object.is(left, right)) return true;
+        if (left == null || right == null) return left == null && right == null;
+        if (typeof left === 'object' || typeof right === 'object') {
             try {
-                JSON.parse(value);
-                valid = true;
+                return JSON.stringify(left) === JSON.stringify(right);
             } catch {
-                valid = false;
+                return false;
             }
-        } else if (type === 'states') {
-            value = value === undefined ? '' : value;
-            const normalizedStates = normalizeStates(states || common.states) || {};
-            valid = value !== '' && Object.prototype.hasOwnProperty.call(normalizedStates, String(value));
-        } else {
-            value = value === undefined ? '' : String(value);
         }
+        return String(left) === String(right);
+    };
 
-        return { type, value, propsValue: value, valid };
+    const sameTypedValue = (left, right, type) => {
+        if (type === 'boolean') return toBoolean(left) === toBoolean(right);
+        if (type === 'number') {
+            try { return parseNumber(left) === parseNumber(right); } catch { return sameValue(left, right); }
+        }
+        if (type === 'mixed') {
+            if (typeof right === 'boolean') return toBoolean(left) === right;
+            if (typeof right === 'number') {
+                try { return parseNumber(left) === right; } catch { return false; }
+            }
+        }
+        return sameValue(left, right);
     };
 
-    const parseNumber = (value, common) => {
-        if (value === null || value === 'null') return null;
-        const normalized = typeof value === 'string' ? value.trim().replace(',', '.') : value;
-        if (normalized === '') throw new Error('Der Zahlenwert darf nicht leer sein.');
-        const number = Number(normalized);
-        if (!Number.isFinite(number)) throw new Error(`Ungültiger Zahlenwert: ${String(value)}`);
-        if (typeof common.min === 'number' && number < common.min) throw new Error(`Wert liegt unter dem Minimum ${common.min}.`);
-        if (typeof common.max === 'number' && number > common.max) throw new Error(`Wert liegt über dem Maximum ${common.max}.`);
-        return number;
+    const optionScore = (option, mode) => {
+        const text = normalizeText(`${option.key} ${option.label}`).replace(/[^a-z0-9]+/g, ' ');
+        const offWords = ['false', '0', 'off', 'no', 'nein', 'disabled', 'inactive', 'closed', 'stop', 'aus'];
+        const onWords = ['true', '1', 'on', 'yes', 'ja', 'enabled', 'active', 'open', 'start', 'ein'];
+        const words = mode === 'on' ? onWords : offWords;
+        return words.reduce((score, word) => score + (new RegExp(`(?:^|\\s)${word}(?:\\s|$)`).test(text) ? 10 : 0), 0);
     };
 
-    const parseJsonStateValue = (value, declared) => {
-        const raw = value == null ? '' : typeof value === 'string' ? value : JSON.stringify(value);
-        if (!raw.trim()) throw new Error('Der JSON-Wert darf nicht leer sein.');
-        const parsed = JSON.parse(raw);
-        if (declared === 'array' && !Array.isArray(parsed)) throw new Error('Der Datenpunkt erwartet ein JSON-Array.');
-        if (declared === 'object' && (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed))) {
-            throw new Error('Der Datenpunkt erwartet ein JSON-Objekt.');
+    const getBinaryOptions = obj => {
+        const common = obj && obj.common ? obj.common : {};
+        const explicit = getExplicitBinaryOptions(obj);
+        if (explicit) return explicit;
+        const type = normalizeCommonType(obj);
+        const entries = normalizeStates(common.states);
+        if (entries.length > 2) return null;
+        if (entries.length === 2) {
+            const typed = entries.map(entry => ({ ...entry, value: castStateKey(entry.key, type) }));
+            const firstOff = optionScore(typed[0], 'off');
+            const firstOn = optionScore(typed[0], 'on');
+            const secondOff = optionScore(typed[1], 'off');
+            const secondOn = optionScore(typed[1], 'on');
+            if (firstOn > firstOff && secondOff >= secondOn) return { off: typed[1].value, on: typed[0].value };
+            if (secondOn > secondOff && firstOff >= firstOn) return { off: typed[0].value, on: typed[1].value };
+            return { off: typed[0].value, on: typed[1].value };
         }
-        // ioBroker StateValue is scalar. Structured values are therefore stored
-        // as a validated JSON string instead of passing an unsupported object.
-        return raw;
+        if (type === 'boolean') return { off: false, on: true };
+        if (type === 'number') {
+            const off = typeof common.min === 'number' ? common.min : 0;
+            let on = typeof common.max === 'number' ? common.max : 1;
+            if (sameValue(off, on)) on = off === 0 ? 1 : 0;
+            return { off, on };
+        }
+        if (type === 'string') return { off: 'false', on: 'true' };
+        if (type === 'mixed') return { off: false, on: true };
+        return null;
     };
 
-    const coerceByDeclaredType = (obj, value, currentValue) => {
-        const common = getCommon(obj);
-        const declared = normalizeCommonType(common.type);
-        if (value && typeof value === 'object' && Object.prototype.hasOwnProperty.call(value, 'value')) value = value.value;
-
-        if (declared === 'number') return parseNumber(value, common);
-        if (declared === 'boolean') return value === null || value === 'null' ? null : toBoolean(value);
-        if (declared === 'string') return value === null ? '' : String(value);
-        if (declared === 'object' || declared === 'array' || declared === 'json') return parseJsonStateValue(value, declared);
-
-        // mixed or missing type: preserve the current/default primitive type where possible.
-        const candidate = currentValue !== undefined && currentValue !== null ? currentValue : common.def;
-        const inferred = inferPrimitiveType(candidate);
-        if (inferred === 'number') return parseNumber(value, common);
-        if (inferred === 'boolean') return value === null || value === 'null' ? null : toBoolean(value);
-        if (inferred === 'object' || inferred === 'array') return parseJsonStateValue(value, inferred);
-        if (typeof value === 'string' && value.trim() === 'null') return null;
-        return value == null ? '' : value;
+    const isButtonState = (obj, item) => {
+        const common = obj && obj.common ? obj.common : {};
+        const role = normalizeText(common.role);
+        const data = item && item.data ? item.data : {};
+        return Boolean(data.button) || role === 'button' || role.startsWith('button.') || role === 'action' || role.startsWith('action.');
     };
 
-    const coerceStateKey = (obj, value, currentValue) => {
-        const raw = value && typeof value === 'object' && Object.prototype.hasOwnProperty.call(value, 'value') ? value.value : value;
-        return coerceByDeclaredType(obj, raw, currentValue);
+    const isSwitchState = (obj, item) => {
+        const common = obj && obj.common ? obj.common : {};
+        const role = normalizeText(common.role);
+        const data = item && item.data ? item.data : {};
+        const requested = Boolean(data.switch) || role === 'switch' || role.startsWith('switch.') || normalizeCommonType(obj) === 'boolean';
+        return requested && Boolean(getBinaryOptions(obj));
     };
 
-    const coerceWriteValue = (obj, rawValue, editorType, originalType, currentValue) => {
-        const common = getCommon(obj);
-        if (common.write === false) throw new Error('common.write=false');
-
-        if (editorType === 'states') return coerceStateKey(obj, rawValue, currentValue);
-        if (editorType === 'number') return parseNumber(rawValue, common);
-        if (editorType === 'boolean') return rawValue === null || rawValue === 'null' ? null : toBoolean(rawValue);
-        if (editorType === 'json') return parseJsonStateValue(rawValue, normalizeCommonType(common.type));
-        if (editorType === 'string') return rawValue == null ? '' : String(rawValue);
-        return coerceByDeclaredType(obj, rawValue, currentValue);
+    const getWriteBehavior = (id, obj, item, expertMode) => {
+        if (!obj || obj.type !== 'state') return 'readonly';
+        const common = obj.common || {};
+        if (common.write === false) return 'readonly';
+        if (isExpertOnlyState(id, obj) && !expertMode) return 'expert-only';
+        if (normalizeCommonType(obj) === 'file') return 'file';
+        const explicitTrigger = getExplicitManualValue(obj, 'manualTriggerValue');
+        if (isButtonState(obj, item) && (explicitTrigger.found || common.def !== undefined || !['array', 'object'].includes(normalizeCommonType(obj)))) return 'button';
+        if (isSwitchState(obj, item)) return 'switch';
+        return 'dialog';
     };
 
-    const booleanTokens = {
-        true: ['true', '1', 'on', 'yes', 'ja', 'enabled', 'enable', 'active', 'start', 'open', 'ein', 'an'],
-        false: ['false', '0', 'off', 'no', 'nein', 'disabled', 'disable', 'inactive', 'stop', 'closed', 'aus'],
+    const getDirectWriteValue = (id, obj, item, currentValue, behavior) => {
+        const common = obj && obj.common ? obj.common : {};
+        const type = normalizeCommonType(obj, currentValue);
+        const mode = behavior || getWriteBehavior(id, obj, item, true);
+        if (mode === 'button') {
+            const explicit = getExplicitManualValue(obj, 'manualTriggerValue');
+            if (explicit.found) return explicit.value;
+            // A default false/0/empty value describes the idle state of most
+            // ioBroker buttons (not the trigger payload). Only active defaults
+            // are allowed to become the command value.
+            if (common.def !== undefined && !isInactiveTriggerValue(common.def)) return common.def;
+            const options = getBinaryOptions(obj);
+            if (options) return options.on;
+            if (type === 'boolean') return true;
+            if (type === 'number') return 1;
+            if (type === 'string') return 'true';
+            if (type === 'mixed') return true;
+            if (common.def !== undefined) return common.def;
+            throw new Error(`Button-Datenpunkt ${id} benötigt einen expliziten Vorgabewert`);
+        }
+        if (mode === 'switch') {
+            const options = getBinaryOptions(obj);
+            if (!options) throw new Error(`Datenpunkt ${id} ist kein binärer Schalter`);
+            return sameTypedValue(currentValue, options.on, type) ? options.off : options.on;
+        }
+        throw new Error(`Direktes Schreiben ist für ${mode} nicht vorgesehen`);
     };
 
-    const stringTogglePairs = [
-        ['off', 'on'], ['false', 'true'], ['0', '1'], ['disabled', 'enabled'], ['disable', 'enable'],
-        ['inactive', 'active'], ['stop', 'start'], ['closed', 'open'], ['aus', 'ein'], ['nein', 'ja'],
-    ];
-
-    const findBooleanStateKey = (states, desired) => {
-        const normalized = normalizeStates(states);
-        if (!normalized) return undefined;
-        const tokens = desired ? booleanTokens.true : booleanTokens.false;
-        for (const [key, label] of Object.entries(normalized)) {
-            if (tokens.includes(normalizeText(key)) || tokens.includes(normalizeText(label))) return key;
+    const readFreshStateValue = async (socket, id, fallbackValue, timeoutMs = 1500) => {
+        if (!socket || typeof socket.getState !== 'function') return fallbackValue;
+        let timeoutHandle;
+        try {
+            const timeout = new Promise(resolve => {
+                timeoutHandle = setTimeout(() => resolve(null), timeoutMs);
+            });
+            const state = await Promise.race([Promise.resolve(socket.getState(id)), timeout]);
+            if (state && Object.prototype.hasOwnProperty.call(state, 'val')) return state.val;
+        } catch {
+            // A transient read failure must not block manual operation. The
+            // ObjectBrowser cache remains a safe fallback for the toggle.
+        } finally {
+            if (timeoutHandle) clearTimeout(timeoutHandle);
         }
-        return undefined;
+        return fallbackValue;
     };
 
-    const getStringToggleValue = (currentValue, desired) => {
-        const raw = String(currentValue == null ? '' : currentValue).trim();
-        const current = normalizeText(raw);
-        let result = desired ? 'true' : 'false';
-        for (const [falseToken, trueToken] of stringTogglePairs) {
-            if (current === falseToken || current === trueToken) {
-                result = desired ? trueToken : falseToken;
-                break;
+    const resolveDirectWriteValue = async (socket, id, obj, item, currentValue, behavior) => {
+        const mode = behavior || getWriteBehavior(id, obj, item, true);
+        const effectiveValue = mode === 'switch'
+            ? await readFreshStateValue(socket, id, currentValue)
+            : currentValue;
+        return getDirectWriteValue(id, obj, item, effectiveValue, mode);
+    };
+
+    const inferEditorType = (obj, currentValue) => {
+        const common = obj && obj.common ? obj.common : {};
+        if (normalizeStates(common.states).length) return 'states';
+        const type = normalizeCommonType(obj, currentValue);
+        if (type === 'array' || type === 'object' || type === 'json') return 'json';
+        if (type === 'mixed') return 'json';
+        if (type === 'number' || type === 'boolean' || type === 'string') return type;
+        return 'string';
+    };
+
+    const prepareEditor = (obj, currentValue) => {
+        const editorType = inferEditorType(obj, currentValue);
+        const originalType = normalizeCommonType(obj, currentValue);
+        let value = currentValue;
+        if (editorType === 'json') {
+            if (typeof value === 'string') {
+                try {
+                    value = JSON.stringify(JSON.parse(value), null, 2);
+                } catch {
+                    value = originalType === 'mixed' ? JSON.stringify(value) : value;
+                }
+            } else {
+                value = JSON.stringify(value == null ? null : value, null, 2);
             }
+        } else if (editorType === 'number') {
+            value = value == null ? '' : value;
+        } else if (editorType === 'boolean') {
+            value = toBoolean(value);
+        } else if (editorType === 'string') {
+            value = value == null ? '' : String(value);
         }
-        if (raw && raw === raw.toUpperCase()) return result.toUpperCase();
-        if (raw && raw[0] === raw[0].toUpperCase() && raw.slice(1) === raw.slice(1).toLowerCase()) {
-            return result.charAt(0).toUpperCase() + result.slice(1);
-        }
-        return result;
+        return {
+            editorType,
+            value,
+            originalType,
+        };
     };
 
-    const getDirectWriteValue = (id, obj, item, behavior, currentValue) => {
-        const common = getCommon(obj);
-        const desired = behavior === 'button' ? true : !toBoolean(currentValue);
-        const explicitName = behavior === 'button' ? 'manualTriggerValue' : desired ? 'manualTrueValue' : 'manualFalseValue';
-        const explicit = getExplicitValue(obj, explicitName);
-        if (explicit !== undefined) return coerceByDeclaredType(obj, explicit, currentValue);
+    const parseEditorValue = (obj, editorType, rawValue) => {
+        const common = obj && obj.common ? obj.common : {};
+        const originalType = normalizeCommonType(obj, rawValue);
+        let value = rawValue && typeof rawValue === 'object' && Object.prototype.hasOwnProperty.call(rawValue, 'value')
+            ? rawValue.value
+            : rawValue;
 
-        const stateKey = findBooleanStateKey(common.states, desired);
-        if (stateKey !== undefined) return coerceStateKey(obj, stateKey, currentValue);
+        if (editorType !== 'string' && value === 'null') return null;
 
-        if (behavior === 'button' && common.def !== undefined && common.def !== null) {
-            return coerceByDeclaredType(obj, common.def, currentValue);
+        if (editorType === 'states') {
+            value = castStateKey(value, originalType);
+        } else if (editorType === 'number') {
+            value = parseNumber(value);
+        } else if (editorType === 'boolean') {
+            value = toBoolean(value);
+        } else if (editorType === 'json') {
+            value = parseJson(value);
+        } else {
+            value = value == null ? '' : String(value);
         }
 
-        const declared = normalizeCommonType(common.type);
-        if (declared === 'number') {
-            if (behavior === 'switch') {
-                if (desired && typeof common.max === 'number') return common.max;
-                if (!desired && typeof common.min === 'number') return common.min;
-            }
-            return desired ? 1 : 0;
-        }
-        if (declared === 'string') return getStringToggleValue(currentValue, desired);
-        if (declared === 'object' || declared === 'array' || declared === 'json') {
-            throw new Error('Objekt-/Array-Befehle müssen über den Wertdialog gesetzt werden.');
+        if (originalType === 'number' && typeof value !== 'number') value = parseNumber(value);
+        if (originalType === 'boolean' && typeof value !== 'boolean') value = toBoolean(value);
+        if (originalType === 'string' && typeof value !== 'string') value = String(value);
+        if (originalType === 'array') {
+            if (typeof value === 'string') value = parseJson(value);
+            if (!Array.isArray(value)) throw new Error('Der Datenpunkt erwartet ein JSON-Array');
         }
-        if (declared === 'mixed') {
-            if (typeof currentValue === 'number') return desired ? 1 : 0;
-            if (typeof currentValue === 'string') return getStringToggleValue(currentValue, desired);
+        if (originalType === 'object') {
+            if (typeof value === 'string') value = parseJson(value);
+            if (!value || typeof value !== 'object' || Array.isArray(value)) throw new Error('Der Datenpunkt erwartet ein JSON-Objekt');
         }
-        return desired;
-    };
 
-    const getWriteBehavior = (id, obj, item, expertMode) => {
-        if (!obj || obj.type !== 'state') return 'readonly';
-        const common = getCommon(obj);
-        if (common.write === false) return 'readonly';
-        if (isExpertOnlyState(id, obj) && !expertMode) return 'expert-only';
-        if (normalizeCommonType(common.type) === 'file') return 'file';
-
-        const role = normalizeText(common.role);
-        const data = item && item.data ? item.data : {};
-        const declared = normalizeCommonType(common.type);
-        const explicitControl = normalizeText(
-            getExplicitValue(obj, 'manualWriteControl') !== undefined
-                ? getExplicitValue(obj, 'manualWriteControl')
-                : getExplicitValue(obj, 'manualControl'),
-        );
-        if (['button', 'trigger', 'action'].includes(explicitControl) && !['object', 'array', 'json'].includes(declared)) return 'button';
-        if (['dialog', 'value', 'editor'].includes(explicitControl)) return 'dialog';
-        if (['switch', 'toggle'].includes(explicitControl)) return 'switch';
-
-        const normalizedStates = normalizeStates(common.states);
-        const stateCount = normalizedStates ? Object.keys(normalizedStates).length : 0;
-        const isButton = Boolean(data.button) || role === 'button' || role.startsWith('button.') || role === 'action' || role.startsWith('action.') || role === 'trigger' || role.startsWith('trigger.');
-        if (isButton && declared !== 'object' && declared !== 'array' && declared !== 'json') return 'button';
-        if (declared === 'boolean') return 'switch';
-        // A numeric/string mode with more than two states is a selector, not a
-        // toggle. Treating it as a switch would make only two of its values reachable.
-        if ((Boolean(data.switch) || role === 'switch' || role.startsWith('switch.')) && stateCount <= 2) return 'switch';
-        return 'dialog';
-    };
-
-    const getWriteLabel = (id, obj, behavior, expertMode, hasState) => {
-        if (behavior === 'readonly') return 'Nur lesbar';
-        if (behavior === 'expert-only') return 'Nur im Expertenmodus beschreibbar';
-        if (behavior === 'button') return 'Befehl auslösen';
-        if (behavior === 'switch') return 'Schalten';
-        if (!hasState) return 'Wert setzen (schreibender Datenpunkt ohne aktuellen Lesewert)';
-        return 'Wert bearbeiten';
+        if (typeof value === 'number') {
+            if (typeof common.min === 'number' && value < common.min) throw new Error(`Wert liegt unter dem Minimum ${common.min}`);
+            if (typeof common.max === 'number' && value > common.max) throw new Error(`Wert liegt über dem Maximum ${common.max}`);
+        }
+        return value;
     };
 
     const writeManualState = (socket, id, value) => {
@@ -429,41 +437,43 @@
         }
         const key = String(id || '');
         if (!key) return Promise.reject(new Error('Missing datapoint ID'));
-        if (value === undefined) return Promise.reject(new Error(`Undefined is not a valid state value for ${key}`));
-        if (value !== null && !['string', 'number', 'boolean'].includes(typeof value)) {
-            return Promise.reject(new Error(`Unsupported state value type for ${key}: ${typeof value}`));
-        }
 
-        const previous = writeQueues.get(key) || Promise.resolve();
-        const operation = previous.catch(() => undefined).then(() => {
-            let timeoutHandle;
-            const write = Promise.resolve().then(() => socket.setState(key, { val: value, ack: false, q: 0 }));
+        const previous = pendingWrites.get(key);
+        if (previous && sameValue(previous.value, value)) return previous.promise;
+
+        const predecessor = previous ? previous.promise.catch(() => undefined) : Promise.resolve();
+        let timeoutHandle;
+        const operation = predecessor.then(() => {
+            const write = Promise.resolve(socket.setState(key, { val: value, ack: false, q: 0 }));
             const timeout = new Promise((_, reject) => {
                 timeoutHandle = setTimeout(() => reject(new Error(`Write timeout for ${key}`)), 15000);
             });
-            return Promise.race([write, timeout]).finally(() => {
-                if (timeoutHandle) clearTimeout(timeoutHandle);
-            });
+            return Promise.race([write, timeout]);
         });
-        const tail = operation.finally(() => {
-            if (writeQueues.get(key) === tail) writeQueues.delete(key);
+        const promise = operation.finally(() => {
+            if (timeoutHandle) clearTimeout(timeoutHandle);
+            const active = pendingWrites.get(key);
+            if (active && active.promise === promise) pendingWrites.delete(key);
         });
-        writeQueues.set(key, tail);
-        return operation;
+        pendingWrites.set(key, { value, promise });
+        return promise;
     };
 
     return {
+        normalizeCommonType,
+        normalizeStates,
         getExplicitExpertOnly,
+        getExpertOnlyReason,
         isExpertOnlyState,
+        getBinaryOptions,
         getWriteBehavior,
-        getWriteLabel,
-        resolveEditorType,
-        prepareEditorValue,
-        coerceWriteValue,
         getDirectWriteValue,
+        resolveDirectWriteValue,
+        readFreshStateValue,
+        inferEditorType,
+        prepareEditor,
+        parseEditorValue,
         toBoolean,
         writeManualState,
-        normalizeStates,
-        normalizeCommonType,
     };
 });