schematex 0.9.2 → 0.9.3

package/dist/{chunk-TP7LQ5PF.js → chunk-BP6MLXJU.js}

@@ -1,21 +1,21 @@
-import { orgchart } from './chunk-HJA7MIMV.js';
-import { circuit } from './chunk-MERU76LW.js';
-import { blockdiagram } from './chunk-IQLZUCWI.js';
-import { ladder } from './chunk-VY4JOTM2.js';
-import { sld } from './chunk-VMUNKEB2.js';
-import { entity } from './chunk-TMAOPJCT.js';
-import { fishbone } from './chunk-KR7PPCC4.js';
-import { venn } from './chunk-TWTUIUNK.js';
-import { flowchart, layoutFlowchart } from './chunk-7Z2GDS4G.js';
-import { genogram } from './chunk-2RFFCZ3I.js';
-import { ecomap, estimateTextWidth } from './chunk-VWIKDJNV.js';
-import { pedigree } from './chunk-7SVB3XA7.js';
+import { orgchart } from './chunk-ZUK4BY55.js';
+import { circuit } from './chunk-QHZEGWE7.js';
+import { blockdiagram } from './chunk-JEQGWH5N.js';
+import { ladder } from './chunk-X3GEGVW2.js';
+import { sld } from './chunk-7P4C5DMD.js';
+import { entity } from './chunk-XAYD5NVJ.js';
+import { fishbone } from './chunk-6GHXO3WQ.js';
+import { venn } from './chunk-UNLLWCQK.js';
+import { flowchart, layoutFlowchart } from './chunk-PUD7PIY5.js';
+import { genogram } from './chunk-PZCYFT2A.js';
+import { ecomap, estimateTextWidth } from './chunk-OND4N5ZZ.js';
+import { pedigree } from './chunk-4CLAD7VZ.js';
 import { parseFrontmatter } from './chunk-2KTQ75LN.js';
-import { phylo } from './chunk-VZVREOTM.js';
-import { sociogram } from './chunk-56DSMSXK.js';
+import { phylo } from './chunk-ZQECHIBI.js';
+import { sociogram } from './chunk-TDSGQT7R.js';
 import { timing } from './chunk-MTIZIHWE.js';
-import { logic } from './chunk-JR6JNQEZ.js';
-import { resolveBaseTheme, resolveTimelineTheme, resolveStateTheme, cssCustomProperties, resolvePetriTheme, resolveNetworkTheme, resolveUmlClassTheme, DEFAULT_FONT_FAMILY, FONT_SIZE, resolveReliabilityTheme, STROKE_WIDTH, resolveBowtieTheme, resolveMindmapTheme, resolveMatrixTheme, resolveBpmnTheme } from './chunk-TYEQC7PV.js';
+import { logic } from './chunk-U4AJLMHC.js';
+import { resolveBaseTheme, resolveTimelineTheme, resolveStateTheme, cssCustomProperties, resolvePetriTheme, resolveNetworkTheme, resolveUmlClassTheme, DEFAULT_FONT_FAMILY, FONT_SIZE, resolveReliabilityTheme, STROKE_WIDTH, resolveBowtieTheme, resolveMindmapTheme, resolveMatrixTheme, resolveBpmnTheme, resolveFloorplanTheme, TITLE } from './chunk-D4QZ6UDO.js';
 import { QUOTE_PAIRS, stripQuotes, isOpenQuote, extractQuotedString, matchQuotedTitle } from './chunk-TO6PNBT3.js';
 import { el, escapeXml, group, rect, text, line, path, circle, polygon, title, desc, svgRoot, defs, multilineText } from './chunk-SYYBKDL7.js';
 
@@ -2283,11 +2283,11 @@ function layoutSwimlane(ast) {
       ];
       let labelY = candidates[0];
       for (const y of candidates) {
-        const box = { x1: x - labelW / 2, x2: x + labelW / 2, y };
-        const collide = labelBoxes.some((b) => Math.abs(b.y - box.y) < 13 && b.x1 < box.x2 && b.x2 > box.x1);
+        const box2 = { x1: x - labelW / 2, x2: x + labelW / 2, y };
+        const collide = labelBoxes.some((b) => Math.abs(b.y - box2.y) < 13 && b.x1 < box2.x2 && b.x2 > box2.x1);
         if (!collide) {
           labelY = y;
-          labelBoxes.push(box);
+          labelBoxes.push(box2);
           break;
         }
       }
@@ -2448,10 +2448,10 @@ function layoutGantt(ast) {
     let labelY = pinZoneTop + 12;
     let step = 0;
     while (step < 4) {
-      const box = { x1: x - labelW / 2, x2: x + labelW / 2, y: labelY };
-      const collide = pinBoxes.some((b) => Math.abs(b.y - box.y) < 14 && b.x1 < box.x2 && b.x2 > box.x1);
+      const box2 = { x1: x - labelW / 2, x2: x + labelW / 2, y: labelY };
+      const collide = pinBoxes.some((b) => Math.abs(b.y - box2.y) < 14 && b.x1 < box2.x2 && b.x2 > box2.x1);
       if (!collide) {
-        pinBoxes.push(box);
+        pinBoxes.push(box2);
         break;
       }
       labelY += 16;
@@ -7453,10 +7453,10 @@ function arrowMarker(t) {
     )
   ]);
 }
