@pascal-app/core 1.0.4 → 1.0.5

package/dist/agent-operations/layout-clearance.js

@@ -7,7 +7,18 @@
  *
  * See packages/mcp/docs/layout-clearance-error-log.md for regression checklist.
  */
+import { floorConstructionLift, liftedManualSlab } from '../lib/floor-construction-lift.js';
+import { selectSlabSupportForItem } from '../lib/item-slab-support.js';
+import { getRenderableSlabPolygon } from '../lib/slab-polygon.js';
+import { levelBaseElevationAt } from '../lib/terrain-support-query.js';
+import { boundsOf, boxCorners, frame, rotateVector, transformPoint, } from '../procedural-items/spatial.js';
+import { getScaledDimensions } from '../schema/index.js';
+import { resolveCeilingHeight } from '../services/level-height.js';
+import { CEILING_DRAW_OFFSET } from '../services/storey.js';
 import { aabbsOverlap, findBlockedDoors, itemNodePlanAabb, itemPlanAabb, resolveNodeLevelId, } from './door-clearance.js';
+import { furnitureKind, isFloorUnderlay } from './furniture-kind.js';
+import { itemHosts, itemLevelHeightRange, itemPlanAabbInLevel } from './item-space.js';
+import { pointInPolygon } from './plan-geometry.js';
 export { aabbsOverlap, collectDoorKeepouts, findBlockedDoors, itemNodePlanAabb, itemPlanAabb, resolveNodeLevelId, } from './door-clearance.js';
 /** Minimum free space (m) required between item footprints. */
 export const DEFAULT_ITEM_GAP = 0.08;
@@ -31,15 +42,17 @@ export function collectOccupiedFootprints(nodes, options) {
         const levelId = resolveNodeLevelId(node.id, byId);
         if (options?.levelId && levelId !== options.levelId)
             continue;
-        // Floor packing: prefer level-parented items (not wall-hosted children).
+        if (levelId && node.parentId === levelId && isFloorUnderlay(node))
+            continue;
+        // A wall's children keep wall-local coordinates and are read by the wall observations.
+        if (node.parentId && byId.get(node.parentId)?.type === 'wall')
+            continue;
+        // Floor packing: prefer level-parented items (not ceiling-hosted children).
         if (options?.floorOnly && node.parentId && levelId && node.parentId !== levelId) {
             if (attach === 'wall' || attach === 'wall-side' || attach === 'ceiling')
                 continue;
-            // Wall-parented items without attachTo still skipped for floor packing.
-            if (byId.get(node.parentId)?.type === 'wall')
-                continue;
         }
-        const aabb = nodeItemAabb(node);
+        const aabb = itemPlanAabbInLevel(node, byId);
         if (!aabb)
             continue;
         const name = node.name ?? node.asset?.name;
@@ -52,9 +65,146 @@ export function collectOccupiedFootprints(nodes, options) {
     }
     return out;
 }
