iobroker.alias-workbench 0.9.9 → 0.9.11

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2026 Ricardo Hipp
+Copyright (c) 2026 Ricardo Hipp <ricardo.hipp@googlemail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -564,6 +564,35 @@ 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
+* Three small things spotted during the run. **RSSI** was pre-ticked in the five Tasmota and measuring-point templates but not in the eleven Homematic ones — the same device property, two answers depending on the vendor; it is now unticked everywhere, like the rest of the diagnostics. **The `MAP_URL` slot** in the vacuum pattern got no role because its expression starts without `^` and the derivation demanded both anchors; a missing start anchor no longer counts against a slot. **And the "guessed" tag** in the swap dialog looked like text stuck to the point name — its styling hung on three parent levels that do not exist there. It is now a pill like in the state list and says in its tooltip whether the guess came from the point name or from the role
+* The save button in the template dialog now also checks when pressed, not only when drawn. It is re-evaluated when a field is left — typing an open bracket into the name hint and clicking "Save template" without leaving the field left you with a blue button and saved a template with a broken expression. The five lock reasons now live in one place that drawing and saving share
+* Three places now say why they cannot. **The save button in the template dialog** was greyed out and silent — five reasons can lock it and none of them was shown; every applicable one now appears on the button and as a box in the dialog. **The error dialog when deleting** only gave a count ("1 operations failed") and not which id is stuck; writing has had that list all along. **And the reason a send point could not be created** hung on a button that the same callback threw away 120 ms later — it now sits at the top of the dry run and survives the rebuild
+* If a point's type does not match its pattern slot, all three places now say so — not just the expanded row. If the slot was **required**, the pattern stops applying altogether, and the whole list showed up tinted: on the Bastelzimmer_Licht, switching SET from `boolean` to `mixed` was enough for eight of eight rows to count as "no slot", while the pattern field reported "✕ SET missing" — SET was right there. It now reads "✕ SET: type mixed instead of boolean", and above the list: "The light pattern does not apply right now: SET requires boolean, but mixed is set. That is why no row has a slot." Only the row that causes it is tinted now — the whole list used to light up, which showed the consequence instead of the cause.
+* A late answer to `system.config` now really does carry the expert mode over. The tab gives up after 2.5 seconds and continues with the browser language; if the answer arrives later, the language stays as it is (switching after the labels are drawn would be worse), the expert mode is adopted and the tree is redrawn once. That had long been built — but above it sat a guard from the time before, which bailed out in exactly this case. Without the mode, every node under `system.*` and `enum.*` was missing, with nothing saying why
+* The swap dialog notices when one level up fits better. The picker lets you choose any node with data points underneath — it has to, because on a flat adapter the channel is the device. With MQTT, though, `stat`, `tele` and `cmnd` are topic folders: landing there finds fewer points, and the lock would ask you to remove some. The workbench now also computes the parent level and says so — "One level up (…) finds a target for 7 of 7 points, here only 5" — with a button that switches the selection. Nothing is forbidden
+* The device list in the swap dialog keeps its position. Scrolling down a long list and picking a device used to jump back to the top, with the freshly picked entry out of sight — picking rebuilds the dialog, and the tree is a different element afterwards. If the selected row still ends up outside, it is brought into view. A new search and a freshly opened dialog still start at the top
+* When swapping the source, a write target no longer counts if it coincides with the read source. The search tries the bare point name as its last form, so `cmnd.POWER` found a status point that also ends in `POWER` — the alias would then have written to its own read source. Guessing already caught this, matching by path did not; it showed when the new source was picked as a sub-node instead of the device
+* When swapping the source, a point that cannot come along now stops the swap instead of letting it fail halfway. A point with separate sources — reads from `stat.POWER`, writes to `cmnd.POWER` — needs both at the new source. If the write target is missing, ioBroker has **no** form that means "reads, writes nowhere": a plain id means "write to the status point", `{read: X}` without `write` is rejected by the js-controller, and `common.write: false` does not protect the source (measured: writing to such an alias overwrote the read source). So the user decides — the checkbox "remove this point when swapping" now appears in this case as well, and "Swap now" stays disabled until someone has decided; the reason shows on the button and as a line in the dialog. Before, the swap started, failed at the controller and left the alias half on the old and half on the new source
+* If a write fails during the swap, **nothing** is deleted. The deletions used to run anyway, so an alias that was already half migrated lost points on top of it. Moving an alias has followed that rule for a long time
+* "All data points of the device" no longer moves the storage location. For a device with several outputs the workbench creates a folder with one channel per output. The button rebuilds the draft and passed on only the **finished target**; `setzeZiel` reads its last segment as the device name — with several outputs that segment is the output, and it ended up in the folder as well. Every press pushed the location one level deeper, and that is where it was written, too: three clicks produced four folders instead of one (`…Garten-Ventilinsel.POWER2.POWER2.POWER2.POWER2`). The button now passes folder and name separately, the way the output selector next to it has always done. A single-output device was never affected
+
 ### 0.9.9
 * The build source moved from `src/` to `src-admin/`. ioBroker reserves that name for frontend sources that are bundled into `admin/` and never reach the user, and the adapter checker skips such directories when it looks for missing dependencies. `@iobroker/type-detector` therefore stays in `devDependencies`, which is where it belongs: esbuild bakes it into `admin/detector.js` at build time and nothing loads it at runtime. Users receive the finished 71 KB file, not the 548 KB package (W5042)
 * The settings page now takes its translations from `admin/i18n/` — the dictionary ioBroker reads itself (`"i18n": true`) and that Weblate can work with. The eleven languages it already carried moved there unchanged; not a word was retranslated. The tab keeps its own dictionary, now at `admin/sprachen/`: 588 keys in German and English, with an unknown language falling back to English. Two dictionaries, two jobs — the name `i18n` is the one the adapter checker inspects, and it expects all eleven languages there (W5603, W5614, W5015)

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 ---- */
 
