@pascal-app/core 1.0.4 → 1.0.5

package/dist/agent-operations/__fixtures__/structure-cases.js

@@ -1,4 +1,7 @@
 import { BuildingNode, CeilingNode, LevelNode, SiteNode, SlabNode, WallNode, ZoneNode, } from '../../schema/index.js';
+import { FOUNDATION_CONSTRUCTIONS } from '../../lib/foundation-construction.js';
+import { foundationWallConstruction } from '../../lib/foundation-wall.js';
+import { getLevelElevations } from '../../services/storey.js';
 const HALL = [
     [0, 0],
     [6, 0],
@@ -11,6 +14,16 @@ const graph = (...nodes) => ({
         .filter((node) => node.type === 'building')
         .map((node) => node.id),
 });
+/** The world floors (the stack's offsets added up) levels must stand at, as a list of what differs. */
+const levelFloorProblems = (nodes, expected) => {
+    const floors = getLevelElevations(nodes);
+    return Object.entries(expected).flatMap(([id, floor]) => {
+        const actual = floors.get(id)?.baseY;
+        return actual !== undefined && Math.abs(actual - floor) < 1e-9
+            ? []
+            : [`${id} stands at ${actual}, expected ${floor}`];
+    });
+};
 export function storeysScene() {
     const wall = WallNode.parse({
         id: 'wall_ground',
@@ -74,7 +87,283 @@ function soloScene() {
 }
 const bareBuildingScene = () => graph(BuildingNode.parse({ id: 'building_bare' }));
 const emptyScene = () => ({ nodes: {}, rootNodeIds: [] });
+/** A basement 2.8 m under a ground floor: the lower level stands below grade, the other at it. */
+function basementHouseScene() {
+    const base = LevelNode.parse({
+        id: 'level_base',
+        parentId: 'building_basement',
+        level: -1,
+        name: 'Basement',
+        height: 2.8,
+        baseElevation: -2.8,
+    });
+    const ground = LevelNode.parse({
+        id: 'level_main',
+        parentId: 'building_basement',
+        level: 0,
+        name: 'Main',
+        height: 2.8,
+    });
+    return graph(BuildingNode.parse({ id: 'building_basement', children: [base.id, ground.id] }), base, ground);
+}
+/** The basement with its 10 × 8 m perimeter already built of foundation walls. */
+function basementRoomScene() {
+    const scene = basementHouseScene();
+    const corners = [
+        [0, 0],
+        [10, 0],
+        [10, 8],
+        [0, 8],
+    ];
+    const walls = corners.map((start, index) => WallNode.parse({
+        id: `wall_base_${index}`,
+        parentId: 'level_base',
+        start,
+        end: corners[(index + 1) % 4],
+        ...foundationWallConstruction(FOUNDATION_CONSTRUCTIONS.cmu),
+    }));
+    const base = scene.nodes.level_base;
+    return {
+        ...scene,
+        nodes: {
+            ...scene.nodes,
+            level_base: { ...base, children: walls.map((wall) => wall.id) },
+            ...Object.fromEntries(walls.map((wall) => [wall.id, wall])),
+        },
+    };
+}
+const SHELL = [
+    [0, 0],
+    [6, 0],
+    [6, 4],
+    [0, 4],
+];
+/** The below-grade default: 8 in CMU core, 2x4 pressure-treated furring flat inside, thickness the sum. */
+function foundationWallProblems(wall) {
+    if (wall?.type !== 'wall')
+        return [`not a wall: ${JSON.stringify(wall)}`];
+    const [block, furring, ...rest] = wall.assembly?.layers ?? [];
+    const ok = block?.core === true &&
+        block.material === 'cmu' &&
+        Math.abs(block.thickness - 0.203) < 1e-9 &&
+        furring?.role === 'furring' &&
+        Math.abs(furring.thickness - 0.038) < 1e-9 &&
+        rest.length === 0 &&
+        wall.assembly?.face === 'exterior' &&
+        Math.abs((wall.thickness ?? 0) - 0.241) < 1e-9;
+    return ok ? [] : [`${wall.id} is not a foundation wall: ${JSON.stringify([wall.thickness, wall.assembly])}`];
+}
+function plainWallProblems(wall) {
+    return wall?.type === 'wall' && wall.assembly === undefined && (wall.thickness ?? 0.1) === 0.1
+        ? []
+        : [`expected a plain 0.1 m wall, got ${JSON.stringify(wall)}`];
+}
+/**
+ * `scene` standing on `site` the way a loaded project nests: the site holds the buildings, so every
+ * runner finds it.
+ */
+function onSite(scene, site) {
+    const nodes = { ...scene.nodes };
+    const buildings = Object.values(nodes).filter((node) => node.type === 'building');
+    for (const building of buildings)
+        nodes[building.id] = { ...building, parentId: site.id };
+    nodes[site.id] = { ...site, children: buildings.map((building) => building.id) };
+    return { nodes, rootNodeIds: [site.id] };
+}
+const dossierAt = (formatted) => ({
+    provider: 'pascal-map',
+    asOf: '2026-10-16',
+    address: { formatted },
+    sections: {},
+});
+/** The basement house on a site in Paris, in Austin, or with no site at all (`basementHouseScene`). */
+const parisBasementScene = () => onSite(basementHouseScene(), SiteNode.parse({ id: 'site_paris', dossier: dossierAt('12 Rue de Rivoli, 75004 Paris, France') }));
+const austinBasementScene = () => onSite(basementHouseScene(), SiteNode.parse({ id: 'site_austin', address: { city: 'Austin', state: 'Texas' } }));
+/** The cast-concrete default: membrane and insulation outside, 25 cm concrete core, thickness the sum. */
+function castConcreteWallProblems(wall) {
+    if (wall?.type !== 'wall')
+        return [`not a wall: ${JSON.stringify(wall)}`];
+    const [membrane, insulation, concrete, ...rest] = wall.assembly?.layers ?? [];
+    const ok = membrane?.role === 'membrane' &&
+        insulation?.role === 'insulation' &&
+        Math.abs(insulation.thickness - 0.1) < 1e-9 &&
+        concrete?.core === true &&
+        concrete.material === 'concrete' &&
+        Math.abs(concrete.thickness - 0.25) < 1e-9 &&
+        rest.length === 0 &&
+        wall.assembly?.face === 'exterior' &&
+        Math.abs((wall.thickness ?? 0) - 0.354) < 1e-9;
+    return ok ? [] : [`${wall.id} is not a cast concrete foundation wall: ${JSON.stringify([wall.thickness, wall.assembly])}`];
+}
+function stoneWallProblems(wall) {
+    if (wall?.type !== 'wall')
+        return [`not a wall: ${JSON.stringify(wall)}`];
+    const [stone, ...rest] = wall.assembly?.layers ?? [];
+    return stone?.core === true &&
+        stone.material === 'stone' &&
+        rest.length === 0 &&
+        Math.abs((wall.thickness ?? 0) - 0.5) < 1e-9
+        ? []
+        : [`${wall.id} is not a stone foundation wall: ${JSON.stringify([wall.thickness, wall.assembly])}`];
+}
 export const ADD_WALL_CASES = [
+    {
+        name: 'the first wall of a basement is an 8 in CMU foundation wall with 2x4 furring laid flat inside, and says so',
+        tool: 'add_wall',
+        scene: basementHouseScene,
+        input: { levelId: 'level_base', start: [0, 0], end: [6, 0] },
+        expect: {
+            result: { ok: true, levelId: 'level_base', construction: { thickness: 0.241 } },
+            mentions: ['foundation wall', 'CMU', 'furring'],
+            check: (result, nodes) => foundationWallProblems(nodes[result.wallId]),
+        },
+    },
+    {
+        name: 'a wall below grade given a thickness keeps it, with no stack',
+        tool: 'add_wall',
+        scene: basementHouseScene,
+        input: { levelId: 'level_base', start: [0, 0], end: [6, 0], thickness: 0.3 },
+        expect: {
+            result: { ok: true },
+            absent: ['construction'],
+            check: (result, nodes) => {
+                const wall = nodes[result.wallId];
+                return wall?.type === 'wall' && wall.thickness === 0.3 && wall.assembly === undefined
+                    ? []
+                    : [`expected a plain 0.3 m wall, got ${JSON.stringify(wall)}`];
+            },
+        },
+    },
+    {
+        name: 'a wall against the ground on a basement outline is a foundation wall',
+        tool: 'add_wall',
+        scene: basementRoomScene,
+        input: { levelId: 'level_base', start: [10, 2], end: [13, 2] },
+        expect: {
+            result: { ok: true, construction: { thickness: 0.241 } },
+            mentions: ['foundation wall', 'against the ground'],
+            check: (result, nodes) => foundationWallProblems(nodes[result.wallId]),
+        },
+    },
+    {
+        name: 'a partition inside the basement is an ordinary wall, and says so',
+        tool: 'add_wall',
+        scene: basementRoomScene,
+        input: { levelId: 'level_base', start: [5, 0], end: [5, 8] },
+        expect: {
+            result: { ok: true },
+            absent: ['construction'],
+            mentions: ['ordinary wall', 'partition', 'foundation wall'],
+            check: (result, nodes) => plainWallProblems(nodes[result.wallId]),
+        },
+    },
+    {
+        name: 'a basement wall on a site in Paris is cast concrete insulated and waterproofed outside, and names the region it read',
+        tool: 'add_wall',
+        scene: parisBasementScene,
+        input: { levelId: 'level_base', start: [0, 0], end: [6, 0] },
+        expect: {
+            result: { ok: true, construction: { thickness: 0.354, region: 'europe' } },
+            mentions: ['foundation wall', 'cast concrete', 'Europe', 'France'],
+            absent: ['CMU'],
+            check: (result, nodes) => castConcreteWallProblems(nodes[result.wallId]),
+        },
+    },
+    {
+        name: 'a basement wall on a site in Texas is the 8 in CMU block, and names the region it read',
+        tool: 'add_wall',
+        scene: austinBasementScene,
+        input: { levelId: 'level_base', start: [0, 0], end: [6, 0] },
+        expect: {
+            result: { ok: true, construction: { thickness: 0.241, region: 'us' } },
+            mentions: ['foundation wall', 'CMU', 'United States', 'TX'],
+            check: (result, nodes) => foundationWallProblems(nodes[result.wallId]),
+        },
+    },
+    {
+        name: 'a basement room on a site in Paris is built of cast concrete foundation walls',
+        tool: 'create_room',
+        scene: parisBasementScene,
+        input: {
+            levelId: 'level_base',
+            name: 'Cellar',
+            polygon: [
+                [0, 0],
+                [6, 0],
+                [6, 4],
+                [0, 4],
+            ],
+        },
+        expect: {
+            result: { ok: true, construction: { region: 'europe' } },
+            mentions: ['foundation walls', 'cast concrete', 'Europe'],
+            check: (result, nodes) => result.wallIds.flatMap((id) => castConcreteWallProblems(nodes[id])),
+        },
+    },
+    {
+        name: 'a room built inside the basement outline has ordinary walls, and says so',
+        tool: 'create_room',
+        scene: basementRoomScene,
+        input: {
+            levelId: 'level_base',
+            name: 'Storage',
+            polygon: [
+                [1, 1],
+                [4, 1],
+                [4, 4],
+                [1, 4],
+            ],
+        },
+        expect: {
+            result: { ok: true },
+            absent: ['construction'],
+            mentions: ['ordinary walls', 'partition'],
+            check: (result, nodes) => result.wallIds.flatMap((id) => plainWallProblems(nodes[id])),
+        },
+    },
+    {
+        name: 'a wall on the ground floor over a basement keeps the schema wall',
+        tool: 'add_wall',
+        scene: basementHouseScene,
+        input: { levelId: 'level_main', start: [0, 0], end: [6, 0] },
+        expect: {
+            result: { ok: true },
+            absent: ['construction'],
+            check: (result, nodes) => {
+                const wall = nodes[result.wallId];
+                return wall?.type === 'wall' && (wall.thickness ?? 0.1) === 0.1 && wall.assembly === undefined
+                    ? []
+                    : [`expected a plain 0.1 m wall, got ${JSON.stringify(wall)}`];
+            },
+        },
+    },
+    {
+        name: 'the walls of a room below grade, against the ground, are foundation walls: the result says so',
+        tool: 'create_room',
+        scene: basementHouseScene,
+        input: { levelId: 'level_base', name: 'Cellar', polygon: SHELL },
+        expect: {
+            result: { ok: true, construction: {} },
+            mentions: ['foundation walls', 'CMU'],
+            check: (result, nodes) => result.wallIds.flatMap((id) => foundationWallProblems(nodes[id])),
+        },
+    },
+    {
+        name: 'a room below grade given a wall thickness is built as asked',
+        tool: 'create_room',
+        scene: basementHouseScene,
+        input: { levelId: 'level_base', name: 'Cellar', polygon: SHELL, wallThickness: 0.2 },
+        expect: {
+            result: { ok: true },
+            absent: ['construction'],
+            check: (result, nodes) => result.wallIds.flatMap((id) => {
+                const wall = nodes[id];
+                return wall?.type === 'wall' && wall.thickness === 0.2 && wall.assembly === undefined
+                    ? []
+                    : [`${id} is not a plain 0.2 m wall: ${JSON.stringify(wall)}`];
+            }),
+        },
+    },
     {
         name: 'a wall on the level named, numbered as the editor numbers walls',
         tool: 'add_wall',
@@ -95,7 +384,6 @@ export const ADD_WALL_CASES = [
         scene: storeysScene,
         input: { start: [0, 0], end: [4, 0] },
         context: { activeLevelId: 'level_upper' },
-        surfaces: ['core', 'chat'],
         expect: { result: { levelId: 'level_upper' } },
     },
     {
@@ -141,18 +429,156 @@ export const ADD_WALL_CASES = [
         expect: { refusal: 'wall_too_short' },
     },
 ];
+const fencesOn = (nodes, levelId) => Object.values(nodes).filter((node) => node.type === 'fence' && node.parentId === levelId);
+export const ADD_FENCE_CASES = [
+    {
+        name: 'one fence per side along the points, privacy panels unless asked',
+        tool: 'add_fence',
+        scene: storeysScene,
+        input: {
+            levelId: 'level_ground',
+            points: [
+                [0, 0],
+                [8, 0],
+                [8, 6],
+            ],
+        },
+        expect: {
+            result: { ok: true, count: 2, levelId: 'level_ground', length: 14 },
+            check: (_, nodes) => {
+                const fences = fencesOn(nodes, 'level_ground');
+                return fences.length === 2 && fences.every((fence) => fence.style === 'privacy')
+                    ? []
+                    : [`${fences.length} fences on the ground floor, styles ${fences.map((f) => f.style)}`];
+            },
+        },
+    },
+    {
+        name: "closed runs back to the first point, a lot's boundary",
+        tool: 'add_fence',
+        scene: storeysScene,
+        input: {
+            levelId: 'level_ground',
+            closed: true,
+            style: 'picket',
+            points: [
+                [0, 0],
+                [10, 0],
+                [10, 10],
+                [0, 10],
+            ],
+        },
+        expect: { result: { ok: true, count: 4, length: 40 } },
+    },
+    {
+        name: 'a side shorter than 10 cm is refused, nothing built',
+        tool: 'add_fence',
+        scene: storeysScene,
+        input: {
+            levelId: 'level_ground',
+            points: [
+                [0, 0],
+                [4, 0],
+                [4, 0.05],
+            ],
+        },
+        expect: { refusal: 'fence_too_short' },
+    },
+    {
+        name: 'a roof level takes no fence',
+        tool: 'add_fence',
+        scene: storeysScene,
+        input: {
+            levelId: 'level_roof',
+            points: [
+                [0, 0],
+                [4, 0],
+            ],
+        },
+        expect: { refusal: 'roof_level', mentions: ['level_roof'] },
+    },
+    {
+        name: 'a finish the library lacks is refused with the nearest',
+        tool: 'add_fence',
+        scene: storeysScene,
+        input: {
+            levelId: 'level_ground',
+            materialPreset: 'library:unobtainium',
+            points: [
+                [0, 0],
+                [4, 0],
+            ],
+        },
+        expect: { refusal: 'unknown_material' },
+    },
+];
 export const ADD_LEVEL_CASES = [
+    {
+        name: 'a basement says what a new wall on it is built of',
+        tool: 'add_level',
+        scene: storeysScene,
+        input: { buildingId: 'building_house', position: 'below', height: 2.8, name: 'Cellar' },
+        expect: {
+            result: { ok: true },
+            check: (result) => typeof result.wallConstruction === 'string' && /CMU/.test(result.wallConstruction)
+                ? []
+                : ['the result does not say what a wall on the basement is built of'],
+            mentions: ['foundation wall', 'CMU'],
+        },
+    },
+    {
+        name: 'a storey above the ground floor says nothing of foundation walls',
+        tool: 'add_level',
+        scene: storeysScene,
+        input: { buildingId: 'building_house', height: 2.8 },
+        expect: { result: { ok: true }, absent: ['wallConstruction'] },
+    },
+    {
+        name: 'add_level below on a site in Paris says its walls are cast concrete, and the region',
+        tool: 'add_level',
+        scene: () => onSite(storeysScene(), SiteNode.parse({ id: 'site_paris', dossier: dossierAt('Paris, France') })),
+        input: { buildingId: 'building_house', position: 'below' },
+        expect: {
+            result: { ok: true },
+            mentions: ['below grade', 'cast concrete', 'Europe'],
+        },
+    },
+    {
+        name: 'set_ground_level on a site in Paris seats the building 0.15 m over grade, as cast concrete foundations do',
+        tool: 'set_ground_level',
+        scene: () => onSite(storeysScene(), SiteNode.parse({ id: 'site_paris', dossier: dossierAt('Paris, France') })),
+        input: { levelId: 'level_ground' },
+        expect: {
+            result: {
+                ok: true,
+                floorElevation: 0.15,
+                aboveGrade: 0.15,
+                foundation: { region: 'europe', construction: 'cast-concrete' },
+            },
+            mentions: ['cast concrete', 'Europe'],
+            after: { building_house: { position: [0, 0.15, 0], groundLevelId: 'level_ground' } },
+        },
+    },
     {
         name: 'above the highest level of the viewed building, at the default storey height',
         tool: 'add_level',
         scene: storeysScene,
         input: { name: 'Attic' },
         context: { activeLevelId: 'level_ground' },
-        surfaces: ['core', 'chat'],
         expect: {
             result: { ok: true, buildingId: 'building_house', floorIndex: 2, name: 'Attic', height: 2.5 },
         },
     },
+    {
+        name: 'on top of the storeys, under the roof level, which moves up one',
+        tool: 'add_level',
+        scene: storeysScene,
+        input: { buildingId: 'building_roofed' },
+        expect: {
+            result: { ok: true, floorIndex: 1, shiftedLevelIds: ['level_roof'] },
+            after: { level_roof: { level: 2 } },
+        },
+    },
     {
         name: 'below the lowest level for a basement, at the height asked',
         tool: 'add_level',
@@ -160,6 +586,95 @@ export const ADD_LEVEL_CASES = [
         input: { buildingId: 'building_house', position: 'below', height: '3 m' },
         expect: { result: { buildingId: 'building_house', floorIndex: -1, height: 3 } },
     },
+    {
+        name: 'a basement goes under the lowest floor and every floor keeps its place',
+        tool: 'add_level',
+        scene: storeysScene,
+        input: { buildingId: 'building_house', position: 'below', height: 3 },
+        expect: {
+            result: { ok: true, floorIndex: -1, height: 3 },
+            check: (result, nodes) => levelFloorProblems(nodes, { [result.levelId]: -3, level_ground: 0 }),
+        },
+    },
+    {
+        name: 'a second basement goes under the first, the floors above where they were',
+        tool: 'run_batch',
+        scene: storeysScene,
+        input: {
+            calls: [
+                {
+                    tool: 'add_level',
+                    input: { buildingId: 'building_house', position: 'below', height: 3, name: 'Basement' },
+                },
+                {
+                    tool: 'add_level',
+                    input: { buildingId: 'building_house', position: 'below', height: 2.5, name: 'Basement 2' },
+                },
+            ],
+        },
+        expect: {
+            result: { status: 'applied', applied: 2, refused: 0 },
+            check: (_result, nodes) => {
+                const named = (name) => Object.values(nodes).find((node) => node.type === 'level' && node.name === name)?.id ?? '';
+                return levelFloorProblems(nodes, {
+                    [named('Basement')]: -3,
+                    [named('Basement 2')]: -5.5,
+                    level_ground: 0,
+                });
+            },
+        },
+    },
+    {
+        name: 'set_ground_level on the upper floor renumbers: it is 0, the floor under it is -1',
+        tool: 'set_ground_level',
+        scene: storeysScene,
+        input: { levelId: 'level_upper' },
+        expect: {
+            result: { ok: true, renumbered: true, floorElevation: 0.203 },
+            after: {
+                level_upper: { level: 0 },
+                level_ground: { level: -1 },
+                building_house: { groundLevelId: 'level_upper' },
+            },
+        },
+    },
+    {
+        name: 'set_ground_level on a roof level is refused',
+        tool: 'set_ground_level',
+        scene: storeysScene,
+        input: { levelId: 'level_roof' },
+        expect: { refusal: 'not_a_storey', mentions: ['level_roof'] },
+    },
+    {
+        name: 'set_ground_level on an unknown level is refused with the id',
+        tool: 'set_ground_level',
+        scene: storeysScene,
+        input: { levelId: 'level_missing' },
+        expect: { refusal: 'level_not_found', mentions: ['level_missing'] },
+    },
+    {
+        name: 'set_ground_level on a node that is not a level is refused',
+        tool: 'set_ground_level',
+        scene: storeysScene,
+        input: { levelId: 'building_house' },
+        expect: { refusal: 'not_a_level' },
+    },
+    {
+        name: 'list_levels names the level at grade, its standing, and whether the building names it',
+        tool: 'list_levels',
+        scene: storeysScene,
+        input: {},
+        expect: {
+            result: {},
+            contains: {
+                groundLevels: [{ buildingId: 'building_house', levelId: 'level_ground', named: false }],
+                levels: [
+                    { id: 'level_ground', isGroundLevel: true, gradeStanding: 'at-grade' },
+                    { id: 'level_upper', isGroundLevel: false, gradeStanding: 'at-grade' },
+                ],
+            },
+        },
+    },
     {
         name: 'the scene’s only building needs no id',
         tool: 'add_level',
@@ -286,6 +801,40 @@ function splitScene(eastSlab = true) {
     };
     return scene;
 }
+/**
+ * The house with its upper floor in two rooms: a hall wrapping an L stair at (1, 0.3), its flights
+ * and landing, and a bedroom over the corner the L leaves inside, where its footprint's middle lies.
+ */
+function wrappedScene() {
+    const scene = storeysScene();
+    const hall = SlabNode.parse({
+        id: 'slab_upper',
+        parentId: 'level_upper',
+        polygon: [
+            [0, 0],
+            [1.7, 0],
+            [1.7, 2.4],
+            [5.5, 2.4],
+            [5.5, 4],
+            [0, 4],
+        ],
+    });
+    const bedroom = SlabNode.parse({
+        id: 'slab_bedroom',
+        parentId: 'level_upper',
+        polygon: [
+            [1.7, 0],
+            [5.5, 0],
+            [5.5, 2.4],
+            [1.7, 2.4],
+        ],
+    });
+    scene.nodes.slab_upper = hall;
+    scene.nodes.slab_bedroom = bedroom;
+    const upper = scene.nodes.level_upper;
+    scene.nodes.level_upper = { ...upper, children: [hall.id, bedroom.id] };
+    return scene;
+}
 const stairOf = (nodes) => Object.values(nodes).find((node) => node.type === 'stair');
 const openingsOf = (nodes) => Object.values(nodes).filter((node) => node.type === 'floor-opening');
 /** An outline's extent: [minX, minZ, maxX, maxZ]. */
@@ -320,7 +869,6 @@ export const CREATE_STAIR_CASES = [
         scene: storeysScene,
         input: { x: 3, z: 4, rotation: '180°', height: 2.8, steps: 14, width: '90 cm' },
         context: { activeLevelId: 'level_ground' },
-        surfaces: ['core', 'chat'],
         expect: {
             result: {
                 fromLevelId: 'level_ground',
@@ -585,4 +1133,83 @@ export const CREATE_STAIR_CASES = [
         input: { levelId: 'level_missing', x: 1, z: 1 },
         expect: { refusal: 'level_not_found', mentions: ['level_missing'] },
     },
+    {
+        // The default opening as given is the stair's footprint, whatever its shape.
+        name: "a U's opening as given spans the stair's footprint, the margin round it",
+        tool: 'create_stair',
+        scene: ceiledScene,
+        input: {
+            levelId: 'level_ground',
+            x: 1,
+            z: 0.5,
+            layout: 'u',
+            openingWidth: 2.2,
+            createSourceCeilingOpening: false,
+        },
+        expect: {
+            // 2 m across the two flights, 1 + 2.24 m along: 2.2 m across as asked, 0.08 m round it.
+            result: { ok: true, slabHoleCut: true, footprint: { minX: 0.5, minZ: 0.5, maxX: 2.5 } },
+            check: (_result, nodes) => {
+                const [opening] = openingsOf(nodes);
+                return spans(opening?.polygon, [0.32, 0.42, 2.68, 3.82])
+                    ? []
+                    : [`spans ${opening && extent(opening.polygon)}`];
+            },
+        },
+    },
+    {
+        name: "an L's opening as given goes through the slab over its flights, not the one under its middle",
+        tool: 'create_stair',
+        scene: wrappedScene,
+        input: { levelId: 'level_ground', x: 1, z: 0.3, layout: 'l', createSourceCeilingOpening: false },
+        expect: { result: { ok: true, slabHoleCut: true, destinationSlabId: 'slab_upper' } },
+    },
+    {
+        name: 'a turn or lower flight with no L or U is refused',
+        tool: 'create_stair',
+        scene: storeysScene,
+        input: { levelId: 'level_ground', x: 3, z: 1, turn: 'right' },
+        expect: { refusal: 'stair_layout_required', mentions: ['layout'] },
+    },
+    {
+        name: 'a lower flight that leaves the upper one no riser is refused with the range',
+        tool: 'create_stair',
+        scene: storeysScene,
+        input: { levelId: 'level_ground', x: 3, z: 1, layout: 'l', lowerSteps: 16 },
+        expect: { refusal: 'stair_layout', mentions: ['1 to 15'] },
+    },
+    {
+        name: 'an L of fewer than four risers is refused',
+        tool: 'create_stair',
+        scene: storeysScene,
+        input: { levelId: 'level_ground', x: 3, z: 1, layout: 'l', steps: 3 },
+        expect: { refusal: 'stair_layout', mentions: ['An L stair needs at least 4 risers'] },
+    },
+    {
+        name: 'a flight to no level with an opening asked is refused',
+        tool: 'create_stair',
+        scene: storeysScene,
+        input: { levelId: 'level_ground', x: 3, z: 1, toLevelId: null, openingWidth: 1.2 },
+        expect: { refusal: 'no_level_above', mentions: ['toLevelId'] },
+    },
+    {
+        name: 'from the top storey, a flight to no level makes no level',
+        tool: 'create_stair',
+        scene: soloScene,
+        input: { x: 1, z: 1, toLevelId: null, height: '18 in' },
+        expect: {
+            result: { ok: true, upperLevelId: null, createdUpperLevel: false, stepCount: 3, rise: 0.457 },
+            check: (_result, nodes) => {
+                const levels = Object.values(nodes).filter((node) => node.type === 'level');
+                return levels.length === 1 ? [] : [`${levels.length} levels`];
+            },
+        },
+    },
+    {
+        name: 'a railing finish the library lacks is refused, naming the field',
+        tool: 'create_stair',
+        scene: storeysScene,
+        input: { levelId: 'level_ground', x: 3, z: 1, railingMaterial: 'library:brass-rail' },
+        expect: { refusal: 'unknown_material', mentions: ['railingMaterial', 'library:brass-rail'] },
+    },
 ];