iobroker.alias-workbench 0.8.1 → 0.8.3

package/admin/js/erkennung.js

@@ -22,6 +22,89 @@ export function rolleAusAusdruck(r) {
 
 export function rolleVonPlatz(st) { return st.defaultRole || rolleAusAusdruck(st.role); }
 
+/* Alle Schreibweisen, die ein Platz annimmt — nicht nur seine Vorgabe.
+
+   Der LOWBAT-Platz nennt als Vorgabe `indicator.maintenance.lowbat`,
+   sein Ausdruck erlaubt aber vier Formen:
+
+       /^indicator(\.maintenance)?\.(lowbat|battery)$/
+
+   Nur die Vorgabe in die Auswahlliste zu stellen hiess: Wer die Rolle
+   sucht, die sein eigenes Geraet traegt, findet sie nicht. hm-rpc
+   schreibt `indicator.lowbat`, alle elf Homematic-Vorlagen benutzen sie,
+   und die ioBroker-Rollenliste fuehrt beide nebeneinander — nur die
+   Werkbank kannte eine davon nicht (Ricardo, 06.09.2026).
+
+   Ausmultipliziert werden genau zwei Formen, weil nur die im Detector
+   vorkommen: Alternativen `(a|b)` und optionale Gruppen `(…)?`. Alles
+   andere — Zeichenklassen, `.*`, Verschachtelung — gibt leer zurueck;
+   dann bleibt es bei der Vorgaberolle. Lieber eine Schreibweise zu wenig
+   als eine erfundene in der Liste. */
+export function schreibweisenAus(r) {
+  if (!r) { return []; }
+  var q = (r.source !== undefined) ? r.source : String(r);
+  if (q.charAt(0) !== '^' || q.slice(-1) !== '$') { return []; }
+  q = q.slice(1, -1);
+
+  var teile = [''];
+  var rest = q;
+  var sicher = 0;
+  while (rest && sicher++ < 40) {
+    var g = /^\(([^()]*)\)(\?)?/.exec(rest);
+    if (g) {
+      var wahl = g[1].split('|');
+      if (g[2]) { wahl = wahl.concat(['']); }        /* optional: auch weglassen */
+      var neu = [];
+      teile.forEach(function (v) {
+        wahl.forEach(function (w) { neu.push(v + w.split('\\').join('')); });
+      });
+      teile = neu;
+      rest = rest.slice(g[0].length);
+      continue;
+    }
+    var lit = /^(\\.|[A-Za-z0-9_.])+/.exec(rest);
+    if (!lit) { return []; }                          /* etwas Unbekanntes */
+    var text = lit[0].split('\\').join('');
+    teile = teile.map(function (v) { return v + text; });
+    rest = rest.slice(lit[0].length);
+  }
+  if (rest) { return []; }
+
+  var gut = [];
+  teile.forEach(function (t) {
+    if (/^[A-Za-z0-9_]+([.][A-Za-z0-9_]+)*$/.test(t) && gut.indexOf(t) === -1) { gut.push(t); }
+  });
+  return gut;
+}
+
+/* Rollen, die der Detector aus Ruecksicht auf alte Adapter noch annimmt,
+   die aber nicht mehr benutzt werden sollen. Aus der Tabelle „Deprecated
+   role aliases" in ioBroker.docs (docs/en/dev/stateroles.md, gelesen am
+   06.09.2026) — dort steht zu jeder auch, was stattdessen gilt.
+
+   Sie stehen hier, weil die Zerlegung oben sonst gerade sie in die
+   Auswahlliste holt: `indicator(\.maintenance)?\.(lowbat|battery)`
+   erlaubt eben auch `indicator.battery`. Eine laengere Liste ist kein
+   Gewinn, wenn die Haelfte davon veraltet ist.
+
+   Vorgaberollen des Detectors werden NICHT gefiltert: was er selbst als
+   Vorgabe fuehrt, gilt, auch wenn die Doku es anders saehe. Gefiltert
+   wird nur, was diese Zerlegung zusaetzlich vorschlaegt. */
+var VERALTET = {};
+('action.close action.close.blind action.close.tilt action.home action.next ' +
+ 'action.open action.open.blind action.open.tilt action.pause action.play ' +
+ 'action.prev action.stop action.stop.blind action.stop.tilt ' +
+ 'indicator.battery indicator.fire indicator.flood ' +
+ 'indicator.maintenance.battery indicator.unreach ' +
+ 'level.thermostat sensor.co sensor.fire sensor.flood ' +
+ 'state.active state.alarm.co state.alarm.fire state.alarm.flood state.co ' +
+ 'state.door state.fire state.flood state.light state.motion state.window ' +
+ 'switch.active switch.autofocus switch.autowhitebalance switch.boost ' +
+ 'switch.brightness switch.nightmode switch.party ' +
+ 'value.accuracy value.brush value.brush.side value.elevation ' +
+ 'value.latitude value.longitude value.radius value.sensors'
+).split(' ').forEach(function (r) { VERALTET[r] = 1; });
+
 export var ROLLEN = (function () {
   if (!D) { return []; }
   var m = {};
@@ -29,6 +112,10 @@ export var ROLLEN = (function () {
     D.patterns[t].states.forEach(function (st) {
       var r = rolleVonPlatz(st);
       if (r) { m[r] = 1; }
+      /* Dazu, was der Platz sonst noch annimmt — ohne das Veraltete. */
+      schreibweisenAus(st.role).forEach(function (x) {
+        if (!VERALTET[x]) { m[x] = 1; }
+      });
     });
   });
   ['state', 'text', 'json', 'value'].forEach(function (r) { m[r] = 1; });

package/admin/js/quellentausch.js

@@ -23,7 +23,7 @@ import { tr, txt } from './sprache.js';
 import { socket } from './verbindung.js';
 import { aliasQuellen, kindZustaende } from './werte.js';
 import { holeZweig, indexNeu } from './objekte.js';
-import { waehle } from './entwurf.js';
+import { waehle, knotenDa } from './entwurf.js';
 import { zeichneErgebnis } from './ergebnis.js';
 
 /* Die Punkte des Alias, die ueberhaupt eine Quelle haben. */
@@ -325,7 +325,7 @@ export function zeigeTausch() {
   /* Wie bei zeigeVerlegen und zeigeLoeschen: an der Quelle ist
      S.current die Quelle, gemeint ist das Ziel des Entwurfs (T1). */
   var ziel = (S.entwurf && (S.entwurf.ziel || S.entwurf.kanal)) || S.current;
-  if (!ziel || ziel.indexOf('alias.') !== 0 || !S.objects[ziel]) { return; }
+  if (!ziel || ziel.indexOf('alias.') !== 0 || !knotenDa(ziel)) { return; }
   S.tauschZiel = ziel;
   S.tauschNeu = '';
   S.tauschWeg = {};
@@ -355,6 +355,22 @@ function zeichneTausch() {
   var z1 = el('div');
   z1.appendChild(el('b', null, tr('swap.from') + ' '));
   z1.appendChild(el('span', 'sn', alt || tr('swap.unknown')));
+  /* Den Namen dahinter, wo er mehr sagt als die Kennung.
+
+     `hm-rpc.0.0000DBE9A2B8AF` sagt einem nichts; woran man das Geraet
+     erkennt, steht allein im Namen (Ricardo, 06.09.2026). Dieselbe Regel
+     wie im Baum: gleicht der Name dem letzten Stueck der Kennung, bringt
+     er nichts und bleibt weg.
+
+     Ist das Geraet weg — der Normalfall bei „Geraet kaputt" —, gibt es
+     kein Objekt und damit keinen Namen mehr. Dann steht dort wie bisher
+     nur die Kennung, und die Zeile darunter sagt, dass es sie nicht mehr
+     gibt. */
+  var altObj = alt && S.objects[alt];
+  var altName = altObj ? txt(altObj.common && altObj.common.name).trim() : '';
+  if (altName && altName !== String(alt).split('.').pop()) {
+    z1.appendChild(el('span', 'leise', ' ' + altName));
+  }
   kopf.appendChild(z1);
   if (alt && !S.objects[alt] && !kindZustaende(alt).length) {
     kopf.appendChild(el('div', 'hint', tr('swap.gone')));

package/admin/js/schreiben.js

@@ -18,7 +18,9 @@ import {
   ordnerUnterAlias,
   gemeinsameKanaele,
   kennungtauglich,
-  entwurfFuer
+  entwurfFuer,
+  aliasFuer,
+  knotenDa
 } from './entwurf.js';
 import { zeichneErgebnis } from './ergebnis.js';
 
@@ -162,8 +164,22 @@ export function objektText(o, geordnet) {
   return JSON.stringify(geordnet ? ordne(k, '') : k, null, 2);
 }
 
+/* Der gespeicherte Stand zu einer Kennung.
+
+   Aufzaehlungen liegen nicht in `S.objects` - die Werkbank haelt sie in
+   einem eigenen Vorrat, weil der Admin sie getrennt ausliefert. Der
+   Trockenlauf las trotzdem nur `S.objects`, und so blieb die Spalte
+   „bisher" bei jeder Aufzaehlung leer: verglichen wurde gegen nichts,
+   also stand rechts jede Zeile als neu da - auch die zehn Mitglieder,
+   die laengst drin waren (Ricardo, 08.09.2026). */
+export function bestandsObjekt(id) {
+  if (S.objects[id]) { return S.objects[id]; }
+  if (String(id).indexOf('enum.') === 0 && enums[id]) { return enums[id]; }
+  return null;
+}
+
 export function unveraendert(id, obj) {
-  var alt = S.objects[id];
+  var alt = bestandsObjekt(id);
   if (!alt) { return false; }
   var putz = function (x) {
     var k = JSON.parse(JSON.stringify(x || {}));
@@ -300,7 +316,9 @@ export function baueObjekte(e) {
    das wird nicht ungefragt geloescht. */
 export function verwaiste(e) {
   var ziel = e.ziel || e.kanal;
-  if (!S.objects[ziel]) { return []; }
+  /* Auch ohne Kanalobjekt kann darunter ein Alias liegen - dann gibt es
+     dort auch verwaiste Punkte zu finden. */
+  if (!knotenDa(ziel)) { return []; }
   var behalten = {};
   e.states.forEach(function (st) {
     if (st.on && st.n) { behalten[ziel + '.' + st.n] = 1; }
@@ -472,7 +490,8 @@ export function zeigeTrockenlauf(alleAusgaenge) {
      verspraeche er eine Wirkung, die er nicht hat. */
   var vergleichbar = liste.filter(function (x) { return !x.neu && !x.gleich; });
   var rohAnders = vergleichbar.some(function (x) {
-    return objektText(S.objects[x.id], false) !== objektText(S.objects[x.id], true)
+    var b0 = bestandsObjekt(x.id);
+    return objektText(b0, false) !== objektText(b0, true)
         || objektText(x.obj, false) !== objektText(x.obj, true);
   });
   if (vergleichbar.length && rohAnders) {
@@ -488,6 +507,20 @@ export function zeigeTrockenlauf(alleAusgaenge) {
   }
   body.appendChild(kopf);
 
+  /* Dieselbe Auskunft wie in der Zielleiste, noch einmal hier - der
+     Trockenlauf ist die letzte Stelle vor dem Schreiben, und wer den
+     Balken oben ueberliest, soll es spaetestens jetzt sehen: es gibt
+     schon einen Alias auf diese Quelle, und der bleibt stehen. */
+  var zwQuelle = S.entwurf && S.entwurf.kanal;
+  var zwZiel = S.entwurf && (S.entwurf.ziel || S.entwurf.kanal);
+  var zwAlt = zwQuelle ? aliasFuer(zwQuelle) : null;
+  if (zwAlt && S.objects[zwAlt] && zwAlt !== zwZiel) {
+    var zwK = el('div', 'aside w');
+    zwK.style.marginBottom = '11px';
+    zwK.appendChild(el('b', null, tr('target.twinExists', zwAlt)));
+    body.appendChild(zwK);
+  }
+
   if (weg.length) {
     var wk = el('div', 'card');
     wk.style.marginBottom = '11px';
@@ -657,7 +690,7 @@ export function zeigeTrockenlauf(alleAusgaenge) {
       var vgl = el('div', 'dvgl');
       vgl.appendChild(el('span', 'dkopf', tr('write.diffOld')));
       vgl.appendChild(el('span', 'dkopf', tr('write.diffNew')));
-      zeilenVergleich(objektText(S.objects[x.id], !S.trockenRoh),
+      zeilenVergleich(objektText(bestandsObjekt(x.id), !S.trockenRoh),
                       objektText(x.obj, !S.trockenRoh))
         .forEach(function (z) {
           vgl.appendChild(el('span', 'dz l ' + z.art, z.l === undefined ? '' : z.l));
@@ -678,7 +711,7 @@ export function zeigeTrockenlauf(alleAusgaenge) {
   var zt = $('#dry-titel');
   if (zt) {
     var zielName = S.entwurf.ziel || S.entwurf.kanal;
-    zt.textContent = (S.objects[zielName] ? tr('write.dryTitleUpdate') : tr('write.dryTitleCreate')) +
+    zt.textContent = (knotenDa(zielName) ? tr('write.dryTitleUpdate') : tr('write.dryTitleCreate')) +
       (entwuerfe.length > 1 ? tr('write.dryOutputs', entwuerfe.length) : '');
   }
   /* Beim Oeffnen wieder herstellen: der Dialog wird wiederverwendet, und
@@ -714,7 +747,7 @@ function geschwisterVon(ziel) {
 
 export function zeigeLoeschen() {
   var ziel = (S.entwurf && (S.entwurf.ziel || S.entwurf.kanal)) || S.current;
-  if (!ziel || ziel.indexOf('alias.') !== 0 || !S.objects[ziel]) { return; }
+  if (!ziel || ziel.indexOf('alias.') !== 0 || !knotenDa(ziel)) { return; }
   S.loeschZiel = ziel;
   S.loeschAlleAusgaenge = false;
   zeichneLoeschen();
@@ -986,17 +1019,27 @@ export function sucheInSkripten(kennung, fertig) {
   } catch { fertigMit(); }
 }
 
-export function zeigeVerlegen() {
+export function zeigeVerlegen(altVorgabe, zielVorgabe) {
   /* Der Knopf steht auch an der Quelle, sobald es den Alias gibt (T1).
      Dort ist S.current die Quelle, nicht der Alias - gemeint ist immer
      das Ziel des Entwurfs. Genauso haelt es zeigeLoeschen; zeigeTausch
      tat es bis 05.09.2026 nicht, und beide Knoepfe waren an der Quelle
-     sichtbar, aber wirkungslos: kein Dialog, keine Meldung. */
-  var alt = (S.entwurf && (S.entwurf.ziel || S.entwurf.kanal)) || S.current;
+     sichtbar, aber wirkungslos: kein Dialog, keine Meldung.
+
+     Die zwei Vorgaben kommen vom Knopf „stattdessen verlegen" in der
+     Zielleiste: dort ist das Ziel des Entwurfs der NEUE Pfad, den es
+     noch gar nicht gibt - ohne Vorgabe stiege der Dialog gleich in der
+     ersten Zeile wieder aus. Verlegt wird der vorhandene Alias
+     (`altVorgabe`), und die Felder stehen schon auf dem, was in der
+     Zielleiste getippt wurde (`zielVorgabe`). */
+  var alt = (typeof altVorgabe === 'string' && altVorgabe) ||
+            (S.entwurf && (S.entwurf.ziel || S.entwurf.kanal)) || S.current;
   if (!alt || alt.indexOf('alias.') !== 0 || !S.objects[alt]) { return; }
   S.verlegeZiel = alt;
 
-  var teile = alt.split('.');
+  var vorbelegt = (typeof zielVorgabe === 'string' && zielVorgabe &&
+                   zielVorgabe.indexOf('alias.') === 0) ? zielVorgabe : alt;
+  var teile = vorbelegt.split('.');
   var name0 = teile.pop();
   var ordner0 = teile.join('.');
 

package/admin/js/vorlagen.js

@@ -370,8 +370,17 @@ export function schreibZiel(z, kanal, auf) {
   return befehlMoeglich(kanal, pfad) ? (kanal + '.' + pfad) : '';
 }
 
-/* Vorlage auf einen Kanal anwenden → Entwurf. */
-export function wendeAn(v, kanal, gruende, instanz) {
+/* Vorlage auf einen Kanal anwenden → Entwurf.
+
+   `auchOhneTreffer` laesst einen Entwurf auch dann entstehen, wenn keine
+   einzige Zeile der Vorlage eine Quelle am Geraet findet. Das gilt nur fuer
+   die Wahl von Hand: Genau dafuer ist das Auswahlfeld gedacht — „sonst steht
+   man bei einem Geraet, das noch nichts gesendet hat, ohne jede Moeglichkeit
+   da". Bis 06.09.2026 fiel gerade dieser Fall durch das Sieb unten, und der
+   Wechsel scheiterte still (Ricardo). Die automatische Erkennung ruft ohne
+   die Fahne auf und bleibt unveraendert — dort waere ein Entwurf ohne eine
+   einzige Zeile ein Fehlgriff. */
+export function wendeAn(v, kanal, gruende, instanz, auchOhneTreffer) {
   var auf = function (t) { return setzeInstanz(t, v, instanz); };
   var e = { kanal: kanal, states: [], want: v.geraetetyp, wantAuto: v.geraetetyp,
             alleMuster: false, vorschlag: true, roh: false,
@@ -499,7 +508,7 @@ export function wendeAn(v, kanal, gruende, instanz) {
     });
   });
 
-  return e.states.length ? e : null;
+  return (e.states.length || auchOhneTreffer) ? e : null;
 }
 
 /* Beste Vorlage suchen und anwenden. */
@@ -521,7 +530,7 @@ export function vorschlag(kanal, vorlagenId, instanz) {
     gewaehlt = treffer[0];
   }
 
-  var e = wendeAn(gewaehlt.vorlage, kanal, gewaehlt.gruende, gewaehlt.instanz);
+  var e = wendeAn(gewaehlt.vorlage, kanal, gewaehlt.gruende, gewaehlt.instanz, !!vorlagenId);
   if (!e) { return null; }
   if (!vorlagenId && gewaehlt.passt) {
     var gleichAuf = treffer.filter(function (t) { return t.punkte === gewaehlt.punkte; });

package/admin/js/werte.js

@@ -93,6 +93,26 @@ export function holeWerte(kanal, extraIds, fertig) {
   });
 }
 
+/* Nur diese Kennungen, ohne den Rundumschlag ueber einen Kanal.
+
+   Gebraucht dort, wo Zeilen erst spaeter dazukommen und ihre Quelle
+   ausserhalb des angeklickten Knotens liegt - dann ist der Kanal
+   laengst abgefragt, und ein zweites `getForeignStates` darauf braechte
+   nichts als Last. */
+export function holeEinzelne(ids, fertig) {
+  var eindeutig = {};
+  (ids || []).forEach(function (i) { if (i) { eindeutig[i] = 1; } });
+  var liste = Object.keys(eindeutig);
+  if (!liste.length) { if (typeof fertig === 'function') { fertig(false); } return; }
+  var offen = liste.length, etwas = false;
+  liste.forEach(function (id) {
+    socket.emit('getState', id, function (err, st) {
+      if (!err && st) { S.werte[id] = st; etwas = true; }
+      if (--offen <= 0 && typeof fertig === 'function') { fertig(etwas); }
+    });
+  });
+}
+
 /* ================== Formel und Wert ================== */
 export function auswerten(formel, roh) {
   if (roh === undefined || roh === null) { return { ok: false, txt: tr('detail.noValue') }; }

package/admin/js/zielleiste.js

@@ -11,8 +11,9 @@ import { el } from './basis.js';
 import { tr } from './sprache.js';
 import { enumListe } from './aufzaehlungen.js';
 import { enumZeile, setzeZiel } from './zuordnung.js';
-import { aliasFuer, ordnerUnterAlias, kennungtauglich } from './entwurf.js';
+import { aliasFuer, ordnerUnterAlias, kennungtauglich, knotenDa } from './entwurf.js';
 import { zeichneErgebnis, entwurfAngefasst, angebotFrisch } from './ergebnis.js';
+import { zeigeVerlegen } from './schreiben.js';
 
 export function baueZielleiste(host, e) {
   var istQuelle = S.current.indexOf('alias.') !== 0;
@@ -224,7 +225,23 @@ export function baueZielleiste(host, e) {
     });
     iO.addEventListener('change', uebernehmen);
     iO.addEventListener('keydown', function (ev) {
-      if (ev.key === 'Escape') { schliessen(); return; }
+      /* Escape heisst „doch nicht" — die Liste zu machen reicht dafuer
+         nicht, der getippte Text muss auch weg. Sonst steht er weiter im
+         Feld und wird beim Verlassen uebernommen: Wer Escape drueckt und
+         danebenklickt, legt den Alias unter einem Ordner an, den er
+         gerade verworfen zu haben glaubte.
+
+         Musterfeld (`musterwahl.js`, ruft mBeschriften) und
+         Aufzaehlungsfeld (`zuordnung.js`, setzt ei.value zurueck) machen
+         das laengst; hier und im Namensfeld daneben fehlte es
+         (Ricardo, 06.09.2026). */
+      if (ev.key === 'Escape') {
+        iO.value = (e.zielOrdner === 'alias.0') ? '' : e.zielOrdner.slice('alias.0.'.length);
+        xBtn.hidden = !iO.value;
+        schliessen();
+        iO.blur();
+        return;
+      }
       if (ev.key === 'ArrowDown' || ev.key === 'ArrowUp') {
         if (vlist.hidden) { malen(true); return; }
         ev.preventDefault();
@@ -263,6 +280,14 @@ export function baueZielleiste(host, e) {
     var iN2 = el('input', 'tx');
     iN2.type = 'text';
     iN2.value = e.zielName;
+    /* Dasselbe fuer den Namen. Hier gab es bisher gar keinen
+       Tastenhandler — Escape tat nichts, der getippte Name blieb stehen
+       und wurde beim Verlassen uebernommen (Ricardo, 06.09.2026). */
+    iN2.addEventListener('keydown', function (ev) {
+      if (ev.key !== 'Escape') { return; }
+      iN2.value = e.zielName;
+      iN2.blur();
+    });
     iN2.addEventListener('change', function () {
       /* Dieselbe Regel wie im Vorschlag und im Verlege-Dialog. Die eigene
          Fassung hier liess Punkte und doppelte Unterstriche stehen - ein
@@ -278,7 +303,10 @@ export function baueZielleiste(host, e) {
     /* Beide Faelle, an einer Stelle. Vorher stand „wird neu angelegt"
        oben im Kopf und „gibt es schon" hier — zwei Formulierungen fuer
        dieselbe Auskunft, an zwei Orten. */
-    var gibtsZiel = !!S.objects[e.ziel];
+    /* `knotenDa`, nicht `S.objects`: ein Alias, dessen Punkte von Hand
+       angelegt wurden, hat oft kein Kanalobjekt - der Chip meldete dort
+       „wird neu angelegt", obwohl geaendert wird (Ricardo, 08.09.2026). */
+    var gibtsZiel = knotenDa(e.ziel);
     var ch2 = el('span', 'chip ' + (gibtsZiel ? 'warn' : 'ok'),
       gibtsZiel ? tr('target.exists') : tr('result.newlyCreated'));
     ch2.style.marginLeft = '7px';
@@ -291,7 +319,13 @@ export function baueZielleiste(host, e) {
        Aenderung folgen, und der Blick ist beim angefassten Feld, nicht
        beim anderen. Der Text nennt deshalb die Wirkung woanders. */
     var angebot = null;
-    if (e.zuletzt === 'ordner' && !aliasFuer(e.kanal)) {
+    /* Frueher hing hier zusaetzlich `!aliasFuer(e.kanal)` - an einem
+       Geraet, das schon einen Alias hat, kam die Frage also nie. Gedacht
+       war das als „am fertigen Alias wird nicht mehr geraten"; in
+       Wahrheit ist gerade das der Fall, in dem sie gebraucht wird: wer
+       den Ordner eines vorhandenen Alias umschreibt, zieht um, und der
+       Raum soll mit (Ricardo, 06.09.2026). */
+    if (e.zuletzt === 'ordner') {
       var otx = String(e.zielOrdner || '').slice('alias.0.'.length);
       if (otx && otx.indexOf('.') === -1) {
         var vorhandenerRaum = enumListe('rooms', true).filter(function (r) {
@@ -322,6 +356,42 @@ export function baueZielleiste(host, e) {
       setTimeout(function () { iO.focus(); }, 0);
     }
 
+    /* Der Zwilling: es gibt schon einen Alias auf diese Quelle, und das
+       Ziel zeigt woandershin.
+
+       Die Werkbank weiss das in diesem Moment - `aliasFuer` liefert den
+       alten Pfad -, sagte es aber nirgends. Am Chip stand nur „wird neu
+       angelegt", was stimmt und die Haelfte verschweigt: der alte bleibt
+       stehen, und aus einem Umbenennen des Ordners wird lautlos ein
+       zweiter Alias auf dieselbe Quelle (Ricardo, 06.09.2026, am
+       Bastelzimmer_Decklenlicht_RGB).
+
+       Verboten wird nichts. Zwei Aliase auf eine Quelle sind ein
+       ordentlicher Fall - einer fuers Licht, einer fuer den Verbrauch;
+       „alle anlegen" tut bei mehreren Ausgaengen nichts anderes. Es
+       fehlte die Auskunft, nicht die Sperre. Wer wirklich einen zweiten
+       will, drueckt denselben Knopf wie bisher und weiss jetzt, was er
+       tut; wer umziehen wollte, hat den Weg dafuer daneben.
+
+       Ohne Rueckprobe ueber `quelleVon`: an einem Homematic-Kanal
+       (…B8AF.0) zeigt die Quelle des Alias auf das Geraet (…B8AF), die
+       Probe schluege fehl und der Hinweis bliebe genau dort aus, wo er
+       gebraucht wird. `aliasFuer` ist dieselbe Funktion, mit der die
+       Werkbank auch „zum Alias →" und ihre Zielvorschlaege bestimmt -
+       irrt sie hier, irrt sie dort ebenso. Und der Hinweis haelt
+       niemanden auf. */
+    var zwilling = null;
+    var vorhAlias = aliasFuer(e.kanal);
+    if (vorhAlias && S.objects[vorhAlias] && vorhAlias !== e.ziel) {
+      var zw = el('div', 'uebernahme zwilling');
+      zw.appendChild(el('span', 'zq', tr('target.twinExists', vorhAlias)));
+      var vb = el('button', 'btn mini', tr('target.moveInstead'));
+      vb.title = tr('target.moveInsteadHint');
+      vb.addEventListener('click', function () { zeigeVerlegen(vorhAlias, e.ziel); });
+      zw.appendChild(vb);
+      zwilling = zw;
+    }
+
     /* Das Angebot ganz ans Ende der Leiste.
 
        Zuerst hing es direkt hinter dem Ordnerfeld - und weil es eine
@@ -329,6 +399,7 @@ export function baueZielleiste(host, e) {
        Namensfeld stand ploetzlich darunter statt daneben. Eine Zeile,
        die umbricht, gehoert hinter das, was in der Zeile bleiben soll. */
     if (angebot) { zb.appendChild(angebot); }
+    if (zwilling) { zb.appendChild(zwilling); }
 
     zb.appendChild(ergebnis);
 

package/admin/js/zuordnung.js

@@ -14,8 +14,8 @@ import {
 } from './aufzaehlungen.js';
 import { enumVorlagen, katalogFehlt, ikonCache, ikonErlaubt, ikonNachtrag,
          ikonTaugt, vorlageZu, holeIkon } from './katalog.js';
-import { kindZustaende, aliasQuellen } from './werte.js';
-import { aliasFuer, zielId } from './entwurf.js';
+import { kindZustaende, aliasQuellen, holeEinzelne } from './werte.js';
+import { aliasFuer, zielId, knotenDa } from './entwurf.js';
 import { zeichneErgebnis, entwurfAngefasst, angebotFrisch } from './ergebnis.js';
 
 
@@ -394,7 +394,11 @@ export function enumZeile(host, e) {
 export function setzeEnums(e) {
   if (e.raum !== undefined && e.funktion !== undefined) { return; }
   var ziel = e.ziel || e.kanal;
-  var da = !!S.objects[ziel];
+  /* Gibt es den Alias, gelten SEINE Aufzaehlungen - auch wenn sein Kanal
+     kein eigenes Objekt hat. Sonst wurden Raum und Funktion geraten und
+     als „vorgeschlagen" angezeigt, obwohl beide laengst zugeordnet
+     waren (Ricardo, 08.09.2026). */
+  var da = knotenDa(ziel);
 
   if (e.raum === undefined) {
     var r = da ? (enumsVon(ziel, 'rooms')[0] || '') : '';
@@ -499,7 +503,21 @@ export function setzeZiel(e) {
 export function uebernehmeBestand(e) {
   if (!e.ziel || e.bestandGeprueft === e.ziel) { return; }
   e.bestandGeprueft = e.ziel;
-  if (!S.objects[e.ziel]) { return; }
+  /* Gefragt ist, ob es unter dem Ziel schon einen Alias gibt - nicht, ob
+     das Ziel selbst ein Objekt ist. Das ist nicht dasselbe: wer seine
+     Punkte von Hand im Admin anlegt, bekommt `alias.0.X.Y.PUNKT`, ohne
+     dass `alias.0.X.Y` als Kanal entsteht. Der Baum zeigt so einen
+     Knoten trotzdem, weil er sich aus den Kennungen aufbaut - `knotenDa`
+     ist genau dafuer da.
+
+     Mit der alten Frage stieg der ganze Bestandsabgleich dort aus:
+     `alias.0.Bastelzimmer.Klima` und `alias.0.Solar.Einstellungen.Bilanz`
+     haben kein Kanalobjekt, und ein Aktualisieren haette ihre Namen
+     durch die blossen Punktnamen ersetzt - „Strompreis fuer die
+     Ersparnisrechnung" waere zu „Strompreis_ct_kWh" geworden. Rollen,
+     Formeln und Schreibrichtung waeren ebenso durchgefallen
+     (Ricardo, 08.09.2026). */
+  if (!knotenDa(e.ziel)) { return; }
   /* Im Aliasmodus ist der Entwurf schon der Bestand. */
   if (e.kanal === e.ziel) { return; }
 
@@ -533,9 +551,35 @@ export function uebernehmeBestand(e) {
     z.states = c.states || undefined;
     z.f = (typeof a.read === 'string') ? a.read : '';
     z.fw = (typeof a.write === 'string') ? a.write : '';
+    /* Die Beschriftung steht im Alias und gehoert dem Nutzer.
+
+       Sie fehlte hier als einzige - `bestandVorrang` holt sie laengst
+       (`s.caption = txt(c.name)`), diese Zwillingsfunktion nicht. Also
+       blieb `caption` leer, im aufgeklappten Feld stand nichts, und ein
+       „Alias aktualisieren" haette den Namen durch den blossen
+       Zeilennamen ersetzt: aus „Netzbezug (+) / Einspeisung (-)" waere
+       „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 : '';
     if (q2.read) { z.srcR = q2.read; }
+    /* Und dieselbe Schreibregel wie im Bestandsvorrang.
+
+       Hier stand die Schreibquelle nur fuer das getrennte Paar; sonst
+       blieb stehen, was der Vorschlag aus der Quelle abgeleitet hatte.
+       Bei einem Nur-Lese-Alias auf einen beschreibbaren Punkt hiess das:
+       die Quelle sagt `write: true`, der Alias sagt `write: false` - und
+       die Werkbank meldete eine Abweichung, die sie selbst erzeugt hatte,
+       und haette den Alias beim Aktualisieren schreibbar gemacht.
+
+       Belegt ist das Schreiben durch `common.write` oder durch eine
+       hinterlegte Schreibformel; bei getrennten Quellen zaehlt, was in
+       `alias.id.write` steht. */
+    z.srcW = q2.einfach
+      ? ((c.write === true || typeof a.write === 'string') ? (q2.write || '') : '')
+      : (q2.write || '');
     if (q2.write && !q2.einfach && q2.write !== q2.read) {
-      z.srcW = q2.write;
       /* Die Gegenzeile eines Paars ist keine eigene mehr - ihre Quelle
          steckt jetzt als Schreibquelle in dieser Zeile. */
       e.states.forEach(function (x) {
@@ -577,6 +621,21 @@ export function uebernehmeBestand(e) {
        stehen; neue Punkte bekommen den neuen Namen. */
     if (q.read && kenntQuelle[q.read] && !S.objects[e.ziel + '.' + kenntQuelle[q.read].n]) {
       var vorhanden = kenntQuelle[q.read];
+      /* Die Zeile bekommt den Namen aus dem Alias — und damit einen
+         anderen, als die Erkennung eben gesehen hat. `platzVon` kennt
+         noch den Vorlagennamen, die Zeile heisst jetzt anders, und die
+         Platzpruefung findet nichts: Am `Bastelzimmer_Licht` stand nach
+         einem Wechsel auf die Steckdosen-Vorlage „kein Platz im
+         Steckdose-Muster" an ON_ACTUAL, obwohl der Platz ACTUAL frei
+         besetzt war. Nach jedem beliebigen Neuzeichnen war es weg
+         (Ricardo, 06.09.2026).
+
+         `bestandZog` loest genau dafuer das einmalige Nachzeichnen aus.
+         Gesetzt wurde es bisher nur in `vomAliasUebernehmen` — und das
+         steigt bei gesetzter Vorlage sofort aus, damit der Vorlagenstand
+         gilt. Die Umbenennung findet aber trotzdem statt, also gehoert
+         die Fahne hierher. */
+      if (vorhanden.n !== n) { e.bestandZog = true; }
       vorhanden.n = n;
       vorhanden.on = true;
       vorhanden.ausBestand = true;
@@ -590,7 +649,22 @@ export function uebernehmeBestand(e) {
       role: c.role || '', typ: c.type || '', unit: c.unit || '',
       states: c.states || undefined,
       wr: !!c.write,
-      srcR: q.read || '', srcW: q.einfach ? '' : (q.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: q.einfach
+        ? ((c.write === true || typeof a.write === 'string') ? (q.write || '') : '')
+        : (q.write || ''),
       f: (typeof a.read === 'string') ? a.read : '',
       fw: (typeof a.write === 'string') ? a.write : '',
       caption: (nm && nm !== n) ? nm : '',
@@ -612,6 +686,38 @@ export function uebernehmeBestand(e) {
     e.bestandNachgezeichnet = true;
     setTimeout(function () { if (S.entwurf === e) { zeichneErgebnis(); } }, 0);
   }
+
+  /* Und die Werte zu den eben ergaenzten Zeilen nachholen.
+
+     `waehle` holt die Werte, bevor es diese Zeilen ueberhaupt gibt: es
+     fragt den angeklickten Kanal ab und die Quellen, die der Entwurf zu
+     dem Zeitpunkt kennt. Was hier dazukommt, steht nur im Alias - und
+     seine Quelle kann irgendwo liegen. Solange sie unter demselben
+     Knoten liegt, faellt nichts auf, weil `getForeignStates` sie
+     mitgenommen hat. Liegt sie woanders, blieb die Zeile ohne Wert und
+     behauptete „Quelle liefert nichts", obwohl der Alias einwandfrei
+     arbeitet.
+
+     Gefunden am 07.09.2026 (Ricardo) an `alias.0.Solar.Netz`: drei
+     Punkte aus `0_userdata`, zwei aus `mqtt-client`. Nach einem
+     Reiterwechsel und dem ersten Klick auf den Knoten standen genau die
+     beiden mqtt-Zeilen leer; ein zweiter Klick heilte es, weil der Wert
+     dann schon im Vorrat lag. Der Mitschnitt zeigte, dass nach der
+     mqtt-Kennung nie gefragt wurde.
+
+     Einmal je Entwurf, und nur, wenn wirklich etwas fehlt. */
+  if (!e.bestandWerte) {
+    var fehlen = [];
+    e.states.forEach(function (s) {
+      if (s.srcR && !S.werte[s.srcR] && fehlen.indexOf(s.srcR) === -1) { fehlen.push(s.srcR); }
+    });
+    if (fehlen.length) {
+      e.bestandWerte = true;
+      holeEinzelne(fehlen, function (etwas) {
+        if (etwas && S.entwurf === e) { zeichneErgebnis(); }
+      });
+    }
+  }
 }
 
 export function unterschiede(e) {
@@ -652,7 +758,7 @@ export function unterschiede(e) {
      Grundlinie — dann zaehlt, was sich gegenueber dem Gespeicherten
      aendert. Gibt es ihn noch nicht, ist es der Vorschlag der
      Vorlage. */
-  var aliasDa = !!S.objects[zielBasis];
+  var aliasDa = knotenDa(zielBasis);
 
   e.states.forEach(function (s) {
     if (s.manuell) { raus.push({ n: s.n || '(ohne Namen)', was: tr('diff.newByHand') }); return; }