iobroker.alias-workbench 0.9.8 → 0.9.10

package/admin/js/vorlagenblatt.js

@@ -9,7 +9,7 @@ import { D, $, el, kurz } from './basis.js';
 import { tr, sprachtext, sprache } from './sprache.js';
 import { katalogFehlt } from './katalog.js';
 import { funktionsAuswahl, kennungZuFunktion } from './aufzaehlungen.js';
-import { musterVon, rolleTrifft } from './erkennung.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 { kindZustaende, hatPunkt, feldAusFormel } from './werte.js';
@@ -283,9 +283,12 @@ export function zeichneVorlagenBlatt(host) {
   var st = el('select', 'tx');
   st.disabled = !eigen;
   st.appendChild(opt('', tr('tpls.noType')));
+  /* Wie im Speichern-Dialog: der Wert ist der Typ, nicht der
+     Musterschluessel. musterwahl.js loest es seit laengerem so. */
   (D ? Object.keys(D.patterns).sort() : []).forEach(function (m) {
-    var o = opt(m, musterZeile(m));
-    if (m === v.geraetetyp) { o.selected = true; }
+    var typ = D.patterns[m].type || m;
+    var o = opt(typ, musterZeile(m));
+    if (typ === v.geraetetyp) { o.selected = true; }
     st.appendChild(o);
   });
   st.addEventListener('change', function () {
@@ -543,7 +546,7 @@ function dtFeld(beschriftung, element) {
 
 /* Rollenauswahl samt Begruendung. geraetetyp darf leer sein — dann
    entfaellt nur der Hinweis, welchen Platz die Rolle traefe. */
-function rollenBlock(rolle, geraetetyp, setzen) {
+function rollenBlock(rolle, geraetetyp, setzen, typJetzt, setzeTyp) {
   var rb = el('div');
   /* Dasselbe durchsuchbare Feld wie am Geraet - ein Aussehen fuer alle
      Rollenwahlen. Ohne Belegt-Vermerk: in der Vorlage gibt es keinen
@@ -553,24 +556,38 @@ function rollenBlock(rolle, geraetetyp, setzen) {
     muster: geraetetyp,
     leerErlaubt: true,
     breite: '300px',
-    beiWahl: function (r) { setzen(r); }
+    /* Wie am Geraet: der Platz bringt seinen Datentyp mit, also wird er
+       beim Waehlen der Rolle gleich gesetzt. Eine Vorlage, deren Rolle
+       stimmt und deren Typ nicht, faellt sonst lautlos aus dem Muster. */
+    beiWahl: function (r) {
+      /* Wie am Geraet: nur ein eindeutiger Typ wird gesetzt. */
+      var moegliche = typenFuerRolle(geraetetyp, r);
+      if (moegliche.length === 1 && setzeTyp && typJetzt !== moegliche[0]) { setzeTyp(moegliche[0]); }
+      setzen(r);
+    }
   }));
 
   var must = geraetetyp && musterVon(geraetetyp);
   if (must) {
-    var treffer = null;
-    must.states.forEach(function (pp) {
-      if (!treffer && pp.role && rolleTrifft(pp.role, rolle)) { treffer = pp; }
-    });
+    var treffer = platzFuerRolle(geraetetyp, rolle, typJetzt);
+    var erlaubt = typenFuerRolle(geraetetyp, rolle);
     var hin = el('div', 'sugg');
     if (treffer) {
       hin.appendChild(document.createTextNode(tr('pattern.fitsOn')));
       hin.appendChild(el('b', null, String(treffer.role)));
       hin.appendChild(document.createTextNode(tr('pattern.toSlot', treffer.name, musterName(geraetetyp) || geraetetyp)));
+      if (erlaubt.length) {
+        hin.appendChild(document.createTextNode(
+          tr('pattern.expectsType', erlaubt.join(tr('pattern.typeOr')))));
+      }
     } else {
       hin.textContent = tr('pattern.noPlaceLong', musterName(geraetetyp) || geraetetyp);
     }
     rb.appendChild(hin);
+    if (treffer && typJetzt && erlaubt.length && erlaubt.indexOf(typJetzt) === -1) {
+      rb.appendChild(el('div', 'aside w',
+        tr('pattern.typeMismatch', treffer.name, erlaubt.join(tr('pattern.typeOr')), typJetzt)));
+    }
   }
   return rb;
 }
@@ -782,7 +799,7 @@ function vZeilenDetail(z, nr) {
 
   dtZeile(d, tr('detail.role'), rollenBlock(z.rolle, v.geraetetyp, function (neu) {
     setzeFeld('rolle', neu);
-  }));
+  }, z.typ, function (t) { setzeFeld('typ', t); }));
 
   dtZeile(d, tr('detail.display'), anzeigeBlock(
     function (was) {
@@ -1222,9 +1239,24 @@ export function vorlagenVorbereiten(e) {
 
   var zeilen = [];
   e.states.forEach(function (s) {
-    if (!s.n || !s.srcR) { return; }
-    var r = relZu(s.srcR, e.kanal);
-    var w = (s.srcW && s.srcW !== s.srcR) ? relZu(s.srcW, e.kanal) : null;
+    /* Eine Zeile braucht wenigstens ein Ziel - lesend oder schreibend.
+       `STOP` am Rollladen hat nur ein Schreibziel: ein Tastendruck hat
+       keinen Zustand zum Lesen. Bis 11.09.2026 stand hier `!s.srcR`,
+       und solche Zeilen fielen beim Speichern lautlos weg. Dass das
+       Anwenden diesen Fall kennt, steht seit dem 09.09.2026 in
+       vorlagen.js - die Gegenrichtung war vergessen worden. */
+    if (!s.n || (!s.srcR && !s.srcW)) { return; }
+    var r = s.srcR ? relZu(s.srcR, e.kanal) : { p: '', abs: false };
+    /* Das Schreibziel gehoert in die Vorlage, auch wenn es derselbe
+       Punkt ist wie der gelesene. Bis 11.09.2026 stand hier zusaetzlich
+       `s.srcW !== s.srcR`, und genau das trifft auf jeden Aktor zu, der
+       seinen eigenen Zustand fuehrt: Rollladen, Dimmer, Thermostat
+       schreiben auf denselben Punkt, den sie lesen (1.LEVEL). Beim
+       Speichern verschwand ihr Schreibweg - der Alias zeigte die
+       Position an und liess sich nicht mehr verstellen. Aufgefallen
+       bei Tasmota nie, weil dort tele.STATE gelesen und cmnd.POWER
+       geschrieben wird. */
+    var w = s.srcW ? relZu(s.srcW, e.kanal) : null;
     var zv = null;
     if (quelle && s.ausVorlage) {
       (quelle.zustaende || []).forEach(function (z) { if (z.name === s.ausVorlage) { zv = z; } });
@@ -1348,9 +1380,11 @@ export function baueVorlage(z) {
       name: r.name,
       rolle: s.role || undefined,
       typ: s.typ || undefined,
-      einheit: s.unit || undefined,
-      lesen: zPfad(r, k, false, z.zeilen)
+      einheit: s.unit || undefined
     };
+    /* Ohne Lesequelle kein `lesen` - sonst stuende dort ein leerer
+       Pfad, und `wendeAn` suchte einen Punkt namens "". */
+    if (r.lesenRoh) { zu.lesen = zPfad(r, k, false, z.zeilen); }
     if (r.lesenAbs) { zu.absolut = true; }
     if (r.schreibenRoh) { zu.schreiben = zPfad(r, k, true, z.zeilen); }
     if (f) { zu.feld = f; } else if (s.f) { zu.leseformel = s.f; }
@@ -1696,9 +1730,16 @@ export function zeichneVorlagenDialog() {
   lt.appendChild(el('span', 'feldlabel', tr('tpls.deviceType')));
   var st = el('select', 'tx');
   st.appendChild(opt('', tr('tpls.noType')));
+  /* Der Wert ist der Geraetetyp, nicht der Musterschluessel - drei
+     Muster tragen einen anderen Namen als ihr Typ: blinds meldet
+     "blind", mediaPlayer meldet "media", levelSlider meldet "slider".
+     Die Vorlagen fuehren den Typ. Bis 11.09.2026 stand hier der
+     Schluessel, und an jedem Rollladen zeigte der Dialog
+     "- keiner -", obwohl "blind" gesetzt war. */
   (D ? Object.keys(D.patterns).sort() : []).forEach(function (m) {
-    var o = opt(m, musterZeile(m));
-    if (m === k.geraetetyp) { o.selected = true; }
+    var typ = D.patterns[m].type || m;
+    var o = opt(typ, musterZeile(m));
+    if (typ === k.geraetetyp) { o.selected = true; }
     st.appendChild(o);
   });
   st.addEventListener('change', function () { k.geraetetyp = st.value; zeichneVorlagenDialog(); });
@@ -2017,19 +2058,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/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,55 @@ 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,
+    srcR: 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 {}; }

package/admin/js/zuordnung.js

@@ -14,7 +14,8 @@ import {
 } from './aufzaehlungen.js';
 import { enumVorlagen, katalogFehlt, ikonCache, ikonErlaubt, ikonNachtrag,
          ikonTaugt, vorlageZu, holeIkon } from './katalog.js';
-import { kindZustaende, aliasQuellen, holeEinzelne, schreibQuelle } from './werte.js';
+import { kindZustaende, aliasQuellen, holeEinzelne,
+         zeileAusAlias } from './werte.js';
 import { aliasFuer, zielId, knotenDa } from './entwurf.js';
 import { zeichneErgebnis, entwurfAngefasst, angebotFrisch } from './ergebnis.js';
 
@@ -580,7 +581,8 @@ export function uebernehmeBestand(e) {
      hiesse, dem Vorlagenknopf den Wert zu nehmen, den er zurueckholen
      soll. */
   function vomAliasUebernehmen(z, o) {
-    var c = o.common || {}, a = c.alias || {}, q2 = aliasQuellen(o);
+    var c = o.common || {}, q2 = aliasQuellen(o);
+    var ist = zeileAusAlias(o, z.n);
     if (!z.vorlagenWert) {
       z.vorlagenWert = {
         on: z.on, role: z.role, typ: z.typ, unit: z.unit, caption: z.caption,
@@ -593,10 +595,10 @@ export function uebernehmeBestand(e) {
        stellen, kann der Stand nicht wieder auseinanderlaufen. */
     if (c.role !== undefined) { z.role = c.role; }
     if (c.type !== undefined) { z.typ = c.type; }
-    z.unit = c.unit || '';
-    z.states = c.states || undefined;
-    z.f = (typeof a.read === 'string') ? a.read : '';
-    z.fw = (typeof a.write === 'string') ? a.write : '';
+    z.unit = ist.unit;
+    z.states = ist.states;
+    z.f = ist.f;
+    z.fw = ist.fw;
     /* Die Beschriftung steht im Alias und gehoert dem Nutzer.
 
        Sie fehlte hier als einzige - `bestandVorrang` holt sie laengst
@@ -607,8 +609,7 @@ export function uebernehmeBestand(e) {
        „Bezug" geworden (Ricardo, 07.09.2026, an alias.0.Solar.Netz).
        Gleicht die Beschriftung dem Zeilennamen, bleibt sie leer - so
        haelt es der Zweig darunter, der neue Zeilen anlegt, auch. */
-    var nm2 = txt(c.name);
-    z.caption = (nm2 && nm2 !== z.n) ? nm2 : '';
+    z.caption = ist.caption;
     if (q2.read) { z.srcR = q2.read; }
     /* Und dieselbe Schreibregel wie im Bestandsvorrang.
 
@@ -622,7 +623,7 @@ export function uebernehmeBestand(e) {
        Belegt ist das Schreiben durch `common.write` oder durch eine
        hinterlegte Schreibformel; bei getrennten Quellen zaehlt, was in
        `alias.id.write` steht. */
-    z.srcW = schreibQuelle(o);
+    z.srcW = ist.srcW;
     if (q2.write && !q2.einfach && q2.write !== q2.read) {
       /* Die Gegenzeile eines Paars ist keine eigene mehr - ihre Quelle
          steckt jetzt als Schreibquelle in dieser Zeile. */
@@ -663,7 +664,7 @@ export function uebernehmeBestand(e) {
   kindZustaende(e.ziel).forEach(function (id) {
     var n = id.slice(e.ziel.length + 1);
     if (n.indexOf('.') !== -1 || kennt[n]) { return; }
-    var o = S.objects[id], c = o.common || {}, a = c.alias || {}, q = aliasQuellen(o);
+    var o = S.objects[id], q = aliasQuellen(o);
 
     /* Derselbe Punkt unter anderem Namen? Dann ist es kein zweiter,
        sondern derselbe — und der Name, der schon im Alias steht, gilt.
@@ -699,31 +700,24 @@ export function uebernehmeBestand(e) {
       kennt[n] = vorhanden;
       return;
     }
-    var nm = txt(c.name);
-    e.states.push({
-      n: n, on: true, ausBestand: true, nurImAlias: true,
-      role: c.role || '', typ: c.type || '', unit: c.unit || '',
-      states: c.states || undefined,
-      wr: !!c.write,
-      srcR: q.read || '',
-      /* Dieselbe Schreibregel wie oben und im Bestandsvorrang.
-
-         Hier stand `q.einfach ? '' : (q.write || '')` - bei schlichtem
-         `alias.id` also immer leer, ohne `common.write` ueberhaupt
-         anzusehen. Es trifft jeden Alias, bei dem MEHRERE Punkte auf
-         denselben Quellpunkt zeigen: die eine Vorschlagszeile bekommt
-         der erste von ihnen, alle weiteren landen hier. Am
-         `alias.0.Badezimmer.Rollladen` zeigen OPEN, CLOSE, SET und pct
-         alle auf `…Bad.level`; CLOSE lief oben durch und behielt seine
-         Schreibquelle, OPEN, SET und pct verloren sie - ein
-         Aktualisieren haette den Rollladen ueber den Alias unfahrbar
-         gemacht (Ricardo, 08.09.2026). */
-      srcW: schreibQuelle(o),
-      f: (typeof a.read === 'string') ? a.read : '',
-      fw: (typeof a.write === 'string') ? a.write : '',
-      caption: (nm && nm !== n) ? nm : '',
-      manuell: false
-    });
+    /* Rolle, Typ, Einheit, Zustaende, Formeln, Quellen und Beschriftung
+       kommen geschlossen aus `zeileAusAlias` - dieselbe Ablesung wie in
+       `bestandVorrang`, `bestandsAbweichung` und `vomAliasUebernehmen`.
+
+       Dazu gehoert die Schreibregel: Hier stand `q.einfach ? '' :
+       (q.write || '')` - bei schlichtem `alias.id` also immer leer, ohne
+       `common.write` ueberhaupt anzusehen. Es trifft jeden Alias, bei dem
+       MEHRERE Punkte auf denselben Quellpunkt zeigen: die eine
+       Vorschlagszeile bekommt der erste von ihnen, alle weiteren landen
+       hier. Am `alias.0.Badezimmer.Rollladen` zeigen OPEN, CLOSE, SET und
+       pct alle auf `…Bad.level`; CLOSE lief oben durch und behielt seine
+       Schreibquelle, OPEN, SET und pct verloren sie - ein Aktualisieren
+       haette den Rollladen ueber den Alias unfahrbar gemacht (Ricardo,
+       08.09.2026). Seit dem Zusammenlegen der vier Stellen (Y5) gilt die
+       Regel fuer alle zugleich. */
+    e.states.push(Object.assign(zeileAusAlias(o, n), {
+      n: n, on: true, ausBestand: true, nurImAlias: true, manuell: false
+    }));
   });
 
   /* Einmal nachzeichnen.

package/admin/js/zustandsliste.js

@@ -9,7 +9,7 @@
 import { S } from './zustand.js';
 import { el, $ } from './basis.js';
 import { tr } from './sprache.js';
-import { erkenneEntwurf, musterVon, rolleVonPlatz } from './erkennung.js';
+import { erkenneEntwurf, musterVon, rolleVonPlatz, typKonflikte } from './erkennung.js';
 import { kindZustaende, wertVon, fmt } from './werte.js';
 import { steuerKanaele, vorlagenAbweichung, bestandsAbweichung, waehle, quelleHier, quellenVerteilung } from './entwurf.js';
 import { musterName } from './musternamen.js';
@@ -367,6 +367,11 @@ export function baueListe(host, e, pl, rateKnopf, musterBlock) {
   var legendenPlatz = el('div');
   card.appendChild(legendenPlatz);
 
+  /* Kippt das ganze Muster an einem einzelnen Typkonflikt? Einmal
+     gerechnet: die Zeilenschleife braucht es, die Legende darunter
+     ebenso, und beide sollen dieselbe Antwort geben. */
+  var kipptAnTyp = typKonflikte(e.states, e.want).filter(function (x) { return x.pflicht; })[0] || null;
+
   /* --- Zustandsliste --- */
   e.states.forEach(function (s, i) {
     var pl = platzVon[s.n];
@@ -378,12 +383,27 @@ export function baueListe(host, e, pl, rateKnopf, musterBlock) {
        06.09.2026). Jetzt traegt die Zeile eine Marke, der Satz steht
        einmal als Legende ueber der Liste, und der lange Text haengt als
        Hinweis an der Zeile. */
-    var ohnePlatz = (s.on && !unfertig && !pl);
+    /* Kippt das Muster an einem Typkonflikt, wird nur der Verursacher
+       getoent - nicht die ganze Liste.
+
+       Dass danach keine Zeile einen Platz hat, stimmt zwar, taugt aber
+       nicht als Auskunft: Die Toenung liest sich als „mit dieser Zeile
+       stimmt etwas nicht", und das trifft auf sieben von acht nicht zu.
+       Sie zeigte die Folge und nicht die Ursache (Ricardo, 12.09.2026).
+       Die Legende darueber nennt den Grund; markiert wird die Zeile, an
+       der er haengt. */
+    var ohnePlatz = (s.on && !unfertig && !pl &&
+                     (!kipptAnTyp || kipptAnTyp.n === s.n));
     if (ohnePlatz) { ohnePlatzZahl++; ohnePlatzNamen.push(s.n); }
     var row = el('div', 'erow' + (s.on ? '' : ' skip') + (S.openRow === i ? ' open' : '') +
                  (ohnePlatz ? ' ohneplatz' : ''));
     row.tabIndex = 0;
-    if (ohnePlatz) { row.title = tr('pattern.noPlaceLong', musterName(e.want) || e.want || '?'); }
+    if (ohnePlatz) {
+      row.title = kipptAnTyp
+        ? tr('pattern.noPlaceBecauseType', musterName(e.want) || e.want || '?',
+            kipptAnTyp.platz, kipptAnTyp.erwartet.join(tr('pattern.typeOr')), kipptAnTyp.typ)
+        : tr('pattern.noPlaceLong', musterName(e.want) || e.want || '?');
+    }
 
     var cbw = el('span');
     var cb = document.createElement('input');
@@ -670,7 +690,20 @@ export function baueListe(host, e, pl, rateKnopf, musterBlock) {
   if (ohnePlatzZahl) {
     var mn = musterName(e.want) || e.want || '?';
     var lg = el('div', 'legendenzeile');
-    lg.appendChild(document.createTextNode(tr('pattern.noPlaceLegend', mn)));
+    /* Steht die ganze Liste ohne Platz da, weil EINE Zeile im falschen
+       Datentyp ist, sagt die Legende das - statt acht Zeilen pauschal zu
+       beschuldigen.
+
+       Der Ablauf: der Punkt faellt wegen des Typs aus dem Muster, damit
+       ist ein Pflichtplatz leer, damit greift das Muster nicht mehr, und
+       damit hat KEINE Zeile mehr einen Platz. Am Bastelzimmer_Licht
+       reichte ein Wechsel an SET von `boolean` auf `mixed`: acht von acht
+       Zeilen getoent, Musterfeld „✕ SET fehlt", und die Ursache stand
+       nur in der aufgeklappten SET-Zeile (Ricardo, 12.09.2026). */
+    lg.appendChild(document.createTextNode(kipptAnTyp
+      ? tr('pattern.noPlaceBecauseType', mn, kipptAnTyp.platz,
+          kipptAnTyp.erwartet.join(tr('pattern.typeOr')), kipptAnTyp.typ)
+      : tr('pattern.noPlaceLegend', mn)));
 
     var ib = el('button', 'infoknopf', 'i');
     ib.type = 'button';