@pascal-app/core 1.0.5 → 1.0.7

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

@@ -15,13 +15,45 @@ import { boundsOf, boxCorners, frame, rotateVector, transformPoint, } from '../p
 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';
+import { aabbsOverlap, findBlockedDoors as findBlockedDoorsByBox, itemNodePlanAabb, itemNodePlanCorners, itemPlanAabb, resolveNodeLevelId, } from './door-clearance.js';
+import { designedTogether, isFloorUnderlay, isWallDressing, wallBoundWord } from './furniture-kind.js';
+import { manifestSolids, relateSolids } from './item-solids.js';
+import { itemLevelHeightRange, itemLevelPose, itemPlanAabbInLevel } from './item-space.js';
+import { axisOverlap, clearingMoves, describeMoves, metres, roundBox, roundMm, } from './plan-clearance.js';
+import { distanceToSegment, pointInPolygon } from './plan-geometry.js';
+export { aabbsOverlap, collectDoorKeepouts, itemNodePlanAabb, itemPlanAabb, resolveNodeLevelId, } from './door-clearance.js';
+import { queryNodes } from './scene-queries.js';
 /** Minimum free space (m) required between item footprints. */
 export const DEFAULT_ITEM_GAP = 0.08;
+function boxReading(a, b, gap) {
+    const shared = axisOverlap(a, b);
+    const depth = Math.min(shared.x, shared.z);
+    const clearBy = clearingMoves(a, b, gap);
+    return depth > 0
+        ? {
+            overlapM: roundMm(depth),
+            overlapAlongM: { x: roundMm(shared.x), z: roundMm(shared.z) },
+            clearBy,
+        }
+        : { gapM: roundMm(-depth), clearBy };
+}
+function collisionMessage(violation, gap, [a, b], reading) {
+    const [first, second] = [a.name ?? a.id, b.name ?? b.id];
+    const pair = `${first} (${a.id}) and ${second} (${b.id})`;
+    const how = 'overlapAreaM2' in reading
+        ? `share ${metres(reading.overlapAreaM2)} m²`
+        : 'overlapAlongM' in reading
+            ? `by ${metres(reading.overlapAlongM.x)} m along x and ${metres(reading.overlapAlongM.z)} m along z`
+            : `are ${metres(reading.gapM)} m apart`;
+    const lead = violation === 'overlap'
+        ? `Items overlap: ${pair} ${how}`
+        : `Items are closer than ${gap} m: ${pair} ${how}`;
+    const shapes = 'clearBy' in reading ? 'footprint boxes' : 'real shapes';
+    const moves = 'clearBy' in reading
+        ? ` ${first} is ${gap} m clear of ${second}, the gap the check keeps, after ${describeMoves(reading.clearBy)}.`
+        : '';
+    return `${lead} (${shapes}).${moves}`;
+}
 export function nodeItemAabb(node) {
     return itemNodePlanAabb(node);
 }
@@ -92,7 +124,7 @@ function itemFloorLift(node, nodes) {
         floorConstructionLift(nodes, node);
     if (node.supportSlabId === 'ground')
         return ground();
-    const list = Object.values(nodes);
+    const list = queryNodes(nodes, { type: ['slab', 'wall'] });
     const slabs = list
         .filter((other) => other.type === 'slab' && other.parentId === levelId)
         .map((slab) => liftedManualSlab(nodes, slab));
@@ -161,6 +193,26 @@ export function scriptItemBoundsInLevel(node, nodes) {
         // Malformed or unsupported support geometry is not evidence of separation.
     }
 }
