iobroker.alias-workbench 0.8.3 → 0.9.7

package/admin/js/entwurf.js

@@ -8,9 +8,11 @@ import { $ } from './basis.js';
 import { txt, tr } from './sprache.js';
 import './enums.js';
 import { zusatzName, setzeModus, zeichneBaum, merkeKlappstand } from './baum.js';
-import { kindZustaende, aliasQuellen, holeWerte } from './werte.js';
+import { kindZustaende, aliasQuellen, holeWerte,
+  mitVorspann, schreibQuelle
+} from './werte.js';
 import { erkenneEntwurf } from './erkennung.js';
-import { vorschlag , pruefeVorlage } from './vorlagen.js';
+import { vorschlag , pruefeVorlage, zeigeAbozahl } from './vorlagen.js';
 
 import { zeichneErgebnis } from './ergebnis.js';
 
@@ -101,11 +103,7 @@ export function baueEntwurf(kanal) {
          alias.0.Badezimmer.Rollladen.CLOSE). Belegt ist das Schreiben
          durch `common.write` oder durch eine vorhandene Schreibformel -
          wer eine hinterlegt hat, wollte schreiben. */
-      srcW: istAlias
-        ? (q.einfach
-            ? ((c.write === true || typeof a.write === 'string') ? (q.write || '') : '')
-            : (q.write || ''))
-        : (c.write ? id : ''),
+      srcW: istAlias ? schreibQuelle(o) : (c.write ? id : ''),
       f: (typeof a.read === 'string') ? a.read : '',
       fw: (typeof a.write === 'string') ? a.write : '',
       caption: istAlias ? txt(c.name) : kanalBeschriftung(kanal, kurzName),