-function classForBox(box) {
-  if (box.variant === "previous") return "prisma-stage-previous";
-  const base = box.variant === "exclusion" ? "prisma-exclusion" : "prisma-stage";
-  return `${base} prisma-stage-${box.stage}`;
+function classForBox(box2) {
+  if (box2.variant === "previous") return "prisma-stage-previous";
+  const base = box2.variant === "exclusion" ? "prisma-exclusion" : "prisma-stage";
+  return `${base} prisma-stage-${box2.stage}`;
 }
 function classForLine(style) {
   switch (style) {
@@ -7540,22 +7540,22 @@ function renderHeader(h) {
   );
   return group({ "data-header": h.column }, [r6, ...lines]);
 }
-function renderBox(box) {
+function renderBox(box2) {
   const r6 = rect({
-    x: box.x,
-    y: box.y,
-    width: box.width,
-    height: box.height,
+    x: box2.x,
+    y: box2.y,
+    width: box2.width,
+    height: box2.height,
     rx: PRISMA_CONST.BOX_RADIUS,
     ry: PRISMA_CONST.BOX_RADIUS,
-    class: classForBox(box),
-    "data-role": box.role
+    class: classForBox(box2),
+    "data-role": box2.role
   });
-  const innerLeft = box.x + PRISMA_CONST.BOX_PAD_X;
-  const innerRight = box.x + box.width - PRISMA_CONST.BOX_PAD_X;
-  const centerX = box.x + box.width / 2;
+  const innerLeft = box2.x + PRISMA_CONST.BOX_PAD_X;
+  const innerRight = box2.x + box2.width - PRISMA_CONST.BOX_PAD_X;
+  const centerX = box2.x + box2.width / 2;
   let widestIndented = 0;
-  for (const line2 of box.lines) {
+  for (const line2 of box2.lines) {
     if ((line2.indent ?? 0) > 0) {
       const w = approxLineWidth(line2);
       if (w > widestIndented) widestIndented = w;
@@ -7565,9 +7565,9 @@ function renderBox(box) {
     innerLeft,
     Math.min(centerX - widestIndented / 2, innerRight - widestIndented)
   );
-  let textY = box.y + PRISMA_CONST.BOX_PAD_Y;
+  let textY = box2.y + PRISMA_CONST.BOX_PAD_Y;
   const textEls = [];
-  for (const line2 of box.lines) {
+  for (const line2 of box2.lines) {
     const lh = lineHeightForLine(line2.style);
     const baseline = textY + Math.round(lh * 0.75);
     const indented = (line2.indent ?? 0) > 0;
@@ -7595,9 +7595,9 @@ function renderBox(box) {
   }
   return group(
     {
-      "data-prisma-role": box.role,
-      "data-prisma-variant": box.variant,
-      "data-prisma-stage": box.stage
+      "data-prisma-role": box2.role,
+      "data-prisma-variant": box2.variant,
+      "data-prisma-stage": box2.stage
     },
     [r6, ...textEls]
   );
@@ -8528,7 +8528,7 @@ function layoutUsecase(ast) {
       const y = cy - h / 2;
       const anchorX = side === "left" ? x + w : x;
       const anchorY = isRect ? cy : cy - 6;
-      const box = {
+      const box2 = {
         actor: a,
         x,
         y,
@@ -8538,8 +8538,8 @@ function layoutUsecase(ast) {
         anchorX,
         anchorY
       };
-      actorBoxes.push(box);
-      actorById2.set(a.id, box);
+      actorBoxes.push(box2);
+      actorById2.set(a.id, box2);
       cy += C2.ACTOR_PITCH;
     }
   }
@@ -10126,7 +10126,7 @@ function layoutNetwork(ast, schedule) {
         y = cursor;
         cursor += C2.BOX_H + C2.V_GAP;
       }
-      const box = {
+      const box2 = {
         id,
         task: t,
         computed,
@@ -10137,8 +10137,8 @@ function layoutNetwork(ast, schedule) {
         milestone: t.milestone,
         rank: r6
       };
-      boxes.push(box);
-      boxById.set(id, box);
+      boxes.push(box2);
+      boxById.set(id, box2);
     }
   }
   const edges = [];
@@ -10345,7 +10345,7 @@ function layoutSwimlane2(ast, schedule) {
         const w = t.milestone ? C2.MS_W : C2.BOX_W;
         const x = colX(r6) + (C2.BOX_W - w) / 2;
         const y = y0 + idx * (C2.BOX_H + C2.V_GAP);
-        const box = {
+        const box2 = {
           id,
           task: t,
           computed: schedule.computed.get(id),
@@ -10356,8 +10356,8 @@ function layoutSwimlane2(ast, schedule) {
           milestone: t.milestone,
           rank: r6
         };
-        boxes.push(box);
-        boxById.set(id, box);
+        boxes.push(box2);
+        boxById.set(id, box2);
       });
     }
   }
@@ -10427,7 +10427,7 @@ function layoutTimescaled(ast, schedule) {
     const iv = intervalById.get(t.id);
     const lane = laneOf.get(t.id);
     const y = topPad + lane * (C2.TS_BOX_H + C2.TS_LANE_GAP);
-    const box = {
+    const box2 = {
       id: t.id,
       task: t,
       computed: schedule.computed.get(t.id),
@@ -10438,8 +10438,8 @@ function layoutTimescaled(ast, schedule) {
       milestone: t.milestone,
       rank: 0
     };
-    boxes.push(box);
-    boxById.set(t.id, box);
+    boxes.push(box2);
+    boxById.set(t.id, box2);
   }
   const edges = [];
   for (const t of ast.tasks) {
@@ -13864,26 +13864,26 @@ function labelText(d) {
 function deviceFootprint(d) {
   return iconSize(d.kind);
 }
-function effBox(box) {
-  const labelW = Math.max(box.w, labelText(box.device).length * NET_CONST.CHAR_W + 6);
+function effBox(box2) {
+  const labelW = Math.max(box2.w, labelText(box2.device).length * NET_CONST.CHAR_W + 6);
   const half = labelW / 2;
   return {
-    left: box.cx - half,
-    top: box.y,
-    right: box.cx + half,
-    bottom: box.y + box.h + labelExtra(box.device)
-  };
-}
-function edgePoint(box, tx, ty) {
-  const dx = tx - box.cx;
-  const dy = ty - box.cy;
-  if (dx === 0 && dy === 0) return { x: box.cx, y: box.cy };
-  const hw = box.w / 2;
-  const hh = box.h / 2;
+    left: box2.cx - half,
+    top: box2.y,
+    right: box2.cx + half,
+    bottom: box2.y + box2.h + labelExtra(box2.device)
+  };
+}
+function edgePoint(box2, tx, ty) {
+  const dx = tx - box2.cx;
+  const dy = ty - box2.cy;
+  if (dx === 0 && dy === 0) return { x: box2.cx, y: box2.cy };
+  const hw = box2.w / 2;
+  const hh = box2.h / 2;
   const sx = dx !== 0 ? hw / Math.abs(dx) : Infinity;
   const sy = dy !== 0 ? hh / Math.abs(dy) : Infinity;
   const s = Math.min(sx, sy);
-  return { x: box.cx + dx * s, y: box.cy + dy * s };
+  return { x: box2.cx + dx * s, y: box2.cy + dy * s };
 }
 function placeBanded(ast, ranks) {
   const lr = ast.direction === "lr";
@@ -17558,7 +17558,7 @@ function layoutFaultTree(ast) {
     bump(g.cx + g.width / 2, g.cy + g.height / 2);
     if (g.cond) bump(g.cond.x + g.cond.w / 2, g.cond.y + g.cond.h / 2);
   }
-  for (const box of cutSetBoxes) bump(box.x + box.width, box.y + box.height);
+  for (const box2 of cutSetBoxes) bump(box2.x + box2.width, box2.y + box2.height);
   for (const t of transfers) bump(t.x + 22, t.y + 30);
   if (ast.title) bump(C2.CANVAS_PAD + ast.title.length * 8.5, 0);
   if (ast.analysis.probability) {
@@ -17637,20 +17637,20 @@ function renderFaultTreeLayout(layout, config) {
       text({ x: layout.width / 2, y: 22, class: "sx-ft-title", "font-family": fontFamily, "text-anchor": "middle" }, ast.title)
     );
   }
-  for (const box of layout.cutSetBoxes) {
+  for (const box2 of layout.cutSetBoxes) {
     inner.push(
       rect({
-        x: box.x,
-        y: box.y,
-        width: box.width,
-        height: box.height,
+        x: box2.x,
+        y: box2.y,
+        width: box2.width,
+        height: box2.height,
         rx: 6,
         class: "sx-ft-cutset",
-        "data-cutset": box.cutSet.events.join(","),
-        "data-cutset-index": String(box.index),
-        "data-order": String(box.cutSet.order),
-        ...box.cutSet.isSpof ? { "data-spof": "true" } : {},
-        ...box.cutSet.prob !== void 0 ? { "data-cutset-prob": String(box.cutSet.prob) } : {}
+        "data-cutset": box2.cutSet.events.join(","),
+        "data-cutset-index": String(box2.index),
+        "data-order": String(box2.cutSet.order),
+        ...box2.cutSet.isSpof ? { "data-spof": "true" } : {},
+        ...box2.cutSet.prob !== void 0 ? { "data-cutset-prob": String(box2.cutSet.prob) } : {}
       })
     );
   }
@@ -21735,16 +21735,16 @@ function layoutMarkov(ast) {
     const tag = classOf?.[st.id];
     const isAbsorbing = tag === "absorbing";
     const pi = piMap?.[st.id] ?? perClassPi[st.id];
-    const box = {
+    const box2 = {
       state: st,
       cx: c.x,
       cy: c.y,
       r: C2.STATE_R,
       isAbsorbing
     };
-    if (tag) box.classTag = tag;
-    if (pi !== void 0) box.pi = pi;
-    return box;
+    if (tag) box2.classTag = tag;
+    if (pi !== void 0) box2.pi = pi;
+    return box2;
   });
   const arcKey = (a, b) => `${a}\0${b}`;
   const present = /* @__PURE__ */ new Set();
@@ -24163,13 +24163,13 @@ function parseFunction2(ast, rest, lineNo) {
     ast.warnings.push(`Line ${lineNo}: box "${id}" redeclared \u2014 keeping first declaration.`);
     return;
   }
-  const box = {
+  const box2 = {
     id,
     name,
     // analysis assigns the real number; explicit wins if given.
     number: explicitNumber ?? 0
   };
-  ast.boxes.push(box);
+  ast.boxes.push(box2);
 }
 function parseRoleArrow(ast, role, rest, lineNo) {
   const idM = /^([A-Za-z_]\w*)/.exec(rest);
@@ -24441,8 +24441,8 @@ function layoutIdef0(astIn) {
   const C2 = IDEF0_CONST;
   const ox = C2.MARGIN;
   const oy = C2.MARGIN + C2.TITLE_H;
-  const boxes = ast.boxes.map((box, idx) => ({
-    box,
+  const boxes = ast.boxes.map((box2, idx) => ({
+    box: box2,
     x: ox + idx * C2.STEP_X,
     y: oy + idx * C2.STEP_Y,
     width: C2.BOX_W,
@@ -35971,6 +35971,2508 @@ var sfc = {
   }
 };
 
+// src/diagrams/floorplan/catalog.ts
+var CHAIR_W = 0.44;
+var CHAIR_D = 0.38;
+var CHAIR_GAP = 0.27;
+var CHAIR_OVERHANG = 0.5;
+var RING = 0.45;
+function chairAt(px, cx, cy, deg) {
+  const body = rect({
+    class: "sx-fp-chair",
+    x: px(-CHAIR_W / 2),
+    y: px(-CHAIR_D / 2),
+    width: px(CHAIR_W),
+    height: px(CHAIR_D),
+    rx: px(0.09)
+  });
+  const rot = Math.round(deg * 10) / 10;
+  return el("g", { transform: `translate(${px(cx)},${px(cy)}) rotate(${rot})` }, [body]);
+}
+function edgeChairs(c, top, bottom) {
+  const n = Math.max(1, Math.round(c.w / 0.65));
+  const out = [];
+  for (let i = 0; i < n; i++) {
+    const cx = (i + 0.5) / n * c.w;
+    if (top) out.push(chairAt(c.px, cx, -CHAIR_GAP, 0));
+    out.push(chairAt(c.px, cx, c.h + CHAIR_GAP, 180));
+  }
+  return out.join("");
+}
+function box(c, cls = "sx-fp-furn", rx = 0) {
+  return rect({ class: cls, x: 0, y: 0, width: c.px(c.w), height: c.px(c.h), rx: rx ? c.px(rx) : void 0 });
+}
+function glyphText(c, label) {
+  return text(
+    {
+      class: "sx-fp-furn-text",
+      x: c.px(c.w / 2),
+      y: c.px(c.h / 2),
+      "text-anchor": "middle",
+      "dominant-baseline": "central",
+      "font-size": c.px(Math.min(0.24, c.h * 0.4))
+    },
+    label
+  );
+}
+function bedDraw(pillows) {
+  return (c) => {
+    const parts = [box(c, "sx-fp-furn", 0.05)];
+    const pw = pillows === 2 ? c.w / 2 - 0.18 : c.w - 0.24;
+    parts.push(rect({ class: "sx-fp-furn", x: c.px(0.12), y: c.px(0.1), width: c.px(pw), height: c.px(0.42), rx: c.px(0.06) }));
+    if (pillows === 2) {
+      parts.push(rect({ class: "sx-fp-furn", x: c.px(c.w / 2 + 0.06), y: c.px(0.1), width: c.px(pw), height: c.px(0.42), rx: c.px(0.06) }));
+    }
+    parts.push(line({ class: "sx-fp-furn-line", x1: 0, y1: c.px(0.72), x2: c.px(c.w), y2: c.px(0.72) }));
+    return parts.join("");
+  };
+}
+function sofaDraw(cushions) {
+  return (c) => {
+    const parts = [box(c, "sx-fp-furn", 0.08)];
+    parts.push(rect({ class: "sx-fp-furn", x: c.px(0.15), y: 0, width: c.px(c.w - 0.3), height: c.px(0.18), rx: c.px(0.05) }));
+    parts.push(line({ class: "sx-fp-furn-line", x1: c.px(0.15), y1: c.px(0.18), x2: c.px(0.15), y2: c.px(c.h - 0.05) }));
+    parts.push(line({ class: "sx-fp-furn-line", x1: c.px(c.w - 0.15), y1: c.px(0.18), x2: c.px(c.w - 0.15), y2: c.px(c.h - 0.05) }));
+    for (let i = 1; i < cushions; i++) {
+      const x = c.px(0.15 + (c.w - 0.3) * i / cushions);
+      parts.push(line({ class: "sx-fp-furn-line", x1: x, y1: c.px(0.18), x2: x, y2: c.px(c.h - 0.08) }));
+    }
+    return parts.join("");
+  };
+}
+function shelfDraw(c) {
+  const parts = [box(c)];
+  const n = Math.max(2, Math.round(c.w / 0.15));
+  for (let i = 1; i < n; i++) {
+    const x = c.px(c.w * i / n);
+    parts.push(line({ class: "sx-fp-furn-line", x1: x, y1: 0, x2: x, y2: c.px(c.h) }));
+  }
+  return parts.join("");
+}
+function boardDraw(c) {
+  return [
+    rect({ class: "sx-fp-furn-solid", x: 0, y: 0, width: c.px(c.w), height: c.px(c.h) }),
+    rect({ class: "sx-fp-board-inner", x: c.px(0.08), y: c.px(c.h * 0.2), width: c.px(c.w - 0.16), height: c.px(c.h * 0.6) })
+  ].join("");
+}
+function applianceDraw(label, drum) {
+  return (c) => {
+    const parts = [box(c)];
+    if (drum) {
+      parts.push(circle({ class: "sx-fp-furn-line", cx: c.px(c.w / 2), cy: c.px(c.h / 2), r: c.px(Math.min(c.w, c.h) * 0.32) }));
+    } else {
+      parts.push(line({ class: "sx-fp-furn-line", x1: 0, y1: c.px(0.12), x2: c.px(c.w), y2: c.px(0.12) }));
+    }
+    parts.push(glyphText(c, label));
+    return parts.join("");
+  };
+}
+function roundTable(seats, diaM) {
+  const nominal = diaM + 2 * RING;
+  return {
+    w: nominal,
+    h: nominal,
+    draw: (c) => {
+      const half = Math.min(c.w, c.h) / 2;
+      const ring = Math.min(RING, half * 0.37);
+      const r6 = half - ring;
+      const cx = c.w / 2;
+      const cy = c.h / 2;
+      const parts = [circle({ class: "sx-fp-furn", cx: c.px(cx), cy: c.px(cy), r: c.px(r6) })];
+      for (let i = 0; i < seats; i++) {
+        const a = i / seats * 2 * Math.PI - Math.PI / 2;
+        const px0 = cx + (r6 + ring * 0.55) * Math.cos(a);
+        const py0 = cy + (r6 + ring * 0.55) * Math.sin(a);
+        parts.push(chairAt(c.px, px0, py0, a * 180 / Math.PI + 90));
+      }
+      return parts.join("");
+    }
+  };
+}
+function tableDraw(top, bottom) {
+  return (c) => box(c) + edgeChairs(c, top);
+}
+var TREAD = 0.28;
+function treadLines(c, vert, fixed0, fixed1, from, to, dashedFrom) {
+  const parts = [];
+  const dir = to >= from ? 1 : -1;
+  for (let d = from; dir > 0 ? d <= to : d >= to; d += TREAD * dir) {
+    const dashed = dashedFrom !== void 0 && (dir > 0 ? d > dashedFrom : d < dashedFrom);
+    const cls = dashed ? "sx-fp-furn-dash" : "sx-fp-furn-line";
+    if (vert) parts.push(line({ class: cls, x1: c.px(fixed0), y1: c.px(d), x2: c.px(fixed1), y2: c.px(d) }));
+    else parts.push(line({ class: cls, x1: c.px(d), y1: c.px(fixed0), x2: c.px(d), y2: c.px(fixed1) }));
+  }
+  return parts.join("");
+}
+function breakLine(c, vert, lo, hi, at) {
+  const span = hi - lo;
+  const dz = Math.min(0.12, span * 0.18);
+  const tilt = span * 0.18;
+  const pts = vert ? [
+    [lo, at + tilt],
+    [lo + span * 0.4, at + tilt * 0.2],
+    [lo + span * 0.5 - dz, at + tilt * 0.2 + dz],
+    [lo + span * 0.5 + dz, at - tilt * 0.2 - dz],
+    [lo + span * 0.6, at - tilt * 0.2],
+    [hi, at - tilt]
+  ] : [
+    [at + tilt, lo],
+    [at + tilt * 0.2, lo + span * 0.4],
+    [at + tilt * 0.2 + dz, lo + span * 0.5 - dz],
+    [at - tilt * 0.2 - dz, lo + span * 0.5 + dz],
+    [at - tilt * 0.2, lo + span * 0.6],
+    [at - tilt, hi]
+  ];
+  const d = pts.map(([a, b], i) => `${i === 0 ? "M" : "L"} ${c.px(vert ? a : a)} ${c.px(vert ? b : b)}`).join(" ");
+  return path({ class: "sx-fp-stair-break", d });
+}
+function dirArrow(c, points, labelText2) {
+  const parts = [];
+  const [sx, sy] = points[0];
+  parts.push(circle({ class: "sx-fp-furn-line", cx: c.px(sx), cy: c.px(sy), r: c.px(0.05) }));
+  const d = points.map(([x, y], i) => `${i === 0 ? "M" : "L"} ${c.px(x)} ${c.px(y)}`).join(" ");
+  parts.push(path({ class: "sx-fp-furn-line", d }));
+  const [ex, ey] = points[points.length - 1];
+  const [px2, py2] = points[points.length - 2];
+  const ang = Math.atan2(ey - py2, ex - px2);
+  const hs = 0.11;
+  const a1 = ang + Math.PI - 0.5;
+  const a2 = ang + Math.PI + 0.5;
+  parts.push(
+    polygon({
+      class: "sx-fp-furn-dot",
+      points: `${c.px(ex)},${c.px(ey)} ${c.px(ex + hs * Math.cos(a1))},${c.px(ey + hs * Math.sin(a1))} ${c.px(ex + hs * Math.cos(a2))},${c.px(ey + hs * Math.sin(a2))}`
+    })
+  );
+  const [nx, ny] = points[1];
+  const segLen = Math.hypot(nx - sx, ny - sy) || 1;
+  const ux = (nx - sx) / segLen;
+  const uy = (ny - sy) / segLen;
+  const lx = sx + ux * 0.42 - uy * 0.16;
+  const ly = sy + uy * 0.42 + ux * 0.16;
+  parts.push(
+    text(
+      {
+        class: "sx-fp-furn-text",
+        x: c.px(lx),
+        y: c.px(ly),
+        "text-anchor": "middle",
+        "dominant-baseline": "central",
+        "font-size": c.px(0.18)
+      },
+      labelText2
+    )
+  );
+  return parts.join("");
+}
+function straightStairs(c) {
+  const vert = c.h >= c.w;
+  const len = vert ? c.h : c.w;
+  const breakAt = Math.min(7 * TREAD, len * 0.62);
+  const parts = [box(c, "sx-fp-furn-nofill")];
+  if (vert) {
+    parts.push(treadLines(c, true, 0, c.w, c.h - TREAD, 0.02, c.h - breakAt));
+    parts.push(breakLine(c, true, 0, c.w, c.h - breakAt));
+    parts.push(dirArrow(c, [[c.w / 2, c.h - 0.18], [c.w / 2, c.h - breakAt + 0.28]], c.label ?? "UP"));
+  } else {
+    parts.push(treadLines(c, false, 0, c.h, TREAD, c.w - 0.02, breakAt));
+    parts.push(breakLine(c, false, 0, c.h, breakAt));
+    parts.push(dirArrow(c, [[0.18, c.h / 2], [breakAt - 0.28, c.h / 2]], c.label ?? "UP"));
+  }
+  return parts.join("");
+}
+function lStairs(c) {
+  const rw = Math.min(c.w, c.h) * 0.45;
+  const parts = [
+    path({
+      class: "sx-fp-furn-nofill",
+      d: `M 0 0 L ${c.px(c.w)} 0 L ${c.px(c.w)} ${c.px(rw)} L ${c.px(rw)} ${c.px(rw)} L ${c.px(rw)} ${c.px(c.h)} L 0 ${c.px(c.h)} Z`
+    })
+  ];
+  parts.push(line({ class: "sx-fp-furn-line", x1: c.px(rw), y1: 0, x2: c.px(rw), y2: c.px(rw) }));
+  parts.push(treadLines(c, true, 0, rw, c.h - TREAD, rw + 0.05));
+  const breakAt = rw + (c.w - rw) * 0.55;
+  parts.push(treadLines(c, false, 0, rw, rw + TREAD, c.w - 0.02, breakAt));
+  parts.push(breakLine(c, false, 0, rw, breakAt));
+  parts.push(
+    dirArrow(
+      c,
+      [
+        [rw / 2, c.h - 0.18],
+        [rw / 2, rw / 2],
+        [breakAt - 0.24, rw / 2]
+      ],
+      c.label ?? "UP"
+    )
+  );
+  return parts.join("");
+}
+function uStairs(c) {
+  const lh = Math.min(c.h * 0.3, Math.max(0.9, c.w / 2));
+  const mid = c.w / 2;
+  const parts = [box(c, "sx-fp-furn-nofill")];
+  parts.push(line({ class: "sx-fp-furn-line", x1: 0, y1: c.px(lh), x2: c.px(c.w), y2: c.px(lh) }));
+  parts.push(line({ class: "sx-fp-furn-line", x1: c.px(mid), y1: c.px(lh), x2: c.px(mid), y2: c.px(c.h) }));
+  parts.push(treadLines(c, true, mid, c.w, c.h - TREAD, lh + 0.05));
+  const breakAt = lh + (c.h - lh) * 0.4;
+  parts.push(treadLines(c, true, 0, mid, lh + TREAD, c.h - 0.02, breakAt));
+  parts.push(breakLine(c, true, 0, mid, breakAt));
+  parts.push(
+    dirArrow(
+      c,
+      [
+        [mid + mid / 2, c.h - 0.18],
+        [mid + mid / 2, lh / 2],
+        [mid / 2, lh / 2],
+        [mid / 2, breakAt - 0.24]
+      ],
+      c.label ?? "UP"
+    )
+  );
+  return parts.join("");
+}
+function spiralStairs(c) {
+  const r6 = Math.min(c.w, c.h) / 2 - 0.02;
+  const cx = c.w / 2;
+  const cy = c.h / 2;
+  const parts = [
+    circle({ class: "sx-fp-furn", cx: c.px(cx), cy: c.px(cy), r: c.px(r6) }),
+    circle({ class: "sx-fp-furn-line", cx: c.px(cx), cy: c.px(cy), r: c.px(0.08) })
+  ];
+  for (let i = 0; i < 12; i++) {
+    const a = i / 12 * 2 * Math.PI;
+    parts.push(
+      line({
+        class: "sx-fp-furn-line",
+        x1: c.px(cx + 0.08 * Math.cos(a)),
+        y1: c.px(cy + 0.08 * Math.sin(a)),
+        x2: c.px(cx + r6 * Math.cos(a)),
+        y2: c.px(cy + r6 * Math.sin(a))
+      })
+    );
+  }
+  const wr = r6 * 0.62;
+  const a0 = Math.PI * 0.75;
+  const a1 = Math.PI * 1.9;
+  const steps = 5;
+  const pts = [];
+  for (let i = 0; i <= steps; i++) {
+    const a = a0 + (a1 - a0) * i / steps;
+    pts.push([cx + wr * Math.cos(a), cy + wr * Math.sin(a)]);
+  }
+  parts.push(dirArrow(c, pts, c.label ?? "UP"));
+  return parts.join("");
+}
+var FLOORPLAN_SYMBOLS = {
+  // ── residential / living ──
+  "bed-double": { w: 1.6, h: 2, draw: bedDraw(2) },
+  "bed-single": { w: 0.9, h: 2, draw: bedDraw(1) },
+  "bed-queen": { w: 1.55, h: 2.05, draw: bedDraw(2) },
+  "bed-king": { w: 1.95, h: 2.05, draw: bedDraw(2) },
+  sofa: { w: 2.2, h: 0.9, draw: sofaDraw(3) },
+  loveseat: { w: 1.5, h: 0.9, draw: sofaDraw(2) },
+  armchair: { w: 0.9, h: 0.9, draw: sofaDraw(1) },
+  "coffee-table": { w: 1, h: 0.5, draw: (c) => box(c, "sx-fp-furn", 0.06) },
+  tv: { w: 1.4, h: 0.15, draw: (c) => rect({ class: "sx-fp-furn-solid", x: 0, y: 0, width: c.px(c.w), height: c.px(c.h) }) },
+  rug: {
+    w: 2,
+    h: 1.4,
+    underlay: true,
+    draw: (c) => rect({ class: "sx-fp-rug", x: 0, y: 0, width: c.px(c.w), height: c.px(c.h), rx: c.px(0.1) })
+  },
+  wardrobe: {
+    w: 1.8,
+    h: 0.6,
+    draw: (c) => {
+      const parts = [box(c)];
+      if (c.w >= c.h) {
+        parts.push(line({ class: "sx-fp-furn-line", x1: 0, y1: c.px(c.h / 2), x2: c.px(c.w), y2: c.px(c.h / 2) }));
+        const n = Math.max(2, Math.round(c.w / 0.15));
+        for (let i = 0; i < n; i++) {
+          const x = c.px((i + 0.5) / n * c.w);
+          parts.push(line({ class: "sx-fp-furn-line", x1: x, y1: c.px(c.h / 2 - 0.1), x2: x, y2: c.px(c.h / 2 + 0.1) }));
+        }
+      } else {
+        parts.push(line({ class: "sx-fp-furn-line", x1: c.px(c.w / 2), y1: 0, x2: c.px(c.w / 2), y2: c.px(c.h) }));
+        const n = Math.max(2, Math.round(c.h / 0.15));
+        for (let i = 0; i < n; i++) {
+          const y = c.px((i + 0.5) / n * c.h);
+          parts.push(line({ class: "sx-fp-furn-line", x1: c.px(c.w / 2 - 0.1), y1: y, x2: c.px(c.w / 2 + 0.1), y2: y }));
+        }
+      }
+      return parts.join("");
+    }
+  },
+  dresser: {
+    w: 1.2,
+    h: 0.5,
+    draw: (c) => [
+      box(c),
+      line({ class: "sx-fp-furn-line", x1: 0, y1: c.px(c.h / 2), x2: c.px(c.w), y2: c.px(c.h / 2) }),
+      circle({ class: "sx-fp-furn-line", cx: c.px(c.w * 0.3), cy: c.px(c.h * 0.25), r: c.px(0.03) }),
+      circle({ class: "sx-fp-furn-line", cx: c.px(c.w * 0.7), cy: c.px(c.h * 0.25), r: c.px(0.03) })
+    ].join("")
+  },
+  nightstand: {
+    w: 0.5,
+    h: 0.4,
+    draw: (c) => box(c) + circle({ class: "sx-fp-furn-line", cx: c.px(c.w / 2), cy: c.px(c.h / 2), r: c.px(0.08) })
+  },
+  bookshelf: { w: 0.9, h: 0.3, draw: shelfDraw },
+  plant: {
+    w: 0.5,
+    h: 0.5,
+    draw: (c) => {
+      const r6 = Math.min(c.w, c.h) / 2;
+      const parts = [circle({ class: "sx-fp-furn", cx: c.px(c.w / 2), cy: c.px(c.h / 2), r: c.px(r6) })];
+      for (const a of [0, 60, 120, 180, 240, 300]) {
+        const rad = a * Math.PI / 180;
+        parts.push(
+          line({
+            class: "sx-fp-furn-line",
+            x1: c.px(c.w / 2),
+            y1: c.px(c.h / 2),
+            x2: c.px(c.w / 2 + (r6 - 0.03) * Math.cos(rad)),
+            y2: c.px(c.h / 2 + (r6 - 0.03) * Math.sin(rad))
+          })
+        );
+      }
+      return parts.join("");
+    }
+  },
+  "dining-table": { w: 1.6, h: 0.9, envelope: [CHAIR_OVERHANG, 0, CHAIR_OVERHANG, 0], draw: tableDraw(true) },
+  sectional: {
+    w: 2.6,
+    h: 2,
+    draw: (c) => {
+      const d = 0.9 * Math.min(c.h / 2, 1);
+      const parts = [
+        path({
+          class: "sx-fp-furn",
+          d: `M 0 0 L ${c.px(c.w)} 0 L ${c.px(c.w)} ${c.px(d)} L ${c.px(d)} ${c.px(d)} L ${c.px(d)} ${c.px(c.h)} L 0 ${c.px(c.h)} Z`
+        }),
+        rect({ class: "sx-fp-furn", x: c.px(0.12), y: 0, width: c.px(c.w - 0.24), height: c.px(0.16), rx: c.px(0.05) }),
+        rect({ class: "sx-fp-furn", x: 0, y: c.px(0.12), width: c.px(0.16), height: c.px(c.h - 0.24), rx: c.px(0.05) })
+      ];
+      for (const fx of [0.33, 0.66]) {
+        parts.push(line({ class: "sx-fp-furn-line", x1: c.px(d + (c.w - d) * fx), y1: c.px(0.16), x2: c.px(d + (c.w - d) * fx), y2: c.px(d - 0.05) }));
+      }
+      parts.push(line({ class: "sx-fp-furn-line", x1: c.px(0.16), y1: c.px(c.h / 2 + d / 4), x2: c.px(d - 0.05), y2: c.px(c.h / 2 + d / 4) }));
+      return parts.join("");
+    }
+  },
+  "side-table": { w: 0.5, h: 0.5, draw: (c) => box(c, "sx-fp-furn", 0.06) },
+  "tv-stand": {
+    w: 1.6,
+    h: 0.45,
+    underlay: true,
+    // a surface — the TV sits on it
+    draw: (c) => box(c) + line({ class: "sx-fp-furn-line", x1: 0, y1: c.px(c.h / 2), x2: c.px(c.w), y2: c.px(c.h / 2) })
+  },
+  fireplace: {
+    w: 1.5,
+    h: 0.5,
+    draw: (c) => {
+      const inset = Math.min(0.18, c.w * 0.15);
+      return [
+        box(c),
+        // firebox opening toward the room (south edge)
+        rect({
+          class: "sx-fp-furn-line",
+          x: c.px(inset),
+          y: c.px(c.h * 0.3),
+          width: c.px(c.w - 2 * inset),
+          height: c.px(c.h * 0.7 - 0.04)
+        }),
+        line({ class: "sx-fp-furn-line", x1: 0, y1: c.px(c.h * 0.3), x2: c.px(inset), y2: 0 }),
+        line({ class: "sx-fp-furn-line", x1: c.px(c.w), y1: c.px(c.h * 0.3), x2: c.px(c.w - inset), y2: 0 })
+      ].join("");
+    }
+  },
+  "floor-lamp": {
+    w: 0.35,
+    h: 0.35,
+    draw: (c) => {
+      const r6 = Math.min(c.w, c.h) / 2;
+      return [
+        circle({ class: "sx-fp-furn", cx: c.px(c.w / 2), cy: c.px(c.h / 2), r: c.px(r6) }),
+        line({ class: "sx-fp-furn-line", x1: c.px(c.w / 2 - r6), y1: c.px(c.h / 2), x2: c.px(c.w / 2 + r6), y2: c.px(c.h / 2) }),
+        line({ class: "sx-fp-furn-line", x1: c.px(c.w / 2), y1: c.px(c.h / 2 - r6), x2: c.px(c.w / 2), y2: c.px(c.h / 2 + r6) })
+      ].join("");
+    }
+  },
+  ottoman: { w: 0.6, h: 0.45, draw: (c) => box(c, "sx-fp-furn", 0.12) },
+  piano: {
+    w: 1.5,
+    h: 1.7,
+    draw: (c) => {
+      const X = (v) => c.px(v * (c.w / 1.5));
+      const Y = (v) => c.px(v * (c.h / 1.7));
+      const body = [
+        `M ${X(0)} ${Y(0)}`,
+        `L ${X(1.5)} ${Y(0)}`,
+        `L ${X(1.5)} ${Y(0.75)}`,
+        `C ${X(1.5)} ${Y(1.25)} ${X(1.25)} ${Y(1.7)} ${X(0.8)} ${Y(1.7)}`,
+        `C ${X(0.45)} ${Y(1.7)} ${X(0.28)} ${Y(1.45)} ${X(0.28)} ${Y(1.1)}`,
+        `C ${X(0.28)} ${Y(0.85)} ${X(0.14)} ${Y(0.72)} ${X(0)} ${Y(0.68)}`,
+        "Z"
+      ].join(" ");
+      return path({ class: "sx-fp-furn", d: body }) + line({ class: "sx-fp-furn-line", x1: X(0), y1: Y(0.14), x2: X(1.5), y2: Y(0.14) }) + chairAt(c.px, c.w / 1.5 * 0.75, -0.25, 180);
+    },
+    envelope: [CHAIR_OVERHANG, 0, 0, 0]
+  },
+  "piano-upright": {
+    w: 1.5,
+    h: 0.6,
+    envelope: [0, 0, CHAIR_OVERHANG, 0],
+    draw: (c) => box(c) + line({ class: "sx-fp-furn-line", x1: 0, y1: c.px(c.h * 0.55), x2: c.px(c.w), y2: c.px(c.h * 0.55) }) + chairAt(c.px, c.w / 2, c.h + CHAIR_GAP, 180)
+  },
+  "pool-table": {
+    w: 2.54,
+    h: 1.27,
+    draw: (c) => {
+      const rail = Math.min(0.12, c.h * 0.1);
+      const parts = [
+        box(c, "sx-fp-furn", 0.06),
+        rect({ class: "sx-fp-furn-line", x: c.px(rail), y: c.px(rail), width: c.px(c.w - 2 * rail), height: c.px(c.h - 2 * rail) })
+      ];
+      for (const [px0, py0] of [
+        [rail, rail],
+        [c.w / 2, rail],
+        [c.w - rail, rail],
+        [rail, c.h - rail],
+        [c.w / 2, c.h - rail],
+        [c.w - rail, c.h - rail]
+      ]) {
+        parts.push(circle({ class: "sx-fp-furn-dot", cx: c.px(px0), cy: c.px(py0), r: c.px(0.045) }));
+      }
+      return parts.join("");
+    }
+  },
+  crib: {
+    w: 0.7,
+    h: 1.3,
+    draw: (c) => {
+      const parts = [box(c, "sx-fp-furn", 0.05), rect({ class: "sx-fp-furn-line", x: c.px(0.08), y: c.px(0.08), width: c.px(c.w - 0.16), height: c.px(c.h - 0.16), rx: c.px(0.04) })];
+      const n = Math.max(3, Math.round(c.h / 0.18));
+      for (let i = 1; i < n; i++) {
+        const y = c.px(0.08 + (c.h - 0.16) * i / n);
+        parts.push(line({ class: "sx-fp-furn-line", x1: c.px(0.08), y1: y, x2: c.px(c.w - 0.08), y2: y }));
+      }
+      return parts.join("");
+    }
+  },
+  "bunk-bed": {
+    w: 0.95,
+    h: 2,
+    draw: (c) => bedDraw(1)(c) + line({ class: "sx-fp-furn-dash", x1: c.px(0.07), y1: c.px(0.07), x2: c.px(c.w - 0.07), y2: c.px(0.07) }) + [0.25, 0.45, 0.65].map((f) => line({ class: "sx-fp-furn-line", x1: c.px(c.w - 0.16), y1: c.px(c.h * f), x2: c.px(c.w), y2: c.px(c.h * f) })).join("")
+  },
+  "ceiling-fan": {
+    w: 0.9,
+    h: 0.9,
+    underlay: true,
+    // overhead fixture — never collides with floor furniture
+    draw: (c) => {
+      const r6 = Math.min(c.w, c.h) / 2;
+      const cx = c.w / 2;
+      const cy = c.h / 2;
+      const parts = [
+        circle({ class: "sx-fp-furn-dash", cx: c.px(cx), cy: c.px(cy), r: c.px(r6) }),
+        circle({ class: "sx-fp-furn", cx: c.px(cx), cy: c.px(cy), r: c.px(r6 * 0.18) })
+      ];
+      for (const a of [20, 110, 200, 290]) {
+        const rad = a * Math.PI / 180;
+        parts.push(
+          el("ellipse", {
+            class: "sx-fp-furn-line",
+            cx: c.px(cx + r6 * 0.55 * Math.cos(rad)),
+            cy: c.px(cy + r6 * 0.55 * Math.sin(rad)),
+            rx: c.px(r6 * 0.42),
+            ry: c.px(r6 * 0.15),
+            transform: `rotate(${a} ${c.px(cx + r6 * 0.55 * Math.cos(rad))} ${c.px(cy + r6 * 0.55 * Math.sin(rad))})`
+          })
+        );
+      }
+      return parts.join("");
+    }
+  },
+  // ── kitchen / bath ──
+  counter: {
+    w: 2,
+    h: 0.6,
+    underlay: true,
+    draw: (c) => box(c) + line({
+      class: "sx-fp-furn-dash",
+      x1: c.px(0.05),
+      y1: c.px(c.h - 0.06),
+      x2: c.px(c.w - 0.05),
+      y2: c.px(c.h - 0.06)
+    })
+  },
+  "kitchen-sink": {
+    w: 0.8,
+    h: 0.6,
+    draw: (c) => [
+      box(c),
+      rect({ class: "sx-fp-furn-line", x: c.px(0.07), y: c.px(0.1), width: c.px(c.w / 2 - 0.11), height: c.px(c.h - 0.2), rx: c.px(0.04) }),
+      rect({ class: "sx-fp-furn-line", x: c.px(c.w / 2 + 0.04), y: c.px(0.1), width: c.px(c.w / 2 - 0.11), height: c.px(c.h - 0.2), rx: c.px(0.04) }),
+      circle({ class: "sx-fp-furn-dot", cx: c.px(c.w / 2), cy: c.px(0.06), r: c.px(0.024) })
+    ].join("")
+  },
+  stove: {
+    w: 0.6,
+    h: 0.6,
+    draw: (c) => {
+      const parts = [box(c)];
+      const inset = 0.18;
+      for (const [bx, by] of [
+        [inset, inset],
+        [c.w - inset, inset],
+        [inset, c.h - inset],
+        [c.w - inset, c.h - inset]
+      ]) {
+        parts.push(circle({ class: "sx-fp-furn-line", cx: c.px(bx), cy: c.px(by), r: c.px(0.085) }));
+      }
+      return parts.join("");
+    }
+  },
+  fridge: { w: 0.7, h: 0.7, draw: applianceDraw("REF", false) },
+  dishwasher: { w: 0.6, h: 0.6, draw: applianceDraw("DW", false) },
+  island: {
+    w: 1.8,
+    h: 0.9,
+    underlay: true,
+    draw: (c) => box(c) + rect({ class: "sx-fp-furn-line", x: c.px(0.08), y: c.px(0.08), width: c.px(c.w - 0.16), height: c.px(c.h - 0.16) })
+  },
+  toilet: {
+    w: 0.5,
+    h: 0.7,
+    draw: (c) => [
+      rect({ class: "sx-fp-furn", x: 0, y: 0, width: c.px(c.w), height: c.px(0.2), rx: c.px(0.04) }),
+      el("ellipse", {
+        class: "sx-fp-furn",
+        cx: c.px(c.w / 2),
+        cy: c.px(0.2 + (c.h - 0.24) / 2),
+        rx: c.px(c.w / 2 - 0.04),
+        ry: c.px((c.h - 0.28) / 2)
+      })
+    ].join("")
+  },
+  sink: {
+    w: 0.55,
+    h: 0.45,
+    draw: (c) => [
+      box(c, "sx-fp-furn", 0.05),
+      el("ellipse", {
+        class: "sx-fp-furn-line",
+        cx: c.px(c.w / 2),
+        cy: c.px(c.h / 2 + 0.02),
+        rx: c.px(c.w / 2 - 0.08),
+        ry: c.px(c.h / 2 - 0.1)
+      }),
+      circle({ class: "sx-fp-furn-dot", cx: c.px(c.w / 2), cy: c.px(0.07), r: c.px(0.024) })
+    ].join("")
+  },
+  bathtub: {
+    w: 0.8,
+    h: 1.7,
+    draw: (c) => [
+      box(c, "sx-fp-furn", 0.08),
+      rect({ class: "sx-fp-furn-line", x: c.px(0.09), y: c.px(0.09), width: c.px(c.w - 0.18), height: c.px(c.h - 0.18), rx: c.px(0.22) }),
+      circle({ class: "sx-fp-furn-dot", cx: c.px(c.w / 2), cy: c.px(0.26), r: c.px(0.035) })
+    ].join("")
+  },
+  shower: {
+    w: 0.9,
+    h: 0.9,
+    draw: (c) => [
+      box(c),
+      line({ class: "sx-fp-furn-line", x1: 0, y1: 0, x2: c.px(c.w), y2: c.px(c.h) }),
+      line({ class: "sx-fp-furn-line", x1: c.px(c.w), y1: 0, x2: 0, y2: c.px(c.h) }),
+      circle({ class: "sx-fp-furn", cx: c.px(0.15), cy: c.px(0.15), r: c.px(0.06) })
+    ].join("")
+  },
+  washer: { w: 0.6, h: 0.6, draw: applianceDraw("W", true) },
+  dryer: { w: 0.6, h: 0.6, draw: applianceDraw("D", true) },
+  "wall-cabinet": {
+    w: 0.9,
+    h: 0.35,
+    underlay: true,
+    // above the cut plane — drawn dashed over the base run
+    draw: (c) => rect({ class: "sx-fp-furn-dash", x: 0, y: 0, width: c.px(c.w), height: c.px(c.h) })
+  },
+  "range-hood": {
+    w: 0.8,
+    h: 0.55,
+    underlay: true,
+    // above the cut plane
+    draw: (c) => el("g", {}, [
+      polygon({
+        class: "sx-fp-furn-dash",
+        points: `${c.px(0.08)},0 ${c.px(c.w - 0.08)},0 ${c.px(c.w)},${c.px(c.h)} 0,${c.px(c.h)}`
+      })
+    ])
+  },
+  "bar-stool": {
+    w: 0.35,
+    h: 0.35,
+    draw: (c) => circle({ class: "sx-fp-chair", cx: c.px(c.w / 2), cy: c.px(c.h / 2), r: c.px(Math.min(c.w, c.h) / 2) })
+  },
+  vanity: {
+    w: 1.5,
+    h: 0.55,
+    draw: (c) => {
+      const parts = [box(c)];
+      for (const fx of [0.27, 0.73]) {
+        parts.push(
+          el("ellipse", {
+            class: "sx-fp-furn-line",
+            cx: c.px(c.w * fx),
+            cy: c.px(c.h / 2 + 0.02),
+            rx: c.px(Math.min(0.22, c.w * 0.16)),
+            ry: c.px(c.h / 2 - 0.12)
+          })
+        );
+        parts.push(circle({ class: "sx-fp-furn-dot", cx: c.px(c.w * fx), cy: c.px(0.07), r: c.px(0.022) }));
+      }
+      return parts.join("");
+    }
+  },
+  bidet: {
+    w: 0.4,
+    h: 0.6,
+    draw: (c) => rect({ class: "sx-fp-furn", x: c.px(c.w * 0.15), y: 0, width: c.px(c.w * 0.7), height: c.px(0.12), rx: c.px(0.03) }) + el("ellipse", {
+      class: "sx-fp-furn",
+      cx: c.px(c.w / 2),
+      cy: c.px(0.12 + (c.h - 0.16) / 2),
+      rx: c.px(c.w / 2 - 0.03),
+      ry: c.px((c.h - 0.18) / 2)
+    }) + circle({ class: "sx-fp-furn-line", cx: c.px(c.w / 2), cy: c.px(c.h * 0.45), r: c.px(0.035) })
+  },
+  urinal: {
+    w: 0.4,
+    h: 0.35,
+    draw: (c) => rect({ class: "sx-fp-furn", x: 0, y: 0, width: c.px(c.w), height: c.px(0.08) }) + path({
+      class: "sx-fp-furn",
+      d: `M ${c.px(0.05)} ${c.px(0.08)} L ${c.px(c.w - 0.05)} ${c.px(0.08)} C ${c.px(c.w - 0.05)} ${c.px(c.h * 0.75)} ${c.px(c.w * 0.7)} ${c.px(c.h)} ${c.px(c.w / 2)} ${c.px(c.h)} C ${c.px(c.w * 0.3)} ${c.px(c.h)} ${c.px(0.05)} ${c.px(c.h * 0.75)} ${c.px(0.05)} ${c.px(0.08)} Z`
+    })
+  },
+  // ── stairs & vertical circulation ──
+  stairs: { w: 1, h: 3, consumesLabel: true, draw: straightStairs },
+  "stairs-l": { w: 2.2, h: 2.2, consumesLabel: true, draw: lStairs },
+  "stairs-u": { w: 2, h: 3, consumesLabel: true, draw: uStairs },
+  "spiral-stairs": { w: 1.5, h: 1.5, consumesLabel: true, draw: spiralStairs },
+  elevator: {
+    w: 1.6,
+    h: 1.5,
+    draw: (c) => box(c) + line({ class: "sx-fp-furn-line", x1: 0, y1: 0, x2: c.px(c.w), y2: c.px(c.h) }) + line({ class: "sx-fp-furn-line", x1: c.px(c.w), y1: 0, x2: 0, y2: c.px(c.h) })
+  },
+  // ── structural ──
+  column: {
+    w: 0.4,
+    h: 0.4,
+    draw: (c) => rect({ class: "sx-fp-furn-solid", x: 0, y: 0, width: c.px(c.w), height: c.px(c.h) })
+  },
+  // ── classroom / office ──
+  "desk-chair": {
+    w: 0.6,
+    h: 0.75,
+    draw: (c) => [
+      rect({ class: "sx-fp-furn", x: 0, y: 0, width: c.px(c.w), height: c.px(c.h * 0.58) }),
+      rect({
+        class: "sx-fp-chair",
+        x: c.px(c.w / 2 - c.w * 0.3),
+        y: c.px(c.h * 0.66),
+        width: c.px(c.w * 0.6),
+        height: c.px(c.h * 0.32),
+        rx: c.px(0.07)
+      })
+    ].join("")
+  },
+  desk: {
+    w: 1.4,
+    h: 0.7,
+    envelope: [0, 0, CHAIR_OVERHANG, 0],
+    draw: (c) => box(c) + chairAt(c.px, c.w / 2, c.h + CHAIR_GAP, 180)
+  },
+  chair: {
+    w: 0.45,
+    h: 0.45,
+    draw: (c) => rect({ class: "sx-fp-chair", x: 0, y: 0, width: c.px(c.w), height: c.px(c.h), rx: c.px(0.1) }) + line({ class: "sx-fp-furn-line", x1: 0, y1: c.px(0.06), x2: 0, y2: c.px(c.h - 0.06) })
+  },
+  whiteboard: { w: 3, h: 0.12, draw: boardDraw },
+  smartboard: { w: 2, h: 0.12, draw: boardDraw },
+  bookcase: { w: 0.9, h: 0.3, draw: shelfDraw },
+  "desk-l": {
+    w: 1.6,
+    h: 1.6,
+    draw: (c) => {
+      const d = 0.7 * Math.min(c.w / 1.6, c.h / 1.6);
+      return path({
+        class: "sx-fp-furn",
+        d: `M 0 0 L ${c.px(c.w)} 0 L ${c.px(c.w)} ${c.px(d)} L ${c.px(d)} ${c.px(d)} L ${c.px(d)} ${c.px(c.h)} L 0 ${c.px(c.h)} Z`
+      }) + chairAt(c.px, d + 0.32, d + 0.32, 315);
+    }
+  },
+  "filing-cabinet": {
+    w: 0.5,
+    h: 0.6,
+    draw: (c) => box(c) + line({ class: "sx-fp-furn-line", x1: 0, y1: c.px(c.h / 3), x2: c.px(c.w), y2: c.px(c.h / 3) }) + line({ class: "sx-fp-furn-line", x1: 0, y1: c.px(2 * c.h / 3), x2: c.px(c.w), y2: c.px(2 * c.h / 3) })
+  },
+  lockers: {
+    w: 1.8,
+    h: 0.45,
+    draw: (c) => {
+      const parts = [box(c)];
+      const n = Math.max(2, Math.round(c.w / 0.3));
+      for (let i = 1; i < n; i++) {
+        const x = c.px(c.w * i / n);
+        parts.push(line({ class: "sx-fp-furn-line", x1: x, y1: 0, x2: x, y2: c.px(c.h) }));
+      }
+      for (let i = 0; i < n; i++) {
+        parts.push(circle({ class: "sx-fp-furn-dot", cx: c.px((i + 0.78) / n * c.w), cy: c.px(c.h / 2), r: c.px(0.02) }));
+      }
+      return parts.join("");
+    }
+  },
+  cubbies: {
+    w: 2,
+    h: 0.4,
+    draw: (c) => {
+      const parts = [box(c)];
+      const n = Math.max(2, Math.round(c.w / 0.3));
+      for (let i = 1; i < n; i++) {
+        const x = c.px(c.w * i / n);
+        parts.push(line({ class: "sx-fp-furn-line", x1: x, y1: 0, x2: x, y2: c.px(c.h) }));
+      }
+      return parts.join("");
+    }
+  },
+  "kidney-table": {
+    w: 1.8,
+    h: 1.2,
+    draw: (c) => {
+      const sx = c.w / 1.8;
+      const sy = c.h / 1.2;
+      const X = (v) => c.px(v * sx);
+      const Y = (v) => c.px(v * sy);
+      const d = [
+        `M ${X(0)} ${Y(0.55)}`,
+        `C ${X(0)} ${Y(0.15)} ${X(0.35)} ${Y(0)} ${X(0.9)} ${Y(0)}`,
+        `C ${X(1.45)} ${Y(0)} ${X(1.8)} ${Y(0.15)} ${X(1.8)} ${Y(0.55)}`,
+        `C ${X(1.8)} ${Y(0.95)} ${X(1.5)} ${Y(1.2)} ${X(1.18)} ${Y(1.2)}`,
+        `Q ${X(0.9)} ${Y(0.82)} ${X(0.62)} ${Y(1.2)}`,
+        `C ${X(0.3)} ${Y(1.2)} ${X(0)} ${Y(0.95)} ${X(0)} ${Y(0.55)}`,
+        "Z"
+      ].join(" ");
+      return path({ class: "sx-fp-furn", d });
+    }
+  },
+  "round-table-4": roundTable(4, 1.52),
+  "round-table-6": roundTable(6, 1.52),
+  "round-table-8": roundTable(8, 1.52),
+  "round-table-10": roundTable(10, 1.83),
+  "conference-table": { w: 2.4, h: 1.2, envelope: [CHAIR_OVERHANG, 0, CHAIR_OVERHANG, 0], draw: tableDraw(true) },
+  // ── event / banquet ──
+  "banquet-table": { w: 2.44, h: 0.76, envelope: [CHAIR_OVERHANG, 0, CHAIR_OVERHANG, 0], draw: tableDraw(true) },
+  "head-table": { w: 3.7, h: 0.76, envelope: [0, 0, CHAIR_OVERHANG, 0], draw: tableDraw(false) },
+  stage: {
+    w: 4,
+    h: 2,
+    draw: (c) => box(c) + rect({
+      class: "sx-fp-furn-dash",
+      x: c.px(0.1),
+      y: c.px(0.1),
+      width: c.px(c.w - 0.2),
+      height: c.px(c.h - 0.2)
+    })
+  },
+  "dance-floor": {
+    w: 4,
+    h: 4,
+    underlay: true,
+    draw: (c) => {
+      const parts = [];
+      for (let d = 0.5; d < c.w + c.h; d += 0.5) {
+        const x1 = Math.max(0, d - c.h);
+        const y1 = Math.min(d, c.h);
+        const x2 = Math.min(d, c.w);
+        const y2 = Math.max(0, d - c.w);
+        parts.push(line({ class: "sx-fp-hatch", x1: c.px(x1), y1: c.px(y1), x2: c.px(x2), y2: c.px(y2) }));
+      }
+      parts.push(rect({ class: "sx-fp-furn-nofill", x: 0, y: 0, width: c.px(c.w), height: c.px(c.h) }));
+      return parts.join("");
+    }
+  },
+  bar: {
+    w: 3,
+    h: 0.7,
+    draw: (c) => box(c) + line({ class: "sx-fp-furn-line", x1: 0, y1: c.px(c.h - 0.15), x2: c.px(c.w), y2: c.px(c.h - 0.15) })
+  },
+  "dj-booth": { w: 1.2, h: 0.8, draw: (c) => box(c) + glyphText(c, "DJ") },
+  "cocktail-table": {
+    w: 0.76,
+    h: 0.76,
+    draw: (c) => circle({ class: "sx-fp-furn", cx: c.px(c.w / 2), cy: c.px(c.h / 2), r: c.px(Math.min(c.w, c.h) / 2) }) + circle({ class: "sx-fp-furn-line", cx: c.px(c.w / 2), cy: c.px(c.h / 2), r: c.px(Math.min(c.w, c.h) / 6) })
+  },
+  podium: {
+    w: 0.6,
+    h: 0.5,
+    draw: (c) => polygon({
+      class: "sx-fp-furn",
+      points: `${c.px(c.w * 0.15)},0 ${c.px(c.w * 0.85)},0 ${c.px(c.w)},${c.px(c.h)} 0,${c.px(c.h)}`
+    })
+  },
+  "row-chairs": {
+    w: 2.2,
+    h: 0.5,
+    draw: (c) => {
+      const n = Math.max(1, Math.floor(c.w / 0.55 + 1e-6));
+      const parts = [];
+      for (let i = 0; i < n; i++) {
+        parts.push(chairAt(c.px, (i + 0.5) / n * c.w, c.h / 2, 0));
+      }
+      return parts.join("");
+    }
+  },
+  // ── retail ──
+  // Gondola run: a long fixture with a back-to-back spine and product bays.
+  shelving: {
+    w: 1.8,
+    h: 0.6,
+    draw: (c) => {
+      const parts = [box(c)];
+      parts.push(line({ class: "sx-fp-furn-line", x1: 0, y1: c.px(c.h / 2), x2: c.px(c.w), y2: c.px(c.h / 2) }));
+      const n = Math.max(2, Math.round(c.w / 0.45));
+      for (let i = 1; i < n; i++) {
+        const x = c.px(c.w * i / n);
+        parts.push(line({ class: "sx-fp-furn-line", x1: x, y1: 0, x2: x, y2: c.px(c.h) }));
+      }
+      return parts.join("");
+    }
+  },
+  // POS counter with a register block and a belt line.
+  checkout: {
+    w: 1.6,
+    h: 0.7,
+    draw: (c) => [
+      box(c),
+      rect({ class: "sx-fp-furn-solid", x: c.px(c.w - 0.5), y: c.px(0.12), width: c.px(0.34), height: c.px(0.3), rx: c.px(0.04) }),
+      line({ class: "sx-fp-furn-line", x1: c.px(0.12), y1: c.px(c.h * 0.6), x2: c.px(c.w - 0.62), y2: c.px(c.h * 0.6) })
+    ].join("")
+  },
+  // Round garment rack: rail circle with radial hanger ticks.
+  "clothing-rack": {
+    w: 1,
+    h: 1,
+    draw: (c) => {
+      const r6 = Math.min(c.w, c.h) / 2;
+      const cx = c.w / 2;
+      const cy = c.h / 2;
+      const parts = [
+        circle({ class: "sx-fp-furn-nofill", cx: c.px(cx), cy: c.px(cy), r: c.px(r6) }),
+        circle({ class: "sx-fp-furn-dot", cx: c.px(cx), cy: c.px(cy), r: c.px(0.04) })
+      ];
+      for (const a of [0, 45, 90, 135, 180, 225, 270, 315]) {
+        const rad = a * Math.PI / 180;
+        parts.push(
+          line({
+            class: "sx-fp-furn-line",
+            x1: c.px(cx + (r6 - 0.09) * Math.cos(rad)),
+            y1: c.px(cy + (r6 - 0.09) * Math.sin(rad)),
+            x2: c.px(cx + r6 * Math.cos(rad)),
+            y2: c.px(cy + r6 * Math.sin(rad))
+          })
+        );
+      }
+      return parts.join("");
+    }
+  },
+  // Changing booth: bench at the back, a mirror strip, a dashed curtain at the opening.
+  "fitting-room": {
+    w: 1.1,
+    h: 1.1,
+    draw: (c) => [
+      rect({ class: "sx-fp-furn-nofill", x: 0, y: 0, width: c.px(c.w), height: c.px(c.h) }),
+      rect({ class: "sx-fp-furn", x: c.px(0.12), y: c.px(0.12), width: c.px(c.w - 0.24), height: c.px(0.28), rx: c.px(0.04) }),
+      line({ class: "sx-fp-furn-dash", x1: 0, y1: c.px(c.h), x2: c.px(c.w), y2: c.px(c.h) }),
+      rect({ class: "sx-fp-furn-solid", x: c.px(c.w - 0.06), y: c.px(c.h * 0.5), width: c.px(0.04), height: c.px(c.h * 0.35) })
+    ].join("")
+  },
+  // ── warehouse / industrial ──
+  // Pallet racking: an open frame with bay dividers and cross-bracing.
+  "pallet-rack": {
+    w: 2.7,
+    h: 1.1,
+    draw: (c) => {
+      const parts = [rect({ class: "sx-fp-furn-nofill", x: 0, y: 0, width: c.px(c.w), height: c.px(c.h) })];
+      const bays = Math.max(2, Math.round(c.w / 1.35));
+      for (let i = 0; i < bays; i++) {
+        const x0 = c.w * i / bays;
+        const x1 = c.w * (i + 1) / bays;
+        if (i > 0) parts.push(line({ class: "sx-fp-furn-line", x1: c.px(x0), y1: 0, x2: c.px(x0), y2: c.px(c.h) }));
+        parts.push(line({ class: "sx-fp-furn-line", x1: c.px(x0), y1: 0, x2: c.px(x1), y2: c.px(c.h) }));
+        parts.push(line({ class: "sx-fp-furn-line", x1: c.px(x1), y1: 0, x2: c.px(x0), y2: c.px(c.h) }));
+      }
+      return parts.join("");
+    }
+  },
+  // Dock door: roll-up door segments with two bumpers at the outer face.
+  "loading-dock": {
+    w: 3,
+    h: 0.6,
+    draw: (c) => {
+      const parts = [box(c)];
+      const n = Math.max(3, Math.round(c.w / 0.5));
+      for (let i = 1; i < n; i++) {
+        const x = c.px(c.w * i / n);
+        parts.push(line({ class: "sx-fp-furn-line", x1: x, y1: 0, x2: x, y2: c.px(c.h) }));
+      }
+      parts.push(rect({ class: "sx-fp-furn-solid", x: c.px(0.12), y: c.px(c.h - 0.12), width: c.px(0.3), height: c.px(0.1) }));
+      parts.push(rect({ class: "sx-fp-furn-solid", x: c.px(c.w - 0.42), y: c.px(c.h - 0.12), width: c.px(0.3), height: c.px(0.1) }));
+      return parts.join("");
+    }
+  },
+  // Counterbalance forklift silhouette: body, mast forks at the front, operator seat.
+  forklift: {
+    w: 1.2,
+    h: 2.2,
+    draw: (c) => [
+      rect({ class: "sx-fp-furn", x: c.px(0.15), y: c.px(0.42), width: c.px(c.w - 0.3), height: c.px(c.h - 0.72), rx: c.px(0.06) }),
+      rect({ class: "sx-fp-furn-solid", x: c.px(0.25), y: 0, width: c.px(0.12), height: c.px(0.42) }),
+      rect({ class: "sx-fp-furn-solid", x: c.px(c.w - 0.37), y: 0, width: c.px(0.12), height: c.px(0.42) }),
+      circle({ class: "sx-fp-furn-line", cx: c.px(c.w / 2), cy: c.px(c.h - 0.62), r: c.px(0.18) })
+    ].join("")
+  },
+  // ── salon / spa ──
+  // Styling station: back counter with a mirror strip and a chair facing it.
+  "salon-chair": {
+    w: 0.8,
+    h: 1.4,
+    draw: (c) => [
+      rect({ class: "sx-fp-furn", x: 0, y: 0, width: c.px(c.w), height: c.px(0.32), rx: c.px(0.03) }),
+      rect({ class: "sx-fp-furn-solid", x: c.px(0.08), y: c.px(0.05), width: c.px(c.w - 0.16), height: c.px(0.05) }),
+      circle({ class: "sx-fp-furn", cx: c.px(c.w / 2), cy: c.px(c.h * 0.64), r: c.px(Math.min(c.w, 0.62) / 2) }),
+      circle({ class: "sx-fp-furn-line", cx: c.px(c.w / 2), cy: c.px(c.h * 0.64), r: c.px(0.08) })
+    ].join("")
+  },
+  // Backwash unit: a reclining chair with a wash basin at the head end.
+  "shampoo-bowl": {
+    w: 0.9,
+    h: 1.5,
+    draw: (c) => [
+      rect({ class: "sx-fp-furn", x: c.px(0.1), y: c.px(0.5), width: c.px(c.w - 0.2), height: c.px(c.h - 0.6), rx: c.px(0.08) }),
+      circle({ class: "sx-fp-furn", cx: c.px(c.w / 2), cy: c.px(0.4), r: c.px(0.32) }),
+      circle({ class: "sx-fp-furn-line", cx: c.px(c.w / 2), cy: c.px(0.4), r: c.px(0.12) }),
+      circle({ class: "sx-fp-furn-dot", cx: c.px(c.w / 2), cy: c.px(0.12), r: c.px(0.04) })
+    ].join("")
+  },
+  // Manicure table: a small table with a client and a technician chair.
+  "manicure-table": {
+    w: 1,
+    h: 0.5,
+    envelope: [CHAIR_GAP + CHAIR_D, 0, CHAIR_GAP + CHAIR_D, 0],
+    draw: (c) => [box(c), chairAt(c.px, c.w / 2, -CHAIR_GAP, 0), chairAt(c.px, c.w / 2, c.h + CHAIR_GAP, 180)].join("")
+  },
+  // ── gym / fitness ──
+  // Treadmill: a deck with a running belt and a console at the front.
+  treadmill: {
+    w: 0.9,
+    h: 2,
+    draw: (c) => [
+      box(c, "sx-fp-furn", 0.05),
+      rect({ class: "sx-fp-furn-line", x: c.px(0.12), y: c.px(0.5), width: c.px(c.w - 0.24), height: c.px(c.h - 0.65), rx: c.px(0.04) }),
+      rect({ class: "sx-fp-furn-solid", x: c.px(0.1), y: c.px(0.08), width: c.px(c.w - 0.2), height: c.px(0.16), rx: c.px(0.03) })
+    ].join("")
+  },
+  // Flat bench with upright posts and a loaded barbell crossing it.
+  "weight-bench": {
+    w: 0.6,
+    h: 1.8,
+    envelope: [0, 0.35, 0, 0.35],
+    draw: (c) => [
+      rect({ class: "sx-fp-furn", x: c.px(c.w / 2 - 0.12), y: c.px(0.3), width: c.px(0.24), height: c.px(c.h - 0.4), rx: c.px(0.05) }),
+      rect({ class: "sx-fp-furn-solid", x: c.px(0.06), y: c.px(0.18), width: c.px(0.1), height: c.px(0.1) }),
+      rect({ class: "sx-fp-furn-solid", x: c.px(c.w - 0.16), y: c.px(0.18), width: c.px(0.1), height: c.px(0.1) }),
+      line({ class: "sx-fp-furn-line", x1: c.px(-0.3), y1: c.px(0.23), x2: c.px(c.w + 0.3), y2: c.px(0.23) })
+    ].join("")
+  },
+  // Power rack: a square frame with four corner posts and a barbell.
+  "power-rack": {
+    w: 1.4,
+    h: 1.4,
+    envelope: [0, 0.3, 0, 0.3],
+    draw: (c) => {
+      const post = 0.14;
+      const corners = [
+        [0, 0],
+        [c.w - post, 0],
+        [0, c.h - post],
+        [c.w - post, c.h - post]
+      ];
+      const parts = [rect({ class: "sx-fp-furn-nofill", x: 0, y: 0, width: c.px(c.w), height: c.px(c.h) })];
+      for (const [px0, py0] of corners) {
+        parts.push(rect({ class: "sx-fp-furn-solid", x: c.px(px0), y: c.px(py0), width: c.px(post), height: c.px(post) }));
+      }
+      parts.push(line({ class: "sx-fp-furn-line", x1: c.px(-0.28), y1: c.px(c.h * 0.4), x2: c.px(c.w + 0.28), y2: c.px(c.h * 0.4) }));
+      return parts.join("");
+    }
+  },
+  // Exercise mat — an underlay surface, like a rug.
+  "yoga-mat": {
+    w: 0.6,
+    h: 1.8,
+    underlay: true,
+    draw: (c) => rect({ class: "sx-fp-furn-dash", x: 0, y: 0, width: c.px(c.w), height: c.px(c.h), rx: c.px(0.08) })
+  },
+  // ── site / outdoor ──
+  // Tree in plan: a canopy disc with a foliage ring and a trunk dot.
+  tree: {
+    w: 2,
+    h: 2,
+    draw: (c) => {
+      const r6 = Math.min(c.w, c.h) / 2;
+      return [
+        circle({ class: "sx-fp-furn", cx: c.px(c.w / 2), cy: c.px(c.h / 2), r: c.px(r6) }),
+        circle({ class: "sx-fp-furn-line", cx: c.px(c.w / 2), cy: c.px(c.h / 2), r: c.px(r6 * 0.6) }),
+        circle({ class: "sx-fp-furn-dot", cx: c.px(c.w / 2), cy: c.px(c.h / 2), r: c.px(0.07) })
+      ].join("");
+    }
+  },
+  // Car in plan (parking-stall footprint): body, glazing lines, four wheels.
+  car: {
+    w: 1.8,
+    h: 4.4,
+    draw: (c) => {
+      const parts = [rect({ class: "sx-fp-furn", x: c.px(0.12), y: c.px(0.1), width: c.px(c.w - 0.24), height: c.px(c.h - 0.2), rx: c.px(0.35) })];
+      parts.push(line({ class: "sx-fp-furn-line", x1: c.px(0.3), y1: c.px(c.h * 0.26), x2: c.px(c.w - 0.3), y2: c.px(c.h * 0.26) }));
+      parts.push(line({ class: "sx-fp-furn-line", x1: c.px(0.3), y1: c.px(c.h * 0.72), x2: c.px(c.w - 0.3), y2: c.px(c.h * 0.72) }));
+      for (const wy of [c.h * 0.3, c.h * 0.7]) {
+        parts.push(rect({ class: "sx-fp-furn-solid", x: 0, y: c.px(wy - 0.18), width: c.px(0.14), height: c.px(0.36), rx: c.px(0.03) }));
+        parts.push(rect({ class: "sx-fp-furn-solid", x: c.px(c.w - 0.14), y: c.px(wy - 0.18), width: c.px(0.14), height: c.px(0.36), rx: c.px(0.03) }));
+      }
+      return parts.join("");
+    }
+  }
+};
+var FURNITURE_TYPES = Object.keys(FLOORPLAN_SYMBOLS);
+
+// src/diagrams/floorplan/parser.ts
+var FloorplanParseError = class extends Error {
+  line;
+  constructor(message, line2) {
+    super(`line ${line2}: ${message}`);
+    this.name = "FloorplanParseError";
+    this.line = line2;
+  }
+};
+var isStr = (t) => t !== void 0 && "str" in t;
+var isWord = (t, w) => t !== void 0 && "word" in t && (w === void 0 || t.word === w);
+function normalizeQuotes3(line2) {
+  return line2.replace(/[“”「」『』]/g, '"').replace(/[‘’]/g, "'");
+}
+function tokenize7(line2) {
+  const out = [];
+  const re = /"([^"]*)"|(\S+)/g;
+  let m;
+  while (m = re.exec(line2)) {
+    if (m[1] !== void 0) out.push({ str: m[1] });
+    else out.push({ word: m[2] });
+  }
+  return out;
+}
+function parseNum(t, what, ln) {
+  if (!isWord(t)) throw new FloorplanParseError(`expected a number for ${what}`, ln);
+  const v = Number(t.word);
+  if (!Number.isFinite(v)) throw new FloorplanParseError(`expected a number for ${what}, got "${t.word}"`, ln);
+  return v;
+}
+function parseCoord2(t, what, ln) {
+  if (!isWord(t)) throw new FloorplanParseError(`expected "x,y" for ${what}`, ln);
+  const m = /^(-?\d*\.?\d+),(-?\d*\.?\d+)$/.exec(t.word);
+  if (!m) throw new FloorplanParseError(`expected "x,y" for ${what}, got "${t.word}"`, ln);
+  return { x: Number(m[1]), y: Number(m[2]) };
+}
+function parseDims(t, what, ln) {
+  if (!isWord(t)) throw new FloorplanParseError(`expected "WxH" for ${what}`, ln);
+  const m = /^(\d*\.?\d+)x(\d*\.?\d+)$/i.exec(t.word);
+  if (!m) throw new FloorplanParseError(`expected "WxH" for ${what}, got "${t.word}"`, ln);
+  return { w: Number(m[1]), h: Number(m[2]) };
+}
+function parsePct(t, ln) {
+  if (!isWord(t)) throw new FloorplanParseError(`expected a percentage for "at"`, ln);
+  const v = Number(t.word.replace(/%$/, ""));
+  if (!Number.isFinite(v)) throw new FloorplanParseError(`expected a percentage for "at", got "${t.word}"`, ln);
+  return v;
+}
+function parseId(t, what, ln) {
+  if (!isWord(t)) throw new FloorplanParseError(`expected ${what}`, ln);
+  return t.word;
+}
+var SIDES = ["north", "south", "east", "west"];
+var REL_HOW = ["right-of", "left-of", "above", "below"];
+function parseFurnitureType(t, ln) {
+  const word = isWord(t) ? t.word : "";
+  if (!FURNITURE_TYPES.includes(word)) {
+    throw new FloorplanParseError(
+      `unknown furniture type "${word}". Valid types: ${FURNITURE_TYPES.join(", ")}`,
+      ln
+    );
+  }
+  return word;
+}
+function parseHeader3(tok, ast, ln) {
+  while (tok.length) {
+    const t = tok.shift();
+    if (isStr(t)) ast.title = t.str;
+    else if (t.word === "unit") {
+      const u = parseId(tok.shift(), "unit (m|ft)", ln);
+      if (u !== "m" && u !== "ft") throw new FloorplanParseError(`unit must be "m" or "ft", got "${u}"`, ln);
+      ast.unit = u;
+    } else throw new FloorplanParseError(`floorplan: unexpected token "${t.word}"`, ln);
+  }
+}
+function parseRoom(tok, ast, ln) {
+  const id = parseId(tok.shift(), "a room id", ln);
+  if (ast.rooms.some((r6) => r6.id === id)) {
+    throw new FloorplanParseError(`duplicate room id "${id}"`, ln);
+  }
+  const room = { id, label: id, w: 4, h: 3, line: ln };
+  while (tok.length) {
+    const t = tok.shift();
+    if (isStr(t)) room.label = t.str;
+    else if (t.word === "at") room.at = parseCoord2(tok.shift(), "at", ln);
+    else if (REL_HOW.includes(t.word)) {
+      room.rel = {
+        how: t.word,
+        ref: parseId(tok.shift(), `a room id after "${t.word}"`, ln),
+        offset: void 0,
+        align: void 0
+      };
+    } else if (t.word === "offset") {
+      if (!room.rel) throw new FloorplanParseError(`"offset" requires a relative placement (right-of/left-of/above/below)`, ln);
+      room.rel.offset = parseNum(tok.shift(), "offset", ln);
+    } else if (t.word === "align") {
+      if (!room.rel) throw new FloorplanParseError(`"align" requires a relative placement (right-of/left-of/above/below)`, ln);
+      const a = parseId(tok.shift(), "align (start|center|end)", ln);
+      if (a !== "start" && a !== "center" && a !== "end") {
+        throw new FloorplanParseError(`align must be start|center|end, got "${a}"`, ln);
+      }
+      room.rel.align = a;
+    } else if (t.word === "size") {
+      const d = parseDims(tok.shift(), "size", ln);
+      room.w = d.w;
+      room.h = d.h;
+    } else if (t.word === "fill") room.fill = parseId(tok.shift(), "a fill color", ln);
+    else if (t.word === "nolabel") room.nolabel = true;
+    else throw new FloorplanParseError(`room: unexpected token "${t.word}"`, ln);
+  }
+  ast.rooms.push(room);
+}
+function parseExtend(tok, ast, ln) {
+  const room = parseId(tok.shift(), "a room id", ln);
+  const ext = { room, w: 2, h: 2, line: ln };
+  while (tok.length) {
+    const t = tok.shift();
+    if (!isWord(t)) throw new FloorplanParseError(`extend: unexpected string "${t.str}"`, ln);
+    else if (t.word === "at") ext.at = parseCoord2(tok.shift(), "at", ln);
+    else if (REL_HOW.includes(t.word)) {
+      ext.rel = {
+        how: t.word,
+        ref: parseId(tok.shift(), `a room id after "${t.word}"`, ln),
+        offset: void 0,
+        align: void 0
+      };
+    } else if (t.word === "offset") {
+      if (!ext.rel) throw new FloorplanParseError(`"offset" requires a relative placement (right-of/left-of/above/below)`, ln);
+      ext.rel.offset = parseNum(tok.shift(), "offset", ln);
+    } else if (t.word === "align") {
+      if (!ext.rel) throw new FloorplanParseError(`"align" requires a relative placement (right-of/left-of/above/below)`, ln);
+      const a = parseId(tok.shift(), "align (start|center|end)", ln);
+      if (a !== "start" && a !== "center" && a !== "end") {
+        throw new FloorplanParseError(`align must be start|center|end, got "${a}"`, ln);
+      }
+      ext.rel.align = a;
+    } else if (t.word === "size") {
+      const d = parseDims(tok.shift(), "size", ln);
+      ext.w = d.w;
+      ext.h = d.h;
+    } else throw new FloorplanParseError(`extend: unexpected token "${t.word}"`, ln);
+  }
+  ast.extensions.push(ext);
+}
+var DOOR_TYPES = ["single", "double", "sliding", "pocket", "bifold"];
+var WINDOW_TYPES = ["fixed", "sliding", "casement", "bay"];
+function parseOpening(kind, tok, ast, ln) {
+  const op = {
+    kind,
+    pct: 50,
+    width: 0,
+    // resolved after the form is known
+    hinge: "left",
+    swing: "in",
+    doorType: "single",
+    windowType: "fixed",
+    line: ln
+  };
+  const t0 = tok.shift();
+  if (isWord(t0, "between")) {
+    op.between = [parseId(tok.shift(), "a room id", ln), parseId(tok.shift(), "a second room id", ln)];
+  } else {
+    op.room = parseId(t0, `a room id or "between"`, ln);
+    const side = parseId(tok.shift(), "a wall side", ln);
+    if (!SIDES.includes(side)) {
+      throw new FloorplanParseError(`expected a wall side north|south|east|west, got "${side}"`, ln);
+    }
+    op.side = side;
+  }
+  while (tok.length) {
+    const t = tok.shift();
+    if (!isWord(t)) throw new FloorplanParseError(`${kind}: unexpected string "${t.str}"`, ln);
+    else if (t.word === "at") op.pct = parsePct(tok.shift(), ln);
+    else if (t.word === "width") op.width = parseNum(tok.shift(), "width", ln);
+    else if (t.word === "hinge") {
+      const h = parseId(tok.shift(), "hinge (left|right)", ln);
+      if (h !== "left" && h !== "right") throw new FloorplanParseError(`hinge must be left|right, got "${h}"`, ln);
+      op.hinge = h;
+    } else if (t.word === "swing") {
+      const s = parseId(tok.shift(), "swing (in|out)", ln);
+      if (s !== "in" && s !== "out") throw new FloorplanParseError(`swing must be in|out, got "${s}"`, ln);
+      op.swing = s;
+    } else if (t.word === "type") {
+      const d = parseId(tok.shift(), `${kind} type`, ln);
+      if (kind === "window") {
+        if (!WINDOW_TYPES.includes(d)) {
+          throw new FloorplanParseError(`window type must be ${WINDOW_TYPES.join("|")}, got "${d}"`, ln);
+        }
+        op.windowType = d;
+      } else {
+        if (!DOOR_TYPES.includes(d)) {
+          throw new FloorplanParseError(`door type must be ${DOOR_TYPES.join("|")}, got "${d}"`, ln);
+        }
+        op.doorType = d;
+      }
+    } else throw new FloorplanParseError(`${kind}: unexpected token "${t.word}"`, ln);
+  }
+  if (op.width === 0) {
+    op.width = kind === "window" ? 1.2 : kind === "opening" ? 1 : op.between ? 0.8 : 0.9;
+  }
+  ast.openings.push(op);
+}
+function parseFurniture(tok, ast, ln) {
+  const type = parseFurnitureType(tok.shift(), ln);
+  const f = { type, x: 0, y: 0, rotate: 0, line: ln };
+  while (tok.length) {
+    const t = tok.shift();
+    if (isStr(t)) f.label = t.str;
+    else if (t.word === "in") f.room = parseId(tok.shift(), `a room id after "in"`, ln);
+    else if (t.word === "at") {
+      const c = parseCoord2(tok.shift(), "at", ln);
+      f.x = c.x;
+      f.y = c.y;
+    } else if (t.word === "size") f.size = parseDims(tok.shift(), "size", ln);
+    else if (t.word === "rotate") f.rotate = parseNum(tok.shift(), "rotate", ln);
+    else throw new FloorplanParseError(`furniture: unexpected token "${t.word}"`, ln);
+  }
+  ast.furniture.push(f);
+}
+function parseArray(mode, tok, ast, ln) {
+  const type = parseFurnitureType(tok.shift(), ln);
+  const a = {
+    mode,
+    type,
+    rows: 1,
+    cols: 1,
+    count: Infinity,
+    rotate: 0,
+    line: ln
+  };
+  while (tok.length) {
+    const t = tok.shift();
+    if (!isWord(t)) throw new FloorplanParseError(`${mode}: unexpected string "${t.str}"`, ln);
+    else if (t.word === "in") a.room = parseId(tok.shift(), `a room id after "in"`, ln);
+    else if (t.word === "rows") a.rows = parseNum(tok.shift(), "rows", ln);
+    else if (t.word === "cols") a.cols = parseNum(tok.shift(), "cols", ln);
+    else if (t.word === "count") a.count = parseNum(tok.shift(), "count", ln);
+    else if (t.word === "area") {
+      a.p1 = parseCoord2(tok.shift(), "area p1", ln);
+      a.p2 = parseCoord2(tok.shift(), "area p2", ln);
+    } else if (t.word === "itemsize") a.itemsize = parseDims(tok.shift(), "itemsize", ln);
+    else if (t.word === "rotate") a.rotate = parseNum(tok.shift(), "rotate", ln);
+    else if (t.word === "center") a.center = parseCoord2(tok.shift(), "center", ln);
+    else if (t.word === "radius") a.radius = parseNum(tok.shift(), "radius", ln);
+    else if (t.word === "from") a.fromDeg = parseNum(tok.shift(), "from", ln);
+    else if (t.word === "to") a.toDeg = parseNum(tok.shift(), "to", ln);
+    else throw new FloorplanParseError(`${mode}: unexpected token "${t.word}"`, ln);
+  }
+  ast.arrays.push(a);
+}
+function parseFloorplan(text2) {
+  const ast = {
+    type: "floorplan",
+    title: "Floor Plan",
+    unit: "m",
+    rooms: [],
+    extensions: [],
+    openings: [],
+    furniture: [],
+    arrays: []
+  };
+  let sawHeader = false;
+  const lines = text2.split(/\r?\n/);
+  for (let i = 0; i < lines.length; i++) {
+    const ln = i + 1;
+    const raw = normalizeQuotes3(lines[i]).trim();
+    if (!raw) continue;
+    const all = tokenize7(raw);
+    const tok = [];
+    for (let k = 0; k < all.length; k++) {
+      const t = all[k];
+      if (isWord(t) && (t.word.startsWith("#") || t.word.startsWith("//"))) {
+        const prev = all[k - 1];
+        if (t.word.startsWith("#") && isWord(prev, "fill")) {
+          tok.push(t);
+          continue;
+        }
+        break;
+      }
+      tok.push(t);
+    }
+    if (tok.length === 0) continue;
+    const head = tok.shift();
+    if (!isWord(head)) throw new FloorplanParseError(`unexpected string at line start`, ln);
+    const kw = head.word.toLowerCase();
+    if (kw === "floorplan") {
+      parseHeader3(tok, ast, ln);
+      sawHeader = true;
+    } else if (!sawHeader) {
+      throw new FloorplanParseError(`the first statement must be the "floorplan" header`, ln);
+    } else if (kw === "room") parseRoom(tok, ast, ln);
+    else if (kw === "north") {
+      ast.north = tok.length ? parseNum(tok.shift(), "north rotation (degrees)", ln) : 0;
+      if (tok.length) throw new FloorplanParseError(`north: unexpected trailing tokens`, ln);
+    } else if (kw === "extend") parseExtend(tok, ast, ln);
+    else if (kw === "door" || kw === "window" || kw === "opening") parseOpening(kw, tok, ast, ln);
+    else if (kw === "furniture") parseFurniture(tok, ast, ln);
+    else if (kw === "grid" || kw === "row" || kw === "arc") parseArray(kw, tok, ast, ln);
+    else {
+      throw new FloorplanParseError(
+        `unknown keyword "${kw}". Expected: floorplan, room, extend, door, window, opening, furniture, grid, row, arc`,
+        ln
+      );
+    }
+  }
+  return ast;
+}
+
+// src/diagrams/floorplan/layout.ts
+var FT = 0.3048;
+var FLOORPLAN_CONST = {
+  /** Wall band thickness, meters (§5). */
+  wallT: 0.2,
+  /** Default render scale, px per meter (§4.1). */
+  scale: 55,
+  /** Jamb margin an opening keeps from the segment ends, meters (§4.3). */
+  jamb: 0.05,
+  /** Dimension band depth outside the plan, meters. */
+  dimBand: 1,
+  /** Outer padding, meters. */
+  pad: 0.45,
+  /** Offsets of the major / minor dimension rows from the plan edge, meters. */
+  dimMajorOff: 0.62,
+  dimMinorOff: 0.3
+};
+function formatLength(m, unit) {
+  if (unit === "m") {
+    const v = Math.round(m * 100) / 100;
+    return `${v} m`;
+  }
+  const ftv = m / FT;
+  let f = Math.floor(ftv + 1e-6);
+  let inches = Math.round((ftv - f) * 12);
+  if (inches >= 12) {
+    f += 1;
+    inches = 0;
+  }
+  return inches ? `${f}'${inches}"` : `${f}'`;
+}
+function formatArea(areaM2, unit) {
+  if (unit === "m") return `${areaM2.toFixed(1)} m\xB2`;
+  return `${Math.round(areaM2 / (FT * FT))} sq ft`;
+}
+var fmtNum = (v) => String(Math.round(v * 100) / 100);
+var snap = (v) => Math.round(v * 1e6) / 1e6;
+var ADJ_EPS = 0.051;
+var MIN_OVERLAP = 0.3;
+function rectSharedEdge(a, b) {
+  if (Math.abs(a.x + a.w - b.x) < ADJ_EPS || Math.abs(b.x + b.w - a.x) < ADJ_EPS) {
+    const along = Math.abs(a.x + a.w - b.x) < ADJ_EPS ? a.x + a.w : b.x + b.w;
+    const lo = Math.max(a.y, b.y);
+    const hi = Math.min(a.y + a.h, b.y + b.h);
+    if (hi - lo >= MIN_OVERLAP) return { vertical: true, along, lo, hi };
+  }
+  if (Math.abs(a.y + a.h - b.y) < ADJ_EPS || Math.abs(b.y + b.h - a.y) < ADJ_EPS) {
+    const along = Math.abs(a.y + a.h - b.y) < ADJ_EPS ? a.y + a.h : b.y + b.h;
+    const lo = Math.max(a.x, b.x);
+    const hi = Math.min(a.x + a.w, b.x + b.w);
+    if (hi - lo >= MIN_OVERLAP) return { vertical: false, along, lo, hi };
+  }
+  return null;
+}
+function roomSharedEdge(a, b) {
+  let best = null;
+  for (const pa of a.parts) {
+    for (const pb of b.parts) {
+      const e = rectSharedEdge(pa, pb);
+      if (e && (!best || e.hi - e.lo > best.edge.hi - best.edge.lo)) {
+        best = { edge: e, aPart: pa, bPart: pb };
+      }
+    }
+  }
+  return best;
+}
+function rectOverlap(a, b) {
+  return {
+    ox: Math.min(a.x + a.w, b.x + b.w) - Math.max(a.x, b.x),
+    oy: Math.min(a.y + a.h, b.y + b.h) - Math.max(a.y, b.y)
+  };
+}
+function obbCorners(x, y, w, h, rotDeg, margins) {
+  const [mt, mr, mb, ml] = margins;
+  const cx = x + w / 2;
+  const cy = y + h / 2;
+  const corners = [
+    [x - ml, y - mt],
+    [x + w + mr, y - mt],
+    [x + w + mr, y + h + mb],
+    [x - ml, y + h + mb]
+  ];
+  if (!rotDeg) return corners;
+  const rad = rotDeg * Math.PI / 180;
+  const cos = Math.cos(rad);
+  const sin = Math.sin(rad);
+  return corners.map(([px, py]) => {
+    const dx = px - cx;
+    const dy = py - cy;
+    return [cx + dx * cos - dy * sin, cy + dx * sin + dy * cos];
+  });
+}
+function rotatedAabb(x, y, w, h, rotDeg, margins) {
+  const corners = obbCorners(x, y, w, h, rotDeg, margins);
+  let minX = Infinity;
+  let minY = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  for (const [px, py] of corners) {
+    minX = Math.min(minX, px);
+    minY = Math.min(minY, py);
+    maxX = Math.max(maxX, px);
+    maxY = Math.max(maxY, py);
+  }
+  return { minX, minY, maxX, maxY };
+}
+function obbPenetration(a, b) {
+  let minPen = Infinity;
+  for (const poly of [a, b]) {
+    for (let i = 0; i < 4; i++) {
+      const j = (i + 1) % 4;
+      let ax = poly[j][1] - poly[i][1];
+      let ay = poly[i][0] - poly[j][0];
+      const len = Math.hypot(ax, ay);
+      if (len < 1e-12) continue;
+      ax /= len;
+      ay /= len;
+      let aLo = Infinity;
+      let aHi = -Infinity;
+      for (const [px, py] of a) {
+        const v = px * ax + py * ay;
+        aLo = Math.min(aLo, v);
+        aHi = Math.max(aHi, v);
+      }
+      let bLo = Infinity;
+      let bHi = -Infinity;
+      for (const [px, py] of b) {
+        const v = px * ax + py * ay;
+        bLo = Math.min(bLo, v);
+        bHi = Math.max(bHi, v);
+      }
+      const pen = Math.min(aHi, bHi) - Math.max(aLo, bLo);
+      if (pen <= 0) return 0;
+      minPen = Math.min(minPen, pen);
+    }
+  }
+  return minPen === Infinity ? 0 : minPen;
+}
+function resolvePlacement(p, w, h, byId, rooms, u, who, errors) {
+  if (p.at) return { x: snap(p.at.x * u), y: snap(p.at.y * u) };
+  if (p.rel) {
+    const refIdx = byId.get(p.rel.ref);
+    if (refIdx === void 0) {
+      errors.push(`${who}: unknown reference room "${p.rel.ref}" \u2014 declare it first`);
+      return null;
+    }
+    const ref = rooms[refIdx];
+    const off = (p.rel.offset ?? 0) * u;
+    const alignPos = (refStart, refLen, len) => {
+      if (p.rel.align === "center") return refStart + (refLen - len) / 2 + off;
+      if (p.rel.align === "end") return refStart + refLen - len + off;
+      return refStart + off;
+    };
+    let x = 0;
+    let y = 0;
+    switch (p.rel.how) {
+      case "right-of":
+        x = ref.x + ref.w;
+        y = alignPos(ref.y, ref.h, h);
+        break;
+      case "left-of":
+        x = ref.x - w;
+        y = alignPos(ref.y, ref.h, h);
+        break;
+      case "below":
+        y = ref.y + ref.h;
+        x = alignPos(ref.x, ref.w, w);
+        break;
+      case "above":
+        y = ref.y - h;
+        x = alignPos(ref.x, ref.w, w);
+        break;
+    }
+    return { x: snap(x), y: snap(y) };
+  }
+  return { x: 0, y: 0 };
+}
+function refreshRoomBounds(room, unit) {
+  let minX = Infinity;
+  let minY = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  let area = 0;
+  for (const p of room.parts) {
+    minX = Math.min(minX, p.x);
+    minY = Math.min(minY, p.y);
+    maxX = Math.max(maxX, p.x + p.w);
+    maxY = Math.max(maxY, p.y + p.h);
+    area += p.w * p.h;
+  }
+  room.x = snap(minX);
+  room.y = snap(minY);
+  room.w = snap(maxX - minX);
+  room.h = snap(maxY - minY);
+  room.areaM2 = area;
+  room.areaText = formatArea(area, unit);
+}
+function subtractIntervals(lo, hi, cuts) {
+  let pieces = [[lo, hi]];
+  for (const [cLo, cHi] of cuts) {
+    const next = [];
+    for (const [pLo, pHi] of pieces) {
+      if (cHi <= pLo + 1e-9 || cLo >= pHi - 1e-9) {
+        next.push([pLo, pHi]);
+        continue;
+      }
+      if (cLo > pLo + 1e-9) next.push([pLo, Math.min(cLo, pHi)]);
+      if (cHi < pHi - 1e-9) next.push([Math.max(cHi, pLo), pHi]);
+    }
+    pieces = next;
+  }
+  return pieces.filter(([a, b]) => b - a > 1e-9);
+}
+function sideSegments(room, side) {
+  const segs = [];
+  for (const p of room.parts) {
+    const vertical = side === "west" || side === "east";
+    const along = side === "north" ? p.y : side === "south" ? p.y + p.h : side === "west" ? p.x : p.x + p.w;
+    const lo = vertical ? p.y : p.x;
+    const hi = vertical ? p.y + p.h : p.x + p.w;
+    const cuts = [];
+    for (const q of room.parts) {
+      if (q === p) continue;
+      const qNear = side === "north" ? q.y + q.h : side === "south" ? q.y : side === "west" ? q.x + q.w : q.x;
+      if (Math.abs(qNear - along) >= ADJ_EPS) continue;
+      const cLo = vertical ? Math.max(lo, q.y) : Math.max(lo, q.x);
+      const cHi = vertical ? Math.min(hi, q.y + q.h) : Math.min(hi, q.x + q.w);
+      if (cHi > cLo) cuts.push([cLo, cHi]);
+    }
+    for (const [sLo, sHi] of subtractIntervals(lo, hi, cuts)) {
+      if (sHi - sLo >= MIN_OVERLAP) segs.push({ along, lo: sLo, hi: sHi });
+    }
+  }
+  return segs.sort((a, b) => a.lo - b.lo || a.along - b.along);
+}
+function layoutFloorplan(ast) {
+  const u = ast.unit === "ft" ? FT : 1;
+  const errors = [];
+  const warnings = [];
+  const rooms = [];
+  const byId = /* @__PURE__ */ new Map();
+  const stmts = [
+    ...ast.rooms.map((room) => ({ line: room.line ?? 0, room })),
+    ...ast.extensions.map((ext) => ({ line: ext.line ?? 0, ext }))
+  ].sort((a, b) => a.line - b.line);
+  for (const stmt of stmts) {
+    if (stmt.room) {
+      const r6 = stmt.room;
+      const w = r6.w * u;
+      const h = r6.h * u;
+      const pos = resolvePlacement(r6, w, h, byId, rooms, u, `room "${r6.id}"`, errors) ?? { x: 0, y: 0 };
+      const part = { x: pos.x, y: pos.y, w, h };
+      const room = {
+        id: r6.id,
+        label: r6.label,
+        x: part.x,
+        y: part.y,
+        w,
+        h,
+        parts: [part],
+        areaM2: 0,
+        areaText: "",
+        fill: r6.fill,
+        nolabel: r6.nolabel ?? false
+      };
+      refreshRoomBounds(room, ast.unit);
+      byId.set(r6.id, rooms.length);
+      rooms.push(room);
+    } else if (stmt.ext) {
+      const e = stmt.ext;
+      const idx = byId.get(e.room);
+      if (idx === void 0) {
+        errors.push(`extend: unknown room "${e.room}" \u2014 declare it first`);
+        continue;
+      }
+      const room = rooms[idx];
+      const w = e.w * u;
+      const h = e.h * u;
+      const pos = resolvePlacement(e, w, h, byId, rooms, u, `extend "${e.room}"`, errors);
+      if (!pos) continue;
+      const part = { x: pos.x, y: pos.y, w, h };
+      let touches = false;
+      let overlaps = false;
+      for (const p of room.parts) {
+        const { ox, oy } = rectOverlap(p, part);
+        if (ox > ADJ_EPS && oy > ADJ_EPS) overlaps = true;
+        if (rectSharedEdge(p, part)) touches = true;
+      }
+      if (overlaps) {
+        errors.push(`extend "${e.room}": extension overlaps the room's existing area \u2014 place it edge-to-edge`);
+        continue;
+      }
+      if (!touches) {
+        errors.push(`extend "${e.room}": extension does not touch the room \u2014 extensions must share an edge`);
+        continue;
+      }
+      room.parts.push(part);
+      refreshRoomBounds(room, ast.unit);
+    }
+  }
+  for (let i = 0; i < rooms.length; i++) {
+    for (let j = i + 1; j < rooms.length; j++) {
+      const a = rooms[i];
+      const b = rooms[j];
+      let worst = null;
+      for (const pa of a.parts) {
+        for (const pb of b.parts) {
+          const { ox, oy } = rectOverlap(pa, pb);
+          if (ox > ADJ_EPS && oy > ADJ_EPS && (!worst || ox * oy > worst.ox * worst.oy)) {
+            worst = { ox, oy };
+          }
+        }
+      }
+      if (worst) {
+        errors.push(
+          `rooms "${a.id}" and "${b.id}" overlap by ${worst.ox.toFixed(2)}\xD7${worst.oy.toFixed(2)} m \u2014 move "${b.id}" right-of "${a.id}" or shrink size`
+        );
+      }
+    }
+  }
+  const seams = [];
+  for (let ri = 0; ri < rooms.length; ri++) {
+    const parts = rooms[ri].parts;
+    for (let i = 0; i < parts.length; i++) {
+      for (let j = i + 1; j < parts.length; j++) {
+        const e = rectSharedEdge(parts[i], parts[j]);
+        if (e) seams.push({ vertical: e.vertical, along: e.along, lo: e.lo, hi: e.hi, room: ri });
+      }
+    }
+  }
+  const openings = [];
+  for (const op of ast.openings) {
+    const geom = resolveOpening(op, rooms, byId, u, ast.unit, errors, warnings);
+    if (geom) openings.push(geom);
+  }
+  const items = [];
+  const seqByType = /* @__PURE__ */ new Map();
+  const place = (type, roomIdx, localX, localY, w, h, rotate, label) => {
+    const room = rooms[roomIdx];
+    const seq = (seqByType.get(type) ?? 0) + 1;
+    seqByType.set(type, seq);
+    items.push({ type, x: room.x + localX, y: room.y + localY, w, h, rotate, label, roomId: room.id, seq });
+  };
+  const roomIdxOf = (stmt, roomId, line2) => {
+    if (!roomId) {
+      errors.push(`${stmt}${line2 ? ` (line ${line2})` : ""}: missing "in <room>"`);
+      return void 0;
+    }
+    const idx = byId.get(roomId);
+    if (idx === void 0) {
+      errors.push(`${stmt}: unknown room "${roomId}"`);
+      return void 0;
+    }
+    return idx;
+  };
+  for (const f of ast.furniture) {
+    const def = FLOORPLAN_SYMBOLS[f.type];
+    const idx = roomIdxOf(`furniture ${f.type}`, f.room, f.line);
+    if (idx === void 0) continue;
+    const w = f.size ? f.size.w * u : def.w;
+    const h = f.size ? f.size.h * u : def.h;
+    place(f.type, idx, f.x * u, f.y * u, w, h, f.rotate, f.label);
+  }
+  for (const a of ast.arrays) {
+    const def = FLOORPLAN_SYMBOLS[a.type];
+    const idx = roomIdxOf(`${a.mode} ${a.type}`, a.room, a.line);
+    if (idx === void 0) continue;
+    const room = rooms[idx];
+    const iw = a.itemsize ? a.itemsize.w * u : def.w;
+    const ih = a.itemsize ? a.itemsize.h * u : def.h;
+    const p1 = a.p1 ? { x: a.p1.x * u, y: a.p1.y * u } : { x: 0.5 * u, y: 0.5 * u };
+    const p2 = a.p2 ? { x: a.p2.x * u, y: a.p2.y * u } : { x: room.w - 0.5 * u, y: room.h - 0.5 * u };
+    if (a.mode === "grid" || a.mode === "row") {
+      const nRows = a.mode === "row" ? 1 : Math.max(1, Math.round(a.rows));
+      const nCols = Math.max(1, Math.round(a.cols));
+      const cap2 = Number.isFinite(a.count) ? a.count : nRows * nCols;
+      const spanW = p2.x - p1.x;
+      const spanH = p2.y - p1.y;
+      let placed = 0;
+      for (let r6 = 0; r6 < nRows && placed < cap2; r6++) {
+        for (let col = 0; col < nCols && placed < cap2; col++) {
+          const cx = p1.x + (nCols === 1 ? spanW / 2 : col * spanW / (nCols - 1));
+          const cy = p1.y + (nRows === 1 ? spanH / 2 : r6 * spanH / (nRows - 1));
+          place(a.type, idx, cx - iw / 2, cy - ih / 2, iw, ih, a.rotate);
+          placed++;
+        }
+      }
+    } else {
+      const n = Math.max(1, Number.isFinite(a.count) ? a.count : Math.max(1, Math.round(a.cols)));
+      const cen = a.center ? { x: a.center.x * u, y: a.center.y * u } : { x: room.w / 2, y: room.h * 0.6 };
+      const radius = a.radius !== void 0 ? a.radius * u : Math.min(room.w, room.h) / 3;
+      const a0 = (a.fromDeg ?? 200) * Math.PI / 180;
+      const a1 = (a.toDeg ?? 340) * Math.PI / 180;
+      for (let i = 0; i < n; i++) {
+        const th = a0 + (a1 - a0) * i / Math.max(n - 1, 1);
+        const cx = cen.x + radius * Math.cos(th);
+        const cy = cen.y + radius * Math.sin(th);
+        const facing = th * 180 / Math.PI + 270;
+        place(a.type, idx, cx - iw / 2, cy - ih / 2, iw, ih, facing + a.rotate);
+      }
+    }
+  }
+  const roomOf = /* @__PURE__ */ new Map();
+  for (const r6 of rooms) roomOf.set(r6.id, r6);
+  const warnItems = /* @__PURE__ */ new Set();
+  for (const it of items) {
+    const room = roomOf.get(it.roomId);
+    if (!room) continue;
+    const bb = rotatedAabb(it.x, it.y, it.w, it.h, it.rotate, [0, 0, 0, 0]);
+    const over = Math.max(
+      room.x - bb.minX,
+      bb.maxX - (room.x + room.w),
+      room.y - bb.minY,
+      bb.maxY - (room.y + room.h)
+    );
+    if (over > 0.011) {
+      errors.push(
+        `furniture ${it.type} #${it.seq} extends ${fmtNum(over)} m outside room "${it.roomId}" \u2014 move it or shrink size`
+      );
+      continue;
+    }
+    if (room.parts.length > 1) {
+      const bw = bb.maxX - bb.minX;
+      const bh = bb.maxY - bb.minY;
+      let covered = 0;
+      for (const p of room.parts) {
+        const ox = Math.min(p.x + p.w, bb.maxX) - Math.max(p.x, bb.minX);
+        const oy = Math.min(p.y + p.h, bb.maxY) - Math.max(p.y, bb.minY);
+        if (ox > 0 && oy > 0) covered += ox * oy;
+      }
+      const uncovered = bw * bh - covered;
+      if (uncovered > 0.01) {
+        errors.push(
+          `furniture ${it.type} #${it.seq} sits outside room "${it.roomId}"'s L-shape (${fmtNum(uncovered)} m\xB2 past the notch) \u2014 move it onto a room part`
+        );
+      }
+    }
+  }
+  const envelopes = items.map((it) => {
+    const def = FLOORPLAN_SYMBOLS[it.type];
+    return obbCorners(it.x, it.y, it.w, it.h, it.rotate, def.envelope ?? [0, 0, 0, 0]);
+  });
+  for (let i = 0; i < items.length; i++) {
+    const a = items[i];
+    if (FLOORPLAN_SYMBOLS[a.type].underlay) continue;
+    for (let j = i + 1; j < items.length; j++) {
+      const b = items[j];
+      if (FLOORPLAN_SYMBOLS[b.type].underlay) continue;
+      const pen = obbPenetration(envelopes[i], envelopes[j]);
+      if (pen > 0.011) {
+        warnings.push(
+          `${a.type} #${a.seq} overlaps ${b.type} #${b.seq} by ${fmtNum(pen)} m \u2014 increase spacing or reduce cols`
+        );
+        warnItems.add(i);
+        warnItems.add(j);
+      }
+    }
+  }
+  let minX = Infinity;
+  let minY = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  for (const r6 of rooms) {
+    minX = Math.min(minX, r6.x);
+    minY = Math.min(minY, r6.y);
+    maxX = Math.max(maxX, r6.x + r6.w);
+    maxY = Math.max(maxY, r6.y + r6.h);
+  }
+  if (rooms.length === 0) {
+    minX = minY = 0;
+    maxX = maxY = 1;
+    errors.push('no rooms defined \u2014 declare at least one: room id "Label" at 0,0 size 4x3');
+  }
+  const dims = [];
+  if (rooms.length > 0) {
+    dims.push({
+      vertical: false,
+      at: minY - FLOORPLAN_CONST.dimMajorOff,
+      lo: minX,
+      hi: maxX,
+      label: formatLength(maxX - minX, ast.unit),
+      minor: false
+    });
+    dims.push({
+      vertical: true,
+      at: minX - FLOORPLAN_CONST.dimMajorOff,
+      lo: minY,
+      hi: maxY,
+      label: formatLength(maxY - minY, ast.unit),
+      minor: false
+    });
+    const topSegs = [];
+    for (const r6 of rooms) {
+      for (const sg of sideSegments(r6, "north")) {
+        if (Math.abs(sg.along - minY) < 0.01) topSegs.push({ lo: sg.lo, hi: sg.hi });
+      }
+    }
+    if (topSegs.length > 1) {
+      for (const sg of topSegs.sort((a, b) => a.lo - b.lo)) {
+        dims.push({
+          vertical: false,
+          at: minY - FLOORPLAN_CONST.dimMinorOff,
+          lo: sg.lo,
+          hi: sg.hi,
+          label: formatLength(sg.hi - sg.lo, ast.unit),
+          minor: true
+        });
+      }
+    }
+    const leftSegs = [];
+    for (const r6 of rooms) {
+      for (const sg of sideSegments(r6, "west")) {
+        if (Math.abs(sg.along - minX) < 0.01) leftSegs.push({ lo: sg.lo, hi: sg.hi });
+      }
+    }
+    if (leftSegs.length > 1) {
+      for (const sg of leftSegs.sort((a, b) => a.lo - b.lo)) {
+        dims.push({
+          vertical: true,
+          at: minX - FLOORPLAN_CONST.dimMinorOff,
+          lo: sg.lo,
+          hi: sg.hi,
+          label: formatLength(sg.hi - sg.lo, ast.unit),
+          minor: true
+        });
+      }
+    }
+  }
+  return {
+    title: ast.title,
+    unit: ast.unit,
+    north: ast.north,
+    rooms,
+    seams,
+    openings,
+    items,
+    dims,
+    bounds: { minX, minY, maxX, maxY },
+    wallT: FLOORPLAN_CONST.wallT,
+    totalAreaM2: rooms.reduce((s, r6) => s + r6.areaM2, 0),
+    errors,
+    warnings,
+    warnItems: [...warnItems]
+  };
+}
+function resolveOpening(op, rooms, byId, u, unit, errors, warnings) {
+  let seg = null;
+  let owner = -1;
+  let negRoom;
+  let posRoom;
+  let inward = 1;
+  if (op.between) {
+    const ia = byId.get(op.between[0]);
+    const ib = byId.get(op.between[1]);
+    if (ia === void 0 || ib === void 0) {
+      errors.push(`${op.kind}: unknown room "${ia === void 0 ? op.between[0] : op.between[1]}"`);
+      return null;
+    }
+    const a = rooms[ia];
+    const b = rooms[ib];
+    const found = roomSharedEdge(a, b);
+    if (!found) {
+      const gapX = Math.max(a.x, b.x) - Math.min(a.x + a.w, b.x + b.w);
+      const gapY = Math.max(a.y, b.y) - Math.min(a.y + a.h, b.y + b.h);
+      const axis = gapX >= gapY ? "x" : "y";
+      const gap = Math.max(gapX, gapY);
+      errors.push(
+        gap > 0 ? `${op.kind} between "${a.id}" and "${b.id}": rooms share no wall (gap ${fmtNum(gap)} m on ${axis}-axis)` : `${op.kind} between "${a.id}" and "${b.id}": rooms share no wall`
+      );
+      return null;
+    }
+    seg = found.edge;
+    owner = ia;
+    if (seg.vertical) {
+      const aIsNeg = found.aPart.x + found.aPart.w / 2 < seg.along;
+      negRoom = aIsNeg ? ia : ib;
+      posRoom = aIsNeg ? ib : ia;
+      inward = aIsNeg ? -1 : 1;
+    } else {
+      const aIsNeg = found.aPart.y + found.aPart.h / 2 < seg.along;
+      negRoom = aIsNeg ? ia : ib;
+      posRoom = aIsNeg ? ib : ia;
+      inward = aIsNeg ? -1 : 1;
+    }
+  } else {
+    const idx = byId.get(op.room);
+    if (idx === void 0) {
+      errors.push(`${op.kind}: unknown room "${op.room}"`);
+      return null;
+    }
+    owner = idx;
+    const r6 = rooms[idx];
+    const side = op.side;
+    const segs = sideSegments(r6, side);
+    if (segs.length === 0) {
+      errors.push(`${op.kind} on "${r6.id}" ${side}: that side has no exterior wall segment`);
+      return null;
+    }
+    const total = segs.reduce((s, sg) => s + (sg.hi - sg.lo), 0);
+    const pct2 = Math.min(100, Math.max(0, op.pct));
+    let target = total * pct2 / 100;
+    let chosen = segs[segs.length - 1];
+    for (const sg of segs) {
+      const len = sg.hi - sg.lo;
+      if (target <= len) {
+        chosen = sg;
+        break;
+      }
+      target -= len;
+    }
+    const within = Math.min(1, Math.max(0, target / (chosen.hi - chosen.lo)));
+    op = { ...op, pct: within * 100 };
+    seg = { vertical: side === "west" || side === "east", along: chosen.along, lo: chosen.lo, hi: chosen.hi };
+    switch (side) {
+      case "north":
+        inward = 1;
+        posRoom = idx;
+        break;
+      case "south":
+        inward = -1;
+        negRoom = idx;
+        break;
+      case "west":
+        inward = 1;
+        posRoom = idx;
+        break;
+      case "east":
+        inward = -1;
+        negRoom = idx;
+        break;
+    }
+  }
+  const jamb = FLOORPLAN_CONST.jamb;
+  const segLen = seg.hi - seg.lo;
+  const avail = segLen - 2 * jamb;
+  let wd = op.width * u;
+  if (wd > avail) {
+    warnings.push(
+      `${op.kind}${op.room ? ` on "${op.room}" ${op.side}` : op.between ? ` between "${op.between[0]}" and "${op.between[1]}"` : ""}: width ${formatLength(wd, unit)} clamped to ${formatLength(avail, unit)} to fit the wall segment`
+    );
+    wd = avail;
+  }
+  const pct = Math.min(100, Math.max(0, op.pct));
+  const c = seg.lo + segLen * pct / 100;
+  const lo = Math.max(seg.lo + jamb, Math.min(c - wd / 2, seg.hi - jamb - wd));
+  const hi = lo + wd;
+  const arcDir = op.kind === "door" && op.swing === "out" ? inward === 1 ? -1 : 1 : inward;
+  return {
+    kind: op.kind,
+    doorType: op.doorType,
+    windowType: op.windowType,
+    vertical: seg.vertical,
+    along: seg.along,
+    lo,
+    hi,
+    inward: arcDir,
+    hinge: op.hinge,
+    negRoom,
+    posRoom,
+    owner
+  };
+}
+
+// src/diagrams/floorplan/renderer.ts
+var r24 = (n) => Math.round(n * 100) / 100;
+function buildCss13(t) {
+  return `
+.sx-fp { font-family: ${DEFAULT_FONT_FAMILY}; }
+.sx-fp-title { font: ${TITLE.weight} ${TITLE.size}px sans-serif; fill: ${t.text}; }
+.sx-fp-wall { fill: ${t.wallFill}; stroke: none; }
+.sx-fp-furn { fill: ${t.furnFill}; stroke: ${t.furnStroke}; stroke-width: 1.2; }
+.sx-fp-furn-nofill { fill: none; stroke: ${t.furnStroke}; stroke-width: 1.2; }
+.sx-fp-furn-line { fill: none; stroke: ${t.furnStroke}; stroke-width: 1; }
+.sx-fp-furn-dash { fill: none; stroke: ${t.furnStroke}; stroke-width: 1; stroke-dasharray: 4 3; }
+.sx-fp-furn-dot { fill: ${t.furnStroke}; stroke: none; }
+.sx-fp-furn-solid { fill: ${t.furnSolid}; stroke: none; }
+.sx-fp-board-inner { fill: ${t.boardInner}; stroke: none; }
+.sx-fp-chair { fill: ${t.chairFill}; stroke: ${t.furnStroke}; stroke-width: 1; }
+.sx-fp-rug { fill: none; stroke: ${t.rugStroke}; stroke-width: 1.2; stroke-dasharray: 5 4; }
+.sx-fp-hatch { fill: none; stroke: ${t.hatchStroke}; stroke-width: 1; }
+.sx-fp-furn-text { font-weight: 600; font-family: sans-serif; fill: ${t.furnLabel}; paint-order: stroke; stroke: ${t.floorFill}; stroke-width: 2.5px; stroke-linejoin: round; }
+.sx-fp-furn-label { font: 11px sans-serif; fill: ${t.furnLabel}; paint-order: stroke; stroke: ${t.floorFill}; stroke-width: 3px; stroke-linejoin: round; }
+.sx-fp-door-leaf { fill: none; stroke: ${t.doorLeaf}; stroke-width: 1.6; }
+.sx-fp-door-arc { fill: none; stroke: ${t.doorArc}; stroke-width: 1; }
+.sx-fp-window { fill: none; stroke: ${t.windowStroke}; stroke-width: 1.3; }
+.sx-fp-jamb { fill: none; stroke: ${t.furnStroke}; stroke-width: 1.2; }
+.sx-fp-room-name { font: 600 13.5px sans-serif; fill: ${t.roomName}; paint-order: stroke; stroke: ${t.floorFill}; stroke-width: 3px; stroke-linejoin: round; }
+.sx-fp-room-area { font: 11px sans-serif; fill: ${t.roomArea}; paint-order: stroke; stroke: ${t.floorFill}; stroke-width: 3px; stroke-linejoin: round; }
+.sx-fp-stair-break { fill: none; stroke: ${t.furnStroke}; stroke-width: 1.6; }
+.sx-fp-compass { fill: none; stroke: ${t.dimStroke}; stroke-width: 1.2; }
+.sx-fp-compass-n { font: 700 11px sans-serif; fill: ${t.dimText}; }
+.sx-fp-dim { fill: none; stroke: ${t.dimStroke}; stroke-width: 1; }
+.sx-fp-dim-text { font: 10.5px sans-serif; fill: ${t.dimText}; }
+.sx-fp-dim-text-minor { font: 9px sans-serif; fill: ${t.dimText}; }
+.sx-fp-warn-item { fill: none; stroke: ${t.negative}; stroke-width: 1.5; stroke-dasharray: 4 3; }
+.sx-fp-warn { font: 11px ui-monospace, Menlo, monospace; fill: ${t.warn}; }
+.sx-fp-error-box { fill: ${t.bg}; stroke: ${t.negative}; stroke-width: 1.5; }
+.sx-fp-error-title { font: 700 13px ui-monospace, Menlo, monospace; fill: ${t.negative}; }
+.sx-fp-error-line { font: 12px ui-monospace, Menlo, monospace; fill: ${t.negative}; }
+`.trim();
+}
+function renderErrorPanel(lay, t) {
+  const lines = lay.errors;
+  const w = Math.max(560, ...lines.map((l) => l.length * 6.6 + 48));
+  const h = 56 + lines.length * 19;
+  return svgRoot(
+    { viewBox: `0 0 ${r24(w)} ${h}`, class: "sx-fp", role: "img" },
+    [
+      title(lay.title),
+      desc(`Floor plan validation failed with ${lines.length} error${lines.length === 1 ? "" : "s"}.`),
+      el("style", {}, buildCss13(t)),
+      rect({ class: "sx-fp-error-box", x: 1, y: 1, width: r24(w - 2), height: h - 2, rx: 6 }),
+      text({ class: "sx-fp-error-title", x: 16, y: 26 }, `floorplan: ${lines.length} validation error${lines.length === 1 ? "" : "s"}`),
+      ...lines.map((e, i) => text({ class: "sx-fp-error-line", x: 16, y: 50 + i * 19 }, `\u26A0 ${e}`))
+    ]
+  );
+}
+function gapFill(lay, t, roomIdx) {
+  if (roomIdx === void 0) return t.bg;
+  return lay.rooms[roomIdx]?.fill ?? t.floorFill;
+}
+function punchGap(o, lay, c) {
+  const tpx = c.px(c.wallT);
+  const negFill = gapFill(lay, c.t, o.negRoom);
+  const posFill = gapFill(lay, c.t, o.posRoom);
+  if (o.vertical) {
+    const x2 = c.X(o.along);
+    const y2 = c.Y(o.lo);
+    const h = c.px(o.hi - o.lo);
+    return rect({ class: "sx-fp-gap", fill: negFill, x: r24(x2 - tpx / 2 - 0.5), y: y2, width: r24(tpx / 2 + 0.5), height: h }) + rect({ class: "sx-fp-gap", fill: posFill, x: x2, y: y2, width: r24(tpx / 2 + 0.5), height: h });
+  }
+  const y = c.Y(o.along);
+  const x = c.X(o.lo);
+  const w = c.px(o.hi - o.lo);
+  return rect({ class: "sx-fp-gap", fill: negFill, x, y: r24(y - tpx / 2 - 0.5), width: w, height: r24(tpx / 2 + 0.5) }) + rect({ class: "sx-fp-gap", fill: posFill, x, y, width: w, height: r24(tpx / 2 + 0.5) });
+}
+function windowSymbol(o, c) {
+  const tpx = c.px(c.wallT);
+  const parts = [];
+  const outward = o.inward === 1 ? -1 : 1;
+  if (o.vertical) {
+    const x = c.X(o.along);
+    const mid = c.Y((o.lo + o.hi) / 2);
+    if (o.windowType === "sliding") {
+      parts.push(line({ class: "sx-fp-window", x1: r24(x - tpx * 0.22), y1: c.Y(o.lo), x2: r24(x - tpx * 0.22), y2: mid }));
+      parts.push(line({ class: "sx-fp-window", x1: r24(x + tpx * 0.22), y1: mid, x2: r24(x + tpx * 0.22), y2: c.Y(o.hi) }));
+    } else {
+      for (const k of [-1, 0, 1]) {
+        parts.push(line({ class: "sx-fp-window", x1: r24(x + k * tpx * 0.38), y1: c.Y(o.lo), x2: r24(x + k * tpx * 0.38), y2: c.Y(o.hi) }));
+      }
+    }
+    for (const yy of [o.lo, o.hi]) {
+      parts.push(line({ class: "sx-fp-window", x1: r24(x - tpx / 2), y1: c.Y(yy), x2: r24(x + tpx / 2), y2: c.Y(yy) }));
+    }
+    if (o.windowType === "casement") {
+      const wd = c.px(o.hi - o.lo);
+      const leafX = r24(x + outward * wd);
+      const sweep = outward === 1 ? 1 : 0;
+      parts.push(line({ class: "sx-fp-door-leaf", x1: x, y1: c.Y(o.lo), x2: leafX, y2: c.Y(o.lo) }));
+      parts.push(path({ class: "sx-fp-door-arc", d: `M ${leafX} ${c.Y(o.lo)} A ${wd} ${wd} 0 0 ${sweep} ${x} ${r24(c.Y(o.lo) + wd)}` }));
+    }
+    if (o.windowType === "bay") {
+      const proj = c.px(0.45) * outward;
+      const splay = c.px(0.3);
+      const x0 = r24(x + outward * tpx / 2);
+      parts.push(
+        path({
+          class: "sx-fp-window",
+          d: `M ${x0} ${c.Y(o.lo)} L ${r24(x0 + proj)} ${r24(c.Y(o.lo) + splay)} L ${r24(x0 + proj)} ${r24(c.Y(o.hi) - splay)} L ${x0} ${c.Y(o.hi)}`
+        })
+      );
+    }
+  } else {
+    const y = c.Y(o.along);
+    const mid = c.X((o.lo + o.hi) / 2);
+    if (o.windowType === "sliding") {
+      parts.push(line({ class: "sx-fp-window", x1: c.X(o.lo), y1: r24(y - tpx * 0.22), x2: mid, y2: r24(y - tpx * 0.22) }));
+      parts.push(line({ class: "sx-fp-window", x1: mid, y1: r24(y + tpx * 0.22), x2: c.X(o.hi), y2: r24(y + tpx * 0.22) }));
+    } else {
+      for (const k of [-1, 0, 1]) {
+        parts.push(line({ class: "sx-fp-window", x1: c.X(o.lo), y1: r24(y + k * tpx * 0.38), x2: c.X(o.hi), y2: r24(y + k * tpx * 0.38) }));
+      }
+    }
+    for (const xx of [o.lo, o.hi]) {
+      parts.push(line({ class: "sx-fp-window", x1: c.X(xx), y1: r24(y - tpx / 2), x2: c.X(xx), y2: r24(y + tpx / 2) }));
+    }
+    if (o.windowType === "casement") {
+      const wd = c.px(o.hi - o.lo);
+      const leafY = r24(y + outward * wd);
+      const sweep = outward === 1 ? 0 : 1;
+      parts.push(line({ class: "sx-fp-door-leaf", x1: c.X(o.lo), y1: y, x2: c.X(o.lo), y2: leafY }));
+      parts.push(path({ class: "sx-fp-door-arc", d: `M ${c.X(o.lo)} ${leafY} A ${wd} ${wd} 0 0 ${sweep} ${r24(c.X(o.lo) + wd)} ${y}` }));
+    }
+    if (o.windowType === "bay") {
+      const proj = c.px(0.45) * outward;
+      const splay = c.px(0.3);
+      const y0 = r24(y + outward * tpx / 2);
+      parts.push(
+        path({
+          class: "sx-fp-window",
+          d: `M ${c.X(o.lo)} ${y0} L ${r24(c.X(o.lo) + splay)} ${r24(y0 + proj)} L ${r24(c.X(o.hi) - splay)} ${r24(y0 + proj)} L ${c.X(o.hi)} ${y0}`
+        })
+      );
+    }
+  }
+  return parts.join("");
+}
+function jambLines(o, c) {
+  const tpx = c.px(c.wallT);
+  if (o.vertical) {
+    const x = c.X(o.along);
+    return [o.lo, o.hi].map((yy) => line({ class: "sx-fp-jamb", x1: r24(x - tpx / 2), y1: c.Y(yy), x2: r24(x + tpx / 2), y2: c.Y(yy) })).join("");
+  }
+  const y = c.Y(o.along);
+  return [o.lo, o.hi].map((xx) => line({ class: "sx-fp-jamb", x1: c.X(xx), y1: r24(y - tpx / 2), x2: c.X(xx), y2: r24(y + tpx / 2) })).join("");
+}
+function swingLeaf(o, c, hingeAtLo, widthM) {
+  const dir = o.inward;
+  const rpx = c.px(widthM);
+  if (o.vertical) {
+    const x = c.X(o.along);
+    const hy = hingeAtLo ? c.Y(o.lo) : c.Y(o.hi);
+    const sy = hingeAtLo ? 1 : -1;
+    const leafX = r24(x + dir * rpx);
+    const sweep2 = dir === 1 === hingeAtLo ? 1 : 0;
+    return line({ class: "sx-fp-door-leaf", x1: x, y1: hy, x2: leafX, y2: hy }) + path({ class: "sx-fp-door-arc", d: `M ${leafX} ${hy} A ${rpx} ${rpx} 0 0 ${sweep2} ${x} ${r24(hy + sy * rpx)}` });
+  }
+  const y = c.Y(o.along);
+  const hx = hingeAtLo ? c.X(o.lo) : c.X(o.hi);
+  const sx = hingeAtLo ? 1 : -1;
+  const leafY = r24(y + dir * rpx);
+  const sweep = dir === 1 !== hingeAtLo ? 1 : 0;
+  return line({ class: "sx-fp-door-leaf", x1: hx, y1: y, x2: hx, y2: leafY }) + path({ class: "sx-fp-door-arc", d: `M ${hx} ${leafY} A ${rpx} ${rpx} 0 0 ${sweep} ${r24(hx + sx * rpx)} ${y}` });
+}
+function doorSymbol(o, c) {
+  const wd = o.hi - o.lo;
+  if (o.doorType === "double") {
+    const half = { ...o };
+    const mid = (o.lo + o.hi) / 2;
+    const left = { ...half, hi: mid };
+    const right = { ...half, lo: mid };
+    return jambLines(o, c) + swingLeaf(left, c, true, wd / 2) + swingLeaf(right, c, false, wd / 2);
+  }
+  if (o.doorType === "bifold") {
+    const peak = c.px((o.hi - o.lo) * 0.22) * o.inward;
+    const q1 = o.lo + (o.hi - o.lo) * 0.25;
+    const mid = (o.lo + o.hi) / 2;
+    const q3 = o.lo + (o.hi - o.lo) * 0.75;
+    const parts = [jambLines(o, c)];
+    if (o.vertical) {
+      const x = c.X(o.along);
+      parts.push(
+        path({
+          class: "sx-fp-door-leaf",
+          d: `M ${x} ${c.Y(o.lo)} L ${r24(x + peak)} ${c.Y(q1)} L ${x} ${c.Y(mid)} L ${r24(x + peak)} ${c.Y(q3)} L ${x} ${c.Y(o.hi)}`
+        })
+      );
+    } else {
+      const y = c.Y(o.along);
+      parts.push(
+        path({
+          class: "sx-fp-door-leaf",
+          d: `M ${c.X(o.lo)} ${y} L ${c.X(q1)} ${r24(y + peak)} L ${c.X(mid)} ${y} L ${c.X(q3)} ${r24(y + peak)} L ${c.X(o.hi)} ${y}`
+        })
+      );
+    }
+    return parts.join("");
+  }
+  if (o.doorType === "sliding" || o.doorType === "pocket") {
+    const off = c.px(c.wallT) * 0.28;
+    const mid = (o.lo + o.hi) / 2;
+    const parts = [jambLines(o, c)];
+    if (o.vertical) {
+      const x = c.X(o.along);
+      parts.push(line({ class: "sx-fp-door-leaf", x1: r24(x - off), y1: c.Y(o.lo), x2: r24(x - off), y2: c.Y(mid) }));
+      if (o.doorType === "sliding") {
+        parts.push(line({ class: "sx-fp-door-leaf", x1: r24(x + off), y1: c.Y(mid), x2: r24(x + off), y2: c.Y(o.hi) }));
+      }
+    } else {
+      const y = c.Y(o.along);
+      parts.push(line({ class: "sx-fp-door-leaf", x1: c.X(o.lo), y1: r24(y - off), x2: c.X(mid), y2: r24(y - off) }));
+      if (o.doorType === "sliding") {
+        parts.push(line({ class: "sx-fp-door-leaf", x1: c.X(mid), y1: r24(y + off), x2: c.X(o.hi), y2: r24(y + off) }));
+      }
+    }
+    return parts.join("");
+  }
+  return jambLines(o, c) + swingLeaf(o, c, o.hinge !== "right", wd);
+}
+function renderDim(d, c) {
+  const cls = d.minor ? "sx-fp-dim-text-minor" : "sx-fp-dim-text";
+  const tick = 3.6;
+  if (!d.vertical) {
+    const y = c.Y(d.at);
+    const x1 = c.X(d.lo);
+    const x2 = c.X(d.hi);
+    return line({ class: "sx-fp-dim", x1, y1: y, x2, y2: y }) + line({ class: "sx-fp-dim", x1: r24(x1 - tick), y1: r24(y + tick), x2: r24(x1 + tick), y2: r24(y - tick) }) + line({ class: "sx-fp-dim", x1: r24(x2 - tick), y1: r24(y + tick), x2: r24(x2 + tick), y2: r24(y - tick) }) + text({ class: cls, x: r24((x1 + x2) / 2), y: r24(y - 4), "text-anchor": "middle" }, d.label);
+  }
+  const x = c.X(d.at);
+  const y1 = c.Y(d.lo);
+  const y2 = c.Y(d.hi);
+  const mid = r24((y1 + y2) / 2);
+  return line({ class: "sx-fp-dim", x1: x, y1, x2: x, y2 }) + line({ class: "sx-fp-dim", x1: r24(x - tick), y1: r24(y1 + tick), x2: r24(x + tick), y2: r24(y1 - tick) }) + line({ class: "sx-fp-dim", x1: r24(x - tick), y1: r24(y2 + tick), x2: r24(x + tick), y2: r24(y2 - tick) }) + text(
+    { class: cls, x: r24(x - 5), y: mid, "text-anchor": "middle", transform: `rotate(-90 ${r24(x - 5)} ${mid})` },
+    d.label
+  );
+}
+function renderFloorplanLayout(lay, config) {
+  const t = resolveFloorplanTheme(config?.theme ?? "default");
+  if (lay.errors.length > 0) return renderErrorPanel(lay, t);
+  const scale = FLOORPLAN_CONST.scale;
+  const px = (m) => r24(m * scale);
+  const band = FLOORPLAN_CONST.dimBand + FLOORPLAN_CONST.pad;
+  let outward = 0;
+  for (const o of lay.openings) {
+    if (o.kind !== "window") continue;
+    if (o.windowType === "casement") outward = Math.max(outward, o.hi - o.lo + 0.1);
+    if (o.windowType === "bay") outward = Math.max(outward, 0.6);
+  }
+  const tail = FLOORPLAN_CONST.pad + lay.wallT + outward;
+  const ox = -lay.bounds.minX + band;
+  const oy = -lay.bounds.minY + band;
+  const X = (m) => px(m + ox);
+  const Y = (m) => px(m + oy);
+  const ctx = { X, Y, px, t, wallT: lay.wallT };
+  const titleH = TITLE.bandH;
+  const warnH = lay.warnings.length ? lay.warnings.length * 17 + 10 : 0;
+  const W2 = px(lay.bounds.maxX - lay.bounds.minX + band + tail);
+  const H2 = px(lay.bounds.maxY - lay.bounds.minY + band + tail) + titleH + warnH;
+  const titleX = r24(X((lay.bounds.minX + lay.bounds.maxX) / 2));
+  const floors = [];
+  const furniture = [];
+  const walls = [];
+  const openings = [];
+  const labels = [];
+  const dims = [];
+  for (const r6 of lay.rooms) {
+    floors.push(
+      group(
+        { class: "sx-fp-floor", "data-room": r6.id },
+        r6.parts.map(
+          (p) => rect({
+            fill: r6.fill ?? t.floorFill,
+            x: X(p.x),
+            y: Y(p.y),
+            width: px(p.w),
+            height: px(p.h)
+          })
+        )
+      )
+    );
+    if (!r6.nolabel) {
+      const main = r6.parts.reduce((a, b) => b.w * b.h > a.w * a.h ? b : a);
+      const cx = X(main.x + main.w / 2);
+      const cy = Y(main.y + main.h / 2);
+      labels.push(text({ class: "sx-fp-room-name", x: cx, y: r24(cy - 3), "text-anchor": "middle" }, r6.label));
+      labels.push(text({ class: "sx-fp-room-area", x: cx, y: r24(cy + 13), "text-anchor": "middle" }, r6.areaText));
+    }
+  }
+  const warnSet = new Set(lay.warnItems);
+  lay.items.forEach((it, idx) => {
+    const def = FLOORPLAN_SYMBOLS[it.type];
+    const wpx = px(it.w);
+    const hpx = px(it.h);
+    const cx = r24(X(it.x) + wpx / 2);
+    const cy = r24(Y(it.y) + hpx / 2);
+    const rot = Math.round(it.rotate * 10) / 10;
+    const children = [def.draw({ w: it.w, h: it.h, px, label: it.label })];
+    if (warnSet.has(idx)) {
+      children.push(rect({ class: "sx-fp-warn-item", x: -1, y: -1, width: r24(wpx + 2), height: r24(hpx + 2) }));
+    }
+    furniture.push(
+      group(
+        {
+          class: "sx-fp-item",
+          "data-furniture": it.type,
+          transform: `translate(${cx},${cy})${rot ? ` rotate(${rot})` : ""} translate(${r24(-wpx / 2)},${r24(-hpx / 2)})`
+        },
+        children
+      )
+    );
+    if (it.label && !def.consumesLabel) {
+      labels.push(text({ class: "sx-fp-furn-label", x: cx, y: r24(cy + 4), "text-anchor": "middle" }, it.label));
+    }
+  });
+  const tw = lay.wallT;
+  for (const r6 of lay.rooms) {
+    for (const p of r6.parts) {
+      walls.push(rect({ class: "sx-fp-wall", x: r24(X(p.x) - px(tw / 2)), y: r24(Y(p.y) - px(tw / 2)), width: r24(px(p.w + tw)), height: px(tw) }));
+      walls.push(rect({ class: "sx-fp-wall", x: r24(X(p.x) - px(tw / 2)), y: r24(Y(p.y + p.h) - px(tw / 2)), width: r24(px(p.w + tw)), height: px(tw) }));
+      walls.push(rect({ class: "sx-fp-wall", x: r24(X(p.x) - px(tw / 2)), y: r24(Y(p.y) - px(tw / 2)), width: px(tw), height: r24(px(p.h + tw)) }));
+      walls.push(rect({ class: "sx-fp-wall", x: r24(X(p.x + p.w) - px(tw / 2)), y: r24(Y(p.y) - px(tw / 2)), width: px(tw), height: r24(px(p.h + tw)) }));
+    }
+  }
+  for (const s of lay.seams) {
+    const fill = lay.rooms[s.room]?.fill ?? t.floorFill;
+    const tpx = px(tw);
+    if (s.vertical) {
+      openings.push(
+        rect({ class: "sx-fp-gap", fill, x: r24(X(s.along) - tpx / 2 - 0.5), y: Y(s.lo), width: r24(tpx + 1), height: px(s.hi - s.lo) })
+      );
+    } else {
+      openings.push(
+        rect({ class: "sx-fp-gap", fill, x: X(s.lo), y: r24(Y(s.along) - tpx / 2 - 0.5), width: px(s.hi - s.lo), height: r24(tpx + 1) })
+      );
+    }
+  }
+  for (const o of lay.openings) {
+    openings.push(punchGap(o, lay, ctx));
+    if (o.kind === "window") openings.push(windowSymbol(o, ctx));
+    else if (o.kind === "door") openings.push(doorSymbol(o, ctx));
+    else openings.push(jambLines(o, ctx));
+  }
+  for (const d of lay.dims) dims.push(renderDim(d, ctx));
+  if (lay.north !== void 0) {
+    const ncx = r24(X(lay.bounds.maxX) + px(0.55));
+    const ncy = r24(Y(lay.bounds.minY) - px(0.62));
+    const rr = px(0.32);
+    const rot = Math.round(lay.north * 10) / 10;
+    dims.push(
+      group({ class: "sx-fp-compass-g", transform: rot ? `rotate(${rot} ${ncx} ${ncy})` : "" }, [
+        el("circle", { class: "sx-fp-compass", cx: ncx, cy: ncy, r: rr }),
+        line({ class: "sx-fp-compass", x1: ncx, y1: r24(ncy + rr * 0.7), x2: ncx, y2: r24(ncy - rr * 0.55) }),
+        el("polygon", {
+          class: "sx-fp-compass",
+          fill: t.dimText,
+          points: `${ncx},${r24(ncy - rr * 0.85)} ${r24(ncx - rr * 0.22)},${r24(ncy - rr * 0.3)} ${r24(ncx + rr * 0.22)},${r24(ncy - rr * 0.3)}`
+        }),
+        text({ class: "sx-fp-compass-n", x: r24(ncx + rr + 4), y: r24(ncy - rr * 0.45), "text-anchor": "start" }, "N")
+      ])
+    );
+  }
+  const warnBlock = [];
+  if (lay.warnings.length) {
+    const y0 = H2 - warnH + 4;
+    lay.warnings.forEach((w, i) => {
+      warnBlock.push(text({ class: "sx-fp-warn", x: 10, y: r24(y0 + i * 17 + 10) }, `\u26A0 ${w}`));
+    });
+  }
+  const nRooms = lay.rooms.length;
+  const descText = `${nRooms} room${nRooms === 1 ? "" : "s"}, ${formatArea(lay.totalAreaM2, lay.unit)} total. ${lay.items.length} furniture item${lay.items.length === 1 ? "" : "s"}.` + (lay.warnings.length ? ` Warnings: ${lay.warnings.join("; ")}.` : "");
+  return svgRoot(
+    { viewBox: `0 0 ${W2} ${H2}`, class: "sx-fp", role: "img" },
+    [
+      title(lay.title),
+      desc(descText),
+      el("style", {}, buildCss13(t)),
+      rect({ fill: t.bg, x: 0, y: 0, width: W2, height: H2 }),
+      text({ class: "sx-fp-title", x: titleX, y: TITLE.y, "text-anchor": "middle" }, lay.title),
+      group({ transform: `translate(0,${titleH})` }, [
+        group({ class: "sx-fp-floors" }, floors),
+        group({ class: "sx-fp-furniture" }, furniture),
+        group({ class: "sx-fp-walls" }, walls),
+        group({ class: "sx-fp-openings" }, openings),
+        group({ class: "sx-fp-labels" }, labels),
+        group({ class: "sx-fp-dims" }, dims)
+      ]),
+      ...warnBlock
+    ]
+  );
+}
+function renderFloorplan(text2, config) {
+  return renderFloorplanLayout(layoutFloorplan(parseFloorplan(text2)), config);
+}
+
+// src/diagrams/floorplan/index.ts
+var floorplan = {
+  type: "floorplan",
+  detect(text2) {
+    for (const raw of text2.split(/\r?\n/)) {
+      const t = raw.trim();
+      if (!t) continue;
+      if (t.startsWith("#") || t.startsWith("//")) continue;
+      return /^floorplan\b/i.test(t);
+    }
+    return false;
+  },
+  parse: parseFloorplan,
+  render(text2, config) {
+    return renderFloorplan(text2, config);
+  },
+  lint(text2) {
+    try {
+      const lay = layoutFloorplan(parseFloorplan(text2));
+      return [
+        ...lay.errors.map(
+          (message) => ({
+            severity: "error",
+            code: "floorplan/validation",
+            message,
+            fatal: false
+          })
+        ),
+        ...lay.warnings.map(
+          (message) => ({
+            severity: "warning",
+            code: "floorplan/warning",
+            message,
+            fatal: false
+          })
+        )
+      ];
+    } catch {
+      return [];
+    }
+  }
+};
+
 // src/core/api.ts
 var plugins = [
   genogram,
@@ -36017,7 +38519,8 @@ var plugins = [
   epc,
   idef0,
   threatmodel,
-  welding
+  welding,
+  floorplan
 ];
 function detectPlugin(text2, config) {
   if (config?.type) {
@@ -36028,7 +38531,7 @@ function detectPlugin(text2, config) {
     if (plugin.detect(text2)) return plugin;
   }
   throw new Error(
-    "Cannot detect diagram type. Start your text with 'genogram', 'ecomap', 'pedigree', 'phylo', 'sociogram', 'timing', 'logic', 'circuit', 'blockdiagram', 'ladder', 'sld', 'entity-structure', 'fishbone', 'venn', 'flowchart', 'mindmap', 'matrix', 'orgchart', 'state', 'pid', 'erd', 'breadboard', 'bpmn', 'fbd', 'sfc', 'prisma', 'usecase', 'pert', 'sequence', 'petri', 'network', 'umlclass', 'faulttree', or 'bowtie'."
+    "Cannot detect diagram type. Start your text with 'genogram', 'ecomap', 'pedigree', 'phylo', 'sociogram', 'timing', 'logic', 'circuit', 'blockdiagram', 'ladder', 'sld', 'entity-structure', 'fishbone', 'venn', 'flowchart', 'mindmap', 'matrix', 'orgchart', 'state', 'pid', 'erd', 'breadboard', 'bpmn', 'fbd', 'sfc', 'prisma', 'usecase', 'pert', 'sequence', 'petri', 'network', 'umlclass', 'faulttree', 'bowtie', or 'floorplan'."
   );
 }
 function stripCodeFences(text2) {
@@ -36165,6 +38668,6 @@ function renderWithPlugin(prepared, plugin, config) {
   return plugin.render(prepared, renderConfig);
 }
 
-export { GEOMETRY, bowtie2 as bowtie, causalloop, decisiontree, drawDeviceIcon, epc, eventtree, faulttree, fmea, gitgraph, iconSize, idef0, markov, network, parse, parseResult, pert, petri, pid, prisma, render, renderEquip, renderPreview, renderResult, sequence, state, threatmodel, timeline, umlclass, usecase, welding };
-//# sourceMappingURL=chunk-TP7LQ5PF.js.map
-//# sourceMappingURL=chunk-TP7LQ5PF.js.map
+export { FLOORPLAN_SYMBOLS, GEOMETRY, bowtie2 as bowtie, causalloop, decisiontree, drawDeviceIcon, epc, eventtree, faulttree, fmea, gitgraph, iconSize, idef0, markov, network, parse, parseResult, pert, petri, pid, prisma, render, renderEquip, renderPreview, renderResult, sequence, state, threatmodel, timeline, umlclass, usecase, welding };
+//# sourceMappingURL=chunk-BP6MLXJU.js.map
+//# sourceMappingURL=chunk-BP6MLXJU.js.map