+/**
+ * Where a script item's own model space stands in its level: maps a point of its manifest (its
+ * bounds, parts, surfaces) to the level's frame, through the corrective asset pose and the item's
+ * node pose the renderer applies. Undefined where the bounds cannot be resolved.
+ */
+export function scriptItemToLevel(node, nodes) {
+    const resolved = scriptItemBoundsInLevel(node, nodes);
+    const origin = node.source?.manifest.bounds.min;
+    const corner = resolved?.corners[0];
+    if (!(origin && corner))
+        return;
+    const corrected = (point) => {
+        const asset = rotateVector(point.map((value, axis) => value * (node.asset.scale?.[axis] ?? 1)), node.asset.rotation);
+        return rotateVector(asset.map((value, axis) => (value + (node.asset.offset[axis] ?? 0)) * (node.scale[axis] ?? 1)), node.rotation);
+    };
+    // The elected attachment translation comes from the shared bounds resolver, not a guessed floor Y.
+    const first = corrected(origin);
+    const shift = corner.map((value, axis) => value - (first[axis] ?? 0));
+    return (point) => corrected(point).map((value, axis) => value + shift[axis]);
+}
 function itemVerticalInterval(node, nodes) {
     // Keep the existing plan-layout evidence limited to yaw-only model poses.
     if (node?.type !== 'item' ||
@@ -175,6 +227,114 @@ function itemVerticalInterval(node, nodes) {
             max: resolved.bounds.max[1],
         };
 }
+/**
+ * An item's real shape in its level's frame (see `item-solids`), or null where there is none to read:
+ * a script with no faces, a catalogue model, a tilted or animated one. A thing hosted by another item
+ * stands at its host chain's pose, on the floor construction under the item at the chain's root.
+ */
+export function itemSolidsInLevel(node, nodes) {
+    const manifest = node.source?.manifest;
+    if (!manifest ||
+        manifest.animations?.length ||
+        !planarRotation(node.rotation) ||
+        !planarRotation(node.asset.rotation))
+        return null;
+    const direct = scriptItemToLevel(node, nodes);
+    const toLevel = direct ?? hostedToLevel(node, nodes);
+    if (!toLevel)
+        return null;
+    try {
+        const solids = manifestSolids(manifest, toLevel);
+        return solids?.every((solid) => Number.isFinite(solid.y0) && Number.isFinite(solid.y1))
+            ? solids
+            : null;
+    }
+    catch {
+        // A malformed outline is not evidence of separation: the box reads instead.
+        return null;
+    }
+}
+/** The map of a manifest point to the level for an item hosted by other items, or undefined. */
+function hostedToLevel(node, nodes) {
+    // biome-ignore lint/plugin: an item hosted by other items resolves each parent through the whole scene
+    const byId = new Map(Object.entries(nodes));
+    const pose = itemLevelPose(node, byId);
+    if (!pose ||
+        !node.scale.every((value) => value > 0) ||
+        !(node.asset.scale ?? [1, 1, 1]).every((value) => value > 0))
+        return;
+    let root = node;
+    for (let depth = 0; depth < 16; depth++) {
+        const parent = root.parentId ? nodes[root.parentId] : undefined;
+        if (parent?.type !== 'item')
+            break;
+        root = parent;
+    }
+    const rootParent = root.parentId ? nodes[root.parentId] : undefined;
+    if (rootParent?.type !== 'level')
+        return;
+    const lift = itemFloorLift(root, nodes);
+    if (!Number.isFinite(lift))
+        return;
+    const assetScale = node.asset.scale ?? [1, 1, 1];
+    const turn = [node.rotation[0], pose.yawDeg, node.rotation[2]];
+    return (point) => {
+        const asset = rotateVector(point.map((value, axis) => value * assetScale[axis]), node.asset.rotation);
+        const placed = rotateVector(asset.map((value, axis) => (value + node.asset.offset[axis]) * node.scale[axis]), turn);
+        return [
+            placed[0] + pose.position[0],
+            placed[1] + pose.position[1] + lift,
+            placed[2] + pose.position[2],
+        ];
+    };
+}
+/**
+ * Doors blocked by furniture. An item is its box, as tall as its heights say (a pendant over the door
+ * is above its leaf); wall panelling alone is its real strips (see `findItemItemCollisions`).
+ */
+export function findBlockedDoors(args) {
+    const list = [...args.nodes];
+    const nodes = Object.fromEntries(list.map((node) => [node.id, node]));
+    const byId = new Map(list.map((node) => [node.id, node]));
+    const finite = list.every((node) => node.type === 'item' || finiteNumbers(node));
+    return findBlockedDoorsByBox({
+        ...args,
+        nodes: list,
+        solidsOf: (node) => (finite && isWallDressing(node) ? itemSolidsInLevel(node, nodes) : null),
+        heightsOf: (node) => itemHeightsInLevel(node, nodes, byId, finite) ?? null,
+    });
+}
+/** Plan overlap, in square metres, from which two real shapes are overlapping: a touching edge or a boolean's sliver is not. */
+export const MIN_OVERLAP_AREA = 0.001;
+/**
+ * An item's bottom and top in the level's frame, as the renderer stands it: the model's own bounds
+ * through the floor construction under it (measured) or, where it has none, its pose and its height
+ * above its host, lifted by the floor construction under the item at the root of its host chain. A
+ * thing hosted by a ceiling or a wall, or one whose heights are unknown, has none.
+ */
+export function itemHeightsInLevel(node, nodes, byId, finiteContext = true) {
+    const measured = finiteContext ? itemVerticalInterval(node, nodes) : undefined;
+    if (measured)
+        return measured;
+    const range = itemLevelHeightRange(node, byId);
+    let root = node;
+    for (let depth = 0; depth < 16; depth++) {
+        const parent = root.parentId ? nodes[root.parentId] : undefined;
+        if (parent?.type !== 'item')
+            break;
+        root = parent;
+    }
+    const rootParent = root.parentId ? nodes[root.parentId] : undefined;
+    const levelId = resolveNodeLevelId(node.id, byId);
+    if (!(range && levelId && finiteContext && rootParent?.type === 'level'))
+        return undefined;
+    const lift = itemFloorLift(root, nodes);
+    return Number.isFinite(lift)
+        ? { levelId, min: range.min + lift, max: range.max + lift }
+        : undefined;
+}
+/** How far an item may sink into what it stands on and still be resting on it, in metres. */
+export const STACK_TOLERANCE = 0.02;
 export function findItemItemCollisions(args) {
     const gap = args.gap ?? DEFAULT_ITEM_GAP;
     const list = [...args.nodes];
@@ -183,28 +343,37 @@ export function findItemItemCollisions(args) {
     // 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 heights = new Map();
+    for (const { id } of footprints)
+        heights.set(id, itemHeightsInLevel(nodes[id], nodes, byId, finiteContext));
+    // A box is as tall as its heights say; a real shape is read for wall panelling only.
+    const solids = new Map();
+    const solidsOf = (id) => {
+        if (!solids.has(id))
+            solids.set(id, finiteContext ? itemSolidsInLevel(nodes[id], nodes) : null);
+        return solids.get(id) ?? null;
+    };
+    const boxSolid = (id) => {
         const node = nodes[id];
-        const measured = finiteContext ? itemVerticalInterval(node, nodes) : undefined;
-        if (measured)
-            return [id, { ...measured, measured: true }];
-        const range = itemLevelHeightRange(node, byId);
+        const pose = itemLevelPose(node, byId);
+        if (!pose)
+            return null;
+        const corners = itemNodePlanCorners({
+            ...node,
+            position: pose.position,
+            rotation: [node.rotation[0], pose.yawDeg, node.rotation[2]],
+        });
+        if (!corners.every((corner) => corner.every(Number.isFinite)))
+            return null;
+        const interval = heights.get(id);
         return [
-            id,
-            range
-                ? {
-                    levelId: resolveNodeLevelId(id, byId) ?? '',
-                    min: range.min,
-                    max: range.max,
-                    measured: false,
-                }
-                : undefined,
+            {
+                polygons: [{ outer: corners.map(([x, z]) => [x, z]), holes: [] }],
+                y0: interval?.min ?? Number.NEGATIVE_INFINITY,
+                y1: interval?.max ?? Number.POSITIVE_INFINITY,
+            },
         ];
-    }));
-    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++) {
@@ -212,29 +381,47 @@ 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)
+            const aY = heights.get(a.id);
+            const bY = heights.get(b.id);
+            let violation;
+            let reading;
+            if (isWallDressing(nodes[a.id]) || isWallDressing(nodes[b.id])) {
+                // Wall panelling is thin strips along the walls, and its box is the room's: it is read by its
+                // strips, a piece beside it by its footprint. Nothing else is: a script's horizontal faces leave
+                // out its rails, backs and foliage, so the box stays the shape of the rest.
+                const left = solidsOf(a.id) ?? boxSolid(a.id);
+                const right = solidsOf(b.id) ?? boxSolid(b.id);
+                if (!(left && right))
+                    continue;
+                const relation = relateSolids(left, right, {
+                    stack: STACK_TOLERANCE,
+                    minArea: MIN_OVERLAP_AREA,
+                });
+                if (relation.overlapArea > 0) {
+                    violation = 'overlap';
+                    reading = { overlapAreaM2: roundMm(relation.overlapArea) };
+                }
+                else if (relation.gap < gap) {
+                    violation = 'clearance';
+                    reading = { gapM: roundMm(relation.gap) };
+                }
+                else
                     continue;
             }
