@pascal-app/core 1.0.6 → 1.1.0

package/dist/agent-operations/author-scene.js

@@ -1,32 +1,88 @@
 import { refuse } from '../agent-tools/refusal.js';
-import { doorTypeFields } from '../building/door-types.js';
+import { doorTypeFields, NEW_DOOR_FRAME_THICKNESS } from '../building/door-types.js';
 import { DOOR_STYLES, doorStyleLook, getWindowStyleOverrides, WINDOW_STYLES, } from '../building/opening-style-presets.js';
-import { windowTakesStyle, windowTypeFields } from '../building/window-types.js';
+import { doorFacing, wallOpeningCeilingOver } from '../building/wall-openings.js';
+import { NEW_WINDOW_FRAME_THICKNESS, windowTakesStyle, windowTypeFields, } from '../building/window-types.js';
+import { cutFloorOpening } from '../commands/structure/floor-opening.js';
+import { doorPositionForFacing, getDoorOpeningSize } from '../lib/door-opening.js';
 import { floorRoomFaces } from '../lib/floor-room-faces.js';
 import { matchScriptSlotsToLibrary, requireMeasured, scriptedSize, scriptSource, } from '../lib/geometry-script-node.js';
+import { exposedIntervals } from '../lib/level-footprints.js';
+import { area, containsPoint, difference, intersection, union, } from '../lib/polygon-boolean.js';
+import { roundFloorElevation } from '../lib/room-floor-feasibility.js';
 import { detectSpacesForLevel } from '../lib/space-detection.js';
 import { reconcileSceneStructure } from '../lib/structure-reconcile.js';
 import { wallFaceScriptInputs } from '../lib/wall-face-script.js';
+import { nodeSlotDeclarations } from '../node-slots/index.js';
 import { nearestLibraryColorRef } from '../procedural-items/library-colors.js';
-import { ColumnNode, DoorNode, LevelNode, SlabNode, WallNode, WindowNode, ZoneNode, } from '../schema/index.js';
+import { ColumnNode, CurtainWallConfig, DoorNode, FenceNode, getActiveRoofHeight, getCurtainWallConfig, getSegmentSlopeFrame, LevelNode, RoofNode, RoofSegmentNode, SlabNode, UnitNode, WallNode, WindowNode, ZoneNode, } from '../schema/index.js';
 import { DoorType, WindowType } from '../schema/nodes/opening-types.js';
-import { resolveCeilingHeight } from '../services/level-height.js';
+import { MIN_SLAB_THICKNESS } from '../schema/nodes/slab.js';
+import { DEFAULT_LEVEL_HEIGHT, resolveCeilingHeight } from '../services/level-height.js';
+import { planRoofLevel } from '../services/roof-level.js';
 import { CEILING_DRAW_OFFSET } from '../services/storey.js';
+import { resolveRoofElevation } from '../systems/roof/roof-elevation.js';
+import { stairArrivalOpening } from '../systems/stair/stair-footprint.js';
+import { getMaxWallCurveOffset, getWallCenterlineSegments, getWallCurveLength, getWallSurfacePolygon, isCurvedWall, normalizeWallCurveOffset, } from '../systems/wall/wall-curve.js';
+import { getWallPlanFootprint, getWallThickness } from '../systems/wall/wall-footprint.js';
 import { getWallLocalFaceZ } from '../systems/wall/wall-frame.js';
+import { calculateLevelMiters } from '../systems/wall/wall-mitering.js';
 import { roomFaceCover } from '../systems/wall/wall-room-sides.js';
 import { migrateRoomZones } from '../utils/room-zone-migration.js';
 import { addObject } from './add-object.js';
+import { applySceneChanges } from './apply-changes.js';
 import { authoredSceneChanges } from './authored-scene-merge.js';
+import { createStair } from './create-stair.js';
 import { paint } from './paint.js';
 import { pointInPolygon, projectWorldPointToWallLocalX } from './plan-geometry.js';
-import { resolveInlinePaintMaterial } from './scene-materials.js';
+import { exactColorMaterial, exactScriptSlots, MATTE } from './scene-materials.js';
+import { queryNodes } from './scene-queries.js';
 import { setWallSkirting } from './wall-skirting.js';
+const BOOKKEEPING = ['authorSceneBase', 'authorSceneWritten'];
+/** A value as live collaboration and storage keep it: no undefined, no non-finite number. */
+const plain = (value) => JSON.parse(JSON.stringify(value));
+/** A node without the conversion's bookkeeping: what a person edits and a revision merges. */
+function withoutBookkeeping(node) {
+    const metadata = node.metadata;
+    if (!(metadata && BOOKKEEPING.some((key) => key in metadata)))
+        return node;
+    const kept = { ...metadata };
+    for (const key of BOOKKEEPING)
+        delete kept[key];
+    return { ...node, metadata: kept };
+}
+/** A node the person deleted since the last conversion: present in the baseline, never read. */
+const DELETED = { type: 'deleted' };
+/**
+ * The last conversion of `building`, read back from its levels and nodes: its seed, its source-key
+ * identities, and the baseline of every node it wrote (a deleted one marked so).
+ */
+function authoredBaseline(scene, building) {
+    const state = building.metadata?.authorSceneState;
+    if (!(state?.version === 2 && state.buildingId === building.id && typeof state.seed === 'string'))
+        return undefined;
+    const ids = {};
+    const nodes = {};
+    // The building lists what it holds itself (its units); each level, what stands on it.
+    for (const holder of [building, ...queryNodes(scene, { type: 'level', parentId: building.id })]) {
+        const written = holder.metadata?.authorSceneWritten;
+        if (!written)
+            continue;
+        Object.assign(ids, written.keys);
+        for (const id of written.ids) {
+            const node = scene[id];
+            nodes[id] = node?.metadata?.authorSceneBase ?? DELETED;
+        }
+    }
+    return { seed: state.seed, ids, nodes };
+}
 const JOIN_REACH = 0.3;
+/** The deepest floor between storeys: a wall stopping this far under the floor above carries it. */
+const FLOOR_DEPTH = 0.5;
 const THIN_SLAB = 0.02;
 const MANY_SLABS = 20;
 const MANY_REGIONS = 24;
 const HEX = /^#[0-9a-f]{6}$/i;
