iobroker.alias-workbench 0.8.0

package/admin/js/musternamen.js

@@ -0,0 +1,94 @@
+/* Die uebersetzten Namen der Muster, angezapft beim Geraete-Adapter.
+
+   Der type-detector kennt nur rohe Typnamen (socket, thermostat). Der
+   Geraete-Adapter fuehrt fuer genau diese Typen fertige Uebersetzungen
+   in elf Sprachen - in seinem Bundle, ein Block je Sprache, und jeder
+   Block gibt sich am Eintrag "type-Device type" selbst zu erkennen.
+   Wir holen den Block der Oberflaechensprache und schlagen darin nach;
+   eine eigene Liste wuerde bei jedem type-detector-Update altern
+   (Ricardos Punkt 13, 25.08.2026 - Weg 2, wie der Raum/Funktion-Katalog).
+
+   Bricht die Kette - Adapter fehlt, Bundle umgebaut - bleibt die Karte
+   leer und ueberall steht der rohe Name. Kein Fehler, nur weniger
+   Komfort. Beide Bundle-Fassungen werden verstanden: die neue (4.x)
+   schreibt Werte in Backticks, die alte (1.x, produktiv) als
+   JSON-Strings. */
+
+import { sprache } from './sprache.js';
+import { holeText } from './basis.js';
+
+var musterNamen = {};
+var geholt = false;
+
+/* Woran sich der gesuchte Sprachblock zu erkennen gibt. Mehr Sprachen
+   kennt die Werkbank nicht (SPRACHEN in sprache.js). */
+var ANKER = { de: 'Ger\u00e4tetyp', en: 'Device type' };
+
+function ziehe(src) {
+  var anker = ANKER[sprache] || ANKER.en;
+  var re = /"type-Device type":(?:`([^`]*)`|"((?:[^"\\]|\\.)*)")/g;
+  var m, start = -1;
+  while ((m = re.exec(src))) {
+    if ((m[1] !== undefined ? m[1] : m[2]) === anker) { start = m.index; break; }
+  }
+  if (start < 0) { return null; }
+  /* Der Block enthaelt nur type-Schluessel - das naechste } beendet ihn. */
+  var teil = src.slice(start, src.indexOf('}', start));
+  var raus = {};
+  var re2 = /"type-([^"]+)":(?:`([^`]*)`|"((?:[^"\\]|\\.)*)")/g;
+  var m2;
+  while ((m2 = re2.exec(teil))) {
+    var wert = m2[2] !== undefined ? m2[2] : m2[3].replace(/\\(.)/g, '$1');
+    if (m2[1] !== 'Device type') { raus[m2[1]] = wert; }
+  }
+  return Object.keys(raus).length ? raus : null;
+}
+
+export function ladeMusterNamen(nachher) {
+  if (geholt) { return; }
+  geholt = true;
+  holeText('/adapter/devices/tab.html').then(function (html) {
+    /* Die tab.html nennt mehrere Bausteine (Bootstrap-Haeppchen,
+       Vendor, Hauptbundle). Die Karte steckt im Hauptbundle - das
+       heisst in beiden bekannten Fassungen index-<hash>.js, also
+       dieses zuerst, die uebrigen als Rueckfall der Reihe nach. */
+    var dateien = (html.match(/assets\/[A-Za-z0-9_\-.]+\.js/g) || [])
+      .filter(function (x, i, a) { return a.indexOf(x) === i; })
+      .sort(function (a, b) {
+        return (b.indexOf('assets/index-') === 0 ? 1 : 0)
+             - (a.indexOf('assets/index-') === 0 ? 1 : 0);
+      })
+      .slice(0, 8);
+    if (!dateien.length) { throw new Error('kein Bundle'); }
+    return dateien.reduce(function (kette, f) {
+      return kette.then(function (fertig) {
+        if (fertig) { return true; }
+        return holeText('/adapter/devices/' + f).then(function (src) {
+          var karte = ziehe(src);
+          if (karte) { musterNamen = karte; return true; }
+          return false;
+        })['catch'](function () { return false; });
+      });
+    }, Promise.resolve(false));
+  })['catch'](function () { /* still bleiben: rohe Namen genuegen */ })
+    .then(function () { if (typeof nachher === 'function') { nachher(); } });
+}
+
+/* Der Beiname eines Musters - leer nur, wenn der Katalog nichts weiss.
+   Auch die blosse Grossschreibung („Dimmer“ zu dimmer) zaehlt: sonst
+   standen in der Liste grosse Beinamen und kleine rohe Namen gemischt
+   (Ricardo, 25.08.2026). Ob der rohe Name dazugehoert, entscheidet die
+   Anzeige - sagt der Beiname nur die Schreibung, waere „Dimmer ·
+   dimmer“ doppelt gemoppelt. */
+export function musterName(typ) {
+  return musterNamen[typ] || '';
+}
+
+/* Beiname und roher Name fuer Listen, immer als Paar: „Fenstersensor
+   · window“ und auch „Dimmer · dimmer“ - einheitlich lesbar, selbst
+   wenn Deutsch und roher Name fast gleich sind (Ricardo, 25.08.2026).
+   Nur ohne Katalogeintrag steht der rohe Name allein. */
+export function musterZeile(typ) {
+  var n = musterNamen[typ];
+  return n ? (n + '  ·  ' + typ) : typ;
+}

