iobroker.alias-workbench 0.9.10 → 0.9.11

package/README.md

@@ -564,6 +564,20 @@ imported, and that both language files carry the same keys.
 
 ## Changelog
 
+### 0.9.11 (2026-09-16)
+* After saving, the next click in the tree asked **“unsaved changes”** — about an alias that had just been written. The “something unwritten is here” mark was only ever set, never cleared; it went away solely when the draft itself was dropped, i.e. on delete and on move. It now falls after every successful write — and only then: if something went wrong, the change really is not in yet, and the question stays justified. **There is a second effect that had been missing for a long time**: while the mark stood, the workbench deliberately did not rebuild the draft. After a write the old one therefore stayed, instead of rebuilding from the freshly written alias.
+* A second press of **“Suggest free slots”** bent back a row you had set yourself. On the air conditioner: guess nine slots, set the role of the SPEED row to `level.speed` by hand, discard — and the next suggestion put the guessed `level.mode.fan` back. The pattern slot looked free, so the same row was guessed a second time; it then carried **both** marks, “changed” and “guessed”, which exclude each other — what was just guessed cannot have been changed before. Guessing now leaves any row marked “changed” alone. The slot stays free, and the note below says why. Putting a second row next to it was the alternative — the same source point would then hold two slots, and the eighth check would rightly report it.
+* As soon as guesses were pending, the button in the pattern bar renamed itself to **“Discard suggestions”** — and a second one with the same word and the same effect stood in the blue bar below it. Two buttons, one handle. The bar now always says “Suggest free slots”, and only while something is left to guess; once everything is guessed it disappears. Discarding happens where it belongs: in the blue bar, next to “keep all”.
+* Instead of „either every slot is taken, or no remaining datapoint fits" the note now states the case that actually applies — with the **names** of the slots that stay free: “SPEED, SWING … stays free. Every remaining datapoint already serves as a read or write source in a filled row”, or “… No remaining datapoint fits”. If a hand decision holds a slot open, a sentence is appended: “1 rows were decided by hand and are left untouched.” The “every slot taken” case stays silent unless asked — it says “nothing to do”, and would otherwise appear on nearly every device.
+* Ricardo’s air conditioner is detected as a **thermostat** and fills 3 of 24 slots. **airCondition** fails because its only required slot, MODE, does not carry the role — and that settles it, since “does not fit” has the last word. With automatic suggestions it would reach **9 of 29** against 8 of 24. That now stands next to the pattern field: “· airCondition might fit better” — a single line, both numbers in the tooltip. **One** pattern is named — the best one — and only when it really is better; measured in filled slots, not in ratio. Next to it sits a small **→** button that does both in one go: switch to that pattern and press “Suggest free slots” right away — otherwise the note would be an announcement without an action. In the pattern list every affected row carries “with suggestions: fits” behind its reason. It is computed once when the device is selected and after that only on a row change — suggesting reads names, value lists, units and types, no measured values.
+* In the **template sheet** and in the „save as template" dialog the device type showed its **pattern key** instead of its name: a blind read „blinds", a media player „mediaPlayer", a slider „levelSlider" — words that appear nowhere else in the interface. The stored value was right all along (the type, since 11.09.2026); only the label came from the wrong field, and since the Admin does not know those three keys, the translated name fell away with them. It now says the same as the pattern picker next to it: „Jalousien · blind".
+* A **button** can now be created. `STOP` on a blind only writes — a key press has no state to read — and that used to defeat the **whole** alias: the dry run said “STOP: no source chosen”, “create now” stayed greyed out, and not a single blind alias ever got a STOP. The first diagnosis was wrong, and that deserves saying: it was not the write check being too strict. **ioBroker rejects an alias without a read source** — `{ id: { write: … } }` yields “Alias id is invalid: The id is empty!”. The correct shape is the one Ricardo has long been using on his ten hand-built STOPs: `alias.id` as plain text pointing at the command point, plus `common.read: false` on the alias point. That tells vis, Alexa and matter to draw a **button** rather than a toggle stuck at “off” forever. What decides is the **target**, not the role: `read: false` is written by the adapter itself (measured on a real `hm-rpc` STOP). If the target is readable the block stays — then the missing read source really is a defect. The button also survives being read back: all three places that reconstruct an alias now know it, otherwise `read` would quietly flip to `true` on the next update. **The same question grew into a new check**: “target can do what is asked”. The workbench writes to foreign points and reads from foreign points without ever checking whether they can do that. Three ways it silently falls apart — the write formula produces text and the target takes none; the target carries `write: false` (ioBroker stores the value anyway but the adapter passes nothing on: a silent dud); the read source carries `read: false` and never reports anything. All three now appear in the checks panel and as a chip on the ID in the detail view, right where the formula is typed
+* The workbench creates MQTT **send points** itself — a `cmnd` point only comes into existence in ioBroker once something has been published to its topic; before that the alias would have nothing to write to. It took the type from the command knowledge, and `POWER` is listed there as `boolean` — right next to the write formula `val ? "ON" : "OFF"`. The two do not add up: the js-controller converts the formula result back to the type of the **target** on write, the `"ON"` becomes `true` again, and the formula sits in the alias without effect. Switching still works — Tasmota takes `on` as well as `true` — but the point looked different from every point mqtt-client creates, and the formula claimed something it did not do. On the production system it was **one of 196** alias points with an MQTT write target, and it came from us. The rule now is: **where a write formula exists, the point is created as `mixed`** — no exception for `POWER` but a rule that also covers `Fade` and `LedTable`. Without a formula the exact type stays, because the admin derives min, max and unit from `number`. **Plus two places where it becomes visible**: the target point's type now shows as a chip behind its ID in the detail view — right where the formula is typed — in warning colour when the two do not match. And the checks panel has an eighth check, "write formula takes effect", that names it instead of keeping quiet
+* A template now counts as fitting only where its **mandatory rows** actually find their source. Until now detection alone decided, and detection asks a different question than application: `pruefeVorlage` checks whether the named **points** exist, the rows need particular **fields inside them**. A hand-built power-meter template whose mandatory row reads `tele.SENSOR · SML.Total_Summe` thus won on **17** ordinary Tasmota devices and delivered exactly one — and unchecked — row there, where the socket template would have built eleven. The device said "identified as: Tasmota power meter", and the draft was empty. Now it does not even enter the race there and the next best one takes the place; what was skipped is stated in the "why". Optional rows do not count, that is what optional means — measured against the stock, **none** of the fifteen other templates loses any of its 51 wins. **And the try-out in the template sheet**: it now also fetches the values of the points the rows read. Without them it judged fields it could not see, and the same template reported different numbers depending on what had been clicked before. It now shows per device how many rows would really come out, and on "does not fit" **which mandatory row is missing** — turning "22 devices matched, 17 of them won" into the honest "22 matched, 1 won · 21× does not fit". **And the try-out now computes like the creation does**: at first it compared only against the single highest-scoring other template — if that one did not fit the device, the template under test declared itself the winner. "Plain measuring point" thus reported a win on a Tasmota although the socket template sits in between and really fits there. It now walks the match list like `vorschlag` does; measured afterwards, all 150 pairs of template and device agree
+* An alias whose source has vanished from the system is now visible without clicking it. Until now it was only said in the expanded detail and in the checks panel — the row in the list stayed quiet because it asked whether a source was **entered**, not whether it **exists**. The row now carries the red `!` with the note "source does not exist", the header a chip "1 point points nowhere" with the list in its tooltip, and the alias tree a red `!` on the affected channel. This is not cosmetic: the js-controller remembers "source missing" permanently and never corrects it — only deleting and recreating helps. It is computed once when the objects load, not on every redraw; on the production system 531 alias points in 5.2 ms. Two were found straight away: a window contact still pointing at the long-replaced `zigbee` adapter, and an NSPanel point with a missing `0_userdata` source for both reading and writing. A row with **no** source at all keeps its own note — it is unfinished, not broken
+* New: **"Referenced in"** on an existing alias. The box below the change comparison searches on click for whatever else mentions the ID — the **scripts** of the javascript adapter with folder, name, state and line numbers, the **files** of the instance folders (that is, the vis and vis-2 views), every loaded **object** (where the matter bridges keep their members, for instance), the **enumerations** and the entries on the point itself (`SET → influxdb.0`) — and the same again for the **source**, including further aliases on it. That answers the question of what was left behind when moving to the alias. Measured on the production system with 24,706 objects and 66 files: the first look takes 1.3 seconds, every further alias after that 0.17. The web interfaces of the adapters are not searched — 160 of the 177 MB of text in the file tree, identical on every ioBroker, and they carry examples like `alias.0.Floor.Room.MotionSensor`; without that boundary the workbench would find its own source files as users of itself. Deliberately without a verdict: a source that is still mentioned is not a fault — a script that feeds it belongs exactly there (of 376 aliases with a source, 61 still had the source mentioned directly, a good share of them rightly so). **And the delete dialog now searches the scripts too** — that only existed when moving, although deleting is the irreversible one
+* The field picker on a JSON point now copes with every key. Until now the workbench glued the field name onto the access with dots — which only works as long as every part is a valid JavaScript name. `gpu_usages.amd-vaapi.gpu` turned into an arithmetic expression (`?.amd - vaapi?.gpu`), `service.storage./dev/shm.free` and `cpu_usages.1111740.mem` into a syntax error. Measured on a Frigate telegram: of 233 offered fields **27** were usable, the other 206 ended in the red "formula broken" message. `feldFormel` now uses brackets where the key is not a name — `JSON.parse(val)?.gpu_usages?.['amd-vaapi']?.gpu ?? null` — and reads them back again, so the picker stays on the chosen field instead of falling back to "own formula". For ordinary names **not a single character** changes, so the shipped templates are untouched. A dot inside the key itself (`frigate.full_system`) remains unresolvable and still shows "own formula"
+
 ### 0.9.10 (2026-09-13)
 * Four things from the full test run. **A channel identifier** was not sanitised in the multi-output path: from the channel name “Licht, Bar” the js-controller quietly made `Licht_ Bar`, while the workbench displayed “Licht, Bar” and wrote it into the enumerations — an identifier that never existed, and after deleting the alias it stayed there as a leftover. `ausgangName` now sanitises itself, and where two channels produce the same name the second gets a `_2`. **The caption** differed between the two views: where the point's name equals the row name, “Edit alias” showed it and “Create alias” an empty field. **The row list** now counts like the tree — `POWER2` before `POWER10`. And **an enumeration the workbench created itself** now also disappears when it becomes empty through a change of function, not only when the alias is deleted
 * Tidying: "turn an alias object into a draft row" was written out five times — each with the same write-source rule and slightly different surroundings. Four bugs in this version came from exactly that: the lost write source on the roller shutter, a switching point that became a read-only one, the missing caption on `alias.0.Solar.Netz`, and a deviation the workbench had produced itself. The reading now lives in one place; what the four callers do with it — compare, create, overwrite — stays with them. Behaviour is unchanged

