iobroker.alias-workbench 0.9.10 → 0.9.12

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)));

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

@@ -166,7 +166,12 @@ export function zeileAusAlias(o, zeilenname) {
     unit: c.unit || '',
     states: c.states || undefined,
     wr: !!c.write,
-    srcR: q.read || '',
+    /* 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 : '',
@@ -280,7 +285,7 @@ export function auswerten(formel, roh) {
   var gedauert = performance.now() - t0;
   if (gedauert > GEDULD_MS) {
     formelGesperrt[formel] = Math.round(gedauert);
-    console.warn('[alias-workbench] Formel gesperrt nach ' + Math.round(gedauert) + ' ms: ' + formel);
+    console.warn('[alias-workbench] Formula blocked after ' + Math.round(gedauert) + ' ms: ' + formel);
     return { ok: false, txt: tr('detail.formulaTooSlow', Math.round(gedauert)), fehler: true };
   }
   if (sch !== null) {
@@ -348,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; }
@@ -380,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;
+}

package/admin/js/zielleiste.js

@@ -11,7 +11,7 @@ import { el } from './basis.js';
 import { tr } from './sprache.js';
 import { enumListe } from './aufzaehlungen.js';
 import { enumZeile, setzeZiel } from './zuordnung.js';
-import { aliasFuer, ordnerUnterAlias, kennungtauglich, knotenDa } from './entwurf.js';
+import { aliasFuer, ausgangsQuellen, ordnerUnterAlias, kennungtauglich, knotenDa } from './entwurf.js';
 import { zeichneErgebnis, entwurfAngefasst, angebotFrisch } from './ergebnis.js';
 import { zeigeVerlegen } from './schreiben.js';
 
@@ -381,7 +381,13 @@ export function baueZielleiste(host, e) {
        irrt sie hier, irrt sie dort ebenso. Und der Hinweis haelt
        niemanden auf. */
     var zwilling = null;
-    var vorhAlias = aliasFuer(e.kanal);
+    /* Dieselbe Frage wie die Vorbelegung, also auch dieselbe Antwort:
+       am Mehrfachgeraet der Alias DIESES Ausgangs. Sonst nennt der
+       Hinweis einen anderen Alias als den, dessen Stand oben in der
+       Liste steht - zwei Aussagen auf einem Bildschirm, die sich
+       widersprechen (C13). */
+    var vorhAlias = aliasFuer(e.kanal, ausgangsQuellen(e)) ||
+      ((e.instanz === null || e.instanz === undefined) ? aliasFuer(e.kanal) : null);
     if (vorhAlias && S.objects[vorhAlias] && vorhAlias !== e.ziel) {
       var zw = el('div', 'uebernahme zwilling');
       zw.appendChild(el('span', 'zq', tr('target.twinExists', vorhAlias)));

package/admin/js/zuordnung.js

@@ -16,7 +16,8 @@ import { enumVorlagen, katalogFehlt, ikonCache, ikonErlaubt, ikonNachtrag,
          ikonTaugt, vorlageZu, holeIkon } from './katalog.js';
 import { kindZustaende, aliasQuellen, holeEinzelne,
          zeileAusAlias } from './werte.js';
-import { aliasFuer, zielId, knotenDa } from './entwurf.js';
+import { aliasFuer, ausgangsQuellen, zielId, knotenDa,
+         aboErgaenzen, quellenVonEntwurf } from './entwurf.js';
 import { zeichneErgebnis, entwurfAngefasst, angebotFrisch } from './ergebnis.js';
 
 
@@ -475,18 +476,35 @@ export function setzeZiel(e) {
       /* Mehrere Ausgaenge: das Geraet wird zum Ordner, jeder Ausgang
          ein Kanal darin. Ein folder darueber, kein device — sonst
          rutscht die Erkennung hoch und macht aus dreien wieder eins. */
-      if (vorhanden) {
-        /* Der gefundene Kanal ist einer der Ausgaenge; der Ordner liegt
-           darueber. Wie der einzelne Ausgang heisst, kann die Werkbank
-           nicht wissen — wer sie umbenannt hat, sieht den Vorschlag in
-           der Zielzeile und kann ihn anpassen. */
-        var tm = vorhanden.split('.');
-        tm.pop();
-        e.zielOrdner = tm.join('.');
+      /* Gibt es den Alias fuer GENAU DIESEN Ausgang, ist er das Ziel —
+         mit seinem eigenen Namen, nicht mit dem der Ausgangsnummer.
+
+         Hier stand: „Wie der einzelne Ausgang heisst, kann die Werkbank
+         nicht wissen." Das galt, solange sie nur nach dem GERAET fragen
+         konnte. Seit `ausgangsQuellen` weiss sie es: Ricardos `RF1000`
+         liest aus `stat.POWER1` und ist damit Ausgang 1. Vorher schlug
+         die Zielzeile `…Steckdosenleiste.POWER1` vor — eine Kennung, die
+         es gar nicht gibt —, meldete „wird neu angelegt" und haette beim
+         Klick einen zweiten Alias neben `RF1000` gesetzt (C13,
+         16.09.2026). */
+      var vorhAus = aliasFuer(S.current, ausgangsQuellen(e));
+      if (vorhAus) {
+        var ta = vorhAus.split('.');
+        e.zielName = ta.pop();
+        e.zielOrdner = ta.join('.');
       } else {
-        e.zielOrdner = zt0.join('.') + '.' + geraet;
+        if (vorhanden) {
+          /* Kein Alias fuer diesen Ausgang, aber einer am Geraet: der gibt
+             wenigstens den Ordner vor. Der Name kommt aus der
+             Ausgangsnummer — hier entsteht wirklich etwas Neues. */
+          var tm = vorhanden.split('.');
+          tm.pop();
+          e.zielOrdner = tm.join('.');
+        } else {
+          e.zielOrdner = zt0.join('.') + '.' + geraet;
+        }
+        e.zielName = ausgangName(e, e.instanz);
       }
-      e.zielName = ausgangName(e, e.instanz);
     } else if (vorhanden) {
       var te = vorhanden.split('.');
       e.zielName = te.pop();
@@ -583,7 +601,10 @@ export function uebernehmeBestand(e) {
   function vomAliasUebernehmen(z, o) {
     var c = o.common || {}, q2 = aliasQuellen(o);
     var ist = zeileAusAlias(o, z.n);
-    if (!z.vorlagenWert) {
+    /* Dieselbe Frage wie in `bestandVorrang`: ohne Vorlage gibt es keinen
+       Vorlagenwert. Sonst verglich die Zeile gegen den Rohentwurf und
+       nannte das „weicht von der Vorlage ab" (17.09.2026). */
+    if (!z.vorlagenWert && e.vorschlag && e.vorlage) {
       z.vorlagenWert = {
         on: z.on, role: z.role, typ: z.typ, unit: z.unit, caption: z.caption,
         f: z.f, fw: z.fw, srcR: z.srcR, srcW: z.srcW, states: z.states
@@ -610,7 +631,9 @@ export function uebernehmeBestand(e) {
        Gleicht die Beschriftung dem Zeilennamen, bleibt sie leer - so
        haelt es der Zweig darunter, der neue Zeilen anlegt, auch. */
     z.caption = ist.caption;
-    if (q2.read) { z.srcR = q2.read; }
+    /* Wie im Bestandsvorrang: `ist.srcR` kennt den Taster, `q2.read`
+       nicht. */
+    if (q2.read) { z.srcR = ist.srcR; }
     /* Und dieselbe Schreibregel wie im Bestandsvorrang.
 
        Hier stand die Schreibquelle nur fuer das getrennte Paar; sonst
@@ -766,6 +789,13 @@ export function uebernehmeBestand(e) {
       });
     }
   }
+  /* Geholt ist nur der erste Wert - mitlaufen tut er erst mit einem Abo.
+     Die Zeilen aus dem Alias lesen oft aus einem anderen Knoten als dem
+     angeklickten (J9, 18.09.2026: `Stromzaehler` zeigte drei Zeilen „aus
+     Solar.Netz" stundenlang auf dem Stand vom Anklicken). Ergaenzt wird
+     nur, was noch nicht laeuft; bei jedem Zeichnen zu rufen kostet also
+     nichts. */
+  if (S.entwurf === e && e.kanal === S.current) { aboErgaenzen(quellenVonEntwurf(e)); }
 }
 
 export function unterschiede(e) {

package/admin/js/zustand.js

@@ -14,6 +14,9 @@ export var S = {
   objects: {},
   keysSorted: [],
   kleinIndex: {},
+  /* Alias-Kanal -> Zahl der Punkte, deren Quelle es nicht (mehr) gibt.
+     Einmal beim Laden gerechnet; der Baum schlaegt nur nach. */
+  aliasKaputt: {},
   werte: {},
   current: null,
   openRow: null,