package/admin/js/musterwahl.js

@@ -0,0 +1,334 @@
+/* Die Musterwahl: das Suchfeld mit eigener Liste, die Bewertung je
+   Muster (passt / n von m belegt) und der Knopf, der freie Plaetze
+   vorschlaegt. Gebaut wird beides hier, eingehaengt woanders: der Block
+   je nach Ansicht im Vorlagenkasten oder in der Leiste ueber der Liste,
+   der Knopf immer in der Leiste.
+
+   Herausgeloest aus zeichneErgebnis - der Abschnitt hing an `e`, dem
+   Erkennungsergebnis und sonst an nichts. */
+
+import { S } from './zustand.js';
+import { D, el, $ } from './basis.js';
+import { tr, sprachtext } from './sprache.js';
+import { VORSCHAU, musterVon, erkenneEntwurf } from './erkennung.js';
+import { anMusterAnpassen } from './vorlagen.js';
+import { ratePlaetze, rateZurueck, rateAnzahl, rateMoeglich } from './vorschlagen.js';
+import { zeichneErgebnis, entwurfAngefasst, knopfFrisch } from './ergebnis.js';
+import { musterName, musterZeile } from './musternamen.js';
+
+export function baueMusterwahl(e, haupt, pflichtFehlt) {
+  var vw = el('div', 'verdictwrap' + (haupt && !pflichtFehlt.length ? '' : ' bad'));
+  var vlbl = el('span', 'feldlabel', tr('pattern.label'));
+  vw.appendChild(vlbl);
+  /* Musterwahl als Eingabefeld mit eigener Liste statt als <select>.
+     Ein <select> laesst sich nicht durchsuchen, und die 51 Muster
+     brauchten deshalb einen Knopf daneben, der die Liste umschaltet.
+     Jetzt ist beides im Feld: tippen sucht ueber alle Muster, und die
+     letzte Zeile schaltet zwischen den ueblichen und allen um. Kein
+     <datalist> - dessen Fenster malt das Betriebssystem, und in
+     eingebetteten Ansichten landet es neben dem Fenster. */
+  var mwrap = el('div', 'feldwrap');
+  var sel = el('input', 'tx musterwahl');
+  sel.type = 'text';
+  sel.setAttribute('autocomplete', 'off');
+  sel.placeholder = tr('pattern.search');
+  mwrap.appendChild(sel);
+  /* Kein eigenes Pfeilzeichen mehr: das Feld traegt denselben
+     SVG-Pfeil wie jedes Auswahlfeld (werkbank.css). Das Zeichen ▾
+     ist in der Schrift ein bewusst kleines Dreieck und fiel neben den
+     Selects sichtbar ab. */
+  var mlist = el('div', 'vorschlaege musterliste');
+  mlist.hidden = true;
+  mwrap.appendChild(mlist);
+  vw.appendChild(mwrap);
+
+  /* Der Knopf, der die freien Plaetze belegt.
+
+     Ein Knopf und nicht der Musterwechsel als Ausloeser: sonst haette
+     ausgerechnet ein erkanntes Geraet keinen. Ricardos Klimaanlage wird
+     als `thermostat` erkannt, man wechselt also gar nichts, und ohne
+     Knopf bliebe es dabei.
+
+     Er wird hier gebaut, weil er zum Muster gehoert - haengt aber unten
+     in der Leiste ueber der Zustandsliste. Neben dem Musterfeld stand er
+     am Rand; die Liste, die er veraendert, faengt darunter an. */
+  /* Und nur, wenn er etwas anzubieten haette: ohne freie Plaetze oder
+     freie Zeilen ist der Knopf ein leeres Versprechen — dann faellt er
+     weg, statt beim Klick „nichts gefunden" zu melden. Zuruecknehmen
+     bleibt immer moeglich, solange Vermutungen im Entwurf stehen. */
+  var rateKnopf = null;
+  if (rateAnzahl(e) || rateMoeglich(e)) {
+    /* Mit passender Vorlage ist Raten nicht der normale Weg - die
+       Zuordnung steht ja schon. Der Knopf bleibt, tritt aber leise auf
+       und fragt vor dem Lauf nach (Ricardo, 25.08.2026). */
+    var beilaeufig = !!e.vorlage && !rateAnzahl(e);
+    rateKnopf = el('button', 'btn mini' + (rateAnzahl(e) ? ' wichtig' : '')
+      + (beilaeufig ? ' leise' : '')
+      /* Ein leiser Knopf pocht nicht - das Pochen wuerde genau die
+         Aufmerksamkeit holen, die er nicht verdient. */
+      + (!beilaeufig && knopfFrisch('raten:' + S.current + ':' + (rateAnzahl(e) ? 'zurueck' : 'vor')) ? ' frisch' : ''),
+      rateAnzahl(e) ? tr('guess.undo') : tr('guess.button'));
+    rateKnopf.title = beilaeufig ? tr('guess.tplHint') : tr('guess.hint');
+    var rateLos = function () {
+      e.rateMeldung = ratePlaetze(e) ? null : tr('guess.none');
+      entwurfAngefasst();
+      S.openRow = null;
+      zeichneErgebnis();
+    };
+    rateKnopf.addEventListener('click', function () {
+      if (rateAnzahl(e)) {
+        rateZurueck(e); e.rateMeldung = null;
+        entwurfAngefasst();
+        S.openRow = null;
+        zeichneErgebnis();
+        return;
+      }
+      if (!beilaeufig) { rateLos(); return; }
+      var vq = null;
+      S.VORLAGEN.forEach(function (v) { if (v.id === e.vorlage) { vq = v; } });
+      var body = $('#guess-body');
+      body.textContent = '';
+      body.appendChild(el('div', 'aside w',
+        tr('guess.tplAsk', vq ? sprachtext(vq.name) : e.vorlage)));
+      /* onclick statt addEventListener: der Dialog ist einer fuer alle
+         Geraete, der Griff muss beim Oeffnen den alten ersetzen. */
+      $('#btn-guess-go').onclick = function () {
+        $('#dlg-guess').close();
+        rateLos();
+      };
+      $('#dlg-guess').showModal();
+    });
+  }
+
+  /* Typen, nicht Schluessel: wer „blinds" waehlte, bekam einen
+     Entwurf fuer einen Typ, den der Detektor nicht kennt. */
+  var alleTypen = Object.keys(D.patterns)
+    .map(function (k) { return D.patterns[k].type || k; })
+    .filter(function (t, n, arr) { return arr.indexOf(t) === n; }).sort();
+
+  /* Die Belegung je Muster auszurechnen kostet einen Erkennungslauf.
+     Beim Tippen wird die Liste bei jedem Anschlag neu gemalt, deshalb
+     einmal gemerkt statt jedes Mal neu gerechnet. */
+  var markeCache = {};
+  function bewerte(m) {
+    if (markeCache[m] !== undefined) { return markeCache[m]; }
+    /* Die Vorschau muss vorhersagen, was das Auswaehlen wirklich tut.
+       Beim Vorschlag werden Lampe und Steckdose samt Rollen neu gebaut -
+       also auch hier gegen den umgebauten Entwurf pruefen. Sonst stuende
+       hier „SET fehlt", und nach dem Klick passte trotzdem alles. */
+    var pruefE = e;
+    if (e.vorschlag && !e.roh && m !== e.want && musterVon(m)) {
+      var kopie = JSON.parse(JSON.stringify({ kanal: e.kanal, states: e.states, want: e.want }));
+      anMusterAnpassen(kopie, m);
+      if (kopie.states.some(function (x, n) { return x.role !== e.states[n].role; })) {
+        pruefE = kopie;
+      }
+    }
+    var r = erkenneEntwurf(pruefE, m), mark;
+    if (!r.length) {
+      var fehlend = musterVon(m).states.filter(function (x) { return x.required; })
+        .map(function (x) { return x.name; });
+      mark = fehlend.length ? ('✕ ' + tr('pattern.missing', fehlend.join(', ')))
+                            : tr('pattern.doesNotFit');
+    } else {
+      var g = r[0].states.filter(function (x) { return x.id; }).length;
+      mark = tr('pattern.slotsTaken', g, r[0].states.length);
+      /* Hier stand frueher „(Rollen werden angepasst)" hinter der
+         Belegung. Der Vermerk erschien an jeder Zeile ausser der gerade
+         gewaehlten — an einem Fensterkontakt also an sieben von acht.
+         Was fast ueberall steht, unterscheidet nichts; es verdraengte
+         nur Name und Belegung, also genau das, wonach man in der Liste
+         sucht. Dass beim Wechsel die Rollen passend gesetzt werden, ist
+         ohnehin das gewollte Verhalten und keine Abwaegung, die man vor
+         der Auswahl treffen muesste. */
+    }
+    markeCache[m] = { mark: mark, passt: !!r.length, belegt: r.length ? r[0].states.filter(function (x) { return x.id; }).length : 0 };
+    return markeCache[m];
+  }
+  function markeFuer(m) { return bewerte(m).mark; }
+
+  /* Welche Muster ohne Suchtext angeboten werden. Das erkannte und das
+     gerade gewaehlte gehoeren immer dazu - sonst fiel rgbSingle heraus,
+     sobald man einmal auf light gewechselt hatte, und der Weg zurueck
+     fuehrte nur ueber die ganze Liste. */
+  function grundListe() {
+    var l = e.alleMuster ? alleTypen.slice() : VORSCHAU.slice();
+    [e.wantAuto, e.want].forEach(function (m0) {
+      if (m0 && musterVon(m0) && l.indexOf(m0) === -1) { l.unshift(m0); }
+    });
+    return l.filter(function (m) { return !!musterVon(m); });
+  }
+
+  /* Gesucht wird ueber den Namen des Musters und ueber die Rollen seiner
+     Plaetze. „state" findet so auch light und window, deren Plaetze
+     state.light und state.window annehmen - der Name allein haette dazu
+     nichts gemeldet. */
+  function rollenVon(m) {
+    var mu = musterVon(m);
+    if (!mu) { return []; }
+    return mu.states.map(function (x) { return x.defaultRole || ''; })
+      .filter(Boolean).filter(function (r0, n, arr) { return arr.indexOf(r0) === n; });
+  }
+
+  var mMarkiert = -1;
+  var mEintraege = [];
+  var mSchliessen = function () { mlist.hidden = true; mMarkiert = -1; };
+
+  var mWaehlen = function (neuTyp) {
+    if (!musterVon(neuTyp)) { return; }
+    mSchliessen();
+    /* Beim Vorschlag reicht es nicht, das Muster umzustellen - die Rollen
+       entscheiden. switch.light passt auf kein socket-SET. Also den
+       Vorschlag mit den passenden Rollen neu bauen. */
+    if (e.vorschlag && !e.roh) {
+      anMusterAnpassen(e, neuTyp);
+    } else {
+      e.want = neuTyp;
+    }
+    S.openRow = null;
+    /* Kein Fokus zurueck ins Feld: der Fokus oeffnete die Liste sofort
+       wieder, und nach der Wahl stand sie erneut offen — man musste
+       eigens daneben klicken. Die Wahl ist getroffen; wer ein anderes
+       Muster will, klickt neu ins Feld. */
+    zeichneErgebnis();
+  };
+
+  var mMalen = function () {
+    var such = String(sel.value || '').trim().toLowerCase();
+    var treffer = [];
+    if (!such) {
+      treffer = grundListe().map(function (m) { return { m: m, via: null }; });
+    } else {
+      /* Mit Suchtext wird immer der ganze Bestand durchsucht, nicht nur
+         die uebliche Auswahl - sonst muesste man erst umschalten, um
+         ueberhaupt finden zu koennen. */
+      alleTypen.forEach(function (m) {
+        if (!musterVon(m)) { return; }
+        /* Wer „Steckdose“ tippt, will socket finden - die Suche geht
+           ueber rohen Namen UND Beinamen. */
+        if (m.toLowerCase().indexOf(such) > -1
+            || musterName(m).toLowerCase().indexOf(such) > -1) { treffer.push({ m: m, via: null }); return; }
+        var r0 = rollenVon(m).filter(function (x) { return x.toLowerCase().indexOf(such) > -1; });
+        if (r0.length) { treffer.push({ m: m, via: r0[0] }); }
+      });
+    }
+    /* Was passt, steht oben. Ein Muster, dem eine Pflichtangabe fehlt,
+       ist keine Wahl, die man gerade trifft — es soll die Liste nicht
+       anfuehren, nur weil es alphabetisch vorn steht. Unter den
+       passenden gewinnt, wer mehr Plaetze belegt; darunter bleibt die
+       Reihenfolge, in der die Liste zusammengestellt wurde. */
+    treffer.forEach(function (t0, n) { t0.rang = n; });
+    treffer.sort(function (a, b) {
+      var pa = bewerte(a.m), pb = bewerte(b.m);
+      if (pa.passt !== pb.passt) { return pa.passt ? -1 : 1; }
+      if (pa.passt && pb.belegt !== pa.belegt) { return pb.belegt - pa.belegt; }
+      return a.rang - b.rang;
+    });
+    mEintraege = treffer;
+
+    mlist.textContent = '';
+    if (!treffer.length) {
+      var leer = el('div', 'vz zurueck');
+      leer.appendChild(el('span', null, tr('pattern.noMatch', sel.value)));
+      mlist.appendChild(leer);
+    }
+    treffer.forEach(function (t0, n) {
+      var z = el('div', 'vz' + (n === mMarkiert ? ' an' : '')
+        + (t0.m === e.want ? ' gewaehlt' : ''));
+      z.appendChild(el('span', null, musterZeile(t0.m)));
+      z.appendChild(el('span', 'tiefer',
+        (t0.via ? tr('pattern.viaRole', t0.via) + '   ' : '') + markeFuer(t0.m)));
+      /* mousedown statt click: sonst greift der Fokusverlust zuerst und
+         die Liste ist weg, bevor der Klick ankommt. */
+      z.addEventListener('mousedown', function (ev) {
+        ev.preventDefault();
+        mWaehlen(t0.m);
+      });
+      mlist.appendChild(z);
+    });
+
+    /* Der Umschalter, der frueher als Knopf daneben stand. Beim Suchen
+       ist er ueberfluessig - dann laeuft die Suche ohnehin ueber alles. */
+    if (!such && alleTypen.length > VORSCHAU.length) {
+      var um = el('div', 'vz mehr');
+      um.appendChild(el('span', null, (e.alleMuster ? '▴  ' : '▾  ')
+        + (e.alleMuster ? tr('pattern.usualOnly')
+                        : tr('pattern.allPatterns', alleTypen.length))));
+      um.addEventListener('mousedown', function (ev) {
+        ev.preventDefault();
+        e.alleMuster = !e.alleMuster;
+        mMarkiert = -1;
+        mMalen();
+        sel.focus();
+      });
+      mlist.appendChild(um);
+    }
+    mlist.hidden = false;
+  };
+
+  /* Solange nichts getippt ist, steht im Feld das gewaehlte Muster mit
+     seiner Belegung - dieselbe Auskunft wie frueher im zugeklappten
+     Auswahlfeld. */
+  var mBeschriften = function () {
+    /* Im Feld der Beiname, der rohe Name im Tooltip - fuer beides
+       nebeneinander ist das Feld zu schmal. */
+    sel.value = e.want ? ((musterName(e.want) || e.want) + '   ' + markeFuer(e.want)) : '';
+    sel.title = e.want || '';
+  };
+  mBeschriften();
+
+  sel.addEventListener('focus', function () {
+    sel.value = '';
+    mMarkiert = -1;
+    mMalen();
+  });
+  sel.addEventListener('input', function () { mMarkiert = -1; mMalen(); });
+  sel.addEventListener('blur', function () {
+    setTimeout(function () { mSchliessen(); mBeschriften(); }, 120);
+  });
+  sel.addEventListener('keydown', function (ev) {
+    if (ev.key === 'Escape') { mSchliessen(); mBeschriften(); sel.blur(); return; }
+    if (ev.key === 'ArrowDown' || ev.key === 'ArrowUp') {
+      if (mlist.hidden) { mMalen(); return; }
+      ev.preventDefault();
+      if (!mEintraege.length) { return; }
+      mMarkiert += (ev.key === 'ArrowDown' ? 1 : -1);
+      if (mMarkiert < 0) { mMarkiert = mEintraege.length - 1; }
+      if (mMarkiert >= mEintraege.length) { mMarkiert = 0; }
+      mMalen();
+      var akt = mlist.children[mMarkiert];
+      if (akt && akt.scrollIntoView) { akt.scrollIntoView({ block: 'nearest' }); }
+      return;
+    }
+    if (ev.key === 'Enter') {
+      ev.preventDefault();
+      if (!mlist.hidden && mEintraege.length) {
+        mWaehlen(mEintraege[mMarkiert >= 0 ? mMarkiert : 0].m);
+      }
+    }
+  });
+  if (S.fokusMusterfeld) {
+    S.fokusMusterfeld = false;
+    setTimeout(function () { sel.focus(); }, 0);
+  }
+
+  /* Kein Fliesstext unter dem Auswahlfeld: die Belegung steht schon in
+     jeder Zeile des Auswahlfelds, und eine zweite Zeile verschoebe die
+     Felder daneben gegeneinander. Nur Meldungen bleiben. */
+  var meta = el('div', 'vmeta');
+  if (!haupt) {
+    meta.appendChild(el('span', 'chip bad', tr('pattern.notDetected')));
+  } else if (pflichtFehlt.length) {
+    meta.appendChild(el('span', 'chip bad',
+      tr('pattern.missing', pflichtFehlt.map(function (x) { return x.name; }).join(', '))));
+  }
+  if (e.want && e.wantAuto && e.want !== e.wantAuto) {
+    meta.appendChild(el('span', 'chip warn', tr('pattern.manualInstead', e.wantAuto)));
+  }
+  if (meta.childNodes.length) { vw.appendChild(meta); }
+  /* Der Knopf „alle 51 Muster" stand frueher neben dem Auswahlfeld und
+     schaltete die Liste um. Er sitzt jetzt als letzte Zeile in der Liste
+     selbst - dort, wo man ihn braucht, statt daneben. */
+
+  return { block: vw, rateKnopf: rateKnopf };
+}

