@pascal-app/core 1.0.6 → 1.0.7

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

@@ -1,3 +1,4 @@
+import { getDoorOpeningSize } from '../lib/door-opening.js';
 /**
  * Door access keep-outs for MCP layout tools.
  *
@@ -6,10 +7,14 @@
  *
  * See docs/layout-clearance-error-log.md for pitfalls (levels, gap sign, scale).
  */
+import { isVehicleDoorType } from '../lib/door-operation.js';
+import { area, intersection } from '../lib/polygon-boolean.js';
 import { boxCorners, rotateVector } from '../procedural-items/spatial.js';
 import { getScaledDimensions } from '../schema/index.js';
-import { isFloorUnderlay } from './furniture-kind.js';
+import { DEFAULT_WALL_THICKNESS } from '../systems/wall/wall-footprint.js';
+import { isFloorUnderlay, isVehicle } from './furniture-kind.js';
 import { itemLevelHeightRange, itemPlanAabbInLevel } from './item-space.js';
+import { axisOverlap, clearingMoves, describeMoves, metres, roundBox, roundMm, } from './plan-clearance.js';
 import { wallLength } from './plan-geometry.js';
 /** Plan depth (m) cleared on each side of the wall face through the opening. */
 export const DEFAULT_DOOR_CLEAR_DEPTH = 0.65;
