iobroker.alias-workbench 0.9.9 → 0.9.11

package/admin/js/erkennung.js

@@ -61,11 +61,25 @@ export function rolleTrifft(r, rolle) {
    Ableitung bekam so ein Punkt gar keine: er belegte seinen Platz nie,
    liess sich beliebig oft hinzufuegen, und die Rolle fehlte auch in der
    Auswahlliste — der Platz war auf keinem Weg zu befuellen. */
+/* Der fehlende Anfangsanker zaehlt nicht gegen den Platz.
+
+   `vacuumCleaner.MAP_URL` schreibt `/vacuum\.map\.url$/` - ohne `^`.
+   Gemeint ist derselbe eine Rollenname wie bei den anderen; der Platz
+   blieb aber ohne Rolle, weil hier beide Anker verlangt wurden
+   (gemessen 12.09.2026 ueber alle 53 Muster: ausser MAP_URL traf es
+   nur `media.COVER`, und dessen Ausdruck `/^media\.cover(\..*)$/`
+   beschreibt wirklich keinen einen Namen - der Platz hat dafuer eine
+   `defaultRole`).
+
+   Das Endezeichen bleibt Pflicht: ohne `$` waere `/^level\.dimmer/`
+   auch von `level.dimmer.irgendwas` erfuellt, und dann ist es kein
+   Name mehr, sondern ein Praefix. */
 export function rolleAusAusdruck(r) {
   var q = ausdruckText(r);
   if (!q) { return ''; }
-  if (q.charAt(0) !== '^' || q.slice(-1) !== '$') { return ''; }
-  var t = q.slice(1, -1).split(String.fromCharCode(92)).join('');
+  if (q.slice(-1) !== '$') { return ''; }
+  if (q.charAt(0) === '^') { q = q.slice(1); }
+  var t = q.slice(0, -1).split(String.fromCharCode(92)).join('');
   return /^[A-Za-z0-9_]+([.][A-Za-z0-9_]+)*$/.test(t) ? t : '';
 }
 
@@ -260,6 +274,36 @@ export function typenFuerRolle(musterName, rolle) {
   return raus;
 }
 
+/* Welche angehakten Zeilen treffen ihren Platz in der Rolle, aber nicht
+   im Datentyp?
+
+   Ein solcher Punkt faellt lautlos aus dem Muster - und wenn es ein
+   Pflichtplatz war, greift das Muster gar nicht mehr. Dann hat auf
+   einmal KEINE Zeile einen Platz, und die Oberflaeche beschuldigte alle:
+   am Bastelzimmer_Licht standen nach einem Typwechsel an SET alle acht
+   Zeilen getoent da, das Musterfeld sagte „✕ SET fehlt", und die
+   Wahrheit stand nur in der aufgeklappten SET-Zeile (Ricardo,
+   12.09.2026).
+
+   Hier steht die Frage einmal, damit Musterfeld, Legende und Zeile
+   dieselbe Antwort geben. `pflicht` sagt, ob der betroffene Platz ein
+   Pflichtplatz ist - nur dann kippt das ganze Muster. */
+export function typKonflikte(states, musterName) {
+  var mu = musterName && musterVon(musterName);
+  if (!mu) { return []; }
+  var raus = [];
+  (states || []).forEach(function (s) {
+    if (!s.on || !s.role || !s.typ) { return; }
+    var moegliche = typenFuerRolle(musterName, s.role);
+    if (!moegliche.length || moegliche.indexOf(s.typ) > -1) { return; }
+    var platz = platzFuerRolle(musterName, s.role);
+    if (!platz) { return; }
+    raus.push({ n: s.n, typ: s.typ, erwartet: moegliche, platz: platz.name,
+                pflicht: !!platz.required });
+  });
+  return raus;
+}
+
 /* Die Datentypen, die ein Platz zulaesst - als Liste.
 
    Drei Faelle, gemessen am type-detector 6.0.1: 622 Plaetze nennen

package/admin/js/mqtt.js

@@ -655,6 +655,27 @@ function mqttCustom(g, thema) {
    zurueckzulesen ist ein Wettlauf: die Sicht hinkt dem frisch
    geschriebenen Objekt einen Wimpernschlag hinterher, und der
    Trockenlauf sperrte weiter wegen eines Punktes, den es laengst gab. */
+/* Der Typ eines Sendepunktes: `mixed`, sobald eine Schreibformel im
+   Spiel ist.
+
+   Sonst rechnet der js-controller den Formelwert beim Schreiben auf den
+   Typ des Ziels zurueck, und die Formel war umsonst: `POWER` traegt im
+   Befehlswissen `typ: boolean` UND `schreibformel: val ? "ON" : "OFF"`.
+   Aus dem "ON" wurde am boolean-Ziel wieder true, auf der Leitung stand
+   true statt ON. Geschaltet hat die Tasmota trotzdem — sie nimmt beides —,
+   aber die Formel stand nutzlos im Alias, und der von der Werkbank
+   angelegte Punkt sah anders aus als jeder von mqtt-client angelegte
+   (die sind alle `mixed`). Am Produktivsystem war es genau EINER von 196
+   (Ricardo, 15.09.2026, an alias.0.Bastelzimmer.Deckenlicht).
+
+   Keine Ausnahme fuer POWER, sondern eine Regel, die sich selbst
+   durchsetzt — sie gilt ebenso fuer `Fade` und `LedTable`. Wo keine
+   Formel steht, bleibt der genaue Typ: aus `number` zieht der Admin
+   Min, Max und Einheit. */
+function punktTyp(w) {
+  return w.schreibformel ? 'mixed' : (w.typ || 'mixed');
+}
+
 export function mqttEinzelnStill(kanal, name, fertig) {
   var bau = mqttPunktBauen(kanal, name, 'neu');
   if (!bau) { return fertig && fertig(); }
@@ -694,7 +715,7 @@ function mqttPunktBauen(kanal, name, was) {
     var common0 = {
       name: name,
       role: w0.rolle || 'state',
-      type: w0.typ || 'mixed',
+      type: punktTyp(w0),
       read: true, write: true,
       desc: tr('mq.createdBy'),
       custom: mqttCustom(g, thema0)
@@ -728,7 +749,7 @@ export function mqttEinzeln(kanal, name, was, knopf) {
     var common = {
       name: name,
       role: w.rolle || 'state',
-      type: w.typ || 'mixed',
+      type: punktTyp(w),
       read: true, write: true,
       desc: tr('mq.createdBy'),
       custom: mqttCustom(g, thema)

package/admin/js/musterwahl.js

@@ -10,9 +10,9 @@
 import { S } from './zustand.js';
 import { D, el, $ } from './basis.js';
 import { tr, sprachtext } from './sprache.js';
-import { VORSCHAU, musterVon, erkenneEntwurf, platzFuerRolle, typenFuerRolle } from './erkennung.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);
     });
   }
 
@@ -138,7 +180,17 @@ export function baueMusterwahl(e, haupt, pflichtFehlt) {
     if (!r.length) {
       var fehlend = musterVon(m).states.filter(function (x) { return x.required; })
         .map(function (x) { return x.name; });
-      if (fehlend.length) {
+      /* Ein Pflichtplatz kann auch deshalb leer sein, weil die Zeile
+         dafuer im falschen Datentyp steht - die Rolle stimmt, der Typ
+         nicht, und der Punkt faellt aus dem Muster. „SET fehlt" ist dann
+         die falsche Auskunft: SET ist da. Der Typ-Grund geht vor, wo es
+         einen gibt (Ricardo, 12.09.2026, am Bastelzimmer_Licht). */
+      var konflikt = typKonflikte(pruefE.states, m)
+        .filter(function (x) { return fehlend.indexOf(x.platz) > -1; })[0];
+      if (konflikt) {
+        mark = tr('pattern.fitsNotType', konflikt.platz, konflikt.typ,
+          konflikt.erwartet.join(tr('pattern.typeOr')));
+      } else if (fehlend.length) {
         mark = '✕ ' + tr('pattern.missing', fehlend.join(', '));
       } else {
         /* Kein Pflichtplatz fehlt und trotzdem passt nichts - dann liegt
@@ -174,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
@@ -252,6 +356,7 @@ export function baueMusterwahl(e, haupt, pflichtFehlt) {
       return a.rang - b.rang;
     });
     mEintraege = treffer;
+    var auL = aussicht();
 
     mlist.textContent = '';
     if (!treffer.length) {
@@ -263,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) {
@@ -311,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)
   ];