@@ -132,8 +130,8 @@ export function baueEntwurf(kanal) {
    entstanden ist - dieselbe Regel wie in `waehle`. Ohne sie durfte eine
    spaeter angelegte Vorlage beim Umschalten auf die Alle-Ansicht das
    fertige Geraet still uebernehmen (26.08.2026). */
-export function alleUndVorlage(kanal, vorlagenId) {
-  var v = vorschlag(kanal, vorlagenId);
+export function alleUndVorlage(kanal, vorlagenId, instanz) {
+  var v = vorschlag(kanal, vorlagenId, instanz);
   var roh = baueEntwurf(kanal);
   if (!v) { return roh; }
 
@@ -215,6 +213,120 @@ export function knotenDa(id) {
   return kindZustaende(id).length > 0;
 }
 
+/* Aus welchen Knoten liest dieser Alias, und wie oft aus jedem?
+
+   Dieselbe Zaehlung wie in `quelleVon` - nur dass die dort das Ergebnis
+   auf einen Sieger eindampft. Fuer die Anzeige zaehlt aber gerade das,
+   was dabei verlorengeht: dass es mehr als einen gibt. Ricardos
+   `alias.0.Solar.Netz` liest drei Punkte aus `0_userdata` und zwei aus
+   `mqtt-client`; der Sprungknopf fuehrte zur Mehrheit und sagte kein
+   Wort ueber den Rest (Ricardo, 08.09.2026).
+
+   Absteigend nach Anzahl, bei Gleichstand alphabetisch - sonst
+   wechselte die Reihenfolge bei jedem Neuzeichnen. */
+/* Zu welcher Quelle des Alias gehoert der Knoten, an dem ich stehe?
+
+   Die Antwort ist nicht „die Mehrheit", sondern „die hier". Sie traegt
+   zwei Dinge: den Rueckweg zum Alias (er gehoert an jede Quelle, nicht
+   nur an die groesste) und den Bezugspunkt der Zeilenmarken - markiert
+   wird, was NICHT von hier kommt (Ricardo, 08.09.2026).
+
+   Getroffen wird ein Eintrag der Verteilung auf drei Weisen: genau er,
+   ein Knoten unter ihm (`…Stromzaehler.stat` unter der zusammengefassten
+   Sparte) oder sein unmittelbarer Elternknoten - dort steht man am
+   Geraet, waehrend die Quelle eine Ebene tiefer liegt. Nur eine Ebene:
+   sonst bekaeme `mqtt-client.0.SmartHome` den Knopf und jede Ebene
+   darueber gleich mit. */
+export function quelleHier(aliasId, knoten) {
+  if (!aliasId || !knoten) { return null; }
+  var treffer = null;
+  quellenVerteilung(aliasId).forEach(function (q) {
+    if (treffer) { return; }
+    if (q.id === knoten) { treffer = q.id; return; }
+    if (knoten.indexOf(q.id + '.') === 0) { treffer = q.id; return; }
+    var t = q.id.split('.');
+    t.pop();
+    if (t.join('.') === knoten) { treffer = q.id; }
+  });
+  return treffer;
+}
+
+export function quellenVerteilung(aliasId) {
+  var zaehler = {};
+  kindZustaende(aliasId).forEach(function (id) {
+    var q = aliasQuellen(S.objects[id]);
+    /* Einmal je DATENPUNKT, nicht je Quellangabe. `quelleVon` zaehlt
+       Lese- und Schreibquelle getrennt - fuer den Mehrheitsentscheid
+       gleichgueltig, fuer eine Anzeige nicht: an einem Alias mit fuenf
+       Punkten stand „6 und 4" statt „3 und 2". Wo Lesen und Schreiben
+       auseinandergehen, zaehlt die Lesequelle: aus ihr kommt der Wert,
+       den man sieht. */
+    var x = q.read || q.write;
+    if (!x) { return; }
+    var t = String(x).split('.');
+    t.pop();
+    var eltern = t.join('.');
+    if (eltern) { zaehler[eltern] = (zaehler[eltern] || 0) + 1; }
+  });
+  var sortiere = function (liste) {
+    return liste.sort(function (a, b) { return (b.n - a.n) || (a.id < b.id ? -1 : 1); });
+  };
+  var liste = sortiere(Object.keys(zaehler).map(function (k) { return { id: k, n: zaehler[k] }; }));
+
+  /* Sparten desselben Geraets sind keine zweite Quelle.
+
+     Ein Tasmota-Alias liest aus `…Licht.stat` und `…Licht.tele` - das
+     sind zwei Knoten, aber ein Geraet, und „2 Quellen" waere dort
+     schlicht falsch. Alles, was unterhalb der Hauptquelle liegt, zaehlt
+     deshalb zu ihr. Uebrig bleiben nur eigene Zweige - bei Ricardos
+     `alias.0.Solar.Netz` `0_userdata` und `mqtt-client` (08.09.2026). */
+  var haupt = quelleVon(aliasId);
+  if (!haupt) { return liste; }
+  var raus = [], hauptN = 0;
+  liste.forEach(function (q) {
+    if (q.id === haupt || q.id.indexOf(haupt + '.') === 0) { hauptN += q.n; return; }
+    raus.push(q);
+  });
+  if (hauptN) { raus.push({ id: haupt, n: hauptN }); }
+
+  /* Dasselbe noch einmal unter den Nebenquellen.
+
+     Der Schritt darueber fasst nur gegen die HAUPTquelle zusammen. Bei
+     `alias.0.Solar.Balkon.Einspeisung` liegen aber zwei der Nebenquellen
+     ebenfalls beieinander - `…Solar_Balkon.stat` und `…Solar_Balkon.tele`
+     sind ein Tasmota, und es standen „4 Quellen" statt drei (Ricardo,
+     08.09.2026).
+
+     Zusammengefasst wird nur, was wirklich zusammengehoert: mehrere
+     Knoten unter demselben Elternknoten, und das auch nur, wenn sie
+     blosse Kennungsebenen ohne eigenes Objekt sind (so legt MQTT seine
+     Sparten an) oder ihr Elternknoten ein `device` ist (so liegen die
+     Kanaele bei Homematic). Zwei `channel` in einem Ordner - etwa
+     `0_userdata.0.Solar.Netz` und `…Solar.Balkon` - bleiben getrennt:
+     das sind zwei Geraete, keine zwei Sparten. */
+  var nachEltern = {};
+  raus.forEach(function (q) {
+    var t = q.id.split('.');
+    t.pop();
+    var eltern = t.join('.');
+    (nachEltern[eltern] = nachEltern[eltern] || []).push(q);
+  });
+  var zusammen = [];
+  Object.keys(nachEltern).forEach(function (eltern) {
+    var gruppe = nachEltern[eltern];
+    var ohneObjekt = gruppe.every(function (q) { return !S.objects[q.id]; });
+    var elternGeraet = !!(S.objects[eltern] && S.objects[eltern].type === 'device');
+    if (gruppe.length < 2 || !eltern || (!ohneObjekt && !elternGeraet)) {
+      zusammen = zusammen.concat(gruppe);
+      return;
+    }
+    var summe = 0;
+    gruppe.forEach(function (q) { summe += q.n; });
+    zusammen.push({ id: eltern, n: summe });
+  });
+  return sortiere(zusammen);
+}
+
 export function quelleVon(aliasId) {
   var o = S.objects[aliasId];
   var q = o && o.native && o.native.quelle;
@@ -436,7 +548,14 @@ export function steuerKanaele(dev) {
     var pflicht = f[0].states.filter(function (st) { return st.id; })
       .map(function (st) { return st.id; });
     if (!f[0].states.some(function (st) { return st.required && st.id; })) { return; }
-    raus.push({ id: id, typ: f[0].type, name: eigenerKanalName(id) || id.slice(pre.length),
+    /* `name` ist der Anzeigename und darf alles enthalten, was ein Mensch
+       hinschreibt. `kennung` ist, was als Objekt-ID taugt — dieselbe
+       Saeuberung wie ueberall sonst (T19). Getrennt, weil beides
+       gebraucht wird: die Liste zeigt den Namen, das Ziel nimmt die
+       Kennung. */
+    var kn = eigenerKanalName(id);
+    raus.push({ id: id, typ: f[0].type, name: kn || id.slice(pre.length),
+                kennung: kennungtauglich(kn || '') || id.slice(pre.length),
                 pflicht: pflicht });
   });
   kanalGeraeteCache[dev] = raus;
@@ -529,6 +648,20 @@ export function entwurfFuer(id, gemeinsam, gemAn) {
   return merkeHakenVorgabe(e2);
 }
 
+/* Alle laufenden Abos abmelden.
+
+   Stand nur in `waehle` — und damit meldete kein einziger der Wege ab,
+   die die Auswahl fallen lassen: der Moduswechsel, das Zuklappen eines
+   Zweigs, das Abschalten des Expertenmodus, das Loeschen eines Alias.
+   Danach lief ein Abo auf ein Geraet, das rechts gar nicht mehr steht,
+   der Zaehler in der Kopfleiste behauptete „ein Abo", und `S.werte`
+   fuellte sich weiter (gemessen 09.09.2026). */
+export function aboLoesen() {
+  (S.abo || []).forEach(function (m) { socket.emit('unsubscribe', m); });
+  S.abo = [];
+  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`
@@ -573,9 +706,118 @@ export function waehle(id, fertig) {
     sel.scrollIntoView({ block: 'nearest' });
   }
 
-  if (S.abo) { socket.emit('unsubscribe', S.abo); }
-  S.abo = id + '.*';
-  socket.emit('subscribe', S.abo);
+  /* Abonniert wird, was auch angezeigt wird.
+
+     Bisher nur `<knoten>.*`. An einer Quelle stimmt das - die Werte in
+     der Liste kommen von dort. Am Alias nicht: dort stehen die Werte der
+     QUELLEN, und die bekamen kein Ereignis. Die Zahlen wurden einmal
+     beim Auswaehlen geholt und standen dann still; an
+     `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. */
+  aboLoesen();
+  var muster = [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 = [];
+    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); }
+      });
+    });
+  }
+  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
@@ -600,7 +842,17 @@ export function waehle(id, fertig) {
   var werteDa = false;
   holeWerte(id, quellen, function () {
     werteDa = true;
-    if (id !== S.current) { return; }
+    if (id !== S.current) {
+      /* Der Knoten hat gewechselt, waehrend die Werte unterwegs waren.
+         Am Entwurf ist hier nichts mehr zu tun — der Rueckruf muss aber
+         trotzdem kommen. Sonst bleibt `so59Laeuft` oder `abfrageLaeuft`
+         fuer immer gesetzt (der Knopf steht dauerhaft auf „laeuft"), und
+         der Trockenlauf nach dem Anlegen fehlender Sendepunkte geht nie
+         auf. Zwoelf Sekunden Wartezeit bei einer SetOption59-Abfrage
+         sind reichlich Gelegenheit dafuer (09.09.2026). */
+      if (typeof fertig === 'function') { fertig(); }
+      return;
+    }
 
     /* Wer schon Hand angelegt hat, behaelt seinen Entwurf.
 
@@ -812,13 +1064,40 @@ export function geraeteDarunter(wurzel) {
    angelegt" und erzeugt beim Klick ein zweites Geraet, waehrend das
    erste verwaist stehenbleibt. Beim Karbonator lag der Alias unter
    alias.0.Strom, vorgeschlagen wurde alias.0.SmartHome. */
-export function aliasFuer(quelle) {
-  var treffer = null;
-  S.keysSorted.forEach(function (id) {
-    if (treffer || id.indexOf('alias.') !== 0) { return; }
+/* Rueckwaertskarte Quelle -> Alias, einmal je Indexstand.
+
+   `aliasFuer` lief zweimal ueber alle Kennungen — und wird je
+   Neuzeichnen mehrfach gerufen. Die Karte entsteht bei der ersten Frage
+   nach einem Indexwechsel und beantwortet alle weiteren aus dem
+   Gedaechtnis. Erkannt wird der Wechsel an Laenge und erster Kennung;
+   `indexNeu()` sortiert ohnehin bei jeder Aenderung neu. */
+var alsQuelleKarte = null, alsQuelleStand = '';
+function alsQuelleKarten() {
+  var stand = S.keysSorted.length + '|' + (S.keysSorted[0] || '');
+  if (alsQuelleKarte && alsQuelleStand === stand) { return alsQuelleKarte; }
+  var fest = {}, zweig = {};
+  mitVorspann('alias.').forEach(function (id) {
     var o = S.objects[id];
-    if (o && o.native && o.native.quelle === quelle) { treffer = id; }
+    if (!o) { return; }
+    if (o.native && o.native.quelle && fest[o.native.quelle] === undefined) {
+      fest[o.native.quelle] = id;
+    }
+    if (o.type !== 'state') { return; }
+    var q = aliasQuellen(o);
+    [q.read, q.write].forEach(function (x) {
+      if (!x) { return; }
+      var kanal = id.split('.').slice(0, -1).join('.');
+      (zweig[x] = zweig[x] || []).push(kanal);
+    });
   });
+  alsQuelleKarte = { fest: fest, zweig: zweig };
+  alsQuelleStand = stand;
+  return alsQuelleKarte;
+}
+
+export function aliasFuer(quelle) {
+  var karte = alsQuelleKarten();
+  var treffer = karte.fest[quelle] || null;
   if (treffer) { return treffer; }
 
   /* Welcher Aliaskanal liest oder schreibt am haeufigsten in diesen
@@ -827,17 +1106,19 @@ export function aliasFuer(quelle) {
      erste Treffer. */
   var zaehler = {}, bester = null, wieviel = 0;
   var pre = quelle + '.';
-  S.keysSorted.forEach(function (id) {
-    if (id.indexOf('alias.') !== 0) { return; }
-    var o = S.objects[id];
-    if (!o || o.type !== 'state') { return; }
-    var q = aliasQuellen(o);
-    var passt = (q.read && q.read.indexOf(pre) === 0) ||
-                (q.write && q.write.indexOf(pre) === 0);
-    if (!passt) { return; }
-    var eltern = id.slice(0, id.lastIndexOf('.'));
-    zaehler[eltern] = (zaehler[eltern] || 0) + 1;
-    if (zaehler[eltern] > wieviel) { wieviel = zaehler[eltern]; bester = eltern; }
+  /* Aus der Karte: welche Aliaskanaele lesen oder schreiben in diesen
+     Zweig? Die Quellen stehen dort als volle Kennung, gesucht ist alles
+     darunter — also die Kennungen des Zweigs abklappern statt aller
+     Aliase. */
+  var karte2 = alsQuelleKarten();
+  var kanaele = [];
+  Object.keys(karte2.zweig).forEach(function (q0) {
+    if (q0.indexOf(pre) !== 0) { return; }
+    karte2.zweig[q0].forEach(function (kanal) { kanaele.push(kanal); });
+  });
+  kanaele.forEach(function (kanal) {
+    zaehler[kanal] = (zaehler[kanal] || 0) + 1;
+    if (zaehler[kanal] > wieviel) { wieviel = zaehler[kanal]; bester = kanal; }
   });
   return bester;
 }
@@ -897,9 +1178,7 @@ export function bestandVorrang(e, aliasId) {
     s.f = (typeof a.read === 'string') ? a.read : '';
     s.fw = (typeof a.write === 'string') ? a.write : '';
     if (q.read) { s.srcR = q.read; }
-    s.srcW = q.einfach
-      ? ((c.write === true || typeof a.write === 'string') ? (q.write || '') : '')
-      : (q.write || '');
+    s.srcW = schreibQuelle(o);
     s.on = true;
     s.ausBestand = true;
   });
@@ -936,9 +1215,7 @@ export function bestandsAbweichung(s, aliasId) {
     f: (typeof a.read === 'string') ? a.read : '',
     fw: (typeof a.write === 'string') ? a.write : '',
     srcR: q.read || '',
-    srcW: q.einfach
-      ? ((c.write === true || typeof a.write === 'string') ? (q.write || '') : '')
-      : (q.write || '')
+    srcW: schreibQuelle(o)
   };
   var raus = [];
   ['role', 'typ', 'unit', 'f', 'fw', 'srcR', 'srcW'].forEach(function (k) {
@@ -948,13 +1225,6 @@ export function bestandsAbweichung(s, aliasId) {
   return raus;
 }
 
-/* Einen einzelnen Wert aus dem gespeicherten Alias zurueckholen. */
-export function bestandsWert(s, aliasId, feld) {
-  var abw = bestandsAbweichung(s, aliasId);
-  var tr0 = null;
-  abw.forEach(function (x) { if (x.feld === feld) { tr0 = x; } });
-  return tr0 ? tr0.bestand : null;
-}
 
 /* Wo weicht die Vorlage vom Bestand ab? Liefert je Zeile die Felder, die
    „Vorlage anwenden" aendern wuerde - die Beschriftung ausgenommen. */

package/admin/js/enums.js

@@ -9,15 +9,58 @@ import { socket } from './verbindung.js';
    suchen haben. */
 export var enums = {};
 
+/* Wissen wir gerade, was in den Aufzaehlungen steht?
+
+   Das ist keine Feinheit, sondern die Bedingung dafuer, ueberhaupt eine
+   schreiben zu duerfen. Frueher setzte ein Ladefehler `enums` auf `{}`
+   und verschwieg es. Danach hielt die Werkbank jede Aufzaehlung fuer
+   nicht vorhanden - der Katalog bot `garden` weiter an, weil der
+   Dublettenfilter gegen nichts pruefte, und `enumAenderungen` baute sie
+   als NEU aus der Vorlage. `setObject` ersetzt ein Objekt vollstaendig:
+   Gemessen 09.09.2026 am Testsystem verlor `enum.rooms.garden` dabei
+   drei Mitglieder und behielt eines, dazu die Herkunftsmarke, die ihn
+   spaeter auch noch loeschbar macht. Bei Ricardo waeren das die aus der
+   CCU gespiegelten Raeume.
+
+   Solange diese Marke steht, wird keine Aufzaehlung angefasst. */
+var unbekannt = false;
+export function enumsUnbekannt() { return unbekannt; }
+
+/* Ein Aussetzer soll die Werkbank nicht fuer den Rest der Sitzung
+   lahmlegen. Dreimal mit wachsendem Abstand, dann ist Schluss - eine
+   Schleife ohne Ende waere schlimmer als der Fehler. */
+var versuch = 0;
+var wiederTimer = null;
+
 export function ladeEnums(danach) {
+  if (wiederTimer) { clearTimeout(wiederTimer); wiederTimer = null; }
   socket.emit('getObjectView', 'system', 'enum',
-    { startkey: 'enum.', endkey: 'enum.\u9999' }, function (err, doc) {
-      enums = {};
-      if (!err && doc && doc.rows) {
-        doc.rows.forEach(function (r) {
-          if (r.value && r.id) { enums[r.id] = r.value; }
-        });
+    { startkey: 'enum.', endkey: 'enum.香' }, function (err, doc) {
+      if (err || !doc || !doc.rows) {
+        /* Den alten Stand behalten. Er ist vielleicht veraltet, aber
+           veraltet ist naeher an der Wahrheit als leer. */
+        unbekannt = true;
+        console.warn('[alias-workbench] Aufzaehlungen nicht geladen: ' +
+                     (err || 'keine Antwort'));
+        if (versuch < 3) {
+          versuch++;
+          wiederTimer = setTimeout(function () {
+            wiederTimer = null;
+            ladeEnums();
+          }, versuch * 4000);
+        }
+        if (typeof danach === 'function') { danach(err || 'leer'); }
+        return;
       }
-      if (typeof danach === 'function') { danach(); }
+      /* Erst sammeln, dann tauschen: ein Fehler mittendrin liesse sonst
+         einen halben Vorrat stehen. */
+      var frisch = {};
+      doc.rows.forEach(function (r) {
+        if (r.value && r.id) { frisch[r.id] = r.value; }
+      });
+      enums = frisch;
+      unbekannt = false;
+      versuch = 0;
+      if (typeof danach === 'function') { danach(null); }
     });
 }