iobroker.eos-admin 7.9.75 → 7.9.76

package/adminWww/assets/sentry-B7YeoTAx-v71.js

@@ -1 +1 @@
-export * from "./sentry-B7YeoTAx-v75.js";
+export * from "./sentry-B7YeoTAx-v76.js";

package/adminWww/assets/sentry-B7YeoTAx-v72.js

@@ -1 +1 @@
-export * from "./sentry-B7YeoTAx-v75.js";
+export * from "./sentry-B7YeoTAx-v76.js";

package/adminWww/assets/sentry-B7YeoTAx-v73.js

@@ -1 +1 @@
-export * from "./sentry-B7YeoTAx-v75.js";
+export * from "./sentry-B7YeoTAx-v76.js";

package/adminWww/assets/sentry-B7YeoTAx-v74.js

@@ -1 +1 @@
-export * from "./sentry-B7YeoTAx-v75.js";
+export * from "./sentry-B7YeoTAx-v76.js";

package/adminWww/assets/sentry-B7YeoTAx-v75.js

@@ -1 +1 @@
-import{j as s}from"./DefaultPropsProvider-BiXBMQYQ.js";import{i as f}from"./iobroker_admin__loadShare__react__loadShare__-LM7uyL45.js";import{a as t,i as h}from"./iobroker_admin__loadShare___mf_0_mui_mf_1_icons_mf_2_material__loadShare__-CJO5yP3h.js";const p={},b={All:t.AllInclusive,messaging:t.Message,communication:t.WifiTethering,general:t.Apps,logic:t.VpnKey,alarm:t.NotificationsActive,"iot-systems":t.SystemUpdateAlt,"misc-data":t.EmojiSymbols,multimedia:t.PermMedia,network:t.SettingsEthernet,storage:t.Storage,visualization:t.Visibility,"climate-control":t.SettingsBrightness,"date-and-time":t.DateRange,energy:t.BatteryChargingFull,garden:t.FilterVintage,geoposition:t.LocationOn,hardware:t.Phonelink,health:t.Favorite,household:t.House,infrastructure:t.Apartment,lighting:t.EmojiObjects,protocols:t.DialerSip,utility:t.PhonelinkSetup,vehicle:t.AirportShuttle,"visualization-icons":t.BubbleChart,"visualization-widgets":t.Widgets,weather:t.Brightness6,metering:t.LinearScale};function x({iconName:d,className:a,adapter:n,socket:e,onClick:r,style:m}){const[_,g]=f.useState("");if(f.useEffect(()=>{n&&e&&(p[n]instanceof Promise||(p[n]=e.getObject(`system.adapter.${n}`)),p[n].then(o=>{var c;return((c=o==null?void 0:o.common)==null?void 0:c.icon)&&g(`../../adapter/${n}/${o.common.icon}`)}))},[n,e]),n)return s.jsx("img",{onClick:o=>r&&r(o),src:_||"",className:a,style:m,alt:""});const l=b[d]||t.Help;return s.jsx(l,{className:a,style:m,onClick:o=>r&&r(o)})}const y={button:{marginLeft:10,marginRight:10},icon:{marginRight:5}};function E({arrayItem:d,title:a,onClick:n,value:e,contained:r,buttonIcon:m,icons:_,t:g,translateSuffix:l,noTranslation:o}){const[c,u]=f.useState(null);return l=l||"",s.jsxs(s.Fragment,{children:[s.jsx(h.Tooltip,{title:a||"",slotProps:{popper:{sx:{pointerEvents:"none"}}},children:s.jsxs(h.Button,{style:y.button,variant:r?"contained":"outlined",color:"primary",onClick:i=>u(i.currentTarget),children:[m||_&&s.jsx(x,{iconName:e,style:y.icon}),typeof e=="number"||o?e:g(e+l)]})}),s.jsx(h.Menu,{anchorEl:c,open:!!c,disableScrollLock:!0,marginThreshold:8,anchorOrigin:{vertical:"bottom",horizontal:"left"},transformOrigin:{vertical:"top",horizontal:"left"},slotProps:{root:{className:"eos-module-filter-menu"},paper:{className:"eos-module-filter-menu-paper",sx:{minWidth:180,maxWidth:"min(420px, calc(100vw - 24px))",maxHeight:"min(70vh, 640px)",overflowY:"auto"}}},onClose:()=>u(null),children:d.map(({name:i},S)=>s.jsxs(h.MenuItem,{selected:e||e===0?i===e:S===0,disabled:e||e===0?i===e:S===0,className:`tag-card-${i}`,style:{placeContent:"space-between"},value:i,onClick:()=>{n(i),u(null)},children:[_&&s.jsx(x,{iconName:i,style:y.icon}),typeof i=="number"||o?i:g(i+l)]},i))})]})}const A="data:image/svg+xml,%3csvg%20viewBox='0%200%20256%20230'%20xmlns='http://www.w3.org/2000/svg'%3e%3cpath%20d='M251.22%20187.856c5.785%2010.045%206.345%2020.608%201.538%2028.958-4.8%208.357-14.192%2013.143-25.768%2013.143h-21.816c.259-4.068.431-8.17.431-12.302%200-4.628-.215-9.198-.531-13.754l14.35-.014c3.528%200%206.38-2.867%206.38-6.403a6.46%206.46%200%200%200-.768-3.053l-91.46-158.97a6.349%206.349%200%200%200-5.54-3.24%206.374%206.374%200%200%200-5.461%203.09l-14.522%2025.243c44.134%2033.27%2073.804%2084.813%2077.864%20143.333.316%204.548.531%209.119.531%2013.753%200%204.132-.172%208.228-.424%2012.302h-71.246c.388-4.053.611-8.148.611-12.302%200-4.649-.273-9.233-.776-13.753-3.52-32.206-19.286-60.748-42.503-80.89l-10.003%2017.376c17.54%2016.325%2029.512%2038.558%2032.767%2063.514.59%204.505.92%209.09.92%2013.753%200%204.154-.273%208.264-.74%2012.302H29.01c-11.576%200-20.968-4.793-25.768-13.15-4.807-8.35-4.247-18.905%201.538-28.958l13.56-23.238a79.42%2079.42%200%200%201%2020.715%2016.052l-8.083%2013.768a6.523%206.523%200%200%200-.77%203.054%206.383%206.383%200%200%200%206.382%206.395l32.033.015c-2.687-15.356-9.772-29.21-19.918-40.183-5.979-6.445-12.963-11.9-20.738-16.074l35.77-62.15a151.427%20151.427%200%200%201%2021.564%2014.624c30.827%2025.013%2051.644%2061.955%2055.416%20103.776h19.172c-3.91-48.892-28.477-92.006-64.937-120.548a171.205%20171.205%200%200%200-21.672-14.457l30.532-53.045C109.583%205.77%20118.42%200%20128.036%200c9.607%200%2018.438%205.77%2024.223%2015.823l98.961%20172.033z'%20fill='%23FB2D26'/%3e%3c/svg%3e";export{E as C,x as M,A as s};
+export * from "./sentry-B7YeoTAx-v76.js";

