@pascal-app/mcp 1.0.0-beta.3 → 1.0.0-beta.5

package/dist/tools/door-clearance.d.ts

@@ -0,0 +1,119 @@
+/**
+ * Door access keep-outs for MCP layout tools.
+ *
+ * Furniture that overlaps a door clear zone is reported as blocking the door.
+ * Used by furnish_room (skip placements) and verify_scene (layout issues).
+ *
+ * See docs/layout-clearance-error-log.md for pitfalls (levels, gap sign, scale).
+ */
+import type { AnyNode } from '@pascal-app/core/schema';
+import { type Vec2 } from './geometry';
+export type PlanAabb = {
+    minX: number;
+    maxX: number;
+    minZ: number;
+    maxZ: number;
+};
+export type DoorKeepout = {
+    doorId: string;
+    wallId: string;
+    levelId: string | null;
+    /** World-space AABB on both sides of the wall opening. */
+    aabb: PlanAabb;
+    width: number;
+    localX: number;
+};
+/**
+ * Wall shape these helpers accept. Deliberately structural rather than
+ * `Pick<WallNode, …>`: `keepoutForPolygonEdge` feeds in synthetic `edge-N`
+ * segments for room edges that do not have a wall node yet, so the id cannot
+ * be the branded `wall_${string}`.
+ */
+export type WallSegmentLike = {
+    id: string;
+    start: Vec2;
+    end: Vec2;
+};
+/**
+ * Door shape these helpers accept — a real `DoorNode` or a planned opening.
+ * `Pick<AnyNode, 'position' | 'width'>` does not work: those keys exist on
+ * only some members of the `AnyNode` union, so `Pick` rejects them.
+ */
+export type DoorOpeningLike = {
+    id: string;
+    position?: readonly number[];
+    width?: number;
+};
+/** Plan depth (m) cleared on each side of the wall face through the opening. */
+export declare const DEFAULT_DOOR_CLEAR_DEPTH = 0.65;
+/** Extra half-width (m) beyond the door leaf along the wall. */
+export declare const DEFAULT_DOOR_SIDE_PAD = 0.05;
+/**
+ * True when A and B come closer than `gap` meters (including penetration).
+ * `gap` is the **minimum free space required** between boxes:
+ * expand each box by gap/2, then test intersection.
+ */
+export declare function aabbsOverlap(a: PlanAabb, b: PlanAabb, gap?: number): boolean;
+/**
+ * Walk parentId chain to the enclosing level id (pure; no bridge required).
+ */
+export declare function resolveNodeLevelId(nodeId: string, byId: Map<string, AnyNode>): string | null;
+/**
+ * Axis-aligned item footprint in plan (x/z), rotation-aware.
+ * Prefer scaled dimensions when the node is available.
+ */
+export declare function itemPlanAabb(position: [number, number, number] | number[], dimensions: [number, number, number] | number[] | undefined, rotationYRad?: number): PlanAabb;
+/** Footprint for a scene item node (uses getScaledDimensions). */
+export declare function itemNodePlanAabb(node: AnyNode): PlanAabb | null;
+/**
+ * Build a rectangular keep-out around a wall door, extruded perpendicular to the wall
+ * on both faces so either swing side is protected.
+ */
+export declare function doorKeepoutFromWall(wall: WallSegmentLike, door: DoorOpeningLike, options?: {
+    clearDepth?: number;
+    sidePad?: number;
+    levelId?: string | null;
+}): DoorKeepout | null;
+export declare function collectDoorKeepouts(nodes: Iterable<AnyNode>, options?: {
+    clearDepth?: number;
+    sidePad?: number;
+    levelId?: string;
+}): DoorKeepout[];
+export declare function itemBlocksDoorKeepout(itemAabb: PlanAabb, keepout: DoorKeepout): boolean;
+export type BlockedDoorIssue = {
+    doorId: string;
+    wallId: string;
+    itemId: string;
+    levelId?: string | null;
+    itemName?: string;
+    message: string;
+};
+export declare function findBlockedDoors(args: {
+    nodes: Iterable<AnyNode>;
+    clearDepth?: number;
+    sidePad?: number;
+    /** When set, only doors and items on this level are considered. */
+    levelId?: string;
+}): BlockedDoorIssue[];
+/**
+ * Synthetic keep-outs for a room polygon edge that will host a door (before doors exist).
+ * Used by furnish_room when doorWallIndex is known.
+ */
+export declare function keepoutForPolygonEdge(polygon: Vec2[], edgeIndex: number, options?: {
+    t?: number;
+    width?: number;
+    clearDepth?: number;
+    sidePad?: number;
+}): PlanAabb | null;
+/**
+ * Whether an existing keep-out already covers this room-edge planned zone
+ * (so we do not double-count a real door on that edge).
+ *
+ * Requires the planned keep-out **center** to lie inside the existing keep-out,
+ * and the existing box to cover a large fraction of the planned area.
+ * Plain AABB overlap is not enough (nearby hallway doors must not suppress
+ * this room's entrance keep-out).
+ */
+export declare function keepoutCoversPlanned(existing: PlanAabb, planned: PlanAabb): boolean;
+export declare function aabbFromPlan(a: PlanAabb): PlanAabb;
+//# sourceMappingURL=door-clearance.d.ts.map

