@pascal-app/core 0.9.2 → 1.0.0-beta.2

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

@@ -1,4 +1,4 @@
-import type { AnyNode, AnyNodeId } from '../../schema';
+import type { AnyNode, AnyNodeId, LevelNode, SlabNode } from '../../schema';
 export declare function resolveLevelId(node: AnyNode, nodes: Record<string, AnyNode>): string;
 /**
  * Walks the parent chain of `nodeId` and returns the id of the first ancestor
@@ -28,4 +28,49 @@ export declare function findLevelAncestorId(nodeId: AnyNodeId, nodes: Record<str
  */
 export declare function resolveBuildingForLevel(levelId: AnyNodeId, nodes: Record<AnyNodeId, AnyNode>): AnyNodeId | null;
 export declare function initSpatialGridSync(): () => void;
+/**
+ * A level's stored height moved: plane-bound walls follow the new plane,
+ * stair rise re-derives, and ceilings/fences re-resolve their clamp — mark
+ * them all so their systems rebuild. Restacking the level containers alone
+ * leaves their geometry stale.
+ */
+export declare function markLevelHeightDependents(level: LevelNode, nodes: Record<string, AnyNode>, markDirty: (id: AnyNodeId) => void): void;
+/**
+ * A deck slab's walking surface moved: stairs attached to it via
+ * `deckSlabId` derive their rise from that elevation, so their geometry
+ * (and rise-derived affordances) must rebuild.
+ */
+export declare function markDeckAttachedStairs(slabId: string, nodes: Record<string, AnyNode>, markDirty: (id: AnyNodeId) => void): void;
+/**
+ * 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 declare function markSlabChangeDependents(previous: SlabNode, next: SlabNode, nodes: Record<string, AnyNode>, markDirty: (id: AnyNodeId) => void): void;
+/**
+ * The sculpted ground moved: every node the terrain *supports* must re-elevate.
+ *
+ * The other rules in this file gate on a footprint overlapping the changed
+ * surface. Terrain has no such gate — a stroke rewrites a field that spans the
+ * whole lot, and the resolver samples it at each node's own XZ — so the sweep is
+ * every floor-placed node on a storey at grade, plus every wall whose explicit
+ * terrain infill samples that field. During a live stroke it fires per dab, but
+ * dirty ids coalesce in a Set until the frame systems consume them; the scene
+ * graph itself is still written only once on commit.
+ *
+ * Without this a sculpt silently desyncs the scene from its own ground. Nothing
+ * re-runs `getFloorPlacedElevation`, so the React commit that rebinds a node
+ * group's base Y leaves it there: a column that was resting on a hillside drops
+ * to the datum and stays buried under the terrain it used to stand on.
+ *
+ * Gated on `isLevelAtSiteDatum` — the same predicate `terrainSupportLift` uses to
+ * decide whether it drapes at all, so the two cannot disagree about which storey
+ * is on the ground.
+ */
+export declare function markTerrainSupportDependents(nodes: Record<string, AnyNode>, markDirty: (id: AnyNodeId) => void): void;
+/**
+ * A slab on `slabLevelId` was created/deleted or changed shape/placement:
+ * the covering bound (slab underside) over the level BELOW moved, so that
+ * level's plane-bound walls and clamped ceilings must rebuild.
+ */
+export declare function markCoveringDependentsBelow(slabLevelId: string, nodes: Record<string, AnyNode>, markDirty: (id: AnyNodeId) => void): void;
 //# sourceMappingURL=spatial-grid-sync.d.ts.map

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":"AAEA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAsB,MAAM,cAAc,CAAA;AAS1E,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,CAgFhD"}
+{"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"}

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

