@pascal-app/core 0.8.0 → 0.9.2

package/dist/hooks/spatial-grid/spatial-grid-manager.js

@@ -1,5 +1,10 @@
+import { getRenderableSlabPolygon } from '../../lib/slab-polygon';
+import { nodeRegistry } from '../../registry';
 import { getScaledDimensions, isLowProfileItemSurface } from '../../schema';
 import useScene from '../../store/use-scene';
+import { getWallCurveFrameAt, isCurvedWall } from '../../systems/wall/wall-curve';
+import { DEFAULT_WALL_THICKNESS } from '../../systems/wall/wall-footprint';
+import { getFloorPlacedFootprints } from './floor-placed-elevation';
 import { SpatialGrid } from './spatial-grid';
 import { WallSpatialGrid } from './wall-spatial-grid';
 // ============================================================================
@@ -38,6 +43,24 @@ function getItemFootprint(position, dimensions, rotation, inset = 0) {
         [x + (-halfW * cos - halfD * sin), z + (-halfW * sin + halfD * cos)],
     ];
 }
+/**
+ * Axis-aligned XZ extent of a footprint at `position`, rotated by `yRot`. The
+ * rotated width/depth is the same conservative bound the floor-placement draft
+ * uses, so a draft and an existing node are compared with identical math.
+ */
+function footprintBoundsXZ(position, dimensions, yRot) {
+    const [width, , depth] = dimensions;
+    const cos = Math.abs(Math.cos(yRot));
+    const sin = Math.abs(Math.sin(yRot));
+    const rotatedW = width * cos + depth * sin;
+    const rotatedD = width * sin + depth * cos;
+    return {
+        minX: position[0] - rotatedW / 2,
+        maxX: position[0] + rotatedW / 2,
+        minZ: position[2] - rotatedD / 2,
+        maxZ: position[2] + rotatedD / 2,
+    };
+}
 function getItemLocalBounds(item) {
     const [width, height, depth] = getScaledDimensions(item);
     const minZ = item.asset.attachTo === 'wall-side' ? -depth : -depth / 2;
@@ -97,6 +120,24 @@ function resolveNodeLevelId(node, nodes) {
     }
     return 'default';
 }
+function expandIgnoredNodeIds(ignoreIds, nodes) {
+    const ignored = new Set(ignoreIds ?? []);
+    const queue = [...ignored];
+    while (queue.length > 0) {
+        const id = queue.pop();
+        const node = nodes[id];
+        const children = node?.children;
+        if (!Array.isArray(children))
+            continue;
+        for (const childId of children) {
+            if (typeof childId !== 'string' || ignored.has(childId))
+                continue;
+            ignored.add(childId);
+            queue.push(childId);
+        }
+    }
+    return ignored;
+}
 /**
  * Test if two line segments (a1->a2) and (b1->b2) intersect.
  */
@@ -162,91 +203,399 @@ export function itemOverlapsPolygon(position, dimensions, rotation, polygon, ins
     }
     return false;
 }