package/admin/js/objekte.js

@@ -0,0 +1,243 @@
+/* Das Objektlager: Laden, Abo, Index, gezieltes Nachladen.
+
+   Was hier lebt, ist die eine Wahrheit ueber die Objektdatenbank, wie der
+   Reiter sie kennt: S.objects samt sortiertem Index. Alles Zeichnen und
+   Entwerfen liest daraus.
+
+   Die Rueckrufe nach oben (zeichnen, waehlen) kommen als Kreis-Import aus
+   werkbank.js - beim Laden der Module ist das unkritisch, weil sie erst
+   zur Laufzeit gerufen werden. */
+
+import { S } from './zustand.js';
+import { socket } from './verbindung.js';
+import './basis.js';
+import './sprache.js';
+import { ladeEinstellungen } from './einstellungen.js';
+import { zeigeObjektzahl } from './vorlagen.js';
+import { enums, ladeEnums } from './enums.js';
+import { ladeEnumVorlagen } from './katalog.js';
+import { zeichneBaum } from './baum.js';
+import { waehle , tipptGerade } from './entwurf.js';
+import { zeichneErgebnis, neuZeichnenOderAufbauen } from './ergebnis.js';
+
+
+/* ================== Objekte holen ================== */
+export var ARTEN = ['device', 'channel', 'folder', 'state'];
+
+/* Nach dem Neuladen soll der Bericht stimmen. Die Erkennung haengt an
+   den vorhandenen Objekten — legt man einen cmnd-Punkt an, kann eine
+   Vorlage greifen, die vorher nicht griff. Vorher zeichnete das Laden
+   nur den Baum neu und liess rechts den alten Entwurf stehen. */
+export function ladeObjekte(danach) {
+  var offen = ARTEN.length;
+  S.objects = {};
+  ARTEN.forEach(function (art) {
+    socket.emit('getObjectView', 'system', art, { startkey: '', endkey: '香' }, function (err, doc) {
+      if (!err && doc && doc.rows) {
+        doc.rows.forEach(function (r) {
+          if (r.value && r.id) { S.objects[r.id] = r.value; }
+        });
+      }
+      if (--offen === 0) {
+        S.keysSorted = Object.keys(S.objects).sort();
+        S.kleinIndex = {};
+        ladeEnums();
+        /* Erst die Einstellungen, dann die Vorlagen - sonst holt die
+           Werkbank sie auch dann, wenn sie abgeschaltet sind. */
+        ladeEinstellungen(function () {
+          /* Kam der Katalog spaeter als das erste Zeichnen, fehlte dem
+             Feld der Vorschlag - nachzeichnen, sobald er da ist. */
+          ladeEnumVorlagen(function () {
+            if (S.current) { zeichneErgebnis(); }
+          });
+        });
+        /* Kopfzeile nachziehen - je nach Ladereihenfolge stand dort
+           noch die Null von vor dem Einlesen. */
+        zeigeObjektzahl();
+        zeichneBaum();
+        if (S.current && S.baumModus !== 'vorlagen') { waehle(S.current); }
+        horcheAufObjekte();
+        if (typeof danach === 'function') { danach(); }
+      }
+    });
+  });
+}
+
+/* Objekte entstehen auch ohne Zutun der Werkbank. Der uebliche Weg ist
+   genau der: cmnd.POWER anlegen, einmal schalten — und mqtt-client legt
+   stat.POWER an. Ohne Abo zeigte die Werkbank danach weiter „stat.POWER
+   fehlt", bis man den Reiter neu lud. Man erreichte den Zustand, in dem
+   die Vorlage greift, mit dem Werkzeug allein nie.
+
+   Nachgezogen wird immer, neu gezeichnet nur, wenn es den gerade
+   gewaehlten Zweig betrifft und kein Dialog offensteht — sonst
+   verschwindet einem die Zeile unter dem Finger. */
+var horcht = false, nachziehTimer = null, nachziehBaum = false, enumTimer = null;
+
+/* Wer selbst frisch nachgeladen hat, macht den Nachzieher des Abos
+   ueberfluessig. */
+export function nachziehenErledigt() {
+  if (nachziehTimer) { clearTimeout(nachziehTimer); nachziehTimer = null; }
+  nachziehBaum = false;
+}
+
+export function horcheAufObjekte() {
+  if (horcht) { return; }
+  horcht = true;
+  socket.emit('subscribeObjects', '*');
+  socket.on('objectChange', function (id, obj) {
+    if (!id) { return; }
+    /* Nur was zaehlt, nicht jeder Schreibvorgang: ts und from aendern
+       sich bei jedem setObject, auch wenn inhaltlich alles gleich
+       bleibt. Ohne diesen Vergleich zeichnete die Werkbank ein zweites
+       Mal neu, nachdem sie selbst geschrieben und schon nachgezogen
+       hatte — der Baum sprang sichtbar zweimal. */
+    var kern = function (o) {
+      return o ? JSON.stringify([o.type, o.common, o.native]) : null;
+    };
+    var vorher = kern(S.objects[id]);
+    var nachher = kern(obj);
+    if (vorher === nachher) { return; }
+
+    /* Aufzaehlungen gehen einen eigenen Weg.
+
+       Sie gehoeren nicht in `objects` - dort stuenden sie im Geraetebaum,
+       wo sie nichts zu suchen haben. Nachziehen muss man sie aber, und
+       das war der Fehler: Die Werkbank las sie einmal beim Start und nie
+       wieder. Nach dem ersten Schreiben arbeitete sie mit einem
+       veralteten Stand weiter, kannte die eben gesetzte Zuordnung nicht
+       und trug sie beim naechsten Mal nicht aus. Die neue Funktion kam
+       hinzu, statt die alte abzuloesen - ein Geraet stand am Ende in
+       zweien. Gemessen an `alias.0.FK_Badezimmer`, das in „Licht“ und
+       „Verschluss“ gleichzeitig hing. */
+    if (id.indexOf('enum.') === 0) {
+      if (kern(enums[id]) === nachher) { return; }
+      if (obj) { enums[id] = obj; } else { delete enums[id]; }
+      if (enumTimer) { clearTimeout(enumTimer); }
+      var enumNachziehen = function () {
+        enumTimer = null;
+        /* Wer gerade im Trockenlauf steht oder tippt, wird nicht
+           unterbrochen - gleich nochmal. */
+        if (document.querySelector('dialog[open]') || tipptGerade()) {
+          enumTimer = setTimeout(enumNachziehen, 400);
+          return;
+        }
+        if (S.current) { zeichneErgebnis(); }
+      };
+      enumTimer = setTimeout(enumNachziehen, 300);
+      return;
+    }
+
+    var gabEs = S.objects[id] !== undefined;
+    if (obj) { S.objects[id] = obj; } else { delete S.objects[id]; }
+    if (gabEs !== (S.objects[id] !== undefined)) { nachziehBaum = true; }
+
+    var betrifft = S.current && (id === S.current || id.indexOf(S.current + '.') === 0);
+    if (!betrifft && !nachziehBaum) { return; }
+    if (nachziehTimer) { clearTimeout(nachziehTimer); }
+    var nachziehen = function () {
+      nachziehTimer = null;
+      /* Offener Dialog: spaeter nochmal, nicht ersatzlos fallenlassen.
+
+         Vorher stand hier ein blankes `return`. Wer einen Alias ueber den
+         Loeschdialog entfernte, bekam waehrend der offenen Meldung die
+         `objectChange`-Meldungen: `objects` verlor die Eintraege,
+         `keysSorted` behielt sie, und der Nachzieher, der beides wieder
+         in Deckung gebracht haette, wurde verworfen. Der naechste
+         Baumaufbau griff dann auf ein Objekt zu, das es nicht mehr gab -
+         `Cannot read properties of undefined (reading 'type')`. */
+      if (document.querySelector('dialog[open]')) {
+        nachziehTimer = setTimeout(nachziehen, 400);
+        return;
+      }
+      /* Wer gerade tippt, behaelt seine Eingabe — spaeter nochmal. */
+      if (tipptGerade()) { nachziehTimer = setTimeout(nachziehen, 400); return; }
+      if (nachziehBaum || indexStimmtNicht()) {
+        indexNeu();
+        nachziehBaum = false;
+        zeichneBaum();
+      }
+      neuZeichnenOderAufbauen();
+    };
+    nachziehTimer = setTimeout(nachziehen, 600);
+  });
+}
+
+/* Nach einer eigenen Aktion nur nachziehen, was sich geaendert hat.
+   Vorher rief jede angelegte cmnd-Zeile ladeObjekte() und las die ganze
+   Datenbank neu — auf einer gewachsenen Anlage sind das 24 500 Objekte
+   fuer einen einzigen Datenpunkt, und der Baum sprang zweimal. */
+/* Sobald jemand am Entwurf etwas eingestellt hat, darf ihn kein
+   Nachladen mehr wegwerfen. Vorher genuegte ein angelegter Datenpunkt,
+   und Zielordner, Haken und von Hand angelegte Punkte waren weg. */
+
+export function uebernimmObjekt(id, o) {
+  var gabEs = S.objects[id] !== undefined;
+  if (o) { S.objects[id] = o; } else { delete S.objects[id]; }
+  return gabEs !== (S.objects[id] !== undefined);
+}
+
+/* Der Baum liest aus S.keysSorted, nicht aus S.objects. Wer einen Punkt
+   hinzufuegt oder entfernt, muss den Index neu bauen — sonst kennt der
+   Baum ihn nicht, egal wie oft man zeichnet. */
+export function indexNeu() {
+  S.keysSorted = Object.keys(S.objects).sort();
+  S.kleinIndex = {};
+  zeigeObjektzahl();
+}
+
+/* Stimmt die Zahl der Schluessel nicht mit dem Index ueberein, hat
+   jemand anders an S.objects gearbeitet — das Abo etwa, das eintraegt und
+   das Aufraeumen seinem Zeitgeber ueberlaesst. Ohne diese Probe fiel
+   genau der uebliche Fall durch: Abo traegt ein, das gezielte Nachladen
+   sieht keine Aenderung mehr, bricht den Zeitgeber ab, und der Baum
+   bleibt auf altem Stand. */
+export function indexStimmtNicht() {
+  return S.keysSorted.length !== Object.keys(S.objects).length;
+}
+
+export function holeObjekt(id, danach) {
+  socket.emit('getObject', id, function (err, o) {
+    var anders = uebernimmObjekt(id, err ? null : o);
+    if (anders || nachziehBaum || indexStimmtNicht()) {
+      indexNeu();
+      zeichneBaum();
+    }
+    /* Das Abo hat auf dieselbe Aenderung schon einen Nachzieher
+       angesetzt — der ist jetzt erledigt. Sonst zeichnet die Werkbank
+       ein zweites Mal, eine halbe Sekunde spaeter, und alles springt. */
+    nachziehenErledigt();
+    neuZeichnenOderAufbauen(danach);
+  });
+}
+
+/* Nach einer Abfrage am Geraet weiss man nicht, welche Punkte dabei
+   entstanden sind — dann eben der ganze Zweig, aber nicht mehr. */
+export function holeZweig(praefix, danach) {
+  /* `baumNeu` ist ein lokales Flag - nicht der Baum in S. Beim Umzug in
+     das Zustandsmodul geriet es einmal faelschlich unter die Raeder,
+     weil es in einer Komma-Deklaration versteckt war. */
+  var offen = ARTEN.length, baumNeu = false;
+  ARTEN.forEach(function (art) {
+    socket.emit('getObjectView', 'system', art,
+      { startkey: praefix, endkey: praefix + '香' }, function (err, doc) {
+        if (!err && doc && doc.rows) {
+          doc.rows.forEach(function (r) {
+            if (r.value && r.id && uebernimmObjekt(r.id, r.value)) { baumNeu = true; }
+          });
+        }
+        if (--offen === 0) {
+          if (baumNeu || nachziehBaum || indexStimmtNicht()) {
+            indexNeu();
+            zeichneBaum();
+          }
+          nachziehenErledigt();
+          neuZeichnenOderAufbauen(danach);
+        }
+      });
+  });
+}
+
+/* ================== Baum ================== */
+/* Aus den flachen IDs einen Baum bauen. Nur Zweige, die irgendwo
+   Zustaende enthalten — der Rest ist fuer uns Laerm. */