iobroker.alias-workbench 0.9.9 → 0.9.10

package/admin/js/schreiben.js

@@ -445,12 +445,31 @@ export function zuSchreiben(alleAusgaenge) {
     }).filter(Boolean);
   }
   if (!alleAusgaenge || !S.entwurf.instanzen || S.entwurf.instanzen.length < 2) { return [S.entwurf]; }
+  /* Der Kanalname wird zur Kennung - und zwei koennen dabei gleich werden.
+
+     `ausgangName` saeubert seit dem 12.09.2026 selbst (G31), und damit
+     ergeben „Licht Bar" und „Licht, Bar" beide `Licht_Bar`: der zweite
+     Kanal ueberschriebe den ersten, still und ohne Meldung. Deshalb
+     wird hier mitgezaehlt, was schon vergeben ist - der zweite bekommt
+     `_2`, der dritte `_3`. Der Anzeigename bleibt der des Kanals. */
+  var vergeben = {};
+  var eindeutig = function (name) {
+    if (!vergeben[name]) { vergeben[name] = 1; return name; }
+    var z = 1, n2;
+    do { z++; n2 = name + '_' + z; } while (vergeben[n2]);
+    vergeben[n2] = 1;
+    return n2;
+  };
   return S.entwurf.instanzen.map(function (n) {
-    if (String(n) === String(S.entwurf.instanz)) { return S.entwurf; }
+    if (String(n) === String(S.entwurf.instanz)) {
+      S.entwurf.zielName = eindeutig(S.entwurf.zielName);
+      S.entwurf.ziel = S.entwurf.zielOrdner + '.' + S.entwurf.zielName;
+      return S.entwurf;
+    }
     var v = vorschlag(S.current, S.entwurf.vorlage, n);
     if (v) {
       v.zielOrdner = S.entwurf.zielOrdner;
-      v.zielName = ausgangName(v, n);
+      v.zielName = eindeutig(ausgangName(v, n));
       v.ziel = v.zielOrdner + '.' + v.zielName;
       enumsUebertragen(v);
     }
@@ -487,6 +506,35 @@ function sammle(liste, o) {
   vorh.neu = vorh.neu && o.neu;
 }
 
+/* Eine selbst angelegte Aufzaehlung, die durch diesen Schreibvorgang
+   leer wird, geht mit.
+
+   Beim LOESCHEN eines Alias tut das `enumsDieLeerWuerden` seit jeher.
+   Beim blossen WECHSEL der Funktion nicht: wer „Stehlampe" waehlte,
+   schrieb, dann auf „Licht" umstellte, hinterliess ein leeres
+   `enum.functions.floor_lamp` - von der Werkbank angelegt, von der
+   Werkbank geleert, und trotzdem stehengeblieben (gemessen 12.09.2026).
+
+   Dieselbe Regel wie dort: nur was `angelegtVon` traegt, und nur wenn
+   hinterher kein Mitglied uebrig ist. Der Eintrag wandert aus der
+   Schreibliste in die Loeschliste - sonst schriebe ihn `setObject`
+   parallel zum `delObject` wieder hin.
+
+   Gerufen von `zeigeTrockenlauf` UND `schreibeObjekte`: beide bauen ihre
+   Liste selbst, und was der Trockenlauf zeigt, muss das Schreiben tun. */
+function leereEigeneEnums(liste, weg) {
+  liste.slice().forEach(function (x) {
+    if (!x.istEnum || !x.weg) { return; }
+    var o = enums[x.id];
+    if (!o || !o.native || o.native.angelegtVon !== 'alias-workbench') { return; }
+    if (((x.obj.common || {}).members || []).length) { return; }
+    liste.splice(liste.indexOf(x), 1);
+    if (!weg.some(function (y) { return y.id === x.id; })) {
+      weg.push({ id: x.id, vorgabe: true, grund: tr('enums.nowEmpty') });
+    }
+  });
+}
+
 export function zeigeTrockenlauf(alleAusgaenge) {
   if (!S.entwurf) { return; }
   S.trockenAlle = !!alleAusgaenge;
@@ -532,6 +580,7 @@ export function zeigeTrockenlauf(alleAusgaenge) {
       if (!weg.some(function (x) { return x.id === v.id; })) { weg.push(v); }
     });
   });