+function pointSegmentDistance(px, pz, ax, az, bx, bz) {
+    const dx = bx - ax;
+    const dz = bz - az;
+    const lengthSquared = dx * dx + dz * dz;
+    if (lengthSquared < 1e-18)
+        return Math.hypot(px - ax, pz - az);
+    const t = Math.max(0, Math.min(1, ((px - ax) * dx + (pz - az) * dz) / lengthSquared));
+    return Math.hypot(px - (ax + dx * t), pz - (az + dz * t));
+}
+// Ray-cast pointInPolygon is unreliable for points exactly on the polygon
+// boundary: the answer flips depending on which side of the polygon the edge
+// is on. Interval classification below therefore treats "within this distance
+// of the boundary" as inside explicitly, so walls sitting exactly on a slab
+// edge (the common case — auto-slab polygons derive from wall centerlines)
+// classify identically on every side of the slab.
+const ON_BOUNDARY_EPSILON = 1e-4;
+function pointOnPolygonBoundary(px, pz, polygon) {
+    const n = polygon.length;
+    for (let i = 0; i < n; i++) {
+        const [ax, az] = polygon[i];
+        const [bx, bz] = polygon[(i + 1) % n];
+        if (pointSegmentDistance(px, pz, ax, az, bx, bz) <= ON_BOUNDARY_EPSILON)
+            return true;
+    }
+    return false;
+}
+function mergeIntervals(intervals) {
+    if (intervals.length <= 1)
+        return intervals;
+    const sorted = [...intervals].sort((a, b) => a[0] - b[0]);
+    const merged = [[sorted[0][0], sorted[0][1]]];
+    for (let i = 1; i < sorted.length; i++) {
+        const [intervalStart, intervalEnd] = sorted[i];
+        const last = merged[merged.length - 1];
+        if (intervalStart <= last[1] + 1e-9) {
+            last[1] = Math.max(last[1], intervalEnd);
+        }
+        else {
+            merged.push([intervalStart, intervalEnd]);
+        }
+    }
+    return merged;
+}
+/** Total length of a merged (sorted, disjoint) interval list. */
+function intervalsLength(intervals) {
+    let total = 0;
+    for (const [intervalStart, intervalEnd] of intervals)
+        total += intervalEnd - intervalStart;
+    return total;
+}
+/** `base` minus `cut`. Both inputs may be unsorted; the result is merged. */
+function subtractIntervals(base, cut) {
+    if (base.length === 0 || cut.length === 0)
+        return mergeIntervals(base);
+    const cuts = mergeIntervals(cut);
+    const result = [];
+    for (const [baseStart, baseEnd] of mergeIntervals(base)) {
+        let cursor = baseStart;
+        for (const [cutStart, cutEnd] of cuts) {
+            if (cutEnd <= cursor)
+                continue;
+            if (cutStart >= baseEnd)
+                break;
+            if (cutStart > cursor)
+                result.push([cursor, cutStart]);
+            cursor = cutEnd;
+            if (cursor >= baseEnd)
+                break;
+        }
+        if (cursor < baseEnd)
+            result.push([cursor, baseEnd]);
+    }
+    return result;
+}
 /**
- * Check if wall segment (a) is substantially on polygon edge segment (b).
- * Returns true only if BOTH endpoints of the wall are on or very close to the edge.
- * This prevents walls that just touch one point from being detected.
+ * Sub-intervals of segment (ax,az)→(bx,bz) that lie inside the polygon (and,
+ * when `includeBoundary`, on its boundary), as [t0, t1] fractions of the
+ * segment. The segment is split at every crossing with a polygon edge and
+ * each sub-interval is classified by its midpoint, so no test point ever
+ * sits on a crossing.
  */