@@ -553,9 +620,14 @@
   .erow .nm3 .geae { font-family:var(--sans); font-size:8px; font-weight:700; letter-spacing:.05em;
                      text-transform:uppercase; background:var(--warn-soft); color:var(--warn);
                      padding:0 6px; border-radius:999px; margin-left:6px; }
-  .erow .nm3 .rat { font-family:var(--sans); font-size:8px; font-weight:700; letter-spacing:.05em;
-                    text-transform:uppercase; background:var(--accent-soft); color:var(--accent);
-                    padding:0 6px; border-radius:999px; margin-left:6px; }
+  /* Die Marke gilt ueberall gleich, nicht nur in der Zustandsliste.
+     Mit den drei Ebenen davor griff sie im Tausch-Dialog nicht: dort
+     haengt das span unter .sn, und "vermutet" stand als blosser Text
+     am Punktnamen - ohne Abstand, ohne Farbe, in 12 statt 8 px
+     (Ricardo, 12.09.2026, an alias.0.Garten.FK_Badezimmer). */
+  .rat { font-family:var(--sans); font-size:8px; font-weight:700; letter-spacing:.05em;
+         text-transform:uppercase; background:var(--accent-soft); color:var(--accent);
+         padding:0 6px; border-radius:999px; margin-left:6px; white-space:nowrap; }
   .erow .nm3 .ratknopf { font-family:var(--sans); font-size:11px; cursor:pointer; margin-left:5px;
                          color:var(--ink-3); padding:0 4px; border-radius:var(--r-sm); }
   .erow .nm3 .ratknopf:hover { background:var(--surface-3); color:var(--ink); }
@@ -710,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;
@@ -809,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; }
@@ -931,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

@@ -9,7 +9,7 @@ import { txt, tr } from './sprache.js';
 import './enums.js';
 import { zusatzName, setzeModus, zeichneBaum, merkeKlappstand } from './baum.js';
 import { kindZustaende, aliasQuellen, holeWerte,
-  mitVorspann, schreibQuelle
+  mitVorspann, schreibQuelle, zeileAusAlias
 } from './werte.js';
 import { erkenneEntwurf } from './erkennung.js';
 import { vorschlag , pruefeVorlage, zeigeAbozahl } from './vorlagen.js';
@@ -58,6 +58,17 @@ export function merkeHakenVorgabe(e) {
   return e;
 }
 
+/* Was von `common.name` als Beschriftung uebrig bleibt.
+
+   Gleicht der Name dem Zeilennamen, ist er keine eigene Beschriftung,
+   sondern die Vorgabe - dann bleibt das Feld leer. Dieselbe Regel gilt
+   in `zeileAusAlias` (werte.js) und damit an allen vier Stellen, die
+   eine Zeile aus einem Alias-Objekt bauen. */
+function beschriftungAus(name, zeilenname) {
+  var nm = txt(name);
+  return (nm && nm !== zeilenname) ? nm : '';
+}
+
 export function baueEntwurf(kanal) {
   var istAlias = (kanal.indexOf('alias.') === 0);
   var e = { kanal: kanal, states: [], want: null, wantAuto: null, alleMuster: false };
@@ -91,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
@@ -106,7 +123,18 @@ export function baueEntwurf(kanal) {
       srcW: istAlias ? schreibQuelle(o) : (c.write ? id : ''),
       f: (typeof a.read === 'string') ? a.read : '',
       fw: (typeof a.write === 'string') ? a.write : '',
-      caption: istAlias ? txt(c.name) : kanalBeschriftung(kanal, kurzName),
+      /* Dieselbe Regel wie ueberall sonst: „leer, wenn sie dem
+         Zeilennamen gleicht".
+
+         Hier stand `istAlias ? txt(c.name) : …` ohne diese Pruefung.
+         Folge: Wo `common.name` dem Punktnamen gleicht - bei fast jedem
+         Alias, den die Werkbank selbst angelegt hat -, zeigte „Alias
+         bearbeiten" den Namen und „Alias anlegen" ein leeres Feld.
+         Derselbe Alias, zwei Ansichten, zwei Antworten (U21, gemessen
+         12.09.2026). Geschrieben wurde in beiden Faellen dasselbe; zu
+         sehen war es trotzdem. */
+      caption: istAlias ? beschriftungAus(c.name, kurzName)
+                        : kanalBeschriftung(kanal, kurzName),
       manuell: false
     });
   });
