iobroker.alias-workbench 0.9.11 → 0.9.12

package/admin/js/entwurf.js

@@ -12,7 +12,7 @@ import { kindZustaende, aliasQuellen, holeWerte,
   mitVorspann, schreibQuelle, zeileAusAlias
 } from './werte.js';
 import { erkenneEntwurf } from './erkennung.js';
-import { vorschlag , pruefeVorlage, zeigeAbozahl } from './vorlagen.js';
+import { vorschlag , pruefeVorlage, zeigeAbozahl, setzeInstanz } from './vorlagen.js';
 
 import { zeichneErgebnis } from './ergebnis.js';
 
@@ -75,6 +75,23 @@ export function baueEntwurf(kanal) {
   kindZustaende(kanal).forEach(function (id) {
     var o = S.objects[id], c = o.common || {}, a = c.alias || {}, q = aliasQuellen(o);
     var kurzName = id.slice(kanal.length + 1);
+    /* Ein Knopfdruck hat keinen Zustand — sonst hat auch ein
+       nur-schreibender Punkt einen.
+
+       `read: false` allein reicht als Merkmal nicht. Homematic vergibt es
+       fuer beides: fuer `OLD_LEVEL` und `RAMP_STOP` (Gerätebeschreibung
+       `TYPE: ACTION` — ein Tastendruck) ebenso wie fuer `ON_TIME` und
+       `RAMP_TIME` (`TYPE: FLOAT` — eine Vorgabe fuer den naechsten
+       Schaltbefehl, die stehen bleibt). Nur beim ersten ist eine
+       Lesequelle sinnlos.
+
+       Nachgemessen am 17.09.2026: einen Alias auf `1.ON_TIME` gelegt, die
+       QUELLE direkt auf 30 gesetzt — der Alias zeigte 30. `read: false`
+       sperrt das Lesen also nicht, es sagt nur, dass von allein nichts
+       kommt. Wer den Wert setzt, will ihn auch sehen. */
+    var nat = o.native || {};
+    var istTaster = (c.read === false && !!c.write) &&
+      (nat.TYPE === 'ACTION' || /^button/.test(String(c.role || '')));
     e.states.push({
       /* Bei einer Quelle wird aus stat.POWER der Zustand stat_POWER —
          ein Punkt im Namen wuerde sonst eine Unterebene im Alias
@@ -109,7 +126,32 @@ export function baueEntwurf(kanal) {
          nichts abzuholen ist (K23). Dieselbe Ablesung wie in
          `zeileAusAlias` — sonst zeigte „Alias bearbeiten" eine Quelle,
          die „Alias anlegen" nie eingetragen hat. */
-      srcR: istAlias ? ((c.read === false && q.einfach) ? '' : (q.read || '')) : id,
+      /* An der Quelle ist der Punkt seine eigene Lesequelle — ausser er
+         sagt selbst, dass dort nichts ankommt.
+
+         `read: false` heisst nicht „gesperrt": lesen kann den Punkt
+         jeder, er liegt in der Datenbank. Es heisst, dass nie eine
+         Aktualisierung eintrifft. Was drinsteht, ist der Wert, den
+         zuletzt jemand hineingeschrieben hat — meist der Anfangswert
+         beim Adapterstart. Ein Alias, der daraus liest, zeigt fuer immer
+         diesen einen Wert und sieht dabei aus wie ein Messwert.
+
+         Bei Homematic steht es in der Geraetebeschreibung: `OPERATIONS`
+         ist eine Bitmaske (1 lesen, 2 schreiben, 4 meldet von selbst),
+         und `2.OLD_LEVEL` traegt 2 bei `TYPE: ACTION` — ein Knopfdruck,
+         kein Zustand. Am Wohnzimmer_Dimmer sind das 15 von 43 Zeilen,
+         jede davon las und schrieb bisher auf denselben Befehlspunkt
+         (Ricardo, 17.09.2026).
+
+         Ist der Punkt beschreibbar, wird daraus also ein Taster: keine
+         Lesequelle, nur ein Schreibziel. Genau die Form, die K23/K26 am
+         Rollladen-STOP beschreiben — der Alias bekommt `read: false`,
+         und vis, Alexa und matter zeichnen einen Knopf statt eines
+         Schalters, der ewig auf „aus" steht. Kann der Punkt auch nicht
+         schreiben, bleibt er, wie er ist: dann ist die fehlende Meldung
+         wirklich ein Mangel, und die Marke sagt es. */
+      srcR: istAlias ? ((c.read === false && q.einfach) ? '' : (q.read || ''))
+                     : (istTaster ? '' : id),
       /* Steht in `common.alias.id` ein einzelner Text, gilt er fuer Lesen
          UND Schreiben - dann ist die Schreibquelle dieselbe wie die
          Lesequelle. Hier stand frueher eine leere Zeichenkette, gedacht
@@ -565,8 +607,30 @@ export function steuerKanaele(dev) {
     if (!S.objects[id] || S.objects[id].type !== 'channel') { return; }
     var e2 = baueEntwurf(id);
     if (!e2.states.length) { return; }
-    var f = erkenneEntwurf(e2, null).filter(function (x) { return x.type !== 'info'; });
-    if (!f.length) { return; }
+    /* Auch Informationskanaele zaehlen mit (Ricardo, 17.09.2026).
+
+       Vorher fielen sie hier heraus — und damit sagte der Knopf am
+       Geschirrspueler „3 Stueck", waehrend im Baum daneben sechs Kanaele
+       standen. Wer `general` einzeln anklickt, bekommt laengst einen
+       Entwurf („Information ✓ 7/14 belegt") und kann ihn anlegen; nur
+       der Sammelweg liess ihn aus. Zwei Wege, zwei Antworten am selben
+       Geraet.
+
+       Der Zweck dieses Wegs ist, die Struktur der Quelle abzubilden —
+       dann gehoert jeder Kanal hinein, der fuer sich einen Entwurf
+       ergibt, und nicht nur der, den der Detektor fuer ein Geraet haelt.
+       Nebenbei faellt damit das Verteilen der „gemeinsamen" Kanaele in
+       den meisten Faellen weg: was einen eigenen Ordner bekommt, muss
+       nicht mehr in jeden anderen hineinkopiert werden (produktiv
+       gemessen: beim Maeher wanderten 206 Rohdatenpunkte in jeden der
+       vier Entwuerfe, beim Shelly SHEM-3 galten die drei Emeter-Phasen
+       als „gemeinsam" statt als eigene Kanaele). */
+    var alle = erkenneEntwurf(e2, null);
+    if (!alle.length) { return; }
+    /* Ein Kanal, der ein Geraet ergibt, wird danach benannt; nur wenn er
+       nichts als Information hergibt, gilt der info-Fund. */
+    var f = alle.filter(function (x) { return x.type !== 'info'; });
+    if (!f.length) { f = alle; }
     /* Nur zaehlen, was einen Pflichtplatz wirklich besetzt — sonst
        gilt jeder Kanal mit irgendeinem Messwert als Geraet. */
     /* Alles, was der Kanal an Plaetzen belegt — nicht nur die
@@ -590,92 +654,131 @@ export function steuerKanaele(dev) {
   return raus;
 }
 
-/* Ein fertiger Entwurf fuer einen Knoten, so wie ihn `waehle` erzeugen
-   wuerde — Vorlage, sonst Rohentwurf mit erkanntem Muster und der
-   Vorbelegung „nur was einen Platz hat". Gebraucht wird das, wenn aus
-   mehreren Kanaelen auf einmal Aliase entstehen sollen. */
-/* Welche Kanaele eines Geraets gehoeren keinem einzelnen Verbraucher,
-   sondern allen? Bei Homematic ist das Kanal 0 mit Batterie, Empfang und
-   Erreichbarkeit — ein Funkmodul, zwei Lampen. */
-export function gemeinsameKanaele(dev, kanalGeraete) {
-  var eigen = {};
-  (kanalGeraete || []).forEach(function (k) { eigen[k.id] = 1; });
-  var pre = dev + '.';
-  var raus = [];
-  S.keysSorted.forEach(function (id) {
-    if (id.indexOf(pre) !== 0) { return; }
-    if (id.slice(pre.length).indexOf('.') !== -1) { return; }
-    if (!S.objects[id] || S.objects[id].type !== 'channel') { return; }
-    if (eigen[id]) { return; }
-    if (!kindZustaende(id).length) { return; }
-    raus.push(id);
+/* Welche Unterordner entstehen, wenn die Struktur der Quelle abgebildet
+   wird — und zwar nach den HAKEN, nicht nach einer Vermutung.
+
+   Bis 17.09.2026 baute dieser Weg je Kanal einen frischen Entwurf und
+   hakte an, was das Muster des Kanals hergab. Damit entstand, was
+   niemand ausgewaehlt hatte: am `MISCHKANAL` bekam der Wartungskanal
+   `LOW_BAT`, `RSSI_DEVICE` und `UNREACH`, obwohl oben nur `UNREACH`
+   angehakt war. Umgekehrt fiel weg, was jemand von Hand angehakt hatte —
+   der Entwurf wurde ja gar nicht gelesen (Ricardo, 17.09.2026).
+
+   Jetzt gilt: was angehakt ist, bestimmt beides — welche Ordner es gibt
+   und was darin steht. Ein Kanal ohne angehakte Zeile kommt nicht vor.
+   Zeilen, deren Quelle direkt am Geraet haengt oder von woanders kommt,
+   bleiben im Behaelter selbst (`eigen`). */
+export function kanalGruppen(e) {
+  if (!e || !e.kanal || e.kanal.indexOf('alias.') === 0) { return []; }
+  var basis = e.kanal + '.';
+  var gruppen = [], nach = {}, eigen = [];
+  (e.states || []).forEach(function (st) {
+    if (!st.on || !st.n) { return; }
+    var quelle = st.srcR || st.srcW || '';
+    var rest = (quelle.indexOf(basis) === 0) ? quelle.slice(basis.length) : '';
+    var p = rest.indexOf('.');
+    /* Ohne Punkt liegt der Punkt direkt am Geraet; ohne `rest` liest die
+       Zeile von woanders. Beides gehoert in den Behaelter, nicht in einen
+       erfundenen Unterordner. */
+    if (!rest || p < 0) { eigen.push(st); return; }
+    var kid = e.kanal + '.' + rest.slice(0, p);
+    if (!S.objects[kid]) { eigen.push(st); return; }
+    if (!nach[kid]) {
+      var kn = eigenerKanalName(kid);
+      var kurz = rest.slice(0, p);
+      nach[kid] = { id: kid, kurz: kurz, name: kn || kurz,
+                    kennung: kennungtauglich(kn || '') || kurz, zeilen: [] };
+      gruppen.push(nach[kid]);
+    }
+    nach[kid].zeilen.push(st);
   });
-  return raus;
+  if (eigen.length) {
+    gruppen.unshift({ id: e.kanal, kurz: '', name: '', kennung: '',
+                      eigen: true, zeilen: eigen });
+  }
+  return gruppen;
 }
 
-export function entwurfFuer(id, gemeinsam, gemAn) {
-  var v = vorschlag(id);
-  if (v) { return v; }
+/* Der Entwurf ohne jede Vorlage — alle Punkte des Geraets, alle
+   angehakt, dazu das erkannte Muster als Anhaltspunkt.
+
+   Gebraucht fuer „— keine Vorlage —" in der Vorlagenwahl. Bis zum
+   17.09.2026 liess sich eine erkannte Vorlage nicht abwaehlen: der erste
+   Eintrag der Liste war eine blosse Ueberschrift, sein Wert leer, und der
+   Zweig stieg bei leerem Wert sofort aus. Wechseln ging, weglassen nicht
+   (Ricardo).
+
+   Zuerst hakte dieser Weg an, was im erkannten Muster einen Platz hat.
+   Das ging an zwei GLEICHARTIGEN Kanaelen schief: am `hm.ZWEIKANAL`
+   nahm der Detektor einen der beiden Ausgaenge — und zwar den zweiten —,
+   `Licht_Esstisch` stand angehakt da und `Licht_Bar` leer. Welcher es
+   wird, ist Zufall, und danach zu raten ist nicht die Aufgabe eines
+   Entwurfs OHNE Vorlage. Wer sie abwaehlt, will die Punkte selbst
+   aussuchen; also stehen alle da (Ricardo, 17.09.2026). */
+export function rohEntwurf(id) {
   var e2 = baueEntwurf(id);
   if (!e2.states.length) { return null; }
-
-  /* Die Wartungsdaten des gemeinsamen Kanals gehoeren in jedes Geraet,
-     nicht in eines davon oder in einen Kanal daneben.
-
-     Ein Alias-Punkt ist ein Verweis, kein Wert — zwei Geraete duerfen
-     auf dieselbe Quelle zeigen, und der Batteriestand des Funkmoduls
-     gilt fuer beide Lampen gleichermassen. Lagerte man ihn in einen
-     eigenen `info`-Kanal aus, haette keine der beiden eine
-     Batteriewarnung: der Detektor schaut nur innerhalb eines Kanals.
-     Genau so macht es die Tasmota-Mehrfachvorlage mit RSSI — jeder der
-     vier Ausgaenge bekommt seinen eigenen, alle lesen aus tele/STATE. */
-  (gemeinsam || []).forEach(function (gid) {
-    kindZustaende(gid).forEach(function (qid) {
-      var o = S.objects[qid]; if (!o) { return; }
-      var c = o.common || {};
-      var kurz = qid.slice(gid.length + 1).replace(/\./g, '_');
-      /* Traegt der Kanal selbst schon einen Punkt dieses Namens, den
-         gemeinsamen unterscheidbar machen. */
-      if (e2.states.some(function (x) { return x.n === kurz; })) {
-        kurz = gid.split('.').pop() + '_' + kurz;
-      }
-      e2.states.push({
-        n: kurz, on: false, role: c.role || '', typ: c.type || '',
-        unit: c.unit || '', states: c.states || undefined, wr: false,
-        srcR: qid, srcW: '', f: '', fw: '', caption: '', manuell: false,
-        gemeinsam: true
-      });
-    });
-  });
   var f = erkenneEntwurf(e2, null);
   e2.wantAuto = f.length ? f[0].type : null;
   e2.want = e2.wantAuto;
-  var funde = e2.want ? erkenneEntwurf(e2, e2.want) : f;
-  var haupt = funde.length ? funde[0] : null;
-  var platz = {};
-  if (haupt) {
-    haupt.states.forEach(function (x) {
-      if (x.id) { platz[x.id.slice(id.length + 1)] = x.name; }
-    });
-  }
-  if (Object.keys(platz).length) {
-    e2.states.forEach(function (st) { st.on = !!platz[st.n]; });
-  }
-  /* Zum Schluss die Wartungspunkte, die auf der Geraeteebene einen Platz
-     gefunden haben. Warum nicht einfach den Detektor auf dem Kanal
-     fragen? Weil er dort nur SET und WORKING zuordnet, obwohl dieselben
-     Punkte mit denselben Rollen im Abbild stehen — auf der Geraeteebene
-     findet er LOWBAT, UNREACH und RSSI. Die Zuordnung von dort ist die
-     belastbare; sie stammt aus demselben Detektor, nur aus dem Lauf, der
-     sie sieht. */
-  if (gemAn) {
-    e2.states.forEach(function (st) {
-      if (st.gemeinsam && gemAn[st.srcR]) { st.on = true; }
-    });
-  }
   return merkeHakenVorgabe(e2);
 }
 
+/* Wohin die Unterordner kommen — der Behaelter fuer das Geraet.
+
+   Beim ersten Mal ist das schlicht `zielOrdner` plus Geraetename. Nach
+   dem Aufteilen gibt es aber mehrere Aliase zu derselben Quelle, je Kanal
+   einen, und `aliasFuer` liefert einen davon — den mit den meisten
+   Punkten. Der Behaelter waere dann dieser Unterordner, und der zweite
+   Druck haengte alles eine Ebene tiefer: aus
+   `alias.0.Geschirrspueler.Befehle` wurde
+   `alias.0.Geschirrspueler.Allgemeine_Informationen.Befehle`, beim
+   dritten Druck noch eine Ebene tiefer (17.09.2026).
+
+   Woran man es erkennt: das gefundene Ziel fuehrt in `native.quelle`
+   einen KANAL der Quelle, nicht das Geraet. Dann ist es selbst ein
+   Unterordner aus einem frueheren Durchgang, und der Behaelter ist sein
+   Elternknoten. */
+export function aufteilBehaelter(e) {
+  var ordner = (e.zielOrdner || 'alias.0') + '.' + e.zielName;
+  var ziel = e.ziel;
+  if (!ziel) { return ordner; }
+  var q = ((S.objects[ziel] && S.objects[ziel].native) || {}).quelle;
+  if (q && e.kanal && q.indexOf(e.kanal + '.') === 0) {
+    var p = ziel.lastIndexOf('.');
+    if (p > 0) { return ziel.slice(0, p); }
+  }
+  return ordner;
+}
+
+/* Aus einer Gruppe wird ein Entwurf: dieselben Zeilen, nur auf den Kanal
+   bezogen benannt. Was jemand an einer Zeile geaendert hat — Rolle, Typ,
+   Einheit, Formel, Beschriftung — wandert unveraendert mit; es waere
+   sonderbar, eine Handeingabe beim Aufteilen wegzuwerfen. */
+export function teilEntwurf(e, g) {
+  var v = { kanal: g.id, states: [], want: null, wantAuto: null,
+            alleMuster: false, raum: e.raum, funktion: e.funktion };
+  g.zeilen.forEach(function (st) {
+    var k = JSON.parse(JSON.stringify(st));
+    /* Der Name wird auf den Kanal bezogen: aus `commands_BSH_…` wird im
+       Kanal `Befehle` schlicht `BSH_…`. Gekuerzt wird ueber die Quelle —
+       und bei einem Taster ist das die SCHREIBquelle, denn `srcR` ist
+       dort leer. Ohne diesen Zusatz behielt genau diese Zeile ihren
+       langen Namen: `…Befehle.commands_BSH_Common_Command_StopProgram`
+       neben `…Allgemeine_Informationen.brand` (17.09.2026). */
+    var quelle = st.srcR || st.srcW || '';
+    if (!g.eigen && quelle && quelle.indexOf(g.id + '.') === 0) {
+      k.n = quelle.slice(g.id.length + 1).replace(/\./g, '_');
+    }
+    k.on = true;
+    v.states.push(k);
+  });
+  var f = erkenneEntwurf(v, null);
+  v.wantAuto = f.length ? f[0].type : null;
+  v.want = v.wantAuto;
+  return merkeHakenVorgabe(v);
+}
+
 /* Alle laufenden Abos abmelden.
 
    Stand nur in `waehle` — und damit meldete kein einziger der Wege ab,
@@ -690,6 +793,108 @@ export function aboLoesen() {
   zeigeAbozahl();
 }
 
+/* Die Quellen eines Entwurfs - alles, woraus eine Zeile liest oder
+   wohin sie schreibt. */
+export function quellenVonEntwurf(e) {
+  var raus = [];
+  ((e && e.states) || []).forEach(function (s) {
+    if (s.srcR) { raus.push(s.srcR); }
+    if (s.srcW) { raus.push(s.srcW); }
+  });
+  return raus;
+}
+
+/* Abonniert Quellen dazu, die rechts angezeigt werden.
+
+   Ergaenzt nur: was ein laufendes Muster schon deckt, kommt nicht noch
+   einmal dazu, doppelt rufen schadet also nicht. Die Regeln stammen aus
+   `waehle`, wo sie vorher fest verbaut waren und nur am Alias griffen.
+
+   `quellenVerteilung` fasst zusammen, was die rechte Seite als
+   „Quellen" zeigt — dafuer bildet sie den ELTERNknoten jeder Quelle.
+   Bei einem flachen MQTT-Geraet ist das der halbe Adapter: gemessen
+   09.09.2026 wurde daraus `mqtt-client.0.*` mit 322 Objekten, an einem
+   einzigen Alias. Abonniert wird deshalb der Kanal jeder wirklich
+   gelesenen Quelle. */
+export function aboErgaenzen(quellen) {
+  var muster = (S.abo || []).slice();
+  var vorher = muster.length;
+  var drinSchon = function (was) {
+    return muster.some(function (m0) {
+      var p0 = m0.slice(-2) === '.*' ? m0.slice(0, -2) : m0;
+      return was === p0 || was.indexOf(p0 + '.') === 0;
+    });
+  };
+  var offen = [];
+  (quellen || []).forEach(function (x) {
+    if (x && !drinSchon(x) && offen.indexOf(x) === -1) { offen.push(x); }
+  });
+  if (!offen.length) { zeigeAbozahl(); return; }
+
+  var kanaele = [];
+  offen.forEach(function (x) {
+    var t = String(x).split('.');
+    t.pop();
+    var kn = t.join('.');
+    if (kn && kanaele.indexOf(kn) === -1) { kanaele.push(kn); }
+  });
+  var SCHWELLE = 30;
+  var wieBreit = function (knoten) {
+    var n = 0;
+    S.keysSorted.forEach(function (k0) { if (k0.indexOf(knoten + '.') === 0) { n++; } });
+    return n;
+  };
+
+  /* Sparten desselben Geraets zu einem Muster zusammenfassen.
+
+     Ein Tasmota-Alias liest aus `…Licht.stat`, `…Licht.tele` und
+     `…Licht.cmnd` — drei Kanaele, ein Geraet, und in der Kopfleiste
+     gehoert dort „ein Abo" zu stehen, nicht drei. Zusammengefasst wird
+     aber nur, wo wirklich MEHRERE Kanaele unter demselben Knoten
+     haengen: Sonst waere aus `…Garten.Weihnachten_aussen` schlicht
+     `…Garten` geworden — breiter als noetig, ohne dass etwas
+     zusammenfaellt. */
+  for (var runde = 0; runde < 4; runde++) {
+    var unter = {};
+    kanaele.forEach(function (kn) {
+      var t = kn.split('.');
+      if (t.length <= 3) { return; }
+      var ob = t.slice(0, -1).join('.');
+      (unter[ob] = unter[ob] || []).push(kn);
+    });
+    var geaendert = false;
+    Object.keys(unter).forEach(function (ob) {
+      if (unter[ob].length < 2 || wieBreit(ob) > SCHWELLE) { return; }
+      kanaele = kanaele.filter(function (kn) { return unter[ob].indexOf(kn) === -1; });
+      if (kanaele.indexOf(ob) === -1) { kanaele.push(ob); }
+      geaendert = true;
+    });
+    if (!geaendert) { break; }
+  }
+
+  /* Ein schmaler Kanal wird als Muster abonniert, ein breiter nicht.
+
+     Bei einem flachen Geraet IST der Kanal der breite Knoten: Die
+     Quelle `mqtt-client.0.SmartHome.Lavalampe_POWER` liegt direkt
+     unter `SmartHome`, und `SmartHome.*` sind 320 Objekte (gemessen
+     09.09.2026). Ab dieser Schwelle werden die Quellen einzeln
+     abonniert — ein paar Abos mehr, dafuer genau die, deren Werte auch
+     angezeigt werden. */
+  kanaele.forEach(function (kn) {
+    if (drinSchon(kn)) { return; }
+    if (wieBreit(kn) > SCHWELLE) { return; }
+    muster.push(kn + '.*');
+  });
+  offen.forEach(function (x) {
+    if (!drinSchon(x) && muster.indexOf(x) === -1) { muster.push(x); }
+  });
+
+  var neu = muster.slice(vorher);
+  S.abo = muster;
+  neu.forEach(function (m) { socket.emit('subscribe', m); });
+  zeigeAbozahl();
+}
+
 export function waehle(id, fertig) {
   /* Wer links etwas anderes anklickt, will es rechts sehen - auch wenn
      der Fokus noch in einem Feld der rechten Seite steht. `tipptGerade`
@@ -743,109 +948,28 @@ export function waehle(id, fertig) {
      `alias.0.Solar.Balkon.Energie`, wo sich im Sekundentakt etwas
      aendert, fiel es auf (Ricardo, 08.09.2026).
 
-     Deshalb am Alias zusaetzlich seine Quellen - `quellenVerteilung`
-     weiss ja, welche das sind. Und deshalb eine Liste: sonst bliebe
-     beim naechsten Wechsel die Haelfte abonniert und die Werkbank
-     bekaeme mit der Zeit Ereignisse fuer das halbe System. Die Zahl der
-     laufenden Abos steht in der Kopfleiste - dort sieht man sofort, ob
-     sich etwas ansammelt. */
+     Deshalb am Alias zusaetzlich seine Quellen, und - seit dem
+     18.09.2026 - an der Quelle ebenso: dort ergaenzt `uebernehmeBestand`
+     die Zeilen des vorhandenen Alias, und die lesen oft woanders
+     (`Stromzaehler` zeigt drei Zeilen „aus Solar.Netz"). Die standen
+     nach dem ersten Abholen still, gemessen 428 W gegen 22 W am System
+     (J9). `aboErgaenzen` wird darum von jeder Stelle gerufen, an der
+     Zeilen mit neuen Quellen dazukommen. Eine Liste, damit beim
+     naechsten Wechsel `aboLoesen` alles abmeldet. */
   aboLoesen();
-  var muster = [id + '.*'];
+  S.abo = [id + '.*'];
+  socket.emit('subscribe', id + '.*');
   if (id.indexOf('alias.') === 0) {
-    /* Aus den Quellen, nicht aus der Anzeige-Verteilung.
-
-       `quellenVerteilung` fasst zusammen, was die rechte Seite als
-       „Quellen" zeigt — dafuer bildet sie den ELTERNknoten jeder
-       Quelle. Bei einem flachen MQTT-Geraet ist das der halbe Adapter:
-       gemessen 09.09.2026 wurde daraus `mqtt-client.0.*` mit 322
-       Objekten, an einem einzigen Alias. Und `S.werte` wird nie
-       geleert, das sammelt sich also.
-
-       Abonniert wird deshalb der Kanal jeder wirklich gelesenen Quelle.
-       Wo die Quellen ohnehin gebuendelt liegen, bleibt es bei einem
-       Muster; wo nicht, sind es ein paar mehr — aber jedes davon eng. */
-    var kanaele = [];
+    var ausAlias = [];
     kindZustaende(id).forEach(function (kid) {
       var q = aliasQuellen(S.objects[kid]);
-      [q.read, q.write].forEach(function (x) {
-        if (!x) { return; }
-        var t = String(x).split('.');
-        t.pop();
-        var kn = t.join('.');
-        if (kn && kanaele.indexOf(kn) === -1) { kanaele.push(kn); }
-      });
-    });
-    /* Ein schmaler Kanal wird als Muster abonniert, ein breiter nicht.
-
-       Bei einem flachen Geraet IST der Kanal der breite Knoten: Die
-       Quelle `mqtt-client.0.SmartHome.Lavalampe_POWER` liegt direkt
-       unter `SmartHome`, und `SmartHome.*` sind 320 Objekte. Ab dieser
-       Schwelle werden die Quellen einzeln abonniert — ein paar Abos
-       mehr, dafuer genau die, deren Werte auch angezeigt werden. */
-    var SCHWELLE = 30;
-    var wieBreit = function (knoten) {
-      var n = 0;
-      S.keysSorted.forEach(function (k0) { if (k0.indexOf(knoten + '.') === 0) { n++; } });
-      return n;
-    };
-    var drinSchon = function (was) {
-      return muster.some(function (m0) {
-        var p0 = m0.slice(-2) === '.*' ? m0.slice(0, -2) : m0;
-        return was === p0 || was.indexOf(p0 + '.') === 0;
-      });
-    };
-
-    /* Sparten desselben Geraets zu einem Muster zusammenfassen.
-
-       Ein Tasmota-Alias liest aus `…Licht.stat`, `…Licht.tele` und
-       `…Licht.cmnd` — drei Kanaele, ein Geraet, und in der Kopfleiste
-       gehoert dort „ein Abo" zu stehen, nicht drei. Zusammengefasst wird
-       aber nur, wo wirklich MEHRERE Kanaele unter demselben Knoten
-       haengen: Sonst waere aus `…Garten.Weihnachten_aussen` schlicht
-       `…Garten` geworden — breiter als noetig, ohne dass etwas
-       zusammenfaellt. */
-    for (var runde = 0; runde < 4; runde++) {
-      var unter = {};
-      kanaele.forEach(function (kn) {
-        var t = kn.split('.');
-        if (t.length <= 3) { return; }
-        var ob = t.slice(0, -1).join('.');
-        (unter[ob] = unter[ob] || []).push(kn);
-      });
-      var geaendert = false;
-      Object.keys(unter).forEach(function (ob) {
-        if (unter[ob].length < 2 || wieBreit(ob) > SCHWELLE) { return; }
-        kanaele = kanaele.filter(function (kn) { return unter[ob].indexOf(kn) === -1; });
-        if (kanaele.indexOf(ob) === -1) { kanaele.push(ob); }
-        geaendert = true;
-      });
-      if (!geaendert) { break; }
-    }
-
-    /* Ein schmaler Kanal wird als Muster abonniert, ein breiter nicht.
-
-       Bei einem flachen Geraet IST der Kanal der breite Knoten: Die
-       Quelle `mqtt-client.0.SmartHome.Lavalampe_POWER` liegt direkt
-       unter `SmartHome`, und `SmartHome.*` sind 320 Objekte (gemessen
-       09.09.2026; vorher wurde daraus sogar `mqtt-client.0.*` mit 322).
-       Ab dieser Schwelle werden die Quellen einzeln abonniert — ein paar
-       Abos mehr, dafuer genau die, deren Werte auch angezeigt werden. */
-    kanaele.forEach(function (kn) {
-      if (drinSchon(kn)) { return; }
-      if (wieBreit(kn) > SCHWELLE) { return; }
-      muster.push(kn + '.*');
-    });
-    /* Was jetzt noch von keinem Muster gedeckt ist, kommt einzeln. */
-    kindZustaende(id).forEach(function (kid) {
-      var q = aliasQuellen(S.objects[kid]);
-      [q.read, q.write].forEach(function (x) {
-        if (x && !drinSchon(x) && muster.indexOf(x) === -1) { muster.push(x); }
-      });
+      if (q.read) { ausAlias.push(q.read); }
+      if (q.write) { ausAlias.push(q.write); }
     });
+    aboErgaenzen(ausAlias);
+  } else {
+    zeigeAbozahl();
   }
-  S.abo = muster;
-  muster.forEach(function (m) { socket.emit('subscribe', m); });
-  zeigeAbozahl();
 
   /* Erst die Werte, dann der Vorschlag. Die Erkennung schaut in den
      Rohwert von tele.SENSOR hinein — ohne Werte haelt sie ein Geraet
@@ -922,10 +1046,14 @@ export function waehle(id, fertig) {
         if (fest) { v.vonHandGewaehlt = false; v.ausBestand = true; }
         /* Gibt es den Alias schon, gilt sein Stand - in beiden Ansichten
            dasselbe Bild (Ricardo, 25.08.2026). */
-        if (vorh && S.objects[vorh]) { bestandVorrang(v, vorh); }
+        /* An einem Mehrfachgeraet zaehlt der Alias DIESES Ausgangs,
+           nicht der mit den meisten Punkten (C13). */
+        var vorhA = aliasFuer(id, ausgangsQuellen(v)) || (v.instanz === null || v.instanz === undefined ? vorh : null);
+        if (vorhA && S.objects[vorhA]) { bestandVorrang(v, vorhA); }
         S.entwurf = v;
       }
     }
+    aboErgaenzen(quellenVonEntwurf(S.entwurf));
     var nach = [];
     S.entwurf.states.forEach(function (s) {
       if (s.srcR && !S.werte[s.srcR]) { nach.push(s.srcR); }
@@ -1123,7 +1251,75 @@ function alsQuelleKarten() {
   return alsQuelleKarte;
 }
 
-export function aliasFuer(quelle) {
+/* Welche Quellen gehoeren zu genau diesem Ausgang?
+
+   An einem Mehrfachgeraet ist "der Alias dieses Geraets" keine
+   beantwortbare Frage - es gibt je Ausgang einen, dazu oft einen fuer
+   die gemeinsame Messung. Beantwortbar ist nur: welcher gehoert zu dem
+   Ausgang, der gerade gewaehlt ist.
+
+   Geraten wird dabei nichts an Namen herum. Gefragt wird die Vorlage:
+   welche ihrer Pfade tragen den Platzhalter? Genau die unterscheiden die
+   Ausgaenge (bei `tasmota-mehrfach` `stat.POWER%N%` und `cmnd.POWER%N%`),
+   alles andere (`tele.SENSOR`, `tele.LWT`) ist allen gemeinsam. Damit
+   faellt auch die Falle aus I31 weg: `tele.INFO2` traegt zwar eine Zwei,
+   aber keinen Platzhalter - es gehoert zu keinem Ausgang.
+
+   Fuer Ausgang 1 kommt das blanke `cmnd.POWER` dazu. Bei Tasmota ist
+   POWER ohne Nummer ein Zweitname fuer POWER1 - am 16.09.2026 an der
+   Steckdosenleiste nachgemessen: eine Abfrage an `cmnd/POWER` wird mit
+   `{"POWER1":"ON"}` beantwortet, und `stat/POWER` gibt es nicht. Ein
+   Alias, der so gebaut wurde, schaltet wirklich Ausgang 1 und gehoert
+   dorthin. */
+export function ausgangsQuellen(e) {
+  if (!e || e.instanz === null || e.instanz === undefined || !e.kanal) { return null; }
+  var v = null;
+  S.VORLAGEN.forEach(function (x) { if (x.id === e.vorlage) { v = x; } });
+  if (!v || !v.mehrfach) { return null; }
+  var platz = (v.mehrfach && v.mehrfach.platzhalter) || '%N%';
+  var raus = [];
+  var dazu = function (p) {
+    if (!p) { return; }
+    var voll = e.kanal + '.' + p;
+    if (raus.indexOf(voll) === -1) { raus.push(voll); }
+  };
+  (v.zustaende || []).forEach(function (z) {
+    [z.lesen, z.schreiben].forEach(function (p) {
+      if (!p || String(p).indexOf(platz) === -1) { return; }
+      dazu(setzeInstanz(p, v, e.instanz));
+      if (String(e.instanz) === '1') { dazu(String(p).split(platz).join('')); }
+    });
+  });
+  return raus.length ? raus : null;
+}
+
+/* Mit `ausgang` - der Liste aus `ausgangsQuellen` - fragt sie enger: nur
+   ein Alias, der wirklich aus einer dieser Quellen liest oder in eine
+   schreibt, gehoert zu diesem Ausgang. Ohne das Argument, und das sind
+   alle anderen sieben Aufrufer, bleibt sie Zeile fuer Zeile wie sie war.
+
+   Die Mehrheitsregel unten ist an einem Geraet mit einem Ausgang richtig
+   und an einem Mehrfachgeraet die falsche Frage: An Ricardos
+   Steckdosenleiste gewann `Verbrauch` mit sechs Punkten aus
+   `tele.SENSOR` gegen `RF1000` mit zwei Punkten aus `stat.POWER1`, und
+   der Entwurf fuer Ausgang 1 uebernahm dessen Haken. Im Musterfeld stand
+   danach "✕ SET fehlt" an einem Geraet mit funktionierendem SET
+   (C13, produktiv gemessen 16.09.2026).
+
+   Auch die Abkuerzung ueber `native.quelle` faellt in diesem Fall weg:
+   die zeigt auf das GERAET, nicht auf den Ausgang. */
+export function aliasFuer(quelle, ausgang) {
+  if (ausgang && ausgang.length) {
+    var karteA = alsQuelleKarten();
+    var zaehlA = {}, bestA = null, vielA = 0;
+    ausgang.forEach(function (q0) {
+      (karteA.zweig[q0] || []).forEach(function (kanal) {
+        zaehlA[kanal] = (zaehlA[kanal] || 0) + 1;
+        if (zaehlA[kanal] > vielA) { vielA = zaehlA[kanal]; bestA = kanal; }
+      });
+    });
+    return bestA;
+  }
   var karte = alsQuelleKarten();
   var treffer = karte.fest[quelle] || null;
   if (treffer) { return treffer; }
@@ -1170,6 +1366,22 @@ export function aliasFuer(quelle) {
 export function bestandVorrang(e, aliasId) {
   if (!e || !e.states || !aliasId) { return e; }
   var kanal = aliasId;
+  /* `vorlagenWert` heisst, was es heisst: was die VORLAGE sagen wuerde.
+     Ist keine in Kraft — abgewaehlt oder nie gefunden —, gibt es nichts,
+     wovon etwas abweichen koennte, und die Kopie darf nicht entstehen.
+
+     Bis zum 17.09.2026 wurde sie unbesehen gesetzt, und dann log die
+     Zeile: an `hm-rpc.2.NEQ1660737` nach „keine Vorlage" stand an SET
+     „weicht von der Vorlage ab" und darunter „Die Vorlage will hier:
+     switch" — waehrend im Alias `switch.light` steht, was auf das Muster
+     `light` sogar passt. Verglichen wurde in Wahrheit gegen den
+     Rohentwurf, also gegen die blanke Rolle des Quellpunkts, und als
+     abweichend markiert ausgerechnet der bessere Wert. Dasselbe an einem
+     Geraet, zu dem NIE eine Vorlage gefunden wurde (nachgestellt an
+     `echt.Warmwasser`): auch dort erschien die Marke. Ricardo: „es gibt
+     ja gar keine Vorlage mehr, man kann hoechstens vom Muster
+     abweichen." */
+  var mitVorlage = !!(e.vorschlag && e.vorlage);
   e.states.forEach(function (s) {
     if (!s.n) { return; }
     var o = S.objects[kanal + '.' + s.n];
@@ -1179,22 +1391,26 @@ export function bestandVorrang(e, aliasId) {
          anlegen (Ricardo, 25.08.2026: UNREACH und RSSI standen angehakt,
          obwohl sie im Alias fehlen). Anhaken kann man sie weiterhin, und
          der Chip „Vorlage" holt die Vorgabe der Vorlage zurueck. */
-      s.vorlagenWert = { on: s.on, role: s.role, typ: s.typ, unit: s.unit,
-                         caption: s.caption, f: s.f, fw: s.fw,
-                         srcR: s.srcR, srcW: s.srcW, states: s.states };
+      if (mitVorlage) {
+        s.vorlagenWert = { on: s.on, role: s.role, typ: s.typ, unit: s.unit,
+                           caption: s.caption, f: s.f, fw: s.fw,
+                           srcR: s.srcR, srcW: s.srcW, states: s.states };
+      }
       s.on = false;
       return;
     }
     var c = o.common;
     var q = aliasQuellen(o);
     /* Was die Vorlage wollte - fuer den Vergleich und den Knopf. */
-    s.vorlagenWert = {
-      role: s.role, typ: s.typ, unit: s.unit, caption: s.caption,
-      f: s.f, fw: s.fw, srcR: s.srcR, srcW: s.srcW, states: s.states,
-      /* Auch der Haken der Vorlage - der Chip „Vorlage" stellt ihn wieder
-         her, nachdem der Bestand ihn ueberschrieben hat. */
-      on: s.on
-    };
+    if (mitVorlage) {
+      s.vorlagenWert = {
+        role: s.role, typ: s.typ, unit: s.unit, caption: s.caption,
+        f: s.f, fw: s.fw, srcR: s.srcR, srcW: s.srcW, states: s.states,
+        /* Auch der Haken der Vorlage - der Chip „Vorlage" stellt ihn wieder
+           her, nachdem der Bestand ihn ueberschrieben hat. */
+        on: s.on
+      };
+    }
     var ist = zeileAusAlias(o, s.n);
     /* Rolle und Typ NUR, wenn sie im Alias ueberhaupt stehen.