@chanmeng666/archlang 0.2.0 → 0.3.0

package/dist/{chunk-ICYNEDSM.js → chunk-3YUQPQPZ.js}

@@ -138,20 +138,577 @@ function lex(src) {
   return { tokens, errors };
 }
 
+// src/geometry.ts
+var sub = (a, b) => ({ x: a.x - b.x, y: a.y - b.y });
+var add = (a, b) => ({ x: a.x + b.x, y: a.y + b.y });
+var mul = (v, s) => ({ x: v.x * s, y: v.y * s });
+var length = (v) => Math.hypot(v.x, v.y);
+function unit(v) {
+  const l = length(v);
+  return l === 0 ? { x: 0, y: 0 } : { x: v.x / l, y: v.y / l };
+}
+var normal = (v) => ({ x: -v.y, y: v.x });
+var emptyBounds = () => ({
+  minX: Infinity,
+  minY: Infinity,
+  maxX: -Infinity,
+  maxY: -Infinity
+});
+function extendBounds(b, x, y) {
+  if (x < b.minX) b.minX = x;
+  if (y < b.minY) b.minY = y;
+  if (x > b.maxX) b.maxX = x;
+  if (y > b.maxY) b.maxY = y;
+}
+function distPointToSegment(p, a, b) {
+  const abx = b.x - a.x;
+  const aby = b.y - a.y;
+  const apx = p.x - a.x;
+  const apy = p.y - a.y;
+  const len2 = abx * abx + aby * aby;
+  let t = len2 === 0 ? 0 : (apx * abx + apy * aby) / len2;
+  t = Math.max(0, Math.min(1, t));
+  const cx = a.x + t * abx;
+  const cy = a.y + t * aby;
+  return Math.hypot(p.x - cx, p.y - cy);
+}
+function rectCorners(x, y, w, h) {
+  return [
+    { x, y },
+    { x: x + w, y },
+    { x: x + w, y: y + h },
+    { x, y: y + h }
+  ];
+}
+function segmentRectangle(a, b, thickness) {
+  const d = unit(sub(b, a));
+  const n = normal(d);
+  const half = thickness / 2;
+  const a2 = add(a, mul(d, -half));
+  const b2 = add(b, mul(d, half));
+  return [
+    add(a2, mul(n, half)),
+    add(b2, mul(n, half)),
+    add(b2, mul(n, -half)),
+    add(a2, mul(n, -half))
+  ];
+}
+function segmentsOfWall(w) {
+  const segs = [];
+  for (let k = 0; k < w.points.length - 1; k++) {
+    segs.push({ a: w.points[k], b: w.points[k + 1], thickness: w.thickness, category: w.category });
+  }
+  if (w.closed && w.points.length > 2) {
+    segs.push({ a: w.points[w.points.length - 1], b: w.points[0], thickness: w.thickness, category: w.category });
+  }
+  return segs;
+}
+function hostSegmentForWalls(walls, at, ref) {
+  const candidates = ref ? walls.filter((w) => w.id === ref || w.category === ref) : walls;
+  let best = null;
+  let bestDist = Infinity;
+  for (const w of candidates) {
+    for (const s of segmentsOfWall(w)) {
+      const dist = distPointToSegment(at, s.a, s.b);
+      if (dist < bestDist) {
+        bestDist = dist;
+        best = s;
+      }
+    }
+  }
+  return best;
+}
+function isOnSomeWall(walls, at, ref) {
+  const candidates = ref ? walls.filter((w) => w.id === ref || w.category === ref) : walls;
+  for (const w of candidates) {
+    const tol = w.thickness / 2 + Math.max(w.thickness, 1);
+    for (const s of segmentsOfWall(w)) {
+      if (distPointToSegment(at, s.a, s.b) <= tol) return true;
+    }
+  }
+  return false;
+}
+
+// src/elements/wall.ts
+var wall = {
+  kind: "wall",
+  keyword: "wall",
+  parse(ctx) {
+    const kw = ctx.eatKeyword("wall");
+    const id = ctx.parseIdOpt();
+    const category = ctx.eatIdent().value;
+    ctx.eatKeyword("thickness");
+    const thickness = ctx.eatNumber();
+    ctx.eat("lcurly");
+    const points = [];
+    let closed = false;
+    while (!ctx.isType("rcurly") && !ctx.isType("eof")) {
+      if (ctx.isKeyword("close")) {
+        ctx.next();
+        closed = true;
+        break;
+      }
+      if (ctx.isType("lparen")) {
+        points.push(ctx.parsePoint());
+        continue;
+      }
+      ctx.fail(`Expected a point "(x,y)" or "close" in wall body but found ${describe(ctx)}`);
+    }
+    ctx.eat("rcurly");
+    if (points.length < 2) ctx.fail("A wall needs at least two points", kw);
+    return { kind: "wall", id, category, thickness, points, closed, line: kw.line };
+  },
+  idPrefix: (node) => node.category || "wall",
+  resolve(node, ctx) {
+    const n = node;
+    const id = ctx.idOf(n);
+    const points = n.points.map(ctx.snapPt);
+    const thickness = ctx.snap(n.thickness) || n.thickness;
+    if (thickness <= 0) {
+      ctx.diag({ severity: "error", message: `Wall "${id}" must have a positive thickness`, code: "E_WALL_THICKNESS", span: n.span });
+    }
+    return { kind: "wall", id, category: n.category, thickness, points, closed: n.closed, span: n.span };
+  },
+  bounds(resolved) {
+    const w = resolved;
+    return segmentsOfWall(w).flatMap((s) => segmentRectangle(s.a, s.b, s.thickness));
+  },
+  render(resolved, ctx) {
+    const w = resolved;
+    const { fmt: fmt2, pt: pt2, theme, sizes } = ctx;
+    const segs = segmentsOfWall(w);
+    const ops = [];
+    for (const s of segs) {
+      const poly = segmentRectangle(s.a, s.b, s.thickness);
+      ops.push({ pass: "wallFill", svg: `<polygon points="${poly.map(pt2).join(" ")}" fill="url(#poche)"/>` });
+    }
+    for (const s of segs) {
+      const d = unit(sub(s.b, s.a));
+      const n = normal(d);
+      const h = s.thickness / 2;
+      const fa1 = add(s.a, mul(n, h));
+      const fb1 = add(s.b, mul(n, h));
+      const fa2 = add(s.a, mul(n, -h));
+      const fb2 = add(s.b, mul(n, -h));
+      ops.push({
+        pass: "wallFace",
+        svg: `<line x1="${fmt2(fa1.x)}" y1="${fmt2(fa1.y)}" x2="${fmt2(fb1.x)}" y2="${fmt2(fb1.y)}" stroke="${theme.wallStroke}" stroke-width="${fmt2(sizes.wallStroke)}" stroke-linecap="square"/>`
+      });
+      ops.push({
+        pass: "wallFace",
+        svg: `<line x1="${fmt2(fa2.x)}" y1="${fmt2(fa2.y)}" x2="${fmt2(fb2.x)}" y2="${fmt2(fb2.y)}" stroke="${theme.wallStroke}" stroke-width="${fmt2(sizes.wallStroke)}" stroke-linecap="square"/>`
+      });
+    }
+    return ops;
+  }
+};
+function describe(ctx) {
+  const t = ctx.peek();
+  if (t.type === "eof") return "end of input";
+  if (t.type === "string") return `string ${JSON.stringify(t.value)}`;
+  return `"${t.value}"`;
+}
+
+// src/elements/room.ts
+var room = {
+  kind: "room",
+  keyword: "room",
+  parse(ctx) {
+    const kw = ctx.eatKeyword("room");
+    const id = ctx.parseIdOpt();
+    ctx.eatKeyword("at");
+    const at = ctx.parsePoint();
+    ctx.eatKeyword("size");
+    const dim2 = ctx.eat("dimension");
+    const node = { kind: "room", id, at, size: { w: dim2.num, h: dim2.num2 }, line: kw.line };
+    if (ctx.isKeyword("label")) {
+      ctx.next();
+      node.label = ctx.eatString();
+    }
+    return node;
+  },
+  idPrefix: () => "room",
+  resolve(node, ctx) {
+    const n = node;
+    const id = ctx.idOf(n);
+    const at = ctx.snapPt(n.at);
+    const size = { w: ctx.snap(n.size.w), h: ctx.snap(n.size.h) };
+    if (size.w <= 0 || size.h <= 0) {
+      ctx.diag({ severity: "error", message: `Room "${id}" must have a positive size`, code: "E_ROOM_SIZE", span: n.span });
+    }
+    return { kind: "room", id, at, size, label: n.label, span: n.span };
+  },
+  bounds(resolved) {
+    const r = resolved;
+    return rectCorners(r.at.x, r.at.y, r.size.w, r.size.h);
+  },
+  render(resolved, ctx) {
+    const r = resolved;
+    const { fmt: fmt2, pt: pt2, xml: xml2, theme, sizes } = ctx;
+    const ops = [];
+    const c = rectCorners(r.at.x, r.at.y, r.size.w, r.size.h);
+    ops.push({ pass: "floor", svg: `<polygon points="${c.map(pt2).join(" ")}" fill="${theme.roomFill}"/>` });
+    const cx = r.at.x + r.size.w / 2;
+    const cy = r.at.y + r.size.h / 2;
+    const areaM2 = (r.size.w / 1e3 * (r.size.h / 1e3)).toFixed(1);
+    if (r.label) {
+      ops.push({
+        pass: "labels",
+        svg: `<text x="${fmt2(cx)}" y="${fmt2(cy - sizes.roomFont * 0.2)}" font-size="${fmt2(sizes.roomFont)}" fill="${theme.roomLabel}" text-anchor="middle" dominant-baseline="central" font-weight="600">${xml2(r.label)}</text>`
+      });
+    }
+    ops.push({
+      pass: "labels",
+      svg: `<text x="${fmt2(cx)}" y="${fmt2(cy + (r.label ? sizes.roomFont * 0.9 : 0))}" font-size="${fmt2(sizes.areaFont)}" fill="${theme.areaLabel}" text-anchor="middle" dominant-baseline="central">${areaM2} m\xB2</text>`
+    });
+    return ops;
+  }
+};
+
+// src/elements/door.ts
+var door = {
+  kind: "door",
+  keyword: "door",
+  parse(ctx) {
+    const kw = ctx.eatKeyword("door");
+    const id = ctx.parseIdOpt();
+    ctx.eatKeyword("at");
+    const at = ctx.parsePoint();
+    ctx.eatKeyword("width");
+    const width = ctx.eatNumber();
+    const node = { kind: "door", id, at, width, hinge: "left", swing: "in", line: kw.line };
+    if (ctx.isKeyword("wall")) {
+      ctx.next();
+      node.wall = ctx.eatIdent().value;
+    }
+    if (ctx.isKeyword("hinge")) {
+      ctx.next();
+      const h = ctx.eatIdent().value;
+      if (h !== "left" && h !== "right") ctx.fail(`Expected hinge "left" or "right" but found "${h}"`);
+      node.hinge = h;
+    }
+    if (ctx.isKeyword("swing")) {
+      ctx.next();
+      const s = ctx.eatIdent().value;
+      if (s !== "in" && s !== "out") ctx.fail(`Expected swing "in" or "out" but found "${s}"`);
+      node.swing = s;
+    }
+    return node;
+  },
+  idPrefix: () => "door",
+  resolve(node, ctx) {
+    const n = node;
+    const id = ctx.idOf(n);
+    const at = ctx.snapPt(n.at);
+    const width = ctx.snap(n.width) || n.width;
+    if (width <= 0) {
+      ctx.diag({ severity: "error", message: `Door "${id}" must have a positive width`, code: "E_DOOR_WIDTH", span: n.span });
+    }
+    if (ctx.walls.length > 0 && !ctx.isOnWall(at, n.wall)) {
+      ctx.diag({ severity: "warning", message: `Door "${id}" does not lie on any wall`, code: "W_DOOR_OFF_WALL", span: n.span });
+    }
+    return { kind: "door", id, at, width, hinge: n.hinge, swing: n.swing, host: ctx.hostSegment(at, n.wall), span: n.span };
+  },
+  bounds: () => [],
+  render(resolved, ctx) {
+    const dr = resolved;
+    const seg = dr.host;
+    if (!seg) return [];
+    const { fmt: fmt2, pt: pt2, theme, sizes } = ctx;
+    const d = unit(sub(seg.b, seg.a));
+    const n = normal(d);
+    const h = seg.thickness / 2 + sizes.wallStroke;
+    const hw = dr.width / 2;
+    const cover = [
+      add(add(dr.at, mul(d, -hw)), mul(n, h)),
+      add(add(dr.at, mul(d, hw)), mul(n, h)),
+      add(add(dr.at, mul(d, hw)), mul(n, -h)),
+      add(add(dr.at, mul(d, -hw)), mul(n, -h))
+    ];
+    const ops = [];
+    ops.push({ pass: "doors", svg: `<polygon points="${cover.map(pt2).join(" ")}" fill="${theme.opening}"/>` });
+    const hinge = dr.hinge === "left" ? add(dr.at, mul(d, -hw)) : add(dr.at, mul(d, hw));
+    const farJamb = dr.hinge === "left" ? add(dr.at, mul(d, hw)) : add(dr.at, mul(d, -hw));
+    const leafDir = dr.swing === "in" ? n : mul(n, -1);
+    const leafEnd = add(hinge, mul(leafDir, dr.width));
+    const cross = (leafEnd.x - hinge.x) * (farJamb.y - hinge.y) - (leafEnd.y - hinge.y) * (farJamb.x - hinge.x);
+    const sweep = cross < 0 ? 1 : 0;
+    ops.push({
+      pass: "doors",
+      svg: `<line x1="${fmt2(hinge.x)}" y1="${fmt2(hinge.y)}" x2="${fmt2(leafEnd.x)}" y2="${fmt2(leafEnd.y)}" stroke="${theme.doorLeaf}" stroke-width="${fmt2(sizes.thin * 1.3)}"/>`
+    });
+    ops.push({
+      pass: "doors",
+      svg: `<path d="M ${pt2(leafEnd)} A ${fmt2(dr.width)} ${fmt2(dr.width)} 0 0 ${sweep} ${pt2(farJamb)}" fill="none" stroke="${theme.doorLeaf}" stroke-width="${fmt2(sizes.thin)}" stroke-dasharray="${fmt2(sizes.thin * 4)} ${fmt2(sizes.thin * 3)}"/>`
+    });
+    return ops;
+  }
+};
+
+// src/elements/window.ts
+var windowEl = {
+  kind: "window",
+  keyword: "window",
+  parse(ctx) {
+    const kw = ctx.eatKeyword("window");
+    const id = ctx.parseIdOpt();
+    ctx.eatKeyword("at");
+    const at = ctx.parsePoint();
+    ctx.eatKeyword("width");
+    const width = ctx.eatNumber();
+    const node = { kind: "window", id, at, width, line: kw.line };
+    if (ctx.isKeyword("wall")) {
+      ctx.next();
+      node.wall = ctx.eatIdent().value;
+    }
+    return node;
+  },
+  idPrefix: () => "window",
+  resolve(node, ctx) {
+    const n = node;
+    const id = ctx.idOf(n);
+    const at = ctx.snapPt(n.at);
+    const width = ctx.snap(n.width) || n.width;
+    if (width <= 0) {
+      ctx.diag({ severity: "error", message: `Window "${id}" must have a positive width`, code: "E_WINDOW_WIDTH", span: n.span });
+    }
+    if (ctx.walls.length > 0 && !ctx.isOnWall(at, n.wall)) {
+      ctx.diag({ severity: "warning", message: `Window "${id}" does not lie on any wall`, code: "W_WINDOW_OFF_WALL", span: n.span });
+    }
+    return { kind: "window", id, at, width, host: ctx.hostSegment(at, n.wall), span: n.span };
+  },
+  bounds: () => [],
+  render(resolved, ctx) {
+    const wn = resolved;
+    const seg = wn.host;
+    if (!seg) return [];
+    const { fmt: fmt2, pt: pt2, theme, sizes } = ctx;
+    const d = unit(sub(seg.b, seg.a));
+    const n = normal(d);
+    const h = seg.thickness / 2;
+    const he = h + sizes.wallStroke;
+    const hw = wn.width / 2;
+    const cover = [
+      add(add(wn.at, mul(d, -hw)), mul(n, he)),
+      add(add(wn.at, mul(d, hw)), mul(n, he)),
+      add(add(wn.at, mul(d, hw)), mul(n, -he)),
+      add(add(wn.at, mul(d, -hw)), mul(n, -he))
+    ];
+    const ops = [];
+    ops.push({ pass: "windows", svg: `<polygon points="${cover.map(pt2).join(" ")}" fill="${theme.opening}"/>` });
+    const jA = add(wn.at, mul(d, -hw));
+    const jB = add(wn.at, mul(d, hw));
+    for (const off of [h, -h]) {
+      const a = add(jA, mul(n, off));
+      const bb = add(jB, mul(n, off));
+      ops.push({
+        pass: "windows",
+        svg: `<line x1="${fmt2(a.x)}" y1="${fmt2(a.y)}" x2="${fmt2(bb.x)}" y2="${fmt2(bb.y)}" stroke="${theme.wallStroke}" stroke-width="${fmt2(sizes.thin)}"/>`
+      });
+    }
+    ops.push({
+      pass: "windows",
+      svg: `<line x1="${fmt2(jA.x)}" y1="${fmt2(jA.y)}" x2="${fmt2(jB.x)}" y2="${fmt2(jB.y)}" stroke="${theme.windowPane}" stroke-width="${fmt2(sizes.thin)}"/>`
+    });
+    return ops;
+  }
+};
+
+// src/elements/furniture.ts
+var furniture = {
+  kind: "furniture",
+  keyword: "furniture",
+  parse(ctx) {
+    const kw = ctx.eatKeyword("furniture");
+    const id = ctx.parseIdOpt();
+    const category = ctx.eatIdent().value;
+    ctx.eatKeyword("at");
+    const at = ctx.parsePoint();
+    ctx.eatKeyword("size");
+    const dim2 = ctx.eat("dimension");
+    const node = { kind: "furniture", id, category, at, size: { w: dim2.num, h: dim2.num2 }, line: kw.line };
+    if (ctx.isKeyword("label")) {
+      ctx.next();
+      node.label = ctx.eatString();
+    }
+    return node;
+  },
+  idPrefix: (node) => node.category || "furniture",
+  resolve(node, ctx) {
+    const n = node;
+    const id = ctx.idOf(n);
+    const at = ctx.snapPt(n.at);
+    const size = { w: ctx.snap(n.size.w), h: ctx.snap(n.size.h) };
+    if (size.w <= 0 || size.h <= 0) {
+      ctx.diag({ severity: "error", message: `Furniture "${id}" must have a positive size`, code: "E_FURN_SIZE", span: n.span });
+    }
+    return { kind: "furniture", id, category: n.category, at, size, label: n.label, span: n.span };
+  },
+  bounds(resolved) {
+    const f = resolved;
+    return rectCorners(f.at.x, f.at.y, f.size.w, f.size.h);
+  },
+  render(resolved, ctx) {
+    const f = resolved;
+    const { fmt: fmt2, pt: pt2, xml: xml2, theme, sizes } = ctx;
+    const ops = [];
+    const c = rectCorners(f.at.x, f.at.y, f.size.w, f.size.h);
+    ops.push({
+      pass: "furniture",
+      svg: `<polygon points="${c.map(pt2).join(" ")}" fill="${theme.furnitureFill}" stroke="${theme.furnitureStroke}" stroke-width="${fmt2(sizes.thin)}"/>`
+    });
+    if (f.label) {
+      const cx = f.at.x + f.size.w / 2;
+      const cy = f.at.y + f.size.h / 2;
+      ops.push({
+        pass: "furniture",
+        svg: `<text x="${fmt2(cx)}" y="${fmt2(cy)}" font-size="${fmt2(sizes.furnFont)}" fill="${theme.furnitureLabel}" text-anchor="middle" dominant-baseline="central">${xml2(f.label)}</text>`
+      });
+    }
+    return ops;
+  }
+};
+
+// src/elements/dim.ts
+var dim = {
+  kind: "dim",
+  keyword: "dim",
+  parse(ctx) {
+    const kw = ctx.eatKeyword("dim");
+    const from = ctx.parsePoint();
+    ctx.eat("arrow");
+    const to = ctx.parsePoint();
+    const node = { kind: "dim", id: "", from, to, offset: 300, line: kw.line };
+    if (ctx.isKeyword("offset")) {
+      ctx.next();
+      node.offset = ctx.eatNumber();
+    }
+    if (ctx.isKeyword("text")) {
+      ctx.next();
+      node.text = ctx.eatString();
+    }
+    return node;
+  },
+  idPrefix: () => "dim",
+  resolve(node, ctx) {
+    const n = node;
+    return {
+      kind: "dim",
+      id: ctx.idOf(n),
+      from: ctx.snapPt(n.from),
+      to: ctx.snapPt(n.to),
+      offset: n.offset,
+      text: n.text,
+      span: n.span
+    };
+  },
+  bounds(resolved) {
+    const dm = resolved;
+    return [dm.from, dm.to];
+  },
+  render(resolved, ctx) {
+    const dm = resolved;
+    const { fmt: fmt2, xml: xml2, theme, sizes } = ctx;
+    const dir = unit(sub(dm.to, dm.from));
+    const n = normal(dir);
+    const off = mul(n, dm.offset);
+    const p1 = add(dm.from, off);
+    const p2 = add(dm.to, off);
+    const tick = sizes.refDim * 0.012;
+    const ops = [];
+    ops.push({
+      pass: "dims",
+      svg: `<line x1="${fmt2(dm.from.x)}" y1="${fmt2(dm.from.y)}" x2="${fmt2(p1.x)}" y2="${fmt2(p1.y)}" stroke="${theme.dim}" stroke-width="${fmt2(sizes.thin * 0.7)}"/>`
+    });
+    ops.push({
+      pass: "dims",
+      svg: `<line x1="${fmt2(dm.to.x)}" y1="${fmt2(dm.to.y)}" x2="${fmt2(p2.x)}" y2="${fmt2(p2.y)}" stroke="${theme.dim}" stroke-width="${fmt2(sizes.thin * 0.7)}"/>`
+    });
+    ops.push({
+      pass: "dims",
+      svg: `<line x1="${fmt2(p1.x)}" y1="${fmt2(p1.y)}" x2="${fmt2(p2.x)}" y2="${fmt2(p2.y)}" stroke="${theme.dim}" stroke-width="${fmt2(sizes.thin)}"/>`
+    });
+    for (const p of [p1, p2]) {
+      const t1 = add(p, mul(unit({ x: dir.x + n.x, y: dir.y + n.y }), tick));
+      const t2 = add(p, mul(unit({ x: dir.x + n.x, y: dir.y + n.y }), -tick));
+      ops.push({
+        pass: "dims",
+        svg: `<line x1="${fmt2(t1.x)}" y1="${fmt2(t1.y)}" x2="${fmt2(t2.x)}" y2="${fmt2(t2.y)}" stroke="${theme.dim}" stroke-width="${fmt2(sizes.thin)}"/>`
+      });
+    }
+    const mid = { x: (p1.x + p2.x) / 2, y: (p1.y + p2.y) / 2 };
+    const tp = add(mid, mul(n, sizes.dimFont * 0.7));
+    let angle = Math.atan2(dir.y, dir.x) * 180 / Math.PI;
+    if (angle > 90) angle -= 180;
+    if (angle < -90) angle += 180;
+    const label = dm.text ?? String(Math.round(length(sub(dm.to, dm.from))));
+    ops.push({
+      pass: "dims",
+      svg: `<text x="${fmt2(tp.x)}" y="${fmt2(tp.y)}" font-size="${fmt2(sizes.dimFont)}" fill="${theme.dim}" text-anchor="middle" dominant-baseline="central" transform="rotate(${fmt2(angle)} ${fmt2(tp.x)} ${fmt2(tp.y)})">${xml2(label)}</text>`
+    });
+    return ops;
+  }
+};
+
+// src/elements/column.ts
+var column = {
+  kind: "column",
+  keyword: "column",
+  parse(ctx) {
+    const kw = ctx.eatKeyword("column");
+    const id = ctx.parseIdOpt();
+    ctx.eatKeyword("at");
+    const at = ctx.parsePoint();
+    ctx.eatKeyword("size");
+    const dim2 = ctx.eat("dimension");
+    return { kind: "column", id, at, size: { w: dim2.num, h: dim2.num2 }, line: kw.line };
+  },
+  idPrefix: () => "column",
+  resolve(node, ctx) {
+    const n = node;
+    const id = ctx.idOf(n);
+    const at = ctx.snapPt(n.at);
+    const size = { w: ctx.snap(n.size.w), h: ctx.snap(n.size.h) };
+    if (size.w <= 0 || size.h <= 0) {
+      ctx.diag({ severity: "error", message: `Column "${id}" must have a positive size`, code: "E_COLUMN_SIZE", span: n.span });
+    }
+    return { kind: "column", id, at, size, span: n.span };
+  },
+  bounds(resolved) {
+    const c = resolved;
+    return rectCorners(c.at.x, c.at.y, c.size.w, c.size.h);
+  },
+  render(resolved, ctx) {
+    const c = resolved;
+    const { fmt: fmt2, pt: pt2, theme, sizes } = ctx;
+    const pts = rectCorners(c.at.x, c.at.y, c.size.w, c.size.h);
+    return [
+      {
+        pass: "furniture",
+        svg: `<polygon points="${pts.map(pt2).join(" ")}" fill="${theme.column}" stroke="${theme.wallStroke}" stroke-width="${fmt2(sizes.thin)}"/>`
+      }
+    ];
+  }
+};
+
+// src/elements/index.ts
+var registryOrder = [];
+var registry = /* @__PURE__ */ new Map();
+function register(def) {
+  registry.set(def.keyword, def);
+  registryOrder.push(def);
+}
+register(wall);
+register(room);
+register(door);
+register(windowEl);
+register(furniture);
+register(dim);
+register(column);
+
 // src/parser.ts