+function finiteVec3(value) {
+    return (Array.isArray(value) &&
+        value.length === 3 &&
+        [value[0], value[1], value[2]].every(Number.isFinite));
+}
+function planarRotation(value) {
+    return finiteVec3(value) && value[0] === 0 && value[2] === 0;
+}
+function finiteNumbers(value) {
+    if (typeof value === 'number')
+        return Number.isFinite(value);
+    if (Array.isArray(value))
+        return value.every(finiteNumbers);
+    if (value && typeof value === 'object')
+        return Object.values(value).every(finiteNumbers);
+    return true;
+}
+/** Snapshot counterpart of the item floorPlaced support election; never reads the live grid. */
+function itemFloorLift(node, nodes) {
+    // The renderer's item floorPlaced.applies skips corrective surface attachments.
+    if (node.asset.attachTo)
+        return 0;
+    const levelId = node.parentId;
+    const ground = () => levelBaseElevationAt(nodes, levelId, node.position[0], node.position[2]) +
+        floorConstructionLift(nodes, node);
+    if (node.supportSlabId === 'ground')
+        return ground();
+    const list = Object.values(nodes);
+    const slabs = list
+        .filter((other) => other.type === 'slab' && other.parentId === levelId)
+        .map((slab) => liftedManualSlab(nodes, slab));
+    const walls = list.filter((other) => {
+        if (other.type !== 'wall')
+            return false;
+        let parent = other.parentId ? nodes[other.parentId] : undefined;
+        for (let depth = 0; parent && parent.type !== 'level' && depth < 16; depth++) {
+            parent = parent.parentId ? nodes[parent.parentId] : undefined;
+        }
+        return parent?.type === 'level' && parent.id === levelId;
+    });
+    const support = selectSlabSupportForItem(slabs, { position: node.position, dimensions: getScaledDimensions(node), rotation: node.rotation }, (slab) => getRenderableSlabPolygon(slab, {
+        walls,
+        siblingSlabs: slabs.filter((other) => other.id !== slab.id),
+    }), { preferredSlabId: node.supportSlabId });
+    return support ? support.elevation : ground();
+}
+/**
+ * Only script manifests supply raw bounds for the renderer's corrective asset pose.
+ * Catalog dimensions describe a plan box, not proof of the raw model's Y origin.
+ */
+export function scriptItemBoundsInLevel(node, nodes) {
+    if (node?.type !== 'item' || node.roofSegmentId || node.blockFaceId)
+        return;
+    const bounds = node.source?.manifest?.bounds;
+    const assetScale = node.asset.scale ?? [1, 1, 1];
+    if (!bounds ||
+        node.source?.manifest?.animations?.length ||
+        !finiteVec3(bounds.min) ||
+        !finiteVec3(bounds.max) ||
+        bounds.min.some((min, axis) => min > bounds.max[axis]) ||
+        !finiteVec3(node.position) ||
+        !finiteVec3(node.rotation) ||
+        !finiteVec3(node.scale) ||
+        node.scale.some((scale) => scale <= 0) ||
+        !finiteVec3(node.asset.offset) ||
+        !finiteVec3(node.asset.rotation) ||
+        !finiteVec3(assetScale) ||
+        assetScale.some((scale) => scale <= 0) ||
+        !finiteVec3(node.asset.dimensions) ||
+        node.asset.dimensions.some((size) => size <= 0))
+        return;
+    const parent = node.parentId ? nodes[node.parentId] : undefined;
+    const level = parent?.type === 'level'
+        ? parent
+        : parent?.type === 'ceiling' && parent.parentId
+            ? nodes[parent.parentId]
+            : undefined;
+    if (level?.type !== 'level' || !finiteNumbers(level) || !finiteNumbers(parent))
+        return;
+    try {
+        const hostY = parent?.type === 'ceiling'
+            ? resolveCeilingHeight(parent, nodes) - CEILING_DRAW_OFFSET
+            : itemFloorLift(node, nodes);
+        const pose = frame([node.position[0], hostY + node.position[1], node.position[2]], node.rotation);
+        // Match the model groups: corrective asset pose is inside the node-scale group.
+        const corners = boxCorners(bounds.min, bounds.max).map((point) => {
+            const rotated = rotateVector(point.map((value, axis) => value * assetScale[axis]), node.asset.rotation);
+            return transformPoint(pose, rotated.map((value, axis) => (value + node.asset.offset[axis]) * node.scale[axis]));
+        });
+        if (corners.every(finiteVec3))
+            return { levelId: level.id, bounds: boundsOf(corners), corners };
+    }
+    catch {
+        // Malformed or unsupported support geometry is not evidence of separation.
+    }
+}
+function itemVerticalInterval(node, nodes) {
+    // Keep the existing plan-layout evidence limited to yaw-only model poses.
+    if (node?.type !== 'item' ||
+        !planarRotation(node.rotation) ||
+        !planarRotation(node.asset.rotation))
+        return;
+    const resolved = scriptItemBoundsInLevel(node, nodes);
+    if (resolved)
+        return {
+            levelId: resolved.levelId,
+            min: resolved.bounds.min[1],
+            max: resolved.bounds.max[1],
+        };
+}
 export function findItemItemCollisions(args) {
     const gap = args.gap ?? DEFAULT_ITEM_GAP;
-    const footprints = collectOccupiedFootprints(args.nodes, { levelId: args.levelId });
+    const list = [...args.nodes];
+    const nodes = Object.fromEntries(list.map((node) => [node.id, node]));
+    const footprints = collectOccupiedFootprints(list, { levelId: args.levelId });
+    // Drawing fallbacks on invalid support heights cannot prove collision separation.
+    const finiteContext = list.every((node) => node.type === 'item' || finiteNumbers(node));
+    const byId = new Map(list.map((node) => [node.id, node]));
+    // The measured interval when the model's bounds allow it, else the node's own height above its
+    // floor. A measured contact stays a collision (roundoff); a lamp standing on a table top by its
+    // own height is stacked.
+    const intervals = new Map(footprints.map(({ id }) => {
+        const node = nodes[id];
+        const measured = finiteContext ? itemVerticalInterval(node, nodes) : undefined;
+        if (measured)
+            return [id, { ...measured, measured: true }];
+        const range = itemLevelHeightRange(node, byId);
+        return [
+            id,
+            range
+                ? {
+                    levelId: resolveNodeLevelId(id, byId) ?? '',
+                    min: range.min,
+                    max: range.max,
+                    measured: false,
+                }
+                : undefined,
+        ];
+    }));
+    const hosts = new Map(footprints.map(({ id }) => [id, itemHosts(nodes[id], byId)]));
     const collisions = [];
     for (let i = 0; i < footprints.length; i++) {
         for (let j = i + 1; j < footprints.length; j++) {
@@ -62,8 +212,29 @@ export function findItemItemCollisions(args) {
             const b = footprints[j];
             if (a.levelId && b.levelId && a.levelId !== b.levelId)
                 continue;
+            // A thing resting on top of its host is stacked by design: its bottom at the host's top. A
+            // child sunk into its host, or one whose height is unknown, is still a collision.
+            const [child, host] = hosts.get(a.id)?.has(b.id)
+                ? [a, b]
+                : hosts.get(b.id)?.has(a.id)
+                    ? [b, a]
+                    : [];
+            if (child && host) {
+                const cY = intervals.get(child.id);
+                const hY = intervals.get(host.id);
+                if (cY && hY && cY.min >= hY.max - 0.02)
+                    continue;
+            }
             if (!aabbsOverlap(a.aabb, b.aabb, gap))
                 continue;
+            const aY = intervals.get(a.id);
+            const bY = intervals.get(b.id);
+            // Contact and sub-micrometre separation remain conservative against roundoff.
+            if (aY && bY && aY.levelId === bY.levelId) {
+                const touch = aY.measured && bY.measured ? 1e-6 : -1e-6;
+                if (bY.min - aY.max > touch || aY.min - bY.max > touch)
+                    continue;
+            }
             collisions.push({
                 aId: a.id,
                 bId: b.id,
@@ -102,9 +273,69 @@ export function classifyPlacement(args) {
     }
     return 'ok';
 }
+/** How far a placement may step a piece off its spot, into the room, to clear doors and other pieces. */
+export const PLACEMENT_INSETS_M = [0, 0.25, 0.5, 0.75];
+/**
+ * Slides along a wall between `min` and `max`, nearest first: the nearest to none at all, then
+ * every 0.4 m (0, -0.4, 0.4, … when the range holds 0).
+ */
+export function lateralSteps(min, max) {
+    const nearest = Math.min(Math.max(0, min), max);
+    const steps = [nearest];
+    for (let k = Math.ceil(min / 0.4 - 1e-9); k * 0.4 <= max + 1e-9; k++)
+        if (Math.abs(k * 0.4 - nearest) > 1e-9)
+            steps.push(k * 0.4);
+    return steps.sort((a, b) => Math.abs(a) - Math.abs(b) || a - b);
+}
+/** Whether segment a–b passes through the open box |u| < halfU, |v| < halfV (Liang–Barsky). */
+function segmentEntersBox(a, b, halfU, halfV) {
+    const [du, dv] = [b[0] - a[0], b[1] - a[1]];
+    let [enter, exit] = [0, 1];
+    for (const [p, q] of [
+        [-du, a[0] + halfU],
+        [du, halfU - a[0]],
+        [-dv, a[1] + halfV],
+        [dv, halfV - a[1]],
+    ]) {
+        if (p === 0) {
+            if (q <= 0)
+                return false;
+            continue;
+        }
+        const t = q / p;
+        if (p < 0)
+            enter = Math.max(enter, t);
+        else
+            exit = Math.min(exit, t);
+        if (enter >= exit)
+            return false;
+    }
+    return true;
+}
+/**
+ * Whether a piece's turned footprint stands inside a room's outline, a notch or an L's missing
+ * corner included: its middle is inside and no edge of the outline passes through it. A piece may
+ * touch the outline, and overlap it by up to {@link OUTLINE_CONTACT_M}.
+ */
+function insideOutline({ x, z, rotationDeg }, dimensions, outline) {
+    if (!pointInPolygon([x, z], outline, false))
+        return false;
+    const [width = 1, , depth = 1] = dimensions ?? [1, 1, 1];
+    const yaw = (rotationDeg * Math.PI) / 180;
+    const [cos, sin] = [Math.cos(yaw), Math.sin(yaw)];
+    // In the piece's own frame (the inverse of itemNodePlanCorners' turn): u across, v deep.
+    const local = ([px, pz]) => [
+        (px - x) * cos - (pz - z) * sin,
+        (px - x) * sin + (pz - z) * cos,
+    ];
+    // A piece a few millimetres thin keeps half its own thickness, so its box is never empty.
+    const inset = (half) => Math.max(half - OUTLINE_CONTACT_M, half / 2);
+    const [halfU, halfV] = [inset(width / 2), inset(depth / 2)];
+    return !outline.some((point, i) => segmentEntersBox(local(point), local(outline[(i + 1) % outline.length]), halfU, halfV));
+}
 export function generatePlacementCandidates(primary, options) {
-    const laterals = options?.lateralsM ?? [0, -0.4, 0.4, -0.8, 0.8, -1.2, 1.2];
-    const insets = options?.insetsM ?? [0, 0.25, 0.5, 0.75];
+    const laterals = options?.lateralsM ?? lateralSteps(-1.2, 1.2);
+    const insets = options?.insetsM ?? PLACEMENT_INSETS_M;
     const along = options?.along ?? { x: 1, z: 0 };
     const inward = options?.inward ?? { x: 0, z: 1 };
     const out = [];
@@ -126,37 +357,113 @@ export function findValidPlacement(args) {
     const candidates = generatePlacementCandidates(args.primary, {
         along: args.along,
         inward: args.inward,
+        lateralsM: args.lateralsM,
+        insetsM: args.insetsM,
     });
-    // Prefer reporting why the **primary** pose failed (door/overlap), not the
-    // last lateral/inset candidate (often outside_bounds after large nudges).
-    let primaryReason = null;
-    const reasonPriority = [
-        'blocks_door_clearance',
-        'overlaps_item',
-        'outside_bounds',
-    ];
-    let bestFailReason = 'overlaps_item';
-    for (let i = 0; i < candidates.length; i++) {
-        const c = candidates[i];
-        const rot = (c.rotationDeg * Math.PI) / 180;
-        const aabb = itemPlanAabb([c.x, 0, c.z], args.dimensions, rot);
-        const reason = classifyPlacement({
+    // Why the first spot that stands against a wall failed (a door, a piece), not the last nudge
+    // tried (often outside the room after large ones); off_wall when no spot had a wall.
+    let refused = null;
+    for (const c of candidates) {
+        const aabb = itemPlanAabb([c.x, 0, c.z], args.dimensions, (c.rotationDeg * Math.PI) / 180);
+        if (args.againstWalls && gapToWalls(aabb, args.againstWalls) > MID_ROOM_DISTANCE_M)
+            continue;
+        let reason = classifyPlacement({
             aabb,
             doorKeepouts: args.doorKeepouts,
             occupied: args.occupied,
             roomBounds: args.roomBounds,
         });
+        if (reason === 'ok' && args.roomOutline && !insideOutline(c, args.dimensions, args.roomOutline))
+            reason = 'outside_bounds';
         if (reason === 'ok')
             return { candidate: c, reason };
-        if (i === 0)
-            primaryReason = reason;
-        const prevRank = reasonPriority.indexOf(bestFailReason);
-        const nextRank = reasonPriority.indexOf(reason);
-        if (nextRank >= 0 && (prevRank < 0 || nextRank < prevRank)) {
-            bestFailReason = reason;
-        }
+        refused ??= { at: c, reason };
+    }
+    return { candidate: null, reason: refused?.reason ?? 'off_wall', refused: refused?.at ?? null };
+}
+/** A wall-bound piece whose nearest edge is further than this from every wall face is not against a wall. */
+export const MID_ROOM_DISTANCE_M = 0.4;
+/** How far a piece may overlap a room's outline (m): touching it, give or take a millimetre. */
+const OUTLINE_CONTACT_M = 1e-3;
+const DEFAULT_WALL_THICKNESS_M = 0.1;
+const cross = (o, p, q) => (p[0] - o[0]) * (q[1] - o[1]) - (p[1] - o[1]) * (q[0] - o[0]);
+function distanceToSegment(point, a, b) {
+    const dx = b[0] - a[0];
+    const dz = b[1] - a[1];
+    const length2 = dx * dx + dz * dz;
+    const t = length2 === 0
+        ? 0
+        : Math.max(0, Math.min(1, ((point[0] - a[0]) * dx + (point[1] - a[1]) * dz) / length2));
+    return Math.hypot(point[0] - (a[0] + t * dx), point[1] - (a[1] + t * dz));
+}
+/** The shortest distance from a footprint box to a wall's centre line (0 when the line passes through it). */
+function boxToSegment(box, a, b) {
+    const corners = [
+        [box.minX, box.minZ],
+        [box.maxX, box.minZ],
+        [box.maxX, box.maxZ],
+        [box.minX, box.maxZ],
+    ];
+    let nearest = Number.POSITIVE_INFINITY;
+    for (let i = 0; i < 4; i++) {
+        const c = corners[i];
+        const d = corners[(i + 1) % 4];
+        if (cross(a, b, c) * cross(a, b, d) < 0 && cross(c, d, a) * cross(c, d, b) < 0)
+            return 0;
+        nearest = Math.min(nearest, distanceToSegment(a, c, d), distanceToSegment(b, c, d), distanceToSegment(c, a, b), distanceToSegment(d, a, b));
+    }
+    return nearest;
+}
+/** The walls of a level (resolved through `byId`), as the mid-room check reads them. */
+export function wallFacesOn(nodes, levelId, byId = new Map([...nodes].map((node) => [node.id, node]))) {
+    const walls = [];
+    for (const node of nodes) {
+        if (node.type !== 'wall' || resolveNodeLevelId(node.id, byId) !== levelId)
+            continue;
+        walls.push({
+            a: [node.start[0], node.start[1]],
+            b: [node.end[0], node.end[1]],
+            halfThickness: (node.thickness ?? DEFAULT_WALL_THICKNESS_M) / 2,
+        });
+    }
+    return walls;
+}
+/** How far a footprint stands from the nearest wall's face (m); Infinity with no wall. */
+export function gapToWalls(box, walls) {
+    return Math.min(Number.POSITIVE_INFINITY, ...walls.map((wall) => Math.max(0, boxToSegment(box, wall.a, wall.b) - wall.halfThickness)));
+}
+/**
+ * Wall-bound pieces (a fridge, a counter, a bed, a sofa) that stand in a room but away from every
+ * wall: further than {@link MID_ROOM_DISTANCE_M} from the face of each wall of their level. Pieces
+ * outside every room, free-standing kinds, and levels with no walls are not judged.
+ */
+export function findItemsMidRoom(args) {
+    const list = [...args.nodes];
+    const byId = new Map(list.map((node) => [node.id, node]));
+    const walls = wallFacesOn(list, args.levelId, byId);
+    const zones = list.filter((node) => node.type === 'zone' && resolveNodeLevelId(node.id, byId) === args.levelId);
+    if (walls.length === 0 || zones.length === 0)
+        return [];
+    const found = [];
+    for (const footprint of collectOccupiedFootprints(list, {
+        floorOnly: true,
+        ...(args.levelId === undefined ? {} : { levelId: args.levelId }),
+    })) {
+        const node = byId.get(footprint.id);
+        if (node?.type !== 'item' || furnitureKind(node.asset) !== 'wall')
+            continue;
+        const room = zones.find((zone) => pointInPolygon([node.position[0], node.position[2]], zone.polygon, true));
+        if (!room)
+            continue;
+        const gap = gapToWalls(footprint.aabb, walls);
+        if (gap <= MID_ROOM_DISTANCE_M)
+            continue;
+        found.push({
+            id: node.id,
+            message: `${footprint.name ?? node.asset.id} (${node.id}) stands in the middle of ${room.name || room.id}, ${gap.toFixed(1)} m from the nearest wall: a ${node.asset.id} belongs against a wall (place_in_room puts it there).`,
+        });
     }
-    return { candidate: null, reason: primaryReason ?? bestFailReason };
+    return found;
 }
 /**
  * Collect layout issues, scoped per level so stacked floors do not false-positive.
@@ -184,6 +491,9 @@ export function layoutIssuesFromScene(nodes) {
         for (const c of findItemItemCollisions({ nodes: list, levelId })) {
             issues.set(c.message, c.violation === 'overlap' ? 'item_overlap' : 'item_too_close');
         }
+        for (const m of findItemsMidRoom({ nodes: list, levelId })) {
+            issues.set(m.message, 'item_mid_room');
+        }
     }
     // Deduplicate (node may appear under multiple walks)
     return [...issues].map(([message, type]) => ({ type, message }));

package/dist/agent-operations/level-height-fill.d.ts

@@ -0,0 +1,12 @@
+import type { AnyNode } from '../schema/index.js';
+import type { NodeWrite } from './types.js';
+/**
+ * A level written without a height reads as legacy data: the editor's load derives its storey plane
+ * from what it holds and rewrites its walls, stairs and ceilings to match, while a session that
+ * wrote it reads 2.5 m. A write that creates a level without one, or clears it, gets the height the
+ * editor would derive, from what the level holds once the whole write lands (an empty level: the
+ * default storey height), so every reader agrees. Fills the operations in place and returns a note
+ * per level filled, for the write's answer.
+ */
+export declare function fillLevelHeights(ops: NodeWrite[], scene: Readonly<Record<string, AnyNode>>): string[];
+//# sourceMappingURL=level-height-fill.d.ts.map

package/dist/agent-operations/level-height-fill.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"level-height-fill.d.ts","sourceRoot":"","sources":["../../src/agent-operations/level-height-fill.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAa,MAAM,WAAW,CAAA;AAEnD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAA;AAIxC;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAC9B,GAAG,EAAE,SAAS,EAAE,EAChB,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GACvC,MAAM,EAAE,CA4CV"}

package/dist/agent-operations/level-height-fill.js

@@ -0,0 +1,59 @@
+import { deriveLegacyLevelHeight } from '../services/level-height.js';
+const round = (value) => Math.round(value * 100) / 100;
+/**
+ * A level written without a height reads as legacy data: the editor's load derives its storey plane
+ * from what it holds and rewrites its walls, stairs and ceilings to match, while a session that
+ * wrote it reads 2.5 m. A write that creates a level without one, or clears it, gets the height the
+ * editor would derive, from what the level holds once the whole write lands (an empty level: the
+ * default storey height), so every reader agrees. Fills the operations in place and returns a note
+ * per level filled, for the write's answer.
+ */
+export function fillLevelHeights(ops, scene) {
+    const after = { ...scene };
+    for (const op of ops) {
+        // A create's own parentId wins over its node's, as the write applies it.
+        if (op.op === 'create')
+            after[op.node.id] = op.parentId ? { ...op.node, parentId: op.parentId } : op.node;
+        else if (op.op === 'delete')
+            delete after[op.id];
+        else if (after[op.id])
+            after[op.id] = { ...after[op.id], ...op.data };
+    }
+    const notes = [];
+    const derive = (levelId) => {
+        const level = after[levelId];
+        if (level?.type !== 'level')
+            return null;
+        // The level's own list, and what names it as parent: a create lists no children yet.
+        const held = Object.values(after)
+            .filter((node) => node.parentId === levelId)
+            .map((node) => node.id);
+        const children = [...new Set([...(level.children ?? []), ...held])].filter((id) => after[id]);
+        const height = deriveLegacyLevelHeight(levelId, {
+            ...after,
+            [levelId]: { ...level, children },
+        });
+        const holds = children.some((id) => after[id]?.type === 'wall' || after[id]?.type === 'ceiling');
+        notes.push(holds
+            ? `level ${levelId}: height ${round(height)} m derived from its walls and ceilings, as the editor reads a level written without one`
+            : `level ${levelId}: height ${round(height)} m, the default storey height, as nothing on it gives one`);
+        return height;
+    };
+    for (const op of ops) {
+        if (op.op === 'create') {
+            if (op.node.type !== 'level' || op.node.height != null)
+                continue;
+            const height = derive(op.node.id);
+            if (height !== null)
+                op.node.height = height;
+        }
+        else if (op.op === 'update' && 'height' in op.data && op.data.height == null) {
+            if (after[op.id]?.type !== 'level')
+                continue;
+            const height = derive(op.id);
+            if (height !== null)
+                op.data.height = height;
+        }
+    }
+    return notes;
+}

package/dist/agent-operations/level-reads.d.ts

@@ -16,8 +16,12 @@ export declare function wallSummary(nodes: SceneNodes, wall: WallNode): {
     resolvedHeight: number;
     heightIsExplicit: boolean;
     thickness: number | undefined;
+    wallFaceChains: {
+        a: import("../index.js").WallFaceChainFinish;
+        b: import("../index.js").WallFaceChainFinish;
+    };
     openings: {
-        id: `item_${string}` | `procedural-item_${string}` | `door_${string}` | `window_${string}` | `leanto_${string}`;
+        id: `door_${string}` | `item_${string}` | `leanto_${string}` | `procedural-item_${string}` | `window_${string}`;
         type: "door" | "window";
         position: [number, number, number];
         width: number;

package/dist/agent-operations/level-reads.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"level-reads.d.ts","sourceRoot":"","sources":["../../src/agent-operations/level-reads.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAA2C,QAAQ,EAAY,MAAM,WAAW,CAAA;AAK5F,OAAO,EAAE,KAAK,gBAAgB,EAAe,MAAM,gBAAgB,CAAA;AAEnE,OAAO,KAAK,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAQzD;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,QAAQ,GAAG,MAAM,CAe5E;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,QAAQ;;;;;;;;;;;;;;;;;EAkB5D;AA2GD,2BAA2B;AAC3B,eAAO,MAAM,eAAe,EAAE,cAAc,CAAC,gBAAgB,CAE3D,CAAA;AAEF,mBAAmB;AACnB,eAAO,MAAM,QAAQ,EAAE,cAAc,CAAC,gBAAgB,CAIrD,CAAA;AAED,mBAAmB;AACnB,eAAO,MAAM,QAAQ,EAAE,cAAc,CAAC,gBAAgB,CAIrD,CAAA"}
+{"version":3,"file":"level-reads.d.ts","sourceRoot":"","sources":["../../src/agent-operations/level-reads.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAA2C,QAAQ,EAAY,MAAM,WAAW,CAAA;AAM5F,OAAO,EAAE,KAAK,gBAAgB,EAAe,MAAM,gBAAgB,CAAA;AAEnE,OAAO,KAAK,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAQzD;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,QAAQ,GAAG,MAAM,CAiB5E;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,QAAQ;IAEzD,EAAE;IACF,IAAI;IACJ,KAAK;IACL,GAAG;IACH,MAAM;IACN,MAAM;IACN,cAAc;IACd,gBAAgB;IAChB,SAAS;IACT,cAAc;QACZ,CAAC;QACD,CAAC;;IAEH,QAAQ;;;;;;;EAOX;AA6GD,2BAA2B;AAC3B,eAAO,MAAM,eAAe,EAAE,cAAc,CAAC,gBAAgB,CAE3D,CAAA;AAEF,mBAAmB;AACnB,eAAO,MAAM,QAAQ,EAAE,cAAc,CAAC,gBAAgB,CAIrD,CAAA;AAED,mBAAmB;AACnB,eAAO,MAAM,QAAQ,EAAE,cAAc,CAAC,gBAAgB,CAIrD,CAAA"}

package/dist/agent-operations/level-reads.js

@@ -1,8 +1,9 @@
 import { area } from '../lib/polygon-boolean.js';
 import { roomFloorChoices } from '../lib/room-floor-choices.js';
 import { DEFAULT_LEVEL_HEIGHT } from '../services/level-height.js';
-import { getWallPlaneTop } from '../services/storey.js';
+import { getWallTop } from '../services/storey.js';
 import { computeWallSlabSupport } from '../systems/slab/slab-support.js';
+import { resolveWallFaceChain } from '../systems/wall/wall-finish.js';
 import { resolveWallEffectiveHeight } from '../systems/wall/wall-top.js';
 import { targetLevel } from './level-target.js';
 import { contentCounts, levelIdOf, levelRole, nodesOnLevel } from './scene-queries.js';
@@ -20,8 +21,8 @@ export function wallResolvedHeight(nodes, wall) {
         return resolveWallEffectiveHeight(wall, DEFAULT_LEVEL_HEIGHT, 0);
     const onLevel = nodesOnLevel(nodes, levelId);
     const support = computeWallSlabSupport(wall, ofType(onLevel, 'slab'), ofType(onLevel, 'wall'), wall.supportSlabId, undefined, 0, nodes);
-    const planeTop = getWallPlaneTop(wall, levelId, nodes);
-    return resolveWallEffectiveHeight(wall, planeTop, support.elevation);
+    return (getWallTop(wall, levelId, nodes, support.elevation) -
+        support.elevation);
 }
 export function wallSummary(nodes, wall) {
     return {
@@ -34,6 +35,10 @@ export function wallSummary(nodes, wall) {
         resolvedHeight: wallResolvedHeight(nodes, wall),
         heightIsExplicit: wall.height !== undefined,
         thickness: wall.thickness,
+        wallFaceChains: {
+            a: resolveWallFaceChain(wall, 'a'),
+            b: resolveWallFaceChain(wall, 'b'),
+        },
         openings: wall.children.flatMap((id) => {
             const child = nodes[id];
             if (child?.type !== 'door' && child?.type !== 'window')
@@ -60,6 +65,8 @@ const zoneSummary = (nodes, zone) => ({
     color: zone.color,
     polygon: zone.polygon,
     holes: zone.holes ?? [],
+    wallMaterial: zone.wallMaterial ?? null,
+    wallOverrides: zone.wallOverrides ?? [],
     ...zoneSize(zone),
     floor_choices: roomFloorChoices(nodes, zone.id),
 });

package/dist/agent-operations/list-levels.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"list-levels.d.ts","sourceRoot":"","sources":["../../src/agent-operations/list-levels.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAE7C,mFAAmF;AACnF,eAAO,MAAM,UAAU,EAAE,cA4BxB,CAAA"}
+{"version":3,"file":"list-levels.d.ts","sourceRoot":"","sources":["../../src/agent-operations/list-levels.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAE7C,mFAAmF;AACnF,eAAO,MAAM,UAAU,EAAE,cAiDxB,CAAA"}

package/dist/agent-operations/list-levels.js

@@ -1,6 +1,26 @@
+import { levelGradeStanding } from '../lib/grade-standing.js';
+import { groundSeat } from '../lib/ground-seat.js';
 import { levelRole, levelsOf } from './scene-queries.js';
 /** `list_levels`: every level of every building, in floor order, with its role. */
 export const listLevels = (nodes, _input, context) => {
+    const groundLevels = Object.values(nodes)
+        .filter((node) => node.type === 'building')
+        .flatMap((building) => {
+        const seat = groundSeat(nodes, building.id);
+        return seat
+            ? [
+                {
+                    buildingId: building.id,
+                    levelId: seat.levelId,
+                    named: seat.explicit,
+                    floorElevation: seat.floorElevation,
+                    gradeElevation: seat.gradeElevation,
+                    floorOverGrade: Math.round(seat.offset * 1000) / 1000,
+                    seated: seat.seated,
+                },
+            ]
+            : [];
+    });
     const levels = levelsOf(nodes).map((level) => {
         const { role, metadataRole, referenceLevelId } = levelRole(nodes, level);
         return {
@@ -14,6 +34,8 @@ export const listLevels = (nodes, _input, context) => {
             isSupportLevel: role !== 'occupied',
             referenceLevelId,
             childCount: Array.isArray(level.children) ? level.children.length : 0,
+            gradeStanding: levelGradeStanding(nodes, level.id),
+            isGroundLevel: groundLevels.some((ground) => ground.levelId === level.id),
             isActive: level.id === context.activeLevelId,
         };
     });
@@ -21,6 +43,7 @@ export const listLevels = (nodes, _input, context) => {
     return {
         result: {
             activeLevelId: context.activeLevelId,
+            groundLevels,
             levelCount: levels.length,
             occupiedStoryCount,
             supportLevelCount: levels.length - occupiedStoryCount,

package/dist/agent-operations/material-preset.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"material-preset.d.ts","sourceRoot":"","sources":["../../src/agent-operations/material-preset.ts"],"names":[],"mappings":"AA6CA;;;;;;;;GAQG;AACH,wBAAgB,4BAA4B,CAC1C,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAChC,MAAM,GAAG,IAAI,CAkCf"}
+{"version":3,"file":"material-preset.d.ts","sourceRoot":"","sources":["../../src/agent-operations/material-preset.ts"],"names":[],"mappings":"AAuCA;;;;;;;;GAQG;AACH,wBAAgB,4BAA4B,CAC1C,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAChC,MAAM,GAAG,IAAI,CAkCf"}

package/dist/agent-operations/material-preset.js

@@ -1,17 +1,11 @@
-import { getCatalogMaterialById, LIBRARY_MATERIAL_REF_PREFIX, MATERIAL_CATALOG, parseMaterialColor, parseMaterialRef, } from '../material-library.js';
+import { LIBRARY_MATERIAL_REF_PREFIX, MATERIAL_CATALOG, parseMaterialColor, parseMaterialRef, } from '../material-library.js';
 import { nodeSlotDeclarations } from '../node-slots/index.js';
 import { AnyNode } from '../schema/index.js';
+import { isLibraryMaterialId } from './material-refs.js';
 const isPresetField = (key) => key === 'materialPreset' || key.endsWith('MaterialPreset');
-// Community-library ids (`library:mtl_…`): the host checks them against its
-// material catalog; without one they pass.
-const COMMUNITY_MATERIAL_ID_PREFIX = 'mtl_';
 function isKnownMaterialRef(value) {
     const ref = parseMaterialRef(value);
-    if (!ref)
-        return false;
-    if (ref.kind === 'scene' || ref.id.startsWith(COMMUNITY_MATERIAL_ID_PREFIX))
-        return true;
-    return !!getCatalogMaterialById(ref.id);
+    return !!ref && (ref.kind === 'scene' || isLibraryMaterialId(ref.id));
 }
 function presetCatalogLine() {
     const byCategory = new Map();