@pascal-app/core 0.9.1 → 1.0.0-beta.1

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

@@ -1,27 +1,22 @@
+import { getRenderableSlabPolygon } from '../../lib/slab-polygon';
+import { terrainSupportLift } from '../../lib/terrain-support';
+import { nodeRegistry } from '../../registry';
 import { getScaledDimensions, isLowProfileItemSurface } from '../../schema';
+import { getWallPlaneTop } from '../../services/storey';
+import useLiveNodeOverrides, { getEffectiveNode } from '../../store/use-live-node-overrides';
+import useLiveTransforms from '../../store/use-live-transforms';
 import useScene from '../../store/use-scene';
-import { isCurvedWall, sampleWallCenterline } from '../../systems/wall/wall-curve';
+import { computeWallSlabSupport, pointInPolygon, SUPPORT_ELEVATION_EPSILON, } from '../../systems/slab/slab-support';
 import { DEFAULT_WALL_THICKNESS } from '../../systems/wall/wall-footprint';
+import { resolveWallEffectiveHeight } from '../../systems/wall/wall-top';
+import { getFloorPlacedFootprints } from './floor-placed-elevation';
 import { SpatialGrid } from './spatial-grid';
+import { GROUND_SUPPORT_ID } from './support-host-id';
 import { WallSpatialGrid } from './wall-spatial-grid';
+export { computeWallSlabElevation, computeWallSlabSupport, pointInPolygon, SUPPORT_ELEVATION_EPSILON, wallOverlapsPolygon, } from '../../systems/slab/slab-support';
 // ============================================================================
 // GEOMETRY HELPERS
 // ============================================================================
-/**
- * Point-in-polygon test using ray casting algorithm.
- */
-export function pointInPolygon(px, pz, polygon) {
-    let inside = false;
-    const n = polygon.length;
-    for (let i = 0, j = n - 1; i < n; j = i++) {
-        const xi = polygon[i][0], zi = polygon[i][1];
-        const xj = polygon[j][0], zj = polygon[j][1];
-        if (zi > pz !== zj > pz && px < ((xj - xi) * (pz - zi)) / (zj - zi) + xi) {
-            inside = !inside;
-        }
-    }
-    return inside;
-}
 /**
  * Compute the 4 XZ footprint corners of an item given its position, dimensions, and Y rotation.
  */
@@ -40,6 +35,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;
@@ -99,6 +112,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.
  */
@@ -164,169 +195,6 @@ export function itemOverlapsPolygon(position, dimensions, rotation, polygon, ins
     }
     return false;
 }