+            else {
+                // Two boxes. One standing on the other (a lamp on a table, a vase on a console) is stacked,
+                // whether it is the other's child or a sibling in the scene: its bottom is at or above the
+                // other's top, to within what a model sinks into it. Unknown heights waive nothing.
+                if (aY &&
+                    bY &&
+                    aY.levelId === bY.levelId &&
+                    (aY.min >= bY.max - STACK_TOLERANCE - 1e-9 || bY.min >= aY.max - STACK_TOLERANCE - 1e-9))
+                    continue;
+                violation = aabbsOverlap(a.aabb, b.aabb, 0) ? 'overlap' : 'clearance';
+                reading = boxReading(a.aabb, b.aabb, gap);
+            }
             collisions.push({
                 aId: a.id,
                 bId: b.id,
@@ -242,11 +429,11 @@ export function findItemItemCollisions(args) {
                 bName: b.name,
                 levelId: a.levelId ?? b.levelId,
                 kind: 'item-aabb',
-                violation: aabbsOverlap(a.aabb, b.aabb, 0) ? 'overlap' : 'clearance',
+                violation,
                 minimumClearanceMeters: gap,
-                message: aabbsOverlap(a.aabb, b.aabb, 0)
-                    ? `Items overlap: ${a.name ?? a.id} (${a.id}) and ${b.name ?? b.id} (${b.id})`
-                    : `Items are closer than ${gap} m: ${a.name ?? a.id} (${a.id}) and ${b.name ?? b.id} (${b.id})`,
+                footprints: [roundBox(a.aabb), roundBox(b.aabb)],
+                reading,
+                message: collisionMessage(violation, gap, [a, b], reading),
             });
         }
     }
