@chanmeng666/archlang 0.6.0 → 0.7.0

package/dist/{chunk-PABYLU6Z.js → chunk-CPK5CI5Y.js}

@@ -396,6 +396,13 @@ function distPointToSegment(p, a, b) {
   const cy = a.y + t * aby;
   return Math.hypot(p.x - cx, p.y - cy);
 }
+function minorArcDegrees(center, start, end) {
+  const deg = (p) => Math.atan2(-(p.y - center.y), p.x - center.x) * 180 / Math.PI;
+  const a1 = deg(start);
+  const a2 = deg(end);
+  const ccw = ((a2 - a1) % 360 + 360) % 360;
+  return ccw <= 180 ? [a1, a2] : [a2, a1];
+}
 function rectCorners(x, y, w, h) {
   return [
     { x, y },
@@ -547,33 +554,29 @@ var wall = {
     const w = resolved;
     return segmentsOfWall(w).flatMap((s) => segmentRectangle(s.a, s.b, s.thickness));
   },
+  /**
+   * Per-segment wall fill (poché) + two crisp face lines. This is the angled-wall
+   * path; orthogonal walls are unioned into clean loops in `scene-build.ts`. The
+   * fill always references the default poché pattern, matching v0.1.
+   */
   render(resolved, ctx) {
     const w = resolved;
-    const { fmt: fmt2, pt: pt2, theme, sizes } = ctx;
+    const { theme, sizes } = ctx;
     const segs = segmentsOfWall(w);
-    const ops = [];
+    const nodes = [];
     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)"/>` });
+      nodes.push({ layer: "wallFill", prim: { t: "polygon", pts: poly }, paint: { 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"/>`
-      });
+      const face = { stroke: theme.wallStroke, width: sizes.wallStroke, linecap: "square" };
+      nodes.push({ layer: "wallFace", prim: { t: "line", a: add(s.a, mul(n, h)), b: add(s.b, mul(n, h)) }, paint: face });
+      nodes.push({ layer: "wallFace", prim: { t: "line", a: add(s.a, mul(n, -h)), b: add(s.b, mul(n, -h)) }, paint: face });
     }
-    return ops;
+    return nodes;
   }
 };
 function describe2(ctx) {
@@ -618,24 +621,26 @@ var room = {
   },
   render(resolved, ctx) {
     const r = resolved;
-    const { fmt: fmt2, pt: pt2, xml: xml2, theme, sizes } = ctx;
-    const ops = [];
+    const { theme, sizes } = ctx;
+    const nodes = [];
     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}"/>` });
+    nodes.push({ layer: "floor", prim: { t: "polygon", pts: c }, paint: { 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>`
+      nodes.push({
+        layer: "labels",
+        prim: { t: "text", at: { x: cx, y: cy - sizes.roomFont * 0.2 }, value: r.label, size: sizes.roomFont, anchor: "middle", baseline: "central", weight: 600 },
+        paint: { fill: theme.roomLabel }
       });
     }
-    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>`
+    nodes.push({
+      layer: "labels",
+      prim: { t: "text", at: { x: cx, y: cy + (r.label ? sizes.roomFont * 0.9 : 0) }, value: `${areaM2} m\xB2`, size: sizes.areaFont, anchor: "middle", baseline: "central" },
+      paint: { fill: theme.areaLabel }
     });
-    return ops;
+    return nodes;
   }
 };
 
@@ -685,11 +690,17 @@ var door = {
     return { kind: "door", id, at, width, hinge: n.hinge, swing: n.swing, host: ctx.hostSegment(at, n.wall), span: n.span };
   },
   bounds: () => [],
+  /**
+   * Opening cover + leaf line + swing arc. The swing geometry (hinge, leaf,
+   * far jamb, minor-arc orientation) is computed **here, once** — every backend
+   * (SVG, DXF, PDF) now serializes the same `arc` primitive rather than
+   * re-deriving it.
+   */
   render(resolved, ctx) {
     const dr = resolved;
     const seg = dr.host;
     if (!seg) return [];
-    const { fmt: fmt2, pt: pt2, theme, sizes } = ctx;
+    const { theme, sizes } = ctx;
     const d = unit(sub(seg.b, seg.a));
     const n = normal(d);
     const h = seg.thickness / 2 + sizes.wallStroke;
@@ -700,23 +711,25 @@ var door = {
       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 nodes = [];
+    nodes.push({ layer: "doors", prim: { t: "polygon", pts: cover }, paint: { 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)}"/>`
+    nodes.push({
+      layer: "doors",
+      prim: { t: "line", a: hinge, b: leafEnd },
+      paint: { stroke: theme.doorLeaf, width: 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)}"/>`
+    nodes.push({
+      layer: "doors",
+      prim: { t: "arc", center: hinge, r: dr.width, start: leafEnd, end: farJamb, sweep },
+      paint: { fill: "none", stroke: theme.doorLeaf, width: sizes.thin, dash: [sizes.thin * 4, sizes.thin * 3] }
     });
-    return ops;
+    return nodes;
   }
 };
 
@@ -758,7 +771,7 @@ var windowEl = {
     const wn = resolved;
     const seg = wn.host;
     if (!seg) return [];
-    const { fmt: fmt2, pt: pt2, theme, sizes } = ctx;
+    const { theme, sizes } = ctx;
     const d = unit(sub(seg.b, seg.a));
     const n = normal(d);
     const h = seg.thickness / 2;
@@ -770,23 +783,23 @@ var windowEl = {
       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 nodes = [];
+    nodes.push({ layer: "windows", prim: { t: "polygon", pts: cover }, paint: { 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)}"/>`
+      nodes.push({
+        layer: "windows",
+        prim: { t: "line", a: add(jA, mul(n, off)), b: add(jB, mul(n, off)) },
+        paint: { stroke: theme.wallStroke, width: 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)}"/>`
+    nodes.push({
+      layer: "windows",
+      prim: { t: "line", a: jA, b: jB },
+      paint: { stroke: theme.windowPane, width: sizes.thin }
     });
-    return ops;
+    return nodes;
   }
 };
 
@@ -826,22 +839,24 @@ var furniture = {
   },
   render(resolved, ctx) {
     const f = resolved;
-    const { fmt: fmt2, pt: pt2, xml: xml2, theme, sizes } = ctx;
-    const ops = [];
+    const { theme, sizes } = ctx;
+    const nodes = [];
     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)}"/>`
+    nodes.push({
+      layer: "furniture",
+      prim: { t: "polygon", pts: c },
+      paint: { fill: theme.furnitureFill, stroke: theme.furnitureStroke, width: 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>`
+      nodes.push({
+        layer: "furniture",
+        prim: { t: "text", at: { x: cx, y: cy }, value: f.label, size: sizes.furnFont, anchor: "middle", baseline: "central" },
+        paint: { fill: theme.furnitureLabel }
       });
     }
-    return ops;
+    return nodes;
   }
 };
 
@@ -884,33 +899,22 @@ var dim = {
   },
   render(resolved, ctx) {
     const dm = resolved;
-    const { fmt: fmt2, xml: xml2, theme, sizes } = ctx;
+    const { 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)}"/>`
-    });
+    const thinPaint = { stroke: theme.dim, width: sizes.thin };
+    const nodes = [];
+    nodes.push({ layer: "dims", prim: { t: "line", a: dm.from, b: p1 }, paint: { stroke: theme.dim, width: sizes.thin * 0.7 } });
+    nodes.push({ layer: "dims", prim: { t: "line", a: dm.to, b: p2 }, paint: { stroke: theme.dim, width: sizes.thin * 0.7 } });
+    nodes.push({ layer: "dims", prim: { t: "line", a: p1, b: p2 }, paint: thinPaint });
     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)}"/>`
-      });
+      nodes.push({ layer: "dims", prim: { t: "line", a: t1, b: t2 }, paint: thinPaint });
     }
     const mid = { x: (p1.x + p2.x) / 2, y: (p1.y + p2.y) / 2 };
     const tp = add(mid, mul(n, sizes.dimFont * 0.7));
@@ -918,11 +922,12 @@ var dim = {
     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>`
+    nodes.push({
+      layer: "dims",
+      prim: { t: "text", at: tp, value: label, size: sizes.dimFont, anchor: "middle", baseline: "central", rotate: angle },
+      paint: { fill: theme.dim }
     });
-    return ops;
+    return nodes;
   }
 };
 
@@ -956,12 +961,13 @@ var column = {
   },
   render(resolved, ctx) {
     const c = resolved;
-    const { fmt: fmt2, pt: pt2, theme, sizes } = ctx;
+    const { 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)}"/>`
+        layer: "furniture",
+        prim: { t: "polygon", pts },
+        paint: { fill: theme.column, stroke: theme.wallStroke, width: sizes.thin }
       }
     ];
   }