-/**
- * 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.
- */
-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;
-}
-/**
- * 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)
- * - (curved walls) any sample along the centerline is inside
- *
- * Note: A wall with just one endpoint touching the edge but the rest outside
- * is NOT considered overlapping (adjacent only).
- */
-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);
-    // Curved walls: sample the centerline. The chord-based checks below miss
-    // walls that bow into/out of the slab — e.g. endpoints on the slab
-    // boundary with the curve arcing inward through the slab interior. Without
-    // this, `getSlabElevationForWall` returns 0 (wall drops to floor) and
-    // `markNodesOverlappingSlab` never re-dirties the wall when the slab Y
-    // moves.
-    if (curveOffset !== 0) {
-        const wallLike = { start, end, curveOffset };
-        if (isCurvedWall(wallLike)) {
-            const samples = sampleWallCenterline(wallLike, 16);
-            for (let i = 0; i < samples.length; i++) {
-                const point = samples[i];
-                if (pointInPolygon(point.x, point.y, polygon))
-                    return true;
-                // Also test ±halfThickness perpendicular at each sample so a curve
-                // skirting the slab edge with its centerline just outside still
-                // registers — its body sits inside the slab.
-                if (halfThickness > 0 && i > 0) {
-                    const prev = samples[i - 1];
-                    const sx = point.x - prev.x;
-                    const sz = point.y - prev.y;
-                    const sl = Math.sqrt(sx * sx + sz * sz);
-                    if (sl > 1e-10) {
-                        const tnx = (-sz / sl) * halfThickness;
-                        const tnz = (sx / sl) * halfThickness;
-                        if (pointInPolygon(point.x + tnx, point.y + tnz, polygon))
-                            return true;
-                        if (pointInPolygon(point.x - tnx, point.y - tnz, polygon))
-                            return true;
-                    }
-                }
-            }
-        }
-    }
-    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;
-        }
-        // Wall-thickness perpendicular test. Walls aren't infinitely thin lines;
-        // a wall whose centerline sits just outside the slab boundary still has
-        // half its body inside the slab and should follow the slab elevation.
-        // Without this, the perimeter walls of a room often miss the slab-overlap
-        // detection (the slab polygon is the room's interior, the wall centerline
-        // sits on or just outside its edge) and stay at Y=0 while the slab moves
-        // up.
-        if (halfThickness > 0) {
-            const ux = dx / len;
-            const uz = dz / len;
-            const tnx = -uz * halfThickness;
-            const tnz = ux * halfThickness;
-            for (const t of [0, 0.25, 0.5, 0.75, 1]) {
-                const bx = start[0] + dx * t;
-                const bz = start[1] + dz * t;
-                if (pointInPolygon(bx + tnx, bz + tnz, polygon))
-                    return true;
-                if (pointInPolygon(bx - tnx, bz - tnz, 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;
-        }
-    }
-    return false;
-}
 export class SpatialGridManager {
     floorGrids = new Map(); // levelId -> grid
     wallGrids = new Map(); // levelId -> wall grid
@@ -361,7 +229,14 @@ export class SpatialGridManager {
     }
     getWallHeight(wallId) {
         const wall = this.walls.get(wallId);
-        return wall?.height ?? 2.5; // Default wall height
+        if (!wall)
+            return 0;
+        if (wall.height != null)
+            return wall.height;
+        const nodes = useScene.getState().nodes;
+        const levelId = resolveNodeLevelId(wall, nodes);
+        const support = this.getSlabSupportForWall(levelId, wall.start, wall.end, wall.curveOffset ?? 0, wall.thickness, wall.supportSlabId ?? null, undefined, wall.supportOffset);
+        return resolveWallEffectiveHeight(wall, getWallPlaneTop(wall, levelId, nodes), support.elevation);
     }
     getCeilingGrid(ceilingId) {
         if (!this.ceilingGrids.has(ceilingId)) {
@@ -375,10 +250,122 @@ export class SpatialGridManager {
         }
         return this.slabsByLevel.get(levelId);
     }
+    /**
+     * Per-slab RENDERED polygon cache (`getRenderableSlabPolygon`). Item
+     * support queries run per frame and the projection scans the level's
+     * walls + sibling slabs, so the result is cached per slab id and
+     * dropped for the whole level whenever a slab or wall on that level
+     * flows through the manager's create/update/delete handlers.
+     */
+    renderedSlabPolygons = new Map();
+    invalidateRenderedSlabPolygons(levelId) {
+        const slabMap = this.slabsByLevel.get(levelId);
+        if (!slabMap)
+            return;
+        for (const slabId of slabMap.keys())
+            this.renderedSlabPolygons.delete(slabId);
+    }
+    /**
+     * True while a slab or wall on `levelId` has a live preview: group drags
+     * publish translated slab polygons and wall endpoints to
+     * `useLiveNodeOverrides`, and the slab move tool / room-preset stamp
+     * publish a translation DELTA to `useLiveTransforms` — either way the
+     * scene store commits only on release, so the committed cache and index
+     * would elect support against pre-drag footprints (items and walls
+     * visibly drop to ground mid-preview). Support queries then read
+     * live-effective records and skip the rendered-polygon cache.
+     */
+    levelHasLivePreview(levelId) {
+        const nodes = useScene.getState().nodes;
+        const structuralOnLevel = (id) => {
+            const node = nodes[id];
+            if (!node || (node.type !== 'slab' && node.type !== 'wall'))
+                return false;
+            return resolveNodeLevelId(node, nodes) === levelId;
+        };
+        const overrides = useLiveNodeOverrides.getState().overrides;
+        for (const id of overrides.keys()) {
+            if (structuralOnLevel(id))
+                return true;
+        }
+        const transforms = useLiveTransforms.getState().transforms;
+        for (const id of transforms.keys()) {
+            if (structuralOnLevel(id))
+                return true;
+        }
+        return false;
+    }
+    /**
+     * The live-effective slab record: field overrides merged, then the
+     * `useLiveTransforms` DELTA (slab publishers — move tool, room-preset
+     * stamp — store a translation, not an absolute position) applied to the
+     * polygon, holes, and elevation. Mapping happens exactly ONCE at each
+     * public query's loop entry: `slabSupportsFootprint` /
+     * `getRenderedSlabPolygon` take the already-effective record and must
+     * never re-map, or the delta would apply twice.
+     */
+    effectiveSlabRecord(slab) {
+        let effective = getEffectiveNode(slab);
+        const live = useLiveTransforms.getState().get(slab.id);
+        if (live) {
+            const [dx, dy, dz] = live.position;
+            if (dx !== 0 || dy !== 0 || dz !== 0) {
+                effective = {
+                    ...effective,
+                    polygon: effective.polygon.map(([x, z]) => [x + dx, z + dz]),
+                    holes: (effective.holes || []).map((hole) => hole.map(([x, z]) => [x + dx, z + dz])),
+                    elevation: (effective.elevation ?? 0.05) + dy,
+                };
+            }
+        }
+        return effective;
+    }
+    getRenderedSlabPolygon(levelId, slab) {
+        const live = this.levelHasLivePreview(levelId);
+        if (!live) {
+            const cached = this.renderedSlabPolygons.get(slab.id);
+            if (cached)
+                return cached;
+        }
+        const siblingSlabs = [];
+        for (const other of this.getSlabMap(levelId).values()) {
+            if (other.id !== slab.id)
+                siblingSlabs.push(live ? this.effectiveSlabRecord(other) : other);
+        }
+        const walls = this.getLevelWallNodes(levelId);
+        const polygon = getRenderableSlabPolygon(slab, {
+            walls: live ? walls.map((wall) => getEffectiveNode(wall)) : walls,
+            siblingSlabs,
+        });
+        if (!live)
+            this.renderedSlabPolygons.set(slab.id, polygon);
+        return polygon;
+    }
+    /**
+     * Support test shared by election, candidate listing, and persisted-host
+     * validation: the footprint overlaps the slab's RENDERED polygon (what
+     * users see — matching the wall election in `computeWallSlabSupport`),
+     * with the center-point hole veto kept against the stored holes (holes
+     * are data, never render-offset).
+     */
+    slabSupportsFootprint(levelId, slab, position, dimensions, rotation) {
+        if (slab.polygon.length < 3)
+            return false;
+        const rendered = this.getRenderedSlabPolygon(levelId, slab);
+        if (!itemOverlapsPolygon(position, dimensions, rotation, rendered, 0.01))
+            return false;
+        const [cx, , cz] = position;
+        for (const hole of slab.holes || []) {
+            if (hole.length >= 3 && pointInPolygon(cx, cz, hole))
+                return false;
+        }
+        return true;
+    }
     // Called when nodes change
     handleNodeCreated(node, levelId) {
         if (node.type === 'slab') {
             this.getSlabMap(levelId).set(node.id, node);
+            this.invalidateRenderedSlabPolygons(levelId);
         }
         else if (node.type === 'ceiling') {
             this.ceilings.set(node.id, node);
@@ -386,6 +373,8 @@ export class SpatialGridManager {
         else if (node.type === 'wall') {
             const wall = node;
             this.walls.set(wall.id, wall);
+            // Rendered slab polygons adopt wall bands — a new wall can extend them.
+            this.invalidateRenderedSlabPolygons(levelId);
         }
         else if (node.type === 'item') {
             const item = node;
@@ -430,6 +419,7 @@ export class SpatialGridManager {
     handleNodeUpdated(node, levelId) {
         if (node.type === 'slab') {
             this.getSlabMap(levelId).set(node.id, node);
+            this.invalidateRenderedSlabPolygons(levelId);
         }
         else if (node.type === 'ceiling') {
             this.ceilings.set(node.id, node);
@@ -437,6 +427,7 @@ export class SpatialGridManager {
         else if (node.type === 'wall') {
             const wall = node;
             this.walls.set(wall.id, wall);
+            this.invalidateRenderedSlabPolygons(levelId);
         }
         else if (node.type === 'item') {
             const item = node;
@@ -486,6 +477,9 @@ export class SpatialGridManager {
     }
     handleNodeDeleted(nodeId, nodeType, levelId) {
         if (nodeType === 'slab') {
+            // Invalidate before removal so the deleted slab's own cache entry
+            // (still keyed in the level map here) is dropped with its siblings'.
+            this.invalidateRenderedSlabPolygons(levelId);
             this.getSlabMap(levelId).delete(nodeId);
         }
         else if (nodeType === 'ceiling') {
@@ -494,6 +488,7 @@ export class SpatialGridManager {
         }
         else if (nodeType === 'wall') {
             this.walls.delete(nodeId);
+            this.invalidateRenderedSlabPolygons(levelId);
             // Remove all items attached to this wall from the spatial grid
             const removedItemIds = this.getWallGrid(levelId).removeWall(nodeId);
             return removedItemIds; // Caller can use this to delete the items from scene
@@ -512,37 +507,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 };
@@ -617,7 +626,8 @@ export class SpatialGridManager {
         if (!slabMap)
             return 0;
         let maxElevation = 0;
-        for (const slab of slabMap.values()) {
+        for (const stored of slabMap.values()) {
+            const slab = this.effectiveSlabRecord(stored);
             if (slab.polygon.length >= 3 && pointInPolygon(x, z, slab.polygon)) {
                 // Check if point is in any hole
                 let inHole = false;
@@ -640,96 +650,222 @@ export class SpatialGridManager {
     }
     /**
      * Get the slab elevation for an item using its full footprint (bounding box).
-     * Checks if any part of the item's rotated footprint overlaps with any slab polygon (excluding holes).
-     * Returns the highest overlapping slab elevation, or 0 if none.
+     * Thin wrapper over {@link getSlabSupportForItem} for callers (and tests)
+     * that only need the number.
+     */
+    getSlabElevationForItem(levelId, position, dimensions, rotation, maxElevation) {
+        return this.getSlabSupportForItem(levelId, position, dimensions, rotation, maxElevation)
+            .elevation;
+    }
+    /**
+     * Elect the supporting slab for a footprint: the highest-elevation slab
+     * whose RENDERED polygon the footprint overlaps (center-point hole veto
+     * applies). Returns `{ elevation: 0, slabId: null }` when nothing
+     * overlaps.
+     *
+     * `maxElevation` is the pointer-decided cap: when set, only slabs whose
+     * walking surface sits at or below `maxElevation +
+     * SUPPORT_ELEVATION_EPSILON` may win — a deck hanging above the surface
+     * the cursor ray actually hit never captures the election.
      */
-    getSlabElevationForItem(levelId, position, dimensions, rotation) {
+    getSlabSupportForItem(levelId, position, dimensions, rotation, maxElevation) {
         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 &&
-                itemOverlapsPolygon(position, dimensions, rotation, slab.polygon, 0.01)) {
-                // Check if item is entirely within a hole (if so, ignore this slab)
-                // We consider it entirely in a hole if the item center is in the hole
+            return { elevation: 0, slabId: null };
+        let winningElevation = Number.NEGATIVE_INFINITY;
+        let winnerId = null;
+        for (const stored of slabMap.values()) {
+            const slab = this.effectiveSlabRecord(stored);
+            const elevation = slab.elevation ?? 0.05;
+            if (maxElevation != null && elevation > maxElevation + SUPPORT_ELEVATION_EPSILON)
+                continue;
+            if (!this.slabSupportsFootprint(levelId, slab, position, dimensions, rotation))
+                continue;
+            if (elevation > winningElevation) {
+                winningElevation = elevation;
+                winnerId = slab.id;
+            }
+        }
+        return winnerId === null
+            ? { elevation: 0, slabId: null }
+            : { elevation: winningElevation, slabId: winnerId };
+    }
+    /**
+     * The walking surface the pointer actually points at: the nearest slab
+     * plane the ray crosses INSIDE that slab's rendered polygon (hole veto
+     * applies), or the level base (`elevation: 0, slabId: null`) when it
+     * crosses none. Ray origin/direction are level-local. Deliberately a
+     * point test, not a footprint test — it answers "which surface is under
+     * the cursor", which then caps the footprint election so a deck hanging
+     * above the aimed-at floor never lifts the placement. `point` is the
+     * ray's crossing of that surface's plane — the stable plan point
+     * callers should elect/preview at (see {@link PointedSupportSurface}).
+     */
+    getPointedSupportSurface(levelId, rayOrigin, rayDirection) {
+        const slabMap = this.slabsByLevel.get(levelId);
+        const [ox, oy, oz] = rayOrigin;
+        const [dx, dy, dz] = rayDirection;
+        if (Math.abs(dy) < 1e-9)
+            return { elevation: 0, slabId: null, point: null };
+        let best = null;
+        if (slabMap) {
+            for (const stored of slabMap.values()) {
+                const slab = this.effectiveSlabRecord(stored);
+                if (slab.polygon.length < 3)
+                    continue;
+                const elevation = slab.elevation ?? 0.05;
+                const t = (elevation - oy) / dy;
+                if (t <= 0)
+                    continue;
+                if (best && t >= best.t)
+                    continue;
+                const x = ox + dx * t;
+                const z = oz + dz * t;
+                const rendered = this.getRenderedSlabPolygon(levelId, slab);
+                if (rendered.length < 3 || !pointInPolygon(x, z, rendered))
+                    continue;
                 let inHole = false;
-                const [cx, , cz] = position;
-                const holes = slab.holes || [];
-                for (const hole of holes) {
-                    if (hole.length >= 3 && pointInPolygon(cx, cz, hole)) {
+                for (const hole of slab.holes || []) {
+                    if (hole.length >= 3 && pointInPolygon(x, z, hole)) {
                         inHole = true;
                         break;
                     }
                 }
-                if (!inHole) {
-                    const elevation = slab.elevation ?? 0.05;
-                    if (elevation > maxElevation) {
-                        maxElevation = elevation;
-                    }
-                }
+                if (inHole)
+                    continue;
+                best = { t, elevation, slabId: slab.id };
             }
         }
-        return maxElevation === Number.NEGATIVE_INFINITY ? 0 : maxElevation;
+        if (best) {
+            return {
+                elevation: best.elevation,
+                slabId: best.slabId,
+                point: [ox + dx * best.t, oz + dz * best.t],
+            };
+        }
+        const tBase = -oy / dy;
+        return {
+            elevation: 0,
+            slabId: null,
+            point: tBase > 0 ? [ox + dx * tBase, oz + dz * tBase] : null,
+        };
+    }
+    /**
+     * All slabs supporting a footprint, one entry per overlapping slab
+     * (highest elevation first; slab id breaks ties deterministically).
+     * Commit-side ambiguity check: persist a `supportSlabId` only when the
+     * candidates carry ≥ 2 distinct elevations.
+     */
+    getSupportCandidatesForFootprint(levelId, position, dimensions, rotation) {
+        const slabMap = this.slabsByLevel.get(levelId);
+        if (!slabMap)
+            return [];
+        const candidates = [];
+        for (const stored of slabMap.values()) {
+            const slab = this.effectiveSlabRecord(stored);
+            if (!this.slabSupportsFootprint(levelId, slab, position, dimensions, rotation))
+                continue;
+            candidates.push({ slabId: slab.id, elevation: slab.elevation ?? 0.05 });
+        }
+        candidates.sort((a, b) => b.elevation - a.elevation || (a.slabId < b.slabId ? -1 : a.slabId > b.slabId ? 1 : 0));
+        return candidates;
+    }
+    /**
+     * Elevation of a persisted support host for a footprint, or null when
+     * the slab no longer exists on the level or no longer overlaps the
+     * footprint (same overlap test as election). Deliberately read-only: a
+     * host reshaped away is NOT cleared — callers fall back to election and
+     * the stale reference resumes hosting if the slab's polygon returns.
+     * Slab deletion is the only writer (`deleteNodesAction` strips it).
+     */
+    getHostSlabElevationForFootprint(levelId, slabId, position, dimensions, rotation) {
+        const stored = this.slabsByLevel.get(levelId)?.get(slabId);
+        if (!stored)
+            return null;
+        const slab = this.effectiveSlabRecord(stored);
+        if (!this.slabSupportsFootprint(levelId, slab, position, dimensions, rotation))
+            return null;
+        return slab.elevation ?? 0.05;
     }
     /**
      * 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, curveOffset = 0, thickness = DEFAULT_WALL_THICKNESS) {
+    getSlabElevationForWall(levelId, start, end, curveOffset = 0, thickness = DEFAULT_WALL_THICKNESS, preferredSlabId) {
+        return this.getSlabSupportForWall(levelId, start, end, curveOffset, thickness, preferredSlabId)
+            .elevation;
+    }
+    getSlabSupportForWall(levelId, start, end, curveOffset = 0, thickness = DEFAULT_WALL_THICKNESS, preferredSlabId, maxElevation, supportOffset = 0) {
+        if (preferredSlabId === GROUND_SUPPORT_ID) {
+            const nodes = useScene.getState().nodes;
+            const elevation = (terrainSupportLift(nodes, levelId, start[0], start[1]) ?? 0) + supportOffset;
+            return {
+                elevation,
+                electedSlabId: null,
+                baseElevation: elevation,
+                baseSegments: [{ start: 0, end: 1, elevation }],
+            };
+        }
         const slabMap = this.slabsByLevel.get(levelId);
-        if (!slabMap)
-            return 0;
-        const wallLike = { start, end, curveOffset, thickness };
-        const isCurved = curveOffset !== 0 && isCurvedWall(wallLike);
-        const holeSamplePoints = isCurved
-            ? sampleWallCenterline(wallLike, 8)
-            : [0, 0.25, 0.5, 0.75, 1].map((t) => ({
-                x: start[0] + (end[0] - start[0]) * t,
-                y: start[1] + (end[1] - start[1]) * t,
-            }));
-        let maxElevation = Number.NEGATIVE_INFINITY;
-        for (const slab of slabMap.values()) {
-            if (slab.polygon.length < 3)
-                continue;
-            if (!wallOverlapsPolygon(wallLike, 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) {
+            const elevation = supportOffset;
+            return {
+                elevation,
+                electedSlabId: null,
+                baseElevation: elevation,
+                baseSegments: [{ start: 0, end: 1, elevation }],
+            };
+        }
+        const support = computeWallSlabSupport({ start, end, curveOffset, thickness }, [...slabMap.values()].map((slab) => this.effectiveSlabRecord(slab)), this.getLevelWallNodes(levelId).map((wall) => getEffectiveNode(wall)), preferredSlabId, maxElevation);
+        if (supportOffset === 0)
+            return support;
+        return {
+            ...support,
+            elevation: support.elevation + supportOffset,
+            baseElevation: support.baseElevation + supportOffset,
+            baseSegments: support.baseSegments.map((segment) => ({
+                ...segment,
+                elevation: segment.elevation + supportOffset,
+            })),
+        };
+    }
+    /**
+     * 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.
-            let hasValidPoint = false;
-            for (const sample of holeSamplePoints) {
-                let inHole = false;
-                for (const hole of holes) {
-                    if (hole.length >= 3 && pointInPolygon(sample.x, sample.y, 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.
@@ -789,6 +925,7 @@ export class SpatialGridManager {
         return { valid: conflicts.length === 0, conflictIds: conflicts };
     }
     clearLevel(levelId) {
+        this.invalidateRenderedSlabPolygons(levelId);
         this.floorGrids.delete(levelId);
         this.wallGrids.delete(levelId);
         this.slabsByLevel.delete(levelId);
@@ -801,7 +938,26 @@ export class SpatialGridManager {
         this.ceilingGrids.clear();
         this.ceilings.clear();
         this.itemCeilingMap.clear();
+        this.renderedSlabPolygons.clear();
     }
 }
 // Singleton instance
 export const spatialGridManager = new SpatialGridManager();
+/** Level-local Y where the rendered wall mesh begins. */
+export function getWallBaseElevationForNodes(wall, nodes) {
+    const levelId = resolveNodeLevelId(wall, nodes);
+    return spatialGridManager.getSlabSupportForWall(levelId, wall.start, wall.end, wall.curveOffset ?? 0, wall.thickness, wall.supportSlabId ?? null, undefined, wall.supportOffset).elevation;
+}
+/**
+ * Effective (extruded) height of a wall resolved from a nodes record:
+ * {@link resolveWallEffectiveHeight} over the covering-clamped plane top
+ * (`getWallPlaneTop`) and the singleton manager's slab election — so the
+ * value always agrees with the rendered wall. One shared resolver for the
+ * editor overlays (measurement label, action menu, side handles) that used
+ * to copy this derivation locally.
+ */
+export function getWallEffectiveHeightForNodes(wall, nodes) {
+    const levelId = resolveNodeLevelId(wall, nodes);
+    const baseElevation = getWallBaseElevationForNodes(wall, nodes);
+    return resolveWallEffectiveHeight(wall, getWallPlaneTop(wall, levelId, nodes), baseElevation);
+}