feat v1.20.0: rooms may not overlap

- A click strictly inside an existing room is refused while drawing; a click ON a wall
  stays legal (neighbours share walls, and real walls overlap collinearly rather than
  match exactly, so vertices land on existing outlines mid-span constantly).
- Closing an outline that overlaps an existing room is refused — vertex checks alone are
  not enough, an outline drawn AROUND a room has every vertex outside it. Nesting counts
  as overlap. The outline stays open so it can be corrected.
- New pure geometry: roomPoly, pointOnBoundary, pointStrictlyInside, segmentsProperlyCross
  (touching/collinear deliberately not a crossing), roomsOverlap. +4 tests (67).
Verified live: all 15 existing neighbour pairs stay clean (no false positives).

src/houseplan-card.ts

@@ -13,7 +13,7 @@ import {
 } from './rules';
 import {
   lqiColor, snapToGrid, samePoint, pointInPolygon, markerIdForBinding,
-  segmentCm, formatLength, roomEdges,
+  segmentCm, formatLength, roomEdges, roomPoly, pointStrictlyInside, roomsOverlap,
   averageLqi, fitView, declump, safeUrl, resolveTapAction, floorsOf, type FloorInfo,
   spaceDisplayOf, roomFillColor, DEFAULT_ROOM_COLOR, DEFAULT_ROOM_OPACITY,
   DEFAULT_TEMP_MIN, DEFAULT_TEMP_MAX, type SpaceDisplay,
@@ -27,7 +27,7 @@ import './space-card';
 import { cardStyles } from './styles';
 import { langOf, t, type I18nKey } from './i18n';
 
-const CARD_VERSION = '1.19.0';
+const CARD_VERSION = '1.20.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';
@@ -1010,6 +1010,25 @@ class HouseplanCard extends LitElement {
       });
   }, 500);
 
