@reekon-tools/boldr-cad 0.1.0 → 1.0.0

package/dist/editor/elevation.js

@@ -1,475 +1,427 @@
-import { afterEdit, redo, resolveOpeningsNow, undo } from '../app/edit';
+import { afterEdit, analyze, resolveOpeningsNow, undo } from '../app/edit';
 import { ed } from '../app/state';
-import { addElevLine, elevFrame, elevKey, elevLines, elevLineUZ, elevOpenings, openingHeights, roomSideOf, toU, wallHeight, WINDOW_H } from '../model/elevation';
+import { DOOR_H, elevFrame, elevOpenings, openingHeights, roomSideOf, toU, wallHeight, WINDOW_H } from '../model/elevation';
+import { faceEdit, faceKey, faceKeyParts } from '../model/faces';
+import { wallFace } from '../model/wallfaces';
+import { faceOverflow, forgetSynced, openFace, placedMarks, planOverflow, pushedOut, setPlacedMarks, syncFace, syncFaces } from '../model/facesolve';
 import { clamp } from '../model/geom';
 import { pushHistory } from '../model/history';
 import { uid } from '../model/ids';
-import { applySlide, openingSpan, pickBetween, sameRef, slideGroup } from '../model/openings';
-import { onSessionReset, sessionState } from '../model/session';
+import { applySlide, edgeS, openingSpan, pickBetween, resolveOpenings, sameRef, slideGroup, STANDARD_OPENING_W } from '../model/openings';
+import { sessionState } from '../model/session';
 import { settings } from '../model/settings';
-import { deleteSel, lineLen } from '../model/sketch';
-import { SK } from '../model/store';
-import { elevT } from '../render/elevation';
-import { requestDraw, S } from '../render/view';
+import { deleteSel, gc, lineLen, restorePos, snapshotPos } from '../model/sketch';
+import { planSK, SK } from '../model/store';
+import { cabBox, previewChip } from '../render/elevation';
+import { TH } from '../render/theme';
+import { fitView, mainT, requestDraw, requestOverlayDraw, S, setWallBox } from '../render/view';
 import { editElevationPosition, editOpeningHeight, editSill, editWallHeight } from '../tools/elevation';
 import { editOpeningDim } from '../tools/openings';
+import { cancelTool } from '../tools/registry';
 import { fmtLen } from '../units';
-import { openKeypad, renderElevation, setCursor, toast, updateCtx } from './ports';
+import { addCabinet, addHeightLine, CAB, cabinetSpot, deleteCabinets, dimensionFace, editCabinet, editCabinetDepth, snapObjectMove } from './face';
+import { openKeypad, refreshModes, renderElevation, toast, updateCtx, updateHint, updateRail, updateTopBar } from './ports';
 /*
-  The wall elevation: a full-screen view of one straight wall, straight on, whatever draws it.
-  It shows the live drawing (nothing is copied), so the plan and the elevation can't disagree. Drag a door or
-  window to move it (unless a dimension locks it); tap a dimension to select it, then + changes it; draw lines and
-  guides on the wall face; place doors and windows. This module holds the view's state, tools, snapping, selection,
-  the bar's decisions, delete, and pointer routing; the interface draws it (render/elevationView.ts) and shows it.
+  The wall view: one straight wall seen straight on, edited with the plan's own tools. Opening a wall makes the
+  editor work on that wall face's sketch (model/faces.ts: SK() is the face) — its grid, lines, circles and arcs,
+  constraints, dimensions, selection and dragging are the plan's — with the plan's corners, floor, ceiling, doors and
+  windows as fixed anchors to snap and constrain to. On top of that, the wall view's own: doors and windows placed
+  and dragged on the wall (they're the plan's), cabinets, height lines, and the dimension chips doors, windows and
+  cabinets get (render/elevation.ts), each tapped to select and changed with the yellow +.
 */
-/** The open wall view's state (the interface reads it to draw). */
+/** The open wall: which wall, from which side, and its frame (from the live plan). */
 export const elev = sessionState(() => ({
     lid: null,
     flip: false,
-    view: null,
     frame: null,
-    W: 0, H: 0,
-    hits: [],
-    /** the selected dimension (ringed in yellow; the bar's + opens its keypad) */
-    active: null,
-    /** the opening being dragged (outlined in yellow) */
-    dragOp: null,
-    /** selected openings, wall corners and drawn lines (tap; Shift/⌘-tap adds) — the bar's + dimensions them */
-    objs: [],
-    /** the active tool (the toolbar on the left) */
-    tool: 'select',
-    /** line / guide tool: the first point, [u, z], once placed */
-    lineStart: null,
-    /** where the pointer is (snapped), for previews while a drawing tool is active */
-    cursor: null,
 }));
-const objKey = (o) => (o.k === 'corner' ? 'corner:' + o.end : o.k + ':' + o.id);
 /** Size of a new door/window placed in the wall view (as the plan's tool), inches. */
-export const NEW_W = 36;
+export const NEW_W = STANDARD_OPENING_W;
 export const elevOpen = () => elev.lid != null;
