@chanmeng666/archlang 0.3.0 → 0.4.0

package/dist/{chunk-3YUQPQPZ.js → chunk-DHNWMOP7.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,146 @@ 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/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 });
@@ -238,7 +401,7 @@ var wall = {
     const id = ctx.parseIdOpt();
     const category = ctx.eatIdent().value;
     ctx.eatKeyword("thickness");
-    const thickness = ctx.eatNumber();
+    const thickness = ctx.parseExpr();
     ctx.eat("lcurly");
     const points = [];
     let closed = false;
@@ -252,7 +415,7 @@ 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);
@@ -261,9 +424,10 @@ var wall = {
   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 });
     }
@@ -302,7 +466,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 +483,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 +494,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 +539,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 +562,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 +620,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 +631,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 +691,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 +702,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 +744,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 +760,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 +826,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 +873,7 @@ register(dim);
 register(column);
 
 // src/parser.ts
-var SETTINGS = ["units", "grid", "scale", "north", "title"];
+var SETTINGS = ["units", "grid", "scale", "north", "title", "let", "component"];
 var STATEMENT_STARTS = /* @__PURE__ */ new Set([...SETTINGS, ...registry.keys()]);
 var ParseError = class extends Error {
   constructor(message, span) {
@@ -752,6 +918,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 +958,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 +985,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 +1036,21 @@ var Parser = class {
             plan.title = n;
             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 +1096,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 +1145,121 @@ var Parser = class {
     this.eat("rcurly");
     return node;
   }
+  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 +1276,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"
   );
@@ -1327,4 +1636,4 @@ export {
   compile,
   clearCache
 };
-//# sourceMappingURL=chunk-3YUQPQPZ.js.map
+//# sourceMappingURL=chunk-DHNWMOP7.js.map