@@ -210,8 +215,14 @@ export function doorKeepoutFromWall(wall, door, options) {
     const length = wallLength(wall);
     if (length <= 1e-6)
         return null;
-    const width = typeof door.width === 'number' && door.width > 0 ? door.width : 0.9;
-    const localX = Array.isArray(door.position) ? (door.position[0] ?? length / 2) : length / 2;
+    const size = getDoorOpeningSize({
+        ...door,
+        width: typeof door.width === 'number' && door.width > 0 ? door.width : 0.9,
+        height: typeof door.height === 'number' && door.height > 0 ? door.height : DEFAULT_DOOR_HEIGHT,
+    });
+    const width = size.width;
+    const localX = (Array.isArray(door.position) ? (door.position[0] ?? length / 2) : length / 2) -
+        size.leafOffsetX * (Math.cos(door.rotation?.[1] ?? 0) >= 0 ? 1 : -1);
     const [sx, sz] = wall.start;
     const [ex, ez] = wall.end;
     const dx = (ex - sx) / length;
@@ -237,13 +248,28 @@ export function doorKeepoutFromWall(wall, door, options) {
     }
     const xs = corners.map((c) => c[0]);
     const zs = corners.map((c) => c[1]);
+    const vehicleAperture = isVehicleDoorType(door.doorType)
+        ? doorKeepoutFromWall(wall, { ...door, doorType: undefined }, {
+            clearDepth: (wall.thickness ?? DEFAULT_WALL_THICKNESS) / 2,
+            sidePad,
+            levelId: options?.levelId,
+        })
+        : null;
     return {
+        ...(vehicleAperture
+            ? { vehicleAperture: { ...vehicleAperture, doorType: door.doorType } }
+            : {}),
         doorId: door.id,
         wallId: wall.id,
         levelId: options?.levelId ?? null,
         width,
         localX,
-        height: typeof door.height === 'number' && door.height > 0 ? door.height : DEFAULT_DOOR_HEIGHT,
+        doorType: door.doorType,
+        centre: [sx + dx * localX, sz + dz * localX],
+        normal: [nx, nz],
+        alongM: 2 * half,
+        depthM: { inward: front, outward: -back },
+        height: size.height,
         aabb: {
             minX: Math.min(...xs),
             maxX: Math.max(...xs),
@@ -279,8 +305,87 @@ export function collectDoorKeepouts(nodes, options) {
     }
     return keepouts;
 }
+/** How near a door's keep-out an item may stand before it is read as in it (m): a leaf's play, not a measure of the house. */
+export const DOOR_KEEPOUT_MARGIN = 0.02;
 export function itemBlocksDoorKeepout(itemAabb, keepout) {
-    return aabbsOverlap(itemAabb, keepout.aabb, 0.02);
+    return aabbsOverlap(itemAabb, keepout.aabb, DOOR_KEEPOUT_MARGIN);
+}
+/** How much of a keep-out an item's real shape must stand in to block it (m²): a touching edge is not. */
+export const DOOR_KEEPOUT_MIN_AREA = 1e-4;
+/**
+ * The area (m²) of an item's solids that reach below the door's head and stand in the keep-out,
+ * grown by the same margin the box is read with; 0 when none does.
+ */
+function solidsKeepoutArea(solids, keepout) {
+    const { minX, maxX, minZ, maxZ } = keepout.aabb;
+    const m = DOOR_KEEPOUT_MARGIN;
+    const zone = [
+        [minX - m, minZ - m],
+        [maxX + m, minZ - m],
+        [maxX + m, maxZ + m],
+        [minX - m, maxZ + m],
+    ];
+    return solids.reduce((total, solid) => {
+        // A pendant over the doorway is above the leaf.
+        if (solid.y0 >= keepout.height - 0.05)
+            return total;
+        const shared = area(intersection(solid.polygons, zone));
+        return shared >= DOOR_KEEPOUT_MIN_AREA ? total + shared : total;
+    }, 0);
+}
+function clearZoneOf(keepout) {
+    return {
+        box: roundBox(keepout.aabb),
+        alongWallM: roundMm(keepout.alongM),
+        depthM: { inward: roundMm(keepout.depthM.inward), outward: roundMm(keepout.depthM.outward) },
+    };
+}
+function sideOfWall(keepout, footprint) {
+    const across = ((footprint.minX + footprint.maxX) / 2 - keepout.centre[0]) * keepout.normal[0] +
+        ((footprint.minZ + footprint.maxZ) / 2 - keepout.centre[1]) * keepout.normal[1];
+    return across >= 0 ? 'inward' : 'outward';
+}
+function blockedDoorMessage(keepout, item, facts) {
+    const { side, clearZone, reading } = facts;
+    const standing = 'overlapAreaM2' in reading
+        ? `its shape covers ${metres(reading.overlapAreaM2)} m² of the door's clear zone`
+        : reading.overlapM > 0
+            ? `its footprint stands ${metres(reading.overlapM)} m into the door's clear zone`
+            : `its footprint stands within the ${DOOR_KEEPOUT_MARGIN.toFixed(2)} m the check keeps clear of the door's clear zone`;
+    const { box, alongWallM, depthM } = clearZone;
+    const zone = `Clear zone: x ${metres(box.minX)}…${metres(box.maxX)}, z ${metres(box.minZ)}…${metres(box.maxZ)} (${alongWallM.toFixed(2)} m along the wall, ${depthM.inward.toFixed(2)} m deep inward and ${depthM.outward.toFixed(2)} m outward of the wall's centre line).`;
+    const clear = 'clearBy' in reading ? ` Clear of it: ${describeMoves(reading.clearBy)}.` : '';
+    const kind = keepout.doorType ? `${keepout.doorType}, ` : '';
+    return `Door ${keepout.doorId} (${kind}${keepout.width.toFixed(2)} m wide) on wall ${keepout.wallId} is blocked by item ${item.name} (${item.id}): ${standing}, on the ${side} side of the wall. ${zone}${clear}`;
+}
+function doorBlockReading(keepout, footprint, solidsAreaM2) {
+    if (solidsAreaM2 !== undefined)
+        return { overlapAreaM2: roundMm(solidsAreaM2) };
+    const shared = axisOverlap(footprint, keepout.aabb);
+    return {
+        overlapM: Math.max(0, roundMm(Math.min(shared.x, shared.z))),
+        clearBy: clearingMoves(footprint, keepout.aabb, DOOR_KEEPOUT_MARGIN),
+    };
+}
+/** A blocked door as the agent reads it: the item, how far it stands in the zone, the ways out, the zone. */
+function blockedDoorIssue(keepout, node, footprint, levelId, solidsAreaM2) {
+    const name = node.name ?? node.asset?.name ?? node.id;
+    const item = { name: typeof name === 'string' ? name : node.id, id: node.id };
+    const facts = {
+        side: sideOfWall(keepout, footprint),
+        clearZone: clearZoneOf(keepout),
+        reading: doorBlockReading(keepout, footprint, solidsAreaM2),
+    };
+    return {
+        doorId: keepout.doorId,
+        wallId: keepout.wallId,
+        itemId: node.id,
+        levelId,
+        itemName: item.name,
+        footprint: roundBox(footprint),
+        message: blockedDoorMessage(keepout, item, facts),
+        ...facts,
+    };
 }
 export function findBlockedDoors(args) {
     const nodes = [...args.nodes];
@@ -307,27 +412,29 @@ export function findBlockedDoors(args) {
         const aabb = itemPlanAabbInLevel(node, byId);
         if (!aabb)
             continue;
-        const heights = itemLevelHeightRange(node, byId);
-        for (const keepout of keepouts) {
+        const heights = args.heightsOf?.(node) ?? itemLevelHeightRange(node, byId);
+        const solids = args.solidsOf?.(node) ?? null;
+        const vehicle = isVehicle(node);
+        for (const full of keepouts) {
             // Same-level only (multi-story safety).
-            if (keepout.levelId && itemLevel && keepout.levelId !== itemLevel)
+            if (full.levelId && itemLevel && full.levelId !== itemLevel)
                 continue;
-            if (args.levelId && keepout.levelId && keepout.levelId !== args.levelId)
+            if (args.levelId && full.levelId && full.levelId !== args.levelId)
                 continue;
+            const keepout = (vehicle && full.vehicleAperture) || full;
             if (!itemBlocksDoorKeepout(aabb, keepout))
                 continue;
-            // A pendant over the doorway is above the leaf.
-            if (heights && heights.min >= keepout.height - 0.05)
+            let solidsAreaM2;
+            if (solids) {
+                solidsAreaM2 = solidsKeepoutArea(solids, keepout);
+                if (solidsAreaM2 === 0)
+                    continue;
+            }
+            else if (heights && heights.min >= keepout.height - 0.05) {
+                // A pendant over the doorway is above the leaf.
                 continue;
-            const itemName = node.name ?? node.asset?.name ?? node.id;
-            issues.push({
-                doorId: keepout.doorId,
-                wallId: keepout.wallId,
-                itemId: node.id,
-                levelId: itemLevel,
-                itemName: typeof itemName === 'string' ? itemName : undefined,
-                message: `Door ${keepout.doorId} on wall ${keepout.wallId} is blocked by item ${itemName} (${node.id})`,
-            });
+            }
+            issues.push(blockedDoorIssue(keepout, node, aabb, itemLevel, solidsAreaM2));
         }
     }
     return issues;

package/dist/agent-operations/dress-targets.d.ts

@@ -0,0 +1,23 @@
+import type { WallNode } from '../schema/index.js';
+import type { RoomWallFace } from './room-faces.js';
+type Plan = [number, number];
+/** What a layer is laid against: the plan corners of a fixture or a cabinet run, and the worktop of a run. */
+export type DressTarget = {
+    id: string;
+    corners: Plan[];
+    worktop?: number;
+};
+/** How far a footprint's edge may stand from a face and still stand against it, metres. */
+export declare const STANDS_AGAINST_M = 0.15;
+/**
+ * The stretch of a face a target stands against, widened by `margin` and held to the stretch the room
+ * stands on, in metres along the wall; undefined when the target is not at the face. A target stands
+ * against a face when its nearest corner is within `STANDS_AGAINST_M` of the face's plane on the room's
+ * side. A curved face has no straight plane to measure: the caller skips it.
+ */
+export declare function standsAgainst(wall: WallNode, stretch: RoomWallFace, corners: readonly Plan[], margin: number): {
+    u0: number;
+    u1: number;
+} | undefined;
+export {};
+//# sourceMappingURL=dress-targets.d.ts.map

package/dist/agent-operations/dress-targets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dress-targets.d.ts","sourceRoot":"","sources":["../../src/agent-operations/dress-targets.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAA;AAEzC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAA;AAEhD,KAAK,IAAI,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AAE5B,8GAA8G;AAC9G,MAAM,MAAM,WAAW,GAAG;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,IAAI,EAAE,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAE,CAAA;AAE3E,2FAA2F;AAC3F,eAAO,MAAM,gBAAgB,OAAO,CAAA;AAcpC;;;;;GAKG;AACH,wBAAgB,aAAa,CAC3B,IAAI,EAAE,QAAQ,EACd,OAAO,EAAE,YAAY,EACrB,OAAO,EAAE,SAAS,IAAI,EAAE,EACxB,MAAM,EAAE,MAAM,GACb;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,CAgBxC"}

package/dist/agent-operations/dress-targets.js

@@ -0,0 +1,34 @@
+import { getWallFaceOffsets } from '../systems/wall/wall-frame.js';
+/** How far a footprint's edge may stand from a face and still stand against it, metres. */
+export const STANDS_AGAINST_M = 0.15;
+/** The slack a footprint may sink into a face before it stands behind it instead, metres. */
+const SINK_M = 0.03;
+const millimetre = (metres) => Math.round(metres * 1000) / 1000;
+const aabbCorners = (box) => [
+    [box.minX, box.minZ],
+    [box.maxX, box.minZ],
+    [box.maxX, box.maxZ],
+    [box.minX, box.maxZ],
+];
+/**
+ * The stretch of a face a target stands against, widened by `margin` and held to the stretch the room
+ * stands on, in metres along the wall; undefined when the target is not at the face. A target stands
+ * against a face when its nearest corner is within `STANDS_AGAINST_M` of the face's plane on the room's
+ * side. A curved face has no straight plane to measure: the caller skips it.
+ */
+export function standsAgainst(wall, stretch, corners, margin) {
+    const length = stretch.length;
+    const dx = (wall.end[0] - wall.start[0]) / length;
+    const dz = (wall.end[1] - wall.start[1]) / length;
+    // Face a is on the left of start to end; both normals point into the room.
+    const sign = stretch.face === 'a' ? 1 : -1;
+    const plane = sign * getWallFaceOffsets(wall)[stretch.face];
+    const along = corners.map(([x, z]) => (x - wall.start[0]) * dx + (z - wall.start[1]) * dz);
+    const into = corners.map(([x, z]) => sign * (-(x - wall.start[0]) * dz + (z - wall.start[1]) * dx));
+    const gap = Math.min(...into) - plane;
+    if (gap > STANDS_AGAINST_M || gap < -SINK_M)
+        return undefined;
+    const u0 = Math.max(stretch.u0, millimetre(Math.min(...along) - margin));
+    const u1 = Math.min(stretch.u1, millimetre(Math.max(...along) + margin));
+    return u1 - u0 > 1e-6 ? { u0, u1 } : undefined;
+}

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

@@ -0,0 +1,14 @@
+import type { AgentOperation } from './types.js';
+type DuplicateNodeInput = {
+    ids: string[];
+    offset?: number[];
+    targetLevelId?: string;
+};
+/**
+ * `duplicate_node`: the editor's Duplicate — the same clone its duplicate-without-move path
+ * makes (`collectSubtree` + `cloneNodesInto`), its clipboard's root rules, and its paste's
+ * host-reference remap, with the offset seated by the same plan as `move_node`.
+ */
+export declare const duplicateNode: AgentOperation<DuplicateNodeInput>;
+export {};
+//# sourceMappingURL=duplicate-node.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"duplicate-node.d.ts","sourceRoot":"","sources":["../../src/agent-operations/duplicate-node.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,cAAc,EAA4B,MAAM,SAAS,CAAA;AAEvE,KAAK,kBAAkB,GAAG;IACxB,GAAG,EAAE,MAAM,EAAE,CAAA;IACb,MAAM,CAAC,EAAE,MAAM,EAAE,CAAA;IACjB,aAAa,CAAC,EAAE,MAAM,CAAA;CACvB,CAAA;AAyGD;;;;GAIG;AACH,eAAO,MAAM,aAAa,EAAE,cAAc,CAAC,kBAAkB,CA6E5D,CAAA"}

package/dist/agent-operations/duplicate-node.js

@@ -0,0 +1,173 @@
+import { refuse } from '../agent-tools/refusal.js';
+import { cloneNodesInto, collectSubtree } from '../registry/subtree.js';
+import { isDerivedNode } from '../store/derived-node-guard.js';
+import { achievedChanges } from './achieved.js';
+import { planNodeMove } from './move-plan.js';
+import { levelIdOf, levelsOf } from './scene-queries.js';
+const DEDICATED_TOOL = {
+    level: 'duplicate_level',
+    zone: 'duplicate_zone',
+    roof: 'create_roof',
+    'roof-segment': 'create_roof',
+};
+// Kinds the editor does not copy node by node: scene structure with its own tools, plus the
+// kinds whose definitions declare themselves not duplicable (a spawn is one per level).
+const REFUSED_TYPES = new Set([
+    'site',
+    'building',
+    'level',
+    'zone',
+    'roof',
+    'roof-segment',
+    'guide',
+    'unit',
+    'floor-opening',
+    'stair-segment',
+    'separator',
+    'facade',
+    'scan',
+    'spawn',
+]);
+/** The parent classes the editor copies a root from, as its clipboard roots are decided. */
+function requireCopyableRoot(nodes, node) {
+    if (isDerivedNode(node) || REFUSED_TYPES.has(node.type)) {
+        const dedicated = DEDICATED_TOOL[node.type];
+        refuse('duplicate_not_supported', `A ${node.type} is not copied node by node${dedicated ? `; use ${dedicated}` : ''}.`, { id: node.id, type: node.type });
+    }
+    const parent = node.parentId ? nodes[node.parentId] : undefined;
+    const hostedRoot = (parent?.type === 'wall' &&
+        (node.type === 'door' || node.type === 'window' || node.type === 'item')) ||
+        (parent?.type === 'ceiling' && node.type === 'item') ||
+        parent?.type === 'roof-segment';
+    if (parent?.type !== 'level' && !hostedRoot)
+        refuse('duplicate_root_invalid', `${node.type} ${node.id} is copied as part of its parent${parent ? ` (${parent.type} ${parent.id})` : ''}; name the parent instead.`, { id: node.id, type: node.type, parentId: node.parentId ?? null });
+    return parent;
+}
+function isDescendantOf(nodes, id, rootIds) {
+    let parentId = nodes[id]?.parentId;
+    while (parentId) {
+        if (rootIds.has(parentId))
+            return true;
+        parentId = nodes[parentId]?.parentId;
+    }
+    return false;
+}
+/** Derived plates are rebuilt by the host's reconciler, as the editor's copy leaves them out. */
+function withoutDerived(subtree) {
+    const pruned = new Set();
+    return subtree.filter((node, index) => {
+        // collectSubtree lists parents before children, so a pruned parent prunes its subtree.
+        if (index > 0 && (isDerivedNode(node) || (node.parentId && pruned.has(node.parentId)))) {
+            pruned.add(node.id);
+            return false;
+        }
+        return true;
+    });
+}
+/** Host references inside the copied set point at the copies, as the editor's paste remaps them. */
+function remapHostRefs(cloned, idMap) {
+    for (const node of cloned) {
+        const record = node;
+        for (const field of ['wallId', 'roofSegmentId']) {
+            const value = record[field];
+            if (typeof value === 'string') {
+                const fresh = idMap.get(value);
+                if (fresh)
+                    record[field] = fresh;
+            }
+        }
+    }
+}
+/** A stair copied to another floor climbs from that floor, as the editor's paste re-aims it. */
+function reaimStairs(nodes, cloned, targetLevelId) {
+    if (!targetLevelId)
+        return;
+    const target = nodes[targetLevelId];
+    if (target?.type !== 'level')
+        return;
+    const next = levelsOf(nodes).find((level) => level.parentId === target.parentId && level.level > target.level);
+    for (const node of cloned) {
+        if (node.type !== 'stair')
+            continue;
+        const stair = node;
+        stair.fromLevelId = targetLevelId;
+        stair.toLevelId = next?.id ?? null;
+    }
+}
+/**
+ * `duplicate_node`: the editor's Duplicate — the same clone its duplicate-without-move path
+ * makes (`collectSubtree` + `cloneNodesInto`), its clipboard's root rules, and its paste's
+ * host-reference remap, with the offset seated by the same plan as `move_node`.
+ */
+export const duplicateNode = (nodes, input) => {
+    const targetLevel = input.targetLevelId ? nodes[input.targetLevelId] : undefined;
+    if (input.targetLevelId && targetLevel?.type !== 'level')
+        refuse('level_not_found', `Level not found: ${input.targetLevelId}.`, {
+            levelId: input.targetLevelId,
+        });
+    const requested = [...new Set(input.ids)];
+    for (const id of requested) {
+        if (!nodes[id])
+            refuse('node_not_found', `Node not found: ${id}.`, { id });
+    }
+    const roots = [];
+    const skippedIds = [];
+    for (const id of requested) {
+        const node = nodes[id];
+        const parent = requireCopyableRoot(nodes, node);
+        if (isDescendantOf(nodes, id, new Set(requested.filter((other) => other !== id)))) {
+            skippedIds.push(id);
+            continue;
+        }
+        if (targetLevel && parent?.type !== 'level' && levelIdOf(nodes, id) !== targetLevel.id)
+            refuse('hosted_root_level', `${node.type} ${id} is hosted on ${parent?.type} ${parent?.id} on another level; copy its host, or copy it without targetLevelId.`, { id, hostId: parent?.id ?? null, targetLevelId: targetLevel.id });
+        roots.push(node);
+    }
+    const clonedAll = [];
+    const idMap = new Map();
+    const copies = [];
+    for (const root of roots) {
+        const subtree = collectSubtree(nodes, root.id);
+        if (!subtree)
+            refuse('node_not_found', `Node not found: ${root.id}.`, { id: root.id });
+        const members = withoutDerived([subtree.root, ...subtree.descendants]);
+        const parentId = (targetLevel && nodes[root.parentId ?? '']?.type === 'level' ? targetLevel.id : root.parentId);
+        const cloned = cloneNodesInto(members, { rootId: root.id, parentId });
+        for (const [source, fresh] of cloned.idMap)
+            idMap.set(source, fresh);
+        clonedAll.push(...cloned.nodes);
+        copies.push({
+            sourceId: root.id,
+            copyId: cloned.rootId,
+            type: root.type,
+            descendantCount: cloned.nodes.length - 1,
+        });
+    }
+    remapHostRefs(clonedAll, idMap);
+    reaimStairs(nodes, clonedAll, input.targetLevelId);
+    const offset = input.offset ?? [0, 0];
+    if (offset[0] || offset[1]) {
+        const withClones = { ...nodes };
+        for (const node of clonedAll)
+            withClones[node.id] = node;
+        for (const copy of copies) {
+            const clone = withClones[copy.copyId];
+            const plan = planNodeMove(withClones, clone, { by: offset }, { checkOverlap: false });
+            Object.assign(clone, plan.data);
+        }
+    }
+    const changes = {
+        create: clonedAll.map((node) => ({ node, parentId: node.parentId ?? undefined })),
+    };
+    return {
+        result: {
+            ok: true,
+            copies,
+            totalCreated: clonedAll.length,
+            skippedIds,
+            message: `Duplicated ${copies.length} node${copies.length === 1 ? '' : 's'} (${clonedAll.length} created)`,
+            achieved: achievedChanges(nodes, changes),
+        },
+        changes,
+    };
+};

package/dist/agent-operations/find-by-type.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"find-by-type.d.ts","sourceRoot":"","sources":["../../src/agent-operations/find-by-type.ts"],"names":[],"mappings":"AAkBA,OAAO,KAAK,EAAgB,cAAc,EAAc,MAAM,SAAS,CAAA;AAIvE,MAAM,MAAM,eAAe,GAAG;IAC5B,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,KAAK,CAAC,EAAE,MAAM,CAAA;CACf,CAAA;AAsPD;;;;;GAKG;AACH,eAAO,MAAM,UAAU,EAAE,cAAc,CAAC,eAAe,CAiGtD,CAAA"}
+{"version":3,"file":"find-by-type.d.ts","sourceRoot":"","sources":["../../src/agent-operations/find-by-type.ts"],"names":[],"mappings":"AAkBA,OAAO,KAAK,EAAgB,cAAc,EAAc,MAAM,SAAS,CAAA;AAIvE,MAAM,MAAM,eAAe,GAAG;IAC5B,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,KAAK,CAAC,EAAE,MAAM,CAAA;CACf,CAAA;AAuPD;;;;;GAKG;AACH,eAAO,MAAM,UAAU,EAAE,cAAc,CAAC,eAAe,CAmGtD,CAAA"}

package/dist/agent-operations/find-by-type.js

@@ -211,6 +211,7 @@ function namesAnything(nodes, names, { nodeSchema }) {
     const known = (name) => CORE_KINDS.has(name) || registered.includes(name) || Boolean(nodeSchema?.(name));
     if ([...names].some(known))
         return true;
+    // biome-ignore lint/plugin: a type word may name any node's kind, category or part
     return Object.values(nodes).some((node) => names.has(kindOf(node)) ||
         (node.type === 'item' &&
             [...names].some((name) => matchesWord(node.asset?.category, name))) ||
@@ -240,6 +241,7 @@ export const findByType = (nodes, input, context) => {
         ? undefined
         : new Set([kind, kind.includes(':') ? kind : kind.replace(/s$/, '')]);
     const results = [];
+    // biome-ignore lint/plugin: any node, or any typed part of an authored object, may match
     for (const node of Object.values(nodes)) {
         if (parentId && node.parentId !== parentId)
             continue;
@@ -294,6 +296,7 @@ export const findByType = (nodes, input, context) => {
             results.push(...(inZone ? inZone(node, level, matched) : matched).map(({ found }) => found));
     }
     if (names && results.length === 0 && !namesAnything(nodes, names, context)) {
+        // biome-ignore lint/plugin: the refusal lists every kind the scene holds
         const kinds = [...new Set(Object.values(nodes).map(kindOf))].sort();
         refuse('unknown_type', `"${kind}" names nothing find_by_type reads: no node kind (core's or a plugin's this host knows), and no item category or part type in this scene. Kinds in this scene: ${kinds.join(', ')}.`, { type: kind, kinds });
     }

package/dist/agent-operations/furnish-room.d.ts

@@ -9,6 +9,8 @@ type FurnishRoomInput = LevelTargetInput & {
     roomType: RoomType;
     doorWallIndex?: number;
 };
+/** Every catalog id a room type's set may take, whatever the room's size: what a host reads first. */
+export declare const FURNISH_ROOM_ASSETS: Readonly<Record<RoomType, readonly string[]>>;
 export declare const WALL_GAP = 0.1;
 /** The room asked for: a zone's level and outline, or a polygon on the level named. */
 export declare function roomToFurnish(nodes: SceneNodes, input: LevelTargetInput & Pick<FurnishRoomInput, 'zoneId' | 'polygon'>, context: AgentContext): {

package/dist/agent-operations/furnish-room.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"furnish-room.d.ts","sourceRoot":"","sources":["../../src/agent-operations/furnish-room.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AAsBvE,OAAO,EAAE,KAAK,gBAAgB,EAAe,MAAM,gBAAgB,CAAA;AACnE,OAAO,EAA8B,KAAK,IAAI,EAAE,MAAM,iBAAiB,CAAA;AAEvE,OAAO,KAAK,EAAE,YAAY,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAEvE,KAAK,QAAQ,GAAG,CAAC,OAAO,oBAAoB,CAAC,CAAC,MAAM,CAAC,CAAA;AAErD,KAAK,gBAAgB,GAAG,gBAAgB,GAAG;IACzC,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,OAAO,CAAC,EAAE,MAAM,EAAE,EAAE,CAAA;IACpB,QAAQ,EAAE,QAAQ,CAAA;IAClB,aAAa,CAAC,EAAE,MAAM,CAAA;CACvB,CAAA;AAKD,eAAO,MAAM,QAAQ,MAAM,CAAA;AAQ3B,uFAAuF;AACvF,wBAAgB,aAAa,CAC3B,KAAK,EAAE,UAAU,EACjB,KAAK,EAAE,gBAAgB,GAAG,IAAI,CAAC,gBAAgB,EAAE,QAAQ,GAAG,SAAS,CAAC,EACtE,OAAO,EAAE,YAAY;;aAkBwB,IAAI,EAAE;EAKpD;AA2BD,sGAAsG;AACtG,wBAAgB,SAAS,CAAC,OAAO,EAAE,IAAI,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI;;;;;;;;;;;;EAWrE;AA0KD;;;;GAIG;AACH,eAAO,MAAM,WAAW,EAAE,cAAc,CAAC,gBAAgB,CAsGxD,CAAA"}
+{"version":3,"file":"furnish-room.d.ts","sourceRoot":"","sources":["../../src/agent-operations/furnish-room.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AAsBvE,OAAO,EAAE,KAAK,gBAAgB,EAAe,MAAM,gBAAgB,CAAA;AACnE,OAAO,EAA8B,KAAK,IAAI,EAAE,MAAM,iBAAiB,CAAA;AAEvE,OAAO,KAAK,EAAE,YAAY,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAEvE,KAAK,QAAQ,GAAG,CAAC,OAAO,oBAAoB,CAAC,CAAC,MAAM,CAAC,CAAA;AAErD,KAAK,gBAAgB,GAAG,gBAAgB,GAAG;IACzC,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,OAAO,CAAC,EAAE,MAAM,EAAE,EAAE,CAAA;IACpB,QAAQ,EAAE,QAAQ,CAAA;IAClB,aAAa,CAAC,EAAE,MAAM,CAAA;CACvB,CAAA;AAED,sGAAsG;AACtG,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,MAAM,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAC,CAU7E,CAAA;AAKD,eAAO,MAAM,QAAQ,MAAM,CAAA;AAQ3B,uFAAuF;AACvF,wBAAgB,aAAa,CAC3B,KAAK,EAAE,UAAU,EACjB,KAAK,EAAE,gBAAgB,GAAG,IAAI,CAAC,gBAAgB,EAAE,QAAQ,GAAG,SAAS,CAAC,EACtE,OAAO,EAAE,YAAY;;aAkBwB,IAAI,EAAE;EAKpD;AA0BD,sGAAsG;AACtG,wBAAgB,SAAS,CAAC,OAAO,EAAE,IAAI,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI;;;;;;;;;;;;EAWrE;AA0KD;;;;GAIG;AACH,eAAO,MAAM,WAAW,EAAE,cAAc,CAAC,gBAAgB,CAuGxD,CAAA"}

package/dist/agent-operations/furnish-room.js

@@ -7,7 +7,19 @@ import { furnitureKind } from './furniture-kind.js';
 import { collectOccupiedFootprints, findValidPlacement, lateralSteps, MID_ROOM_DISTANCE_M, PLACEMENT_INSETS_M, wallFacesOn, } from './layout-clearance.js';
 import { targetLevel } from './level-target.js';
 import { polygonArea, polygonBounds } from './plan-geometry.js';
-import { levelIdOf, levelRole } from './scene-queries.js';
+import { levelIdOf, levelRole, queryNodes } from './scene-queries.js';
+/** Every catalog id a room type's set may take, whatever the room's size: what a host reads first. */
+export const FURNISH_ROOM_ASSETS = {
+    bedroom: ['double-bed', 'single-bed', 'bedside-table', 'dresser', 'closet'],
+    kitchen: ['kitchen', 'kitchen-counter', 'stove', 'fridge'],
+    bathroom: ['toilet', 'bathroom-sink', 'bathtub', 'shower-square'],
+    living: ['sofa', 'coffee-table', 'livingroom-chair', 'tv-stand'],
+    dining: ['dining-table', 'dining-chair'],
+    hallway: ['coat-rack'],
+    entry: ['coat-rack'],
+    laundry: ['washing-machine', 'drying-rack'],
+    storage: ['closet'],
+};
 // A door belongs to a room edge when it stands this close to the edge's line, within its span.
 const DOOR_EDGE_TOLERANCE = 0.25;
 // Clearance between a piece's back and the wall's centreline: half a wall and a hand's width.
@@ -36,9 +48,7 @@ export function roomToFurnish(nodes, input, context) {
 /** The doors of the level that stand on an edge of the room, by where they stand. */
 function doorsOfRoom(nodes, levelId, polygon) {
     const found = [];
-    for (const wall of Object.values(nodes)) {
-        if (wall.type !== 'wall' || wall.parentId !== levelId)
-            continue;
+    for (const wall of queryNodes(nodes, { type: 'wall', parentId: levelId })) {
         const length = Math.hypot(wall.end[0] - wall.start[0], wall.end[1] - wall.start[1]);
         if (length < 1e-9)
             continue;
@@ -222,6 +232,7 @@ export const furnishRoom = (nodes, input, context) => {
         refuse('edge_out_of_range', `The room has ${polygon.length} edges (0–${polygon.length - 1}); there is no edge ${input.doorWallIndex}.`);
     const doors = doorsOfRoom(nodes, levelId, polygon);
     const doorWall = input.doorWallIndex ?? doors[0]?.edge ?? 0;
+    // biome-ignore lint/plugin: door keep-outs and occupied footprints resolve each item through its parents
     const all = Object.values(nodes);
     const doorKeepouts = collectDoorKeepouts(all, { levelId });
     const keepouts = doorKeepouts.map((door) => door.aabb);

package/dist/agent-operations/furniture-kind.d.ts

@@ -5,14 +5,41 @@ type Named = {
     id: string;
     name?: string | undefined;
 };
-/** Only a named, flat floor covering is nonblocking, never an arbitrary short solid or low top surface. */
+/**
+ * A car, a ute: filed as a vehicle, or named as one when nothing is filed. What stands in a garage
+ * to be driven out of it, so the garage door's opening is its way and not a thing it obstructs.
+ */
+export declare function isVehicle(item: ItemNode): boolean;
+/**
+ * Only a flat floor covering is nonblocking, never an arbitrary short solid or low top surface. It is
+ * a rug by what it is filed under (its category: "rug", "rugs", "tapis"), else by what it is called
+ * in English or French, and in both cases it must lie flat on the floor.
+ */
 export declare function isFloorUnderlay(item: ItemNode): boolean;
+/**
+ * Wall panelling and trim are the wall's own surface: an item filed under them is read by its strips
+ * (its box is the room's) in a collision and in a door's clearance. A piece beside it keeps the gap
+ * it keeps from anything else.
+ */
+export declare function isWallDressing(item: ItemNode): boolean;
+/**
+ * Whether two items are designed to stand together, a few centimetres apart: a nightstand beside a
+ * bed, a chair or stool at a desk or table, a sofa beside a side table. Such a pair being close is
+ * the design, not a finding; two of them overlapping is still one. Read from what each is filed
+ * under (its category), by its words only where the category says nothing.
+ */
+export declare function designedTogether(a: ItemNode, b: ItemNode): boolean;
 /**
  * Wall-bound pieces (a fridge, a counter, a bed, a sofa) stand against a wall and never in the
  * middle of a room; free-standing ones (a dining table, a rug, a plant) may take the middle; a chair
  * is placed around its table. A name the table does not know is free-standing.
  */
 export declare function furnitureKind(asset: Named): FurnitureKind;
+/**
+ * The word that makes a piece wall-bound ("fridge", "counter"), for a piece that is judged to stand
+ * against a wall; null for every other piece, a sofa or stools that float by design included.
+ */
+export declare function wallBoundWord(asset: Named): string | null;
 /**
  * What a piece faces when it does not stand against a wall, as a pattern for the name of the item
  * it belongs with: the coffee table and the TV face the sofa, a chair faces its table.

package/dist/agent-operations/furniture-kind.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"furniture-kind.d.ts","sourceRoot":"","sources":["../../src/agent-operations/furniture-kind.ts"],"names":[],"mappings":"AAAA,OAAO,EAAuB,KAAK,QAAQ,EAAuC,MAAM,WAAW,CAAA;AAEnG,sFAAsF;AACtF,MAAM,MAAM,aAAa,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,CAAA;AAErD,KAAK,KAAK,GAAG;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;CAAE,CAAA;AAetD,2GAA2G;AAC3G,wBAAgB,eAAe,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CA+BvD;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,KAAK,GAAG,aAAa,CAQzD;AAED;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM,GAAG,IAAI,CAMpD"}
+{"version":3,"file":"furniture-kind.d.ts","sourceRoot":"","sources":["../../src/agent-operations/furniture-kind.ts"],"names":[],"mappings":"AACA,OAAO,EAAuB,KAAK,QAAQ,EAAuC,MAAM,WAAW,CAAA;AAEnG,sFAAsF;AACtF,MAAM,MAAM,aAAa,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,CAAA;AAErD,KAAK,KAAK,GAAG;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;CAAE,CAAA;AA0BtD;;;GAGG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAIjD;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAgCvD;AAMD;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAEtD;AAsDD;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,QAAQ,GAAG,OAAO,CAMlE;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,KAAK,GAAG,aAAa,CAQzD;AAKD;;;GAGG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM,GAAG,IAAI,CAIzD;AAED;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM,GAAG,IAAI,CAMpD"}