package/adminWww/assets/sentry-B7YeoTAx-v76.js

@@ -0,0 +1 @@
+import{j as s}from"./DefaultPropsProvider-BiXBMQYQ.js";import{i as f}from"./iobroker_admin__loadShare__react__loadShare__-LM7uyL45.js";import{a as t,i as h}from"./iobroker_admin__loadShare___mf_0_mui_mf_1_icons_mf_2_material__loadShare__-CJO5yP3h.js";const p={},b={All:t.AllInclusive,messaging:t.Message,communication:t.WifiTethering,general:t.Apps,logic:t.VpnKey,alarm:t.NotificationsActive,"iot-systems":t.SystemUpdateAlt,"misc-data":t.EmojiSymbols,multimedia:t.PermMedia,network:t.SettingsEthernet,storage:t.Storage,visualization:t.Visibility,"climate-control":t.SettingsBrightness,"date-and-time":t.DateRange,energy:t.BatteryChargingFull,garden:t.FilterVintage,geoposition:t.LocationOn,hardware:t.Phonelink,health:t.Favorite,household:t.House,infrastructure:t.Apartment,lighting:t.EmojiObjects,protocols:t.DialerSip,utility:t.PhonelinkSetup,vehicle:t.AirportShuttle,"visualization-icons":t.BubbleChart,"visualization-widgets":t.Widgets,weather:t.Brightness6,metering:t.LinearScale};function x({iconName:d,className:a,adapter:n,socket:e,onClick:r,style:m}){const[_,g]=f.useState("");if(f.useEffect(()=>{n&&e&&(p[n]instanceof Promise||(p[n]=e.getObject(`system.adapter.${n}`)),p[n].then(o=>{var c;return((c=o==null?void 0:o.common)==null?void 0:c.icon)&&g(`../../adapter/${n}/${o.common.icon}`)}))},[n,e]),n)return s.jsx("img",{onClick:o=>r&&r(o),src:_||"",className:a,style:m,alt:""});const l=b[d]||t.Help;return s.jsx(l,{className:a,style:m,onClick:o=>r&&r(o)})}const y={button:{marginLeft:10,marginRight:10},icon:{marginRight:5}};function E({arrayItem:d,title:a,onClick:n,value:e,contained:r,buttonIcon:m,icons:_,t:g,translateSuffix:l,noTranslation:o}){const[c,u]=f.useState(null);return l=l||"",s.jsxs(s.Fragment,{children:[s.jsx(h.Tooltip,{title:a||"",slotProps:{popper:{sx:{pointerEvents:"none"}}},children:s.jsxs(h.Button,{style:y.button,variant:r?"contained":"outlined",color:"primary",onClick:i=>u(i.currentTarget),children:[m||_&&s.jsx(x,{iconName:e,style:y.icon}),typeof e=="number"||o?e:g(e+l)]})}),s.jsx(h.Menu,{anchorEl:c,open:!!c,disableScrollLock:!0,marginThreshold:8,anchorOrigin:{vertical:"bottom",horizontal:"left"},transformOrigin:{vertical:"top",horizontal:"left"},slotProps:{root:{className:"eos-module-filter-menu"},paper:{className:"eos-module-filter-menu-paper",sx:{minWidth:180,maxWidth:"min(420px, calc(100vw - 24px))",maxHeight:"min(70vh, 640px)",overflowY:"auto"}}},onClose:()=>u(null),children:d.map(({name:i},S)=>s.jsxs(h.MenuItem,{selected:e||e===0?i===e:S===0,disabled:e||e===0?i===e:S===0,className:`tag-card-${i}`,style:{placeContent:"space-between"},value:i,onClick:()=>{n(i),u(null)},children:[_&&s.jsx(x,{iconName:i,style:y.icon}),typeof i=="number"||o?i:g(i+l)]},i))})]})}const A="data:image/svg+xml,%3csvg%20viewBox='0%200%20256%20230'%20xmlns='http://www.w3.org/2000/svg'%3e%3cpath%20d='M251.22%20187.856c5.785%2010.045%206.345%2020.608%201.538%2028.958-4.8%208.357-14.192%2013.143-25.768%2013.143h-21.816c.259-4.068.431-8.17.431-12.302%200-4.628-.215-9.198-.531-13.754l14.35-.014c3.528%200%206.38-2.867%206.38-6.403a6.46%206.46%200%200%200-.768-3.053l-91.46-158.97a6.349%206.349%200%200%200-5.54-3.24%206.374%206.374%200%200%200-5.461%203.09l-14.522%2025.243c44.134%2033.27%2073.804%2084.813%2077.864%20143.333.316%204.548.531%209.119.531%2013.753%200%204.132-.172%208.228-.424%2012.302h-71.246c.388-4.053.611-8.148.611-12.302%200-4.649-.273-9.233-.776-13.753-3.52-32.206-19.286-60.748-42.503-80.89l-10.003%2017.376c17.54%2016.325%2029.512%2038.558%2032.767%2063.514.59%204.505.92%209.09.92%2013.753%200%204.154-.273%208.264-.74%2012.302H29.01c-11.576%200-20.968-4.793-25.768-13.15-4.807-8.35-4.247-18.905%201.538-28.958l13.56-23.238a79.42%2079.42%200%200%201%2020.715%2016.052l-8.083%2013.768a6.523%206.523%200%200%200-.77%203.054%206.383%206.383%200%200%200%206.382%206.395l32.033.015c-2.687-15.356-9.772-29.21-19.918-40.183-5.979-6.445-12.963-11.9-20.738-16.074l35.77-62.15a151.427%20151.427%200%200%201%2021.564%2014.624c30.827%2025.013%2051.644%2061.955%2055.416%20103.776h19.172c-3.91-48.892-28.477-92.006-64.937-120.548a171.205%20171.205%200%200%200-21.672-14.457l30.532-53.045C109.583%205.77%20118.42%200%20128.036%200c9.607%200%2018.438%205.77%2024.223%2015.823l98.961%20172.033z'%20fill='%23FB2D26'/%3e%3c/svg%3e";export{E as C,x as M,A as s};

