v1.55.3

The v1.55.2 recheck (verdict NEEDS FIX) found two lifecycle holes in the
first-open boot veil (HP-1552); both are closed here and covered by
demo/smoke_preloader_lifecycle.mjs, which fails on v1.55.2.

AUD-1552-01 (high): disconnect/reconnect while booting hid the plan
FOREVER. disconnectedCallback cleared the boot timer but kept its
truthy id, so 'updated()' never restarted the watcher. Now the id is
nulled on disconnect and connectedCallback restarts the whole veil
lifecycle: a fresh watch (fresh clock, BOOT_MAX_MS hard cap) while
booting, the tail timers when detached mid-fade or mid-grace.

AUD-1552-02 (medium): two equal reads at 200/400 ms revealed the plan
at ~400 ms, so HA chrome landing at 450+ ms jumped on a VISIBLE plan.
The veil now holds a full protective window (BOOT_MIN_MS=700 — the old
600 ms plus a frame-latency margin: a shift applied at ~590 ms only
materializes in the stage height a couple frames later) with 100 ms
sampling and trailing quiescence (BOOT_QUIET_MS=250 restarts on every
height change), capped by BOOT_MAX_MS=1200. After the reveal a short
soft grace (BOOT_SOFT_MS=1500, .stage.hpsettle) turns later passive
shifts into a 0.25 s height glide — the viewport ResizeObserver refits
the plan along the transition; deliberate height changes (_setMode into
an editor) cancel the grace so the plan never drifts under the pointer.
Reduced motion disables the glide.

Regressions (demo/smoke_preloader_lifecycle.mjs, all FAIL on v1.55.2):
- A: detach before the first tick -> reattach -> veil lifts within the
  cap, plan visible, no hpboot class, no zombie veil after a mid-fade
  remount either;
- B: parameterized layout shifts at 150/300/450/590 ms -> not a single
  frame shows the plan at a non-final stage height;
- C: a shift after the reveal glides (>=3 intermediate frames), no snap.

smoke_modes.mjs now strips the transient hpsettle class from its exact
stage-class assertions. Docs: CHANGELOG en+ru, STATUS.

README.md

@@ -28,7 +28,8 @@ right on your Lovelace dashboard.
 **Feature highlights**
 
 - 🖱 **GUI-first floorplan editor** — rooms, doors & windows, island rooms,
-  virtual walls and a visual decor layer, all drawn with clicks; smart
+  virtual walls and a visual decor layer, all drawn with clicks; room resize
+  by dragging walls, with live lengths and areas as you drag; smart
   alignment guides and a live ruler in real meters/feet.
 - 💡 **Lights toggle on click** out of the box; wall-switch markers can control
   whole groups of lights (works for dumb switches and stateless remotes too).

README.ru.md

@@ -26,7 +26,8 @@
 **Главное**
 
 - 🖱 **Редакторы прямо в карточке** — комнаты, двери и окна, комнаты-острова,
-  виртуальные стены и декор-слой рисуются кликами; помощник выравнивания и
+  виртуальные стены и декор-слой рисуются кликами; размеры комнат меняются
+  перетаскиванием стен с живыми длинами и площадями; помощник выравнивания и
   линейка в реальных метрах.
 - 💡 **Свет переключается кликом** из коробки; значок выключателя может
   управлять группой ламп (в т.ч. «тупые» выключатели и кнопки-пульты).

custom_components/houseplan/const.py

@@ -45,7 +45,7 @@ PLAN_ORPHAN_TTL_S = 3600
 SCHEDULED_GRACE_S = 30 * 24 * 3600
 FILES_DIR = "houseplan/files"
 CONF_ADMIN_ONLY = "admin_only"
-VERSION = "1.54.1"
+VERSION = "1.55.3"
 
 DEFAULT_CONFIG: dict = {
     "spaces": [],

custom_components/houseplan/manifest.json

@@ -16,5 +16,5 @@
   "issue_tracker": "https://github.com/Matysh/houseplan-card/issues",
   "requirements": [],
   "single_config_entry": true,
-  "version": "1.54.1"
+  "version": "1.55.3"
 }

custom_components/houseplan/validation.py

