wadi-mcp 0.1.10 → 0.1.11

package/dist/server.mjs

@@ -411972,6 +411972,14 @@ function anchorItem(rect, spec, wallT, units) {
   else y = (iy0 + iy1) / 2 + gy;
   return { x, y };
 }
+function anchorFacing(anchor) {
+  const { h, v } = parseAnchor(anchor);
+  if (v === "top") return 0;
+  if (v === "bottom") return 180;
+  if (h === "left") return 90;
+  if (h === "right") return 270;
+  return 0;
+}
 
 // ../editor/src/svg2d/expand.ts
 var SIDES = ["north", "south", "east", "west"];
@@ -412059,13 +412067,14 @@ function expandRoomWalls(houseConfig, wallThickness, opts, _depth = 0) {
     }
     const anchoredItem = (rect, specIn) => {
       const spec = resolveItemFormulas(specIn);
+      const rotation = spec.rotation ?? anchorFacing(spec.anchor);
       const p = anchorItem(
         rect,
         {
           anchor: spec.anchor,
           gapX: spec.gap_x,
           gapY: spec.gap_y,
-          rotation: spec.rotation,
+          rotation,
           scale: spec.scale,
           dimensions: spec.asset.dimensions
         },
@@ -412078,7 +412087,7 @@ function expandRoomWalls(houseConfig, wallThickness, opts, _depth = 0) {
         asset: spec.asset,
         x: p.x,
         y: p.y,
-        rotation: spec.rotation ?? 0,
+        rotation,
         scale: spec.scale,
         z_offset: spec.z_offset,
         layer: spec.layer
@@ -412121,6 +412130,7 @@ function expandRoomWalls(houseConfig, wallThickness, opts, _depth = 0) {
             const p = anchoredItem(rr, obj);
             obj.x = p.x;
             obj.y = p.y;
+            obj.rotation = p.rotation;
           } else if (opts?.lenient) {
             opts.onWarning?.(`item '${obj.name ?? "?"}': anchor_to room '${at}' not found`);
           }
@@ -418007,7 +418017,7 @@ var DOCS = {
   },
   "dsl": {
     "title": "The Wadi DSL (.wdl) \u2014 syntax reference",
-    "body": '# The Wadi DSL (`.wdl`) \u2014 authoring reference\n\nYou author houses in the **Wadi DSL** \u2014 a small, formal language (`.wdl`) that\ncompiles to a resolved `.wadi` (`house_config.json`). The DSL is **complete**:\nevery object type in the model has first-class syntax, so you rarely need the\n`raw` escape. Authoring the DSL is more direct and less error-prone than writing\nJSON \u2014 the grammar enforces structure, and `check.sh` reports parse errors with\nline:col.\n\n**This file is the SYNTAX reference.** The *semantics* live in the other\nreferences and apply unchanged \u2014 read them:\n\n- `coordinate-system.md` \u2014 X\u2192right, **Y\u2192DOWN**, Z\u2192up; **10 units = 1 ft**;\n  the **centreline** convention. The #1 source of mistakes.\n- `conventions.md` \u2014 the **structural coding conventions** (`check.sh` enforces\n  them): plinth-floor height must match the plinth block, rooms must wall every\n  exterior side, a no-slab floor must set `slab_thickness 0`.\n- `parametric-conventions.md` \u2014 the grid-first recipe for reusable templates.\n- `roof-v2-guide.md` \u2014 roof segments, hip vs gable, trusses, joints.\n- `data-model.md` \u2014 the underlying `.wadi` schema (what the DSL compiles to; also\n  the field reference for the `raw` escape).\n\n## The loop\n\n1. Write / edit `house.wdl` \u2014 the **single shared source** (you and the human\n   co-edit it; the app\'s DSL previewer renders it live). You never produce a `.wadi`.\n2. `wadi-skill/architect/scripts/check.sh house.wdl` \u2014 runs the DSL compiler +\n   validator (schema + wall/roof geometry) against a **throwaway temp** just for\n   feedback; fix any reported error and re-run.\n3. `preview.sh house.wdl` \u2192 read the PNGs (plans / elevations / roof) to check your\n   work. (It also compiles to a throwaway temp \u2014 no persistent `.wadi`.)\n\n## Skeleton\n\n```wdl\nhouse MyHouse {\n  convention center                 // ALWAYS use center (wall-centreline coords)\n  units feet_inches per_unit 10     // 10 project units = 1 ft\n  site { plot (WIDTH, LENGTH) ref (0, 0) }\n  defaults { floor_height 120 wall_height 108 slab_thickness 8 wall_thickness 8 }\n\n  // parametric core (optional): var, point, grid, configurator\n  // component / layer declarations (optional)\n  floor 0 "Plinth" { \u2026 }            // floors stack in source order (0 = plinth)\n  floor 1 "Ground Floor" { \u2026 }\n  floor 2 "Loft" { roof \u2026 }         // roof lives ALONE on its own top floor\n}\n```\n\nNumbers are **project units** (feet \xD7 10 by default). Names after `house`,\n`room`, `pillar`, `var`, `point`, `grid`, and `use`/`component` are bare\nidentifiers (no spaces); names introduced with the `name` keyword are quoted\nstrings.\n\n## Parametric core (domain-neutral)\n\n```wdl\nvar wallT = 8                       // a knob; may reference other vars\nvar pilInset = (pillarW - wallT) / 2\n\npoint House { x = 420, y = 470 }    // reference as House.x / House.W / House.L\n                                    // (.W = x, .L = y \u2014 a point doubles as a size)\n\ngrid main {                         // named wall centrelines; publishes main.x1 / main.yA\n  x: 1 @ wallT / 2, 2 @ House.W / 2, 3 @ House.W - wallT / 2\n  y: A @ wallT / 2, B @ House.L / 2, C @ House.L - wallT / 2\n}\n// each line may add:  \u2026 @ <expr> thick <expr>  role structural|planning\n\nconfigurator {                      // the knobs a downstream user turns\n  slider pillarW    "Column size" ft [8 .. 14 step 1]\n  number ceiling    "Ceiling height" ft\n  toggle has_loft   "Add a loft"\n  select roof_style "Roof style" { Flat = 0, Shed = 1, Gable = 2, Hip = 3 }\n}\n```\n\n**Formulas are automatic.** Any geometry number can be a formula \u2014 just write the\nexpression instead of a literal (`at (main.x1, main.yA)`, `size (House.W/2, 200)`).\nOperators: `+ - * /`, unary `-`, parentheses, and the functions\n`min max clamp round floor ceil abs`. References: a `var`, a `point`\n(`House.W`), or a grid line (`main.x3 - main.x1`). No comparison operators \u2014 gate\nthings with the `min/abs` idiom (see `enabled` below).\n\n## Common attribute tail (every object)\n\nAfter an object\'s geometry, in THIS order, any of:\n\n```\n\u2026 z_offset <expr>   enabled <expr>   layer "id"   [material "id"]\n```\n\n- `enabled <expr>` \u2014 the on/off switch. A `0`/`false` value hides the object. To\n  gate on a configurator variable, use a 0/1 formula:\n  `enabled 1 - min(1, abs(roof_style - 3))` renders the object only when\n  `roof_style == 3`. (This is how one template carries several roofs and shows\n  only the chosen one.)\n- `z_offset <expr>` \u2014 lift above the floor base (split levels).\n- `material "id"` \u2014 only on plinth / ground / room / wall / staircase / kitchen /\n  roof.\n\n## Objects \u2014 structure & envelope\n\n```wdl\nslab   [name "N"] at (x,y) size (w,l) [thickness <t>]     // floor_slab\nbeam   [name "N"] at (x,y) size (w,l) [height <h>]\nplinth [name "N"] at (x,y) size (w,l) height <h>          // raised base (Plinth floor)\nground [name "N"] at (x,y) size (w,l) [height <h>]        // terrain plane\npillar Name       at (x,y) size (w,l) [height <h>]        // (x,y) = TOP-LEFT corner\n```\n\n`at (x,y)` is the **TOP-LEFT CORNER** \u2014 **not the centre** \u2014 for every one of these\n(same as rooms/slabs/beams); `size (w,l)` is width \xD7 length. All accept the common tail.\n\n**Pillars catch people out here.** A column reads as "placed at a point," but `at` is\nstill its corner. To **centre a column on a point** `(cx, cy)` \u2014 a grid node, a room\ncorner \u2014 place it at **`at (cx - w/2, cy - l/2)`**, never at `(cx, cy)`. On a grid, the\n`pilInset` idiom (see `parametric-conventions.md`) does exactly this so columns sit flush.\n\n## Objects \u2014 rooms, walls & openings\n\nA room shows exactly the walls you declare. A **bare room (no `wall` lines) is\nenclosed on all four sides.** List plain walls compactly; give a wall its own line\nonly when it carries a door/window; omit a side to leave it open (verandah).\n\n```wdl\nroom Name at (x,y) size (w,l) [height <h>] [material "\u2026"] {\n  wall east west north                 // plain walls \u2014 several in one statement\n  wall south { door Main at <offset> size (w,h) [open] }   // wall WITH openings: one side\n  wall west  { window W at <offset> size (w,h) [sill <s>] [open] }\n  item asset { \u2026 } anchor center [gap (gx,gy)]   // furniture anchored inside the room\n}\n```\n\n- `wall <side>\u2026` sides are `north|south|east|west`. A `wall <side>` line may also\n  add `height <h>` / `height_end <h>` (sloped).\n- `door`/`window` `at <offset>` is measured along the wall from its start;\n  `size (width, height)`; `window \u2026 sill <s>` sets the sill height; `open` = a bare\n  hole (no leaf/glazing).\n\nA **free-standing wall** (not a room side):\n\n```wdl\nwall Name from (x1,y1) to (x2,y2) [height <h>] [height_end <h>] [facing north|\u2026] {\n  \u2026 door/window openings \u2026\n}\n```\n\n- `from`/`to` are the wall\'s **centreline** endpoints; the wall is drawn as a rectangle\n  `wall_thickness` wide, centred on that line.\n- **Overlap walls at corners \u2014 they do NOT auto-mitre.** Two free-standing walls that\n  merely *touch* at a shared endpoint leave an unfilled square notch (\xBD\xB7`wall_thickness`)\n  at the corner, because each is just a rectangle capped at its endpoint. To fill the\n  corner, **extend the endpoints so the wall bodies OVERLAP** \u2014 run at least one wall\'s\n  end **half the wall thickness past** the shared point (overlapping by the full thickness\n  is fine and simplest). For an L of thickness 8 meeting at `(160,40)`:\n\n  ```wdl\n  wall H from (40, 40)  to (164, 40)  height 108   // ends 4 (\xBD\xB78) PAST the corner\n  wall V from (160, 40) to (160, 160) height 108    // butts into H\'s overlapped body\n  ```\n\n  (Room walls handle their own corners; this only applies to `wall \u2026 from \u2026 to \u2026`.)\n\n## Objects \u2014 circulation & fittings\n\n```wdl\nstaircase [name "N"] at (start_x, start_y) step (rise, tread, width)\n  direction north|south|east|west\n  [total_height <h>] [max_run <r>] [landing_depth <d>]\n  [landing_thickness <t>] [turn clockwise|anticlockwise] [flight_gap <g>]\n\nkitchen [name "N"] path ((x,y), (x,y), \u2026) side left|right\n  depth <d> height <h> [base_z <z>]        // path points are literal numbers\n```\n\n**Staircases are TOP-anchored \u2014 this is the #1 mistake.** You put a staircase on the\n**UPPER** floor and it **DESCENDS** to the floor below:\n\n- `at (x,y)` is the **TOP** of the stair (where it meets the floor it\'s declared on).\n- `direction` is the **descent** direction (the way it travels going *down*).\n- `total_height` is the **drop** to the floor below (omit \u2192 the floor-below\'s height).\n- `max_run` caps a flight\'s run; exceed it and the stair auto-splits into switchback\n  flights with turn landings (`landing_depth`/`turn`/`flight_gap` tune the switchback).\n\nSo a stair connecting the ground floor **up** to the first floor lives on the **First\nFloor**, descending to the ground:\n\n```wdl\nfloor 2 "First Floor" height 116 {\n  slab at (\u2026) size (\u2026)\n  staircase name "Stair" at (212, 64) step (7, 11, 44)   // top = this floor, at the landing\n    direction south total_height 116                     // descends south to the floor below\n}\n```\n\nPut it on the *lower* floor (thinking of it as "climbing up") and it descends the wrong way\n\u2014 **below ground** \u2014 where it draws in 2D plans but is buried/invisible in 3D. `check.sh`\ncatches that (convention **C5**), but author it top-anchored from the start.\n\n// three ways to name the GLB, in order of preference:\nitem [name "N"] f."sofa"                                  // 1. from an imported module (see Imports)\nitem [name "N"] "sofa"                                    // 2. a same-file / bare-imported `asset` id\nitem [name "N"] asset { id "sofa" src "\u2026/sofa.glb" dims (w,h,d) [category "\u2026"] }  // 3. inline one-off\n  at (x,y) [rotation <deg>] [scale <s>]\n  [anchor_to "RoomName" anchor center gap (gx,gy)]\n```\n\nPrefer the module form (`item f."bed_double"`) \u2014 `import "std-furniture" as f`\nonce and every piece is a short id, no URLs. The bare form (`item "sofa"`) needs\na matching top-level `asset "sofa" \u2026` in the file (or a bare `import`). The inline\n`asset { \u2026 }` block is only for a one-off GLB not in any pack. All three produce\nthe identical `{id,src,dims}` downstream. Furniture `dims` are the real-world size\nin **metres** `(width, height, depth)`; `src` is a GLB URL (an unreachable GLB\nshows a placeholder box, never a blank). `anchor` is one of `top-left top-center\ntop-right center-left center center-right bottom-left bottom-center bottom-right`.\n\n**Orientation \u2014 this is how you point furniture the right way.** A piece\'s FRONT\n(the side you sit at / the doors / the open side) faces a known compass direction\nper its `rotation` (degrees):\n\n| `rotation` | front faces |\n|---|---|\n| `0`   | **South** (the plot front / entrance side, +Y) |\n| `90`  | East |\n| `180` | North |\n| `270` | West |\n\nSo a sofa against the NORTH wall (facing into the room, i.e. south) is `rotation\n0`; against the SOUTH wall (facing north) it\'s `rotation 180`; against the WEST\nwall (facing east) `rotation 90`. The floor plan (`wadi_preview plans`) draws a\nsmall triangle on each piece\'s front edge so you can verify the way it points;\nfor a definitive 3D check use `wadi_capture_3d({ room: "\u2026" })` (first-person from\ninside the room).\n\n## Imports & modules (reusable `.wdl` libraries)\n\nA `.wdl` file can be a **module** \u2014 top-level declarations (no `house` needed) \u2014\nthat another file `import`s. Two bundled ones: `std-furniture` (asset pack \u2192\n`item ns."id"`) and `konkan/base` (goal-tagged component pack \u2192 `use ns.Comp`;\nStairwell, Verandah, Otla, Bathroom, Kitchen, TulsiVrindavan, Parapet). The\n`konkan_cottage` example (`wadi_examples`) assembles a whole house from both.\n\n```wdl\nhouse Home {\n  import "std-furniture" as f       // aliased: refer to its assets as f."<id>"\n  // import "std-furniture"          // bare: its ids drop into scope for item "<id>"\n  floor 1 "G" slab_thickness 0 {\n    room Bed at (20,20) size (160,200) { wall north east south west\n      item f."bed_double" anchor center }\n  }\n}\n```\n\nA module file itself is just top-level `asset` (later: `component`) decls:\n\n```wdl\n// my-furniture.wdl \u2014 a house-less module (a reusable library)\nasset "daybed" src "https://\u2026/daybed.glb" dims (1.8, 0.4, 0.9) name "Daybed" category "Living"\n```\n\nOver MCP, `wadi_modules` lists importable modules and `wadi_module "<name>"`\nshows a module\'s asset ids + dimensions (filter with a `query`). Import refs\nresolve by name against the bundled `std-*` packs (a local `modules/` search\npath and git refs come later).\n\n## Objects \u2014 roof (one object; flat / shed / gable / hip)\n\nThe roof lives ALONE on its own top floor and you never set its Z (see\n`roof-v2-guide.md`). `endpoint`: `closed` = hip triangle, `open` = gable end-wall.\n\n```wdl\nroof [name "N"] pitched|shed|flat\n  [endpoint open|closed]\n  [slope angle <deg> | slope height <ridge_h>]\n  [overhang <o>] [slab_thickness <t>] [parapet <h> x <t>] [gable_wall_thickness <t>] {\n    segment "id" from (x,y) to (x,y) width <w>\n      [high_side left|right]                        // shed only\n      [start_endpoint open|closed] [end_endpoint open|closed]\n      [hip_setback (a,b)] [gable_overhang (a,b)] [hip_ridge_extension (a,b)]\n      [overhang <o>]                                // uniform eave, all four sides\n      [overhang_start <o>] [overhang_end <o>]       // per-side along the axis (shed;\n                                                    //   on a gable end = gable_overhang)\n      [overhang_low <o>] [overhang_high <o>]        // SHED eaves (down-slope / up-slope)\n      [overhang_left <o>] [overhang_right <o>]      // PITCHED eaves (left / right of ridge)\n      [tie_beams N]\n    truss "segId" fink|mono_pitch at (pos, pos, \u2026)\n  }\n```\n\nSegment `from`/`to`/`width` and the `hip_setback`/\u2026 values accept formulas, so a\nroof scales with the plot (e.g. `width House.W`, `hip_setback (Verandah.L, Padvi.L)`).\n\n**Per-side overhang (cantilever one edge).** `overhang <o>` sets a uniform eave on\nall four sides. Any sloping roof can override a side independently \u2014 each defaults to\n`overhang`. **Along the axis:** `overhang_start` / `overhang_end` (on a shed, or a\ngable open end \u2014 there they\'re the same as `gable_overhang`; a hip end is geometric,\ntuned via `hip_setback`). **Eaves:** `overhang_low` / `overhang_high` on a **shed**\n(down-slope / up-slope); `overhang_left` / `overhang_right` on a **pitched** roof\n(the two eaves either side of the ridge). A bigger eave overhang also drops that\neave\'s edge along the same pitch, so the slope stays planar. (Per-eave on a *pitched*\nroof is single-segment only \u2014 on a multi-segment roof the eaves share one height so\njoints line up.)\nIdiom: keep the roof FOOTPRINT (its supported edges) on the main room, then cantilever\none eave to cover an entry landing / stair \u2014 end the axis on the room wall and set a big\n`overhang_end`:\n```wdl\n// footprint ends on the main room\'s east wall (x204 centreline \u2192 x208 outer);\n// the east eave reaches 258, covering a landing that sticks out to x256.\nsegment "seg0" from (4,124) to (204,124) width 240 high_side right overhang 25 overhang_end 50\n```\n\n**Roof coordinates are wall centrelines (under `convention center`), same as\nrooms.** `from`/`to` is the segment\'s ridge/axis and `width` its span *centred on\nthat axis*. Author them on the **same centreline grid as the walls** \u2014 a segment\nwhose axis + width match the rooms\' centrelines auto-grows to the **outer wall\nface** on every side (the compiler extends the axis by \xBD\xB7wall_thickness at each end\nand widens by wall_thickness, exactly the grow a room gets). `overhang` then\nextends *beyond* the outer face. So to cover a footprint spanning wall centrelines\n`x1..x2` (E\u2013W) and `yA..yB` (N\u2013S), write `from (x1, (yA+yB)/2) to (x2, (yA+yB)/2)\nwidth (yB - yA)` \u2014 do **not** add \xBD-wall fudge factors; the convention handles it.\n(Before this, a roof drawn on the grid sat half a wall-thickness *inside* the walls.)\n\n## Components & layers\n\n```wdl\ncomponent Bench {                 // a reusable mini-house in LOCAL coords (origin 0,0)\n  param blen = 60 label "Bench length"\n  beam name "Top" at (0,0) size (blen, 18) height 6\n}\nuse Bench as "B1" at (x,y) with { blen = 80 }   // stamp it onto a floor\n\nlayer "structure" "Structure" [color "#rrggbb"] [group "Frame"]   // per-house layer registry\n```\n\nA component may carry a **`goal`** \u2014 a short description of what it accomplishes,\nthe discovery key for module lookup (`wadi_module` / a `wadi_modules` query):\n\n```wdl\ncomponent Stairwell goal "climb to the next floor" {\n  param rise = 116\n  staircase name "Stair" at (0,0) step (7,11,44) direction south total_height rise\n}\n```\n\nComponents can also come from an **imported module** (see *Imports & modules*),\nstamped with a namespaced `use ns.Comp`:\n\n```wdl\nhouse Home {\n  import "konkan/base" as kb        // Stairwell, Verandah, Otla (goal-tagged)\n  floor 1 "G" slab_thickness 0 {\n    room Hall at (20,20) size (200,200) { wall north east south west }\n    use kb.Stairwell at (60,60) with { rise = 116 }   // param args use `=`, not `:`\n  }\n}\n```\n\n`use ns.Comp` expands byte-identical to an inline `component`; keep module\ncomponents flat (they don\'t `use` other components). Un-overridden `param`s fall\nback to their declared defaults.\n\n## The `raw` escape (rarely needed)\n\nAnything the first-class syntax doesn\'t cover can be written as literal JSON per\nthe `.wadi` schema (`data-model.md`):\n\n```wdl\nraw "type" { "field": 1, "formulas": { "field": "= expr" } }\n```\n\n## DSL-specific pitfalls\n\n- **`convention center` and `units \u2026 per_unit 10`** belong at the top of every\n  `house` \u2014 same as the JSON path. All the `coordinate-system.md` rules (Y-down,\n  units, centreline abutment) apply identically; the DSL just writes them shorter.\n- **Formulas are bare expressions**, not `"= \u2026"` strings \u2014 the compiler emits the\n  `= \u2026` form for you. Write `at (main.x1, main.yA)`, not `at ("= main.x1", \u2026)`.\n- **`name "\u2026"` is quoted; `room`/`pillar`/`var`/grid-line names are bare** ids\n  (no spaces, and not a reserved word like `width`, `height`, `size`, `at`).\n- **Roof alone on the top floor**; segment widths/positions come from the walls\n  they sit on. See `roof-v2-guide.md`.\n- **A pillar\'s `at` is its TOP-LEFT corner, not its centre.** To centre a column on\n  `(cx,cy)`, author `at (cx - w/2, cy - l/2)`.\n- **Free-standing walls don\'t auto-mitre at corners** \u2014 extend endpoints so the wall\n  bodies overlap (\u2265 \xBD\xB7`wall_thickness` past the shared point), or the corner is left\n  as a gap.\n- **Staircases are top-anchored** \u2014 put them on the UPPER floor; they descend to the\n  floor below (`check.sh` C5 flags one that lands below ground). See the staircase note.\n- **Structural conventions are enforced** \u2014 `check.sh` fails on floating floors\n  (plinth-floor `height` \u2260 plinth block height; a no-slab floor with nonzero\n  `slab_thickness`) and warns on exterior room sides left open. See\n  `conventions.md`; the DSL editor shows the same findings in its status pill.\n- Compile after **every** edit; a parse error means the `.wadi` wasn\'t updated, so\n  the live model just won\'t change \u2014 never silently wrong.\n'
+    "body": '# The Wadi DSL (`.wdl`) \u2014 authoring reference\n\nYou author houses in the **Wadi DSL** \u2014 a small, formal language (`.wdl`) that\ncompiles to a resolved `.wadi` (`house_config.json`). The DSL is **complete**:\nevery object type in the model has first-class syntax, so you rarely need the\n`raw` escape. Authoring the DSL is more direct and less error-prone than writing\nJSON \u2014 the grammar enforces structure, and `check.sh` reports parse errors with\nline:col.\n\n**This file is the SYNTAX reference.** The *semantics* live in the other\nreferences and apply unchanged \u2014 read them:\n\n- `coordinate-system.md` \u2014 X\u2192right, **Y\u2192DOWN**, Z\u2192up; **10 units = 1 ft**;\n  the **centreline** convention. The #1 source of mistakes.\n- `conventions.md` \u2014 the **structural coding conventions** (`check.sh` enforces\n  them): plinth-floor height must match the plinth block, rooms must wall every\n  exterior side, a no-slab floor must set `slab_thickness 0`.\n- `parametric-conventions.md` \u2014 the grid-first recipe for reusable templates.\n- `roof-v2-guide.md` \u2014 roof segments, hip vs gable, trusses, joints.\n- `data-model.md` \u2014 the underlying `.wadi` schema (what the DSL compiles to; also\n  the field reference for the `raw` escape).\n\n## The loop\n\n1. Write / edit `house.wdl` \u2014 the **single shared source** (you and the human\n   co-edit it; the app\'s DSL previewer renders it live). You never produce a `.wadi`.\n2. `wadi-skill/architect/scripts/check.sh house.wdl` \u2014 runs the DSL compiler +\n   validator (schema + wall/roof geometry) against a **throwaway temp** just for\n   feedback; fix any reported error and re-run.\n3. `preview.sh house.wdl` \u2192 read the PNGs (plans / elevations / roof) to check your\n   work. (It also compiles to a throwaway temp \u2014 no persistent `.wadi`.)\n\n## Skeleton\n\n```wdl\nhouse MyHouse {\n  convention center                 // ALWAYS use center (wall-centreline coords)\n  units feet_inches per_unit 10     // 10 project units = 1 ft\n  site { plot (WIDTH, LENGTH) ref (0, 0) }\n  defaults { floor_height 120 wall_height 108 slab_thickness 8 wall_thickness 8 }\n\n  // parametric core (optional): var, point, grid, configurator\n  // component / layer declarations (optional)\n  floor 0 "Plinth" { \u2026 }            // floors stack in source order (0 = plinth)\n  floor 1 "Ground Floor" { \u2026 }\n  floor 2 "Loft" { roof \u2026 }         // roof lives ALONE on its own top floor\n}\n```\n\nNumbers are **project units** (feet \xD7 10 by default). Names after `house`,\n`room`, `pillar`, `var`, `point`, `grid`, and `use`/`component` are bare\nidentifiers (no spaces); names introduced with the `name` keyword are quoted\nstrings.\n\n## Parametric core (domain-neutral)\n\n```wdl\nvar wallT = 8                       // a knob; may reference other vars\nvar pilInset = (pillarW - wallT) / 2\n\npoint House { x = 420, y = 470 }    // reference as House.x / House.W / House.L\n                                    // (.W = x, .L = y \u2014 a point doubles as a size)\n\ngrid main {                         // named wall centrelines; publishes main.x1 / main.yA\n  x: 1 @ wallT / 2, 2 @ House.W / 2, 3 @ House.W - wallT / 2\n  y: A @ wallT / 2, B @ House.L / 2, C @ House.L - wallT / 2\n}\n// each line may add:  \u2026 @ <expr> thick <expr>  role structural|planning\n\nconfigurator {                      // the knobs a downstream user turns\n  slider pillarW    "Column size" ft [8 .. 14 step 1]\n  number ceiling    "Ceiling height" ft\n  toggle has_loft   "Add a loft"\n  select roof_style "Roof style" { Flat = 0, Shed = 1, Gable = 2, Hip = 3 }\n}\n```\n\n**Formulas are automatic.** Any geometry number can be a formula \u2014 just write the\nexpression instead of a literal (`at (main.x1, main.yA)`, `size (House.W/2, 200)`).\nOperators: `+ - * /`, unary `-`, parentheses, and the functions\n`min max clamp round floor ceil abs`. References: a `var`, a `point`\n(`House.W`), or a grid line (`main.x3 - main.x1`). No comparison operators \u2014 gate\nthings with the `min/abs` idiom (see `enabled` below).\n\n## Common attribute tail (every object)\n\nAfter an object\'s geometry, in THIS order, any of:\n\n```\n\u2026 z_offset <expr>   enabled <expr>   layer "id"   [material "id"]\n```\n\n- `enabled <expr>` \u2014 the on/off switch. A `0`/`false` value hides the object. To\n  gate on a configurator variable, use a 0/1 formula:\n  `enabled 1 - min(1, abs(roof_style - 3))` renders the object only when\n  `roof_style == 3`. (This is how one template carries several roofs and shows\n  only the chosen one.)\n- `z_offset <expr>` \u2014 lift above the floor base (split levels).\n- `material "id"` \u2014 only on plinth / ground / room / wall / staircase / kitchen /\n  roof.\n\n## Objects \u2014 structure & envelope\n\n```wdl\nslab   [name "N"] at (x,y) size (w,l) [thickness <t>]     // floor_slab\nbeam   [name "N"] at (x,y) size (w,l) [height <h>]\nplinth [name "N"] at (x,y) size (w,l) height <h>          // raised base (Plinth floor)\nground [name "N"] at (x,y) size (w,l) [height <h>]        // terrain plane\npillar Name       at (x,y) size (w,l) [height <h>]        // (x,y) = TOP-LEFT corner\n```\n\n`at (x,y)` is the **TOP-LEFT CORNER** \u2014 **not the centre** \u2014 for every one of these\n(same as rooms/slabs/beams); `size (w,l)` is width \xD7 length. All accept the common tail.\n\n**Pillars catch people out here.** A column reads as "placed at a point," but `at` is\nstill its corner. To **centre a column on a point** `(cx, cy)` \u2014 a grid node, a room\ncorner \u2014 place it at **`at (cx - w/2, cy - l/2)`**, never at `(cx, cy)`. On a grid, the\n`pilInset` idiom (see `parametric-conventions.md`) does exactly this so columns sit flush.\n\n## Objects \u2014 rooms, walls & openings\n\nA room shows exactly the walls you declare. A **bare room (no `wall` lines) is\nenclosed on all four sides.** List plain walls compactly; give a wall its own line\nonly when it carries a door/window; omit a side to leave it open (verandah).\n\n```wdl\nroom Name at (x,y) size (w,l) [height <h>] [material "\u2026"] {\n  wall east west north                 // plain walls \u2014 several in one statement\n  wall south { door Main at <offset> size (w,h) [open] }   // wall WITH openings: one side\n  wall west  { window W at <offset> size (w,h) [sill <s>] [open] }\n  item asset { \u2026 } anchor center [gap (gx,gy)]   // furniture anchored inside the room\n}\n```\n\n- `wall <side>\u2026` sides are `north|south|east|west`. A `wall <side>` line may also\n  add `height <h>` / `height_end <h>` (sloped).\n- `door`/`window` `at <offset>` is measured along the wall from its start;\n  `size (width, height)`; `window \u2026 sill <s>` sets the sill height; `open` = a bare\n  hole (no leaf/glazing).\n\nA **free-standing wall** (not a room side):\n\n```wdl\nwall Name from (x1,y1) to (x2,y2) [height <h>] [height_end <h>] [facing north|\u2026] {\n  \u2026 door/window openings \u2026\n}\n```\n\n- `from`/`to` are the wall\'s **centreline** endpoints; the wall is drawn as a rectangle\n  `wall_thickness` wide, centred on that line.\n- **Overlap walls at corners \u2014 they do NOT auto-mitre.** Two free-standing walls that\n  merely *touch* at a shared endpoint leave an unfilled square notch (\xBD\xB7`wall_thickness`)\n  at the corner, because each is just a rectangle capped at its endpoint. To fill the\n  corner, **extend the endpoints so the wall bodies OVERLAP** \u2014 run at least one wall\'s\n  end **half the wall thickness past** the shared point (overlapping by the full thickness\n  is fine and simplest). For an L of thickness 8 meeting at `(160,40)`:\n\n  ```wdl\n  wall H from (40, 40)  to (164, 40)  height 108   // ends 4 (\xBD\xB78) PAST the corner\n  wall V from (160, 40) to (160, 160) height 108    // butts into H\'s overlapped body\n  ```\n\n  (Room walls handle their own corners; this only applies to `wall \u2026 from \u2026 to \u2026`.)\n\n## Objects \u2014 circulation & fittings\n\n```wdl\nstaircase [name "N"] at (start_x, start_y) step (rise, tread, width)\n  direction north|south|east|west\n  [total_height <h>] [max_run <r>] [landing_depth <d>]\n  [landing_thickness <t>] [turn clockwise|anticlockwise] [flight_gap <g>]\n\nkitchen [name "N"] path ((x,y), (x,y), \u2026) side left|right\n  depth <d> height <h> [base_z <z>]        // path points are literal numbers\n```\n\n**Staircases are TOP-anchored \u2014 this is the #1 mistake.** You put a staircase on the\n**UPPER** floor and it **DESCENDS** to the floor below:\n\n- `at (x,y)` is the **TOP** of the stair (where it meets the floor it\'s declared on).\n- `direction` is the **descent** direction (the way it travels going *down*).\n- `total_height` is the **drop** to the floor below (omit \u2192 the floor-below\'s height).\n- `max_run` caps a flight\'s run; exceed it and the stair auto-splits into switchback\n  flights with turn landings (`landing_depth`/`turn`/`flight_gap` tune the switchback).\n\nSo a stair connecting the ground floor **up** to the first floor lives on the **First\nFloor**, descending to the ground:\n\n```wdl\nfloor 2 "First Floor" height 116 {\n  slab at (\u2026) size (\u2026)\n  staircase name "Stair" at (212, 64) step (7, 11, 44)   // top = this floor, at the landing\n    direction south total_height 116                     // descends south to the floor below\n}\n```\n\nPut it on the *lower* floor (thinking of it as "climbing up") and it descends the wrong way\n\u2014 **below ground** \u2014 where it draws in 2D plans but is buried/invisible in 3D. `check.sh`\ncatches that (convention **C5**), but author it top-anchored from the start.\n\n// three ways to name the GLB, in order of preference:\nitem [name "N"] f."sofa"                                  // 1. from an imported module (see Imports)\nitem [name "N"] "sofa"                                    // 2. a same-file / bare-imported `asset` id\nitem [name "N"] asset { id "sofa" src "\u2026/sofa.glb" dims (w,h,d) [category "\u2026"] }  // 3. inline one-off\n  at (x,y) [rotation <deg>] [scale <s>]\n  [anchor_to "RoomName" anchor center gap (gx,gy)]\n```\n\nPrefer the module form (`item f."bed_double"`) \u2014 `import "std-furniture" as f`\nonce and every piece is a short id, no URLs. The bare form (`item "sofa"`) needs\na matching top-level `asset "sofa" \u2026` in the file (or a bare `import`). The inline\n`asset { \u2026 }` block is only for a one-off GLB not in any pack. All three produce\nthe identical `{id,src,dims}` downstream. Furniture `dims` are the real-world size\nin **metres** `(width, height, depth)`; `src` is a GLB URL (an unreachable GLB\nshows a placeholder box, never a blank). `anchor` is one of `top-left top-center\ntop-right center-left center center-right bottom-left bottom-center bottom-right`.\n\n**Orientation \u2014 this is how you point furniture the right way.** A piece\'s FRONT\n(the side you sit at / the doors / the open side) faces a known compass direction\nper its `rotation` (degrees):\n\n| `rotation` | front faces |\n|---|---|\n| `0`   | **South** (the plot front / entrance side, +Y) |\n| `90`  | East |\n| `180` | North |\n| `270` | West |\n\nSo a sofa against the NORTH wall (facing into the room, i.e. south) is `rotation\n0`; against the SOUTH wall (facing north) it\'s `rotation 180`; against the WEST\nwall (facing east) `rotation 90`. The floor plan (`wadi_preview plans`) draws a\nsmall triangle on each piece\'s front edge so you can verify the way it points;\nfor a definitive 3D check use `wadi_capture_3d({ room: "\u2026" })` (first-person from\ninside the room).\n\n**Anchoring auto-orients.** When you `anchor` a piece to a wall and DON\'T give a\n`rotation`, it automatically faces away from that wall, into the room \u2014 `anchor\ntop-center` \u2192 faces south, `bottom-center` \u2192 north, `center-left` \u2192 east,\n`center-right` \u2192 west (a corner uses its north/south edge). So `item f."bed_double"\nanchor top-center` needs no rotation. An explicit `rotation` always overrides,\nand the derived value is written into the resolved model, so the plan notch and\nthe 3D view show it \u2014 anchoring never changes facing silently.\n\n## Imports & modules (reusable `.wdl` libraries)\n\nA `.wdl` file can be a **module** \u2014 top-level declarations (no `house` needed) \u2014\nthat another file `import`s. Two bundled ones: `std-furniture` (asset pack \u2192\n`item ns."id"`) and `konkan/base` (goal-tagged component pack \u2192 `use ns.Comp`;\nStairwell, Verandah, Otla, Bathroom, Kitchen, TulsiVrindavan, Parapet). The\n`konkan_cottage` example (`wadi_examples`) assembles a whole house from both.\n\n```wdl\nhouse Home {\n  import "std-furniture" as f       // aliased: refer to its assets as f."<id>"\n  // import "std-furniture"          // bare: its ids drop into scope for item "<id>"\n  floor 1 "G" slab_thickness 0 {\n    room Bed at (20,20) size (160,200) { wall north east south west\n      item f."bed_double" anchor center }\n  }\n}\n```\n\nA module file itself is just top-level `asset` (later: `component`) decls:\n\n```wdl\n// my-furniture.wdl \u2014 a house-less module (a reusable library)\nasset "daybed" src "https://\u2026/daybed.glb" dims (1.8, 0.4, 0.9) name "Daybed" category "Living"\n```\n\nOver MCP, `wadi_modules` lists importable modules and `wadi_module "<name>"`\nshows a module\'s asset ids + dimensions (filter with a `query`). Import refs\nresolve by name against the bundled `std-*` packs (a local `modules/` search\npath and git refs come later).\n\n## Objects \u2014 roof (one object; flat / shed / gable / hip)\n\nThe roof lives ALONE on its own top floor and you never set its Z (see\n`roof-v2-guide.md`). `endpoint`: `closed` = hip triangle, `open` = gable end-wall.\n\n```wdl\nroof [name "N"] pitched|shed|flat\n  [endpoint open|closed]\n  [slope angle <deg> | slope height <ridge_h>]\n  [overhang <o>] [slab_thickness <t>] [parapet <h> x <t>] [gable_wall_thickness <t>] {\n    segment "id" from (x,y) to (x,y) width <w>\n      [high_side left|right]                        // shed only\n      [start_endpoint open|closed] [end_endpoint open|closed]\n      [hip_setback (a,b)] [gable_overhang (a,b)] [hip_ridge_extension (a,b)]\n      [overhang <o>]                                // uniform eave, all four sides\n      [overhang_start <o>] [overhang_end <o>]       // per-side along the axis (shed;\n                                                    //   on a gable end = gable_overhang)\n      [overhang_low <o>] [overhang_high <o>]        // SHED eaves (down-slope / up-slope)\n      [overhang_left <o>] [overhang_right <o>]      // PITCHED eaves (left / right of ridge)\n      [tie_beams N]\n    truss "segId" fink|mono_pitch at (pos, pos, \u2026)\n  }\n```\n\nSegment `from`/`to`/`width` and the `hip_setback`/\u2026 values accept formulas, so a\nroof scales with the plot (e.g. `width House.W`, `hip_setback (Verandah.L, Padvi.L)`).\n\n**Per-side overhang (cantilever one edge).** `overhang <o>` sets a uniform eave on\nall four sides. Any sloping roof can override a side independently \u2014 each defaults to\n`overhang`. **Along the axis:** `overhang_start` / `overhang_end` (on a shed, or a\ngable open end \u2014 there they\'re the same as `gable_overhang`; a hip end is geometric,\ntuned via `hip_setback`). **Eaves:** `overhang_low` / `overhang_high` on a **shed**\n(down-slope / up-slope); `overhang_left` / `overhang_right` on a **pitched** roof\n(the two eaves either side of the ridge). A bigger eave overhang also drops that\neave\'s edge along the same pitch, so the slope stays planar. (Per-eave on a *pitched*\nroof is single-segment only \u2014 on a multi-segment roof the eaves share one height so\njoints line up.)\nIdiom: keep the roof FOOTPRINT (its supported edges) on the main room, then cantilever\none eave to cover an entry landing / stair \u2014 end the axis on the room wall and set a big\n`overhang_end`:\n```wdl\n// footprint ends on the main room\'s east wall (x204 centreline \u2192 x208 outer);\n// the east eave reaches 258, covering a landing that sticks out to x256.\nsegment "seg0" from (4,124) to (204,124) width 240 high_side right overhang 25 overhang_end 50\n```\n\n**Roof coordinates are wall centrelines (under `convention center`), same as\nrooms.** `from`/`to` is the segment\'s ridge/axis and `width` its span *centred on\nthat axis*. Author them on the **same centreline grid as the walls** \u2014 a segment\nwhose axis + width match the rooms\' centrelines auto-grows to the **outer wall\nface** on every side (the compiler extends the axis by \xBD\xB7wall_thickness at each end\nand widens by wall_thickness, exactly the grow a room gets). `overhang` then\nextends *beyond* the outer face. So to cover a footprint spanning wall centrelines\n`x1..x2` (E\u2013W) and `yA..yB` (N\u2013S), write `from (x1, (yA+yB)/2) to (x2, (yA+yB)/2)\nwidth (yB - yA)` \u2014 do **not** add \xBD-wall fudge factors; the convention handles it.\n(Before this, a roof drawn on the grid sat half a wall-thickness *inside* the walls.)\n\n## Components & layers\n\n```wdl\ncomponent Bench {                 // a reusable mini-house in LOCAL coords (origin 0,0)\n  param blen = 60 label "Bench length"\n  beam name "Top" at (0,0) size (blen, 18) height 6\n}\nuse Bench as "B1" at (x,y) with { blen = 80 }   // stamp it onto a floor\n\nlayer "structure" "Structure" [color "#rrggbb"] [group "Frame"]   // per-house layer registry\n```\n\nA component may carry a **`goal`** \u2014 a short description of what it accomplishes,\nthe discovery key for module lookup (`wadi_module` / a `wadi_modules` query):\n\n```wdl\ncomponent Stairwell goal "climb to the next floor" {\n  param rise = 116\n  staircase name "Stair" at (0,0) step (7,11,44) direction south total_height rise\n}\n```\n\nComponents can also come from an **imported module** (see *Imports & modules*),\nstamped with a namespaced `use ns.Comp`:\n\n```wdl\nhouse Home {\n  import "konkan/base" as kb        // Stairwell, Verandah, Otla (goal-tagged)\n  floor 1 "G" slab_thickness 0 {\n    room Hall at (20,20) size (200,200) { wall north east south west }\n    use kb.Stairwell at (60,60) with { rise = 116 }   // param args use `=`, not `:`\n  }\n}\n```\n\n`use ns.Comp` expands byte-identical to an inline `component`; keep module\ncomponents flat (they don\'t `use` other components). Un-overridden `param`s fall\nback to their declared defaults.\n\n## The `raw` escape (rarely needed)\n\nAnything the first-class syntax doesn\'t cover can be written as literal JSON per\nthe `.wadi` schema (`data-model.md`):\n\n```wdl\nraw "type" { "field": 1, "formulas": { "field": "= expr" } }\n```\n\n## DSL-specific pitfalls\n\n- **`convention center` and `units \u2026 per_unit 10`** belong at the top of every\n  `house` \u2014 same as the JSON path. All the `coordinate-system.md` rules (Y-down,\n  units, centreline abutment) apply identically; the DSL just writes them shorter.\n- **Formulas are bare expressions**, not `"= \u2026"` strings \u2014 the compiler emits the\n  `= \u2026` form for you. Write `at (main.x1, main.yA)`, not `at ("= main.x1", \u2026)`.\n- **`name "\u2026"` is quoted; `room`/`pillar`/`var`/grid-line names are bare** ids\n  (no spaces, and not a reserved word like `width`, `height`, `size`, `at`).\n- **Roof alone on the top floor**; segment widths/positions come from the walls\n  they sit on. See `roof-v2-guide.md`.\n- **A pillar\'s `at` is its TOP-LEFT corner, not its centre.** To centre a column on\n  `(cx,cy)`, author `at (cx - w/2, cy - l/2)`.\n- **Free-standing walls don\'t auto-mitre at corners** \u2014 extend endpoints so the wall\n  bodies overlap (\u2265 \xBD\xB7`wall_thickness` past the shared point), or the corner is left\n  as a gap.\n- **Staircases are top-anchored** \u2014 put them on the UPPER floor; they descend to the\n  floor below (`check.sh` C5 flags one that lands below ground). See the staircase note.\n- **Structural conventions are enforced** \u2014 `check.sh` fails on floating floors\n  (plinth-floor `height` \u2260 plinth block height; a no-slab floor with nonzero\n  `slab_thickness`) and warns on exterior room sides left open. See\n  `conventions.md`; the DSL editor shows the same findings in its status pill.\n- Compile after **every** edit; a parse error means the `.wadi` wasn\'t updated, so\n  the live model just won\'t change \u2014 never silently wrong.\n'
   },
   "conventions": {
     "title": "Structural coding conventions (C1/C2/C3\u2026)",
@@ -418430,7 +418440,7 @@ server.registerTool(
       }
       lines.push(`  e.g. \`item ns."${assets[0].id}" at (x, y)\` or in a room \`item ns."${assets[0].id}" anchor center\``);
       lines.push(
-        `  Orientation: a piece's front faces SOUTH at rotation 0 (90=East, 180=North, 270=West) \u2014 e.g. a sofa on the north wall faces south = rotation 0, on the south wall = rotation 180. wadi_preview plans draws a front-notch; wadi_capture_3d({room}) shows it from inside.`
+        `  Orientation: a piece's front faces SOUTH at rotation 0 (90=East, 180=North, 270=West). ANCHORING auto-orients \u2014 an anchored piece with no rotation faces into the room (anchor top-center\u2192south, bottom-center\u2192north, center-left\u2192east, center-right\u2192west); an explicit rotation overrides. wadi_preview plans draws a front-notch; wadi_capture_3d({room}) shows it from inside.`
       );
     }
     return { content: [{ type: "text", text: lines.join("\n") }] };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wadi-mcp",
-  "version": "0.1.10",
+  "version": "0.1.11",
   "description": "MCP server for the Wadi house designer — check, preview, and reference the Wadi DSL (.wdl) without the repo.",
   "type": "module",
   "license": "MIT",