package/admin/css/werkbank.css

@@ -377,6 +377,50 @@
   .aside.w { border-left-color:var(--warn); }
   .aside b { color:var(--ink); }
 
+  /* Der Kasten „Wird genannt in“.
+
+     Zuerst mit den Klassen der Zustandsliste gebaut (.slot, .sn, .typ) -
+     die sind durchgehend Schreibmaschinenschrift, und der Kasten sah aus
+     wie Quelltext statt wie Text. Beschriftung links deshalb wie im
+     Detail (.k), Inhalt als gewoehnlicher Satz, und nur Kennungen in
+     Schreibmaschine. */
+  /* Der Blockkopf muss sich von den Zeilenbeschriftungen darunter
+     abheben - stand er in derselben grauen Versalschrift, las sich
+     „DER ALIAS“ wie eine weitere Zeile statt wie die Ueberschrift
+     darueber (Ricardo, 14.09.2026). Deshalb eigene Leiste mit Grund,
+     Akzentfarbe und etwas groesser. */
+  .vwkopf {
+    display:flex; align-items:baseline; gap:10px; flex-wrap:wrap;
+    padding:7px 13px; background:var(--surface-2);
+    border-top:1px solid var(--line); border-bottom:1px solid var(--line);
+  }
+  .vwkopf .t {
+    font-family:var(--sans); font-size:10px; text-transform:uppercase;
+    letter-spacing:.08em; color:var(--accent); font-weight:700;
+  }
+  .vwkopf .id { font-family:var(--mono); font-size:12px; color:var(--ink); word-break:break-all; }
+  .vwzeile {
+    display:grid; grid-template-columns:148px minmax(0,1fr); gap:10px;
+    align-items:start; padding:4px 13px; font-size:12px; color:var(--ink);
+  }
+  .vwzeile .k {
+    font-family:var(--sans); font-size:9px; text-transform:uppercase;
+    letter-spacing:.06em; color:var(--ink-3); font-weight:700; padding-top:3px;
+  }
+  .vwzeile .leer { color:var(--ink-3); }
+  .vwzeile .id { font-family:var(--mono); font-size:11.5px; word-break:break-all; }
+  .vwzeile ul { margin:0; padding-left:15px; }
+  .vwzeile li { margin:1px 0; line-height:1.5; }
+  .vwzeile li .id { font-weight:600; }
+  .vwzeile li .ord { color:var(--ink-3); }
+  .vwnote { padding:10px 13px 0; }
+  .vwnote:last-child { padding-bottom:12px; }
+
+  /* Der Alias im Baum, dessen Quelle es nicht mehr gibt. Klein und rot,
+     neben Geraetepunkt und Zahl - kein Kasten, keine Toenung: die Zeile
+     soll lesbar bleiben. */
+  .kaputt { color:var(--bad); font-weight:700; }
+
   .empty { color:var(--ink-3); font-size:13px; padding:36px 8px; text-align:center; }
   /* Der Erklaertext der leeren Seite: lesbar breit, nicht ueber die
      ganze Flaeche gezogen, zweiter Absatz gedaempft. */