+  /**
+   * The room that strictly contains p. Being ON a wall does not count: neighbouring
+   * rooms share walls, so new vertices legitimately land on existing outlines.
+   */
+  private _roomAt(p: number[]): RoomCfg | undefined {
+    return this._spaceModel().rooms.find((r) => {
+      const poly = roomPoly(r);
+      return !!poly && pointStrictlyInside(p, poly);
+    });
+  }
+
+  /** The first existing room the outline would overlap (rooms must not overlap). */
+  private _overlapRoom(verts: number[][]): RoomCfg | undefined {
+    return this._spaceModel().rooms.find((r) => {
+      const poly = roomPoly(r);
+      return !!poly && roomsOverlap(verts, poly);
+    });
+  }
+
   private _pointInRoom(p: number[], r: RoomCfg): boolean {
     if (r.poly) return pointInPolygon(p, r.poly);
     return (
@@ -1036,20 +1055,37 @@ class HouseplanCard extends LitElement {
     // draw: clicks on grid points build the outline. Nothing is written to the config
     // 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;
+      }
+    }
     if (!this._path.length) {
       this._path = [pt];
       return;
     }
     const last = this._path[this._path.length - 1];
     if (this._samePt(pt, last)) return; // repeated click on the same point
-    this._path = [...this._path, pt];
-    // closing the outline: a click on the first vertex → the save dialog
-    if (this._path.length >= 4 && this._samePt(pt, this._path[0])) {
+    if (closing) {
+      // a contour can enclose an existing room without any vertex inside it
+      const clash = this._overlapRoom(this._path);
+      if (clash) {
+        this._showToast(this._t('toast.room_overlap', { name: clash.name || '' }));
+        return; // leave the outline open so it can be corrected
+      }
+      this._path = [...this._path, pt];
       this._cursorPt = null;
       this._nameSel = '';
       this._areaSel = '';
       this._roomDialog = true;
+      return;
     }
+    this._path = [...this._path, pt];
   }
 
   private get _contourClosed(): boolean {

src/i18n/en.json

@@ -92,6 +92,8 @@
   "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.room_saved": "Room saved ({n}). Devices added: {added}. Outline the next one or exit markup.",
   "toast.room_saved_no_area": "Room saved ({n}, no area). Outline the next one or exit markup.",
   "toast.marker_needs_server": "Device editing is available after the config is moved to the server",

src/i18n/ru.json

@@ -92,6 +92,8 @@
   "toast.markup_needs_server": "Разметка доступна после переноса конфига на сервер",
   "toast.conflict": "Конфиг изменён в другом окне — данные обновлены, повторите последнее действие",
   "toast.cfg_save_failed": "Не удалось сохранить конфиг: {err}",
+  "toast.point_in_room": "Точка внутри комнаты «{name}» — комнаты не должны накладываться",
+  "toast.room_overlap": "Контур накладывается на комнату «{name}» — комнаты не должны накладываться",
   "toast.room_saved": "Комната сохранена ({n}). Устройств добавлено: {added}. Обведите следующую или выйдите из разметки.",
   "toast.room_saved_no_area": "Комната сохранена ({n}, без зоны). Обведите следующую или выйдите из разметки.",
   "toast.marker_needs_server": "Редактирование устройств доступно после переноса конфига на сервер",

src/logic.ts

@@ -48,15 +48,19 @@ export function segKey(a: number[], b: number[], prec = 1): string {
  * room. Shared walls are emitted once, which is what makes deleting a room keep the
  * borders its neighbours still contribute — the neighbour's polygon still yields them.
  */
+export function roomPoly(r: any): number[][] | null {
+  if (r?.poly?.length >= 3) return r.poly;
+  if (r && r.x != null && r.y != null && r.w != null && r.h != null)
+    return [[r.x, r.y], [r.x + r.w, r.y], [r.x + r.w, r.y + r.h], [r.x, r.y + r.h]];
+  return null;
+}
+
 export function roomEdges(rooms: any[]): number[][] {
   const out: number[][] = [];
   const seen = new Set<string>();
   for (const r of rooms || []) {
-    let pts: number[][] | null = null;
-    if (r?.poly?.length) pts = r.poly;
-    else if (r && r.x != null && r.y != null && r.w != null && r.h != null)
-      pts = [[r.x, r.y], [r.x + r.w, r.y], [r.x + r.w, r.y + r.h], [r.x, r.y + r.h]];
-    if (!pts || pts.length < 3) continue;
+    const pts = roomPoly(r);
+    if (!pts) continue;
     for (let i = 0; i < pts.length; i++) {
       const a = pts[i];
       const b = pts[(i + 1) % pts.length];
@@ -85,6 +89,87 @@ export function pointInPolygon(p: number[], poly: number[][]): boolean {
   return inside;
 }
 
+/** Distance from p to segment ab. */
+function distToSeg(p: number[], a: number[], b: number[]): number {
+  const dx = b[0] - a[0];
+  const dy = b[1] - a[1];
+  const len2 = dx * dx + dy * dy;
+  let t = len2 ? ((p[0] - a[0]) * dx + (p[1] - a[1]) * dy) / len2 : 0;
+  t = Math.max(0, Math.min(1, t));
+  return Math.hypot(p[0] - (a[0] + t * dx), p[1] - (a[1] + t * dy));
+}
+
+/**
+ * Is p on the outline itself (within eps)? This is the normal case, not an anomaly:
+ * neighbouring rooms share walls, so their vertices sit on each other's outlines —
+ * including mid-span, since real walls overlap collinearly rather than match exactly.
+ */
+export function pointOnBoundary(p: number[], poly: number[][], eps = 1e-6): boolean {
+  if (!poly || poly.length < 2) return false;
+  for (let i = 0; i < poly.length; i++)
+    if (distToSeg(p, poly[i], poly[(i + 1) % poly.length]) <= eps) return true;
+  return false;
+}
+
+/** Inside the outline AND not on it — a point on a shared wall is not "inside". */
+export function pointStrictlyInside(p: number[], poly: number[][], eps = 1e-6): boolean {
+  if (!poly || poly.length < 3) return false;
+  if (pointOnBoundary(p, poly, eps)) return false;
+  return pointInPolygon(p, poly);
+}
+
+function cross3(a: number[], b: number[], c: number[]): number {
+  return (b[0] - a[0]) * (c[1] - a[1]) - (b[1] - a[1]) * (c[0] - a[0]);
+}
+
+/**
+ * Do two segments cross transversally? Touching at an endpoint and collinear overlap
+ * deliberately do NOT count — that is what sharing a wall looks like.
+ */
+export function segmentsProperlyCross(
+  p1: number[], p2: number[], p3: number[], p4: number[], eps = 1e-9,
+): boolean {
+  const d1 = cross3(p3, p4, p1);
+  const d2 = cross3(p3, p4, p2);
+  const d3 = cross3(p1, p2, p3);
+  const d4 = cross3(p1, p2, p4);
+  return (
+    ((d1 > eps && d2 < -eps) || (d1 < -eps && d2 > eps)) &&
+    ((d3 > eps && d4 < -eps) || (d3 < -eps && d4 > eps))
+  );
+}
+
+/** Is any area of outline `a` strictly inside `b`? Also catches nested and duplicate outlines. */
+function coversArea(a: number[][], b: number[][], eps: number): boolean {
+  let allOnBoundary = true;
+  for (const v of a) {
+    if (pointStrictlyInside(v, b, eps)) return true;
+    if (!pointOnBoundary(v, b, eps)) allOnBoundary = false;
+  }
+  // every vertex sits on b's outline → a duplicate or traced outline: probe the middle
+  if (allOnBoundary) {
+    const c = [
+      a.reduce((s, p) => s + p[0], 0) / a.length,
+      a.reduce((s, p) => s + p[1], 0) / a.length,
+    ];
+    return pointStrictlyInside(c, b, eps);
+  }
+  return false;
+}
+
+/**
+ * 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.
+ */
+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;
+  return coversArea(a, b, eps) || coversArea(b, a, eps);
+}
+
 /**
  * Marker id by binding: device → device_id, entity → 'lg_'+entity_id,
  * virtual → the passed-in existing (if it is already a v_ marker) or a new one via newId().