@pascal-app/core 1.0.3 → 1.0.5

package/dist/agent-operations/__fixtures__/build-room-cases.js

@@ -0,0 +1,1005 @@
+import { BuildingNode, DoorNode, ItemNode, LevelNode, WallNode, WindowNode, ZoneNode, } from '../../schema/index.js';
+import { doorFacing } from '../../building/wall-openings.js';
+import { area as clippedArea, difference } from '../../lib/polygon-boolean.js';
+import { reconcileSceneStructure } from '../../lib/structure-reconcile.js';
+import { findBlockedDoors, itemNodePlanCorners } from '../door-clearance.js';
+import { findItemItemCollisions, findItemsMidRoom } from '../layout-clearance.js';
+const graph = (...nodes) => ({
+    nodes: Object.fromEntries(nodes.map((node) => [node.id, node])),
+    rootNodeIds: nodes
+        .filter((node) => node.type === 'building')
+        .map((node) => node.id),
+});
+const KITCHEN = [
+    [10, 0],
+    [14, 0],
+    [14, 3],
+    [10, 3],
+];
+/** A 4 × 3 m room clear of everything on either floor. */
+const CLEAR = [
+    [0, 5],
+    [4, 5],
+    [4, 8],
+    [0, 8],
+];
+function roomsScene() {
+    const door = DoorNode.parse({
+        id: 'door_g',
+        parentId: 'wall_g',
+        wallId: 'wall_g',
+        position: [1, 1.05, 0],
+    });
+    const window = WindowNode.parse({
+        id: 'window_g',
+        parentId: 'wall_g',
+        wallId: 'wall_g',
+        width: 1,
+        height: 1.2,
+        position: [3, 1.5, 0],
+    });
+    const wallG = WallNode.parse({
+        id: 'wall_g',
+        parentId: 'level_g',
+        start: [0, 0],
+        end: [4, 0],
+        height: 2.5,
+        children: [door.id, window.id],
+    });
+    const kitchen = ZoneNode.parse({
+        id: 'zone_kitchen',
+        parentId: 'level_g',
+        name: 'Kitchen',
+        polygon: KITCHEN,
+        spaceRole: 'room',
+    });
+    const wallU = WallNode.parse({
+        id: 'wall_u',
+        parentId: 'level_u',
+        start: [0, 0],
+        end: [4, 0],
+        height: 2.5,
+    });
+    const ground = LevelNode.parse({
+        id: 'level_g',
+        parentId: 'building_b',
+        level: 0,
+        name: 'Ground',
+        height: 2.8,
+        children: [wallG.id, kitchen.id],
+    });
+    const upper = LevelNode.parse({
+        id: 'level_u',
+        parentId: 'building_b',
+        level: 1,
+        name: 'Upper',
+        height: 2.8,
+        children: [wallU.id],
+    });
+    const roof = LevelNode.parse({
+        id: 'level_r',
+        parentId: 'building_b',
+        level: 2,
+        name: 'Roof',
+        metadata: { role: 'roof' },
+    });
+    const building = BuildingNode.parse({
+        id: 'building_b',
+        children: [ground.id, upper.id, roof.id],
+    });
+    return graph(building, ground, upper, roof, wallG, door, window, kitchen, wallU);
+}
+/**
+ * Run 6's order: walls drawn first, one add_wall each, round CLEAR (and `extra` inside it), then the
+ * rooms the reconciler made of them, "Room 1" first; `renamed` is a name a person gave it since.
+ */
+function walledScene({ extra = [], renamed } = {}) {
+    return () => {
+        const base = roomsScene().nodes;
+        const walls = [...CLEAR.map((point, i) => [point, CLEAR[(i + 1) % 4]]), ...extra].map(([start, end], i) => WallNode.parse({ id: `wall_c${i}`, parentId: 'level_g', start, end, height: 2.5 }));
+        const level = base.level_g;
+        let nodes = {
+            ...base,
+            level_g: { ...level, children: [...level.children, ...walls.map((wall) => wall.id)] },
+            ...Object.fromEntries(walls.map((wall) => [wall.id, wall])),
+        };
+        const names = { zone: ['zone_walled', 'zone_side'] };
+        let count = 0;
+        nodes = reconcileSceneStructure({
+            nodes,
+            mintId: (kind) => names[kind]?.shift() ?? `${kind}_walled${++count}`,
+        }).nodes;
+        if (renamed)
+            nodes.zone_walled = { ...nodes.zone_walled, name: renamed };
+        return graph(...Object.values(nodes));
+    };
+}
+// ─── Checks the table cannot state: minted ids and derived construction ───────────────────────
+const problems = (...entries) => entries.flatMap(([ok, problem]) => (ok ? [] : [problem]));
+const wallsOn = (nodes, levelId) => Object.values(nodes).filter((node) => node.type === 'wall' && node.parentId === levelId);
+/** Where an opening stands on the plan: along its wall from the wall's start. */
+function openingPlanPoint(nodes, id) {
+    const opening = nodes[id];
+    const wall = opening?.parentId ? nodes[opening.parentId] : undefined;
+    if (!(opening?.position && wall?.type === 'wall'))
+        return null;
+    const length = Math.hypot(wall.end[0] - wall.start[0], wall.end[1] - wall.start[1]);
+    const t = opening.position[0] / length;
+    return [
+        wall.start[0] + t * (wall.end[0] - wall.start[0]),
+        wall.start[1] + t * (wall.end[1] - wall.start[1]),
+    ];
+}
+const near = (a, b) => Math.abs(a - b) < 1e-6;
+/** The room the result names: its zone, its walls in edge order, its derived floor and ceiling. */
+function roomBuilt(levelId, name, edges) {
+    return (result, nodes) => {
+        const zone = nodes[result.zoneId];
+        const wallIds = result.wallIds;
+        const slab = nodes[result.slabId];
+        const ceiling = nodes[result.ceilingId];
+        return problems([
+            zone?.type === 'zone' &&
+                zone.parentId === levelId &&
+                zone.name === name &&
+                zone.spaceRole === 'room',
+            `zone ${String(result.zoneId)} is not the room "${name}" on ${levelId}`,
+        ], 
+        // The reconciler adopted the room the call wrote rather than minting one of its own.
+        [
+            zone?.type === 'zone' && zone.autoFromWalls === true,
+            `zone ${String(result.zoneId)} was not adopted by the reconciler`,
+        ], [
+            wallIds.length === edges && new Set(wallIds).size === edges,
+            `wallIds ${JSON.stringify(wallIds)} is not one wall per edge`,
+        ], [
+            wallIds.every((id) => id && nodes[id]?.type === 'wall' && nodes[id]?.parentId === levelId),
+            `wallIds ${JSON.stringify(wallIds)} are not walls of ${levelId}`,
+        ], [
+            slab?.type === 'slab' &&
+                slab.boundary === 'auto' &&
+                !!slab.zoneIds?.includes(result.zoneId),
+            `slabId ${String(result.slabId)} is not the room's derived floor plate`,
+        ], [
+            ceiling?.type === 'ceiling' &&
+                ceiling.boundary === 'auto' &&
+                ceiling.zoneId === result.zoneId,
+            `ceilingId ${String(result.ceilingId)} is not the room's derived ceiling`,
+        ]);
+    };
+}
+/** The room zones of the ground floor inside CLEAR's box: the one per walled space there. */
+const roomsInClear = (nodes) => Object.values(nodes).filter((node) => node.type === 'zone' &&
+    node.parentId === 'level_g' &&
+    node.spaceRole === 'room' &&
+    node.polygon.every(([x, z]) => x >= -0.01 && x <= 4.01 && z >= 4.99 && z <= 8.01));
+const area = (polygon) => Math.abs(polygon.reduce((sum, [x, z], i) => {
+    const [nx, nz] = polygon[(i + 1) % polygon.length];
+    return sum + x * nz - nx * z;
+}, 0) / 2);
+const roomOn = (levelId) => (result, nodes) => problems([
+    nodes[result.zoneId]?.parentId === levelId,
+    `the room is on ${String(nodes[result.zoneId]?.parentId)}, not ${levelId}`,
+]);
+const room = (input) => ({ name: 'Bedroom', polygon: CLEAR, ...input });
+export const CREATE_ROOM_CASES = [
+    // A door declared with a new room is planned before the host knows the new walls' outside;
+    // once the room is derived, a door on an outside wall faces out, as add_door's does.
+    {
+        name: "a door declared on a new room's outside wall faces out",
+        tool: 'create_room',
+        scene: roomsScene,
+        input: { levelId: 'level_g', name: 'Studio', polygon: CLEAR, doors: [{ wallIndex: 0 }] },
+        expect: {
+            result: { ok: true },
+            check: (result, nodes) => {
+                const [doorId] = result.doorIds;
+                const door = nodes[doorId];
+                const wall = nodes[door?.parentId ?? ''];
+                const facing = wall?.type === 'wall' ? doorFacing(wall) : undefined;
+                return problems([facing?.side !== undefined, `the wall does not know its outside: ${JSON.stringify(wall)}`], [
+                    door?.type === 'door' && door.side === facing?.side,
+                    `the door faces ${door?.type === 'door' ? door.side : '?'}, its wall's outside is ${facing?.side}`,
+                ]);
+            },
+        },
+    },
+    {
+        name: 'a room is a wall per edge and a zone; its floor plate and ceiling are derived',
+        tool: 'create_room',
+        scene: roomsScene,
+        input: room({ levelId: 'level_g' }),
+        expect: {
+            result: { ok: true, reusedWalls: 0, areaSqMeters: 12, doorIds: [], windowIds: [] },
+            check: roomBuilt('level_g', 'Bedroom', 4),
+        },
+    },
+    {
+        name: 'an edge a wall already runs along reuses that wall, its door and window kept',
+        tool: 'create_room',
+        scene: roomsScene,
+        input: {
+            levelId: 'level_g',
+            name: 'Hall',
+            polygon: [
+                [0, 0],
+                [4, 0],
+                [4, -3],
+                [0, -3],
+            ],
+        },
+        expect: {
+            result: { ok: true, reusedWalls: 1 },
+            after: { wall_g: { children: ['door_g', 'window_g'] } },
+            check: (result, nodes) => [
+                ...roomBuilt('level_g', 'Hall', 4)(result, nodes),
+                ...problems([
+                    result.wallIds[0] === 'wall_g',
+                    `edge 0 is ${result.wallIds[0]}, not the wall already there`,
+                ]),
+            ],
+        },
+    },
+    // The 2026-09-03 defect: the chat bound an upper room's openings to the collinear wall below.
+    {
+        name: "openings go on the walls of the room's own level, never the collinear wall below",
+        tool: 'create_room',
+        scene: roomsScene,
+        input: {
+            levelId: 'level_u',
+            name: 'Study',
+            polygon: [
+                [0, 0],
+                [4, 0],
+                [4, 3],
+                [0, 3],
+            ],
+            doors: [{ wallIndex: 0, t: 0.25 }],
+            windows: [{ wallIndex: 2 }],
+        },
+        expect: {
+            result: { ok: true, reusedWalls: 1 },
+            after: { wall_g: { children: ['door_g', 'window_g'] } },
+            check: (result, nodes) => {
+                const [doorId] = result.doorIds;
+                const [windowId] = result.windowIds;
+                const windowWall = nodes[nodes[windowId]?.parentId ?? ''];
+                return problems([nodes[doorId]?.parentId === 'wall_u', `the door hangs off ${nodes[doorId]?.parentId}`], [
+                    windowWall?.type === 'wall' && windowWall.parentId === 'level_u',
+                    `the window hangs off ${windowWall?.id} on ${windowWall?.parentId}`,
+                ], [
+                    near(openingPlanPoint(nodes, doorId)?.[0] ?? -1, 1),
+                    `the door is not a quarter along edge 0: ${openingPlanPoint(nodes, doorId)}`,
+                ]);
+            },
+        },
+    },
+    {
+        name: 'a room across a wall splits it; the door and window stay where they stood',
+        tool: 'create_room',
+        scene: roomsScene,
+        input: {
+            levelId: 'level_g',
+            name: 'Den',
+            polygon: [
+                [2, 0],
+                [6, 0],
+                [6, 3],
+                [2, 3],
+            ],
+        },
+        expect: {
+            result: { ok: true },
+            present: ['door_g', 'window_g'],
+            check: (result, nodes) => problems(...['door_g', 'window_g'].map((id) => {
+                const wall = nodes[nodes[id]?.parentId ?? ''];
+                return [
+                    wall?.type === 'wall' && wall.parentId === 'level_g',
+                    `${id} hangs off ${wall?.id}, not a wall of level_g`,
+                ];
+            }), [near(openingPlanPoint(nodes, 'door_g')?.[0] ?? -1, 1), 'door_g moved'], [near(openingPlanPoint(nodes, 'window_g')?.[0] ?? -1, 3), 'window_g moved'], [
+                !!nodes[result.zoneId] && !!nodes[result.ceilingId],
+                'the room has no zone or no derived ceiling',
+            ]),
+        },
+    },
+    {
+        name: 'two declared doors that overlap: the second is skipped with its code, the room stands',
+        tool: 'create_room',
+        scene: roomsScene,
+        input: room({
+            levelId: 'level_g',
+            doors: [
+                { wallIndex: 0, t: 0.5 },
+                { wallIndex: 0, t: 0.55 },
+            ],
+        }),
+        expect: {
+            result: { ok: true },
+            contains: { skippedOpenings: [{ kind: 'door', index: 1, code: 'opening_overlap' }] },
+            check: (result) => problems([result.doorIds.length === 1, 'not exactly one door built']),
+        },
+    },
+    {
+        name: 'a door wider than its edge is skipped: wall_too_short',
+        tool: 'create_room',
+        scene: roomsScene,
+        input: room({
+            levelId: 'level_g',
+            name: 'Closet',
+            polygon: [
+                [0, 5],
+                [0.8, 5],
+                [0.8, 8],
+                [0, 8],
+            ],
+            doors: [{ wallIndex: 0 }],
+        }),
+        expect: {
+            result: { ok: true, doorIds: [] },
+            contains: { skippedOpenings: [{ kind: 'door', index: 0, code: 'wall_too_short' }] },
+        },
+    },
+    {
+        name: 'an edge the polygon does not have is skipped: edge_out_of_range',
+        tool: 'create_room',
+        scene: roomsScene,
+        input: room({ levelId: 'level_g', windows: [{ wallIndex: 7 }] }),
+        expect: {
+            result: { ok: true, windowIds: [] },
+            contains: { skippedOpenings: [{ kind: 'window', index: 0, code: 'edge_out_of_range' }] },
+        },
+    },
+    {
+        name: 'a window is centred on its wall, as add_window places it; a door takes its size, hinge, swing and style',
+        tool: 'create_room',
+        scene: roomsScene,
+        input: room({
+            levelId: 'level_g',
+            windows: [{ wallIndex: 2 }],
+            doors: [
+                {
+                    wallIndex: 0,
+                    width: '36 in',
+                    hingesSide: 'right',
+                    swingDirection: 'outward',
+                    style: 'glass',
+                },
+            ],
+        }),
+        expect: {
+            result: { ok: true },
+            check: (result, nodes) => {
+                const window = nodes[result.windowIds[0]];
+                const door = nodes[result.doorIds[0]];
+                // Centred on the wall as it stands when the room is made, the storey's 2.8 m: the floor plate
+                // is derived afterwards, and a later add_window sees the slab (a window 2.5 cm lower).
+                const wall = window?.type === 'window' && window.wallId ? nodes[window.wallId] : undefined;
+                const level = wall?.parentId ? nodes[wall.parentId] : undefined;
+                const ceiling = level?.type === 'level' ? (level.height ?? Number.NaN) : Number.NaN;
+                return problems([
+                    window?.type === 'window' &&
+                        near(window.position[1], ceiling / 2) &&
+                        window.width === 1.5,
+                    `window ${JSON.stringify(window)} is not 1.5 m wide and centred on its ${ceiling} m wall`,
+                ], [
+                    door?.type === 'door' &&
+                        Math.abs(door.width - 0.9144) < 1e-4 &&
+                        door.hingesSide === 'right' &&
+                        door.swingDirection === 'outward',
+                    `door ${JSON.stringify(door)} is not 36 in, hinged right, opening outward`,
+                ]);
+            },
+        },
+    },
+    {
+        name: 'level is the same field as levelId',
+        tool: 'create_room',
+        scene: roomsScene,
+        input: room({ level: 'level_u' }),
+        expect: { result: { ok: true }, check: roomOn('level_u') },
+    },
+    {
+        name: 'without a level, the floor the person is viewing',
+        tool: 'create_room',
+        scene: roomsScene,
+        input: room({}),
+        context: { activeLevelId: 'level_u' },
+        expect: { result: { ok: true }, check: roomOn('level_u') },
+    },
+    {
+        name: 'without a level or a viewed floor, the lowest storey',
+        tool: 'create_room',
+        scene: roomsScene,
+        input: room({}),
+        expect: { result: { ok: true }, check: roomOn('level_g') },
+    },
+    {
+        name: 'outdoor: a terrace closed by separators, no walls of its own and no ceiling',
+        tool: 'create_room',
+        scene: roomsScene,
+        input: {
+            levelId: 'level_g',
+            name: 'Terrace',
+            outdoor: true,
+            polygon: [
+                [0, 10],
+                [4, 10],
+                [4, 13],
+                [0, 13],
+            ],
+        },
+        expect: {
+            result: { ok: true, wallIds: [null, null, null, null], ceilingId: null },
+            check: (result, nodes) => {
+                const zone = nodes[result.zoneId];
+                const separators = Object.values(nodes).filter((node) => node.type === 'separator' && node.parentId === 'level_g');
+                return problems([
+                    zone?.type === 'zone' && zone.name === 'Terrace' && zone.hasCeiling === false,
+                    'no terrace zone without a ceiling',
+                ], [separators.length === 4, `${separators.length} separators, not 4`], [wallsOn(nodes, 'level_g').length === 1, 'the terrace built walls'], [nodes[result.slabId]?.type === 'slab', 'the terrace has no derived floor']);
+            },
+        },
+    },
+    {
+        name: 'outdoor over a room is refused and names it',
+        tool: 'create_room',
+        scene: roomsScene,
+        input: {
+            levelId: 'level_g',
+            name: 'Terrace',
+            outdoor: true,
+            polygon: [
+                [11, 1],
+                [13, 1],
+                [13, 2],
+                [11, 2],
+            ],
+        },
+        expect: { refusal: 'outdoor_room_overlap', mentions: ['Kitchen'] },
+    },
+    // Run 6: 54 walls drawn first, then 14 create_room calls, each stacking its named zone on the
+    // "Room N" the walls had made: 16 twins.
+    {
+        name: 'a room over walls that already enclose it names the room they made, never a second zone',
+        tool: 'create_room',
+        scene: walledScene(),
+        input: room({ levelId: 'level_g' }),
+        expect: {
+            result: { ok: true, reusedWalls: 4, zoneId: 'zone_walled' },
+            after: { zone_walled: { name: 'Bedroom' } },
+            check: (result, nodes) => [
+                ...roomBuilt('level_g', 'Bedroom', 4)(result, nodes),
+                ...problems([
+                    roomsInClear(nodes).length === 1,
+                    `${roomsInClear(nodes).map((zone) => zone.name).join(', ')} stand over one walled room`,
+                ]),
+            ],
+        },
+    },
+    {
+        name: 'the walled room is named whichever way round and from whichever corner the polygon runs',
+        tool: 'create_room',
+        scene: walledScene(),
+        input: {
+            levelId: 'level_g',
+            name: 'Study',
+            polygon: [
+                [4, 8],
+                [4, 5],
+                [0, 5],
+                [0, 8],
+            ],
+        },
+        expect: {
+            result: { ok: true, zoneId: 'zone_walled' },
+            check: (_, nodes) => problems([
+                roomsInClear(nodes).map((zone) => zone.name).join() === 'Study',
+                `${roomsInClear(nodes).map((zone) => zone.name).join(', ')} stand there, not Study alone`,
+            ]),
+        },
+    },
+    {
+        name: 'a polygon over two walled spaces names the one holding most of it; the other keeps its name',
+        tool: 'create_room',
+        scene: walledScene({
+            extra: [
+                [
+                    [3, 5],
+                    [3, 8],
+                ],
+            ],
+        }),
+        input: room({ levelId: 'level_g', name: 'Master Bedroom' }),
+        expect: {
+            result: { ok: true },
+            check: (result, nodes) => {
+                const rooms = roomsInClear(nodes);
+                const master = nodes[result.zoneId];
+                return problems([rooms.length === 2, `${rooms.length} rooms over two walled spaces`], [
+                    master?.name === 'Master Bedroom' && Math.abs(area(master.polygon) - 9) < 0.05,
+                    `the named room is ${master?.name} over ${master && area(master.polygon)} m², not the 9 m² space`,
+                ], [
+                    rooms.some((zone) => /^Room \d+$/.test(zone.name ?? '')),
+                    'the smaller space lost its own name',
+                ]);
+            },
+        },
+    },
+    // A room a person named is never renamed silently, and never twinned: the refusal names it, and
+    // the agent either passes rename: true or asks the person.
+    {
+        name: 'a room a person named is refused with a choice, never twinned or renamed silently',
+        tool: 'create_room',
+        scene: walledScene({ renamed: 'Library' }),
+        input: room({ levelId: 'level_g' }),
+        expect: { refusal: 'room_named_by_person', mentions: ['Library', 'rename: true only if the person asked', 'ask them'] },
+    },
+    {
+        name: 'rename: true names the room a person named, in place, with no second zone',
+        tool: 'create_room',
+        scene: walledScene({ renamed: 'Library' }),
+        input: room({ levelId: 'level_g', rename: true }),
+        expect: {
+            result: { ok: true, zoneId: 'zone_walled' },
+            after: { zone_walled: { name: 'Bedroom' } },
+            check: (_, nodes) => problems([roomsInClear(nodes).length === 1, 'a second zone stands beside the renamed room']),
+        },
+    },
+    {
+        name: 'the same name over a room a person named has nothing to create',
+        tool: 'create_room',
+        scene: walledScene({ renamed: 'Bedroom' }),
+        input: room({ levelId: 'level_g' }),
+        expect: { refusal: 'room_named_by_person', mentions: ['already', 'Bedroom'] },
+    },
+    {
+        name: 'outdoor over a space walls already enclose names that room and drops its ceiling',
+        tool: 'create_room',
+        scene: walledScene(),
+        input: room({ levelId: 'level_g', name: 'Courtyard', outdoor: true }),
+        expect: {
+            result: { ok: true, zoneId: 'zone_walled', ceilingId: null },
+            after: { zone_walled: { name: 'Courtyard', hasCeiling: false } },
+            check: (_, nodes) => problems([roomsInClear(nodes).length === 1, 'the courtyard stands beside its room']),
+        },
+    },
+    {
+        name: 'a roof level takes no room',
+        tool: 'create_room',
+        scene: roomsScene,
+        input: room({ levelId: 'level_r' }),
+        expect: { refusal: 'roof_level' },
+    },
+    {
+        name: 'a made-up level id is refused',
+        tool: 'create_room',
+        scene: roomsScene,
+        input: room({ levelId: 'level_1' }),
+        expect: { refusal: 'level_not_found' },
+    },
+    {
+        name: 'a polygon that crosses itself is refused',
+        tool: 'create_room',
+        scene: roomsScene,
+        input: room({
+            levelId: 'level_g',
+            polygon: [
+                [0, 5],
+                [4, 8],
+                [4, 5],
+                [0, 8],
+            ],
+        }),
+        expect: { refusal: 'invalid_polygon' },
+    },
+];
+// ─── furnish_room ─────────────────────────────────────────────────────────────────────────────
+const item = (id, dimensions) => ({
+    id,
+    name: id,
+    category: 'furniture',
+    thumbnail: `/items/${id}/thumbnail.webp`,
+    src: `/items/${id}/model.glb`,
+    dimensions,
+});
+const CATALOG = [
+    item('double-bed', [1.6, 0.5, 2.1]),
+    item('single-bed', [1, 0.5, 2]),
+    item('bedside-table', [0.5, 0.5, 0.4]),
+    item('dresser', [1.2, 0.8, 0.5]),
+    item('closet', [1.5, 2, 0.6]),
+    // The MCP's built-in sizes (asset-catalog.ts).
+    item('sofa', [2.5, 0.8, 1.5]),
+    item('coffee-table', [2, 0.4, 1.5]),
+    item('livingroom-chair', [1.5, 0.8, 1.5]),
+    item('tv-stand', [2, 0.4, 0.5]),
+    item('toilet', [1, 0.9, 1]),
+    item('bathroom-sink', [2, 1, 1.5]),
+    item('shower-square', [1, 2, 1]),
+    item('bathtub', [1.7, 0.6, 0.8]),
+];
+const ROOM_WALLS = ['wall_s', 'wall_e', 'wall_n', 'wall_w'];
+/** A `width` × `depth` m room: walls south (edge 0), east, north (edge 2), west. */
+const roomOutline = (width, depth) => [
+    [0, 0],
+    [width, 0],
+    [width, depth],
+    [0, depth],
+];
+/** A 5 × 4 m bedroom. */
+const BEDROOM = roomOutline(5, 4);
+/** An L: 10 m along the south, 5 m deep, and a 4 × 5 m wing to the north-west. */
+const L_ROOM = [
+    [0, 0],
+    [10, 0],
+    [10, 5],
+    [4, 5],
+    [4, 10],
+    [0, 10],
+];
+/** A U: two 4 m arms, 6 m deep, round a 2 × 4 m notch to the north. */
+const U_ROOM = [
+    [0, 0],
+    [10, 0],
+    [10, 10],
+    [6, 10],
+    [6, 6],
+    [4, 6],
+    [4, 10],
+    [0, 10],
+];
+/** A 6√2 × 4√2 m room turned 45°. */
+const DIAMOND_ROOM = [
+    [0, 0],
+    [6, 6],
+    [2, 10],
+    [-4, 4],
+];
+/**
+ * A room of `outline`, a wall on each edge (`wall_s`, `wall_e`, `wall_n`, `wall_w` round a
+ * rectangle, `wall_<edge>` round any other outline) but the `open` ones and a repeated corner's,
+ * a door in the middle of each wall in `doorsOn`, and a desk if asked.
+ */
+function roomScene({ outline = BEDROOM, name = 'Bedroom', doorsOn = [], open = [], desk, } = {}) {
+    const wallIds = outline.map((_, i) => (outline.length === 4 ? ROOM_WALLS[i] : `wall_${i}`));
+    return () => {
+        const doors = doorsOn.map((wallId) => {
+            const i = wallIds.indexOf(wallId);
+            const [a, b] = [outline[i], outline[(i + 1) % outline.length]];
+            const middle = Math.hypot(b[0] - a[0], b[1] - a[1]) / 2;
+            return DoorNode.parse({
+                id: `door_${wallId.slice(5)}`,
+                parentId: wallId,
+                wallId,
+                position: [middle, 1.05, 0],
+            });
+        });
+        const walls = outline.flatMap((start, i) => open.includes(wallIds[i]) || `${start}` === `${outline[(i + 1) % outline.length]}`
+            ? []
+            : WallNode.parse({
+                id: wallIds[i],
+                parentId: 'level_f',
+                start,
+                end: outline[(i + 1) % outline.length],
+                children: doors.filter((door) => door.parentId === wallIds[i]).map((door) => door.id),
+            }));
+        const zone = ZoneNode.parse({
+            id: 'zone_bed',
+            parentId: 'level_f',
+            name,
+            polygon: outline,
+            spaceRole: 'room',
+        });
+        // Where the bed would stand against the north wall.
+        const deskItem = desk
+            ? ItemNode.parse({
+                id: 'item_desk',
+                parentId: 'level_f',
+                position: [2.5, 0, 3.5],
+                asset: item('desk', [1.6, 0.8, 0.8]),
+            })
+            : null;
+        const level = LevelNode.parse({
+            id: 'level_f',
+            parentId: 'building_f',
+            level: 0,
+            height: 2.8,
+            children: [...walls.map((wall) => wall.id), zone.id, ...(deskItem ? [deskItem.id] : [])],
+        });
+        const building = BuildingNode.parse({ id: 'building_f', children: [level.id] });
+        return graph(building, level, ...walls, zone, ...doors, ...(deskItem ? [deskItem] : []));
+    };
+}
+/**
+ * The piece's turned footprint inside the room, read by clipping it against the outline (not the
+ * operation's own test): what stands outside, under a square centimetre of rounding.
+ */
+const standsIn = (item, outline) => {
+    const corners = itemNodePlanCorners(item);
+    const [cx, cz] = [0, 1].map((axis) => corners.reduce((sum, c) => sum + c[axis], 0) / 4);
+    // Round the footprint, not across it: itemNodePlanCorners lists its corners by side.
+    const ring = corners.sort((a, b) => Math.atan2(a[1] - cz, a[0] - cx) - Math.atan2(b[1] - cz, b[0] - cx));
+    return clippedArea(difference(ring, outline)) < 1e-4;
+};
+const furnished = (result, nodes) => {
+    const items = Object.values(nodes);
+    const itemIds = result.itemIds;
+    return problems([itemIds.length > 0, 'nothing placed'], [
+        itemIds.every((id) => nodes[id]?.type === 'item' && nodes[id]?.parentId === 'level_f'),
+        'an item is not on the room level',
+    ], [findBlockedDoors({ nodes: items }).length === 0, 'an item blocks a door'], [findItemItemCollisions({ nodes: items }).length === 0, 'two items overlap'], [
+        findItemsMidRoom({ nodes: items, levelId: 'level_f' }).length === 0,
+        'a wall-bound piece stands in the middle of the room',
+    ], [
+        itemIds.every((id) => {
+            const [item, zone] = [nodes[id], nodes.zone_bed];
+            return (item?.type === 'item' && zone?.type === 'zone' && standsIn(item, zone.polygon));
+        }),
+        'an item stands outside the room',
+    ]);
+};
+/** Where the piece of `assetId` stands, null when it was not placed. */
+const positionOf = (nodes, assetId) => {
+    const piece = Object.values(nodes).find((node) => node.type === 'item' && node.asset.id === assetId);
+    return piece?.type === 'item' ? piece.position : null;
+};
+const bedPosition = (nodes) => positionOf(nodes, 'double-bed');
+/** The sofa and the TV placed, the coffee table and the TV straight across from the sofa. */
+const livingGroupKept = (nodes) => {
+    const [sofa, table, tv] = ['sofa', 'coffee-table', 'tv-stand'].map((id) => positionOf(nodes, id));
+    const across = (piece) => !!sofa && !!piece && Math.abs(piece[0] - sofa[0]) < 0.01;
+    return problems([sofa !== null, 'the sofa was skipped'], [tv !== null, 'the TV stand was skipped'], [across(table) && across(tv), 'the coffee table and the TV are not across from the sofa']);
+};
+export const FURNISH_ROOM_CASES = [
+    {
+        name: 'a room named by its zone: its level and outline; the bed faces the door from the far wall',
+        tool: 'furnish_room',
+        scene: roomScene({ doorsOn: ['wall_s'] }),
+        input: { zoneId: 'zone_bed', roomType: 'bedroom' },
+        context: { catalog: CATALOG },
+        expect: {
+            result: { ok: true, doorWallIndex: 0, doorsDetected: 1 },
+            check: (result, nodes) => [
+                ...furnished(result, nodes),
+                ...problems([(bedPosition(nodes)?.[2] ?? 0) > 2, 'the bed is not against the north wall']),
+            ],
+        },
+    },
+    {
+        name: 'the door it finds sets the furniture wall, whichever edge it is on',
+        tool: 'furnish_room',
+        scene: roomScene({ doorsOn: ['wall_n'] }),
+        input: { zoneId: 'zone_bed', roomType: 'bedroom' },
+        context: { catalog: CATALOG },
+        expect: {
+            result: { ok: true, doorWallIndex: 2, doorsDetected: 1 },
+            check: (result, nodes) => [
+                ...furnished(result, nodes),
+                ...problems([(bedPosition(nodes)?.[2] ?? 4) < 2, 'the bed is not against the south wall']),
+            ],
+        },
+    },
+    {
+        name: 'doorWallIndex names the door wall of a room with no door yet, and keeps it clear',
+        tool: 'furnish_room',
+        scene: roomScene(),
+        input: { zoneId: 'zone_bed', roomType: 'bedroom', doorWallIndex: 1 },
+        context: { catalog: CATALOG },
+        expect: {
+            result: { ok: true, doorWallIndex: 1, doorsDetected: 0 },
+            check: (result, nodes) => [
+                ...furnished(result, nodes),
+                ...problems([(bedPosition(nodes)?.[0] ?? 5) < 2.5, 'the bed is not against the west wall']),
+            ],
+        },
+    },
+    {
+        name: 'a polygon instead of a zone, on the lowest storey when no level is named',
+        tool: 'furnish_room',
+        scene: roomScene({ doorsOn: ['wall_s'] }),
+        input: { polygon: BEDROOM, roomType: 'bedroom' },
+        context: { catalog: CATALOG },
+        expect: { result: { ok: true, doorWallIndex: 0 }, check: furnished },
+    },
+    {
+        name: 'an item already in the room is never overlapped',
+        tool: 'furnish_room',
+        scene: roomScene({ doorsOn: ['wall_s'], desk: true }),
+        input: { zoneId: 'zone_bed', roomType: 'bedroom' },
+        context: { catalog: CATALOG },
+        expect: { result: { ok: true }, check: furnished },
+    },
+    {
+        name: 'a door in the sofa wall and in the TV wall: the sofa slides along its wall, the table and the TV with it, nothing into the room',
+        tool: 'furnish_room',
+        scene: roomScene({
+            outline: roomOutline(7, 4.5),
+            name: 'Living room',
+            doorsOn: ['wall_s', 'wall_n'],
+        }),
+        input: { zoneId: 'zone_bed', roomType: 'living' },
+        context: { catalog: CATALOG },
+        expect: {
+            result: { ok: true, doorWallIndex: 0, doorsDetected: 2 },
+            check: (result, nodes) => [...furnished(result, nodes), ...livingGroupKept(nodes)],
+        },
+    },
+    {
+        name: 'a skip names the other sources, and a set with no skip does not',
+        tool: 'furnish_room',
+        scene: roomScene({
+            outline: roomOutline(7, 4.5),
+            name: 'Living room',
+            open: ['wall_s', 'wall_e', 'wall_w'],
+        }),
+        input: { zoneId: 'zone_bed', roomType: 'living', doorWallIndex: 0 },
+        context: { catalog: CATALOG },
+        expect: {
+            result: { ok: true },
+            check: (result) => problems([result.skipped.length > 0, 'nothing was skipped: no case here'], [
+                String(result.message).includes('For what was skipped: add_object builds an object of any shape and size'),
+                'a skip does not name the sources',
+            ]),
+        },
+    },
+    {
+        name: 'every piece placed comes with its name, size and id',
+        tool: 'furnish_room',
+        scene: roomScene({ outline: roomOutline(7, 4.5), name: 'Living room', doorsOn: ['wall_s'] }),
+        input: { zoneId: 'zone_bed', roomType: 'living' },
+        context: { catalog: CATALOG },
+        expect: {
+            result: { ok: true, skipped: [] },
+            mentions: ['sofa (2.5 × 1.5 m): item_'],
+            check: (result) => {
+                const pieces = result.pieces;
+                const ids = result.itemIds;
+                return problems([pieces.length === ids.length && ids.length > 0, 'pieces and ids differ'], [
+                    pieces.every((piece, i) => piece.endsWith(`: ${ids[i]}`) && / \(\d[\d.]* × \d[\d.]* m\): /.test(piece)),
+                    `a piece lacks its size or its id: ${pieces}`,
+                ], [!String(result.message).includes('add_object'), 'a set with no skip names the sources']);
+            },
+        },
+    },
+    {
+        name: 'a wall-bound piece where no wall stands is skipped, and says so: the TV of a living room open to the south',
+        tool: 'furnish_room',
+        scene: roomScene({
+            outline: roomOutline(7, 4.5),
+            name: 'Living room',
+            open: ['wall_s', 'wall_e', 'wall_w'],
+        }),
+        input: { zoneId: 'zone_bed', roomType: 'living', doorWallIndex: 0 },
+        context: { catalog: CATALOG },
+        expect: {
+            result: { ok: true },
+            mentions: ['tv-stand (2 × 0.5 m): no wall to stand against there'],
+            check: (result, nodes) => [
+                ...furnished(result, nodes),
+                ...problems([positionOf(nodes, 'sofa') !== null, 'the sofa was skipped']),
+            ],
+        },
+    },
+    {
+        name: 'an L-shaped bedroom: nothing lands in the corner the L leaves out',
+        tool: 'furnish_room',
+        scene: roomScene({ outline: L_ROOM, doorsOn: ['wall_0'] }),
+        input: { zoneId: 'zone_bed', roomType: 'bedroom' },
+        context: { catalog: CATALOG },
+        expect: { result: { ok: true, doorWallIndex: 0 }, check: furnished },
+    },
+    {
+        name: 'an outline drawn closed (its first corner repeated) is the same room: the closet stands against its far wall',
+        tool: 'furnish_room',
+        scene: roomScene({ outline: [...roomOutline(6, 4), [0, 0]], name: 'Storage' }),
+        input: { zoneId: 'zone_bed', roomType: 'storage', doorWallIndex: 0 },
+        context: { catalog: CATALOG },
+        expect: {
+            result: { ok: true, placed: 1 },
+            check: (result, nodes) => [
+                ...furnished(result, nodes),
+                ...problems([
+                    (positionOf(nodes, 'closet')?.[2] ?? 0) > 3,
+                    'the closet is not against the far wall',
+                ]),
+            ],
+        },
+    },
+    {
+        name: 'a U-shaped room: nothing stands in the notch between its arms, though its corners touch the outline',
+        tool: 'furnish_room',
+        scene: roomScene({ outline: U_ROOM, name: 'Dining room' }),
+        input: { zoneId: 'zone_bed', roomType: 'dining', doorWallIndex: 0 },
+        context: {
+            catalog: [
+                ...CATALOG,
+                item('dining-table', [2, 0.75, 4]),
+                item('dining-chair', [0.5, 0.9, 0.5]),
+            ],
+        },
+        expect: {
+            result: { ok: true },
+            mentions: ['dining-table (2 × 4 m): outside the room'],
+            check: furnished,
+        },
+    },
+    {
+        name: 'a room turned 45°: the closet stands inside it, against a wall',
+        tool: 'furnish_room',
+        scene: roomScene({ outline: DIAMOND_ROOM, name: 'Storage', doorsOn: [] }),
+        input: { zoneId: 'zone_bed', roomType: 'storage', doorWallIndex: 0 },
+        context: { catalog: CATALOG },
+        expect: {
+            result: { ok: true, placed: 1 },
+            check: (result, nodes) => [
+                ...furnished(result, nodes),
+                ...problems([positionOf(nodes, 'closet') !== null, 'the closet was skipped']),
+            ],
+        },
+    },
+    {
+        name: 'a bathroom under 6.5 m², which takes a shower and no tub: the shower stands against a wall, not in the middle',
+        tool: 'furnish_room',
+        scene: roomScene({ outline: roomOutline(2.4, 2.6), name: 'Bathroom', doorsOn: ['wall_s'] }),
+        input: { zoneId: 'zone_bed', roomType: 'bathroom' },
+        context: { catalog: CATALOG },
+        expect: {
+            result: { ok: true },
+            check: (result, nodes) => [
+                ...furnished(result, nodes),
+                ...problems([positionOf(nodes, 'shower-square') !== null, 'the shower was skipped'], [positionOf(nodes, 'bathtub') === null, 'a tub was placed']),
+            ],
+        },
+    },
+    {
+        name: 'a piece the catalog lacks is skipped and named',
+        tool: 'furnish_room',
+        scene: roomScene({ doorsOn: ['wall_s'] }),
+        input: { zoneId: 'zone_bed', roomType: 'bedroom' },
+        context: { catalog: CATALOG.filter((entry) => entry.id !== 'bedside-table') },
+        expect: { result: { ok: true }, mentions: ['bedside-table: not in the catalog'] },
+    },
+    {
+        name: 'no room named: room_required',
+        tool: 'furnish_room',
+        scene: roomScene(),
+        input: { roomType: 'bedroom' },
+        context: { catalog: CATALOG },
+        expect: { refusal: 'room_required' },
+    },
+    {
+        name: 'a wall id for the room: not_a_zone',
+        tool: 'furnish_room',
+        scene: roomScene(),
+        input: { zoneId: 'wall_s', roomType: 'bedroom' },
+        context: { catalog: CATALOG },
+        expect: { refusal: 'not_a_zone', mentions: ['wall_s'] },
+    },
+    {
+        name: 'a zone id that does not exist: zone_not_found',
+        tool: 'furnish_room',
+        scene: roomScene(),
+        input: { zoneId: 'zone_nope', roomType: 'bedroom' },
+        context: { catalog: CATALOG },
+        expect: { refusal: 'zone_not_found' },
+    },
+    {
+        name: 'a roof level takes no furniture',
+        tool: 'furnish_room',
+        scene: roomsScene,
+        input: { levelId: 'level_r', polygon: CLEAR, roomType: 'bedroom' },
+        context: { catalog: CATALOG },
+        expect: { refusal: 'roof_level' },
+    },
+    // Every host has a catalog (the MCP its built-in list at least); an operation run without one
+    // says so rather than placing nothing.
+    {
+        name: 'a host without a catalog: no_catalog',
+        tool: 'furnish_room',
+        scene: roomScene(),
+        input: { zoneId: 'zone_bed', roomType: 'bedroom' },
+        surfaces: ['core', 'chat'],
+        expect: { refusal: 'no_catalog' },
+    },
+];