@@ -460,6 +504,29 @@
     padding:2px 24px 2px 6px; width:290px; max-width:290px;
   }
   .vmeta { display:flex; gap:5px; align-items:center; flex-wrap:wrap; }
+  /* „mit Raten: Klimaanlage 9/29, Thermostat 8/24" - der Hinweis neben
+     dem Musterfeld. Kein Chip: es ist keine Marke am Geraet, sondern ein
+     Weg, den man gehen kann. Deshalb Text in der Farbe der Vermutung,
+     nicht in der von Gut oder Schlecht. */
+  /* Die Breite ist auf die des Feldes darueber gedeckelt, und der Satz
+     darf umbrechen.
+
+     Mit `nowrap` war er eine 315 px breite Zeile, und weil der Block
+     seine Breite aus dem breitesten Kind nimmt, wurde der ganze
+     Musterblock breiter. Im Vorlagenkasten passte die Knopfleiste damit
+     nicht mehr in dieselbe Zeile, rutschte in die naechste - und deren
+     `margin-top:16px` plus der Zeilenabstand von 18 px standen dann als
+     34 px Leere zwischen Hinweis und Knopf (Ricardo, 15.09.2026). Es
+     fehlten drei Pixel; jede Wortaenderung haette es wieder kippen
+     koennen. Ein Deckel ist verlaesslicher als ein knapper Umbruch. */
+  .ratAussicht { font-size:11px; color:var(--accent); max-width:290px;
+                 display:flex; gap:5px; align-items:center; flex-wrap:wrap; }
+  /* Der Knopf traegt die Farbe des Hinweises, nicht die eines
+     gewoehnlichen Knopfes - er gehoert zum Satz daneben. Reicht die
+     Breite nicht, rutscht er unter den Text statt den Block zu
+     verbreitern (siehe den Deckel darueber). */
+  .rtgo { color:var(--accent); border-color:var(--accent); flex:none;
+          font-size:12px; line-height:1; padding:1px 6px; }
 
   /* ---- Geraetekarte ---- */
 