+  leereEigeneEnums(liste, weg);
   S.loeschListe = weg;
   var body = $('#dry-body');
   body.textContent = '';
@@ -600,6 +649,20 @@ export function zeigeTrockenlauf(alleAusgaenge) {
     body.appendChild(zwK);
   }
 
+  /* Was beim letzten Anlegen der Sendepunkte schiefging - hier oben, wo
+     man es sieht, und nicht als Tooltip an einem Knopf, den derselbe
+     Rueckruf gleich wieder wegwirft (H17). */
+  if (S.mqFehler && S.mqFehler.length) {
+    var mk = el('div', 'aside w');
+    mk.style.borderLeftColor = 'var(--bad)';
+    mk.style.marginBottom = '11px';
+    mk.appendChild(el('b', null, tr('write.failed', S.mqFehler.length)));
+    var mul = el('ul');
+    S.mqFehler.forEach(function (x) { mul.appendChild(el('li', null, x)); });
+    mk.appendChild(mul);
+    body.appendChild(mk);
+  }
+
   /* Die Aufzaehlungen sind gerade nicht bekannt — dann wird auch keine
      geschrieben. Das gehoert hierher und nicht in eine Sperre: der Alias
      selbst braucht sie nicht, und aus einem stillen Datenverlust eine
@@ -618,7 +681,12 @@ export function zeigeTrockenlauf(alleAusgaenge) {
     var wch = el('div', 'ch');
     wch.appendChild(el('span', 'typ', tr('write.remove')));
     wch.appendChild(el('span', 'chip bad', tr('write.removeCount', weg.length)));
-    wch.appendChild(el('span', 'chip mut', tr('write.removeHint')));
+    /* Der Satz gilt fuer Datenpunkte. Steht eine leer gewordene
+       Aufzaehlung mit in der Liste, waere er dort falsch - die liegt
+       nicht im Alias und stand nie im Entwurf (12.09.2026). */
+    if (weg.some(function (v) { return String(v.id).indexOf('enum.') !== 0; })) {
+      wch.appendChild(el('span', 'chip mut', tr('write.removeHint')));
+    }
     wk.appendChild(wch);
     weg.forEach(function (v, i) {
       var r = el('div', 'slot');
@@ -685,6 +753,19 @@ export function zeigeTrockenlauf(alleAusgaenge) {
                 kn2.disabled = false;
                 kn2.textContent = tr('write.retry');
                 kn2.title = mqFehler.join(' | ');
+                /* Und zwar so, dass es den Neuaufbau ueberlebt.
+
+                   Drei Zeilen weiter unten wird der Entwurf neu gebaut
+                   und der Trockenlauf noch einmal gerechnet - dabei
+                   verschwindet dieser Knopf samt seiner Begruendung aus
+                   dem DOM. Gemessen 12.09.2026: nach rund 120 ms war er
+                   weg. Der neue Dialog sperrte wieder und sagte, welcher
+                   Sendepunkt fehlt, aber nicht mehr, WARUM er nicht
+                   entstanden ist (H17). Am Zustand gemerkt, zeichnet
+                   `zeigeTrockenlauf` ihn oben wieder hin. */
+                S.mqFehler = mqFehler.slice();
+              } else {
+                S.mqFehler = null;
               }
               /* Erst den Entwurf neu aufbauen lassen, dann den
                  Trockenlauf noch einmal rechnen. Sofort geoeffnet zeigte
@@ -1024,6 +1105,16 @@ export function loescheAlias() {
         m.style.fontSize = '13px';
         if (fehler.length) {
           m.appendChild(el('b', null, tr('write.failed', fehler.length)));
+          /* Und WAS schiefging, nicht nur wie viel.
+
+             Beim Schreiben steht die Liste seit jeher da (`melden` beim
+             Verlegen, der Trockenlauf-Dialog beim Anlegen); beim Loeschen
+             fehlte sie, und zurueck blieb die blosse Zahl. Wer wissen
+             will, welcher Punkt haengt — etwa weil ein Skript ihn sperrt
+             —, erfuhr es nicht (G44, gemessen 12.09.2026). */
+          var ul = el('ul');
+          fehler.forEach(function (x) { ul.appendChild(el('li', null, x)); });
+          m.appendChild(ul);
         } else {
           m.appendChild(el('b', null, tr('del.done', alle.length)));
         }
@@ -1674,6 +1765,10 @@ export function schreibeObjekte() {
     schlecht += pruefeSchreiben(en).length;
   });
   if (schlecht) { return; }