-var STATEMENT_STARTS = /* @__PURE__ */ new Set([
-  "units",
-  "grid",
-  "scale",
-  "north",
-  "wall",
-  "room",
-  "door",
-  "window",
-  "furniture",
-  "dim",
-  "title"
-]);
+var SETTINGS = ["units", "grid", "scale", "north", "title"];
+var STATEMENT_STARTS = /* @__PURE__ */ new Set([...SETTINGS, ...registry.keys()]);
 var ParseError = class extends Error {
   constructor(message, span) {
     super(message);
@@ -184,10 +741,26 @@ function parse(src) {
 var Parser = class {
   constructor(toks) {
     this.toks = toks;
+    this.ctx = {
+      peek: (o) => this.peek(o),
+      next: () => this.next(),
+      eat: (type) => this.eat(type),
+      eatKeyword: (kw) => this.eatKeyword(kw),
+      eatIdent: () => this.eatIdent(),
+      eatNumber: () => this.eatNumber(),
+      eatString: () => this.eatString(),
+      isKeyword: (kw, o) => this.isKeyword(kw, o),
+      isType: (type) => this.isType(type),
+      parsePoint: () => this.parsePoint(),
+      parseIdOpt: () => this.parseIdOpt(),
+      fail: (msg, t) => this.fail(msg, t)
+    };
   }
   toks;
   pos = 0;
   diagnostics = [];
+  /** Facade passed to element parse functions (see registry.ts). */
+  ctx;
   peek(o = 0) {
     return this.toks[Math.min(this.pos + o, this.toks.length - 1)];
   }
@@ -217,12 +790,12 @@ var Parser = class {
   }
   eatKeyword(kw) {
     const t = this.peek();
-    if (t.type !== "ident" || t.value !== kw) this.fail(`Expected "${kw}" but found ${describe(t)}`);
+    if (t.type !== "ident" || t.value !== kw) this.fail(`Expected "${kw}" but found ${describe2(t)}`);
     return this.next();
   }
   eat(type) {
     const t = this.peek();
-    if (t.type !== type) this.fail(`Expected ${type} but found ${describe(t)}`);
+    if (t.type !== type) this.fail(`Expected ${type} but found ${describe2(t)}`);
     return this.next();
   }
   eatIdent() {
@@ -244,18 +817,20 @@ var Parser = class {
       units: "mm",
       grid: 0,
       north: "up",
-      walls: [],
-      rooms: [],
-      doors: [],
-      windows: [],
-      furniture: [],
-      dims: []
+      elements: []
     };
     while (!this.isType("rcurly") && !this.isType("eof")) {
       const t = this.peek();
       const start = t.start;
       try {
-        if (t.type !== "ident") this.fail(`Expected a statement but found ${describe(t)}`);
+        if (t.type !== "ident") this.fail(`Expected a statement but found ${describe2(t)}`);
+        const def = registry.get(t.value);
+        if (def) {
+          const node = def.parse(this.ctx);
+          node.span = this.spanFrom(start);
+          plan.elements.push(node);
+          continue;
+        }
         switch (t.value) {
           case "units": {
             this.next();
@@ -280,42 +855,6 @@ var Parser = class {
             this.next();
             plan.north = this.parseNorth();
             break;
-          case "wall": {
-            const n = this.parseWall();
-            n.span = this.spanFrom(start);
-            plan.walls.push(n);
-            break;
-          }
-          case "room": {
-            const n = this.parseRoom();
-            n.span = this.spanFrom(start);
-            plan.rooms.push(n);
-            break;
-          }
-          case "door": {
-            const n = this.parseDoor();
-            n.span = this.spanFrom(start);
-            plan.doors.push(n);
-            break;
-          }
-          case "window": {
-            const n = this.parseWindow();
-            n.span = this.spanFrom(start);
-            plan.windows.push(n);
-            break;
-          }
-          case "furniture": {
-            const n = this.parseFurniture();
-            n.span = this.spanFrom(start);
-            plan.furniture.push(n);
-            break;
-          }
-          case "dim": {
-            const n = this.parseDim();
-            n.span = this.spanFrom(start);
-            plan.dims.push(n);
-            break;
-          }
           case "title": {
             const n = this.parseTitle();
             n.span = this.spanFrom(start);
@@ -367,7 +906,7 @@ var Parser = class {
       this.next();
       return t.value;
     }
-    this.fail(`Expected a north direction (up|down|left|right|<degrees>) but found ${describe(t)}`);
+    this.fail(`Expected a north direction (up|down|left|right|<degrees>) but found ${describe2(t)}`);
   }
   parsePoint() {
     this.eat("lparen");
@@ -377,123 +916,13 @@ var Parser = class {
     this.eat("rparen");
     return { x, y };
   }
-  parseWall() {
-    const kw = this.eatKeyword("wall");
-    const id = this.parseIdOpt();
-    const kind = this.eatIdent().value;
-    this.eatKeyword("thickness");
-    const thickness = this.eatNumber();
-    this.eat("lcurly");
-    const points = [];
-    let closed = false;
-    while (!this.isType("rcurly") && !this.isType("eof")) {
-      if (this.isKeyword("close")) {
-        this.next();
-        closed = true;
-        break;
-      }
-      if (this.isType("lparen")) {
-        points.push(this.parsePoint());
-        continue;
-      }
-      this.fail(`Expected a point "(x,y)" or "close" in wall body but found ${describe(this.peek())}`);
-    }
-    this.eat("rcurly");
-    if (points.length < 2) this.fail("A wall needs at least two points", kw);
-    return { id, kind, thickness, points, closed, line: kw.line };
-  }
-  parseRoom() {
-    const kw = this.eatKeyword("room");
-    const id = this.parseIdOpt();
-    this.eatKeyword("at");
-    const at = this.parsePoint();
-    this.eatKeyword("size");
-    const dim = this.eat("dimension");
-    const node = { id, at, size: { w: dim.num, h: dim.num2 }, line: kw.line };
-    if (this.isKeyword("label")) {
-      this.next();
-      node.label = this.eatString();
-    }
-    return node;
-  }
-  parseDoor() {
-    const kw = this.eatKeyword("door");
-    const id = this.parseIdOpt();
-    this.eatKeyword("at");
-    const at = this.parsePoint();
-    this.eatKeyword("width");
-    const width = this.eatNumber();
-    const node = { id, at, width, hinge: "left", swing: "in", line: kw.line };
-    if (this.isKeyword("wall")) {
-      this.next();
-      node.wall = this.eatIdent().value;
-    }
-    if (this.isKeyword("hinge")) {
-      this.next();
-      const h = this.eatIdent().value;
-      if (h !== "left" && h !== "right") this.fail(`Expected hinge "left" or "right" but found "${h}"`);
-      node.hinge = h;
-    }
-    if (this.isKeyword("swing")) {
-      this.next();
-      const s = this.eatIdent().value;
-      if (s !== "in" && s !== "out") this.fail(`Expected swing "in" or "out" but found "${s}"`);
-      node.swing = s;
-    }
-    return node;
-  }
-  parseWindow() {
-    const kw = this.eatKeyword("window");
-    const id = this.parseIdOpt();
-    this.eatKeyword("at");
-    const at = this.parsePoint();
-    this.eatKeyword("width");
-    const width = this.eatNumber();
-    const node = { id, at, width, line: kw.line };
-    if (this.isKeyword("wall")) {
-      this.next();
-      node.wall = this.eatIdent().value;
-    }
-    return node;
-  }
-  parseFurniture() {
-    const kw = this.eatKeyword("furniture");
-    const id = this.parseIdOpt();
-    const kind = this.eatIdent().value;
-    this.eatKeyword("at");
-    const at = this.parsePoint();
-    this.eatKeyword("size");
-    const dim = this.eat("dimension");
-    const node = { id, kind, at, size: { w: dim.num, h: dim.num2 }, line: kw.line };
-    if (this.isKeyword("label")) {
-      this.next();
-      node.label = this.eatString();
-    }
-    return node;
-  }
-  parseDim() {
-    const kw = this.eatKeyword("dim");
-    const from = this.parsePoint();
-    this.eat("arrow");
-    const to = this.parsePoint();
-    const node = { id: "", from, to, offset: 300, line: kw.line };
-    if (this.isKeyword("offset")) {
-      this.next();
-      node.offset = this.eatNumber();
-    }
-    if (this.isKeyword("text")) {
-      this.next();
-      node.text = this.eatString();
-    }
-    return node;
-  }
   parseTitle() {
     const kw = this.eatKeyword("title");
     this.eat("lcurly");
     const node = { line: kw.line };
     while (!this.isType("rcurly") && !this.isType("eof")) {
       const t = this.peek();
-      if (t.type !== "ident") this.fail(`Expected a title field but found ${describe(t)}`);
+      if (t.type !== "ident") this.fail(`Expected a title field but found ${describe2(t)}`);
       switch (t.value) {
         case "project":
           this.next();
@@ -515,157 +944,24 @@ var Parser = class {
     return node;
   }
 };
-function describe(t) {
+function describe2(t) {
   if (t.type === "eof") return "end of input";
   if (t.type === "string") return `string ${JSON.stringify(t.value)}`;
   return `"${t.value}"`;
 }
 
-// src/geometry.ts
-var sub = (a, b) => ({ x: a.x - b.x, y: a.y - b.y });
-var add = (a, b) => ({ x: a.x + b.x, y: a.y + b.y });
-var mul = (v, s) => ({ x: v.x * s, y: v.y * s });
-var length = (v) => Math.hypot(v.x, v.y);
-function unit(v) {
-  const l = length(v);
-  return l === 0 ? { x: 0, y: 0 } : { x: v.x / l, y: v.y / l };
-}
-var normal = (v) => ({ x: -v.y, y: v.x });
-var emptyBounds = () => ({
-  minX: Infinity,
-  minY: Infinity,
-  maxX: -Infinity,
-  maxY: -Infinity
-});
-function extendBounds(b, x, y) {
-  if (x < b.minX) b.minX = x;
-  if (y < b.minY) b.minY = y;
-  if (x > b.maxX) b.maxX = x;
-  if (y > b.maxY) b.maxY = y;
-}
-function distPointToSegment(p, a, b) {
-  const abx = b.x - a.x;
-  const aby = b.y - a.y;
-  const apx = p.x - a.x;
-  const apy = p.y - a.y;
-  const len2 = abx * abx + aby * aby;
-  let t = len2 === 0 ? 0 : (apx * abx + apy * aby) / len2;
-  t = Math.max(0, Math.min(1, t));
-  const cx = a.x + t * abx;
-  const cy = a.y + t * aby;
-  return Math.hypot(p.x - cx, p.y - cy);
-}
-function rectCorners(x, y, w, h) {
-  return [
-    { x, y },
-    { x: x + w, y },
-    { x: x + w, y: y + h },
-    { x, y: y + h }
-  ];
-}
-function segmentRectangle(a, b, thickness) {
-  const d = unit(sub(b, a));
-  const n = normal(d);
-  const half = thickness / 2;
-  const a2 = add(a, mul(d, -half));
-  const b2 = add(b, mul(d, half));
-  return [
-    add(a2, mul(n, half)),
-    add(b2, mul(n, half)),
-    add(b2, mul(n, -half)),
-    add(a2, mul(n, -half))
-  ];
-}
-function wallSegments(plan) {
-  const segs = [];
-  for (const w of plan.walls) {
-    for (let k = 0; k < w.points.length - 1; k++) {
-      segs.push({ a: w.points[k], b: w.points[k + 1], thickness: w.thickness, kind: w.kind });
-    }
-    if (w.closed && w.points.length > 2) {
-      segs.push({ a: w.points[w.points.length - 1], b: w.points[0], thickness: w.thickness, kind: w.kind });
-    }
-  }
-  return segs;
-}
-function hostSegment(plan, at, wallRef) {
-  const walls = wallRef ? plan.walls.filter((w) => w.id === wallRef || w.kind === wallRef) : plan.walls;
-  let best = null;
-  let bestDist = Infinity;
-  for (const w of walls) {
-    const segs = [];
-    for (let k = 0; k < w.points.length - 1; k++) segs.push([w.points[k], w.points[k + 1]]);
-    if (w.closed && w.points.length > 2) segs.push([w.points[w.points.length - 1], w.points[0]]);
-    for (const [a, b] of segs) {
-      const dist = distPointToSegment(at, a, b);
-      if (dist < bestDist) {
-        bestDist = dist;
-        best = { a, b, thickness: w.thickness, kind: w.kind };
-      }
-    }
-  }
-  return best;
-}
-function planBounds(plan) {
-  const b = emptyBounds();
-  for (const seg of wallSegments(plan)) {
-    for (const c of segmentRectangle(seg.a, seg.b, seg.thickness)) extendBounds(b, c.x, c.y);
-  }
-  for (const r of plan.rooms) {
-    extendBounds(b, r.at.x, r.at.y);
-    extendBounds(b, r.at.x + r.size.w, r.at.y + r.size.h);
-  }
-  for (const f of plan.furniture) {
-    extendBounds(b, f.at.x, f.at.y);
-    extendBounds(b, f.at.x + f.size.w, f.at.y + f.size.h);
-  }
-  for (const d of plan.dims) {
-    extendBounds(b, d.from.x, d.from.y);
-    extendBounds(b, d.to.x, d.to.y);
-  }
-  if (!isFinite(b.minX)) {
-    return { minX: 0, minY: 0, maxX: 1e3, maxY: 1e3 };
-  }
-  return b;
-}
-
-// src/validate.ts
-function validate(plan) {
-  const diags = [];
-  const error = (message, code, span) => diags.push({ severity: "error", message, code, span });
-  const warn = (message, code, span) => diags.push({ severity: "warning", message, code, span });
-  const g = plan.grid;
+// src/ir.ts
+function resolve(ast) {
+  const diagnostics = [];
+  const g = ast.grid;
   const snap = (v) => g > 0 ? Math.round(v / g) * g : v;
   const snapPt = (p) => ({ x: snap(p.x), y: snap(p.y) });
-  for (const w of plan.walls) {
-    w.points = w.points.map(snapPt);
-    w.thickness = snap(w.thickness) || w.thickness;
-  }
-  for (const r of plan.rooms) {
-    r.at = snapPt(r.at);
-    r.size = { w: snap(r.size.w), h: snap(r.size.h) };
-  }
-  for (const f of plan.furniture) {
-    f.at = snapPt(f.at);
-    f.size = { w: snap(f.size.w), h: snap(f.size.h) };
-  }
-  for (const d of plan.doors) {
-    d.at = snapPt(d.at);
-    d.width = snap(d.width) || d.width;
-  }
-  for (const win of plan.windows) {
-    win.at = snapPt(win.at);
-    win.width = snap(win.width) || win.width;
-  }
-  for (const dm of plan.dims) {
-    dm.from = snapPt(dm.from);
-    dm.to = snapPt(dm.to);
-  }
+  const idMap = /* @__PURE__ */ new Map();
   const seen = /* @__PURE__ */ new Set();
-  const assign = (provided, prefix, idx, span) => {
+  const assignId = (provided, prefix, idx, span) => {
     if (provided) {
       if (seen.has(provided)) {
-        error(`Duplicate id "${provided}"`, "E_DUP_ID", span);
+        diagnostics.push({ severity: "error", message: `Duplicate id "${provided}"`, code: "E_DUP_ID", span });
       }
       seen.add(provided);
       return provided;
@@ -675,68 +971,88 @@ function validate(plan) {
     seen.add(auto);
     return auto;
   };
-  plan.walls.forEach((w, i) => w.id = assign(w.id, w.kind || "wall", i + 1, w.span));
-  plan.rooms.forEach((r, i) => r.id = assign(r.id, "room", i + 1, r.span));
-  plan.doors.forEach((d, i) => d.id = assign(d.id, "door", i + 1, d.span));
-  plan.windows.forEach((w, i) => w.id = assign(w.id, "window", i + 1, w.span));
-  plan.furniture.forEach((f, i) => f.id = assign(f.id, f.kind || "furniture", i + 1, f.span));
-  plan.dims.forEach((d, i) => d.id = assign(d.id, "dim", i + 1, d.span));
-  for (const r of plan.rooms) {
-    if (r.size.w <= 0 || r.size.h <= 0)
-      error(`Room "${r.id}" must have a positive size`, "E_ROOM_SIZE", r.span);
-  }
-  for (const f of plan.furniture) {
-    if (f.size.w <= 0 || f.size.h <= 0)
-      error(`Furniture "${f.id}" must have a positive size`, "E_FURN_SIZE", f.span);
-  }
-  for (const d of plan.doors) {
-    if (d.width <= 0) error(`Door "${d.id}" must have a positive width`, "E_DOOR_WIDTH", d.span);
-  }
-  for (const w of plan.windows) {
-    if (w.width <= 0) error(`Window "${w.id}" must have a positive width`, "E_WINDOW_WIDTH", w.span);
-  }
-  for (const w of plan.walls) {
-    if (w.thickness <= 0)
-      error(`Wall "${w.id}" must have a positive thickness`, "E_WALL_THICKNESS", w.span);
-  }
-  if (plan.walls.length === 0 && plan.rooms.length === 0 && plan.furniture.length === 0) {
-    warn("Plan has no walls, rooms, or furniture \u2014 nothing to draw", "W_EMPTY_PLAN");
-  }
-  const onSomeWall = (at, wallRef) => {
-    const candidates = wallRef ? plan.walls.filter((w) => w.id === wallRef || w.kind === wallRef) : plan.walls;
-    for (const w of candidates) {
-      const tol = w.thickness / 2 + Math.max(w.thickness, 1);
-      for (let k = 0; k < w.points.length - 1; k++) {
-        if (distPointToSegment(at, w.points[k], w.points[k + 1]) <= tol) return true;
-      }
-      if (w.closed && w.points.length > 2) {
-        if (distPointToSegment(at, w.points[w.points.length - 1], w.points[0]) <= tol) return true;
-      }
+  for (const def of registryOrder) {
+    let idx = 0;
+    for (const node of ast.elements) {
+      if (node.kind !== def.kind) continue;
+      idx++;
+      idMap.set(node, assignId(node.id, def.idPrefix(node), idx, node.span));
     }
-    return false;
+  }
+  const walls = [];
+  const ctx = {
+    grid: g,
+    snap,
+    snapPt,
+    idOf: (node) => idMap.get(node) ?? node.id,
+    walls,
+    hostSegment: (at, ref) => hostSegmentForWalls(walls, at, ref),
+    isOnWall: (at, ref) => isOnSomeWall(walls, at, ref),
+    diag: (d) => diagnostics.push(d)
   };
-  for (const d of plan.doors) {
-    if (plan.walls.length > 0 && !onSomeWall(d.at, d.wall))
-      warn(`Door "${d.id}" does not lie on any wall`, "W_DOOR_OFF_WALL", d.span);
+  const rmap = /* @__PURE__ */ new Map();
+  for (const def of registryOrder) {
+    for (const node of ast.elements) {
+      if (node.kind !== def.kind) continue;
+      const r = def.resolve(node, ctx);
+      rmap.set(node, r);
+      if (r.kind === "wall") walls.push(r);
+    }
   }
-  for (const w of plan.windows) {
-    if (plan.walls.length > 0 && !onSomeWall(w.at, w.wall))
-      warn(`Window "${w.id}" does not lie on any wall`, "W_WINDOW_OFF_WALL", w.span);
+  const elements = ast.elements.map((n) => rmap.get(n));
+  const drawable = elements.some(
+    (e) => e.kind === "wall" || e.kind === "room" || e.kind === "furniture" || e.kind === "column"
+  );
+  if (!drawable) {
+    diagnostics.push({
+      severity: "warning",
+      message: "Plan has no walls, rooms, or furniture \u2014 nothing to draw",
+      code: "W_EMPTY_PLAN"
+    });
   }
-  for (let a = 0; a < plan.rooms.length; a++) {
-    for (let b = a + 1; b < plan.rooms.length; b++) {
-      const r1 = plan.rooms[a];
-      const r2 = plan.rooms[b];
+  const rooms = elements.filter((e) => e.kind === "room");
+  for (let a = 0; a < rooms.length; a++) {
+    for (let b = a + 1; b < rooms.length; b++) {
+      const r1 = rooms[a];
+      const r2 = rooms[b];
       const ox = Math.max(0, Math.min(r1.at.x + r1.size.w, r2.at.x + r2.size.w) - Math.max(r1.at.x, r2.at.x));
       const oy = Math.max(0, Math.min(r1.at.y + r1.size.h, r2.at.y + r2.size.h) - Math.max(r1.at.y, r2.at.y));
       if (ox > 1 && oy > 1) {
-        warn(`Rooms "${r1.id}" and "${r2.id}" overlap`, "W_ROOM_OVERLAP", r2.span);
+        diagnostics.push({
+          severity: "warning",
+          message: `Rooms "${r1.id}" and "${r2.id}" overlap`,
+          code: "W_ROOM_OVERLAP",
+          span: r2.span
+        });
       }
     }
   }
-  return diags;
+  const ir = {
+    name: ast.name,
+    units: ast.units,
+    grid: ast.grid,
+    scale: ast.scale,
+    north: ast.north,
+    title: ast.title,
+    elements,
+    walls
+  };
+  return { ir, diagnostics };
 }
 
+// src/registry.ts
+var RENDER_PASSES = [
+  "floor",
+  "furniture",
+  "wallFill",
+  "wallFace",
+  "doors",
+  "windows",
+  "labels",
+  "dims",
+  "annotations"
+];
+
 // src/render.ts
 var THEME = {
   bg: "#ffffff",
@@ -754,7 +1070,8 @@ var THEME = {
   windowPane: "#3a6ea5",
   dim: "#0E5484",
   annotation: "#333333",
-  annotationMuted: "#888888"
+  annotationMuted: "#888888",
+  column: "#4a4a4a"
 };
 function fmt(v) {
   const r = Math.round(v * 100) / 100;
@@ -770,19 +1087,35 @@ function niceBarLength(target) {
   for (const v of NICE_LENGTHS) if (v <= target) best = v;
   return best;
 }
-function render(plan, opts = {}) {
-  const b = planBounds(plan);
+function planBounds(ir) {
+  const b = emptyBounds();
+  for (const el of ir.elements) {
+    const def = registry.get(el.kind);
+    if (!def) continue;
+    for (const p of def.bounds(el)) extendBounds(b, p.x, p.y);
+  }
+  if (!isFinite(b.minX)) {
+    return { minX: 0, minY: 0, maxX: 1e3, maxY: 1e3 };
+  }
+  return b;
+}
+function render(ir, opts = {}) {
+  const b = planBounds(ir);
   const drawW = b.maxX - b.minX;
   const drawH = b.maxY - b.minY;
   const refDim = Math.max(drawW, drawH, 1);
-  const wallStroke = refDim * 28e-4;
-  const thin = refDim * 16e-4;
-  const roomFont = refDim * 0.03;
-  const areaFont = refDim * 0.022;
-  const dimFont = refDim * 0.02;
-  const furnFont = refDim * 0.017;
-  const margin = refDim * 0.17;
-  const hatchGap = refDim * 0.013;
+  const sizes = {
+    refDim,
+    wallStroke: refDim * 28e-4,
+    thin: refDim * 16e-4,
+    roomFont: refDim * 0.03,
+    areaFont: refDim * 0.022,
+    dimFont: refDim * 0.02,
+    furnFont: refDim * 0.017,
+    margin: refDim * 0.17,
+    hatchGap: refDim * 0.013
+  };
+  const { thin, margin, hatchGap } = sizes;
   const vbX = b.minX - margin;
   const vbY = b.minY - margin;
   const vbW = drawW + margin * 2;
@@ -796,157 +1129,27 @@ function render(plan, opts = {}) {
     `<defs><pattern id="poche" patternUnits="userSpaceOnUse" width="${fmt(hatchGap)}" height="${fmt(hatchGap)}" patternTransform="rotate(45)"><rect width="${fmt(hatchGap)}" height="${fmt(hatchGap)}" fill="${THEME.pocheBase}"/><line x1="0" y1="0" x2="0" y2="${fmt(hatchGap)}" stroke="${THEME.pocheHatch}" stroke-width="${fmt(thin * 0.7)}"/></pattern></defs>`
   );
   out.push(`<rect x="${fmt(vbX)}" y="${fmt(vbY)}" width="${fmt(vbW)}" height="${fmt(vbH)}" fill="${THEME.bg}"/>`);
-  for (const r of plan.rooms) {
-    const c = rectCorners(r.at.x, r.at.y, r.size.w, r.size.h);
-    out.push(`<polygon points="${c.map(pt).join(" ")}" fill="${THEME.roomFill}"/>`);
-  }
-  for (const f of plan.furniture) {
-    const c = rectCorners(f.at.x, f.at.y, f.size.w, f.size.h);
-    out.push(
-      `<polygon points="${c.map(pt).join(" ")}" fill="${THEME.furnitureFill}" stroke="${THEME.furnitureStroke}" stroke-width="${fmt(thin)}"/>`
-    );
-    if (f.label) {
-      const cx = f.at.x + f.size.w / 2;
-      const cy = f.at.y + f.size.h / 2;
-      out.push(
-        `<text x="${fmt(cx)}" y="${fmt(cy)}" font-size="${fmt(furnFont)}" fill="${THEME.furnitureLabel}" text-anchor="middle" dominant-baseline="central">${xml(f.label)}</text>`
-      );
-    }
-  }
-  const segs = wallSegments(plan);
-  for (const s of segs) {
-    const poly = segmentRectangle(s.a, s.b, s.thickness);
-    out.push(`<polygon points="${poly.map(pt).join(" ")}" fill="url(#poche)"/>`);
-  }
-  for (const s of segs) {
-    const d = unit(sub(s.b, s.a));
-    const n = normal(d);
-    const h = s.thickness / 2;
-    const fa1 = add(s.a, mul(n, h));
-    const fb1 = add(s.b, mul(n, h));
-    const fa2 = add(s.a, mul(n, -h));
-    const fb2 = add(s.b, mul(n, -h));
-    out.push(
-      `<line x1="${fmt(fa1.x)}" y1="${fmt(fa1.y)}" x2="${fmt(fb1.x)}" y2="${fmt(fb1.y)}" stroke="${THEME.wallStroke}" stroke-width="${fmt(wallStroke)}" stroke-linecap="square"/>`
-    );
-    out.push(
-      `<line x1="${fmt(fa2.x)}" y1="${fmt(fa2.y)}" x2="${fmt(fb2.x)}" y2="${fmt(fb2.y)}" stroke="${THEME.wallStroke}" stroke-width="${fmt(wallStroke)}" stroke-linecap="square"/>`
-    );
-  }
-  for (const dr of plan.doors) {
-    const seg = hostSegment(plan, dr.at, dr.wall);
-    if (!seg) continue;
-    const d = unit(sub(seg.b, seg.a));
-    const n = normal(d);
-    const h = seg.thickness / 2 + wallStroke;
-    const hw = dr.width / 2;
-    const cover = [
-      add(add(dr.at, mul(d, -hw)), mul(n, h)),
-      add(add(dr.at, mul(d, hw)), mul(n, h)),
-      add(add(dr.at, mul(d, hw)), mul(n, -h)),
-      add(add(dr.at, mul(d, -hw)), mul(n, -h))
-    ];
-    out.push(`<polygon points="${cover.map(pt).join(" ")}" fill="${THEME.opening}"/>`);
-    const hinge = dr.hinge === "left" ? add(dr.at, mul(d, -hw)) : add(dr.at, mul(d, hw));
-    const farJamb = dr.hinge === "left" ? add(dr.at, mul(d, hw)) : add(dr.at, mul(d, -hw));
-    const leafDir = dr.swing === "in" ? n : mul(n, -1);
-    const leafEnd = add(hinge, mul(leafDir, dr.width));
-    const cross = (leafEnd.x - hinge.x) * (farJamb.y - hinge.y) - (leafEnd.y - hinge.y) * (farJamb.x - hinge.x);
-    const sweep = cross < 0 ? 1 : 0;
-    out.push(
-      `<line x1="${fmt(hinge.x)}" y1="${fmt(hinge.y)}" x2="${fmt(leafEnd.x)}" y2="${fmt(leafEnd.y)}" stroke="${THEME.doorLeaf}" stroke-width="${fmt(thin * 1.3)}"/>`
-    );
-    out.push(
-      `<path d="M ${pt(leafEnd)} A ${fmt(dr.width)} ${fmt(dr.width)} 0 0 ${sweep} ${pt(farJamb)}" fill="none" stroke="${THEME.doorLeaf}" stroke-width="${fmt(thin)}" stroke-dasharray="${fmt(thin * 4)} ${fmt(thin * 3)}"/>`
-    );
-  }
-  for (const wn of plan.windows) {
-    const seg = hostSegment(plan, wn.at, wn.wall);
-    if (!seg) continue;
-    const d = unit(sub(seg.b, seg.a));
-    const n = normal(d);
-    const h = seg.thickness / 2;
-    const he = h + wallStroke;
-    const hw = wn.width / 2;
-    const cover = [
-      add(add(wn.at, mul(d, -hw)), mul(n, he)),
-      add(add(wn.at, mul(d, hw)), mul(n, he)),
-      add(add(wn.at, mul(d, hw)), mul(n, -he)),
-      add(add(wn.at, mul(d, -hw)), mul(n, -he))
-    ];
-    out.push(`<polygon points="${cover.map(pt).join(" ")}" fill="${THEME.opening}"/>`);
-    const jA = add(wn.at, mul(d, -hw));
-    const jB = add(wn.at, mul(d, hw));
-    for (const off of [h, -h]) {
-      const a = add(jA, mul(n, off));
-      const bb = add(jB, mul(n, off));
-      out.push(
-        `<line x1="${fmt(a.x)}" y1="${fmt(a.y)}" x2="${fmt(bb.x)}" y2="${fmt(bb.y)}" stroke="${THEME.wallStroke}" stroke-width="${fmt(thin)}"/>`
-      );
-    }
-    out.push(
-      `<line x1="${fmt(jA.x)}" y1="${fmt(jA.y)}" x2="${fmt(jB.x)}" y2="${fmt(jB.y)}" stroke="${THEME.windowPane}" stroke-width="${fmt(thin)}"/>`
-    );
-  }
-  for (const r of plan.rooms) {
-    const cx = r.at.x + r.size.w / 2;
-    const cy = r.at.y + r.size.h / 2;
-    const areaM2 = (r.size.w / 1e3 * (r.size.h / 1e3)).toFixed(1);
-    if (r.label) {
-      out.push(
-        `<text x="${fmt(cx)}" y="${fmt(cy - roomFont * 0.2)}" font-size="${fmt(roomFont)}" fill="${THEME.roomLabel}" text-anchor="middle" dominant-baseline="central" font-weight="600">${xml(r.label)}</text>`
-      );
-    }
-    out.push(
-      `<text x="${fmt(cx)}" y="${fmt(cy + (r.label ? roomFont * 0.9 : 0))}" font-size="${fmt(areaFont)}" fill="${THEME.areaLabel}" text-anchor="middle" dominant-baseline="central">${areaM2} m\xB2</text>`
-    );
-  }
-  for (const dm of plan.dims) {
-    const dir = unit(sub(dm.to, dm.from));
-    const n = normal(dir);
-    const off = mul(n, dm.offset);
-    const p1 = add(dm.from, off);
-    const p2 = add(dm.to, off);
-    const tick = refDim * 0.012;
-    out.push(
-      `<line x1="${fmt(dm.from.x)}" y1="${fmt(dm.from.y)}" x2="${fmt(p1.x)}" y2="${fmt(p1.y)}" stroke="${THEME.dim}" stroke-width="${fmt(thin * 0.7)}"/>`
-    );
-    out.push(
-      `<line x1="${fmt(dm.to.x)}" y1="${fmt(dm.to.y)}" x2="${fmt(p2.x)}" y2="${fmt(p2.y)}" stroke="${THEME.dim}" stroke-width="${fmt(thin * 0.7)}"/>`
-    );
-    out.push(
-      `<line x1="${fmt(p1.x)}" y1="${fmt(p1.y)}" x2="${fmt(p2.x)}" y2="${fmt(p2.y)}" stroke="${THEME.dim}" stroke-width="${fmt(thin)}"/>`
-    );
-    for (const p of [p1, p2]) {
-      const t1 = add(p, mul(unit({ x: dir.x + n.x, y: dir.y + n.y }), tick));
-      const t2 = add(p, mul(unit({ x: dir.x + n.x, y: dir.y + n.y }), -tick));
-      out.push(
-        `<line x1="${fmt(t1.x)}" y1="${fmt(t1.y)}" x2="${fmt(t2.x)}" y2="${fmt(t2.y)}" stroke="${THEME.dim}" stroke-width="${fmt(thin)}"/>`
-      );
-    }
-    const mid = { x: (p1.x + p2.x) / 2, y: (p1.y + p2.y) / 2 };
-    const tp = add(mid, mul(n, dimFont * 0.7));
-    let angle = Math.atan2(dir.y, dir.x) * 180 / Math.PI;
-    if (angle > 90) angle -= 180;
-    if (angle < -90) angle += 180;
-    const label = dm.text ?? String(Math.round(length(sub(dm.to, dm.from))));
-    out.push(
-      `<text x="${fmt(tp.x)}" y="${fmt(tp.y)}" font-size="${fmt(dimFont)}" fill="${THEME.dim}" text-anchor="middle" dominant-baseline="central" transform="rotate(${fmt(angle)} ${fmt(tp.x)} ${fmt(tp.y)})">${xml(label)}</text>`
-    );
+  const ctx = { fmt, pt, xml, theme: THEME, sizes, bounds: b };
+  const ops = ir.elements.flatMap((el) => {
+    const def = registry.get(el.kind);
+    return def ? def.render(el, ctx) : [];
+  });
+  for (const pass of RENDER_PASSES) {
+    for (const op of ops) if (op.pass === pass) out.push(op.svg);
   }
-  out.push(northArrow(plan, b, margin, refDim));
+  out.push(northArrow(ir, b, margin, refDim));
   out.push(scaleBar(b, margin, refDim, thin));
-  const tb = titleBlock(plan, b, margin, refDim, thin);
+  const tb = titleBlock(ir, b, margin, refDim, thin);
   if (tb) out.push(tb);
   out.push("</svg>");
   return out.join("\n");
 }
-function northArrow(plan, b, margin, refDim) {
+function northArrow(ir, b, margin, refDim) {
   const r = refDim * 0.045;
   const cx = b.maxX - r;
   const cy = b.minY - margin * 0.55;
   let deg;
-  switch (plan.north) {
+  switch (ir.north) {
     case "up":
       deg = 0;
       break;
@@ -960,7 +1163,7 @@ function northArrow(plan, b, margin, refDim) {
       deg = 90;
       break;
     default:
-      deg = typeof plan.north === "object" ? plan.north.deg : 0;
+      deg = typeof ir.north === "object" ? ir.north.deg : 0;
   }
   const fs = refDim * 0.026;
   const tri = `${fmt(cx)},${fmt(cy - r)} ${fmt(cx - r * 0.5)},${fmt(cy + r * 0.6)} ${fmt(cx)},${fmt(cy + r * 0.25)} ${fmt(cx + r * 0.5)},${fmt(cy + r * 0.6)}`;
@@ -991,9 +1194,9 @@ function scaleBar(b, margin, refDim, thin) {
   );
   return `<g>${parts.join("")}</g>`;
 }
-function titleBlock(plan, b, margin, refDim, thin) {
-  const t = plan.title;
-  if (!t && !plan.scale) return null;
+function titleBlock(ir, b, margin, refDim, thin) {
+  const t = ir.title;
+  if (!t && !ir.scale) return null;
   const boxW = refDim * 0.34;
   const boxH = margin * 0.82;
   const x0 = b.maxX - boxW;
@@ -1004,7 +1207,7 @@ function titleBlock(plan, b, margin, refDim, thin) {
   if (t?.project) lines.push({ k: "PROJECT", v: t.project });
   if (t?.drawnBy) lines.push({ k: "DRAWN BY", v: t.drawnBy });
   if (t?.date) lines.push({ k: "DATE", v: t.date });
-  if (plan.scale) lines.push({ k: "SCALE", v: plan.scale });
+  if (ir.scale) lines.push({ k: "SCALE", v: ir.scale });
   const parts = [];
   parts.push(
     `<rect x="${fmt(x0)}" y="${fmt(y0)}" width="${fmt(boxW)}" height="${fmt(boxH)}" fill="none" stroke="${THEME.annotation}" stroke-width="${fmt(thin)}"/>`
@@ -1106,11 +1309,12 @@ function toLegacy(source, d) {
 }
 function compileUncached(source, opts) {
   const { plan, diagnostics: parseDiags } = parse(source);
-  const diagnostics = plan ? [...parseDiags, ...validate(plan)] : [...parseDiags];
+  const resolved = plan ? resolve(plan) : null;
+  const diagnostics = resolved ? [...parseDiags, ...resolved.diagnostics] : [...parseDiags];
   const errs = diagnostics.filter((d) => d.severity === "error");
   const errors = errs.map((d) => toLegacy(source, d));
   const warnings = diagnostics.filter((d) => d.severity === "warning").map((d) => toLegacy(source, d));
-  const svg = plan && errs.length === 0 ? render(plan, opts) : "";
+  const svg = resolved && errs.length === 0 ? render(resolved.ir, opts) : "";
   return { svg, errors, warnings, diagnostics, ast: plan };
 }
 function clearCache() {
@@ -1123,4 +1327,4 @@ export {
   compile,
   clearCache
 };
-//# sourceMappingURL=chunk-ICYNEDSM.js.map
+//# sourceMappingURL=chunk-3YUQPQPZ.js.map