@@ -715,6 +782,14 @@
   .tree .geraetepunkt { margin-left:auto; font-size:8px; color:var(--accent); }
   .tree .node.sel .geraetepunkt { color:var(--accent-ink); }
   .tree .geraetepunkt + .cnt { margin-left:5px; }
+  /* Die Warnung steht in derselben rechten Gruppe wie Geraetepunkt und
+     Zahl - und VOR dem Punkt, damit Punkt und Zahl ihr Paar behalten.
+     Stand sie dazwischen, verlor `.geraetepunkt + .cnt` seinen Griff und
+     die Zahl rutschte allein an den rechten Rand (Ricardo, 14.09.2026). */
+  .tree .kaputt { margin-left:auto; font-size:10px; line-height:1; }
+  .tree .kaputt + .geraetepunkt { margin-left:6px; }
+  .tree .kaputt + .cnt { margin-left:6px; }
+  .tree .node.sel .kaputt { color:var(--accent-ink); }
 
   .erow .fehltnoch {
     margin-left:7px; font-style:normal; font-size:10px; font-weight:700;
@@ -814,6 +889,7 @@
   /* Gleiche Strichstaerke wie Vorlage und Ausgang daneben - halbfett
      wirkte wie eine andere Schrift in der Zeile. */
   .suggestbox .verdictwrap .musterwahl { font-weight:400; width:250px; max-width:250px; }
+  .suggestbox .ratAussicht { max-width:250px; }
   .suggestbox .vmeta { font-size:10.5px; color:var(--ink-3); gap:6px; }
   .suggestbox .luecke { flex:1 1 20px; }
   .suggestbox .knoepfe { display:flex; gap:7px; align-items:flex-end; }
@@ -936,6 +1012,10 @@
   }
   .listbar .verdictwrap.inbar .musterwahl { font-size:12px; width:230px; max-width:230px; }
   .listbar .verdictwrap.inbar .vmeta { margin:0; }