@@ -1,8 +1,12 @@
 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';
 export function resolveLevelId(node, nodes) {
     // If the node itself is a level
     if (node.type === 'level')
@@ -93,7 +97,7 @@ export function initSpatialGridSync() {
     // 2. Then subscribe to future changes
     const markDirty = (id) => store.getState().markDirty(id);
     // Subscribe to all changes
-    const unsubscribe = store.subscribe((state, prevState) => {
+    const unsubscribeScene = store.subscribe((state, prevState) => {
         // Detect added nodes
         for (const [id, node] of Object.entries(state.nodes)) {
             if (!prevState.nodes[id]) {
@@ -102,6 +106,13 @@ export function initSpatialGridSync() {
                 // When a slab is added, mark overlapping items/walls dirty
                 if (node.type === 'slab') {
                     markNodesOverlappingSlab(node, state.nodes, markDirty);
+                    markCoveringDependentsBelow(levelId, state.nodes, markDirty);
+                }
+                // A site arriving with terrain already on it (scene load, paste,
+                // imported elevation data) is the same event as a stroke: ground exists
+                // where flat ground was assumed.
+                if (node.type === 'site' && node.terrain) {
+                    markTerrainSupportDependents(state.nodes, markDirty);
                 }
             }
         }
@@ -113,6 +124,12 @@ export function initSpatialGridSync() {
                 // 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);
+                    markCoveringDependentsBelow(levelId, state.nodes, markDirty);
+                }
+                // Deleting a sculpted site drops the ground back to the datum, so its
+                // contents have to come down with it.
+                if (node.type === 'site' && node.terrain) {
+                    markTerrainSupportDependents(state.nodes, markDirty);
                 }
             }
         }
@@ -136,23 +153,197 @@ export function initSpatialGridSync() {
                 }
             }
             else if (node.type === 'slab' && prev.type === 'slab') {
-                if (node.polygon !== prev.polygon ||
+                const supportChanged = node.polygon !== prev.polygon ||
                     node.elevation !== prev.elevation ||
-                    node.holes !== prev.holes) {
+                    node.holes !== prev.holes;
+                if (supportChanged) {
                     const levelId = resolveLevelId(node, state.nodes);
                     spatialGridManager.handleNodeUpdated(node, levelId);
-                    // Mark nodes overlapping old polygon and new polygon as dirty
-                    markNodesOverlappingSlab(prev, state.nodes, markDirty);
-                    markNodesOverlappingSlab(node, state.nodes, markDirty);
+                }
+                markSlabChangeDependents(prev, node, state.nodes, markDirty);
+            }
+            else if (node.type === 'level' && prev.type === 'level') {
+                if (node.height !== prev.height) {
+                    markLevelHeightDependents(node, state.nodes, markDirty);
+                }
+            }
+            else if (node.type === 'site' && prev.type === 'site') {
+                // Object identity, not deep equality: the store is
+                // immutable-by-convention, so a sculpt commit necessarily produces a new
+                // `terrain` object and an unrelated site edit (polygon, name) keeps the
+                // old one. The same reasoning `terrain-source`'s field cache is keyed on.
+                if (node.terrain !== prev.terrain) {
+                    markTerrainSupportDependents(state.nodes, markDirty);
+                }
+            }
+            else if (node.type === 'wall' && prev.type === 'wall') {
+                if (node.start !== prev.start ||
+                    node.end !== prev.end ||
+                    node.curveOffset !== prev.curveOffset ||
+                    node.thickness !== prev.thickness) {
+                    // Rendered slab polygons adopt wall bands, so a wall reshape
+                    // must reach the manager to refresh its wall map and drop the
+                    // level's rendered-polygon cache.
+                    spatialGridManager.handleNodeUpdated(node, resolveLevelId(node, state.nodes));
                 }
             }
         }
     });
-    return unsubscribe;
+    // Live terrain is deliberately not written into `useScene` per dab: doing so
+    // would encode the whole field, flood history, and wake every scene subscriber.
+    // Reuse the committed-terrain dependency sweep against the transient field
+    // instead. Dirty marks coalesce in their Set until the next frame, while an
+    // `end` notification also restores every dependent after an abandoned stroke.
+    const unsubscribeLiveTerrain = useLiveTerrain.subscribe(() => {
+        markTerrainSupportDependents(store.getState().nodes, markDirty);
+    });
+    return () => {
+        unsubscribeScene();
+        unsubscribeLiveTerrain();
+    };
 }
 function arraysEqual(a, b) {
     return a.length === b.length && a.every((v, i) => v === b[i]);
 }
+/**
+ * A level's stored height moved: plane-bound walls follow the new plane,
+ * stair rise re-derives, and ceilings/fences re-resolve their clamp — mark
+ * them all so their systems rebuild. Restacking the level containers alone
+ * leaves their geometry stale.
+ */
+export function markLevelHeightDependents(level, nodes, markDirty) {
+    for (const childId of level.children) {
+        const child = nodes[childId];
+        if (!child)
+            continue;
+        if (child.type === 'wall' ||
+            child.type === 'stair' ||
+            child.type === 'ceiling' ||
+            child.type === 'fence') {
+            markDirty(child.id);
+        }
+    }
+}
+/**
+ * A deck slab's walking surface moved: stairs attached to it via
+ * `deckSlabId` derive their rise from that elevation, so their geometry
+ * (and rise-derived affordances) must rebuild.
+ */
+export function markDeckAttachedStairs(slabId, nodes, markDirty) {
+    for (const node of Object.values(nodes)) {
+        if (node.type === 'stair' && node.deckSlabId === slabId) {
+            markDirty(node.id);
+        }
+    }
+}
+/**
+ * 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 ||
+        next.elevation !== previous.elevation ||
+        next.holes !== previous.holes;
+    if (supportChanged) {
+        markNodesOverlappingSlab(previous, nodes, markDirty);
+        markNodesOverlappingSlab(next, nodes, markDirty);
+    }
+    if (next.elevation !== previous.elevation) {
+        markDeckAttachedStairs(next.id, nodes, markDirty);
+    }
+    if (supportChanged ||
+        next.thickness !== previous.thickness ||
+        next.recessed !== previous.recessed) {
+        markCoveringDependentsBelow(resolveLevelId(next, nodes), nodes, markDirty);
+    }
+}
+/**
+ * The sculpted ground moved: every node the terrain *supports* must re-elevate.
+ *
+ * The other rules in this file gate on a footprint overlapping the changed
+ * surface. Terrain has no such gate — a stroke rewrites a field that spans the
+ * whole lot, and the resolver samples it at each node's own XZ — so the sweep is
+ * every floor-placed node on a storey at grade, plus every wall whose explicit
+ * terrain infill samples that field. During a live stroke it fires per dab, but
+ * dirty ids coalesce in a Set until the frame systems consume them; the scene
+ * graph itself is still written only once on commit.
+ *
+ * Without this a sculpt silently desyncs the scene from its own ground. Nothing
+ * re-runs `getFloorPlacedElevation`, so the React commit that rebinds a node
+ * group's base Y leaves it there: a column that was resting on a hillside drops
+ * to the datum and stays buried under the terrain it used to stand on.
+ *
+ * Gated on `isLevelAtSiteDatum` — the same predicate `terrainSupportLift` uses to
+ * decide whether it drapes at all, so the two cannot disagree about which storey
+ * is on the ground.
+ */
+export function markTerrainSupportDependents(nodes, markDirty) {
+    const gradeLevels = new Map();
+    const isGrade = (levelId) => {
+        let cached = gradeLevels.get(levelId);
+        if (cached === undefined) {
+            cached = isLevelAtSiteDatum(nodes, levelId);
+            gradeLevels.set(levelId, cached);
+        }
+        return cached;
+    };
+    for (const node of Object.values(nodes)) {
+        if (node.type === 'slab' && node.fillToTerrain === true) {
+            if (isGrade(resolveLevelId(node, nodes)))
+                markDirty(node.id);
+            continue;
+        }
+        if (node.type === 'wall') {
+            if (node.supportSlabId !== GROUND_SUPPORT_ID && node.fillToTerrain !== true)
+                continue;
+            if (!isGrade(resolveLevelId(node, nodes)))
+                continue;
+            markDirty(node.id);
+            continue;
+        }
+        const floorPlaced = nodeRegistry.get(node.type)?.capabilities?.floorPlaced;
+        if (!floorPlaced) {
+            // A kind whose geometry builder resolved its own origin from the ground
+            // (`ctx.levelBaseAt`) has that ground baked into its meshes, so it has to
+            // rebuild even though nothing about the node changed. This is the
+            // invalidation half of the builder seam: without it a fence keeps the
+            // hillside it was built on and floats after the next stroke. Kinds that
+            // are `floorPlaced` need no entry here — the sweep below already covers
+            // them, through a mesh transform rather than a rebuild.
+            if (isLevelBaseConsumer(node.type) && isGrade(resolveLevelId(node, nodes))) {
+                markDirty(node.id);
+            }
+            continue;
+        }
+        if (floorPlaced.applies && !floorPlaced.applies(node))
+            continue;
+        // Items hosted on a shelf or table inherit Y from the parent group; only
+        // level-parented nodes read the ground. Mirrors the resolver's own gate.
+        const parentId = node.parentId;
+        const parent = parentId ? nodes[parentId] : null;
+        if (parent && parent.type !== 'level')
+            continue;
+        if (!isGrade(resolveLevelId(node, nodes)))
+            continue;
+        markDirty(node.id);
+    }
+}
+/**
+ * A slab on `slabLevelId` was created/deleted or changed shape/placement:
+ * the covering bound (slab underside) over the level BELOW moved, so that
+ * level's plane-bound walls and clamped ceilings must rebuild.
+ */
+export function markCoveringDependentsBelow(slabLevelId, nodes, markDirty) {
+    const below = getLevelBelow(slabLevelId, nodes);
+    if (!below)
+        return;
+    for (const childId of below.children) {
+        const child = nodes[childId];
+        if (child?.type === 'wall' || child?.type === 'ceiling') {
+            markDirty(child.id);
+        }
+    }
+}
 /**
  * Mark all floor items and walls that may be affected by a slab change as dirty.
  */
@@ -160,10 +351,11 @@ function markNodesOverlappingSlab(slab, nodes, markDirty) {
     if (slab.polygon.length < 3)
         return;
     const slabLevelId = resolveLevelId(slab, nodes);
-    // Walls follow the slab's RENDERED footprint (band-adopted edges reach
-    // the wall's outer face), so the dirty gate must test the same polygon
-    // `getSlabElevationForWall` will re-evaluate — a stored polygon that
-    // stops short of the wall body would otherwise never re-elevate it.
+    // 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)) {
@@ -213,7 +405,7 @@ function markNodesOverlappingSlab(slab, nodes, markDirty) {
         if (!position)
             continue;
         for (const footprint of getFloorPlacedFootprints(floorPlaced, node, { nodes })) {
-            if (itemOverlapsPolygon(footprint.position ?? position, footprint.dimensions, footprint.rotation, slab.polygon, 0.01)) {
+            if (itemOverlapsPolygon(footprint.position ?? position, footprint.dimensions, footprint.rotation, renderedPolygon, 0.01)) {
                 markDirty(node.id);
                 break;
             }

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

@@ -0,0 +1,3 @@
+/** Persisted support host meaning the level base rather than a slab. */
+export declare const GROUND_SUPPORT_ID = "ground";
+//# sourceMappingURL=support-host-id.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"support-host-id.d.ts","sourceRoot":"","sources":["../../../src/hooks/spatial-grid/support-host-id.ts"],"names":[],"mappings":"AAAA,wEAAwE;AACxE,eAAO,MAAM,iBAAiB,WAAW,CAAA"}

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

@@ -0,0 +1,2 @@
+/** Persisted support host meaning the level base rather than a slab. */
+export const GROUND_SUPPORT_ID = 'ground';

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

@@ -0,0 +1,51 @@
+import type { AnyNode, FenceNode, WallNode } from '../../schema';
+export type SupportSlabPatch = {
+    supportSlabId: string | undefined;
+};
+export type SupportSlabPatchOptions = {
+    /**
+     * Pointer-decided support cap (level-local Y) — see
+     * `FloorPlacedElevationArgs.maxElevation`. When set, the persisted host
+     * reproduces the CAPPED election: the elected lower slab wins over a
+     * deck hanging above the cap, and `GROUND_SUPPORT_ID` is stored when the
+     * ground is elected while capped-out slabs still overlap the footprint.
+     */
+    maxElevation?: number | null;
+    /** Pointer- or snap-decided host. Ground is a first-class support source. */
+    preferredSlabId?: string | null;
+};
+export declare function resolveSupportSlabPatch(node: AnyNode, nodes: Record<string, AnyNode>, options?: SupportSlabPatchOptions): SupportSlabPatch;
+export declare function resolveWallSupportSlabPatch(wall: WallNode, nodes: Record<string, AnyNode>, options?: SupportSlabPatchOptions): SupportSlabPatch;
+/**
+ * Re-elect a moved wall without discarding an explicit construction source.
+ *
+ * Move tools change only the wall's plan geometry. A persisted host therefore
+ * remains preferred when it still supports the new footprint; the normal
+ * resolver falls back when a slab no longer overlaps. Ground is also an
+ * explicit source, so preserving it keeps terrain-hosted walls on terrain.
+ */
+export declare function resolveMovedWallSupportSlabPatch(wall: WallNode, nodes: Record<string, AnyNode>): SupportSlabPatch;
+/** Fence-like shape the fence host election needs — plain segment, arc, or spline. */
+export type FenceSupportInput = Pick<FenceNode, 'start' | 'end' | 'curveOffset' | 'path' | 'thickness' | 'parentId'>;
+/**
+ * Support-host patch for a fence: elect the slab the fence line stands on
+ * and persist it as `supportSlabId` (the fence lift resolves absent =
+ * level floor — see `packages/nodes/src/fence/lift.ts`).
+ *
+ * The centerline (chord, sampled arc, or spline path) is turned into thin
+ * band footprints and run through the same candidate machinery items use.
+ * `options.maxElevation` is the pointer-decided cap: aiming at the floor
+ * under a deck elects the floor, aiming at the deck top elects the deck.
+ *
+ * Persist rule: the items ambiguity rule (stacked candidates disagree)
+ * PLUS the elevated-host case — a winner sitting meaningfully above the
+ * level floor must be persisted even when unambiguous (a balcony deck with
+ * nothing underneath), or the commit loses the election entirely since
+ * fences run no per-frame election. A single default ground slab (its top
+ * within `SUPPORT_ELEVATION_EPSILON` of the floor) stays unpersisted so
+ * plain fences keep sitting at the level base. A capped-out election (all
+ * overlapping slabs above the aimed-at ground) also resolves to the floor
+ * via the same absent-host default. Pure; exported for tests.
+ */
+export declare function resolveFenceSupportSlabPatch(fence: FenceSupportInput, nodes: Record<string, AnyNode>, options?: SupportSlabPatchOptions): SupportSlabPatch;
+//# sourceMappingURL=support-host-patch.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,164 @@
+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';
+export function resolveSupportSlabPatch(node, nodes, options) {
+    const floorPlaced = nodeRegistry.get(node.type)?.capabilities?.floorPlaced;
+    if (!floorPlaced || (floorPlaced.applies && !floorPlaced.applies(node))) {
+        return { supportSlabId: undefined };
+    }
+    const parentId = node.parentId ?? null;
+    const parent = parentId ? nodes[parentId] : null;
+    if (parent?.type !== 'level')
+        return { supportSlabId: undefined };
+    const maxElevation = options?.maxElevation;
+    const footprints = getFloorPlacedFootprints(floorPlaced, node, { nodes });
+    const candidateElevations = new Set();
+    let winner = null;
+    let cappedOut = false;
+    for (const footprint of footprints) {
+        const position = footprint.position ?? node.position;
+        if (!Array.isArray(position) || position.length !== 3)
+            continue;
+        const candidates = spatialGridManager.getSupportCandidatesForFootprint(parent.id, position, footprint.dimensions, footprint.rotation);
+        for (const candidate of candidates)
+            candidateElevations.add(candidate.elevation);
+        const support = spatialGridManager.getSlabSupportForItem(parent.id, position, footprint.dimensions, footprint.rotation, maxElevation);
+        if (support.slabId && (!winner || support.elevation > winner.elevation)) {
+            winner = { slabId: support.slabId, elevation: support.elevation };
+        }
+        if (maxElevation != null && support.slabId === null && candidates.length > 0) {
+            cappedOut = true;
+        }
+    }
+    if (winner !== null) {
+        return { supportSlabId: 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 };
+}
+export function resolveWallSupportSlabPatch(wall, nodes, options) {
+    const parent = wall.parentId ? nodes[wall.parentId] : null;
+    if (parent?.type !== 'level')
+        return { supportSlabId: undefined };
+    if (options?.preferredSlabId === GROUND_SUPPORT_ID) {
+        return { supportSlabId: GROUND_SUPPORT_ID };
+    }
+    // Winner under the pointer cap (when given): a deck hanging above the
+    // aimed-at surface can't capture the elected base, so a wall drawn at the
+    // floor underneath it persists the floor slab the user actually targeted.
+    const support = spatialGridManager.getSlabSupportForWall(parent.id, wall.start, wall.end, wall.curveOffset, wall.thickness, options?.preferredSlabId, options?.maxElevation);
+    const candidateElevations = new Set();
+    for (const node of Object.values(nodes)) {
+        if (node.type !== 'slab' || node.parentId !== parent.id)
+            continue;
+        const candidate = node;
+        const preferred = spatialGridManager.getSlabSupportForWall(parent.id, wall.start, wall.end, wall.curveOffset, wall.thickness, candidate.id);
+        if (preferred.electedSlabId === candidate.id) {
+            candidateElevations.add(candidate.elevation);
+        }
+    }
+    if (support.electedSlabId === options?.preferredSlabId) {
+        return { supportSlabId: support.electedSlabId ?? undefined };
+    }
+    if (options?.maxElevation != null &&
+        support.electedSlabId === null &&
+        candidateElevations.size > 0) {
+        return { supportSlabId: GROUND_SUPPORT_ID };
+    }
+    return {
+        supportSlabId: candidateElevations.size >= 2 ? (support.electedSlabId ?? undefined) : undefined,
+    };
+}
+/**
+ * Re-elect a moved wall without discarding an explicit construction source.
+ *
+ * Move tools change only the wall's plan geometry. A persisted host therefore
+ * remains preferred when it still supports the new footprint; the normal
+ * resolver falls back when a slab no longer overlaps. Ground is also an
+ * explicit source, so preserving it keeps terrain-hosted walls on terrain.
+ */
+export function resolveMovedWallSupportSlabPatch(wall, nodes) {
+    return resolveWallSupportSlabPatch(wall, nodes, {
+        preferredSlabId: wall.supportSlabId ?? null,
+    });
+}
+/** Sample count for a curved (sagitta) fence centerline, matching the wall band test. */
+const FENCE_CURVE_SUPPORT_SAMPLES = 16;
+/** Fallback fence thickness (schema default) when the node carries none. */
+const DEFAULT_FENCE_THICKNESS = 0.08;
+/** Minimum band depth so the footprint survives the election's polygon inset. */
+const MIN_FENCE_SUPPORT_BAND = 0.05;
+function fenceCenterlinePoints(fence) {
+    if (fence.path && fence.path.length >= 2) {
+        return fence.path.map((point) => [point[0], point[1]]);
+    }
+    const wallLike = { start: fence.start, end: fence.end, curveOffset: fence.curveOffset ?? 0 };
+    if ((fence.curveOffset ?? 0) !== 0 && isCurvedWall(wallLike)) {
+        const points = [];
+        for (let i = 0; i <= FENCE_CURVE_SUPPORT_SAMPLES; i++) {
+            const frame = getWallCurveFrameAt(wallLike, i / FENCE_CURVE_SUPPORT_SAMPLES);
+            points.push([frame.point.x, frame.point.y]);
+        }
+        return points;
+    }
+    return [
+        [fence.start[0], fence.start[1]],
+        [fence.end[0], fence.end[1]],
+    ];
+}
+/**
+ * Support-host patch for a fence: elect the slab the fence line stands on
+ * and persist it as `supportSlabId` (the fence lift resolves absent =
+ * level floor — see `packages/nodes/src/fence/lift.ts`).
+ *
+ * The centerline (chord, sampled arc, or spline path) is turned into thin
+ * band footprints and run through the same candidate machinery items use.
+ * `options.maxElevation` is the pointer-decided cap: aiming at the floor
+ * under a deck elects the floor, aiming at the deck top elects the deck.
+ *
+ * Persist rule: the items ambiguity rule (stacked candidates disagree)
+ * PLUS the elevated-host case — a winner sitting meaningfully above the
+ * level floor must be persisted even when unambiguous (a balcony deck with
+ * nothing underneath), or the commit loses the election entirely since
+ * fences run no per-frame election. A single default ground slab (its top
+ * within `SUPPORT_ELEVATION_EPSILON` of the floor) stays unpersisted so
+ * plain fences keep sitting at the level base. A capped-out election (all
+ * overlapping slabs above the aimed-at ground) also resolves to the floor
+ * via the same absent-host default. Pure; exported for tests.
+ */
+export function resolveFenceSupportSlabPatch(fence, nodes, options) {
+    const parent = fence.parentId ? nodes[fence.parentId] : null;
+    if (parent?.type !== 'level')
+        return { supportSlabId: undefined };
+    const maxElevation = options?.maxElevation;
+    const band = Math.max(fence.thickness ?? DEFAULT_FENCE_THICKNESS, MIN_FENCE_SUPPORT_BAND);
+    const points = fenceCenterlinePoints(fence);
+    const candidateElevations = new Set();
+    let winner = null;
+    for (let i = 1; i < points.length; i++) {
+        const [ax, az] = points[i - 1];
+        const [bx, bz] = points[i];
+        const length = Math.hypot(bx - ax, bz - az);
+        if (length < 1e-6)
+            continue;
+        const position = [(ax + bx) / 2, 0, (az + bz) / 2];
+        const dimensions = [length, 1, band];
+        // 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];
+        const candidates = spatialGridManager.getSupportCandidatesForFootprint(parent.id, position, dimensions, rotation);
+        for (const candidate of candidates)
+            candidateElevations.add(candidate.elevation);
+        const support = spatialGridManager.getSlabSupportForItem(parent.id, position, dimensions, rotation, maxElevation);
+        if (support.slabId && (!winner || support.elevation > winner.elevation)) {
+            winner = { slabId: support.slabId, elevation: support.elevation };
+        }
+    }
+    if (winner === null)
+        return { supportSlabId: undefined };
+    const persist = candidateElevations.size >= 2 || winner.elevation > SUPPORT_ELEVATION_EPSILON;
+    return { supportSlabId: persist ? winner.slabId : undefined };
+}