package/adminWww/css/eos-branding.css

@@ -3764,7 +3764,7 @@ html.eos-objects-surface [data-eos-scalar-capture="1"]:hover {
     box-shadow: inset 0 0 0 1px rgba(0, 255, 136, .30) !important;
 }
 
-/* === NexoWatt EOS v7.9.75: type-aware manual datapoint controls =========
+/* === NexoWatt EOS v7.9.76: universal manual datapoint controls =========
    Button/trigger and boolean switch states use the whole value cell as one
    deterministic action target. Safety-relevant commands remain visible but
    are locked outside expert mode. */
@@ -3811,3 +3811,41 @@ html .eos-object-value-cell[data-eos-expert-only="1"]:hover {
     background: rgba(255, 177, 0, .11) !important;
     box-shadow: inset 0 0 0 1px rgba(255, 177, 0, .25) !important;
 }
+
+/* === NexoWatt EOS v7.9.76: universal manual write surface ================
+   Every declared writable state gets a deterministic full-cell hit target.
+   Write-only states without a current read value show a visible placeholder.
+   The object browser remains responsible for ACL and common.write semantics. */
+html.eos-app.eos-objects-surface .eos-object-value-cell[data-eos-object-writable="1"],
+html.eos-objects-surface .eos-object-value-cell[data-eos-object-writable="1"] {
+    min-height: 32px !important;
+    display: flex !important;
+    align-items: center !important;
+    width: 100% !important;
+    box-sizing: border-box !important;
+    pointer-events: auto !important;
+    cursor: pointer !important;
+}
+html.eos-app.eos-objects-surface .eos-object-value-cell[data-eos-write-behavior="dialog"],
+html.eos-objects-surface .eos-object-value-cell[data-eos-write-behavior="dialog"] {
+    cursor: text !important;
+}
+html.eos-app.eos-objects-surface .eos-write-placeholder,
+html.eos-objects-surface .eos-write-placeholder {
+    display: inline-flex !important;
+    align-items: center !important;
+    min-height: 26px !important;
+    padding: 0 8px !important;
+    border: 1px dashed rgba(0, 255, 170, .42) !important;
+    border-radius: 7px !important;
+    color: rgba(226, 255, 246, .82) !important;
+    background: rgba(0, 255, 170, .055) !important;
+    font-size: 12px !important;
+    line-height: 1.2 !important;
+    pointer-events: none !important;
+}
+html.eos-app.eos-objects-surface .eos-object-value-cell[data-eos-object-writable="1"]:focus-visible,
+html.eos-objects-surface .eos-object-value-cell[data-eos-object-writable="1"]:focus-visible {
+    outline: 2px solid rgba(0, 255, 170, .75) !important;
+    outline-offset: -2px !important;
+}