@@ -173,6 +173,8 @@ SPACE_DISPLAY_SCHEMA = vol.Schema(
         vol.Optional("show_borders"): bool,
         vol.Optional("show_names"): bool,
         vol.Optional("room_color"): vol.Match(r"^#[0-9a-fA-F]{6}$"),
+        # per-space background around the plan; absent = inherit the global one
+        vol.Optional("bg_color"): vol.Match(r"^#[0-9a-fA-F]{6}$"),
         vol.Optional("room_opacity"): vol.All(vol.Coerce(float), vol.Range(min=0, max=1)),
         vol.Optional("fill_mode"): vol.In(["none", "lqi", "light", "temp", "glow"]),
         vol.Optional("temp_min"): vol.Coerce(float),
@@ -319,6 +321,8 @@ CONFIG_SCHEMA = vol.Schema(
         vol.Optional("settings", default=dict): vol.Schema(
             {
                 vol.Optional("glow_radius_cm"): vol.All(vol.Coerce(float), vol.Range(min=10, max=10000)),
+                # background around the plan, all spaces (a space may override)
+                vol.Optional("bg_color"): vol.Match(r"^#[0-9a-fA-F]{6}$"),
                 vol.Optional("known_devices"): vol.All([_TEXT], vol.Length(max=MAX_KNOWN_DEVICES)),
                 vol.Optional("new_device_ids"): vol.All([_TEXT], vol.Length(max=MAX_KNOWN_DEVICES)),
                 vol.Optional("fill_colors"): vol.Schema(

demo/serve.mjs

@@ -56,6 +56,10 @@ export async function launch(viewport = { width: 820, height: 760 }, scale = 1)
   });
   await page.goto('http://demo.local/demo.html', { waitUntil: 'domcontentloaded' });
   await page.waitForFunction(() => window.__card?._model?.length > 0, { timeout: 9000 });
+  // HP-1552: the first-open boot veil hides the plan (visibility:hidden) until
+  // the stage height settles — real pointer interaction cannot hit a hidden
+  // plan, so every smoke starts where the user does: with the plan revealed.
+  await page.waitForFunction(() => window.__card._booting === false, { timeout: 9000 });
   // hass flows continuously in production; the stub sets it once — nudge a rebuild
   await page.evaluate(() => { const c = window.__card; c.hass = { ...c.hass }; });
   await page.waitForFunction(() => window.__card._devices.length > 0, { timeout: 9000 });

demo/shot_motion_sense.mjs

@@ -0,0 +1,31 @@
+import { launch } from './serve.mjs';
+const { page, browser } = await launch({ width: 820, height: 760 }, 2);
+await page.evaluate(async () => {
+  const c = window.__card;
+  // the flash is keyed to a WITNESSED off→on transition (owner's rule
+  // 2026-08-01: разовая вспышка в момент обнаружения) — cycle through off
+  const set = async (state) => {
+    c.hass = { ...c.hass, states: { ...c.hass.states,
+      'binary_sensor.hall_motion': { entity_id: 'binary_sensor.hall_motion', state,
+        attributes: { friendly_name: 'Motion', device_class: 'motion', linkquality: 64 } } } };
+    await c.updateComplete;
+  };
+  await set('off');
+  await set('on');
+  // freeze the pulse at a visible frame for a deterministic capture
+  const st = document.createElement('style');
+  st.textContent = '.dev.senseflash::after{animation-delay:-0.4s;animation-play-state:paused;}';
+  (c.shadowRoot || c.renderRoot).appendChild(st);
+});
+await page.waitForTimeout(300);
+const box = await page.evaluate(() => {
+  const c = window.__card;
+  const el = (c.shadowRoot || c.renderRoot).querySelector('.dev.senseflash');
+  const r = el.getBoundingClientRect();
+  return { x: r.x, y: r.y, w: r.width, h: r.height };
+});
+const pad = 70;
+await page.screenshot({ path: process.argv[2] || '/tmp/motion_sense.png',
+  clip: { x: Math.max(0, box.x - pad), y: Math.max(0, box.y - pad), width: box.w + pad * 2, height: box.h + pad * 2 } });
+await browser.close();
+console.log('shot ok');

demo/smoke_bg_color.mjs

@@ -0,0 +1,144 @@
+// New setting "background color around the plan": global (config.settings.bg_color,
+// gear dialog) with a per-space override (space dialog, empty = inherit), applied
+// to the stage in view and kiosk modes and to the static space-card. Editors keep
+// their own canvas; the open dialogs preview the pending color live.
+import { launch, checkAll, finish } from './serve.mjs';
+const { page, browser } = await launch({ width: 900, height: 900 }, 1);
+const res = await page.evaluate(async () => {
+  const out = {};
+  const c = window.__card;
+  const sr = () => c.shadowRoot || c.renderRoot;
+  const stageBg = async () => {
+    c.requestUpdate();
+    await c.updateComplete;
+    return getComputedStyle(sr().querySelector('.stage')).backgroundColor;
+  };
+  const rgb = (hex) => `rgb(${parseInt(hex.slice(1, 3), 16)}, ${parseInt(hex.slice(3, 5), 16)}, ${parseInt(hex.slice(5, 7), 16)})`;
+
+  const themeBg = await stageBg(); // theme default from the stylesheet
+  const sp = c._serverCfg.spaces.find((s) => s.id === c._space);
+
+  // 1) global setting colors the stage
+  c._serverCfg.settings = { ...(c._serverCfg.settings || {}), bg_color: '#224466' };
+  out.globalApplies = (await stageBg()) === rgb('#224466');
+
+  // 2) per-space override wins
+  sp.settings = { ...(sp.settings || {}), bg_color: '#663311' };
+  out.spaceOverrides = (await stageBg()) === rgb('#663311');
+
+  // 3) clearing the space setting inherits the global again
+  delete sp.settings.bg_color;
+  out.clearInheritsGlobal = (await stageBg()) === rgb('#224466');
+
+  // 4) clearing the global returns the theme default
+  delete c._serverCfg.settings.bg_color;
+  out.clearRestoresTheme = (await stageBg()) === themeBg;
+
+  // 5) invalid stored value is ignored (renderer never trusts garbage)
+  c._serverCfg.settings.bg_color = 'url(javascript:alert(1))';
+  out.garbageIgnored = (await stageBg()) === themeBg;
+  delete c._serverCfg.settings.bg_color;
+
+  // 6) the settings dialog previews its pending color live + saves it
+  let saved = null;
+  const origWS = c.hass.callWS;
+  c.hass.callWS = async (m) => {
+    if (m.type === 'houseplan/config/set') { saved = m.config; return { rev: (c._cfgRev || 0) + 1 }; }
+    return origWS.call(c.hass, m);
+  };
+  c._openSettingsDialog();
+  await c.updateComplete;
+  out.dialogHasBgRow = !!sr().querySelector('.dialog .colorrow input[type=color]');
+  c._settingsDialog = { ...c._settingsDialog, bgColor: '#0a2a4a' };
+  out.dialogPreviews = (await stageBg()) === rgb('#0a2a4a');
+  await c._saveSettingsDialog();
+  out.dialogSaves = saved?.settings?.bg_color === '#0a2a4a';
+  out.savedApplies = (await stageBg()) === rgb('#0a2a4a');
+
+  // 7) the space dialog previews and saves the override
+  c._openSpaceDialog('edit', c._space);
+  await c.updateComplete;
+  c._spaceDialog = { ...c._spaceDialog, bgColor: '#4a0a2a' };
+  out.spaceDialogPreviews = (await stageBg()) === rgb('#4a0a2a');
+  saved = null;
+  await c._saveSpaceDialog();
+  const savedSp = saved?.spaces?.find((s) => s.id === c._space);
+  out.spaceDialogSaves = savedSp?.settings?.bg_color === '#4a0a2a';
+  out.spaceSavedApplies = (await stageBg()) === rgb('#4a0a2a');
+
+  // ...and clearing it in the dialog inherits the global again
+  c._openSpaceDialog('edit', c._space);
+  await c.updateComplete;
+  out.spaceDialogPrefilled = c._spaceDialog.bgColor === '#4a0a2a';
+  c._spaceDialog = { ...c._spaceDialog, bgColor: null };
+  await c._saveSpaceDialog();
+  // over the wire `undefined` keys vanish — check the JSON form, like the backend sees it
+  const wire = JSON.parse(JSON.stringify(saved));
+  const savedSp2 = wire?.spaces?.find((s) => s.id === c._space);
+  out.spaceDialogClears = !('bg_color' in (savedSp2?.settings || {}));
+  out.backToGlobal = (await stageBg()) === rgb('#0a2a4a');
+  c.hass.callWS = origWS;
+
+  // 8) editors keep their own canvas (inline bg only in view/kiosk)
+  c._setMode('decor');
+  const editorBg = await stageBg();
+  out.editorUnpainted = editorBg !== rgb('#0a2a4a');
+  c._setMode('view');
+  out.viewPaintedAgain = (await stageBg()) === rgb('#0a2a4a');
+
+  // 9) kiosk instance respects the setting
+  const k = document.createElement('houseplan-card');
+  k.setConfig({ type: 'custom:houseplan-card', kiosk: true, cycle: 0 });
+  k.hass = c.hass;
+  k.style.cssText = 'position:fixed;left:0;top:0;width:860px;height:860px;z-index:99';
+  document.body.appendChild(k);
+  await new Promise((r) => setTimeout(r, 300));
+  // the kiosk instance re-reads the pristine demo config — inject the color
+  // into ITS copy; what matters here is the kiosk rendering path
+  k._serverCfg.settings = { ...(k._serverCfg.settings || {}), bg_color: '#0a2a4a' };
+  k.hass = { ...c.hass };
+  k.requestUpdate();
+  await k.updateComplete;
+  const kStage = (k.shadowRoot || k.renderRoot).querySelector('.stage');
+  out.kioskApplies = !!kStage && getComputedStyle(kStage).backgroundColor === rgb('#0a2a4a');
+  k.remove();
+
+  // 10) the static space-card paints the same background
+  await customElements.whenDefined('houseplan-space-card');
+  const cfg = JSON.parse(JSON.stringify(c._serverCfg));
+  cfg.settings = { ...(cfg.settings || {}), bg_color: '#123456' };
+  const hass2 = { ...c.hass, callWS: async (m) => {
+    if (m.type === 'houseplan/config/get') return { config: cfg, rev: 1 };
+    if (m.type === 'houseplan/layout/get') return { layout: {} };
+    return origWS.call(c.hass, m);
+  } };
+  const scHost = document.createElement('div');
+  document.body.appendChild(scHost);
+  const sc = document.createElement('houseplan-space-card');
+  sc.setConfig({ type: 'custom:houseplan-space-card', space: c._space });
+  sc.hass = hass2;
+  scHost.appendChild(sc);
+  const t0 = Date.now();
+  while (!sc.renderRoot?.querySelector('.hp-static-stage') && Date.now() - t0 < 6000) await new Promise((r) => setTimeout(r, 80));
+  await sc.updateComplete;
+  const st = sc.renderRoot.querySelector('.hp-static-stage');
+  out.staticCardApplies = !!st && getComputedStyle(st).backgroundColor === rgb('#123456');
+  // ...and the space override beats the global there too
+  cfg.spaces.find((s) => s.id === c._space).settings = { bg_color: '#654321' };
+  sc.hass = { ...hass2 };
+  sc._cfg = null; // force a config re-read
+  await new Promise((r) => setTimeout(r, 200));
+  sc.requestUpdate(); await sc.updateComplete;
+  const st2 = sc.renderRoot.querySelector('.hp-static-stage');
+  out.staticCardSpaceWins = !!st2 && getComputedStyle(st2).backgroundColor === rgb('#654321');
+  scHost.remove();
+
+  // tidy: drop the color so later smokes on this page see the theme default
+  delete c._serverCfg.settings.bg_color;
+  const spx = c._serverCfg.spaces.find((s) => s.id === c._space);
+  if (spx?.settings) delete spx.settings.bg_color;
+  await stageBg();
+  return out;
+});
+checkAll(res);
+await finish(browser, res);

demo/smoke_decor.mjs

@@ -25,10 +25,22 @@ const res = await page.evaluate(async () => {
   out.rectRendered = !!sr().querySelector('.decorlayer rect.dshape');
   // 3) линия и овал
   c._decorDraft = { kind: 'line', a: [g * 2, g * 2], b: [g * 8, g * 2], pid: 1 };
+  await c.updateComplete;
+  // превью рисуемой линии уже с круглыми концами (зубцы на стыках)
+  const draftLine = sr().querySelector('.decorlayer line.ddraft');
+  out.draftLineRound = !!draftLine
+    && draftLine.getAttribute('stroke-linecap') === 'round'
+    && draftLine.getAttribute('stroke-linejoin') === 'round';
   c._decorCommitDraft();
   c._decorDraft = { kind: 'ellipse', a: [g * 30, g * 30], b: [g * 40, g * 36], pid: 1 };
   c._decorCommitDraft(); await c.updateComplete;
   out.threeShapes = c._decorList.length === 3;
+  // сохранённые линии рендерятся с круглыми концами: диаметр = толщине линии,
+  // стык двух линий под углом — без зубца (скриншот владельца)
+  await c.updateComplete;
+  const lines = [...sr().querySelectorAll('.decorlayer line.dshape')];
+  out.savedLineRound = lines.length > 0 && lines.every((l) =>
+    l.getAttribute('stroke-linecap') === 'round' && l.getAttribute('stroke-linejoin') === 'round');
   // вырожденная фигура не сохраняется
   c._decorDraft = { kind: 'line', a: [g, g], b: [g, g], pid: 1 };
   c._decorCommitDraft();

demo/smoke_general_settings.mjs

@@ -28,8 +28,8 @@ const res = await page.evaluate(async () => {
 });
 // значения зафиксированы прогоном на v1.43.1 и сверены с кодом (audit T1)
 checkAll(res, {
-  "rows": 11,
-  "groups": ["Fill: lights", "Fill: temperature", "Fill: zigbee signal", "Light-sources fill"],
+  "rows": 12, // 10 цветов + радиус свечения + фон вокруг плана
+  "groups": ["Fill: lights", "Fill: temperature", "Fill: zigbee signal", "Light-sources fill", "Stage background"],
   "saved": {"c": "#ff00ff", "a": 0.5},
   "lqiBefore": 7,
   "lqiAfter": 0,

demo/smoke_icon_scale.mjs

@@ -35,4 +35,60 @@ const out = await page.evaluate(async () => {
   c._cfgEpoch++; c._regSignature = ''; c._maybeRebuildDevices();
   return o;
 });
-await finish(browser, checkAll(out));
+checkAll(out);
+
+// Тот же класс бага для СПУТНИКОВ значка (репорт владельца, 2026-08-01):
+// бейдж значения (display:value) и temp-плашка считались от базового
+// --icon-size и оставались маленькими при size=2. Всё, что визуально
+// принадлежит устройству, обязано расти вместе с --dev-scale.
+const out2 = await page.evaluate(async () => {
+  const o = {};
+  const c = window.__card;
+  const sr = () => c.shadowRoot || c.renderRoot;
+  const devEl = () => {
+    const idx = c._devices.filter((x) => x.space === c._space).findIndex((x) => x.id === 'd_temp');
+    return sr().querySelectorAll('.dev')[idx];
+  };
+  const setMarker = async (extra) => {
+    c._serverCfg.markers = (c._serverCfg.markers || []).filter((m) => m.id !== 'd_temp');
+    c._serverCfg.markers.push({ id: 'd_temp', binding: 'device:d_temp', ...extra });
+    c._cfgEpoch++; c._regSignature = '';
+    c._maybeRebuildDevices(); c.requestUpdate(); await c.updateComplete;
+    await new Promise((r) => setTimeout(r, 80));
+  };
+  const fs = (el) => parseFloat(getComputedStyle(el).fontSize);
+  // базовый --icon-size в px: ширина немасштабированного бейджа минус рамка 1px×2
+  const plain = [...sr().querySelectorAll('.dev')].find(
+    (e) => !e.classList.contains('ghost') && !e.classList.contains('valonly') && !(e.getAttribute('style') || '').includes('--dev-scale'));
+  const iconPx = plain.getBoundingClientRect().width - 2;
+
+  // --- бейдж значения (valonly) ---
+  await setMarker({ display: 'value', size: 1 });
+  const v1 = devEl().getBoundingClientRect();
+  const vf1 = fs(devEl().querySelector('.valtext'));
+  // при size=1 дефолт не изменился: шрифт ровно прежние 0.45 * icon-size
+  o.valDefaultKept = Math.abs(vf1 - iconPx * 0.45) < 0.75;
+  await setMarker({ display: 'value', size: 2 });
+  const v2 = devEl().getBoundingClientRect();
+  const vf2 = fs(devEl().querySelector('.valtext'));
+  o.valFontScales = vf2 / vf1 > 1.8 && vf2 / vf1 < 2.2;
+  o.valPlateScales = (v2.height - 2) / (v1.height - 2) > 1.8 && (v2.height - 2) / (v1.height - 2) < 2.2
+    && v2.width / v1.width > 1.6 && v2.width / v1.width < 2.4;
+
+  // --- temp-плашка (.tval) рядом со значком ---
+  await setMarker({ size: 1 });
+  const t1 = devEl().querySelector('.tval').getBoundingClientRect();
+  const tf1 = fs(devEl().querySelector('.tval'));
+  // дефолт: line-height 0.68 * icon-size + рамка 1px×2
+  o.tvalDefaultKept = Math.abs(t1.height - (iconPx * 0.68 + 2)) < 1;
+  await setMarker({ size: 2 });
+  const t2 = devEl().querySelector('.tval').getBoundingClientRect();
+  const tf2 = fs(devEl().querySelector('.tval'));
+  o.tvalScales = (t2.height - 2) / (t1.height - 2) > 1.8 && (t2.height - 2) / (t1.height - 2) < 2.2
+    && tf2 / tf1 > 1.8 && tf2 / tf1 < 2.2;
+
+  c._serverCfg.markers = c._serverCfg.markers.filter((m) => m.id !== 'd_temp');
+  c._cfgEpoch++; c._regSignature = ''; c._maybeRebuildDevices();
+  return o;
+});
+await finish(browser, checkAll(out2));

demo/smoke_modes.mjs

@@ -13,7 +13,8 @@ const st = () => page.evaluate(() => {
     editBtns: sr.querySelectorAll('.head .btn:not(.zb)').length,
     gears: sr.querySelectorAll('.tabedit').length,
     markupBar: !!sr.querySelector('.editbar'),
-    stageClass: sr.querySelector('.stage').className,
+    // hpsettle is the transient post-boot grace (AUD-1552-02), not a mode class
+    stageClass: sr.querySelector('.stage').className.replace(/ ?\bhpsettle\b/, ''),
   };
 });
 // 1) старт: view, чистая шапка

demo/smoke_motion_sense.mjs

@@ -0,0 +1,122 @@
+// Правило владельца (2026-08-01, вариант «б»): «движение = разовая вспышка
+// в момент обнаружения; cool-down не пульсирует; присутствие = статичное
+// кольцо пока обитаемо». Датчик ДВИЖЕНИЯ (device_class motion) при переходе
+// off→on получает класс 'senseflash' — короткая вспышка кольца (hp-sense,
+// 3 удара, ~3.3 c), после чего класс снимается, ДАЖЕ если сущность всё ещё
+// висит в on (это cool-down датчика, а не движение). Новый цикл off→on —
+// новая вспышка. Датчики ПРИСУТСТВИЯ (occupancy/presence) при on несут
+// 'sensehold' — статичное жёлтое кольцо без анимации (opacity 0.4). Жёлтая
+// заливка .dev.on в обоих случаях не участвует; ghost — без кольца
+// (призрак — конфигурация, не статус).
+import { launch, checkAll, finish } from './serve.mjs';
+const { page, browser } = await launch();
+const res = await page.evaluate(async () => {
+  const out = {};
+  const c = window.__card;
+  const sr = () => c.shadowRoot || c.renderRoot;
+  const setMotion = async (state, device_class) => {
+    c.hass = { ...c.hass, states: { ...c.hass.states,
+      'binary_sensor.hall_motion': { entity_id: 'binary_sensor.hall_motion', state,
+        attributes: { friendly_name: 'Motion', device_class, linkquality: 64 } } } };
+    await c.updateComplete;
+  };
+  const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+  // --- motion off→on: вспышка senseflash, 3 удара, подложка НЕ жёлтая -----
+  await setMotion('off', 'motion');
+  out.offNoFlash = sr().querySelectorAll('.dev.senseflash, .dev.sensehold').length === 0;
+  await setMotion('on', 'motion');
+  const flashEl = sr().querySelector('.dev.senseflash');
+  out.motionTripFlashes = !!flashEl;
+  out.flashIsNotOn = !!flashEl && !flashEl.classList.contains('on') && !flashEl.classList.contains('open');
+  const after = flashEl ? getComputedStyle(flashEl, '::after') : null;
+  out.flashAnimated = !!after && after.animationName === 'hp-sense';
+  out.flashFinite = !!after && after.animationIterationCount === '3'; // не infinite!
+  // подложка нейтральная — как у обычного .dev, не как у .dev.on
+  const neutral = [...sr().querySelectorAll('.dev')].find((e) =>
+    !e.classList.contains('senseflash') && !e.classList.contains('sensehold')
+    && !e.classList.contains('on') && !e.classList.contains('open')
+    && !e.classList.contains('alarm') && !e.classList.contains('unavail') && !e.classList.contains('valonly'));
+  const bg = flashEl ? getComputedStyle(flashEl).backgroundColor : '';
+  out.flashBgNeutral = !!neutral && bg === getComputedStyle(neutral).backgroundColor;
+  out.flashBgNotYellow = bg !== '' && bg !== 'rgb(255, 212, 92)'; // --hp-on
+
+  // --- КЛЮЧЕВОЙ ассерт: вспышка гаснет, хотя state всё ещё on -------------
+  // (cool-down датчика — не движение: класс обязан уйти сам по таймеру)
+  await sleep(3600);
+  await c.updateComplete;
+  out.stateStillOn = c.hass.states['binary_sensor.hall_motion'].state === 'on';
+  out.flashEndsWhileOn = sr().querySelectorAll('.dev.senseflash').length === 0;
+
+  // --- повторный цикл off→on: новая вспышка --------------------------------
+  await setMotion('off', 'motion');
+  await setMotion('on', 'motion');
+  out.retripFlashesAgain = sr().querySelectorAll('.dev.senseflash').length === 1;
+
+  // --- HP-1543-02: быстрый повторный off→on ДО конца текущей вспышки ------
+  // обязан ПЕРЕЗАПУСТИТЬ анимацию (новый timeline). Раньше класс senseflash
+  // не снимался и animation-name не менялся — браузер продолжал старый
+  // timeline, и после его конца (base opacity 0) второй trip был невидим.
+  await sleep(3600); await c.updateComplete;   // дать текущей вспышке догореть
+  const senseAnim = (el) => el && el.getAnimations({ subtree: true })
+    .find((a) => a.animationName && a.animationName.startsWith('hp-sense'));
+  await setMotion('off', 'motion');
+  await setMotion('on', 'motion');             // trip №1
+  out.rapidFirstTripFlashes = sr().querySelectorAll('.dev.senseflash').length === 1;
+  await sleep(1200);                           // середина первой вспышки (< 3.3s)
+  const a1 = senseAnim(sr().querySelector('.dev.senseflash'));
+  out.rapidFirstAnimMidway = !!a1 && a1.currentTime > 900 && a1.currentTime < 3300;
+  await setMotion('off', 'motion');
+  await setMotion('on', 'motion');             // trip №2 — retrip до конца вспышки
+  out.rapidRetripKeepsFlash = sr().querySelectorAll('.dev.senseflash').length === 1;
+  const a2 = senseAnim(sr().querySelector('.dev.senseflash'));
+  // новый timeline: currentTime у начала (старый уже был ~1.2s и продолжал бы расти)
+  out.rapidRetripRestartsAnim = !!a2 && a2.currentTime != null && a2.currentTime < 300;
+  // кольцо реально играет ПОСЛЕ момента, где закончилась бы первая анимация:
+  // ~2.3s после trip №2 = ~3.5s после trip №1 (старый timeline уже отыграл бы)
+  await sleep(2300);
+  const el3 = sr().querySelector('.dev.senseflash');
+  const a3 = senseAnim(el3);
+  out.rapidSecondFlashStillPlays = !!a3 && a3.playState === 'running';
+  out.rapidRingVisibleAfterFirstWindow = !!el3
+    && parseFloat(getComputedStyle(el3, '::after').opacity) > 0.03;
+  // и класс уходит через полные ~3.3s после ВТОРОГО trip (flashTs/таймер обновлены)
+  await sleep(1400); await c.updateComplete;
+  out.rapidFlashEndsAfterSecondWindow = sr().querySelectorAll('.dev.senseflash').length === 0;
+
+  // --- occupancy: статичное кольцо sensehold, без анимации ----------------
+  await setMotion('on', 'occupancy');
+  const holdEl = sr().querySelector('.dev.sensehold');
+  out.occupancyHolds = !!holdEl;
+  const hAfter = holdEl ? getComputedStyle(holdEl, '::after') : null;
+  out.holdNotAnimated = !!hAfter && hAfter.animationName === 'none';
+  out.holdRingFaint = !!hAfter && Math.abs(parseFloat(hAfter.opacity) - 0.4) < 0.01;
+  out.holdBgNeutral = !!holdEl && !!neutral
+    && getComputedStyle(holdEl).backgroundColor === getComputedStyle(neutral).backgroundColor;
+  out.holdNoFlashClass = !!holdEl && !holdEl.classList.contains('senseflash');
+  await setMotion('off', 'occupancy');
+  out.occupancyOffClears = sr().querySelectorAll('.dev.sensehold').length === 0;
+
+  // --- presence аналогично -------------------------------------------------
+  await setMotion('on', 'presence');
+  out.presenceHolds = sr().querySelectorAll('.dev.sensehold').length === 1;
+  // и это именно sense-состояние, не тревога и не «открыто»
+  out.noAlarmNoOpen = !sr().querySelector('.dev.sensehold.alarm') && !sr().querySelector('.dev.sensehold.open');
+
+  // --- ghost не рисует ничего (призрак — конфигурация, не статус) ---------
+  await setMotion('off', 'motion');
+  await setMotion('on', 'motion');
+  const d = c._devices.find((x) => x.entities.includes('binary_sensor.hall_motion'));
+  c._serverCfg.markers = c._serverCfg.markers || [];
+  c._serverCfg.markers.push({ id: d.id, binding: 'device:' + d.bindingRef, hidden: true });
+  c._cfgEpoch++; c._regSignature = '';
+  c._maybeRebuildDevices(); c.requestUpdate(); await c.updateComplete;
+  out.hiddenNotInView = sr().querySelectorAll('.dev.senseflash, .dev.sensehold').length === 0;
+  c._showHidden = true; c._setMode('devices'); c.requestUpdate(); await c.updateComplete;
+  const ghost = sr().querySelector('.dev.ghost');
+  out.ghostNoSense = !!ghost && !ghost.classList.contains('senseflash') && !ghost.classList.contains('sensehold')
+    && getComputedStyle(ghost, '::after').animationName !== 'hp-sense';
+  return out;
+});
+checkAll(res, {});
+await finish(browser, res);

demo/smoke_preloader.mjs

@@ -0,0 +1,144 @@
+// HP-1552: residual jump on first open in NORMAL (non-kiosk) mode. The stage is
+// calc(100dvh - _hdrH) and _hdrH is measured from HA's chrome, which loads
+// AFTER the card's first paint — so the plan painted, then jumped when the
+// panels landed. The fix hides the plan behind a boot veil (pulsing house)
+// until the height reads the same twice in a row (or ~600 ms). This smoke
+// simulates the late HA panel: a spacer above the card grows 0 → 56 px at
+// t=300 ms. Assertions: the veil is shown, and there is NOT A SINGLE frame
+// where the plan is visible at a non-final stage height. Kiosk: no veil ever.
+import { launch, check, finish } from './serve.mjs';
+
+const { page, browser } = await launch({ width: 820, height: 760 });
+
+// ---------- phase 1: normal mode, HA panel lands late ----------
+const res = await page.evaluate(async () => {
+  const out = {};
+  const spacer = document.createElement('div');
+  spacer.style.cssText = 'height:0px';
+  const c = document.createElement('houseplan-card');
+  c.setConfig({ type: 'custom:houseplan-card' });
+  c.hass = window.__card.hass;
+  const wrap = document.createElement('div');
+  wrap.style.cssText = 'position:fixed;left:0;top:0;width:800px;z-index:99;background:#000';
+  wrap.append(spacer, c);
+  document.body.appendChild(wrap);
+
+  const frames = [];
+  const sr = () => c.shadowRoot || c.renderRoot;
+  const t0 = performance.now();
+  let grown = false;
+  await new Promise((done) => {
+    const sample = () => {
+      const t = performance.now() - t0;
+      if (!grown && t >= 300) {
+        grown = true; // the "HA panel" arrives: everything above the card grows
+        spacer.style.height = '56px';
+        window.dispatchEvent(new Event('resize'));
+      }
+      const stage = sr().querySelector('.stage');
+      if (stage) {
+        const veil = sr().querySelector('.bootveil');
+        const wrapEl = stage.querySelector(':scope > .zoomwrap');
+        const planHidden =
+          !wrapEl ||
+          getComputedStyle(wrapEl).visibility === 'hidden' ||
+          (veil && !veil.classList.contains('off') && getComputedStyle(veil).opacity !== '0');
+        frames.push({
+          t: Math.round(t),
+          planVisible: !planHidden,
+          veil: !!veil,
+          veilBg: veil ? getComputedStyle(veil).backgroundColor : null,
+          house: !!(veil && veil.querySelector('.boothouse path')),
+          stageH: stage.clientHeight,
+        });
+      } else {
+        frames.push(null);
+      }
+      if (t < 1400) requestAnimationFrame(sample);
+      else done();
+    };
+    requestAnimationFrame(sample);
+  });
+
+  const seen = frames.filter(Boolean);
+  const finalH = seen[seen.length - 1].stageH;
+  out.sampledFrames = seen.length > 40;
+  out.veilShownWhileSettling = seen.some((f) => f.veil && !f.planVisible && f.house);
+  out.veilIsDark = (() => {
+    const f = seen.find((x) => x.veilBg);
+    const m = f && f.veilBg.match(/(\d+),\s*(\d+),\s*(\d+)/);
+    return !!m && +m[1] + +m[2] + +m[3] < 300; // dark, not white/transparent
+  })();
+  // THE assertion: no frame may show the plan at a stale (pre-panel) height
+  const bad = seen.filter((f) => f.planVisible && Math.abs(f.stageH - finalH) > 2);
+  out.noVisibleFrameAtStaleHeight = bad.length === 0
+    ? true
+    : `plan visible at h=${bad[0].stageH} (final ${finalH}) at t=${bad[0].t}ms — the jump is visible`;
+  const shown = seen.filter((f) => f.planVisible);
+  out.planShownAfterSettle = shown.length >= 5 && Math.abs(shown[0].stageH - finalH) <= 2;
+  out.veilGoneInTheEnd = !seen[seen.length - 1].veil;
+  out.heightReactedToPanel = finalH !== seen[0].stageH; // the simulated panel actually moved the stage
+  wrap.remove();
+  return out;
+});
+for (const [k, v] of Object.entries(res)) check(k, v);
+
+// ---------- phase 2: kiosk never shows the veil ----------
+const kiosk = await page.evaluate(async () => {
+  const out = {};
+  const c = document.createElement('houseplan-card');
+  c.setConfig({ type: 'custom:houseplan-card', kiosk: true, cycle: 0 });
+  c.hass = window.__card.hass;
+  c.style.cssText = 'position:fixed;left:0;top:0;width:800px;height:700px;z-index:99';
+  document.body.appendChild(c);
+  const sr = () => c.shadowRoot || c.renderRoot;
+  let veilEver = false;
+  let planHiddenEver = false;
+  const t0 = performance.now();
+  await new Promise((done) => {
+    const sample = () => {
+      const stage = sr().querySelector('.stage');
+      if (stage) {
+        if (sr().querySelector('.bootveil')) veilEver = true;
+        const wrapEl = stage.querySelector(':scope > .zoomwrap');
+        if (wrapEl && getComputedStyle(wrapEl).visibility === 'hidden') planHiddenEver = true;
+      }
+      if (performance.now() - t0 < 900) requestAnimationFrame(sample);
+      else done();
+    };
+    requestAnimationFrame(sample);
+  });
+  out.kioskNoVeil = !veilEver;
+  out.kioskPlanNeverHidden = !planHiddenEver;
+  c.remove();
+  return out;
+});
+check('kioskNoVeil', kiosk.kioskNoVeil);
+check('kioskPlanNeverHidden', kiosk.kioskPlanNeverHidden);
+
+// ---------- phase 3: prefers-reduced-motion → the house does not pulse ----------
+await page.emulateMedia({ reducedMotion: 'reduce' });
+const reduced = await page.evaluate(async () => {
+  const c = document.createElement('houseplan-card');
+  c.setConfig({ type: 'custom:houseplan-card' });
+  c.hass = window.__card.hass;
+  c.style.cssText = 'position:fixed;left:0;top:0;width:800px;z-index:99';
+  document.body.appendChild(c);
+  const sr = () => c.shadowRoot || c.renderRoot;
+  const t0 = performance.now();
+  let anim = 'missed';
+  await new Promise((done) => {
+    const tick = () => {
+      const house = sr().querySelector('.bootveil .boothouse');
+      if (house) { anim = getComputedStyle(house).animationName; done(); return; }
+      if (performance.now() - t0 < 500) requestAnimationFrame(tick);
+      else done();
+    };
+    requestAnimationFrame(tick);
+  });
+  c.remove();
+  return { anim };
+});
+check('reducedMotionStaticHouse', reduced.anim, 'none');
+
+await finish(browser, { ...res, ...kiosk, ...reduced });

demo/smoke_preloader_lifecycle.mjs

@@ -0,0 +1,180 @@
+// AUD-1552-01 + AUD-1552-02: adversarial lifecycle regressions for the
+// first-open boot veil (HP-1552). Both scenarios FAIL on v1.55.2.
+//
+// A. disconnect/reconnect while booting (Lovelace rebuilds its DOM, a view
+//    switch remounts the card). v1.55.2 cleared the boot timer on disconnect
+//    but kept its truthy id, so the reconnect never restarted the watcher and
+//    the plan stayed hidden FOREVER. Now the veil lifecycle restarts from
+//    connectedCallback: the veil must lift no later than the hard cap.
+// B. layout shifts before, between and after the old poll ticks (150, 300,
+//    450, 590 ms). v1.55.2 revealed the plan after two equal reads at
+//    200/400 ms, so a panel landing at 450+ ms jumped on a VISIBLE plan. Now
+//    the veil holds for the full protective window with trailing quiescence:
+//    not a single frame may show the plan at a non-final stage height.
+// C. a shift AFTER the reveal (slower than the cap) must glide, not snap:
+//    for a short grace the stage height transitions and the plan refits
+//    along with it (no transition at all on v1.55.2 — instant jump).
+import { launch, check, finish } from './serve.mjs';
+
+const { page, browser } = await launch({ width: 820, height: 760 });
+
+// ---------- A: detach before the first tick, reattach, veil must lift ----------
+const rec = await page.evaluate(async () => {
+  const out = {};
+  const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+  const c = document.createElement('houseplan-card');
+  c.setConfig({ type: 'custom:houseplan-card' });
+  c.hass = window.__card.hass;
+  const wrap = document.createElement('div');
+  wrap.style.cssText = 'position:fixed;left:0;top:0;width:800px;z-index:99;background:#000';
+  wrap.appendChild(c);
+  document.body.appendChild(wrap);
+  await sleep(50); // the first boot tick has not fired yet
+  out.bootingWhenDetached = c._booting === true;
+  c.remove(); // disconnect: timers die here
+  await sleep(30);
+  wrap.appendChild(c); // reconnect — the veil lifecycle must restart
+  const t0 = performance.now();
+  const sr = () => c.shadowRoot || c.renderRoot;
+  while (c._booting && performance.now() - t0 < 2000) await sleep(50);
+  out.revealMs = Math.round(performance.now() - t0);
+  out.bootSettledAfterReconnect = c._booting === false;
+  out.settledWithinCap = performance.now() - t0 < 1500; // hard cap 1200 + slack
+  await sleep(300); // let the fade finish
+  const stage = sr().querySelector('.stage');
+  const wrapEl = stage && stage.querySelector(':scope > .zoomwrap');
+  out.planVisibleAfterReconnect = !!wrapEl && getComputedStyle(wrapEl).visibility === 'visible';
+  out.noHpbootClass = !!stage && !stage.classList.contains('hpboot');
+  out.veilGone = !sr().querySelector('.bootveil');
+
+  // A2: a second detach DURING the fade must not leave a zombie veil either
+  const c2 = document.createElement('houseplan-card');
+  c2.setConfig({ type: 'custom:houseplan-card' });
+  c2.hass = window.__card.hass;
+  wrap.appendChild(c2);
+  const t1 = performance.now();
+  while (c2._booting && performance.now() - t1 < 2000) await sleep(50);
+  // _bootFading is true for ~220 ms after the reveal — detach right inside it
+  c2.remove();
+  await sleep(30);
+  wrap.appendChild(c2);
+  await sleep(400);
+  const sr2 = c2.shadowRoot || c2.renderRoot;
+  out.fadeVeilGoneAfterReattach = !sr2.querySelector('.bootveil') && c2._bootFading === false;
+  wrap.remove();
+  return out;
+});
+for (const [k, v] of Object.entries(rec)) check(k, v, k === 'revealMs' ? rec.revealMs : true);
+
+// ---------- B: shifts at 150/300/450/590 ms — never a visible stale frame ----------
+const shifts = [150, 300, 450, 590];
+const outB = {};
+for (const shiftMs of shifts) {
+  const res = await page.evaluate(async (shiftAt) => {
+    const out = {};
+    const spacer = document.createElement('div');
+    spacer.style.cssText = 'height:0px';
+    const c = document.createElement('houseplan-card');
+    c.setConfig({ type: 'custom:houseplan-card' });
+    c.hass = window.__card.hass;
+    const wrap = document.createElement('div');
+    wrap.style.cssText = 'position:fixed;left:0;top:0;width:800px;z-index:99;background:#000';
+    wrap.append(spacer, c);
+    document.body.appendChild(wrap);
+    const frames = [];
+    const sr = () => c.shadowRoot || c.renderRoot;
+    const t0 = performance.now();
+    let grown = false;
+    await new Promise((done) => {
+      const sample = () => {
+        const t = performance.now() - t0;
+        if (!grown && t >= shiftAt) {
+          grown = true; // the "HA panel" arrives
+          spacer.style.height = '56px';
+          window.dispatchEvent(new Event('resize'));
+        }
+        const stage = sr().querySelector('.stage');
+        if (stage) {
+          const veil = sr().querySelector('.bootveil');
+          const wrapEl = stage.querySelector(':scope > .zoomwrap');
+          const planHidden =
+            !wrapEl ||
+            getComputedStyle(wrapEl).visibility === 'hidden' ||
+            (veil && !veil.classList.contains('off') && getComputedStyle(veil).opacity !== '0');
+          frames.push({ t: Math.round(t), planVisible: !planHidden, stageH: stage.clientHeight });
+        }
+        if (t < 1900) requestAnimationFrame(sample);
+        else done();
+      };
+      requestAnimationFrame(sample);
+    });
+    const seen = frames;
+    const finalH = seen[seen.length - 1].stageH;
+    // THE assertion: no frame may show the plan at a stale (pre-panel) height
+    const bad = seen.filter((f) => f.planVisible && Math.abs(f.stageH - finalH) > 2);
+    out.noStaleFrame = bad.length === 0
+      ? true
+      : `plan visible at h=${bad[0].stageH} (final ${finalH}) at t=${bad[0].t}ms`;
+    const shown = seen.filter((f) => f.planVisible);
+    out.planShown = shown.length >= 5 && Math.abs(shown[0].stageH - finalH) <= 2;
+    out.heightReacted = finalH !== seen[0].stageH;
+    wrap.remove();
+    return out;
+  }, shiftMs);
+  outB[`shift${shiftMs}_noStaleFrame`] = res.noStaleFrame;
+  outB[`shift${shiftMs}_planShown`] = res.planShown;
+  outB[`shift${shiftMs}_heightReacted`] = res.heightReacted;
+  check(`shift${shiftMs}_noStaleFrame`, res.noStaleFrame);
+  check(`shift${shiftMs}_planShown`, res.planShown);
+  check(`shift${shiftMs}_heightReacted`, res.heightReacted);
+}
+
+// ---------- C: shift AFTER the reveal glides instead of snapping ----------
+const late = await page.evaluate(async () => {
+  const out = {};
+  const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+  const spacer = document.createElement('div');
+  spacer.style.cssText = 'height:0px';
+  const c = document.createElement('houseplan-card');
+  c.setConfig({ type: 'custom:houseplan-card' });
+  c.hass = window.__card.hass;
+  const wrap = document.createElement('div');
+  wrap.style.cssText = 'position:fixed;left:0;top:0;width:800px;z-index:99;background:#000';
+  wrap.append(spacer, c);
+  document.body.appendChild(wrap);
+  const sr = () => c.shadowRoot || c.renderRoot;
+  const t0 = performance.now();
+  while (c._booting && performance.now() - t0 < 2500) await sleep(25);
+  out.revealed = c._booting === false;
+  await sleep(120); // clearly after the reveal, still inside the soft grace
+  const stage = sr().querySelector('.stage');
+  const h0 = stage.clientHeight;
+  spacer.style.height = '56px'; // VERY late panel — slower than the cap
+  window.dispatchEvent(new Event('resize'));
+  const heights = [];
+  await new Promise((done) => {
+    const t1 = performance.now();
+    const sample = () => {
+      heights.push(stage.clientHeight);
+      if (performance.now() - t1 < 700) requestAnimationFrame(sample);
+      else done();
+    };
+    requestAnimationFrame(sample);
+  });
+  const hEnd = heights[heights.length - 1];
+  out.heightMoved = Math.abs(hEnd - h0) > 30;
+  // the glide: intermediate frames strictly between the endpoints
+  const mid = heights.filter((h) => Math.abs(h - h0) > 4 && Math.abs(h - hEnd) > 4);
+  out.lateShiftGlides = mid.length >= 3
+    ? true
+    : `only ${mid.length} intermediate frame(s): ${h0} -> ${hEnd} snapped`;
+  out.settledAtFinal = Math.abs(hEnd - (h0 - 56)) <= 2;
+  wrap.remove();
+  return out;
+});
+check('late_revealed', late.revealed);
+check('late_heightMoved', late.heightMoved);
+check('late_lateShiftGlides', late.lateShiftGlides);
+check('late_settledAtFinal', late.settledAtFinal);
+
+await finish(browser, { ...rec, ...outB, ...late });

demo/smoke_resize_audit_1550.mjs

@@ -0,0 +1,210 @@
+// The v1.55.0 resize audit (HP-1550-01/-03/-04), numeric regressions:
+//   01 — a debounced config write pending from a PREVIOUS edit must never carry
+//        the live resize preview to the server; Esc leaves server === snapshot;
+//        a normal pointerup produces exactly one write;
+//   03 — pointercancel aborts the drag (no commit, no undo step, no write),
+//        for wall handles and corner handles alike; lostpointercapture after
+//        a cancel must not double-fire;
+//   04 — a door at the exact midpoint of a wall must not shadow the resize
+//        handle: the handle wins the hit test, the wall drags WITH the door,
+//        and no opening-edit drag starts in the resize tool.
+import { launch, check, finish } from './serve.mjs';
+const { page, browser } = await launch();
+
+const snap = await page.evaluate(() => JSON.stringify(window.__card._serverCfg));
+const restore = () => page.evaluate((s) => {
+  const c = window.__card;
+  c._serverCfg = JSON.parse(s);
+  c._rszSel = null; c._rszDrag = null; c._rszLive = null; c._rszUndo = [];
+  if ('_rszPreview' in c) c._rszPreview = null;
+  c._cfgEpoch++; c.requestUpdate();
+  return c.updateComplete && true;
+}, snap);
+const enter = (tool) => page.evaluate((t) => {
+  const c = window.__card;
+  if (!c._markup) c._setMode('plan');
+  c._tool = t; c._rszSel = null; c.requestUpdate();
+  return c.updateComplete && true;
+}, tool);
+const settle = () => page.evaluate(() => new Promise((res) => requestAnimationFrame(() => requestAnimationFrame(res))));
+const screenPt = (x, y) => page.evaluate(([x, y]) => {
+  const c = window.__card;
+  const stage = c.renderRoot.querySelector('.stage');
+  const r = stage.getBoundingClientRect();
+  const svg = stage.querySelector('svg');
+  const [vx, vy, vw, vh] = svg.getAttribute('viewBox').split(' ').map(Number);
+  return [r.left + ((x - vx) / vw) * r.width, r.top + ((y - vy) / vh) * r.height];
+}, [x, y]);
+// geometry the SERVER would get (the mutable config _writeConfig reads)
+const roomSrv = (id) => page.evaluate((id) => {
+  const r = window.__card._serverCfg.spaces.find((s) => s.id === 'f1').rooms.find((x) => x.id === id);
+  return r?.poly ? r.poly.map((p) => [p[0], p[1]]) : null;
+}, id);
+// geometry AS RENDERED (includes the live preview overlay when a drag is on)
+const roomLive = (id) => page.evaluate((id) => {
+  const r = window.__card._curSpaceCfg.rooms.find((x) => x.id === id);
+  return r?.poly ? r.poly.map((p) => [p[0], p[1]]) : null;
+}, id);
+
+// spy on every config write with a deep copy taken AT CALL TIME — exactly what
+// the backend would persist (a later fix of the mutable object must not hide it)
+await page.evaluate(() => {
+  const c = window.__card;
+  window.__writes = [];
+  const orig = c.hass.callWS.bind(c.hass);
+  c.hass = { ...c.hass, callWS: async (m) => {
+    if (m.type === 'houseplan/config/set') window.__writes.push(JSON.parse(JSON.stringify(m.config)));
+    return orig(m);
+  } };
+  return c.updateComplete && true;
+});
+const writes = () => page.evaluate(() => window.__writes.length);
+const writeWallAt = (i, x) => page.evaluate(([i, x]) => {
+  const w = window.__writes[i];
+  const r1 = w.spaces.find((s) => s.id === 'f1').rooms.find((r) => r.id === 'r1');
+  return r1.poly.some((p) => Math.abs(p[0] - x) < 0.011);
+}, [i, x]);
+
+// ================= HP-1550-01: pending write vs live preview =================
+await enter('resize');
+await settle();
+// precompute every screen point so drag 2 starts well inside the 500 ms window
+const [h550x, h550y] = await screenPt(550, 360);
+const [h600x] = await screenPt(600, 360);
+const [h650x] = await screenPt(650, 360);
+const [h700x] = await screenPt(700, 360);
+// drag 1 commits r1's right wall 0.55 → 0.60: a write enters the debounce queue
+await page.mouse.move(h550x, h550y);
+await page.mouse.down();
+await page.mouse.move(h600x, h550y, { steps: 3 });
+await page.mouse.up();
+// drag 2 starts IMMEDIATELY (pending save still queued): preview 0.60 → 0.70, HOLD
+await page.mouse.move(h600x, h550y);
+await page.mouse.down();
+await page.mouse.move(h700x, h550y, { steps: 3 });
+await settle();
+check('01_committed_wall', Math.abs((await roomSrv('r1'))[1][0] - 0.60) < 0.011);
+check('01_preview_live', Math.abs((await roomLive('r1'))[1][0] - 0.70) < 0.011);
+// … the queued write fires while the handle is still held (>500 ms)
+await page.waitForTimeout(800);
+check('01_pending_write_fired', (await writes()) >= 1);
+// Esc abandons the drag
+await page.keyboard.press('Escape');
+await settle();
+await page.mouse.up();
+await page.waitForTimeout(800); // any stray debounced write would have fired
+const nw = await writes();
+for (let i = 0; i < nw; i++) {
+  check(`01_write_${i}_no_preview_coords`, await writeWallAt(i, 0.70), false);
+  check(`01_write_${i}_has_committed`, await writeWallAt(i, 0.60), true);
+}
+check('01_server_geom_is_snapshot', Math.abs((await roomSrv('r1'))[1][0] - 0.60) < 1e-6);
+check('01_local_geom_is_snapshot', Math.abs((await roomLive('r1'))[1][0] - 0.60) < 1e-6);
+// a normal pointerup still produces EXACTLY ONE write
+{
+  const before = await writes();
+  await page.mouse.move(h600x, h550y);
+  await page.mouse.down();
+  await page.mouse.move(h650x, h550y, { steps: 3 });
+  await settle();
+  await page.mouse.up();
+  await page.waitForTimeout(800);
+  check('01_single_write_per_commit', (await writes()) - before, 1);
+  check('01_commit_reached_server', Math.abs((await roomSrv('r1'))[1][0] - 0.65) < 0.011);
+}
+await restore();
+
+// ================= HP-1550-03: pointercancel = abort, not commit =============
+await enter('resize');
+await settle();
+{
+  const w0 = await writes();
+  const [ax, ay] = await screenPt(550, 360);
+  const [bx] = await screenPt(650, 360);
+  await page.mouse.move(ax, ay);
+  await page.mouse.down();
+  await page.mouse.move(bx, ay, { steps: 3 });
+  await settle();
+  check('03_preview_moved', Math.abs((await roomLive('r1'))[1][0] - 0.65) < 0.011);
+  // the system interrupts the stream (app switch, palm rejection)
+  await page.evaluate(() => {
+    const c = window.__card;
+    const pid = c._rszDrag.pid;
+    const el = c.renderRoot.querySelector('.rszhandle');
+    el.dispatchEvent(new PointerEvent('pointercancel', { pointerId: pid, bubbles: true }));
+    // the lostpointercapture that follows a cancel must not double-fire
+    el.dispatchEvent(new PointerEvent('lostpointercapture', { pointerId: pid, bubbles: true }));
+  });
+  await settle();
+  check('03_snapshot_back_live', Math.abs((await roomLive('r1'))[1][0] - 0.55) < 1e-6);
+  check('03_server_untouched', Math.abs((await roomSrv('r1'))[1][0] - 0.55) < 1e-6);
+  check('03_undo_empty', await page.evaluate(() => window.__card._rszUndo.length), 0);
+  check('03_drag_cleared', await page.evaluate(() => window.__card._rszDrag === null));
+  await page.waitForTimeout(800);
+  check('03_no_pending_write', (await writes()) - w0, 0);
+  await page.mouse.up();
+}
+await restore();
+// the corner (scale) handle takes the same abort path
+await enter('resize');
+await page.evaluate(() => { const c = window.__card; c._rszSel = 'r4'; c.requestUpdate(); return c.updateComplete && true; });
+await settle();
+{
+  const w0 = await writes();
+  const [ax, ay] = await screenPt(550, 860);
+  const [bx, by] = await screenPt(448, 804); // ≈ k=0.8 about (40,580)
+  await page.mouse.move(ax, ay);
+  await page.mouse.down();
+  await page.mouse.move(bx, by, { steps: 3 });
+  await settle();
+  check('03_corner_preview', Math.abs((await roomLive('r4'))[2][0] - 0.55) > 0.02);
+  await page.evaluate(() => {
+    const c = window.__card;
+    const pid = c._rszDrag.pid;
+    const el = c.renderRoot.querySelector('.rszcorner') || c.renderRoot.querySelector('.rszhandle');
+    el.dispatchEvent(new PointerEvent('pointercancel', { pointerId: pid, bubbles: true }));
+  });
+  await settle();
+  check('03_corner_snapshot_back', Math.abs((await roomLive('r4'))[2][0] - 0.55) < 1e-6);
+  check('03_corner_undo_empty', await page.evaluate(() => window.__card._rszUndo.length), 0);
+  await page.waitForTimeout(800);
+  check('03_corner_no_write', (await writes()) - w0, 0);
+  await page.mouse.up();
+}
+await restore();
+
+// ============ HP-1550-04: a door mid-wall must not shadow the handle =========
+await enter('resize');
+await page.evaluate(() => {
+  const c = window.__card;
+  const sp = c._serverCfg.spaces.find((s) => s.id === 'f1');
+  // exactly at the midpoint of r1's right wall (y 0.14..0.58 → 0.36)
+  sp.openings = [{ id: 'opm', type: 'door', x: 0.55, y: 0.36, angle: 90, length: 0.08 }];
+  c._cfgEpoch++; c.requestUpdate();
+  return c.updateComplete && true;
+});
+await settle();
+{
+  const [hx, hy] = await screenPt(550, 360);
+  const [tx] = await screenPt(650, 360);
+  // the REAL hit test: the topmost interactive element must be the handle
+  const top = await page.evaluate(([x, y]) => {
+    const el = window.__card.shadowRoot.elementFromPoint(x, y);
+    return el ? el.getAttribute('class') || '' : '';
+  }, [hx, hy]);
+  check('04_handle_wins_hit_test', String(top).includes('rszhandle'));
+  await page.mouse.move(hx, hy);
+  await page.mouse.down();
+  await page.mouse.move(tx, hy, { steps: 4 });
+  await settle();
+  check('04_no_opening_drag', await page.evaluate(() => !window.__card._opDrag));
+  check('04_wall_drag_started', await page.evaluate(() => !!window.__card._rszDrag));
+  await page.mouse.up();
+  await settle();
+  check('04_wall_moved', Math.abs((await roomSrv('r1'))[1][0] - 0.65) < 0.011);
+  const op = await page.evaluate(() => window.__card._serverCfg.spaces.find((s) => s.id === 'f1').openings[0]);
+  check('04_door_travelled_with_wall', Math.abs(op.x - 0.65) < 0.011);
+}
+await restore();
+
+await finish(browser, { done: true });

demo/smoke_room_resize.mjs

@@ -0,0 +1,249 @@
+// Room resize tool (docs/RESIZE.md): wall drag with shared walls (T-junction),
+// live badges, stops (neighbour min size, opening anchor), the corner scale
+// frame, Esc-cancel and one-step undo. Vertex positions are checked NUMERICALLY.
+import { launch, check, finish } from './serve.mjs';
+const { page, browser } = await launch();
+
+const snap = await page.evaluate(() => JSON.stringify(window.__card._serverCfg));
+const restore = () => page.evaluate((s) => {
+  const c = window.__card;
+  c._serverCfg = JSON.parse(s);
+  c._rszSel = null; c._rszDrag = null; c._rszLive = null; c._rszUndo = []; c._rszPreview = null;
+  c._cfgEpoch++; c.requestUpdate();
+  return c.updateComplete && true;
+}, snap);
+
+const enter = (tool) => page.evaluate((t) => {
+  const c = window.__card;
+  if (!c._markup) c._setMode('plan');
+  c._tool = t; c._rszSel = null; c.requestUpdate();
+  return c.updateComplete && true;
+}, tool);
+
+const handleCount = () => page.evaluate(() => window.__card.renderRoot.querySelectorAll('.rszhandle').length);
+const roomPolyN = (id) => page.evaluate((id) => {
+  const r = window.__card._serverCfg.spaces.find((s) => s.id === 'f1').rooms.find((x) => x.id === id);
+  return r?.poly ? r.poly.map((p) => [p[0], p[1]]) : null;
+}, id);
+// mid-drag geometry AS RENDERED: HP-1550-01 moved the live preview out of
+// _serverCfg into the _rszPreview overlay (_curSpaceCfg serves it to renders)
+const roomPolyLive = (id) => page.evaluate((id) => {
+  const r = window.__card._curSpaceCfg.rooms.find((x) => x.id === id);
+  return r?.poly ? r.poly.map((p) => [p[0], p[1]]) : null;
+}, id);
+const openingOf = (id) => page.evaluate((id) =>
+  (window.__card._serverCfg.spaces.find((s) => s.id === 'f1').openings || []).find((o) => o.id === id) || null, id);
+// screen position of a render-unit point (the svg viewBox fills the stage exactly)
+const screenPt = (x, y) => page.evaluate(([x, y]) => {
+  const c = window.__card;
+  const stage = c.renderRoot.querySelector('.stage');
+  const r = stage.getBoundingClientRect();
+  const svg = stage.querySelector('svg');
+  const [vx, vy, vw, vh] = svg.getAttribute('viewBox').split(' ').map(Number);
+  return [r.left + ((x - vx) / vw) * r.width, r.top + ((y - vy) / vh) * r.height];
+}, [x, y]);
+const settle = () => page.evaluate(() => new Promise((res) => requestAnimationFrame(() => requestAnimationFrame(res))));
+const labels = () => page.evaluate(() =>
+  [...window.__card.renderRoot.querySelectorAll('.measurelabel')].map((el) => el.textContent.trim()));
+const polyClose = (name, got, want, tol = 1e-4) => {
+  check(name + '.len', got?.length, want.length);
+  if (got?.length !== want.length) return;
+  for (let i = 0; i < want.length; i++) {
+    check(`${name}[${i}]`, Math.hypot(got[i][0] - want[i][0], got[i][1] - want[i][1]) <= tol, true);
+  }
+};
+
+// ---------- no handles outside the resize tool ----------
+await enter('draw');
+check('draw_tool_no_handles', await handleCount(), 0);
+await enter('opening');
+check('opening_tool_no_handles', await handleCount(), 0);
+
+// ---------- handles appear in the resize tool ----------
+await enter('resize');
+await settle();
+check('resize_handles_16', await handleCount(), 16); // 4 rooms × 4 walls
+
+// ---------- wall drag: T-stack r1|r2+r3, opening rides along, live badges ----------
+// opening op2 sits ON the shared wall x=0.55 → it must travel with it
+await page.evaluate(() => {
+  const c = window.__card;
+  const sp = c._serverCfg.spaces.find((s) => s.id === 'f1');
+  sp.openings = [{ id: 'op2', type: 'door', x: 0.55, y: 0.30, angle: 90, length: 0.08 }];
+  c._cfgEpoch++; c.requestUpdate();
+});
+await settle();
+const [hx, hy] = await screenPt(550, 360);           // r1 right-wall handle (mid y of 140..580)
+const [tx] = await screenPt(650, 360);               // +100 render units
+await page.mouse.move(hx, hy);
+await page.mouse.down();
+await page.mouse.move((hx + tx) / 2, hy, { steps: 4 });
+await settle();
+const mid = await labels();
+check('drag_badges_visible', mid.length >= 6);       // 3 wall lengths + 3 areas (r1, r2, r3)
+check('drag_badges_have_area', mid.filter((t) => t.includes('m²')).length >= 3);
+check('drag_badges_have_len', mid.some((t) => /\d\.\d\d m$/.test(t)));
+const midR1 = await roomPolyLive('r1');
+check('preview_moves_r1', Math.abs(midR1[1][0] - 0.6) < 0.011); // halfway ≈ 0.60 (snapped)
+// HP-1550-01: the preview must NOT leak into the config a queued write reads
+const midSrv = await roomPolyN('r1');
+check('preview_not_in_servercfg', Math.abs(midSrv[1][0] - 0.55) < 1e-9);
+await page.mouse.move(tx, hy, { steps: 4 });
+await settle();
+const end = await labels();
+check('drag_badges_change', JSON.stringify(mid) !== JSON.stringify(end));
+check('area_updates_live', mid.find((t) => t.includes('m²')) !== end.find((t) => t.includes('m²')));
+await page.mouse.up();
+await settle();
+// committed geometry: r1 grew, r2 translated, r3 became L-shaped with 6 vertices
+polyClose('r1_after', await roomPolyN('r1'), [[0.04, 0.14], [0.65, 0.14], [0.65, 0.58], [0.04, 0.58]]);
+polyClose('r2_after', await roomPolyN('r2'), [[0.65, 0.14], [0.96, 0.14], [0.96, 0.46], [0.65, 0.46]]);
+polyClose('r3_after', await roomPolyN('r3'),
+  [[0.65, 0.46], [0.96, 0.46], [0.96, 0.86], [0.55, 0.86], [0.55, 0.58], [0.65, 0.58]]);
+const op2 = await openingOf('op2');
+check('opening_travels', Math.abs(op2.x - 0.65) < 1e-4 && Math.abs(op2.y - 0.30) < 1e-6);
+
+// ---------- undo: one release = one step back ----------
+await page.keyboard.press('Control+z');
+await settle();
+polyClose('undo_r1', await roomPolyN('r1'), [[0.04, 0.14], [0.55, 0.14], [0.55, 0.58], [0.04, 0.58]]);
+polyClose('undo_r2', await roomPolyN('r2'), [[0.55, 0.14], [0.96, 0.14], [0.96, 0.46], [0.55, 0.46]]);
+polyClose('undo_r3', await roomPolyN('r3'), [[0.55, 0.46], [0.96, 0.46], [0.96, 0.86], [0.55, 0.86]]);
+const op2b = await openingOf('op2');
+check('undo_opening_back', Math.abs(op2b.x - 0.55) < 1e-9);
+await restore();
+
+// ---------- stop: the shrinking neighbour keeps ~30 cm ----------
+await enter('resize');
+await settle();
+{
+  const [ax, ay] = await screenPt(550, 360);
+  const [bx] = await screenPt(1050, 360); // far past r2/r3 (right walls at 0.96)
+  await page.mouse.move(ax, ay);
+  await page.mouse.down();
+  await page.mouse.move(bx, ay, { steps: 6 });
+  await settle();
+  await page.mouse.up();
+  await settle();
+  const r1 = await roomPolyN('r1');
+  const r2 = await roomPolyN('r2');
+  const width2 = (r2[1][0] - r2[0][0]) * 1000;
+  check('neighbour_min_stop', Math.abs(r1[1][0] - 0.93333) < 0.005); // clamped, NOT 1.05
+  check('neighbour_min_width', width2 >= 25 - 1e-6 && width2 <= 25 + 1000 / 240 + 1e-6);
+}
+await restore();
+
+// ---------- stop: an opening anchors the shortening wall ----------
+await enter('resize');
+await settle();
+{
+  // a door on r1's LEFT wall (x=0.04), spans y 0.16..0.24. Dragging r1's TOP
+  // wall down shortens that wall from above — it must stop at the door edge.
+  // (No collinear neighbour wall can adopt this door — a real «упор».)
+  await page.evaluate(() => {
+    const c = window.__card;
+    const sp = c._serverCfg.spaces.find((s) => s.id === 'f1');
+    sp.openings = [{ id: 'op1', type: 'door', x: 0.04, y: 0.20, angle: 90, length: 0.08 }];
+    c._cfgEpoch++; c.requestUpdate();
+  });
+  await settle();
+  const [ax, ay] = await screenPt(295, 140); // r1 top-wall handle
+  const [, by] = await screenPt(295, 300);   // try to push far past the door top (y=160)
+  await page.mouse.move(ax, ay);
+  await page.mouse.down();
+  await page.mouse.move(ax, by, { steps: 5 });
+  await settle();
+  await page.mouse.up();
+  await settle();
+  const r1 = await roomPolyN('r1');
+  const topY = r1[0][1] * 1000;
+  check('opening_stop', topY <= 160 + 1e-6);                       // never below the door top
+  check('opening_stop_close', topY >= 160 - 1000 / 240 - 1e-6);    // and clamped right at it
+  const op1 = await openingOf('op1');
+  check('anchored_opening_static', Math.abs(op1.y - 0.2) < 1e-9 && Math.abs(op1.x - 0.04) < 1e-9);
+}
+await restore();
+
+// ---------- the scale frame: proportional, neighbours stay, stops work ----------
+await enter('resize');
+await page.evaluate(() => { const c = window.__card; c._rszSel = 'r4'; c.requestUpdate(); return c.updateComplete && true; });
+await settle();
+check('frame_corners', await page.evaluate(() => window.__card.renderRoot.querySelectorAll('.rszcorner').length), 4);
+check('frame_present', await page.evaluate(() => !!window.__card.renderRoot.querySelector('.rszframe')));
+{
+  // shrink about the top-left corner (40,580): drag br (550,860) toward it
+  const [ax, ay] = await screenPt(550, 860);
+  const [bx, by] = await screenPt(448, 804); // ≈ k=0.8
+  await page.mouse.move(ax, ay);
+  await page.mouse.down();
+  await page.mouse.move(bx, by, { steps: 5 });
+  await settle();
+  await page.mouse.up();
+  await settle();
+  const r4 = await roomPolyN('r4');
+  const base = [[0.04, 0.58], [0.55, 0.58], [0.55, 0.86], [0.04, 0.86]];
+  // ALL vertices scale by the SAME factor about the fixed corner (0.04, 0.58)
+  const ks = base.map((b, i) => {
+    const dx = b[0] - 0.04, dy = b[1] - 0.58;
+    if (Math.abs(dx) > 1e-9) return (r4[i][0] - 0.04) / dx;
+    if (Math.abs(dy) > 1e-9) return (r4[i][1] - 0.58) / dy;
+    return null;
+  }).filter((k) => k != null);
+  const kAvg = ks.reduce((a, b) => a + b, 0) / ks.length;
+  check('scale_shrinks', kAvg > 0.7 && kAvg < 0.9);
+  check('scale_proportional', ks.every((k) => Math.abs(k - kAvg) < 1e-3));
+  const ky = base.map((b, i) => (Math.abs(b[1] - 0.58) > 1e-9 ? (r4[i][1] - 0.58) / (b[1] - 0.58) : null)).filter((k) => k != null);
+  check('scale_uniform_xy', ky.every((k) => Math.abs(k - kAvg) < 1e-3));
+  // neighbours did NOT move (scale never drags them — docs/RESIZE.md exception)
+  polyClose('scale_r1_static', await roomPolyN('r1'), [[0.04, 0.14], [0.55, 0.14], [0.55, 0.58], [0.04, 0.58]]);
+  polyClose('scale_r3_static', await roomPolyN('r3'), [[0.55, 0.46], [0.96, 0.46], [0.96, 0.86], [0.55, 0.86]]);
+}
+await restore();
+await enter('resize');
+await page.evaluate(() => { const c = window.__card; c._rszSel = 'r4'; c.requestUpdate(); return c.updateComplete && true; });
+await settle();
+{
+  // growing about the top-left corner immediately runs into r3 → the scale stops at ≈1
+  const [ax, ay] = await screenPt(550, 860);
+  const [bx, by] = await screenPt(805, 1000); // ≈ k=1.5
+  await page.mouse.move(ax, ay);
+  await page.mouse.down();
+  await page.mouse.move(bx, by, { steps: 5 });
+  await settle();
+  await page.mouse.up();
+  await settle();
+  const r4 = await roomPolyN('r4');
+  check('scale_neighbour_stop', Math.abs(r4[1][0] - 0.55) < 0.005 && Math.abs(r4[2][1] - 0.86) < 0.005);
+  polyClose('scale_stop_r3_static', await roomPolyN('r3'), [[0.55, 0.46], [0.96, 0.46], [0.96, 0.86], [0.55, 0.86]]);
+}
+await restore();
+
+// ---------- Esc cancels the current drag ----------
+await enter('resize');
+await settle();
+{
+  const [ax, ay] = await screenPt(550, 360);
+  const [bx] = await screenPt(700, 360);
+  await page.mouse.move(ax, ay);
+  await page.mouse.down();
+  await page.mouse.move(bx, ay, { steps: 4 });
+  await settle();
+  const midPoly = await roomPolyLive('r1');
+  check('esc_preview_moved', Math.abs(midPoly[1][0] - 0.70) < 0.011);
+  await page.keyboard.press('Escape');
+  await settle();
+  polyClose('esc_restores_r1', await roomPolyN('r1'), [[0.04, 0.14], [0.55, 0.14], [0.55, 0.58], [0.04, 0.58]]);
+  polyClose('esc_restores_r2', await roomPolyN('r2'), [[0.55, 0.14], [0.96, 0.14], [0.96, 0.46], [0.55, 0.46]]);
+  check('esc_no_badges', (await labels()).length, 0);
+  await page.mouse.up();
+}
+await restore();
+
+// ---------- leaving the tool removes every handle ----------
+await enter('merge');
+check('merge_tool_no_handles', await handleCount(), 0);
+await page.evaluate(() => { window.__card._setMode('devices'); });
+await settle();
+check('devices_mode_no_handles', await handleCount(), 0);
+
+await finish(browser, { done: true });

demo/smoke_zoom_flash.mjs

@@ -0,0 +1,110 @@
+// HP-1551: opening the card with a saved per-space zoom must NOT paint even a
+// single frame at the default fit ("the plan flashes and re-scales"). Repro of
+// the field report: LS holds the config cache (instant render) and a saved
+// zoom of 1.8, the server config arrives ~350 ms later like a real HA
+// websocket round-trip. Every rAF frame from the first possible moment is
+// sampled: a frame where the stage is visible AND the viewBox is at the
+// default scale is the flash.
+import { launch, check, finish } from './serve.mjs';
+import { readFileSync, existsSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname } from 'node:path';
+
+const ROOT = dirname(fileURLToPath(import.meta.url)) + '/srv';
+const CT = { '.html': 'text/html', '.js': 'text/javascript', '.svg': 'image/svg+xml' };
+const ZOOM = 1.8;
+
+// ---- phase 1: prime the config cache exactly the way production does ------
+const { page, browser } = await launch();
+await page.waitForFunction(() => !!localStorage.getItem('houseplan_card_cfg_v1'), { timeout: 9000 });
+const cfgCache = await page.evaluate(() => localStorage.getItem('houseplan_card_cfg_v1'));
+// default fit width at zoom 1 (clean LS): the yardstick for "default scale"
+const defaultFitW = await page.evaluate(() => window.__card._view.w);
+await page.close();
+
+// ---- phase 2: cold open with a saved zoom and a slow server ----------------
+const ctx = await browser.newContext({ viewport: { width: 820, height: 760 } });
+await ctx.route('**/*', (r) => {
+  const u = new URL(r.request().url());
+  let p = decodeURIComponent(u.pathname);
+  if (p === '/') p = '/demo.html';
+  const f = ROOT + p;
+  existsSync(f)
+    ? r.fulfill({ status: 200, headers: { 'content-type': CT[p.slice(p.lastIndexOf('.'))] || 'application/octet-stream' }, body: readFileSync(f) })
+    : r.fulfill({ status: 404, body: 'nf' });
+});
+await ctx.addInitScript(([cache, zoom]) => {
+  localStorage.setItem('houseplan_card_cfg_v1', cache);
+  localStorage.setItem('houseplan_card_zoom_v1', JSON.stringify({ f1: zoom }));
+  localStorage.removeItem('houseplan_card_nav_v1');
+  window.__frames = [];
+  const origCreate = Document.prototype.createElement;
+  Document.prototype.createElement = function (tag, ...a) {
+    const el = origCreate.call(this, tag, ...a);
+    if (String(tag).toLowerCase() !== 'houseplan-card' || window.__hooked) return el;
+    window.__hooked = true;
+    // model the HA websocket latency: the config cache renders instantly,
+    // the live config lands 350 ms later
+    let proto = Object.getPrototypeOf(el), desc = null;
+    while (proto && !desc) { desc = Object.getOwnPropertyDescriptor(proto, 'hass'); proto = Object.getPrototypeOf(proto); }
+    if (desc?.set) {
+      Object.defineProperty(el, 'hass', {
+        configurable: true,
+        get() { return desc.get.call(this); },
+        set(v) {
+          if (v && typeof v.callWS === 'function' && !v.__slow) {
+            const orig = v.callWS.bind(v);
+            v.__slow = true;
+            v.callWS = (m) => (m && m.type === 'houseplan/config/get')
+              ? new Promise((res) => setTimeout(() => res(orig(m)), 350))
+              : orig(m);
+          }
+          desc.set.call(this, v);
+        },
+      });
+    }
+    // rAF sampling from the first possible moment (before the first paint)
+    const sample = () => {
+      const sr = el.shadowRoot || el.renderRoot;
+      const stage = sr && sr.querySelector('.stage');
+      const svgEl = stage && stage.querySelector(':scope > .zoomwrap > svg');
+      if (stage && svgEl) {
+        const cs = getComputedStyle(stage);
+        const cw = getComputedStyle(svgEl.parentElement);
+        const cv = getComputedStyle(svgEl);
+        const r = stage.getBoundingClientRect();
+        const vb = (svgEl.getAttribute('viewBox') || '').split(/\s+/).map(Number);
+        const hidden = [cs, cw, cv].some((c) => c.opacity === '0' || c.visibility === 'hidden' || c.display === 'none');
+        window.__frames.push({ visible: !hidden && r.width > 1 && r.height > 1, vbW: vb[2] || 0, zoom: el._zoom });
+      } else {
+        window.__frames.push(null);
+      }
+      if (window.__frames.length < 75) requestAnimationFrame(sample);
+      else window.__framesDone = true;
+    };
+    requestAnimationFrame(sample);
+    return el;
+  };
+}, [cfgCache, ZOOM]);
+
+const p2 = await ctx.newPage();
+p2.on('pageerror', (e) => console.log('EXC2', e.message));
+await p2.goto('http://demo.local/demo.html', { waitUntil: 'domcontentloaded' });
+await p2.waitForFunction(() => window.__framesDone === true, { timeout: 15000 });
+
+const frames = await p2.evaluate(() => window.__frames);
+const targetW = defaultFitW / ZOOM;
+const seen = frames.filter(Boolean);
+// the flash: stage visible while the viewBox is still at the default scale
+// (clearly wider than the saved-zoom view; the default fit is 1.8x wider)
+const flashFrames = seen.filter((f) => f.visible && f.vbW > targetW * 1.35);
+const last = seen[seen.length - 1];
+const goodFrames = seen.filter((f) => f.visible && Math.abs(f.vbW - targetW) < targetW * 0.02);
+
+check('sampledFrames', seen.length > 30);
+check('noDefaultScaleFlash', flashFrames.length === 0 ? true
+  : `flash: ${flashFrames.length} visible frame(s) at default scale, e.g. vbW=${flashFrames[0].vbW.toFixed(3)} vs target ${targetW.toFixed(3)}`);
+check('settledAtSavedZoom', !!last && last.visible && Math.abs(last.zoom - ZOOM) < 0.01
+  && Math.abs(last.vbW - targetW) < targetW * 0.02);
+check('planActuallyShown', goodFrames.length >= 5); // the fix must not just hide the plan forever
+await finish(browser);

demo/smoke_zoom_out.mjs

@@ -48,6 +48,149 @@ out.floorIsHalf = await page.evaluate(() => { window.__card._resetZoom(); const
   c._applyView(0.1); return c._zoom; }) === 0.4; // clamped at the floor
 await page.evaluate(() => window.__card._resetZoom());
 
+// -- editor zoom is a working tool, not the viewing intent ----------------
+// view 1.6 → devices editor 2.5 → back to view: the pre-editor viewport
+// (zoom AND center) comes back; the editor keeps its own zoom while open.
+out.editorZoomNotSaved = await page.evaluate(async () => {
+  const c = window.__card;
+  const raf2 = () => new Promise((r) => requestAnimationFrame(() => requestAnimationFrame(r)));
+  const center = () => { const v = c._view; return [v.x + v.w / 2, v.y + v.h / 2]; };
+  c._setMode('view');
+  c._resetZoom();
+  c._zoomAt(10, 10, 1.6); c._saveZoom(); // off-center on purpose
+  const want = { zoom: c._zoom, c: center() };
+  c._setMode('devices'); await raf2();
+  c._zoomAt(10, 10, 2.5); c._saveZoom(); // off-center too: the center must not leak either
+  const editorZoomFree = Math.abs(c._zoom - 2.5) < 0.01; // zooming inside stays
+  c._setMode('view'); await raf2();
+  const got = { zoom: c._zoom, c: center() };
+  const ls = JSON.parse(localStorage.getItem('houseplan_card_zoom_v1') || '{}');
+  return {
+    editorZoomFree,
+    zoomRestored: Math.abs(got.zoom - want.zoom) < 0.01,
+    centerRestored: Math.hypot(got.c[0] - want.c[0], got.c[1] - want.c[1]) < 0.02,
+    lsRestored: Math.abs((ls[c._space] || 1) - want.zoom) < 0.01,
+  };
+});
+out.editorZoomFree = out.editorZoomNotSaved.editorZoomFree;
+out.viewZoomRestored = out.editorZoomNotSaved.zoomRestored;
+out.viewCenterRestored = out.editorZoomNotSaved.centerRestored;
+out.viewZoomBackInLs = out.editorZoomNotSaved.lsRestored;
+delete out.editorZoomNotSaved;
+
+// -- editor entered and left without touching zoom: no jump ---------------
+out.untouchedEditorNoJump = await page.evaluate(async () => {
+  const c = window.__card;
+  const raf2 = () => new Promise((r) => requestAnimationFrame(() => requestAnimationFrame(r)));
+  c._setMode('view');
+  c._resetZoom();
+  c._zoomAt(30, 30, 1.6); c._saveZoom();
+  const before = { ...c._view };
+  c._setMode('plan'); await raf2();
+  c._setMode('view'); await raf2();
+  const v = c._view;
+  return Math.abs(c._zoom - 1.6) < 0.01
+    && Math.abs(v.x - before.x) < 0.005 && Math.abs(v.y - before.y) < 0.005
+    && Math.abs(v.w - before.w) < 0.005 && Math.abs(v.h - before.h) < 0.005;
+});
+
+// -- the view zoom still survives a space switch, per space ---------------
+out.viewZoomSurvivesSpaceSwitch = await page.evaluate(async () => {
+  const c = window.__card;
+  const wait = (ms) => new Promise((r) => setTimeout(r, ms));
+  c._setMode('view');
+  c._resetZoom(); c._applyView(1.7); c._saveZoom();
+  c._slideTo('garden', 'left'); await wait(350);
+  const gardenGotOwnZoom = Math.abs(c._zoom - (JSON.parse(
+    localStorage.getItem('houseplan_card_zoom_v1') || '{}').garden || 1)) < 0.01;
+  c._slideTo('f1', 'right'); await wait(350);
+  return gardenGotOwnZoom && Math.abs(c._zoom - 1.7) < 0.01;
+});
+await page.evaluate(() => window.__card._resetZoom());
+
+// -- owner's dacha regression: editor 500% must never reach the per-space
+// view store. View zoom set on BOTH floors, editor cranked to 5.0, back to
+// view — and the floor tab is clicked in the SAME tick (on the tablet the
+// exit re-render janks, so the click runs before the restore rAF and the
+// old fix-up save was skipped). Two switches later the stale 5.0 came back.
+out.editorZoomNeverInSpaceStore = await page.evaluate(async () => {
+  const c = window.__card;
+  const wait = (ms) => new Promise((r) => setTimeout(r, ms));
+  const raf2 = () => new Promise((r) => requestAnimationFrame(() => requestAnimationFrame(r)));
+  c._setMode('view');
+  c._resetZoom(); c._zoomAt(10, 10, 1.6); c._saveZoom();      // floor 1 view zoom
+  c._slideTo('garden', 'left'); await wait(350);
+  c._resetZoom(); c._zoomAt(10, 10, 1.4); c._saveZoom();      // floor 2 view zoom
+  c._setMode('devices'); await raf2();
+  c._zoomAt(10, 10, 5.0); c._saveZoom();                      // 500% — a working tool
+  const lsInEditor = JSON.parse(localStorage.getItem('houseplan_card_zoom_v1') || '{}');
+  c._setMode('view');
+  c._slideTo('f1', 'right'); await wait(350);                 // same tick as the exit — beats the rAF
+  const firstSwitch = Math.abs(c._zoom - 1.6) < 0.01;
+  c._slideTo('garden', 'left'); await wait(350);
+  const secondSwitch = Math.abs(c._zoom - 1.4) < 0.01;        // used to come back as 5.0
+  const ls = JSON.parse(localStorage.getItem('houseplan_card_zoom_v1') || '{}');
+  c._slideTo('f1', 'right'); await wait(350); c._resetZoom(); // leave the stage as the next tests expect
+  return {
+    editorNotPersisted: Math.abs((lsInEditor.garden || 1) - 1.4) < 0.01,
+    firstSwitch,
+    secondSwitch,
+    lsClean: Math.abs((ls.garden || 1) - 1.4) < 0.01 && Math.abs((ls.f1 || 1) - 1.6) < 0.01,
+  };
+});
+out.editorZoomStaysOutOfLs = out.editorZoomNeverInSpaceStore.editorNotPersisted;
+out.ownerFirstSwitchOk = out.editorZoomNeverInSpaceStore.firstSwitch;
+out.ownerSecondSwitchOk = out.editorZoomNeverInSpaceStore.secondSwitch;
+out.ownerLsClean = out.editorZoomNeverInSpaceStore.lsClean;
+delete out.editorZoomNeverInSpaceStore;
+
+// -- HP-1543-01: смена этажа ВНУТРИ редактора не тащит editor zoom в view --
+// view-зум сохранён на обоих этажах → редактор на f1 → переключение ВКЛАДКОЙ
+// на garden → editor zoom 5.0 → выход в view (остаёмся на garden): вид обязан
+// вернуться к сохранённому view-зуму garden (1.4) с штатным центром
+// _restoreZoom(), а не остаться на редакторских 500% (снапшот-guard по space
+// отбрасывал восстановление, а текущий _zoom так и оставался редакторским).
+out.crossFloorEditorExit = await page.evaluate(async () => {
+  const c = window.__card;
+  const wait = (ms) => new Promise((r) => setTimeout(r, ms));
+  const raf2 = () => new Promise((r) => requestAnimationFrame(() => requestAnimationFrame(r)));
+  const sr = c.shadowRoot || c.renderRoot;
+  c._setMode('view');
+  c._resetZoom(); c._zoomAt(10, 10, 1.6); c._saveZoom();      // f1 view zoom
+  c._slideTo('garden', 'left'); await wait(350);
+  c._resetZoom(); c._zoomAt(10, 10, 1.4); c._saveZoom();      // garden view zoom
+  c._slideTo('f1', 'right'); await wait(350);
+  c._setMode('devices'); await raf2();
+  // этаж меняется НАСТОЯЩЕЙ вкладкой — именно этот путь под подозрением
+  const idx = c._model.findIndex((s) => s.id === 'garden');
+  sr.querySelectorAll('.tabs .tab')[idx].click();
+  await c.updateComplete; await raf2();
+  c._zoomAt(10, 10, 5.0); c._saveZoom();                      // 500% — рабочий инструмент
+  c._setMode('view'); await raf2(); await wait(60);
+  const stillGarden = c._space === 'garden';
+  const gotZoom = c._zoom;
+  const v = c._view; const vb = c._baseVb();
+  const centred = !!v && Math.abs(v.x + v.w / 2 - (vb[0] + vb[2] / 2)) < 1
+    && Math.abs(v.y + v.h / 2 - (vb[1] + vb[3] / 2)) < 1;
+  const ls = JSON.parse(localStorage.getItem('houseplan_card_zoom_v1') || '{}');
+  const store = { ...c._zoomBySpace };
+  c._slideTo('f1', 'right'); await wait(350); c._resetZoom(); // вернуть сцену следующим тестам
+  return {
+    stillGarden,
+    viewZoomRestoredCrossFloor: Math.abs(gotZoom - 1.4) < 0.01,          // было 5.0 (HP-1543-01)
+    centerRestoredCrossFloor: centred,                                   // центр как у _restoreZoom()
+    storeIntactCrossFloor: Math.abs((store.garden || 1) - 1.4) < 0.01,   // _zoomBySpace не тронут
+    lsIntactCrossFloor: Math.abs((ls.garden || 1) - 1.4) < 0.01
+      && Math.abs((ls.f1 || 1) - 1.6) < 0.01,                            // LS_ZOOM не тронут
+  };
+});
+out.crossFloorStillGarden = out.crossFloorEditorExit.stillGarden;
+out.crossFloorViewZoomRestored = out.crossFloorEditorExit.viewZoomRestoredCrossFloor;
+out.crossFloorCenterRestored = out.crossFloorEditorExit.centerRestoredCrossFloor;
+out.crossFloorStoreIntact = out.crossFloorEditorExit.storeIntactCrossFloor;
+out.crossFloorLsIntact = out.crossFloorEditorExit.lsIntactCrossFloor;
+delete out.crossFloorEditorExit;
+
 // -- devices outside rooms stretch the default frame ---------------------
 out.devicesStretchFrame = await page.evaluate(() => {
   const c = window.__card;

demo/stand/README.md

@@ -11,3 +11,19 @@ of the shipped integration.
   (template LQI sensors, alarm helpers, the smoke automation) lives in the
   seeds on the stand host — see `docs/TESTING-DEMO.md` and the memory note
   `houseplan-demo-stand`.
+
+- `demo_guard/` — stand-only guard (2026-07-31). Visitors log in as an
+  administrator (the card editor is gated on `is_admin`) and kept restarting
+  HA from the UI, which looked like the stand crashing between hourly resets.
+  The component re-registers `homeassistant.restart`/`homeassistant.stop` as
+  no-ops after startup. Deployed to `custom_components/demo_guard` in
+  seed-demo only (the dev stand sits behind basic auth) + `demo_guard:` in
+  configuration.yaml.
+
+- `www/stand-reset-timer.js` — console-only countdown to the next hourly
+  reset (`hp-reset.timer`, every hour at :00). Served as
+  `/local/stand-reset-timer.js` from `seed-demo/www/`, wired through
+  `frontend: extra_module_url`. Logs a styled `console.info` every minute,
+  switching to `console.warn` for the last 5 minutes. `www/stand-dev-info.js`
+  is the dev-stand counterpart: a single `console.info` saying the dev stand
+  only resets on deploy.

demo/stand/demo_guard/__init__.py

@@ -0,0 +1,46 @@
+"""Stand-only guard: keep visitor-admins from killing the public demo.
+
+Visitors log in as `demo`, and that user HAS to be an administrator — the
+House Plan card gates its editor on `user.is_admin`, and demonstrating the
+editor is the whole point of the stand. But an administrator can also call
+`homeassistant.restart` / `homeassistant.stop`, and visitors do exactly that
+(seen live 2026-07-31: HA exited with the restart code 100 minutes after a
+scheduled reset, right as a visitor session from an external IP was active —
+that is what looked like «стенд перезагружается чаще, чем раз в час»).
+
+Once startup finishes this component re-registers both services as no-ops:
+the UI buttons stay, pressing them only leaves a WARNING in the log. The
+hourly stand reset is NOT affected — hp-reset.timer restarts the docker
+container from the outside.
+"""
+from __future__ import annotations
+
+import logging
+
+from homeassistant.const import EVENT_HOMEASSISTANT_STARTED
+from homeassistant.core import HomeAssistant, ServiceCall, callback
+from homeassistant.helpers.typing import ConfigType
+
+_LOGGER = logging.getLogger(__name__)
+
+DOMAIN = "demo_guard"
+BLOCKED = ("restart", "stop")
+
+
+async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
+    async def _blocked(call: ServiceCall) -> None:
+        _LOGGER.warning(
+            "демо-стенд: homeassistant.%s отключён для посетителей "
+            "(стенд и так сбрасывается сам, ежечасно в :00)",
+            call.service,
+        )
+
+    @callback
+    def _neuter(_event) -> None:
+        # After EVENT_HOMEASSISTANT_STARTED every core service is in place;
+        # registering the same domain/name again replaces the handler.
+        for service in BLOCKED:
+            hass.services.async_register("homeassistant", service, _blocked)
+
+    hass.bus.async_listen_once(EVENT_HOMEASSISTANT_STARTED, _neuter)
+    return True

demo/stand/demo_guard/manifest.json

@@ -0,0 +1,10 @@
+{
+  "domain": "demo_guard",
+  "name": "Demo Stand Guard",
+  "codeowners": [],
+  "dependencies": [],
+  "documentation": "https://github.com/Matysh/houseplan-card/tree/dev/demo/stand/demo_guard",
+  "iot_class": "calculated",
+  "requirements": [],
+  "version": "1.0.0"
+}

demo/stand/demo_guard/services.yaml

@@ -0,0 +1,5 @@
+# demo_guard re-registers EXISTING homeassistant.restart / homeassistant.stop
+# as no-ops on the public demo stand (visitors are admins by necessity — the
+# card's editor requires is_admin — and kept restarting HA). It defines no
+# services of its own; this file exists because hassfest requires it for any
+# integration that calls async_register.

demo/stand/www/stand-dev-info.js

@@ -0,0 +1,7 @@
+// Dev-стенд House Plan: ежечасного сброса НЕТ. Контейнер перезапускается
+// только при новом коммите в ветку dev (hp-update-dev.timer, проверка раз
+// в 10 минут). Одно информационное сообщение при загрузке, без таймера.
+console.info(
+  "%c[dev-стенд] сброс только при деплое: перезапуск при новом коммите в dev (проверка раз в 10 мин)",
+  "background:#5d4037;color:#fff;padding:2px 6px;border-radius:3px"
+);

demo/stand/www/stand-reset-timer.js

@@ -0,0 +1,31 @@
+// Демо-стенд House Plan: таймер до ближайшего сброса — пишет ТОЛЬКО в консоль
+// DevTools, никакого UI. Стенд сбрасывается systemd-таймером hp-reset.timer
+// ежечасно в :00 (RandomizedDelaySec=0; сам перезапуск занимает ~15 секунд,
+// отсюда «~» в сообщении).
+(() => {
+  "use strict";
+  const INFO = "background:#03589c;color:#fff;padding:2px 6px;border-radius:3px";
+  const WARN = "background:#b71c1c;color:#fff;padding:2px 6px;border-radius:3px;font-weight:bold";
+
+  const tick = () => {
+    const now = new Date();
+    const next = new Date(now);
+    next.setMinutes(60, 0, 0); // ближайший :00
+    const left = Math.max(1, Math.ceil((next - now) / 60000));
+    if (left <= 5) {
+      console.warn(
+        `%c[демо-стенд] до сброса ~${left} мин — несохранённые эксперименты пропадут (сброс ежечасно в :00)`,
+        WARN
+      );
+    } else {
+      console.info(`%c[демо-стенд] до сброса ~${left} мин (сброс ежечасно в :00)`, INFO);
+    }
+  };
+
+  tick();
+  // выравниваемся по границе минуты, дальше — раз в минуту
+  setTimeout(() => {
+    tick();
+    setInterval(tick, 60000);
+  }, (60 - new Date().getSeconds()) * 1000);
+})();

docs/CHANGELOG.md

@@ -1,5 +1,181 @@
 # Changelog
 
+## v1.55.3 — 2026-08-02
+
+Patch release: two fixes for the v1.55.2 first-open veil, found by an
+adversarial lifecycle audit (AUD-1552-01/02).
+
+- **A dashboard rebuild during the first open can no longer leave the
+  plan hidden forever** (AUD-1552-01). Disconnecting the card while the
+  boot veil was up (Lovelace recreates its DOM, a view switch remounts
+  the card) killed the settle timers but kept their ids, so nothing ever
+  lifted the veil again. The veil lifecycle now restarts from every
+  reconnect — with a fresh clock and an unconditional hard cap — and the
+  fade-out also survives a mid-fade remount.
+- **The veil no longer opens early, right before a late panel lands**
+  (AUD-1552-02). Two equal height reads at 200/400 ms used to reveal the
+  plan at ~400 ms, so Home Assistant chrome arriving at 450+ ms jumped
+  on a visible plan — exactly what the veil was meant to prevent. The
+  veil now holds for a full protective window with trailing quiescence
+  (height changes near the cap extend the wait), and for a short grace
+  after the reveal any later shift glides via a height transition
+  instead of snapping. Deliberate height changes (entering an editor)
+  still apply instantly.
+
+## v1.55.2 — 2026-08-02
+
+Patch release: a calmer first open — no zoom flash and no layout jumps
+while Home Assistant is still settling — plus a new background color
+setting and two bits of editor polish.
+
+- **Opening a plan no longer flashes the default view before your saved
+  zoom** (HP-1551). The saved zoom used to be applied a beat after the
+  first render, so the card painted the default fit for a frame and then
+  snapped to your position. It is now applied synchronously, before the
+  first paint — the plan appears exactly where you left it.
+- **A first-open veil hides the plan until the layout settles**
+  (HP-1552). While Home Assistant is still loading its side panels, the
+  stage height can change several times, and the plan visibly jumped
+  along with it. The card now waits under a dark veil with a pulsing
+  house outline until the height stops moving, then reveals the plan
+  already in place. Kiosk mode skips the veil entirely.
+- **New setting: background color around the plan** (HP-1554). The area
+  around the plan can now be any color — set it in general settings for
+  the whole card, or override it per space. The backend validates the
+  value as a #rrggbb hex color.
+- **Round caps and joins on background-editor lines** (HP-1553). Strokes
+  used to end and meet in square cuts; line ends and corners are rounded
+  now, so traced walls and outlines look clean.
+- **The Resize tool's wall handles now look the part.** They are half
+  the previous size, show a wall-with-arrows glyph that rotates to
+  follow the wall, and use the grab cursor — while the hit area stays
+  exactly as large as before.
+
+## v1.55.1 — 2026-08-01
+
+Patch release: the four findings of the v1.55.0 audit, all in the new
+Room resize tool (HP-1550-01..04).
+
+- **A pending save can no longer leak a live drag to the server**
+  (HP-1550-01). The resize preview used to be written straight into the
+  shared config object, and a debounced save still queued from a
+  previous edit could snapshot it mid-drag — so a resize you then
+  cancelled with Esc quietly survived on the server and came back after
+  a reload. The live geometry now stays in a separate overlay that only
+  the renderer sees; it reaches the config exactly once, when the
+  handle is released.
+- **An interrupted drag is cancelled, not committed** (HP-1550-03).
+  When the system cuts a drag short — switching apps, palm rejection on
+  a tablet — the tool used to treat it as a release and save the
+  half-finished geometry. Such interruptions now take the same path as
+  Esc: the original geometry comes back, no undo step, no save.
+- **A door in the middle of a wall no longer blocks resizing it**
+  (HP-1550-04). The door's invisible hit area used to sit on top of the
+  wall handle, making such a wall ungrabbable for both rooms. In the
+  resize tool the handles now own the hit test (openings are not
+  editable there anyway — they simply travel with the wall), while all
+  other editor tools keep openings clickable exactly as before.
+- **The ~30 cm minimum size now holds for any room shape**
+  (HP-1550-02). The old check only measured parallel opposite walls, so
+  a triangular room could be squeezed into a sliver, and a rotated
+  room could scale its real short side below the floor unnoticed. Both
+  measures are orientation-independent now: wall drags respect every
+  obstacle in the wall's path (a triangle's apex, a slanted wall), and
+  the scale frame uses the room's true minimum width. Rooms already
+  thinner than the floor may still be improved, never made worse.
+
+## v1.55.0 — 2026-08-01
+
+Minor release: rooms are no longer set in stone — a dedicated Resize
+tool in the plan editor changes their size by dragging walls; plus the
+two findings of the v1.54.3 audit (HP-1543-01/02).
+
+- **Room resize — a new «Размер» tool in the plan editor** (spec:
+  docs/RESIZE.md). Every wall gets a handle at its midpoint; drag it
+  and the whole wall moves, staying parallel to itself, with grid
+  snap. Works for polygons (L-shapes included) and for legacy
+  rectangles alike.
+- **Shared walls always move together.** If the dragged wall coincides
+  with a neighbour's boundary, the neighbour follows: your room grows,
+  the neighbour shrinks — gaps and overlaps cannot appear by
+  construction. At T-junctions only the coinciding stretch follows,
+  inserting new corners into the neighbour's outline where needed.
+- **Live numbers while you drag.** The dragged wall and its two
+  adjacent walls show their lengths in real meters/feet, and the room
+  area in m² updates live at the room centre — for a shared wall, the
+  areas of both rooms.
+- **The wall stops where it must.** Rooms cannot get thinner than
+  ~30 cm (neither yours nor the neighbour's), an outline never crosses
+  itself, a growing wall stops at foreign rooms and island rooms, and
+  doors and windows are anchors: an opening travels with its wall, and
+  a wall carrying openings can never get too short for them.
+- **A scale frame for the whole room.** Click a room in the resize
+  tool to select it: dragging a corner of the dashed frame scales the
+  outline proportionally, with the same stops applied.
+- **Esc and Ctrl+Z.** Esc cancels the current drag and puts the
+  original geometry back; one released drag is one undo step, and
+  Ctrl+Z walks back up to 30 of them while the tool is active.
+- **Fix: room overlap detection missed equal-height rectangles slid
+  over each other.** Found while building the resize stops; the
+  slide-over case now counts as an overlap everywhere the check is
+  consulted, including the draw tool.
+- **Fix (HP-1543-01): editor zoom stayed on screen after a floor
+  switch made inside the editor.** Exiting an editor on a different
+  floor than the one you started on skipped the viewport restore and
+  left the editor working zoom in view mode. Such an exit now falls
+  back to the current floor's saved view zoom.
+- **Fix (HP-1543-02): a motion sensor re-tripped mid-flash stayed
+  invisible.** A rapid off→on before the current flash ended kept the
+  old CSS animation timeline, so the second detection played nothing.
+  Every witnessed trip now gets a fresh animation identity and the
+  flash restarts; under reduced motion the static ring stays, as
+  before.
+
+## v1.54.3 — 2026-08-01
+
+Patch release: three quality-of-life rounds — icon satellites now follow
+the per-device size multiplier, editor zoom stopped leaking into view
+mode, and motion sensors got a visual language of their own.
+
+- **The per-device size multiplier now scales the icon's satellites
+  too.** Reported by an owner with a screenshot: shrinking a device left
+  the value badge, the temperature/humidity plates, the LQI label, the
+  «new» dot and the alarm ring at full size, towering over the tiny
+  icon. Every satellite now follows the multiplier along with the icon.
+- **Editor zoom is a working tool, not a saved setting.** Zooming to
+  500% to place a marker precisely and then closing the editor used to
+  drop you into a 500% view mode. Leaving any editor now restores the
+  viewport you had in view mode before you started editing.
+- **Fix: editor zoom could still resurrect when switching floors.** The
+  editor viewport raced the per-floor viewport store and won: switch
+  floors while editing and the 500% was written down as that floor's
+  saved view, greeting you on the next visit (steps to reproduce came
+  from the owner). Editor zoom is never written to the store anymore.
+- **Tripped motion and presence sensors signal with a yellow ring.** The
+  rule stays «fill = on»: motion is a one-shot flash — three pulses at
+  the moment of detection, with no pulsing during the cool-down tail —
+  while occupancy/presence hold a static ring for as long as they report
+  someone present.
+- Stand only: a `services.yaml` for the demo stand's `demo_guard` to
+  keep hassfest green; nothing of it ships in the integration.
+
+## v1.54.2 — 2026-07-31
+
+Patch release: the one remaining finding of the v1.54.1 re-audit
+(HP-1541-01), pinned by regression tests on both sides of the contract.
+
+- **Fix: a vacuum whose own `selected_map` is `0` split calibration and
+  trail between two map ids.** The v1.54.1 map-id contract («the first value
+  that exists wins, and zero is a value») was applied to the source entity
+  but not to the card's fallback on the vacuum's `selected_map`: the
+  frontend still judged it by truthiness and turned `0` into `default`,
+  while the server recorder stored the run under `0`. Calibration was saved
+  under a key the recorder never used, and the recorded trail never rendered
+  after a reload. The fallback now follows the same not-nullish rule on both
+  sides (`vacMapIdWithFallback` in the card, `resolve_map_id` on the
+  server), with cross-runtime regressions for `selected_map` = `0`, `"0"`
+  and `""`.
+
 ## v1.54.1 — 2026-07-31
 
 Patch release: everything the adversarial audit of v1.54.0 found

docs/CHANGELOG.ru.md

@@ -6,6 +6,188 @@
 > **Правило проекта:** оба файла пополняются в одном коммите с самим
 > изменением — как и остальная документация (см. docs/STATUS.md).
 
+## v1.55.3 — 2026-08-02
+
+Патч-релиз: два исправления вуали первого открытия из v1.55.2,
+найденные adversarial-аудитом жизненного цикла (AUD-1552-01/02).
+
+- **Пересборка дашборда во время первого открытия больше не оставляет
+  план скрытым навсегда** (AUD-1552-01). Отключение карточки при
+  поднятой вуали (Lovelace пересоздаёт DOM, переключение вью
+  перемонтирует карточку) убивало таймеры стабилизации, но сохраняло их
+  id — и вуаль уже никогда не снималась. Теперь жизненный цикл вуали
+  перезапускается при каждом повторном подключении — с новым отсчётом и
+  безусловным жёстким таймаутом; затухание тоже переживает размонтирование
+  посреди fade.
+- **Вуаль больше не открывается рано, прямо перед поздней панелью**
+  (AUD-1552-02). Два одинаковых замера высоты на 200/400 мс открывали
+  план уже на ~400 мс, и хром Home Assistant, пришедший на 450+ мс,
+  прыгал на видимом плане — ровно то, от чего вуаль должна защищать.
+  Теперь вуаль держится полное защитное окно с trailing quiescence
+  (изменения высоты у края окна продлевают ожидание), а короткое время
+  после открытия поздний сдвиг применяется плавно (transition высоты),
+  а не скачком. Намеренные изменения высоты (вход в редактор)
+  по-прежнему применяются мгновенно.
+
+## v1.55.2 — 2026-08-02
+
+Патч-релиз: спокойное первое открытие — без вспышки зума и прыжков
+макета, пока Home Assistant догружается, — плюс новая настройка цвета
+фона и две полировки редактора.
+
+- **План больше не мигает видом по умолчанию перед сохранённым зумом**
+  (HP-1551). Сохранённый зум применялся на такт позже первого рендера:
+  карточка на кадр рисовала стандартную подгонку и лишь потом прыгала к
+  вашей позиции. Теперь он применяется синхронно, до первой отрисовки —
+  план появляется ровно там, где вы его оставили.
+- **Вуаль первого открытия прячет план, пока макет не устаканится**
+  (HP-1552). Пока Home Assistant догружает свои панели, высота сцены
+  может меняться несколько раз, и план заметно прыгал вместе с ней.
+  Теперь карточка ждёт под тёмной вуалью с пульсирующим контуром домика,
+  пока высота не перестанет меняться, и показывает план уже на месте.
+  В режиме киоска вуаль не показывается вовсе.
+- **Новая настройка: цвет фона вокруг плана** (HP-1554). Области вокруг
+  плана теперь можно задать любой цвет — в общих настройках для всей
+  карточки или отдельно для каждого пространства. Бэкенд проверяет
+  значение как hex-цвет #rrggbb.
+- **Круглые концы и стыки линий в редакторе подложки** (HP-1553). Штрихи
+  обрывались и стыковались квадратными срезами; теперь концы линий и
+  углы скруглены — обведённые стены и контуры выглядят аккуратно.
+- **Ручки стен в инструменте Resize теперь выглядят по делу.** Они вдвое
+  меньше прежних, несут значок «стенка со стрелочками», повёрнутый вдоль
+  своей стены, и показывают курсор grab — при этом зона клика осталась
+  прежней, большой.
+
+## v1.55.1 — 2026-08-01
+
+Патч-релиз: четыре находки аудита v1.55.0, все — в новом инструменте
+ресайза комнат (HP-1550-01..04).
+
+- **Отложенное сохранение больше не утаскивает живое перетаскивание на
+  сервер** (HP-1550-01). Превью ресайза писалось прямо в общий объект
+  конфигурации, и отложенная запись, оставшаяся в очереди от прошлой
+  правки, могла сфотографировать его посреди перетаскивания — ресайз,
+  который вы затем отменили по Esc, тихо оставался на сервере и
+  возвращался после перезагрузки. Теперь живая геометрия живёт в
+  отдельном слое, который видит только отрисовка; в конфигурацию она
+  попадает ровно один раз — при отпускании ручки.
+- **Прерванное перетаскивание отменяется, а не сохраняется**
+  (HP-1550-03). Когда систему прерывает сам поток ввода — переключение
+  приложения, ладонь на планшете — инструмент считал это отпусканием и
+  сохранял недоделанную геометрию. Теперь такие прерывания идут тем же
+  путём, что и Esc: исходная геометрия возвращается, без шага отмены и
+  без записи.
+- **Дверь посреди стены больше не мешает менять её размер**
+  (HP-1550-04). Невидимая зона клика двери ложилась поверх ручки стены,
+  и такую стену нельзя было схватить ни у одной из комнат. В
+  инструменте ресайза ручки теперь главные в hit-тесте (проёмы там всё
+  равно не редактируются — они просто едут вместе со стеной), а во всех
+  остальных инструментах редактора проёмы кликаются как раньше.
+- **Минимум ~30 см теперь держится для комнаты любой формы**
+  (HP-1550-02). Старая проверка мерила только параллельные
+  противоположные стены: треугольную комнату можно было сплющить в
+  щепку, а повёрнутая комната при масштабировании незаметно уводила
+  свою реальную короткую сторону ниже порога. Обе меры теперь не
+  зависят от ориентации: перетаскивание стены упирается в любое
+  препятствие на её пути (вершину треугольника, косую стену), а рамка
+  масштабирования использует истинную минимальную ширину комнаты.
+  Комнаты, уже более тонкие, по-прежнему можно улучшать, но не ухудшать.
+
+## v1.55.0 — 2026-08-01
+
+Минорный релиз: комнаты больше не высечены в камне — новый инструмент
+«Размер» в редакторе плана меняет их габариты перетаскиванием стен;
+плюс обе находки аудита v1.54.3 (HP-1543-01/02).
+
+- **Ресайз комнат — новый инструмент «Размер» в редакторе плана**
+  (спека: docs/RESIZE.md). У каждой стены появляется ручка в середине;
+  тяните её — и стена едет целиком, оставаясь параллельной себе, с
+  привязкой к сетке. Работает и для полигонов (включая Г-образные), и
+  для старых прямоугольников.
+- **Общие стены всегда двигаются вместе.** Если перетаскиваемая стена
+  совпадает с границей соседа, сосед следует за ней: ваша комната
+  растёт — соседняя сжимается, щели и наложения не появляются по
+  построению. На Т-стыках следует только совпадающий отрезок, при
+  необходимости в контур соседа вставляются новые вершины.
+- **Живые цифры во время перетаскивания.** Перетаскиваемая стена и две
+  смежные показывают длины в реальных метрах/футах, а площадь комнаты
+  в м² обновляется в центре комнаты вживую — для общей стены — площади
+  обеих комнат.
+- **Стена упирается там, где должна.** Комната не может стать тоньше
+  ~30 см (ни своя, ни соседская), контур не пересекает сам себя,
+  растущая стена останавливается о чужие комнаты и острова, а двери и
+  окна — якоря: проём едет вместе со стеной, и стена с проёмами не
+  может стать для них слишком короткой.
+- **Рамка масштабирования всей комнаты.** Клик по комнате в
+  инструменте выбирает её: перетаскивание уголка пунктирной рамки
+  пропорционально масштабирует контур — с теми же упорами.
+- **Esc и Ctrl+Z.** Esc отменяет текущее перетаскивание и возвращает
+  исходную геометрию; одно отпускание ручки — один шаг отмены, Ctrl+Z
+  откатывает до 30 шагов, пока инструмент активен.
+- **Исправлено: детекция наложения комнат пропускала равновысокие
+  прямоугольники, надвинутые друг на друга.** Найдено при постройке
+  упоров ресайза; slide-over теперь считается наложением везде, где
+  используется эта проверка, включая инструмент рисования.
+- **Исправлено (HP-1543-01): редакторский зум оставался на экране
+  после смены этажа внутри редактора.** Выход из редактора на другом
+  этаже, чем тот, где начинали, пропускал восстановление вьюпорта и
+  оставлял рабочий зум редактора в режиме просмотра. Теперь такой
+  выход откатывается к сохранённому view-зуму текущего этажа.
+- **Исправлено (HP-1543-02): датчик движения, сработавший повторно
+  посреди вспышки, оставался невидимым.** Быстрое off→on до конца
+  текущей вспышки не перезапускало CSS-анимацию — второе срабатывание
+  ничего не проигрывало. Теперь каждый зафиксированный trip получает
+  новую идентичность анимации, и вспышка стартует заново; при
+  prefers-reduced-motion остаётся статичное кольцо, как и раньше.
+
+## v1.54.3 — 2026-08-01
+
+Патч-релиз: три раунда качества жизни — спутники значка теперь слушаются
+пер-девайсного множителя размера, редакторский зум перестал протекать в
+режим просмотра, а датчики движения получили собственный визуальный язык.
+
+- **Пер-девайсный множитель размера теперь масштабирует и спутники
+  значка.** Репорт владельца со скриншотом: у уменьшенного устройства
+  бейдж значения, плашки температуры и влажности, подпись LQI, точка
+  «new» и кольцо тревоги оставались полноразмерными и нависали над
+  крошечным значком. Теперь все спутники следуют за множителем вместе со
+  значком.
+- **Редакторский зум — рабочий инструмент, а не сохранённая настройка.**
+  Приблизить до 500%, чтобы точно поставить маркер, и закрыть редактор
+  раньше означало оказаться в режиме просмотра на тех же 500%. Выход из
+  любого редактора теперь восстанавливает тот вид, который был в режиме
+  просмотра до начала правок.
+- **Исправлено: редакторский зум всё ещё «воскресал» при переключении
+  этажей.** Редакторский вьюпорт гонялся с пер-этажным хранилищем вида и
+  побеждал: переключите этаж во время правок — и 500% записывались как
+  сохранённый вид этого этажа и встречали вас в следующий раз (шаги
+  воспроизведения — от владельца). Теперь редакторский зум в хранилище
+  не пишется никогда.
+- **Сработавшие датчики движения и присутствия сигнализируют жёлтым
+  кольцом.** Правило прежнее — «подложка = включено»: движение — разовая
+  вспышка, три удара в момент обнаружения, без пульсации на хвосте
+  cool-down; occupancy/presence держат статичное кольцо, пока
+  докладывают о присутствии.
+- Только для стенда: `services.yaml` для стендового `demo_guard`, чтобы
+  hassfest оставался зелёным; в саму интеграцию это не попадает.
+
+## v1.54.2 — 2026-07-31
+
+Патч-релиз: единственная оставшаяся находка повторного аудита v1.54.1
+(HP-1541-01), закреплена регрессиями с обеих сторон контракта.
+
+- **Исправлено: пылесос с собственным `selected_map: 0` делил калибровку и
+  след между двумя id карты.** Контракт map id из v1.54.1 («побеждает
+  первое существующее значение, и ноль — значение») был применён к
+  source-сущности, но не к фолбэку карточки на `selected_map` самого
+  пылесоса: фронтенд по-прежнему судил по «истинности» и превращал `0` в
+  `default`, тогда как серверный рекордер писал уборку под `0`. Калибровка
+  сохранялась под ключом, которого рекордер не использовал, а записанный
+  след после перезагрузки не отображался. Теперь фолбэк живёт по тому же
+  правилу «не-null» с обеих сторон (`vacMapIdWithFallback` в карточке,
+  `resolve_map_id` на сервере), с кросс-регрессиями для `selected_map` =
+  `0`, `"0"` и `""`.
+
 ## v1.54.1 — 2026-07-31
 
 Патч-релиз: всё, что нашёл adversarial-аудит v1.54.0 (HP-1540-01..06),

docs/RESIZE.md

@@ -0,0 +1,168 @@
+# Room resize — the spec (source of truth)
+
+Status: approved by the owner 2026-08-01. Dev-branch feature, **no
+release**. Scope decisions final: a dedicated tool mode, wall-drag with
+shared walls always moving together, a corner-scale frame for the
+selected room, live numbers (wall lengths + room areas), grid snap,
+Esc-cancel, one drag = one undo step.
+
+## Principle
+
+Until now room geometry could only be changed by split/merge or by
+redrawing the outline — there was no vertex or wall dragging at all
+(the `.rlhandle` corners belong to the room LABEL card, not to the
+room). Resize adds exactly two mechanisms, both living ONLY inside a
+dedicated Plan-editor tool «Изменение размера комнат» (`_tool ===
+'resize'`). In every other tool the plan looks and behaves exactly as
+before — no handles, no new hit areas.
+
+## Mechanism A — wall drag
+
+- Every visible room shows a small handle at the midpoint of every
+  wall (handles for all rooms at once — owner's UX pick). The visible
+  glyph is a compact icon — a wall segment with two arrows pointing
+  perpendicular to it (the directions the wall drags), rotated to the
+  wall's orientation; accent ink over a `--hp-bg` halo. It is half the
+  size of the old circle, but the HIT area is an invisible circle of
+  the original finger-sized radius (derived from `view.w` like
+  `.vacfithandle`), so touch targets did not shrink. Cursor: `grab`,
+  `grabbing` while dragging.
+- Dragging a handle moves the wall along its outward normal; **both
+  ends of the edge translate together** (the wall stays parallel to
+  itself; adjacent walls stretch/shrink). Works for any polygon
+  (L-shaped included) and for legacy `x/y/w/h` rectangles — those are
+  converted through `roomPoly` and are **saved back as `poly`**.
+- The moved wall position snaps to the drawing grid (`snapToGrid`,
+  same pitch as the draw tool).
+- **Handles own the hit test** (HP-1550-04): inside the resize tool
+  openings are not editable — their transparent hit area is inert
+  (`pointer-events: none`) and the resize layer renders above the
+  openings, so a door sitting exactly at the midpoint of a wall can
+  never shadow that wall's handle. A drag of such a wall carries the
+  door along through the normal anchor pipeline; clicking over a door
+  falls through to room picking. Every other Plan tool keeps the
+  openings interactive exactly as before.
+
+## Shared walls — ALWAYS together
+
+If a stretch of the dragged wall coincides with a neighbour's boundary
+(collinear overlap with an epsilon, the `sharedBoundary` notion), the
+coinciding stretches of the neighbour move synchronously: your room
+grows — the neighbour shrinks. Gaps and overlaps cannot appear by
+construction.
+
+Partial contact (T-junctions): only the coinciding stretch of the
+neighbour moves. Where the stretch ends inside a neighbour wall, new
+vertices are inserted into the neighbour outline, which may legally
+become L-shaped. All of this is shown as a live preview during the
+drag. On commit collinear leftovers are simplified away
+(`simplifyPoly`), so geometry stays clean.
+
+## Stops (the wall stops dead)
+
+1. **Minimum size** — neither the own room nor a shrinking neighbour
+   may get thinner than ~30 cm (`MIN_ROOM_CM`, expressed in canvas
+   units through `cell_cm`). The measure is orientation-independent
+   (HP-1550-02): for a wall drag it is the smallest perpendicular
+   distance from the moved stretch to any part of the room boundary
+   inside the band the stretch sweeps along its normal — vertices and
+   crossing walls count whether parallel or not (a triangle's apex, a
+   slanted obstacle), while collinear remainders and the step corners
+   a T-junction inserts at the very ends of the stretch do not. For
+   the scale frame it is the TRUE minimum width of the outline
+   (rotating calipers over the convex hull) scaled by `k` — the
+   axis-aligned bbox is never consulted, so rotation cannot hide the
+   short side. Rooms that are ALREADY thinner keep their clearance
+   (the drag may improve it, never worsen it).
+2. **Self-intersection** — a wall never passes through the opposite
+   side; the outline must stay a simple polygon with its orientation
+   and a positive area.
+3. **Foreign rooms** — a growing wall stops when it would overlap a
+   room that is not a shared-wall neighbour (`roomsOverlap`; touching
+   walls are legal, crossing is not).
+4. **Island rooms** — islands inside the room (`islandsOf`) must stay
+   fully inside; a wall shrinking onto an island stops.
+5. **Openings are anchors** — a door/window ON the moving stretch
+   travels with the wall (its `openings[].x/y` centre is shifted, the
+   angle is unchanged). A wall that carries openings cannot get too
+   short for them: every opening previously sitting on a wall of an
+   affected room must still fit fully on some wall afterwards — for
+   the own room AND for the neighbour.
+
+## Mechanism B — the scale frame
+
+- In the resize tool a click inside a room SELECTS it: a dashed
+  bounding frame with 4 corner handles appears.
+- Dragging a corner scales ALL vertices proportionally (uniform
+  similarity) about the opposite bbox corner — the same maths family
+  as the vacuum fit panel (`reanchorFit`), only without rotation.
+- The same stops apply (minimum size, foreign overlap, islands,
+  openings; self-intersection is impossible under a similarity).
+- **The one exception to «shared walls always together»:** a scale
+  breaks collinear coincidence (walls move apart at an angle-preserving
+  ratio, not along a normal), so neighbours are NOT dragged along.
+  Growing into a neighbour simply stops the scale (the neighbour is a
+  wall to hit); shrinking away from a neighbour legally opens a gap.
+- Openings exclusive to the scaled room follow the transform
+  (position scales, physical length does not); openings on a wall
+  shared with an unchanged neighbour stay with the neighbour's wall.
+
+## Live numbers
+
+While a handle is being dragged:
+
+- length badges (`.measurelabel` style, `segmentCm`/`formatLength`,
+  metric or imperial per the HA unit system) on the dragged wall and
+  its two adjacent walls;
+- the room area in m² (`polygonArea` × scale²) at the room centre,
+  live; when a shared wall is dragged — the areas of BOTH rooms
+  (owner picked «стены + площадь»);
+- Esc cancels the current drag and puts the original geometry back;
+- releasing the handle (pointerup) commits: one write through the
+  standard debounced `_saveConfig` path;
+- `pointercancel` / `lostpointercapture` (the system interrupted the
+  stream: app switch, palm rejection) takes the CANCEL path, never the
+  commit path — snapshot geometry back, no undo step, no write
+  (HP-1550-03).
+
+## Preview vs commit (HP-1550-01)
+
+The live drag preview never touches the shared `_serverCfg`: it lives
+in a separate overlay (`_rszPreview`) that `_curSpaceCfg`/`_renderCfg`
+substitute into every render. Config writes are serialized and read
+`_serverCfg` at the moment they run (HP-1454-03), so a debounced write
+still queued from a previous edit can fire mid-drag — with the overlay
+it carries only committed geometry. The overlay moves into the real
+config exactly once, on pointerup; a cancel (Esc, pointercancel) just
+drops the overlay, leaving nothing to restore and nothing to write.
+
+## Undo
+
+One operation (handle release that changed something) = one undo step.
+The plan editor has no committed-operation undo stack (Ctrl+Z/Esc only
+walk back draw/split points), so the resize tool keeps its own stack
+of pre-drag snapshots (rooms + openings of the space, capped at 30)
+and Ctrl+Z/⌘Z pops it while the tool is active.
+
+## Out of scope / invariants
+
+- Device positions are not touched; the room settings button (pole of
+  inaccessibility) recomputes itself from the new outline.
+- Saving goes through the standard config path (`houseplan/config/set`
+  with `expected_rev`); backend validation already covers polygons
+  (`_GEOM` ±4, `MAX_POLY_POINTS` 500) — inserted neighbour vertices are
+  just polygon points, openings keep their schema, nothing new to
+  validate server-side.
+- Touch: handles are finger-sized, use pointer capture and swallow
+  `pointerdown`, so the stage pan/pinch never fights a handle drag.
+- The label-card corners (`.rlhandle`, `_rlResizeDown`) are untouched.
+
+## Geometry home
+
+All pure geometry lives in `src/resize.ts` (edge normals, edge move,
+shared-span search and vertex insertion, all stops — including the
+orientation-independent `minSpanClearance` band measure and the
+`minPolyWidth` calipers width — the scale clamp, area formatting)
+under node:test units in `test/resize.test.mjs`;
+`src/houseplan-card.ts` only wires pointers, the preview overlay,
+badges and undo.

docs/STATUS.md

@@ -11,16 +11,16 @@
 > (versions, publication, infrastructure), DEVELOPMENT.md for new gotchas,
 > ARCHITECTURE.md for design changes, ROADMAP.md when plans move.
 
-## Snapshot (2026-07-29)
+## Snapshot (2026-08-02)
 
 | Item | State |
 |---|---|
-| Version | **v1.54.1** everywhere (manifest, const.py, package.json, CARD_VERSION); deployed to the home instance |
+| Version | **v1.55.3** everywhere (manifest, const.py, package.json, CARD_VERSION); deployed to the home instance. Closes the v1.55.2 audit findings AUD-1552-01/02 (boot-veil lifecycle: reconnect restart + full protective window with trailing quiescence + post-reveal soft grace; regressions in `demo/smoke_preloader_lifecycle.mjs`) |
 | Workflow | Since 2026-07-22: minor changes go to branch **`dev`** (build + smokes → deploy home → commit → push, NO release); releases are batched on the owner's command (merge dev→main, one tag, one release with a summary changelog, CI checked on dev beforehand) |
 | GitHub | https://github.com/Matysh/houseplan-card — **`main` carries every published release, the latest tag is the current version above**; `dev` is where work lands and is merged into `main` at release time (so `dev` is normally equal to or ahead of `main`, never behind). Push via SSH key `ha_jb` (remote git@github.com:…); API releases via the fine-grained PAT in `~/.git-credentials` (Contents R/W, issued 2026-07-23) |
 | CI | validate.yml (hacs + hassfest + frontend + backend) green; release.yml attaches the bundle on release publish |
 | HACS | Custom repository works. **Inclusion PR: hacs/default#9004** — open, valid, labeled, mergeable clean, never drafted. Queue: 1212 open, 835 older than ours. Merge rate COLLAPSED: 75 in July but almost all in the first decade, 0 in the last week (checked 2026-07-29) — maintainers process in rare bursts; ETA unknowable, months at best. Nothing actionable on our side |
-| Home instance | ha.jbstudio.pro (SSH port **22222**, key `ha_jb`; HA config root is `/mnt/data/supervisor/homeassistant` — `/config` does NOT exist in this SSH environment), deployed **v1.54.0** via direct copy (HACS custom repo also installed) |
+| Home instance | ha.jbstudio.pro (SSH port **22222**, key `ha_jb`; HA config root is `/mnt/data/supervisor/homeassistant` — `/config` does NOT exist in this SSH environment), deployed **v1.55.3** via direct copy (HACS custom repo also installed) |
 | Localization | UI en/ru (src/i18n/*.json), everything user-visible localized incl. kiosk popover |
 | Tests | Four layers: frontend unit (`npm test`, node:test over `test-build/`), pure backend (`pytest tests_backend`, runs anywhere), HA-harness backend (same folder, CI only — needs py3.13 + pytest-homeassistant-custom-component), and browser smokes (`demo/smoke_*.mjs`, headless chromium). **Counts are not written down here** — they went stale within two releases while the version line beside them was kept current, which reads as less coverage than exists (review R5-2). Run `npm run inventory` for the current numbers, or read them off the last CI run |
 | Vacuums | Live robot vacuums shipped (docs/VACUUM.md): puck, server-side trails with display modes, fit-panel calibration. Verified on a live Dreame X50 Master |

docs/TESTING.md

@@ -833,3 +833,36 @@ require hands on real hardware — they remain for the human pass.
   clicks must land on the overlay (elementFromPoint smoke guards it).
 - Multi-floor: one matrix per robot map (Dreame `selected_map` on the
   vacuum entity names the active one).
+
+## Room resize (docs/RESIZE.md)
+
+- [ ] The «Размер» tool appears in the Plan editor toolbar; in EVERY other
+      tool (and in Devices/Decor/View) there is not a single `.rszhandle`
+- [ ] Handles sit at the midpoint of every wall of every room; they are
+      finger-sized, capture the pointer and never start a stage pan
+- [ ] Dragging a handle moves the wall along its normal, both edge ends
+      together; the wall line snaps to the drawing grid
+- [ ] A wall fully shared with a neighbour drags the neighbour's wall with
+      it — the neighbour shrinks/grows, no gap and no overlap can appear
+- [ ] A partially shared wall (T-junction) moves only the coinciding
+      stretch: the neighbour becomes L-shaped (new vertices), shown live
+- [ ] Legacy x/y/w/h rectangle rooms resize the same way and are saved back
+      as polygons
+- [ ] Live badges while dragging: lengths of the dragged wall + both
+      adjacent walls, and the m² area at the room centre; dragging a shared
+      wall shows BOTH areas; all numbers update continuously
+- [ ] Stops: ~30 cm minimum for the own room AND the shrinking neighbour;
+      a foreign room in the path (touch is ok, overlap never); islands
+      inside; a door/window on a shortening wall (the wall corner can not
+      pass the opening edge)
+- [ ] A door/window ON the moving wall travels with it (openings x/y
+      recompute; angle unchanged)
+- [ ] Esc mid-drag cancels: the original geometry is back instantly
+- [ ] Click a room in the resize tool → dashed bbox frame with 4 corner
+      handles; dragging a corner scales all vertices proportionally about
+      the opposite corner; neighbours are NOT dragged along (the one
+      exception to «shared walls together»), growing into one stops
+- [ ] Ctrl+Z / ⌘Z after releasing a handle restores the previous geometry —
+      one release = one undo step (rooms AND openings)
+- [ ] Device markers do not move; the room settings gear re-centres itself
+- [ ] Smoke: `node demo/smoke_room_resize.mjs`

package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "houseplan-card",
-  "version": "1.54.1",
+  "version": "1.55.3",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "houseplan-card",
-      "version": "1.54.1",
+      "version": "1.55.3",
       "license": "MIT",
       "dependencies": {
         "lit": "^3.1.3",

package.json

@@ -1,6 +1,6 @@
 {
   "name": "houseplan-card",
-  "version": "1.54.1",
+  "version": "1.55.3",
   "description": "Interactive house plan Lovelace card for Home Assistant",
   "license": "MIT",
   "type": "module",

src/i18n/en.json

@@ -35,6 +35,9 @@
   "markup.add": "Add",
   "markup.merge": "Merge",
   "markup.split": "Split",
+  "markup.resize": "Resize",
+  "title.markup_resize": "Resize rooms: drag a wall handle; click a room for a corner scale frame",
+  "markup.hint_resize": "drag a wall handle · click a room — corner frame · Esc cancels a drag · Ctrl+Z — undo a step",
   "markup.opening": "Opening",
   "title.markup_opening": "Doors & windows: click a wall to place, click an opening to edit",
   "opening.new": "New opening",
@@ -376,5 +379,12 @@
   "vac.fit_mirror": "Mirror",
   "vac.trail_never": "Never",
   "vac.trail_cleaning": "While cleaning",
-  "vac.trail_always": "Always"
+  "vac.trail_always": "Always",
+  "gs.bg_group": "Stage background",
+  "gs.bg_color": "Background around the plan",
+  "gs.bg_default": "Theme default",
+  "gs.bg_theme": "theme default",
+  "space.bg_color": "Background around the plan",
+  "space.bg_inherit": "Inherit general",
+  "space.bg_inherited": "inherits general settings"
 }

src/i18n/ru.json

@@ -35,6 +35,9 @@
   "markup.add": "Добавить",
   "markup.merge": "Объединить",
   "markup.split": "Разделить",
+  "markup.resize": "Размер",
+  "title.markup_resize": "Изменение размера комнат: тяните ручку стены; клик по комнате — угловая рамка масштаба",
+  "markup.hint_resize": "тяните ручку стены · клик по комнате — угловая рамка · Esc отменяет перетаскивание · Ctrl+Z — отмена шага",
   "markup.opening": "Проём",
   "title.markup_opening": "Двери и окна: клик по стене — добавить, клик по проёму — редактировать",
   "opening.new": "Новый проём",
@@ -376,5 +379,12 @@
   "vac.fit_mirror": "Отразить",
   "vac.trail_never": "Не показывать никогда",
   "vac.trail_cleaning": "Во время уборки",
-  "vac.trail_always": "Показывать всегда"
+  "vac.trail_always": "Показывать всегда",
+  "gs.bg_group": "Фон сцены",
+  "gs.bg_color": "Цвет фона вокруг плана",
+  "gs.bg_default": "Как в теме",
+  "gs.bg_theme": "по умолчанию — из темы",
+  "space.bg_color": "Цвет фона вокруг плана",
+  "space.bg_inherit": "Наследовать общий",
+  "space.bg_inherited": "наследуется из общих настроек"
 }

src/logic.ts

@@ -739,6 +739,8 @@ export interface SpaceDisplay {
   labelHum: boolean;
   labelLqi: boolean;
   labelLight: boolean;
+  /** Background around the plan; null = inherit the global setting / theme. */
+  bgColor: string | null;
 }
 
 export const DEFAULT_ROOM_COLOR = '#3ea6ff';
@@ -766,9 +768,21 @@ export function spaceDisplayOf(spaceCfg: any): SpaceDisplay {
     labelHum: s.label_hum === true,
     labelLqi: s.label_lqi === true,
     labelLight: s.label_light === true,
+    bgColor: typeof s.bg_color === 'string' && /^#[0-9a-f]{6}$/i.test(s.bg_color) ? s.bg_color : null,
   };
 }
 
+/**
+ * Effective background color around the plan: the per-space override wins,
+ * then the global config.settings.bg_color, then '' — meaning "keep the
+ * theme default" (the stage's stylesheet background stays untouched).
+ */
+export function stageBgOf(settings: any, disp: { bgColor: string | null }): string {
+  if (disp.bgColor) return disp.bgColor;
+  const g = settings?.bg_color;
+  return typeof g === 'string' && /^#[0-9a-f]{6}$/i.test(g) ? g : '';
+}
+
 // ---------------- global fill colors ----------------
 
 export interface FillColorEntry {

src/resize.ts

@@ -0,0 +1,605 @@
+/**
+ * Room resize geometry — pure functions only (docs/RESIZE.md).
+ *
+ * Mechanism A: dragging a wall along its normal, shared stretches of
+ * neighbours move together (T-junctions insert vertices). Mechanism B:
+ * uniform scale of one room about a bbox corner. Every stop («упор») is
+ * decided here so it can be unit-tested; the card only wires pointers.
+ *
+ * All coordinates are render units (NORM_W-scaled), same as the card's
+ * space model. Nothing here touches Lit or the DOM.
+ */
+import { intersection } from 'polyclip-ts';
+import {
+  polygonArea, segmentsProperlyCross, polyContainsPoly, roomsOverlap,
+} from './logic';
+
+/** Minimal room dimension in centimetres (owner: «мин. габарит ~30 см»). */
+export const MIN_ROOM_CM = 30;
+
+export interface RoomIn { id: string; poly: number[][] }
+/** Opening in render units: centre, wall angle (deg), full length. */
+export interface OpeningIn { id: string; x: number; y: number; length: number }
+
+export interface EdgeDragPlan {
+  roomId: string;
+  edge: number;            // edge index i: v[i] -> v[i+1]
+  a: number[];             // edge endpoints BEFORE the drag
+  b: number[];
+  n: [number, number];     // outward unit normal (d > 0 grows the room)
+}
+
+export interface EdgeDragResult {
+  /** roomId -> new outline (only rooms that changed). */
+  polys: Record<string, number[][]>;
+  /** openingId -> new centre (only openings that travelled with the wall). */
+  openings: Record<string, [number, number]>;
+  /** roomId -> the moved stretches AFTER the move (for clearance/labels). */
+  movedSpans: Record<string, [number[], number[]][]>;
+}
+
+// ---------------- tiny vector helpers ----------------
+
+const sub = (p: number[], q: number[]) => [p[0] - q[0], p[1] - q[1]];
+const add2 = (p: number[], d: number[]) => [p[0] + d[0], p[1] + d[1]];
+const dot = (p: number[], q: number[]) => p[0] * q[0] + p[1] * q[1];
+const len2d = (p: number[]) => Math.hypot(p[0], p[1]);
+
+function signedArea(poly: number[][]): number {
+  let s = 0;
+  for (let i = 0; i < poly.length; i++) {
+    const a = poly[i], b = poly[(i + 1) % poly.length];
+    s += a[0] * b[1] - b[0] * a[1];
+  }
+  return s / 2;
+}
+
+function pointInPoly(p: number[], poly: number[][]): boolean {
+  let inside = false;
+  for (let i = 0, j = poly.length - 1; i < poly.length; j = i++) {
+    const xi = poly[i][0], yi = poly[i][1], xj = poly[j][0], yj = poly[j][1];
+    if (yi > p[1] !== yj > p[1] && p[0] < ((xj - xi) * (p[1] - yi)) / (yj - yi) + xi) inside = !inside;
+  }
+  return inside;
+}
+
+function distPointToSpan(p: number[], a: number[], b: number[]): number {
+  const ab = sub(b, a);
+  const l2 = dot(ab, ab);
+  if (l2 < 1e-12) return len2d(sub(p, a));
+  let t = dot(sub(p, a), ab) / l2;
+  t = Math.max(0, Math.min(1, t));
+  return len2d(sub(p, [a[0] + ab[0] * t, a[1] + ab[1] * t]));
+}
+
+/**
+ * Outward unit normal of edge i. Candidate is the +90° rotation of the edge
+ * direction; a probe point decides the sign, so polygon orientation (either
+ * winding survives in real configs) does not matter.
+ */
+export function edgeNormal(poly: number[][], i: number): [number, number] {
+  const a = poly[i], b = poly[(i + 1) % poly.length];
+  const d = sub(b, a);
+  const l = len2d(d) || 1;
+  let n: [number, number] = [d[1] / l, -d[0] / l];
+  const mid = [(a[0] + b[0]) / 2, (a[1] + b[1]) / 2];
+  const probe = Math.max(l * 0.01, 1e-4);
+  if (pointInPoly([mid[0] + n[0] * probe, mid[1] + n[1] * probe], poly)) n = [-n[0], -n[1]];
+  return n;
+}
+
+/** Translate BOTH endpoints of edge i by the normal times d (docs/RESIZE.md, mechanism A). */
+export function movePolyEdge(poly: number[][], i: number, d: number, n?: [number, number]): number[][] {
+  const nn = n || edgeNormal(poly, i);
+  const j = (i + 1) % poly.length;
+  return poly.map((p, k) => (k === i || k === j ? [p[0] + nn[0] * d, p[1] + nn[1] * d] : [...p]));
+}
+
+/** Collinear overlap stretches of `poly`'s edges with segment a-b, as [p,q] pairs (pre-move). */
+export function sharedSpansWith(poly: number[][], a: number[], b: number[], eps: number): [number[], number[]][] {
+  const out: [number[], number[]][] = [];
+  const ab = sub(b, a);
+  const L = len2d(ab);
+  if (L < eps) return out;
+  const u = [ab[0] / L, ab[1] / L];
+  for (let j = 0; j < poly.length; j++) {
+    const q1 = poly[j], q2 = poly[(j + 1) % poly.length];
+    const off1 = Math.abs((q1[0] - a[0]) * u[1] - (q1[1] - a[1]) * u[0]);
+    const off2 = Math.abs((q2[0] - a[0]) * u[1] - (q2[1] - a[1]) * u[0]);
+    if (off1 > eps || off2 > eps) continue; // not collinear with a-b
+    const t1 = dot(sub(q1, a), u);
+    const t2 = dot(sub(q2, a), u);
+    const lo = Math.max(0, Math.min(t1, t2));
+    const hi = Math.min(L, Math.max(t1, t2));
+    if (hi - lo > eps) out.push([[a[0] + u[0] * lo, a[1] + u[1] * lo], [a[0] + u[0] * hi, a[1] + u[1] * hi]]);
+  }
+  return out;
+}
+
+/**
+ * Neighbour sync: translate the stretches of `poly` that coincide with segment
+ * a-b by vector D, inserting vertices at partial-contact boundaries (T-junction
+ * → the neighbour may become L-shaped). Returns null when nothing coincides.
+ */
+export function shiftSharedSpans(
+  poly: number[][], a: number[], b: number[], D: [number, number], eps: number,
+): number[][] | null {
+  const spans = sharedSpansWith(poly, a, b, eps);
+  if (!spans.length) return null;
+  const onSpan = (p: number[]) => spans.some(([p1, p2]) => distPointToSpan(p, p1, p2) <= eps);
+  const n = poly.length;
+  const out: number[][] = [];
+  for (let j = 0; j < n; j++) {
+    const q1 = poly[j], q2 = poly[(j + 1) % n];
+    out.push(onSpan(q1) ? add2(q1, D) : [...q1]);
+    const e = sub(q2, q1);
+    const elen = len2d(e);
+    if (elen < eps) continue;
+    const u = [e[0] / elen, e[1] / elen];
+    // collinear with a-b? (both endpoints on the a-b LINE)
+    const abL = len2d(sub(b, a)) || 1;
+    const uv = [(b[0] - a[0]) / abL, (b[1] - a[1]) / abL];
+    const o1 = Math.abs((q1[0] - a[0]) * uv[1] - (q1[1] - a[1]) * uv[0]);
+    const o2 = Math.abs((q2[0] - a[0]) * uv[1] - (q2[1] - a[1]) * uv[0]);
+    if (o1 > eps || o2 > eps) continue;
+    const tA = dot(sub(a, q1), u);
+    const tB = dot(sub(b, q1), u);
+    const lo = Math.max(0, Math.min(tA, tB));
+    const hi = Math.min(elen, Math.max(tA, tB));
+    if (hi - lo <= eps) continue;
+    // interior boundaries split the edge: entering the overlap emits the static
+    // point then its moved copy, leaving it emits the moved copy then the static
+    if (lo > eps && lo < elen - eps) {
+      const p = [q1[0] + u[0] * lo, q1[1] + u[1] * lo];
+      out.push([...p], add2(p, D));
+    }
+    if (hi > eps && hi < elen - eps) {
+      const p = [q1[0] + u[0] * hi, q1[1] + u[1] * hi];
+      out.push(add2(p, D), [...p]);
+    }
+  }
+  return out;
+}
+
+/** Drop consecutive duplicates and collinear middle vertices (commit-time cleanup). */
+export function simplifyPoly(poly: number[][], eps = 1e-6): number[][] {
+  let pts = poly.filter((p, i) => len2d(sub(p, poly[(i + 1) % poly.length])) > eps);
+  for (let pass = 0; pass < 2; pass++) {
+    pts = pts.filter((p, i) => {
+      const prev = pts[(i - 1 + pts.length) % pts.length];
+      const next = pts[(i + 1) % pts.length];
+      const cross = (p[0] - prev[0]) * (next[1] - prev[1]) - (p[1] - prev[1]) * (next[0] - prev[0]);
+      const span = len2d(sub(next, prev)) || 1;
+      return Math.abs(cross) / span > eps; // keep only real corners
+    });
+  }
+  return pts.length >= 3 ? pts : poly;
+}
+
+/** Simple polygon: no properly crossing edges (shared walls touching is fine). */
+export function polyIsSimple(poly: number[][]): boolean {
+  const n = poly.length;
+  if (n < 3) return false;
+  for (let i = 0; i < n; i++)
+    for (let j = i + 1; j < n; j++) {
+      if (j === i || (j + 1) % n === i || (i + 1) % n === j) continue;
+      if (segmentsProperlyCross(poly[i], poly[(i + 1) % n], poly[j], poly[(j + 1) % n])) return false;
+    }
+  return true;
+}
+
+/**
+ * Normal clearance between the moved stretches and every PARALLEL wall of the
+ * same room with an overlapping projection — the «opposite wall» distance that
+ * enforces the 30 cm minimum. Infinity when no opposite wall exists.
+ */
+export function minParallelClearance(
+  poly: number[][], spans: [number[], number[]][], eps = 1e-6,
+): number {
+  let best = Infinity;
+  for (const [a, b] of spans) {
+    const ab = sub(b, a);
+    const L = len2d(ab);
+    if (L < eps) continue;
+    const u = [ab[0] / L, ab[1] / L];
+    for (let j = 0; j < poly.length; j++) {
+      const q1 = poly[j], q2 = poly[(j + 1) % poly.length];
+      const e = sub(q2, q1);
+      const elen = len2d(e);
+      if (elen < eps) continue;
+      const cosang = Math.abs((e[0] * u[0] + e[1] * u[1]) / elen);
+      if (cosang < 1 - 1e-4) continue; // not parallel
+      // projection overlap along the span direction
+      const t1 = dot(sub(q1, a), u);
+      const t2 = dot(sub(q2, a), u);
+      const lo = Math.max(0, Math.min(t1, t2));
+      const hi = Math.min(L, Math.max(t1, t2));
+      if (hi - lo <= eps) continue;
+      const d1 = Math.abs((q1[0] - a[0]) * u[1] - (q1[1] - a[1]) * u[0]);
+      if (d1 <= eps) continue; // the span itself / collinear leftovers
+      if (d1 < best) best = d1;
+    }
+  }
+  return best;
+}
+
+/**
+ * HP-1550-02: orientation-independent clearance of the moved stretches.
+ *
+ * minParallelClearance only saw PARALLEL opposite walls, so a triangle (no
+ * parallel wall at all) reported Infinity and the 30 cm floor was simply off —
+ * the base could be dragged to a 5-unit sliver. This measure looks at the whole
+ * band the span sweeps along its normal: every vertex strictly inside the band
+ * and every edge crossing the band interior counts with its perpendicular
+ * distance from the span line. Two exclusions keep it honest:
+ *   - anything ON the span line (offset ≤ eps) is the span itself, a collinear
+ *     wall remainder or a T-insert — not an opposite obstacle;
+ *   - the band ENDS (projection ≤ eps or ≥ L − eps) are excluded, so the
+ *     |d|-long step edge a T-junction inserts at the very end of the span does
+ *     not read as a paper-thin room on every small drag.
+ * Offsets cannot change sign inside the band (that would cross the span —
+ * polyIsSimple already rejected it), so an edge's minimum lies at a clip bound.
+ * Infinity still means «nothing opposite at all» (e.g. growing outward).
+ */
+export function minSpanClearance(
+  poly: number[][], spans: [number[], number[]][], eps = 1e-6,
+): number {
+  let best = Infinity;
+  for (const [a, b] of spans) {
+    const ab = sub(b, a);
+    const L = len2d(ab);
+    if (L < eps) continue;
+    const u = [ab[0] / L, ab[1] / L];
+    const soff = (p: number[]) => (p[0] - a[0]) * u[1] - (p[1] - a[1]) * u[0];
+    const tOf = (p: number[]) => (p[0] - a[0]) * u[0] + (p[1] - a[1]) * u[1];
+    const lo = eps, hi = L - eps;
+    for (const v of poly) {
+      const o = Math.abs(soff(v));
+      if (o <= eps) continue;
+      const tv = tOf(v);
+      if (tv <= lo || tv >= hi) continue;
+      if (o < best) best = o;
+    }
+    for (let j = 0; j < poly.length; j++) {
+      const q1 = poly[j], q2 = poly[(j + 1) % poly.length];
+      const o1 = soff(q1), o2 = soff(q2);
+      if (Math.abs(o1) <= eps || Math.abs(o2) <= eps) continue; // attached to the moving wall
+      const t1 = tOf(q1), t2 = tOf(q2);
+      const tlo = Math.max(lo, Math.min(t1, t2));
+      const thi = Math.min(hi, Math.max(t1, t2));
+      if (thi - tlo <= eps) continue; // casts no shadow on the span interior
+      const dt = t2 - t1;
+      if (Math.abs(dt) < eps) { // perpendicular-ish edge fully inside the band
+        best = Math.min(best, Math.abs(o1), Math.abs(o2));
+        continue;
+      }
+      const offAt = (tt: number) => Math.abs(o1 + ((tt - t1) / dt) * (o2 - o1));
+      best = Math.min(best, offAt(tlo), offAt(thi));
+    }
+  }
+  return best;
+}
+
+/** Convex hull (monotone chain) — only the width measure below needs it. */
+function convexHull(pts: number[][]): number[][] {
+  const p = [...pts].sort((a, b) => a[0] - b[0] || a[1] - b[1]);
+  if (p.length < 3) return p;
+  const cross = (o: number[], a: number[], b: number[]) =>
+    (a[0] - o[0]) * (b[1] - o[1]) - (a[1] - o[1]) * (b[0] - o[0]);
+  const lower: number[][] = [];
+  for (const pt of p) {
+    while (lower.length >= 2 && cross(lower[lower.length - 2], lower[lower.length - 1], pt) <= 0) lower.pop();
+    lower.push(pt);
+  }
+  const upper: number[][] = [];
+  for (let i = p.length - 1; i >= 0; i--) {
+    const pt = p[i];
+    while (upper.length >= 2 && cross(upper[upper.length - 2], upper[upper.length - 1], pt) <= 0) upper.pop();
+    upper.push(pt);
+  }
+  lower.pop(); upper.pop();
+  return lower.concat(upper);
+}
+
+/**
+ * HP-1550-02: the TRUE minimum width of a polygon — rotating calipers over the
+ * convex hull (the min over hull edge directions of the perpendicular extent).
+ * The axis-aligned bbox lied under rotation: a 500×100 rectangle turned 45° has
+ * a ≈424×424 bbox, so a 0.1 scale slid the real 100-side down to 10 unchecked.
+ * A similarity scales every distance by k, which makes k·minPolyWidth exact —
+ * and a concave room is judged by its overall silhouette, so a small notch
+ * that takes no part in the operation cannot veto a legal scale.
+ */
+export function minPolyWidth(poly: number[][]): number {
+  const h = convexHull(poly);
+  if (h.length < 3) return 0;
+  let best = Infinity;
+  for (let i = 0; i < h.length; i++) {
+    const a = h[i], b = h[(i + 1) % h.length];
+    const e = sub(b, a);
+    const L = len2d(e);
+    if (L < 1e-12) continue;
+    const u = [e[0] / L, e[1] / L];
+    let w = 0;
+    for (const pt of h) w = Math.max(w, Math.abs((pt[0] - a[0]) * u[1] - (pt[1] - a[1]) * u[0]));
+    if (w < best) best = w;
+  }
+  return Number.isFinite(best) ? best : 0;
+}
+
+/**
+ * Do two outlines ILLEGALLY share floor area? `roomsOverlap` alone misses the
+ * «slide-over» case: equal-height rectangles overlapping horizontally have all
+ * their edge intersections on collinear stretches, so nothing «properly
+ * crosses» and nothing is strictly inside. A real polygon intersection area
+ * settles it; legal full nesting (island rooms) stays legal.
+ */
+export function illegalOverlap(a: number[][], b: number[][], eps: number): boolean {
+  if (roomsOverlap(a, b, eps)) return true;
+  if (polyContainsPoly(a, b, eps) || polyContainsPoly(b, a, eps)) return false;
+  let area = 0;
+  try {
+    const res = intersection(
+      [[...a.map((p) => [p[0], p[1]]), [a[0][0], a[0][1]]]] as any,
+      [[...b.map((p) => [p[0], p[1]]), [b[0][0], b[0][1]]]] as any,
+    );
+    for (const poly of res as any) if (poly?.[0]) area += polygonArea(poly[0]);
+  } catch {
+    return false; // a degenerate clip must not block the drag; the other stops still hold
+  }
+  return area > Math.max(1e-7, eps * eps);
+}
+
+// ---------------- mechanism A: the full drag pipeline ----------------
+
+export function planEdgeDrag(rooms: RoomIn[], roomId: string, edge: number): EdgeDragPlan | null {
+  const room = rooms.find((r) => r.id === roomId);
+  if (!room || !room.poly || room.poly.length < 3) return null;
+  if (edge < 0 || edge >= room.poly.length) return null;
+  const a = [...room.poly[edge]];
+  const b = [...room.poly[(edge + 1) % room.poly.length]];
+  return { roomId, edge, a, b, n: edgeNormal(room.poly, edge) };
+}
+
+/** Apply the drag at distance d: own edge + every coinciding neighbour stretch. */
+export function applyEdgeDrag(
+  rooms: RoomIn[], openings: OpeningIn[], plan: EdgeDragPlan, d: number, eps: number,
+): EdgeDragResult {
+  const D: [number, number] = [plan.n[0] * d, plan.n[1] * d];
+  const res: EdgeDragResult = { polys: {}, openings: {}, movedSpans: {} };
+  if (Math.abs(d) < 1e-9) return res;
+  for (const r of rooms) {
+    if (r.id === plan.roomId) {
+      res.polys[r.id] = movePolyEdge(r.poly, plan.edge, d, plan.n);
+      res.movedSpans[r.id] = [[add2(plan.a, D), add2(plan.b, D)]];
+      continue;
+    }
+    const spans = sharedSpansWith(r.poly, plan.a, plan.b, eps);
+    if (!spans.length) continue;
+    const shifted = shiftSharedSpans(r.poly, plan.a, plan.b, D, eps);
+    if (shifted) {
+      res.polys[r.id] = shifted;
+      res.movedSpans[r.id] = spans.map(([p, q]) => [add2(p, D), add2(q, D)] as [number[], number[]]);
+    }
+  }
+  // openings ON the moving wall travel with it (docs/RESIZE.md: anchors)
+  for (const o of openings) {
+    if (distPointToSpan([o.x, o.y], plan.a, plan.b) <= eps) res.openings[o.id] = [o.x + D[0], o.y + D[1]];
+  }
+  return res;
+}
+
+/** An opening must sit fully on ONE wall of some room: centre on the edge, both ends within it. */
+function openingFits(o: { x: number; y: number; length: number }, polys: number[][][], eps: number): boolean {
+  for (const poly of polys) {
+    for (let j = 0; j < poly.length; j++) {
+      const q1 = poly[j], q2 = poly[(j + 1) % poly.length];
+      const e = sub(q2, q1);
+      const elen = len2d(e);
+      if (elen < eps) continue;
+      const u = [e[0] / elen, e[1] / elen];
+      const off = Math.abs((o.x - q1[0]) * u[1] - (o.y - q1[1]) * u[0]);
+      if (off > eps) continue;
+      const t = (o.x - q1[0]) * u[0] + (o.y - q1[1]) * u[1];
+      if (t - o.length / 2 >= -eps && t + o.length / 2 <= elen + eps) return true;
+    }
+  }
+  return false;
+}
+
+/** Openings that sit on any wall of any of the given (pre-move) outlines. */
+function openingsOnRooms(openings: OpeningIn[], polys: number[][][], eps: number): OpeningIn[] {
+  return openings.filter((o) =>
+    polys.some((poly) => {
+      for (let j = 0; j < poly.length; j++)
+        if (distPointToSpan([o.x, o.y], poly[j], poly[(j + 1) % poly.length]) <= eps) return true;
+      return false;
+    }),
+  );
+}
+
+export interface StopOpts {
+  minDim: number;   // canvas units (≈30 cm through cell_cm)
+  eps: number;      // collinearity epsilon (canvas units)
+}
+
+/** All the stops of docs/RESIZE.md for one candidate distance. */
+export function validateEdgeDrag(
+  rooms: RoomIn[], openings: OpeningIn[], plan: EdgeDragPlan, d: number, opts: StopOpts,
+): boolean {
+  const { minDim, eps } = opts;
+  if (!Number.isFinite(d)) return false;
+  if (Math.abs(d) < 1e-9) return true;
+  const res = applyEdgeDrag(rooms, openings, plan, d, eps);
+  const changedIds = Object.keys(res.polys);
+  const newPolyOf = (r: RoomIn) => res.polys[r.id] || r.poly;
+  for (const id of changedIds) {
+    const r = rooms.find((x) => x.id === id)!;
+    const np = res.polys[id];
+    // simple + orientation preserved + not degenerate
+    if (!polyIsSimple(np)) return false;
+    const s0 = signedArea(r.poly), s1 = signedArea(np);
+    if (Math.abs(s1) < eps || s0 * s1 <= 0) return false;
+    // minimum size: orientation-independent clearance of the moved stretches
+    // (HP-1550-02 — the parallel-walls-only measure left triangles and other
+    // non-parallel geometry without the 30 cm floor); a room already thinner
+    // keeps its clearance (improving is allowed, worsening is not)
+    const oldSpans: [number[], number[]][] = id === plan.roomId
+      ? [[plan.a, plan.b]]
+      : sharedSpansWith(r.poly, plan.a, plan.b, eps);
+    const cOld = minSpanClearance(r.poly, oldSpans, eps);
+    const cNew = minSpanClearance(np, res.movedSpans[id] || [], eps);
+    if (cNew < Math.min(minDim, cOld) - eps) return false;
+    // every pre-existing room relationship must SURVIVE the drag: an island
+    // stays an island (a jump fully past a thin island crosses no edge, so
+    // containment is checked explicitly), a nested room stays inside its
+    // parent, and unrelated rooms must not start sharing area or nesting
+    for (const other of rooms) {
+      if (other.id === id) continue;
+      const otherNew = newPolyOf(other);
+      if (polyContainsPoly(r.poly, other.poly, eps)) {          // our island
+        if (!polyContainsPoly(np, otherNew, eps)) return false;
+        continue;
+      }
+      if (polyContainsPoly(other.poly, r.poly, eps)) {          // we are the island
+        if (!polyContainsPoly(otherNew, np, eps)) return false;
+        continue;
+      }
+      if (polyContainsPoly(np, otherNew, eps) || polyContainsPoly(otherNew, np, eps)) return false;
+      if (illegalOverlap(np, otherNew, eps)) return false;
+    }
+  }
+  // openings: everything that sat on a wall of an affected room must still fit
+  const oldPolys = changedIds.map((id) => rooms.find((x) => x.id === id)!.poly);
+  const allNew = rooms.map(newPolyOf);
+  for (const o of openingsOnRooms(openings, oldPolys, eps * 2)) {
+    const c = res.openings[o.id];
+    const moved = c ? { ...o, x: c[0], y: c[1] } : o;
+    if (!openingFits(moved, allNew, eps * 2)) return false;
+  }
+  return true;
+}
+
+/**
+ * Largest valid distance toward dWanted, stepping back by `step` (the grid
+ * pitch, so a stopped wall still lands on the grid). 0 = the wall stays put.
+ */
+export function clampEdgeDrag(
+  rooms: RoomIn[], openings: OpeningIn[], plan: EdgeDragPlan, dWanted: number, step: number, opts: StopOpts,
+): number {
+  if (!Number.isFinite(dWanted) || Math.abs(dWanted) < 1e-9) return 0;
+  const sign = Math.sign(dWanted);
+  let mag = Math.abs(dWanted);
+  const s = Math.max(step, 1e-6);
+  for (let guard = 0; guard < 4096 && mag > 1e-9; guard++, mag -= s) {
+    const d = sign * mag;
+    if (validateEdgeDrag(rooms, openings, plan, d, opts)) return d;
+  }
+  return 0;
+}
+
+// ---------------- mechanism B: the scale frame ----------------
+
+export interface ScaleResult {
+  poly: number[][];
+  openings: Record<string, [number, number]>;
+}
+
+/** Uniform scale of the room about `fixed`; exclusive openings follow, shared ones stay. */
+export function applyRoomScale(
+  room: RoomIn, openings: OpeningIn[], otherPolys: number[][][], fixed: [number, number], k: number, eps: number,
+): ScaleResult {
+  const scalePt = (p: number[]) => [fixed[0] + (p[0] - fixed[0]) * k, fixed[1] + (p[1] - fixed[1]) * k];
+  const res: ScaleResult = { poly: room.poly.map(scalePt), openings: {} };
+  for (const o of openings) {
+    let on = false;
+    for (let j = 0; j < room.poly.length; j++)
+      if (distPointToSpan([o.x, o.y], room.poly[j], room.poly[(j + 1) % room.poly.length]) <= eps) { on = true; break; }
+    if (!on) continue;
+    // an opening on a wall shared with a neighbour belongs to the neighbour's
+    // wall once the scale detaches ours — it stays put (docs/RESIZE.md)
+    const shared = otherPolys.some((poly) => {
+      for (let j = 0; j < poly.length; j++)
+        if (distPointToSpan([o.x, o.y], poly[j], poly[(j + 1) % poly.length]) <= eps) return true;
+      return false;
+    });
+    if (!shared) {
+      const c = scalePt([o.x, o.y]);
+      res.openings[o.id] = [c[0], c[1]];
+    }
+  }
+  return res;
+}
+
+/** Stops for one candidate scale factor (neighbours are never dragged along). */
+export function validateRoomScale(
+  rooms: RoomIn[], openings: OpeningIn[], roomId: string, fixed: [number, number], k: number, opts: StopOpts,
+): boolean {
+  const { minDim, eps } = opts;
+  if (!Number.isFinite(k) || k <= 0) return false;
+  if (Math.abs(k - 1) < 1e-9) return true;
+  const room = rooms.find((r) => r.id === roomId);
+  if (!room) return false;
+  const otherPolys = rooms.filter((r) => r.id !== roomId).map((r) => r.poly);
+  const res = applyRoomScale(room, openings, otherPolys, fixed, k, eps * 2);
+  const np = res.poly;
+  // minimum size: a similarity scales every distance by exactly k, so the TRUE
+  // minimum width of the original scales to k·w0 (HP-1550-02 — the axis-aligned
+  // bbox side let a rotated rectangle shrink its real short side unchecked);
+  // an already-thin room keeps the improve-only rule
+  const w0 = minPolyWidth(room.poly);
+  if (w0 * k < Math.min(minDim, w0) - eps) return false;
+  // the neighbour is a wall to hit: pre-existing nesting must survive,
+  // everything else must not gain shared area or become nested (engulfing a
+  // foreign room via scale is a stop, not a new island)
+  for (const r of rooms) {
+    if (r.id === roomId) continue;
+    if (polyContainsPoly(room.poly, r.poly, eps)) {             // our island
+      if (!polyContainsPoly(np, r.poly, eps)) return false;
+      continue;
+    }
+    if (polyContainsPoly(r.poly, room.poly, eps)) {             // we are the island
+      if (!polyContainsPoly(r.poly, np, eps)) return false;
+      continue;
+    }
+    if (polyContainsPoly(np, r.poly, eps) || polyContainsPoly(r.poly, np, eps)) return false;
+    if (illegalOverlap(np, r.poly, eps)) return false;
+  }
+  // openings of this room (moved or kept) must still fit on some wall
+  const allNew = rooms.map((r) => (r.id === roomId ? np : r.poly));
+  for (const o of openingsOnRooms(openings, [room.poly], eps * 2)) {
+    const c = res.openings[o.id];
+    const moved = c ? { ...o, x: c[0], y: c[1] } : o;
+    if (!openingFits(moved, allNew, eps * 2)) return false;
+  }
+  return true;
+}
+
+/** Closest valid factor to kWanted (bisecting toward 1, which is always valid). */
+export function clampRoomScale(
+  rooms: RoomIn[], openings: OpeningIn[], roomId: string, fixed: [number, number], kWanted: number, opts: StopOpts,
+): number {
+  if (!Number.isFinite(kWanted) || kWanted <= 0) return 1;
+  if (validateRoomScale(rooms, openings, roomId, fixed, kWanted, opts)) return kWanted;
+  let good = 1, bad = kWanted;
+  for (let i = 0; i < 28; i++) {
+    const mid = (good + bad) / 2;
+    if (validateRoomScale(rooms, openings, roomId, fixed, mid, opts)) good = mid;
+    else bad = mid;
+  }
+  return good;
+}
+
+// ---------------- live numbers ----------------
+
+/** Room area in m² from render units via the grid scale. */
+export function areaM2(poly: number[][], gridPitch: number, cellCm: number): number {
+  const cmPerUnit = cellCm / gridPitch;
+  return (polygonArea(poly) * cmPerUnit * cmPerUnit) / 1e4;
+}
+
+/** "12.4 m²" or "133 ft²" per the HA unit system. */
+export function formatArea(m2: number, imperial: boolean): string {
+  if (imperial) return `${Math.round(m2 * 10.7639)} ft²`;
+  return `${(Math.round(m2 * 10) / 10).toFixed(1)} m²`;
+}

src/space-render.ts

@@ -8,7 +8,7 @@
  */
 import { html, svg, nothing, type TemplateResult } from 'lit';
 import { buildDevices, areaLqi, areaLights, areaTemp } from './devices';
-import { spaceDisplayOf, roomFillStyle, fillColorsOf, roomFillModeOf } from './logic';
+import { spaceDisplayOf, roomFillStyle, fillColorsOf, roomFillModeOf, stageBgOf } from './logic';
 import { DEFAULT_ICON_RULES, compileIconRules, EXCLUDED_DOMAINS } from './rules';
 import { t, type Lang } from './i18n';
 import type { ServerConfig } from './types';
@@ -146,9 +146,11 @@ export function renderSpaceStatic(o: StaticRenderOpts): TemplateResult | null {
     : [];
 
   const bgHref = space.bg ? (o.displayUrl ? o.displayUrl(space.bg.href) : space.bg.href) : '';
+  // the static card paints the same background around the plan as the full one
+  const stageBg = stageBgOf(o.cfg?.settings, disp);
 
   return html`
-    <div class="hp-static-stage" style="aspect-ratio:${vb[2]}/${vb[3]}">
+    <div class="hp-static-stage" style="aspect-ratio:${vb[2]}/${vb[3]}${stageBg ? ';background:' + stageBg : ''}">
       <svg viewBox="${vb[0]} ${vb[1]} ${vb[2]} ${vb[3]}" preserveAspectRatio="xMidYMid meet">
         ${bgHref
           ? svg`<image href="${bgHref}" x="${space.bg!.x}" y="${space.bg!.y}" width="${space.bg!.w}" height="${space.bg!.h}" preserveAspectRatio="none" />`

src/styles.ts

@@ -151,6 +151,53 @@ export const cardStyles = css`
       position: absolute;
       inset: 0;
     }
+    /* HP-1552: first-open boot veil — the plan hides until the stage height settles */
+    .stage.hpboot .zoomwrap,
+    .stage.hpboot .zoombadge {
+      visibility: hidden;
+    }
+    /* AUD-1552-02: post-veil grace — HA chrome landing after the cap moves
+       the stage height smoothly; the viewport ResizeObserver refits the plan
+       along the transition, so a late panel glides instead of jumping. */
+    .stage.hpsettle {
+      transition: height 0.25s ease;
+    }
+    .bootveil {
+      position: absolute;
+      inset: 0;
+      z-index: 40;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      background: var(--hp-bg, #16212e);
+      opacity: 1;
+      transition: opacity 0.15s ease;
+      pointer-events: none;
+    }
+    .bootveil.off {
+      opacity: 0;
+    }
+    .bootveil .boothouse {
+      position: static; /* .stage svg pins itself to inset:0 — not this one */
+      width: 56px;
+      height: 56px;
+      fill: var(--hp-accent);
+      opacity: 0.85;
+      animation: hp-boot-pulse 1.3s ease-in-out infinite;
+    }
+    @keyframes hp-boot-pulse {
+      0%, 100% { opacity: 0.3; transform: scale(0.94); }
+      50% { opacity: 0.9; transform: scale(1); }
+    }
+    @media (prefers-reduced-motion: reduce) {
+      .bootveil .boothouse {
+        animation: none;
+        opacity: 0.7;
+      }
+      .stage.hpsettle {
+        transition: none;
+      }
+    }
     .zoomctl {
       display: inline-flex;
       gap: 2px;
@@ -262,6 +309,15 @@ export const cardStyles = css`
     .stage.markup .op-hit:active {
       cursor: grabbing;
     }
+    /* HP-1550-04: in the resize tool the wall handles own the hit test — the
+       transparent .op-hit of a door at the midpoint of a wall used to sit ON
+       TOP of the handle and made that wall ungrabbable for both rooms.
+       Openings are not editable in this tool (they ride along with the wall),
+       so their hit area goes fully inert; every other Plan tool is untouched. */
+    .stage.markup.tool-resize .op-hit {
+      pointer-events: none;
+      cursor: default;
+    }
     .oplock {
       pointer-events: none; /* inert while editing; clickable in View (rule below) */
       position: absolute;
@@ -866,12 +922,16 @@ export const cardStyles = css`
       width: 130px;
     }
     .dev.valonly {
+      /* all satellite metrics from --dev-size, not --icon-size: the per-device
+         size multiplier must scale the value plate with its marker — same bug
+         class as the v1.51.3 glyph fix (pinned to base size, the multiplier
+         grew nothing). */
       width: auto;
       min-width: var(--dev-size, var(--icon-size, 2.5cqw));
-      padding: 0 calc(var(--icon-size, 2.5cqw) * 0.16);
+      padding: 0 calc(var(--dev-size, var(--icon-size, 2.5cqw)) * 0.16);
     }
     .dev.valonly .valtext {
-      font-size: calc(var(--icon-size, 2.5cqw) * 0.45);
+      font-size: calc(var(--dev-size, var(--icon-size, 2.5cqw)) * 0.45);
       font-weight: 700;
       white-space: nowrap;
     }
@@ -879,11 +939,66 @@ export const cardStyles = css`
     /* v1.52.0: the RGB tint of the icon/border is gone — a lamp's colour
        lives ONLY in its glow spot (owner's rule). The ripple-color fallback
        keeps using the light colour; that is set inline via --ripple-color. */
+    /* Owner's rule (2026-08-01, вариант «б»): «движение = разовая вспышка
+       в момент обнаружения; cool-down не пульсирует; присутствие =
+       статичное кольцо пока обитаемо». The yellow FILL stays reserved for
+       «включено» — both sense states keep the neutral badge. Both rings
+       are declared BEFORE .dev.alarm on purpose: equal specificity on the
+       shared ::after means the later alarm rule wins if a device ever
+       carries both — red beats yellow. */
+    /* MOTION tripped: a short ONE-SHOT flash — three beats of the yellow
+       ring (3 × 1.1s), then silence, even while the entity still reports
+       'on' (that tail is the sensor's cool-down, not motion). The
+       iteration count is FINITE, and the card itself drops the class
+       ~3.3s after the off→on transition (_senseTick/_stateClass in
+       houseplan-card.ts); base opacity 0 keeps the ring invisible should
+       the class outlive the animation by a frame. */
+    .dev.senseflash::after {
+      content: '';
+      position: absolute;
+      inset: calc(var(--dev-size, var(--icon-size, 2.5cqw)) * -0.35);
+      border: 2px solid var(--hp-on);
+      border-radius: 50%;
+      opacity: 0;
+      animation: hp-sense 1.1s ease-in-out 3;
+      pointer-events: none;
+    }
+    /* HP-1543-02: a rapid off→on retrip must RESTART the flash. The card
+       flips the .sf2 marker on every trip (_senseTick generation parity);
+       hp-sense-b duplicates hp-sense exactly — switching the animation-name
+       is what makes the browser abandon the old timeline and start a fresh
+       one on the same pseudo-element (a same-name animation never restarts
+       while the class stays on). */
+    .dev.senseflash.sf2::after { animation-name: hp-sense-b; }
+    /* OCCUPANCY/PRESENCE while 'on': a calm STATIC ring, no animation —
+       «комната обитаема» is a state, not an event, so it must not blink.
+       Brightness matches the reduced-motion variant of the flash. */
+    .dev.sensehold::after {
+      content: '';
+      position: absolute;
+      inset: calc(var(--dev-size, var(--icon-size, 2.5cqw)) * -0.35);
+      border: 2px solid var(--hp-on);
+      border-radius: 50%;
+      opacity: 0.4;
+      pointer-events: none;
+    }
+    @keyframes hp-sense {
+      0% { transform: scale(0.9); opacity: 0.5; }
+      60% { transform: scale(1.12); opacity: 0.12; }
+      100% { transform: scale(1.12); opacity: 0; }
+    }
+    /* identical twin of hp-sense — exists ONLY as the alternate animation
+       identity for the retrip restart (HP-1543-02), keep the two in sync */
+    @keyframes hp-sense-b {
+      0% { transform: scale(0.9); opacity: 0.5; }
+      60% { transform: scale(1.12); opacity: 0.12; }
+      100% { transform: scale(1.12); opacity: 0; }
+    }
     /* alarms pulse red over everything */
     .dev.alarm::after {
       content: '';
       position: absolute;
-      inset: calc(var(--icon-size, 2.5cqw) * -0.35);
+      inset: calc(var(--dev-size, var(--icon-size, 2.5cqw)) * -0.35);
       border: 3px solid #f25a4a;
       border-radius: 50%;
       animation: hp-alarm 1s ease-out infinite;
@@ -895,13 +1010,18 @@ export const cardStyles = css`
     }
     @media (prefers-reduced-motion: reduce) {
       .dev.alarm::after { animation: none; opacity: 0.9; }
+      /* the motion flash becomes a static ring for the same ~3.3s class
+         window — consistent with alarm's treatment; sensehold is static
+         by design already */
+      .dev.senseflash::after,
+      .dev.senseflash.sf2::after { animation: none; opacity: 0.4; } /* HP-1543-02: retrip re-arms the window, ring stays static */
     }
     .dev .newdot {
       position: absolute;
-      top: calc(var(--icon-size, 2.5cqw) * -0.12);
-      right: calc(var(--icon-size, 2.5cqw) * -0.12);
-      width: calc(var(--icon-size, 2.5cqw) * 0.34);
-      height: calc(var(--icon-size, 2.5cqw) * 0.34);
+      top: calc(var(--dev-size, var(--icon-size, 2.5cqw)) * -0.12);
+      right: calc(var(--dev-size, var(--icon-size, 2.5cqw)) * -0.12);
+      width: calc(var(--dev-size, var(--icon-size, 2.5cqw)) * 0.34);
+      height: calc(var(--dev-size, var(--icon-size, 2.5cqw)) * 0.34);
       border-radius: 50%;
       background: #f0301f;
       border: 2px solid var(--card-background-color, var(--hp-bg));
@@ -993,14 +1113,14 @@ export const cardStyles = css`
       left: 100%;
       top: 50%;
       transform: translateY(-50%);
-      margin-left: calc(var(--icon-size, 2.5cqw) * 0.1);
+      margin-left: calc(var(--dev-size, var(--icon-size, 2.5cqw)) * 0.1);
       background: var(--card-background-color, var(--hp-bg));
       border: 1px solid var(--hp-accent);
-      border-radius: calc(var(--icon-size, 2.5cqw) * 0.18);
-      padding: 0 calc(var(--icon-size, 2.5cqw) * 0.14);
+      border-radius: calc(var(--dev-size, var(--icon-size, 2.5cqw)) * 0.18);
+      padding: 0 calc(var(--dev-size, var(--icon-size, 2.5cqw)) * 0.14);
       font-size: calc(var(--dev-size, var(--icon-size, 2.5cqw)) * 0.45);
       font-weight: 700;
-      line-height: calc(var(--icon-size, 2.5cqw) * 0.68);
+      line-height: calc(var(--dev-size, var(--icon-size, 2.5cqw)) * 0.68);
       color: var(--hp-txt);
       white-space: nowrap;
       pointer-events: none;
@@ -1010,14 +1130,14 @@ export const cardStyles = css`
       left: 100%;
       top: 50%;
       transform: translateY(-50%);
-      margin-left: calc(var(--icon-size, 2.5cqw) * 0.1);
+      margin-left: calc(var(--dev-size, var(--icon-size, 2.5cqw)) * 0.1);
       background: var(--card-background-color, var(--hp-bg));
       border: 1px solid #4fc3f7;
-      border-radius: calc(var(--icon-size, 2.5cqw) * 0.18);
-      padding: 0 calc(var(--icon-size, 2.5cqw) * 0.14);
+      border-radius: calc(var(--dev-size, var(--icon-size, 2.5cqw)) * 0.18);
+      padding: 0 calc(var(--dev-size, var(--icon-size, 2.5cqw)) * 0.14);
       font-size: calc(var(--dev-size, var(--icon-size, 2.5cqw)) * 0.45);
       font-weight: 700;
-      line-height: calc(var(--icon-size, 2.5cqw) * 0.68);
+      line-height: calc(var(--dev-size, var(--icon-size, 2.5cqw)) * 0.68);
       color: var(--hp-txt);
       white-space: nowrap;
       pointer-events: none;
@@ -1027,8 +1147,8 @@ export const cardStyles = css`
       top: 100%;
       left: 50%;
       transform: translateX(-50%);
-      margin-top: calc(var(--icon-size, 2.5cqw) * 0.05);
-      font-size: calc(var(--icon-size, 2.5cqw) * 0.38);
+      margin-top: calc(var(--dev-size, var(--icon-size, 2.5cqw)) * 0.05);
+      font-size: calc(var(--dev-size, var(--icon-size, 2.5cqw)) * 0.38);
       font-weight: 700;
       line-height: 1;
       text-shadow: 0 0 3px rgba(0, 0, 0, 0.9), 0 0 2px rgba(0, 0, 0, 0.9);
@@ -1338,6 +1458,50 @@ export const cardStyles = css`
       pointer-events: none;
       user-select: none;
     }
+    /* room resize tool (docs/RESIZE.md) */
+    /* wall handle: invisible finger-sized hit circle (HP-1550-04 hit priority
+       kept), the visible glyph lives in the sibling .rszicon */
+    .rszhandle {
+      fill: transparent;
+      stroke: none;
+      pointer-events: all;
+      cursor: grab;
+      touch-action: none;
+    }
+    .rszhandle:active { cursor: grabbing; }
+    /* wall-with-arrows glyph: accent ink over a bg halo, readable on any plan */
+    .rszicon { pointer-events: none; }
+    .rszicon path {
+      fill: none;
+      stroke-linecap: round;
+      stroke-linejoin: round;
+      vector-effect: non-scaling-stroke;
+    }
+    .rszhalo { stroke: var(--hp-bg); stroke-width: 6; }
+    .rszink { stroke: var(--hp-accent); stroke-width: 2; }
+    .rszhandle:hover + .rszicon .rszink { stroke-width: 3; }
+    /* corner (scale-frame) handles keep the classic filled circle */
+    .rszcorner {
+      fill: var(--hp-bg);
+      stroke: var(--hp-accent);
+      stroke-width: 2;
+      vector-effect: non-scaling-stroke;
+      cursor: nwse-resize;
+    }
+    .rszcorner:hover { fill: var(--hp-accent); }
+    .rszcorner:active { cursor: nwse-resize; }
+    .rszframe {
+      fill: none;
+      stroke: var(--hp-accent);
+      stroke-width: 1.5;
+      stroke-dasharray: 6 5;
+      vector-effect: non-scaling-stroke;
+      pointer-events: none;
+    }
+    .measurelabel.rszarea {
+      transform: translate(-50%, -50%);
+      background: rgba(0, 0, 0, 0.6);
+    }
     .vacfitdot { fill: var(--hp-accent); pointer-events: none; }
     .vacfithandle {
       fill: var(--hp-bg);

src/vacuum.ts

@@ -94,6 +94,19 @@ export function vacMapIdFromAttrs(attrs: Record<string, any>): string {
   return String(attrs.map_name ?? attrs.current_map ?? attrs.map_index ?? attrs.selected_map ?? 'default');
 }
 
+/**
+ * The card-side fallback half of that contract (HP-1541-01): when source
+ * telemetry names no map ('default'), the vacuum entity's own selected_map
+ * decides — under the SAME not-nullish rule as above. The old truthiness
+ * check in _vacMapId turned `selected_map: 0` into 'default' while the
+ * server recorder (trails.py resolve_map_id) stored the trail under '0', so
+ * calibration and saved runs lived under a key the renderer never matched.
+ */
+export function vacMapIdWithFallback(teleMapId: string, selectedMap: unknown): string {
+  if (teleMapId !== 'default') return teleMapId;
+  return selectedMap != null ? String(selectedMap) : 'default';
+}
+
 /**
  * Normalise the attribute zoo. One parser instead of per-brand classes: the
  * three Tier-A integrations (Xiaomi Cloud Map Extractor, Tasshack

test/resize.test.mjs

@@ -0,0 +1,258 @@
+// Room resize geometry (docs/RESIZE.md): every «упор» and the T-junction
+// vertex insertion are pinned here numerically.
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {
+  edgeNormal, movePolyEdge, sharedSpansWith, shiftSharedSpans, simplifyPoly,
+  polyIsSimple, minParallelClearance, planEdgeDrag, applyEdgeDrag,
+  validateEdgeDrag, clampEdgeDrag, applyRoomScale, validateRoomScale,
+  clampRoomScale, areaM2, formatArea, MIN_ROOM_CM,
+} from '../test-build/resize.js';
+import { roomPoly } from '../test-build/logic.js';
+
+const OPTS = { minDim: 25, eps: 0.5 }; // 25 units ≈ 30 cm at cell_cm=5, pitch 1000/240
+const STEP = 5;
+
+// A: 300×300 square, right edge is index 1 ((400,100)→(400,400))
+const A = () => ({ id: 'A', poly: [[100, 100], [400, 100], [400, 400], [100, 400]] });
+// R: full-height neighbour to the right — the ENTIRE wall x=400 is shared
+const R = () => ({ id: 'R', poly: [[400, 100], [700, 100], [700, 400], [400, 400]] });
+// B: shorter neighbour to the right — T-junction (covers y 100..300 only)
+const B = () => ({ id: 'B', poly: [[400, 100], [700, 100], [700, 300], [400, 300]] });
+
+const closeTo = (got, want, tol = 1e-6) =>
+  assert.ok(Math.abs(got - want) <= tol, `expected ${want}, got ${got}`);
+const polyEq = (got, want, tol = 1e-6) => {
+  assert.equal(got.length, want.length, `vertex count: ${JSON.stringify(got)}`);
+  for (let i = 0; i < want.length; i++) {
+    closeTo(got[i][0], want[i][0], tol);
+    closeTo(got[i][1], want[i][1], tol);
+  }
+};
+
+test('edgeNormal points outward for both windings', () => {
+  const a = A();
+  assert.deepEqual(edgeNormal(a.poly, 1).map((v) => Math.round(v) + 0), [1, 0]);   // right wall → +x
+  assert.deepEqual(edgeNormal(a.poly, 3).map((v) => Math.round(v) + 0), [-1, 0]);  // left wall → −x
+  const ccw = [...a.poly].reverse(); // reversed winding, same square
+  const n = edgeNormal(ccw, ccw.findIndex((p) => p[0] === 400 && p[1] === 400));
+  assert.deepEqual(n.map((v) => Math.round(v) + 0), [1, 0]);
+});
+
+test('movePolyEdge translates BOTH edge endpoints along the normal', () => {
+  polyEq(movePolyEdge(A().poly, 1, 50), [[100, 100], [450, 100], [450, 400], [100, 400]]);
+  polyEq(movePolyEdge(A().poly, 1, -50), [[100, 100], [350, 100], [350, 400], [100, 400]]);
+});
+
+test('legacy x/y/w/h rectangles resize through roomPoly', () => {
+  const poly = roomPoly({ x: 100, y: 100, w: 300, h: 300 });
+  polyEq(movePolyEdge(poly, 1, 50), [[100, 100], [450, 100], [450, 400], [100, 400]]);
+});
+
+test('full shared wall: the neighbour moves synchronously, no gap by construction', () => {
+  const rooms = [A(), R()];
+  const plan = planEdgeDrag(rooms, 'A', 1);
+  const res = applyEdgeDrag(rooms, [], plan, 50, OPTS.eps);
+  polyEq(res.polys.A, [[100, 100], [450, 100], [450, 400], [100, 400]]);
+  polyEq(res.polys.R, [[450, 100], [700, 100], [700, 400], [450, 400]]); // R shrank, walls still coincide
+});
+
+test('T-junction: only the coinciding stretch of the neighbour moves, vertices are inserted', () => {
+  const rooms = [A(), B()];
+  // drag B's left wall (edge 3: (400,300)→(400,100)) 50 units INTO A
+  const plan = planEdgeDrag(rooms, 'B', 3);
+  assert.deepEqual(plan.n.map((v) => Math.round(v) + 0), [-1, 0]);
+  const res = applyEdgeDrag(rooms, [], plan, 50, OPTS.eps);
+  polyEq(res.polys.B, [[350, 100], [700, 100], [700, 300], [350, 300]]);
+  // A becomes L-shaped: the shared stretch (y 100..300) caves in, the rest stays
+  polyEq(res.polys.A, [[100, 100], [350, 100], [350, 300], [400, 300], [400, 400], [100, 400]]);
+});
+
+test('stop: own room minimum size (~30 cm)', () => {
+  const rooms = [A()];
+  const plan = planEdgeDrag(rooms, 'A', 1);
+  assert.equal(validateEdgeDrag(rooms, [], plan, -280, OPTS), false); // width 20 < 25
+  assert.equal(validateEdgeDrag(rooms, [], plan, -275, OPTS), true);  // width 25 — the floor
+  closeTo(clampEdgeDrag(rooms, [], plan, -280, STEP, OPTS), -275);
+});
+
+test('stop: the shrinking neighbour keeps its minimum size too', () => {
+  const rooms = [A(), R()];
+  const plan = planEdgeDrag(rooms, 'A', 1);
+  assert.equal(validateEdgeDrag(rooms, [], plan, 290, OPTS), false); // R would be 10 wide
+  closeTo(clampEdgeDrag(rooms, [], plan, 290, STEP, OPTS), 275);     // R stays 25
+});
+
+test('stop: a growing wall may touch a foreign room but never overlap it', () => {
+  const F = { id: 'F', poly: [[500, 100], [700, 100], [700, 400], [500, 400]] };
+  const rooms = [A(), F];
+  const plan = planEdgeDrag(rooms, 'A', 1);
+  assert.equal(validateEdgeDrag(rooms, [], plan, 150, OPTS), false); // crosses F
+  assert.equal(validateEdgeDrag(rooms, [], plan, 100, OPTS), true);  // touching = legal shared wall
+  closeTo(clampEdgeDrag(rooms, [], plan, 150, STEP, OPTS), 100);
+});
+
+test('stop: islands (islandsOf) block the wall, including a jump fully past them', () => {
+  const P = { id: 'P', poly: [[100, 100], [500, 100], [500, 500], [100, 500]] };
+  const I = { id: 'I', poly: [[250, 250], [350, 250], [350, 350], [250, 350]] };
+  const rooms = [P, I];
+  const plan = planEdgeDrag(rooms, 'P', 1); // right wall of the parent
+  assert.equal(validateEdgeDrag(rooms, [], plan, -200, OPTS), false); // wall at 300 cuts the island
+  assert.equal(validateEdgeDrag(rooms, [], plan, -280, OPTS), false); // wall at 220 — island fully outside (no edge crossing!)
+  assert.equal(validateEdgeDrag(rooms, [], plan, -155, OPTS), false); // wall at 345 crosses the island
+  assert.equal(validateEdgeDrag(rooms, [], plan, -150, OPTS), true);  // wall at 350 — flush with the island is a touch, legal
+  closeTo(clampEdgeDrag(rooms, [], plan, -280, STEP, OPTS), -150);
+});
+
+test('openings: a door ON the moving wall travels with it', () => {
+  const rooms = [A(), R()];
+  const plan = planEdgeDrag(rooms, 'A', 1);
+  const ops = [{ id: 'o1', x: 400, y: 200, length: 60 }];
+  const res = applyEdgeDrag(rooms, ops, plan, 50, OPTS.eps);
+  assert.deepEqual(res.openings.o1, [450, 200]);
+  assert.equal(validateEdgeDrag(rooms, ops, plan, 50, OPTS), true);
+});
+
+test('stop: a side wall cannot get too short for its opening (own room)', () => {
+  const rooms = [A()];
+  const plan = planEdgeDrag(rooms, 'A', 1);
+  const ops = [{ id: 'o2', x: 350, y: 100, length: 80 }]; // top wall, spans x 310..390
+  assert.equal(validateEdgeDrag(rooms, ops, plan, -50, OPTS), false); // top wall ends at 350 < 390
+  assert.equal(validateEdgeDrag(rooms, ops, plan, -10, OPTS), true);  // ends exactly at 390
+  closeTo(clampEdgeDrag(rooms, ops, plan, -50, STEP, OPTS), -10);
+});
+
+test('stop: the neighbour’s opening anchors the drag too', () => {
+  const rooms = [A(), R()];
+  const plan = planEdgeDrag(rooms, 'A', 1);
+  const ops = [{ id: 'o3', x: 460, y: 100, length: 40 }]; // R’s top wall, spans x 440..480
+  // the wall corner may not land INSIDE the door: at d=50 the joint (x=450)
+  // would sit in the middle of the opening — that is the «упор»
+  assert.equal(validateEdgeDrag(rooms, ops, plan, 50, OPTS), false);
+  assert.equal(validateEdgeDrag(rooms, ops, plan, 40, OPTS), true);   // joint exactly at the door edge
+  closeTo(clampEdgeDrag(rooms, ops, plan, 50, STEP, OPTS), 40);
+  // fully past the door the opening sits on the GROWN room's wall — the
+  // composite wall y=100 never shortens, so this is legal by construction
+  assert.equal(validateEdgeDrag(rooms, ops, plan, 100, OPTS), true);
+});
+
+test('scale: all vertices scale proportionally about the fixed corner', () => {
+  const res = applyRoomScale(A(), [], [], [100, 100], 1.5, OPTS.eps);
+  polyEq(res.poly, [[100, 100], [550, 100], [550, 550], [100, 550]]);
+});
+
+test('scale stops: minimum size and the neighbour as a hard wall', () => {
+  const F = { id: 'F', poly: [[500, 100], [700, 100], [700, 400], [500, 400]] };
+  const rooms = [A(), F];
+  assert.equal(validateRoomScale(rooms, [], 'A', [100, 100], 0.05, OPTS), false); // 15 < 25
+  const kMin = clampRoomScale(rooms, [], 'A', [100, 100], 0.05, OPTS);
+  closeTo(kMin * 300, 25, 0.5); // clamped at the 30 cm floor
+  assert.equal(validateRoomScale(rooms, [], 'A', [100, 100], 2, OPTS), false);    // overlaps F
+  const kMax = clampRoomScale(rooms, [], 'A', [100, 100], 2, OPTS);
+  closeTo(kMax, 400 / 300, 1e-3); // right wall lands exactly on F
+});
+
+test('scale never drags the neighbour; a SHARED opening stays with the neighbour wall', () => {
+  const rooms = [A(), R()];
+  const shared = { id: 'os', x: 400, y: 200, length: 60 };   // on the shared wall
+  const own = { id: 'oo', x: 100, y: 200, length: 60 };      // on A’s left wall only
+  const res = applyRoomScale(A(), [shared, own], [R().poly], [400, 400], 0.5, OPTS.eps);
+  assert.equal(res.openings.os, undefined);                  // stays put
+  assert.deepEqual(res.openings.oo, [250, 300]);             // follows the transform
+  assert.equal(validateRoomScale(rooms, [shared], 'A', [400, 400], 0.5, OPTS), true);
+});
+
+test('scale stop: an exclusive opening must still fit', () => {
+  const rooms = [A()];
+  const ops = [{ id: 'o4', x: 250, y: 100, length: 200 }]; // top wall, needs 200 units
+  assert.equal(validateRoomScale(rooms, ops, 'A', [100, 100], 0.5, OPTS), false); // wall 150 < opening 200
+  const k = clampRoomScale(rooms, ops, 'A', [100, 100], 0.5, OPTS);
+  // the opening centre scales too: it fits while 100·(1−1.5k) ≤ ε, i.e. k ≥ 0.66
+  closeTo(k, 0.66, 1e-3);
+});
+
+test('shared spans + shiftSharedSpans invariants', () => {
+  const spans = sharedSpansWith(B().poly, [400, 100], [400, 400], OPTS.eps);
+  assert.equal(spans.length, 1);
+  polyEq([spans[0][0], spans[0][1]].sort((p, q) => p[1] - q[1]), [[400, 100], [400, 300]]);
+  assert.equal(shiftSharedSpans(A().poly, [900, 100], [900, 400], [10, 0], OPTS.eps), null); // nothing coincides
+});
+
+test('simplifyPoly drops collinear leftovers, polyIsSimple flags a bowtie', () => {
+  polyEq(simplifyPoly([[0, 0], [50, 0], [100, 0], [100, 100], [0, 100]]), [[0, 0], [100, 0], [100, 100], [0, 100]]);
+  assert.equal(polyIsSimple([[0, 0], [100, 100], [100, 0], [0, 100]]), false);
+  assert.equal(polyIsSimple(A().poly), true);
+});
+
+test('minParallelClearance: the opposite-wall distance', () => {
+  closeTo(minParallelClearance(A().poly, [[[400, 100], [400, 400]]], OPTS.eps), 300);
+  // L-shape: only walls with an OVERLAPPING projection count — the x=80 wall
+  // spans y 60..200 and casts no shadow on the y 0..60 span, so the opposite
+  // wall is x=0 at distance 200 (the x=80 obstruction is the simplicity stop)
+  const L = [[0, 0], [200, 0], [200, 60], [80, 60], [80, 200], [0, 200]];
+  closeTo(minParallelClearance(L, [[[200, 0], [200, 60]]], OPTS.eps), 200);
+});
+
+test('live numbers: areaM2 and formatArea', () => {
+  const pitch = 1000 / 240;
+  const poly = [[0, 0], [100, 0], [100, 100], [0, 100]]; // 24 cells → 120 cm a side
+  closeTo(areaM2(poly, pitch, 5), 1.44, 1e-9);
+  assert.equal(formatArea(1.44, false), '1.4 m²');
+  assert.equal(formatArea(1.44, true), '16 ft²');
+  assert.equal(MIN_ROOM_CM, 30);
+});
+
+test('zero drag is always valid and clamps to zero', () => {
+  const rooms = [A()];
+  const plan = planEdgeDrag(rooms, 'A', 1);
+  assert.equal(validateEdgeDrag(rooms, [], plan, 0, OPTS), true);
+  assert.equal(clampEdgeDrag(rooms, [], plan, 0, STEP, OPTS), 0);
+});
+
+// ================= HP-1550-02 (the v1.55.0 audit): the 30 cm floor must be
+// orientation-independent — triangles have no parallel opposite wall and a
+// rotated rectangle hides its true short side from the axis-aligned bbox.
+
+test('HP-1550-02: triangle — the min-size stop holds without a parallel opposite wall', () => {
+  // base 300 wide, apex 300 above it; drag the base toward the apex
+  const T = { id: 'T', poly: [[0, 0], [300, 0], [150, 300]] };
+  const rooms = [T];
+  const plan = planEdgeDrag(rooms, 'T', 0);
+  assert.deepEqual(plan.n.map((v) => Math.round(v) + 0), [0, -1]); // outward = away from the apex
+  assert.equal(validateEdgeDrag(rooms, [], plan, -295, OPTS), false); // height 5 < 25
+  const d = clampEdgeDrag(rooms, [], plan, -295, STEP, OPTS);
+  const height = 300 - Math.abs(d);
+  assert.ok(height >= OPTS.minDim - OPTS.eps, `triangle squeezed to height ${height}`);
+});
+
+test('HP-1550-02: rotated rectangle — scale stops at the TRUE short side, not the bbox', () => {
+  // 500×100 rectangle rotated 45°: its axis-aligned bbox is ≈424×424, so the
+  // bbox measure let k=0.1 slip through while the real short side became 10
+  const c45 = Math.SQRT1_2;
+  const rot = ([x, y]) => [x * c45 - y * c45, x * c45 + y * c45];
+  const P = [[0, 0], [500, 0], [500, 100], [0, 100]].map(rot);
+  const rooms = [{ id: 'S', poly: P }];
+  const fixed = [P[0][0], P[0][1]];
+  assert.equal(validateRoomScale(rooms, [], 'S', fixed, 0.1, OPTS), false); // side 10 < 25
+  const k = clampRoomScale(rooms, [], 'S', fixed, 0.1, OPTS);
+  assert.ok(k * 100 >= OPTS.minDim - OPTS.eps, `short side shrank to ${k * 100}`);
+});
+
+test('HP-1550-02: concave room — a non-parallel obstacle stops the drag', () => {
+  // a "roof" vertex dips into the room at (200,120); the bottom wall dragged up
+  // has NO parallel opposite wall, yet must stop ~30 cm short of the dip
+  const C = { id: 'C', poly: [[0, 0], [400, 0], [400, 200], [200, 120], [0, 200]] };
+  const rooms = [C];
+  const plan = planEdgeDrag(rooms, 'C', 0);
+  assert.equal(validateEdgeDrag(rooms, [], plan, -115, OPTS), false); // 5 from the dip
+  assert.equal(validateEdgeDrag(rooms, [], plan, -95, OPTS), true);   // 25 — the floor
+  closeTo(clampEdgeDrag(rooms, [], plan, -115, STEP, OPTS), -95);
+});
+
+test('HP-1550-02: an already-thin triangle may improve but never worsen', () => {
+  const T = { id: 'T', poly: [[0, 0], [300, 0], [150, 20]] }; // height 20 < 25 already
+  const rooms = [T];
+  const plan = planEdgeDrag(rooms, 'T', 0);
+  assert.equal(validateEdgeDrag(rooms, [], plan, -5, OPTS), false); // 20 → 15: worse
+  assert.equal(validateEdgeDrag(rooms, [], plan, 50, OPTS), true);  // 20 → 70: better
+});

test/vacuum.test.mjs

@@ -1,6 +1,6 @@
 import test from 'node:test';
 import assert from 'node:assert/strict';
-import { solveAffine, applyAffine, affineResidual, readVacTelemetry, autoCalibrate, thinPath, pushTrailPoint, isVacMoving, isVacSourceState, vacMapIdFromAttrs } from '../test-build/vacuum.js';
+import { solveAffine, applyAffine, affineResidual, readVacTelemetry, autoCalibrate, thinPath, pushTrailPoint, isVacMoving, isVacSourceState, vacMapIdFromAttrs, vacMapIdWithFallback } from '../test-build/vacuum.js';
 
 test('solveAffine recovers rotation+scale+mirror+offset exactly', () => {
   // target = mirror-X, rotate 90°, scale 0.02, offset (300, 400)
@@ -148,6 +148,33 @@ test('vacMapIdFromAttrs: first NOT-nullish value wins, zero survives', () => {
   assert.equal(vacMapIdFromAttrs({}), 'default');
 });
 
+// HP-1541-01: the vacuum-entity fallback half of the contract. Truthiness
+// here turned selected_map: 0 into 'default' while the server recorder
+// stored the trail under '0' — reloads never showed the saved run.
+test('vacMapIdWithFallback: selected_map 0 / "0" / "" survive, nullish falls back', () => {
+  assert.equal(vacMapIdWithFallback('default', 0), '0');
+  assert.equal(vacMapIdWithFallback('default', '0'), '0');
+  assert.equal(vacMapIdWithFallback('default', ''), '');
+  assert.equal(vacMapIdWithFallback('default', 'Vac'), 'Vac');
+  assert.equal(vacMapIdWithFallback('default', null), 'default');
+  assert.equal(vacMapIdWithFallback('default', undefined), 'default');
+  assert.equal(vacMapIdWithFallback('1', 0), '1'); // telemetry wins over fallback
+});
+
+// HP-1541-01 cross-runtime contract: for the same inputs the card-side chain
+// (vacMapIdFromAttrs -> vacMapIdWithFallback) must yield exactly what
+// trails.py resolve_map_id stores. Mirrored by
+// tests_backend/test_trail_recorder.py::test_map_id_contract_first_not_none_wins.
+test('map-id contract: frontend chain matches backend resolve_map_id', () => {
+  const chain = (srcAttrs, vacSel) => vacMapIdWithFallback(vacMapIdFromAttrs(srcAttrs), vacSel);
+  assert.equal(chain({}, 0), '0');
+  assert.equal(chain({}, '0'), '0');
+  assert.equal(chain({}, ''), '');
+  assert.equal(chain({}, 'Vac'), 'Vac');
+  assert.equal(chain({}, undefined), 'default');
+  assert.equal(chain({ map_index: 0 }, 'Vac'), '0'); // source wins over vacuum
+});
+
 test('readVacTelemetry keeps numeric zero map_index as map id (HP-1540-02)', () => {
   const t = readVacTelemetry({ vacuum_position: { x: 1, y: 2 }, map_index: 0 });
   assert.equal(t.mapId, '0');

tests_backend/test_trail_recorder.py

@@ -184,6 +184,18 @@ def test_map_index_zero_matches_frontend_contract():
     assert rec.book.data["m1"]["current"]["map_id"] == "0"
 
 
+def test_vacuum_selected_map_zero_fallback_recorded_as_zero():
+    # HP-1541-01: source names no map, vacuum reports selected_map: 0 — the
+    # recorder must store the run under "0", the same id the fixed card-side
+    # fallback (vacMapIdWithFallback) resolves. Before the fix the card asked
+    # for calibration/trails under "default" and never found this run.
+    rec, _hass, states = _rec()
+    states["camera.map"] = S("idle", {"vacuum_position": {"x": 10, "y": 20}})
+    states["vacuum.x50"] = S("cleaning", {"selected_map": 0})
+    assert rec._sample("camera.map", 1.0)
+    assert rec.book.data["m1"]["current"]["map_id"] == "0"
+
+
 def test_map_id_contract_first_not_none_wins():
     # HP-1540-02: the shared contract — first NOT-None value, stringified
     cases = [
@@ -194,6 +206,11 @@ def test_map_id_contract_first_not_none_wins():
         ({"current_map": 2}, {}, "2"),
         ({"selected_map": "Src"}, {"selected_map": "Vac"}, "Src"),
         ({}, {"selected_map": "Vac"}, "Vac"),
+        # HP-1541-01: the vacuum-entity fallback with a zero-ish id — must
+        # match the card's vacMapIdWithFallback (test/vacuum.test.mjs)
+        ({}, {"selected_map": 0}, "0"),
+        ({}, {"selected_map": "0"}, "0"),
+        ({}, {"selected_map": ""}, ""),
         ({}, {}, "default"),
     ]
     for src_attrs, vac_attrs, want in cases:

tests_backend/test_validation.py

@@ -164,6 +164,24 @@ def test_space_display_settings():
         v.SPACE_SCHEMA(bad_mode)
 
 
+def test_bg_color_setting():
+    """Background-around-the-plan color: strict #rrggbb, globally and per space."""
+    ok_space = {
+        "id": "f1", "title": "F", "view_box": [0, 0, 1, 1], "rooms": [],
+        "settings": {"bg_color": "#102030"},
+    }
+    v.SPACE_SCHEMA(ok_space)
+    v.CONFIG_SCHEMA({"spaces": [], "settings": {"bg_color": "#A1b2C3"}})
+    with pytest.raises(vol.Invalid):
+        v.SPACE_SCHEMA(dict(ok_space, settings={"bg_color": "red"}))
+    with pytest.raises(vol.Invalid):
+        v.CONFIG_SCHEMA({"spaces": [], "settings": {"bg_color": "url(javascript:x)"}})
+    with pytest.raises(vol.Invalid):
+        v.CONFIG_SCHEMA({"spaces": [], "settings": {"bg_color": "#12345"}})
+    with pytest.raises(vol.Invalid):
+        v.CONFIG_SCHEMA({"spaces": [], "settings": {"bg_color": "#1234567"}})
+
+
 def test_space_temp_bounds():
     """Temperature comfort bounds validate as floats; temp fill mode accepted."""
     ok = {

tsconfig.test.json

@@ -9,6 +9,7 @@
   },
   "include": [
     "src/logic.ts", "src/vacuum.ts",
+    "src/resize.ts",
     "src/rules.ts",
     "src/devices.ts",
     "src/types.ts",