iobroker.alias-workbench 0.9.10 → 0.9.11

package/admin/js/musterwahl.js

@@ -12,7 +12,7 @@ import { D, el, $ } from './basis.js';
 import { tr, sprachtext } from './sprache.js';
 import { VORSCHAU, musterVon, erkenneEntwurf, platzFuerRolle, typenFuerRolle, typKonflikte } from './erkennung.js';
 import { anMusterAnpassen } from './vorlagen.js';
-import { ratePlaetze, rateZurueck, rateAnzahl, rateMoeglich } from './vorschlagen.js';
+import { ratePlaetze, rateAnzahl } from './vorschlagen.js';
 import { zeichneErgebnis, entwurfAngefasst, knopfFrisch } from './ergebnis.js';
 import { musterName, musterZeile } from './musternamen.js';
 
@@ -52,51 +52,93 @@ export function baueMusterwahl(e, haupt, pflichtFehlt) {
      Er wird hier gebaut, weil er zum Muster gehoert - haengt aber unten
      in der Leiste ueber der Zustandsliste. Neben dem Musterfeld stand er
      am Rand; die Liste, die er veraendert, faengt darunter an. */
+  /* Der Trockenlauf, der beides beantwortet: ob der Knopf etwas
+     anzubieten haette, und - wenn nicht - warum nicht. Frueher lief er
+     zweimal (einmal fuer `rateMoeglich`, einmal fuer den Klick); einmal
+     reicht, das Ergebnis traegt den Grund gleich mit. */
+  var probe = ratePlaetze(e, true);
+
+  /* Was frueher ein Sammelsatz war („entweder alle Plaetze besetzt, oder
+     kein Datenpunkt passt"), steht jetzt als der Fall da, der wirklich
+     vorliegt - mit den Namen der Plaetze, die frei bleiben. Ohne die
+     Namen war die Meldung nicht nachpruefbar.
+
+     Gezeigt wird sie, solange keine Vermutung offen ist: dann fuehrt die
+     blaue Leiste das Wort, und zwei Meldungen uebereinander widersprechen
+     sich nur. */
+  function plaetzeText(frei) {
+    var kurz = frei.slice(0, 6).join(', ');
+    return frei.length > 6 ? tr('guess.slotsMore', kurz, frei.length - 6) : kurz;
+  }
+  function meldungZu(p) {
+    if (p.anzahl > 0) { return null; }
+    var satz = p.grund === 'voll' ? tr('guess.noneFull')
+      : p.grund === 'vergeben' ? tr('guess.noneUsed', plaetzeText(p.frei))
+      : p.grund === 'keinTreffer' ? tr('guess.noneFit', plaetzeText(p.frei))
+      : null;
+    /* Der Zusatz zur Handentscheidung (U15): Steht ein Platz nur deshalb
+       leer, weil die Zeile dazu von Hand entschieden ist, muss genau das
+       dastehen - sonst sieht es aus wie ein Fehler des Ratens. */
+    if (satz && p.handWeg) { satz += '  ' + tr('guess.noneHand', p.handWeg); }
+    return satz;
+  }
+  /* Ungefragt gezeigt wird sie nur, wo sie etwas erklaert: dass kein
+     Knopf dasteht, obwohl Plaetze frei sind. Der Fall „alle Plaetze
+     besetzt" bleibt stumm - er sagt „alles gut, nichts zu tun", und das
+     stuende dann an fast jedem Geraet (dieselbe Ueberlegung wie C27).
+     Ueber den Klick ist er weiter erreichbar. */
+  e.rateMeldung = (rateAnzahl(e) || probe.grund === 'voll')
+    ? null : meldungZu(probe);
+
   /* Und nur, wenn er etwas anzubieten haette: ohne freie Plaetze oder
      freie Zeilen ist der Knopf ein leeres Versprechen — dann faellt er
-     weg, statt beim Klick „nichts gefunden" zu melden. Zuruecknehmen
-     bleibt immer moeglich, solange Vermutungen im Entwurf stehen. */
+     weg, statt beim Klick „nichts gefunden" zu melden. Das Zuruecknehmen
+     steht seit dem 15.09.2026 nicht mehr auch hier: derselbe Knopf hiess
+     je nach Lage „Freie Plaetze vorschlagen" oder „Vorschlaege
+     verwerfen", und daneben stand in der blauen Leiste ein zweiter mit
+     demselben Wort. Verworfen wird dort - bei dem, was es betrifft. */
+  /* Der Rueckfrage-Dialog, wenn eine Vorlage greift (U27). Er sitzt hier
+     als eigene Funktion, weil ihn zwei Knoepfe brauchen: der in der
+     Leiste und der kleine neben dem Hinweis, der Muster wechselt und
+     gleich vorschlaegt. */
+  function mitVorlagenfrage(dann) {
+    var vq = null;
+    S.VORLAGEN.forEach(function (v) { if (v.id === e.vorlage) { vq = v; } });
+    var body = $('#guess-body');
+    body.textContent = '';
+    body.appendChild(el('div', 'aside w',
+      tr('guess.tplAsk', vq ? sprachtext(vq.name) : e.vorlage)));
+    /* onclick statt addEventListener: der Dialog ist einer fuer alle
+       Geraete, der Griff muss beim Oeffnen den alten ersetzen. */
+    $('#btn-guess-go').onclick = function () {
+      $('#dlg-guess').close();
+      dann();
+    };
+    $('#dlg-guess').showModal();
+  }
+
   var rateKnopf = null;
-  if (rateAnzahl(e) || rateMoeglich(e)) {
+  if (probe.anzahl > 0) {
     /* Mit passender Vorlage ist Raten nicht der normale Weg - die
        Zuordnung steht ja schon. Der Knopf bleibt, tritt aber leise auf
        und fragt vor dem Lauf nach (Ricardo, 25.08.2026). */
     var beilaeufig = !!e.vorlage && !rateAnzahl(e);
-    rateKnopf = el('button', 'btn mini' + (rateAnzahl(e) ? ' wichtig' : '')
+    rateKnopf = el('button', 'btn mini'
       + (beilaeufig ? ' leise' : '')
       /* Ein leiser Knopf pocht nicht - das Pochen wuerde genau die
          Aufmerksamkeit holen, die er nicht verdient. */
-      + (!beilaeufig && knopfFrisch('raten:' + S.current + ':' + (rateAnzahl(e) ? 'zurueck' : 'vor')) ? ' frisch' : ''),
-      rateAnzahl(e) ? tr('guess.undo') : tr('guess.button'));
+      + (!beilaeufig && knopfFrisch('raten:' + S.current + ':vor') ? ' frisch' : ''),
+      tr('guess.button'));
     rateKnopf.title = beilaeufig ? tr('guess.tplHint') : tr('guess.hint');
     var rateLos = function () {
-      e.rateMeldung = ratePlaetze(e) ? null : tr('guess.none');
+      e.rateMeldung = meldungZu(ratePlaetze(e));
       entwurfAngefasst();
       S.openRow = null;
       zeichneErgebnis();
     };
     rateKnopf.addEventListener('click', function () {
-      if (rateAnzahl(e)) {
-        rateZurueck(e); e.rateMeldung = null;
-        entwurfAngefasst();
-        S.openRow = null;
-        zeichneErgebnis();
-        return;
-      }
       if (!beilaeufig) { rateLos(); return; }
-      var vq = null;
-      S.VORLAGEN.forEach(function (v) { if (v.id === e.vorlage) { vq = v; } });
-      var body = $('#guess-body');
-      body.textContent = '';
-      body.appendChild(el('div', 'aside w',
-        tr('guess.tplAsk', vq ? sprachtext(vq.name) : e.vorlage)));
-      /* onclick statt addEventListener: der Dialog ist einer fuer alle
-         Geraete, der Griff muss beim Oeffnen den alten ersetzen. */
-      $('#btn-guess-go').onclick = function () {
-        $('#dlg-guess').close();
-        rateLos();
-      };
-      $('#dlg-guess').showModal();
+      mitVorlagenfrage(rateLos);
     });
   }
 
@@ -184,6 +226,58 @@ export function baueMusterwahl(e, haupt, pflichtFehlt) {
   }
   function markeFuer(m) { return bewerte(m).mark; }
 
+  /* ---- Was nach dem Raten passen wuerde ----------------------------
+
+     Ricardos Klimaanlage ist der Fall: `thermostat` greift und belegt 3
+     von 24 Plaetzen, `airCondition` faellt durch, weil sein einziger
+     Pflichtplatz MODE die Rolle nicht traegt. Nach dem Raten stuenden
+     dort 9 von 29 statt 8 von 24 - nur sieht man das nirgends, weil
+     „passt nicht" das letzte Wort behaelt. Wer nicht weiss, dass es den
+     Knopf gibt, waehlt `airCondition` nie aus.
+
+     Also wird einmal durchgerechnet, was jedes Muster nach dem Raten
+     ergaebe. Gerechnet wird auf einer Kopie - am Entwurf aendert das
+     nichts. Das Raten liest nur Namen, Werteliste, Einheit und Typ,
+     keine Messwerte; das Ergebnis haengt also allein an den Zeilen und
+     wird beim blossen Neuzeichnen nicht ungueltig. Gemerkt wird es
+     deshalb an `e` und faellt erst, wenn eine Zeile sich aendert
+     (`entwurfAngefasst`) oder ein anderes Muster gewaehlt ist.
+
+     Gemessen am `midea.AC` (43 Punkte): ein Trockenlauf 1,2 ms, alle 51
+     Muster 35 ms - einmal je Geraeteauswahl, gegen rund 200 ms fuers
+     Auswaehlen selbst. */
+  function probeMuster(m) {
+    if (!musterVon(m)) { return null; }
+    var kopie = JSON.parse(JSON.stringify({ kanal: e.kanal, states: e.states, want: m }));
+    /* Dieselbe Vorbereitung wie in `bewerte`: beim Vorschlag entscheidet
+       nicht das Muster, sondern die Rollen, die das Auswaehlen setzen
+       wuerde. */
+    if (e.vorschlag && !e.roh && m !== e.want) { anMusterAnpassen(kopie, m); }
+    ratePlaetze(kopie);
+    var r = erkenneEntwurf(kopie, m);
+    if (!r.length) { return { passt: false }; }
+    return { passt: true, gesamt: r[0].states.length,
+             belegt: r[0].states.filter(function (x) { return x.id; }).length };
+  }
+
+  function aussicht() {
+    if (e.rateAussicht && e.rateAussicht.want === e.want) { return e.rateAussicht; }
+    var proM = {}, neuPassend = [];
+    if (e.states && e.states.length) {
+      alleTypen.forEach(function (m) {
+        var p = probeMuster(m);
+        if (!p) { return; }
+        proM[m] = p;
+        /* „Neu" heisst: passt jetzt nicht, nach dem Raten schon. Das
+           gewaehlte Muster gehoert nicht dazu - es ist kein anderes. */
+        if (p.passt && m !== e.want && !bewerte(m).passt) { neuPassend.push(m); }
+      });
+    }
+    e.rateAussicht = { want: e.want, proM: proM, neu: neuPassend,
+                       selbst: proM[e.want] || null };
+    return e.rateAussicht;
+  }
+
   /* Welche Muster ohne Suchtext angeboten werden. Das erkannte und das
      gerade gewaehlte gehoeren immer dazu - sonst fiel rgbSingle heraus,
      sobald man einmal auf light gewechselt hatte, und der Weg zurueck
@@ -262,6 +356,7 @@ export function baueMusterwahl(e, haupt, pflichtFehlt) {
       return a.rang - b.rang;
     });
     mEintraege = treffer;
+    var auL = aussicht();
 
     mlist.textContent = '';
     if (!treffer.length) {
@@ -273,8 +368,13 @@ export function baueMusterwahl(e, haupt, pflichtFehlt) {
       var z = el('div', 'vz' + (n === mMarkiert ? ' an' : '')
         + (t0.m === e.want ? ' gewaehlt' : ''));
       z.appendChild(el('span', null, musterZeile(t0.m)));
+      /* Hinter „✕ MODE fehlt" steht, ob das Muster nach dem Raten doch
+         greift - sonst liest man nur, dass es nicht passt, und haelt es
+         fuer erledigt. */
+      var nachRaten = (!bewerte(t0.m).passt && auL.proM[t0.m] && auL.proM[t0.m].passt)
+        ? '   ' + tr('guess.alsoRow') : '';
       z.appendChild(el('span', 'tiefer',
-        (t0.via ? tr('pattern.viaRole', t0.via) + '   ' : '') + markeFuer(t0.m)));
+        (t0.via ? tr('pattern.viaRole', t0.via) + '   ' : '') + markeFuer(t0.m) + nachRaten));
       /* mousedown statt click: sonst greift der Fokusverlust zuerst und
          die Liste ist weg, bevor der Klick ankommt. */
       z.addEventListener('mousedown', function (ev) {
@@ -321,6 +421,73 @@ export function baueMusterwahl(e, haupt, pflichtFehlt) {
   };
   mBeschriften();
 
+  /* Der Hinweis neben dem Feld: genannt wird EIN Muster - das beste -
+     und nur, wenn es wirklich besser ist als das gewaehlte.
+
+     Der erste Anlauf zaehlte bloss, wie viele Muster nach dem Vorschlag
+     dazukaemen, und schrieb bei mehreren „12 weitere Muster" hin. Am
+     `midea.AC` sind das tatsaechlich zwoelf - aber elf davon sind
+     Beifang: `blind` 4/19, `illuminance` 3/7, `windowTilt` 3/7 an einer
+     Klimaanlage. Eine Zahl, die Beifang mitzaehlt, verdeckt genau die
+     eine Auskunft, um die es geht (Ricardo, 15.09.2026): `airCondition`
+     9/29 gegen `thermostat` 8/24.
+
+     Gemessen wird an den belegten Plaetzen, nicht am Anteil. 9 von 29
+     ist besser als 8 von 24, weil neun Punkte des Geraets einen Platz
+     bekommen statt acht - der Anteil waere hier sogar knapp kleiner.
+     Beide Zahlen stehen NACH dem Vorschlag; „3/24" ist der Stand jetzt
+     und gehoert nicht daneben.
+
+     Ist nichts besser, steht hier nichts - der haeufigste Fall bleibt
+     damit stumm. */
+  var auF = aussicht();
+  var bestes = null;
+  auF.neu.forEach(function (m) {
+    if (!bestes || auF.proM[m].belegt > auF.proM[bestes].belegt) { bestes = m; }
+  });
+  /* Der Vergleichswert ist der Stand des gewaehlten Musters NACH dem
+     Vorschlag. Passt es auch dann nicht, ist jedes andere besser. */
+  var jetzt = (auF.selbst && auF.selbst.passt) ? auF.selbst.belegt : -1;
+  if (bestes && auF.proM[bestes].belegt > jetzt) {
+    var pB = auF.proM[bestes], nB = musterName(bestes) || bestes;
+    var hw = el('span', 'ratAussicht');
+    var htx = el('span', null, '· ' + tr('guess.better', nB));
+    htx.title = jetzt >= 0
+      ? tr('guess.betterHint', nB, pB.belegt + '/' + pB.gesamt,
+           musterName(e.want) || e.want, auF.selbst.belegt + '/' + auF.selbst.gesamt)
+      : tr('guess.betterHintNone', nB, pB.belegt + '/' + pB.gesamt,
+           musterName(e.want) || e.want);
+    hw.appendChild(htx);
+
+    /* Der Weg dorthin in einem Griff: wechseln UND vorschlagen.
+       Sonst waere der Hinweis eine Ansage ohne Handlung - man muesste
+       das Muster in der Liste suchen und danach noch den Knopf in der
+       Leiste finden (Ricardo, 16.09.2026).
+
+       Ein Zeichen statt eines Wortes: neben dem Satz bleiben rund 55 px,
+       „wechseln" braucht 58. Dieselbe Bauart wie die Uebernahmeknoepfe
+       im Detail (`←`, `⟲`) - kleines Zeichen, ausfuehrlicher Tooltip. */
+    var hgo = el('button', 'btn winzig rtgo', '→');
+    hgo.title = tr('guess.betterGoHint', nB, tr('guess.button'));
+    hgo.addEventListener('click', function (ev) {
+      ev.stopPropagation();
+      var los = function () {
+        /* Beim Vorschlag entscheidet nicht das Muster, sondern die
+           Rollen, die das Auswaehlen setzt - genau wie in `mWaehlen`. */
+        if (e.vorschlag && !e.roh) { anMusterAnpassen(e, bestes); } else { e.want = bestes; }
+        e.rateMeldung = meldungZu(ratePlaetze(e));
+        entwurfAngefasst();
+        S.openRow = null;
+        zeichneErgebnis();
+      };
+      /* Greift eine Vorlage, fragt auch dieser Weg nach (U27) - er raet
+         ja genauso ueber eine fertige Zuordnung hinweg. */
+      if (e.vorlage && !rateAnzahl(e)) { mitVorlagenfrage(los); } else { los(); }
+    });
+    hw.appendChild(hgo);
+    vw.appendChild(hw);
+  }
+
   sel.addEventListener('focus', function () {
     sel.value = '';
     mMarkiert = -1;

package/admin/js/objekte.js

@@ -41,6 +41,7 @@ export function ladeObjekte(danach) {
       if (--offen === 0) {
         S.keysSorted = Object.keys(S.objects).sort();
         S.kleinIndex = {};
+        kaputteAliaseNeu();
         ladeEnums();
         /* Erst die Einstellungen, dann die Vorlagen - sonst holt die
            Werkbank sie auch dann, wenn sie abgeschaltet sind. */
@@ -206,9 +207,39 @@ export function uebernimmObjekt(id, o) {
 /* Der Baum liest aus S.keysSorted, nicht aus S.objects. Wer einen Punkt
    hinzufuegt oder entfernt, muss den Index neu bauen — sonst kennt der
    Baum ihn nicht, egal wie oft man zeichnet. */
+/* Aliase, bei denen mindestens ein Punkt auf eine Quelle zeigt, die es
+   nicht (mehr) gibt.
+
+   Der teuerste Fehler am Alias: der js-controller merkt sich „Quelle
+   fehlt" dauerhaft und korrigiert das nie - nur loeschen und neu anlegen
+   hilft (siehe schreiben.js). Bis zum 14.09.2026 stand das nur im
+   aufgeklappten Detail und im Pruefungen-Kasten; die Zeile in der Liste
+   schwieg, weil sie „ist eine Quelle eingetragen" fragte statt „gibt es
+   sie".
+
+   Einmal gerechnet und gemerkt, nicht bei jedem Zeichnen: den Baum baut
+   die Werkbank an sechzehn Stellen neu. Gemessen am Produktivsystem:
+   531 Alias-Punkte in 5,2 ms. */
+export function kaputteAliaseNeu() {
+  var raus = {};
+  Object.keys(S.objects).forEach(function (id) {
+    if (id.indexOf('alias.') !== 0) { return; }
+    var ob = S.objects[id];
+    if (!ob || ob.type !== 'state') { return; }
+    var a = (ob.common || {}).alias;
+    if (!a || !a.id) { return; }
+    var ziele = (typeof a.id === 'string') ? [a.id] : [a.id.read, a.id.write];
+    if (!ziele.some(function (q) { return q && !S.objects[q]; })) { return; }
+    var kanal = id.split('.').slice(0, -1).join('.');
+    raus[kanal] = (raus[kanal] || 0) + 1;
+  });
+  S.aliasKaputt = raus;
+}
+
 export function indexNeu() {
   S.keysSorted = Object.keys(S.objects).sort();
   S.kleinIndex = {};
+  kaputteAliaseNeu();
   zeigeObjektzahl();
 }
 

package/admin/js/pruefungen.js

@@ -1,9 +1,9 @@
-/* Die sieben Pruefungen - laufen immer mit, fassen nichts an. */
+/* Die acht Pruefungen - laufen immer mit, fassen nichts an. */
 
 import { S } from './zustand.js';
 import { $, el } from './basis.js';
 import { tr } from './sprache.js';
-import { wertVon } from './werte.js';
+import { wertVon, zielKann } from './werte.js';
 import './erkennung.js';
 import { sofortRueckmeldung, mqttEinstellung } from './mqtt.js';
 
@@ -94,6 +94,31 @@ export function pruefungSenden(e) {
 }
 
 
+/* Kann das Ziel, was der Punkt von ihm verlangt?
+
+   Drei Fragen an fremde Objekte, die die Werkbank vorher nie gestellt hat:
+   Nimmt das Schreibziel den Wert der Formel an? Laesst es sich ueberhaupt
+   beschreiben? Meldet die Lesequelle etwas? Was dabei schiefgeht, faellt
+   nirgends auf — geschrieben wird trotzdem, gelesen auch, es kommt nur
+   nichts dabei heraus (Ricardo, 15.09.2026).
+
+   Hinweis, nicht Fehler: Ob am Ende wirklich nichts passiert, entscheidet
+   der Adapter hinter dem Punkt, und den kennt die Werkbank nicht. */
+export function pruefungZielKann(e) {
+  var treffer = [];
+  e.states.forEach(function (s) {
+    if (!s.on) { return; }
+    zielKann(s).forEach(function (x) { treffer.push({ n: s.n, art: x.art, typ: x.typ }); });
+  });
+  if (!treffer.length) { return { s: 'ok', t: tr('check.targetCan'), d: tr('check.targetCanFine') }; }
+  var text = treffer.map(function (x) {
+    if (x.art === 'formelBlind') { return tr('check.targetVoidFormula', x.n, x.typ); }
+    if (x.art === 'nichtSchreibbar') { return tr('check.targetNoWrite', x.n); }
+    return tr('check.targetNoRead', x.n);
+  }).join(', ');
+  return { s: 'warn', t: tr('check.targetCan'), d: text };
+}
+
 export function baueChecks(e, haupt, pflichtFehlt) {
   var an = e.states.filter(function (s) { return s.on; });
   var ohneQuelle = an.filter(function (s) { return s.srcR && !S.objects[s.srcR]; });
@@ -113,6 +138,7 @@ export function baueChecks(e, haupt, pflichtFehlt) {
             : haupt.type) : tr('check.noPatternFits') },
     pruefungSenden(e),
     pruefungRueckmeldung(e),
+    pruefungZielKann(e),
     pruefungDopplung(e)
   ];
 

package/admin/js/schreiben.js

@@ -28,6 +28,7 @@ import { zeichneErgebnis } from './ergebnis.js';
 import { uebernehmeBestand , enumAenderungen, setzeZiel } from './zuordnung.js';
 
 import { mqttEinzelnStill } from './mqtt.js';
+import { sucheInSkripten, sucheInSkriptenMehrere, skriptListe } from './verwendung.js';
 
 import { rateBehalten } from './vorschlagen.js';
 
@@ -270,20 +271,33 @@ export function baueObjekte(e) {
   } });
 
   e.states.forEach(function (s) {
-    if (!s.on || !s.n || !s.srcR) { return; }
+    if (!s.on || !s.n) { return; }
+    /* Ohne Lesequelle faellt die Zeile heraus - ausser sie ist ein
+       Taster, der nur schreibt (K23). */
+    if (!s.srcR && !taster(s)) { return; }
     var id = ziel + '.' + s.n;
 
     var alias = {};
-    if (s.srcW && s.srcW !== s.srcR) { alias.id = { read: s.srcR, write: s.srcW }; }
+    /* ioBroker verlangt immer eine `alias.id`; ein reines `{ write: … }`
+       weist der js-controller ab („Alias id is invalid: The id is
+       empty!", gemessen 15.09.2026). Beim Taster steht deshalb das
+       Schreibziel darin, und `common.read: false` sagt, dass dort nichts
+       abzuholen ist. */
+    if (!s.srcR) { alias.id = s.srcW; }
+    else if (s.srcW && s.srcW !== s.srcR) { alias.id = { read: s.srcR, write: s.srcW }; }
     else { alias.id = s.srcR; }
     if (s.f)  { alias.read = s.f; }
     if (s.fw && s.srcW) { alias.write = s.fw; }
 
+    /* Ein Taster meldet nichts — dann sagt der Alias-Punkt das auch.
+       Sonst malen vis, Alexa und matter einen Kippschalter, der ewig auf
+       „aus" steht, statt eines Knopfes. */
+    var istTaster = taster(s);
     var common = {
       name: s.caption || s.n,
       role: s.role,
       type: s.typ || 'mixed',
-      read: true,
+      read: !istTaster,
       write: !!s.srcW,
       alias: alias
     };
@@ -349,6 +363,19 @@ export function verwaiste(e) {
 }
 
 /* Was dem Schreiben im Weg steht. */
+/* Ein Taster: keine Lesequelle, ein Schreibziel, und das Ziel sagt
+   selbst, dass es nichts zu melden hat (`common.read === false`).
+
+   Nicht ueber die Rolle entschieden: `button.stop` ist Konvention, aber
+   nur der Adapter weiss wirklich, ob am Punkt etwas abzulesen ist. An
+   `hm-rpc.2.NEQ1795694.1.STOP` steht `read: false` — hingeschrieben von
+   hm-rpc, nicht von uns. */
+export function taster(s) {
+  if (!s || s.srcR || !s.srcW) { return false; }
+  var o = S.objects[s.srcW];
+  return !!(o && o.common && o.common.read === false);
+}
+
 export function pruefeSchreiben(e) {
   var probleme = [];
   var an = e.states.filter(function (s) { return s.on; });
@@ -361,7 +388,20 @@ export function pruefeSchreiben(e) {
     namen[s.n] = 1;
 
     if (!s.srcR) {
-      probleme.push(tr('write.noSourceChosen', s.n));
+      /* Ein Taster hat keinen Zustand zum Lesen.
+
+         `STOP` am Rollladen schreibt nur; am Geraet traegt der Punkt
+         `read: false`, der hm-rpc-Adapter setzt das selbst. Die Sperre
+         hier war deshalb richtig UND falsch zugleich: richtig, weil
+         ioBroker ohne `alias.id` keinen Punkt anlegt — falsch, weil sie
+         damit jeden Rollladen-Alias mit STOP unmoeglich machte. Kein
+         einziger ist je entstanden (gefunden 14.09.2026, K23).
+
+         Massgeblich ist, was das ZIEL kann, nicht was die Rolle
+         nahelegt: `read: false` ist eine Tatsache am Objekt, die der
+         Adapter hinschreibt. Beim Schreiben nimmt `alias.id` dann das
+         Schreibziel, und der Alias-Punkt bekommt selbst `read: false`. */
+      if (!(s.srcW && taster(s))) { probleme.push(tr('write.noSourceChosen', s.n)); }
     } else if (!S.objects[s.srcR]) {
       /* Der teuerste Fehler: der js-controller merkt sich „Quelle fehlt"
          dauerhaft und korrigiert das nie. Nur loeschen und neu anlegen
@@ -1069,6 +1109,32 @@ export function zeichneLoeschen() {
     body.appendChild(ew);
   }
 
+  /* Wer nennt diese Kennungen sonst noch?
+
+     Beim Verlegen steht die Liste seit jeher da, beim Loeschen fehlte
+     sie - dabei ist die Folge hier endgueltig: ein Skript, das den
+     Alias anspricht, laeuft danach ins Leere. Gesucht wird nur im
+     Klartext und nur in den Skripten; der Hinweis darunter sagt das. */
+  var skriptFeld = el('div');
+  skriptFeld.style.marginTop = '11px';
+  body.appendChild(skriptFeld);
+  var wurzeln = [ziel].concat(S.loeschAlleAusgaenge ? geschwisterVon(ziel) : []);
+  sucheInSkriptenMehrere(wurzeln, function (treffer) {
+    if (S.loeschZiel !== ziel) { return; }
+    skriptFeld.textContent = '';
+    if (!treffer.length) {
+      skriptFeld.appendChild(el('div', 'aside', tr('move.noScripts')));
+      return;
+    }
+    var w = el('div', 'aside w');
+    w.appendChild(el('b', null, treffer.length === 1
+      ? tr('del.scriptsHead1')
+      : tr('del.scriptsHead', treffer.length)));
+    w.appendChild(skriptListe(treffer));
+    w.appendChild(el('div', 'hint', tr('del.scriptsHint')));
+    skriptFeld.appendChild(w);
+  });
+
   var b = $('#btn-del-go');
   b.disabled = false;
   b.hidden = false;
@@ -1226,41 +1292,6 @@ function verlegeUmfang(alt) {
   });
 }
 
-/* Wer nennt diese Kennung sonst noch?
-
-   Die Skripte des javascript-Adapters lassen sich durchsuchen; sie sind
-   der haeufigste Ort, an dem eine Kennung im Klartext steht. vis-
-   Ansichten und fremde Adapter kann die Werkbank nicht durchsehen -
-   darauf weist der Dialog eigens hin, statt Vollstaendigkeit
-   vorzutaeuschen. */
-export function sucheInSkripten(kennung, fertig) {
-  var treffer = [];
-  var fertigMit = function () { fertig(treffer); };
-  try {
-    socket.emit('getObjectView', 'script', 'javascript',
-      { startkey: 'script.js.', endkey: 'script.js.\u9999' }, function (err, doc) {
-        if (err || !doc || !doc.rows) { return fertigMit(); }
-        doc.rows.forEach(function (r) {
-          var o = r.value;
-          var q = o && o.common && o.common.source;
-          if (!q || q.indexOf(kennung) === -1) { return; }
-          var zeilen = String(q).split('\n');
-          var stellen = [];
-          zeilen.forEach(function (z, i) {
-            if (z.indexOf(kennung) > -1) { stellen.push(i + 1); }
-          });
-          treffer.push({
-            id: r.id,
-            name: txt((o.common || {}).name) || r.id.split('.').pop(),
-            an: !!(o.common && o.common.enabled),
-            zeilen: stellen
-          });
-        });
-        fertigMit();
-      });
-  } catch { fertigMit(); }
-}
-
 export function zeigeVerlegen(altVorgabe, zielVorgabe) {
   /* Der Knopf steht auch an der Quelle, sobald es den Alias gibt (T1).
      Dort ist S.current die Quelle, nicht der Alias - gemeint ist immer
@@ -1531,14 +1562,7 @@ export function zeigeVerlegen(altVorgabe, zielVorgabe) {
       w3.appendChild(el('b', null, treffer.length === 1
         ? tr('move.scriptsHead1')
         : tr('move.scriptsHead', treffer.length)));
-      var ul3 = el('ul');
-      treffer.forEach(function (t) {
-        ul3.appendChild(el('li', null, t.name + (t.an ? '' : ' (' + tr('move.scriptOff') + ')') +
-          '  \u2014  ' + (t.zeilen.length === 1
-            ? tr('move.scriptLines', t.zeilen[0])
-            : tr('move.scriptLinesN', t.zeilen.join(', ')))));
-      });
-      w3.appendChild(ul3);
+      w3.appendChild(skriptListe(treffer));
       skriptFeld.appendChild(w3);
     });
   };
@@ -1849,9 +1873,32 @@ export function schreibeObjekte() {
        stehen, bis man den Reiter neu lud, und behauptete damit eine
        Abweichung, die es nicht mehr gibt. Nur bei Erfolg loeschen: ging
        etwas schief, ist die Aenderung tatsaechlich noch nicht drin. */
-    if (!fehler.length && S.entwurf && S.entwurf.states) {
-      S.entwurf.states.forEach(function (s) { s.geaendert = false; rateBehalten(s); });
+    if (!fehler.length && S.entwurf) {
+      if (S.entwurf.states) {
+        S.entwurf.states.forEach(function (s) { s.geaendert = false; rateBehalten(s); });
+      }
       S.entwurf.rateMeldung = null;
+      /* Und dasselbe eine Ebene hoeher (G51, Ricardo, 15.09.2026).
+
+         `angefasst` sagt „hier steht etwas Ungeschriebenes". Die Marke
+         wurde im ganzen Programm nur gesetzt, nie geloescht - weg war
+         sie allein, wenn der Entwurf ganz wegfiel (Loeschen, Verlegen).
+         Nach einem gelungenen Schreibvorgang blieb sie also stehen, und
+         der naechste Klick im Baum fragte „Ungespeicherte Aenderungen …
+         Wechselst du jetzt, sind sie weg" - ueber einen Alias, der
+         gerade eben geschrieben worden war.
+
+         Die Marke faellt nur bei Erfolg. Ging etwas schief, ist die
+         Aenderung tatsaechlich noch nicht drin, und die Frage ist dann
+         berechtigt.
+
+         Sie hat eine zweite Aufgabe, und die erledigt sich mit: Solange
+         `angefasst` steht, baut `neuZeichnenOderAufbauen` den Entwurf
+         absichtlich NICHT neu auf - es soll ja nichts Ungeschriebenes
+         ueberbuegeln. Das `holeZweig` unten laeuft gleich danach; jetzt
+         baut es den Entwurf am frisch geschriebenen Alias neu auf,
+         statt den alten stehenzulassen. */
+      S.entwurf.angefasst = false;
     }
 
     /* Nur der Aliaszweig, nicht die ganze Datenbank. */