package/adminWww/index.html

@@ -7,9 +7,9 @@
         <meta http-equiv="Cache-Control" content="no-store, no-cache, must-revalidate" />
         <meta http-equiv="Pragma" content="no-cache" />
         <meta http-equiv="Expires" content="0" />
-          <script src="./js/eos-console-quiet.js?v=75"></script>
-          <script src="./js/eos-manual-write-policy.js?v=75"></script>
-          <script type="module" src="./assets/hostInit-v75.js?v=75"></script>
+          <script src="./js/eos-console-quiet.js?v=76"></script>
+          <script src="./js/eos-manual-write-policy.js?v=76"></script>
+          <script type="module" src="./assets/hostInit-v76.js?v=76"></script>
         
         <meta charset="utf-8" />
         <link
@@ -36,7 +36,7 @@
             rel="stylesheet"
             href="css/leaflet.css"
         />
-        <link rel="stylesheet" href="./css/eos-branding.css?v=75" />
+        <link rel="stylesheet" href="./css/eos-branding.css?v=76" />
         <link
             rel="manifest"
             href="manifest.json"
@@ -156,15 +156,15 @@
                 false,
             );
         </script>
-      <script type="module" crossorigin src="./assets/index-CQZugZ1z-v75.js?v=75"></script>
+      <script type="module" crossorigin src="./assets/index-CQZugZ1z-v76.js?v=76"></script>
       <link rel="modulepreload" crossorigin href="./assets/preload-helper-BDBacUwf.js">
       <link rel="modulepreload" crossorigin href="./assets/iobroker_admin__mf_v__runtimeInit__mf_v__-g2X2zhAf.js">
