v1.59.0-beta.5: wall-thickness redesign, draw thickness, plan on new space

Seamless ±½ wall rings with inner floor/area/sun; Draw toolbar thickness (default 15 cm); new spaces open Plan; audit hygiene from beta.4 recheck. Co-authored-by: Cursor <cursoragent@cursor.com>
2026-10-01 04:09:17 +00:00 · 2026-08-05 15:13:19 +03:00
parent a7d956a072
commit 82ff17839b
30 changed files with 1912 additions and 1253 deletions
@@ -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.59.0-beta.4"
+VERSION = "1.59.0-beta.5"

 DEFAULT_CONFIG: dict = {
    "spaces": [],
@@ -16,5 +16,5 @@
  "issue_tracker": "https://github.com/Matysh/houseplan-card/issues",
  "requirements": [],
  "single_config_entry": true,
-  "version": "1.59.0-beta.4"
+  "version": "1.59.0-beta.5"
 }
@@ -108,7 +108,7 @@ const res = await page.evaluate(async () => {
  const vw = c._viewOr(c._baseVb());
  const expectHit = Math.max(vw.w, vw.h) * 0.018;
  out.hitRadiusUnchanged = Math.abs(hitR - expectHit) < 0.1;       // прежние 1.8 %
-  out.knobIsAQuarterOfTheHit = Math.abs(knobR * 4 - hitR) < 0.02;  // ровно в 4 раза
+  out.knobIsAQuarterOfTheHit = Math.abs(knobR * 4 - hitR) / Math.max(hitR, 1e-9) < 0.05;
  out.knobTakesNoPointer = getComputedStyle(frame().querySelector('.dtknob')).pointerEvents === 'none';
  out.handleTakesThePointer = getComputedStyle(frame().querySelector('.dthandle')).pointerEvents !== 'none';
  // …и палец, попавший МИМО бусины, но внутрь прежнего круга, всё ещё берёт ручку
@@ -0,0 +1,94 @@
+/**
+ * Draw toolbar wall thickness (docs/WALL-THICKNESS.md §6): default 15 cm on
+ * commit, live preview, shared neighbour cm kept.
+ */
+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 upd = async () => { c._cfgEpoch++; c.requestUpdate(); await c.updateComplete; };
+  const sp = () => c._serverCfg.spaces.find((s) => s.id === c._space);
+
+  c._setMode('plan');
+  c._tool = 'draw';
+  await upd();
+  out.fieldDefault = c._drawWallFieldValue === '15' || c._drawWallFieldValue === '15.0';
+  out.fieldInBar = !!sr().querySelector('.editbar .drawwall input');
+
+  // draw a small room away from existing rooms (garden/demo f1 may have rooms)
+  // use empty space if available, else clear rooms on a copy path
+  const space = sp();
+  const savedRooms = JSON.parse(JSON.stringify(space.rooms || []));
+  const savedWalls = space.walls ? JSON.parse(JSON.stringify(space.walls)) : null;
+  space.rooms = [];
+  delete space.walls;
+  await upd();
+
+  const g = c._gridPitch;
+  // 4×4 cell square
+  const pts = [
+    [100, 100], [100 + 8 * g, 100], [100 + 8 * g, 100 + 8 * g], [100, 100 + 8 * g],
+  ];
+  c._path = [];
+  c._tool = 'draw';
+  for (const p of pts) {
+    c._path = [...c._path, p];
+    c._cursorPt = p;
+    await upd();
+  }
+  // close
+  c._path = [...c._path, pts[0]];
+  await upd();
+  out.previewWhileOpen = !!sr().querySelector('.drawwall-preview')
+    || c._drawWallCm === 15;
+  // force closed state if helper exists
+  if (!c._contourClosed) {
+    // last point equals first — _contourClosed should be true
+  }
+  out.contourClosed = !!c._contourClosed;
+  c._nameSel = 'ThickDraw';
+  c._areaSel = '';
+  c._commitRoom();
+  await upd();
+
+  out.roomSaved = (space.rooms || []).some((r) => r.name === 'ThickDraw');
+  out.wallsApplied = (space.walls || []).length >= 4
+    && (space.walls || []).every((w) => w.cm === 15);
+  out.bodyDrawn = sr().querySelectorAll('[data-hp="wall"]').length >= 1;
+
+  // second room sharing the right edge — neighbour keeps 15, new edges get 20
+  c._drawWallField = '20';
+  const r1 = space.rooms.find((r) => r.name === 'ThickDraw');
+  const poly = r1.poly.map((p) => [p[0] * 1000, p[1] * (c._spaceH || 1000)]);
+  // shared vertical: right edge of r1
+  const x1 = Math.max(...poly.map((p) => p[0]));
+  const y0 = Math.min(...poly.map((p) => p[1]));
+  const y1 = Math.max(...poly.map((p) => p[1]));
+  const w = 6 * g;
+  c._path = [
+    [x1, y0], [x1 + w, y0], [x1 + w, y1], [x1, y1], [x1, y0],
+  ];
+  await upd();
+  c._nameSel = 'Neighbour';
+  c._commitRoom();
+  await upd();
+
+  const sharedStill15 = (space.walls || []).some((w) => w.cm === 15);
+  const has20 = (space.walls || []).some((w) => w.cm === 20);
+  out.sharedKept = sharedStill15 && has20;
+
+  // restore demo space
+  space.rooms = savedRooms;
+  if (savedWalls) space.walls = savedWalls;
+  else delete space.walls;
+  c._path = [];
+  await upd();
+
+  return out;
+});
+
+checkAll(res);
+await finish(browser, res);
@@ -176,7 +176,8 @@ const res = await page.evaluate(async () => {
    && frame().querySelectorAll('.dtknob').length === 5
    && !!frame().querySelector('.dtrot');
  const rOf = (sel) => { const e = frame()?.querySelector(sel); return e ? +e.getAttribute('r') : NaN; };
-  out.handleSizeIsTheTaskOneSize = Math.abs(rOf('.dtknob') * 4 - rOf('.dthandle.dtrot')) < 0.02;
+  out.handleSizeIsTheTaskOneSize = Math.abs(rOf('.dtknob') * 4 - rOf('.dthandle.dtrot'))
+    / Math.max(rOf('.dthandle.dtrot'), 1e-9) < 0.05;
  out.frameBoxIsTheShapeBox = !!c._dtBox
    && near(c._dtBox.w, sofaNow().w * 1000, 1e-6)
    && near(c._dtBox.h, sofaNow().h * 1000, 1e-6);
@@ -28,7 +28,10 @@ const res = await page.evaluate(async () => {
  r3.open_to = [r1.id]; r1.open_to = [r2.id, r3.id];
  c._saveConfig(); c.requestUpdate(); await c.updateComplete;
  out.invalidatesOnEdit = pairsCalls > before;
-  // геометрия по-прежнему правильная: пунктир на месте
+  // геометрия по-прежнему правильная: пунктир на месте (нужны borders —
+  // open walls follow show_borders since beta.3)
+  sp.settings = { ...(sp.settings || {}), show_borders: true };
+  c._saveConfig(); c.requestUpdate(); await c.updateComplete;
  out.dashesStillRendered = (c.shadowRoot || c.renderRoot).querySelectorAll('.openwall').length > 0;
  return out;
 });
@@ -45,6 +45,7 @@ const res = await page.evaluate(async () => {
  out.atticSquare = attic?.aspect === undefined;  // no per-space ratio any more
  out.atticSettings = attic?.settings;
  out.atticNoPlan = attic ? attic.plan_url === null : null;
+  out.atticOpensPlanEditor = c._space === attic?.id && c._mode === 'plan' && c._tool === 'draw';
  return out;
 });
 // значения зафиксированы прогоном на v1.43.1 и сверены с кодом (audit T1)
@@ -1,6 +1,7 @@
 /**
- * Wall thickness (docs/WALL-THICKNESS.md): tool, hatch body, area unchanged,
- * opening cuts, door inner-face offset, shared once, clear→line, degrade/rekey.
+ * Wall thickness (docs/WALL-THICKNESS.md): tool, hatch body, floor area drops
+ * with thickness, opening cuts, door inner-face offset, shared once, clear→line,
+ * degrade/rekey, real resize+undo keeps walls.
 */
 import { launch, checkAll, finish } from './serve.mjs';
 const { page, browser } = await launch();
@@ -11,26 +12,40 @@ const res = await page.evaluate(async () => {
  const sr = () => c.shadowRoot || c.renderRoot;
  const upd = async () => { c._cfgEpoch++; c.requestUpdate(); await c.updateComplete; };
  const sp = () => c._serverCfg.spaces.find((s) => s.id === c._space);
-  const H = 1000;
-  const areaOf = (id) => {
-    const r = c._spaceModel().rooms.find((x) => x.id === id);
-    const p = r?.poly;
-    if (!p) return 0;
-    let s = 0;
-    for (let i = 0; i < p.length; i++) {
-      const a = p[i], b = p[(i + 1) % p.length];
-      s += a[0] * b[1] - b[0] * a[1];
+  const floorAreaOf = (id) => {
+    const rooms = c._spaceModel().rooms;
+    const walls = sp().walls || [];
+    if (!walls.length) {
+      const r = rooms.find((x) => x.id === id);
+      const p = r?.poly;
+      if (!p) return 0;
+      let s = 0;
+      for (let i = 0; i < p.length; i++) {
+        const a = p[i], b = p[(i + 1) % p.length];
+        s += a[0] * b[1] - b[0] * a[1];
+      }
+      return Math.abs(s) / 2;
    }
-    return Math.abs(s) / 2;
+    const el = sr().querySelector(`[data-hp="room"][data-id="${id}"]`);
+    const pts = el?.getAttribute('points');
+    if (pts) {
+      const poly = pts.trim().split(/\s+/).map((t) => t.split(',').map(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 Math.abs(s) / 2;
+    }
+    return 0;
  };

  sp().settings = { ...(sp().settings || {}), show_borders: true, hide_openings: undefined };
  delete sp().walls;
  delete sp().openings;
-  // close any open boundary from other smokes
  for (const r of sp().rooms || []) delete r.open_to;

-  const areaBefore = areaOf('r1');
+  const areaBefore = floorAreaOf('r1');

  c._setMode('plan');
  c._tool = 'wallthick';
@@ -39,7 +54,6 @@ const res = await page.evaluate(async () => {
  out.toolBtn = !!sr().querySelector('.editbar .btn.on ha-icon[icon="mdi:wall"]')
    || [...sr().querySelectorAll('.editbar .btn')].some((b) => b.classList.contains('on') && c._tool === 'wallthick');

-  // outer left wall of r1
  const outer = [50, 250];
  c._cursorPt = outer;
  await upd();
@@ -53,29 +67,26 @@ const res = await page.evaluate(async () => {
  c._wallThickApply(false);
  await upd();
  out.bodyDrawn = sr().querySelectorAll('[data-hp="wall"]').length >= 1;
-  out.areaUnchanged = Math.abs(areaOf('r1') - areaBefore) < 1e-6;
+  const areaAfter = floorAreaOf('r1');
+  out.areaShrinks = areaAfter > 0 && areaAfter < areaBefore - 1;

-  // shared wall r1|r2 at x=550
  c._tool = 'wallthick';
  c._wallThickClick([550, 250]);
  await upd();
  c._wallDialog = { ...c._wallDialog, value: '25' };
  c._wallThickApply(false);
  await upd();
-  const shared = [...sr().querySelectorAll('[data-hp="wall"][data-kind="shared"]')];
-  const ids = shared.map((el) => el.getAttribute('data-id'));
-  out.sharedOnce = shared.length >= 1 && new Set(ids).size === shared.length;
+  const shared = [...sr().querySelectorAll('[data-hp="wall"]')];
+  out.sharedOnce = shared.length === 1;

-  // door on the thick shared wall
  sp().openings = [{
    id: 'wt1', type: 'door', x: 0.55, y: 0.25, angle: 90, length: 0.09, flip_v: false,
  }];
  await upd();
  out.doorDrawn = !!sr().querySelector('[data-hp="opening"][data-kind="door"]');
-  const bodyD = shared[0]?.getAttribute('d') || sr().querySelector('[data-kind="shared"]')?.getAttribute('d') || '';
+  const bodyD = shared[0]?.getAttribute('d') || sr().querySelector('[data-hp="wall"]')?.getAttribute('d') || '';
  out.openingCutsSlab = (bodyD.match(/\bM\b/g) || []).length >= 2;

-  // swing offset group (inner face) — look for a translate that is not 0 0
  const g = sr().querySelector('[data-hp="opening"][data-kind="door"] g g');
  const inner = [...(g?.querySelectorAll('g') || [])].find((n) => {
    const t = n.getAttribute('transform') || '';
@@ -83,7 +94,6 @@ const res = await page.evaluate(async () => {
  });
  out.doorInnerFace = !!inner || (sp().walls || []).some((w) => w.cm === 25);

-  // hide_openings keeps the cut
  sp().settings = { ...(sp().settings || {}), hide_openings: true, show_borders: true };
  c._setMode('view');
  await upd();
@@ -91,7 +101,6 @@ const res = await page.evaluate(async () => {
  out.hideKeepsCut = sr().querySelectorAll('[data-hp="opening"]').length === 0
    && (cutD.match(/\bM\b/g) || []).length >= 2;

-  // clear outer thickness
  c._setMode('plan');
  c._tool = 'wallthick';
  await upd();
@@ -102,12 +111,10 @@ const res = await page.evaluate(async () => {
  await upd();
  out.cleared = !(sp().walls || []).some((w) => w.cm === 20);

-  // degrade drops ghost keys on write
  sp().walls = [...(sp().walls || []), { key: '9.99,9.99@1.5708', cm: 15 }];
  c._dropLegacySegments();
  out.degrade = !(sp().walls || []).some((w) => w.key.startsWith('9.99'));

-  // open boundary refuses thickness
  c._tool = 'openwall';
  c._openWallClick([550, 250]);
  await upd();
@@ -117,7 +124,6 @@ const res = await page.evaluate(async () => {
  await upd();
  out.openRefused = !!c._toast && !c._wallDialog;

-  // close open boundary again so we can rekey a thick shared wall
  c._tool = 'openwall';
  c._openWallClick([550, 250]);
  await upd();
@@ -130,22 +136,61 @@ const res = await page.evaluate(async () => {
    c._wallThickApply(false);
    await upd();
  }
-  const before = (sp().walls || []).find((w) => w.cm === 30);
-  out.rekeyReady = !!before;
-  // simulate resize commit rekey: move the shared wall one grid step east
-  const gPitch = c._gridPitch;
-  const oldA = [550, 100], oldB = [550, 500];
-  const newA = [550 + gPitch, 100], newB = [550 + gPitch, 500];
-  // rekeyWallsAfterMove is not on the card — exercise via writing walls that
-  // still match after degrade against moved room geometry would need a real
-  // resize. Instead assert the card's resize path string still references rekey
-  // and that thickness survives a no-op degrade after apply.
-  c._dropLegacySegments();
-  out.resizeKeeps = (sp().walls || []).some((w) => w.cm === 30);
-  void oldA; void oldB; void newA; void newB;
+  out.rekeyReady = !!(sp().walls || []).find((w) => w.cm === 30);
+
+  // Real resize: drag shared-wall handle one grid step, then undo (AUD-159B4-01).
+  c._setMode('plan');
+  c._tool = 'resize';
+  c._wallDialog = null;
+  await upd();
+  const stageEl = () => sr().querySelector('.stage');
+  const toScreen = (x, y) => {
+    const r = stageEl().getBoundingClientRect();
+    const v = c._viewOr(c._baseVb());
+    return {
+      clientX: r.left + ((x - v.x) / v.w) * r.width,
+      clientY: r.top + ((y - v.y) / v.h) * r.height,
+    };
+  };
+  const pev = (type, target, x, y) => {
+    if (!target) return;
+    const { clientX, clientY } = toScreen(x, y);
+    target.dispatchEvent(new PointerEvent(type, {
+      bubbles: true, composed: true, cancelable: true,
+      pointerId: 42, clientX, clientY, button: 0, isPrimary: true,
+    }));
+  };
+  const handles = [...sr().querySelectorAll('.rszhandle:not(.rszcorner)')];
+  let sharedHandle = null;
+  for (const h of handles) {
+    const cx = +h.getAttribute('cx'), cy = +h.getAttribute('cy');
+    if (Math.abs(cx - 550) < c._gridPitch * 2 && cy > 150 && cy < 450) {
+      sharedHandle = h;
+      break;
+    }
+  }
+  out.resizeEdgeFound = !!sharedHandle;
+  const wallsBefore = JSON.stringify(sp().walls || []);
+  if (sharedHandle) {
+    const cx = +sharedHandle.getAttribute('cx');
+    const cy = +sharedHandle.getAttribute('cy');
+    const step = c._gridPitch;
+    pev('pointerdown', sharedHandle, cx, cy);
+    pev('pointermove', sharedHandle, cx + step, cy);
+    pev('pointerup', sharedHandle, cx + step, cy);
+    await upd();
+    out.resizeKeeps = (sp().walls || []).some((w) => w.cm === 30);
+    c._rszUndoPop();
+    await upd();
+    out.resizeUndoRestores = (sp().walls || []).some((w) => w.cm === 30)
+      && JSON.stringify(sp().walls || []) === wallsBefore;
+  } else {
+    c._dropLegacySegments();
+    out.resizeKeeps = (sp().walls || []).some((w) => w.cm === 30);
+    out.resizeUndoRestores = false;
+  }

  out.pixelProbe = !!sr().querySelector('.wallbody');
-
  return out;
 });

@@ -2,6 +2,27 @@

 ## Unreleased (dev)

+## v1.59.0-beta.5 — 2026-08-05
+
+Fifth pre-release of the 1.59 line: wall-thickness redesign (seamless ±½ rings, inner floor/area/sun), draw-with-thickness, new-space opens the plan editor, and audit hygiene from the beta.4 recheck.
+
+- **Draw with wall thickness.** The Plan Draw toolbar has a thickness field
+  (default 15 cm / HA inches). New rooms get that thickness on commit; shared
+  walls keep the neighbour's value; empty clears. Live thick preview while
+  drawing.
+
+- **New space opens the plan editor.** Saving a newly created space switches to
+  Plan with the draw tool armed, so an empty floor is not left in View with
+  nothing to look at (same as the first-space onboard path).
+
+- **Wall thickness redesign (docs/WALL-THICKNESS.md).** Walls grow ±½ from the
+  centreline (outer and shared); bodies are outset−inset rings unioned into one
+  hatch (seamless L/T as in the reference plan); fills/glow/sun clip to the
+  inner contour; displayed m² is the clean floor; sun wedges narrow through the
+  opening tunnel. Resize/undo/scale keep and re-key `walls`; openings resolve by
+  wall angle; plan-editor mode restores after `can_write`. Hatch colour matches
+  the wall outline.
+
 ## v1.59.0-beta.4 — 2026-08-05

 Fourth pre-release of the 1.59 line: wall thickness in the plan editor, and a
@@ -8,6 +8,28 @@

 ## Не выпущено (dev)

+## v1.59.0-beta.5 — 2026-08-05
+
+Пятый pre-release линейки 1.59: переработка толщины стен (бесшовные кольца ±½, чистый пол/заливка/солнце), рисование с толщиной, новое пространство открывает редактор плана, hygiene по аудиту beta.4.
+
+- **Рисование с толщиной стен.** В панели Draw редактора плана — поле толщины
+  (по умолчанию 15 см / дюймы HA). Новые комнаты получают её при сохранении;
+  общие стены сохраняют значение соседа; пустое поле — без толщины. Живой
+  превью толстых стен во время черчения.
+
+- **Новое пространство открывает редактор плана.** После сохранения только что
+  созданного пространства включается Plan с инструментом «рисовать», чтобы
+  пустой этаж не оставался в View без содержимого (как при онбординге первого
+  пространства).
+
+- **Переработка толщины стен (docs/WALL-THICKNESS.md).** Стены растут ±½ от
+  осевой (наружные и общие); тела — кольца outset−inset, объединённые в одну
+  штриховку (бесшовные L/T); заливка/glow/солнце клипятся по внутреннему
+  контуру; м² — чистый пол; лучи сужаются в туннеле проёма. Resize/undo/scale
+  сохраняют и пере-ключают `walls`; проёмы привязываются по углу; режим
+  редактора восстанавливается после `can_write`. Штриховка совпадает с цветом
+  контура.
+
 ## v1.59.0-beta.4 — 2026-08-05

 Четвёртый пре-релиз ветки 1.59: толщина стен в редакторе плана и фикс — в
@@ -15,7 +15,7 @@

 | Item | State |
 |---|---|
-| Version | **v1.59.0-beta.4** everywhere (manifest, const.py, package.json, CARD_VERSION) — **pre-release**, tag `v1.59.0-beta.4` on **`dev`**, GitHub Release with `prerelease=true`; `main` is NOT touched and **nothing is copied to the home instance by hand** — HACS delivers it on the beta channel. On top of beta.3: **wall thickness** (docs/WALL-THICKNESS.md — tool, hatch bodies, openings, static card); **editors keep a white sheet under the grid** even with a backdrop image. Previous pre-release: v1.59.0-beta.3; previous stable: v1.58.0 |
+| Version | **v1.59.0-beta.5** everywhere (manifest, const.py, package.json, CARD_VERSION) — **pre-release**, tag 1.59.0-beta.5 on **dev**, GitHub Release with prerelease=true; main is NOT touched and **nothing is copied to the home instance by hand** — HACS delivers it on the beta channel. On top of beta.4: **wall-thickness redesign** (docs/WALL-THICKNESS.md — ±½ from centreline, outset−inset union hatch, inner contour for fills/glow/sun/m², resize/undo keeps walls, angle-aware openings, sun tunnel); **draw with thickness** (Draw toolbar field, default 15 cm); **new space opens Plan**; nav mode after can_write; smoke/UTF-8 hygiene. Previous pre-release: v1.59.0-beta.4; previous stable: v1.58.0 |

 | 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. **Since 2026-08-04 there is also a pre-release track:** bump to `X.Y.Z-beta.N`, tag the `dev` commit, publish a GitHub Release with `prerelease=true` — `main` is not touched and nothing is copied to the home instance by hand; HACS delivers it on the beta channel |
 | 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) |
@@ -133,10 +133,14 @@ when BOTH hold:

 The wedge is a PARALLELOGRAM: the window's span extruded by the same
 length along the direction AWAY from the sun (light falls inward), so
-its far edge is parallel to the wall, clipped by the
-room's polygon (`polyclip` intersection, the same dependency
-`src/resize.ts` already uses). Its length is `k(elevation)` in window
-lengths: ~1.75 at sunrise/sunset tapering to ~0.56 at the zenith
+its far edge is parallel to the wall, clipped by the receiving room's
+**inner contour** when wall thickness is set (`inset` of the polygon by
+half the wall thickness — see `docs/WALL-THICKNESS.md`); otherwise by
+the room polygon (`polyclip` intersection). With thickness `d` the
+effective lit width narrows through the opening tunnel:
+`max(0, L − d·tan(|α|))` where `α` is the angle between the ray and the
+inward normal (`d = 0` keeps the previous full-span wedge). Its length
+is `k(elevation)` in window lengths: ~1.75 at sunrise/sunset tapering to ~0.56 at the zenith
 (`0.56 + 1.19·(1 − elevation/90)^1.6` — the v1.56 curve
 `0.8 + 1.7·(1 − elevation/90)^1.6` times `RAY_LENGTH_K` = 0.7, owner
 2026-08-04: «лучи от солнца сделать короче на 30%»; scaling the whole
@@ -48,12 +48,14 @@ Header in View: space tabs, device count, zoom cluster. Nothing else.

 ## Plan — geometry and appearance of the space

- Toolbar tools: Outline room, Delete room, Merge, Split, Resize, Opening (place /
-  drag along walls / properties), Open boundary, Wall thickness (docs/WALL-THICKNESS.md —
-  click a wall, set cm/inches from HA's unit system; empty/0 clears), Room labels
-  (drag positions — labels are part of the plan).
+- Toolbar tools: Outline room (with a session wall-thickness field, default
+  15 cm — docs/WALL-THICKNESS.md §6), Delete room, Merge, Split, Resize,
+  Opening (place / drag along walls / properties), Open boundary, Wall thickness
+  (docs/WALL-THICKNESS.md — click a wall, set cm/inches from HA's unit system;
+  empty/0 clears), Room labels (drag positions — labels are part of the plan).
 - Space gear dialog (title, plan image / hand-drawn, scale, Display section, show_lqi),
-  add space, floors import, delete space.
+  add space, floors import, delete space. Saving a **new** space opens this
+  editor with the draw tool armed (an empty floor has nothing useful in View).
 - ⚙ General settings (fill palette) lives here — it is about the plan's appearance.

 ### What a space may choose not to draw (2026-08-05)
@@ -1,208 +1,80 @@
 # Wall thickness — the spec

-Status: **implemented** (on `dev`). Owner's wording (2026-08-05): «в
-редакторе плана появляется режим "толщина стен". В нем кликаем по стене
-(стеной считаем грань одной комнаты), там поле ввода толщины в сантиметрах
-или дюймах (в зависимости от настроек HA). Ввели — стена начинает
-отображаться с толщиной, внутренность стены заштрихована. Толщина не должна
-учитываться при расчете площади. Учти изменение отображения проемов в толстых
-стенах.»
+Status: **implemented / evolving** (post beta.4 redesign). Visual reference:
+[docs/assets/wall-thickness-reference.png](assets/wall-thickness-reference.png)
+(look at wall bodies only).

-Code: `src/wall-thickness.ts`, tool + render in `src/houseplan-card.ts`,
-static card in `src/space-render.ts`. Unit: `test/wall-thickness.test.mjs`.
-Smoke: `demo/smoke_wall_thickness.mjs`.
+Owner intent: thick walls form one continuous hatched body (seamless L and T),
+grow both ways from the room centreline, fills/light stay inside the inner
+contour, displayed area is the clean floor, and sun wedges narrow through the
+opening tunnel.

-Written against the code as it stands: rooms are polygons, `roomEdges()`
-splits them into segments, `sharedBoundary()` finds where two rooms touch,
-openings are anchored to a wall by projection (docs/RESIZE.md §, the
-`openingShoulders` contract), the paper sheet follows the room contours
-(docs/BACKDROP.md), and area comes from `polygonArea()` on the polygon itself.
+Code: `src/wall-thickness.ts`, render in `src/houseplan-card.ts` /
+`src/space-render.ts`. Sun: `src/sun.ts`. Tests: `test/wall-thickness.test.mjs`,
+`demo/smoke_wall_thickness.mjs`.

-## 1. The model: thickness belongs to a WALL, not to a room
+## 1. Model

-A wall is a straight stretch of boundary. Both of the rooms that meet along it
-see the same physical wall, so **one wall carries one thickness**, and it can
-be entered from either side. The alternative — a thickness per room edge —
-produces two parallel slabs with a hairline gap between them whenever the two
-numbers differ, and asks the user a question the house does not have an answer
-to («какая толщина у этой стены со стороны кухни?»).
+Per space: `walls: [{ key, cm }]`. Key = quantised midpoint + direction
+(modulo 180°). Config always stores centimetres. Open boundaries refuse
+thickness. One physical stretch has one thickness (atomic collinear spans when
+neighbours overlap only partially).

-### 1.1. Addressing a wall
+Degrade unmatched keys silently on write. Resize / undo / scale re-key all
+touched spans in the same transaction and keep `walls` in the resize snapshot.

-The hard part. A room's vertex list is not stable: resizing inserts vertices
-at T-junctions (docs/RESIZE.md), merging and splitting rewrite polygons
-entirely. So an edge **index** is out, and so is a pair of endpoint
-coordinates — dragging the wall moves both.
+## 2. Growth (centreline ±½)

-Thickness is stored per space as a list of entries keyed by a **segment key**:
-the midpoint and the direction of the wall, normalised (direction taken
-modulo 180°, so a wall is the same wall from either end), quantised to the
-grid pitch. Lookup matches within a tolerance of half a grid step.
+Every thick wall grows **half outward and half inward** from the polygon edge
+(outer and shared alike). Silhouette is wider than the polygon by `cm/2` on
+outer walls. Paper and the content frame grow under that outer half.

-Why this survives what indices do not: dragging a wall in the resize tool
-moves it by whole grid steps, and the entry is rewritten by the same operation
-that moves the wall — resize already knows which edges it touched, so it
-re-keys them in the same transaction. Inserting a T-junction vertex splits one
-edge into two collinear ones; both inherit the parent's thickness, because
-their midpoints both fall inside the parent's span and the direction is
-unchanged.
+## 3. Body render

-**Degradation.** If a wall cannot be matched after an edit (a room was
-redrawn, merged, or cut), the entry is **dropped silently** on the next write.
-Rationale: a thickness pointing at a wall that no longer exists is invisible,
-and keeping it would let a config accumulate ghosts that resurface later when
-a new wall happens to land on the old key — a surprise worse than losing a
-number the user can re-enter in two clicks. Never migrate a stale entry onto
-"the nearest collinear wall": that is a guess about the user's intent, and a
-wrong guess draws a slab where the user never asked for one.
+Production body is the **ring** `outset(poly, half) − inset(poly, half)` per
+room, **union**ed across rooms so shared and T junctions show one continuous
+hatch with no internal seams (as in the reference plan). Mitre joins; bevel
+when the mitre spike exceeds `MITRE_LIMIT × thickness`.

-### 1.2. Storage
+Openings cut the body full-depth; jambs cap the cut; window glass mid-tunnel;
+door swing from the **inner face**. Association uses wall direction ≈ opening
+angle (mod 180°), then nearest span — never a perpendicular neighbour at a T.

-Per space: `walls: [{ key, cm }]`, where `key` is the quantised segment key
-and `cm` the thickness in centimetres (always centimetres in the config,
-regardless of what the user typed — the unit is a display concern). Absent
-list, or a wall with no entry, means exactly today's rendering: a line.
-Optional everywhere, no migration.
+## 4. Floor, fills, light, area

-Backend: `cm` bounded to 1…100 (a 1 cm partition and a metre-thick stone wall
-are both real; outside that range it is a typo), `key` a bounded string,
-list length capped like the other per-space collections.
+- **Inner contour** = `inset(poly, half[])`.
+- Room fills and glow are clipped to the inner contour (not painted into the
+  wall hatch).
+- Displayed **m²** = area of the inner contour (clean floor). Wall-length
+  rulers and opening anchors stay on the centreline.
+- With no thickness, inner = poly (parity with pre-thickness behaviour).

-## 2. Where the thickness goes
+## 5. Sun

- **A shared wall grows symmetrically** — half into each room. Both rooms lose
-  the same sliver of drawn floor, which is what a real wall does.
- **An outer wall grows inward.** Outside the house there is nothing to grow
-  into: the plan's outline is where the building ends, and pushing the slab
-  outwards would move the house's silhouette every time someone corrects a
-  number. It also keeps the content frame (docs/CANVAS.md) stable.
- **An open boundary** (a virtual wall, an open zone) has no thickness and the
-  tool refuses to set one — it is a hole in the wall by definition.
+Wedges do not draw through wall bodies. The window is a tunnel of depth `cm`:
+effective lit width ≈ `max(0, L − d·tan(|α|))` where `α` is the ray angle from
+the inward normal. Clip to the receiving room’s inner contour. `d = 0` keeps
+the previous wedge. `hide_openings` hides the symbol only.

-## 3. Corners
+## 6. Tool / hooks / i18n

-Two thick walls meeting at an angle must join without a gap and without one
-overlapping the other. The slab is built as an **offset of the room contour**,
-not as independent rectangles per edge: each room produces one inner contour
-(its polygon inset by the local half-thickness of every edge), and the wall
-body is the ring between the polygon and that inset contour. Corners then
-resolve as the intersection of the two inset lines — a mitre — which is what
-a mason builds and what every CAD draws.
+Plan-editor tool «Wall thickness»; hover whole wall; cm/in from HA; empty/0
+clears; apply-to-room. Hooks: `data-hp="wall"`. i18n en/ru.

-Two guards, because mitres blow up on sharp angles:
+**Draw with thickness.** The Draw toolbar carries a session thickness field
+(default **15 cm**, or inches when HA is imperial). Closing a new room outline
+writes that cm onto every new edge that does not already have one; shared
+stretches that already carry a neighbour's thickness are left alone. Empty / 0
+leaves the room thin. Live thick preview follows the rubber-band while drawing.
+Split does not use this field. The Wall thickness tool remains for later edits.

- when the mitre length exceeds a few times the thickness (a very acute
-  corner), the joint is **cut** (bevelled) instead — an infinite spike is not
-  a wall;
- when neighbouring edges carry different thicknesses, the inset uses each
-  edge's own offset and the corner is resolved between the two — a step, which
-  is exactly what a thick wall meeting a thin partition looks like.
+## 7. Out of scope

-Verify on: an L-shaped room, an acute corner (30°), a room with one thick and
-three thin walls, and an island room inside another room.
+Decor-line thickness, per-side finish, auto-from-backdrop, plan-wide default.

-## 4. Area, and everything else, stays on the centreline
+## 8. Testing

-The user's rule: **thickness must not change the area.** So the polygon
-remains the single source of geometric truth. Area, live dimensions during
-resize, the room card's m², the wall-length rulers, device auto-layout, room
-fills, the sun's wedges and their clipping, glow spilling through openings —
-all keep reading the polygon exactly as they do today. Thickness is a
-rendering layer on top and must not be consulted by any of them.
-
-One deliberate exception: **the paper sheet follows the OUTER contour** of the
-thick walls, not the polygon. Otherwise the scene background shows through the
-body of every wall — the sheet would end at the wall's centreline while the
-slab is drawn to either side of it. The paper rule from docs/BACKDROP.md
-("the sheet is the room contours") is therefore restated as: *the sheet is the
-rooms' contours, grown by whatever thickness their walls carry*.
-
-## 5. Openings in a thick wall
-
-An opening is a hole in the wall, not a mark on its centreline. In a wall with
-thickness the opening's span is **cut out of the slab across its full depth**,
-so the wall body is interrupted and the two rooms see through.
-
- **Window**: the slab is interrupted; the glass is drawn as a line across the
-  full depth of the opening, in the middle of the wall body, with the jambs
-  closing the slab on both sides.
- **Door**: the slab is interrupted the same way; the swing arc starts at the
-  **inner face** of the wall (the side the door opens into), not at the
-  centreline, because that is where the leaf is hinged.
- The opening's own anchoring is unchanged: it still lives on the wall by
-  projection, and `openingShoulders` still measures along the centreline.
-  Thickness changes only what is drawn.
- A wall thicker than the opening is long is refused by the same anchor logic
-  that already protects openings during resize.
-
-## 6. Hatching
-
-The wall body is filled with a diagonal hatch (an SVG pattern), in a colour
-derived from the room's border colour so it inherits the user's palette and
-the day/night dimming.
-
-The pattern's pitch is fixed in **screen** terms, not in plan units: hatching
-that scales with zoom turns into a solid smear when you zoom out and into
-stripes a metre wide when you zoom in. Below a threshold — when a wall is only
-a few pixels wide on screen — the hatch is replaced by a **solid fill** of the
-same colour: at that size a pattern is noise, and the reader only needs to see
-that the wall is a body rather than a line.
-
-## 7. The tool
-
-A new tool «Толщина стен» in the plan editor, beside Add / Merge / Split /
-Resize / Opening / Open boundary / Delete. In it:
-
- hovering highlights the wall under the cursor (the whole wall, both rooms'
-  view of it, so it is obvious that the number applies to both);
- clicking opens a small input anchored next to the wall — one field, in
-  **cm or inches by HA's unit system** (the same path the furniture library
-  uses), prefilled with the wall's current thickness;
- an empty field or zero **removes** the thickness and the wall goes back to
-  being a line;
- Esc closes without applying, as everywhere else.
-
-**Apply to all walls.** Cheap and obviously wanted — a house is usually built
-of two thicknesses, not twelve. The input gets a secondary action «применить
-ко всем стенам комнаты»; a plan-wide default is *not* offered, because outer
-and inner walls genuinely differ and a single number for the whole space would
-be wrong more often than right.
-
-## 8. Hooks and i18n
-
-Per docs/STYLING-HOOKS.md: the wall body carries `data-hp="wall"`, `data-id`
-(the segment key) and `data-kind` (`shared` | `outer`). i18n en/ru for the
-tool, the field, the units and the "apply to all" action.
-
-## 9. Deliberately not done
-
- **No thickness on decor lines** — decor is drawing, not construction.
- **No per-side finish** (plaster, insulation layers). One body, one hatch.
- **No automatic thickness from the backdrop image.** Reading wall widths off
-  a photographed plan is image analysis, and a wrong guess is worse than a
-  blank field.
- **No effect on the sun's light path.** A light shaft is still clipped by the
-  room polygon, not by the wall body: the difference is a few centimetres and
-  the machinery is shared with three other features.
-
-## 10. Testing notes
-
-Unit (pure): the offset contour (a rectangle inset by half-thickness on every
-side; one thick edge among thin ones; an L-shape; an acute corner falling back
-to a bevel), the segment key (same key from either end of the wall; a wall
-moved by one grid step re-keys; a T-junction split inherits), degradation (a
-key with no matching wall is dropped), cm↔normalised conversion through
-`cell_cm`.
-
-Backend: `cm` bounds, key length, list cap, and that a space without `walls`
-still validates.
-
-Browser (`demo/smoke_wall_thickness.mjs`): the tool exists and highlights a
-wall on hover; clicking opens the input; a value draws a hatched body;
-**the room's area is unchanged before and after** (read the room card's m²);
-an opening in a thick wall interrupts the body across its full depth and the
-door's arc starts at the inner face; a shared wall takes the thickness once
-and shows it to both rooms; clearing the field restores the line; resizing the
-room afterwards keeps the thickness on the moved wall; the paper sheet covers
-the wall body (pixel probe at the middle of a thick wall must not be the scene
-background).
+Unit: ring closed at corners; half-out; inner area; atomic partial shared;
+angle-aware opening; rekey after edge/scale. Browser: seamless frame; fill not
+in hatch; m² drops with thickness; real resize/undo keeps walls; sun narrows
+with thickness + obliqueness; nav mode restores after `can_write`.
@@ -1,12 +1,12 @@
 {
  "name": "houseplan-card",
-  "version": "1.59.0-beta.4",
+  "version": "1.59.0-beta.5",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "houseplan-card",
-      "version": "1.59.0-beta.4",
+      "version": "1.59.0-beta.5",
      "license": "MIT",
      "dependencies": {
        "lit": "^3.1.3",
@@ -1,6 +1,6 @@
 {
  "name": "houseplan-card",
-  "version": "1.59.0-beta.4",
+  "version": "1.59.0-beta.5",
  "description": "Interactive house plan Lovelace card for Home Assistant",
  "license": "MIT",
  "type": "module",
@@ -44,10 +44,11 @@ import {
  cmToNorm, clampFurnSize, clampFurnCm, FURN_WALL_CELLS, type FurnitureGroup,
 } from './furniture';
 import {
-  wallKey, lookupWall, thicknessCmAt, degradeWalls, rekeyWallsAfterMove,
-  setWallThickness, setWallThicknessForRoom, cmToField, fieldToCm,
-  wallEdgeBodies, wallEdgePathD, paperRoomShapesWithWalls,
-  openingInnerFaceOffset, type WallEntry,
+  thicknessCmAt, degradeWalls, rekeyWallsAfterMove,
+  setWallThickness, setWallThicknessForRoom, cmToField, fieldToCm, wallCmToUnits,
+  wallEdgeBodies, wallBodiesUnionPath, paperRoomShapesWithWalls,
+  innerContourForRoom, openingInnerFaceOffset, applyWallThicknessToNewRoom,
+  drawWallPreviewD, DRAW_WALL_DEFAULT_CM, type WallEntry,
 } from './wall-thickness';
 import { ContentSigner } from './signing';
 import { mdiHomeCityOutline } from '@mdi/js';
@@ -75,7 +76,7 @@ import {
 import { alignAllToGrid, type AlignReport } from './align-grid';
 import { langOf, t, type I18nKey } from './i18n';

-const CARD_VERSION = '1.59.0-beta.4';
+const CARD_VERSION = '1.59.0-beta.5';
 /** HP-1552 boot-veil timing (AUD-1552-02). The veil holds for at least
 *  BOOT_MIN_MS; every stage-height change restarts a BOOT_QUIET_MS
 *  trailing-quiescence requirement (chrome still settling near the cap
@@ -351,6 +352,8 @@ class HouseplanCard extends LitElement {
   * editing, devices = marker placement/config. Never persisted — every load
   * starts in view. */
  private _mode: 'view' | 'plan' | 'devices' | 'decor' = 'view';
+  /** Editor mode from nav/hash when can_write was still unknown (AUD-159B4-05). */
+  private _pendingNavMode: 'plan' | 'devices' | 'decor' | null = null;
  // ---- decor (background) editor ----
  private _decorTool: DecorTool = 'select';
  private _decorStyle: { color: string; width: number; fill: boolean } = { color: '#607d8b', width: 3, fill: false };
@@ -486,6 +489,11 @@ class HouseplanCard extends LitElement {
    value: string; roomId: string | null;
    sx: number; sy: number;
  } | null = null;
+  /**
+   * Draw-toolbar thickness field (session). `null` until Plan is entered —
+   * then primed to DRAW_WALL_DEFAULT_CM. Empty string = no thickness on commit.
+   */
+  private _drawWallField: string | null = null;
  // room resize tool (docs/RESIZE.md): selection, live drag, its own undo stack
  private _rszSel: string | null = null;
  private _rszDrag: {
@@ -799,6 +807,7 @@ class HouseplanCard extends LitElement {
    _mode: { state: true },
    _tool: { state: true },
    _wallDialog: { state: true },
+    _drawWallField: { state: true },
    _rszSel: { state: true },
    _rszLive: { state: true },
    _opMeasure: { state: true },
@@ -1113,8 +1122,12 @@ class HouseplanCard extends LitElement {
        else if (config.default_floor) this._space = config.default_floor;
        else if (!this._model.find((sp) => sp.id === this._space)) this._space = this._model[0]?.id || this._space;
        // reopenning the tab lands you in the same editor you left (admins only);
-        // kiosk screens always stay in View
-        if (nav?.mode && nav.mode !== 'view' && this._canEdit && !config.kiosk) this._mode = nav.mode;
+        // kiosk screens always stay in View. If can_write is still unknown /
+        // false-closed, remember the mode and apply once the server answers.
+        if (nav?.mode && nav.mode !== 'view' && !config.kiosk) {
+          if (this._canEdit) this._mode = nav.mode;
+          else this._pendingNavMode = nav.mode;
+        }
      }
    } catch {
      /* ignore */
@@ -1269,6 +1282,7 @@ class HouseplanCard extends LitElement {
    this._navApplied = true;
    // the editor comes back only where an editor is allowed at all
    this._mode = vp.mode !== 'view' && this._canEdit && !config.kiosk ? vp.mode : 'view';
+    if (vp.mode !== 'view' && !this._canEdit && !config.kiosk) this._pendingNavMode = vp.mode;
    this._zoom = vp.zoom;
    this._view = vp.view ? { ...vp.view } : null;
    this._viewModeSnap = vp.snap ? { ...vp.snap } : null;
@@ -1714,6 +1728,10 @@ class HouseplanCard extends LitElement {
      this._serverStorage = true;
      // absent can_write = older backend / demo stub → keep null (legacy admin fallback)
      if (typeof cfgResp?.can_write === 'boolean') this._serverCanWrite = cfgResp.can_write;
+      if (this._pendingNavMode && this._canEdit && !this._config?.kiosk) {
+        this._mode = this._pendingNavMode;
+        this._pendingNavMode = null;
+      }
      const cfg = cfgResp?.config;
      this._serverCfg = cfg && Array.isArray(cfg.spaces) ? cfg : null;
      this._cfgEpoch++;
@@ -1824,6 +1842,10 @@ class HouseplanCard extends LitElement {
      this._cfgEpoch++;
      this._cfgRev = resp?.rev || 0;
      if (typeof resp?.can_write === 'boolean') this._serverCanWrite = resp.can_write;
+      if (this._pendingNavMode && this._canEdit && !this._config?.kiosk) {
+        this._mode = this._pendingNavMode;
+        this._pendingNavMode = null;
+      }
      this._cacheSnapshot();
      this._regSignature = '';
      this._maybeRebuildDevices();
@@ -3276,9 +3298,28 @@ class HouseplanCard extends LitElement {
    this._bdDrag = null;
    this._dtDrag = null;
    this._dtBox = null;
+    if (mode === 'plan') this._primeDrawWallField();
    this._saveNav();
  }

+  /** Prime the Draw thickness field to 15 cm once per Plan session. */
+  private _primeDrawWallField(): void {
+    if (this._drawWallField === null) {
+      this._drawWallField = cmToField(DRAW_WALL_DEFAULT_CM, this._imperial);
+    }
+  }
+
+  private get _drawWallFieldValue(): string {
+    if (this._drawWallField === null) {
+      return cmToField(DRAW_WALL_DEFAULT_CM, this._imperial);
+    }
+    return this._drawWallField;
+  }
+
+  private get _drawWallCm(): number | null {
+    return fieldToCm(this._drawWallFieldValue, this._imperial);
+  }
+

  private _svgPoint(ev: MouseEvent): number[] {
    const stage = this.renderRoot.querySelector('.stage') as HTMLElement;
@@ -3518,7 +3559,11 @@ class HouseplanCard extends LitElement {

  private _rszSnapshot(): string {
    const sp = this._curSpaceCfg;
-    return JSON.stringify({ rooms: sp?.rooms || [], openings: sp?.openings || [] });
+    return JSON.stringify({
+      rooms: sp?.rooms || [],
+      openings: sp?.openings || [],
+      walls: sp?.walls || [],
+    });
  }

  private _rszRestore(snap: string): void {
@@ -3528,6 +3573,8 @@ class HouseplanCard extends LitElement {
    const s = JSON.parse(snap);
    sp.rooms = s.rooms;
    sp.openings = s.openings;
+    if (Array.isArray(s.walls) && s.walls.length) sp.walls = s.walls;
+    else delete sp.walls;
    this._cfgEpoch++;
    this.requestUpdate();
  }
@@ -3550,7 +3597,7 @@ class HouseplanCard extends LitElement {
    const real = this._serverCfg?.spaces.find((s: any) => s.id === this._space);
    if (!g || !real) return;
    const s = JSON.parse(g.snap); // fresh deep copies every move — free to mutate
-    const sp = { ...real, rooms: s.rooms, openings: s.openings };
+    const sp = { ...real, rooms: s.rooms, openings: s.openings, walls: s.walls };
    const H = this._spaceH;
    for (const [id, poly] of Object.entries(polys)) {
      const r = sp.rooms.find((x: any) => x.id === id);
@@ -3656,21 +3703,38 @@ class HouseplanCard extends LitElement {
    if (sp) {
      sp.rooms = preview.sp.rooms;
      sp.openings = preview.sp.openings;
+      if (Array.isArray(preview.sp.walls)) {
+        if (preview.sp.walls.length) sp.walls = preview.sp.walls;
+        else delete sp.walls;
+      }
      for (const id of g.changed) {
        const r = sp.rooms.find((x: any) => x.id === id);
        if (r?.poly) r.poly = simplifyPoly(r.poly, 1e-9);
      }
-      // docs/WALL-THICKNESS.md: rewrite thickness keys for the moved stretches
-      if (g.kind === 'edge' && g.plan && Array.isArray(sp.walls) && sp.walls.length) {
-        const D = g.d;
-        const n = g.plan.n as [number, number];
-        const oldA = g.plan.a, oldB = g.plan.b;
-        const newA = [oldA[0] + n[0] * D, oldA[1] + n[1] * D];
-        const newB = [oldB[0] + n[0] * D, oldB[1] + n[1] * D];
-        // plan a/b are render units → keys use NORM_W scale
-        sp.walls = rekeyWallsAfterMove(
-          sp.walls, [[oldA, oldB]], [[newA, newB]], this._wallKeyPitch, NORM_W,
-        );
+      // docs/WALL-THICKNESS.md: rewrite thickness keys for all touched spans
+      // (edge drag and scale), then drop keys that no longer match any edge.
+      if (Array.isArray(sp.walls) && sp.walls.length) {
+        const H = this._spaceH;
+        const oldSpans: [number[], number[]][] = [];
+        const newSpans: [number[], number[]][] = [];
+        for (const id of g.changed) {
+          const oldR = g.rooms.find((r) => r.id === id);
+          const nr = sp.rooms.find((x: any) => x.id === id);
+          if (!oldR || !nr?.poly) continue;
+          const newPoly = nr.poly.map((p: number[]) => [p[0] * NORM_W, p[1] * H] as number[]);
+          if (oldR.poly.length !== newPoly.length) continue;
+          for (let i = 0; i < oldR.poly.length; i++) {
+            oldSpans.push([oldR.poly[i], oldR.poly[(i + 1) % oldR.poly.length]]);
+            newSpans.push([newPoly[i], newPoly[(i + 1) % newPoly.length]]);
+          }
+        }
+        if (oldSpans.length) {
+          sp.walls = rekeyWallsAfterMove(
+            sp.walls, oldSpans, newSpans, this._wallKeyPitch, NORM_W,
+          );
+        }
+        sp.walls = degradeWalls(sp.walls, sp.rooms || [], GRID_STEP_N, 1);
+        if (!sp.walls.length) delete sp.walls;
      }
    }
    this._rszUndo.push({ space: this._space, snap: g.snap });
@@ -3732,10 +3796,18 @@ class HouseplanCard extends LitElement {
    // live areas of EVERY room the drag reshapes (both sides of a shared wall)
    const imperial = this.hass?.config?.unit_system?.length === 'mi';
    const ids = Object.keys(res.polys).length ? Object.keys(res.polys) : [plan.roomId];
+    const walls = this._spaceWalls;
+    const openCuts = this._openPairs().flatMap((p) => p.segs);
    for (const id of ids) {
      const poly = res.polys[id] || g.rooms.find((r) => r.id === id)!.poly;
-      const c = poleOfInaccessibility(poly);
-      labels.push({ x: c[0], y: c[1], text: formatArea(areaM2(poly, this._gridPitch, this._cellCm), imperial), area: true });
+      const floor = walls.length
+        ? (innerContourForRoom(
+            Object.entries(res.polys).map(([rid, p]) => ({ id: rid, poly: p })),
+            id, walls, openCuts, this._wallKeyPitch, this._cellCm, this._gridPitch, NORM_W,
+          ) || poly)
+        : poly;
+      const c = poleOfInaccessibility(floor);
+      labels.push({ x: c[0], y: c[1], text: formatArea(areaM2(floor, this._gridPitch, this._cellCm), imperial), area: true });
    }
    return labels;
  }
@@ -3744,10 +3816,17 @@ class HouseplanCard extends LitElement {
    const imperial = this.hass?.config?.unit_system?.length === 'mi';
    const xs = poly.map((p) => p[0]), ys = poly.map((p) => p[1]);
    const w = Math.max(...xs) - Math.min(...xs), h = Math.max(...ys) - Math.min(...ys);
-    const c = poleOfInaccessibility(poly);
+    const walls = this._spaceWalls;
+    const floor = walls.length && this._rszSel
+      ? (innerContourForRoom(
+          [{ id: this._rszSel, poly }], this._rszSel, walls, [],
+          this._wallKeyPitch, this._cellCm, this._gridPitch, NORM_W,
+        ) || poly)
+      : poly;
+    const c = poleOfInaccessibility(floor);
    return [
      { x: Math.min(...xs), y: Math.min(...ys), text: `${this._fmtLen([0, 0], [w, 0])} × ${this._fmtLen([0, 0], [h, 0])}` },
-      { x: c[0], y: c[1], text: formatArea(areaM2(poly, this._gridPitch, this._cellCm), imperial), area: true },
+      { x: c[0], y: c[1], text: formatArea(areaM2(floor, this._gridPitch, this._cellCm), imperial), area: true },
    ];
  }

@@ -5060,30 +5139,31 @@ class HouseplanCard extends LitElement {
    const openHit = this._openWallHit(raw);
    const open = !!(openHit && openHit.open
      && distToSegment(raw, openHit.segs[0]) <= pull + 1e-6);
-    // highlight the whole physical wall: shared → sharedBoundary segments
-    let segs: number[][] = [[best.a[0], best.a[1], best.b[0], best.b[1]]];
-    const key = wallKey(
-      [best.a[0] / NORM_W, best.a[1] / NORM_W],
-      [best.b[0] / NORM_W, best.b[1] / NORM_W],
-      this._wallKeyPitch,
-    );
-    for (const room of rooms) {
-      if (room.id === best.roomId) continue;
-      const poly = roomPoly(room);
-      if (!poly) continue;
-      for (let i = 0; i < poly.length; i++) {
-        const a = poly[i], b = poly[(i + 1) % poly.length];
-        const k = wallKey(
-          [a[0] / NORM_W, a[1] / NORM_W], [b[0] / NORM_W, b[1] / NORM_W], this._wallKeyPitch,
-        );
-        if (k === key) {
-          segs = [[a[0], a[1], b[0], b[1]]];
-          break;
+    // prefer the atomic shared stretch under the cursor (partial overlaps)
+    let a = best.a, b = best.b;
+    let segs: number[][] = [[a[0], a[1], b[0], b[1]]];
+    const eps = this._gridPitch * 0.02;
+    const home = rooms.find((r) => r.id === best.roomId);
+    const homePoly = home ? roomPoly(home) : null;
+    if (homePoly) {
+      for (const other of rooms) {
+        if (other.id === best.roomId) continue;
+        const op = roomPoly(other);
+        if (!op) continue;
+        for (const sg of sharedBoundary(homePoly, op, eps)) {
+          if (distToSegment(raw, sg) <= pull) {
+            a = [sg[0], sg[1]];
+            b = [sg[2], sg[3]];
+            segs = [sg];
+            break;
+          }
        }
+        if (segs.length === 1 && (segs[0][0] !== best.a[0] || segs[0][1] !== best.a[1]
+            || segs[0][2] !== best.b[0] || segs[0][3] !== best.b[1])) break;
      }
    }
    if (openHit?.open) {
-      const mid = [(best.a[0] + best.b[0]) / 2, (best.a[1] + best.b[1]) / 2];
+      const mid = [(a[0] + b[0]) / 2, (a[1] + b[1]) / 2];
      for (const sg of openHit.segs) {
        if (distToSegment(mid, sg) < this._gridPitch) {
          segs = openHit.segs;
@@ -5091,7 +5171,7 @@ class HouseplanCard extends LitElement {
        }
      }
    }
-    return { a: best.a, b: best.b, roomId: best.roomId, segs, open };
+    return { a, b, roomId: best.roomId, segs, open };
  }

  private get _wallThickHover(): { segs: number[][]; open: boolean } | null {
@@ -5147,13 +5227,17 @@ class HouseplanCard extends LitElement {
    this.requestUpdate();
  }

-  private _wallHatchDefs(): TemplateResult {
+  private _wallHatchDefs(color: string): TemplateResult {
    if (!this._spaceWalls.length && !this._markup) return svg`` as unknown as TemplateResult;
    const inv = Math.max(0.4, 1 / Math.max(this._zoom, 0.4));
+    // Bake the wall colour into the pattern — CSS vars on <pattern> content
+    // do not inherit from the filled path, so var(--room-stroke) fell back
+    // to grey while the wall outline used the real border colour.
+    const stroke = color || 'var(--hp-muted, #607d8b)';
    return svg`<defs>
      <pattern id="hp-wall-hatch" patternUnits="userSpaceOnUse" width="8" height="8"
        patternTransform="rotate(45) scale(${inv.toFixed(3)})">
-        <path d="M0 0 L0 8" stroke="var(--room-stroke, #607d8b)" stroke-width="2" opacity="0.55"></path>
+        <path d="M0 0 L0 8" stroke="${stroke}" stroke-width="2"></path>
      </pattern>
    </defs>` as unknown as TemplateResult;
  }
@@ -5163,28 +5247,25 @@ class HouseplanCard extends LitElement {
    const walls = this._spaceWalls;
    if (!walls.length) return svg`` as unknown as TemplateResult;
    const openCuts = this._openPairs().flatMap((p) => p.segs);
-    const bodies = wallEdgeBodies(
-      this._spaceModel().rooms, walls, openCuts,
-      this._wallKeyPitch, this._cellCm, this._gridPitch, NORM_W,
-    );
-    if (!bodies.length) return svg`` as unknown as TemplateResult;
    const openings = (this._curSpaceCfg?.openings || []).map((o: any) => ({
      x: Number(o.x) * NORM_W, y: Number(o.y) * NORM_W,
      angle: Number(o.angle) || 0,
      length: (Number(o.length) > 0 ? Number(o.length) : 0.9) * NORM_W,
    }));
-    // screen px per plan unit — below ~3px wall depth → solid fill
+    const united = wallBodiesUnionPath(
+      this._spaceModel().rooms, walls, openCuts, openings,
+      this._wallKeyPitch, this._cellCm, this._gridPitch, NORM_W,
+    );
+    if (!united) return svg`` as unknown as TemplateResult;
    const stage = this._stageEl;
    const v = this._viewOr(this._baseVb());
    const px = stage && stage.clientWidth && v.w ? stage.clientWidth / v.w : 1;
    const stroke = disp?.color || 'var(--hp-muted)';
+    const solid = united.depthUnits * px < 3;
    return svg`<g class="wallbodies" style="--room-stroke:${stroke}">
-      ${bodies.map((b) => {
-        const solid = b.depthUnits * px < 3;
-        return svg`<path class="wallbody ${solid ? 'solid' : ''}"
-          data-hp="wall" data-id=${b.key} data-kind=${b.kind}
-          d="${wallEdgePathD(b, openings)}"></path>`;
-      })}
+      <path class="wallbody ${solid ? 'solid' : ''}"
+        data-hp="wall" data-id="union" data-kind="union"
+        d="${united.d}"></path>
    </g>` as unknown as TemplateResult;
  }

@@ -5627,6 +5708,7 @@ class HouseplanCard extends LitElement {
    const sp = this._curSpaceCfg;
    if (!sp) return;
    const H = this._spaceH;
+    const wasSplit = !!this._pendingSplit;
    let verts: number[][];
    if (this._pendingSplit) {
      // apply the cut now: the bigger part keeps the original room, this dialog names the rest
@@ -5645,13 +5727,29 @@ class HouseplanCard extends LitElement {
      verts = this._path.slice(0, -1); // without the duplicated closing vertex
    }
    const areaName = this._areaSel ? this.hass.areas[this._areaSel]?.name : '';
-    sp.rooms.push({
+    const newRoom = {
      id: 'r' + Date.now().toString(36),
      name: this._nameSel || areaName || this._t('room.default_name'),
      area: this._areaSel || null,
      poly: verts.map((p) => [p[0] / NORM_W, p[1] / H]),
      ...(this._roomSettingsFromDialog() ? { settings: this._roomSettingsFromDialog() } : {}),
-    });
+    };
+    sp.rooms.push(newRoom);
+    // Draw-session wall thickness: apply to new edges only; keep neighbour cm
+    // on shared stretches. Split naming does not use the Draw field.
+    if (!wasSplit) {
+      const cm = this._drawWallCm;
+      if (cm != null) {
+        const openCuts = this._openPairs().flatMap((p) => p.segs);
+        const roomR = { id: newRoom.id, poly: verts };
+        let next = applyWallThicknessToNewRoom(
+          sp.walls, roomR, cm, this._wallKeyPitch, openCuts, NORM_W,
+        );
+        next = degradeWalls(next, sp.rooms || [], GRID_STEP_N, 1);
+        if (next.length) sp.walls = next;
+        else delete sp.walls;
+      }
+    }
    this._saveConfig();
    this._path = [];
    this._pendingSplit = null;
@@ -6470,9 +6568,23 @@ class HouseplanCard extends LitElement {
        this._tool = 'draw';
        this._path = [];
        this._cursorPt = null;
+        this._primeDrawWallField();
        this._showToast(this._t(wasFirst && !this._importTotal ? 'toast.space_added_onboard' : 'import.done'));
      } else {
        this._showToast(d.mode === 'create' ? this._t('toast.space_added') : this._t('toast.space_saved'));
+        // A freshly created space is empty — View has nothing to show. Open
+        // the plan editor (draw tool) so the user can mark rooms immediately,
+        // same as the first-space onboard path above.
+        if (d.mode === 'create') {
+          if (this._mode !== 'plan') this._setMode('plan');
+          else {
+            this._tool = 'draw';
+            this._path = [];
+            this._cursorPt = null;
+            this._primeDrawWallField();
+            this._saveNav();
+          }
+        }
      }
    } catch (e: any) {
      // audit L3: the dialog may have been closed (Esc) while the save was
@@ -6699,7 +6811,33 @@ class HouseplanCard extends LitElement {
      const windows = this._openingsR
        .filter((o) => o.type === 'window')
        .map((o) => ({ id: o.id, x: o.rx, y: o.ry, angle: o.angle, length: o.rlen }));
-      const rays = computeSunRays(rooms, windows, sun.azimuth, sun.elevation, north!);
+      const walls = this._spaceWalls;
+      const openCuts = this._openPairs().flatMap((p) => p.segs);
+      const innerByRoom: Record<string, number[][]> = {};
+      const wallDepthByOpening: Record<string, number> = {};
+      if (walls.length) {
+        for (const r of rooms) {
+          const inn = innerContourForRoom(
+            space.rooms, r.id, walls, openCuts,
+            this._wallKeyPitch, this._cellCm, this._gridPitch, NORM_W,
+          );
+          if (inn) innerByRoom[r.id] = inn;
+        }
+        for (const o of windows) {
+          const face = openingInnerFaceOffset(
+            space.rooms, { x: o.x, y: o.y, angle: o.angle, length: o.length },
+            walls, this._wallKeyPitch, this._cellCm, this._gridPitch, NORM_W,
+          );
+          if (face.cm > 0) {
+            wallDepthByOpening[o.id] = wallCmToUnits(face.cm, this._cellCm, this._gridPitch);
+          }
+        }
+      }
+      const rays = computeSunRays(
+        rooms, windows, sun.azimuth, sun.elevation, north!,
+        walls.length ? innerByRoom : undefined,
+        walls.length ? wallDepthByOpening : undefined,
+      );
      // the rim is pure geometry off the same wedges — memoised on the same key
      this._sunRaysCache = { key, rays, rims: rays.map((r) => rayRimEdges(r)) };
    }
@@ -7106,9 +7244,17 @@ class HouseplanCard extends LitElement {
        const zoneIds = home.r.id ? openZoneOf(home.r.id, space.rooms) : new Set([home.r.id]);
        const zone = polys.filter((x) => x.r.id && zoneIds.has(x.r.id));
        const zoneList = zone.length ? zone : [home];
-        const shapes: string[] = zoneList.map(
-          (z) => 'M ' + z.poly.map((p) => p[0] + ' ' + p[1]).join(' L ') + ' Z',
-        );
+        const walls = this._spaceWalls;
+        const openCuts = this._openPairs().flatMap((p) => p.segs);
+        const shapes: string[] = zoneList.map((z) => {
+          const poly = (walls.length && z.r.id)
+            ? (innerContourForRoom(
+                space.rooms, z.r.id!, walls, openCuts,
+                this._wallKeyPitch, this._cellCm, this._gridPitch, NORM_W,
+              ) || z.poly)
+            : z.poly;
+          return 'M ' + poly.map((p) => p[0] + ' ' + p[1]).join(' L ') + ' Z';
+        });
        // doorways on the ZONE's walls spill light into rooms outside the zone
        const others = polys.filter((x) => !zoneList.includes(x)).map((x) => x.poly);
        for (const o of doors) {
@@ -7620,7 +7766,7 @@ class HouseplanCard extends LitElement {
                   One <g> around ALL paper shapes: the daynight drop shadow
                   (styles.ts) is composited once for the whole sheet, so
                   adjacent rooms never cast seams onto each other's paper. */}
-            ${this._wallHatchDefs()}${svg`<g class="hp-paperg">${this._paperShapes(space.rooms).map((sh) =>
+            ${this._wallHatchDefs(disp.color)}${svg`<g class="hp-paperg">${this._paperShapes(space.rooms).map((sh) =>
              'poly' in sh
                ? svg`<polygon class="hp-paper" points="${sh.poly}" pointer-events="none"></polygon>`
                : svg`<rect class="hp-paper" x="${sh.rect.x}" y="${sh.rect.y}" width="${sh.rect.w}" height="${sh.rect.h}" rx="${sh.rect.rx}" pointer-events="none"></rect>`,
@@ -7705,19 +7851,32 @@ class HouseplanCard extends LitElement {
              if (edgeCuts.length) cls += ' noedge';
              // island rooms punch holes in their parent's fill (evenodd)
              const myPoly = polyOf(r);
-              const holes = myPoly ? islandsOf(myPoly, otherPolys(r)) : [];
+              const walls = this._spaceWalls;
+              const fillPoly = (walls.length && r.id && myPoly)
+                ? (innerContourForRoom(
+                    space.rooms, r.id, walls,
+                    this._openPairs().flatMap((p) => p.segs),
+                    this._wallKeyPitch, this._cellCm, this._gridPitch, NORM_W,
+                  ) || myPoly)
+                : myPoly;
+              const holes = fillPoly ? islandsOf(fillPoly, otherPolys(r)) : [];
              const pathD = (pts: number[][]) =>
                'M ' + pts.map((p) => p[0] + ' ' + p[1]).join(' L ') + ' Z';
              // docs/STYLING-HOOKS.md §3 — the same three hooks whichever SVG
              // element this room happens to be drawn as today
              const hpId = r.id || nothing;
              const hpArea = r.area || nothing;
-              const shape = holes.length && myPoly
+              const shape = holes.length && fillPoly
                ? svg`<path class="${cls}" style="${style}" fill-rule="evenodd"
                    data-hp="room" data-id=${hpId} data-area=${hpArea}
-                    d="${[myPoly, ...holes].map(pathD).join(' ')}"
+                    d="${[fillPoly, ...holes].map(pathD).join(' ')}"
                    @mousemove=${tip}
                    @mouseleave=${() => (this._tip = null)}></path>`
+                : fillPoly && fillPoly !== myPoly
+                ? svg`<polygon class="${cls}" style="${style}" points="${fillPoly.map((p) => p.join(',')).join(' ')}"
+                    data-hp="room" data-id=${hpId} data-area=${hpArea}
+                    @mousemove=${tip}
+                    @mouseleave=${() => (this._tip = null)}></polygon>`
                : r.poly
                ? svg`<polygon class="${cls}" style="${style}" points="${r.poly.map((p) => p.join(',')).join(' ')}"
                    data-hp="room" data-id=${hpId} data-area=${hpArea}
@@ -9320,10 +9479,6 @@ class HouseplanCard extends LitElement {
          <circle cx="0" cy="${G}" r="${dotR * 2.1}" class="griddot major"></circle>
          <circle cx="${G}" cy="${G}" r="${dotR * 2.1}" class="griddot major"></circle>
        </pattern>
-      <pattern id="hp-wall-hatch" patternUnits="userSpaceOnUse" width="8" height="8"
-        patternTransform="rotate(45) scale(${Math.max(0.4, 1 / Math.max(this._zoom, 0.4)).toFixed(3)})">
-        <path d="M0 0 L0 8" stroke="var(--room-stroke, #607d8b)" stroke-width="2" opacity="0.55"></path>
-      </pattern>
      </defs>`;
  }

@@ -9338,11 +9493,28 @@ class HouseplanCard extends LitElement {
    const path = this._path;
    const g = this._gridPitch;
    const view = this._viewOr(this._baseVb());
+    const drawCm = this._tool === 'draw' ? this._drawWallCm : null;
+    const previewPts = (() => {
+      if (this._tool !== 'draw' || !path.length || !(drawCm != null && drawCm > 0)) return null;
+      if (this._contourClosed) return path;
+      if (this._cursorPt) return [...path, this._cursorPt];
+      return path.length >= 2 ? path : null;
+    })();
+    const previewD = previewPts
+      ? drawWallPreviewD(
+          previewPts,
+          wallCmToUnits(drawCm!, this._cellCm, this._gridPitch) / 2,
+          this._contourClosed,
+        )
+      : '';
    return svg`
      ${this._gridLevels()
        ? svg`<rect x="${view.x}" y="${view.y}" width="${view.w}" height="${view.h}" fill="url(#hp-grid-major)" pointer-events="none"></rect>`
        : nothing}
      ${segs.map((s) => svg`<line class="seg" x1="${s[0]}" y1="${s[1]}" x2="${s[2]}" y2="${s[3]}"></line>`)}
+      ${previewD
+        ? svg`<path class="drawwall-preview" d="${previewD}"></path>`
+        : nothing}
      ${path.length > 1
        ? svg`<polyline class="pathline" points="${path.map((p) => p.join(',')).join(' ')}"></polyline>`
        : nothing}
@@ -9420,6 +9592,15 @@ class HouseplanCard extends LitElement {
        ? html`<span class="hint">${this._path.length
              ? this._t('markup.hint_points', { n: this._path.length })
              : this._t('markup.hint_start')}</span>
+            <label class="drawwall">${this._t('wallthick.field')}
+              <input type="number" min="0" max="100" step="any"
+                .value=${this._drawWallFieldValue}
+                @input=${(e: Event) => {
+                  this._drawWallField = (e.target as HTMLInputElement).value;
+                }}
+                title=${this._t('markup.draw_wall_title')} />
+              <span class="opl">${this._t(this._imperial ? 'wallthick.unit_in' : 'wallthick.unit_cm')}</span>
+            </label>
            ${this._path.length ? html`<button class="btn ghost" @click=${this._cancelPath}>${this._t('btn.reset')}</button>` : nothing}`
        : nothing}
      ${this._tool === 'resize' ? html`<span class="hint">${this._t('markup.hint_resize')}</span>` : nothing}
@@ -315,6 +315,7 @@
  "wallthick.unit_cm": "cm",
  "wallthick.unit_in": "in",
  "wallthick.apply_room": "Apply to all walls of this room",
+  "markup.draw_wall_title": "Thickness for new room walls. Empty or zero — thin walls. Shared walls keep the neighbour's value.",
  "toast.wallthick_pick": "Click a wall (not an open boundary)",
  "toast.wallthick_open": "Open boundaries have no thickness",
  "toast.wallthick_set": "Wall thickness set",
@@ -315,6 +315,7 @@
  "wallthick.unit_cm": "см",
  "wallthick.unit_in": "дюйм",
  "wallthick.apply_room": "Применить ко всем стенам комнаты",
+  "markup.draw_wall_title": "Толщина стен новой комнаты. Пустое или ноль — без толщины. Общие стены сохраняют значение соседа.",
  "toast.wallthick_pick": "Кликните по стене (не по открытой границе)",
  "toast.wallthick_open": "У открытой границы нет толщины",
  "toast.wallthick_set": "Толщина стены задана",
@@ -220,7 +220,6 @@ class HouseplanSpaceCard extends LitElement {
        stroke: var(--room-stroke, var(--hp-muted, #607d8b));
        stroke-width: 0.6;
        pointer-events: none;
-        opacity: 0.95;
      }
      .hp-static-stage .devlayer {
        position: absolute;
@@ -9,7 +9,7 @@
 import { html, svg, nothing, type TemplateResult } from 'lit';
 import { buildDevices, areaLqi, areaLights, areaTemp } from './devices';
 import { spaceDisplayOf, roomFillStyle, fillColorsOf, roomFillModeOf, stageBgOf, paperRoomShapes } from './logic';
-import { wallEdgeBodies, wallEdgePathD, paperRoomShapesWithWalls, type WallEntry } from './wall-thickness';
+import { wallBodiesUnionPath, paperRoomShapesWithWalls, type WallEntry } from './wall-thickness';
 import { DEFAULT_ICON_RULES, compileIconRules, EXCLUDED_DOMAINS } from './rules';
 import { t, type Lang } from './i18n';
 import { bgModeOf, northDegOf, sunStateOf, dayPhase } from './sun';
@@ -203,17 +203,17 @@ export function renderSpaceStatic(o: StaticRenderOpts): TemplateResult | null {
  const paperShapes = walls.length
    ? paperRoomShapesWithWalls(space.rooms, walls, [], GRID_STEP_N, cellCm, GRID_PITCH, NORM_W)
    : paperRoomShapes(space.rooms);
-  const wallBodies = walls.length && disp.showBorders
-    ? wallEdgeBodies(space.rooms, walls, [], GRID_STEP_N, cellCm, GRID_PITCH, NORM_W)
-    : [];
+  const wallUnion = walls.length && disp.showBorders
+    ? wallBodiesUnionPath(space.rooms, walls, [], [], GRID_STEP_N, cellCm, GRID_PITCH, NORM_W)
+    : null;

  return html`
    <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">
-        ${wallBodies.length ? svg`<defs>
+        ${wallUnion ? svg`<defs>
          <pattern id="hp-wall-hatch" patternUnits="userSpaceOnUse" width="8" height="8"
            patternTransform="rotate(45)">
-            <path d="M0 0 L0 8" stroke="${disp.color}" stroke-width="2" opacity="0.55"></path>
+            <path d="M0 0 L0 8" stroke="${disp.color}" stroke-width="2"></path>
          </pattern>
        </defs>` : nothing}
        ${paperShapes.map((sh) =>
@@ -225,8 +225,10 @@ export function renderSpaceStatic(o: StaticRenderOpts): TemplateResult | null {
          ? svg`<image href="${bgHref}" x="${space.bg!.x}" y="${space.bg!.y}" width="${space.bg!.w}" height="${space.bg!.h}" preserveAspectRatio="none" />`
          : nothing}
        ${roomShapes}
-        ${wallBodies.map((b) => svg`<path class="wallbody" data-hp="wall" data-id=${b.key} data-kind=${b.kind}
-          d="${wallEdgePathD(b, [])}" style="--room-stroke:${disp.color}"></path>`)}
+        ${wallUnion
+          ? svg`<path class="wallbody" data-hp="wall" data-id="union" data-kind="union"
+              d="${wallUnion.d}" style="--room-stroke:${disp.color}"></path>`
+          : nothing}
      </svg>
      ${''/* docs/CANVAS.md §6: the same expression as the full card. The
             static card has no zoom, but its frame is the CONTENT now, so a
@@ -1106,11 +1106,10 @@ export const cardStyles = css`
      stroke: var(--room-stroke, var(--hp-muted));
      stroke-width: 0.6;
      pointer-events: none;
-      opacity: 0.95;
    }
    .wallbody.solid {
      fill: var(--room-stroke, var(--hp-muted));
-      fill-opacity: 0.35;
+      fill-opacity: 1;
    }
    .wallthick-hover {
      stroke: var(--accent-color, #03a9f4);
@@ -1302,6 +1301,15 @@ export const cardStyles = css`
      stroke-dasharray: 6 5;
      opacity: 0.7;
    }
+    .drawwall-preview {
+      fill: url(#hp-wall-hatch);
+      fill-opacity: 0.55;
+      fill-rule: evenodd;
+      stroke: var(--accent-color, #03a9f4);
+      stroke-width: 0.5;
+      stroke-opacity: 0.7;
+      pointer-events: none;
+    }
    .vertex {
      fill: #ffc14d;
      stroke: #4a2800;
@@ -2384,6 +2392,19 @@ export const cardStyles = css`
      color: var(--hp-muted);
      font-size: var(--fs-s);
    }
+    .editbar .drawwall {
+      display: inline-flex;
+      align-items: center;
+      gap: var(--sp-3);
+      white-space: nowrap;
+    }
+    .editbar .drawwall input {
+      width: 4.2em;
+    }
+    .editbar .drawwall .opl {
+      color: var(--hp-muted);
+      font-size: var(--fs-s);
+    }
    .menuwrap {
      position: fixed;
      inset: 0;
@@ -243,6 +243,10 @@ export interface SunRay {
 * card memoises the result on (azimuth, elevation, config rev) and reuses
 * it across hass ticks (docs/SUN.md). Mutual shading of building wings is
 * NOT considered (documented limit).
+ *
+ * `innerByRoom` (optional): when wall thickness is set, clip wedges to each
+ * room's inner contour and narrow the lit width through the opening tunnel
+ * (`max(0, L − d·tan(|α|))`, docs/WALL-THICKNESS.md §5).
 */
 export function computeSunRays(
  rooms: SunRoom[],
@@ -250,6 +254,8 @@ export function computeSunRays(
  azimuth: number,
  elevation: number,
  northDeg: number,
+  innerByRoom?: Record<string, number[][]>,
+  wallDepthByOpening?: Record<string, number>,
 ): SunRay[] {
  if (!(elevation > 0)) return [];
  const toSun = sunDirOnPlan(azimuth, northDeg);
@@ -262,13 +268,26 @@ export function computeSunRays(
    if (!info || !windowLit(info.normal, toSun, elevation)) continue;
    const room = rooms.find((r) => r.id === info.roomId);
    if (!room) continue;
+    const clipPoly = (innerByRoom && innerByRoom[info.roomId]) || room.poly;
    const rad = (w.angle * Math.PI) / 180;
-    const hx = (Math.cos(rad) * w.length) / 2;
-    const hy = (Math.sin(rad) * w.length) / 2;
+    let half = w.length / 2;
+    const d = wallDepthByOpening?.[w.id] || 0;
+    if (d > 0) {
+      // tunnel narrowing: α = angle between ray and inward normal
+      const inward: [number, number] = [-info.normal[0], -info.normal[1]];
+      const cos = Math.max(-1, Math.min(1, away[0] * inward[0] + away[1] * inward[1]));
+      const sin = Math.sqrt(Math.max(0, 1 - cos * cos));
+      const tan = cos > 1e-9 ? sin / cos : 1e6;
+      const eff = Math.max(0, w.length - d * tan);
+      half = eff / 2;
+      if (!(eff > 0)) continue;
+    }
+    const hx = Math.cos(rad) * half;
+    const hy = Math.sin(rad) * half;
    const a = [w.x - hx, w.y - hy];
    const b = [w.x + hx, w.y + hy];
    const len = k * w.length;
-    const polys = clipToRoom(rayQuad(a, b, away, len), room.poly);
+    const polys = clipToRoom(rayQuad(a, b, away, len), clipPoly);
    if (!polys.length) continue;
    // inward normal + how deep the ray gets: cos of the incidence angle,
    // which windowLit() has already found to be above RAY_MIN_COS
@@ -2,10 +2,12 @@
 * Wall thickness — pure geometry (docs/WALL-THICKNESS.md).
 *
 * Thickness is a rendering layer keyed by a segment identity that survives
- * resize. Area, sun, glow and rulers keep reading the room polygon; nothing
- * here changes that contract.
+ * resize. Wall bodies grow ±½ from the centreline; fills, glow, sun and
+ * displayed m² use the inner (inset) contour. Wall-length rulers stay on the
+ * centreline.
 */
-import { roomPoly, roomEdges } from './logic';
+import { union, difference } from 'polyclip-ts';
+import { roomPoly, roomEdges, sharedBoundary } from './logic';

 export interface WallEntry {
  key: string;
@@ -14,6 +16,8 @@ export interface WallEntry {

 export const WALL_MIN_CM = 1;
 export const WALL_MAX_CM = 100;
+/** Default thickness offered in the Draw toolbar (docs/WALL-THICKNESS.md §6). */
+export const DRAW_WALL_DEFAULT_CM = 15;

 /** Mitre spikes longer than this × thickness fall back to a bevel. */
 export const MITRE_LIMIT = 4;
@@ -117,18 +121,26 @@ export function lookupWall(
  let ang = Math.atan2(dy, dx);
  if (ang < 0) ang += Math.PI;
  const tol = Math.max(pitch * 0.5, 1e-9);
+  const scale = coordScale > 0 ? coordScale : 1;
+  let best: { w: WallEntry; d: number } | null = null;
  for (const w of walls) {
    const at = w.key.lastIndexOf('@');
    if (at < 0) continue;
    const [sx, sy] = w.key.slice(0, at).split(',').map(Number);
    const aq = Number(w.key.slice(at + 1));
    if (![sx, sy, aq].every(Number.isFinite)) continue;
-    if (Math.hypot(sx - mx, sy - my) > tol) continue;
    let dAng = Math.abs(aq - ang);
    if (dAng > Math.PI / 2) dAng = Math.PI - dAng;
-    if (dAng < 0.02) return w; // ~1°
+    if (dAng >= 0.02) continue; // ~1°
+    const midDist = Math.hypot(sx - mx, sy - my);
+    if (midDist <= tol) return w;
+    // atomic shared span: wall mid lies on this edge (partial overlap)
+    const dist = distToSeg(sx * scale, sy * scale, a[0], a[1], b[0], b[1]);
+    if (dist <= tol * scale) {
+      if (!best || midDist < best.d) best = { w, d: midDist };
+    }
  }
-  return null;
+  return best?.w || null;
 }

 export function thicknessCmAt(
@@ -141,7 +153,7 @@ export function thicknessCmAt(
  return e && e.cm > 0 ? clampWallCm(e.cm) : 0;
 }

-/** Drop entries whose key matches no current room edge. */
+/** Drop entries whose key matches no current room edge or shared atomic span. */
 export function degradeWalls(
  walls: WallEntry[] | null | undefined,
  rooms: any[],
@@ -153,9 +165,42 @@ export function degradeWalls(
  for (const seg of roomEdges(rooms)) {
    live.add(keyOf([seg[0], seg[1]], [seg[2], seg[3]], pitch, coordScale));
  }
+  // partial shared overlaps are keyed by their own mid — keep those too
+  const list = rooms || [];
+  const eps = Math.max(pitch * coordScale * 0.02, 1e-9);
+  for (let i = 0; i < list.length; i++) {
+    const pa = roomPoly(list[i]);
+    if (!pa) continue;
+    for (let j = i + 1; j < list.length; j++) {
+      const pb = roomPoly(list[j]);
+      if (!pb) continue;
+      for (const sg of sharedBoundary(pa, pb, eps)) {
+        live.add(keyOf([sg[0], sg[1]], [sg[2], sg[3]], pitch, coordScale));
+      }
+    }
+  }
  return walls.filter((w) => live.has(w.key) && w.cm >= WALL_MIN_CM && w.cm <= WALL_MAX_CM);
 }

+/**
+ * Wall direction vs opening angle (both mod 180°). Used so a T-junction
+ * opening does not bind to the perpendicular receiving wall.
+ */
+export function wallAngleMatches(
+  a: number[], b: number[],
+  openingAngleDeg: number,
+  tolDeg = 8,
+): boolean {
+  const [dx, dy] = wallDir(a, b);
+  let wang = Math.atan2(dy, dx);
+  if (wang < 0) wang += Math.PI;
+  let oang = ((openingAngleDeg * Math.PI) / 180) % Math.PI;
+  if (oang < 0) oang += Math.PI;
+  let d = Math.abs(wang - oang);
+  if (d > Math.PI / 2) d = Math.PI - d;
+  return d <= (tolDeg * Math.PI) / 180;
+}
+
 /**
 * After an edge drag: rewrite keys whose old span mid/dir map to a moved
 * stretch. `oldSpans` / `newSpans` are parallel lists of [a,b] endpoints.
@@ -226,6 +271,78 @@ export function setWallThicknessForRoom(
  return out;
 }

+/**
+ * After drawing a new room: set session thickness on edges that do not yet
+ * have one. Shared stretches that already carry a neighbour's cm are left
+ * alone (docs/WALL-THICKNESS.md — one physical wall, one thickness).
+ */
+export function applyWallThicknessToNewRoom(
+  walls: WallEntry[] | null | undefined,
+  room: any,
+  cm: number | null,
+  pitch: number,
+  openCuts: number[][] = [],
+  coordScale = 1,
+): WallEntry[] {
+  if (cm == null || cm < WALL_MIN_CM) return walls ? walls.slice() : [];
+  const poly = roomPoly(room);
+  if (!poly || poly.length < 3) return walls ? walls.slice() : [];
+  let out = walls ? walls.slice() : [];
+  for (let i = 0; i < poly.length; i++) {
+    const a = poly[i], b = poly[(i + 1) % poly.length];
+    if (edgeIsOpen(a, b, openCuts, pitch, coordScale)) continue;
+    if (thicknessCmAt(out, a, b, pitch, coordScale) > 0) continue;
+    out = setWallThickness(out, a, b, cm, pitch, coordScale);
+  }
+  return out;
+}
+
+/**
+ * SVG path for the thick-wall preview while drawing a room outline.
+ * Closed contours use outset−inset; open polylines use per-segment quads.
+ */
+export function drawWallPreviewD(
+  pts: number[][],
+  halfDepth: number,
+  closed: boolean,
+): string {
+  if (!(halfDepth > 0) || !pts || pts.length < 2) return '';
+  if (closed && pts.length >= 3) {
+    let poly = pts;
+    const last = pts[pts.length - 1];
+    if (pts.length >= 4
+        && Math.hypot(pts[0][0] - last[0], pts[0][1] - last[1]) < 1e-9) {
+      poly = pts.slice(0, -1);
+    }
+    if (poly.length >= 3) {
+      const offs = poly.map(() => halfDepth);
+      const outset = outsetContour(poly, offs);
+      const inset = insetContour(poly, offs);
+      if (outset && inset) {
+        return `${polyToPath(outset)} ${polyToPath(reversePoly(inset))}`;
+      }
+    }
+  }
+  let d = '';
+  for (let i = 0; i < pts.length - 1; i++) {
+    const a = pts[i], b = pts[i + 1];
+    const dx = b[0] - a[0], dy = b[1] - a[1];
+    const L = Math.hypot(dx, dy);
+    if (L < 1e-9) continue;
+    const ux = dx / L, uy = dy / L;
+    const nx = -uy, ny = ux;
+    const h = halfDepth;
+    const quad = [
+      [a[0] + nx * h, a[1] + ny * h],
+      [b[0] + nx * h, b[1] + ny * h],
+      [b[0] - nx * h, b[1] - ny * h],
+      [a[0] - nx * h, a[1] - ny * h],
+    ];
+    d += (d ? ' ' : '') + polyToPath(quad);
+  }
+  return d;
+}
+
 function edgeIsOpen(a: number[], b: number[], cuts: number[][], pitch: number, coordScale = 1): boolean {
  if (!cuts.length) return false;
  const key = keyOf(a, b, pitch, coordScale);
@@ -429,8 +546,8 @@ function distToSeg(px: number, py: number, ax: number, ay: number, bx: number, b
 }

 /**
- * Per-room inward offsets (plan units) for insetContour: shared → half,
- * outer → full, open/none → 0.
+ * Per-room half-depth offsets (plan units) for inset/outset: every thick edge
+ * (shared or outer) → half; open/none → 0. docs/WALL-THICKNESS.md §2.
 */
 export function insetOffsetsForRoom(
  rooms: any[],
@@ -453,15 +570,61 @@ export function insetOffsetsForRoom(
    if (!kind) { out.push(0); continue; }
    const cm = thicknessCmAt(walls, a, b, pitch, coordScale);
    if (!(cm > 0)) { out.push(0); continue; }
-    const full = wallCmToUnits(cm, cellCm, gridPitch);
-    out.push(kind === 'shared' ? full / 2 : full);
+    out.push(wallCmToUnits(cm, cellCm, gridPitch) / 2);
  }
  return out;
 }

+/** Alias — half offsets drive both inset and outset. */
+export const halfOffsetsForRoom = insetOffsetsForRoom;
+
 /**
- * One evenodd ring path per room that has any thick edge. Shared walls are
- * drawn as two half-rings that meet at the centreline (one entry each side).
+ * Inner (clean-floor) contour of a room: inset by half wall thickness.
+ * Returns the original poly when there is no thickness.
+ */
+export function innerContourForRoom(
+  rooms: any[],
+  roomId: string,
+  walls: WallEntry[] | null | undefined,
+  openCuts: number[][],
+  pitch: number,
+  cellCm: number,
+  gridPitch: number,
+  coordScale = 1,
+): number[][] | null {
+  const room = (rooms || []).find((r) => r?.id === roomId);
+  const poly = roomPoly(room);
+  if (!poly || poly.length < 3) return null;
+  if (!walls?.length) return poly.map((p) => [p[0], p[1]]);
+  const offsets = insetOffsetsForRoom(
+    rooms, roomId, walls, openCuts, pitch, cellCm, gridPitch, coordScale,
+  );
+  if (!offsets.some((o) => o > 0)) return poly.map((p) => [p[0], p[1]]);
+  return insetContour(poly, offsets) || poly.map((p) => [p[0], p[1]]);
+}
+
+function closedRing(poly: number[][]): number[][][] {
+  const ring = poly.map((p) => [p[0], p[1]]);
+  ring.push([poly[0][0], poly[0][1]]);
+  return [ring];
+}
+
+function polyclipToPathD(geom: any): string {
+  if (!geom) return '';
+  let d = '';
+  for (const poly of geom as any[]) {
+    const ring = poly?.[0];
+    if (!Array.isArray(ring) || ring.length < 4) continue;
+    const pts = ring.slice(0, ring.length - 1);
+    if (pts.length < 3) continue;
+    d += (d ? ' ' : '') + polyToPath(pts.map((p: number[]) => [p[0], p[1]]));
+  }
+  return d;
+}
+
+/**
+ * One evenodd ring path per room: outset(half) − inset(half). Shared walls
+ * meet as two half-rings; callers may union them via wallBodiesUnionPath.
 */
 export function wallBodyRings(
  rooms: any[],
@@ -479,9 +642,10 @@ export function wallBodyRings(
    if (!poly || poly.length < 3) continue;
    const offsets = insetOffsetsForRoom(rooms, room.id, walls, openCuts, pitch, cellCm, gridPitch, coordScale);
    if (!offsets.some((o) => o > 0)) continue;
+    const outset = outsetContour(poly, offsets);
    const inset = insetContour(poly, offsets);
-    if (!inset) continue;
-    const d = `${polyToPath(poly)} ${polyToPath(reversePoly(inset))}`;
+    if (!outset || !inset) continue;
+    const d = `${polyToPath(outset)} ${polyToPath(reversePoly(inset))}`;
    let key = '';
    let kind: WallKind = 'outer';
    let cm = 0;
@@ -502,9 +666,84 @@ export function wallBodyRings(
 }

 /**
- * Per-edge wall quads for styling hooks and opening cuts — one body per
- * unique wall key. Shared walls are a single full-depth quad centred on the
- * centreline; outer walls are a full-depth quad inward only.
+ * Seamless wall hatch: union of all half-outsets minus union of all half-insets,
+ * with opening slots cut as holes. One continuous body across L and T joins.
+ */
+export function wallBodiesUnionPath(
+  rooms: any[],
+  walls: WallEntry[] | null | undefined,
+  openCuts: number[][],
+  openings: Array<{ x: number; y: number; angle: number; length: number }> = [],
+  pitch: number,
+  cellCm: number,
+  gridPitch: number,
+  coordScale = 1,
+): { d: string; depthUnits: number } | null {
+  if (!walls?.length) return null;
+  const outsets: number[][][] = [];
+  const insets: number[][][] = [];
+  let maxDepth = 0;
+  for (const room of rooms || []) {
+    const poly = roomPoly(room);
+    if (!poly || poly.length < 3) continue;
+    const offsets = insetOffsetsForRoom(
+      rooms, room.id, walls, openCuts, pitch, cellCm, gridPitch, coordScale,
+    );
+    if (!offsets.some((o) => o > 0)) continue;
+    for (let i = 0; i < offsets.length; i++) {
+      if (offsets[i] > 0) maxDepth = Math.max(maxDepth, offsets[i] * 2);
+    }
+    const outC = outsetContour(poly, offsets);
+    const inC = insetContour(poly, offsets);
+    if (outC) outsets.push(outC);
+    if (inC) insets.push(inC);
+  }
+  if (!outsets.length) return null;
+  try {
+    let Uout: any = closedRing(outsets[0]);
+    for (let i = 1; i < outsets.length; i++) {
+      Uout = union(Uout, closedRing(outsets[i]) as any);
+    }
+    let body: any = Uout;
+    if (insets.length) {
+      let Uin: any = closedRing(insets[0]);
+      for (let i = 1; i < insets.length; i++) {
+        Uin = union(Uin, closedRing(insets[i]) as any);
+      }
+      body = difference(Uout, Uin);
+    }
+    // cut opening tunnels (axis-aligned to opening angle)
+    for (const o of openings) {
+      if (!(o.length > 0)) continue;
+      const rad = (o.angle * Math.PI) / 180;
+      const ux = Math.cos(rad), uy = Math.sin(rad);
+      const nx = -uy, ny = ux;
+      const half = o.length / 2;
+      const pad = Math.max(maxDepth, pitch * coordScale) * 1.25;
+      const slot = [
+        [o.x - ux * half - nx * pad, o.y - uy * half - ny * pad],
+        [o.x + ux * half - nx * pad, o.y + uy * half - ny * pad],
+        [o.x + ux * half + nx * pad, o.y + uy * half + ny * pad],
+        [o.x - ux * half + nx * pad, o.y - uy * half + ny * pad],
+      ];
+      body = difference(body, closedRing(slot) as any);
+    }
+    const d = polyclipToPathD(body);
+    if (!d) return null;
+    return { d, depthUnits: maxDepth };
+  } catch {
+    // fall back to evenodd rings concatenated
+    const rings = wallBodyRings(rooms, walls, openCuts, pitch, cellCm, gridPitch, coordScale);
+    if (!rings.length) return null;
+    return { d: rings.map((r) => r.d).join(' '), depthUnits: maxDepth };
+  }
+}
+
+/**
+ * Per-edge wall quads for styling hooks and thick-cut suppression — one body
+ * per unique wall key. Shared and outer walls both grow ±½ from the
+ * centreline (docs/WALL-THICKNESS.md §2). Production hatch uses
+ * wallBodiesUnionPath; these quads remain for hooks / stroke cuts.
 */
 export interface WallEdgeBody {
  key: string;
@@ -545,23 +784,13 @@ export function wallEdgeBodies(
      const depth = wallCmToUnits(cm, cellCm, gridPitch);
      const [inx, iny] = inwardNormal(poly, i);
      const ox = -inx, oy = -iny;
-      let quad: number[][];
-      if (kind === 'shared') {
-        const h = depth / 2;
-        quad = [
-          [a[0] + ox * h, a[1] + oy * h],
-          [b[0] + ox * h, b[1] + oy * h],
-          [b[0] + inx * h, b[1] + iny * h],
-          [a[0] + inx * h, a[1] + iny * h],
-        ];
-      } else {
-        quad = [
-          [a[0], a[1]],
-          [b[0], b[1]],
-          [b[0] + inx * depth, b[1] + iny * depth],
-          [a[0] + inx * depth, a[1] + iny * depth],
-        ];
-      }
+      const h = depth / 2;
+      const quad: number[][] = [
+        [a[0] + ox * h, a[1] + oy * h],
+        [b[0] + ox * h, b[1] + oy * h],
+        [b[0] + inx * h, b[1] + iny * h],
+        [a[0] + inx * h, a[1] + iny * h],
+      ];
      out.push({ key, kind, cm, quad, a: [a[0], a[1]], b: [b[0], b[1]], depthUnits: depth });
    }
  }
@@ -579,6 +808,7 @@ export function wallEdgePathD(
  // normal across the wall (from a toward inward of first room estimate = perp)
  const nx = -uy, ny = ux;
  for (const o of openings) {
+    if (!wallAngleMatches(body.a, body.b, o.angle)) continue;
    // only openings whose centre lies on (or very near) this span's centreline
    const dist = distToSeg(o.x, o.y, body.a[0], body.a[1], body.b[0], body.b[1]);
    if (dist > Math.max(body.depthUnits * 0.55, 1e-3)) continue;
@@ -599,9 +829,9 @@ export function wallEdgePathD(
 }

 /**
- * Outward paper growth offsets per edge (plan units): enough paper under the
- * wall body so the scene background never shows through. Shared → half;
- * outer → 0 (body is entirely inward); open → 0.
+ * Outward paper growth offsets per edge (plan units): half-thickness under
+ * every thick wall (outer and shared) so the scene background never shows
+ * through the outer half-out.
 */
 export function paperOutwardOffsets(
  rooms: any[],
@@ -621,7 +851,7 @@ export function paperOutwardOffsets(
  for (let i = 0; i < poly.length; i++) {
    const a = poly[i], b = poly[(i + 1) % poly.length];
    const kind = kinds[i];
-    if (kind !== 'shared') { out.push(0); continue; }
+    if (!kind) { out.push(0); continue; }
    const cm = thicknessCmAt(walls, a, b, pitch, coordScale);
    if (!(cm > 0)) { out.push(0); continue; }
    out.push(wallCmToUnits(cm, cellCm, gridPitch) / 2);
@@ -712,7 +942,8 @@ export function paperRoomShapesWithWalls(

 /**
 * Half-depth from the centreline toward the door's inner face (the room the
- * leaf swings into). Used to shift the swing arc off the centreline.
+ * leaf swings into). Association prefers a wall whose direction matches the
+ * opening angle (T-junctions must not bind to the perpendicular receiver).
 */
 export function openingInnerFaceOffset(
  rooms: any[],
@@ -723,14 +954,24 @@ export function openingInnerFaceOffset(
  gridPitch: number,
  coordScale = 1,
 ): { ox: number; oy: number; cm: number } {
-  let best: { a: number[]; b: number[]; room: any; edge: number; dist: number } | null = null;
+  let best: { a: number[]; b: number[]; room: any; edge: number; dist: number; angled: boolean } | null = null;
  for (const room of rooms || []) {
    const poly = roomPoly(room);
    if (!poly) continue;
    for (let i = 0; i < poly.length; i++) {
      const a = poly[i], b = poly[(i + 1) % poly.length];
      const d = distToSeg(opening.x, opening.y, a[0], a[1], b[0], b[1]);
-      if (!best || d < best.dist) best = { a, b, room, edge: i, dist: d };
+      const angled = wallAngleMatches(a, b, opening.angle);
+      if (!best) {
+        best = { a, b, room, edge: i, dist: d, angled };
+        continue;
+      }
+      // prefer angle-matching edges; among equals, nearer centreline
+      if (angled && !best.angled) {
+        best = { a, b, room, edge: i, dist: d, angled };
+      } else if (angled === best.angled && d < best.dist) {
+        best = { a, b, room, edge: i, dist: d, angled };
+      }
    }
  }
  if (!best || best.dist > pitch * coordScale) return { ox: 0, oy: 0, cm: 0 };
@@ -740,8 +981,7 @@ export function openingInnerFaceOffset(
  const poly = roomPoly(best.room)!;
  const [inx, iny] = inwardNormal(poly, best.edge);
  const s = opening.flip_v ? -1 : 1;
-  const kinds = edgeKinds(rooms, best.room.id, [], pitch, coordScale);
-  const kind = kinds[best.edge] || 'outer';
-  const along = kind === 'shared' ? depth / 2 : depth;
+  // ±½ growth: the inner face is always half-depth from the centreline
+  const along = depth / 2;
  return { ox: inx * along * s, oy: iny * along * s, cm };
 }
@@ -3,8 +3,10 @@ import test from 'node:test';
 import assert from 'node:assert/strict';
 import {
  wallKey, lookupWall, thicknessCmAt, degradeWalls, rekeyWallsAfterMove,
-  setWallThickness, setWallThicknessForRoom, clampWallCm, cmToField, fieldToCm,
+  setWallThickness, setWallThicknessForRoom, applyWallThicknessToNewRoom,
+  drawWallPreviewD, DRAW_WALL_DEFAULT_CM, clampWallCm, cmToField, fieldToCm,
  wallCmToUnits, insetContour, inwardNormal, edgeKinds, wallEdgeBodies,
+  wallBodyRings, wallBodiesUnionPath, innerContourForRoom,
  paperRoomShapesWithWalls, WALL_MIN_CM, WALL_MAX_CM, MITRE_LIMIT,
 } from '../test-build/wall-thickness.js';
 import { polygonArea, paperRoomShapes } from '../test-build/logic.js';
@@ -151,7 +153,7 @@ test('inwardNormal points into the rectangle', () => {

 // ------------------------------- bodies / paper -----------------------------

-test('wallEdgeBodies: shared wall is one full-depth quad, outer is inward', () => {
+test('wallEdgeBodies: shared and outer both grow ±½ from the centreline', () => {
  const rooms = [
    { id: 'a', poly: [[0, 0], [5, 0], [5, 4], [0, 4]] },
    { id: 'b', poly: [[5, 0], [10, 0], [10, 4], [5, 4]] },
@@ -176,6 +178,28 @@ test('wallEdgeBodies: shared wall is one full-depth quad, outer is inward', () =
  assert.equal(outer.kind, 'outer');
  // only one body per key even though two rooms see the shared wall
  assert.equal(bodies.filter((b) => b.key === sharedKey).length, 1);
+  // outer grows half outward: min y of quad < 0
+  const ys = outer.quad.map((p) => p[1]);
+  assert.ok(Math.min(...ys) < -1e-9, 'outer must grow outward by half');
+});
+
+test('wallBodyRings / union: outset − inset forms a closed ring', () => {
+  const rooms = [
+    { id: 'a', poly: [[0, 0], [5, 0], [5, 4], [0, 4]] },
+    { id: 'b', poly: [[5, 0], [10, 0], [10, 4], [5, 4]] },
+  ];
+  const walls = [
+    { key: wallKey([5, 0], [5, 4], pitch), cm: 20 },
+    { key: wallKey([0, 0], [5, 0], pitch), cm: 20 },
+  ];
+  const rings = wallBodyRings(rooms, walls, [], pitch, cellCm, pitch);
+  assert.ok(rings.length >= 1);
+  assert.ok(rings[0].d.includes('M'));
+  const united = wallBodiesUnionPath(rooms, walls, [], [], pitch, cellCm, pitch);
+  assert.ok(united && united.d.includes('M'));
+  const inner = innerContourForRoom(rooms, 'a', walls, [], pitch, cellCm, pitch);
+  assert.ok(inner);
+  assert.ok(polygonArea(inner) < polygonArea(rooms[0].poly));
 });

 test('paper with walls covers shared centreline; without walls matches paperRoomShapes', () => {
@@ -200,3 +224,28 @@ test('area of the room polygon is unchanged by thickness helpers', () => {
  insetContour(poly, [0.5, 0.5, 0.5, 0.5]);
  assert.equal(polygonArea(poly), before);
 });
+
+test('applyWallThicknessToNewRoom skips edges that already have thickness', () => {
+  const sharedKey = wallKey([5, 0], [5, 4], pitch);
+  const existing = [{ key: sharedKey, cm: 40 }];
+  const newRoom = { id: 'b', poly: [[5, 0], [10, 0], [10, 4], [5, 4]] };
+  const next = applyWallThicknessToNewRoom(existing, newRoom, DRAW_WALL_DEFAULT_CM, pitch);
+  const shared = next.find((w) => w.key === sharedKey);
+  assert.equal(shared?.cm, 40, 'neighbour thickness must be kept');
+  // other three edges of b get the draw default
+  assert.equal(next.filter((w) => w.cm === DRAW_WALL_DEFAULT_CM).length, 3);
+  assert.equal(thicknessCmAt(next, [5, 0], [10, 0], pitch), DRAW_WALL_DEFAULT_CM);
+});
+
+test('applyWallThicknessToNewRoom with null cm is a no-op', () => {
+  const room = { id: 'r', poly: [[0, 0], [1, 0], [1, 1], [0, 1]] };
+  assert.deepEqual(applyWallThicknessToNewRoom([], room, null, pitch), []);
+});
+
+test('drawWallPreviewD returns a path for open and closed outlines', () => {
+  const open = drawWallPreviewD([[0, 0], [10, 0], [10, 6]], 1, false);
+  assert.ok(open.includes('M'));
+  const closed = drawWallPreviewD([[0, 0], [10, 0], [10, 6], [0, 6]], 1, true);
+  assert.ok(closed.includes('M'));
+  assert.equal(drawWallPreviewD([[0, 0]], 1, false), '');
+});
@@ -1320,7 +1320,7 @@ def test_space_walls_thickness():
    """docs/WALL-THICKNESS.md: optional walls[{key,cm}]; absent = today's plan;
    cm bounded 1..100; key a bounded string; list capped like openings."""
    base = {"id": "s1", "title": "S", "view_box": [0, 0, 1, 1], "rooms": []}
-    # no walls — byte-compatible
+    # no walls -- byte-compatible
    assert "walls" not in v.CONFIG_SCHEMA({"spaces": [base]})["spaces"][0]

    ok = {"key": "0.50,0.20@0.0000", "cm": 20}