@@ -1502,19 +1508,6 @@ function resolve(ast) {
   return { ir, diagnostics };
 }
 
-// src/registry.ts
-var RENDER_PASSES = [
-  "floor",
-  "furniture",
-  "wallFill",
-  "wallFace",
-  "doors",
-  "windows",
-  "labels",
-  "dims",
-  "annotations"
-];
-
 // src/geometry/union.ts
 function uniqSorted(values) {
   const out = [...new Set(values)].sort((a, b) => a - b);
@@ -1612,21 +1605,7 @@ function mergeCollinear(loop) {
   return out.length >= 3 ? out : loop;
 }
 
-// src/render.ts
-function fmt(v) {
-  const r = Math.round(v * 100) / 100;
-  return Object.is(r, -0) ? "0" : String(r);
-}
-var pt = (p) => `${fmt(p.x)},${fmt(p.y)}`;
-function xml(s) {
-  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
-}
-var NICE_LENGTHS = [500, 1e3, 2e3, 5e3, 1e4, 2e4, 5e4, 1e5];
-function niceBarLength(target) {
-  let best = NICE_LENGTHS[0];
-  for (const v of NICE_LENGTHS) if (v <= target) best = v;
-  return best;
-}
+// src/scene-build.ts
 function planBounds(ir) {
   const b = emptyBounds();
   for (const el of ir.elements) {
@@ -1642,20 +1621,17 @@ function planBounds(ir) {
 function allOrthogonal(walls) {
   return walls.every((w) => segmentsOfWall(w).every((s) => s.a.x === s.b.x || s.a.y === s.b.y));
 }
-function loopsToPath(loops) {
-  return loops.map((loop) => "M " + loop.map(pt).join(" L ") + " Z").join(" ");
-}
 function materialsUsed(walls) {
   return [...new Set(walls.map((w) => w.material))].sort();
 }
-function renderWalls(walls, ctx) {
+function lowerWalls(walls, ctx) {
   if (walls.length === 0) return [];
-  const ops = [];
+  const nodes = [];
   for (const mat of materialsUsed(walls)) {
     const group = walls.filter((w) => w.material === mat);
     if (!allOrthogonal(group)) {
       const def = registry.get("wall");
-      ops.push(...group.flatMap((w) => def.render(w, ctx)));
+      nodes.push(...group.flatMap((w) => def.render(w, ctx)));
       continue;
     }
     const rects = [];
@@ -1669,18 +1645,18 @@ function renderWalls(walls, ctx) {
     }
     const loops = rectUnionOutline(rects);
     if (loops.length === 0) continue;
-    const d = loopsToPath(loops);
-    ops.push({ pass: "wallFill", svg: `<path d="${d}" fill="url(#${patternId(mat)})" fill-rule="nonzero"/>` });
-    ops.push({
-      pass: "wallFace",
-      svg: `<path d="${d}" fill="none" stroke="${ctx.theme.wallStroke}" stroke-width="${ctx.fmt(ctx.sizes.wallStroke)}" stroke-linejoin="miter"/>`
+    nodes.push({ layer: "wallFill", prim: { t: "region", loops }, paint: { fill: `url(#${patternId(mat)})`, fillRule: "nonzero" } });
+    nodes.push({
+      layer: "wallFace",
+      prim: { t: "region", loops },
+      paint: { fill: "none", stroke: ctx.theme.wallStroke, width: ctx.sizes.wallStroke, linejoin: "miter" }
     });
   }
-  return ops;
+  return nodes;
 }
-function render(ir, opts = {}) {
-  const THEME = sanitizeTheme(mergeTheme(DEFAULT_THEME, ir.theme, opts.theme));
-  const lw = THEME.lineWeight;
+function toScene(ir, opts = {}) {
+  const theme = sanitizeTheme(mergeTheme(DEFAULT_THEME, ir.theme, opts.theme));
+  const lw = theme.lineWeight;
   const b = planBounds(ir);
   const drawW = b.maxX - b.minX;
   const drawH = b.maxY - b.minY;
@@ -1696,7 +1672,100 @@ function render(ir, opts = {}) {
     margin: refDim * 0.17,
     hatchGap: refDim * 0.013
   };
+  const ctx = { theme, sizes, bounds: b };
+  const nodes = [];
+  for (const el of ir.elements) {
+    if (el.kind === "wall") continue;
+    const def = registry.get(el.kind);
+    if (def) nodes.push(...def.render(el, ctx));
+  }
+  nodes.push(...lowerWalls(ir.walls, ctx));
+  return {
+    width: drawW + sizes.margin * 2,
+    height: drawH + sizes.margin * 2,
+    bounds: b,
+    nodes,
+    theme,
+    sizes,
+    north: ir.north,
+    scale: ir.scale,
+    title: ir.title,
+    name: ir.name,
+    materials: materialsUsed(ir.walls)
+  };
+}
+
+// src/scene.ts
+var RENDER_PASSES = [
+  "floor",
+  "furniture",
+  "wallFill",
+  "wallFace",
+  "doors",
+  "windows",
+  "labels",
+  "dims",
+  "annotations"
+];
+
+// src/backends/svg.ts
+function fmt(v) {
+  const r = Math.round(v * 100) / 100;
+  return Object.is(r, -0) ? "0" : String(r);
+}
+var pt = (p) => `${fmt(p.x)},${fmt(p.y)}`;
+function xml(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+var NICE_LENGTHS = [500, 1e3, 2e3, 5e3, 1e4, 2e4, 5e4, 1e5];
+function niceBarLength(target) {
+  let best = NICE_LENGTHS[0];
+  for (const v of NICE_LENGTHS) if (v <= target) best = v;
+  return best;
+}
+function strokeAttrs(paint) {
+  if (!paint.stroke) return "";
+  let s = ` stroke="${paint.stroke}" stroke-width="${fmt(paint.width ?? 0)}"`;
+  if (paint.linecap) s += ` stroke-linecap="${paint.linecap}"`;
+  return s;
+}
+function pathPaint(paint) {
+  let s = ` fill="${paint.fill ?? "none"}"`;
+  if (paint.fillRule) s += ` fill-rule="${paint.fillRule}"`;
+  if (paint.stroke) s += ` stroke="${paint.stroke}" stroke-width="${fmt(paint.width ?? 0)}"`;
+  if (paint.linejoin) s += ` stroke-linejoin="${paint.linejoin}"`;
+  if (paint.dash) s += ` stroke-dasharray="${fmt(paint.dash[0])} ${fmt(paint.dash[1])}"`;
+  return s;
+}
+function regionPath(loops) {
+  return loops.map((loop) => "M " + loop.map(pt).join(" L ") + " Z").join(" ");
+}
+function serialize(node) {
+  const { prim, paint } = node;
+  switch (prim.t) {
+    case "polygon":
+      return `<polygon points="${prim.pts.map(pt).join(" ")}" fill="${paint.fill ?? "none"}"${strokeAttrs(paint)}/>`;
+    case "line":
+      return `<line x1="${fmt(prim.a.x)}" y1="${fmt(prim.a.y)}" x2="${fmt(prim.b.x)}" y2="${fmt(prim.b.y)}" stroke="${paint.stroke ?? "none"}" stroke-width="${fmt(paint.width ?? 0)}"${paint.linecap ? ` stroke-linecap="${paint.linecap}"` : ""}/>`;
+    case "region":
+      return `<path d="${regionPath(prim.loops)}"${pathPaint(paint)}/>`;
+    case "arc":
+      return `<path d="M ${pt(prim.start)} A ${fmt(prim.r)} ${fmt(prim.r)} 0 0 ${prim.sweep} ${pt(prim.end)}"${pathPaint(paint)}/>`;
+    case "text": {
+      const weight = prim.weight !== void 0 ? ` font-weight="${prim.weight}"` : "";
+      const transform = prim.rotate !== void 0 ? ` transform="rotate(${fmt(prim.rotate)} ${fmt(prim.at.x)} ${fmt(prim.at.y)})"` : "";
+      return `<text x="${fmt(prim.at.x)}" y="${fmt(prim.at.y)}" font-size="${fmt(prim.size)}" fill="${paint.fill ?? "none"}" text-anchor="${prim.anchor}" dominant-baseline="${prim.baseline}"${weight}${transform}>${xml(prim.value)}</text>`;
+    }
+  }
+}
+function renderSvg(scene, opts = {}) {
+  const THEME = scene.theme;
+  const sizes = scene.sizes;
+  const b = scene.bounds;
+  const refDim = sizes.refDim;
   const { thin, margin, hatchGap } = sizes;
+  const drawW = b.maxX - b.minX;
+  const drawH = b.maxY - b.minY;
   const vbX = b.minX - margin;
   const vbY = b.minY - margin;
   const vbW = drawW + margin * 2;
@@ -1707,32 +1776,25 @@ function render(ir, opts = {}) {
     `<svg xmlns="http://www.w3.org/2000/svg" ${svgAttrs} viewBox="${fmt(vbX)} ${fmt(vbY)} ${fmt(vbW)} ${fmt(vbH)}" font-family="${THEME.font}">`
   );
   const hatchCtx = { fmt, gap: hatchGap, thin, base: THEME.pocheBase, line: THEME.pocheHatch };
-  const patterns = materialsUsed(ir.walls).map((m) => hatchPattern(m, hatchCtx)).join("");
+  const patterns = scene.materials.map((m) => hatchPattern(m, hatchCtx)).join("");
   out.push(`<defs>${patterns}</defs>`);
   out.push(`<rect x="${fmt(vbX)}" y="${fmt(vbY)}" width="${fmt(vbW)}" height="${fmt(vbH)}" fill="${THEME.bg}"/>`);
-  const ctx = { fmt, pt, xml, theme: THEME, sizes, bounds: b };
-  const ops = ir.elements.flatMap((el) => {
-    if (el.kind === "wall") return [];
-    const def = registry.get(el.kind);
-    return def ? def.render(el, ctx) : [];
-  });
-  ops.push(...renderWalls(ir.walls, ctx));
   for (const pass of RENDER_PASSES) {
-    for (const op of ops) if (op.pass === pass) out.push(op.svg);
+    for (const node of scene.nodes) if (node.layer === pass) out.push(serialize(node));
   }
-  out.push(northArrow(ir, b, margin, refDim, THEME));
+  out.push(northArrow(scene.north, b, margin, refDim, THEME));
   out.push(scaleBar(b, margin, refDim, thin, THEME));
-  const tb = titleBlock(ir, b, margin, refDim, thin, THEME);
+  const tb = titleBlock(scene.title, scene.scale, b, margin, refDim, thin, THEME);
   if (tb) out.push(tb);
   out.push("</svg>");
   return out.join("\n");
 }
-function northArrow(ir, b, margin, refDim, THEME) {
+function northArrow(north, b, margin, refDim, THEME) {
   const r = refDim * 0.045;
   const cx = b.maxX - r;
   const cy = b.minY - margin * 0.55;
   let deg;
-  switch (ir.north) {
+  switch (north) {
     case "up":
       deg = 0;
       break;
@@ -1746,7 +1808,7 @@ function northArrow(ir, b, margin, refDim, THEME) {
       deg = 90;
       break;
     default:
-      deg = typeof ir.north === "object" ? ir.north.deg : 0;
+      deg = typeof north === "object" ? 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)}`;
@@ -1777,9 +1839,8 @@ function scaleBar(b, margin, refDim, thin, THEME) {
   );
   return `<g>${parts.join("")}</g>`;
 }
-function titleBlock(ir, b, margin, refDim, thin, THEME) {
-  const t = ir.title;
-  if (!t && !ir.scale) return null;
+function titleBlock(t, scale, b, margin, refDim, thin, THEME) {
+  if (!t && !scale) return null;
   const boxW = refDim * 0.34;
   const boxH = margin * 0.82;
   const x0 = b.maxX - boxW;
@@ -1790,7 +1851,7 @@ function titleBlock(ir, b, margin, refDim, thin, THEME) {
   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 (ir.scale) lines.push({ k: "SCALE", v: ir.scale });
+  if (scale) lines.push({ k: "SCALE", v: 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)}"/>`
@@ -1902,9 +1963,10 @@ var DxfBuilder = class {
     this.pair(40, num(height));
     this.pair(1, value.replace(/\n/g, " "));
   }
-  rect(layer, corners) {
-    for (let i = 0; i < corners.length; i++) {
-      this.line(layer, corners[i], corners[(i + 1) % corners.length]);
+  /** Closed loop of points as a chain of LINEs (R12-safe; no LWPOLYLINE). */
+  loop(layer, pts) {
+    for (let i = 0; i < pts.length; i++) {
+      this.line(layer, pts[i], pts[(i + 1) % pts.length]);
     }
   }
   toString() {
@@ -1912,6 +1974,27 @@ var DxfBuilder = class {
   }
 };
 var LAYERS = ["WALLS", "ROOMS", "DOORS", "WINDOWS", "FURNITURE", "COLUMNS", "DIMS", "LABELS"];
+function dxfLayer(layer) {
+  switch (layer) {
+    case "wallFill":
+    case "wallFace":
+      return "WALLS";
+    case "floor":
+      return "ROOMS";
+    case "doors":
+      return "DOORS";
+    case "windows":
+      return "WINDOWS";
+    case "furniture":
+      return "FURNITURE";
+    case "labels":
+      return "LABELS";
+    case "dims":
+      return "DIMS";
+    default:
+      return "0";
+  }
+}
 function header() {
   const h = [];
   const p = (c, v) => h.push(String(c), String(v));
@@ -1936,124 +2019,215 @@ function header() {
   p(0, "ENDSEC");
   return h.join("\n") + "\n";
 }
-function emitDoor(b, dr) {
-  const seg = dr.host;
-  if (!seg) return;
-  const d = unit(sub(seg.b, seg.a));
-  const n = normal(d);
-  const hw = dr.width / 2;
-  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));
-  b.line("DOORS", hinge, leafEnd);
-  const deg = (p) => Math.atan2(-(p.y - hinge.y), p.x - hinge.x) * 180 / Math.PI;
-  const a1 = deg(leafEnd);
-  const a2 = deg(farJamb);
-  const ccw = ((a2 - a1) % 360 + 360) % 360;
-  if (ccw <= 180) b.arc("DOORS", hinge, dr.width, a1, a2);
-  else b.arc("DOORS", hinge, dr.width, a2, a1);
-}
-function emitWindow(b, wn) {
-  const seg = wn.host;
-  if (!seg) return;
-  const d = unit(sub(seg.b, seg.a));
-  const n = normal(d);
-  const hw = wn.width / 2;
-  const h = seg.thickness / 2;
-  const jA = add(wn.at, mul(d, -hw));
-  const jB = add(wn.at, mul(d, hw));
-  b.line("WINDOWS", add(jA, mul(n, h)), add(jB, mul(n, h)));
-  b.line("WINDOWS", add(jA, mul(n, -h)), add(jB, mul(n, -h)));
-  b.line("WINDOWS", jA, jB);
-}
-function emitDim(b, dm) {
-  const dd = unit(sub(dm.to, dm.from));
-  const dn = normal(dd);
-  const p1 = add(dm.from, mul(dn, dm.offset));
-  const p2 = add(dm.to, mul(dn, dm.offset));
-  b.line("DIMS", p1, p2);
-  if (dm.text) {
-    const mid = { x: (p1.x + p2.x) / 2, y: (p1.y + p2.y) / 2 };
-    b.text("DIMS", mid, 150, dm.text);
+function emit(b, node) {
+  const layer = dxfLayer(node.layer);
+  const prim = node.prim;
+  switch (prim.t) {
+    case "polygon":
+      b.loop(layer, prim.pts);
+      break;
+    case "line":
+      b.line(layer, prim.a, prim.b);
+      break;
+    case "region":
+      for (const lp of prim.loops) b.loop(layer, lp);
+      break;
+    case "arc": {
+      const [a0, a1] = minorArcDegrees(prim.center, prim.start, prim.end);
+      b.arc(layer, prim.center, prim.r, a0, a1);
+      break;
+    }
+    case "text":
+      b.text(layer, prim.at, prim.size, prim.value);
+      break;
   }
 }
-function toDxf(ir) {
+function toDxf(scene) {
   const b = new DxfBuilder();
   b.pair(0, "SECTION");
   b.pair(2, "ENTITIES");
-  const labelAt = (at, w, h) => ({ x: at.x + w / 2, y: at.y + h / 2 });
-  for (const el of ir.elements) {
-    switch (el.kind) {
-      case "wall":
-        for (const s of segmentsOfWall(el)) {
-          const d = unit(sub(s.b, s.a));
-          const n = normal(d);
-          const off = s.thickness / 2;
-          b.line("WALLS", add(s.a, mul(n, off)), add(s.b, mul(n, off)));
-          b.line("WALLS", add(s.a, mul(n, -off)), add(s.b, mul(n, -off)));
-        }
-        break;
-      case "room":
-        b.rect("ROOMS", rectCorners(el.at.x, el.at.y, el.size.w, el.size.h));
-        if (el.label) b.text("LABELS", labelAt(el.at, el.size.w, el.size.h), 200, el.label);
-        break;
-      case "furniture":
-        b.rect("FURNITURE", rectCorners(el.at.x, el.at.y, el.size.w, el.size.h));
-        if (el.label) b.text("LABELS", labelAt(el.at, el.size.w, el.size.h), 150, el.label);
-        break;
-      case "column":
-        b.rect("COLUMNS", rectCorners(el.at.x, el.at.y, el.size.w, el.size.h));
-        break;
-      case "door":
-        emitDoor(b, el);
-        break;
-      case "window":
-        emitWindow(b, el);
-        break;
-      case "dim":
-        emitDim(b, el);
-        break;
-    }
-  }
+  for (const node of scene.nodes) emit(b, node);
   b.pair(0, "ENDSEC");
-  const entities = b.toString();
-  return header() + entities + "0\nEOF\n";
+  return header() + b.toString() + "0\nEOF\n";
 }
 
 // src/export/pdf.ts
-function svgSize(svg) {
-  const w = /<svg[^>]*\bwidth="([\d.]+)/.exec(svg);
-  const h = /<svg[^>]*\bheight="([\d.]+)/.exec(svg);
-  if (w && h) return { width: parseFloat(w[1]), height: parseFloat(h[1]) };
-  const vb = /<svg[^>]*\bviewBox="[\d.\-]+ [\d.\-]+ ([\d.]+) ([\d.]+)"/.exec(svg);
-  if (vb) return { width: parseFloat(vb[1]), height: parseFloat(vb[2]) };
-  return { width: 800, height: 600 };
-}
-async function toPdf(svg) {
+function fillColor(paint, theme) {
+  const f = paint.fill;
+  if (!f || f === "none") return null;
+  if (f.startsWith("url(")) return theme.pocheBase;
+  return f;
+}
+function regionPath2(loops) {
+  return loops.map((loop) => "M " + loop.map((p) => `${p.x} ${p.y}`).join(" L ") + " Z").join(" ");
+}
+function applyPaint(doc, paint, theme) {
+  const fill = fillColor(paint, theme);
+  const stroke = paint.stroke && paint.stroke !== "none" ? paint.stroke : null;
+  if (paint.width !== void 0) doc.lineWidth(paint.width);
+  doc.lineJoin(paint.linejoin ?? "miter");
+  doc.lineCap(paint.linecap === "square" ? "square" : "butt");
+  if (paint.dash) doc.dash(paint.dash[0], { space: paint.dash[1] });
+  else doc.undash();
+  if (fill && stroke) doc.fillAndStroke(fill, stroke);
+  else if (fill) doc.fill(fill);
+  else if (stroke) doc.stroke(stroke);
+  else doc.stroke();
+}
+function drawText(doc, at, value, size, anchor, rotate, color) {
+  doc.undash();
+  doc.fontSize(size).fillColor(color);
+  const w = doc.widthOfString(value);
+  let x = at.x;
+  if (anchor === "middle") x -= w / 2;
+  else if (anchor === "end") x -= w;
+  const y = at.y - size * 0.5;
+  if (rotate !== void 0) {
+    doc.save();
+    doc.rotate(rotate, { origin: [at.x, at.y] });
+    doc.text(value, x, y, { lineBreak: false });
+    doc.restore();
+  } else {
+    doc.text(value, x, y, { lineBreak: false });
+  }
+}
+function drawNode(doc, node, theme) {
+  const { prim, paint } = node;
+  switch (prim.t) {
+    case "polygon":
+      doc.polygon(...prim.pts.map((p) => [p.x, p.y]));
+      applyPaint(doc, paint, theme);
+      break;
+    case "line":
+      doc.moveTo(prim.a.x, prim.a.y).lineTo(prim.b.x, prim.b.y);
+      applyPaint(doc, paint, theme);
+      break;
+    case "region":
+      doc.path(regionPath2(prim.loops));
+      applyPaint(doc, paint, theme);
+      break;
+    case "arc":
+      doc.path(`M ${prim.start.x} ${prim.start.y} A ${prim.r} ${prim.r} 0 0 ${prim.sweep} ${prim.end.x} ${prim.end.y}`);
+      applyPaint(doc, paint, theme);
+      break;
+    case "text":
+      drawText(doc, prim.at, prim.value, prim.size, prim.anchor, prim.rotate, fillColor(paint, theme) ?? "#000000");
+      break;
+  }
+}
+async function toPdf(scene) {
   let PDFDocument;
-  let SVGtoPDF;
   try {
     PDFDocument = (await import("pdfkit")).default;
-    SVGtoPDF = (await import("svg-to-pdfkit")).default;
   } catch {
     throw new Error(
-      "PDF export needs the optional dependencies 'pdfkit' and 'svg-to-pdfkit'. Install them: npm install pdfkit svg-to-pdfkit"
+      "PDF export needs the optional dependency 'pdfkit'. Install it: npm install pdfkit"
     );
   }
-  const { width, height } = svgSize(svg);
-  const doc = new PDFDocument({ size: [width, height], margin: 0 });
+  const { theme, sizes, bounds: b } = scene;
+  const margin = sizes.margin;
+  const vbX = b.minX - margin;
+  const vbY = b.minY - margin;
+  const W = scene.width;
+  const H = scene.height;
+  const doc = new PDFDocument({ size: [W, H], margin: 0 });
   const chunks = [];
   const done = new Promise((resolve2, reject) => {
     doc.on("data", (c) => chunks.push(c));
     doc.on("end", () => resolve2());
     doc.on("error", (e) => reject(e));
   });
-  SVGtoPDF(doc, svg, 0, 0, { width, height, assumePt: true });
+  doc.save();
+  doc.translate(-vbX, -vbY);
+  doc.rect(vbX, vbY, W, H).fill(theme.bg);
+  for (const pass of RENDER_PASSES) {
+    for (const node of scene.nodes) if (node.layer === pass) drawNode(doc, node, theme);
+  }
+  drawChrome(doc, scene);
+  doc.restore();
   doc.end();
   await done;
   return concat(chunks);
 }
+function drawChrome(doc, scene) {
+  const { theme, sizes, bounds: b } = scene;
+  const refDim = sizes.refDim;
+  const margin = sizes.margin;
+  const thin = sizes.thin;
+  {
+    const r = refDim * 0.045;
+    const cx = b.maxX - r;
+    const cy = b.minY - margin * 0.55;
+    const deg = northDegrees(scene.north);
+    const fs = refDim * 0.026;
+    doc.save();
+    doc.rotate(deg, { origin: [cx, cy] });
+    doc.polygon([cx, cy - r], [cx - r * 0.5, cy + r * 0.6], [cx, cy + r * 0.25], [cx + r * 0.5, cy + r * 0.6]).fill(theme.annotation);
+    doc.restore();
+    const rad = deg * Math.PI / 180;
+    const lx = cx + Math.sin(rad) * (r + fs * 0.8);
+    const ly = cy - Math.cos(rad) * (r + fs * 0.8);
+    drawText(doc, { x: lx, y: ly }, "N", fs, "middle", void 0, theme.annotation);
+  }
+  {
+    const barLen = niceBarLength2(refDim * 0.3);
+    const x0 = b.minX;
+    const y0 = b.maxY + margin * 0.55;
+    const hgt = refDim * 0.014;
+    const fs = refDim * 0.02;
+    const half = barLen / 2;
+    doc.rect(x0, y0, half, hgt).fill(theme.annotation);
+    doc.lineWidth(thin).undash();
+    doc.rect(x0 + half, y0, half, hgt).stroke(theme.annotation);
+    drawText(doc, { x: x0, y: y0 + hgt + fs }, "0", fs, "start", void 0, theme.annotation);
+    drawText(doc, { x: x0 + barLen, y: y0 + hgt + fs }, `${barLen / 1e3} m`, fs, "middle", void 0, theme.annotation);
+  }
+  const t = scene.title;
+  if (t || scene.scale) {
+    const boxW = refDim * 0.34;
+    const boxH = margin * 0.82;
+    const x0 = b.maxX - boxW;
+    const y0 = b.maxY + margin * 0.15;
+    const fs = refDim * 0.019;
+    const pad = boxW * 0.05;
+    const lines = [];
+    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 (scene.scale) lines.push({ k: "SCALE", v: scene.scale });
+    doc.lineWidth(thin).undash();
+    doc.rect(x0, y0, boxW, boxH).stroke(theme.annotation);
+    const rowH = boxH / Math.max(lines.length, 1);
+    lines.forEach((ln, i) => {
+      const ly = y0 + rowH * (i + 0.5);
+      drawText(doc, { x: x0 + pad, y: ly }, ln.k, fs * 0.8, "start", void 0, theme.annotationMuted);
+      drawText(doc, { x: x0 + boxW - pad, y: ly }, ln.v, fs, "end", void 0, theme.annotation);
+      if (i > 0) {
+        doc.lineWidth(thin * 0.5).moveTo(x0, y0 + rowH * i).lineTo(x0 + boxW, y0 + rowH * i).stroke(theme.annotation);
+      }
+    });
+  }
+}
+function northDegrees(north) {
+  switch (north) {
+    case "up":
+      return 0;
+    case "down":
+      return 180;
+    case "left":
+      return 270;
+    case "right":
+      return 90;
+    default:
+      return typeof north === "object" ? north.deg : 0;
+  }
+}
+var NICE_LENGTHS2 = [500, 1e3, 2e3, 5e3, 1e4, 2e4, 5e4, 1e5];
+function niceBarLength2(target) {
+  let best = NICE_LENGTHS2[0];
+  for (const v of NICE_LENGTHS2) if (v <= target) best = v;
+  return best;
+}
 function concat(chunks) {
   let total = 0;
   for (const c of chunks) total += c.length;
@@ -2097,8 +2271,13 @@ function compileUncached(source, opts) {
   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 = resolved && errs.length === 0 ? render(resolved.ir, opts) : "";
-  return { svg, errors, warnings, diagnostics, ast: plan };
+  let svg = "";
+  let scene;
+  if (resolved && errs.length === 0) {
+    scene = toScene(resolved.ir, opts);
+    svg = renderSvg(scene, opts);
+  }
+  return { svg, errors, warnings, diagnostics, ast: plan, scene };
 }
 function clearCache() {
   cache.clear();
@@ -2106,6 +2285,7 @@ function clearCache() {
 
 export {
   resolve,
+  toScene,
   offsetToLineCol,
   formatDiagnostic,
   toDxf,
@@ -2113,4 +2293,4 @@ export {
   compile,
   clearCache
 };
-//# sourceMappingURL=chunk-PABYLU6Z.js.map
+//# sourceMappingURL=chunk-CPK5CI5Y.js.map