@@ -1167,18 +1195,37 @@ export function bestandVorrang(e, aliasId) {
          her, nachdem der Bestand ihn ueberschrieben hat. */
       on: s.on
     };
+    var ist = zeileAusAlias(o, s.n);
+    /* Rolle und Typ NUR, wenn sie im Alias ueberhaupt stehen.
+
+       `zeileAusAlias` liefert an dieser Stelle `''` - fuer die anderen
+       drei Aufrufer richtig, hier nicht: ein Alias ohne eigene Rolle
+       soll die der Vorlage behalten, statt sie gegen einen Leerstring zu
+       tauschen. Das ist der eine Unterschied, der beim Zusammenlegen der
+       fuenf Stellen erhalten bleiben musste (Y5) - wer ihn wegraeumt,
+       nimmt jedem vorlagenbasierten Alias seine Rollen. */
     if (c.role !== undefined) { s.role = c.role; }
     if (c.type !== undefined) { s.typ = c.type; }
-    s.unit = (c.unit !== undefined) ? c.unit : '';
+    s.unit = ist.unit;
     s.states = c.states;
     /* Die Beschriftung gehoert dem Nutzer - sie wird auch spaeter vom
-       Vorlagen-Abgleich nicht angefasst (Ricardo, 25.08.2026). */
-    if (c.name !== undefined) { s.caption = txt(c.name); }
-    var a = c.alias || {};
-    s.f = (typeof a.read === 'string') ? a.read : '';
-    s.fw = (typeof a.write === 'string') ? a.write : '';
-    if (q.read) { s.srcR = q.read; }
-    s.srcW = schreibQuelle(o);
+       Vorlagen-Abgleich nicht angefasst (Ricardo, 25.08.2026).
+
+       Seit dem 12.09.2026 gilt hier dieselbe Regel wie ueberall sonst:
+       gleicht sie dem Zeilennamen, bleibt das Feld leer. Vorher stand
+       hier `if (c.name !== undefined) s.caption = txt(c.name)` - und
+       weil `vomAliasUebernehmen` danach laeuft und verwirft, hing es
+       an der Reihenfolge, welche der beiden Antworten man zu sehen
+       bekam (U21). */
+    if (c.name !== undefined) { s.caption = ist.caption; }
+    s.f = ist.f;
+    s.fw = ist.fw;
+    /* `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;
   });
@@ -1209,14 +1256,7 @@ export function bestandsAbweichung(s, aliasId) {
   if (!s || !s.n || !s.on || !aliasId) { return []; }
   var o = S.objects[aliasId + '.' + s.n];
   if (!o || !o.common) { return []; }
-  var c = o.common, a = c.alias || {}, q = aliasQuellen(o);
-  var ist = {
-    role: c.role || '', typ: c.type || '', unit: c.unit || '',
-    f: (typeof a.read === 'string') ? a.read : '',
-    fw: (typeof a.write === 'string') ? a.write : '',
-    srcR: q.read || '',
-    srcW: schreibQuelle(o)
-  };
+  var ist = zeileAusAlias(o, s.n);
   var raus = [];
   ['role', 'typ', 'unit', 'f', 'fw', 'srcR', 'srcW'].forEach(function (k) {
     var jetzt = s[k] || '';

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);
@@ -705,6 +729,27 @@ var warumAuf = false;
         neuE.roh = rohJetzt;
         neuE.vorschlag = true;
         neuE.tplName = e.tplName; neuE.grund = e.grund; neuE.ziel = e.ziel;
+        /* Ordner und Name getrennt mitgeben, nicht nur das fertige Ziel.
+
+           `setzeZiel` rechnet den Ordner nur aus, solange keiner dasteht —
+           und dabei liest es das letzte Segment von `e.ziel` als
+           Geraetenamen. Bei einem Geraet mit mehreren Ausgaengen ist das
+           letzte Segment aber der AUSGANG (`…Garten-Ventilinsel.POWER2`),
+           und der Ordner bekam ihn angehaengt. Jeder Druck auf diesen
+           Knopf schob den Ablageort eine Ebene tiefer, und geschrieben
+           wurde er auch so: gemessen 12.09.2026 am Testsystem entstanden
+           nach drei Klicks vier Ordner statt einem
+           (`…Garten-Ventilinsel.POWER2.POWER2.POWER2.POWER2`).
+
+           Der Ausgangswechsel eine Stelle weiter oben macht es seit jeher
+           richtig — hier dieselbe Form. Im Aliasmodus sind beide Felder
+           `undefined`; dann bleibt alles wie bisher, `setzeZiel` steigt
+           dort ohnehin sofort aus. `ordnerVonHand` gehoert mit, sonst
+           verliert der Raumvorschlag die Entscheidung, wer den Ordner
+           gesetzt hat (E41). */
+        neuE.zielOrdner = e.zielOrdner;
+        neuE.zielName = e.zielName;
+        neuE.ordnerVonHand = e.ordnerVonHand;
         if (fest) { neuE.vonHandGewaehlt = false; neuE.ausBestand = true; }
         if (vorh && S.objects[vorh]) { bestandVorrang(neuE, vorh); }
         S.entwurf = neuE; S.openRow = null; zeichneErgebnis();
