feat v1.34.0: island rooms — nested contours with evenodd holes

- roomsOverlap: full nesting is legal (islands), edge crossings and
  partial overlaps still rejected; polyContainsPoly + islandsOf pure
  helpers (+2 unit tests, 94 total)
- draw tool: per-click point-in-room rejection removed, validation at
  contour closing; parent rooms with islands render as evenodd paths
  (ring fills correctly, island stays clickable through the hole)
- smoke_island_rooms.mjs; smoke_merge_split stale room-count asserts
  fixed (rg pushed a 5th room; cancelWhole silently false for ages)
- TESTING/CHANGELOG same-commit

src/houseplan-card.ts

@@ -14,7 +14,7 @@ import {
 import {
   lqiColor, snapToGrid, samePoint, pointInPolygon, markerIdForBinding,
   segmentCm, formatLength, roomEdges, roomPoly, pointStrictlyInside, roomsOverlap,
-  pointOnBoundary, mergeRooms, splitRoomPath, polygonArea, closestPointOnBoundary, pointStrictlyInside as ptInside,
+  pointOnBoundary, mergeRooms, splitRoomPath, polygonArea, closestPointOnBoundary, pointStrictlyInside as ptInside, islandsOf,
   snapToWall, openingAmount,
   averageLqi, fitView, declump, safeUrl, resolveTapAction, floorsOf, type FloorInfo,
   stateIcon, lightColorOf, isAlarmState, parseRoomRef, diffNewDevices,
@@ -32,7 +32,7 @@ import './space-card';
 import { cardStyles } from './styles';
 import { langOf, t, type I18nKey } from './i18n';
 
-const CARD_VERSION = '1.33.5';
+const CARD_VERSION = '1.34.0';
 const LS_KEY = 'houseplan_card_layout_v1';
 const LS_CFG = 'houseplan_card_cfg_v1'; // cache of the server config+layout for instant rendering
 const LS_ZOOM = 'houseplan_card_zoom_v1';
@@ -1279,15 +1279,10 @@ class HouseplanCard extends LitElement {
     // until the contour closes — an abandoned outline leaves no lines behind.
     const pt = this._snap(raw);
     const closing = this._path.length >= 3 && this._samePt(pt, this._path[0]);
-    // rooms must not overlap: a vertex may sit on a wall (shared walls are normal),
-    // never strictly inside another room
-    if (!closing) {
-      const busy = this._roomAt(pt);
-      if (busy) {
-        this._showToast(this._t('toast.point_in_room', { name: busy.name || '' }));
-        return;
-      }
-    }
+    // Island rooms (v1.34.0): drawing INSIDE an existing room is legal — the
+    // contour may become a nested room (a column, an inner room). Partial
+    // overlaps are still rejected, but only at closing time, when the whole
+    // outline is known (roomsOverlap treats full nesting as legal).
     if (!this._path.length) {
       this._path = [pt];
       return;
@@ -2914,7 +2909,19 @@ class HouseplanCard extends LitElement {
                   r.area ? areaTemp(this.hass, this._devices, r.area) : null);
               const label = !space.bg && !disp.showNames && !this._markup;
               const c = this._roomCenter(r);
-              const shape = r.poly
+              // island rooms punch holes in their parent's fill (evenodd)
+              const myPoly = roomPoly(r);
+              const holes = myPoly
+                ? islandsOf(myPoly, space.rooms.filter((o) => o !== r).map((o) => roomPoly(o)!).filter(Boolean))
+                : [];
+              const pathD = (pts: number[][]) =>
+                'M ' + pts.map((p) => p[0] + ' ' + p[1]).join(' L ') + ' Z';
+              const shape = holes.length && myPoly
+                ? svg`<path class="${cls}" style="${style}" fill-rule="evenodd"
+                    d="${[myPoly, ...holes].map(pathD).join(' ')}"
+                    @click=${() => this._clickRoom(r)} @mousemove=${tip}
+                    @mouseleave=${() => (this._tip = null)}></path>`
+                : r.poly
                 ? svg`<polygon class="${cls}" style="${style}" points="${r.poly.map((p) => p.join(',')).join(' ')}"
                     @click=${() => this._clickRoom(r)} @mousemove=${tip}
                     @mouseleave=${() => (this._tip = null)}></polygon>`

src/i18n/en.json

@@ -122,7 +122,6 @@
   "toast.markup_needs_server": "Markup is available after the config is moved to the server",
   "toast.conflict": "Config was changed in another window — data refreshed, repeat your last action",
   "toast.cfg_save_failed": "Failed to save config: {err}",
-  "toast.point_in_room": "That point is inside room “{name}” — rooms must not overlap",
   "toast.room_overlap": "The outline overlaps room “{name}” — rooms must not overlap",
   "toast.merge_not_adjacent": "Only rooms that share a wall can be merged",
   "toast.rooms_merged": "Rooms merged into “{name}”",

src/i18n/ru.json

@@ -122,7 +122,6 @@
   "toast.markup_needs_server": "Разметка доступна после переноса конфига на сервер",
   "toast.conflict": "Конфиг изменён в другом окне — данные обновлены, повторите последнее действие",
   "toast.cfg_save_failed": "Не удалось сохранить конфиг: {err}",
-  "toast.point_in_room": "Точка внутри комнаты «{name}» — комнаты не должны накладываться",
   "toast.room_overlap": "Контур накладывается на комнату «{name}» — комнаты не должны накладываться",
   "toast.merge_not_adjacent": "Объединять можно только комнаты с общей стеной",
   "toast.rooms_merged": "Комнаты объединены в «{name}»",

src/logic.ts

@@ -241,19 +241,47 @@ function coversArea(a: number[][], b: number[][], eps: number): boolean {
   return false;
 }
 
+/** Is `inner` fully contained in `outer` (edges may touch, never cross)? */
+export function polyContainsPoly(outer: number[][], inner: number[][], eps = 1e-6): boolean {
+  if (!outer || !inner || outer.length < 3 || inner.length < 3) return false;
+  for (let i = 0; i < inner.length; i++)
+    for (let j = 0; j < outer.length; j++)
+      if (segmentsProperlyCross(inner[i], inner[(i + 1) % inner.length], outer[j], outer[(j + 1) % outer.length]))
+        return false;
+  for (const v of inner)
+    if (!pointStrictlyInside(v, outer, eps) && !pointOnBoundary(v, outer, eps)) return false;
+  // identical/traced outlines are NOT containment — probe the centroid strictness both ways
+  const c = [
+    inner.reduce((s, p) => s + p[0], 0) / inner.length,
+    inner.reduce((s, p) => s + p[1], 0) / inner.length,
+  ];
+  return pointStrictlyInside(c, outer, eps) && polygonArea(inner) < polygonArea(outer) - eps;
+}
+
 /**
- * Do two room outlines share floor area? Rooms must never overlap, but sharing a wall
- * (fully or partially) and touching at a corner are normal and stay legal. A room nested
- * inside another counts as an overlap.
+ * Do two room outlines ILLEGALLY share floor area? Sharing a wall (fully or
+ * partially) and touching at a corner are normal. Since v1.34.0 full nesting is
+ * legal too (island rooms: a column inside a ring, an inner room) — only edge
+ * crossings and PARTIAL overlaps are rejected.
  */
 export function roomsOverlap(a: number[][], b: number[][], eps = 1e-6): boolean {
   if (!a || !b || a.length < 3 || b.length < 3) return false;
   for (let i = 0; i < a.length; i++)
     for (let j = 0; j < b.length; j++)
       if (segmentsProperlyCross(a[i], a[(i + 1) % a.length], b[j], b[(j + 1) % b.length])) return true;
+  if (polyContainsPoly(a, b, eps) || polyContainsPoly(b, a, eps)) return false;
   return coversArea(a, b, eps) || coversArea(b, a, eps);
 }
 
+/**
+ * Direct islands of `poly` among `others`: outlines fully inside it that are not
+ * themselves inside a bigger island (those are subtracted by their parent).
+ */
+export function islandsOf(poly: number[][], others: number[][][], eps = 1e-6): number[][][] {
+  const inside = others.filter((o) => polyContainsPoly(poly, o, eps));
+  return inside.filter((o) => !inside.some((p) => p !== o && polyContainsPoly(p, o, eps)));
+}
+
 /** Shoelace area of an outline (absolute value). */
 export function polygonArea(poly: number[][]): number {
   if (!poly || poly.length < 3) return 0;