+  /* In der Leiste steht der Hinweis NEBEN dem Feld (Reihe statt Spalte)
+     und hat die ganze Breite der Leiste zur Verfuegung - dort ist eine
+     Zeile richtig; reicht sie nicht, bricht die Leiste selbst um. */
+  .listbar .verdictwrap.inbar .ratAussicht { max-width:none; white-space:nowrap; flex-wrap:nowrap; }
 
   .feldwrap { position:relative; display:block; min-width:0; }
   /* Das Musterfeld ist ein Eingabefeld, sieht aber aus wie das Auswahlfeld

package/admin/js/baum.js

@@ -412,6 +412,14 @@ function renderKinder(knoten, filter, tiefe) {
        ueberschreibt ihn die Zeile darueber wieder. */
     if (leer) { d.title = (d.title ? d.title + '  ·  ' : '') + tr('tree.emptyNode'); }
     if (waehlbar) {
+      /* Ein Alias, dessen Quelle es nicht mehr gibt, faellt sonst nur
+         auf, wenn man ihn anklickt und die Zeile aufklappt. Die Menge
+         steht fertig in S.aliasKaputt - hier wird nur nachgeschlagen. */
+      if (S.aliasKaputt[k.id]) {
+        var kp = el('span', 'kaputt', '!');
+        kp.title = tr('tree.sourceGone', S.aliasKaputt[k.id]);
+        d.appendChild(kp);
+      }
       if (wohlGeraet(k)) {
         var pk = el('span', 'geraetepunkt', '●');
         pk.title = tr('tree.looksLikeDevice');

package/admin/js/detail.js

@@ -4,7 +4,7 @@ import { S } from './zustand.js';
 import { socket } from './verbindung.js';
 import { el } from './basis.js';
 import { tr } from './sprache.js';
-import { wertVon, jsonFelder, feldAusFormel, feldFormel, feldWert, jsonVon } from './werte.js';
+import { wertVon, jsonFelder, feldAusFormel, feldFormel, feldWert, jsonVon, zielKann } from './werte.js';
 import { musterVon, erkenneEntwurf, platzFuerRolle, typenFuerRolle } from './erkennung.js';
 import { musterName } from './musternamen.js';
 import { rollenFeld } from './rollenwahl.js';
@@ -71,15 +71,59 @@ export function detailZeile(e, s, idx) {
      steht die volle Kennung als eigene Zeile unter dem Feld. Dieselbe
      Bauart wie „Die Vorlage will hier: …": sie darf umbrechen und hat
      damit keine Breitengrenze. */
-  function mitVollId(felder, id) {
+  function mitVollId(felder, id, zusatz) {
     var w = el('div', 'feldstapel');
     w.appendChild(felder);
     var v = el('div', 'vollid');
     if (id) { v.textContent = id; v.title = id; }
+    /* Beim Schreibziel steht hinter der Kennung sein Typ. Er entscheidet,
+       ob die Schreibformel ueberhaupt ankommt - der js-controller rechnet
+       den Formelwert auf den Typ des ZIELS zurueck. Man tippt die Formel
+       also an einer Stelle, an der man bisher nicht sehen konnte, ob sie
+       etwas bewirkt (Ricardo, 15.09.2026). */
+    if (zusatz) { v.appendChild(zusatz); }
     w.appendChild(v);
     return w;
   }
 
+  /* Was der fremde Punkt kann, als kleine Marke hinter seiner Kennung.
+
+     Beide Seiten zeigen dasselbe, nur aus verschiedener Richtung: am
+     Schreibziel seinen Typ (er entscheidet, was von der Formel ankommt)
+     und ob es sich ueberhaupt beschreiben laesst; an der Lesequelle, ob
+     sie etwas meldet. `zielKann` in werte.js ist die eine Stelle, die
+     darueber urteilt - die Pruefungen-Karte fragt dieselbe Funktion. */
+  function zielMarke(s, seite) {
+    var id = seite === 'w' ? s.srcW : s.srcR;
+    if (!id) { return null; }
+    var o = S.objects[id];
+    if (!o || !o.common) { return null; }
+    var c = o.common;
+
+    var maengel = zielKann(s).filter(function (x) {
+      return seite === 'w' ? x.art !== 'meldetNichts' : x.art === 'meldetNichts';
+    });
+
+    var text, hinweis;
+    if (seite === 'w') {
+      if (!c.type) { return null; }
+      text = c.type;
+      var nw = maengel.some(function (x) { return x.art === 'nichtSchreibbar'; });
+      var bl = maengel.some(function (x) { return x.art === 'formelBlind'; });
+      hinweis = nw ? tr('detail.targetNoWrite')
+              : (bl ? tr('detail.targetTypeVoid', c.type) : tr('detail.targetTypeHint', c.type));
+      if (nw) { text = c.type + ' \u00b7 ' + tr('detail.notWritable'); }
+    } else {
+      if (!maengel.length) { return null; }
+      text = tr('detail.reportsNothing');
+      hinweis = tr('detail.targetNoRead');
+    }
+
+    var m = el('span', 'chip ' + (maengel.length ? 'warn' : 'mut'), text);
+    m.style.marginLeft = '7px';
+    m.title = hinweis;
+    return m;
+  }
   /* ---- Wo die Vorlage etwas anderes will --------------------------
 
      Die zugeklappte Zeile sagt nur, DASS etwas abweicht. Welches Feld,
@@ -282,7 +326,7 @@ export function detailZeile(e, s, idx) {
     lF.appendChild(selF);
     qf.appendChild(lF);
   }
-  zeigeBeide(zeile(tr('detail.readsFrom'), mitVollId(qf, s.srcR)), ['srcR']);
+  zeigeBeide(zeile(tr('detail.readsFrom'), mitVollId(qf, s.srcR, zielMarke(s, 'r'))), ['srcR']);
 
   if (s.frei) {
     var iFrei = el('input', 'tx w');
@@ -322,7 +366,7 @@ export function detailZeile(e, s, idx) {
   if (s.srcW && s.srcW !== s.srcR) {
     wf.appendChild(el('div', 'sugg', tr('detail.separateHint')));
   }
-  zeigeBeide(zeile(tr('detail.writesTo'), mitVollId(wf, s.srcW)), ['srcW']);
+  zeigeBeide(zeile(tr('detail.writesTo'), mitVollId(wf, s.srcW, zielMarke(s, 'w'))), ['srcW']);
 
   /* --- Leseformel --- */
   var fb = el('div');
@@ -436,7 +480,10 @@ export function detailZeile(e, s, idx) {
   iU.value = s.unit || '';
   iU.placeholder = '—';
   iU.addEventListener('click', function (ev) { ev.stopPropagation(); });
-  iU.addEventListener('input', function () { s.unit = iU.value; s.geaendert = true; });
+  /* `rateBehalten` gehoert zu jedem `geaendert` dazu - sonst traegt die
+     Zeile beim naechsten Zeichnen beide Marken („geaendert" UND
+     „vermutet"), und die schliessen sich aus (Ricardo, 15.09.2026). */
+  iU.addEventListener('input', function () { s.unit = iU.value; s.geaendert = true; rateBehalten(s); });
   iU.addEventListener('change', function () { neu(); });
   var lU = el('label', 'fld');
   lU.appendChild(el('span', null, tr('detail.unit')));
@@ -461,7 +508,7 @@ export function detailZeile(e, s, idx) {
   iC.value = s.caption || '';
   iC.placeholder = s.n;
   iC.addEventListener('click', function (ev) { ev.stopPropagation(); });
-  iC.addEventListener('input', function () { s.caption = iC.value; s.geaendert = true; });
+  iC.addEventListener('input', function () { s.caption = iC.value; s.geaendert = true; rateBehalten(s); });
   /* Was das Feld tut, stand nirgends - man tippte und sah keine
      Wirkung. Der Wert wird der Anzeigename des Punkts (common.name)
      und erscheint als Zusatz in der Zeile darueber. */

package/admin/js/entwurf.js

@@ -102,8 +102,14 @@ export function baueEntwurf(kanal) {
       states: c.states || undefined,
       wr: !!c.write,
       /* Ohne common.alias ist der Punkt seine eigene Quelle. Vorher stand
-         hier nichts und man musste jede Zeile von Hand zuweisen. */
-      srcR: istAlias ? (q.read || '') : id,
+         hier nichts und man musste jede Zeile von Hand zuweisen.
+
+         Ein Taster hat keine Lesequelle, obwohl `alias.id` eine Kennung
+         nennt: ioBroker verlangt sie, `common.read: false` sagt, dass dort
+         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,
       /* 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
@@ -1214,7 +1220,11 @@ export function bestandVorrang(e, aliasId) {
     if (c.name !== undefined) { s.caption = ist.caption; }
     s.f = ist.f;
     s.fw = ist.fw;
-    if (q.read) { s.srcR = q.read; }
+    /* `ist.srcR`, nicht `q.read`: bei einem Taster laesst
+       `zeileAusAlias` die Lesequelle bewusst leer, obwohl `alias.id` eine
+       Kennung nennt (K23). Die Wache auf `q.read` bleibt — sie verhindert,
+       dass ein Alias ohne Quellangabe die vorhandene ueberschreibt. */
+    if (q.read) { s.srcR = ist.srcR; }
     s.srcW = ist.srcW;
     s.on = true;
     s.ausBestand = true;

package/admin/js/ergebnis.js

@@ -38,6 +38,7 @@ import {
 import { setzeEnums, setzeZiel, unterschiede } from './zuordnung.js';
 import './detail.js';
 import { zeigeTausch, tauscheAus } from './quellentausch.js';
+import { baueVerwendungKarte } from './verwendung.js';
 
 import { baueChecks } from './pruefungen.js';
 import {
@@ -141,7 +142,15 @@ var warumAuf = false;
   }
 
   export function entwurfAngefasst() {
-    if (S.entwurf) { S.entwurf.angefasst = true; }
+    if (S.entwurf) {
+      S.entwurf.angefasst = true;
+      /* Die Aussicht „was passt nach dem Raten" haengt allein an den
+         Zeilen. Sie wird einmal gerechnet und gemerkt; eine Zeilen-
+         aenderung ist der einzige Anlass, sie fallen zu lassen. Beim
+         blossen Neuzeichnen bleibt sie stehen - das Raten liest keine
+         Messwerte, es kaeme dasselbe heraus. */
+      S.entwurf.rateAussicht = null;
+    }
   }
 
   export function neuZeichnenOderAufbauen(danach) {
@@ -323,6 +332,21 @@ var warumAuf = false;
        will, musste ihn bisher im Quellenbaum von Hand wiederfinden.
        Umgekehrt gilt dasselbe: steht man am Geraet und will nachsehen,
        was daraus geworden ist, fuehrt der zweite Knopf hin. */
+    /* Zeigt ein Punkt auf eine Quelle, die es nicht gibt, gehoert das
+       nach oben - nicht nur in die Zeile und in den Pruefungen-Kasten.
+       Der js-controller repariert diesen Zustand nie von allein. */
+    var insLeere = (S.entwurf && S.entwurf.states || []).filter(function (s) {
+      return s.on && s.srcR && !S.objects[s.srcR];
+    });
+    if (insLeere.length) {
+      sub.appendChild(document.createTextNode('  '));
+      var ml = el('span', 'chip bad', insLeere.length === 1
+        ? tr('result.sourceGone1')
+        : tr('result.sourceGoneN', insLeere.length));
+      ml.title = insLeere.map(function (s) { return s.n + ' → ' + s.srcR; }).join('\n');
+      sub.appendChild(ml);
+    }
+
     var sprung = null, sprungZiel = null, sprungModus = null;
     if (S.current.indexOf('alias.') === 0) {
       sprungZiel = quelleVon(S.current);
@@ -971,6 +995,15 @@ var warumAuf = false;
     /* --- Änderungen gegenüber dem, was gespeichert ist --- */
     baueDiffKarte(host, e);
 
+    /* --- Wo wird das benutzt? ---
+
+       Nur an einem Alias, den es schon gibt: an einem Entwurf, der noch
+       nicht geschrieben ist, kann ihn niemand nennen. */
+    var vAlias = e.ziel || e.kanal;
+    if (vAlias && String(vAlias).indexOf('alias.') === 0 && S.objects[vAlias]) {
+      baueVerwendungKarte(host, vAlias, quelleVon(vAlias));
+    }
+
     /* --- Prüfungen, Fusszeile, Knopfleiste --- */
     setzeKnoepfe(e, haupt, pflichtFehlt);
   }

package/admin/js/mqtt.js

@@ -655,6 +655,27 @@ function mqttCustom(g, thema) {
    zurueckzulesen ist ein Wettlauf: die Sicht hinkt dem frisch
    geschriebenen Objekt einen Wimpernschlag hinterher, und der
    Trockenlauf sperrte weiter wegen eines Punktes, den es laengst gab. */
+/* Der Typ eines Sendepunktes: `mixed`, sobald eine Schreibformel im
+   Spiel ist.
+
+   Sonst rechnet der js-controller den Formelwert beim Schreiben auf den
+   Typ des Ziels zurueck, und die Formel war umsonst: `POWER` traegt im
+   Befehlswissen `typ: boolean` UND `schreibformel: val ? "ON" : "OFF"`.
+   Aus dem "ON" wurde am boolean-Ziel wieder true, auf der Leitung stand
+   true statt ON. Geschaltet hat die Tasmota trotzdem — sie nimmt beides —,
+   aber die Formel stand nutzlos im Alias, und der von der Werkbank
+   angelegte Punkt sah anders aus als jeder von mqtt-client angelegte
+   (die sind alle `mixed`). Am Produktivsystem war es genau EINER von 196
+   (Ricardo, 15.09.2026, an alias.0.Bastelzimmer.Deckenlicht).
+
+   Keine Ausnahme fuer POWER, sondern eine Regel, die sich selbst
+   durchsetzt — sie gilt ebenso fuer `Fade` und `LedTable`. Wo keine
+   Formel steht, bleibt der genaue Typ: aus `number` zieht der Admin
+   Min, Max und Einheit. */
+function punktTyp(w) {
+  return w.schreibformel ? 'mixed' : (w.typ || 'mixed');
+}
+
 export function mqttEinzelnStill(kanal, name, fertig) {
   var bau = mqttPunktBauen(kanal, name, 'neu');
   if (!bau) { return fertig && fertig(); }
@@ -694,7 +715,7 @@ function mqttPunktBauen(kanal, name, was) {
     var common0 = {
       name: name,
       role: w0.rolle || 'state',
-      type: w0.typ || 'mixed',
+      type: punktTyp(w0),
       read: true, write: true,
       desc: tr('mq.createdBy'),
       custom: mqttCustom(g, thema0)
@@ -728,7 +749,7 @@ export function mqttEinzeln(kanal, name, was, knopf) {
     var common = {
       name: name,
       role: w.rolle || 'state',
-      type: w.typ || 'mixed',
+      type: punktTyp(w),
       read: true, write: true,
       desc: tr('mq.createdBy'),
       custom: mqttCustom(g, thema)