@pascal-app/core 1.0.4 → 1.0.5

package/dist/agent-operations/create-roof.js

@@ -0,0 +1,304 @@
+import { refuse } from '../agent-tools/refusal.js';
+import { gapBridges } from '../building/wall-gaps.js';
+import { exteriorWallLoops, exteriorWallOutlines } from '../lib/exterior-wall-loops.js';
+import { getActiveRoofHeight, getSegmentSlopeFrame, RoofNode, RoofSegmentNode, } from '../schema/index.js';
+import { planRoofLevel, roofsOver } from '../services/roof-level.js';
+import { resolveRoofElevation } from '../systems/roof/roof-elevation.js';
+import { applySceneChanges } from './apply-changes.js';
+import { requireLevel } from './level-target.js';
+import { finishSurface, requireMaterialRef } from './material-refs.js';
+import { buildingFrame, roofRectangles } from './roof-footprint.js';
+import { levelRole, levelsOf } from './scene-queries.js';
+const mm = (value) => Math.round(value * 1000) / 1000;
+/** A storey a roof can cover: one with a footprint (`footprintPolygons`). */
+const hasFootprint = (nodes, levelId) => footprintPolygons(nodes, levelId).length > 0;
+const buildingLevels = (nodes, level) => levelsOf(nodes).filter((other) => other.parentId === level.parentId);
+/** The segment fields the fascia input writes: none without a band. */
+function fasciaFields({ fasciaHeight, fasciaMaterialPreset }) {
+    if (fasciaHeight === undefined && !fasciaMaterialPreset)
+        return {};
+    return {
+        fascia: true,
+        ...(fasciaHeight !== undefined ? { fasciaHeight } : {}),
+        ...(fasciaMaterialPreset ? { fasciaMaterialPreset } : {}),
+    };
+}
+/** A level a roof can cap: not a roof level, not a support level. */
+const isStorey = (nodes, level) => levelRole(nodes, level).role === 'occupied';
+/**
+ * The storey a roof covers: the one named when it has a footprint, else the highest storey of its
+ * building with one; none named, the top storey with one of the building in view. A rectangle of
+ * its own needs no footprint: the storey named, else the top one that holds something. The floor
+ * in view does not decide: a person looking at the ground floor who asks for a roof means the
+ * house's. A roof level named stands for the storey under it.
+ */
+function coveredStorey(nodes, input, rectangle, context) {
+    const { levelId, level } = input;
+    if (levelId && level && levelId !== level)
+        refuse('conflicting_level', `levelId (${levelId}) and level (${level}) disagree; they are the same field, pass one.`, { levelId, level });
+    const named = levelId ?? level;
+    const requested = named ? requireLevel(nodes, named) : null;
+    if (requested && isStorey(nodes, requested) && (rectangle || hasFootprint(nodes, requested.id)))
+        return { storey: requested };
+    const viewed = context.activeLevelId ? nodes[context.activeLevelId] : undefined;
+    const scope = requested ?? (viewed?.type === 'level' ? viewed : null);
+    const candidates = (scope ? buildingLevels(nodes, scope) : levelsOf(nodes)).filter((candidate) => isStorey(nodes, candidate));
+    const eligible = rectangle
+        ? candidates.filter((candidate) => candidate.children.length > 0)
+        : candidates.filter((candidate) => hasFootprint(nodes, candidate.id));
+    // With no level in view (the MCP), the last level by ordinal would pick a building by its id;
+    // a rectangle with no level holding anything falls back to every candidate, so asks of those.
+    const buildingIds = [
+        ...new Set((rectangle && !eligible.length ? candidates : eligible).map((candidate) => candidate.parentId)),
+    ];
+    if (!scope && buildingIds.length > 1)
+        refuse('building_required', `The scene has ${buildingIds.length} buildings to roof; pass a level of the one to roof: ${buildingIds.join(', ')}.`, { buildingIds });
+    if (rectangle) {
+        const top = eligible.at(-1) ?? candidates.at(-1);
+        if (!top)
+            refuse('no_levels', 'The scene has no storey to roof yet.');
+        return { storey: top };
+    }
+    const storey = eligible.at(-1);
+    if (!storey)
+        refuse('no_rooms', `No rooms or closed walls on ${requested ? `${requested.id} or any other level of its building` : 'any level'}: create rooms first, or pass width and depth to roof a rectangle of your own.`, requested ? { levelId: requested.id } : {});
+    return {
+        storey,
+        ...(requested &&
+            requested.id !== storey.id && {
+            note: `Level ${requested.id} has no rooms or closed walls; the roof covers ${storey.name ?? storey.id} (${storey.id}), the highest level with rooms.`,
+        }),
+    };
+}
+/**
+ * The storey's outline from its walls, every gap bridged as L5 finds them: a roof covers the
+ * building, not only the rooms closed so far (the 290 traced from its PNG, its doors and windows
+ * still gaps, got a roof over a few rooms only).
+ */
+function wallOutline(nodes, storeyId) {
+    const walls = Object.values(nodes).filter((node) => node.type === 'wall' && node.parentId === storeyId);
+    if (walls.length < 3)
+        return [];
+    const bridges = gapBridges(walls).map((gap, index) => ({
+        ...walls[0],
+        id: `wall_roof_gap_${index}`,
+        start: gap.start,
+        end: gap.end,
+        thickness: gap.thickness,
+        curveOffset: 0,
+    }));
+    // Ends a few centimetres apart are one corner: a vectorised plan's near-misses.
+    const closed = [...walls, ...bridges];
+    const outlines = exteriorWallOutlines(closed, NEAR_MISS);
+    if (!outlines.length)
+        return [];
+    // Out to the walls' outer faces, as a floor plate reaches: half the outline walls' thickness.
+    const thickness = new Map(closed.map((wall) => [wall.id, wall.thickness ?? 0.2]));
+    const onOutline = exteriorWallLoops(closed, NEAR_MISS)
+        .flat()
+        .map((face) => thickness.get(face.wallId) ?? 0.2)
+        .sort((a, b) => a - b);
+    const half = (onOutline[Math.floor(onOutline.length / 2)] ?? 0.2) / 2;
+    return outlines.map((polygon) => grown(polygon, half));
+}
+/**
+ * How far a mitre may reach, in multiples of the distance moved: past it (a corner under about
+ * 29°, or an edge folding back on itself) the corner is bevelled, as an SVG stroke's is.
+ */
+const MITER_LIMIT = 4;
+/** A polygon moved out by `distance` along each edge's outward normal, corners mitred up to the limit. */
+export function grown(polygon, distance) {
+    const n = polygon.length;
+    let area = 0;
+    for (let i = 0; i < n; i++) {
+        const [ax, az] = polygon[i];
+        const [bx, bz] = polygon[(i + 1) % n];
+        area += ax * bz - bx * az;
+    }
+    const side = area > 0 ? 1 : -1;
+    const normal = (a, b) => {
+        const [dx, dz] = [b[0] - a[0], b[1] - a[1]];
+        const length = Math.hypot(dx, dz) || 1;
+        return [(side * dz) / length, (-side * dx) / length];
+    };
+    return polygon.flatMap((point, i) => {
+        const before = normal(polygon[(i - 1 + n) % n], point);
+        const after = normal(point, polygon[(i + 1) % n]);
+        const dot = before[0] * after[0] + before[1] * after[1];
+        // The mitre reaches distance × √(2 / (1 + dot)): unbounded as the edges fold onto each other.
+        if (1 + dot < 2 / MITER_LIMIT ** 2)
+            return [
+                [point[0] + before[0] * distance, point[1] + before[1] * distance],
+                [point[0] + after[0] * distance, point[1] + after[1] * distance],
+            ];
+        // Along the bisector, as far as both edges move by `distance`.
+        const scale = distance / (1 + dot);
+        return [[point[0] + (before[0] + after[0]) * scale, point[1] + (before[1] + after[1]) * scale]];
+    });
+}
+const NEAR_MISS = 0.1;
+/**
+ * A storey's footprint: its walls' outline, every gap bridged, else its floor plates (a balcony's
+ * left out; overlapping plates are one footprint), else its rooms.
+ */
+function footprintPolygons(nodes, storeyId) {
+    const outline = wallOutline(nodes, storeyId);
+    if (outline.length)
+        return outline;
+    const on = (type) => Object.values(nodes).filter((node) => node.type === type &&
+        node.parentId === storeyId &&
+        !(node.type === 'slab' &&
+            node.metadata &&
+            node.metadata.balcony));
+    const plates = on('slab');
+    return (plates.length ? plates : on('zone')).map((node) => node.polygon);
+}
+/** Rectangles in the storey's own frame and the turn back to the world, from its footprint. */
+function footprintOf(nodes, storeyId) {
+    const frame = buildingFrame(footprintPolygons(nodes, storeyId));
+    const { rectangles, roofType } = roofRectangles(frame.polygons);
+    return { rectangles, roofType, angle: frame.angle, toWorld: frame.toWorld };
+}
+/**
+ * `create_roof`: a roof over a storey, one segment per rectangle of its footprint (or the one
+ * rectangle asked for), on the building's roof level above it, standing on the storey's walls.
+ */
+export const createRoof = (nodes, input, context) => {
+    const { width, depth } = input;
+    // A finish the library lacks would render as the default.
+    const materialPreset = input.materialPreset === undefined
+        ? undefined
+        : requireMaterialRef(input.materialPreset, 'materialPreset', finishSurface('roof'));
+    const fasciaMaterialPreset = input.fasciaMaterialPreset === undefined
+        ? undefined
+        : requireMaterialRef(input.fasciaMaterialPreset, 'fasciaMaterialPreset', finishSurface('roof'));
+    if ((width === undefined) !== (depth === undefined))
+        refuse('rectangle_incomplete', 'A rectangle of your own takes width and depth together; pass both, or neither to cover the footprint.', { width, depth });
+    const rectangle = width !== undefined && depth !== undefined;
+    const { storey, note } = coveredStorey(nodes, input, rectangle, context);
+    if (!storey.parentId)
+        refuse('storey_without_building', `${storey.name ?? storey.id} (${storey.id}) is not in a building, so no roof level can stand above it. Put the level in a building first.`, { levelId: storey.id });
+    const existing = roofsOver(nodes, storey.id);
+    if (existing.length)
+        refuse('roof_exists', `${storey.name ?? storey.id} (${storey.id}) already has a roof, ${existing.map((roof) => roof.id).join(', ')}: a storey takes one. Edit it, or delete_node it first if the person asked for a new one.`, { levelId: storey.id, roofIds: existing.map((roof) => roof.id) });
+    let rectangles;
+    let chosenType;
+    let angle = 0;
+    let toWorld = ([x, z]) => [x, z];
+    if (rectangle) {
+        const [x = 0, z = 0] = input.center ?? [];
+        const r = { minX: x - width / 2, maxX: x + width / 2, minZ: z - depth / 2, maxZ: z + depth / 2 };
+        rectangles = [r];
+        // The size as asked, the type as the footprint rule would give it.
+        chosenType = roofRectangles([
+            [
+                [r.minX, r.minZ],
+                [r.maxX, r.minZ],
+                [r.maxX, r.maxZ],
+                [r.minX, r.maxZ],
+            ],
+        ]).roofType;
+    }
+    else {
+        const footprint = footprintOf(nodes, storey.id);
+        rectangles = footprint.rectangles;
+        chosenType = footprint.roofType;
+        angle = footprint.angle;
+        toWorld = footprint.toWorld;
+    }
+    const roofType = input.roofType ?? chosenType;
+    if (input.roofSystem === 'glazed' && !['gable', 'shed', 'barrel'].includes(roofType))
+        refuse('unsupported_glazing', 'Glazed roofs support gable, straight shed, and barrel shapes.');
+    const minX = Math.min(...rectangles.map((r) => r.minX));
+    const maxX = Math.max(...rectangles.map((r) => r.maxX));
+    const minZ = Math.min(...rectangles.map((r) => r.minZ));
+    const maxZ = Math.max(...rectangles.map((r) => r.maxZ));
+    const centerX = (minX + maxX) / 2;
+    const centerZ = (minZ + maxZ) / 2;
+    const wallHeight = input.wallHeight ?? 0;
+    const segments = rectangles.map((r) => {
+        // To the millimetre: snapped coordinates subtract to 6.199999…
+        const span = { width: mm(r.maxX - r.minX), depth: mm(r.maxZ - r.minZ) };
+        // A cone stands on a circle.
+        const size = roofType === 'conical'
+            ? { width: Math.max(span.width, span.depth), depth: Math.max(span.width, span.depth) }
+            : span;
+        if (roofType === 'barrel' &&
+            input.barrelRise !== undefined &&
+            input.barrelRise > size.depth / 2)
+            refuse('invalid_barrel_rise', 'Barrel rise must not exceed half the span.');
+        const segment = RoofSegmentNode.parse({
+            roofSystem: input.roofSystem,
+            glazing: input.glazing,
+            barrelRise: input.barrelRise,
+            barrelSegments: input.barrelSegments,
+            ...(input.wallThickness !== undefined && { wallThickness: input.wallThickness }),
+            ...size,
+            roofType,
+            wallHeight,
+            position: [(r.minX + r.maxX) / 2 - centerX, 0, (r.minZ + r.maxZ) / 2 - centerZ],
+            ...(input.pitch !== undefined && { pitch: input.pitch }),
+            ...(input.overhang !== undefined && { overhang: input.overhang }),
+            ...fasciaFields({ ...input, fasciaMaterialPreset }),
+        });
+        // The overhang is asked as the eaves' reach past the walls, in plan, as a builder says it and
+        // Architect's roofs take it; the segment stores it along the slope.
+        // A barrel's overhang is at its ends, already in plan.
+        if (roofType === 'barrel')
+            return segment;
+        return { ...segment, overhang: segment.overhang / getSegmentSlopeFrame(segment).cosTheta };
+    });
+    const peak = Math.max(...segments.map((segment) => getActiveRoofHeight(segment)));
+    const plan = planRoofLevel(nodes, storey.id, wallHeight + peak);
+    if (plan.kind === 'storey') {
+        const above = nodes[plan.levelId];
+        refuse('storey_above', `${storey.name ?? storey.id} (${storey.id}) has a storey above it, ${above.name ?? above.id} (${above.id}): create_roof caps the top storey, and its roof covers the floors under it. A roof over a lower wing or a porch of ${storey.name ?? storey.id} stands on its walls, below the top storey's: do not roof it from the top storey; the person draws it with the Roof tool on ${storey.name ?? storey.id}.`, { levelId: storey.id, storeyAboveId: above.id });
+    }
+    const changes = {
+        create: plan.create ? [{ node: plan.create, parentId: plan.create.parentId ?? undefined }] : [],
+        update: plan.update,
+    };
+    const [roofX, roofZ] = toWorld([centerX, centerZ]);
+    const placed = RoofNode.parse({
+        name: input.name ?? 'Roof',
+        parentId: plan.levelId,
+        position: [roofX, 0, roofZ],
+        rotation: angle,
+        support: { kind: 'walls' },
+        children: segments.map((segment) => segment.id),
+        ...(materialPreset && { materialPreset }),
+    });
+    const draft = [
+        { node: placed, parentId: plan.levelId },
+        ...segments.map((segment) => ({
+            node: { ...segment, parentId: placed.id },
+            parentId: placed.id,
+        })),
+    ];
+    // The eave on the storey's wall tops, as the editor's own follow resolves it: walls taller than
+    // their storey lift it, and the editor makes no second write after the call.
+    const seated = applySceneChanges(nodes, { ...changes, create: [...changes.create, ...draft] });
+    const elevation = resolveRoofElevation(seated[placed.id], seated);
+    const roof = { ...placed, position: [roofX, elevation, roofZ] };
+    // A roof level made for it is as tall as the roof rises over it, the eave's lift included.
+    if (plan.create)
+        changes.create[0] = {
+            node: { ...plan.create, height: Math.max(elevation + wallHeight + peak, 0.2) },
+            parentId: plan.create.parentId ?? undefined,
+        };
+    changes.create.push({ node: roof, parentId: plan.levelId }, ...draft.slice(1));
+    return {
+        result: {
+            ok: true,
+            roofId: roof.id,
+            roofLevelId: plan.levelId,
+            createdRoofLevelId: plan.create?.id ?? null,
+            coveredLevelId: storey.id,
+            segmentIds: segments.map((segment) => segment.id),
+            roofType,
+            message: `Created a ${roofType} roof of ${segments.length} segment${segments.length === 1 ? '' : 's'} over ${storey.name ?? storey.id}, on the roof level ${plan.levelId}.`,
+            ...(note && { note }),
+        },
+        changes,
+    };
+};