@@ -827,15 +872,32 @@ var warumAuf = false;
       ba.hidden = !mehr && !mehrK;
       if (mehr) {
         ba.textContent = tr('write.createAll', e.instanzen.length);
+        /* Dieselbe Rechnung wie beim Schreiben, samt Kollisionsschutz.
+
+           Zwei Kanaele koennen nach der Saeuberung denselben Namen
+           ergeben („Licht Bar" und „Licht, Bar" beide `Licht_Bar`); der
+           Schreibpfad haengt dann `_2` an. Ohne dieselbe Rechnung stuende
+           im Hinweis zweimal derselbe Name und danach etwas anderes am
+           System - genau die Luecke, die G31 beschreibt (12.09.2026). */
+        var belegt = {};
         ba.title = e.instanzen.map(function (n) {
-          return (e.zielOrdner || '') + '.' + ausgangName(e, n);
+          var nm = (String(n) === String(e.instanz)) ? e.zielName : ausgangName(e, n);
+          if (belegt[nm]) {
+            var z = 1, n2;
+            do { z++; n2 = nm + '_' + z; } while (belegt[n2]);
+            nm = n2;
+          }
+          belegt[nm] = 1;
+          return (e.zielOrdner || '') + '.' + nm;
         }).join(String.fromCharCode(10));
       } else if (mehrK) {
         ba.textContent = tr('write.createPerChannel', e.kanalGeraete.length);
         /* Im Hinweis stehen die Namen, die entstehen wuerden — sonst
            klickt man auf eine Zahl und weiss nicht, was danach dasteht. */
         ba.title = e.kanalGeraete.map(function (k) {
-          return (e.zielOrdner || '') + '.' + k.name + '   (' + k.typ + ')';
+          /* Die Kennung, nicht den Anzeigenamen - so heisst das Objekt
+             hinterher wirklich (G31). */
+          return (e.zielOrdner || '') + '.' + (k.kennung || k.name) + '   (' + k.typ + ')';
         }).join(String.fromCharCode(10));
       }
       ba.disabled = false;
@@ -933,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);
   }
@@ -1050,9 +1121,16 @@ var warumAuf = false;
   function verkabeleDialoge() {
     var bc = $('#btn-checks'), bd = $('#btn-dry'), bw = $('#btn-dry-write');
     if (bc) { bc.addEventListener('click', function () { $('#dlg-checks').showModal(); }); }
-    if (bd) { bd.addEventListener('click', function () { zeigeTrockenlauf(false); }); }
+    /* Beim Oeffnen von Hand faengt der Dialog frisch an - ein alter
+       Sendepunkt-Fehler von vorhin hat dann nichts mehr zu sagen (H17).
+       Aus dem Rueckruf heraus wird zeigeTrockenlauf direkt gerufen, dort
+       bleibt die Meldung also stehen. */
+    var frisch = function (alle) {
+      return function () { S.mqFehler = null; zeigeTrockenlauf(alle); };
+    };
+    if (bd) { bd.addEventListener('click', frisch(false)); }
     var ba2 = $('#btn-dry-alle');
-    if (ba2) { ba2.addEventListener('click', function () { zeigeTrockenlauf(true); }); }
+    if (ba2) { ba2.addEventListener('click', frisch(true)); }
     if (bw) { bw.addEventListener('click', schreibeObjekte); }
     var bdel = $('#btn-del'), bdg = $('#btn-del-go');
     if (bdel) { bdel.addEventListener('click', zeigeLoeschen); }