-const GLASS = 'library:preset-glass';
 /**
  * Explicit payload keys retain their identities across revisions; derived nodes use the
  * conversion's retained seed. A changed payload never remints every existing wall or item.
@@ -52,6 +108,17 @@ function payloadSeed(payload) {
 }
 const dist = (a, b) => Math.hypot(a[0] - b[0], a[1] - b[1]);
 const metres = (value) => `${value.toFixed(2)} m`;
+/** The value given most often, the first one on a tie; undefined for none. */
+const mostCommon = (values) => {
+    const counts = new Map();
+    for (const value of values)
+        counts.set(value, (counts.get(value) ?? 0) + 1);
+    let best;
+    for (const [value, count] of counts)
+        if (!best || count > counts.get(best))
+            best = value;
+    return best;
+};
 /**
  * Where a wall end meets another wall's centerline: the projection onto that line, as long as it
  * lands on the wall or within reach past its ends. The line, not the segment, so a partition
@@ -65,6 +132,37 @@ function nearestOnSegment(p, a, b) {
     const q = [a[0] + t * (b[0] - a[0]), a[1] + t * (b[1] - a[1])];
     return { point: q, distance: dist(p, q) };
 }
+/**
+ * The bend Pascal stores (`curveOffset`) for an arc from start to end through a plan point: the
+ * point's distance from the straight line, positive when it lies to the right looking from start
+ * to end (away from the wall's left normal).
+ */
+function bendThrough(start, end, through) {
+    const [dx, dz] = [end[0] - start[0], end[1] - start[1]];
+    return ((through[0] - start[0]) * dz - (through[1] - start[1]) * dx) / (Math.hypot(dx, dz) || 1);
+}
+/** The same on a curved wall: the nearest point of its arc, so a partition meets the curve. */
+function nearestOnWall(p, wall) {
+    if (!wall.spec.through)
+        return nearestOnSegment(p, wall.start, wall.end);
+    const arc = {
+        start: wall.start,
+        end: wall.end,
+        curveOffset: bendThrough(wall.start, wall.end, wall.spec.through),
+    };
+    let best = { point: [p[0], p[1]], distance: Number.POSITIVE_INFINITY };
+    for (const [a, b] of getWallCenterlineSegments(arc, 64)) {
+        const [dx, dz] = [b.x - a.x, b.y - a.y];
+        const t = ((p[0] - a.x) * dx + (p[1] - a.y) * dz) / (dx * dx + dz * dz || 1);
+        const q = [
+            a.x + Math.max(0, Math.min(1, t)) * dx,
+            a.y + Math.max(0, Math.min(1, t)) * dz,
+        ];
+        if (dist(p, q) < best.distance)
+            best = { point: q, distance: dist(p, q) };
+    }
+    return best;
+}
 const cross = (o, a, b) => (a[0] - o[0]) * (b[1] - o[1]) - (a[1] - o[1]) * (b[0] - o[0]);
 /** Whether two segments cross each other's interior (touching ends and shared edges do not). */
 function segmentsCross(a, b, c, d) {
@@ -83,6 +181,8 @@ function polygonsOverlap(a, b) {
 }
 /** A wall's footprint, pulled in by a few millimetres so a slab meeting its face is not on it. */
 function wallFootprint(wall) {
+    if (wall.curveOffset)
+        return getWallSurfacePolygon({ ...wall, thickness: wall.thickness - 0.01 }).map(({ x, y }) => [x, y]);
     const inset = 0.005;
     const [dx, dz] = [wall.end[0] - wall.start[0], wall.end[1] - wall.start[1]];
     const len = Math.hypot(dx, dz) || 1;
@@ -106,7 +206,31 @@ function toLocal(frame, world) {
     const [c, s] = [Math.cos(frame.yaw), Math.sin(frame.yaw)];
     return [c * dx - s * dz, dy, s * dx + c * dz];
 }
-const MATTE = { roughness: 0.9, metalness: 0 };
+/**
+ * A payload light's beam in its host's frame (so it turns with the host), or none for a point
+ * light. A target on the light itself points it down.
+ */
+function lightSpot(light, at, host) {
+    if (!light.direction && !light.target && light.angle === undefined)
+        return undefined;
+    let [x, y, z] = light.target
+        ? [light.target[0] - at[0], light.target[1] - at[1], light.target[2] - at[2]]
+        : (light.direction ?? [0, -1, 0]);
+    let length = Math.hypot(x, y, z);
+    if (length < 1e-6)
+        [x, y, z, length] = [0, -1, 0, 1];
+    const [c, s] = [Math.cos(host.yaw), Math.sin(host.yaw)];
+    const round = (v) => Math.round(v * 1e4) / 1e4;
+    return {
+        direction: [
+            round((c * x - s * z) / length),
+            round(y / length),
+            round((s * x + c * z) / length),
+        ],
+        angle: light.angle ?? 60,
+        softness: light.softness ?? 0.4,
+    };
+}
 /**
  * The finish a payload value writes. A library or scene ref passes through; a hex colour is kept
  * as an exact native material, one scene material per distinct colour and surface across the
@@ -127,25 +251,13 @@ function finishPool(context, say) {
                 return { ref: value };
             if (!HEX.test(value))
                 return { error: `${value} is no colour: give #rrggbb or library:<id>.` };
-            const hex = value.toLowerCase();
             if (!materials) {
                 if (!snapped)
                     say('this host keeps no scene materials: colours written as the nearest library colour');
                 snapped = true;
-                return { ref: nearestLibraryColorRef(hex).ref };
+                return { ref: nearestLibraryColorRef(value).ref };
             }
-            const resolved = resolveInlinePaintMaterial(materials, {
-                properties: {
-                    color: hex,
-                    roughness: surface.roughness,
-                    metalness: surface.metalness,
-                    opacity: 1,
-                    transparent: false,
-                    side: 'front',
-                },
-            }, surface.roughness === MATTE.roughness && surface.metalness === MATTE.metalness
-                ? hex
-                : `${hex}, roughness ${+surface.roughness.toFixed(2)}, metalness ${+surface.metalness.toFixed(2)}`);
+            const resolved = exactColorMaterial(materials, value, surface);
             if (resolved.created) {
                 materials[resolved.sceneMaterial.id] = resolved.sceneMaterial;
                 created.push(resolved.sceneMaterial);
@@ -166,8 +278,13 @@ export default function build({ THREE }) {
 }`;
 /** Candidate modules, compiled by the host before room derivation decides which points are used. */
 export function authorSceneCeilingPoints(payload) {
-    return payload.levels.flatMap((level, index) => level.lights.flatMap((light, i) => light.fixture ? [] : [{ id: `light/${index}/${i}`, code: CEILING_POINT_CODE }]));
+    return payload.levels.flatMap((level, index) => [
+        ...level.lights.flatMap((light, i) => light.fixture ? [] : [{ id: `light/${index}/${i}`, code: CEILING_POINT_CODE }]),
+        // A room left with no light gets one at its seed.
+        ...level.rooms.map((_, i) => ({ id: roomLightId(index, i), code: CEILING_POINT_CODE })),
+    ]);
 }
+const roomLightId = (level, room) => `light/${level}/room/${room}`;
 /**
  * The rooms whose floor finish is a module, by their zone once the write made it: the host reads
  * each room's floor (`floorScriptInputs`), compiles the module for it and writes it with
@@ -181,12 +298,27 @@ export function authorSceneFloorScripts(payload, report) {
         return room.floorCode && zoneId ? [{ roomId, zoneId, code: room.floorCode }] : [];
     }));
 }
+/**
+ * The slabs whose surface finish is a module, by their node once the write made them: the host
+ * reads each slab's surface (`slabSurfaceScriptInputs`), compiles the module for it and writes it
+ * with `setSlabSurfaceScript`, as it does a room's floor module.
+ */
+export function authorSceneSlabScripts(payload, report) {
+    return payload.levels.flatMap((level, index) => (level.slabs ?? []).flatMap((slab, i) => {
+        const slabId = `slab/${index}/${i}`;
+        const nodeId = report.ids[slabId];
+        return slab.surfaceCode && nodeId
+            ? [{ slabId, nodeId, name: slab.name ?? slabId, code: slab.surfaceCode }]
+            : [];
+    }));
+}
 /**
  * Which faces the payload's face modules build on, and why the others cannot be: a wall's own
- * `faceLeft` (face a) and `faceRight` (face b), then each room's `wallCode` on the faces its floor
- * meets (the spans of the room the zone was derived from, the faces `setWallSkirting` runs along),
- * where a wall's own module wins. A face with nothing to build on (a curved or curtain wall) or
- * that no room looks into is a `no_face` defect.
+ * `faceLeft` (face a) and `faceRight` (face b), its `faceOutside` on the faces no room of its level
+ * looks into, then each room's `wallCode` on the faces its floor meets (the spans of the room the
+ * zone was derived from, the faces `setWallSkirting` runs along), where a wall's own module wins.
+ * A face with nothing to build on (a curved or curtain wall), a left or right face no room looks
+ * into, or an outside module on a wall with rooms on both faces is a `no_face` defect.
  */
 function resolveFaceScripts(payload, ids, nodes) {
     const scripts = [];
@@ -225,6 +357,27 @@ function resolveFaceScripts(payload, ids, nodes) {
                 else
                     add(spec.id, face, nodeId, module.code, module.toHeight);
             }
+            const outside = spec.faceOutside;
+            if (!outside)
+                continue;
+            if (!wallFaceScriptInputs(nodes, nodeId, 'a', outside.toHeight)) {
+                defects.push({
+                    id: `${spec.id}/outside`,
+                    code: 'no_face',
+                    message: `Wall ${spec.id} ${flat}: its outside face has nothing a script can build on and keeps its paint.`,
+                });
+                continue;
+            }
+            const cover = roomFaceCover(nodes, nodeId);
+            const faces = ['a', 'b'].filter((face) => cover[face] === 'none');
+            if (!faces.length)
+                defects.push({
+                    id: `${spec.id}/outside`,
+                    code: 'no_face',
+                    message: `Rooms look into both faces of wall ${spec.id}: it has no outside face, so its faceOutside was not written.`,
+                });
+            for (const face of faces)
+                add(spec.id, face, nodeId, outside.code, outside.toHeight);
         }
         const byRoom = new Map();
         for (const [i, room] of level.rooms.entries()) {
@@ -232,7 +385,10 @@ function resolveFaceScripts(payload, ids, nodes) {
             const zone = nodes[ids[roomId] ?? ''];
             if (!room.wallCode || zone?.type !== 'zone')
                 continue;
-            const boundaries = Object.values(nodes).filter((n) => n.parentId === zone.parentId && (n.type === 'wall' || n.type === 'separator'));
+            const boundaries = queryNodes(nodes, {
+                type: ['wall', 'separator'],
+                parentId: zone.parentId ?? null,
+            });
             const zoneWalls = [...zone.boundaryWallIds].sort().join();
             const derived = floorRoomFaces(boundaries).find((r) => [...new Set(r.spans.filter((s) => s.kind === 'wall').map((s) => s.boundaryId))]
                 .sort()
@@ -347,6 +503,8 @@ export function authorScene(scene, input, context) {
             ['slab', level.slabs],
             ['column', level.columns],
             ['light', level.lights],
+            ['stair', level.stairs],
+            ['void', level.voids],
         ])
             parts?.forEach((_, i) => {
                 claimSourceKey(`${kind}/${index}/${i}`);
@@ -360,6 +518,10 @@ export function authorScene(scene, input, context) {
         for (const item of level.items ?? [])
             claimSourceKey(item.id);
     });
+    for (const item of payload.roof?.items ?? [])
+        claimSourceKey(item.id);
+    for (const unit of payload.units)
+        claimSourceKey(`unit/${unit.name}`);
     const buildings = Object.values(scene).filter((n) => n.type === 'building');
     const selected = input.buildingId ?? (context.activeLevelId ? scene[context.activeLevelId]?.parentId : undefined);
     const building = selected
@@ -370,14 +532,7 @@ export function authorScene(scene, input, context) {
     if (!building)
         refuse('no_building', 'The scene has no building to put the levels in.');
     const existingLevels = Object.values(scene).filter((n) => n.type === 'level' && n.parentId === building.id);
-    const saved = building.metadata?.authorSceneState;
-    const previous = saved?.version === 1 &&
-        saved.buildingId === building.id &&
-        saved.nodes &&
-        saved.ids &&
-        typeof saved.seed === 'string'
-        ? saved
-        : undefined;
+    const previous = authoredBaseline(scene, building);
     const converted = Boolean(previous) || existingLevels.some((l) => l.metadata?.authorScene);
     if (converted && !input.replace)
         refuse('conversion_exists', 'This scene already holds a conversion. Pass replace: true to write over it.');
@@ -392,11 +547,16 @@ export function authorScene(scene, input, context) {
         walls: 0,
         doors: 0,
         windows: 0,
+        passages: 0,
         rooms: 0,
         roomsNamed: 0,
         slabs: 0,
         columns: 0,
         items: 0,
+        stairs: 0,
+        voids: 0,
+        roofSegments: 0,
+        units: 0,
         lights: 0,
         floorScripts: 0,
         faceScripts: 0,
@@ -421,23 +581,7 @@ export function authorScene(scene, input, context) {
         }
         return got.ref;
     };
-    const exactSlots = (compiled, id) => {
-        const slots = matchScriptSlotsToLibrary(compiled.manifest);
-        for (const slot of compiled.manifest.slots) {
-            // Glass keeps the glass add_object writes, drawn see-through and letting light pass. A
-            // scene material carries no emission, so an emissive slot keeps the module's own material
-            // (the library match leaves it alone) and a bulb stays lit.
-            if (!slot.color || slot.emissive || slots[slot.id] === GLASS)
-                continue;
-            const ref = finishRef(slot.color, id, {
-                roughness: slot.roughness ?? MATTE.roughness,
-                metalness: slot.metalness ?? MATTE.metalness,
-            });
-            if (ref)
-                slots[slot.id] = ref;
-        }
-        return slots;
-    };
+    const exactSlots = (compiled, id) => exactScriptSlots(compiled.manifest, matchScriptSlotsToLibrary(compiled.manifest), (hex, surface) => finishRef(hex, id, surface));
     const paintContext = (levelId) => ({
         ...context,
         activeLevelId: levelId,
@@ -452,11 +596,20 @@ export function authorScene(scene, input, context) {
     }
     const scaffoldIds = new Set(Object.keys(draft));
     const levelNodes = [];
+    const levelWalls = [];
     const itemNodeIds = new Map();
     const itemFrames = new Map();
     const skirtings = [];
     let untypedWindows = 0;
+    /** By upper level index: the storey under it and the height of the tallest wall carrying it. */
+    const floorsAbove = new Map();
     payload.levels.forEach((level, index) => {
+        // A storey is as tall as the climb to the next level's floor; the top one, as its walls.
+        const above = payload.levels[index + 1];
+        const walled = Math.max(0, ...(level.walls ?? []).map((w) => w.height)) || DEFAULT_LEVEL_HEIGHT;
+        if (above && above.elevation <= level.elevation)
+            say(`"${above.name}" (elevation ${metres(above.elevation)}) is not above "${level.name}" (${metres(level.elevation)}): "${level.name}" is as tall as its walls, ${metres(walled)}`);
+        const storey = above && above.elevation > level.elevation ? above.elevation - level.elevation : 0;
         const levelNode = LevelNode.parse({
             object: 'node',
             type: 'level',
@@ -466,6 +619,7 @@ export function authorScene(scene, input, context) {
             metadata: { authorScene: { elevation: level.elevation } },
             name: level.name,
             level: index,
+            height: storey || walled,
             children: [],
         });
         draft[levelNode.id] = levelNode;
@@ -476,11 +630,26 @@ export function authorScene(scene, input, context) {
             levelNode.children.push(node.id);
         };
         // ---------- walls, joined ----------
+        // Walls keep their height; the floor above is built between the storeys, from the tallest wall
+        // carrying it up to its surface. A wall reaching into that floor stops under it, following the
+        // storey as a drawn wall does.
+        const reaches = (height) => storey > 0 && height > storey - MIN_SLAB_THICKNESS;
         const walls = (level.walls ?? []).map((w) => ({
             spec: w,
             start: [...w.start],
             end: [...w.end],
+            height: reaches(w.height) ? storey : w.height,
         }));
+        const carrying = walls
+            .map((w) => w.spec.height)
+            .filter((height) => storey > 0 && !reaches(height) && height >= storey - FLOOR_DEPTH);
+        if (carrying.length)
+            floorsAbove.set(index + 1, { below: level.name, wallHeight: Math.max(...carrying), storey });
+        const stopped = [
+            ...new Set(walls.filter((w) => w.height !== w.spec.height).map((w) => w.spec.height)),
+        ];
+        if (stopped.length)
+            say(`walls of "${level.name}" given ${stopped.map(metres).join(', ')} reach the floor of "${above.name}", ${metres(storey)} up: they stop under it, following the storey`);
         for (const w of walls) {
             for (const end of ['start', 'end']) {
                 const pt = w[end];
@@ -488,7 +657,7 @@ export function authorScene(scene, input, context) {
                 for (const o of walls) {
                     if (o === w)
                         continue;
-                    const near = nearestOnSegment(pt, o.start, o.end);
+                    const near = nearestOnWall(pt, o);
                     if (near.distance < JOIN_REACH && (!best || near.distance < best.distance))
                         best = near;
                 }
@@ -508,6 +677,13 @@ export function authorScene(scene, input, context) {
                 defect(w.spec.id, 'wall_too_short', 'The wall is shorter than 5 cm after joining.');
                 continue;
             }
+            const bend = w.spec.through ? bendThrough(w.start, w.end, w.spec.through) : 0;
+            const curve = bend ? normalizeWallCurveOffset(w, bend) : 0;
+            if (w.spec.through && !curve)
+                say(`wall ${w.spec.id}: its through point is on the straight line: written straight`);
+            else if (Math.abs(bend) > getMaxWallCurveOffset(w) + 1e-9)
+                say(`wall ${w.spec.id}: its through point stands ${metres(Math.abs(bend))} off the straight line, more than half its ${metres(dist(w.start, w.end))} span: written as a half circle, ${metres(Math.abs(curve))} out`);
+            const { curtain } = w.spec;
             const node = WallNode.parse({
                 object: 'node',
                 type: 'wall',
@@ -518,8 +694,20 @@ export function authorScene(scene, input, context) {
                 children: [],
                 start: w.start,
                 end: w.end,
-                height: w.spec.height,
+                ...(w.height === w.spec.height ? { height: w.spec.height } : {}),
                 thickness: w.spec.thickness,
+                ...(curve ? { curveOffset: curve } : {}),
+                ...(curtain
+                    ? {
+                        wallType: 'curtain',
+                        curtainWall: CurtainWallConfig.parse({
+                            columns: {
+                                layout: 'maximum-spacing',
+                                spacing: Math.min(100, Math.max(0.2, curtain.spacing)),
+                            },
+                        }),
+                    }
+                    : {}),
             });
             place(node);
             wallNodes.set(w.spec.id, { ...w, node });
@@ -532,13 +720,20 @@ export function authorScene(scene, input, context) {
                 });
             report.ids[w.spec.id] = node.id;
             report.walls++;
-            // ---------- its openings ----------
-            const length = dist(w.start, w.end);
+            // ---------- its openings: along the arc on a curved wall, as Pascal places them ----------
+            const length = curve ? getWallCurveLength(node) : dist(w.start, w.end);
             (w.spec.openings ?? []).forEach((o, i) => {
                 const id = `${w.spec.id}/${i}`;
+                const passage = o.kind === 'passage';
+                const kind = passage ? 'door' : o.kind;
+                if (passage) {
+                    const leaf = ['type', 'style', 'leaves', 'hinge', 'swing', 'code'].filter((field) => o[field] !== undefined);
+                    if (leaf.length)
+                        say(`passage ${id}: it has no leaf, its ${leaf.join(', ')} ignored`);
+                }
                 // A module supplies geometry; the declared type still describes how the opening works.
                 let compiled;
-                if (o.code) {
+                if (o.code && !passage) {
                     compiled = input.compiled[id];
                     if (!compiled) {
                         defect(id, 'compile_failed', input.compileErrors?.[id] ?? 'The module did not compile.');
@@ -560,24 +755,53 @@ export function authorScene(scene, input, context) {
                         say(`${o.kind} ${id}: style ignored, its module builds it`);
                 }
                 const [width, height] = compiled ? scriptedSize(compiled.manifest) : [o.width, o.height];
-                if (width > length + 0.01) {
+                const size = o.kind === 'door' && !compiled
+                    ? getDoorOpeningSize({
+                        ...o,
+                        width,
+                        height,
+                        doorType: o.type && isDoorType(o.type) ? o.type : 'hinged',
+                    })
+                    : { width, height, leafOffsetX: 0 };
+                if (size.width > length + 0.01) {
                     defect(id, 'opening_wider_than_wall', `${o.kind} ${width.toFixed(2)} m wide on a ${length.toFixed(2)} m wall.`);
                     return;
                 }
-                const x = Math.min(Math.max(o.along, width / 2), length - width / 2);
-                if (Math.abs(x - o.along) > 0.01)
-                    say(`${o.kind} ${id}: moved ${Math.abs(x - o.along).toFixed(2)} m along the wall to fit inside it`);
+                if (o.kind === 'door') {
+                    const wallHeight = wallOpeningCeilingOver(node, draft, o.along - size.width / 2, o.along + size.width / 2) - (node.wallType === 'curtain' ? getCurtainWallConfig(node).perimeterWidth : 0);
+                    if (o.sill + size.height > wallHeight + 1e-6) {
+                        defect(id, 'wall_too_low', `Wall ${w.spec.id} is ${metres(wallHeight)} high, too low for a ${metres(size.height)} door at sill ${metres(o.sill)}.`);
+                        return;
+                    }
+                }
+                // A door or window is flat, set on the arc at its centre: its ends leave the curve.
+                if (curve) {
+                    const chord = dist(w.start, w.end);
+                    const radius = (chord * chord) / (8 * Math.abs(curve)) + Math.abs(curve) / 2;
+                    const standoff = radius - Math.sqrt(Math.max(0, radius ** 2 - (size.width / 2) ** 2));
+                    const half = w.spec.thickness / 2;
+                    if (standoff > half)
+                        warn(id, 'flat_on_arc', `The ${metres(width)} ${o.kind} is flat on wall ${w.spec.id}, an arc of radius ${metres(radius)}: its ends stand ${metres(standoff)} off the curve, past the wall's faces. Set narrower ones side by side, at most ${metres(2 * Math.sqrt(radius ** 2 - (radius - half) ** 2))} wide.`);
+                }
+                const centre = Math.min(Math.max(o.along, size.width / 2), length - size.width / 2);
+                const x = centre + size.leafOffsetX;
+                if (Math.abs(centre - o.along) > 0.01)
+                    say(`${o.kind} ${id}: moved ${Math.abs(centre - o.along).toFixed(2)} m along the wall to fit inside it`);
                 const common = {
                     object: 'node',
-                    id: mint(o.kind, id),
+                    id: mint(kind, id),
                     parentId: node.id,
                     visible: true,
                     metadata: { authorScene: { id, color: o.color ?? null } },
                     wallId: node.id,
+                    casingFaceA: true,
+                    casingFaceB: true,
                     width,
                     height,
                     rotation: [0, 0, 0],
                     ...(o.name ? { name: o.name } : {}),
+                    ...(o.shape ? { openingShape: o.shape } : {}),
+                    ...(o.archHeight === undefined ? {} : { archHeight: Math.min(o.archHeight, height) }),
                     ...(compiled
                         ? {
                             source: scriptSource(compiled, { category: o.kind }),
@@ -586,7 +810,17 @@ export function authorScene(scene, input, context) {
                         : {}),
                 };
                 let opening;
-                if (o.kind === 'door') {
+                if (passage) {
+                    opening = DoorNode.parse({
+                        ...common,
+                        type: 'door',
+                        frameThickness: NEW_DOOR_FRAME_THICKNESS,
+                        position: [x, o.sill + height / 2, 0],
+                        openingKind: 'opening',
+                    });
+                    report.passages++;
+                }
+                else if (o.kind === 'door') {
                     const type = o.type;
                     if (type && !isDoorType(type))
                         defect(id, 'type_mismatch', `${type} is a window type; the door is written hinged.`);
@@ -600,12 +834,19 @@ export function authorScene(scene, input, context) {
                     opening = DoorNode.parse({
                         ...common,
                         type: 'door',
-                        position: [x, height / 2, 0],
+                        frameThickness: NEW_DOOR_FRAME_THICKNESS,
+                        position: [x, o.sill + height / 2, 0],
                         ...(type && isDoorType(type) ? doorTypeFields(type) : {}),
                         ...(style && isDoorStyle(style) ? doorStyleLook(style) : {}),
                         ...(o.leaves ? { leafCount: o.leaves } : {}),
+                        sidelightLeft: o.sidelightLeft,
+                        sidelightRight: o.sidelightRight,
+                        transomHeight: o.transomHeight,
+                        slidingStyle: o.slidingStyle,
+                        ...(o.slideDirection ? { slideDirection: o.slideDirection } : {}),
                         hingesSide,
                         handleSide,
+                        handleStyle: o.handleStyle,
                         ...(o.swing ? { swingDirection: o.swing === 'back' ? 'outward' : 'inward' } : {}),
                     });
                     report.doors++;
@@ -626,13 +867,35 @@ export function authorScene(scene, input, context) {
                     opening = WindowNode.parse({
                         ...common,
                         type: 'window',
+                        hingesSide: o.hingesSide ?? (o.hinge === 'end' ? 'right' : 'left'),
+                        sashGrid: !windowTakesStyle(windowType ?? 'fixed') && (o.columns || o.rows) ? true : o.sashGrid,
+                        windowHandle: o.windowHandle,
+                        sillInterior: o.sillInterior,
+                        shutters: o.shutters,
+                        shutterWidth: o.shutterWidth,
+                        tiltTurnMode: o.tiltTurnMode,
+                        sillOverhang: o.sillOverhang,
+                        sillInteriorDepth: o.sillInteriorDepth,
+                        sillInteriorThickness: o.sillInteriorThickness,
+                        sillInteriorOverhang: o.sillInteriorOverhang,
+                        shutterOpen: o.shutterOpen,
+                        shutterSides: o.shutterSides,
+                        rollerShutter: o.rollerShutter,
+                        rollerShutterBoxHeight: o.rollerShutterBoxHeight,
+                        rollerShutterOpen: o.rollerShutterOpen,
+                        frameThickness: NEW_WINDOW_FRAME_THICKNESS,
                         position: [x, o.sill + height / 2, 0],
                         ...(windowType ? windowTypeFields(windowType) : {}),
+                        ...(o.openingDirection === undefined ? {} : { openingDirection: o.openingDirection }),
                         ...(style && isWindowStyle(style) && takesStyle ? getWindowStyleOverrides(style) : {}),
+                        ...(o.columns
+                            ? { columnRatios: Array.from({ length: o.columns }, () => 1 / o.columns) }
+                            : {}),
+                        ...(o.rows ? { rowRatios: Array.from({ length: o.rows }, () => 1 / o.rows) } : {}),
                     });
                     report.windows++;
                 }
-                const panel = o.kind === 'door' ? finishRef(o.color, id) : undefined;
+                const panel = kind === 'door' ? finishRef(o.color, id) : undefined;
                 const frame = finishRef(o.frameColor ?? o.color, id);
                 if (panel || frame)
                     opening = {
@@ -658,10 +921,14 @@ export function authorScene(scene, input, context) {
             const polygon = s.polygon;
             // A slab over a wall's footprint, higher than half the wall: a cap, which would lift the
             // wall onto it. Pascal caps its walls itself.
-            const lifted = [...wallNodes.values()].find((w) => s.top > w.spec.height / 2 &&
-                polygonsOverlap(polygon, wallFootprint({ ...w, thickness: w.spec.thickness })));
+            const lifted = [...wallNodes.values()].find((w) => s.top > w.height / 2 &&
+                polygonsOverlap(polygon, wallFootprint({
+                    ...w,
+                    thickness: w.spec.thickness,
+                    curveOffset: w.node.curveOffset,
+                })));
             if (lifted) {
-                defect(id, 'slab_over_wall', `${label} overlaps wall ${lifted.spec.id} with its top at ${metres(s.top)}, above half the wall's ${metres(lifted.spec.height)}: it would lift the wall onto it. Pascal builds a wall's cap itself; fold it into the wall.`);
+                defect(id, 'slab_over_wall', `${label} overlaps wall ${lifted.spec.id} with its top at ${metres(s.top)}, above half the wall's ${metres(lifted.height)}: it would lift the wall onto it. Pascal builds a wall's cap itself; fold it into the wall.`);
                 return;
             }
             if (s.thickness < THIN_SLAB)
@@ -679,35 +946,527 @@ export function authorScene(scene, input, context) {
                 elevation: s.top,
                 thickness: s.thickness,
                 ...(finish ? { slots: { surface: finish } } : {}),
-                ...(s.railing?.length
-                    ? { railing: s.railing.map((r) => ({ start: r.start, end: r.end })) }
-                    : {}),
             });
             place(node);
             report.ids[id] = node.id;
             report.slabs++;
+            (s.railing ?? []).forEach((r, k) => {
+                const railId = `${id}/railing/${k}`;
+                let fence = FenceNode.parse({
+                    object: 'node',
+                    id: mint('fence', railId),
+                    parentId: levelNode.id,
+                    visible: true,
+                    metadata: { authorScene: { id: railId } },
+                    name: 'Railing',
+                    start: r.start,
+                    end: r.end,
+                    height: r.height,
+                    style: 'rail',
+                    baseStyle: 'floating',
+                    baseHeight: 0,
+                    postCap: 'none',
+                    supportSlabId: node.id,
+                });
+                const railFinish = finishRef(r.color, railId);
+                if (railFinish)
+                    fence = {
+                        ...fence,
+                        slots: Object.fromEntries((nodeSlotDeclarations(fence) ?? []).map((slot) => [slot.slotId, railFinish])),
+                    };
+                place(fence);
+            });
         });
         (level.columns ?? []).forEach((c, i) => {
-            const node = ColumnNode.parse({
+            const id = `column/${index}/${i}`;
+            let compiled;
+            if (c.code) {
+                compiled = input.compiled[id];
+                if (!compiled) {
+                    defect(id, 'compile_failed', input.compileErrors?.[id] ?? 'The module did not compile.');
+                    return;
+                }
+                if (compiled.mount !== 'floor') {
+                    defect(id, 'wrong_mount', `A column's module uses mount 'floor', not '${compiled.mount}'.`);
+                    return;
+                }
+                try {
+                    requireMeasured(compiled, { label: c.name ?? id, tool: 'author_scene' });
+                }
+                catch (error) {
+                    const e = error;
+                    defect(id, e.code ?? 'unmeasurable_object', e.message ?? String(error));
+                    return;
+                }
+                if (c.color)
+                    say(`column ${id}: built by its module, which keeps its own colours; color ignored`);
+            }
+            const size = compiled && scriptedSize(compiled.manifest);
+            let node = ColumnNode.parse({
                 object: 'node',
                 type: 'column',
-                id: mint('column', `column/${index}/${i}`),
+                id: mint('column', id),
                 parentId: levelNode.id,
                 visible: true,
-                metadata: { authorScene: { color: c.color ?? null } },
+                metadata: { authorScene: { id } },
                 ...(c.name ? { name: c.name } : {}),
                 position: [c.position[0], 0, c.position[1]],
-                crossSection: 'square',
-                width: c.width,
-                depth: c.depth,
-                height: c.height,
-                baseHeight: 0,
-                capitalHeight: 0,
+                rotation: (c.rotation * Math.PI) / 180,
+                ...(compiled && size
+                    ? {
+                        source: scriptSource(compiled, { category: 'column' }),
+                        slots: exactSlots(compiled, id),
+                        width: size[0],
+                        height: size[1],
+                        depth: size[2],
+                    }
+                    : {
+                        crossSection: c.shape,
+                        ...(c.shape === 'round' ? { radius: c.width / 2 } : {}),
+                        width: c.width,
+                        depth: c.shape === 'round' ? c.width : (c.depth ?? c.width),
+                        height: c.height,
+                        baseHeight: 0,
+                        capitalHeight: 0,
+                    }),
             });
+            const finish = !compiled && finishRef(c.color, id);
+            if (finish)
+                node = {
+                    ...node,
+                    slots: Object.fromEntries((nodeSlotDeclarations(node) ?? []).map((slot) => [slot.slotId, finish])),
+                };
             place(node);
-            report.ids[`column/${index}/${i}`] = node.id;
+            report.ids[id] = node.id;
             report.columns++;
         });
+        levelWalls.push({ walls, wallNodes });
+    });
+    report.levels = levelNodes.length;
+    if (untypedWindows)
+        say(`${untypedWindows} window${untypedWindows === 1 ? ' has' : 's have'} no type: written fixed (cannot open); give type`);
+    // ---------- which face of each wall looks into a room: read from the plan, as the editor does ----------
+    for (const levelNode of levelNodes) {
+        const boundaries = Object.values(draft).filter((n) => n.parentId === levelNode.id && (n.type === 'wall' || n.type === 'separator'));
+        for (const { wallId, ...sides } of detectSpacesForLevel(levelNode.id, boundaries).wallUpdates)
+            draft[wallId] = { ...draft[wallId], ...sides };
+    }
+    // ---------- rooms: Pascal's own derivation, then the payload's names and floors ----------
+    const { nodes: withZones, createdZoneIds } = migrateRoomZones(draft);
+    const zones = createdZoneIds.map((id) => ZoneNode.parse(withZones[id]));
+    for (const zone of zones) {
+        draft[zone.id] = zone;
+        const level = draft[zone.parentId];
+        draft[zone.parentId] = { ...level, children: [...level.children, zone.id] };
+        report.rooms++;
+    }
+    const joined = new Map();
+    const roomIds = new Map();
+    payload.levels.forEach((level, index) => {
+        const levelNode = levelNodes[index];
+        for (const [i, room] of level.rooms.entries()) {
+            const id = `room/${index}/${i}`;
+            roomIds.set(room, id);
+            const zone = zones.find((z) => z.parentId === levelNode.id && pointInPolygon(room.seed, z.polygon));
+            // Several seeds in one enclosure name one open-plan room, in the order given.
+            const sharing = zone && joined.get(zone.id);
+            if (sharing) {
+                sharing.push(room);
+                continue;
+            }
+            if (!zone) {
+                defect(id, 'room_not_enclosed', `No closed room around (${room.seed[0]}, ${room.seed[1]}) "${room.name}": its walls do not meet.`);
+                continue;
+            }
+            if (room.floorRegions.length > MANY_REGIONS)
+                warn(id, 'many_regions', `"${room.name}" has ${room.floorRegions.length} floor regions: regions are fixed polygons that do not follow a resize; use one floor finish.`);
+            const finish = finishRef(room.floor, id);
+            const regions = room.floorRegions.map((r, k) => ({
+                id: `region_${k}`,
+                polygon: r.polygon,
+                finish: finishRef(r.finish, id) ?? r.finish,
+            }));
+            draft[zone.id] = ZoneNode.parse({
+                ...zone,
+                name: room.name,
+                spaceRole: 'room',
+                ...(finish || regions.length
+                    ? {
+                        floor: {
+                            ...zone.floor,
+                            ...(finish ? { finish } : {}),
+                            ...(regions.length ? { regions } : {}),
+                        },
+                    }
+                    : {}),
+                metadata: { ...zone.metadata, authorScene: { seed: room.seed } },
+            });
+            joined.set(zone.id, [room]);
+            report.ids[id] = zone.id;
+            report.roomsNamed++;
+        }
+    });
+    for (const [zoneId, rooms] of joined) {
+        if (rooms.length < 2)
+            continue;
+        const [first, ...rest] = rooms.map((room) => room.name);
+        // "Kitchen" joins as "kitchen"; a name that is not a capitalised word ("WC") stays as given.
+        const names = [
+            first,
+            ...rest.map((name) => name.replace(/^([A-Z])(?=[a-z])/, (c) => c.toLowerCase())),
+        ];
+        const name = `${names.slice(0, -1).join(', ')} and ${names.at(-1)}`;
+        draft[zoneId] = { ...draft[zoneId], name };
+        report.roomsNamed += rest.length;
+        const floors = rooms
+            .slice(1)
+            .filter((room) => room.floor || room.floorCode || room.floorRegions.length);
+        say(`${rooms.map((room) => `"${room.name}"`).join(', ')} are one enclosure, no wall between them: one open-plan room, "${name}"${floors.length ? `, with the floor of "${first}"` : ''}`);
+    }
+    // ---------- units: one per distinct name, under the building, holding the rooms that name it ----------
+    const units = new Map();
+    for (const unit of payload.units) {
+        const color = unit.color && HEX.test(unit.color) ? unit.color : undefined;
+        if (unit.color && !color)
+            defect(`unit/${unit.name}`, 'invalid_color', `"${unit.color}" is not a #rrggbb colour.`);
+        units.set(unit.name, { kind: unit.kind, color, zones: [] });
+    }
+    for (const [zoneId, rooms] of joined) {
+        const names = [...new Set(rooms.flatMap((room) => (room.unit ? [room.unit] : [])))];
+        // One enclosure is one room, so it is in one unit: seeds naming two want a wall between them.
+        if (names.length > 1) {
+            defect(roomIds.get(rooms[0]), 'unit_split_room', `${rooms.map((room) => `"${room.name}"`).join(', ')} are one open-plan room but name different units (${names.join(', ')}): the room is in none. Put a wall between them, or one unit on all of them.`);
+            continue;
+        }
+        if (!names[0])
+            continue;
+        const entry = units.get(names[0]) ?? { kind: 'apartment', zones: [] };
+        entry.zones.push(zoneId);
+        units.set(names[0], entry);
+    }
+    for (const [name, { kind, color, zones: members }] of units) {
+        const unit = UnitNode.parse({
+            id: mint('unit', `unit/${name}`),
+            parentId: building.id,
+            name,
+            kind,
+            ...(color ? { color } : {}),
+            members,
+        });
+        draft[unit.id] = unit;
+        report.ids[`unit/${name}`] = unit.id;
+        report.units++;
+        if (!members.length)
+            warn(`unit/${name}`, 'unit_no_rooms', `No room names unit "${name}".`);
+    }
+    // ---------- floors and ceilings, as the editor derives them on load ----------
+    const levelIds = levelNodes.map((l) => l.id);
+    let written = {
+        ...reconcileSceneStructure({ nodes: draft, levelIds, mintId: (kind) => mint(kind) }).nodes,
+    };
+    for (const opening of Object.values(written)) {
+        const wall = written[opening.parentId ?? ''];
+        if (opening.type !== 'door' || wall?.type !== 'wall' || scaffoldIds.has(opening.id))
+            continue;
+        const facing = doorFacing(wall);
+        written[opening.id] = {
+            ...opening,
+            ...facing,
+            position: doorPositionForFacing(opening, facing.rotation),
+        };
+    }
+    // A room's plate and ceiling are named by its room, whose id follows its walls: a revision keeps
+    // an unchanged room's, and a room it adds brings its own with it (never another room's renamed).
+    const derivedIds = new Map();
+    for (const node of Object.values(written)) {
+        const zones = node.type === 'ceiling' && node.zoneId
+            ? [node.zoneId]
+            : node.type === 'slab' && node.plateRole === 'base'
+                ? [...(node.zoneIds ?? [])].sort()
+                : [];
+        if (zones.length && !scaffoldIds.has(node.id))
+            derivedIds.set(node.id, mint(node.type, `${node.type}/${zones.join('+')}`));
+    }
+    if (derivedIds.size) {
+        let json = JSON.stringify(written);
+        for (const [from, to] of derivedIds)
+            json = json.replaceAll(`"${from}"`, `"${to}"`);
+        written = JSON.parse(json);
+    }
+    // ---------- the floor between storeys: each upper plate keeps its top and reaches down to the walls ----------
+    for (const [index, { below, wallHeight, storey }] of floorsAbove) {
+        const plates = (levelId) => Object.values(written).filter((node) => node.type === 'slab' && node.parentId === levelId && node.plateRole === 'base');
+        // The carrying walls stand on the floor below; their tops, in this level's frame, are its underside.
+        const lower = plates(levelNodes[index - 1].id);
+        const underside = (lower.length ? Math.max(...lower.map((p) => p.elevation)) : 0) + wallHeight;
+        // Seen from outside, the band continues the cladding under it: the colour most of those walls
+        // wear outside paints the plate's edge and sides.
+        const outsides = (payload.levels[index - 1].walls ?? []).flatMap((w) => w.colorOutside ? [w.colorOutside] : []);
+        const cladding = mostCommon(outsides);
+        const bandRef = cladding && finishRef(cladding, `level/${index}/floor`);
+        const depths = new Set();
+        for (const plate of plates(levelNodes[index].id)) {
+            const thickness = roundFloorElevation(plate.elevation - (underside - storey));
+            written[plate.id] = {
+                ...plate,
+                thickness,
+                ...(bandRef ? { slots: { ...plate.slots, edge: bandRef, side: bandRef } } : {}),
+            };
+            depths.add(thickness);
+        }
+        if (depths.size)
+            say(`"${payload.levels[index].name}" stands on a ${[...depths].map(metres).join(', ')} floor over the ${metres(wallHeight)} walls of "${below}": its plate reaches down to their tops`);
+    }
+    /**
+     * The room a plan point of a level is in, its ceiling, and the height in that level's frame that
+     * ceiling hangs things from. Under an opening in the ceiling (a void, a stairwell) it is the
+     * ceiling above, the room's double height.
+     */
+    const ceilingAt = (index, x, z) => {
+        const levelId = levelNodes[index].id;
+        const room = Object.values(written).find((node) => node.type === 'zone' &&
+            node.spaceRole === 'room' &&
+            node.parentId === levelId &&
+            pointInPolygon([x, z], node.polygon) &&
+            !node.holes.some((hole) => pointInPolygon([x, z], hole)));
+        const ceiling = room &&
+            Object.values(written).find((node) => node.type === 'ceiling' && node.zoneId === room.id && node.parentId === levelId);
+        if (!room || !ceiling)
+            return undefined;
+        if (levelNodes[index + 1] && ceiling.holes.some((hole) => pointInPolygon([x, z], hole))) {
+            const above = ceilingAt(index + 1, x, z);
+            const climb = payload.levels[index + 1].elevation - payload.levels[index].elevation;
+            if (above)
+                return { ...above, height: above.height + climb };
+        }
+        return { room, ceiling, height: resolveCeilingHeight(ceiling, written) - CEILING_DRAW_OFFSET };
+    };
+    // ---------- stairs, as create_stair builds them: up to the next level, opening its floor ----------
+    let stairsWritten = false;
+    payload.levels.forEach((level, index) => {
+        const levelNode = levelNodes[index];
+        const upper = levelNodes[index + 1];
+        (level.stairs ?? []).forEach((stair, i) => {
+            const id = `stair/${index}/${i}`;
+            if (!upper) {
+                defect(id, 'no_level_above', `A stair on "${level.name}", the top level, has nothing to rise to: give the level it reaches after this one in levels.`);
+                return;
+            }
+            try {
+                const outcome = createStair(written, {
+                    x: stair.start[0],
+                    z: stair.start[1],
+                    rotation: stair.rotation,
+                    layout: stair.layout,
+                    width: stair.width,
+                    ...(stair.turn ? { turn: stair.turn } : {}),
+                    ...(stair.length === undefined ? {} : { length: stair.length }),
+                    ...(stair.steps === undefined ? {} : { steps: stair.steps }),
+                    ...(stair.lowerSteps === undefined ? {} : { lowerSteps: stair.lowerSteps }),
+                    ...(stair.railing ? { railingMode: stair.railing } : {}),
+                    ...(stair.railingStyle ? { railingStyle: stair.railingStyle } : {}),
+                    ...(stair.name ? { name: stair.name } : {}),
+                    levelId: levelNode.id,
+                    toLevelId: upper.id,
+                }, { ...context, activeLevelId: levelNode.id });
+                const result = outcome.result;
+                // create_stair mints fresh ids; the conversion's own keep the stair across revisions.
+                let json = JSON.stringify(outcome.changes);
+                (outcome.changes?.create ?? []).forEach(({ node }, k) => {
+                    const kind = node.id.slice(0, node.id.indexOf('_'));
+                    json = json.replaceAll(node.id, mint(kind, k ? `${id}/${k}` : id));
+                });
+                const changes = JSON.parse(json);
+                const [made, ...rest] = changes.create;
+                changes.create = [
+                    {
+                        ...made,
+                        node: {
+                            ...made.node,
+                            metadata: { ...made.node.metadata, authorScene: { id } },
+                        },
+                    },
+                    ...rest,
+                ];
+                written = applySceneChanges(written, changes);
+                const finishes = [
+                    ['body', stair.color],
+                    ['treads', stair.treads ?? stair.color],
+                    ['railing', stair.railingColor],
+                ];
+                for (const [role, color] of finishes) {
+                    const finish = finishRef(color, id);
+                    if (!finish)
+                        continue;
+                    if (!nodeSlotDeclarations(written[made.node.id])?.some((slot) => slot.slotId === role)) {
+                        say(`${id}: it has no ${role}, its ${role === 'railing' ? 'railingColor' : 'color'} ignored`);
+                        continue;
+                    }
+                    try {
+                        const { changes } = paint(written, { targets: [made.node.id], material: finish, role }, paintContext(levelNode.id));
+                        written = applySceneChanges(written, changes);
+                    }
+                    catch (error) {
+                        defect(id, 'paint_refused', error.message);
+                    }
+                }
+                report.ids[id] = made.node.id;
+                report.stairs++;
+                stairsWritten = true;
+                if (result.slabHoleCut)
+                    say(`${id}: ${result.message}`);
+                else
+                    warn(id, 'no_floor_opening', result.message);
+            }
+            catch (error) {
+                const e = error;
+                defect(id, e.code ?? 'stair_refused', e.message ?? String(error));
+            }
+        });
+    });
+    /** The plan footprints of a level's walls as written, each grown by `grow` on both faces. */
+    const wallFootprints = (levelId, grow = 0) => {
+        const walls = Object.values(written).flatMap((node) => node.type === 'wall' && node.parentId === levelId
+            ? [grow ? { ...node, thickness: getWallThickness(node) + 2 * grow } : node]
+            : []);
+        const miters = calculateLevelMiters(walls);
+        return walls.map((wall) => getWallPlanFootprint(wall, miters).map(({ x, y }) => [x, y]));
+    };
+    // ---------- voids: openings in a level's floor, the room below rising through them ----------
+    const voidCuts = new Map();
+    const voidsCut = [];
+    payload.levels.forEach((level, index) => {
+        const levelNode = levelNodes[index];
+        (level.voids ?? []).forEach((v, i) => {
+            const id = `void/${index}/${i}`;
+            const label = v.name ? `"${v.name}"` : `void ${i}`;
+            if (index === 0) {
+                defect(id, 'no_level_below', `${label} is in the floor of "${level.name}", the first level, with nothing under it to open onto: give it in the floor of the level above the room that rises through it.`);
+                return;
+            }
+            // The cut stops at the faces of the walls standing on this floor, as the floor carries them,
+            // and at the floor's own edge (a void drawn past a curved outside wall).
+            const floor = union(Object.values(written).flatMap((node) => node.type === 'slab' && node.parentId === levelNode.id && node.plateRole === 'base'
+                ? [node.polygon]
+                : []));
+            const cut = intersection(difference(v.polygon, union(wallFootprints(levelNode.id))), floor).filter((part) => area([part]) > 1e-4);
+            const opened = area(cut);
+            if (opened < 1e-4) {
+                defect(id, 'no_floor', `No floor of "${level.name}" lies under ${label} clear of its walls: there is nothing to open.`);
+                return;
+            }
+            if (cut.some((part) => part.holes.length))
+                warn(id, 'wall_in_void', `A wall of "${level.name}" stands inside ${label}, over the opening around it: end the void at the wall, or move the wall.`);
+            let cutsCeiling = false;
+            cut.forEach((part, k) => {
+                const plan = cutFloorOpening(written, {
+                    levelId: levelNode.id,
+                    polygon: part.outer,
+                    drawnOn: 'floor',
+                    mintId: () => mint('floor-opening', k ? `${id}/${k}` : id),
+                });
+                for (const change of plan.changes) {
+                    if (change.op === 'create') {
+                        const opening = change.node;
+                        cutsCeiling ||= opening.cutsAdjacent;
+                        written[opening.id] = {
+                            ...opening,
+                            name: v.name ?? 'Void',
+                            metadata: { ...opening.metadata, authorScene: { id } },
+                        };
+                        if (!k)
+                            report.ids[id] = opening.id;
+                    }
+                    else if (change.op === 'update')
+                        written[change.id] = { ...written[change.id], ...change.data };
+                }
+            });
+            report.voids++;
+            say(`${id}: the floor of "${level.name}" opened over ${opened.toFixed(1)} m², ${cutsCeiling ? `and the ceiling of "${payload.levels[index - 1].name}" under it` : `with no ceiling of "${payload.levels[index - 1].name}" under it`}`);
+            voidCuts.set(index, union([...(voidCuts.get(index) ?? []), ...cut]));
+            voidsCut.push({
+                id,
+                index,
+                cut,
+                railing: v.railing === null ? null : (v.railing ?? { height: 1.1 }),
+            });
+        });
+    });
+    // The openings the stairs and voids own cut the floor plates and ceilings they pass, as on load.
+    if (stairsWritten || report.voids)
+        written = {
+            ...reconcileSceneStructure({ nodes: written, levelIds, mintId: (kind) => mint(kind) }).nodes,
+        };
+    // ---------- each void's railing: along its open edges, on the floor, as the slab railing looks ----------
+    for (const { id, index, cut, railing } of voidsCut) {
+        const levelNode = levelNodes[index];
+        // Inside the double height the floor's edge round the void continues the walls it rises
+        // between: it wears their inside paint, where the facade's edge keeps the cladding.
+        const insides = (payload.levels[index - 1].walls ?? []).flatMap((w) => w.colorInside ? [w.colorInside] : []);
+        const edge = finishRef(mostCommon(insides), id);
+        if (edge)
+            for (const zone of Object.values(written))
+                if (zone.type === 'zone' &&
+                    zone.parentId === levelNode.id &&
+                    zone.spaceRole === 'room' &&
+                    area(intersection(cut, zone.polygon)) > 1e-4)
+                    written[zone.id] = { ...zone, floorEdgeFinish: edge };
+        if (!railing)
+            continue;
+        // A run stops at a wall standing on the edge and where a stair arrives.
+        const arrivals = Object.values(written).flatMap((node) => node.type === 'stair' && node.toLevelId === levelNode.id
+            ? [stairArrivalOpening(node, written)]
+            : []);
+        const cover = union([
+            ...wallFootprints(levelNode.id, 0.005),
+            ...arrivals.filter((ring) => ring.length >= 3),
+        ]);
+        const runs = exposedIntervals(cut, [], cover).filter(({ start, end }) => dist(start, end) >= 0.1);
+        const plate = Object.values(written)
+            .filter((node) => node.type === 'slab' && node.parentId === levelNode.id && node.plateRole === 'base')
+            .map((node) => ({ node, shared: area(intersection(cut, node.polygon)) }))
+            .sort((a, b) => b.shared - a.shared)[0]?.node;
+        const fences = runs.map((run, k) => FenceNode.parse({
+            object: 'node',
+            id: mint('fence', `${id}/railing/${k}`),
+            parentId: levelNode.id,
+            visible: true,
+            metadata: { authorScene: { id } },
+            name: 'Railing',
+            start: run.start,
+            end: run.end,
+            height: railing.height,
+            style: 'rail',
+            baseStyle: 'floating',
+            baseHeight: 0,
+            postCap: 'none',
+            ...(plate ? { supportSlabId: plate.id } : {}),
+        }));
+        if (!fences.length)
+            continue;
+        const level = written[levelNode.id];
+        written[level.id] = {
+            ...level,
+            children: [...level.children, ...fences.map((f) => f.id)],
+        };
+        for (const fence of fences)
+            written[fence.id] = fence;
+        const finish = finishRef(railing.color, id);
+        if (finish)
+            try {
+                const { changes } = paint(written, { targets: fences.map((fence) => fence.id), material: finish }, paintContext(levelNode.id));
+                for (const u of changes?.update ?? [])
+                    written[u.id] = { ...written[u.id], ...u.data };
+            }
+            catch (error) {
+                defect(id, 'paint_refused', error.message);
+            }
+        say(`${id}: a ${metres(railing.height)} railing along ${metres(runs.reduce((sum, run) => sum + dist(run.start, run.end), 0))} of its edges`);
+    }
+    // ---------- items, on their floors and ceilings, then each wall's paint ----------
+    payload.levels.forEach((level, index) => {
+        const levelNode = levelNodes[index];
+        const { walls, wallNodes } = levelWalls[index];
         // ---------- items, hosts first ----------
         const pending = [...(level.items ?? [])];
         let progress = true;
@@ -725,14 +1484,20 @@ export function authorScene(scene, input, context) {
                     defect(item.id, 'compile_failed', input.compileErrors?.[item.id] ?? 'The module did not compile.');
                     continue;
                 }
+                if (/^(stairs?|staircases?)$/i.test(item.category))
+                    warn(item.id, 'use_stairs', `"${item.name}" is a stair written as an item: give it as its level's stairs, so it rises with the storey and opens the floor above.`);
                 const world = [item.position[0], item.position[1], item.position[2]];
                 const yaw = (item.rotation * Math.PI) / 180;
                 let placed;
+                if (hostWall && isCurvedWall(hostWall.node)) {
+                    defect(item.id, 'curved_host', `Wall ${item.host} is curved: nothing hangs on a curved wall, as in the editor. Hang "${item.name}" on a straight wall, or stand it on the floor.`);
+                    continue;
+                }
                 if (hostWall) {
                     // On the wall as place_items puts a wall-side item there: along it from its start, the
                     // payload's height for its bottom, on the face nearest the point, facing the room.
                     const [width, height] = scriptedSize(compiled.manifest);
-                    const wallHeight = hostWall.spec.height;
+                    const wallHeight = hostWall.height;
                     if (height > wallHeight) {
                         defect(item.id, 'item_too_tall', `"${item.name}" is ${metres(height)} tall; wall ${item.host} is ${metres(wallHeight)}.`);
                         continue;
@@ -773,8 +1538,27 @@ export function authorScene(scene, input, context) {
                         },
                     };
                 }
+                else if (compiled.mount === 'ceiling' && !item.host) {
+                    // From the ceiling of the room its plan point is in, its top on that ceiling.
+                    const over = ceilingAt(index, world[0], world[2]);
+                    if (!over) {
+                        defect(item.id, 'no_ceiling', `"${item.name}" hangs from a ceiling, and no room on "${level.name}" contains (${world[0]}, ${world[2]}): move it into a room, or build it with mount 'floor'.`);
+                        continue;
+                    }
+                    say(`${item.id}: hung from the ceiling of ${over.room.name}, ${metres(over.height)} up`);
+                    placed = {
+                        compiled,
+                        parentId: over.ceiling.id,
+                        position: [world[0], 0, world[2]],
+                        rotation: item.rotation,
+                        frame: { position: [world[0], over.height, world[2]], yaw },
+                    };
+                }
                 else {
                     const host = hostItemId ? itemFrames.get(item.host) : undefined;
+                    const opening = voidCuts.get(index);
+                    if (!host && opening && containsPoint(opening, [world[0], world[2]]))
+                        warn(item.id, 'over_void', `"${item.name}" stands at (${world[0]}, ${world[2]}), over a void in the floor of "${level.name}": nothing is under it. Move it onto the floor.`);
                     placed = {
                         compiled,
                         parentId: hostItemId ?? levelNode.id,
@@ -784,7 +1568,7 @@ export function authorScene(scene, input, context) {
                     };
                 }
                 try {
-                    const outcome = addObject(draft, {
+                    const outcome = addObject(written, {
                         compiled: { ...placed.compiled, nodeId: mint('item', item.id) },
                         name: item.name,
                         category: item.category,
@@ -795,13 +1579,16 @@ export function authorScene(scene, input, context) {
                         ...(placed.side ? { side: placed.side } : {}),
                     }, { ...context, activeLevelId: levelNode.id });
                     for (const { node, parentId } of outcome.changes?.create ?? []) {
-                        draft[node.id] = {
+                        written[node.id] = {
                             ...node,
                             slots: exactSlots(compiled, item.id),
                             ...(placed.wallT === undefined ? {} : { wallT: placed.wallT }),
                         };
-                        const parent = draft[parentId ?? levelNode.id];
-                        parent.children = [...(parent.children ?? []), node.id];
+                        const parent = written[parentId ?? levelNode.id];
+                        written[parent.id] = {
+                            ...parent,
+                            children: [...(parent.children ?? []), node.id],
+                        };
                         itemNodeIds.set(item.id, node.id);
                         itemFrames.set(item.id, placed.frame);
                         report.ids[item.id] = node.id;
@@ -817,15 +1604,46 @@ export function authorScene(scene, input, context) {
         for (const item of pending)
             defect(item.id, 'host_missing', `Its host ${item.host} was not placed.`);
         // ---------- wall paint, through the editor's paint: both faces, or each its own ----------
+        const inside = {
+            left: [],
+            right: [],
+            both: [],
+            neither: [],
+        };
         for (const w of walls) {
             const node = wallNodes.get(w.spec.id)?.node;
             if (!node)
                 continue;
-            const faces = {
-                a: w.spec.colorLeft ?? w.spec.color,
-                b: w.spec.colorRight ?? w.spec.color,
-            };
             const coats = [];
+            if (w.spec.curtain) {
+                // Glass and mullions: no face to paint; its frame takes the colour.
+                const ignored = ['color', 'colorInside', 'colorOutside', 'colorLeft', 'colorRight'].filter((field) => w.spec[field]);
+                if (ignored.length)
+                    say(`wall ${w.spec.id}: a curtain wall has no faces to paint, its ${ignored.join(', ')} ignored; curtain.frameColor colours its frame`);
+                const frame = finishRef(w.spec.curtain.frameColor, w.spec.id);
+                if (frame)
+                    coats.push({ role: 'curtain-frame', material: frame });
+            }
+            const { colorInside, colorOutside } = w.spec.curtain ? {} : w.spec;
+            // A face is inside when a room of this level stands on it, known once the rooms are derived.
+            const cover = colorInside || colorOutside ? roomFaceCover(written, node.id) : undefined;
+            const meant = (face) => cover && (cover[face] === 'none' ? colorOutside : colorInside);
+            if (cover) {
+                const faces = ['a', 'b'].filter((face) => cover[face] !== 'none');
+                inside[faces.length === 2
+                    ? 'both'
+                    : faces.length === 0
+                        ? 'neither'
+                        : faces[0] === 'a'
+                            ? 'left'
+                            : 'right'].push(w.spec.id);
+            }
+            const faces = w.spec.curtain
+                ? {}
+                : {
+                    a: w.spec.colorLeft ?? meant('a') ?? w.spec.color,
+                    b: w.spec.colorRight ?? meant('b') ?? w.spec.color,
+                };
             if (faces.a && faces.a === faces.b) {
                 const ref = finishRef(faces.a, w.spec.id);
                 if (ref)
@@ -839,84 +1657,24 @@ export function authorScene(scene, input, context) {
                 }
             for (const coat of coats) {
                 try {
-                    const { changes } = paint(draft, { targets: [node.id], ...coat }, paintContext(levelNode.id));
+                    const { changes } = paint(written, { targets: [node.id], ...coat }, paintContext(levelNode.id));
                     for (const u of changes?.update ?? [])
-                        draft[u.id] = { ...draft[u.id], ...u.data };
+                        written[u.id] = { ...written[u.id], ...u.data };
                 }
                 catch (error) {
                     defect(w.spec.id, 'paint_refused', error.message);
                 }
             }
         }
+        const resolved = [
+            inside.left.length && `the left face of ${inside.left.join(', ')}`,
+            inside.right.length && `the right face of ${inside.right.join(', ')}`,
+            inside.both.length && `both faces of ${inside.both.join(', ')}`,
+            inside.neither.length && `neither face of ${inside.neither.join(', ')}`,
+        ].filter(Boolean);
+        if (resolved.length)
+            say(`colorInside / colorOutside on "${level.name}", left and right as seen from each wall's start to its end: inside is ${resolved.join('; ')}`);
     });
-    report.levels = levelNodes.length;
-    if (untypedWindows)
-        say(`${untypedWindows} window${untypedWindows === 1 ? ' has' : 's have'} no type: written fixed (cannot open); give type`);
-    // ---------- which face of each wall looks into a room: read from the plan, as the editor does ----------
-    for (const levelNode of levelNodes) {
-        const boundaries = Object.values(draft).filter((n) => n.parentId === levelNode.id && (n.type === 'wall' || n.type === 'separator'));
-        for (const { wallId, ...sides } of detectSpacesForLevel(levelNode.id, boundaries).wallUpdates)
-            draft[wallId] = { ...draft[wallId], ...sides };
-    }
-    // ---------- rooms: Pascal's own derivation, then the payload's names and floors ----------
-    const { nodes: withZones, createdZoneIds } = migrateRoomZones(draft);
-    const zones = createdZoneIds.map((id) => ZoneNode.parse(withZones[id]));
-    for (const zone of zones) {
-        draft[zone.id] = zone;
-        const level = draft[zone.parentId];
-        draft[zone.parentId] = { ...level, children: [...level.children, zone.id] };
-        report.rooms++;
-    }
-    const claimed = new Map();
-    payload.levels.forEach((level, index) => {
-        const levelNode = levelNodes[index];
-        for (const [i, room] of level.rooms.entries()) {
-            const id = `room/${index}/${i}`;
-            const zone = zones.find((z) => z.parentId === levelNode.id && pointInPolygon(room.seed, z.polygon));
-            // Two seeds in one enclosure: the walls do not separate the rooms the payload names.
-            if (zone && claimed.has(zone.id)) {
-                defect(id, 'room_shares_enclosure', `"${room.name}" and "${claimed.get(zone.id)}" are one enclosure: no wall separates them.`);
-                continue;
-            }
-            if (!zone) {
-                defect(id, 'room_not_enclosed', `No closed room around (${room.seed[0]}, ${room.seed[1]}) "${room.name}": its walls do not meet.`);
-                continue;
-            }
-            if (room.floorRegions.length > MANY_REGIONS)
-                warn(id, 'many_regions', `"${room.name}" has ${room.floorRegions.length} floor regions: regions are fixed polygons that do not follow a resize; use one floor finish.`);
-            const finish = finishRef(room.floor, id);
-            const regions = room.floorRegions.map((r, k) => ({
-                id: `region_${k}`,
-                polygon: r.polygon,
-                finish: finishRef(r.finish, id) ?? r.finish,
-            }));
-            draft[zone.id] = ZoneNode.parse({
-                ...zone,
-                name: room.name,
-                spaceRole: 'room',
-                ...(finish || regions.length
-                    ? {
-                        floor: {
-                            ...zone.floor,
-                            ...(finish ? { finish } : {}),
-                            ...(regions.length ? { regions } : {}),
-                        },
-                    }
-                    : {}),
-                metadata: { ...zone.metadata, authorScene: { seed: room.seed } },
-            });
-            claimed.set(zone.id, room.name);
-            report.ids[id] = zone.id;
-            report.roomsNamed++;
-        }
-    });
-    // ---------- floors and ceilings, as the editor derives them on load ----------
-    const structure = reconcileSceneStructure({
-        nodes: draft,
-        levelIds: levelNodes.map((l) => l.id),
-        mintId: (kind) => mint(kind),
-    });
-    const written = { ...structure.nodes };
     // ---------- skirting, native on each wall, along the faces its rooms stand on ----------
     for (const { id, nodeId, levelId, skirting } of skirtings) {
         const finish = finishRef(skirting.color, id);
@@ -944,22 +1702,47 @@ export function authorScene(scene, input, context) {
     // Ceilings exist only after structure reconciliation; lights can now use their room's host.
     payload.levels.forEach((level, index) => {
         const levelNode = levelNodes[index];
-        for (const [i, light] of level.lights.entries()) {
-            const id = `light/${index}/${i}`;
+        const entries = level.lights.map((light, i) => ({ id: `light/${index}/${i}`, light }));
+        // A named room with no light of its own (none whose plan point is in it, given or built into
+        // an item) gets a plain ceiling light at its seed.
+        const lit = [
+            ...level.lights.map((light) => [light.position[0], light.position[2]]),
+            ...(level.items ?? []).flatMap((item) => {
+                const frame = itemFrames.get(item.id);
+                return frame && input.compiled[item.id]?.manifest.lights?.length
+                    ? [[frame.position[0], frame.position[2]]]
+                    : [];
+            }),
+        ];
+        const seen = new Set();
+        level.rooms.forEach((room, i) => {
+            const zone = written[report.ids[`room/${index}/${i}`] ?? ''];
+            if (!zone || seen.has(zone.id))
+                return;
+            seen.add(zone.id);
+            const inside = (p) => pointInPolygon(p, zone.polygon) && !zone.holes.some((hole) => pointInPolygon(p, hole));
+            if (lit.some(inside))
+                return;
+            const over = ceilingAt(index, room.seed[0], room.seed[1]);
+            if (!over)
+                return;
+            entries.push({
+                id: roomLightId(index, i),
+                light: {
+                    position: [room.seed[0], over.height - 0.1, room.seed[1]],
+                    color: '#ffffff',
+                    intensity: 1,
+                },
+                room: zone.name ?? room.name,
+            });
+        });
+        for (const { id, light, room: unlit } of entries) {
             const at = [light.position[0], light.position[1], light.position[2]];
             let hostId = light.fixture ? itemNodeIds.get(light.fixture) : undefined;
             let hostFrame = light.fixture ? itemFrames.get(light.fixture) : undefined;
-            const room = !light.fixture
-                ? Object.values(written).find((node) => node.type === 'zone' &&
-                    node.spaceRole === 'room' &&
-                    node.parentId === levelNode.id &&
-                    pointInPolygon([at[0], at[2]], node.polygon) &&
-                    !node.holes.some((hole) => pointInPolygon([at[0], at[2]], hole)))
-                : undefined;
-            const ceiling = room
-                ? Object.values(written).find((node) => node.type === 'ceiling' && node.zoneId === room.id && node.parentId === levelNode.id)
-                : undefined;
-            if (ceiling) {
+            const over = light.fixture ? undefined : ceilingAt(index, at[0], at[2]);
+            if (over) {
+                const { room, ceiling } = over;
                 const compiled = input.compiled[id];
                 if (!compiled) {
                     defect(id, 'compile_failed', input.compileErrors?.[id] ?? 'The ceiling point module did not compile.');
@@ -980,12 +1763,14 @@ export function authorScene(scene, input, context) {
                     written[ceiling.id] = { ...ceiling, children: [...ceiling.children, node.id] };
                     hostId = node.id;
                     hostFrame = {
-                        position: [at[0], resolveCeilingHeight(ceiling, written) - CEILING_DRAW_OFFSET, at[2]],
+                        position: [at[0], over.height, at[2]],
                         yaw: 0,
                     };
                     report.ids[id] = node.id;
                     report.items++;
-                    say(`light at [${at.join(', ')}] has no fixture: a ceiling point in ${room.name}`);
+                    say(unlit
+                        ? `${unlit} had no light: a ceiling light at its centre`
+                        : `light at [${at.join(', ')}] has no fixture: a ceiling point in ${room.name}`);
                 }
                 catch (error) {
                     const e = error;
@@ -1023,6 +1808,9 @@ export function authorScene(scene, input, context) {
                     color: light.color,
                     intensityRange: [0, light.intensity],
                     offset: toLocal(hostFrame, at),
+                    spot: lightSpot(light, at, hostFrame),
+                    shadows: light.shadows,
+                    glow: light.glow,
                 },
             ];
             written[hostNode.id] = {
@@ -1032,14 +1820,129 @@ export function authorScene(scene, input, context) {
             report.lights++;
         }
     });
-    const nodes = Object.fromEntries(Object.entries(written).filter(([id]) => !scaffoldIds.has(id)));
-    const candidate = {
-        version: 1,
-        buildingId: building.id,
-        seed,
-        ids: report.ids,
-        nodes,
-    };
+    // ---------- the roof: on the building's roof level above the top storey, as create_roof puts it ----------
+    const roof = payload.roof;
+    if (roof && (roof.segments.length || roof.items?.length)) {
+        const top = levelNodes.at(-1);
+        const segments = roof.segments.map((spec, i) => {
+            const segment = RoofSegmentNode.parse({
+                roofType: spec.roofType,
+                width: spec.width,
+                depth: spec.depth,
+                wallHeight: 0,
+                rotation: (spec.rotation * Math.PI) / 180,
+                position: [spec.center[0], 0, spec.center[1]],
+                ...(spec.pitch !== undefined && { pitch: spec.pitch }),
+                ...(spec.gableOverhang !== undefined && { gableOverhang: spec.gableOverhang }),
+            });
+            // The overhang is asked in plan; the segment stores it along its slope (a barrel's, at its ends).
+            const overhang = spec.roofType === 'barrel'
+                ? spec.overhang
+                : spec.overhang / getSegmentSlopeFrame(segment).cosTheta;
+            return { ...segment, id: mint('rseg', `roof/segment/${i}`), overhang };
+        });
+        const peak = Math.max(0, ...segments.map((segment) => getActiveRoofHeight(segment)));
+        // Nothing stands above the payload's top level in its candidate: the plan is a roof level.
+        const plan = planRoofLevel(written, top.id, peak);
+        const created = plan.kind === 'roof' ? plan.create : null;
+        const levelId = created ? mint('level', 'level/roof') : plan.levelId;
+        if (created)
+            written = applySceneChanges(written, {
+                create: [{ node: { ...created, id: levelId }, parentId: building.id }],
+            });
+        report.ids['level/roof'] = levelId;
+        // A roof measured from the top storey's floor stands this much lower on the roof level.
+        const offset = plan.storeyOffset;
+        let rises = peak;
+        if (segments.length) {
+            const cx = segments.reduce((sum, s) => sum + s.position[0], 0) / segments.length;
+            const cz = segments.reduce((sum, s) => sum + s.position[2], 0) / segments.length;
+            const node = RoofNode.parse({
+                id: mint('roof', 'roof'),
+                name: roof.name ?? 'Roof',
+                parentId: levelId,
+                position: [cx, 0, cz],
+                rotation: 0,
+                support: { kind: 'walls' },
+                children: segments.map((segment) => segment.id),
+                metadata: { authorScene: { id: 'roof' } },
+            });
+            written = applySceneChanges(written, {
+                create: [
+                    { node, parentId: levelId },
+                    ...segments.map((segment) => ({
+                        node: {
+                            ...segment,
+                            parentId: node.id,
+                            position: [segment.position[0] - cx, 0, segment.position[2] - cz],
+                        },
+                        parentId: node.id,
+                    })),
+                ],
+            });
+            const elevation = resolveRoofElevation(written[node.id], written);
+            written[node.id] = { ...node, position: [cx, elevation, cz] };
+            rises = elevation + peak;
+            report.ids.roof = node.id;
+            report.roofSegments = segments.length;
+            for (const [role, color] of [
+                ['top', roof.color],
+                ['wall', roof.wallColor],
+            ]) {
+                const finish = finishRef(color, 'roof');
+                if (finish)
+                    try {
+                        const { changes } = paint(written, { targets: [node.id], material: finish, role }, paintContext(levelId));
+                        for (const u of changes?.update ?? [])
+                            written[u.id] = { ...written[u.id], ...u.data };
+                    }
+                    catch (error) {
+                        defect('roof', 'paint_refused', error.message);
+                    }
+            }
+        }
+        for (const item of roof.items ?? []) {
+            const compiled = input.compiled[item.id];
+            if (!compiled) {
+                defect(item.id, 'compile_failed', input.compileErrors?.[item.id] ?? 'The module did not compile.');
+                continue;
+            }
+            try {
+                const outcome = addObject(written, {
+                    compiled: { ...compiled, nodeId: mint('item', item.id) },
+                    name: item.name,
+                    category: item.category,
+                    reason: `author_scene: ${item.name}`,
+                    position: [item.position[0], item.position[1] + offset, item.position[2]],
+                    rotation: item.rotation,
+                    parentId: levelId,
+                    role: 'roof',
+                }, { ...context, activeLevelId: levelId });
+                for (const { node } of outcome.changes?.create ?? []) {
+                    written = applySceneChanges(written, {
+                        create: [
+                            {
+                                node: { ...node, slots: exactSlots(compiled, item.id) },
+                                parentId: levelId,
+                            },
+                        ],
+                    });
+                    report.ids[item.id] = node.id;
+                    report.items++;
+                    rises = Math.max(rises, item.position[1] + offset + scriptedSize(compiled.manifest)[1]);
+                }
+            }
+            catch (error) {
+                const e = error;
+                defect(item.id, e.code ?? 'item_refused', e.message ?? String(error));
+            }
+        }
+        // A roof level made for it is as tall as the roof rises over it.
+        if (created)
+            written[levelId] = { ...written[levelId], height: Math.max(rises, 0.2) };
+    }
+    const nodes = plain(Object.fromEntries(Object.entries(written).filter(([id]) => !scaffoldIds.has(id))));
+    const candidate = { buildingId: building.id, seed, ids: report.ids, nodes };
     const outcome = {
         result: report,
         candidate,
@@ -1053,24 +1956,88 @@ export function finalizeAuthorScene(scene, outcome) {
     const building = scene[outcome.buildingId];
     if (building?.type !== 'building')
         refuse('no_building', 'The target building no longer exists.');
-    const previous = building.metadata?.authorSceneState;
-    const base = previous?.nodes ??
-        Object.fromEntries(Object.values(scene)
-            .filter((node) => node.type === 'level' && node.parentId === building.id)
-            .map((node) => [node.id, node]));
-    const changes = authoredSceneChanges(scene, base, outcome.candidate.nodes);
+    const { candidate } = outcome;
+    const current = Object.fromEntries(Object.entries(scene).map(([id, node]) => [id, withoutBookkeeping(node)]));
+    const base = authoredBaseline(scene, building)?.nodes ??
+        Object.fromEntries(queryNodes(current, { type: 'level', parentId: building.id }).map((node) => [node.id, node]));
+    const changes = authoredSceneChanges(current, base, candidate.nodes);
+    // Each written node keeps its own baseline; each written level lists what stands on it and the
+    // building what it holds itself (its units), so a revision finds every node of the last one.
+    const holderOf = (id) => {
+        let node = candidate.nodes[id];
+        while (node && node.type !== 'level') {
+            if (node.parentId === building.id)
+                return building.id;
+            node = node.parentId ? candidate.nodes[node.parentId] : undefined;
+        }
+        return node?.id;
+    };
+    const keyOf = new Map(Object.entries(candidate.ids).map(([key, id]) => [id, key]));
+    const writtenOn = new Map();
+    for (const id of Object.keys(candidate.nodes)) {
+        const holder = holderOf(id);
+        if (!holder)
+            continue;
+        const written = writtenOn.get(holder) ?? { ids: [], keys: {} };
+        written.ids.push(id);
+        const key = keyOf.get(id);
+        if (key)
+            written.keys[key] = id;
+        writtenOn.set(holder, written);
+    }
+    const bookkeeping = (id) => ({
+        authorSceneBase: withoutBookkeeping(candidate.nodes[id]),
+        ...(writtenOn.has(id) ? { authorSceneWritten: writtenOn.get(id) } : {}),
+    });
+    const create = (changes.create ?? []).map((entry) => candidate.nodes[entry.node.id]
+        ? {
+            ...entry,
+            node: {
+                ...entry.node,
+                metadata: { ...entry.node.metadata, ...bookkeeping(entry.node.id) },
+            },
+        }
+        : entry);
+    const created = new Set(create.map((entry) => entry.node.id));
+    const removed = new Set(changes.delete ?? []);
+    const updated = new Map((changes.update ?? []).map((entry) => [entry.id, entry]));
+    for (const id of Object.keys(candidate.nodes)) {
+        const now = scene[id];
+        if (created.has(id) || removed.has(id) || !now)
+            continue;
+        const kept = { ...bookkeeping(id) };
+        const stored = Object.fromEntries(BOOKKEEPING.flatMap((key) => now.metadata && key in now.metadata ? [[key, now.metadata[key]]] : []));
+        const entry = updated.get(id);
+        if (!entry && equalJson(stored, kept))
+            continue;
+        const metadata = (entry?.data.metadata ??
+            current[id]?.metadata ??
+            {});
+        updated.set(id, {
+            id,
+            data: { ...entry?.data, metadata: { ...metadata, ...kept } },
+        });
+    }
+    const state = { version: 2, buildingId: building.id, seed: candidate.seed };
+    updated.set(building.id, {
+        id: building.id,
+        data: {
+            ...updated.get(building.id)?.data,
+            metadata: {
+                ...withoutBookkeeping(building).metadata,
+                authorSceneState: state,
+                ...(writtenOn.has(building.id) ? { authorSceneWritten: writtenOn.get(building.id) } : {}),
+            },
+        },
+    });
     return {
         ...outcome,
         changes: {
             ...changes,
+            create,
             ...(outcome.changes?.materials ? { materials: outcome.changes.materials } : {}),
-            update: [
-                ...(changes.update ?? []),
-                {
-                    id: building.id,
-                    data: { metadata: { ...building.metadata, authorSceneState: outcome.candidate } },
-                },
-            ],
+            update: [...updated.values()],
         },
     };
 }
+const equalJson = (a, b) => JSON.stringify(a) === JSON.stringify(b);