-/** Tappable dimension chips of the open elevation (canvas pixels), for tests. */
-export const elevHits = () => elev.hits;
-/** Open the elevation of a straight wall, seen from the room side. */
-export function openElevation(lid) {
-    const sk = SK();
-    if (!elevFrame(sk, lid)) {
-        toast('Elevations work on straight walls. Turn the line into a wall first.');
+/** The open wall, for the wall view to fit: along it from corner to corner, and from the floor to its height. */
+const wallBox = () => (elev.frame ? { x0: elev.frame.face[0], y0: 0, x1: elev.frame.face[1], y1: elev.frame.H } : null);
+/** Open the wall view of a straight wall, seen from the room side. */
+/** Open a wall's view: from the side a room is on — or `side`, the face to the left (+1) or right (−1) of its A → B. */
+export function openElevation(lid, side) {
+    if (!elevFrame(planSK(), lid)) {
+        toast('Elevations work on straight walls. Turn the line into a wall first.', { warn: true });
         return;
     }
+    cancelTool();
     elev.lid = lid;
-    elev.flip = false;
-    elev.view = null;
-    elev.active = null;
-    elev.objs = [];
-    elev.lineStart = null;
-    elev.cursor = null;
-    setElevTool('select', true); // renders: the interface shows the sheet first, so the view fits its real size
-}
-/** Back to the plan (the interface hides the sheet). */
+    elev.flip = side != null && side !== (roomSideOf(planSK(), lid) || 1);
+    enterFace();
+}
+/** Start editing the open wall's face (from the side `elev.flip` says). */
+function enterFace() {
+    const f = elevFrame(planSK(), elev.lid, elev.flip);
+    elev.frame = f;
+    // (handed over here, not as this module loads: the view module is still loading then)
+    setWallBox(wallBox);
+    faceEdit.key = faceKey(f.lid, f.side);
+    openFace(planSK(), f.lid, f.side);
+    ed.mode = 'draft';
+    ed.tool = 'select';
+    ed.sel = [];
+    ed.hover = null;
+    ed.snapState = null;
+    ed.preview = null;
+    ed.boxSel = null;
+    analyze();
+    fitView();
+    refreshModes();
+    updateRail();
+    updateCtx();
+    updateHint();
+    updateTopBar();
+    renderElevation();
+    requestDraw();
+}
+/** Stop editing the face (a face with nothing on it isn't kept). */
+function leaveFace() {
+    cancelTool();
+    faceEdit.key = null;
+    gc(planSK());
+}
+/** Open the wall a cabinet is on, from its side, with the cabinet selected (a tap on its footprint in the plan). */
+export function openCabinet(key, cabId) {
+    const { lid, side } = faceKeyParts(key);
+    openElevation(lid);
+    if (!elevOpen())
+        return;
+    if (elev.frame && elev.frame.side !== side)
+        flipElevation();
+    if (SK().cabs?.[cabId]) {
+        ed.sel = [{ type: 'cab', id: cabId }];
+        updateCtx();
+        updateHint();
+        requestDraw();
+    }
+    toast('This cabinet’s wall — Back returns to the plan.');
+}
+/** Back to the plan, with the wall selected. */
 export function closeElevation() {
     if (!elevOpen())
         return;
+    const lid = elev.lid;
+    leaveFace();
     elev.lid = null;
     elev.frame = null;
-    elev.active = null;
-    elev.objs = [];
-    elev.lineStart = null;
-    elev.cursor = null;
+    ed.tool = 'select';
+    ed.hover = null;
+    ed.preview = null;
+    ed.sel = planSK().lines[lid] ? [{ type: 'line', id: lid }] : [];
+    analyze();
+    refreshModes();
+    updateRail();
+    updateCtx();
+    updateHint();
+    updateTopBar();
     renderElevation();
     requestDraw();
 }
+/** Look at the wall from its other side (each side has its own drawing). */
 export function flipElevation() {
     if (!elevOpen())
         return;
+    leaveFace();
     elev.flip = !elev.flip;
-    elev.view = null;
-    elev.active = null;
-    elev.objs = [];
-    elev.lineStart = null;
-    renderElevation();
+    enterFace();
 }
 /** Fit the wall to the view again. */
-export function fitElevation() { elev.view = null; renderElevation(); }
-/** The open wall's frame, from the live drawing. Closes the view if the wall is gone. */
+export function fitElevation() { fitView(); }
+/** The open wall's frame, from the live plan. Closes the view if the wall is gone (or isn't a straight wall now). */
 export function elevSyncFrame() {
     if (!elevOpen())
         return null;
-    const f = elevFrame(SK(), elev.lid, elev.flip);
+    const f = elevFrame(planSK(), elev.lid, elev.flip);
     if (!f) {
         closeElevation();
         return null;
     }
     elev.frame = f;
+    // a room appeared or went on one side: the side "inside" is the other face now
+    const key = faceKey(f.lid, f.side);
+    if (faceEdit.key !== key) {
+        faceEdit.key = key;
+        openFace(planSK(), f.lid, f.side);
+        ed.sel = [];
+        analyze();
+    }
     return f;
 }
-/**
- * After drawing: keep the tappable chips, drop a selected dimension that no longer shows and selected things that
- * are gone. Returns the selected dimension's chip, if any.
- */
-export function elevAfterRender(hits) {
-    elev.hits = hits;
-    let on = elev.active ? hits.find(h => JSON.stringify(h.act) === elev.active) : undefined;
-    if (elev.active && !on) {
-        elev.active = null;
-        on = undefined;
-    }
-    const sk = SK(), lines = elev.frame ? elevLines(sk, elev.frame) : [];
-    elev.objs = elev.objs.filter(o => o.k === 'corner' || (o.k === 'op' ? !!sk.openings[o.id] : lines.some(l => l.id === o.id)));
-    return on;
-}
-/** Whether the trash has something to do: free or remove the selected dimension, or delete selected things. */
-export const elevTrashEnabled = (on) => on ? !!storedDim(on.act) || !!lockedSill(on.act) : elev.objs.some(o => o.k !== 'corner');
 /** The view's title: the wall's length, and which side it's seen from. */
 export function elevTitle() {
-    const sk = SK(), f = elev.frame, hasRoom = roomSideOf(sk, elev.lid) !== 0;
+    const sk = planSK(), f = elev.frame, hasRoom = roomSideOf(sk, elev.lid) !== 0;
     return {
         title: 'Wall ' + fmtLen(lineLen(sk, sk.lines[elev.lid])),
         sub: hasRoom ? (f.inside ? 'Seen from inside' : 'Seen from outside') : 'Side ' + (elev.flip ? 2 : 1) + ' of 2',
     };
 }
-const hitAt = (x, y) => [...elev.hits].reverse().find(h => x >= h.x && x <= h.x + h.w && y >= h.y && y <= h.y + h.h);
-const nameOf = (op) => (SK().openings[op].type === 'door' ? 'door' : 'window');
-/** What dragging an opening will do, given its locks. */
-function dragHint(op) {
-    const sk = SK(), o = sk.openings[op], locked = !slideGroup(sk, op), n = nameOf(op);
-    if (o.type === 'door')
-        return locked ? 'This door is locked by a dimension. Change the dimension, or make it a reference, to move it.' : 'Drag the door to slide it along the floor.';
-    if (locked && o.sillLocked)
-        return 'This window is locked along the wall and in height. Select a blue dimension and press Delete to free it.';
-    if (o.sillLocked)
-        return 'This window’s height above the floor is locked — it only slides along the wall. Delete the blue sill dimension to free it.';
-    return locked ? 'This window is locked along the wall by a dimension — drag it to raise or lower it.' : 'Drag the ' + n + ' to move it along the wall or up and down.';
+// ---- keeping what's drawn inside the wall ----
+/** The open wall face's edges: across from corner to corner, up from the floor to the ceiling. Null outside the wall view. */
+export function wallBounds() {
+    const f = elevOpen() ? elev.frame : null;
+    return f ? { x0: f.face[0], x1: f.face[1], y0: 0, y1: f.H } : null;
 }
-function startDrag(op, cx, cy) {
-    const sk = SK(), o = sk.openings[op];
-    if (!o)
-        return null;
-    const group = slideGroup(sk, op);
-    return { op, group, sill: openingHeights(o).sill, lockedH: !group, started: false, cx, cy };
+/** A point brought inside the wall (as it is, outside the wall view). */
+export function intoWall(x, y) {
+    const b = wallBounds();
+    return b ? [Math.min(Math.max(x, b.x0), b.x1), Math.min(Math.max(y, b.y0), b.y1)] : [x, y];
 }
-function moveDrag(d, du, dz) {
-    const sk = SK(), o = sk.openings[d.op], f = elev.frame, g = o && openingSpan(sk, o), l = o && sk.lines[o.line];
-    if (!o || !f || !g || !l)
-        return;
-    if (!d.started) {
-        const stuck = d.lockedH && (o.type === 'door' || !!o.sillLocked);
-        if (stuck) {
-            toast(dragHint(d.op));
-            elev.dragOp = null;
-            return;
-        }
-        if (d.lockedH || o.sillLocked)
-            toast(dragHint(d.op));
-        d.started = true;
-        pushHistory();
-        elev.dragOp = d.op;
-        elev.active = null;
-        if (!elev.objs.some(x => x.k === 'op' && x.id === d.op))
-            elev.objs = [{ k: 'op', id: d.op }];
-    }
-    if (d.group)
-        applySlide(sk, d.group, f.mirror ? -du : du);
-    if (o.type === 'window' && !o.sillLocked) {
-        const { sill, head } = openingHeights(o), q = 1 / settings.denom;
-        o.sill = clamp(Math.round((d.sill + dz) / q) * q, 0, Math.max(0, wallHeight(l) - (head - sill)));
-    }
-    resolveOpeningsNow();
-    requestDraw();
-    renderElevation();
-}
-// ---- drawing tools ----
-/** The wall view's toolbar: [tool, label, shortcut, icon]. */
-export const ELEV_RAIL = [
-    ['select', 'Select', 'V', 'select'], ['door', 'Door', 'B', 'door'], ['window', 'Window', 'N', 'window'],
-    ['line', 'Line', 'L', 'line'], ['guide', 'Guide line', 'X', 'constr'], '|',
-];
-export const TOOL_HINT = {
-    select: '',
-    door: 'Tap the wall to place a 3\'-0" door. It sits on the floor where you tap.',
-    window: 'Tap the wall to place a 3\'-0" window, centered where you tap.',
-    line: 'Tap two points, or drag, to draw a line. It snaps to corners, openings, the floor and ceiling, and level/plumb.',
-    guide: 'Tap two points, or drag, to draw a dashed guide line.',
-};
-/** Switch the wall view's tool. */
-export function setElevTool(t, quiet = false) {
-    elev.tool = t;
-    elev.lineStart = null;
-    elev.cursor = null;
-    if (t !== 'select') {
-        elev.active = null;
-    }
-    if (!quiet && TOOL_HINT[t])
-        toast(TOOL_HINT[t]);
-    renderElevation();
-}
-/** Esc in the wall view: cancel a line in progress, then leave the tool, then close the view. */
-export function elevEscape() {
-    if (elev.lineStart) {
-        elev.lineStart = null;
-        renderElevation();
-        return;
-    }
-    if (elev.tool !== 'select') {
-        setElevTool('select', true);
-        return;
-    }
-    if (elev.objs.length || elev.active) {
-        elev.objs = [];
-        elev.active = null;
-        renderElevation();
-        return;
-    }
-    closeElevation();
-}
-/** Keyboard shortcuts for the wall view's tools. Returns true if the key was one. */
-export function elevToolKey(k) {
-    const t = { v: 'select', b: 'door', n: 'window', l: 'line', x: 'guide' }[k.toLowerCase()];
-    if (!t)
-        return false;
-    setElevTool(t);
-    return true;
-}
-const toWorld = (x, y) => { const T = elevT(elev.view, elev.W, elev.H); return [(x - T.ox) / T.s, (T.oy - y) / T.s]; };
 /**
- * Snap a screen point for drawing: to a feature point (wall corners, opening corners, line ends and middles),
- * else each axis to a nearby feature line (floor, ceiling, wall ends, opening edges and sill/head heights, line ends),
- * else level/plumb from the line's start, else to the display precision.
+ * How far what's drawn on the face reaches past the wall, inches (0: it's all inside): each point, and each circle's
+ * and arc's reach. Edits that make this grow are refused, so nothing is pushed out (a wall made shorter in the plan can
+ * leave something outside: it can still be edited, just not pushed further out).
  */
-function snapUZ(x, y, from) {
-    const sk = SK(), f = elev.frame, T = elevT(elev.view, elev.W, elev.H), R = 12 / T.s;
-    const [u, z] = toWorld(x, y);
-    const ops = elevOpenings(sk, f), lines = elevLines(sk, f).map(l => elevLineUZ(f, l));
-    const pts = [[f.face[0], 0], [f.face[0], f.H], [f.face[1], 0], [f.face[1], f.H]];
-    for (const o of ops)
-        pts.push([o.u0, o.sill], [o.u0, o.head], [o.u1, o.sill], [o.u1, o.head]);
-    for (const [a, b] of lines)
-        pts.push(a, b, [(a[0] + b[0]) / 2, (a[1] + b[1]) / 2]);
-    let best = null, bd = R;
-    for (const p of pts) {
-        const d = Math.hypot(p[0] - u, p[1] - z);
-        if (d < bd) {
-            bd = d;
-            best = p;
-        }
-    }
-    if (best)
-        return { p: [best[0], best[1]], kind: 'pt' };
-    const us = [f.face[0], f.face[1], ...ops.flatMap(o => [o.u0, o.u1]), ...lines.flatMap(([a, b]) => [a[0], b[0]])];
-    const zs = [0, f.H, ...ops.flatMap(o => [o.sill, o.head]), ...lines.flatMap(([a, b]) => [a[1], b[1]])];
-    const near = (v, list) => list.reduce((m, x) => (Math.abs(x - v) < R && (m == null || Math.abs(x - v) < Math.abs(m - v)) ? x : m), null);
-    const q = 1 / settings.denom, su = near(u, us), sz = near(z, zs);
-    let pu = su ?? Math.round(u / q) * q, pz = sz ?? Math.round(z / q) * q, kind = su != null || sz != null ? 'edge' : null;
-    if (from) {
-        const du = Math.abs(pu - from[0]), dz = Math.abs(pz - from[1]), tan = Math.tan((6 * Math.PI) / 180);
-        if (sz == null && dz < du * tan) {
-            pz = from[1];
-            kind = 'hv';
-        }
-        else if (su == null && du < dz * tan) {
-            pu = from[0];
-            kind = 'hv';
-        }
-    }
-    return { p: [pu, pz], kind };
-}
-/** Where a new door/window would go for a pointer at (u, z): centre s along the wall, and the window's sill. */
-export function openingAt(type, u, z) {
-    const f = elev.frame, w = NEW_W;
-    if (f.L < w + 2)
-        return null;
-    const at = clamp(toU(f, u), w / 2, f.L - w / 2);
-    const q = 1 / settings.denom, sill = type === 'door' ? 0 : clamp(Math.round((z - WINDOW_H / 2) / q) * q, 0, Math.max(0, f.H - WINDOW_H));
-    return { at, sill };
+export function wallOverflow(sk = SK()) {
+    const b = wallBounds();
+    return b ? faceOverflow(sk, b) : {};
 }
-function placeOpening(type, u, z) {
-    const sk = SK(), f = elev.frame, spot = openingAt(type, u, z);
-    if (!spot) {
-        toast('That wall is too short for a ' + fmtLen(NEW_W) + ' ' + type + '.', { warn: true });
+/**
+ * How far things run past their walls, once an edit has been followed through: in the wall view, what's drawn on it;
+ * in the plan, the doors and windows (re-placed from their dimensions) and what's drawn on each wall face (brought up
+ * to date with the plan). Edits that make this grow are refused — a wall can't be made shorter than what's on it.
+ */
+export function overflow(sk = SK()) {
+    if (elevOpen())
+        return wallOverflow(sk);
+    if (sk !== planSK())
+        return {};
+    resolveOpenings(sk);
+    syncFaces(sk, true);
+    return planOverflow(sk);
+}
+export function fitState(sk = SK()) {
+    if (elevOpen() || sk !== planSK())
+        return { pos: snapshotPos(sk) };
+    return planFitState(sk);
+}
+/** Everything following a change to the plan through can change (see planFit), whichever view is open. */
+export function planFitState(sk = planSK()) {
+    const pos = snapshotPos(sk);
+    const ops = {}, faces = {};
+    Object.assign(ops, snapOpenings(sk));
+    // (copied by hand: React Native has no structuredClone)
+    for (const [key, face] of Object.entries(sk.faces ?? {}))
+        faces[key] = { pos: snapshotPos(face), wall: face.wall && { u: [...face.wall.u], ends: [[...face.wall.ends[0]], [...face.wall.ends[1]]] } };
+    return { pos, ops, faces, marks: placedMarks() };
+}
+/** Each door and window as it is — its place, sill, width, dimensions: whatever an edit to it may change. */
+function snapOpenings(sk) {
+    const out = {};
+    for (const [id, o] of Object.entries(sk.openings))
+        out[id] = JSON.stringify(o);
+    return out;
+}
+/** Put them back as they were — in place: what holds on to a door or window (a drag, a keypad) keeps the same one. */
+function putOpenings(sk, snap) {
+    for (const [id, v] of Object.entries(snap)) {
+        const o = sk.openings[id];
+        if (!o)
+            continue;
+        const was = JSON.parse(v);
+        for (const k of Object.keys(o))
+            if (!(k in was))
+                delete o[k];
+        Object.assign(o, was);
+    }
+}
+export function restoreFit(sk, s) {
+    restorePos(sk, s.pos);
+    if (!s.ops)
         return;
-    }
-    pushHistory();
-    const id = uid('o');
-    // a door swings toward the side you're looking from
-    sk.openings[id] = { line: f.lid, at: spot.at, w: NEW_W, type, flip: f.side !== 1, ...(type === 'window' ? { sill: spot.sill } : {}) };
-    elev.objs = [{ k: 'op', id }];
-    afterEdit();
+    putOpenings(sk, s.ops);
+    for (const [key, v] of Object.entries(s.faces ?? {})) {
+        const face = sk.faces?.[key];
+        if (!face)
+            continue;
+        restorePos(face, v.pos);
+        if (v.wall)
+            face.wall = v.wall;
+        else
+            delete face.wall;
+    }
+    setPlacedMarks(s.marks);
+    forgetSynced();
+}
+/** Limit a move of points (from where they started) so they all stay inside the wall, circles centred on them whole. */
+export function keepInWall(sk, ids, start, dx, dy) {
+    const b = wallBounds();
+    if (!b || !ids.length)
+        return [dx, dy];
+    let lo = -Infinity, hi = Infinity, dlo = -Infinity, dhi = Infinity;
+    ids.forEach((id, i) => {
+        const r = Math.max(0, ...Object.values(sk.circles).filter(c => c.c === id).map(c => c.r)), p = start[i];
+        lo = Math.max(lo, b.x0 - (p.x - r));
+        hi = Math.min(hi, b.x1 - (p.x + r));
+        dlo = Math.max(dlo, b.y0 - (p.y - r));
+        dhi = Math.min(dhi, b.y1 - (p.y + r));
+    });
+    return [lo <= hi ? Math.min(Math.max(dx, lo), hi) : 0, dlo <= dhi ? Math.min(Math.max(dy, dlo), dhi) : 0];
 }
-function finishLine(b) {
-    const a = elev.lineStart, f = elev.frame;
-    if (!a || !f)
-        return;
-    if (Math.hypot(b[0] - a[0], b[1] - a[1]) < 0.5)
-        return; // too short: keep waiting for the second point
-    pushHistory();
-    const id = uid('el');
-    addElevLine(SK(), f, a, b, elev.tool === 'guide', id);
-    elev.lineStart = null;
-    elev.objs = [{ k: 'line', id }];
-    afterEdit();
+export const PAST_WALL = 'That would run past the edge of the wall.';
+/** A door or window moved or resized in a way that would shove what's tied to it (a cabinet) off its wall. */
+export const PUSHES_OFF = 'That would push what’s tied to it past the edge of the wall.';
+/**
+ * How far things run past their walls in the plan — doors and windows past their walls' ends, what's on each wall
+ * face past its corners, floor and ceiling — once a change to the plan has been followed through (the doors and
+ * windows re-placed from their dimensions, the faces brought up to date). Whichever view is open: a door or window
+ * changed from the wall view (its width, its distance from a corner) is the plan's.
+ */
+export function planFit(sk = planSK()) {
+    resolveOpenings(sk);
+    syncFaces(sk, true);
+    return planOverflow(sk);
 }
-/** The drawn line nearest a screen point (within 9 px). */
-function lineAt(x, y) {
-    const sk = SK(), f = elev.frame, T = elev.view && elevT(elev.view, elev.W, elev.H);
-    if (!f || !T)
-        return null;
-    let best = null, bd = 9;
-    for (const ln of elevLines(sk, f)) {
-        const [a, b] = elevLineUZ(f, ln), p = S(T, a[0], a[1]), q = S(T, b[0], b[1]);
-        const dx = q[0] - p[0], dy = q[1] - p[1], L2 = dx * dx + dy * dy || 1, t = clamp(((x - p[0]) * dx + (y - p[1]) * dy) / L2, 0, 1);
-        const d = Math.hypot(x - (p[0] + dx * t), y - (p[1] + dy * t));
-        if (d < bd) {
-            bd = d;
-            best = ln.id;
-        }
-    }
-    return best;
-}
-/** What's under a screen point: chips first, then drawn lines, then openings and corners. */
-function pickAt(x, y) {
-    const h = hitAt(x, y);
-    if (h && h.act.k !== 'body' && h.act.k !== 'corner')
-        return h.act;
-    const l = lineAt(x, y);
-    if (l)
-        return { k: 'eline', id: l };
-    return h ? h.act : null;
-}
-/** Set a drawn line's length (its first end stays put). */
-function editLineLength(id) {
-    const sk = SK(), f = elev.frame, ln = f && elevLines(sk, f).find(l => l.id === id);
-    if (!ln)
-        return;
-    const cur = Math.hypot(ln.b[0] - ln.a[0], ln.b[1] - ln.a[1]);
-    openKeypad({
-        title: ln.guide ? 'Guide line length' : 'Line length', initial: fmtLen(cur), selectAll: true, laser: true,
-        onDone: v => {
-            if (v <= 0)
-                return;
-            pushHistory();
-            const k = v / (cur || 1);
-            ln.b = [ln.a[0] + (ln.b[0] - ln.a[0]) * k, ln.a[1] + (ln.b[1] - ln.a[1]) * k];
-            afterEdit();
-        },
-    });
+/**
+ * Make a change to the plan's doors and windows — a width, a distance entered — only if it pushes nothing on a wall
+ * past its edges (a cabinet tied to a window would otherwise be shoved off the wall). Taken back, and said, if it
+ * would. Returns whether it was made.
+ */
+export function withinWalls(change) {
+    const sk = planSK(), was = planFit(sk), held = planFitState(sk);
+    change();
+    if (!pushedOut(was, planFit(sk)))
+        return true;
+    restoreFit(sk, held);
+    planFit(sk);
+    toast(PUSHES_OFF, { warn: true });
+    return false;
 }
 /**
- * A tap. On a door/window or a wall corner: select it (`add`: add or remove it — Shift/⌘/Ctrl with a mouse, any tap by touch).
- * On a dimension chip: select that dimension. The keypad only opens from the bar's yellow +.
+ * Slide a chain of doors and windows along their wall in the plan to `delta` from where it started, no further than
+ * what's drawn on the wall's faces can follow without being pushed off them (`base`: what ran past its wall when the
+ * slide began; `from`: the last slide that pushed nothing further out). The faces follow as it goes. Returns the
+ * slide made.
  */
-function tap(a, add) {
-    if (a && (a.k === 'body' || a.k === 'corner' || a.k === 'eline')) {
-        const o = a.k === 'body' ? { k: 'op', id: a.op } : a.k === 'eline' ? { k: 'line', id: a.id } : { k: 'corner', end: a.end }, key = objKey(o);
-        elev.active = null;
-        if (add)
-            elev.objs = elev.objs.some(x => objKey(x) === key) ? elev.objs.filter(x => objKey(x) !== key) : [...elev.objs, o];
+export function slideWithinWalls(sk, group, delta, from, base) {
+    const held = planFitState(sk);
+    const tryAt = (v) => { applySlide(sk, group, v); return !pushedOut(base, planFit(sk)); };
+    if (tryAt(delta))
+        return delta;
+    let lo = 0, hi = 1;
+    for (let i = 0; i < 8; i++) {
+        const m = (lo + hi) / 2;
+        restoreFit(sk, held);
+        if (tryAt(from + (delta - from) * m))
+            lo = m;
         else
-            elev.objs = [o];
-        renderElevation();
-        return;
-    }
-    elev.objs = [];
-    selectDim(a);
-}
-/** Select an elevation dimension (null clears): yellow border and the bar with its name and the yellow +. */
-function selectDim(a) {
-    elev.active = a ? JSON.stringify(a) : null;
-    renderElevation();
+            hi = m;
+    }
+    // none of the way: back exactly as it was (solved again from there, the faces can land a hair apart — past the wall)
+    restoreFit(sk, held);
+    if (lo === 0)
+        return from;
+    const to = from + (delta - from) * lo;
+    tryAt(to);
+    return to;
+}
+/** In the plan: a wall made shorter than what's on it. */
+export const TOO_SHORT = 'The wall can’t be shorter than what’s on it. Move or remove things on it first.';
+/** The right message for an edit refused by overflow(). */
+export const pastWallMsg = () => (elevOpen() ? PAST_WALL : TOO_SHORT);
+// ---- the dimension chips ----
+/**
+ * What can be tapped in the wall view, in canvas pixels, for tests: the doors' and windows' bodies, cabinets, the
+ * wall's corners (its end edges), and the dimension chips as last drawn (with their look).
+ */
+export function elevHits() {
+    const f = elev.frame;
+    if (!elevOpen() || !f)
+        return [];
+    const T = mainT(), out = [];
+    for (const o of elevOpenings(planSK(), f)) {
+        const [x0, y0] = S(T, o.u0, o.head), [x1, y1] = S(T, o.u1, o.sill);
+        out.push({ x: x0, y: y0, w: x1 - x0, h: y1 - y0, act: { k: 'body', op: o.id } });
+    }
+    for (const id of Object.keys(SK().cabs ?? {})) {
+        const b = cabBox(SK(), id);
+        if (!b)
+            continue;
+        const [x0, y0] = S(T, b.u0, b.z1), [x1, y1] = S(T, b.u1, b.z0);
+        out.push({ x: x0, y: y0, w: x1 - x0, h: y1 - y0, act: { k: 'cab', id } });
+    }
+    for (const [u, end] of [[f.face[0], f.leftEnd], [f.face[1], f.leftEnd === 'a' ? 'b' : 'a']]) {
+        const [x, yTop] = S(T, u, f.H), [, yBot] = S(T, u, 0);
+        out.push({ x: x - 10, y: yTop, w: 20, h: yBot - yTop, act: { k: 'corner', end } });
+    }
+    for (const h of ed.hitChips)
+        if (h.kind === 'elev')
+            out.push({ x: h.x, y: h.y, w: h.w, h: h.h, act: JSON.parse(h.id), look: h.part });
+    return out;
+}
+export const elevAct = (id) => JSON.parse(id);
+/** A chip's name, as the bar shows it. */
+export function elevChipName(a) {
+    if (a.k === 'gap')
+        return a.title;
+    if (a.k === 'len')
+        return 'Wall length · set in the floor plan';
+    if (a.k === 'wallH')
+        return 'Wall height';
+    if (a.k === 'pos')
+        return a.title;
+    if (a.k === 'fdim')
+        return 'Dimension';
+    if (a.k === 'depth')
+        return 'Cabinet depth · out from the wall';
+    const o = planSK().openings[a.op], n = o ? (o.type === 'door' ? 'Door' : 'Window') : '';
+    return a.k === 'w' ? n + ' width' : a.k === 'sill' ? n + ' sill height' : n + ' height';
+}
+/** The yellow + on a selected chip: its keypad. */
+export function editElevChip(a) {
+    if (a.k === 'w')
+        editOpeningDim(a.op, 'w');
+    else if (a.k === 'sill')
+        editSill(a.op);
+    else if (a.k === 'h')
+        editOpeningHeight(a.op);
+    else if (a.k === 'wallH')
+        editWallHeight(elev.lid);
+    else if (a.k === 'pos')
+        editElevationPosition(a.op, a.edge, a.ref, a.title);
+    else if (a.k === 'gap')
+        dimensionFace(a.kind, a.a, a.b, a.title);
+    else if (a.k === 'depth')
+        editCabinetDepth(a.cab);
+    else if (a.k === 'len')
+        goToPlan();
 }
-/** What the + does for the selected objects, with the bar's name for it (null: nothing to dimension). */
-function objPlan() {
-    const sk = SK(), f = elev.frame, objs = elev.objs;
-    if (!f || !objs.length)
-        return null;
-    const ops = elevOpenings(sk, f), seen = (id) => ops.find(o => o.id === id);
-    const label = (id) => (sk.openings[id].type === 'door' ? 'Door' : 'Window');
-    const opsSel = objs.filter((o) => o.k === 'op').map(o => seen(o.id)).filter((o) => !!o);
-    const corners = objs.filter((o) => o.k === 'corner');
-    const lines = objs.filter((o) => o.k === 'line');
-    if (objs.length === 1 && lines.length === 1) {
-        const ln = elevLines(sk, f).find(l => l.id === lines[0].id);
-        if (!ln)
-            return null;
-        return { name: (ln.guide ? 'Guide line ' : 'Line ') + fmtLen(Math.hypot(ln.b[0] - ln.a[0], ln.b[1] - ln.a[1])), run: () => editLineLength(ln.id) };
-    }
-    if (lines.length)
-        return { name: objs.length + ' selected', run: () => toast('Select one line to set its length.') };
-    if (objs.length === 1 && opsSel.length === 1)
-        return { name: label(opsSel[0].id), run: () => editOpeningDim(opsSel[0].id, 'w') };
-    if (objs.length === 1 && corners.length === 1)
-        return { name: 'Corner', run: () => toast('Select a door or window too (Shift-tap), then + for the distance between them.') };
-    if (objs.length === 2 && opsSel.length === 2) {
-        const [l, r] = [...opsSel].sort((p, q) => p.u0 - q.u0), t = pickBetween(sk, l.id, l.e1, r.id, r.e0);
-        return { name: label(l.id) + ' + ' + label(r.id).toLowerCase(), run: () => editElevationPosition(t.op, t.edge, t.ref, 'Space between') };
-    }
-    if (objs.length === 2 && opsSel.length === 1 && corners.length === 1) {
-        const o = opsSel[0], end = corners[0].end, leftCorner = end === f.leftEnd;
-        const ref = { face: end, line: f.lid, side: f.side };
-        return { name: label(o.id) + ' + corner', run: () => editElevationPosition(o.id, leftCorner ? o.e0 : o.e1, ref, 'Distance from the corner') };
-    }
-    if (corners.length === 2 && objs.length === 2)
-        return { name: 'Both corners', run: () => toast('The wall’s length is set in the plan. Go back and use the wall’s +.') };
-    return { name: objs.length + ' selected', run: () => toast('Select two things — two openings, or an opening and a corner — to dimension between them.') };
-}
-/** The bar: the selected dimension, or the selected objects (with Height / Sill for a single opening). */
-export function elevBar(dimAct) {
-    const plan = dimAct ? null : objPlan();
-    if (!dimAct && !plan)
-        return null;
-    if (dimAct && dimAct.k === 'len')
-        return { label: 'Wall length · set in the floor plan', plus: false, actions: [{ icon: 'back', label: 'Go to plan', run: goToPlan }] };
-    if (dimAct)
-        return { label: dimName(dimAct), plus: true, actions: [] };
-    const actions = [];
-    const one = elev.objs.length === 1 && elev.objs[0].k === 'op' ? SK().openings[elev.objs[0].id] : null;
-    if (one) {
-        const id = elev.objs[0].id;
-        actions.push({ icon: 'v', label: 'Height', run: () => editOpeningHeight(id) });
-        if (one.type === 'window')
-            actions.push({ icon: 'h', label: 'Sill', run: () => editSill(id) });
-    }
-    return { label: plan.name, plus: true, actions };
-}
-const dimName = (a) => {
-    const sk = SK(), o = 'op' in a ? sk.openings[a.op] : null, n = o ? (o.type === 'door' ? 'Door' : 'Window') : '';
-    return a.k === 'w' ? n + ' width' : a.k === 'sill' ? n + ' sill height' : a.k === 'h' ? n + ' height' : a.k === 'wallH' ? 'Wall height'
-        : a.k === 'pos' ? a.title : '';
-};
-/** The window whose locked sill height a selected chip shows, if any. */
+/** The window whose locked sill height a chip shows, if any. */
 function lockedSill(a) {
-    if (!a || a.k !== 'sill')
+    if (a.k !== 'sill')
         return null;
-    const o = SK().openings[a.op];
+    const o = planSK().openings[a.op];
     return o && o.sillLocked ? o : null;
 }
-/** The stored door/window dimension a selected position chip shows, if any. */
+/** The stored door/window dimension a position chip shows, if any. */
 function storedDim(a) {
-    if (!a || a.k !== 'pos')
+    if (a.k !== 'pos')
         return null;
-    const o = SK().openings[a.op], d = o && (o.dims || []).find(x => x.edge === a.edge && sameRef(x.ref, a.ref));
+    const o = planSK().openings[a.op], d = o && (o.dims || []).find(x => x.edge === a.edge && sameRef(x.ref, a.ref));
     return d ? { op: a.op, d } : null;
 }
-/**
- * Delete (trash or the Delete key). Selected doors/windows are deleted (with Undo), along with dimensions that
- * measure from them. A selected dimension: a locked one is freed — it stays as a reference — and a reference is removed.
- */
-export function deleteSelectedElevDim() {
-    const doomed = elev.objs.filter((o) => o.k === 'op').map(o => o.id);
-    const doomedLines = elev.objs.filter((o) => o.k === 'line').map(o => o.id);
-    if (!elev.active && (doomed.length || doomedLines.length)) {
-        const sk = SK(), n = doomed.length + doomedLines.length, one = doomed.length === 1 && !doomedLines.length ? sk.openings[doomed[0]] : null;
+/** Whether the trash does something for a selected chip: frees a locked one, or removes a reference. */
+export const elevChipDeletable = (a) => !!storedDim(a) || !!lockedSill(a);
+/** The trash on a selected chip: a locked door/window dimension is freed (it stays as a reference), a reference is removed, a locked sill is freed. */
+export function deleteElevChip(a) {
+    // a cabinet's entered depth: back to the standard one (grey), as an entered size is wiped
+    if (a.k === 'depth') {
+        const cb = SK().cabs?.[a.cab];
+        if (!cb)
+            return;
+        if (!cb.depthSet) {
+            toast('That’s the standard depth. Tap + to enter one.', { warn: true });
+            return;
+        }
         pushHistory();
-        deleteSel(sk, doomed.map(id => ({ type: 'opening', id })));
-        const key = elev.frame && elevKey(elev.frame.lid, elev.frame.side);
-        if (key && sk.elev?.[key])
-            sk.elev[key] = sk.elev[key].filter(l => !doomedLines.includes(l.id));
-        elev.objs = elev.objs.filter(o => o.k === 'corner');
-        ed.sel = ed.sel.filter(x => !(x.type === 'opening' && doomed.includes(x.id)));
+        cb.depth = CAB.d;
+        cb.depthSet = false;
         afterEdit();
-        const what = one ? (one.type === 'door' ? 'Door' : 'Window') : n === 1 ? 'Line' : n + ' items';
-        toast(what + ' deleted', { action: { label: 'Undo', fn: () => undo() } });
+        toast('Depth cleared — back to the standard ' + fmtLen(CAB.d) + '.', { action: { label: 'Undo', fn: () => undo() } });
         return;
     }
-    const a = elev.active ? JSON.parse(elev.active) : null, s = storedDim(a);
     const ls = lockedSill(a);
     if (ls) {
         pushHistory();
@@ -478,12 +430,12 @@ export function deleteSelectedElevDim() {
         toast('Sill height freed — drag the window to raise or lower it.');
         return;
     }
+    const s = storedDim(a);
     if (!s) {
-        if (a)
-            toast('Only locked dimensions and door/window position dimensions can be deleted here.');
+        toast('Only locked dimensions and door/window position dimensions can be deleted here.', { warn: true });
         return;
     }
-    const o = SK().openings[s.op], name = o.type === 'door' ? 'door' : 'window';
+    const o = planSK().openings[s.op], name = o.type === 'door' ? 'door' : 'window';
     pushHistory();
     if (s.d.driving) {
         s.d.driving = false;
@@ -492,258 +444,502 @@ export function deleteSelectedElevDim() {
     }
     else {
         o.dims = (o.dims || []).filter(x => x !== s.d);
+        ed.sel = [];
         afterEdit();
         toast('Dimension removed');
     }
 }
 /** Back to the floor plan with this wall selected, ready for its + (where its length is set). */
 function goToPlan() {
-    const lid = elev.lid;
     closeElevation();
-    if (!lid)
-        return;
-    ed.sel = [{ type: 'line', id: lid }];
-    updateCtx();
-    requestDraw();
     toast('Tap + to change the wall’s length.');
 }
-/** The yellow +: the keypad for the selected dimension (or what the selected things measure). */
-export function editSelected() {
-    const a = elev.active ? JSON.parse(elev.active) : null;
-    if (!a) {
-        objPlan()?.run();
+// ---- doors and windows on the wall ----
+/** Where a new door/window would go for a pointer at (u, z): centre s along the wall, and the window's sill. */
+export function openingAt(type, u, z, tol = 0) {
+    const f = elev.frame, w = NEW_W;
+    if (f.L < w + 2)
+        return null;
+    // snapped (Object snapping) as a door or window dragged on the wall is: its sides to the corners and the other
+    // doors', windows' and cabinets' sides; a window's sill and head to the floor, the ceiling, cabinet tops and other
+    // windows' (a door sits on the floor)
+    const raw = type === 'door' ? 0 : z - WINDOW_H / 2, h = type === 'door' ? DOOR_H : WINDOW_H;
+    const [du, dz] = tol > 0 ? snapObjectMove({}, { u0: u - w / 2, u1: u + w / 2, z0: raw, z1: raw + h }, 0, 0, tol) : [0, 0];
+    const at = clamp(toU(f, u + du), w / 2, f.L - w / 2);
+    const q = 1 / settings.denom, sill = type === 'door' ? 0 : clamp(Math.round((raw + dz) / q) * q, 0, Math.max(0, f.H - WINDOW_H));
+    return { at, sill };
+}
+function placeOpening(type, u, z, tol = 0) {
+    const sk = planSK(), f = elev.frame, spot = openingAt(type, u, z, tol);
+    if (!spot) {
+        toast('That wall is too short for a ' + fmtLen(NEW_W) + ' ' + type + '.', { warn: true });
         return;
     }
-    if (a.k === 'w')
-        editOpeningDim(a.op, 'w');
-    else if (a.k === 'sill')
-        editSill(a.op);
-    else if (a.k === 'h')
-        editOpeningHeight(a.op);
-    else if (a.k === 'wallH')
-        editWallHeight(elev.lid);
-    else if (a.k === 'pos')
-        editElevationPosition(a.op, a.edge, a.ref, a.title);
-    else if (a.k === 'len')
-        goToPlan();
+    pushHistory();
+    const id = uid('o');
+    // a door swings toward the side you're looking from
+    sk.openings[id] = { line: f.lid, at: spot.at, w: NEW_W, wSet: false, type, flip: f.side !== 1, ...(type === 'window' ? { sill: spot.sill } : {}) };
+    // (placed, not selected: tap it to size it)
+    ed.sel = [];
+    afterEdit();
 }
-// ---- pointers: one finger or the mouse pans, two fingers pinch, the wheel zooms; tap selects; drag moves a door/window ----
-const gp = new Map();
-let pinch = null;
-let down = null, drag = null;
-/** middle mouse button: always pans; a press that started a line (drag to draw) */
-let panBtn = false, pressStartedLine = false, mid = null;
-onSessionReset(() => { gp.clear(); pinch = null; down = null; drag = null; panBtn = false; pressStartedLine = false; mid = null; });
-function zoomElevAt(sx, sy, f) {
-    const v = elev.view;
-    const u = v.cu + (sx - elev.W / 2) / v.s, z = v.cz - (sy - elev.H / 2) / v.s;
-    v.s = clamp(v.s * f, 0.05, 60);
-    v.cu = u - (sx - elev.W / 2) / v.s;
-    v.cz = z + (sy - elev.H / 2) / v.s;
-    renderElevation();
+const nameOf = (op) => (planSK().openings[op].type === 'door' ? 'door' : 'window');
+/** What dragging an opening will do, given its locks. */
+function dragHint(op) {
+    const sk = planSK(), o = sk.openings[op], locked = !slideGroup(sk, op), n = nameOf(op);
+    if (o.type === 'door')
+        return locked ? 'This door is locked by a dimension. Change the dimension, or make it a reference, to move it.' : 'Drag the door to slide it along the floor.';
+    if (locked && o.sillLocked)
+        return 'This window is locked along the wall and in height. Select a blue dimension and press Delete to free it.';
+    if (o.sillLocked)
+        return 'This window’s height above the floor is locked — it only slides along the wall. Delete the blue sill dimension to free it.';
+    return locked ? 'This window is locked along the wall by a dimension — drag it to raise or lower it.' : 'Drag the ' + n + ' to move it along the wall or up and down.';
 }
-const drawing = () => elev.tool === 'line' || elev.tool === 'guide';
-const endDrag = () => { if (elev.dragOp) {
-    elev.dragOp = null;
-    afterEdit();
-} };
-/** Pointers on the elevation canvas, in canvas pixels; drags measure from `cx`/`cy` (window pixels) when given. */
-export function elevPointerDown(e) {
-    const p = { x: e.x, y: e.y };
-    gp.set(e.id, p);
-    pinch = null;
-    mid = null;
-    down = gp.size === 1 ? { ...p, moved: false } : null;
-    panBtn = e.button === 1;
-    // a second finger while a press is drawing a line: it's a pinch, not a line
-    if (gp.size > 1 && pressStartedLine) {
-        elev.lineStart = null;
-        elev.cursor = null;
-        renderElevation();
-    }
-    pressStartedLine = false;
-    drag = null;
-    if (!down || panBtn || !elev.view)
-        return;
-    if (drawing()) {
-        // first point now (drag to draw), or the second point of a tap-tap line
-        const sp = snapUZ(p.x, p.y, elev.lineStart);
-        elev.cursor = sp;
-        if (!elev.lineStart) {
-            elev.lineStart = sp.p;
-            pressStartedLine = true;
-            renderElevation();
-        }
-        else
-            finishLine(sp.p);
-        return;
-    }
-    if (elev.tool !== 'select')
-        return; // door/window: placed on release (a drag pans instead)
-    const h = hitAt(p.x, p.y);
-    drag = h && h.act.k === 'body' ? startDrag(h.act.op, e.cx ?? e.x, e.cy ?? e.y) : null;
+export function startOpeningDrag(op) {
+    const sk = planSK(), o = sk.openings[op];
+    if (!o)
+        return null;
+    const group = slideGroup(sk, op), e = elev.frame ? elevOpenings(sk, elev.frame).find(x => x.id === op) : null;
+    return { op, group, sill: openingHeights(o).sill, lockedH: !group, started: false, box: e ? { u0: e.u0, u1: e.u1, z0: e.sill, z1: e.head } : null };
 }
-export function elevPointerMove(e) {
-    const prev = gp.get(e.id), p = { x: e.x, y: e.y };
-    if (!prev) {
-        // hover (mouse): cursor, and previews for the drawing tools
-        if (e.kind !== 'mouse' || !elev.view)
-            return;
-        if (elev.tool === 'select') {
-            const h = pickAt(p.x, p.y);
-            setCursor(!h ? '' : h.k === 'body' ? 'grab' : 'pointer', 'elevation');
-            return;
-        }
-        elev.cursor = snapUZ(p.x, p.y, elev.lineStart);
-        renderElevation();
-        return;
-    }
-    if (!elev.view)
-        return;
-    if (down && !down.moved) {
-        if (Math.hypot(p.x - down.x, p.y - down.y) < 6) {
-            if (drawing()) {
-                elev.cursor = snapUZ(p.x, p.y, elev.lineStart);
-                renderElevation();
-            }
-            return;
+/**
+ * Move a drag to (du, dz) inches from where it started, snapping to corners and the other objects (within `tol`
+ * inches). Returns false if it can't move at all (a locked door).
+ */
+export function moveOpeningDrag(d, du, dz, tol = 0) {
+    if (d.box && tol > 0)
+        [du, dz] = snapObjectMove({ op: d.op }, d.box, du, dz, tol);
+    const sk = planSK(), o = sk.openings[d.op], f = elev.frame, g = o && openingSpan(sk, o), l = o && sk.lines[o.line];
+    if (!o || !f || !g || !l)
+        return false;
+    if (!d.started) {
+        if (d.lockedH && (o.type === 'door' || !!o.sillLocked)) {
+            toast(dragHint(d.op), { warn: true });
+            return false;
         }
-        down.moved = true;
-    }
-    gp.set(e.id, p);
-    if (drawing() && gp.size === 1 && !panBtn) {
-        elev.cursor = snapUZ(p.x, p.y, elev.lineStart);
-        renderElevation();
-        return;
+        if (d.lockedH || o.sillLocked)
+            toast(dragHint(d.op), { warn: true });
+        d.started = true;
     }
-    if (gp.size === 2) {
-        // two fingers: pinch to zoom and move to pan
-        const [a, b] = [...gp.values()], m = { x: (a.x + b.x) / 2, y: (a.y + b.y) / 2 };
-        if (mid) {
-            elev.view.cu -= (m.x - mid.x) / elev.view.s;
-            elev.view.cz += (m.y - mid.y) / elev.view.s;
+    const face = faceEdit.key ? SK() : null;
+    /** The opening at (u, z) from where it started, and what's drawn on the face following it (cabinets tied to it). */
+    const place = (u, z) => {
+        // (a slide is measured from where the chain started)
+        if (d.group)
+            applySlide(sk, d.group, f.mirror ? -u : u);
+        if (o.type === 'window' && !o.sillLocked) {
+            // kept between the floor and the ceiling — but one already past them (pushed there before) isn't yanked back
+            // at the first touch: that dragged whatever's tied to it along, through the floor
+            const { sill, head } = openingHeights(o), q = 1 / settings.denom;
+            o.sill = clamp(Math.round((d.sill + z) / q) * q, Math.min(0, d.sill), Math.max(0, wallHeight(l) - (head - sill), d.sill));
         }
-        mid = m;
-    }
-    if (drag && gp.size === 1 && down) {
-        moveDrag(drag, ((e.cx ?? e.x) - drag.cx) / elev.view.s, -((e.cy ?? e.y) - drag.cy) / elev.view.s);
-        if (!elev.dragOp)
-            drag = null; // refused (locked door)
-        return;
-    }
-    if (drag) {
-        endDrag();
-        drag = null;
-    } // a second finger: stop dragging, pinch instead
-    if (gp.size === 1) {
-        elev.view.cu -= (p.x - prev.x) / elev.view.s;
-        elev.view.cz += (p.y - prev.y) / elev.view.s;
-        renderElevation();
-        return;
-    }
-    const [a, b] = [...gp.values()], d = Math.hypot(a.x - b.x, a.y - b.y);
-    if (!pinch) {
-        pinch = { d, s: elev.view.s };
-        return;
-    }
-    zoomElevAt((a.x + b.x) / 2, (a.y + b.y) / 2, (pinch.s * (d / pinch.d)) / elev.view.s);
-}
-export function elevPointerUp(e) {
-    const tapped = down && !down.moved && gp.size === 1;
-    gp.delete(e.id);
-    pinch = null;
-    if (panBtn) {
-        panBtn = false;
-        down = null;
-        return;
-    }
-    if (drawing()) {
-        // a drag from the first point draws the line on release; a tap waits for the second tap
-        if (pressStartedLine && down?.moved && elev.lineStart)
-            finishLine(snapUZ(e.x, e.y, elev.lineStart).p);
-        pressStartedLine = false;
-        down = null;
-        return;
-    }
-    if ((elev.tool === 'door' || elev.tool === 'window') && tapped && elev.view) {
-        const [u, z] = toWorld(down.x, down.y);
-        if (z < -2 || z > (elev.frame?.H ?? 0) + 2)
-            toast('Tap on the wall to place it.');
-        else
-            placeOpening(elev.tool, u, z);
-        down = null;
-        return;
+        resolveOpeningsNow();
+        // what's drawn on the face follows the opening's corners as it moves
+        if (faceEdit.key)
+            syncFace(sk, faceEdit.key);
+    };
+    if (!face) {
+        place(du, dz);
+        requestDraw();
+        return true;
     }
-    if (drag) {
-        const was = drag.started;
-        endDrag();
-        drag = null;
-        if (was) {
-            down = null;
-            return;
+    // what's tied to it (a cabinet a set distance below a window) can't be pushed off the wall — past its floor,
+    // ceiling or ends: the opening goes as far as that allows and stops there, as a cabinet dragged to the edge does
+    d.base ??= wallOverflow(face);
+    const from = d.last ?? { du: 0, dz: 0 }, held = holdFace(sk, face);
+    const at = (t) => ({ du: from.du + (du - from.du) * t, dz: from.dz + (dz - from.dz) * t });
+    const fits = () => !pushedOut(d.base, wallOverflow(face));
+    place(du, dz);
+    let to = { du, dz };
+    if (!fits()) {
+        let lo = 0, hi = 1;
+        for (let i = 0; i < 8; i++) {
+            const m = (lo + hi) / 2;
+            putBack(sk, face, held);
+            place(at(m).du, at(m).dz);
+            if (fits())
+                lo = m;
+            else
+                hi = m;
         }
+        putBack(sk, face, held);
+        // (none of the way: left exactly as it was — solved again, it can land a hair apart)
+        to = at(lo);
+        if (lo > 0)
+            place(to.du, to.dz);
     }
-    // mouse: Shift/⌘/Ctrl adds to the selection; touch and pencil have no Shift, so their taps always add (tap empty space to clear)
-    if (tapped)
-        tap(pickAt(down.x, down.y), !!e.shift || !!e.mod || e.kind !== 'mouse');
-    down = null;
-}
-export function elevPointerCancel(e) {
-    gp.delete(e.id);
-    pinch = null;
-    if (drag) {
-        endDrag();
-        drag = null;
-    }
-    if (pressStartedLine) {
-        elev.lineStart = null;
-        pressStartedLine = false;
-    }
+    d.last = to;
+    requestDraw();
+    return true;
 }
-/** A mouse left the canvas: drop the drawing tools' preview. */
-export function elevPointerLeave(kind) {
-    if (kind === 'mouse' && elev.cursor && !gp.size) {
-        elev.cursor = null;
-        renderElevation();
-    }
+/** The doors' and windows' places in the plan and what's drawn on the face, to put back if a move is taken back. */
+function holdFace(sk, face) {
+    return { ops: snapOpenings(sk), pos: snapshotPos(face), marks: placedMarks() };
 }
-/** The wheel zooms around the pointer. */
-export function elevWheel(x, y, dy) {
-    if (!elev.view)
-        return;
-    zoomElevAt(x, y, Math.exp(-dy * 0.0015));
+function putBack(sk, face, h) {
+    putOpenings(sk, h.ops);
+    restorePos(face, h.pos);
+    setPlacedMarks(h.marks);
+    forgetSynced();
 }
 /**
- * Keyboard shortcuts while the wall view is open: Esc steps back, ⌘Z / ⇧⌘Z / ⌘Y undo and redo, F fits, tool letters,
- * Delete removes. Returns true when the key was used (the host should stop its default action).
+ * Where a door or window sliding along its wall in the plan can snap its edges: the wall's ends, its corners on both
+ * sides, and the edges of the other doors and windows on it — not those sliding with it (locked to it in a chain).
+ * Empty when Object snapping is off.
+ */
+/**
+ * Where a door or window placed on wall `lid` in the plan snaps its edges (Object snapping): the wall's ends, its
+ * corners on both sides, and the edges of the doors and windows already on it — as one slid along it does.
+ */
+export function placeTargets(sk, lid) {
+    const l = sk.lines[lid];
+    if (!l || !settings.layers.objSnap)
+        return [];
+    const A = sk.points[l.a], B = sk.points[l.b], out = [0, Math.hypot(B.x - A.x, B.y - A.y)];
+    for (const side of [1, -1]) {
+        const wf = wallFace(sk, lid, side);
+        if (wf)
+            out.push(wf.s0, wf.s1);
+    }
+    for (const x of Object.values(sk.openings)) {
+        if (x.line !== lid)
+            continue;
+        const g = openingSpan(sk, x);
+        if (g)
+            out.push(edgeS(x, g.w, 's0'), edgeS(x, g.w, 's1'));
+    }
+    return out;
+}
+export function slideTargets(sk, op, group) {
+    const o = sk.openings[op], l = o && sk.lines[o.line];
+    if (!o || !l || !settings.layers.objSnap)
+        return [];
+    // which move with it: slide the chain a little and see
+    const before = Object.fromEntries(Object.entries(sk.openings).map(([id, x]) => [id, x.at]));
+    applySlide(sk, group, group.hi > 0.25 ? 0.25 : group.lo < -0.25 ? -0.25 : (group.hi || group.lo));
+    resolveOpeningsNow();
+    const moving = new Set(Object.keys(sk.openings).filter(id => Math.abs(sk.openings[id].at - before[id]) > 1e-9));
+    applySlide(sk, group, 0);
+    resolveOpeningsNow();
+    const A = sk.points[l.a], B = sk.points[l.b], out = [0, Math.hypot(B.x - A.x, B.y - A.y)];
+    for (const side of [1, -1]) {
+        const wf = wallFace(sk, o.line, side);
+        if (wf)
+            out.push(wf.s0, wf.s1);
+    }
+    for (const [id, x] of Object.entries(sk.openings)) {
+        if (x.line !== o.line || moving.has(id) || id === op)
+            continue;
+        const g = openingSpan(sk, x);
+        if (g)
+            out.push(edgeS(x, g.w, 's0'), edgeS(x, g.w, 's1'));
+    }
+    return out;
+}
+/** A slide `delta` of a door or window (centre `at0`, width `w`, when the drag began) pulled so an edge meets the nearest target within `tol`. */
+export function snapSlide(at0, w, delta, targets, tol) {
+    let best = null;
+    for (const e of [at0 + delta - w / 2, at0 + delta + w / 2])
+        for (const t of targets)
+            if (Math.abs(t - e) < tol && (best == null || Math.abs(t - e) < Math.abs(best)))
+                best = t - e;
+    return delta + (best ?? 0);
+}
+// ---- the wall tools ----
+/** A ghost of what a placing tool would put at the pointer. */
+function ghost(c, T, u0, z0, w, h, label) {
+    const [x0, y0] = S(T, u0, z0 + h), [x1, y1] = S(T, u0 + w, z0);
+    c.save();
+    c.fillStyle = 'rgba(0,102,255,.08)';
+    c.fillRect(x0, y0, x1 - x0, y1 - y0);
+    c.strokeStyle = TH.blue;
+    c.lineWidth = 1.5;
+    c.setLineDash([6, 4]);
+    c.strokeRect(x0, y0, x1 - x0, y1 - y0);
+    c.restore();
+    if (label)
+        previewChip(c, label, (x0 + x1) / 2, y0 - 16);
+}
+/** On the wall (with a little slack), or not. */
+const onWall = (u, z) => { const f = elev.frame; return !!f && z >= -2 && z <= f.H + 2 && u >= f.face[0] - 2 && u <= f.face[1] + 2; };
+/** A tool that does something where the wall is tapped: a ghost follows the pointer, a tap acts (a drag doesn't). */
+/**
+ * A tool that places something where the wall is tapped, a ghost of it following the pointer first. `tol`: how near
+ * (inches) it snaps to what's on the wall — a finger's reach or a mouse's, as a drag snaps (Object snapping).
  */
-export function elevKeyDown(e) {
-    const k = e.key.toLowerCase();
-    if (e.key === 'Escape') {
-        elevEscape();
+function placingTool(o) {
+    const tolOf = (ev) => (ev.touch ? 16 : 10) / mainT().s;
+    return {
+        st: {},
+        reset() { this.st = {}; ed.preview = null; },
+        hover(ev) {
+            const tol = tolOf(ev);
+            ed.preview = onWall(ev.wx, ev.wy) ? (c, T) => o.preview(c, T, ev.wx, ev.wy, tol) : null;
+            requestOverlayDraw();
+        },
+        down(ev) { this.st = { down: ev, far: false }; this.hover(ev); },
+        move(ev) {
+            const st = this.st;
+            if (st.down && Math.hypot(ev.sx - st.down.sx, ev.sy - st.down.sy) > (ev.touch ? 12 : 6))
+                st.far = true;
+            this.hover(ev);
+        },
+        up(ev) {
+            const st = this.st;
+            this.st = {};
+            if (ev.touch)
+                ed.preview = null;
+            requestOverlayDraw();
+            if (!st.down || st.far)
+                return;
+            if (!onWall(ev.wx, ev.wy)) {
+                toast('Tap on the wall to place it.', { warn: true });
+                return;
+            }
+            o.place(ev.wx, ev.wy, tolOf(ev));
+        },
+        hint: () => o.hint,
+    };
+}
+const openingTool = (type) => placingTool({
+    preview(c, T, u, z, tol) {
+        const spot = openingAt(type, u, z, tol), f = elev.frame;
+        if (!spot || !f)
+            return;
+        const a = toU(f, spot.at - NEW_W / 2), b = toU(f, spot.at + NEW_W / 2);
+        ghost(c, T, Math.min(a, b), spot.sill, NEW_W, type === 'door' ? DOOR_H : WINDOW_H);
+    },
+    place: (u, z, tol) => placeOpening(type, u, z, tol),
+    hint: type === 'door' ? 'Tap the wall to place a 3\'-0" door. It sits on the floor where you tap.' : 'Tap the wall to place a 3\'-0" window, centered where you tap.',
+});
+export const wallDoorTool = openingTool('door');
+export const wallWindowTool = openingTool('window');
+export const cabinetTool = placingTool({
+    preview(c, T, u, z) { const spot = cabinetSpot(u, z); if (spot)
+        ghost(c, T, spot.u0, spot.z0, CAB.w, CAB.h, fmtLen(CAB.w) + ' × ' + fmtLen(CAB.h)); },
+    place: (u, z) => { addCabinet(u, z); },
+    hint: 'Tap the wall to place a cabinet (24" wide, 34½" high, 24" deep) — anywhere, like a window. Tap it, then one of its dimensions, to set it.',
+});
+export const heightTool = placingTool({
+    preview(c, T, _u, z) {
+        const f = elev.frame;
+        if (!f)
+            return;
+        const q = 1 / settings.denom, h = clamp(Math.round(z / q) * q, 0, f.H), [x0, y] = S(T, f.face[0], h), [x1] = S(T, f.face[1], h);
+        c.save();
+        c.strokeStyle = TH.blue;
+        c.lineWidth = 1.5;
+        c.setLineDash([6, 4]);
+        c.beginPath();
+        c.moveTo(x0, y);
+        c.lineTo(x1, y);
+        c.stroke();
+        c.restore();
+        previewChip(c, fmtLen(h), x1 - 40, y - 16);
+    },
+    place: (_u, z) => {
+        const q = 1 / settings.denom, start = clamp(Math.round(z / q) * q, 0, elev.frame.H);
+        openKeypad({ title: 'Height line', sub: 'Floor to the line — it runs across the whole wall', initial: fmtLen(start), selectAll: true, laser: true, onDone: v => { addHeightLine(v); } });
+    },
+    hint: 'Tap the wall at a height, then enter it: a level line across the wall (a counter, a rail).',
+});
+/** The wall view's toolbar: the plan's drawing tools, then what goes on a wall. (The height line tool is kept off it for now.) */
+export const WALL_RAIL = [
+    ['select', 'Select', 'V'], ['line', 'Line', 'L'], ['freehand', 'Draw to shape', 'S'], ['rect', 'Rectangle', 'R'], ['circle', 'Circle', 'C'], ['arc', 'Arc', 'A'], '|',
+    ['dim', 'Dimension', 'D'], ['wdoor', 'Door', 'B'], ['wwindow', 'Window', 'N'], ['cabinet', 'Cabinet', 'K'], '|', ['constr', 'Construction lines', 'X', 'toggle'], '|',
+    ['undo', 'Undo', '⌘Z', 'act'], ['redo', 'Redo', '⇧⌘Z', 'act'],
+];
+/** Tool letters in the wall view. */
+export const WALL_KEYS = { v: 'select', l: 'line', s: 'freehand', r: 'rect', c: 'circle', a: 'arc', d: 'dim', t: 'trim', o: 'offset', b: 'wdoor', n: 'wwindow', k: 'cabinet' };
+/** The icon for a wall tool whose id isn't an icon's name. */
+export const WALL_ICON = { wdoor: 'door', wwindow: 'window', height: 'hline' };
+// ---- what's under the pointer, beyond the face's own geometry ----
+/** A cabinet (on it, or within `slack` inches of its outline) or a door/window body under a world point on the face (cabinets first). */
+export function wallBodyAt(wx, wy, slack = 0) {
+    const face = SK(), f = elev.frame;
+    if (!f)
+        return null;
+    // (inside it: right on its edge picks the edge, as a window's)
+    for (const id of Object.keys(face.cabs ?? {}).reverse()) {
+        const b = cabBox(face, id);
+        if (b && wx > b.u0 && wx < b.u1 && wy > b.z0 && wy < b.z1)
+            return { type: 'cab', id };
+    }
+    for (const o of elevOpenings(planSK(), f))
+        if (wx > o.u0 && wx < o.u1 && wy > o.sill && wy < o.head)
+            return { type: 'opening', id: o.id };
+    return null;
+}
+/** Two doors/windows, or one and a wall end: the + sets the distance between them (the plan's door/window dimension). */
+function wallPair() {
+    if (ed.sel.length !== 2)
+        return null;
+    const ops = ed.sel.filter(x => x.type === 'opening').map(x => x.id);
+    const ends = ed.sel.filter(x => x.type === 'line' && (x.id === '@ea' || x.id === '@eb')).map(x => x.id.slice(2));
+    if (ops.length === 2)
+        return { op: ops[0], other: { op: ops[1] } };
+    if (ops.length === 1 && ends.length === 1)
+        return { op: ops[0], other: { end: ends[0] } };
+    return null;
+}
+/** The bar for what's selected on the wall that the plan doesn't know (a door or window, a cabinet, a chip). Null: the plan's bar. */
+export function wallBar() {
+    if (!elevOpen())
+        return null;
+    const pair = wallPair();
+    if (pair) {
+        const name = (id) => (planSK().openings[id]?.type === 'door' ? 'Door' : 'Window');
+        const label = name(pair.op) + ' + ' + ('op' in pair.other ? name(pair.other.op).toLowerCase() : 'corner');
+        return { label, items: [{ ic: 'dim', label: 'Distance', act: 'wallDist' }], plus: true };
+    }
+    if (ed.sel.length !== 1)
+        return null;
+    const s = ed.sel[0], sk = planSK();
+    if (s.type === 'elev') {
+        const a = elevAct(s.id);
+        return { label: elevChipName(a), items: a.k === 'len' ? [{ ic: 'back', label: 'Go to plan', act: 'wallGoPlan' }] : [], plus: a.k !== 'len' };
+    }
+    // a door, window or cabinet picked as a whole: its sizes to set, by name (no + — it isn't one dimension)
+    if (s.type === 'opening') {
+        const o = sk.openings[s.id];
+        if (!o)
+            return null;
+        return { label: openingLabel(o), items: OPENING_SIZES, plus: false };
+    }
+    if (s.type === 'cab') {
+        const face = SK(), b = cabBox(face, s.id), cb = face.cabs[s.id];
+        return {
+            label: 'Cabinet' + (b ? ' ' + fmtLen(b.u1 - b.u0) + ' L × ' + fmtLen(b.z1 - b.z0) + ' H × ' + fmtLen(cb.depth) + ' D' : ''),
+            items: [{ ic: 'v', label: 'Height', act: 'cabH' }, { ic: 'h', label: 'Length', act: 'cabW' }, { ic: 'thick', label: 'Depth', act: 'cabD' }], plus: false,
+        };
+    }
+    const face = SK();
+    if (s.type === 'line' && face.lines[s.id]?.anchor)
+        return { label: anchorName(s.id), items: [], plus: false };
+    if (s.type === 'line' && face.lines[s.id]?.cab)
+        return { label: 'Cabinet edge', items: [], plus: false };
+    if (s.type === 'point' && face.points[s.id]?.anchor)
+        return { label: 'Corner · set by the plan', items: [], plus: false };
+    return null;
+}
+/** What one of the plan's edges on the face is. */
+function anchorName(id) {
+    if (id === '@floor')
+        return 'Floor';
+    if (id === '@ceil')
+        return 'Ceiling';
+    if (id === '@ea' || id === '@eb')
+        return 'Wall corner';
+    const op = planSK().openings[id.split(':')[1]];
+    return (op?.type === 'door' ? 'Door' : 'Window') + ' edge';
+}
+/** A door's or window's sizes to set, in the bar (the wall view's and the plan's): its height and its length. */
+export const OPENING_SIZES = [{ ic: 'v', label: 'Height', act: 'opHeight' }, { ic: 'h', label: 'Length', act: 'opLength' }];
+/** What the bar calls a door or window: its kind and sizes, length by height ("Door 3'-0" L × 6'-8" H"). */
+export function openingLabel(o) {
+    const { sill, head } = openingHeights(o);
+    return (o.type === 'door' ? 'Door ' : 'Window ') + fmtLen(o.w) + ' L × ' + fmtLen(head - sill) + ' H';
+}
+/** Run a bar action for the wall view's things (a door's or window's sizes work in the plan too). Returns false if it isn't one. */
+export function wallAction(act) {
+    const s = ed.sel[0];
+    switch (act) {
+        case 'opHeight':
+            editOpeningHeight(s.id);
+            return true;
+        case 'opLength':
+            editOpeningDim(s.id, 'w');
+            return true;
+        case 'cabW':
+            editCabinet(s.id, 'w');
+            return true;
+        case 'opSill':
+            editSill(s.id);
+            return true;
+        case 'cabH':
+            editCabinet(s.id, 'h');
+            return true;
+        case 'cabD':
+            editCabinetDepth(s.id);
+            return true;
+        case 'cabZ':
+            editCabinet(s.id, 'z');
+            return true;
+        case 'wallGoPlan':
+            goToPlan();
+            return true;
+        case 'wallDist':
+            wallPlus();
+            return true;
+    }
+    return false;
+}
+/** The yellow + for wall things. Returns false if the plan's + should handle the selection. */
+export function wallPlus() {
+    if (!elevOpen())
+        return false;
+    const pair = wallPair(), f = elev.frame;
+    if (pair) {
+        const ops = elevOpenings(planSK(), f), a = ops.find(o => o.id === pair.op);
+        if (!a)
+            return true;
+        if ('op' in pair.other) {
+            const otherId = pair.other.op, b = ops.find(o => o.id === otherId);
+            if (!b)
+                return true;
+            const [l, r] = a.u0 <= b.u0 ? [a, b] : [b, a], t = pickBetween(planSK(), l.id, l.e1, r.id, r.e0);
+            editElevationPosition(t.op, t.edge, t.ref, 'Space between');
+        }
+        else {
+            const end = pair.other.end, ref = { face: end, line: f.lid, side: f.side };
+            editElevationPosition(a.id, end === f.leftEnd ? a.e0 : a.e1, ref, 'Distance from the corner');
+        }
         return true;
     }
-    if (e.mod && k === 'z') {
-        if (e.shift)
-            redo();
-        else
-            undo();
+    if (ed.sel.length !== 1)
+        return false;
+    const s = ed.sel[0];
+    if (s.type === 'elev') {
+        editElevChip(elevAct(s.id));
         return true;
     }
-    if (e.mod && k === 'y') {
-        redo();
+    if (s.type === 'opening') {
+        editOpeningDim(s.id, 'w');
         return true;
     }
-    if (k === 'f' && !e.mod) {
-        fitElevation();
+    if (s.type === 'cab') {
+        editCabinet(s.id, 'w');
         return true;
     }
-    if (!e.mod && !e.alt && elevToolKey(e.key))
+    return false;
+}
+/**
+ * Delete in the wall view: a selected chip's dimension is freed or removed; doors and windows go from the plan,
+ * cabinets from the face, the rest as in the plan. The plan's anchors stay. Returns false outside the wall view.
+ */
+export function wallDelete() {
+    if (!elevOpen())
+        return false;
+    if (ed.sel.length === 1 && ed.sel[0].type === 'elev') {
+        deleteElevChip(elevAct(ed.sel[0].id));
         return true;
-    if (e.key === 'Delete' || e.key === 'Backspace') {
-        deleteSelectedElevDim();
+    }
+    const face = SK();
+    const anchor = (x) => (x.type === 'line' && !!face.lines[x.id]?.anchor) || (x.type === 'point' && !!face.points[x.id]?.anchor);
+    const items = ed.sel.filter(x => !anchor(x) && x.type !== 'elev');
+    if (!items.length) {
+        toast('The wall’s edges and corners come from the plan — they can’t be deleted here.', { warn: true });
         return true;
     }
-    return false;
+    const one = items.length === 1 ? items[0] : null, op = one?.type === 'opening' ? planSK().openings[one.id] : null;
+    const what = one?.type === 'cab' ? 'Cabinet deleted' : op ? (op.type === 'door' ? 'Door' : 'Window') + ' deleted' : 'Deleted';
+    pushHistory();
+    deleteSel(planSK(), items.filter(x => x.type === 'opening'));
+    deleteCabinets(items.filter(x => x.type === 'cab').map(x => x.id));
+    deleteSel(face, items.filter(x => x.type !== 'opening' && x.type !== 'cab'));
+    ed.sel = [];
+    afterEdit();
+    toast(what, { action: { label: 'Undo', fn: () => undo() } });
+    return true;
 }
 //# sourceMappingURL=elevation.js.map