` (main-axis extent) plus either a strip `height`/`width` or its own `size

x`. ```arch static strip right at (0,0) gap 100 { room size } # error: no extent ``` ## E_TYPE *error* — Type mismatch. **Cause.** A value was used where another type was required (e.g. a string where a number is expected, or a non-array in `for`). **Fix.** Convert or supply the expected type. ```arch static room at (0,0) size "big" x 10 # error: size needs numbers ``` ## E_UNKNOWN_COMPONENT *error* — Unknown component. **Cause.** An instance calls a component name that is not defined or imported. **Fix.** Define the component, import it, or fix the name (see the suggestion hint). ```arch static sofa(0, 0) # error if no `component sofa` is in scope ``` ## E_UNKNOWN_FN *error* — Unknown function. **Cause.** A call uses a name that is neither a built-in nor a value-function in scope. **Fix.** Define it with `let f(…) = …`, or fix the name. ```arch static let x = frobnicate(2) # error ``` ## E_UNKNOWN_REF *error* — Unknown reference. **Cause.** An expression references a name that is not bound in scope. **Fix.** Declare it with `let`, pass it as a parameter, or fix the typo. ```arch static let x = y + 1 # error if `y` is undefined ``` ## E_VERT_SIZE *error* — Vertical circulation must have a positive size. **Cause.** A `stair`, `elevator` or `escalator` footprint's width or height evaluated to zero or a negative number, so there is no run to draw. **Fix.** Give it a positive `size W x H` — the footprint the run occupies on this storey. ```arch static stair id=s at (0,0) size 900x0 dir up # error: zero depth ``` ## E_VOID_SIZE *error* — A floor void must have a positive size. **Cause.** A `void`'s width or height evaluated to zero or a negative number, so there is no opening in the floor plate to draw or to route circulation around. **Fix.** Give it a positive `size W x H` — the hole's extent in plan. ```arch static void id=well at (2000,1000) size 0x3000 # error: zero width ``` ## E_WALL_THICKNESS *error* — Wall must have a positive thickness. **Cause.** A wall's `thickness` evaluated to zero or a negative number. **Fix.** Give the wall a positive `thickness`. ```arch static wall exterior thickness 0 { (0,0) (1,0) } # error ``` ## E_WHILE_LIMIT *error* — `while` exceeded its iteration cap. **Cause.** A `while` ran more times than the safety cap allows (usually a condition that never becomes false). **Fix.** Ensure the loop body updates a binding so the condition eventually fails. ```arch static let i = 0 while i < 1 { column at (0,0) size 1x1 } # error: i never changes ``` ## E_WINDOW_WIDTH *error* — Window must have a positive width. **Cause.** A window's width evaluated to zero or a negative number. **Fix.** Give the window a positive `width`. ```arch static window at (0,0) width 0 # error ``` ## W_ALIAS_MATCH *warning* — A room's use was inferred from an indirect alias, not stated. **Cause.** A room has no authored `uses`, and its function was guessed from its label via a non-canonical alias (an indirect term like `powder` → WC, `foyer` → entry) rather than a direct word (`wc`, `entrance`). The guess is reasonable but the intent is implicit, so a reader (or agent) cannot tell the classification was assumed. **Fix.** Add an explicit `uses …` to the room stating the inferred function — the machine-applicable fix inserts it for you. This pins the classification without changing the room's `describe()` type. ```arch static room at (0,0) size 2000x1500 label "Powder" # warning: WC inferred from the alias "powder"; add `uses wc` ``` ## W_BALCONY_NO_DOOR *warning* — A balcony with no way onto it. **Cause.** An `outdoor balcony` has no `door` and no `window` within one wall thickness of any of its edges, so the drawing shows a slab that cannot be reached. A window counts as well as a door, because a full-height window is a normal way onto a balcony. **Fix.** Add a door (or a full-height window) on the wall the balcony hangs off — the usual fix — or move the balcony to the facade that already has one. ```arch static outdoor balcony at (2000,7200) size 4000x1600 # warning: no opening within reach ``` ## W_BATH_VIA_BEDROOM *warning* — Bathroom is reachable only through a bedroom. **Cause.** Every door path from the entrance to this bathroom/WC passes through a bedroom. That is fine for a private en-suite, but a dwelling's main bathroom should open off circulation (a hall or living space), not a bedroom. **Fix.** Add a door connecting the bathroom to a hall/living space, or route circulation so it is not reached only via a bedroom. ```arch static door id=d_bath at (5200,4000) width 800 wall partition # lint: bath only off the bedroom ``` ## W_BEDROOM_NO_WINDOW *warning* — Bedroom has no window. **Cause.** A room labelled as a bedroom has no window on its perimeter (natural light / egress). **Fix.** Add a `window` on an exterior wall of the room. ```arch static room at (0,0) size 3000x4000 label "Bedroom" # lint: no window ``` ## W_CIRCUITOUS_PATH *warning* — A room is reached by a very roundabout path. **Cause.** The walking distance from the entrance to a room is many times its straight-line distance — the room is reachable but only by a circuitous route (e.g. all the way around the plan). A coarse circulation fact (ADR 0008); the default ratio is generous so a normal tucked-away room does not trip it. **Fix.** Add a more direct connection — a door or a hall — so the room is not reached the long way round. ```arch static room id=bed at (0,0) size 3000x3000 label "Bed" # only door is on the far side, forcing a long detour ``` ## W_DIM_INSIDE *warning* — A hand-written dimension line lands inside the building. **Cause.** A `dim`'s line is drawn at `offset` along the LEFT normal of from→to, so the ENDPOINT ORDER chooses which side it lands on. This dimension's line (not its witness lines) falls inside the room-extents bounding box, where it crosses room labels, furniture and poché instead of reading in the page margin. Almost always the endpoints are simply the wrong way round. Advisory: an interior dimension you actually want (a clear width inside a room) is legitimate — reverse it or leave the warning. **Fix.** Swap the two endpoints — the machine-applicable fix does it for you, but only when the swap actually moves the line out. Swapping mirrors the line across the segment being measured (negating the `offset` does the same thing), so it reaches the outside only when that segment is at the building's edge. A dimension whose measured run cuts THROUGH the plan reads inside either way and carries no automatic fix: measure along a facade instead, or raise the `offset` until the line clears the building. ```arch static dim (0,6000)->(7000,6000) offset -500 text "7000" # warning: the -500 offset pulls the line back inside ``` ## W_DIM_NO_WALL *warning* — A `dim faces`/`dim clear` endpoint has no wall to measure to. **Cause.** The endpoint-projection forms push each endpoint onto the FACE of the wall the measurement runs into, found as the nearest wall segment perpendicular to the dimension's own direction. One (or both) endpoints has no such wall within tolerance — the point is off the wall centerline, the wall is angled, or the plan has no wall there — so there is no face to project onto and the written point is measured as-is. **Fix.** Put the endpoint on the centerline of the wall the dimension runs into (the room-rectangle corner coordinate), or drop the `faces`/`clear` keyword and write the face coordinate yourself. ```arch static wall exterior thickness 200 { (0,0) (5000,0) (5000,4000) (0,4000) close } dim faces (0,9000)->(5000,9000) offset 600 # warning: nothing to project onto at y9000 ``` ## W_DIM_OVERLAP *warning* — Two hand-written dimensions are drawn on top of each other. **Cause.** Two `dim` statements measuring PARALLEL runs land in the same chain tier: their drawn bands — the dimension line, its station ticks, and the length text riding above the line — intersect, so on paper one reads through the other. ArchLang never re-staggers a hand-written dimension (the author's `offset` IS the tier control — ADR 0005, no invisible architect), so the collision is reported rather than silently laid out. Adjacent members of one chain that merely SHARE a station tick are not a collision and never warn, and two dims generated by one `for` are skipped — they share an `offset` expression, so no bump could separate them. **Fix.** Move one of them out a tier: raise the magnitude of its `offset` (keeping its sign, which is the side it reads on). The machine-applicable fix computes the smallest whole number of chain tiers that clears the other dimension's line and text. ```arch static dim (0,-100)->(7000,-100) offset -300 text "7000" dim (0,-100)->(4000,-100) offset -300 text "4000" # warning: both in the same tier ``` ## W_DOOR_CLEARANCE *warning* — Door is narrower than the minimum clear width. **Cause.** A door's width is below the configured minimum passable width (default 700 mm). **Fix.** Widen the door to at least the minimum clear width. ```arch static door at (0,0) width 500 wall exterior # lint: under 700 mm ``` ## W_DOOR_NEAR_CORNER *warning* — A door leaves less wall between its jamb and a corner than the wall is thick. **Cause.** The nib of wall between a door's jamb and the corner its host wall turns at is shorter, along the run, than the wall is thick across it. **The drawing is correct** — the nib IS drawn, and mitred into the neighbouring run — so this is a fact about the plan, not a rendering fault; it was first mis-diagnosed as one during the v1.30 joinery review before it was measured. At page scale such a sliver stops reading as wall continuing to the corner and reads as a chamfer on the corner, and its returned face has nowhere to carry the frame and architrave a jamb is fixed to. The warning states the nib required, the nib measured, and the shortfall. **The threshold is the wall's own thickness** (× `minCornerNibRatio` in the lint ruleset, default 1.0): it is the only length in the drawing intrinsic to the wall being measured, so the rule needs no new absolute constant and scales by itself — a 100 mm partition asks for 100 mm, a 400 mm shell for 400 — and it is the dimension the defect is about. Unlike `W_POCKET_RUN` the threshold is one-limbed, because both sides of the comparison belong to the same wall and there is no narrow-door pathology to guard against. **What counts as a corner:** the host segment's run must END at that point and the wall must go somewhere else from it, so a wall's free end, a redundant collinear vertex, a partition teeing into a wall that carries straight past it, and a TANGENT arc/straight hand-over are all excluded — nothing is mitred at any of them. **On a curve the nib is an arc length, not a chord**, measured at the wall's centreline radius from the radial jambs, in closed form (nothing tessellates, so the number cannot move with a facet count). Kind-independent: a jamb is a jamb whether the leaf swings, slides, folds or parks overhead. Scoped to doors deliberately — a window nib is a different detail with no frame to hang. **Fix.** Move the door further from the corner by the shortfall the warning quotes (`on at ` measures along the run, so the position is the one number to change), or lengthen the wall past the door so the corner moves away from the jamb instead. There is no machine-applicable fix: every remedy rewrites a number the author chose. Narrowing the leaf would also close the gap and is deliberately NOT offered — rewriting the width you asked for to satisfy a checker is the constraint-laundering pattern this project rules out, and it heads toward `W_DOOR_CLEARANCE`. ```arch static wall w1 thickness 250 { (0,0) (5000,0) (5000,4000) } door on w1 at 4400 width 900 # lint: a 150 mm nib on a 250 mm wall ``` ## W_DOOR_OFF_WALL *warning* — Door does not lie on any wall. **Cause.** A door's position is not within tolerance of any wall segment, so it has no host. **Fix.** Move the door onto a wall, or name its host with `wall `. The diagnostic points at the nearest wall. ```arch static door at (9999,9999) width 900 # warning: not on a wall ``` ## W_DOORWAY_BLOCKED *warning* — A doorway's landing is blocked. **Cause.** A piece of furniture/fixture sits in the clear landing space immediately on either side of a door opening, so you cannot pass through the doorway even when the leaf is open. This is the approach path, distinct from the leaf's swing arc (`W_SWING_OBSTRUCTED`). The warning states the landing depth required, the depth actually left, and the shortfall. **Fix.** Move the obstruction clear of the opening by the shortfall the warning quotes (`arch repair` computes the smallest clearing shift), shrink it by that much on the axis facing the door, or move the door along its wall so its landing misses it. ```arch static door at (6000,3000) width 800 furniture wc at (5800,3050) size 700x400 # lint: WC blocks the doorway ``` ## W_DRAWING_OVERFLOW *warning* — The whole drawing does not fit the declared paper, even though the building does. **Cause.** Same ruler as `W_SCALE_OVERFLOW`, different subject. That rule measures the BUILDING's outer-face extent against the sheet minus its margins, dimension bands, title block and margin tables. This one measures **everything the plan draws** against that same area — and a plan draws more than its building: `outdoor` ground, a `fence`, a `site … boundary`, a `roof` eaves line, a fixture set down outside the shell. None of that is in the building's extent, so none of it can make the fit test say no, and `sheet.fits` stays `true` while the sheet cannot hold the drawing. The two are mutually exclusive by design: the drawn extent CONTAINS the building, so when the building itself overflows you get `W_SCALE_OVERFLOW` instead and this would only repeat it. The warning quotes the whole drawing's extent, the drawing area it is measured against, and the overflow on each axis — a millimetre of eaves and a 40 m yard want different answers. **It does not claim the page grows:** nothing is clipped, the reserved sheet margin gives way first, and only a large overrun pushes the page past the paper. `describe().sheet.drawing_fits` is this fact; `scene.sheet.page` is the page that actually came out. Advisory: a site plan you intend to issue oversize, trim or tile is legitimate. **Fix.** Move up a paper size or pick a coarser scale — both also shrink the building, so check the drawing still reads — or draw less ground. There is deliberately NO machine fix: every remedy rewrites a decision the author made, and unlike a building overflow there is no defensible default, since re-scaling shrinks a building that was already sized correctly for the sheet (ADR 0005). ```arch static paper A4 portrait scale 1:100 outdoor lawn at (0,3500) size 4000x40000 label "Yard" # warning on a 4 m cottage: the yard is 40 m long ``` ## W_DUP_ACC_METADATA *warning* — Duplicate `accTitle`/`accDescr`. **Cause.** A plan declares `accTitle` (or `accDescr`) more than once. Only one of each applies, so the last value silently wins. **Fix.** Keep a single `accTitle` and a single `accDescr`; delete the extra line(s). ```arch static accTitle "A" accTitle "B" # warning: "A" is discarded ``` ## W_EMPTY_PLAN *warning* — Empty plan. **Cause.** The plan resolved to no drawable elements. **Fix.** Add at least one element (wall, room, …). ```arch static plan "Empty" { units mm } # warning ``` ## W_FIXTURE_BACK_TO_ROOM *warning* — A fixture stands against a wall but faces the wrong way. **Cause.** A fixture whose symbol has a distinct back — a plumbed one (a WC's cistern, a basin's tap, a counter's nosing) or a piece of furniture that simply has a front (a bed's headboard, a wardrobe's door line, a bookshelf's open face) — is touching a wall, but its back is turned to the room instead of to that wall: the drawing shows the WC's tank, or the headboard, sticking into the floor space. Position right, quarter-turn wrong: fixture symbols are drawn with their back on the TOP edge, so `rotate` is what aims them (0 = back to the north, 90 = east, 180 = south, 270 = west). A rotation-symmetric symbol (a shower tray, a round stool) never trips this, nor does arranged seating whose back to the room is a legitimate layout. A fixture that touches no wall at all is `W_FIXTURE_FLOATING` instead — and only where the piece genuinely needs one for services, which furniture does not. **Fix.** Add the `rotate` that puts the back on the walled edge — the machine-applicable fix inserts it when exactly one edge is walled. Better still, place the piece with `against wall ` or `in anchor ` and let the rotation be derived. ```arch static furniture wc at (5200,5200) size 400x700 # warning: south wall behind it, cistern facing north ``` ## W_FIXTURE_FLOATING *warning* — A plumbing/kitchen fixture is not against a wall. **Cause.** A fixture that conventionally needs a wall behind it (WC, basin, shower, sink, counter, stove, fridge…) sits with no wall backing any edge — it appears to float in the middle of the room. **Fix.** Move the fixture so one edge is against a wall (supply/waste/venting runs in the wall), or remove it. ```arch static furniture wc at (3000,3000) size 400x700 # lint: no wall behind it ``` ## W_FIXTURE_WRONG_ROOM *warning* — Fixture is not inside its declared room. **Cause.** A furniture item declared `in ` has part of its FOOTPRINT off that room's floor, so it is drawn partly (or mostly) in the wrong space. A 100 mm overhang is allowed on every side, because a room's outline runs down wall centrelines and a piece pushed against a room edge legitimately shares that band. Measured against the room's true floor, so a `polygon` or `circle` room is judged by its own shape and not by a bounding box. **Fix.** Move the fixture inside the named room, or correct the `in `. ```arch static furniture wc at (100,100) size 400x700 in bath # lint: not inside "bath" ``` ## W_FURN_CLEARANCE *warning* — A fixture's use-space is blocked. **Cause.** The activity clearance directly in front of a fixture (WC, basin, sink, counter, stove…) is intruded by a free-standing piece of furniture, so the fixture can't be used comfortably. Other plumbing/kitchen fixtures are ignored, so a compact bathroom/kitchen run does not trip this. The warning states the catalogued clearance, the depth actually left, and the shortfall. **Fix.** Move or shrink the obstructing furniture by the shortfall the warning quotes, turn the fixture so its front faces clear floor (its back must stay on a wall), or move the fixture to a wall run with the clearance free in front of it. ```arch static furniture stove at (0,0) size 600x600 furniture sofa at (0,650) size 2000x900 # lint: sofa blocks the stove front ``` ## W_FURNITURE_OVERLAP *warning* — Two pieces of furniture overlap. **Cause.** Two furniture/fixture rectangles occupy the same floor area, so they would physically collide — usually a coordinate or size mistake. **Fix.** Move or resize one so they no longer intersect; leave a walkway between them. ```arch static furniture sofa at (300,300) size 2000x900 furniture bed at (1000,500) size 1500x2000 # lint: overlaps the sofa ``` ## W_FURNITURE_WALL_COLLISION *warning* — Furniture penetrates a wall. **Cause.** A furniture/fixture rectangle intrudes into a wall's solid (it crosses the wall's thickness band rather than sitting flush against its face), so it would physically pass through the wall — a coordinate or size mistake. A piece merely touching the wall face is fine. Measured in the wall's own frame, so a wall at any angle is checked; a CURVED wall edge (`arc`) is not checked at all. **Fix.** Move or resize the piece so it sits fully inside the room (against the wall face, not through it), or anchor it with `against wall `. ```arch static furniture sofa at (350,2300) size 2000x900 # lint: crosses the partition at y3000 ``` ## W_GARAGE_TOO_NARROW *warning* — A garage is too narrow to park in. **Cause.** A room classified as a garage (an authored `uses garage`, or a label the use vocabulary reads as one — "Garage", or the aliases "carport" / "parking") measures less across its short side than the cars in it need: 2700 mm of clear width per bay, which is a body plus the room to open a door on each side. A garage with no `car` fixture drawn is measured against ONE bay — a room you could not park in does not become sound by having no car in it — and `bicycle`/`motorcycle` do not count toward the bay total. The warning states the width required, the width the room actually has, and the shortfall. **The rule declines a POLYGON room** rather than measuring its bounding box: a box's short side is not a concave floor's clear width, and a measurement taken from a shape's box instead of the shape is a defect class this compiler has shipped before. It is advisory and has no machine fix: widening a room moves every wall and opening around it, which is a geometric decision the compiler does not make (ADR 0005). **Fix.** Widen the room to the figure the warning quotes, park fewer cars in it, or drop the `uses garage` tag if the room is not one (a store that happens to be called a garage classifies as one from its label alone — an explicit `uses storage` overrides that). ```arch static room id=g at (0,0) size 2500x6000 label "Garage" uses garage furniture car at (300,300) size 1800x4600 in g # lint: 2500 mm across, one bay wants 2700 ``` ## W_HATCH_SCALE *warning* — Hatch scale must be positive; using 1. **Cause.** A wall material `scale` evaluated to zero or a negative number. **Fix.** Use a positive `scale`. ```arch static wall exterior thickness 200 material brick scale 0 { (0,0) (1,0) } ``` ## W_IMPORT_EMPTY_FILE *warning* — Whole-file import binds an empty component. **Cause.** `import "" as ` turns a module's TOP-LEVEL drawable statements into one component, but that module's plan body has none (it may only declare `component`s, or only `level` blocks — a storey is a page, so levels are dropped). **Fix.** Draw in the module's plan body, or import one of its named components with `import "": `. ```arch static import "lib.arch" as lib # warning when lib.arch only declares components ``` ## W_NO_ENTRANCE *warning* — The plan has no exterior door. **Cause.** The plan has rooms and an exterior wall but no door hosted on an exterior wall, so the building cannot be entered. **Fix.** Add a `door` on an `exterior` wall. ```arch static wall exterior thickness 200 { (0,0) (4000,0) (4000,3000) (0,3000) close } # lint: no way in ``` ## W_OPENING_OFF_WALL *warning* — Opening does not lie on any wall. **Cause.** A cased opening's position is not within tolerance of any wall segment, so it has no host. **Fix.** Move the opening onto a wall, or name its host with `wall `. The diagnostic points at the nearest wall. ```arch static opening at (9999,9999) width 1000 # warning: not on a wall ``` ## W_OUTDOOR_OVERLAPS_ROOM *warning* — A ground surface is laid over a room's floor. **Cause.** An `outdoor` surface's extent overlaps the floor of a room by more than a shared edge. Almost always a coordinate slip — a terrace written from the wrong corner, or a lawn given the building's own extent. It matters because ground and floor are reported in SEPARATE totals (`totals.outdoor_area_m2` and `totals.floor_area_m2`), so the overlapping piece is counted twice by anything that adds them for a plot figure. A surface that merely touches a room along its edge — a patio flush against the house — does NOT trip this. **Fix.** Move or resize the surface so it sits outside the building's rooms. If the overlap is deliberate (a covered terrace drawn under a room), the two are genuinely different things and one of them is the wrong element. ```arch static room id=liv at (0,0) size 5000x4000 label "Living" outdoor paving at (1000,1000) size 3000x2000 # warning: on the living-room floor ``` ## W_PATH_TOO_NARROW *warning* — The walk to a room squeezes below a passable width. **Cause.** The widest route from the entrance into a room (or between a key pair of rooms, e.g. bedroom→bath) has an unavoidable pinch narrower than the minimum passable clear width — a too-narrow door/opening, or furniture crowding the way. The limit case is reported too: when no route reaches the room at all, the message gives the MEASURED width of the best way in that does exist (found by asking which smaller body does get there) rather than a fabricated zero, and calls the walk blocked only when there is no gap at all. A coarse fact from the circulation nav grid (ADR 0008); the number is grid-quantised, and it is the width a body passes through, not the room left over after its own clearance. **Fix.** Widen the tightest door/opening on the route to at least the minimum, move the furniture pinching it, or add a second way in so the pinch is avoidable. There is no machine-applicable fix: the bottleneck is a nav-grid cell, not a named element, so nothing can be rewritten for you. ```arch static door at (4000,1500) width 600 furniture cabinet at (3600,300) size 700x1200 # lint: the way through squeezes below 700 mm ``` ## W_POCKET_RUN *warning* — A pocket door has no wall to slide into. **Cause.** A `pocket` door's panel disappears into a cavity inside the host wall, so the wall must continue past the slide-side jamb by at least the door's own width plus end clearance. This measures the run from that jamb to the end of the host segment, TRUNCATED at the near edge of any other opening (a window or a second door) that falls inside it — a panel cannot slide through a window either. The warning states what the run has to be, what is actually there, and the shortfall. **The threshold, and a deliberate divergence from the source it is borrowed from:** the required run is `width + max(50 mm, width × 5%)` (`pocketRunClearanceMm` in the lint ruleset). The rule is modelled on planscript-rust's `pocket_door_wall_run`, which requires a flat `width × 1.05` — but a pure ratio is wrong on narrow doors: a 700 mm pocket would ask for 35 mm of end clearance, which does not fit a real jamb and pull. We are not publishing a comparison against that project, so matching its constant buys nothing, and architectural correctness outranks reference-comparability. The two extra things this rule does that the reference does not: it subtracts intervening openings, and it carries its remedies as structured fixes rather than printed prose. **Fix.** Reverse the slide (`slide left` ↔ `slide right`) — a machine-applicable fix, emitted only after the reverse run is recomputed and proved to satisfy; move the door along its wall so the pocket lands on solid wall; or lengthen the wall. Narrowing the door is deliberately NOT offered as a fix: rewriting the author's stated width to satisfy a checker is the constraint-laundering pattern this project rules out, and it would also walk into `W_DOOR_CLEARANCE`. ```arch static wall w1 thickness 200 { (0,0) (3000,0) } door pocket on w1 at 80% width 900 slide right # lint: only ~600 mm of run ``` ## W_ROOM_DISCONNECTED *warning* — Room has no door — it can't be entered. **Cause.** No door lies on any of the room's walls, so there is no way into the room. **Fix.** Add a `door` on one of the room's walls. ```arch static room id=r at (0,0) size 3000x3000 # lint: no door on its perimeter ``` ## W_ROOM_LABEL_OUTSIDE *warning* — A room's explicit label anchor falls outside the room. **Cause.** `label "…" at (x,y)` pins the label and area text at a point that is not inside the room's floor, so the text will be drawn over whatever is there instead. **Fix.** Move the anchor inside the room, or drop the `at (…)` — automatic placement uses the rectangle's centre, the circle's centre, or a polygon's area centroid (falling back to the interior point furthest from any edge where a concave ring puts that centroid off its own floor), so it lands inside either way. ```arch static room polygon (0,0) (6000,0) (6000,6000) (0,6000) label "Hall" at (9000,9000) # warning ``` ## W_ROOM_NO_CLEAR_PATH *warning* — A room cannot be entered or crossed. **Cause.** Furniture, fixtures, door swings and their clearances fill the room so densely that a person stepping through a door/opening has no clear floor path into the usable space — the room is technically reachable but physically blocked. **Fix.** Open up the layout: move or shrink the furniture nearest the door so there is a continuous walkable strip from each entrance into the room. ```arch static furniture shower at (5000,3000) size 2000x2000 # lint: fills the bathroom against its only door ``` ## W_ROOM_NO_FIXTURE *warning* — Bathroom or kitchen has no fixtures. **Cause.** A room labelled as a bathroom or kitchen contains no plumbing/kitchen fixture (WC, basin, shower, sink, counter…), so it is drawn as an empty box. **Fix.** Place the expected fixtures — e.g. import `lib/fixtures.arch` and add a `wc`, `basin`, `shower`, or `kitchen_sink`. ```arch static room at (4000,4000) size 3000x2000 label "Bath" # lint: no fixtures inside ``` ## W_ROOM_NOT_ENCLOSED *warning* — Bathroom is not fully enclosed. **Cause.** A run of this bathroom/WC's perimeter is not backed by a wall, so it is open to the adjacent space — a privacy problem for a wet room (a partition that stops short is the usual cause). **Fix.** Extend the partition so the room's perimeter is walled on all sides (a door/window in the wall is fine — only a missing wall counts). ```arch static wall partition thickness 100 { (4000,0) (4000,4000) } # lint: stops short, bath left open ``` ## W_ROOM_NOT_EQUATOR_FACING *warning* — A habitable room has windows, but none faces the equator side. **Cause.** The plan declares `site`, so the equator-facing side is known (`S` in the northern hemisphere, `N` in the southern), and a habitable room — a bedroom, living or dining space — has at least one window with none of them on that aspect. **This is a drafting heuristic, not a measured daylight outcome:** it says the room's windows do not face the equator, and nothing more. A south window in Reykjavík and one in Singapore are not the same daylight, and this rule does not distinguish them (there is no sun model, latitude or date anywhere in ArchLang). The rule cannot fire at all in a plan with no `site`, and a room with NO window is `W_BEDROOM_NO_WINDOW`'s report, not this one. **Fix.** Move a window onto the room's equator-facing facade, or accept the aspect — an urban plot often has no equator-facing wall to spare. There is deliberately NO machine fix: the remedy is a geometric decision (which facade, which wall, what else it displaces) and the compiler does not make those (ADR 0005). ```arch static site { street north } # equator side is S room id=liv at (0,0) size 4000x3000 label "Living" window on north_wall at 50% width 1200 # warning: the only window faces N ``` ## W_ROOM_OVERLAP *warning* — Rooms overlap. **Cause.** Two room rectangles intersect. **Fix.** Adjust positions/sizes if the overlap is unintended (it is allowed). ```arch static room at (0,0) size 2000x2000 room at (1000,0) size 2000x2000 # warning ``` ## W_ROOM_TOO_SMALL *warning* — Room is implausibly small. **Cause.** A room's floor area is below the configured minimum (default 4 m²). **Fix.** Increase its `size`, or merge it into an adjacent space. ```arch static room at (0,0) size 1000x1000 label "Closet" # lint: 1 m² ``` ## W_ROOM_UNREACHABLE *warning* — Room cannot be reached from the entrance. **Cause.** The building has an entrance, but this room has no door/opening path back to the exterior — it is sealed off from the circulation. **Fix.** Add a door or cased `opening` linking it (directly or through a hall) to a space that reaches the entrance. ```arch static room at (5000,0) size 3000x3000 label "Store" # lint: no path from the entrance ``` ## W_SANITIZED_CONFIG *warning* — A disallowed config value was stripped. **Cause.** A theme/style value contained markup or a `data:` URL and was blanked for safety. **Fix.** Use a plain colour/string value (no `<`, `>`, or `url(data:…)`). ```arch static theme { wall: "