package/dist/agent-operations/create-room.d.ts

@@ -8,6 +8,7 @@ type OpeningSpec = {
     height?: number;
     sillHeight?: number;
     hingesSide?: 'left' | 'right';
+    handleSide?: 'left' | 'right';
     swingDirection?: 'inward' | 'outward';
     style?: string;
 };
@@ -18,6 +19,7 @@ type CreateRoomInput = LevelTargetInput & {
     wallHeight?: number;
     wallThickness?: number;
     outdoor?: boolean;
+    rename?: boolean;
     doors?: OpeningSpec[];
     windows?: OpeningSpec[];
 };

package/dist/agent-operations/create-room.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"create-room.d.ts","sourceRoot":"","sources":["../../src/agent-operations/create-room.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,KAAK,gBAAgB,EAAe,MAAM,gBAAgB,CAAA;AACnE,OAAO,EAAe,KAAK,IAAI,EAAE,MAAM,iBAAiB,CAAA;AAExD,OAAO,KAAK,EAAE,cAAc,EAAc,MAAM,SAAS,CAAA;AAEzD,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,CAAA;IACjB,CAAC,CAAC,EAAE,MAAM,CAAA;IACV,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,UAAU,CAAC,EAAE,MAAM,GAAG,OAAO,CAAA;IAC7B,cAAc,CAAC,EAAE,QAAQ,GAAG,SAAS,CAAA;IACrC,KAAK,CAAC,EAAE,MAAM,CAAA;CACf,CAAA;AAED,KAAK,eAAe,GAAG,gBAAgB,GAAG;IACxC,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,MAAM,EAAE,EAAE,CAAA;IACnB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,KAAK,CAAC,EAAE,WAAW,EAAE,CAAA;IACrB,OAAO,CAAC,EAAE,WAAW,EAAE,CAAA;CACxB,CAAA;AAYD,mGAAmG;AACnG,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,SAAS,MAAM,EAAE;;;EAWxE;AA+CD;;;;GAIG;AACH,eAAO,MAAM,UAAU,EAAE,cAAc,CAAC,eAAe,CA+HtD,CAAA"}
+{"version":3,"file":"create-room.d.ts","sourceRoot":"","sources":["../../src/agent-operations/create-room.ts"],"names":[],"mappings":"AAkBA,OAAO,EAAE,KAAK,gBAAgB,EAAe,MAAM,gBAAgB,CAAA;AACnE,OAAO,EAAe,KAAK,IAAI,EAAE,MAAM,iBAAiB,CAAA;AAExD,OAAO,KAAK,EAAE,cAAc,EAAc,MAAM,SAAS,CAAA;AAEzD,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,CAAA;IACjB,CAAC,CAAC,EAAE,MAAM,CAAA;IACV,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,UAAU,CAAC,EAAE,MAAM,GAAG,OAAO,CAAA;IAC7B,UAAU,CAAC,EAAE,MAAM,GAAG,OAAO,CAAA;IAC7B,cAAc,CAAC,EAAE,QAAQ,GAAG,SAAS,CAAA;IACrC,KAAK,CAAC,EAAE,MAAM,CAAA;CACf,CAAA;AAED,KAAK,eAAe,GAAG,gBAAgB,GAAG;IACxC,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,MAAM,EAAE,EAAE,CAAA;IACnB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,KAAK,CAAC,EAAE,WAAW,EAAE,CAAA;IACrB,OAAO,CAAC,EAAE,WAAW,EAAE,CAAA;CACxB,CAAA;AAYD,mGAAmG;AACnG,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,SAAS,MAAM,EAAE;;;EAWxE;AAiDD;;;;GAIG;AACH,eAAO,MAAM,UAAU,EAAE,cAAc,CAAC,eAAe,CAuMtD,CAAA"}

