@pascal-app/core 1.0.0-beta.5 → 1.0.1

package/dist/hooks/spatial-grid/spatial-grid-sync.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"spatial-grid-sync.d.ts","sourceRoot":"","sources":["../../../src/hooks/spatial-grid/spatial-grid-sync.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,SAAS,EAAY,QAAQ,EAAY,MAAM,cAAc,CAAA;AAY/F,wBAAgB,cAAc,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAmBpF;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,SAAS,EACjB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,MAAM,GAAG,IAAI,CASf;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,SAAS,EAClB,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,GAChC,SAAS,GAAG,IAAI,CAgBlB;AAKD,wBAAgB,mBAAmB,IAAI,MAAM,IAAI,CAgIhD;AAMD;;;;;GAKG;AACH,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,SAAS,EAChB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,SAAS,EAAE,CAAC,EAAE,EAAE,SAAS,KAAK,IAAI,QAcnC;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,SAAS,EAAE,CAAC,EAAE,EAAE,SAAS,KAAK,IAAI,QAOnC;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,CACtC,QAAQ,EAAE,QAAQ,EAClB,IAAI,EAAE,QAAQ,EACd,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,SAAS,EAAE,CAAC,EAAE,EAAE,SAAS,KAAK,IAAI,QAqBnC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,4BAA4B,CAC1C,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,SAAS,EAAE,CAAC,EAAE,EAAE,SAAS,KAAK,IAAI,QAgDnC;AAED;;;;GAIG;AACH,wBAAgB,2BAA2B,CACzC,WAAW,EAAE,MAAM,EACnB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,SAAS,EAAE,CAAC,EAAE,EAAE,SAAS,KAAK,IAAI,QAUnC"}
+{"version":3,"file":"spatial-grid-sync.d.ts","sourceRoot":"","sources":["../../../src/hooks/spatial-grid/spatial-grid-sync.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,SAAS,EAAY,QAAQ,EAAY,MAAM,cAAc,CAAA;AAY/F,wBAAgB,cAAc,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAmBpF;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,SAAS,EACjB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,MAAM,GAAG,IAAI,CASf;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,SAAS,EAClB,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,GAChC,SAAS,GAAG,IAAI,CAgBlB;AAKD,wBAAgB,mBAAmB,IAAI,MAAM,IAAI,CAwNhD;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,0BAA0B,KAAK,CAAA;AAE5C,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GACjC,MAAM,CAmBR;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,SAAS,EAAE,CAAC,EAAE,EAAE,SAAS,KAAK,IAAI,QAgBnC;AAMD;;;;;GAKG;AACH,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,SAAS,EAChB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,SAAS,EAAE,CAAC,EAAE,EAAE,SAAS,KAAK,IAAI,QAcnC;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,SAAS,EAAE,CAAC,EAAE,EAAE,SAAS,KAAK,IAAI,QAOnC;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,CACtC,QAAQ,EAAE,QAAQ,EAClB,IAAI,EAAE,QAAQ,EACd,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,SAAS,EAAE,CAAC,EAAE,EAAE,SAAS,KAAK,IAAI,EAClC,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAQ,QA6BtB;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,4BAA4B,CAC1C,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,SAAS,EAAE,CAAC,EAAE,EAAE,SAAS,KAAK,IAAI,QAgDnC;AAED;;;;GAIG;AACH,wBAAgB,2BAA2B,CACzC,WAAW,EAAE,MAAM,EACnB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,SAAS,EAAE,CAAC,EAAE,EAAE,SAAS,KAAK,IAAI,QAUnC"}

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

@@ -1,12 +1,13 @@
-import { getRenderableSlabPolygon } from '../../lib/slab-polygon';
-import { isLevelAtSiteDatum, isLevelBaseConsumer } from '../../lib/terrain-support';
-import { nodeRegistry } from '../../registry';
-import { getLevelBelow } from '../../services/storey';
-import useLiveTerrain from '../../store/use-live-terrain';
-import useScene from '../../store/use-scene';
-import { getFloorPlacedFootprints } from './floor-placed-elevation';
-import { itemOverlapsPolygon, spatialGridManager, wallOverlapsPolygon, } from './spatial-grid-manager';
-import { GROUND_SUPPORT_ID } from './support-host-id';
+import { subtractPolygonsFromPolygon } from '../../lib/polygon-union.js';
+import { getRenderableSlabPolygon } from '../../lib/slab-polygon.js';
+import { isLevelAtSiteDatum, isLevelBaseConsumer } from '../../lib/terrain-support.js';
+import { nodeRegistry } from '../../registry/index.js';
+import { getLevelBelow } from '../../services/storey.js';
+import useLiveTerrain from '../../store/use-live-terrain.js';
+import useScene from '../../store/use-scene.js';
+import { getFloorPlacedFootprints } from './floor-placed-elevation.js';
+import { itemOverlapsPolygon, spatialGridManager, wallOverlapsPolygon, } from './spatial-grid-manager.js';
+import { GROUND_SUPPORT_ID } from './support-host-id.js';
 export function resolveLevelId(node, nodes) {
     // If the node itself is a level
     if (node.type === 'level')
@@ -98,13 +99,55 @@ export function initSpatialGridSync() {
     const markDirty = (id) => store.getState().markDirty(id);
     // Subscribe to all changes
     const unsubscribeScene = store.subscribe((state, prevState) => {
+        if (state.nodes === prevState.nodes)
+            return;
+        // A bulk slab change (scene load/reload, paste, import) used to run
+        // markNodesOverlappingSlab per slab — two full node scans each, O(slabs ×
+        // nodes). Above the threshold, dirty every possible slab dependent once (a
+        // superset of the per-slab result) and skip the per-slab scans below.
+        const bulkSlabs = countBulkSlabChanges(state.nodes, prevState.nodes) >= BULK_SLAB_CHANGE_THRESHOLD;
+        if (bulkSlabs)
+            markAllSlabDependents(state.nodes, markDirty);
+        const changedSlabContextLevels = new Set();
+        const checkSlabContext = (id) => {
+            const previous = prevState.nodes[id];
+            const next = state.nodes[id];
+            if (previous === next)
+                return;
+            const wallChanged = (previous?.type === 'wall' || next?.type === 'wall') &&
+                (previous?.type !== 'wall' ||
+                    next?.type !== 'wall' ||
+                    previous.parentId !== next.parentId ||
+                    previous.start !== next.start ||
+                    previous.end !== next.end ||
+                    previous.thickness !== next.thickness ||
+                    previous.curveOffset !== next.curveOffset);
+            const slabChanged = (previous?.type === 'slab' || next?.type === 'slab') &&
+                (previous?.type !== 'slab' ||
+                    next?.type !== 'slab' ||
+                    previous.parentId !== next.parentId ||
+                    previous.polygon !== next.polygon ||
+                    previous.elevation !== next.elevation);
+            if (!(wallChanged || slabChanged))
+                return;
+            if (previous)
+                changedSlabContextLevels.add(resolveLevelId(previous, prevState.nodes));
+            if (next)
+                changedSlabContextLevels.add(resolveLevelId(next, state.nodes));
+        };
+        for (const id in prevState.nodes)
+            checkSlabContext(id);
+        for (const id in state.nodes) {
+            if (!prevState.nodes[id])
+                checkSlabContext(id);
+        }
         // Detect added nodes
         for (const [id, node] of Object.entries(state.nodes)) {
             if (!prevState.nodes[id]) {
                 const levelId = resolveLevelId(node, state.nodes);
                 spatialGridManager.handleNodeCreated(node, levelId);
                 // When a slab is added, mark overlapping items/walls dirty
-                if (node.type === 'slab') {
+                if (node.type === 'slab' && !bulkSlabs) {
                     markNodesOverlappingSlab(node, state.nodes, markDirty);
                     markCoveringDependentsBelow(levelId, state.nodes, markDirty);
                 }
@@ -122,8 +165,8 @@ export function initSpatialGridSync() {
                 const levelId = resolveLevelId(node, prevState.nodes);
                 spatialGridManager.handleNodeDeleted(id, node.type, levelId);
                 // When a slab is removed, mark items/walls that were on it dirty (using current state)
-                if (node.type === 'slab') {
-                    markNodesOverlappingSlab(node, state.nodes, markDirty);
+                if (node.type === 'slab' && !bulkSlabs) {
+                    markNodesOverlappingSlab(node, state.nodes, markDirty, prevState.nodes);
                     markCoveringDependentsBelow(levelId, state.nodes, markDirty);
                 }
                 // Deleting a sculpted site drops the ground back to the datum, so its
@@ -160,7 +203,9 @@ export function initSpatialGridSync() {
                     const levelId = resolveLevelId(node, state.nodes);
                     spatialGridManager.handleNodeUpdated(node, levelId);
                 }
-                markSlabChangeDependents(prev, node, state.nodes, markDirty);
+                if (!bulkSlabs) {
+                    markSlabChangeDependents(prev, node, state.nodes, markDirty, prevState.nodes);
+                }
             }
             else if (node.type === 'level' && prev.type === 'level') {
                 if (node.height !== prev.height) {
@@ -188,6 +233,38 @@ export function initSpatialGridSync() {
                 }
             }
         }
+        // Unchanged slabs can lose an adopted wall band or a sibling seam. Their
+        // stored polygons cannot identify objects standing on the former boundary.
+        if (changedSlabContextLevels.size === 0)
+            return;
+        const beforeContext = slabBoundaryContext(prevState.nodes, changedSlabContextLevels);
+        const afterContext = slabBoundaryContext(state.nodes, changedSlabContextLevels);
+        for (const context of afterContext.values()) {
+            for (const slab of context.slabs) {
+                const previous = prevState.nodes[slab.id];
+                if (previous?.type !== 'slab')
+                    continue;
+                if (slab.parentId !== previous.parentId ||
+                    slab.polygon !== previous.polygon ||
+                    slab.elevation !== previous.elevation ||
+                    slab.holes !== previous.holes)
+                    continue;
+                const previousContext = beforeContext.get(resolveLevelId(previous, prevState.nodes));
+                const beforePolygon = cachedSlabPolygon(previous, previousContext);
+                const afterPolygon = cachedSlabPolygon(slab, context);
+                if (beforePolygon.length === afterPolygon.length &&
+                    beforePolygon.every((point, i) => arraysEqual(point, afterPolygon[i])))
+                    continue;
+                // Support only changed in the gained/lost bands, not across the slab interior.
+                const changedBands = [
+                    ...subtractPolygonsFromPolygon(beforePolygon, [afterPolygon]),
+                    ...subtractPolygonsFromPolygon(afterPolygon, [beforePolygon]),
+                ];
+                for (const polygon of changedBands) {
+                    markNodesOverlappingPolygon(resolveLevelId(slab, state.nodes), polygon, state.nodes, markDirty, context.consumers);
+                }
+            }
+        }
     });
     // Live terrain is deliberately not written into `useScene` per dab: doing so
     // would encode the whole field, flood history, and wake every scene subscriber.
@@ -202,6 +279,61 @@ export function initSpatialGridSync() {
         unsubscribeLiveTerrain();
     };
 }
+/**
+ * Bulk slab-change guard. A scene load, reload, paste or import changes tens to
+ * thousands of slabs in one store write, and scanning every node twice per slab
+ * is O(slabs × nodes): a 4,600-slab scene blocked the main thread for ~5 s on
+ * every load. When at least this many slabs are added, removed or reshaped in
+ * one write, `markAllSlabDependents` dirties every node any slab could affect,
+ * once, and the per-slab scans are skipped. The marks are a superset of the
+ * per-slab result — and `setScene` marks every node dirty right after `set()`
+ * regardless — so load-time behaviour is unchanged; the saving is the scans.
+ */
+export const BULK_SLAB_CHANGE_THRESHOLD = 32;
+export function countBulkSlabChanges(nodes, prevNodes) {
+    let count = 0;
+    for (const id in nodes) {
+        const node = nodes[id];
+        if (node.type !== 'slab')
+            continue;
+        const prev = prevNodes[id];
+        if (prev?.type !== 'slab' ||
+            prev.polygon !== node.polygon ||
+            prev.elevation !== node.elevation ||
+            prev.holes !== node.holes) {
+            count++;
+        }
+    }
+    for (const id in prevNodes) {
+        if (prevNodes[id].type === 'slab' && !nodes[id])
+            count++;
+    }
+    return count;
+}
+/**
+ * Every node a slab change can dirty, without looking at any slab: walls and
+ * ceilings (overlap and covering-below rules), stairs (deck attachment) and
+ * level-hosted floor-placed kinds (the generic re-elevation sweep).
+ */
+export function markAllSlabDependents(nodes, markDirty) {
+    for (const id in nodes) {
+        const node = nodes[id];
+        if (node.type === 'wall' || node.type === 'ceiling' || node.type === 'stair') {
+            markDirty(node.id);
+            continue;
+        }
+        const floorPlaced = nodeRegistry.get(node.type)?.capabilities?.floorPlaced;
+        if (!floorPlaced)
+            continue;
+        if (floorPlaced.applies && !floorPlaced.applies(node))
+            continue;
+        const parentId = node.parentId;
+        const parent = parentId ? nodes[parentId] : null;
+        if (parent && parent.type !== 'level')
+            continue;
+        markDirty(node.id);
+    }
+}
 function arraysEqual(a, b) {
     return a.length === b.length && a.every((v, i) => v === b[i]);
 }
@@ -240,12 +372,13 @@ export function markDeckAttachedStairs(slabId, nodes, markDirty) {
  * Dirty every consumer of a slab's top or underside. Kept pure so committed
  * scene writes and live handle previews use the same dependency boundary.
  */
-export function markSlabChangeDependents(previous, next, nodes, markDirty) {
-    const supportChanged = next.polygon !== previous.polygon ||
+export function markSlabChangeDependents(previous, next, nodes, markDirty, previousNodes = nodes) {
+    const supportChanged = next.parentId !== previous.parentId ||
+        next.polygon !== previous.polygon ||
         next.elevation !== previous.elevation ||
         next.holes !== previous.holes;
     if (supportChanged) {
-        markNodesOverlappingSlab(previous, nodes, markDirty);
+        markNodesOverlappingSlab(previous, nodes, markDirty, previousNodes);
         markNodesOverlappingSlab(next, nodes, markDirty);
     }
     if (next.elevation !== previous.elevation) {
@@ -254,7 +387,14 @@ export function markSlabChangeDependents(previous, next, nodes, markDirty) {
     if (supportChanged ||
         next.thickness !== previous.thickness ||
         next.recessed !== previous.recessed) {
-        markCoveringDependentsBelow(resolveLevelId(next, nodes), nodes, markDirty);
+        const nextLevelId = resolveLevelId(next, nodes);
+        markCoveringDependentsBelow(nextLevelId, nodes, markDirty);
+        if (next.parentId !== previous.parentId) {
+            const previousLevelId = resolveLevelId(previous, previousNodes);
+            if (previousLevelId !== nextLevelId) {
+                markCoveringDependentsBelow(previousLevelId, nodes, markDirty);
+            }
+        }
     }
 }
 /**
@@ -344,18 +484,8 @@ export function markCoveringDependentsBelow(slabLevelId, nodes, markDirty) {
         }
     }
 }
-/**
- * Mark all floor items and walls that may be affected by a slab change as dirty.
- */
-function markNodesOverlappingSlab(slab, nodes, markDirty) {
-    if (slab.polygon.length < 3)
-        return;
+function renderableSlabPolygon(slab, nodes) {
     const slabLevelId = resolveLevelId(slab, nodes);
-    // Walls AND floor-placed nodes follow the slab's RENDERED footprint
-    // (band-adopted edges reach the wall's outer face), so the dirty gate
-    // must test the same polygon the support queries re-evaluate — a stored
-    // polygon that stops short of the wall body would otherwise never
-    // re-elevate nodes sitting over the adopted band.
     const levelWalls = [];
     const siblingSlabs = [];
     for (const node of Object.values(nodes)) {
@@ -368,8 +498,20 @@ function markNodesOverlappingSlab(slab, nodes, markDirty) {
             siblingSlabs.push(node);
         }
     }
-    const renderedPolygon = getRenderableSlabPolygon(slab, { walls: levelWalls, siblingSlabs });
-    for (const node of Object.values(nodes)) {
+    return getRenderableSlabPolygon(slab, { walls: levelWalls, siblingSlabs });
+}
+/**
+ * Mark all floor items and walls that may be affected by a slab change as dirty.
+ */
+function markNodesOverlappingSlab(slab, nodes, markDirty, contextNodes = nodes) {
+    if (slab.polygon.length < 3)
+        return;
+    const slabLevelId = resolveLevelId(slab, contextNodes);
+    const renderedPolygon = renderableSlabPolygon(slab, contextNodes);
+    markNodesOverlappingPolygon(slabLevelId, renderedPolygon, nodes, markDirty);
+}
+function markNodesOverlappingPolygon(slabLevelId, renderedPolygon, nodes, markDirty, candidates = Object.values(nodes)) {
+    for (const node of candidates) {
         if (node.type === 'wall') {
             const wall = node;
             if (resolveLevelId(node, nodes) !== slabLevelId)
@@ -412,3 +554,38 @@ function markNodesOverlappingSlab(slab, nodes, markDirty) {
         }
     }
 }
+function slabBoundaryContext(nodes, levels) {
+    const contexts = new Map();
+    for (const id in nodes) {
+        const node = nodes[id];
+        const floorPlaced = nodeRegistry.get(node.type)?.capabilities?.floorPlaced;
+        if (node.type !== 'wall' && node.type !== 'slab' && !floorPlaced)
+            continue;
+        const levelId = resolveLevelId(node, nodes);
+        if (!levels.has(levelId))
+            continue;
+        let context = contexts.get(levelId);
+        if (!context) {
+            context = { walls: [], slabs: [], consumers: [], polygons: new Map() };
+            contexts.set(levelId, context);
+        }
+        if (node.type === 'wall')
+            context.walls.push(node);
+        if (node.type === 'slab')
+            context.slabs.push(node);
+        if (node.type === 'wall' || floorPlaced)
+            context.consumers.push(node);
+    }
+    return contexts;
+}
+function cachedSlabPolygon(slab, context) {
+    let polygon = context.polygons.get(slab.id);
+    if (!polygon) {
+        polygon = getRenderableSlabPolygon(slab, {
+            walls: context.walls,
+            siblingSlabs: context.slabs.filter((sibling) => sibling.id !== slab.id),
+        });
+        context.polygons.set(slab.id, polygon);
+    }
+    return polygon;
+}

package/dist/hooks/spatial-grid/support-host-patch.d.ts

@@ -1,4 +1,4 @@
-import type { AnyNode, FenceNode, WallNode } from '../../schema';
+import type { AnyNode, AnyNodeId, FenceNode, WallNode } from '../../schema/index.js';
 export type SupportSlabPatch = {
     supportSlabId: string | undefined;
 };
@@ -13,8 +13,29 @@ export type SupportSlabPatchOptions = {
     maxElevation?: number | null;
     /** Pointer- or snap-decided host. Ground is a first-class support source. */
     preferredSlabId?: string | null;
+    /** Persist even an unambiguous host so later overlapping slabs cannot re-elect it. */
+    pinSupport?: boolean;
+};
+export type FrozenFloorPlacementOptions = {
+    /** Canonical position before floor/support lift is applied. */
+    position: [number, number, number];
+    rotation?: unknown;
+    /** Exact level-local elevation hit on a non-slab construction surface. */
+    elevation: number;
+    /** Slab/ground supporting that construction surface, when known. */
+    preferredSlabId?: string | null;
 };
 export declare function resolveSupportSlabPatch(node: AnyNode, nodes: Record<string, AnyNode>, options?: SupportSlabPatchOptions): SupportSlabPatch;
+/**
+ * Freeze an exact pointed node-top elevation into a floor-placed node's
+ * existing canonical Y offset, while pinning the slab/ground beneath that
+ * surface. This deliberately does not create a live hosting edge to the
+ * pointed node: arbitrary mesh faces can be edited or sloped, so placement
+ * captures the plane the user chose at commit time.
+ */
+export declare function resolveFrozenFloorPlacementPatch(node: AnyNode, nodes: Record<string, AnyNode>, options: FrozenFloorPlacementOptions): SupportSlabPatch & {
+    position: [number, number, number];
+};
 export declare function resolveWallSupportSlabPatch(wall: WallNode, nodes: Record<string, AnyNode>, options?: SupportSlabPatchOptions): SupportSlabPatch;
 /**
  * Re-elect a moved wall without discarding an explicit construction source.
@@ -48,4 +69,27 @@ export type FenceSupportInput = Pick<FenceNode, 'start' | 'end' | 'curveOffset'
  * via the same absent-host default. Pure; exported for tests.
  */
 export declare function resolveFenceSupportSlabPatch(fence: FenceSupportInput, nodes: Record<string, AnyNode>, options?: SupportSlabPatchOptions): SupportSlabPatch;
+export type FenceConstructionOptions = {
+    supportCap?: number | null;
+    preferredSupportSlabId?: string | null;
+    constructionElevation?: number | null;
+};
+export declare function resolveFenceConstructionSupport(fence: FenceNode, levelId: string, nodes: Record<string, AnyNode>, options?: FenceConstructionOptions): FenceNode;
+export type WallConstructionOptions = {
+    supportCap?: number | null;
+    preferredSupportSlabId?: string | null;
+    constructionElevation?: number | null;
+    constructionHeight?: number | null;
+    flatConstructionBase?: boolean;
+    constructionSourceNodeId?: AnyNodeId | null;
+};
+export declare function resolveTerrainWallConstructionOptions(nodes: Record<string, AnyNode>, levelId: string, point: readonly [number, number], defaults?: Record<string, unknown>): WallConstructionOptions | undefined;
+export type WallConstructionResolution = {
+    walls: WallNode[];
+    sourceSupportUpdate: {
+        id: AnyNodeId;
+        data: SupportSlabPatch;
+    } | null;
+};
+export declare function resolveWallConstruction(nodes: Record<string, AnyNode>, levelId: string, walls: readonly WallNode[], options?: WallConstructionOptions): WallConstructionResolution;
 //# sourceMappingURL=support-host-patch.d.ts.map

package/dist/hooks/spatial-grid/support-host-patch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"support-host-patch.d.ts","sourceRoot":"","sources":["../../../src/hooks/spatial-grid/support-host-patch.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAa,SAAS,EAAY,QAAQ,EAAE,MAAM,cAAc,CAAA;AAKrF,MAAM,MAAM,gBAAgB,GAAG;IAAE,aAAa,EAAE,MAAM,GAAG,SAAS,CAAA;CAAE,CAAA;AAEpE,MAAM,MAAM,uBAAuB,GAAG;IACpC;;;;;;OAMG;IACH,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAC5B,6EAA6E;IAC7E,eAAe,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CAChC,CAAA;AAED,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,OAAO,EACb,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,OAAO,CAAC,EAAE,uBAAuB,GAChC,gBAAgB,CAiDlB;AAED,wBAAgB,2BAA2B,CACzC,IAAI,EAAE,QAAQ,EACd,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,OAAO,CAAC,EAAE,uBAAuB,GAChC,gBAAgB,CAiDlB;AAED;;;;;;;GAOG;AACH,wBAAgB,gCAAgC,CAC9C,IAAI,EAAE,QAAQ,EACd,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,gBAAgB,CAIlB;AAED,sFAAsF;AACtF,MAAM,MAAM,iBAAiB,GAAG,IAAI,CAClC,SAAS,EACT,OAAO,GAAG,KAAK,GAAG,aAAa,GAAG,MAAM,GAAG,WAAW,GAAG,UAAU,CACpE,CAAA;AA4BD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,4BAA4B,CAC1C,KAAK,EAAE,iBAAiB,EACxB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,OAAO,CAAC,EAAE,uBAAuB,GAChC,gBAAgB,CA4ClB"}
+{"version":3,"file":"support-host-patch.d.ts","sourceRoot":"","sources":["../../../src/hooks/spatial-grid/support-host-patch.ts"],"names":[],"mappings":"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"}

package/dist/hooks/spatial-grid/support-host-patch.js

@@ -1,7 +1,9 @@
-import { nodeRegistry } from '../../registry';
-import { getWallCurveFrameAt, isCurvedWall } from '../../systems/wall/wall-curve';
-import { GROUND_SUPPORT_ID, getFloorPlacedFootprints } from './floor-placed-elevation';
-import { SUPPORT_ELEVATION_EPSILON, spatialGridManager } from './spatial-grid-manager';
+import { levelBaseElevationAt, terrainSupportLift } from '../../lib/terrain-support.js';
+import { nodeRegistry } from '../../registry/index.js';
+import { DEFAULT_LEVEL_HEIGHT } from '../../services/level-height.js';
+import { getWallCurveFrameAt, isCurvedWall } from '../../systems/wall/wall-curve.js';
+import { GROUND_SUPPORT_ID, getFloorPlacedElevation, getFloorPlacedFootprints, } from './floor-placed-elevation.js';
+import { SUPPORT_ELEVATION_EPSILON, spatialGridManager } from './spatial-grid-manager.js';
 export function resolveSupportSlabPatch(node, nodes, options) {
     const floorPlaced = nodeRegistry.get(node.type)?.capabilities?.floorPlaced;
     if (!floorPlaced || (floorPlaced.applies && !floorPlaced.applies(node))) {
@@ -13,6 +15,21 @@ export function resolveSupportSlabPatch(node, nodes, options) {
         return { supportSlabId: undefined };
     const maxElevation = options?.maxElevation;
     const footprints = getFloorPlacedFootprints(floorPlaced, node, { nodes });
+    if (options?.preferredSlabId === GROUND_SUPPORT_ID) {
+        return { supportSlabId: GROUND_SUPPORT_ID };
+    }
+    if (options?.preferredSlabId) {
+        for (const footprint of footprints) {
+            const position = footprint.position ?? node.position;
+            if (!Array.isArray(position) || position.length !== 3)
+                continue;
+            const elevation = spatialGridManager.getHostSlabElevationForFootprint(parent.id, options.preferredSlabId, position, footprint.dimensions, footprint.rotation);
+            if (elevation !== null &&
+                (maxElevation == null || elevation <= maxElevation + SUPPORT_ELEVATION_EPSILON)) {
+                return { supportSlabId: options.preferredSlabId };
+            }
+        }
+    }
     const candidateElevations = new Set();
     let winner = null;
     let cappedOut = false;
@@ -32,12 +49,54 @@ export function resolveSupportSlabPatch(node, nodes, options) {
         }
     }
     if (winner !== null) {
-        return { supportSlabId: candidateElevations.size >= 2 ? winner.slabId : undefined };
+        return {
+            supportSlabId: options?.pinSupport || candidateElevations.size >= 2 ? winner.slabId : undefined,
+        };
     }
     // Capped election chose the ground while overlapping slabs sit above the
     // cap: persist the ground host, or the uncapped per-frame election would
     // lift the committed node back onto the deck.
-    return { supportSlabId: cappedOut ? GROUND_SUPPORT_ID : undefined };
+    return {
+        supportSlabId: options?.pinSupport || cappedOut ? GROUND_SUPPORT_ID : undefined,
+    };
+}
+/**
+ * Freeze an exact pointed node-top elevation into a floor-placed node's
+ * existing canonical Y offset, while pinning the slab/ground beneath that
+ * surface. This deliberately does not create a live hosting edge to the
+ * pointed node: arbitrary mesh faces can be edited or sloped, so placement
+ * captures the plane the user chose at commit time.
+ */
+export function resolveFrozenFloorPlacementPatch(node, nodes, options) {
+    const effectiveNode = {
+        ...node,
+        position: options.position,
+        ...(options.rotation !== undefined ? { rotation: options.rotation } : {}),
+    };
+    const floorPlaced = nodeRegistry.get(effectiveNode.type)?.capabilities?.floorPlaced;
+    if (!floorPlaced || (floorPlaced.applies && !floorPlaced.applies(effectiveNode))) {
+        return { supportSlabId: undefined, position: options.position };
+    }
+    const supportPatch = resolveSupportSlabPatch(effectiveNode, nodes, {
+        maxElevation: options.elevation,
+        preferredSlabId: options.preferredSlabId,
+        pinSupport: true,
+    });
+    const pinnedNode = { ...effectiveNode, ...supportPatch };
+    const supportElevation = getFloorPlacedElevation({
+        node: pinnedNode,
+        nodes,
+        position: options.position,
+        rotation: options.rotation,
+    });
+    return {
+        ...supportPatch,
+        position: [
+            options.position[0],
+            options.position[1] + options.elevation - supportElevation,
+            options.position[2],
+        ],
+    };
 }
 export function resolveWallSupportSlabPatch(wall, nodes, options) {
     const parent = wall.parentId ? nodes[wall.parentId] : null;
@@ -138,6 +197,9 @@ export function resolveFenceSupportSlabPatch(fence, nodes, options) {
     const points = fenceCenterlinePoints(fence);
     const candidateElevations = new Set();
     let winner = null;
+    if (options?.preferredSlabId === GROUND_SUPPORT_ID) {
+        return { supportSlabId: GROUND_SUPPORT_ID };
+    }
     for (let i = 1; i < points.length; i++) {
         const [ax, az] = points[i - 1];
         const [bx, bz] = points[i];
@@ -149,6 +211,13 @@ export function resolveFenceSupportSlabPatch(fence, nodes, options) {
         // getItemFootprint's rotation convention: local +X maps to
         // (cos yRot, sin yRot) in XZ, so the segment angle aligns the band.
         const rotation = [0, Math.atan2(bz - az, bx - ax), 0];
+        if (options?.preferredSlabId) {
+            const preferredElevation = spatialGridManager.getHostSlabElevationForFootprint(parent.id, options.preferredSlabId, position, dimensions, rotation);
+            if (preferredElevation !== null &&
+                (maxElevation == null || preferredElevation <= maxElevation + SUPPORT_ELEVATION_EPSILON)) {
+                return { supportSlabId: options.preferredSlabId };
+            }
+        }
         const candidates = spatialGridManager.getSupportCandidatesForFootprint(parent.id, position, dimensions, rotation);
         for (const candidate of candidates)
             candidateElevations.add(candidate.elevation);
@@ -157,8 +226,104 @@ export function resolveFenceSupportSlabPatch(fence, nodes, options) {
             winner = { slabId: support.slabId, elevation: support.elevation };
         }
     }
-    if (winner === null)
-        return { supportSlabId: undefined };
+    if (winner === null) {
+        return { supportSlabId: options?.pinSupport ? GROUND_SUPPORT_ID : undefined };
+    }
     const persist = candidateElevations.size >= 2 || winner.elevation > SUPPORT_ELEVATION_EPSILON;
-    return { supportSlabId: persist ? winner.slabId : undefined };
+    return { supportSlabId: options?.pinSupport || persist ? winner.slabId : undefined };
+}
+export function resolveFenceConstructionSupport(fence, levelId, nodes, options) {
+    const supportPatch = resolveFenceSupportSlabPatch({ ...fence, parentId: levelId }, nodes, {
+        maxElevation: options?.supportCap ?? null,
+        preferredSlabId: options?.preferredSupportSlabId ?? null,
+        pinSupport: options?.constructionElevation != null,
+    });
+    const host = supportPatch.supportSlabId ? nodes[supportPatch.supportSlabId] : null;
+    const baseElevation = host?.type === 'slab'
+        ? host.elevation
+        : levelBaseElevationAt(nodes, levelId, fence.start[0], fence.start[1]);
+    const supportOffset = options?.constructionElevation == null
+        ? fence.supportOffset
+        : options.constructionElevation - baseElevation;
+    return {
+        ...fence,
+        ...supportPatch,
+        supportOffset: supportOffset != null && Math.abs(supportOffset) > 1e-6 ? supportOffset : undefined,
+    };
+}
+export function resolveTerrainWallConstructionOptions(nodes, levelId, point, defaults) {
+    const constructionElevation = terrainSupportLift(nodes, levelId, point[0], point[1]);
+    if (constructionElevation == null)
+        return undefined;
+    const level = nodes[levelId];
+    const constructionHeight = typeof defaults?.height === 'number'
+        ? defaults.height
+        : level?.type === 'level'
+            ? (level.height ?? DEFAULT_LEVEL_HEIGHT)
+            : DEFAULT_LEVEL_HEIGHT;
+    return {
+        constructionElevation,
+        constructionHeight,
+        supportCap: constructionElevation,
+    };
+}
+export function resolveWallConstruction(nodes, levelId, walls, options) {
+    let resolvedNodes = nodes;
+    let sourceSupportUpdate = null;
+    const constructionSourceNodeId = options?.constructionSourceNodeId;
+    const constructionSourceIsSlab = constructionSourceNodeId
+        ? nodes[constructionSourceNodeId]?.type === 'slab'
+        : false;
+    if (constructionSourceNodeId) {
+        const sourceNode = nodes[constructionSourceNodeId];
+        const currentSupport = sourceNode && 'supportSlabId' in sourceNode
+            ? sourceNode.supportSlabId
+            : undefined;
+        if (sourceNode && currentSupport == null) {
+            const data = resolveSupportSlabPatch(sourceNode, nodes, { pinSupport: true });
+            if (data.supportSlabId != null) {
+                sourceSupportUpdate = { id: constructionSourceNodeId, data };
+                resolvedNodes = {
+                    ...nodes,
+                    [constructionSourceNodeId]: { ...sourceNode, ...data },
+                };
+            }
+        }
+    }
+    const resolvedWalls = walls.map((createdWall) => {
+        const wallWithParent = { ...createdWall, parentId: levelId };
+        const terrainBase = terrainSupportLift(resolvedNodes, levelId, createdWall.start[0], createdWall.start[1]);
+        const wallOptions = options?.preferredSupportSlabId === GROUND_SUPPORT_ID &&
+            terrainBase == null &&
+            !options.flatConstructionBase
+            ? undefined
+            : options;
+        const flatConstructionBase = wallOptions?.flatConstructionBase === true && !constructionSourceIsSlab;
+        const preferredSupportSlabId = flatConstructionBase
+            ? GROUND_SUPPORT_ID
+            : (wallOptions?.preferredSupportSlabId ??
+                (wallOptions?.constructionElevation != null && terrainBase != null
+                    ? GROUND_SUPPORT_ID
+                    : null));
+        const supportPatch = resolveWallSupportSlabPatch(wallWithParent, resolvedNodes, {
+            maxElevation: wallOptions?.supportCap ?? null,
+            preferredSlabId: preferredSupportSlabId,
+        });
+        const sourceSupport = spatialGridManager.getSlabSupportForWall(levelId, createdWall.start, createdWall.end, createdWall.curveOffset, createdWall.thickness, supportPatch.supportSlabId, wallOptions?.supportCap ?? null);
+        const groundDraft = preferredSupportSlabId === GROUND_SUPPORT_ID && (terrainBase != null || flatConstructionBase);
+        const supportOffset = groundDraft && wallOptions?.constructionElevation != null
+            ? wallOptions.constructionElevation - sourceSupport.elevation
+            : undefined;
+        const preserveDraftHeight = groundDraft &&
+            createdWall.height == null &&
+            wallOptions?.constructionHeight != null &&
+            wallOptions.constructionElevation != null;
+        return {
+            ...wallWithParent,
+            ...supportPatch,
+            height: preserveDraftHeight ? wallOptions.constructionHeight : createdWall.height,
+            supportOffset: supportOffset != null && Math.abs(supportOffset) > 1e-6 ? supportOffset : undefined,
+        };
+    });
+    return { walls: resolvedWalls, sourceSupportUpdate };
 }

package/dist/hooks/spatial-grid/use-spatial-query.d.ts

@@ -1,4 +1,4 @@
-import type { CeilingNode, LevelNode, WallNode } from '../../schema';
+import type { CeilingNode, LevelNode, WallNode } from '../../schema/index.js';
 export declare function useSpatialQuery(): {
     canPlaceOnFloor: (levelId: LevelNode["id"], position: [number, number, number], dimensions: [number, number, number], rotation: [number, number, number], ignoreIds?: string[]) => {
         valid: boolean;

package/dist/hooks/spatial-grid/use-spatial-query.js

@@ -1,5 +1,5 @@
 import { useCallback } from 'react';
-import { spatialGridManager } from './spatial-grid-manager';
+import { spatialGridManager } from './spatial-grid-manager.js';
 export function useSpatialQuery() {
     const canPlaceOnFloor = useCallback((levelId, position, dimensions, rotation, ignoreIds) => {
         return spatialGridManager.canPlaceOnFloor(levelId, position, dimensions, rotation, ignoreIds);