package/dist/tools/door-clearance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"door-clearance.d.ts","sourceRoot":"","sources":["../../src/tools/door-clearance.ts"],"names":[],"mappings":"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"}

package/dist/tools/door-clearance.js

@@ -0,0 +1,240 @@
+/**
+ * Door access keep-outs for MCP layout tools.
+ *
+ * Furniture that overlaps a door clear zone is reported as blocking the door.
+ * Used by furnish_room (skip placements) and verify_scene (layout issues).
+ *
+ * See docs/layout-clearance-error-log.md for pitfalls (levels, gap sign, scale).
+ */
+import { getScaledDimensions } from '@pascal-app/core/schema';
+import { wallLength } from './geometry';
+/** Plan depth (m) cleared on each side of the wall face through the opening. */
+export const DEFAULT_DOOR_CLEAR_DEPTH = 0.65;
+/** Extra half-width (m) beyond the door leaf along the wall. */
+export const DEFAULT_DOOR_SIDE_PAD = 0.05;
+/**
+ * True when A and B come closer than `gap` meters (including penetration).
+ * `gap` is the **minimum free space required** between boxes:
+ * expand each box by gap/2, then test intersection.
+ */
+export function aabbsOverlap(a, b, gap = 0) {
+    const g = gap;
+    return a.maxX + g > b.minX && a.minX - g < b.maxX && a.maxZ + g > b.minZ && a.minZ - g < b.maxZ;
+}
+/**
+ * Walk parentId chain to the enclosing level id (pure; no bridge required).
+ */
+export function resolveNodeLevelId(nodeId, byId) {
+    let current = byId.get(nodeId);
+    const seen = new Set();
+    while (current) {
+        if (seen.has(current.id))
+            return null;
+        seen.add(current.id);
+        if (current.type === 'level')
+            return current.id;
+        const parentId = current.parentId;
+        if (!parentId)
+            return null;
+        current = byId.get(parentId);
+    }
+    return null;
+}
+/**
+ * Axis-aligned item footprint in plan (x/z), rotation-aware.
+ * Prefer scaled dimensions when the node is available.
+ */
+export function itemPlanAabb(position, dimensions, rotationYRad = 0) {
+    const x = position[0] ?? 0;
+    const z = position[2] ?? 0;
+    const [w = 1, , d = 1] = dimensions ?? [1, 1, 1];
+    const cos = Math.abs(Math.cos(rotationYRad));
+    const sin = Math.abs(Math.sin(rotationYRad));
+    const halfW = (w * cos + d * sin) / 2;
+    const halfD = (w * sin + d * cos) / 2;
+    return {
+        minX: x - halfW,
+        maxX: x + halfW,
+        minZ: z - halfD,
+        maxZ: z + halfD,
+    };
+}
+/** Footprint for a scene item node (uses getScaledDimensions). */
+export function itemNodePlanAabb(node) {
+    if (node.type !== 'item')
+        return null;
+    const [w, , d] = getScaledDimensions(node);
+    const rotY = Array.isArray(node.rotation) ? (node.rotation[1] ?? 0) : 0;
+    return itemPlanAabb(node.position, [w, 0, d], rotY);
+}
+/**
+ * Build a rectangular keep-out around a wall door, extruded perpendicular to the wall
+ * on both faces so either swing side is protected.
+ */
+export function doorKeepoutFromWall(wall, door, options) {
+    const clearDepth = options?.clearDepth ?? DEFAULT_DOOR_CLEAR_DEPTH;
+    const sidePad = options?.sidePad ?? DEFAULT_DOOR_SIDE_PAD;
+    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 [sx, sz] = wall.start;
+    const [ex, ez] = wall.end;
+    const dx = (ex - sx) / length;
+    const dz = (ez - sz) / length;
+    const nx = -dz;
+    const nz = dx;
+    const half = width / 2 + sidePad;
+    const corners = [];
+    for (const along of [localX - half, localX + half]) {
+        const cx = sx + dx * along;
+        const cz = sz + dz * along;
+        for (const side of [-clearDepth, clearDepth]) {
+            corners.push([cx + nx * side, cz + nz * side]);
+        }
+    }
+    const xs = corners.map((c) => c[0]);
+    const zs = corners.map((c) => c[1]);
+    return {
+        doorId: door.id,
+        wallId: wall.id,
+        levelId: options?.levelId ?? null,
+        width,
+        localX,
+        aabb: {
+            minX: Math.min(...xs),
+            maxX: Math.max(...xs),
+            minZ: Math.min(...zs),
+            maxZ: Math.max(...zs),
+        },
+    };
+}
+export function collectDoorKeepouts(nodes, options) {
+    const byId = new Map();
+    for (const node of nodes)
+        byId.set(node.id, node);
+    const keepouts = [];
+    for (const node of byId.values()) {
+        if (node.type !== 'door')
+            continue;
+        const wallId = node.wallId ?? node.parentId;
+        if (!wallId)
+            continue;
+        const wall = byId.get(wallId);
+        if (wall?.type !== 'wall')
+            continue;
+        const levelId = resolveNodeLevelId(wall.id, byId) ?? resolveNodeLevelId(node.id, byId);
+        if (options?.levelId && levelId !== options.levelId)
+            continue;
+        const keepout = doorKeepoutFromWall(wall, node, {
+            clearDepth: options?.clearDepth,
+            sidePad: options?.sidePad,
+            levelId,
+        });
+        if (keepout)
+            keepouts.push(keepout);
+    }
+    return keepouts;
+}
+export function itemBlocksDoorKeepout(itemAabb, keepout) {
+    return aabbsOverlap(itemAabb, keepout.aabb, 0.02);
+}
+export function findBlockedDoors(args) {
+    const nodes = [...args.nodes];
+    const byId = new Map(nodes.map((n) => [n.id, n]));
+    const keepouts = collectDoorKeepouts(nodes, {
+        clearDepth: args.clearDepth,
+        sidePad: args.sidePad,
+        levelId: args.levelId,
+    });
+    if (keepouts.length === 0)
+        return [];
+    const issues = [];
+    for (const node of nodes) {
+        if (node.type !== 'item')
+            continue;
+        const itemLevel = resolveNodeLevelId(node.id, byId);
+        if (args.levelId && itemLevel !== args.levelId)
+            continue;
+        const aabb = itemNodePlanAabb(node);
+        if (!aabb)
+            continue;
+        for (const keepout of keepouts) {
+            // Same-level only (multi-story safety).
+            if (keepout.levelId && itemLevel && keepout.levelId !== itemLevel)
+                continue;
+            if (args.levelId && keepout.levelId && keepout.levelId !== args.levelId)
+                continue;
+            if (!itemBlocksDoorKeepout(aabb, keepout))
+                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})`,
+            });
+        }
+    }
+    return issues;
+}
+/**
+ * Synthetic keep-outs for a room polygon edge that will host a door (before doors exist).
+ * Used by furnish_room when doorWallIndex is known.
+ */
+export function keepoutForPolygonEdge(polygon, edgeIndex, options) {
+    if (polygon.length < 3)
+        return null;
+    const i = ((edgeIndex % polygon.length) + polygon.length) % polygon.length;
+    const start = polygon[i];
+    const end = polygon[(i + 1) % polygon.length];
+    const wall = {
+        id: `edge-${i}`,
+        start,
+        end,
+    };
+    const length = wallLength(wall);
+    if (length <= 1e-6)
+        return null;
+    const width = options?.width ?? 0.9;
+    const t = options?.t ?? 0.5;
+    const localX = Math.min(Math.max(t * length, width / 2), length - width / 2);
+    const keepout = doorKeepoutFromWall(wall, {
+        id: `planned-door-${i}`,
+        position: [localX, 1.05, 0],
+        width,
+    }, { clearDepth: options?.clearDepth, sidePad: options?.sidePad });
+    return keepout?.aabb ?? null;
+}
+/**
+ * Whether an existing keep-out already covers this room-edge planned zone
+ * (so we do not double-count a real door on that edge).
+ *
+ * Requires the planned keep-out **center** to lie inside the existing keep-out,
+ * and the existing box to cover a large fraction of the planned area.
+ * Plain AABB overlap is not enough (nearby hallway doors must not suppress
+ * this room's entrance keep-out).
+ */
+export function keepoutCoversPlanned(existing, planned) {
+    const cx = (planned.minX + planned.maxX) / 2;
+    const cz = (planned.minZ + planned.maxZ) / 2;
+    const centerInside = cx >= existing.minX && cx <= existing.maxX && cz >= existing.minZ && cz <= existing.maxZ;
+    if (!centerInside)
+        return false;
+    // Intersection area / planned area must be substantial (same opening, not a glancing touch).
+    const ix0 = Math.max(existing.minX, planned.minX);
+    const ix1 = Math.min(existing.maxX, planned.maxX);
+    const iz0 = Math.max(existing.minZ, planned.minZ);
+    const iz1 = Math.min(existing.maxZ, planned.maxZ);
+    if (ix1 <= ix0 || iz1 <= iz0)
+        return false;
+    const inter = (ix1 - ix0) * (iz1 - iz0);
+    const plannedArea = Math.max(1e-9, (planned.maxX - planned.minX) * (planned.maxZ - planned.minZ));
+    return inter / plannedArea >= 0.5;
+}
+export function aabbFromPlan(a) {
+    return a;
+}

package/dist/tools/layout-clearance.d.ts

@@ -0,0 +1,103 @@
+/**
+ * Shared plan-layout clearance for MCP tools.
+ *
+ * - Door keep-outs (level-scoped)
+ * - Item–item AABB overlap (rotation + scale aware)
+ * - Placement candidate search when primary pose is blocked
+ *
+ * See docs/layout-clearance-error-log.md for regression checklist.
+ */
+import type { AnyNode } from '@pascal-app/core/schema';
+import { type PlanAabb } from './door-clearance';
+export { aabbsOverlap, collectDoorKeepouts, findBlockedDoors, itemNodePlanAabb, itemPlanAabb, type PlanAabb, resolveNodeLevelId, } from './door-clearance';
+/** Minimum free space (m) required between item footprints. */
+export declare const DEFAULT_ITEM_GAP = 0.08;
+export type OccupiedFootprint = {
+    id: string;
+    name?: string;
+    levelId?: string | null;
+    aabb: PlanAabb;
+};
+export type ItemCollision = {
+    aId: string;
+    bId: string;
+    aName?: string;
+    bName?: string;
+    levelId?: string | null;
+    kind: 'item-aabb';
+    message: string;
+};
+export declare function nodeItemAabb(node: AnyNode): PlanAabb | null;
+export declare function collectOccupiedFootprints(nodes: Iterable<AnyNode>, options?: {
+    levelId?: string;
+    excludeIds?: Set<string>;
+    floorOnly?: boolean;
+}): OccupiedFootprint[];
+export declare function findItemItemCollisions(args: {
+    nodes: Iterable<AnyNode>;
+    levelId?: string;
+    gap?: number;
+}): ItemCollision[];
+export type PlacementCandidate = {
+    x: number;
+    z: number;
+    rotationDeg: number;
+};
+export type PlacementRejectReason = 'outside_bounds' | 'blocks_door_clearance' | 'overlaps_item' | 'ok';
+export declare function classifyPlacement(args: {
+    aabb: PlanAabb;
+    doorKeepouts: PlanAabb[];
+    occupied: PlanAabb[];
+    roomBounds?: {
+        minX: number;
+        maxX: number;
+        minZ: number;
+        maxZ: number;
+    };
+    padding?: number;
+    itemGap?: number;
+    doorGap?: number;
+}): PlacementRejectReason;
+export declare function generatePlacementCandidates(primary: PlacementCandidate, options?: {
+    lateralsM?: number[];
+    insetsM?: number[];
+    inward?: {
+        x: number;
+        z: number;
+    };
+    along?: {
+        x: number;
+        z: number;
+    };
+}): PlacementCandidate[];
+export declare function findValidPlacement(args: {
+    primary: PlacementCandidate;
+    dimensions: [number, number, number] | number[] | undefined;
+    doorKeepouts: PlanAabb[];
+    occupied: PlanAabb[];
+    roomBounds?: {
+        minX: number;
+        maxX: number;
+        minZ: number;
+        maxZ: number;
+    };
+    along?: {
+        x: number;
+        z: number;
+    };
+    inward?: {
+        x: number;
+        z: number;
+    };
+}): {
+    candidate: PlacementCandidate;
+    reason: PlacementRejectReason;
+} | {
+    candidate: null;
+    reason: PlacementRejectReason;
+};
+/**
+ * Collect layout issues, scoped per level so stacked floors do not false-positive.
+ */
+export declare function layoutIssuesFromScene(nodes: Iterable<AnyNode>): string[];
+//# sourceMappingURL=layout-clearance.d.ts.map

package/dist/tools/layout-clearance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"layout-clearance.d.ts","sourceRoot":"","sources":["../../src/tools/layout-clearance.ts"],"names":[],"mappings":"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"}

package/dist/tools/layout-clearance.js

@@ -0,0 +1,186 @@
+/**
+ * Shared plan-layout clearance for MCP tools.
+ *
+ * - Door keep-outs (level-scoped)
+ * - Item–item AABB overlap (rotation + scale aware)
+ * - Placement candidate search when primary pose is blocked
+ *
+ * See docs/layout-clearance-error-log.md for regression checklist.
+ */
+import { aabbsOverlap, findBlockedDoors, itemNodePlanAabb, itemPlanAabb, resolveNodeLevelId, } from './door-clearance';
+export { aabbsOverlap, collectDoorKeepouts, findBlockedDoors, itemNodePlanAabb, itemPlanAabb, resolveNodeLevelId, } from './door-clearance';
+/** Minimum free space (m) required between item footprints. */
+export const DEFAULT_ITEM_GAP = 0.08;
+export function nodeItemAabb(node) {
+    return itemNodePlanAabb(node);
+}
+export function collectOccupiedFootprints(nodes, options) {
+    const list = [...nodes];
+    const byId = new Map(list.map((n) => [n.id, n]));
+    const out = [];
+    for (const node of list) {
+        if (node.type !== 'item')
+            continue;
+        if (options?.excludeIds?.has(node.id))
+            continue;
+        const attach = node.asset?.attachTo;
+        if (options?.floorOnly &&
+            (attach === 'wall' || attach === 'wall-side' || attach === 'ceiling')) {
+            continue;
+        }
+        const levelId = resolveNodeLevelId(node.id, byId);
+        if (options?.levelId && levelId !== options.levelId)
+            continue;
+        // Floor packing: prefer level-parented items (not wall-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);
+        if (!aabb)
+            continue;
+        const name = node.name ?? node.asset?.name;
+        out.push({
+            id: node.id,
+            name: typeof name === 'string' ? name : undefined,
+            levelId,
+            aabb,
+        });
+    }
+    return out;
+}
+export function findItemItemCollisions(args) {
+    const gap = args.gap ?? DEFAULT_ITEM_GAP;
+    const footprints = collectOccupiedFootprints(args.nodes, { levelId: args.levelId });
+    const collisions = [];
+    for (let i = 0; i < footprints.length; i++) {
+        for (let j = i + 1; j < footprints.length; j++) {
+            const a = footprints[i];
+            const b = footprints[j];
+            if (a.levelId && b.levelId && a.levelId !== b.levelId)
+                continue;
+            if (!aabbsOverlap(a.aabb, b.aabb, gap))
+                continue;
+            collisions.push({
+                aId: a.id,
+                bId: b.id,
+                aName: a.name,
+                bName: b.name,
+                levelId: a.levelId ?? b.levelId,
+                kind: 'item-aabb',
+                message: `Items overlap: ${a.name ?? a.id} (${a.id}) and ${b.name ?? b.id} (${b.id})`,
+            });
+        }
+    }
+    return collisions;
+}
+export function classifyPlacement(args) {
+    const padding = args.padding ?? 0.05;
+    const itemGap = args.itemGap ?? DEFAULT_ITEM_GAP;
+    const doorGap = args.doorGap ?? 0.02;
+    if (args.roomBounds) {
+        const b = args.roomBounds;
+        if (args.aabb.minX < b.minX + padding ||
+            args.aabb.maxX > b.maxX - padding ||
+            args.aabb.minZ < b.minZ + padding ||
+            args.aabb.maxZ > b.maxZ - padding) {
+            return 'outside_bounds';
+        }
+    }
+    if (args.doorKeepouts.some((k) => aabbsOverlap(args.aabb, k, doorGap))) {
+        return 'blocks_door_clearance';
+    }
+    if (args.occupied.some((o) => aabbsOverlap(args.aabb, o, itemGap))) {
+        return 'overlaps_item';
+    }
+    return 'ok';
+}
+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 along = options?.along ?? { x: 1, z: 0 };
+    const inward = options?.inward ?? { x: 0, z: 1 };
+    const out = [];
+    const seen = new Set();
+    for (const lat of laterals) {
+        for (const inset of insets) {
+            const x = primary.x + along.x * lat + inward.x * inset;
+            const z = primary.z + along.z * lat + inward.z * inset;
+            const key = `${x.toFixed(3)},${z.toFixed(3)},${primary.rotationDeg}`;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            out.push({ x, z, rotationDeg: primary.rotationDeg });
+        }
+    }
+    return out;
+}
+export function findValidPlacement(args) {
+    const candidates = generatePlacementCandidates(args.primary, {
+        along: args.along,
+        inward: args.inward,
+    });
+    // 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({
+            aabb,
+            doorKeepouts: args.doorKeepouts,
+            occupied: args.occupied,
+            roomBounds: args.roomBounds,
+        });
+        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;
+        }
+    }
+    return { candidate: null, reason: primaryReason ?? bestFailReason };
+}
+/**
+ * Collect layout issues, scoped per level so stacked floors do not false-positive.
+ */
+export function layoutIssuesFromScene(nodes) {
+    const list = [...nodes];
+    const byId = new Map(list.map((n) => [n.id, n]));
+    const levelIds = new Set();
+    for (const n of list) {
+        if (n.type === 'level')
+            levelIds.add(n.id);
+    }
+    // Also collect levels referenced by walls/items (in case filter missed)
+    for (const n of list) {
+        const lid = resolveNodeLevelId(n.id, byId);
+        if (lid)
+            levelIds.add(lid);
+    }
+    const issues = [];
+    const levels = levelIds.size > 0 ? [...levelIds] : [undefined];
+    for (const levelId of levels) {
+        for (const b of findBlockedDoors({ nodes: list, levelId })) {
+            issues.push(b.message);
+        }
+        for (const c of findItemItemCollisions({ nodes: list, levelId })) {
+            issues.push(c.message);
+        }
+    }
+    // Deduplicate (node may appear under multiple walks)
+    return [...new Set(issues)];
+}

package/dist/tools/measure.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"measure.d.ts","sourceRoot":"","sources":["../../src/tools/measure.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAA;AAExE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAIpD,eAAO,MAAM,YAAY;;;CAGxB,CAAA;AAED,eAAO,MAAM,aAAa;;;;CAIzB,CAAA;AAsED,wBAAgB,eAAe,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAmEhF"}
+{"version":3,"file":"measure.d.ts","sourceRoot":"","sources":["../../src/tools/measure.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAA;AAExE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAIpD,eAAO,MAAM,YAAY;;;CAGxB,CAAA;AAED,eAAO,MAAM,aAAa;;;;CAIzB,CAAA;AAsED,wBAAgB,eAAe,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAuEhF"}

package/dist/tools/measure.js

@@ -82,7 +82,7 @@ function shoelaceArea(polygon) {
 export function registerMeasure(server, bridge) {
     server.registerTool('measure', {
         title: 'Measure',
-        description: 'Measure distance (in meters) between two nodes, or the area of a polygon node when fromId === toId.',
+        description: 'Measure distance (in meters) between two nodes, or the net area of a polygon node when fromId === toId.',
         inputSchema: measureInput,
         outputSchema: measureOutput,
     }, async ({ fromId, toId }) => {
@@ -98,7 +98,11 @@ export function registerMeasure(server, bridge) {
         if (fromId === toId) {
             const n = from;
             if (n.type === 'zone' || n.type === 'slab' || n.type === 'ceiling') {
-                const area = shoelaceArea(n.polygon);
+                const holes = n.type === 'zone' ? [] : n.holes;
+                const holeArea = Array.isArray(holes)
+                    ? holes.reduce((sum, hole) => sum + shoelaceArea(hole), 0)
+                    : 0;
+                const area = Math.max(0, shoelaceArea(n.polygon) - holeArea);
                 const payload = {
                     distanceMeters: 0,
                     areaSqMeters: area,