schematex 0.9.2 → 0.9.4

package/dist/{chunk-TP7LQ5PF.js → chunk-UFXDAIDD.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-3J4DZPZC.js';
+import { circuit } from './chunk-RDYACU2G.js';
+import { blockdiagram } from './chunk-3PH2MQGN.js';
+import { ladder } from './chunk-B4CMWA6Y.js';
+import { sld } from './chunk-PFZKW3HE.js';
+import { entity } from './chunk-JEMAOC2D.js';
+import { fishbone } from './chunk-GYYYULBL.js';
+import { venn } from './chunk-SXOAAQNY.js';
+import { flowchart, layoutFlowchart } from './chunk-AXMBXAEA.js';
+import { genogram } from './chunk-M26ORU4P.js';
+import { ecomap, estimateTextWidth } from './chunk-XCCXG6RR.js';
+import { pedigree } from './chunk-ZCHGIWJK.js';
 import { parseFrontmatter } from './chunk-2KTQ75LN.js';
-import { phylo } from './chunk-VZVREOTM.js';
-import { sociogram } from './chunk-56DSMSXK.js';
+import { phylo } from './chunk-3WX24RCH.js';
+import { sociogram } from './chunk-64LABNTF.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-NKYR4PAS.js';
+import { resolveBaseTheme, resolveTimelineTheme, resolveStateTheme, cssCustomProperties, resolvePetriTheme, resolveNetworkTheme, resolveUmlClassTheme, DEFAULT_FONT_FAMILY, FONT_SIZE, resolveReliabilityTheme, STROKE_WIDTH, resolveBowtieTheme, resolveMindmapTheme, resolveMatrixTheme, resolveBpmnTheme, resolveFloorplanTheme, TITLE, resolvePlaybookTheme } from './chunk-4MRVJI7G.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';
 
@@ -1876,7 +1876,7 @@ function parseTimeline(src) {
   let i = 0;
   let autoId = 0;
   const nextId2 = (prefix) => `${prefix}-${++autoId}`;
-  const ordinal = { index: 0 };
+  const ordinal2 = { index: 0 };
   const first = lines[0];
   if (/^timeline\b/i.test(first.text)) {
     const rest = first.text.replace(/^timeline\b/i, "").trim();
@@ -1947,7 +1947,7 @@ function parseTimeline(src) {
           i++;
           continue;
         }
-        const parsed2 = parseEventLine(child.text, child.line, nextId2, ordinal);
+        const parsed2 = parseEventLine(child.text, child.line, nextId2, ordinal2);
         if (!parsed2) throw new TimelineParseError(`Unrecognized line in ${keyword}: ${child.text}`, child.line);
         parsed2.event.trackId = trackId;
         ast.events.push(parsed2.event);
@@ -1961,7 +1961,7 @@ function parseTimeline(src) {
       }
       continue;
     }
-    const parsed = parseEventLine(text2, L.line, nextId2, ordinal);
+    const parsed = parseEventLine(text2, L.line, nextId2, ordinal2);
     if (parsed) {
       ast.events.push(parsed.event);
       i++;
@@ -1985,12 +1985,12 @@ function safeParseDate(raw, line2) {
     throw new TimelineParseError(msg, line2);
   }
 }
-function parseRowKey(raw, ordinal) {
+function parseRowKey(raw, ordinal2) {
   const parsed = tryParseDate(raw);
   if (parsed) return parsed;
-  ordinal.index += 1;
+  ordinal2.index += 1;
   return {
-    value: ordinal.index,
+    value: ordinal2.index,
     raw,
     precision: "ordinal"
   };
@@ -2027,7 +2027,7 @@ function applyConfig(ast, k, v, line2) {
       (ast.metadata ??= {})[k] = v;
   }
 }
-function parseEventLine(text2, line2, nextId2, ordinal) {
+function parseEventLine(text2, line2, nextId2, ordinal2) {
   const { props, rest } = parseProperties(text2, line2);
   const { date, end, body } = splitDateAndBody(rest, line2);
   let kind = end ? "range" : "point";
@@ -2044,8 +2044,8 @@ function parseEventLine(text2, line2, nextId2, ordinal) {
     id: nextId2("ev"),
     label,
     kind,
-    start: parseRowKey(date, ordinal),
-    end: end ? parseRowKey(end, ordinal) : void 0,
+    start: parseRowKey(date, ordinal2),
+    end: end ? parseRowKey(end, ordinal2) : void 0,
     icon: props["icon"],
     shape: props["shape"],
     color: props["color"],
@@ -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,4028 @@ 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}`, width: r24(w), height: 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}`, width: W2, height: 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/diagrams/playbook/parser.ts
+var PlaybookParseError = class extends Error {
+  line;
+  constructor(message, line2) {
+    super(`line ${line2}: ${message}`);
+    this.name = "PlaybookParseError";
+    this.line = line2;
+  }
+};
+var isStr2 = (t) => t !== void 0 && "str" in t;
+var isWord2 = (t, w) => t !== void 0 && "word" in t && (w === void 0 || t.word.toLowerCase() === w);
+var tokDisplay = (t) => "word" in t ? t.word : `"${t.str}"`;
+var normalizeQuotes4 = (s) => s.replace(/[“”「」『』]/g, '"').replace(/[‘’]/g, "'");
+function tokenize8(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 parseNum2(t, what, ln) {
+  if (!isWord2(t)) throw new PlaybookParseError(`expected a number for ${what}`, ln);
+  const v = Number(t.word);
+  if (!Number.isFinite(v)) throw new PlaybookParseError(`expected a number for ${what}, got "${t.word}"`, ln);
+  return v;
+}
+function parseId2(t, what, ln) {
+  if (!isWord2(t)) throw new PlaybookParseError(`expected ${what}`, ln);
+  return t.word;
+}
+var COORD = /^([+-]?\d*\.?\d+),([+-]?\d*\.?\d+)$/;
+var POSITIONS = ["o", "c", "ol", "qb", "rb", "wr", "te", "x", "dl", "lb", "db", "s", "gk"];
+var NAMED_ROUTES = [
+  "go",
+  "fly",
+  "streak",
+  "vertical",
+  "slant",
+  "flat",
+  "hitch",
+  "out",
+  "in",
+  "dig",
+  "curl",
+  "comeback",
+  "corner",
+  "flag",
+  "post",
+  "wheel",
+  "cross",
+  "drag",
+  "seam",
+  "screen",
+  "dive",
+  "iso",
+  "power",
+  "counter",
+  "sweep",
+  "toss",
+  "draw",
+  "trap"
+];
+var RUN_CONCEPTS = /* @__PURE__ */ new Set(["dive", "iso", "power", "counter", "sweep", "toss", "draw", "trap"]);
+var FORMATIONS = [
+  "i-form",
+  "shotgun",
+  "singleback",
+  "pistol",
+  "trips",
+  "spread",
+  "trips-right",
+  "trips-left",
+  "empty",
+  "goal-line",
+  "wishbone",
+  "4-4-2",
+  "4-3-3",
+  "4-2-3-1",
+  "3-5-2",
+  "4-4-1-1",
+  "4-5-1",
+  "3-4-3",
+  "horns",
+  "1-4-high",
+  "1-4-low",
+  "box",
+  "spread-pnr",
+  "5-out",
+  "4-out"
+];
+var DEFENSES = [
+  "4-3",
+  "3-4",
+  "4-4",
+  "nickel",
+  "dime",
+  "cover-0",
+  "cover-1",
+  "cover-2",
+  "cover-3",
+  "cover-4",
+  "cover-6",
+  "man",
+  "zone-2-3",
+  "zone-3-2",
+  "zone-1-3-1",
+  "low-block",
+  "mid-block",
+  "high-press"
+];
+var DIRS = ["left", "right"];
+function parseHeader4(tok, ast, ln) {
+  while (tok.length) {
+    const t = tok.shift();
+    if (isStr2(t)) ast.title = t.str;
+    else if (isWord2(t, "sport")) {
+      const s = parseId2(tok.shift(), "sport", ln).toLowerCase();
+      if (s !== "football" && s !== "basketball" && s !== "soccer") {
+        throw new PlaybookParseError(`sport must be football|basketball|soccer, got "${s}"`, ln);
+      }
+      ast.sport = s;
+    } else throw new PlaybookParseError(`playbook: unexpected token "${tokDisplay(t)}"`, ln);
+  }
+}
+function parseField(tok, ast, ln) {
+  while (tok.length) {
+    const t = tok.shift();
+    if (isWord2(t, "down")) ast.down = parseNum2(tok.shift(), "down", ln);
+    else if (isWord2(t, "distance") || isWord2(t, "togo")) ast.distance = parseNum2(tok.shift(), "distance", ln);
+    else if (isWord2(t, "los") || isWord2(t, "ball")) ast.losYard = parseNum2(tok.shift(), "los", ln);
+    else if (isWord2(t, "goal") || isWord2(t, "togoal")) ast.toGoal = parseNum2(tok.shift(), "goal", ln);
+    else if (isWord2(t, "view")) {
+      const v = parseId2(tok.shift(), "view (full|half)", ln).toLowerCase();
+      if (v !== "full" && v !== "half" && v !== "auto") throw new PlaybookParseError(`view must be full|half`, ln);
+      ast.view = v;
+    } else if (isWord2(t, "hash")) {
+      const h = parseId2(tok.shift(), "hash (nfl|college|none)", ln).toLowerCase();
+      if (h !== "nfl" && h !== "college" && h !== "none") throw new PlaybookParseError(`hash must be nfl|college|none`, ln);
+      ast.hash = h;
+    } else throw new PlaybookParseError(`field: unexpected token "${tokDisplay(t)}"`, ln);
+  }
+}
+function parseFormation(tok, ast, ln) {
+  let name = parseId2(tok.shift(), "a formation", ln).toLowerCase();
+  let side;
+  const hy = /^(.*)-(left|right)$/.exec(name);
+  if (hy && FORMATIONS.includes(hy[1]) && hy[1] !== "trips") {
+    name = hy[1];
+    side = hy[2];
+  }
+  if (!FORMATIONS.includes(name)) {
+    throw new PlaybookParseError(`unknown formation "${name}"`, ln);
+  }
+  ast.formation = name;
+  while (tok.length) {
+    const t = tok.shift();
+    if (isWord2(t, "left") || isWord2(t, "right")) side = t.word.toLowerCase();
+    else throw new PlaybookParseError(`formation: unexpected token "${tokDisplay(t)}"`, ln);
+  }
+  if (name === "trips-right") ast.formationSide = "right";
+  else if (name === "trips-left") ast.formationSide = "left";
+  else if (side) ast.formationSide = side;
+}
+function parseDefense(tok, ast, ln) {
+  const d = parseId2(tok.shift(), "a defensive scheme", ln).toLowerCase();
+  if (!DEFENSES.includes(d)) throw new PlaybookParseError(`unknown defense "${d}"`, ln);
+  ast.defense = d;
+}
+function parsePlayer(tok, ast, ln) {
+  const id = parseId2(tok.shift(), "a player id", ln);
+  const posRaw = parseId2(tok.shift(), "a position", ln).toLowerCase();
+  if (!POSITIONS.includes(posRaw)) throw new PlaybookParseError(`unknown position "${posRaw}"`, ln);
+  const isDef = posRaw === "x" || posRaw === "dl" || posRaw === "lb" || posRaw === "db" || posRaw === "s";
+  const p = { id, side: isDef ? "defense" : "offense", pos: posRaw, label: id, line: ln };
+  while (tok.length) {
+    const t = tok.shift();
+    if (isStr2(t)) p.label = t.str;
+    else if (isWord2(t, "label")) {
+      const lt = tok.shift();
+      p.label = isStr2(lt) ? lt.str : parseId2(lt, "a label", ln);
+    } else if (isWord2(t, "at")) {
+      const c = COORD.exec(parseId2(tok.shift(), "x,y", ln));
+      if (!c) throw new PlaybookParseError(`expected "x,y" after at`, ln);
+      p.at = { x: Number(c[1]), y: Number(c[2]) };
+    } else if (isWord2(t, "side")) {
+      const sv = parseId2(tok.shift(), "side", ln).toLowerCase();
+      if (sv !== "offense" && sv !== "defense") throw new PlaybookParseError(`side must be offense|defense`, ln);
+      p.side = sv;
+    } else throw new PlaybookParseError(`player: unexpected token "${tokDisplay(t)}"`, ln);
+  }
+  ast.players.push(p);
+}
+function splitNameDir(token) {
+  const m = /^(.*)-(left|right)$/.exec(token.toLowerCase());
+  if (m) return { name: m[1], dir: m[2] };
+  return { name: token.toLowerCase() };
+}
+function parseDests(tok) {
+  const pts = [];
+  while (tok.length) {
+    const t = tok.shift();
+    if (isWord2(t, "to") || isWord2(t, "then") || isWord2(t, "->")) continue;
+    if (!isWord2(t)) continue;
+    const c = COORD.exec(t.word);
+    if (c) {
+      const rel = /^[+]/.test(c[1]) || /^[+]/.test(c[2]);
+      pts.push({ x: Number(c[1]), y: Number(c[2]), rel });
+    } else {
+      pts.push({ ref: t.word });
+    }
+  }
+  return pts;
+}
+function parseRouteRun(kind, tok, ast, ln) {
+  const player = parseId2(tok.shift(), "a player id", ln);
+  const m = { player, kind, line: ln };
+  const first = tok[0];
+  if (isWord2(first, "to") || isWord2(first, "path")) {
+    tok.shift();
+    m.points = parseDests(tok);
+    ast.moves.push(m);
+    return;
+  }
+  if (isWord2(first)) {
+    const { name, dir } = splitNameDir(first.word);
+    if (NAMED_ROUTES.includes(name)) {
+      tok.shift();
+      m.named = name;
+      if (dir) m.dir = dir;
+      if (kind === "route" && RUN_CONCEPTS.has(name)) m.kind = "run";
+      while (tok.length) {
+        const t = tok.shift();
+        if (isWord2(t) && DIRS.includes(t.word.toLowerCase())) m.dir = t.word.toLowerCase();
+        else if (isWord2(t) && Number.isFinite(Number(t.word))) m.depth = Number(t.word);
+        else if (isWord2(t, "depth")) m.depth = parseNum2(tok.shift(), "depth", ln);
+        else throw new PlaybookParseError(`${kind}: unexpected token "${tokDisplay(t)}"`, ln);
+      }
+      ast.moves.push(m);
+      return;
+    }
+  }
+  m.points = parseDests(tok);
+  if (m.points.length === 0) throw new PlaybookParseError(`${kind} ${player}: needs a route name or destination`, ln);
+  ast.moves.push(m);
+}
+function parsePoly(kind, tok, ast, ln) {
+  const player = parseId2(tok.shift(), "a player id", ln);
+  const points = parseDests(tok);
+  if (points.length === 0) throw new PlaybookParseError(`${kind} ${player}: needs a destination (x,y or a landmark)`, ln);
+  ast.moves.push({ player, kind, points, line: ln });
+}
+function parseTargeted(kind, tok, ast, ln, optionalTarget = false) {
+  const player = parseId2(tok.shift(), "a player id", ln);
+  const nxt = tok[0];
+  if (isWord2(nxt, "to")) tok.shift();
+  const tgt = tok.shift();
+  if (!tgt) {
+    if (optionalTarget) {
+      ast.moves.push({ player, kind, line: ln });
+      return;
+    }
+    throw new PlaybookParseError(`${kind} ${player}: needs a target (player id, landmark, or x,y)`, ln);
+  }
+  const target = isWord2(tgt) ? tgt.word : tgt.str;
+  ast.moves.push({ player, kind, target, line: ln });
+}
+function parsePull(tok, ast, ln) {
+  const player = parseId2(tok.shift(), "a lineman id", ln);
+  const dt = tok.shift();
+  const { dir } = splitNameDir(isWord2(dt) ? dt.word : "");
+  let d = dir;
+  if (!d && isWord2(dt) && DIRS.includes(dt.word.toLowerCase())) d = dt.word.toLowerCase();
+  if (!d) throw new PlaybookParseError(`pull: expected left|right`, ln);
+  ast.moves.push({ player, kind: "pull", named: "power", dir: d, line: ln });
+}
+function parseMotion(tok, ast, ln) {
+  const player = parseId2(tok.shift(), "a player id", ln);
+  const m = { player, kind: "motion", line: ln };
+  const dt = tok.shift();
+  if (isWord2(dt) && DIRS.includes(dt.word.toLowerCase())) {
+    m.dir = dt.word.toLowerCase();
+    const n = tok.shift();
+    if (isWord2(n) && Number.isFinite(Number(n.word))) m.depth = Number(n.word);
+  } else if (isWord2(dt, "to")) {
+    m.points = parseDests(tok);
+  } else if (isWord2(dt)) {
+    const c = COORD.exec(dt.word);
+    if (c) m.points = [{ x: Number(c[1]), y: Number(c[2]), rel: /^[+]/.test(c[1]) }];
+    else m.points = [{ ref: dt.word }];
+  } else throw new PlaybookParseError(`motion: expected left|right or a destination`, ln);
+  ast.moves.push(m);
+}
+function parseZone(tok, ast, ln) {
+  const z = { x: 0, y: 0, rx: 6, ry: 5, line: ln };
+  while (tok.length) {
+    const t = tok.shift();
+    if (isStr2(t)) z.label = t.str;
+    else if (isWord2(t, "at")) {
+      const c = COORD.exec(parseId2(tok.shift(), "x,y", ln));
+      if (!c) throw new PlaybookParseError(`zone: expected "x,y" after at`, ln);
+      z.x = Number(c[1]);
+      z.y = Number(c[2]);
+    } else if (isWord2(t, "size")) {
+      const st = tok.shift();
+      const m = /^(\d*\.?\d+)x(\d*\.?\d+)$/i.exec(isWord2(st) ? st.word : "");
+      if (!m) throw new PlaybookParseError(`zone size expects "rxXry"`, ln);
+      z.rx = Number(m[1]);
+      z.ry = Number(m[2]);
+    } else if (isWord2(t, "label")) {
+      const lt = tok.shift();
+      z.label = isStr2(lt) ? lt.str : parseId2(lt, "a label", ln);
+    } else throw new PlaybookParseError(`zone: unexpected token "${tokDisplay(t)}"`, ln);
+  }
+  ast.zones.push(z);
+}
+function parseHandoff(tok, ast, ln) {
+  const from = parseId2(tok.shift(), "the source id", ln);
+  const to = parseId2(tok.shift(), "the target id", ln);
+  ast.moves.push({ player: from, kind: "handoff", target: to, line: ln });
+}
+function parsePlaybook(text2) {
+  const ast = {
+    type: "playbook",
+    title: "Football Play",
+    sport: "football",
+    down: 0,
+    distance: 0,
+    hash: "nfl",
+    view: "auto",
+    formationSide: "right",
+    players: [],
+    moves: [],
+    zones: []
+  };
+  let sawHeader = false;
+  let titleSetByUser = false;
+  const lines = text2.split(/\r?\n/);
+  for (let i = 0; i < lines.length; i++) {
+    const ln = i + 1;
+    const raw = normalizeQuotes4(lines[i]).trim();
+    if (!raw) continue;
+    const all = tokenize8(raw);
+    const tok = [];
+    for (const t of all) {
+      if (isWord2(t) && (t.word.startsWith("#") || t.word.startsWith("//"))) break;
+      tok.push(t);
+    }
+    if (tok.length === 0) continue;
+    const head = tok.shift();
+    if (!isWord2(head)) throw new PlaybookParseError(`unexpected string at line start`, ln);
+    const kw = head.word.toLowerCase();
+    if (kw === "playbook") {
+      const before = ast.title;
+      parseHeader4(tok, ast, ln);
+      if (ast.title !== before) titleSetByUser = true;
+      sawHeader = true;
+      continue;
+    }
+    if (!sawHeader) throw new PlaybookParseError(`the first statement must be the "playbook" header`, ln);
+    if (kw === "field") parseField(tok, ast, ln);
+    else if (kw === "view") {
+      const v = parseId2(tok.shift(), "view (full|half)", ln).toLowerCase();
+      if (v !== "full" && v !== "half" && v !== "auto") throw new PlaybookParseError(`view must be full|half`, ln);
+      ast.view = v;
+    } else if (kw === "formation" || kw === "set") parseFormation(tok, ast, ln);
+    else if (kw === "defense" || kw === "def") parseDefense(tok, ast, ln);
+    else if (kw === "player") parsePlayer(tok, ast, ln);
+    else if (kw === "route") parseRouteRun("route", tok, ast, ln);
+    else if (kw === "run") parseRouteRun("run", tok, ast, ln);
+    else if (kw === "cut") parsePoly("cut", tok, ast, ln);
+    else if (kw === "move") parsePoly("move", tok, ast, ln);
+    else if (kw === "dribble" || kw === "drive") parsePoly("dribble", tok, ast, ln);
+    else if (kw === "pass") parseTargeted("pass", tok, ast, ln);
+    else if (kw === "screen") parseTargeted("screen", tok, ast, ln);
+    else if (kw === "block") parseTargeted("block", tok, ast, ln);
+    else if (kw === "shot" || kw === "shoot") parseTargeted("shot", tok, ast, ln, true);
+    else if (kw === "pull") parsePull(tok, ast, ln);
+    else if (kw === "handoff") parseHandoff(tok, ast, ln);
+    else if (kw === "motion") parseMotion(tok, ast, ln);
+    else if (kw === "zone") parseZone(tok, ast, ln);
+    else throw new PlaybookParseError(`unknown keyword "${kw}"`, ln);
+  }
+  if (!titleSetByUser) {
+    ast.title = ast.sport === "basketball" ? "Basketball Play" : ast.sport === "soccer" ? "Soccer Tactic" : "Football Play";
+  }
+  return ast;
+}
+
+// src/diagrams/playbook/geometry/football.ts
+var K = {
+  scale: 14,
+  olSplit: 1.4,
+  wrSplit: 13,
+  slotSplit: 6,
+  minHalfWidth: 20,
+  margin: 2,
+  hashNfl: 3.08,
+  hashCollege: 6.67
+};
+var r25 = (n) => Math.round(n * 100) / 100;
+var round22 = (p) => ({ x: Math.round(p.x * 100) / 100, y: Math.round(p.y * 100) / 100 });
+var dirSign = (d) => d === "right" ? 1 : -1;
+function offensiveLine() {
+  return [
+    { id: "LT", pos: "ol", label: "T", x: -2 * K.olSplit, y: 0 },
+    { id: "LG", pos: "ol", label: "G", x: -1 * K.olSplit, y: 0 },
+    { id: "C", pos: "c", label: "C", x: 0, y: 0 },
+    { id: "RG", pos: "ol", label: "G", x: 1 * K.olSplit, y: 0 },
+    { id: "RT", pos: "ol", label: "T", x: 2 * K.olSplit, y: 0 }
+  ];
+}
+function tightEnd(side) {
+  const s = side === "right" ? 1 : -1;
+  return { id: "Y", pos: "te", label: "Y", x: s * (2 * K.olSplit + 1.3), y: 0 };
+}
+function formationRoster(formation, side) {
+  const s = side === "right" ? 1 : -1;
+  const ol = offensiveLine();
+  const X = { id: "X", pos: "wr", label: "X", x: -s * K.wrSplit, y: 0 };
+  const Z = { id: "Z", pos: "wr", label: "Z", x: s * K.wrSplit, y: -1 };
+  switch (formation) {
+    case "i-form":
+      return [
+        ...ol,
+        tightEnd(side),
+        { id: "QB", pos: "qb", label: "QB", x: 0, y: -1.5 },
+        { id: "FB", pos: "rb", label: "F", x: 0, y: -3.6 },
+        { id: "RB", pos: "rb", label: "RB", x: 0, y: -6.2 },
+        X,
+        Z
+      ];
+    case "wishbone":
+      return [
+        ...ol,
+        tightEnd(side),
+        { id: "QB", pos: "qb", label: "QB", x: 0, y: -1.5 },
+        { id: "FB", pos: "rb", label: "F", x: 0, y: -3.4 },
+        { id: "LH", pos: "rb", label: "H", x: -3.5, y: -5.2 },
+        { id: "RB", pos: "rb", label: "H", x: 3.5, y: -5.2 },
+        X
+      ];
+    case "singleback":
+      return [
+        ...ol,
+        tightEnd(side),
+        { id: "QB", pos: "qb", label: "QB", x: 0, y: -1.5 },
+        { id: "RB", pos: "rb", label: "RB", x: 0, y: -5 },
+        X,
+        { id: "H", pos: "wr", label: "H", x: s * K.slotSplit, y: -1 },
+        Z
+      ];
+    case "pistol":
+      return [
+        ...ol,
+        tightEnd(side),
+        { id: "QB", pos: "qb", label: "QB", x: 0, y: -4 },
+        { id: "RB", pos: "rb", label: "RB", x: 0, y: -7 },
+        X,
+        Z
+      ];
+    case "shotgun":
+      return [
+        ...ol,
+        tightEnd(side),
+        { id: "QB", pos: "qb", label: "QB", x: 0, y: -5 },
+        { id: "RB", pos: "rb", label: "RB", x: s * 1.8, y: -5 },
+        X,
+        Z
+      ];
+    case "spread":
+      return [
+        ...ol,
+        { id: "QB", pos: "qb", label: "QB", x: 0, y: -5 },
+        { id: "RB", pos: "rb", label: "RB", x: s * 1.8, y: -5 },
+        { id: "X", pos: "wr", label: "X", x: -13 - 1, y: 0 },
+        { id: "H", pos: "wr", label: "H", x: -6, y: -1 },
+        { id: "Y", pos: "wr", label: "Y", x: K.slotSplit, y: -1 },
+        { id: "Z", pos: "wr", label: "Z", x: K.wrSplit + 1, y: 0 }
+      ];
+    case "trips":
+    case "trips-right":
+    case "trips-left": {
+      const t = formation === "trips-left" ? -1 : formation === "trips-right" ? 1 : s;
+      return [
+        ...ol,
+        { id: "QB", pos: "qb", label: "QB", x: 0, y: -5 },
+        { id: "RB", pos: "rb", label: "RB", x: -t * 1.8, y: -5 },
+        { id: "X", pos: "wr", label: "X", x: -t * (K.wrSplit + 1), y: 0 },
+        { id: "Z", pos: "wr", label: "Z", x: t * (K.wrSplit + 1), y: 0 },
+        { id: "H", pos: "wr", label: "H", x: t * 9, y: -1 },
+        { id: "Y", pos: "wr", label: "Y", x: t * 5, y: -1 }
+      ];
+    }
+    case "empty":
+      return [
+        ...ol,
+        { id: "QB", pos: "qb", label: "QB", x: 0, y: -5 },
+        { id: "X", pos: "wr", label: "X", x: -13 - 1, y: 0 },
+        { id: "H", pos: "wr", label: "H", x: -6 - 1, y: -1 },
+        { id: "Z", pos: "wr", label: "Z", x: K.wrSplit + 1, y: 0 },
+        { id: "Y", pos: "wr", label: "Y", x: K.slotSplit + 1, y: -1 },
+        { id: "H2", pos: "wr", label: "h", x: K.slotSplit - 2, y: -1 }
+      ];
+    case "goal-line":
+      return [
+        ...ol,
+        { id: "Y", pos: "te", label: "Y", x: 2 * K.olSplit + 1.3, y: 0 },
+        { id: "TE2", pos: "te", label: "Y", x: -4.1, y: 0 },
+        { id: "QB", pos: "qb", label: "QB", x: 0, y: -1.5 },
+        { id: "FB", pos: "rb", label: "F", x: 0, y: -3.4 },
+        { id: "RB", pos: "rb", label: "RB", x: 0, y: -5.4 },
+        { id: "Z", pos: "wr", label: "Z", x: s * 9, y: 0 }
+      ];
+    default:
+      return [...ol, { id: "QB", pos: "qb", label: "QB", x: 0, y: -1.5 }];
+  }
+}
+function front43(side) {
+  const s = side === "right" ? 1 : -1;
+  return [
+    { id: "DE_W", pos: "dl", label: "E", x: -3.6, y: 1 },
+    { id: "DT_W", pos: "dl", label: "T", x: -1.2, y: 1 },
+    { id: "DT_S", pos: "dl", label: "T", x: 1.2, y: 1 },
+    { id: "DE_S", pos: "dl", label: "E", x: 3.6, y: 1 },
+    { id: "WLB", pos: "lb", label: "W", x: -4.5, y: 4.3 },
+    { id: "MLB", pos: "lb", label: "M", x: 0, y: 4.8 },
+    { id: "SLB", pos: "lb", label: "S", x: s * 4.5, y: 4.3 }
+  ];
+}
+function front34(side) {
+  const s = side === "right" ? 1 : -1;
+  return [
+    { id: "DE_W", pos: "dl", label: "E", x: -2.6, y: 1 },
+    { id: "NT", pos: "dl", label: "N", x: 0, y: 1 },
+    { id: "DE_S", pos: "dl", label: "E", x: 2.6, y: 1 },
+    { id: "WOLB", pos: "lb", label: "W", x: -5.4, y: 3.6 },
+    { id: "WILB", pos: "lb", label: "M", x: -1.6, y: 4.6 },
+    { id: "SILB", pos: "lb", label: "M", x: 1.6, y: 4.6 },
+    { id: "SOLB", pos: "lb", label: "S", x: s * 5.4, y: 3.6 }
+  ];
+}
+function defensePreset(scheme, side) {
+  const s = side === "right" ? 1 : -1;
+  const cb = (sign, y, label = "C") => ({ id: sign < 0 ? "LCB" : "RCB", pos: "db", label, x: sign * K.wrSplit, y });
+  let front;
+  let cover;
+  let showZones = true;
+  if (scheme === "3-4") {
+    front = front34(side);
+    cover = "cover-2";
+    showZones = false;
+  } else if (scheme === "4-4") {
+    front = [...front43(side), { id: "SS", pos: "s", label: "$", x: s * 6, y: 4.6 }];
+    cover = "cover-3";
+  } else if (scheme === "nickel") {
+    front = front43(side).slice(0, 6);
+    cover = "cover-2";
+  } else if (scheme === "dime") {
+    front = front43(side).slice(0, 5);
+    cover = "cover-3";
+  } else if (scheme.startsWith("cover")) {
+    front = front43(side);
+    cover = scheme;
+  } else {
+    front = front43(side);
+    cover = "cover-2";
+    showZones = false;
+  }
+  const sec = [];
+  const zones = [];
+  switch (cover) {
+    case "cover-0":
+      sec.push(cb(-1, 5.5), cb(1, 5.5), { id: "FS", pos: "s", label: "F", x: -6, y: 5 }, { id: "SS", pos: "s", label: "$", x: s * 6, y: 5 });
+      break;
+    case "cover-1":
+      sec.push(cb(-1, 6), cb(1, 6), { id: "SS", pos: "s", label: "$", x: s * 6, y: 5 }, { id: "FS", pos: "s", label: "F", x: 0, y: 13.5 });
+      zones.push({ x: 0, y: 13.5, rx: 5, ry: 3.5, label: "deep middle" });
+      break;
+    case "cover-2":
+      sec.push(cb(-1, 5), cb(1, 5), { id: "FS", pos: "s", label: "F", x: -9, y: 12.5 }, { id: "SS", pos: "s", label: "$", x: 9, y: 12.5 });
+      zones.push({ x: -9, y: 12.5, rx: 9, ry: 4, label: "deep half" }, { x: 9, y: 12.5, rx: 9, ry: 4, label: "deep half" });
+      break;
+    case "cover-3":
+      sec.push(cb(-1, 11.5), cb(1, 11.5), { id: "FS", pos: "s", label: "F", x: 0, y: 14 }, { id: "SS", pos: "s", label: "$", x: s * 6, y: 5 });
+      zones.push({ x: -13.5, y: 12, rx: 5.8, ry: 3.6, label: "deep \u2153" }, { x: 0, y: 14.5, rx: 5.8, ry: 3.6, label: "deep \u2153" }, { x: 13.5, y: 12, rx: 5.8, ry: 3.6, label: "deep \u2153" });
+      break;
+    case "cover-4":
+      sec.push(cb(-1, 10), cb(1, 10), { id: "FS", pos: "s", label: "F", x: -6, y: 12.5 }, { id: "SS", pos: "s", label: "$", x: 6, y: 12.5 });
+      zones.push({ x: -13, y: 12, rx: 6.5, ry: 4, label: "deep \xBC" }, { x: -5, y: 13, rx: 6.5, ry: 4, label: "deep \xBC" }, { x: 5, y: 13, rx: 6.5, ry: 4, label: "deep \xBC" }, { x: 13, y: 12, rx: 6.5, ry: 4, label: "deep \xBC" });
+      break;
+    case "cover-6":
+      sec.push(cb(-1, 10), cb(1, 5), { id: "FS", pos: "s", label: "F", x: -7, y: 12.5 }, { id: "SS", pos: "s", label: "$", x: 9, y: 12.5 });
+      zones.push({ x: -7, y: 12.5, rx: 7, ry: 4, label: "deep \xBC" }, { x: -13, y: 12, rx: 6.5, ry: 4, label: "deep \xBC" }, { x: 9, y: 12.5, rx: 9, ry: 4, label: "deep \xBD" });
+      break;
+    default:
+      sec.push(cb(-1, 5), cb(1, 5), { id: "FS", pos: "s", label: "F", x: -9, y: 12.5 }, { id: "SS", pos: "s", label: "$", x: 9, y: 12.5 });
+  }
+  return { defenders: [...front, ...sec].slice(0, 11), zones: showZones ? zones : [] };
+}
+function passRoute(named, depth, outSign, inSign) {
+  const d = depth;
+  switch (named) {
+    case "go":
+    case "fly":
+    case "streak":
+    case "vertical":
+      return [{ x: 0, y: 0 }, { x: 0, y: d ?? 16 }];
+    case "seam":
+      return [{ x: 0, y: 0 }, { x: inSign * 0.5, y: d ?? 14 }];
+    case "slant":
+      return [{ x: 0, y: 0 }, { x: 0, y: 1.6 }, { x: inSign * 4.5, y: 6 }];
+    case "flat":
+      return [{ x: 0, y: 0 }, { x: outSign * 1.5, y: 1 }, { x: outSign * 5.5, y: 2.2 }];
+    case "hitch":
+      return [{ x: 0, y: 0 }, { x: 0, y: d ?? 5.5 }, { x: inSign * 1, y: (d ?? 5.5) - 1.2 }];
+    case "out":
+      return [{ x: 0, y: 0 }, { x: 0, y: d ?? 10 }, { x: outSign * 5.5, y: d ?? 10 }];
+    case "in":
+    case "dig":
+      return [{ x: 0, y: 0 }, { x: 0, y: d ?? 10 }, { x: inSign * 6.5, y: d ?? 10 }];
+    case "curl":
+      return [{ x: 0, y: 0 }, { x: 0, y: d ?? 12 }, { x: inSign * 1.6, y: (d ?? 12) - 1.6 }];
+    case "comeback":
+      return [{ x: 0, y: 0 }, { x: 0, y: d ?? 14 }, { x: outSign * 2.2, y: (d ?? 14) - 2.4 }];
+    case "corner":
+    case "flag":
+      return [{ x: 0, y: 0 }, { x: 0, y: d ?? 10 }, { x: outSign * 5.5, y: (d ?? 10) + 5 }];
+    case "post":
+      return [{ x: 0, y: 0 }, { x: 0, y: d ?? 10 }, { x: inSign * 5.5, y: (d ?? 10) + 6 }];
+    case "wheel":
+      return [{ x: 0, y: 0 }, { x: outSign * 3, y: 1 }, { x: outSign * 4, y: d ?? 11 }];
+    case "cross":
+    case "drag":
+      return [{ x: 0, y: 0 }, { x: 0, y: 1.5 }, { x: inSign * 14, y: 3.2 }];
+    case "screen":
+      return [{ x: 0, y: 0 }, { x: 0, y: -1 }, { x: outSign * 4.5, y: -1 }];
+    default:
+      return [{ x: 0, y: 0 }, { x: 0, y: d ?? 10 }];
+  }
+}
+function runPath(named, start, dir) {
+  const k = dirSign(dir);
+  switch (named) {
+    case "dive":
+    case "trap":
+      return [start, { x: k * 1, y: 0.5 }, { x: k * 1.6, y: 3.2 }];
+    case "iso":
+      return [start, { x: k * 0.4, y: 0.5 }, { x: k * 0.8, y: 3.4 }];
+    case "power":
+      return [start, { x: start.x + k * 1.4, y: start.y + 1.5 }, { x: k * 2.6, y: 0.6 }, { x: k * 3.6, y: 4.2 }];
+    case "counter":
+      return [start, { x: -k * 1.6, y: start.y + 0.3 }, { x: k * 2.2, y: 0.6 }, { x: k * 3.2, y: 4.2 }];
+    case "sweep":
+    case "toss":
+      return [start, { x: k * 5, y: start.y + 0.6 }, { x: k * 7, y: 1.2 }, { x: k * 7, y: 5 }];
+    case "draw":
+      return [start, { x: 0, y: start.y + 1.5 }, { x: k * 1, y: 3.4 }];
+    default:
+      return [start, { x: k * 1.4, y: 3.2 }];
+  }
+}
+var footballModule = {
+  scale: K.scale,
+  yUp: true,
+  buildPlayers(ast) {
+    const players = [];
+    const byId = /* @__PURE__ */ new Map();
+    const add = (p) => {
+      if (byId.has(p.id)) players[byId.get(p.id)] = p;
+      else {
+        byId.set(p.id, players.length);
+        players.push(p);
+      }
+    };
+    if (ast.formation) for (const sl of formationRoster(ast.formation, ast.formationSide)) add({ id: sl.id, side: "offense", pos: sl.pos, label: sl.label, x: sl.x, y: sl.y });
+    if (ast.defense) for (const d of defensePreset(ast.defense, ast.formationSide).defenders) add({ id: d.id, side: "defense", pos: d.pos, label: d.label, x: d.x, y: d.y });
+    for (const p of ast.players) {
+      const at = p.at ?? (byId.has(p.id) ? { x: players[byId.get(p.id)].x, y: players[byId.get(p.id)].y } : { x: 0, y: 0 });
+      add({ id: p.id, side: p.side, pos: p.pos, label: p.label, x: at.x, y: at.y });
+    }
+    return players;
+  },
+  buildZones(ast) {
+    const zones = [];
+    if (ast.defense) zones.push(...defensePreset(ast.defense, ast.formationSide).zones);
+    for (const z of ast.zones) zones.push({ x: z.x, y: z.y, rx: z.rx, ry: z.ry, label: z.label });
+    return zones;
+  },
+  resolveNamed(m, src, players, byId) {
+    const endFor2 = (kind) => m.end ?? ("arrow");
+    if (m.kind === "pull") {
+      const k = dirSign(m.dir ?? "right");
+      const offTackle = 2 * K.olSplit + 0.8;
+      const pts = [{ x: src.x, y: 0 }, { x: src.x, y: -1.3 }, { x: k * offTackle, y: -1.3 }, { x: k * offTackle, y: 1.6 }];
+      return { player: m.player, kind: "pull", style: "solid", points: pts.map(round22), end: "arrow" };
+    }
+    if ((m.kind === "run" || m.kind === "route") && m.named) {
+      if (m.kind === "run") {
+        return { player: m.player, kind: "run", style: "solid", points: runPath(m.named, src, m.dir ?? "right").map(round22), end: "arrow" };
+      }
+      const outSign = m.dir ? dirSign(m.dir) : src.x >= 0 ? 1 : -1;
+      const rel = passRoute(m.named, m.depth, outSign, -outSign);
+      return { player: m.player, kind: "route", style: "solid", points: rel.map((p) => round22({ x: src.x + p.x, y: src.y + p.y })), end: endFor2() };
+    }
+    return null;
+  },
+  bounds(ast, players, moves, zones) {
+    let minX = -20, maxX = K.minHalfWidth, minY = -7, maxY = 6;
+    const ext = (x, y) => {
+      minX = Math.min(minX, x);
+      maxX = Math.max(maxX, x);
+      minY = Math.min(minY, y);
+      maxY = Math.max(maxY, y);
+    };
+    for (const p of players) ext(p.x, p.y);
+    for (const mv of moves) for (const pt of mv.points) ext(pt.x, pt.y);
+    for (const z of zones) {
+      ext(z.x - z.rx, z.y - z.ry);
+      ext(z.x + z.rx, z.y + z.ry);
+    }
+    if (ast.toGoal !== void 0) maxY = Math.max(maxY, ast.toGoal + 11);
+    const m = K.margin;
+    return { minX: minX - m, maxX: maxX + m, minY: minY - m, maxY: maxY + m };
+  },
+  drawField(lay, ctx, t) {
+    const b = lay.bounds;
+    const parts = [];
+    const x1 = ctx.X(b.minX), x2 = ctx.X(b.maxX);
+    if (lay.toGoal !== void 0) {
+      const gl = lay.toGoal;
+      const ezTop = Math.min(gl + 10, b.maxY);
+      parts.push(rect({ class: "sx-pb-endzone", x: r25(x1), y: r25(ctx.Y(ezTop)), width: r25((b.maxX - b.minX) * K.scale), height: r25((ezTop - gl) * K.scale) }));
+      parts.push(line({ class: "sx-pb-goalline", x1: r25(x1), y1: r25(ctx.Y(gl)), x2: r25(x2), y2: r25(ctx.Y(gl)) }));
+      const gy = ctx.Y(Math.min(gl + 10, b.maxY) - 0.2);
+      const cx = ctx.X(0);
+      const up = ctx.px(2.2);
+      const cross = ctx.px(3);
+      parts.push(line({ class: "sx-pb-goalpost", x1: r25(cx), y1: r25(gy), x2: r25(cx), y2: r25(gy + ctx.px(1)) }));
+      parts.push(line({ class: "sx-pb-goalpost", x1: r25(cx - cross / 2), y1: r25(gy), x2: r25(cx + cross / 2), y2: r25(gy) }));
+      parts.push(line({ class: "sx-pb-goalpost", x1: r25(cx - cross / 2), y1: r25(gy), x2: r25(cx - cross / 2), y2: r25(gy - up) }));
+      parts.push(line({ class: "sx-pb-goalpost", x1: r25(cx + cross / 2), y1: r25(gy), x2: r25(cx + cross / 2), y2: r25(gy - up) }));
+    }
+    const startY = Math.ceil(b.minY / 5) * 5;
+    for (let yd = startY; yd <= b.maxY; yd += 5) {
+      if (Math.abs(yd) < 1e-6) continue;
+      if (lay.toGoal !== void 0 && yd > lay.toGoal + 0.01) continue;
+      parts.push(line({ class: "sx-pb-yard", x1: r25(x1), y1: r25(ctx.Y(yd)), x2: r25(x2), y2: r25(ctx.Y(yd)) }));
+      if (lay.toGoal !== void 0) {
+        const yardNum = lay.toGoal - yd;
+        if (yardNum > 0 && yardNum % 10 === 0) {
+          parts.push(text({ class: "sx-pb-yardnum", x: r25(x1 + 12), y: r25(ctx.Y(yd) + 4), "text-anchor": "middle" }, String(yardNum)));
+          parts.push(text({ class: "sx-pb-yardnum", x: r25(x2 - 12), y: r25(ctx.Y(yd) + 4), "text-anchor": "middle" }, String(yardNum)));
+        }
+      }
+    }
+    if (lay.hash !== "none") {
+      const hx = lay.hash === "college" ? K.hashCollege : K.hashNfl;
+      const top = lay.toGoal !== void 0 ? Math.min(b.maxY, lay.toGoal) : b.maxY;
+      for (let yd = Math.ceil(b.minY); yd <= top; yd += 1) {
+        for (const sgn of [-1, 1]) {
+          const xc = ctx.X(sgn * hx);
+          parts.push(line({ class: "sx-pb-hash", x1: r25(xc - 2), y1: r25(ctx.Y(yd)), x2: r25(xc + 2), y2: r25(ctx.Y(yd)) }));
+        }
+      }
+    }
+    parts.push(line({ class: "sx-pb-los", x1: r25(x1), y1: r25(ctx.Y(0)), x2: r25(x2), y2: r25(ctx.Y(0)) }));
+    return group({ class: "sx-pb-field-g" }, parts);
+  },
+  legend(lay) {
+    const items = [
+      { kind: "offense", label: "Offense" },
+      { kind: "defense", label: "Defense" },
+      { kind: "run", label: "Route / run" },
+      { kind: "screen", label: "Block" },
+      { kind: "motion", label: "Motion" }
+    ];
+    if (lay.zones.length) items.push({ kind: "zone", label: "Zone" });
+    return items;
+  }
+};
+
+// src/diagrams/playbook/geometry/basketball.ts
+var K2 = {
+  scale: 11,
+  // x ∈ [-25, 25]
+  half: 47,
+  rimY: 5.25,
+  laneHalf: 8,
+  // NBA lane half-width
+  ftY: 15,
+  ftR: 6,
+  threeR: 23.75,
+  cornerX: 22,
+  cornerMeetY: 14.2,
+  restrictedR: 4,
+  centerR: 6,
+  margin: 2.5
+};
+var r26 = (n) => Math.round(n * 100) / 100;
+var LANDMARKS = {
+  top: { x: 0, y: 28 },
+  rslot: { x: 8, y: 26 },
+  lslot: { x: -8, y: 26 },
+  slot: { x: 8, y: 26 },
+  rwing: { x: 19, y: 17 },
+  lwing: { x: -19, y: 17 },
+  wing: { x: 19, y: 17 },
+  rcorner: { x: 22, y: 3 },
+  lcorner: { x: -22, y: 3 },
+  corner: { x: 22, y: 3 },
+  "rshort-corner": { x: 12, y: 2 },
+  "lshort-corner": { x: -12, y: 2 },
+  relbow: { x: 8, y: 15 },
+  lelbow: { x: -8, y: 15 },
+  elbow: { x: 8, y: 15 },
+  rblock: { x: 8, y: 7 },
+  lblock: { x: -8, y: 7 },
+  block: { x: 8, y: 7 },
+  rdunker: { x: 9, y: 4 },
+  ldunker: { x: -9, y: 4 },
+  "high-post": { x: 0, y: 15 },
+  ft: { x: 0, y: 15 },
+  "free-throw": { x: 0, y: 15 },
+  "rlow-post": { x: 9, y: 8 },
+  "llow-post": { x: -9, y: 8 },
+  rim: { x: 0, y: 5.25 },
+  basket: { x: 0, y: 5.25 },
+  hoop: { x: 0, y: 5.25 },
+  paint: { x: 0, y: 10 }
+};
+function setRoster(formation) {
+  const L = LANDMARKS;
+  const at = (lm) => L[lm];
+  const slots = (pts) => pts.map((p, i) => ({ id: String(i + 1), label: String(i + 1), x: p.x, y: p.y }));
+  switch (formation) {
+    case "horns":
+      return slots([at("top"), at("lcorner"), at("rcorner"), at("lelbow"), at("relbow")]);
+    case "1-4-high":
+      return slots([at("top"), at("lwing"), at("rwing"), at("lelbow"), at("relbow")]);
+    case "1-4-low":
+      return slots([at("top"), at("lcorner"), at("rcorner"), at("lblock"), at("rblock")]);
+    case "box":
+      return slots([at("top"), at("lelbow"), at("relbow"), at("lblock"), at("rblock")]);
+    case "spread-pnr":
+      return slots([at("top"), at("lcorner"), at("rcorner"), at("lwing"), { x: 8, y: 24 }]);
+    case "4-out":
+      return slots([at("top"), at("lwing"), at("rwing"), at("lcorner"), at("rblock")]);
+    case "5-out":
+    default:
+      return slots([at("top"), at("lwing"), at("rwing"), at("lcorner"), at("rcorner")]);
+  }
+}
+function defenseRoster(scheme, offense) {
+  const zones = [];
+  if (scheme === "man") {
+    const defenders2 = offense.filter((p) => p.side === "offense").slice(0, 5).map((o) => {
+      const dx = -o.x * 0.12;
+      const dy = (K2.rimY - o.y) * 0.18;
+      return { id: "X" + o.id, label: "X" + o.label, x: o.x + dx, y: o.y + dy };
+    });
+    return { defenders: defenders2, zones };
+  }
+  let pts;
+  if (scheme === "zone-3-2") pts = [{ x: 0, y: 20 }, { x: -13, y: 17 }, { x: 13, y: 17 }, { x: -8, y: 8 }, { x: 8, y: 8 }];
+  else if (scheme === "zone-1-3-1") pts = [{ x: 0, y: 22 }, { x: -12, y: 14 }, { x: 0, y: 13 }, { x: 12, y: 14 }, { x: 0, y: 5.5 }];
+  else pts = [{ x: -7, y: 18 }, { x: 7, y: 18 }, { x: 0, y: 9 }, { x: -13, y: 6 }, { x: 13, y: 6 }];
+  const defenders = pts.map((p, i) => ({ id: "X" + (i + 1), label: "X", x: p.x, y: p.y }));
+  return { defenders, zones };
+}
+var basketballModule = {
+  scale: K2.scale,
+  yUp: false,
+  buildPlayers(ast) {
+    const players = [];
+    const byId = /* @__PURE__ */ new Map();
+    const add = (p) => {
+      if (byId.has(p.id)) players[byId.get(p.id)] = p;
+      else {
+        byId.set(p.id, players.length);
+        players.push(p);
+      }
+    };
+    for (const sl of setRoster(ast.formation)) add({ id: sl.id, side: "offense", pos: "o", label: sl.label, x: sl.x, y: sl.y });
+    if (ast.defense) for (const d of defenseRoster(ast.defense, players).defenders) add({ id: d.id, side: "defense", pos: "x", label: d.label, x: d.x, y: d.y });
+    for (const p of ast.players) {
+      const at = p.at ?? (byId.has(p.id) ? { x: players[byId.get(p.id)].x, y: players[byId.get(p.id)].y } : { x: 0, y: 0 });
+      add({ id: p.id, side: p.side, pos: p.pos === "c" || p.pos === "ol" ? "o" : p.pos, label: p.label, x: at.x, y: at.y });
+    }
+    return players;
+  },
+  buildZones(ast) {
+    return ast.zones.map((z) => ({ x: z.x, y: z.y, rx: z.rx, ry: z.ry, label: z.label }));
+  },
+  resolveLandmark(name) {
+    return LANDMARKS[name.toLowerCase()] ?? null;
+  },
+  bounds(_ast, players, moves, zones) {
+    let minX = -25, maxX = 25, minY = 0, maxY = 30;
+    const ext = (x, y) => {
+      minX = Math.min(minX, x);
+      maxX = Math.max(maxX, x);
+      minY = Math.min(minY, y);
+      maxY = Math.max(maxY, y);
+    };
+    for (const p of players) ext(p.x, p.y);
+    for (const mv of moves) for (const pt of mv.points) ext(pt.x, pt.y);
+    for (const z of zones) {
+      ext(z.x - z.rx, z.y - z.ry);
+      ext(z.x + z.rx, z.y + z.ry);
+    }
+    const m = K2.margin;
+    return { minX: Math.min(-25, minX) - m * 0.4, maxX: Math.max(25, maxX) + m * 0.4, minY: Math.min(0, minY) - m * 0.4, maxY: Math.min(K2.half, maxY + m * 0.6) };
+  },
+  drawField(_lay, ctx, t) {
+    const parts = [];
+    const X = ctx.X, Y = ctx.Y, px = ctx.px;
+    parts.push(rect({ class: "sx-pb-court-line", fill: "none", x: r26(X(-8)), y: r26(Y(0)), width: r26(px(2 * K2.laneHalf)), height: r26(px(K2.ftY)) }));
+    parts.push(circle({ class: "sx-pb-court-line", fill: "none", cx: r26(X(0)), cy: r26(Y(K2.ftY)), r: r26(px(K2.ftR)) }));
+    parts.push(line({ class: "sx-pb-court-line", x1: r26(X(-3)), y1: r26(Y(4)), x2: r26(X(3)), y2: r26(Y(4)) }));
+    parts.push(circle({ class: "sx-pb-rim", fill: "none", cx: r26(X(0)), cy: r26(Y(K2.rimY)), r: r26(px(0.75)) }));
+    parts.push(path({ class: "sx-pb-court-line", fill: "none", d: `M ${r26(X(-4))} ${r26(Y(K2.rimY))} A ${r26(px(K2.restrictedR))} ${r26(px(K2.restrictedR))} 0 0 0 ${r26(X(K2.restrictedR))} ${r26(Y(K2.rimY))}` }));
+    parts.push(path({
+      class: "sx-pb-court-line",
+      fill: "none",
+      d: `M ${r26(X(-22))} ${r26(Y(0))} L ${r26(X(-22))} ${r26(Y(K2.cornerMeetY))} A ${r26(px(K2.threeR))} ${r26(px(K2.threeR))} 0 0 0 ${r26(X(K2.cornerX))} ${r26(Y(K2.cornerMeetY))} L ${r26(X(K2.cornerX))} ${r26(Y(0))}`
+    }));
+    parts.push(path({ class: "sx-pb-court-line", fill: "none", d: `M ${r26(X(-6))} ${r26(Y(K2.half))} A ${r26(px(K2.centerR))} ${r26(px(K2.centerR))} 0 0 1 ${r26(X(K2.centerR))} ${r26(Y(K2.half))}` }));
+    return group({ class: "sx-pb-field-g" }, parts);
+  },
+  legend() {
+    return [
+      { kind: "offense", label: "Offense (1\u20135)" },
+      { kind: "defense", label: "Defense (X)" },
+      { kind: "run", label: "Cut" },
+      { kind: "pass", label: "Pass" },
+      { kind: "dribble", label: "Dribble" },
+      { kind: "screen", label: "Screen" }
+    ];
+  }
+};
+
+// src/diagrams/playbook/geometry/soccer.ts
+var K3 = {
+  scale: 8,
+  L: 105,
+  W: 68,
+  circleR: 9.15,
+  paDepth: 16.5,
+  paHalf: 20.16,
+  // 40.32 / 2
+  gaDepth: 5.5,
+  gaHalf: 9.16,
+  // 18.32 / 2
+  penDist: 11,
+  goalHalf: 3.66,
+  // 7.32 / 2
+  cornerR: 1,
+  margin: 3
+};
+var r27 = (n) => Math.round(n * 100) / 100;
+function formationRoster2(formation) {
+  const p = (id, x, y, gk2 = false) => ({ id, label: id, x, y, gk: gk2 });
+  const back4 = [p("2", 20, 12), p("4", 20, 27), p("5", 20, 41), p("3", 20, 56)];
+  const gk = p("1", 5, 34, true);
+  switch (formation) {
+    case "4-4-2":
+      return [gk, ...back4, p("7", 50, 10), p("6", 50, 27), p("8", 50, 41), p("11", 50, 58), p("9", 80, 28), p("10", 80, 40)];
+    case "4-2-3-1":
+      return [gk, ...back4, p("6", 40, 28), p("8", 40, 40), p("7", 65, 12), p("10", 65, 34), p("11", 65, 56), p("9", 85, 34)];
+    case "4-5-1":
+      return [gk, ...back4, p("6", 48, 27), p("8", 48, 41), p("7", 52, 10), p("11", 52, 58), p("10", 62, 34), p("9", 85, 34)];
+    case "4-4-1-1":
+      return [gk, ...back4, p("7", 50, 10), p("6", 50, 27), p("8", 50, 41), p("11", 50, 58), p("10", 68, 34), p("9", 84, 34)];
+    case "3-5-2":
+      return [gk, p("4", 20, 20), p("5", 20, 34), p("6", 20, 48), p("2", 52, 6), p("3", 52, 62), p("8", 50, 25), p("10", 55, 43), p("7", 45, 34), p("9", 82, 28), p("11", 82, 40)];
+    case "3-4-3":
+      return [gk, p("4", 20, 20), p("5", 20, 34), p("6", 20, 48), p("2", 48, 8), p("8", 48, 28), p("10", 48, 40), p("3", 48, 60), p("7", 82, 14), p("9", 82, 34), p("11", 82, 54)];
+    case "4-3-3":
+    default:
+      return [gk, ...back4, p("6", 42, 34), p("8", 52, 24), p("10", 52, 44), p("7", 82, 12), p("9", 82, 34), p("11", 82, 56)];
+  }
+}
+function opponentBlock(scheme) {
+  const cx = scheme === "high-press" ? 45 : scheme === "mid-block" ? 70 : 88;
+  const p = (i, x, y) => ({ id: "X" + i, label: "X", x, y });
+  return [
+    p(1, cx + 12, 34),
+    p(2, cx, 12),
+    p(3, cx, 27),
+    p(4, cx, 41),
+    p(5, cx, 56),
+    p(6, cx - 14, 14),
+    p(7, cx - 14, 28),
+    p(8, cx - 14, 40),
+    p(9, cx - 14, 54),
+    p(10, cx - 26, 28),
+    p(11, cx - 26, 40)
+  ];
+}
+var LANDMARKS2 = {
+  center: { x: 52.5, y: 34 },
+  "centre-spot": { x: 52.5, y: 34 },
+  box: { x: 96, y: 34 },
+  "top-box": { x: 88.5, y: 34 },
+  d: { x: 84.85, y: 34 },
+  "penalty-arc": { x: 84.85, y: 34 },
+  "penalty-spot": { x: 94, y: 34 },
+  "near-post": { x: 105, y: 30.5 },
+  "far-post": { x: 105, y: 37.7 },
+  goal: { x: 105, y: 34 },
+  "rcorner": { x: 105, y: 2 },
+  "lcorner": { x: 105, y: 66 },
+  "six-yard": { x: 101, y: 34 }
+};
+var soccerModule = {
+  scale: K3.scale,
+  yUp: false,
+  buildPlayers(ast) {
+    const players = [];
+    const byId = /* @__PURE__ */ new Map();
+    const add = (pl2) => {
+      if (byId.has(pl2.id)) players[byId.get(pl2.id)] = pl2;
+      else {
+        byId.set(pl2.id, players.length);
+        players.push(pl2);
+      }
+    };
+    for (const sl of formationRoster2(ast.formation)) add({ id: sl.id, side: "offense", pos: sl.gk ? "gk" : "o", label: sl.label, x: sl.x, y: sl.y });
+    if (ast.defense) for (const d of opponentBlock(ast.defense)) add({ id: d.id, side: "defense", pos: "x", label: d.label, x: d.x, y: d.y });
+    for (const pl2 of ast.players) {
+      const at = pl2.at ?? (byId.has(pl2.id) ? { x: players[byId.get(pl2.id)].x, y: players[byId.get(pl2.id)].y } : { x: 0, y: 0 });
+      add({ id: pl2.id, side: pl2.side, pos: pl2.pos === "c" || pl2.pos === "ol" ? "o" : pl2.pos, label: pl2.label, x: at.x, y: at.y });
+    }
+    return players;
+  },
+  buildZones(ast) {
+    return ast.zones.map((z) => ({ x: z.x, y: z.y, rx: z.rx, ry: z.ry, label: z.label }));
+  },
+  resolveLandmark(name) {
+    return LANDMARKS2[name.toLowerCase()] ?? null;
+  },
+  bounds(ast) {
+    const m = K3.margin;
+    if (ast.view === "half") return { minX: 52.5 - m, maxX: K3.L + m, minY: -m, maxY: K3.W + m };
+    return { minX: -m, maxX: K3.L + m, minY: -m, maxY: K3.W + m };
+  },
+  drawField(_lay, ctx, t) {
+    const X = ctx.X, Y = ctx.Y, px = ctx.px;
+    const parts = [];
+    const ln = (x1, y1, x2, y2) => line({ class: "sx-pb-pitch-line", x1: r27(X(x1)), y1: r27(Y(y1)), x2: r27(X(x2)), y2: r27(Y(y2)) });
+    const bands = 10;
+    for (let i = 0; i < bands; i++) {
+      if (i % 2 === 0) continue;
+      parts.push(rect({ class: "sx-pb-stripe", x: r27(X(i * K3.L / bands)), y: r27(Y(0)), width: r27(px(K3.L / bands)), height: r27(px(K3.W)) }));
+    }
+    const cr = px(K3.cornerR);
+    const corners = [[0, 0, 0], [K3.L, 0, 1], [0, K3.W, 2], [K3.L, K3.W, 3]];
+    for (const [cxF, cyF, q] of corners) {
+      const cx = X(cxF), cy = Y(cyF);
+      const sx = cxF === 0 ? 1 : -1;
+      const sy = cyF === 0 ? 1 : -1;
+      parts.push(path({ class: "sx-pb-pitch-line", fill: "none", d: `M ${r27(cx + sx * cr)} ${r27(cy)} A ${r27(cr)} ${r27(cr)} 0 0 ${q === 1 || q === 2 ? 1 : 0} ${r27(cx)} ${r27(cy + sy * cr)}` }));
+    }
+    parts.push(ln(52.5, 0, 52.5, K3.W));
+    parts.push(circle({ class: "sx-pb-pitch-line", fill: "none", cx: r27(X(52.5)), cy: r27(Y(34)), r: r27(px(K3.circleR)) }));
+    parts.push(circle({ class: "sx-pb-pitch-dot", cx: r27(X(52.5)), cy: r27(Y(34)), r: 1.6 }));
+    const topY = (half) => Math.min(Y(34 - half), Y(34 + half));
+    for (const end of [0, 1]) {
+      const gx = end === 0 ? 0 : K3.L;
+      const sgn = end === 0 ? 1 : -1;
+      parts.push(rect({ class: "sx-pb-pitch-line", fill: "none", x: r27(X(Math.min(gx, gx + sgn * K3.paDepth))), y: r27(topY(K3.paHalf)), width: r27(px(K3.paDepth)), height: r27(px(2 * K3.paHalf)) }));
+      parts.push(rect({ class: "sx-pb-pitch-line", fill: "none", x: r27(X(Math.min(gx, gx + sgn * K3.gaDepth))), y: r27(topY(K3.gaHalf)), width: r27(px(K3.gaDepth)), height: r27(px(2 * K3.gaHalf)) }));
+      const spotX = gx + sgn * K3.penDist;
+      parts.push(circle({ class: "sx-pb-pitch-dot", cx: r27(X(spotX)), cy: r27(Y(34)), r: 1.4 }));
+      const edgeX = gx + sgn * K3.paDepth;
+      const dy = Math.sqrt(K3.circleR * K3.circleR - (K3.paDepth - K3.penDist) * (K3.paDepth - K3.penDist));
+      const sweep = end === 0 ? 1 : 0;
+      parts.push(path({ class: "sx-pb-pitch-line", fill: "none", d: `M ${r27(X(edgeX))} ${r27(Y(34 - dy))} A ${r27(px(K3.circleR))} ${r27(px(K3.circleR))} 0 0 ${sweep} ${r27(X(edgeX))} ${r27(Y(34 + dy))}` }));
+      const goalX = gx - sgn * 2.2;
+      parts.push(rect({ class: "sx-pb-goalbox", x: r27(X(Math.min(gx, goalX))), y: r27(topY(K3.goalHalf)), width: r27(px(2.2)), height: r27(px(2 * K3.goalHalf)) }));
+    }
+    return group({ class: "sx-pb-field-g" }, parts);
+  },
+  legend() {
+    return [
+      { kind: "offense", label: "Team" },
+      { kind: "gk", label: "Keeper" },
+      { kind: "defense", label: "Opponent" },
+      { kind: "pass", label: "Pass" },
+      { kind: "run", label: "Run" },
+      { kind: "dribble", label: "Dribble" },
+      { kind: "shot", label: "Shot" }
+    ];
+  }
+};
+
+// src/diagrams/playbook/layout.ts
+var MODULES = {
+  football: footballModule,
+  basketball: basketballModule,
+  soccer: soccerModule
+};
+function sportModule(sport) {
+  return MODULES[sport];
+}
+var round23 = (p) => ({ x: Math.round(p.x * 100) / 100, y: Math.round(p.y * 100) / 100 });
+function styleFor(sport, kind) {
+  if (kind === "dribble") return "wavy";
+  if (kind === "shot") return sport === "soccer" ? "double" : "solid";
+  if (kind === "pass") return sport === "soccer" ? "solid" : "dashed";
+  if (kind === "motion") return "dashed";
+  if (sport === "soccer" && (kind === "run" || kind === "cut" || kind === "move")) return "dashed";
+  return "solid";
+}
+function endFor(kind, override) {
+  if (override) return override;
+  if (kind === "screen" || kind === "block") return "tee";
+  if (kind === "handoff") return "none";
+  return "arrow";
+}
+function findPlayer(ref, byId) {
+  if (byId.has(ref)) return byId.get(ref);
+  const lower = ref.toLowerCase();
+  for (const [k, v] of byId) if (k.toLowerCase() === lower) return v;
+  return void 0;
+}
+function resolveRef(token, byId, players, mod) {
+  const coord = /^(-?\d*\.?\d+),(-?\d*\.?\d+)$/.exec(token);
+  if (coord) return { x: Number(coord[1]), y: Number(coord[2]) };
+  const pi = findPlayer(token, byId);
+  if (pi !== void 0) return { x: players[pi].x, y: players[pi].y };
+  const lm = mod.resolveLandmark?.(token);
+  if (lm) return { x: lm.x, y: lm.y };
+  return null;
+}
+function layoutPlaybook(ast) {
+  const mod = MODULES[ast.sport];
+  const errors = [];
+  const warnings = [];
+  const players = mod.buildPlayers(ast);
+  const byId = /* @__PURE__ */ new Map();
+  players.forEach((p, i) => byId.set(p.id, i));
+  if (players.length === 0) {
+    errors.push("no players \u2014 add a `formation`/set or explicit `player` statements");
+  }
+  const zones = mod.buildZones(ast, players);
+  const moves = [];
+  for (const m of ast.moves) {
+    const srcIdx = findPlayer(m.player, byId);
+    if (srcIdx === void 0) {
+      warnings.push(`move on unknown player "${m.player}" \u2014 skipped`);
+      continue;
+    }
+    const src = { x: players[srcIdx].x, y: players[srcIdx].y };
+    const named = mod.resolveNamed?.(m, src, players, byId, warnings);
+    if (named) {
+      moves.push(named);
+      continue;
+    }
+    const geom = resolveGeneric(m, src, byId, players, mod, ast.sport, warnings);
+    if (geom) moves.push(geom);
+  }
+  const bounds = mod.bounds(ast, players, moves, zones);
+  return {
+    title: ast.title,
+    sport: ast.sport,
+    down: ast.down,
+    distance: ast.distance,
+    losYard: ast.losYard,
+    toGoal: ast.toGoal,
+    hash: ast.hash,
+    view: ast.view === "half" ? "half" : "full",
+    players,
+    moves,
+    zones,
+    bounds,
+    errors,
+    warnings
+  };
+}
+function resolveGeneric(m, src, byId, players, mod, sport, warnings) {
+  const style = styleFor(sport, m.kind);
+  if (m.points && m.points.length) {
+    const pts = [{ x: src.x, y: src.y }];
+    let cur = { x: src.x, y: src.y };
+    for (const p of m.points) {
+      if (p.ref) {
+        const r6 = resolveRef(p.ref, byId, players, mod);
+        if (!r6) {
+          warnings.push(`${m.kind} ${m.player}: unknown destination "${p.ref}" \u2014 skipped`);
+          return null;
+        }
+        cur = r6;
+      } else if (p.rel) {
+        cur = { x: cur.x + (p.x ?? 0), y: cur.y + (p.y ?? 0) };
+      } else {
+        cur = { x: p.x ?? cur.x, y: p.y ?? cur.y };
+      }
+      pts.push(cur);
+    }
+    return { player: m.player, kind: m.kind, style, points: pts.map(round23), end: endFor(m.kind, m.end) };
+  }
+  let dest = null;
+  if (m.target) dest = resolveRef(m.target, byId, players, mod);
+  else if (m.kind === "shot") dest = mod.resolveLandmark?.("rim") ?? mod.resolveLandmark?.("goal") ?? null;
+  if (!dest) {
+    warnings.push(`${m.kind} ${m.player}: needs a target/destination \u2014 skipped`);
+    return null;
+  }
+  if (m.kind === "screen" || m.kind === "block") {
+    const dx = dest.x - src.x, dy = dest.y - src.y;
+    const len = Math.hypot(dx, dy) || 1;
+    const gap = sport === "football" ? 0.6 : sport === "basketball" ? 1.2 : 1.6;
+    const stop = Math.max(0, len - gap);
+    const end = { x: src.x + dx / len * stop, y: src.y + dy / len * stop };
+    return { player: m.player, kind: m.kind, style, points: [round23(src), round23(end)], end: "tee" };
+  }
+  return { player: m.player, kind: m.kind, style, points: [round23(src), round23(dest)], end: endFor(m.kind, m.end) };
+}
+
+// src/diagrams/playbook/renderer.ts
+var r28 = (n) => Math.round(n * 100) / 100;
+function buildCss14(t) {
+  return `
+.sx-pb { font-family: ${DEFAULT_FONT_FAMILY}; }
+.sx-pb-title { font: ${TITLE.weight} ${TITLE.size}px sans-serif; fill: ${t.text}; }
+.sx-pb-field, .sx-pb-turf { fill: ${t.surface}; }
+.sx-pb-court { fill: ${t.courtSurface}; }
+.sx-pb-surround { fill: ${t.surround}; }
+.sx-pb-surround-court { fill: ${t.courtSurround}; }
+.sx-pb-boundary { fill: none; stroke: ${t.lineBold}; stroke-width: 2.6; }
+.sx-pb-boundary-court { fill: none; stroke: ${t.courtLine}; stroke-width: 2.6; }
+.sx-pb-stripe { fill: ${t.surfaceAlt}; }
+.sx-pb-yard, .sx-pb-pitch-line, .sx-pb-goalbox { fill: none; stroke: ${t.lineSoft}; stroke-width: 1.4; }
+.sx-pb-court-line { fill: none; stroke: ${t.courtLine}; stroke-width: 1.5; }
+.sx-pb-hash { fill: none; stroke: ${t.lineSoft}; stroke-width: 1.2; }
+.sx-pb-los, .sx-pb-goalline { fill: none; stroke: ${t.lineBold}; stroke-width: 2.4; }
+.sx-pb-goalline { stroke: ${t.goalAccent}; }
+.sx-pb-goalpost { fill: none; stroke: ${t.goalAccent}; stroke-width: 2.4; stroke-linecap: round; }
+.sx-pb-endzone { fill: ${t.endzoneFill}; }
+.sx-pb-yardnum { font: 600 11px sans-serif; fill: ${t.surfaceText}; }
+.sx-pb-rim { stroke: ${t.rim}; stroke-width: 2.4; }
+.sx-pb-pitch-dot { fill: ${t.lineBold}; }
+.sx-pb-zone { fill: ${t.zoneFill}; stroke: ${t.zoneStroke}; stroke-width: 1.3; stroke-dasharray: 5 4; }
+.sx-pb-zone-text { font: 9px sans-serif; fill: ${t.zoneStroke}; }
+.sx-pb-move { fill: none; stroke: ${t.moveStroke}; stroke-width: 2.4; stroke-linejoin: round; stroke-linecap: round; }
+.sx-pb-move-dash { fill: none; stroke: ${t.moveStroke}; stroke-width: 2.2; stroke-dasharray: 6 4; stroke-linejoin: round; stroke-linecap: round; }
+.sx-pb-shot { fill: none; stroke: ${t.shotStroke}; stroke-width: 3.4; stroke-linecap: round; }
+.sx-pb-motion { fill: none; stroke: ${t.motionStroke}; stroke-width: 1.9; stroke-dasharray: 4 3; }
+.sx-pb-move-fill { fill: ${t.moveStroke}; stroke: none; }
+.sx-pb-shot-fill { fill: ${t.shotStroke}; stroke: none; }
+.sx-pb-motion-fill { fill: ${t.motionStroke}; stroke: none; }
+.sx-pb-o { fill: ${t.offenseFill}; stroke: ${t.offenseStroke}; stroke-width: 2; }
+.sx-pb-gk { fill: ${t.gkFill}; stroke: ${t.offenseStroke}; stroke-width: 2; }
+.sx-pb-o-text { font: 700 10.5px sans-serif; fill: ${t.offenseLabel}; }
+.sx-pb-x { fill: none; stroke: ${t.defenseStroke}; stroke-width: 2.6; stroke-linecap: round; }
+.sx-pb-x-text { font: 700 9px sans-serif; fill: ${t.defenseStroke}; }
+.sx-pb-ball { fill: ${t.ballFill}; stroke: ${t.lineBold}; stroke-width: 0.8; }
+.sx-pb-anno { font: 600 12px sans-serif; fill: ${t.annotation}; }
+.sx-pb-legend { font: 11px sans-serif; fill: ${t.annotation}; }
+.sx-pb-error-box { fill: ${t.bg}; stroke: ${t.negative}; stroke-width: 1.5; }
+.sx-pb-error-title { font: 700 13px ui-monospace, Menlo, monospace; fill: ${t.negative}; }
+.sx-pb-error-line { font: 12px ui-monospace, Menlo, monospace; fill: ${t.negative}; }
+`.trim();
+}
+function renderErrorPanel2(lay, t) {
+  const lines = lay.errors;
+  const w = Math.max(520, ...lines.map((l) => l.length * 6.6 + 48));
+  const h = 56 + lines.length * 19;
+  return svgRoot(
+    { viewBox: `0 0 ${r28(w)} ${h}`, width: r28(w), height: h, class: "sx-pb", role: "img" },
+    [
+      title(lay.title),
+      desc(`Playbook validation failed with ${lines.length} error${lines.length === 1 ? "" : "s"}.`),
+      el("style", {}, buildCss14(t)),
+      rect({ class: "sx-pb-error-box", x: 1, y: 1, width: r28(w - 2), height: h - 2, rx: 6 }),
+      text({ class: "sx-pb-error-title", x: 16, y: 26 }, `playbook: ${lines.length} validation error${lines.length === 1 ? "" : "s"}`),
+      ...lines.map((e, i) => text({ class: "sx-pb-error-line", x: 16, y: 50 + i * 19 }, `\u26A0 ${e}`))
+    ]
+  );
+}
+function wavyPath(pts, amp = 3.4, wl = 11) {
+  const flat = [];
+  let acc = 0;
+  for (let i = 1; i < pts.length; i++) {
+    const a = pts[i - 1], b = pts[i];
+    const dx = b.x - a.x, dy = b.y - a.y;
+    const segLen = Math.hypot(dx, dy) || 1;
+    const ux = dx / segLen, uy = dy / segLen;
+    const nx = -uy, ny = ux;
+    const lastSeg = i === pts.length - 1;
+    const straightTail = lastSeg ? 9 : 0;
+    const usable = Math.max(0, segLen - straightTail);
+    const steps = Math.max(2, Math.round(usable / 2));
+    for (let s = 0; s <= steps; s++) {
+      const d = usable * s / steps;
+      const off = amp * Math.sin(2 * Math.PI * (acc + d) / wl);
+      flat.push({ x: a.x + ux * d + nx * off, y: a.y + uy * d + ny * off });
+    }
+    acc += usable;
+    if (lastSeg) flat.push({ x: b.x, y: b.y });
+  }
+  return flat.map((p, i) => `${i === 0 ? "M" : "L"} ${r28(p.x)} ${r28(p.y)}`).join(" ");
+}
+function arrowHead4(pts, cls) {
+  if (pts.length < 2) return "";
+  const a = pts[pts.length - 2], b = pts[pts.length - 1];
+  const ang = Math.atan2(b.y - a.y, b.x - a.x);
+  const size = 8, wing = 0.42;
+  const p2 = `${r28(b.x - size * Math.cos(ang - wing))},${r28(b.y - size * Math.sin(ang - wing))}`;
+  const p3 = `${r28(b.x - size * Math.cos(ang + wing))},${r28(b.y - size * Math.sin(ang + wing))}`;
+  return polygon({ class: cls, points: `${r28(b.x)},${r28(b.y)} ${p2} ${p3}` });
+}
+function teeBar(pts, cls) {
+  if (pts.length < 2) return "";
+  const a = pts[pts.length - 2], b = pts[pts.length - 1];
+  const ang = Math.atan2(b.y - a.y, b.x - a.x) + Math.PI / 2;
+  const half = 7;
+  return line({ class: cls, x1: r28(b.x - half * Math.cos(ang)), y1: r28(b.y - half * Math.sin(ang)), x2: r28(b.x + half * Math.cos(ang)), y2: r28(b.y + half * Math.sin(ang)) });
+}
+function renderMove(mv, ctx) {
+  const pts = mv.points.map((p) => ({ x: ctx.X(p.x), y: ctx.Y(p.y) }));
+  const strokeCls = mv.kind === "motion" ? "sx-pb-motion" : mv.kind === "shot" ? "sx-pb-shot" : mv.style === "dashed" ? "sx-pb-move-dash" : "sx-pb-move";
+  const headCls = mv.kind === "motion" ? "sx-pb-motion-fill" : mv.kind === "shot" ? "sx-pb-shot-fill" : "sx-pb-move-fill";
+  const parts = [];
+  if (mv.style === "wavy") {
+    parts.push(path({ class: strokeCls, d: wavyPath(pts) }));
+  } else {
+    parts.push(path({ class: strokeCls, d: pts.map((p, i) => `${i === 0 ? "M" : "L"} ${r28(p.x)} ${r28(p.y)}`).join(" ") }));
+  }
+  if (mv.end === "arrow") parts.push(arrowHead4(pts, headCls));
+  else if (mv.end === "tee") parts.push(teeBar(pts, strokeCls));
+  return group({ class: "sx-pb-move-g", "data-kind": mv.kind, "data-player": mv.player }, parts);
+}
+function playerSymbol(p, ctx) {
+  const cx = ctx.X(p.x), cy = ctx.Y(p.y), r6 = 10;
+  const parts = [];
+  if (p.side === "defense" || p.pos === "x") {
+    const k = r6 * 0.78;
+    parts.push(line({ class: "sx-pb-x", x1: r28(cx - k), y1: r28(cy - k), x2: r28(cx + k), y2: r28(cy + k) }));
+    parts.push(line({ class: "sx-pb-x", x1: r28(cx - k), y1: r28(cy + k), x2: r28(cx + k), y2: r28(cy - k) }));
+    if (p.label) parts.push(text({ class: "sx-pb-x-text", x: r28(cx + k + 5), y: r28(cy - k + 2), "text-anchor": "middle" }, p.label));
+  } else if (p.pos === "gk") {
+    const h = r6 * 1.15;
+    parts.push(polygon({ class: "sx-pb-gk", points: `${r28(cx)},${r28(cy - h)} ${r28(cx + h)},${r28(cy + h * 0.8)} ${r28(cx - h)},${r28(cy + h * 0.8)}` }));
+    parts.push(text({ class: "sx-pb-o-text", x: r28(cx), y: r28(cy + 6), "text-anchor": "middle" }, p.label));
+  } else if (p.pos === "c") {
+    parts.push(rect({ class: "sx-pb-o", x: r28(cx - r6 * 0.82), y: r28(cy - r6 * 0.82), width: r28(r6 * 1.64), height: r28(r6 * 1.64) }));
+    parts.push(text({ class: "sx-pb-o-text", x: r28(cx), y: r28(cy + 3.6), "text-anchor": "middle" }, p.label));
+  } else {
+    parts.push(circle({ class: "sx-pb-o", cx: r28(cx), cy: r28(cy), r: r6 }));
+    parts.push(text({ class: "sx-pb-o-text", x: r28(cx), y: r28(cy + 3.6), "text-anchor": "middle" }, p.label));
+  }
+  return group({ class: "sx-pb-player", "data-side": p.side, "data-id": p.id }, parts);
+}
+function legendSwatch(kind, sport) {
+  const moveCls = (dashed) => dashed ? "sx-pb-move-dash" : "sx-pb-move";
+  const arrow2 = polygon({ class: "sx-pb-move-fill", points: "20,0 13,-3.5 13,3.5" });
+  switch (kind) {
+    case "offense":
+      return circle({ class: "sx-pb-o", cx: 8, cy: 0, r: 6 });
+    case "gk":
+      return polygon({ class: "sx-pb-gk", points: "8,-7 15,5 1,5" });
+    case "defense":
+      return `${line({ class: "sx-pb-x", x1: 3, y1: -5, x2: 13, y2: 5 })}${line({ class: "sx-pb-x", x1: 3, y1: 5, x2: 13, y2: -5 })}`;
+    case "run":
+      return `${line({ class: moveCls(sport === "soccer"), x1: 0, y1: 0, x2: 14, y2: 0 })}${arrow2}`;
+    case "pass":
+      return `${line({ class: moveCls(sport !== "soccer"), x1: 0, y1: 0, x2: 14, y2: 0 })}${arrow2}`;
+    case "dribble":
+      return `${path({ class: "sx-pb-move", d: "M0,0 Q3,-4 6,0 T12,0" })}${polygon({ class: "sx-pb-move-fill", points: "20,0 13,-3.5 13,3.5" })}`;
+    case "screen":
+      return `${line({ class: "sx-pb-move", x1: 0, y1: 0, x2: 16, y2: 0 })}${line({ class: "sx-pb-move", x1: 16, y1: -5, x2: 16, y2: 5 })}`;
+    case "shot":
+      return `${line({ class: "sx-pb-shot", x1: 0, y1: 0, x2: 14, y2: 0 })}${polygon({ class: "sx-pb-shot-fill", points: "20,0 13,-3.5 13,3.5" })}`;
+    case "motion":
+      return `${line({ class: "sx-pb-motion", x1: 0, y1: 0, x2: 14, y2: 0 })}${polygon({ class: "sx-pb-motion-fill", points: "20,0 13,-3.5 13,3.5" })}`;
+    case "zone":
+      return rect({ class: "sx-pb-zone", x: 0, y: -6, width: 18, height: 12, rx: 6 });
+    default:
+      return "";
+  }
+}
+function renderLegend4(items, y, sport) {
+  const parts = [];
+  let cx = 12;
+  for (const it of items) {
+    parts.push(group({ transform: `translate(${r28(cx)},${r28(y)})` }, [legendSwatch(it.kind, sport)]));
+    parts.push(text({ class: "sx-pb-legend", x: r28(cx + 26), y: r28(y + 4) }, it.label));
+    cx += 26 + it.label.length * 6.5 + 20;
+  }
+  return group({ class: "sx-pb-legend-g" }, parts);
+}
+function ordinal(n) {
+  return n === 1 ? "1st" : n === 2 ? "2nd" : n === 3 ? "3rd" : n === 4 ? "4th" : `${n}th`;
+}
+function renderPlaybookLayout(lay, config) {
+  let themeName = config?.theme ?? "default";
+  if (lay.sport === "soccer" && themeName === "dark") themeName = "default";
+  const t = resolvePlaybookTheme(themeName);
+  if (lay.errors.length > 0) return renderErrorPanel2(lay, t);
+  const mod = sportModule(lay.sport);
+  const scale = mod.scale;
+  const b = lay.bounds;
+  const titleH = TITLE.bandH;
+  const annoH = lay.sport === "football" && (lay.down || lay.distance || lay.losYard !== void 0) ? 20 : 0;
+  const topH = titleH + annoH;
+  const legendH = 30;
+  const EDGE = 16;
+  const fieldW = (b.maxX - b.minX) * scale;
+  const fieldH = (b.maxY - b.minY) * scale;
+  const W2 = r28(fieldW + EDGE * 2);
+  const fieldTop = topH + EDGE;
+  const H2 = r28(fieldH + topH + EDGE * 2 + legendH);
+  const X = (u) => r28((u - b.minX) * scale + EDGE);
+  const Y = (v) => r28(mod.yUp ? (b.maxY - v) * scale + fieldTop : (v - b.minY) * scale + fieldTop);
+  const px = (u) => r28(u * scale);
+  const ctx = { X, Y, px };
+  const isCourt = lay.sport === "basketball";
+  const surfaceCls = isCourt ? "sx-pb-court" : lay.sport === "soccer" ? "sx-pb-turf" : "sx-pb-field";
+  const surroundCls = isCourt ? "sx-pb-surround-court" : "sx-pb-surround";
+  const boundaryCls = isCourt ? "sx-pb-boundary-court" : "sx-pb-boundary";
+  const fieldRx = 7;
+  const surround = rect({ class: surroundCls, x: 2, y: r28(topH), width: r28(W2 - 4), height: r28(fieldH + EDGE * 2), rx: 12 });
+  const surfaceBase = rect({ class: surfaceCls, x: EDGE, y: r28(fieldTop), width: r28(fieldW), height: r28(fieldH), rx: fieldRx });
+  const boundary = rect({ class: boundaryCls, x: EDGE, y: r28(fieldTop), width: r28(fieldW), height: r28(fieldH), rx: fieldRx });
+  const clipId = "sx-pb-clip";
+  const clip6 = el("clipPath", { id: clipId }, [rect({ x: EDGE, y: r28(fieldTop), width: r28(fieldW), height: r28(fieldH), rx: fieldRx })]);
+  const field = group({ "clip-path": `url(#${clipId})` }, [mod.drawField(lay, ctx, t)]);
+  const zones = [];
+  for (const z of lay.zones) {
+    zones.push(el("ellipse", { class: "sx-pb-zone", cx: X(z.x), cy: Y(z.y), rx: px(z.rx), ry: px(z.ry) }));
+    if (z.label) zones.push(text({ class: "sx-pb-zone-text", x: X(z.x), y: r28(Y(z.y) - px(z.ry) + (mod.yUp ? 11 : -4)), "text-anchor": "middle" }, z.label));
+  }
+  const moves = lay.moves.map((m) => renderMove(m, ctx));
+  const players = lay.players.map((p) => playerSymbol(p, ctx));
+  const ball = lay.sport === "football" ? el("ellipse", { class: "sx-pb-ball", cx: X(0), cy: Y(0), rx: 4.5, ry: 2.7 }) : "";
+  const annoParts = [];
+  if (annoH) {
+    const bits = [];
+    if (lay.down) bits.push(ordinal(lay.down) + (lay.distance ? ` & ${lay.distance}` : ""));
+    else if (lay.distance) bits.push(`${lay.distance} to go`);
+    if (lay.losYard !== void 0) bits.push(`ball on ${lay.losYard}`);
+    annoParts.push(text({ class: "sx-pb-anno", x: 8, y: titleH + 14 }, bits.join("   \xB7   ")));
+  }
+  const nOff = lay.players.filter((p) => p.side === "offense").length;
+  const nDef = lay.players.filter((p) => p.side === "defense").length;
+  const descText = `${lay.sport} play. ${nOff} ${lay.sport === "football" ? "offensive players" : "players"}, ${nDef} ${lay.sport === "football" ? "defenders" : "opponents"}, ${lay.moves.length} assignment${lay.moves.length === 1 ? "" : "s"}.` + (lay.warnings.length ? ` Warnings: ${lay.warnings.join("; ")}.` : "");
+  return svgRoot(
+    { viewBox: `0 0 ${W2} ${H2}`, width: W2, height: H2, class: "sx-pb", role: "img" },
+    [
+      title(lay.title),
+      desc(descText),
+      el("style", {}, buildCss14(t)),
+      rect({ fill: t.bg, x: 0, y: 0, width: W2, height: H2 }),
+      el("defs", {}, [clip6]),
+      text({ class: "sx-pb-title", x: r28(W2 / 2), y: TITLE.y, "text-anchor": "middle" }, lay.title),
+      ...annoParts,
+      surround,
+      surfaceBase,
+      field,
+      group({ class: "sx-pb-zones", "clip-path": `url(#${clipId})` }, zones),
+      group({ class: "sx-pb-moves" }, moves),
+      boundary,
+      group({ class: "sx-pb-players" }, players),
+      ball,
+      renderLegend4(mod.legend(lay), fieldH + topH + EDGE * 2 + 18, lay.sport)
+    ]
+  );
+}
+function renderPlaybook(text2, config) {
+  return renderPlaybookLayout(layoutPlaybook(parsePlaybook(text2)), config);
+}
+
+// src/diagrams/playbook/index.ts
+var playbook = {
+  type: "playbook",
+  detect(text2) {
+    for (const raw of text2.split(/\r?\n/)) {
+      const t = raw.trim();
+      if (!t) continue;
+      if (t.startsWith("#") || t.startsWith("//")) continue;
+      return /^playbook\b/i.test(t);
+    }
+    return false;
+  },
+  parse: parsePlaybook,
+  render(text2, config) {
+    return renderPlaybook(text2, config);
+  },
+  lint(text2) {
+    try {
+      const lay = layoutPlaybook(parsePlaybook(text2));
+      return [
+        ...lay.errors.map(
+          (message) => ({
+            severity: "error",
+            code: "playbook/validation",
+            message,
+            fatal: false
+          })
+        ),
+        ...lay.warnings.map(
+          (message) => ({
+            severity: "warning",
+            code: "playbook/warning",
+            message,
+            fatal: false
+          })
+        )
+      ];
+    } catch {
+      return [];
+    }
+  }
+};
+
 // src/core/api.ts
 var plugins = [
   genogram,
@@ -36017,7 +40039,9 @@ var plugins = [
   epc,
   idef0,
   threatmodel,
-  welding
+  welding,
+  floorplan,
+  playbook
 ];
 function detectPlugin(text2, config) {
   if (config?.type) {
@@ -36028,7 +40052,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', 'floorplan', or 'playbook'."
   );
 }
 function stripCodeFences(text2) {
@@ -36165,6 +40189,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-UFXDAIDD.js.map
+//# sourceMappingURL=chunk-UFXDAIDD.js.map