package/dist/agent-operations/create-room.js

@@ -1,8 +1,13 @@
 import { isAgentRefusal, refuse } from '../agent-tools/refusal.js';
 import { doorFacing, planWallOpening } from '../building/wall-openings.js';
-import { createZone } from '../commands/structure/create-zone.js';
+import { createZone, walledRoomAt } from '../commands/structure/create-zone.js';
 import { structureChangeBatch } from '../commands/structure/shared.js';
-import { generateId } from '../schema/index.js';
+import { levelFootprintLoops } from '../lib/building-footprint.js';
+import { foundationReadingOfLevel } from '../lib/foundation-construction.js';
+import { foundationWallRule, levelHoldsFoundationWalls } from '../lib/foundation-wall.js';
+import { isAllocatedRoomName } from '../lib/room-name.js';
+import { lotOverhang } from '../lib/site-placement.js';
+import { generateId, } from '../schema/index.js';
 import { applySceneChanges } from './apply-changes.js';
 import { targetLevel } from './level-target.js';
 import { polygonArea } from './plan-geometry.js';
@@ -58,6 +63,7 @@ function derivedSurfaces(nodes, levelId, zoneId) {
     const ceiling = children.find((node) => node.type === 'ceiling' && node.boundary === 'auto' && node.zoneId === zoneId);
     return { slabId: slab?.id ?? null, ceilingId: ceiling?.id ?? null };
 }