@@ -387,15 +574,6 @@ export const MID_ROOM_DISTANCE_M = 0.4;
 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 = [
@@ -414,17 +592,20 @@ function boxToSegment(box, a, b) {
     }
     return nearest;
 }
-/** The walls of a level (resolved through `byId`), as the mid-room check reads them. */
+/**
+ * The walls of a level (resolved through `byId`), as the mid-room check reads them: its wall nodes.
+ */
 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)
+        if (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,
-        });
+        if (node.type === 'wall')
+            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;
 }
@@ -434,8 +615,10 @@ export function gapToWalls(box, walls) {
 }
 /**
  * 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.
+ * wall: further than {@link MID_ROOM_DISTANCE_M} from the face of each wall of their level. A roof
+ * on the level stands walls of its own (knee walls, gable ends) where no wall node does, so a loft
+ * bounded by its roof is measured to them. Pieces outside every room, free-standing kinds, and
+ * levels with neither walls nor a roof shell are not judged.
  */
 export function findItemsMidRoom(args) {
     const list = [...args.nodes];
@@ -450,7 +633,8 @@ export function findItemsMidRoom(args) {
         ...(args.levelId === undefined ? {} : { levelId: args.levelId }),
     })) {
         const node = byId.get(footprint.id);
-        if (node?.type !== 'item' || furnitureKind(node.asset) !== 'wall')
+        const word = node?.type === 'item' ? wallBoundWord(node.asset) : null;
+        if (node?.type !== 'item' || !word)
             continue;
         const room = zones.find((zone) => pointInPolygon([node.position[0], node.position[2]], zone.polygon, true));
         if (!room)
@@ -460,13 +644,14 @@ export function findItemsMidRoom(args) {
             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).`,
+            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 ${word} belongs against a wall (place_in_room puts it there).`,
         });
     }
     return found;
 }
 /**
- * Collect layout issues, scoped per level so stacked floors do not false-positive.
+ * Collect layout issues, scoped per level so stacked floors do not false-positive. A blocked door and
+ * a pair of items carry the numbers of the finding: what stands where, how deep, and the way clear.
  */
 export function layoutIssuesFromScene(nodes) {
     const list = [...nodes];
@@ -484,17 +669,39 @@ export function layoutIssuesFromScene(nodes) {
     }
     const issues = new Map();
     const levels = levelIds.size > 0 ? [...levelIds] : [undefined];
+    const itemById = new Map(list.map((n) => [n.id, n]));
     for (const levelId of levels) {
         for (const b of findBlockedDoors({ nodes: list, levelId })) {
-            issues.set(b.message, 'door_blocked');
+            issues.set(b.message, {
+                type: 'door_blocked',
+                message: b.message,
+                nodeIds: [b.doorId, b.itemId, b.wallId],
+                obstacle: { nodeId: b.itemId, name: b.itemName, footprint: b.footprint, side: b.side },
+                clearZone: b.clearZone,
+                ...b.reading,
+            });
         }
         for (const c of findItemItemCollisions({ nodes: list, levelId })) {
-            issues.set(c.message, c.violation === 'overlap' ? 'item_overlap' : 'item_too_close');
+            // Close is the design for a nightstand beside its bed, a chair at its table: not a finding.
+            const [a, b] = [itemById.get(c.aId), itemById.get(c.bId)];
+            if (c.violation === 'clearance' &&
+                a?.type === 'item' &&
+                b?.type === 'item' &&
+                designedTogether(a, b))
+                continue;
+            issues.set(c.message, {
+                type: c.violation === 'overlap' ? 'item_overlap' : 'item_too_close',
+                message: c.message,
+                nodeIds: [c.aId, c.bId],
+                footprints: c.footprints,
+                minimumClearanceMeters: c.minimumClearanceMeters,
+                ...c.reading,
+            });
         }
         for (const m of findItemsMidRoom({ nodes: list, levelId })) {
-            issues.set(m.message, 'item_mid_room');
+            issues.set(m.message, { type: 'item_mid_room', message: m.message, nodeIds: [m.id] });
         }
     }
     // Deduplicate (node may appear under multiple walks)
-    return [...issues].map(([message, type]) => ({ type, message }));
+    return [...issues.values()];
 }

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