+  /* Dieselbe Bereinigung wie im Trockenlauf - diese Liste entsteht neu,
+     und ohne den Griff hier schriebe `setObject` die leere Aufzaehlung
+     parallel zum `delObject` wieder hin. */
+  leereEigeneEnums(liste, S.loeschListe);
 
   var body = $('#dry-body');
   var offen = liste.length;

package/admin/js/sprache.js

@@ -56,7 +56,12 @@ export function ladeSprache(fertig) {
 
   var beantwortet = false;
   socket.emit('getObject', 'system.config', function (err, obj) {
-    if (beantwortet) { return; }
+    /* Hier stand `if (beantwortet) { return; }` - der Waechter aus der
+       Zeit vor dem Nachziehen. Er stieg genau im Fall aus, fuer den der
+       Zweig weiter unten gebaut wurde, und machte ihn zu totem Text
+       (gemessen 12.09.2026: mit `expertMode: true` am System und einer
+       um 4 s verzoegerten Antwort blieb `expertenVorgabe` auch nach
+       zehn Sekunden auf `false`). */
     /* Auch eine spaete Antwort gilt noch.
 
        Nach 2,5 Sekunden geht es ohne weiter — richtig, sonst haengt der

package/admin/js/vorlagen.js

@@ -7,7 +7,7 @@
 import { S } from './zustand.js';
 import { D, $, el } from './basis.js';
 import { hatPunkt, jsonVon, feldWert, kindZustaende, feldFormel } from './werte.js';
-import { eigenerKanalName, merkeHakenVorgabe } from './entwurf.js';
+import { eigenerKanalName, merkeHakenVorgabe, kennungtauglich } from './entwurf.js';
 import { tasmotaBefehle } from './mqtt.js';
 import { socket } from './verbindung.js';
 
@@ -271,7 +271,17 @@ export function setzeInstanz(text, v, n) {
 export function ausgangName(e, n) {
   if (e && e.kanal) {
     var eigen = eigenerKanalName(e.kanal + '.' + n);
-    if (eigen) { return eigen.replace(/\./g, '_'); }
+    /* Der Kanalname wird hier zur KENNUNG - also durch dieselbe
+       Saeuberung wie ueberall sonst.
+
+       Vorher stand hier nur `replace(/\./g, '_')`. Leerzeichen und
+       Kommas blieben damit stehen, und der js-controller lehnt so etwas
+       nicht ab, er saeubert still: aus dem Kanalnamen „Licht, Bar" wurde
+       `alias.0.…Licht_ Bar`, waehrend die Werkbank „Licht, Bar" anzeigte
+       und in die Aufzaehlungen eintrug - eine Kennung, die es nie gab
+       (G31, gemessen 12.09.2026). Der Name selbst bleibt unberuehrt: er
+       steht als Beschriftung im Objekt. */
+    if (eigen) { return kennungtauglich(eigen) || eigen.replace(/\./g, '_'); }
   }
   if (!e || !e.kanalnameRoh) { return 'POWER' + n; }
   return String(e.kanalnameRoh).split(e.platzhalter || '%N%').join(n);

package/admin/js/vorlagenblatt.js

@@ -2058,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';

package/admin/sprachen/de.json

@@ -130,6 +130,7 @@
   "enums.members": "{0} drin",
   "enums.newSuffix": "neu",
   "enums.noMatch": "nichts gefunden zu „{0}“",
+  "enums.nowEmpty": "ist danach leer und wird entfernt",
   "enums.placeholder": "leer = keine Zuordnung",
   "enums.removeFrom": "wird herausgenommen",
   "enums.room": "Raum",
@@ -288,6 +289,7 @@
   "pattern.manualInstead": "von Hand statt {0}",
   "pattern.missing": "{0} fehlt",
   "pattern.noMatch": "kein Muster passt zu „{0}“",
+  "pattern.noPlaceBecauseType": "Das {0}-Muster greift gerade nicht: {1} verlangt {2}, eingestellt ist {3}. Deshalb hat keine Zeile einen Platz.",
   "pattern.noPlaceLegend": "So hinterlegte Zeilen haben keinen Platz im {0}-Muster",
   "pattern.noPlaceLong": "kein Platz im {0}-Muster — der Punkt wird trotzdem angelegt und ist voll benutzbar, nur Alexa & Co. zählen ihn separat",
   "pattern.notDetected": "nicht erkannt",
@@ -326,14 +328,19 @@
   "roles.slot": "Platz {0} im {1}-Muster",
   "roles.slotFree": "frei",
   "roles.slotTaken": "belegt von {0}",
+  "swap.blocked": "Erst entscheiden — diese Punkte können nicht mitziehen: {0}. Entweder beim Tauschen entfernen oder den Tausch lassen; ein Punkt, der schreiben soll, braucht ein Schreibziel.",
   "swap.button": "Quelle tauschen …",
   "swap.diffRange": "Wertebereich {0} → {1}",
   "swap.diffType": "Typ {0} → {1}",
   "swap.diffUnit": "Einheit {0} → {1}",
   "swap.done": "Getauscht. Der Alias liest jetzt aus {0}.",
   "swap.from": "Liest heute aus:",
+  "swap.goHigher": "eine Ebene höher nehmen",
   "swap.gone": "Dieses Gerät gibt es nicht mehr — genau dafür ist dieser Weg gedacht.",
   "swap.guessHint": "Die mit „vermutet“ gekennzeichneten Zeilen sind über Namen oder Rolle geraten — die bitte einzeln prüfen.",
+  "swap.guessedByName": "Über den Punktnamen geraten: unter der neuen Quelle heißt ebenfalls etwas „{0}\". Das kann weit danebenliegen — bitte prüfen.",
+  "swap.guessedByRole": "Über die Rolle geraten: unter der neuen Quelle trägt ein Punkt dieselbe Rolle „{0}\". Bitte prüfen.",
+  "swap.higherLevel": "Eine Ebene höher ({0}) finden {1} von {2} Punkten ein Ziel, hier nur {3}.",
   "swap.keeps": "Der Alias behält seine Kennung, seine Namen, Rollen und Formeln, die Aufzeichnung in der Datenbank sowie Raum und Funktion. Geändert wird nur, woher jeder Punkt liest und wohin er schreibt.",
   "swap.mapping": "Zuordnung",
   "swap.mind": "Darauf achten:",
@@ -432,6 +439,12 @@
   "tpls.json": "Das wird gespeichert",
   "tpls.loadFailed": "eigene Vorlagen nicht geladen",
   "tpls.loadFailedHint": "Die Instanzkonfiguration hat nicht geantwortet oder einen Fehler gemeldet. Deine eigenen Vorlagen sind nicht verschwunden — sie fehlen nur in dieser Ansicht. Solange dieser Hinweis steht, kann ein Speichern eine vorhandene Vorlage überschreiben: erst neu laden.",
+  "tpls.lockBadHint": "Der Namenshinweis ist kein brauchbarer Ausdruck",
+  "tpls.lockIdTaken": "Die Kennung gehört schon „{0}“",
+  "tpls.lockNoId": "Die Kennung fehlt",
+  "tpls.lockNoRequired": "Kein Punkt ist als Pflicht angehakt — so passt die Vorlage auf gar nichts",
+  "tpls.lockNoRows": "Es ist keine Zeile übrig",
+  "tpls.lockedWhy": "Speichern ist gesperrt:",
   "tpls.losesTo": "verliert gegen {0}",
   "tpls.multiple": "Dieses Gerät hat mehrere Ausgänge",
   "tpls.multipleHelp": "Die {0} in den Pfaden wird durch %N% ersetzt — nur am Ende eines Abschnitts, damit ENERGY.Power heil bleibt.",