+const roundArea = (value) => Math.round(value * 100) / 100;
 const plural = (count, noun) => `${count} ${noun}${count === 1 ? '' : 's'}`;
 /**
  * `create_room`: the editor's room command — walls where no wall runs yet, the zone that names the
@@ -69,6 +75,13 @@ export const createRoom = (nodes, input, context) => {
     if (levelRole(nodes, level).role === 'roof')
         refuse('roof_level', `${level.name || level.id} is a roof level, not a storey: build the room on the storey below it.`, { levelId: level.id });
     const polygon = input.polygon;
+    // A room a person named stands where these walls are: no twin zone, and no silent rename. The
+    // agent passes rename: true to give it the new name, or asks the person.
+    const named = walledRoomAt(nodes, level.id, polygon);
+    if (named && !isAllocatedRoomName(named.name) && !input.rename)
+        refuse('room_named_by_person', named.name === input.name
+            ? `The walls here already enclose the room "${named.name}", with a name of its own, so there is nothing to create: its walls, doors and windows are there. Add what is missing with add_door and add_window.`
+            : `The walls here already enclose the room "${named.name}", which has a name of its own (not a number the editor gave it). Creating "${input.name}" would stack a second room on it. To give it the name "${input.name}", pass rename: true only if the person asked for the rename; otherwise ask them whether to rename it. To keep it, leave it as it is.`, { zoneId: named.id, roomName: named.name });
     let plan;
     try {
         plan = createZone(nodes, {
@@ -76,6 +89,7 @@ export const createRoom = (nodes, input, context) => {
             polygon,
             name: input.name,
             enclose: !input.outdoor,
+            ...(input.rename ? { adoptNamed: true } : {}),
             ...(input.outdoor
                 ? { intent: { hasCeiling: false } }
                 : {
@@ -99,7 +113,18 @@ export const createRoom = (nodes, input, context) => {
     if (plan.conflicts?.length)
         refuse(plan.conflicts[0].code.replaceAll('-', '_'), plan.conflicts.map((conflict) => conflict.message).join(' '), { conflicts: plan.conflicts });
     const roomChanges = structureChangeBatch(plan.changes);
-    if (input.color)
+    if (input.color && plan.renamed)
+        roomChanges.update = [
+            ...roomChanges.update.filter((entry) => entry.id !== plan.zoneId),
+            {
+                id: plan.zoneId,
+                data: {
+                    ...roomChanges.update.find((entry) => entry.id === plan.zoneId)?.data,
+                    color: input.color,
+                },
+            },
+        ];
+    else if (input.color)
         roomChanges.create = roomChanges.create.map((entry) => entry.node.id === plan.zoneId
             ? { ...entry, node: { ...entry.node, color: input.color } }
             : entry);
@@ -135,23 +160,66 @@ export const createRoom = (nodes, input, context) => {
     const windowIds = place('window', input.windows);
     const wallIds = polygon.map((a, i) => wallsAlong(scene, level.id, a, polygon[(i + 1) % polygon.length])[0]?.id ?? null);
     const reusedWalls = wallIds.filter((id) => id && nodes[id]).length;
+    // the room and the walls it raised, their mitred bands: what crosses the lot line
+    const raised = new Set(roomChanges.create.flatMap((entry) => (entry.node.type === 'wall' ? [entry.node.id] : [])));
+    const holdsFoundation = raised.size > 0 &&
+        !input.outdoor &&
+        input.wallThickness === undefined &&
+        levelHoldsFoundationWalls(scene, level.id);
+    const foundation = holdsFoundation
+        ? [...raised].filter((id) => scene[id]?.assembly)
+        : [];
+    const partitions = holdsFoundation ? raised.size - foundation.length : 0;
+    const reading = foundationReadingOfLevel(scene, level.id);
+    const site = lotOverhang(scene, level.id, [
+        polygon,
+        ...levelFootprintLoops(scene, scene[level.id], null, raised),
+    ]);
     const result = {
         ok: true,
         zoneId: plan.zoneId,
         wallIds,
         reusedWalls,
-        areaSqMeters: Math.round(polygonArea(polygon) * 100) / 100,
+        areaSqMeters: roundArea(polygonArea(plan.renamed ? nodes[plan.zoneId].polygon : polygon)),
         doorIds,
         windowIds,
         ...(skippedOpenings.length ? { skippedOpenings } : {}),
+        ...(site ? { site } : {}),
+        ...(foundation.length
+            ? {
+                construction: {
+                    assembly: reading.construction.description,
+                    foundationWallIds: foundation,
+                    region: reading.region,
+                    basis: reading.basis,
+                },
+            }
+            : {}),
         message: [
-            `Created ${input.outdoor ? 'outdoor room' : 'room'} "${input.name}" on ${level.name || level.id}`,
+            plan.renamed
+                ? `Named the ${input.outdoor ? 'outdoor room' : 'room'} the walls already enclose "${input.name}" (it was ${plan.renamed}) on ${level.name || level.id}`
+                : `Created ${input.outdoor ? 'outdoor room' : 'room'} "${input.name}" on ${level.name || level.id}`,
             ...(reusedWalls ? [`reused ${plural(reusedWalls, 'wall')} already there`] : []),
+            ...(foundation.length
+                ? [
+                    `${plural(foundation.length, 'new wall')} against the ground ${foundation.length === 1 ? 'is a foundation wall' : 'are foundation walls'} (${reading.construction.description}; ${reading.basis})`,
+                ]
+                : []),
+            ...(partitions
+                ? [
+                    `${plural(partitions, 'new wall')} inside the outline ${partitions === 1 ? 'is an ordinary wall' : 'are ordinary walls'}: ${foundationWallRule(reading)}`,
+                ]
+                : []),
             ...(doorIds.length ? [plural(doorIds.length, 'door')] : []),
             ...(windowIds.length ? [plural(windowIds.length, 'window')] : []),
             ...(skippedOpenings.length
                 ? [`skipped ${plural(skippedOpenings.length, 'opening')} (see skippedOpenings)`]
                 : []),
+            ...(site
+                ? [
+                    `it reaches ${site.overhangM} m past the lot line (${site.sides.join(', ')}): the house belongs inside the buildable area (get_site, place_building)`,
+                ]
+                : []),
         ].join(', '),
     };
     return {

package/dist/agent-operations/create-stair.d.ts

@@ -1,33 +1,11 @@
-import { type LevelTargetInput } from './level-target.js';
+import type { CreateStairInput } from '../agent-tools/stairs.js';
 import type { AgentOperation } from './types.js';
-type CreateStairInput = LevelTargetInput & {
-    x: number;
-    z: number;
-    rotation?: number;
-    width?: number;
-    length?: number;
-    height?: number;
-    steps?: number;
-    toLevelId?: string;
-    railingMode?: 'none' | 'left' | 'right' | 'both';
-    materialPreset?: string;
-    name?: string;
-    createDestinationSlabOpening?: boolean;
-    createSourceCeilingOpening?: boolean;
-    destinationSlabId?: string;
-    sourceCeilingId?: string;
-    openingWidth?: number;
-    openingLength?: number;
-    openingOffset?: number;
-    openingCenter?: [number, number];
-    openingRotation?: number;
-};
 /**
- * `create_stair`: a straight flight placed as the editor's stair tool places one — rising to the
- * next level (made when there is none), its floor openings owned and cut by the stair. With the
- * opening controls create_stair_between_levels had, the opening is cut as given instead, owned by
- * the stair as main's are, and the stair's own opening is off so nothing is cut twice.
+ * `create_stair`: a straight, L or U stair placed as the editor's stair tool places one — rising to
+ * the next level (made when there is none), its floor openings owned and cut by the stair — or a
+ * flight to no level, which rises as asked and cuts nothing. With the opening controls
+ * create_stair_between_levels had, the opening is cut as given instead, owned by the stair as main's
+ * are, and the stair's own opening is off so nothing is cut twice.
  */
 export declare const createStair: AgentOperation<CreateStairInput>;