@@ -1 +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"}
+{"version":3,"file":"level-height-fill.d.ts","sourceRoot":"","sources":["../../src/agent-operations/level-height-fill.ts"],"names":[],"mappings":"AACA,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,CAqDV"}

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

@@ -1,3 +1,4 @@
+import { draftOf } from '../runtime/reader.js';
 import { deriveLegacyLevelHeight } from '../services/level-height.js';
 const round = (value) => Math.round(value * 100) / 100;
 /**
@@ -9,7 +10,12 @@ const round = (value) => Math.round(value * 100) / 100;
  * per level filled, for the write's answer.
  */
 export function fillLevelHeights(ops, scene) {
-    const after = { ...scene };
+    // Only a level written without a height reads the scene as the write leaves it.
+    if (!ops.some((op) => op.op === 'create'
+        ? op.node.type === 'level' && op.node.height == null
+        : op.op === 'update' && 'height' in op.data && op.data.height == null))
+        return [];
+    const after = draftOf(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')

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

@@ -16,6 +16,11 @@ export declare function wallSummary(nodes: SceneNodes, wall: WallNode): {
     resolvedHeight: number;
     heightIsExplicit: boolean;
     thickness: number | undefined;
+    wallType: "curtain" | "railing" | "standard";
+    type: {
+        id: string;
+        label: string;
+    } | null;
     wallFaceChains: {
         a: import("../index.js").WallFaceChainFinish;
         b: import("../index.js").WallFaceChainFinish;

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;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"}
+{"version":3,"file":"level-reads.d.ts","sourceRoot":"","sources":["../../src/agent-operations/level-reads.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAMV,QAAQ,EAET,MAAM,WAAW,CAAA;AAMlB,OAAO,EAAE,KAAK,gBAAgB,EAAe,MAAM,gBAAgB,CAAA;AAEnE,OAAO,KAAK,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AASzD;;;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;IAKzD,EAAE;IACF,IAAI;IACJ,KAAK;IACL,GAAG;IACH,MAAM;IACN,MAAM;IACN,cAAc;IACd,gBAAgB;IAChB,SAAS;IACT,QAAQ;IACR,IAAI;;;;IACJ,cAAc;QACZ,CAAC;QACD,CAAC;;IAEH,QAAQ;;;;;;;EAOX;AAuID,2BAA2B;AAC3B,eAAO,MAAM,eAAe,EAAE,cAAc,CAAC,gBAAgB,CAE3D,CAAA;AAEF,mBAAmB;AACnB,eAAO,MAAM,QAAQ,EAAE,cAAc,CAAC,gBAAgB,CAUrD,CAAA;AAED,mBAAmB;AACnB,eAAO,MAAM,QAAQ,EAAE,cAAc,CAAC,gBAAgB,CAIrD,CAAA"}

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

@@ -1,4 +1,7 @@
+import { deckBoardSettings } from '../lib/deck-boards.js';
 import { area } from '../lib/polygon-boolean.js';
+import { porchFramingSettings } from '../lib/porch-framing.js';
+import { porchPartOf } from '../lib/porch-framing-sync.js';
 import { roomFloorChoices } from '../lib/room-floor-choices.js';
 import { DEFAULT_LEVEL_HEIGHT } from '../services/level-height.js';
 import { getWallTop } from '../services/storey.js';
@@ -6,7 +9,8 @@ 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';
+import { contentCounts, levelIdOf, levelRole, nodesOnLevel, queryNodes } from './scene-queries.js';
+import { wallTypeChoices } from './wall-type.js';
 const round2 = (value) => Math.round(value * 100) / 100;
 function ofType(content, type) {
     return content.filter((node) => node.type === type);
@@ -25,6 +29,9 @@ export function wallResolvedHeight(nodes, wall) {
         support.elevation);
 }
 export function wallSummary(nodes, wall) {
+    const type = wall.assembly?.presetId
+        ? wallTypeChoices(nodes).find((entry) => entry.id === wall.assembly?.presetId)
+        : undefined;
     return {
         id: wall.id,
         name: wall.name,
@@ -35,6 +42,8 @@ export function wallSummary(nodes, wall) {
         resolvedHeight: wallResolvedHeight(nodes, wall),
         heightIsExplicit: wall.height !== undefined,
         thickness: wall.thickness,
+        wallType: wall.wallType ?? 'standard',
+        type: type ? { id: type.id, label: type.label } : null,
         wallFaceChains: {
             a: resolveWallFaceChain(wall, 'a'),
             b: resolveWallFaceChain(wall, 'b'),
@@ -59,14 +68,35 @@ function zoneSize(zone) {
         },
     };
 }
+/** The unit a zone belongs to; none is common area. */
+const unitOf = (nodes, zoneId) => {
+    const unit = queryNodes(nodes, { type: 'unit' }).find((node) => node.members.includes(zoneId));
+    return { unitId: unit?.id ?? null, unit: unit?.name ?? null };
+};
+function zoneFraming(nodes, zone) {
+    const parts = queryNodes(nodes, { type: ['column', 'beam'], parentId: zone.parentId }).filter((node) => porchPartOf(node)?.porchOf === zone.id);
+    if (!zone.roomType && !zone.porchFraming && parts.length === 0)
+        return null;
+    return {
+        ...porchFramingSettings(zone),
+        auto: zone.porchFraming?.auto ?? (zone.roomType === 'porch' && zone.hasCeiling !== false),
+        postCount: parts.filter((node) => node.type === 'column').length,
+        beamCount: parts.filter((node) => node.type === 'beam').length,
+    };
+}
 const zoneSummary = (nodes, zone) => ({
     id: zone.id,
     name: zone.name,
     color: zone.color,
     polygon: zone.polygon,
     holes: zone.holes ?? [],
+    roomType: zone.roomType ?? 'room',
+    floor: { drop: zone.floor?.drop ?? 0 },
+    porchFraming: zoneFraming(nodes, zone),
+    ...(zone.roomType === 'deck' || zone.decking ? { decking: deckBoardSettings(zone) } : {}),
     wallMaterial: zone.wallMaterial ?? null,
     wallOverrides: zone.wallOverrides ?? [],
+    ...unitOf(nodes, zone.id),
     ...zoneSize(zone),
     floor_choices: roomFloorChoices(nodes, zone.id),
 });
@@ -158,7 +188,13 @@ export const getLevelSummary = (nodes, input, context) => ({
 export const getWalls = (nodes, input, context) => {
     const level = targetLevel(nodes, input, context);
     const walls = ofType(nodesOnLevel(nodes, level.id), 'wall');
-    return { result: { levelId: level.id, walls: walls.map((wall) => wallSummary(nodes, wall)) } };
+    return {
+        result: {
+            levelId: level.id,
+            walls: walls.map((wall) => wallSummary(nodes, wall)),
+            wallTypes: wallTypeChoices(nodes).map(({ id, label }) => ({ id, label })),
+        },
+    };
 };
 /** `get_zones`. */
 export const getZones = (nodes, input, context) => {

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":"AAIA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAE7C,mFAAmF;AACnF,eAAO,MAAM,UAAU,EAAE,cAiDxB,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,cA+CxB,CAAA"}

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

@@ -1,11 +1,9 @@
 import { levelGradeStanding } from '../lib/grade-standing.js';
 import { groundSeat } from '../lib/ground-seat.js';
-import { levelRole, levelsOf } from './scene-queries.js';
+import { levelRole, levelsOf, queryNodes } 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 groundLevels = queryNodes(nodes, { type: 'building' }).flatMap((building) => {
         const seat = groundSeat(nodes, building.id);
         return seat
             ? [

package/dist/agent-operations/move-node.d.ts

@@ -0,0 +1,12 @@
+import { type MoveTarget } from './move-plan.js';
+import type { AgentOperation } from './types.js';
+type MoveNodeInput = MoveTarget & {
+    id: string;
+};
+/**
+ * `move_node`: the editor's move tool for one node — re-seated on its host by `planNodeMove`,
+ * so the node the agent leaves is the node the editor's drag would leave.
+ */
+export declare const moveNode: AgentOperation<MoveNodeInput>;
+export {};
+//# sourceMappingURL=move-node.d.ts.map

package/dist/agent-operations/move-node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"move-node.d.ts","sourceRoot":"","sources":["../../src/agent-operations/move-node.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,UAAU,EAAgB,MAAM,aAAa,CAAA;AAC3D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAE7C,KAAK,aAAa,GAAG,UAAU,GAAG;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE,CAAA;AAEhD;;;GAGG;AACH,eAAO,MAAM,QAAQ,EAAE,cAAc,CAAC,aAAa,CAmBlD,CAAA"}