@pascal-app/core 1.0.3 → 1.0.5

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

@@ -0,0 +1,32 @@
+import { type RoofGlazing, type RoofSystemType, type RoofType } from '../schema/index.js';
+import type { AgentOperation } from './types.js';
+type Pt = [number, number];
+type CreateRoofInput = {
+    levelId?: string;
+    level?: string;
+    roofSystem?: RoofSystemType;
+    glazing?: RoofGlazing;
+    barrelRise?: number;
+    barrelSegments?: number;
+    wallThickness?: number;
+    roofType?: RoofType;
+    pitch?: number;
+    overhang?: number;
+    wallHeight?: number;
+    width?: number;
+    depth?: number;
+    center?: number[];
+    materialPreset?: string;
+    fasciaHeight?: number;
+    fasciaMaterialPreset?: string;
+    name?: string;
+};
+/** A polygon moved out by `distance` along each edge's outward normal, corners mitred up to the limit. */
+export declare function grown(polygon: Pt[], distance: number): Pt[];
+/**
+ * `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 declare const createRoof: AgentOperation<CreateRoofInput>;
+export {};
+//# sourceMappingURL=create-roof.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"create-roof.d.ts","sourceRoot":"","sources":["../../src/agent-operations/create-roof.ts"],"names":[],"mappings":"AAGA,OAAO,EAKL,KAAK,WAAW,EAGhB,KAAK,cAAc,EACnB,KAAK,QAAQ,EAEd,MAAM,WAAW,CAAA;AAQlB,OAAO,KAAK,EAAgB,cAAc,EAA4B,MAAM,SAAS,CAAA;AAErF,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AAI1B,KAAK,eAAe,GAAG;IACrB,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,UAAU,CAAC,EAAE,cAAc,CAAA;IAC3B,OAAO,CAAC,EAAE,WAAW,CAAA;IACrB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,EAAE,QAAQ,CAAA;IACnB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,MAAM,CAAC,EAAE,MAAM,EAAE,CAAA;IACjB,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,oBAAoB,CAAC,EAAE,MAAM,CAAA;IAC7B,IAAI,CAAC,EAAE,MAAM,CAAA;CACd,CAAA;AAmID,0GAA0G;AAC1G,wBAAgB,KAAK,CAAC,OAAO,EAAE,EAAE,EAAE,EAAE,QAAQ,EAAE,MAAM,GAAG,EAAE,EAAE,CA4B3D;AAiCD;;;GAGG;AACH,eAAO,MAAM,UAAU,EAAE,cAAc,CAAC,eAAe,CA0KtD,CAAA"}

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

@@ -0,0 +1,38 @@
+import { type LevelTargetInput } from './level-target.js';
+import { type Vec2 } from './plan-geometry.js';
+import type { AgentOperation } from './types.js';
+type OpeningSpec = {
+    wallIndex: number;
+    t?: number;
+    width?: number;
+    height?: number;
+    sillHeight?: number;
+    hingesSide?: 'left' | 'right';
+    handleSide?: 'left' | 'right';
+    swingDirection?: 'inward' | 'outward';
+    style?: string;
+};
+type CreateRoomInput = LevelTargetInput & {
+    name: string;
+    polygon: number[][];
+    color?: string;
+    wallHeight?: number;
+    wallThickness?: number;
+    outdoor?: boolean;
+    rename?: boolean;
+    doors?: OpeningSpec[];
+    windows?: OpeningSpec[];
+};
+/** Distance from `point` to the line through a and b, and where it projects along a → b (0..1). */
+export declare function edgeProjection(a: Vec2, b: Vec2, point: readonly number[]): {
+    distance: number;
+    t: number;
+};
+/**
+ * `create_room`: the editor's room command — walls where no wall runs yet, the zone that names the
+ * room — then the doors and windows declared by polygon edge, each placed as add_door / add_window
+ * place one. The floor plate and the ceiling are the host's to derive; the result reads them back.
+ */
+export declare const createRoom: AgentOperation<CreateRoomInput>;
+export {};
+//# sourceMappingURL=create-room.d.ts.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,245 @@
+import { isAgentRefusal, refuse } from '../agent-tools/refusal.js';
+import { doorFacing, planWallOpening } from '../building/wall-openings.js';
+import { createZone, walledRoomAt } from '../commands/structure/create-zone.js';
+import { structureChangeBatch } from '../commands/structure/shared.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';
+import { levelRole } from './scene-queries.js';
+// A wall counts as running along a polygon edge when both its ends sit this close to the edge's line.
+const EDGE_TOLERANCE = 0.2;
+const lerp = (a, b, t) => [
+    a[0] + (b[0] - a[0]) * t,
+    a[1] + (b[1] - a[1]) * t,
+];
+/** Distance from `point` to the line through a and b, and where it projects along a → b (0..1). */
+export function edgeProjection(a, b, point) {
+    const dx = b[0] - a[0];
+    const dz = b[1] - a[1];
+    const lengthSq = dx * dx + dz * dz;
+    if (lengthSq < 1e-12)
+        return { distance: Math.hypot(point[0] - a[0], point[1] - a[1]), t: 0 };
+    const rx = point[0] - a[0];
+    const rz = point[1] - a[1];
+    return {
+        distance: Math.abs(rx * dz - rz * dx) / Math.sqrt(lengthSq),
+        t: (rx * dx + rz * dz) / lengthSq,
+    };
+}
+const wallsOn = (nodes, levelId) => Object.values(nodes).filter((node) => node.type === 'wall' && node.parentId === levelId);
+/** The walls of the level that run along the edge a → b, both ends on its line. */
+function wallsAlong(nodes, levelId, a, b) {
+    return wallsOn(nodes, levelId).filter((wall) => {
+        const start = edgeProjection(a, b, wall.start);
+        const end = edgeProjection(a, b, wall.end);
+        return (start.distance < EDGE_TOLERANCE &&
+            end.distance < EDGE_TOLERANCE &&
+            Math.min(1, Math.max(start.t, end.t)) - Math.max(0, Math.min(start.t, end.t)) > 1e-6);
+    });
+}
+/**
+ * Where on which wall a point of a polygon edge falls: by position among the walls of the room's
+ * own level, never by the id a wall had — walls split and join, and the floor below has walls on
+ * the same line.
+ */
+function wallAt(nodes, levelId, a, b, point) {
+    for (const wall of wallsAlong(nodes, levelId, a, b)) {
+        const { t } = edgeProjection(wall.start, wall.end, point);
+        if (t >= -1e-6 && t <= 1 + 1e-6)
+            return { wallId: wall.id, t: Math.min(1, Math.max(0, t)) };
+    }
+    return null;
+}
+/** The construction the host derived for the room: its floor plate and its ceiling. */
+function derivedSurfaces(nodes, levelId, zoneId) {
+    const children = Object.values(nodes).filter((node) => node.parentId === levelId);
+    const slab = children.find((node) => node.type === 'slab' && node.boundary === 'auto' && node.zoneIds?.includes(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
+ * room — then the doors and windows declared by polygon edge, each placed as add_door / add_window
+ * place one. The floor plate and the ceiling are the host's to derive; the result reads them back.
+ */
+export const createRoom = (nodes, input, context) => {
+    const level = targetLevel(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, {
+            levelId: level.id,
+            polygon,
+            name: input.name,
+            enclose: !input.outdoor,
+            ...(input.rename ? { adoptNamed: true } : {}),
+            ...(input.outdoor
+                ? { intent: { hasCeiling: false } }
+                : {
+                    wall: {
+                        ...(input.wallHeight === undefined ? {} : { height: input.wallHeight }),
+                        ...(input.wallThickness === undefined ? {} : { thickness: input.wallThickness }),
+                    },
+                }),
+            mintId: generateId,
+        });
+    }
+    catch (error) {
+        if (!(error instanceof Error && error.name === 'Error'))
+            throw error;
+        if (/valid polygon/.test(error.message))
+            refuse('invalid_polygon', 'The polygon is not a room: give at least three corners in order, edges that do not cross, an area above 0.01 m².');
+        refuse('cannot_enclose', error.message, { levelId: level.id });
+    }
+    // The refusal takes the conflict's own code: today createZone reports only a terrace overlapping
+    // a room (outdoor-room-overlap), and an indoor conflict must not borrow that name.
+    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 && 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);
+    let scene = applySceneChanges(nodes, roomChanges);
+    const openings = [];
+    const skippedOpenings = [];
+    const place = (kind, specs = []) => specs.flatMap(({ wallIndex, t = 0.5, ...spec }, index) => {
+        const skip = (code, message) => {
+            skippedOpenings.push({ kind, index, code, message });
+            return [];
+        };
+        if (wallIndex >= polygon.length)
+            return skip('edge_out_of_range', `The polygon has ${polygon.length} edges (0–${polygon.length - 1}); there is no edge ${wallIndex}.`);
+        const a = polygon[wallIndex];
+        const b = polygon[(wallIndex + 1) % polygon.length];
+        const host = wallAt(scene, level.id, a, b, lerp(a, b, t));
+        if (!host)
+            return skip('no_wall', `No wall runs along edge ${wallIndex} at t ${t}.`);
+        try {
+            const planned = planWallOpening(scene, { kind, ...spec, wallId: host.wallId, t: host.t });
+            const create = { node: planned.node, parentId: planned.wallId };
+            scene = applySceneChanges(scene, { create: [create] });
+            openings.push(create);
+            return [planned.node.id];
+        }
+        catch (error) {
+            if (!isAgentRefusal(error))
+                throw error;
+            return skip(error.code, error.message);
+        }
+    });
+    const doorIds = place('door', input.doors);
+    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: 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: [
+            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 {
+        result,
+        changes: { ...roomChanges, create: [...roomChanges.create, ...openings] },
+        // The doors were planned before the host derived the room, so a new wall did not know its
+        // outside yet; once it does, a door on an outside wall faces out, as add_door's does.
+        afterReconcile: (derived) => {
+            const update = doorIds.flatMap((id) => {
+                const door = derived[id];
+                const wall = derived[door?.parentId ?? ''];
+                if (door?.type !== 'door' || wall?.type !== 'wall')
+                    return [];
+                const facing = doorFacing(wall);
+                return facing.side && facing.side !== door.side ? [{ id, data: facing }] : [];
+            });
+            return {
+                result: { ...result, ...derivedSurfaces(derived, level.id, plan.zoneId) },
+                ...(update.length ? { changes: { update } } : {}),
+            };
+        },
+    };
+};

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

@@ -0,0 +1,11 @@
+import type { CreateStairInput } from '../agent-tools/stairs.js';
+import type { AgentOperation } from './types.js';
+/**
+ * `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>;
+//# sourceMappingURL=create-stair.d.ts.map

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

@@ -0,0 +1 @@
+{"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"}