-export {};
 //# sourceMappingURL=create-stair.d.ts.map

package/dist/agent-operations/create-stair.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"create-stair.d.ts","sourceRoot":"","sources":["../../src/agent-operations/create-stair.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,KAAK,gBAAgB,EAA6B,MAAM,gBAAgB,CAAA;AAIjF,OAAO,KAAK,EAAE,cAAc,EAAgB,MAAM,SAAS,CAAA;AAE3D,KAAK,gBAAgB,GAAG,gBAAgB,GAAG;IACzC,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;IACT,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,WAAW,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,CAAA;IAChD,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,4BAA4B,CAAC,EAAE,OAAO,CAAA;IACtC,0BAA0B,CAAC,EAAE,OAAO,CAAA;IACpC,iBAAiB,CAAC,EAAE,MAAM,CAAA;IAC1B,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,aAAa,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAChC,eAAe,CAAC,EAAE,MAAM,CAAA;CACzB,CAAA;AAsCD;;;;;GAKG;AACH,eAAO,MAAM,WAAW,EAAE,cAAc,CAAC,gBAAgB,CA4OxD,CAAA"}
+{"version":3,"file":"create-stair.d.ts","sourceRoot":"","sources":["../../src/agent-operations/create-stair.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAA;AAsB7D,OAAO,KAAK,EAAE,cAAc,EAA4B,MAAM,SAAS,CAAA;AA6DvE;;;;;;GAMG;AACH,eAAO,MAAM,WAAW,EAAE,cAAc,CAAC,gBAAgB,CAiQxD,CAAA"}