iobroker.alias-workbench 0.9.9 → 0.9.11

package/admin/js/vorlagenblatt.js

@@ -11,7 +11,7 @@ import { katalogFehlt } from './katalog.js';
 import { funktionsAuswahl, kennungZuFunktion } from './aufzaehlungen.js';
 import { musterVon, platzFuerRolle, typenFuerRolle } from './erkennung.js';
 import { musterZeile, musterName } from './musternamen.js';
-import { ladeVorlagen, aendereVorlagen, setzeMeta, pruefeVorlage, hinweisTaugt, INSTANZ_ID } from './vorlagen.js';
+import { ladeVorlagen, aendereVorlagen, setzeMeta, pruefeVorlage, wendeAn, hinweisTaugt, INSTANZ_ID } from './vorlagen.js';
 import { kindZustaende, hatPunkt, feldAusFormel } from './werte.js';
 import { opt } from './entwurf.js';
 import { zeichneErgebnis } from './ergebnis.js';
@@ -287,7 +287,17 @@ export function zeichneVorlagenBlatt(host) {
      Musterschluessel. musterwahl.js loest es seit laengerem so. */
   (D ? Object.keys(D.patterns).sort() : []).forEach(function (m) {
     var typ = D.patterns[m].type || m;
-    var o = opt(typ, musterZeile(m));
+    /* Beschriftet wird nach dem TYP, nicht nach dem Musterschluessel.
+
+       Der Wert stand seit dem 11.09.2026 richtig da, die Beschriftung
+       nicht: `musterZeile(m)` schlug den Schluessel nach, und fuer die
+       drei Muster, die anders heissen als ihr Typ (`blinds`,
+       `mediaPlayer`, `levelSlider`), kennt der Admin keinen Beinamen.
+       Im Feld stand am Rollladen deshalb „blinds" statt „Jalousien ·
+       blind" - der Musterschluessel, den der Nutzer nirgends sonst
+       sieht. Die Musterwahl (musterwahl.js) geht seit jeher ueber den
+       Typ. Gefunden produktiv am 15.09.2026 (I37). */
+    var o = opt(typ, musterZeile(typ));
     if (typ === v.geraetetyp) { o.selected = true; }
     st.appendChild(o);
   });
@@ -465,6 +475,18 @@ export function zeichneVorlagenBlatt(host) {
     ? probelauf(ohneUnterstrich(v), v._quelle === 'benutzer') : [];
   var gew = treffer.filter(function (t) { return t.gewinnt; }).length;
   ph2.appendChild(el('span', 'chip ' + (gew ? 'ok' : 'warn'), tr('tpls.hits', treffer.length, gew)));
+  /* „Getroffen" heisst nur, dass die Erkennung anspringt. Wie oft die
+     Vorlage danach gar nicht antreten kann, weil eine Pflichtzeile ihre
+     Quelle nicht findet, gehoert daneben — das ist die Zahl, an der man
+     beim Bauen einer Vorlage merkt, dass ihre Erkennung breiter greift
+     als ihre Zeilen. Neutral gefaerbt: eine Spezialvorlage SOLL auf die
+     meisten Geraete nicht passen. */
+  var passtNicht = treffer.filter(function (t) { return !t.greift; }).length;
+  if (passtNicht) {
+    var cl = el('span', 'chip mut', tr('tpls.fitsNot', passtNicht));
+    cl.title = tr('tpls.needsRowHint');
+    ph2.appendChild(cl);
+  }
   pk.appendChild(ph2);
   var pb2 = el('div');
   pb2.style.padding = '9px 12px 11px';
@@ -473,14 +495,35 @@ export function zeichneVorlagenBlatt(host) {
   } else {
     treffer.slice(0, 40).forEach(function (t) {
       var r = el('div', 'slot');
-      r.style.gridTemplateColumns = '1fr 110px 150px';
+      /* Die Kennung darf schrumpfen, die Marke rechts nicht: ihr Text
+         ist nicht umbrechbar (`.chip` steht auf nowrap) und wuerde in
+         einer festen Spalte abgeschnitten. */
+      r.style.gridTemplateColumns = 'minmax(0,1fr) 72px 64px auto';
       var idl = el('span', 'sn', t.id);
       idl.style.fontFamily = 'var(--mono)';
+      idl.style.wordBreak = 'break-all';
       r.appendChild(idl);
       r.appendChild(el('span', 'rx', tr('tpls.evidence', t.eigen.belege)));
-      r.appendChild(el('span', 'chip ' + (t.gewinnt ? 'ok' : 'bad'),
-        t.gewinnt ? (t.gegner ? tr('tpls.beats', textIn(t.gegner.vorlage.name, sprache)) : tr('tpls.onlyOne'))
-                  : tr('tpls.losesTo', textIn(t.gegner.vorlage.name, sprache))));
+      /* Wie viele Zeilen dort wirklich entstehen. Die Belege sagen, wie
+         gut die Erkennung greift; erst die Zeilen sagen, was dabei
+         herauskommt. */
+      r.appendChild(el('span', 'rx',
+        t.zeilen === 1 ? tr('tpls.rowBuilt') : tr('tpls.rowsBuilt', t.zeilen)));
+      /* Drei Ausgaenge, nicht zwei: gewonnen und getragen, duenn
+         gewonnen, verloren. Der mittlere sah ohne eigene Marke aus wie
+         ein Erfolg. */
+      if (!t.greift) {
+        /* Passt hier nicht — und es steht dabei, woran es liegt. Ohne
+           den Namen der Zeile raet man, welches Feld am Geraet fehlt. */
+        var cn = el('span', 'chip bad', t.fehlendeZeile
+          ? tr('tpls.needsRow', t.fehlendeZeile) : tr('tpls.buildsNone'));
+        cn.title = tr('tpls.needsRowHint');
+        r.appendChild(cn);
+      } else {
+        r.appendChild(el('span', 'chip ' + (t.gewinnt ? 'ok' : 'bad'),
+          t.gewinnt ? (t.gegner ? tr('tpls.beats', textIn(t.gegner.vorlage.name, sprache)) : tr('tpls.onlyOne'))
+                    : tr('tpls.losesTo', textIn(t.gegner.vorlage.name, sprache))));
+      }
       pb2.appendChild(r);
     });
     if (treffer.length > 40) {
@@ -1540,16 +1583,41 @@ var probeGeholt = {};
 
 function probeWerteHolen(v, danach) {
   var erk = v.erkennung || {};
-  if (!erk.inhalt) { return false; }
   var ph = v.mehrfach ? (v.mehrfach.platzhalter || '%N%') : null;
+
+  /* Nicht nur die Erkennungspunkte, sondern auch die, aus denen die
+     ZEILEN lesen — samt ihrer Ersatzwege.
+
+     Sonst urteilt der Probelauf ueber Felder in Werten, die er gar nicht
+     hat: am `Brenner` lag `tele.STATE` im Speicher und `tele.SENSOR`
+     nicht, und derselbe Probelauf meldete je nachdem, was man vorher
+     angeklickt hatte, „1 statt 11" oder „1 statt 20" (Ricardo,
+     14.09.2026). Eine Zahl, die von der Vorgeschichte abhaengt, ist
+     keine. Hier soll dasselbe herauskommen wie beim „Alias anlegen",
+     und dort sind alle Werte des Geraets geladen. */
+  var pfade = Object.keys(erk.inhalt || {});
+  (v.zustaende || []).forEach(function (z) {
+    if (z.absolut) { return; }
+    if (z.lesen) { pfade.push(z.lesen); }
+    var sonst = z.lesenSonst;
+    if (!sonst) { return; }
+    (Array.isArray(sonst) ? sonst : [sonst]).forEach(function (x) {
+      var pf = (typeof x === 'string') ? x : x.punkt;
+      if (pf) { pfade.push(pf); }
+    });
+  });
+  pfade = pfade.filter(function (x, i, a) { return x && a.indexOf(x) === i; });
+  if (!pfade.length) { return false; }
+
   var fehlt = [];
   kandidatenFuer(v).forEach(function (kanal) {
-    Object.keys(erk.inhalt).forEach(function (p0) {
+    pfade.forEach(function (p0) {
       var pfad = ph ? String(p0).split(ph).join('1') : p0;
       var id = hatPunkt(kanal, pfad);
       if (id && S.werte[id] === undefined && !probeGeholt[id]) { fehlt.push(id); }
     });
   });
+  fehlt = fehlt.filter(function (x, i, a) { return a.indexOf(x) === i; });
   if (!fehlt.length) { return false; }
   var offen = fehlt.length;
   fehlt.forEach(function (id) {
@@ -1581,19 +1649,57 @@ export function probelauf(vorlage, alsEigene) {
 
     /* Wer gewinnt hier heute, mit dem Bestand wie er ist? Beim
        Aktualisieren ist das oft die Vorlage selbst — dann wechselt
-       nichts, auch wenn sie den Vergleich gegen alle anderen gewinnt. */
-    var jetzt = null, andere = null;
+       nichts, auch wenn sie den Vergleich gegen alle anderen gewinnt.
+
+       Die Punktbeste ist nicht zwingend die Gewinnerin: greift sie am
+       Geraet nicht, ruecken die naechsten nach — genau wie in
+       `vorschlag`. Vorher stand hier nur DIE eine punktbeste andere, und
+       griff die nicht, erklaerte sich die gepruefte Vorlage zur
+       Siegerin. An `PC_Bastelzimmer` meldete deshalb „Reiner Messpunkt"
+       einen Sieg, obwohl `tasmota-steckdose` dazwischenliegt und dort
+       wirklich greift (Ricardo, 14.09.2026). */
+    var rang = [];
     S.VORLAGEN.forEach(function (v) {
       var x = pruefeVorlage(v, p);
-      if (!x.passt) { return; }
-      if (!jetzt || x.punkte > jetzt.punkte) { jetzt = x; }
-      if (v.id !== neu.id && (!andere || x.punkte > andere.punkte)) { andere = x; }
+      if (x.passt) { rang.push(x); }
     });
+    rang.sort(function (a, b) { return b.punkte - a.punkte; });
+    var ersteGreifende = function (ausser) {
+      for (var i = 0; i < rang.length; i++) {
+        if (ausser && rang[i].vorlage.id === ausser) { continue; }
+        var x = wendeAn(rang[i].vorlage, p, rang[i].gruende, rang[i].instanz, true);
+        if (x && x.states.length && !x.pflichtFehlt) { return rang[i]; }
+      }
+      return null;
+    };
+    var jetzt = ersteGreifende(null);
+    var andere = ersteGreifende(neu.id);
+    /* Gewinnen ist nicht dasselbe wie greifen.
+
+       `pruefeVorlage` fragt, ob die genannten Punkte da sind; `wendeAn`
+       braucht bestimmte Felder darin. Eine Vorlage, deren Zeilen
+       `SML.Total_Summe` lesen, gewinnt an jeder Tasmota mit
+       `tele.SENSOR` — und baut dort dann keine einzige Zeile.
+
+       Das laesst sich nicht vorhersagen, ohne zu raten. Also wird es
+       gemessen: derselbe Aufruf, der beim Anlegen auch laeuft. Kostet
+       nichts, weil die Kandidatenliste ohnehin schon durchgegangen
+       wird (gefunden 14.09.2026, C3). */
+    /* Mit `auchOhneTreffer`, damit auch der gescheiterte Fall zurueckkommt
+       — sonst wuesste man nur „null", nicht warum. */
+    var gebaut = wendeAn(neu, p, t.gruende, t.instanz, true);
+    var greift = !!(gebaut && gebaut.states.length && !gebaut.pflichtFehlt);
+
+    /* Gewonnen hat nur, wer hier auch greift — und `andere` ist bereits
+       die beste, die das tut. */
+    var vorn = greift && (!andere || t.punkte > andere.punkte);
+
     raus.push({
       id: p, eigen: t, gegner: andere,
-      gewinnt: !andere || t.punkte > andere.punkte,
-      wechsel: !!(jetzt && jetzt.vorlage.id !== neu.id &&
-                  (!andere || t.punkte > andere.punkte))
+      greift: greift, fehlendeZeile: gebaut ? gebaut.pflichtFehlt : null,
+      zeilen: gebaut ? gebaut.states.length : 0,
+      gewinnt: vorn,
+      wechsel: !!(jetzt && jetzt.vorlage.id !== neu.id && vorn)
     });
   });
   return raus;
@@ -1738,7 +1844,17 @@ export function zeichneVorlagenDialog() {
      "- keiner -", obwohl "blind" gesetzt war. */
   (D ? Object.keys(D.patterns).sort() : []).forEach(function (m) {
     var typ = D.patterns[m].type || m;
-    var o = opt(typ, musterZeile(m));
+    /* Beschriftet wird nach dem TYP, nicht nach dem Musterschluessel.
+
+       Der Wert stand seit dem 11.09.2026 richtig da, die Beschriftung
+       nicht: `musterZeile(m)` schlug den Schluessel nach, und fuer die
+       drei Muster, die anders heissen als ihr Typ (`blinds`,
+       `mediaPlayer`, `levelSlider`), kennt der Admin keinen Beinamen.
+       Im Feld stand am Rollladen deshalb „blinds" statt „Jalousien ·
+       blind" - der Musterschluessel, den der Nutzer nirgends sonst
+       sieht. Die Musterwahl (musterwahl.js) geht seit jeher ueber den
+       Typ. Gefunden produktiv am 15.09.2026 (I37). */
+    var o = opt(typ, musterZeile(typ));
     if (typ === k.geraetetyp) { o.selected = true; }
     st.appendChild(o);
   });
@@ -2026,6 +2142,7 @@ export function zeichneVorlagenDialog() {
       r.style.gridTemplateColumns = '1fr 150px 130px';
       var idl = el('span', 'sn', t.id);
       idl.style.fontFamily = 'var(--mono)';
+      idl.style.wordBreak = 'break-all';
       if (t.id === (z.e.kanal || '')) { idl.style.fontWeight = '700'; }
       r.appendChild(idl);
       r.appendChild(el('span', 'rx', tr('tpls.evidence', t.eigen.belege)));
@@ -2058,19 +2175,81 @@ export function zeichneVorlagenDialog() {
 
   var b = $('#btn-tpl-save');
   if (b) {
-    b.disabled = fehlerErk || !k.id || !!fremdeMitId(k) ||
-      !hinweisTaugt(k.namenshinweis) ||
-      !z.zeilen.filter(function (r) { return !r.weg; }).length;
+    /* Fuenf Gruende sperren den Knopf - und jeder von ihnen gehoert
+       hingeschrieben.
+
+       Bisher wurde nur `disabled` gesetzt, `title` blieb leer. Bei
+       fehlenden Pflichtpunkten stand die Erklaerung weiter unten in der
+       Probelauf-Karte, fuer die man scrollen musste; bei den anderen
+       vier stand sie nirgends. Ricardo stiess darauf, als er fuer den
+       Objektdump eine eigene Vorlage anlegen wollte - grauer Knopf,
+       kein Wort dazu (I32, 11.09.2026). Ein Knopf, der nicht sagt warum,
+       ist derselbe Fehler wie eine Sperre ohne Begruendung (U28). */
+    var gruende = sperrgruende(z);
+    b.disabled = gruende.length > 0;
+    b.title = gruende.join(' · ');
     b.textContent = k.modus === 'update' ? tr('tpls.saveUpdate') : tr('tpls.saveNew');
+    if (gruende.length) {
+      var sk = el('div', 'aside w');
+      sk.style.borderLeftColor = 'var(--bad)';
+      sk.appendChild(el('b', null, tr('tpls.lockedWhy')));
+      var sul = el('ul');
+      gruende.forEach(function (x) { sul.appendChild(el('li', null, x)); });
+      sk.appendChild(sul);
+      body.appendChild(sk);
+    }
   }
   var tt = $('#tpl-titel');
   if (tt) { tt.textContent = tr('tpls.title', z.e.kanal.split('.').pop()); }
 }
 
+/* Die fuenf Gruende, die das Speichern sperren - an einer Stelle.
+
+   Gebraucht werden sie zweimal: beim Zeichnen, um Knopf und Kasten zu
+   beschriften, und beim Speichern selbst. Das zweite ist keine
+   Doppelung, sondern die eigentliche Sicherung: Der Knopf wird beim
+   VERLASSEN eines Feldes neu bewertet, nicht beim Tippen. Wer eine
+   offene Klammer in den Namenshinweis schreibt und ohne Umweg auf
+   „Vorlage speichern" klickt, hat einen blauen Knopf vor sich - und die
+   Vorlage wurde mit `namenshinweis: "("` gespeichert (Ricardo,
+   12.09.2026, am Testsystem nachgestellt; `hinweisTrifft` faengt den
+   kaputten Ausdruck zwar ab, aber gespeichert gehoert er trotzdem
+   nicht). */
+export function sperrgruende(z) {
+  if (!z) { return []; }
+  var k = z.kopf;
+  var neu = baueVorlage(z);
+  var gruende = [];
+  if (!neu.erkennung.erforderlich.length) { gruende.push(tr('tpls.lockNoRequired')); }
+  if (!k.id) { gruende.push(tr('tpls.lockNoId')); }
+  var fremd = fremdeMitId(k);
+  if (fremd) { gruende.push(tr('tpls.lockIdTaken', fremd.id)); }
+  if (!hinweisTaugt(k.namenshinweis)) { gruende.push(tr('tpls.lockBadHint')); }
+  if (!z.zeilen.filter(function (r) { return !r.weg; }).length) { gruende.push(tr('tpls.lockNoRows')); }
+  return gruende;
+}
+
 export function speichereVorlageAusDialog() {
   if (!S.tplZ) { return; }
   var neu = baueVorlage(S.tplZ);
 
+  /* Letzte Instanz, unabhaengig vom Zustand des Knopfes. */
+  var gesperrt = sperrgruende(S.tplZ);
+  if (gesperrt.length) {
+    var bodyS = $('#tpl-body');
+    var altS = bodyS.querySelector('.sperrgrund-kasten');
+    if (altS) { altS.remove(); }
+    var wS = el('div', 'aside w sperrgrund-kasten');
+    wS.style.borderLeftColor = 'var(--bad)';
+    wS.appendChild(el('b', null, tr('tpls.lockedWhy')));
+    var ulS = el('ul');
+    gesperrt.forEach(function (x) { ulS.appendChild(el('li', null, x)); });
+    wS.appendChild(ulS);
+    bodyS.insertBefore(wS, bodyS.firstChild);
+    bodyS.scrollTop = 0;
+    return;
+  }
+
   /* Widerspricht sie sich, wird nicht gespeichert — eine Vorlage, die
      auf nichts passen kann, hilft niemandem und ist spaeter schwer zu
      durchschauen. */

package/admin/js/vorschlagen.js

@@ -96,7 +96,7 @@ function kernWoerter(name) {
    ueberhaupt etwas anzubieten haette. */
 function rateLage(e) {
   var mu = musterVon(e.want);
-  if (!mu) { return null; }
+  if (!mu) { return { grund: 'keinMuster', frei: [], handWeg: 0 }; }
 
   /* 1. Was schon belegt ist, bleibt unangetastet - in beide
         Richtungen: weder der Platz noch die Zeile. */
@@ -120,7 +120,11 @@ function rateLage(e) {
     gesehen[pl.name] = true;
     freiePlaetze.push(pl);
   });
-  if (!freiePlaetze.length) { return null; }
+  /* Die Namen der freien Plaetze werden auch dann gebraucht, wenn nichts
+     zu holen ist - die Meldung soll sagen, WAS frei bleibt, statt nur
+     „nichts vorzuschlagen". */
+  var freiNamen = freiePlaetze.map(function (pl) { return pl.name; });
+  if (!freiePlaetze.length) { return { grund: 'voll', frei: [], handWeg: 0 }; }
 
   /* Ein Quellpunkt gehoert an genau eine Stelle.
 
@@ -142,30 +146,58 @@ function rateLage(e) {
     if (st.srcW) { quelleBelegt[st.srcW] = true; }
   });
 
+  /* Was von Hand entschieden ist, bleibt liegen (U15, Ricardo,
+     15.09.2026).
+
+     Vorher fand der zweite Druck den Musterplatz wieder frei - die Rolle
+     stand ja nicht mehr auf dem, was das Muster verlangt - und bog
+     DIESELBE Zeile zurueck: aus der Handentscheidung `level.speed` wurde
+     wieder das vermutete `level.mode.fan`, samt Marke. Die Zeile war
+     damit doppelt bezeichnet („geaendert" UND „vermutet"), was sich
+     ausschliesst: was frisch geraten ist, kann nicht vorher geaendert
+     worden sein.
+
+     Eine zweite Zeile daneben zu legen waere die Alternative gewesen -
+     dann haette derselbe Quellpunkt aber zwei Plaetze, und die achte
+     Pruefung („Kein Punkt doppelt") meldete es zu Recht. Also bleibt der
+     Platz frei. Die Meldung unter der Leiste sagt, dass und warum. */
+  var handWeg = 0;
   var freieZeilen = e.states.filter(function (st) {
     if (!st.n || !st.srcR || zeileBelegt[st.n]) { return false; }
     if (quelleBelegt[st.srcR]) { return false; }
     if (st.srcW && quelleBelegt[st.srcW]) { return false; }
+    if (st.geaendert) { handWeg++; return false; }
     return true;
   });
-  if (!freieZeilen.length) { return null; }
-  return { mu: mu, namenDa: namenDa, freiePlaetze: freiePlaetze,
-           freieZeilen: freieZeilen };
-}
-
-/* Gibt es ueberhaupt etwas, das der Knopf vorschlagen koennte? Die
-   komplette Rechnung, nur ohne anzuwenden - eine grobe Vorpruefung
-   liess den Knopf stehen, obwohl die Schwelle hinterher alles verwarf
-   (Ricardos Thermostat: 3 Zeilen, 22 freie Plaetze, nichts passt).
-   Der Preis ist ein zusaetzlicher Bewertungslauf je Zeichnen; die
-   teuren Erkennungslaeufe macht das Zeichnen ohnehin mehrfach. */
-export function rateMoeglich(e) {
-  return ratePlaetze(e, true) > 0;
+  if (!freieZeilen.length) {
+    return { grund: 'vergeben', frei: freiNamen, handWeg: handWeg };
+  }
+  return { grund: null, mu: mu, namenDa: namenDa, freiePlaetze: freiePlaetze,
+           freieZeilen: freieZeilen, frei: freiNamen, handWeg: handWeg };
 }
 
+/* Der Rateschritt - mit `trocken` rechnet er nur, ohne den Entwurf
+   anzufassen. Zurueck kommt, wie viele Plaetze belegt wurden (`anzahl`),
+   und wenn keiner: warum nicht.
+
+   `grund` ist einer von vier Faellen - `keinMuster`, `voll` (kein Platz
+   frei), `vergeben` (Plaetze frei, aber kein uebriger Punkt mehr da),
+   `keinTreffer` (beides da, nichts kam ueber die Schwelle). `frei` nennt
+   die Plaetze, die frei bleiben, `handWeg` die Zeilen, die als
+   Handentscheidung liegenblieben. Der Text dazu wird dort gebaut, wo die
+   Sprachdatei liegt (musterwahl.js); hier steht nur der Befund.
+
+   Der Trockenlauf rechnet alles bis zur Schwelle durch. Eine grobe
+   Vorpruefung genuegte nicht: sie liess den Knopf stehen, obwohl die
+   Schwelle hinterher alles verwarf (Ricardos Thermostat, 3 Zeilen, 22
+   freie Plaetze, nichts passt). Seit dem 15.09.2026 laeuft er nur noch
+   einmal je Zeichnen - vorher fragte erst `rateMoeglich`, ob der Knopf
+   ueberhaupt hingehoert, und der Klick rechnete dasselbe noch einmal. */
 export function ratePlaetze(e, trocken) {
   var lage = rateLage(e);
-  if (!lage) { return 0; }
+  if (lage.grund) {
+    return { anzahl: 0, grund: lage.grund, frei: lage.frei, handWeg: lage.handWeg };
+  }
   var namenDa = lage.namenDa;
   var freiePlaetze = lage.freiePlaetze, freieZeilen = lage.freieZeilen;
 
@@ -355,7 +387,8 @@ export function ratePlaetze(e, trocken) {
       st.geratenPartner = partner.n;
     }
   });
-  return gesetzt;
+  return { anzahl: gesetzt, grund: gesetzt ? null : 'keinTreffer',
+           frei: lage.frei, handWeg: lage.handWeg };
 }
 
 /* Eine einzelne Vermutung zuruecknehmen. */

package/admin/js/werte.js

@@ -6,7 +6,7 @@
 
 import { S } from './zustand.js';
 import { socket } from './verbindung.js';
-import { tr } from './sprache.js';
+import { tr, txt } from './sprache.js';
 import './entwurf.js';
 
 /* Direkt nachschlagen — die Vorlagen nennen den Pfad ja vollstaendig
@@ -76,10 +76,23 @@ export function mitVorspann(pre) {
   return raus;
 }
 
+/* Wie der Baum: POWER2 vor POWER10.
+
+   `keysSorted` MUSS byteweise sortiert bleiben - die Binaersuche in
+   `mitVorspann` haengt daran. Fuer die Anzeige ist das die falsche
+   Ordnung: an einer Mehrfachsteckdose stand `POWER10` vor `POWER2`,
+   waehrend der Baum daneben richtig zaehlte (er nimmt `Intl.Collator`
+   mit `numeric: true`). Also wird hier nachsortiert, wo die Liste
+   entsteht - je Kanal ein paar Dutzend Eintraege, nicht der
+   Gesamtindex (gemessen 12.09.2026). */
+var ZEILEN_VERGLEICH = new Intl.Collator(undefined, { numeric: true, sensitivity: 'base' });
+
 export function kindZustaende(kanal) {
   var pre = kanal + '.';
   return mitVorspann(pre).filter(function (k) {
     return S.objects[k] && S.objects[k].type === 'state';
+  }).sort(function (a, b) {
+    return ZEILEN_VERGLEICH.compare(a.slice(pre.length), b.slice(pre.length));
   });
 }
 
@@ -112,6 +125,60 @@ export function schreibQuelle(o) {
   return (c.write === true || typeof a.write === 'string') ? (q.write || '') : '';
 }
 
+/* Aus einem Alias-Objekt die Felder einer Entwurfszeile.
+
+   Dieselbe Umrechnung stand fuenfmal ausprogrammiert - dreimal in
+   `entwurf.js`, zweimal in `zuordnung.js` -, jedes Mal mit derselben
+   Schreibquellenregel und leicht anderem Drumherum. Die Kommentare an
+   jenen Stellen dokumentieren vier Fehler, die genau daraus entstanden
+   sind: eine verlorene Schreibquelle am Rollladen, ein schaltender Punkt
+   der zum lesenden wurde, eine fehlende Beschriftung an Solar.Netz und
+   eine Abweichung, die die Werkbank selbst erzeugt hatte (Y5).
+
+   Was hier steht, ist die ABLEITUNG - nicht, was damit geschieht. Die
+   eine Stelle vergleicht nur, die zweite legt eine Zeile an, die beiden
+   anderen ueberschreiben eine bestehende; das bleibt bei den Aufrufern.
+
+   `baueEntwurf` ruft sie bewusst NICHT: die Funktion baut Zeilen fuer
+   zwei Faelle, Alias und rohe Quelle, und drei der Felder haengen dort
+   an dieser Unterscheidung. Sie mit Schaltern hereinzuholen waere
+   schlechter als zwei ehrliche Stellen.
+
+   Die Beschriftung folgt der Regel „leer, wenn sie dem Zeilennamen
+   gleicht" - so halten es `vomAliasUebernehmen` und der Zweig, der neue
+   Zeilen anlegt. `bestandVorrang` will sie anders (uebernehmen, sobald
+   `common.name` gesetzt ist) und behaelt dafuer eine eigene Zeile.
+
+   Und `role`/`typ` bleiben bei den beiden Stellen, die eine BESTEHENDE
+   Zeile ueberschreiben (`bestandVorrang`, `vomAliasUebernehmen`), an
+   ihrer `!== undefined`-Frage: dort steht schon der Vorlagenwert, und
+   ein Alias, der gar keine Rolle nennt, soll ihn behalten statt ihn
+   gegen den Leerstring zu tauschen, den diese Funktion liefert. Wer das
+   wegraeumt, nimmt jedem vorlagenbasierten Alias seine Rollen. */
+export function zeileAusAlias(o, zeilenname) {
+  var c = (o && o.common) || {};
+  var a = c.alias || {};
+  var q = aliasQuellen(o);
+  var nm = txt(c.name);
+  return {
+    role: c.role || '',
+    typ: c.type || '',
+    unit: c.unit || '',
+    states: c.states || undefined,
+    wr: !!c.write,
+    /* Ein Taster meldet nichts, und der Alias sagt es mit `read: false`.
+       Die Kennung steht trotzdem in `alias.id` — ioBroker verlangt sie —,
+       aber als Lesequelle gilt sie nicht: sonst zeigte „Alias bearbeiten"
+       eine Quelle, die „Alias anlegen" nie eingetragen hat, und beim
+       naechsten Aktualisieren kippte `read` still auf `true` zurueck. */
+    srcR: (c.read === false && q.einfach) ? '' : (q.read || ''),
+    srcW: schreibQuelle(o),
+    f: (typeof a.read === 'string') ? a.read : '',
+    fw: (typeof a.write === 'string') ? a.write : '',
+    caption: (nm && nm !== zeilenname) ? nm : ''
+  };
+}
+
 export function aliasQuellen(obj) {
   var a = obj && obj.common && obj.common.alias;
   if (!a) { return {}; }
@@ -286,21 +353,58 @@ export function fmt(s) {
    `JSON.parse(val)?.ENERGY?.Power ?? null`. Beide Schreibweisen muessen
    als Feldzugriff durchgehen - sonst zeigt die Feldauswahl an einem
    Punkt, den die Werkbank selbst gebaut hat, „eigene Formel". */
-var FELDPFAD = /^JSON\.parse\(val\)\??\.([A-Za-z_$][\w$]*(?:\??\.[A-Za-z_$][\w$]*)*)(?:\s*\?\?\s*null)?$/;
+/* ---- Feldpfade: Anfang (die Vorpruefung schneidet diesen Block heraus) ---- */
+
+/* Ein Schluessel darf nur dann hinter den Punkt, wenn er ein gueltiger
+   JS-Bezeichner ist. Sonst entsteht kein Zugriff, sondern etwas anderes:
+   aus `?.DS18B20-1` wird die Rechnung `?.DS18B20 - 1?.…` (ergibt NaN),
+   aus `?./dev/shm` und `?.1111740` wird ein Syntaxfehler. Gemessen an
+   einem Frigate-Telegramm: von 233 angebotenen Feldern liessen sich so
+   nur 27 benutzen. Deshalb Klammern, wo der Name keiner ist. */
+var NAME_OK = /^[A-Za-z_$][\w$]*$/;
+
+function feldSegment(name) {
+  if (NAME_OK.test(name)) { return '?.' + name; }
+  return "?.['" + String(name).replace(/\\/g, '\\\\').replace(/'/g, "\\'") + "']";
+}
+
+/* Ein Wegstueck ist entweder `?.name` oder `?.['name']` — die zweite
+   Form auch mit doppelten Anfuehrungszeichen, falls sie jemand von Hand
+   so geschrieben hat. */
+var FELDTEIL = "\\??\\.(?:[A-Za-z_$][\\w$]*|\\[(?:'(?:[^'\\\\]|\\\\.)*'|\"(?:[^\"\\\\]|\\\\.)*\")\\])";
+var FELDPFAD = new RegExp('^JSON\\.parse\\(val\\)((?:' + FELDTEIL + ')+)(?:\\s*\\?\\?\\s*null)?$');
+var FELDSTUECK = new RegExp(FELDTEIL, 'g');
 
 export function feldAusFormel(f) {
   var m = FELDPFAD.exec(f || '');
-  /* Der Feldname selbst traegt keine Fragezeichen. */
-  return m ? m[1].split('?.').join('.') : '';
+  if (!m) { return ''; }
+  var teile = [];
+  var t;
+  FELDSTUECK.lastIndex = 0;
+  while ((t = FELDSTUECK.exec(m[1])) !== null) {
+    var s = t[0].slice(t[0].indexOf('.') + 1);
+    if (s.charAt(0) === '[') {
+      /* Nur die Fluchtzeichen zurueckdrehen, die feldSegment setzt. */
+      s = s.slice(2, -2).replace(/\\(.)/g, '$1');
+      /* Ein Punkt im Schluessel selbst laesst sich im Pfadformat von
+         `jsonFelder` nicht wieder auseinanderhalten — dann lieber
+         „eigene Formel" zeigen als einen Pfad, der nicht zurueckfuehrt. */
+      if (s.indexOf('.') > -1) { return ''; }
+    }
+    teile.push(s);
+  }
+  return teile.join('.');
 }
 
 /* Der abgesicherte Zugriff auf ein JSON-Feld. An einer Stelle, damit die
    Vorlagen-Abkuerzung und die Feldauswahl im Detail dasselbe bauen. */
 export function feldFormel(feld) {
   if (!feld) { return ''; }
-  return 'JSON.parse(val)?.' + String(feld).split('.').join('?.') + ' ?? null';
+  return 'JSON.parse(val)' + String(feld).split('.').map(feldSegment).join('') + ' ?? null';
 }
 
+/* ---- Feldpfade: Ende ---- */
+
 export function jsonFelder(id) {
   var st = S.werte[id];
   if (!st || typeof st.val !== 'string') { return null; }
@@ -318,3 +422,51 @@ export function jsonFelder(id) {
   })(o, '', 0);
   return raus;
 }
+
+
+/* ---- Was das Ziel kann ---------------------------------------------
+
+   Die Werkbank schreibt auf fremde Punkte und liest aus fremden Punkten.
+   Ob die koennen, was von ihnen verlangt wird, stand nirgends: weder
+   `common.read` noch `common.write` noch der Typ des Ziels wurden je
+   angesehen (Ricardo, 15.09.2026).
+
+   Drei Arten, wie es auseinandergeht, alle drei still:
+
+     `formelBlind`  Die Schreibformel liefert Text, das Ziel nimmt keinen.
+                    Der js-controller rechnet ihn auf den Zieltyp zurueck,
+                    die Formel war umsonst. Aus `"ON"` wird wieder `true`.
+     `nichtSchreibbar`  Das Ziel traegt `write: false`. ioBroker laesst den
+                    Schreibvorgang trotzdem durch — gemessen —, der Adapter
+                    dahinter reicht ihn aber nicht ans Geraet weiter.
+                    Ein stiller Blindgaenger.
+     `meldetNichts` Die Lesequelle traegt `read: false`. Ein Tastendruck
+                    hat keinen Zustand; gelesen wird dort nie etwas.
+
+   Gibt eine Liste zurueck, nicht ein Urteil — wer sie anzeigt, entscheidet
+   ueber die Schaerfe. */
+export function zielKann(s) {
+  var raus = [];
+  if (!s) { return raus; }
+
+  if (s.srcW) {
+    var w = S.objects[s.srcW];
+    var wc = (w && w.common) || null;
+    if (wc) {
+      if (wc.write === false) { raus.push({ art: 'nichtSchreibbar', punkt: s.srcW }); }
+      /* Anfuehrungszeichen im Ausdruck sind der Beleg, dass die Formel Text
+         liefert; ohne sie rechnet sie mit Zahlen oder Wahrheitswerten und
+         passt zum Ziel. */
+      if (s.fw && /['"`]/.test(s.fw) && (wc.type === 'boolean' || wc.type === 'number')) {
+        raus.push({ art: 'formelBlind', punkt: s.srcW, typ: wc.type });
+      }
+    }
+  }
+
+  if (s.srcR) {
+    var r = S.objects[s.srcR];
+    var rc = (r && r.common) || null;
+    if (rc && rc.read === false) { raus.push({ art: 'meldetNichts', punkt: s.srcR }); }
+  }
+  return raus;
+}