-function segmentsCollinearAndOverlap(ax1, az1, ax2, az2, bx1, bz1, bx2, bz2) {
-    const EPSILON = 1e-6;
-    // Cross product to check collinearity
-    const cross1 = (ax2 - ax1) * (bz1 - az1) - (az2 - az1) * (bx1 - ax1);
-    const cross2 = (ax2 - ax1) * (bz2 - az1) - (az2 - az1) * (bx2 - ax1);
-    if (Math.abs(cross1) > EPSILON || Math.abs(cross2) > EPSILON) {
-        return false; // Not collinear
-    }
-    // Check if a point is on segment b
-    const onSegment = (px, pz, qx, qz, rx, rz) => Math.min(px, qx) - EPSILON <= rx &&
-        rx <= Math.max(px, qx) + EPSILON &&
-        Math.min(pz, qz) - EPSILON <= rz &&
-        rz <= Math.max(pz, qz) + EPSILON;
-    // BOTH endpoints of wall (a) must be on edge (b) for substantial overlap
-    const a1OnB = onSegment(bx1, bz1, bx2, bz2, ax1, az1);
-    const a2OnB = onSegment(bx1, bz1, bx2, bz2, ax2, az2);
-    return a1OnB && a2OnB;
+function segmentInsideIntervals(ax, az, bx, bz, polygon, includeBoundary) {
+    const dx = bx - ax;
+    const dz = bz - az;
+    const length = Math.hypot(dx, dz);
+    if (length < 1e-9)
+        return [];
+    const ts = [0, 1];
+    const n = polygon.length;
+    for (let i = 0; i < n; i++) {
+        const [px, pz] = polygon[i];
+        const [qx, qz] = polygon[(i + 1) % n];
+        const ex = qx - px;
+        const ez = qz - pz;
+        const denom = dx * ez - dz * ex;
+        if (Math.abs(denom) < 1e-12)
+            continue; // parallel/collinear — nothing to split at
+        const t = ((px - ax) * ez - (pz - az) * ex) / denom;
+        const s = ((px - ax) * dz - (pz - az) * dx) / denom;
+        if (t > 0 && t < 1 && s >= -1e-9 && s <= 1 + 1e-9)
+            ts.push(t);
+    }
+    ts.sort((a, b) => a - b);
+    const inside = [];
+    for (let i = 1; i < ts.length; i++) {
+        const t0 = ts[i - 1];
+        const t1 = ts[i];
+        if (t1 - t0 < 1e-9)
+            continue;
+        const tm = (t0 + t1) / 2;
+        const mx = ax + dx * tm;
+        const mz = az + dz * tm;
+        const midpointInside = pointOnPolygonBoundary(mx, mz, polygon)
+            ? includeBoundary
+            : pointInPolygon(mx, mz, polygon);
+        if (midpointInside)
+            inside.push([t0, t1]);
+    }
+    return inside;
+}
+function polylineLength(points) {
+    let total = 0;
+    for (let i = 1; i < points.length; i++) {
+        total += Math.hypot(points[i].x - points[i - 1].x, points[i].y - points[i - 1].y);
+    }
+    return total;
 }
 /**
- * Test if a wall segment overlaps with a polygon.
- * A wall is considered to overlap if:
- * - Its midpoint is inside the polygon (wall crosses through)
- * - At least one endpoint is inside (wall partially or fully in slab)
- * - It's collinear with and overlaps a polygon edge (wall on slab boundary)
- *
- * Note: A wall with just one endpoint touching the edge but the rest outside
- * is NOT considered overlapping (adjacent only).
+ * Inside sub-intervals of a polyline against a polygon, in cumulative
+ * arc-length units from the polyline start (merged, disjoint). Boundary
+ * contact counts as inside for slab support (walls sit exactly on slab
+ * edges — see ON_BOUNDARY_EPSILON above); hole callers pass
+ * `includeBoundary: false` so a wall running along a stairwell hole's
+ * rim keeps the rim's support.
  */
-export function wallOverlapsPolygon(start, end, polygon) {
+function polylineInsideIntervals(points, polygon, includeBoundary = true) {
+    const intervals = [];
+    let offset = 0;
+    for (let i = 1; i < points.length; i++) {
+        const a = points[i - 1];
+        const b = points[i];
+        const segmentLength = Math.hypot(b.x - a.x, b.y - a.y);
+        if (segmentLength < 1e-9)
+            continue;
+        for (const [t0, t1] of segmentInsideIntervals(a.x, a.y, b.x, b.y, polygon, includeBoundary)) {
+            intervals.push([offset + t0 * segmentLength, offset + t1 * segmentLength]);
+        }
+        offset += segmentLength;
+    }
+    return mergeIntervals(intervals);
+}
+function polylineInsideLength(points, polygon) {
+    return intervalsLength(polylineInsideIntervals(points, polygon));
+}
+// Minimum length of wall that must lie on/inside a slab polygon before the
+// wall counts as overlapping it. Point contact (a perpendicular wall butting
+// into a room's edge) clips to ~zero length and never reaches this, so such
+// walls don't follow the slab's elevation.
+const WALL_SLAB_MIN_OVERLAP = 0.05;
+/**
+ * Centerline of the wall plus its two face lines (centerline offset by
+ * ±halfThickness). The face lines catch walls whose centerline sits on or
+ * just outside the slab boundary but whose body reaches onto the slab —
+ * e.g. slab polygons drawn to the room's interior faces.
+ */
+function wallTestPolylines(start, end, curveOffset, halfThickness) {
+    const wallLike = { start, end, curveOffset };
+    if (curveOffset !== 0 && isCurvedWall(wallLike)) {
+        const count = 16;
+        const center = [];
+        const left = [];
+        const right = [];
+        for (let i = 0; i <= count; i++) {
+            const frame = getWallCurveFrameAt(wallLike, i / count);
+            center.push(frame.point);
+            left.push({
+                x: frame.point.x + frame.normal.x * halfThickness,
+                y: frame.point.y + frame.normal.y * halfThickness,
+            });
+            right.push({
+                x: frame.point.x - frame.normal.x * halfThickness,
+                y: frame.point.y - frame.normal.y * halfThickness,
+            });
+        }
+        return halfThickness > 0 ? [center, left, right] : [center];
+    }
+    const center = [
+        { x: start[0], y: start[1] },
+        { x: end[0], y: end[1] },
+    ];
     const dx = end[0] - start[0];
     const dz = end[1] - start[1];
-    const len = Math.sqrt(dx * dx + dz * dz);
-    // Nudge endpoint test points a tiny step inward along the wall direction before
-    // testing containment. pointInPolygon (ray casting) produces false positives for
-    // points exactly on polygon vertices or edges — specifically the minimum-z corner
-    // of an axis-aligned polygon returns "inside" because the ray hits the opposite
-    // vertical edge exactly at its base. Nudging by 1e-6 m avoids this: a wall that
-    // merely starts at a slab corner and extends outward will have its nudged point
-    // clearly outside, while a wall that genuinely starts inside stays inside.
-    if (len > 1e-10) {
-        const step = Math.min(1e-6, len * 0.01);
-        const nx = (dx / len) * step;
-        const nz = (dz / len) * step;
-        if (pointInPolygon(start[0] + nx, start[1] + nz, polygon))
-            return true;
-        if (pointInPolygon(end[0] - nx, end[1] - nz, polygon))
-            return true;
-        // Also nudge perpendicular to the wall (into the slab interior) for walls that
-        // lie exactly on the slab boundary. The along-wall nudge keeps points on the
-        // boundary where pointInPolygon is unreliable; a perpendicular inward nudge
-        // moves the point clearly inside (or outside) the polygon.
-        // Sample the wall at 1/4, 1/2, 3/4 positions with a perpendicular nudge.
-        const PERP_STEP = 1e-4;
-        const pnx = (-nz / step) * PERP_STEP; // perpendicular left
-        const pnz = (nx / step) * PERP_STEP;
-        for (const t of [0.25, 0.5, 0.75]) {
-            const bx = start[0] + dx * t;
-            const bz = start[1] + dz * t;
-            if (pointInPolygon(bx + pnx, bz + pnz, polygon))
-                return true;
-            if (pointInPolygon(bx - pnx, bz - pnz, polygon))
-                return true;
-        }
-    }
-    // Check if midpoint is inside (catches walls crossing through)
-    const midX = (start[0] + end[0]) / 2;
-    const midZ = (start[1] + end[1]) / 2;
-    if (pointInPolygon(midX, midZ, polygon))
-        return true;
-    // Check if the wall is collinear with and overlaps any polygon edge
-    const n = polygon.length;
-    for (let i = 0; i < n; i++) {
-        const j = (i + 1) % n;
-        const [p1x, p1z] = polygon[i];
-        const [p2x, p2z] = polygon[j];
-        if (segmentsCollinearAndOverlap(start[0], start[1], end[0], end[1], p1x, p1z, p2x, p2z)) {
-            return true;
+    const len = Math.hypot(dx, dz);
+    if (len < 1e-10 || halfThickness <= 0)
+        return [center];
+    const nx = (-dz / len) * halfThickness;
+    const nz = (dx / len) * halfThickness;
+    return [
+        center,
+        [
+            { x: start[0] + nx, y: start[1] + nz },
+            { x: end[0] + nx, y: end[1] + nz },
+        ],
+        [
+            { x: start[0] - nx, y: start[1] - nz },
+            { x: end[0] - nx, y: end[1] - nz },
+        ],
+    ];
+}
+/**
+ * Test whether a wall overlaps a slab polygon along a segment of its length.
+ *
+ * The wall's centerline and both face lines are clipped against the polygon;
+ * the wall overlaps when the longest clipped inside-or-on-boundary length
+ * exceeds a threshold (5cm, halved for very short walls). Because interval
+ * midpoints classify "on the boundary" as inside explicitly (never by
+ * ray-cast tie-breaking), a wall sitting exactly on a slab edge resolves
+ * identically on every side of the slab.
+ *
+ * A wall that only touches the polygon at a point — a perpendicular wall
+ * butting into a room's edge, or a corner-to-corner touch — clips to ~zero
+ * length and does NOT overlap.
+ */
+export function wallOverlapsPolygon(startOrWall, endOrPolygon, polygonArg) {
+    // Two call shapes:
+    //   wallOverlapsPolygon(wallLike, polygon) — preferred; curve-aware
+    //   wallOverlapsPolygon(start, end, polygon) — legacy chord-only
+    let start;
+    let end;
+    let polygon;
+    let curveOffset = 0;
+    let thickness = DEFAULT_WALL_THICKNESS;
+    if (Array.isArray(startOrWall)) {
+        start = startOrWall;
+        end = endOrPolygon;
+        polygon = polygonArg;
+    }
+    else {
+        start = startOrWall.start;
+        end = startOrWall.end;
+        curveOffset = startOrWall.curveOffset ?? 0;
+        thickness = startOrWall.thickness ?? DEFAULT_WALL_THICKNESS;
+        polygon = endOrPolygon;
+    }
+    const halfThickness = Math.max(thickness / 2, 0);
+    const polylines = wallTestPolylines(start, end, curveOffset, halfThickness);
+    const centerLength = polylineLength(polylines[0]);
+    if (centerLength < 1e-9)
+        return false;
+    let overlap = 0;
+    for (const line of polylines) {
+        overlap = Math.max(overlap, polylineInsideLength(line, polygon));
+    }
+    const threshold = Math.max(1e-3, Math.min(WALL_SLAB_MIN_OVERLAP, centerLength * 0.5));
+    return overlap >= threshold;
+}
+// A slab elevation must support at least this fraction of the wall's
+// length before it can dictate the wall's base. Below majority, a raised
+// slab reaching one endpoint would hoist the whole wall off the floor
+// that actually carries it.
+const WALL_SLAB_SUPPORT_MAJORITY = 0.5;
+// Slabs whose elevations differ by less than this pool their support:
+// a wall shared between two rooms' slabs is covered roughly half by
+// each, and must still follow their common elevation.
+const WALL_SLAB_ELEVATION_POOL_EPSILON = 1e-4;
+export function computeWallSlabSupport(wallLike, slabs, levelWalls) {
+    const { start, end, curveOffset = 0, thickness = DEFAULT_WALL_THICKNESS } = wallLike;
+    const halfThickness = Math.max(thickness / 2, 0);
+    const polylines = wallTestPolylines(start, end, curveOffset, halfThickness);
+    const polylineLengths = polylines.map(polylineLength);
+    const wallLength = polylineLengths[0];
+    if (wallLength < 1e-9) {
+        return { elevation: 0, baseElevation: 0, baseSegments: [] };
+    }
+    const minSupport = Math.max(1e-3, Math.min(WALL_SLAB_MIN_OVERLAP, wallLength * 0.5));
+    const groups = [];
+    for (const slab of slabs) {
+        if (slab.polygon.length < 3)
+            continue;
+        const renderedPolygon = getRenderableSlabPolygon(slab, {
+            walls: levelWalls,
+            siblingSlabs: slabs.filter((other) => other.id !== slab.id),
+        });
+        let supported = 0;
+        const perPolyline = polylines.map((line) => {
+            let intervals = polylineInsideIntervals(line, renderedPolygon);
+            for (const hole of slab.holes || []) {
+                if (intervals.length === 0)
+                    break;
+                if (hole.length < 3)
+                    continue;
+                intervals = subtractIntervals(intervals, polylineInsideIntervals(line, hole, false));
+            }
+            supported = Math.max(supported, intervalsLength(intervals));
+            return intervals;
+        });
+        if (supported < minSupport)
+            continue;
+        const elevation = slab.elevation ?? 0.05;
+        let group = groups.find((candidate) => Math.abs(candidate.elevation - elevation) <= WALL_SLAB_ELEVATION_POOL_EPSILON);
+        if (!group) {
+            group = { elevation, perPolyline: polylines.map(() => []) };
+            groups.push(group);
+        }
+        for (let i = 0; i < perPolyline.length; i++) {
+            group.perPolyline[i].push(...perPolyline[i]);
         }
     }
-    return false;
+    const evaluatedGroups = groups.map((group) => {
+        let coverage = 0;
+        const mergedPerPolyline = group.perPolyline.map(mergeIntervals);
+        for (let i = 0; i < group.perPolyline.length; i++) {
+            const lineLength = polylineLengths[i];
+            if (lineLength < 1e-9)
+                continue;
+            coverage = Math.max(coverage, intervalsLength(mergedPerPolyline[i]) / lineLength);
+        }
+        return { ...group, coverage, mergedPerPolyline };
+    });
+    let majorityElevation = Number.NEGATIVE_INFINITY;
+    let bestElevation = Number.NEGATIVE_INFINITY;
+    let bestCoverage = -1;
+    for (const group of evaluatedGroups) {
+        if (group.coverage >= WALL_SLAB_SUPPORT_MAJORITY - 1e-6) {
+            majorityElevation = Math.max(majorityElevation, group.elevation);
+        }
+        if (group.coverage > bestCoverage + 1e-6 ||
+            (Math.abs(group.coverage - bestCoverage) <= 1e-6 && group.elevation > bestElevation)) {
+            bestCoverage = group.coverage;
+            bestElevation = group.elevation;
+        }
+    }
+    const elevation = majorityElevation !== Number.NEGATIVE_INFINITY
+        ? majorityElevation
+        : bestElevation === Number.NEGATIVE_INFINITY
+            ? 0
+            : bestElevation;
+    const normalizedIntervals = (group, polylineIndex) => {
+        const lineLength = polylineLengths[polylineIndex];
+        if (lineLength < 1e-9)
+            return [];
+        return group.mergedPerPolyline[polylineIndex].map(([intervalStart, intervalEnd]) => [intervalStart / lineLength, intervalEnd / lineLength]);
+    };
+    const normalizedByGroup = evaluatedGroups.map((group) => ({
+        elevation: group.elevation,
+        perPolyline: group.mergedPerPolyline.map((_, index) => normalizedIntervals(group, index)),
+    }));
+    const breakpoints = [0, 1];
+    for (const group of normalizedByGroup) {
+        for (const intervals of group.perPolyline) {
+            for (const [intervalStart, intervalEnd] of intervals) {
+                breakpoints.push(intervalStart, intervalEnd);
+            }
+        }
+    }
+    breakpoints.sort((left, right) => left - right);
+    const uniqueBreakpoints = breakpoints.filter((value, index) => index === 0 || value - breakpoints[index - 1] > 1e-7);
+    const highestAt = (polylineIndex, t) => {
+        let highest = Number.NEGATIVE_INFINITY;
+        for (const group of normalizedByGroup) {
+            if (group.perPolyline[polylineIndex]?.some(([intervalStart, intervalEnd]) => t >= intervalStart - 1e-7 && t <= intervalEnd + 1e-7)) {
+                highest = Math.max(highest, group.elevation);
+            }
+        }
+        return highest;
+    };
+    const baseSegments = [];
+    for (let index = 1; index < uniqueBreakpoints.length; index++) {
+        const start = uniqueBreakpoints[index - 1];
+        const end = uniqueBreakpoints[index];
+        if (end - start < 1e-7)
+            continue;
+        const midpoint = (start + end) / 2;
+        const leftElevation = polylines.length >= 3 ? highestAt(1, midpoint) : Number.NEGATIVE_INFINITY;
+        const rightElevation = polylines.length >= 3 ? highestAt(2, midpoint) : Number.NEGATIVE_INFINITY;
+        const faceElevations = [leftElevation, rightElevation].filter(Number.isFinite);
+        const segmentElevation = faceElevations.length > 0 ? Math.min(...faceElevations) : Math.max(highestAt(0, midpoint), 0);
+        const previous = baseSegments[baseSegments.length - 1];
+        if (previous &&
+            Math.abs(previous.elevation - segmentElevation) <= WALL_SLAB_ELEVATION_POOL_EPSILON) {
+            previous.end = end;
+        }
+        else {
+            baseSegments.push({ start, end, elevation: segmentElevation });
+        }
+    }
+    if (baseSegments.length === 0)
+        baseSegments.push({ start: 0, end: 1, elevation });
+    const baseElevation = Math.min(...baseSegments.map((segment) => segment.elevation));
+    return { elevation, baseElevation, baseSegments };
+}
+export function computeWallSlabElevation(wallLike, slabs, levelWalls) {
+    return computeWallSlabSupport(wallLike, slabs, levelWalls).elevation;
 }
 export class SpatialGridManager {
     floorGrids = new Map(); // levelId -> grid
@@ -433,37 +782,51 @@ export class SpatialGridManager {
     }
     // Query methods
     canPlaceOnFloor(levelId, position, dimensions, rotation, ignoreIds) {
+        return this.canPlaceOnFloorFootprints(levelId, [{ position, dimensions, rotation }], ignoreIds);
+    }
+    canPlaceOnFloorFootprints(levelId, footprints, ignoreIds) {
         const nodes = useScene.getState().nodes;
-        const ignoreSet = new Set(ignoreIds ?? []);
-        const [width, , depth] = dimensions;
-        const yRot = rotation[1];
-        const cos = Math.abs(Math.cos(yRot));
-        const sin = Math.abs(Math.sin(yRot));
-        const rotatedW = width * cos + depth * sin;
-        const rotatedD = width * sin + depth * cos;
-        const draftBounds = {
-            minX: position[0] - rotatedW / 2,
-            maxX: position[0] + rotatedW / 2,
-            minZ: position[2] - rotatedD / 2,
-            maxZ: position[2] + rotatedD / 2,
-        };
+        const ignoreSet = expandIgnoredNodeIds(ignoreIds, nodes);
+        const draftBounds = footprints.map((footprint) => footprintBoundsXZ(footprint.position, footprint.dimensions, footprint.rotation[1] ?? 0));
+        for (let i = 0; i < draftBounds.length; i += 1) {
+            const a = draftBounds[i];
+            for (let j = i + 1; j < draftBounds.length; j += 1) {
+                const b = draftBounds[j];
+                if (intervalsOverlap(a.minX, a.maxX, b.minX, b.maxX) &&
+                    intervalsOverlap(a.minZ, a.maxZ, b.minZ, b.maxZ)) {
+                    return { valid: false, conflictIds: [] };
+                }
+            }
+        }
+        // A floor placement conflicts with any other COLLIDING floor-resting node,
+        // not just items — every kind whose `floorPlaced.collides` is set (item /
+        // shelf / column / cabinet / stair) contributes its footprint(s) as an
+        // obstacle. Each candidate's XZ extent is read from the same declarative
+        // footprint the elevation + sync paths use, so adding a colliding kind
+        // needs no change here.
         const conflicts = [];
         for (const node of Object.values(nodes)) {
-            if (node.type !== 'item')
+            if (ignoreSet.has(node.id))
                 continue;
-            const item = node;
-            if (item.asset.attachTo)
+            const floorPlaced = nodeRegistry.get(node.type)?.capabilities?.floorPlaced;
+            if (!floorPlaced?.collides)
                 continue;
-            if (isLowProfileItemSurface(item))
+            if (floorPlaced.applies && !floorPlaced.applies(node))
                 continue;
-            if (ignoreSet.has(item.id))
+            // Low-profile item surfaces (rugs, mats) are stack-on targets, not
+            // obstacles — keep the long-standing item-only exemption.
+            if (node.type === 'item' && isLowProfileItemSurface(node))
                 continue;
-            if (resolveNodeLevelId(item, nodes) !== levelId)
+            if (resolveNodeLevelId(node, nodes) !== levelId)
                 continue;
-            const bounds = getItemParentAabb(item);
-            if (intervalsOverlap(draftBounds.minX, draftBounds.maxX, bounds.minX, bounds.maxX) &&
-                intervalsOverlap(draftBounds.minZ, draftBounds.maxZ, bounds.minZ, bounds.maxZ)) {
-                conflicts.push(item.id);
+            for (const footprint of getFloorPlacedFootprints(floorPlaced, node, { nodes })) {
+                const fpRotation = Array.isArray(footprint.rotation) ? (footprint.rotation[1] ?? 0) : 0;
+                const bounds = footprintBoundsXZ(footprint.position ?? node.position, footprint.dimensions, fpRotation);
+                if (draftBounds.some((draft) => intervalsOverlap(draft.minX, draft.maxX, bounds.minX, bounds.maxX) &&
+                    intervalsOverlap(draft.minZ, draft.maxZ, bounds.minZ, bounds.maxZ))) {
+                    conflicts.push(node.id);
+                    break;
+                }
             }
         }
         return { valid: conflicts.length === 0, conflictIds: conflicts };
@@ -595,55 +958,59 @@ export class SpatialGridManager {
     }
     /**
      * Get the slab elevation for a wall by checking if it overlaps with any slab polygon (excluding holes).
-     * Uses wallOverlapsPolygon which handles edge cases (points on boundary, collinear segments).
      * Returns the highest slab elevation found, or 0 if none.
+     *
+     * Accepts an optional `curveOffset` so curved walls evaluate overlap
+     * against their actual centerline samples, not just the chord.
      */
-    getSlabElevationForWall(levelId, start, end) {
+    getSlabElevationForWall(levelId, start, end, curveOffset = 0, thickness = DEFAULT_WALL_THICKNESS) {
+        return this.getSlabSupportForWall(levelId, start, end, curveOffset, thickness).elevation;
+    }
+    getSlabSupportForWall(levelId, start, end, curveOffset = 0, thickness = DEFAULT_WALL_THICKNESS) {
         const slabMap = this.slabsByLevel.get(levelId);
-        if (!slabMap)
-            return 0;
-        let maxElevation = Number.NEGATIVE_INFINITY;
-        for (const slab of slabMap.values()) {
-            if (slab.polygon.length < 3)
-                continue;
-            if (!wallOverlapsPolygon(start, end, slab.polygon))
-                continue;
-            const holes = slab.holes || [];
-            if (holes.length === 0) {
-                // No holes: wall is on this slab
-                const elevation = slab.elevation ?? 0.05;
-                if (elevation > maxElevation)
-                    maxElevation = elevation;
+        if (!slabMap) {
+            return {
+                elevation: 0,
+                baseElevation: 0,
+                baseSegments: [{ start: 0, end: 1, elevation: 0 }],
+            };
+        }
+        return computeWallSlabSupport({ start, end, curveOffset, thickness }, [...slabMap.values()], this.getLevelWallNodes(levelId));
+    }
+    /**
+     * Walls on a level, resolved fresh from the scene store (the manager's
+     * own wall map is only maintained on create/delete, not on updates).
+     * Cached per scene `nodes` record so per-pointer-tick callers
+     * (door/window move) don't rescan the node map.
+     */
+    levelWallsCache = new WeakMap();
+    getLevelWallNodes(levelId) {
+        const nodes = useScene.getState().nodes;
+        let byLevel = this.levelWallsCache.get(nodes);
+        if (!byLevel) {
+            byLevel = new Map();
+            this.levelWallsCache.set(nodes, byLevel);
+        }
+        const cached = byLevel.get(levelId);
+        if (cached)
+            return cached;
+        const walls = [];
+        for (const node of Object.values(nodes)) {
+            if (node.type !== 'wall')
                 continue;
+            // Walk the parent chain to the owning level (guarded against cycles).
+            let current = node;
+            let guard = 0;
+            while (current && current.type !== 'level' && guard < 16) {
+                current = current.parentId ? nodes[current.parentId] : undefined;
+                guard += 1;
             }
-            // Sample multiple points along the wall to check whether any portion lies on
-            // solid slab (not inside any hole). Checking only the midpoint fails when the
-            // midpoint falls in a staircase hole but the wall's endpoints are on solid slab.
-            const dx = end[0] - start[0];
-            const dz = end[1] - start[1];
-            let hasValidPoint = false;
-            for (const t of [0, 0.25, 0.5, 0.75, 1]) {
-                const px = start[0] + dx * t;
-                const pz = start[1] + dz * t;
-                let inHole = false;
-                for (const hole of holes) {
-                    if (hole.length >= 3 && pointInPolygon(px, pz, hole)) {
-                        inHole = true;
-                        break;
-                    }
-                }
-                if (!inHole) {
-                    hasValidPoint = true;
-                    break;
-                }
-            }
-            if (hasValidPoint) {
-                const elevation = slab.elevation ?? 0.05;
-                if (elevation > maxElevation)
-                    maxElevation = elevation;
+            if (current?.type === 'level' && current.id === levelId) {
+                walls.push(node);
             }
         }
-        return maxElevation === Number.NEGATIVE_INFINITY ? 0 : maxElevation;
+        byLevel.set(levelId, walls);
+        return walls;
     }
     /**
      * Check if an item can be placed on a ceiling.