@chanmeng666/archlang 0.3.0 → 0.5.0

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

@@ -100,19 +100,42 @@ function lex(src) {
       push("arrow", "->", startLine, startCol, startIdx);
       continue;
     }
-    if (isDigit(c) || c === "-" && isDigit(peek(1)) || c === "." && isDigit(peek(1))) {
+    if (c === "+") {
+      advance();
+      push("plus", "+", startLine, startCol, startIdx);
+      continue;
+    }
+    if (c === "-") {
+      advance();
+      push("minus", "-", startLine, startCol, startIdx);
+      continue;
+    }
+    if (c === "*") {
+      advance();
+      push("star", "*", startLine, startCol, startIdx);
+      continue;
+    }
+    if (c === "/") {
+      advance();
+      push("slash", "/", startLine, startCol, startIdx);
+      continue;
+    }
+    if (c === "%") {
+      advance();
+      push("percent", "%", startLine, startCol, startIdx);
+      continue;
+    }
+    if (isDigit(c) || c === "." && isDigit(peek(1))) {
       let raw = "";
-      if (c === "-") raw += advance();
       while (isDigit(peek())) raw += advance();
       if (peek() === ".") {
         raw += advance();
         while (isDigit(peek())) raw += advance();
       }
       const first = parseFloat(raw);
-      if (peek() === "x" && (isDigit(peek(1)) || peek(1) === "-" && isDigit(peek(2)) || peek(1) === "." && isDigit(peek(2)))) {
+      if (peek() === "x" && (isDigit(peek(1)) || peek(1) === "." && isDigit(peek(2)))) {
         advance();
         let raw2 = "";
-        if (peek() === "-") raw2 += advance();
         while (isDigit(peek())) raw2 += advance();
         if (peek() === ".") {
           raw2 += advance();
@@ -138,6 +161,198 @@ function lex(src) {
   return { tokens, errors };
 }
 
+// src/expr.ts
+var BIN_PREC = {
+  plus: 1,
+  minus: 1,
+  star: 2,
+  slash: 2,
+  percent: 2
+};
+var BIN_OP = {
+  plus: "+",
+  minus: "-",
+  star: "*",
+  slash: "/",
+  percent: "%"
+};
+function parseExpr(ts) {
+  return parseBin(ts, 1);
+}
+function parseBin(ts, minPrec) {
+  let left = parseUnary(ts);
+  for (; ; ) {
+    const t = ts.peek();
+    const prec = BIN_PREC[t.type];
+    if (prec === void 0 || prec < minPrec) break;
+    ts.next();
+    const right = parseBin(ts, prec + 1);
+    left = { t: "bin", op: BIN_OP[t.type], l: left, r: right };
+  }
+  return left;
+}
+function parseUnary(ts) {
+  const t = ts.peek();
+  if (t.type === "minus" || t.type === "plus") {
+    ts.next();
+    return { t: "unary", op: t.type === "minus" ? "-" : "+", e: parseUnary(ts) };
+  }
+  return parseAtom(ts);
+}
+function parseAtom(ts) {
+  const t = ts.peek();
+  if (t.type === "number") {
+    ts.next();
+    return { t: "num", value: t.num };
+  }
+  if (t.type === "ident") {
+    ts.next();
+    return { t: "ref", name: t.value, span: { start: t.start, end: t.end } };
+  }
+  if (t.type === "lparen") {
+    ts.next();
+    const e = parseExpr(ts);
+    const close = ts.peek();
+    if (close.type !== "rparen") ts.fail(`Expected ")" but found ${describe(close)}`);
+    ts.next();
+    return e;
+  }
+  return ts.fail(`Expected a number, name, or "(" but found ${describe(t)}`);
+}
+function evalExpr(e, env, onError) {
+  switch (e.t) {
+    case "num":
+      return e.value;
+    case "ref": {
+      const v = env.get(e.name);
+      if (v === void 0) {
+        const hint = closest(e.name, [...env.keys()]);
+        onError({
+          severity: "error",
+          message: `Unknown name "${e.name}"`,
+          code: "E_UNKNOWN_REF",
+          span: e.span,
+          hints: hint ? [`did you mean "${hint}"?`] : void 0
+        });
+        return 0;
+      }
+      return v;
+    }
+    case "unary": {
+      const v = evalExpr(e.e, env, onError);
+      return e.op === "-" ? -v : v;
+    }
+    case "bin": {
+      const l = evalExpr(e.l, env, onError);
+      const r = evalExpr(e.r, env, onError);
+      switch (e.op) {
+        case "+":
+          return l + r;
+        case "-":
+          return l - r;
+        case "*":
+          return l * r;
+        case "/":
+        case "%":
+          if (r === 0) {
+            onError({ severity: "error", message: `${e.op === "/" ? "Division" : "Modulo"} by zero`, code: "E_DIV_ZERO" });
+            return 0;
+          }
+          return e.op === "/" ? l / r : l % r;
+      }
+    }
+  }
+}
+function describe(t) {
+  if (t.type === "eof") return "end of input";
+  if (t.type === "string") return `string ${JSON.stringify(t.value)}`;
+  return `"${t.value}"`;
+}
+function closest(name, candidates) {
+  let best = null;
+  let bestDist = Infinity;
+  for (const c of candidates) {
+    const d = levenshtein(name, c);
+    if (d < bestDist) {
+      bestDist = d;
+      best = c;
+    }
+  }
+  const limit = Math.max(2, Math.floor(name.length / 3));
+  return best !== null && bestDist <= limit ? best : null;
+}
+function levenshtein(a, b) {
+  const m = a.length;
+  const n = b.length;
+  const dp = Array.from({ length: m + 1 }, (_, i) => i);
+  for (let j = 1; j <= n; j++) {
+    let prev = dp[0];
+    dp[0] = j;
+    for (let i = 1; i <= m; i++) {
+      const tmp = dp[i];
+      dp[i] = Math.min(
+        dp[i] + 1,
+        dp[i - 1] + 1,
+        prev + (a[i - 1] === b[j - 1] ? 0 : 1)
+      );
+      prev = tmp;
+    }
+  }
+  return dp[m];
+}
+
+// src/theme.ts
+var DEFAULT_THEME = {
+  bg: "#ffffff",
+  pocheBase: "#e9e4db",
+  pocheHatch: "#b9b1a4",
+  wallStroke: "#1b1b1b",
+  roomFill: "#fbfaf7",
+  roomLabel: "#222222",
+  areaLabel: "#7a7a7a",
+  furnitureStroke: "#a8a29a",
+  furnitureFill: "#f4f2ee",
+  furnitureLabel: "#9a948c",
+  opening: "#ffffff",
+  doorLeaf: "#555555",
+  windowPane: "#3a6ea5",
+  dim: "#0E5484",
+  annotation: "#333333",
+  annotationMuted: "#888888",
+  column: "#4a4a4a",
+  lineWeight: 1,
+  font: "Helvetica, Arial, sans-serif"
+};
+var ALIASES = {
+  background: "bg",
+  wall: "wallStroke",
+  wallFill: "pocheBase",
+  wallHatch: "pocheHatch",
+  room: "roomFill",
+  furniture: "furnitureFill",
+  door: "doorLeaf",
+  window: "windowPane"
+};
+function resolveThemeKey(key) {
+  if (key in DEFAULT_THEME) return key;
+  if (key in ALIASES) return ALIASES[key];
+  return null;
+}
+function isNumericThemeKey(key) {
+  return key === "lineWeight";
+}
+function mergeTheme(...layers) {
+  const out = { ...DEFAULT_THEME };
+  for (const layer of layers) {
+    if (!layer) continue;
+    for (const k of Object.keys(layer)) {
+      const v = layer[k];
+      if (v !== void 0) out[k] = v;
+    }
+  }
+  return out;
+}
+
 // 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 });
@@ -229,6 +444,46 @@ function isOnSomeWall(walls, at, ref) {
   return false;
 }
 
+// src/hatches.ts
+var KNOWN_MATERIALS = ["poche", "concrete", "brick", "insulation", "tile", "none"];
+var DEFAULT_MATERIAL = "poche";
+function patternId(material) {
+  return material === "poche" ? "poche" : `hatch-${material}`;
+}
+var HATCHES = {
+  poche: (id, c) => `<pattern id="${id}" patternUnits="userSpaceOnUse" width="${c.fmt(c.gap)}" height="${c.fmt(c.gap)}" patternTransform="rotate(45)"><rect width="${c.fmt(c.gap)}" height="${c.fmt(c.gap)}" fill="${c.base}"/><line x1="0" y1="0" x2="0" y2="${c.fmt(c.gap)}" stroke="${c.line}" stroke-width="${c.fmt(c.thin * 0.7)}"/></pattern>`,
+  // Aggregate speckle.
+  concrete: (id, c) => {
+    const w = c.gap * 1.6;
+    return `<pattern id="${id}" patternUnits="userSpaceOnUse" width="${c.fmt(w)}" height="${c.fmt(w)}"><rect width="${c.fmt(w)}" height="${c.fmt(w)}" fill="${c.base}"/><circle cx="${c.fmt(w * 0.25)}" cy="${c.fmt(w * 0.3)}" r="${c.fmt(c.thin * 0.9)}" fill="${c.line}"/><circle cx="${c.fmt(w * 0.7)}" cy="${c.fmt(w * 0.62)}" r="${c.fmt(c.thin * 0.6)}" fill="${c.line}"/><circle cx="${c.fmt(w * 0.45)}" cy="${c.fmt(w * 0.85)}" r="${c.fmt(c.thin * 0.75)}" fill="${c.line}"/></pattern>`;
+  },
+  // Running-bond brick courses.
+  brick: (id, c) => {
+    const w = c.gap * 3;
+    const h = c.gap * 1.4;
+    const sw = c.fmt(c.thin * 0.6);
+    return `<pattern id="${id}" patternUnits="userSpaceOnUse" width="${c.fmt(w)}" height="${c.fmt(h)}"><rect width="${c.fmt(w)}" height="${c.fmt(h)}" fill="${c.base}"/><line x1="0" y1="${c.fmt(h)}" x2="${c.fmt(w)}" y2="${c.fmt(h)}" stroke="${c.line}" stroke-width="${sw}"/><line x1="0" y1="${c.fmt(h / 2)}" x2="${c.fmt(w)}" y2="${c.fmt(h / 2)}" stroke="${c.line}" stroke-width="${sw}"/><line x1="${c.fmt(w / 2)}" y1="0" x2="${c.fmt(w / 2)}" y2="${c.fmt(h / 2)}" stroke="${c.line}" stroke-width="${sw}"/><line x1="0" y1="${c.fmt(h / 2)}" x2="0" y2="${c.fmt(h)}" stroke="${c.line}" stroke-width="${sw}"/><line x1="${c.fmt(w)}" y1="${c.fmt(h / 2)}" x2="${c.fmt(w)}" y2="${c.fmt(h)}" stroke="${c.line}" stroke-width="${sw}"/></pattern>`;
+  },
+  // Cross-hatch batting.
+  insulation: (id, c) => {
+    const w = c.gap * 1.2;
+    return `<pattern id="${id}" patternUnits="userSpaceOnUse" width="${c.fmt(w)}" height="${c.fmt(w)}"><rect width="${c.fmt(w)}" height="${c.fmt(w)}" fill="${c.base}"/><path d="M0,0 L${c.fmt(w)},${c.fmt(w)} M${c.fmt(w)},0 L0,${c.fmt(w)}" stroke="${c.line}" stroke-width="${c.fmt(c.thin * 0.5)}" fill="none"/></pattern>`;
+  },
+  // Square tile grid.
+  tile: (id, c) => {
+    const w = c.gap * 1.8;
+    return `<pattern id="${id}" patternUnits="userSpaceOnUse" width="${c.fmt(w)}" height="${c.fmt(w)}"><rect width="${c.fmt(w)}" height="${c.fmt(w)}" fill="${c.base}"/><rect x="0" y="0" width="${c.fmt(w)}" height="${c.fmt(w)}" fill="none" stroke="${c.line}" stroke-width="${c.fmt(c.thin * 0.6)}"/></pattern>`;
+  },
+  // Solid fill, no hatch.
+  none: (id, c) => `<pattern id="${id}" patternUnits="userSpaceOnUse" width="${c.fmt(c.gap)}" height="${c.fmt(c.gap)}"><rect width="${c.fmt(c.gap)}" height="${c.fmt(c.gap)}" fill="${c.base}"/></pattern>`
+};
+function isKnownMaterial(name) {
+  return KNOWN_MATERIALS.includes(name);
+}
+function hatchPattern(material, c) {
+  return HATCHES[material](patternId(material), c);
+}
+
 // src/elements/wall.ts
 var wall = {
   kind: "wall",
@@ -238,7 +493,12 @@ var wall = {
     const id = ctx.parseIdOpt();
     const category = ctx.eatIdent().value;
     ctx.eatKeyword("thickness");
-    const thickness = ctx.eatNumber();
+    const thickness = ctx.parseExpr();
+    let material;
+    if (ctx.isKeyword("material")) {
+      ctx.next();
+      material = ctx.eatIdent().value;
+    }
     ctx.eat("lcurly");
     const points = [];
     let closed = false;
@@ -252,22 +512,34 @@ var wall = {
         points.push(ctx.parsePoint());
         continue;
       }
-      ctx.fail(`Expected a point "(x,y)" or "close" in wall body but found ${describe(ctx)}`);
+      ctx.fail(`Expected a point "(x,y)" or "close" in wall body but found ${describe2(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 };
+    return { kind: "wall", id, category, thickness, material, 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;
+    const id = ctx.id;
+    const points = n.points.map((p) => ctx.snapPt(ctx.evalPt(p)));
+    const tv = ctx.eval(n.thickness);
+    const thickness = ctx.snap(tv) || tv;
     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 };
+    let material = DEFAULT_MATERIAL;
+    if (n.material !== void 0) {
+      if (isKnownMaterial(n.material)) material = n.material;
+      else
+        ctx.diag({
+          severity: "warning",
+          message: `Unknown wall material "${n.material}" (known: ${KNOWN_MATERIALS.join(", ")}); using the default hatch`,
+          code: "W_UNKNOWN_MATERIAL",
+          span: n.span
+        });
+    }
+    return { kind: "wall", id, category: n.category, thickness, material, points, closed: n.closed, span: n.span };
   },
   bounds(resolved) {
     const w = resolved;
@@ -302,7 +574,7 @@ var wall = {
     return ops;
   }
 };
-function describe(ctx) {
+function describe2(ctx) {
   const t = ctx.peek();
   if (t.type === "eof") return "end of input";
   if (t.type === "string") return `string ${JSON.stringify(t.value)}`;
@@ -319,8 +591,8 @@ var room = {
     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 };
+    const size = ctx.parseDimensions();
+    const node = { kind: "room", id, at, size, line: kw.line };
     if (ctx.isKeyword("label")) {
       ctx.next();
       node.label = ctx.eatString();
@@ -330,9 +602,9 @@ var room = {
   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) };
+    const id = ctx.id;
+    const at = ctx.snapPt(ctx.evalPt(n.at));
+    const size = { w: ctx.snap(ctx.eval(n.size.w)), h: ctx.snap(ctx.eval(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 });
     }
@@ -375,7 +647,7 @@ var door = {
     ctx.eatKeyword("at");
     const at = ctx.parsePoint();
     ctx.eatKeyword("width");
-    const width = ctx.eatNumber();
+    const width = ctx.parseExpr();
     const node = { kind: "door", id, at, width, hinge: "left", swing: "in", line: kw.line };
     if (ctx.isKeyword("wall")) {
       ctx.next();
@@ -398,9 +670,10 @@ var door = {
   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;
+    const id = ctx.id;
+    const at = ctx.snapPt(ctx.evalPt(n.at));
+    const wv = ctx.eval(n.width);
+    const width = ctx.snap(wv) || wv;
     if (width <= 0) {
       ctx.diag({ severity: "error", message: `Door "${id}" must have a positive width`, code: "E_DOOR_WIDTH", span: n.span });
     }
@@ -455,7 +728,7 @@ var windowEl = {
     ctx.eatKeyword("at");
     const at = ctx.parsePoint();
     ctx.eatKeyword("width");
-    const width = ctx.eatNumber();
+    const width = ctx.parseExpr();
     const node = { kind: "window", id, at, width, line: kw.line };
     if (ctx.isKeyword("wall")) {
       ctx.next();
@@ -466,9 +739,10 @@ var windowEl = {
   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;
+    const id = ctx.id;
+    const at = ctx.snapPt(ctx.evalPt(n.at));
+    const wv = ctx.eval(n.width);
+    const width = ctx.snap(wv) || wv;
     if (width <= 0) {
       ctx.diag({ severity: "error", message: `Window "${id}" must have a positive width`, code: "E_WINDOW_WIDTH", span: n.span });
     }
@@ -525,8 +799,8 @@ var furniture = {
     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 };
+    const size = ctx.parseDimensions();
+    const node = { kind: "furniture", id, category, at, size, line: kw.line };
     if (ctx.isKeyword("label")) {
       ctx.next();
       node.label = ctx.eatString();
@@ -536,9 +810,9 @@ var furniture = {
   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) };
+    const id = ctx.id;
+    const at = ctx.snapPt(ctx.evalPt(n.at));
+    const size = { w: ctx.snap(ctx.eval(n.size.w)), h: ctx.snap(ctx.eval(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 });
     }
@@ -578,10 +852,10 @@ var dim = {
     const from = ctx.parsePoint();
     ctx.eat("arrow");
     const to = ctx.parsePoint();
-    const node = { kind: "dim", id: "", from, to, offset: 300, line: kw.line };
+    const node = { kind: "dim", id: "", from, to, offset: { t: "num", value: 300 }, line: kw.line };
     if (ctx.isKeyword("offset")) {
       ctx.next();
-      node.offset = ctx.eatNumber();
+      node.offset = ctx.parseExpr();
     }
     if (ctx.isKeyword("text")) {
       ctx.next();
@@ -594,10 +868,10 @@ var dim = {
     const n = node;
     return {
       kind: "dim",
-      id: ctx.idOf(n),
-      from: ctx.snapPt(n.from),
-      to: ctx.snapPt(n.to),
-      offset: n.offset,
+      id: ctx.id,
+      from: ctx.snapPt(ctx.evalPt(n.from)),
+      to: ctx.snapPt(ctx.evalPt(n.to)),
+      offset: ctx.eval(n.offset),
       text: n.text,
       span: n.span
     };
@@ -660,15 +934,15 @@ var column = {
     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 };
+    const size = ctx.parseDimensions();
+    return { kind: "column", id, at, size, 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) };
+    const id = ctx.id;
+    const at = ctx.snapPt(ctx.evalPt(n.at));
+    const size = { w: ctx.snap(ctx.eval(n.size.w)), h: ctx.snap(ctx.eval(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 });
     }
@@ -707,7 +981,7 @@ register(dim);
 register(column);
 
 // src/parser.ts
-var SETTINGS = ["units", "grid", "scale", "north", "title"];
+var SETTINGS = ["units", "grid", "scale", "north", "title", "theme", "let", "component"];
 var STATEMENT_STARTS = /* @__PURE__ */ new Set([...SETTINGS, ...registry.keys()]);
 var ParseError = class extends Error {
   constructor(message, span) {
@@ -752,6 +1026,8 @@ var Parser = class {
       isKeyword: (kw, o) => this.isKeyword(kw, o),
       isType: (type) => this.isType(type),
       parsePoint: () => this.parsePoint(),
+      parseExpr: () => parseExpr(this.ctx),
+      parseDimensions: () => this.parseDimensions(),
       parseIdOpt: () => this.parseIdOpt(),
       fail: (msg, t) => this.fail(msg, t)
     };
@@ -790,12 +1066,12 @@ var Parser = class {
   }
   eatKeyword(kw) {
     const t = this.peek();
-    if (t.type !== "ident" || t.value !== kw) this.fail(`Expected "${kw}" but found ${describe2(t)}`);
+    if (t.type !== "ident" || t.value !== kw) this.fail(`Expected "${kw}" but found ${describe3(t)}`);
     return this.next();
   }
   eat(type) {
     const t = this.peek();
-    if (t.type !== type) this.fail(`Expected ${type} but found ${describe2(t)}`);
+    if (t.type !== type) this.fail(`Expected ${type} but found ${describe3(t)}`);
     return this.next();
   }
   eatIdent() {
@@ -817,18 +1093,25 @@ var Parser = class {
       units: "mm",
       grid: 0,
       north: "up",
-      elements: []
+      components: /* @__PURE__ */ new Map(),
+      body: []
     };
     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 ${describe2(t)}`);
+        if (t.type !== "ident") this.fail(`Expected a statement but found ${describe3(t)}`);
         const def = registry.get(t.value);
         if (def) {
           const node = def.parse(this.ctx);
           node.span = this.spanFrom(start);
-          plan.elements.push(node);
+          plan.body.push(node);
+          continue;
+        }
+        if (plan.components.has(t.value) && this.peek(1).type === "lparen") {
+          const node = this.parseInstance();
+          node.span = this.spanFrom(start);
+          plan.body.push(node);
           continue;
         }
         switch (t.value) {
@@ -861,6 +1144,25 @@ var Parser = class {
             plan.title = n;
             break;
           }
+          case "theme": {
+            plan.theme = { ...plan.theme, ...this.parseTheme() };
+            break;
+          }
+          case "let": {
+            const n = this.parseLet();
+            n.span = this.spanFrom(start);
+            plan.body.push(n);
+            break;
+          }
+          case "component": {
+            const def2 = this.parseComponent(plan.components);
+            def2.span = this.spanFrom(start);
+            if (plan.components.has(def2.name)) {
+              this.fail(`Component "${def2.name}" is already defined`, t);
+            }
+            plan.components.set(def2.name, def2);
+            break;
+          }
           default:
             this.fail(`Unknown statement "${t.value}"`, t);
         }
@@ -906,23 +1208,35 @@ var Parser = class {
       this.next();
       return t.value;
     }
-    this.fail(`Expected a north direction (up|down|left|right|<degrees>) but found ${describe2(t)}`);
+    this.fail(`Expected a north direction (up|down|left|right|<degrees>) but found ${describe3(t)}`);
   }
   parsePoint() {
     this.eat("lparen");
-    const x = this.eatNumber();
+    const x = parseExpr(this.ctx);
     this.eat("comma");
-    const y = this.eatNumber();
+    const y = parseExpr(this.ctx);
     this.eat("rparen");
     return { x, y };
   }
+  /** A size: either a `WxH` literal dimension token or `<expr> x <expr>`. */
+  parseDimensions() {
+    if (this.isType("dimension")) {
+      const d = this.eat("dimension");
+      return { w: { t: "num", value: d.num }, h: { t: "num", value: d.num2 } };
+    }
+    const w = parseExpr(this.ctx);
+    if (this.isKeyword("x")) this.next();
+    else this.fail(`Expected "x" between width and height but found ${describe3(this.peek())}`);
+    const h = parseExpr(this.ctx);
+    return { w, h };
+  }
   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 ${describe2(t)}`);
+      if (t.type !== "ident") this.fail(`Expected a title field but found ${describe3(t)}`);
       switch (t.value) {
         case "project":
           this.next();
@@ -943,20 +1257,150 @@ var Parser = class {
     this.eat("rcurly");
     return node;
   }
+  /** `theme { key: <value> … }` — colours (strings), `lineWeight` (number), `font` (string). */
+  parseTheme() {
+    this.eatKeyword("theme");
+    this.eat("lcurly");
+    const t = {};
+    while (!this.isType("rcurly") && !this.isType("eof")) {
+      const keyTok = this.eatIdent();
+      if (this.isType("colon")) this.next();
+      const resolved = resolveThemeKey(keyTok.value);
+      if (!resolved) {
+        this.diagnostics.push({
+          severity: "warning",
+          message: `Unknown theme key "${keyTok.value}"`,
+          code: "W_UNKNOWN_THEME_KEY",
+          span: { start: keyTok.start, end: keyTok.end }
+        });
+        if (this.isType("string") || this.isType("number")) this.next();
+        else this.fail(`Expected a value for theme key "${keyTok.value}"`);
+        continue;
+      }
+      if (isNumericThemeKey(resolved)) {
+        t[resolved] = this.eatNumber();
+      } else {
+        t[resolved] = this.eatString();
+      }
+    }
+    this.eat("rcurly");
+    return t;
+  }
+  parseLet() {
+    const kw = this.eatKeyword("let");
+    const name = this.eatIdent().value;
+    this.eat("equals");
+    const value = parseExpr(this.ctx);
+    return { kind: "let", id: "", name, value, line: kw.line };
+  }
+  parseInstance() {
+    const nameTok = this.eatIdent();
+    this.eat("lparen");
+    const args = [];
+    while (!this.isType("rparen") && !this.isType("eof")) {
+      args.push(parseExpr(this.ctx));
+      if (this.isType("comma")) this.next();
+      else break;
+    }
+    this.eat("rparen");
+    return { kind: "instance", id: "", name: nameTok.value, args, line: nameTok.line };
+  }
+  /** `component NAME(p1, p2, …) { <statements> }`. */
+  parseComponent(components) {
+    const kw = this.eatKeyword("component");
+    const name = this.eatIdent().value;
+    this.eat("lparen");
+    const params = [];
+    while (!this.isType("rparen") && !this.isType("eof")) {
+      params.push(this.eatIdent().value);
+      if (this.isType("comma")) this.next();
+      else break;
+    }
+    this.eat("rparen");
+    this.eat("lcurly");
+    const body = [];
+    while (!this.isType("rcurly") && !this.isType("eof")) {
+      const t = this.peek();
+      const start = t.start;
+      const def = registry.get(t.value);
+      if (def) {
+        const node = def.parse(this.ctx);
+        node.span = this.spanFrom(start);
+        body.push(node);
+        continue;
+      }
+      if (t.value === "let") {
+        const n = this.parseLet();
+        n.span = this.spanFrom(start);
+        body.push(n);
+        continue;
+      }
+      if ((components.has(t.value) || t.value === name) && this.peek(1).type === "lparen") {
+        const n = this.parseInstance();
+        n.span = this.spanFrom(start);
+        body.push(n);
+        continue;
+      }
+      this.fail(`Expected an element, "let", or component call in component body but found ${describe3(t)}`, t);
+    }
+    this.eat("rcurly");
+    return { name, params, body, line: kw.line };
+  }
 };
-function describe2(t) {
+function describe3(t) {
   if (t.type === "eof") return "end of input";
   if (t.type === "string") return `string ${JSON.stringify(t.value)}`;
   return `"${t.value}"`;
 }
 
 // src/ir.ts
+var MAX_DEPTH = 64;
+function expandScope(body, env, defined, global, components, diagnostics, depth) {
+  const diag = (d) => diagnostics.push(d);
+  const out = [];
+  for (const stmt of body) {
+    if (stmt.kind === "let") {
+      if (defined.has(stmt.name)) {
+        diag({ severity: "error", message: `"${stmt.name}" is already defined in this scope`, code: "E_REDEF", span: stmt.span });
+        continue;
+      }
+      env.set(stmt.name, evalExpr(stmt.value, env, diag));
+      defined.add(stmt.name);
+    } else if (stmt.kind === "instance") {
+      const comp = components.get(stmt.name);
+      if (!comp) {
+        const hint = closest(stmt.name, [...components.keys()]);
+        diag({ severity: "error", message: `Unknown component "${stmt.name}"`, code: "E_UNKNOWN_COMPONENT", span: stmt.span, hints: hint ? [`did you mean "${hint}"?`] : void 0 });
+        continue;
+      }
+      if (depth >= MAX_DEPTH) {
+        diag({ severity: "error", message: `Component recursion too deep (limit ${MAX_DEPTH}) instantiating "${stmt.name}"`, code: "E_RECURSION", span: stmt.span });
+        continue;
+      }
+      if (stmt.args.length !== comp.params.length) {
+        diag({ severity: "error", message: `Component "${stmt.name}" expects ${comp.params.length} argument(s) but got ${stmt.args.length}`, code: "E_ARGCOUNT", span: stmt.span });
+      }
+      const argVals = comp.params.map((_, i) => stmt.args[i] !== void 0 ? evalExpr(stmt.args[i], env, diag) : 0);
+      const childEnv = new Map(global);
+      const childDefined = /* @__PURE__ */ new Set();
+      comp.params.forEach((p, i) => {
+        childEnv.set(p, argVals[i]);
+        childDefined.add(p);
+      });
+      out.push(...expandScope(comp.body, childEnv, childDefined, global, components, diagnostics, depth + 1));
+    } else {
+      out.push({ node: stmt, env: new Map(env), id: "" });
+    }
+  }
+  return out;
+}
 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) });
-  const idMap = /* @__PURE__ */ new Map();
+  const globalEnv = /* @__PURE__ */ new Map();
+  const entries = expandScope(ast.body, globalEnv, /* @__PURE__ */ new Set(), globalEnv, ast.components, diagnostics, 0);
   const seen = /* @__PURE__ */ new Set();
   const assignId = (provided, prefix, idx, span) => {
     if (provided) {
@@ -973,33 +1417,39 @@ function resolve(ast) {
   };
   for (const def of registryOrder) {
     let idx = 0;
-    for (const node of ast.elements) {
-      if (node.kind !== def.kind) continue;
+    for (const e of entries) {
+      if (e.node.kind !== def.kind) continue;
       idx++;
-      idMap.set(node, assignId(node.id, def.idPrefix(node), idx, node.span));
+      e.id = assignId(e.node.id, def.idPrefix(e.node), idx, e.node.span);
     }
   }
   const walls = [];
+  let activeEnv = /* @__PURE__ */ new Map();
+  const evalNum = (e) => evalExpr(e, activeEnv, (d) => diagnostics.push(d));
+  const evalPt = (p) => ({ x: evalNum(p.x), y: evalNum(p.y) });
   const ctx = {
     grid: g,
     snap,
     snapPt,
-    idOf: (node) => idMap.get(node) ?? node.id,
+    eval: evalNum,
+    evalPt,
+    id: "",
     walls,
     hostSegment: (at, ref) => hostSegmentForWalls(walls, at, ref),
     isOnWall: (at, ref) => isOnSomeWall(walls, at, ref),
     diag: (d) => diagnostics.push(d)
   };
-  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);
+    for (const e of entries) {
+      if (e.node.kind !== def.kind) continue;
+      activeEnv = e.env;
+      ctx.id = e.id;
+      const r = def.resolve(e.node, ctx);
+      e.resolved = r;
       if (r.kind === "wall") walls.push(r);
     }
   }
-  const elements = ast.elements.map((n) => rmap.get(n));
+  const elements = entries.map((e) => e.resolved);
   const drawable = elements.some(
     (e) => e.kind === "wall" || e.kind === "room" || e.kind === "furniture" || e.kind === "column"
   );
@@ -1034,6 +1484,7 @@ function resolve(ast) {
     scale: ast.scale,
     north: ast.north,
     title: ast.title,
+    theme: ast.theme,
     elements,
     walls
   };
@@ -1053,26 +1504,104 @@ var RENDER_PASSES = [
   "annotations"
 ];
 
+// src/geometry/union.ts
+function uniqSorted(values) {
+  const out = [...new Set(values)].sort((a, b) => a - b);
+  return out;
+}
+function rectUnionOutline(rects) {
+  if (rects.length === 0) return [];
+  const xs = uniqSorted(rects.flatMap((r) => [r.x0, r.x1]));
+  const ys = uniqSorted(rects.flatMap((r) => [r.y0, r.y1]));
+  const nx = xs.length - 1;
+  const ny = ys.length - 1;
+  const filled = (i, j) => {
+    if (i < 0 || j < 0 || i >= nx || j >= ny) return false;
+    const cx = (xs[i] + xs[i + 1]) / 2;
+    const cy = (ys[j] + ys[j + 1]) / 2;
+    return rects.some((r) => cx > r.x0 && cx < r.x1 && cy > r.y0 && cy < r.y1);
+  };
+  const key = (x, y) => `${x},${y}`;
+  const starts = /* @__PURE__ */ new Map();
+  const pushEdge = (ax, ay, bx, by) => {
+    const k = key(ax, ay);
+    const list = starts.get(k);
+    if (list) list.push({ x: bx, y: by });
+    else starts.set(k, [{ x: bx, y: by }]);
+  };
+  for (let i = 0; i < nx; i++) {
+    for (let j = 0; j < ny; j++) {
+      if (!filled(i, j)) continue;
+      const x0 = xs[i];
+      const x1 = xs[i + 1];
+      const y0 = ys[j];
+      const y1 = ys[j + 1];
+      if (!filled(i, j - 1)) pushEdge(x1, y0, x0, y0);
+      if (!filled(i - 1, j)) pushEdge(x0, y0, x0, y1);
+      if (!filled(i, j + 1)) pushEdge(x0, y1, x1, y1);
+      if (!filled(i + 1, j)) pushEdge(x1, y1, x1, y0);
+    }
+  }
+  const used = /* @__PURE__ */ new Set();
+  const edgeKey = (a, b) => `${a.x},${a.y}->${b.x},${b.y}`;
+  const loops = [];
+  const takeNext = (from, prevDir) => {
+    const list = starts.get(key(from.x, from.y));
+    if (!list) return null;
+    const candidates = list.filter((to) => !used.has(edgeKey(from, to)));
+    if (candidates.length === 0) return null;
+    if (candidates.length === 1 || !prevDir) return candidates[0];
+    let best = candidates[0];
+    let bestScore = -Infinity;
+    for (const c of candidates) {
+      const dir = { x: c.x - from.x, y: c.y - from.y };
+      const cross = prevDir.x * dir.y - prevDir.y * dir.x;
+      if (cross > bestScore) {
+        bestScore = cross;
+        best = c;
+      }
+    }
+    return best;
+  };
+  for (const [startKey, ends] of starts) {
+    for (const firstEnd of ends) {
+      const [sx, sy] = startKey.split(",").map(Number);
+      const start = { x: sx, y: sy };
+      if (used.has(edgeKey(start, firstEnd))) continue;
+      const loop = [start];
+      let cur = start;
+      let next = firstEnd;
+      let dir = null;
+      while (next) {
+        used.add(edgeKey(cur, next));
+        if (next.x === start.x && next.y === start.y) break;
+        loop.push(next);
+        dir = { x: next.x - cur.x, y: next.y - cur.y };
+        cur = next;
+        next = takeNext(cur, dir);
+      }
+      if (loop.length >= 4) loops.push(mergeCollinear(loop));
+    }
+  }
+  return loops;
+}
+function mergeCollinear(loop) {
+  const n = loop.length;
+  const out = [];
+  for (let i = 0; i < n; i++) {
+    const prev = loop[(i - 1 + n) % n];
+    const cur = loop[i];
+    const next = loop[(i + 1) % n];
+    const d1x = cur.x - prev.x;
+    const d1y = cur.y - prev.y;
+    const d2x = next.x - cur.x;
+    const d2y = next.y - cur.y;
+    if (d1x * d2y - d1y * d2x !== 0) out.push(cur);
+  }
+  return out.length >= 3 ? out : loop;
+}
+
 // src/render.ts
-var THEME = {
-  bg: "#ffffff",
-  pocheBase: "#e9e4db",
-  pocheHatch: "#b9b1a4",
-  wallStroke: "#1b1b1b",
-  roomFill: "#fbfaf7",
-  roomLabel: "#222222",
-  areaLabel: "#7a7a7a",
-  furnitureStroke: "#a8a29a",
-  furnitureFill: "#f4f2ee",
-  furnitureLabel: "#9a948c",
-  opening: "#ffffff",
-  doorLeaf: "#555555",
-  windowPane: "#3a6ea5",
-  dim: "#0E5484",
-  annotation: "#333333",
-  annotationMuted: "#888888",
-  column: "#4a4a4a"
-};
 function fmt(v) {
   const r = Math.round(v * 100) / 100;
   return Object.is(r, -0) ? "0" : String(r);
@@ -1099,15 +1628,56 @@ function planBounds(ir) {
   }
   return b;
 }
+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) {
+  if (walls.length === 0) return [];
+  const ops = [];
+  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)));
+      continue;
+    }
+    const rects = [];
+    for (const w of group) {
+      for (const s of segmentsOfWall(w)) {
+        const corners = segmentRectangle(s.a, s.b, s.thickness);
+        const xsv = corners.map((c) => c.x);
+        const ysv = corners.map((c) => c.y);
+        rects.push({ x0: Math.min(...xsv), y0: Math.min(...ysv), x1: Math.max(...xsv), y1: Math.max(...ysv) });
+      }
+    }
+    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"/>`
+    });
+  }
+  return ops;
+}
 function render(ir, opts = {}) {
+  const THEME = 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;
   const refDim = Math.max(drawW, drawH, 1);
   const sizes = {
     refDim,
-    wallStroke: refDim * 28e-4,
-    thin: refDim * 16e-4,
+    wallStroke: refDim * 28e-4 * lw,
+    thin: refDim * 16e-4 * lw,
     roomFont: refDim * 0.03,
     areaFont: refDim * 0.022,
     dimFont: refDim * 0.02,
@@ -1123,28 +1693,30 @@ function render(ir, opts = {}) {
   const out = [];
   const svgAttrs = opts.width ? `width="${fmt(opts.width)}" height="${fmt(opts.width * vbH / vbW)}"` : "";
   out.push(
-    `<svg xmlns="http://www.w3.org/2000/svg" ${svgAttrs} viewBox="${fmt(vbX)} ${fmt(vbY)} ${fmt(vbW)} ${fmt(vbH)}" font-family="Helvetica, Arial, sans-serif">`
-  );
-  out.push(
-    `<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>`
+    `<svg xmlns="http://www.w3.org/2000/svg" ${svgAttrs} viewBox="${fmt(vbX)} ${fmt(vbY)} ${fmt(vbW)} ${fmt(vbH)}" font-family="${xml(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("");
+  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);
   }
-  out.push(northArrow(ir, b, margin, refDim));
-  out.push(scaleBar(b, margin, refDim, thin));
-  const tb = titleBlock(ir, b, margin, refDim, thin);
+  out.push(northArrow(ir, b, margin, refDim, THEME));
+  out.push(scaleBar(b, margin, refDim, thin, THEME));
+  const tb = titleBlock(ir, b, margin, refDim, thin, THEME);
   if (tb) out.push(tb);
   out.push("</svg>");
   return out.join("\n");
 }
-function northArrow(ir, b, margin, refDim) {
+function northArrow(ir, b, margin, refDim, THEME) {
   const r = refDim * 0.045;
   const cx = b.maxX - r;
   const cy = b.minY - margin * 0.55;
@@ -1174,7 +1746,7 @@ function northArrow(ir, b, margin, refDim) {
   const ly = cy + ny * (r + fs * 0.8);
   return `<g><polygon points="${tri}" fill="${THEME.annotation}" transform="rotate(${fmt(deg)} ${fmt(cx)} ${fmt(cy)})"/><text x="${fmt(lx)}" y="${fmt(ly)}" font-size="${fmt(fs)}" fill="${THEME.annotation}" text-anchor="middle" dominant-baseline="central">N</text></g>`;
 }
-function scaleBar(b, margin, refDim, thin) {
+function scaleBar(b, margin, refDim, thin, THEME) {
   const barLen = niceBarLength(refDim * 0.3);
   const x0 = b.minX;
   const y0 = b.maxY + margin * 0.55;
@@ -1194,7 +1766,7 @@ function scaleBar(b, margin, refDim, thin) {
   );
   return `<g>${parts.join("")}</g>`;
 }
-function titleBlock(ir, b, margin, refDim, thin) {
+function titleBlock(ir, b, margin, refDim, thin, THEME) {
   const t = ir.title;
   if (!t && !ir.scale) return null;
   const boxW = refDim * 0.34;
@@ -1287,7 +1859,7 @@ function formatDiagnostic(source, d) {
 var cache = /* @__PURE__ */ new Map();
 var CACHE_MAX = 64;
 function compile(source, opts = {}) {
-  const key = JSON.stringify([source, opts.width ?? null]);
+  const key = JSON.stringify([source, opts.width ?? null, opts.theme ?? null]);
   if (!opts.noCache) {
     const hit = cache.get(key);
     if (hit) return hit;
@@ -1327,4 +1899,4 @@ export {
   compile,
   clearCache
 };
-//# sourceMappingURL=chunk-3YUQPQPZ.js.map
+//# sourceMappingURL=chunk-GUNWYUR2.js.map