-            <script defer src="./js/eos-policy-client.js?v=75"></script>
-            <script defer src="./js/eos-branding.js?v=75"></script>
-            <script defer src="./js/eos-security-ui.js?v=75"></script>
-            <script defer src="./js/eos-role-ui.js?v=75"></script>
-            <script defer src="./js/eos-assistant.js?v=75"></script>
-            <script defer src="./js/eos-objects-state-tools.js?v=75"></script>
+            <script defer src="./js/eos-policy-client.js?v=76"></script>
+            <script defer src="./js/eos-branding.js?v=76"></script>
+            <script defer src="./js/eos-security-ui.js?v=76"></script>
+            <script defer src="./js/eos-role-ui.js?v=76"></script>
+            <script defer src="./js/eos-assistant.js?v=76"></script>
+            <script defer src="./js/eos-objects-state-tools.js?v=76"></script>
     </head>
     <body>
         <noscript>You need to enable JavaScript to run this app.</noscript>

package/adminWww/js/eos-branding.js

@@ -1,7 +1,7 @@
 (() => {
     'use strict';
 
-    window.NEXOWATT_EOS_UI_VERSION = 'v75-type-aware-manual-controls';
+    window.NEXOWATT_EOS_UI_VERSION = 'v76-universal-manual-write';
 
     const BRAND = 'NexoWatt EOS';
     const EOS_MEANING = 'Energy Operation System';

package/adminWww/js/eos-console-quiet.js

@@ -1,6 +1,6 @@
 (() => {
     'use strict';
-    window.NEXOWATT_EOS_CONSOLE_QUIET_VERSION = 'v75-type-aware-manual-controls';
+    window.NEXOWATT_EOS_CONSOLE_QUIET_VERSION = 'v76-universal-manual-write';
     // Diagnostic output is intentionally left untouched in the stability release.
     // Suppressing broad console prefixes hid important performance and runtime clues.
     window.NEXOWATT_EOS_RESTORE_CONSOLE = () => undefined;

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

@@ -1,45 +1,64 @@
-/* NexoWatt EOS manual datapoint write policy v7.9.75 */
+/* NexoWatt EOS manual datapoint write policy v7.9.76 */
 (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 = 'v75-type-aware-manual-controls';
+    root.NEXOWATT_EOS_MANUAL_WRITE_POLICY_VERSION = 'v76-universal-manual-write';
     root.NEXOWATT_EOS_GET_WRITE_BEHAVIOR = api.getWriteBehavior;
     root.NEXOWATT_EOS_IS_EXPERT_ONLY_STATE = api.isExpertOnlyState;
     root.NEXOWATT_EOS_COERCE_BOOLEAN = api.toBoolean;
     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';
 
-    const pendingWrites = new Map();
+    // 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 normalizeText = value => String(value == null ? '' : value)
         .normalize('NFKD')
         .replace(/[\u0300-\u036f]/g, '')
-        .toLowerCase();
+        .toLowerCase()
+        .trim();
 
     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).join(' ');
+        if (typeof value === 'object') return Object.values(value).map(flattenTranslatedText).filter(Boolean).join(' ');
         return '';
     };
 
-    const getExplicitExpertOnly = obj => {
-        const common = obj && obj.common ? obj.common : {};
-        const native = obj && obj.native ? obj.native : {};
+    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 getExplicitValue = (obj, name) => {
+        const common = getCommon(obj);
+        const native = getNative(obj);
         const custom = common.custom || {};
         const candidates = [
-            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,
+            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],
         ];
+        for (const value of candidates) {
+            if (value !== undefined) 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;
         }
@@ -50,7 +69,7 @@
         const explicit = getExplicitExpertOnly(obj);
         if (explicit !== undefined) return explicit;
 
-        const common = obj && obj.common ? obj.common : {};
+        const common = getCommon(obj);
         const role = normalizeText(common.role);
         const text = normalizeText([
             id,
@@ -61,7 +80,8 @@
         ].join(' '));
         const compact = text.replace(/[^a-z0-9]+/g, '');
 
-        // Writable raw power/current commands are never exposed in normal mode.
+        // 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;
 
@@ -85,54 +105,365 @@
     const toBoolean = value => {
         if (value === true || value === 1) return true;
         if (value === false || value === 0 || value == null) return false;
-        const normalized = normalizeText(value).trim();
-        if (['true', '1', 'on', 'yes', 'ja', 'enabled', 'active'].includes(normalized)) return true;
-        if (['false', '0', 'off', 'no', 'nein', 'disabled', 'inactive', '', 'null', '(null)'].includes(normalized)) 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;
         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' : '';
+        }
+        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 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;
+        }
+        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') {
+            try {
+                return JSON.stringify(JSON.parse(value), null, 2);
+            } catch {
+                return value;
+            }
+        }
+        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;
+    };
+
+    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);
+            try {
+                JSON.parse(value);
+                valid = true;
+            } catch {
+                valid = 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 { type, value, propsValue: value, valid };
+    };
+
+    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 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.');
+        }
+        // ioBroker StateValue is scalar. Structured values are therefore stored
+        // as a validated JSON string instead of passing an unsupported object.
+        return raw;
+    };
+
+    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 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 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 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 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;
+        }
+        return undefined;
+    };
+
+    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;
+            }
+        }
+        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;
+    };
+
+    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 stateKey = findBooleanStateKey(common.states, desired);
+        if (stateKey !== undefined) return coerceStateKey(obj, stateKey, currentValue);
+
+        if (behavior === 'button' && common.def !== undefined && common.def !== null) {
+            return coerceByDeclaredType(obj, common.def, currentValue);
+        }
+
+        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 (declared === 'mixed') {
+            if (typeof currentValue === 'number') return desired ? 1 : 0;
+            if (typeof currentValue === 'string') return getStringToggleValue(currentValue, desired);
+        }
+        return desired;
+    };
+
     const getWriteBehavior = (id, obj, item, expertMode) => {
         if (!obj || obj.type !== 'state') return 'readonly';
-        const common = obj.common || {};
+        const common = getCommon(obj);
         if (common.write === false) return 'readonly';
         if (isExpertOnlyState(id, obj) && !expertMode) return 'expert-only';
-        if (common.type === 'file') return 'file';
+        if (normalizeCommonType(common.type) === 'file') return 'file';
 
         const role = normalizeText(common.role);
         const data = item && item.data ? item.data : {};
-        const isButton = Boolean(data.button) || role === 'button' || role.startsWith('button.') || role === 'action' || role.startsWith('action.');
-        if (isButton) return 'button';
-        if (Boolean(data.switch) || role === 'switch' || role.startsWith('switch.') || common.type === 'boolean') return 'switch';
+        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';
+    };
+
     const writeManualState = (socket, id, value) => {
         if (!socket || typeof socket.setState !== 'function') {
             return Promise.reject(new Error('ioBroker socket is not ready'));
         }
         const key = String(id || '');
         if (!key) return Promise.reject(new Error('Missing datapoint ID'));
-        if (pendingWrites.has(key)) return pendingWrites.get(key);
+        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}`));
+        }
 
-        let timeoutHandle;
-        const operation = Promise.resolve().then(() => socket.setState(key, { val: value, ack: false, q: 0 }));
-        const timeout = new Promise((_, reject) => {
-            timeoutHandle = setTimeout(() => reject(new Error(`Write timeout for ${key}`)), 15000);
-        });
-        const promise = Promise.race([operation, timeout])
-            .finally(() => {
+        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 timeout = new Promise((_, reject) => {
+                timeoutHandle = setTimeout(() => reject(new Error(`Write timeout for ${key}`)), 15000);
+            });
+            return Promise.race([write, timeout]).finally(() => {
                 if (timeoutHandle) clearTimeout(timeoutHandle);
-                pendingWrites.delete(key);
             });
-        pendingWrites.set(key, promise);
-        return promise;
+        });
+        const tail = operation.finally(() => {
+            if (writeQueues.get(key) === tail) writeQueues.delete(key);
+        });
+        writeQueues.set(key, tail);
+        return operation;
     };
 
     return {
         getExplicitExpertOnly,
         isExpertOnlyState,
         getWriteBehavior,
+        getWriteLabel,
+        resolveEditorType,
+        prepareEditorValue,
+        coerceWriteValue,
+        getDirectWriteValue,
         toBoolean,
         writeManualState,
+        normalizeStates,
+        normalizeCommonType,
     };
 });