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

package/dist/services/level-height.d.ts

@@ -2,16 +2,15 @@ import type { CeilingNode } from '../schema';
 import type { AnyNode, AnyNodeId } from '../schema/types';
 export declare const DEFAULT_LEVEL_HEIGHT = 2.5;
 /**
- * Optional resolver for a wall's rendered base Y (mesh elevation).
- *
- * `packages/core` is pure domain logic and must not read viewer/Three.js
- * state (see AGENTS.md “Layer Boundaries”). Callers that legitimately have
- * registry access (viewer systems, node tools) may pass a resolver so the
- * mesh elevation is factored in; pure/headless callers (MCP, tests, server)
- * omit it and get a deterministic result from serialized node data alone.
+ * Effective ceiling height in level-local meters. An explicit stored
+ * `height` wins; absent height means the ceiling follows the level top —
+ * the same bound its write-clamp uses: min(storey plane, lowest
+ * covering-slab underside over its polygon) − CEILING_CLAMP_MARGIN (see
+ * {@link getCeilingClampBound}). Falls back to the default plane minus
+ * the same margin when the owning level is unresolvable.
  */
-export type WallBaseYResolver = (wallId: AnyNodeId) => number | undefined;
-export declare function getLevelHeight(levelId: string, nodes: Record<AnyNodeId, AnyNode>, resolveWallBaseY?: WallBaseYResolver): number;
+export declare function resolveCeilingHeight(ceiling: Pick<CeilingNode, 'height' | 'parentId' | 'polygon'>, nodes: Record<AnyNodeId, AnyNode>): number;
+export declare function deriveLegacyLevelHeight(levelId: string, nodes: Record<AnyNodeId, AnyNode>): number;
 /**
  * The ceiling covering level-local point `[x, z]`, or `null` when none
  * sits over it. Points inside a ceiling's hole are treated as uncovered.

package/dist/services/level-height.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"level-height.d.ts","sourceRoot":"","sources":["../../src/services/level-height.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAuB,MAAM,WAAW,CAAA;AACjE,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAEzD,eAAO,MAAM,oBAAoB,MAAM,CAAA;AAEvC;;;;;;;;GAQG;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,MAAM,EAAE,SAAS,KAAK,MAAM,GAAG,SAAS,CAAA;AAEzE,wBAAgB,cAAc,CAC5B,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EACjC,gBAAgB,CAAC,EAAE,iBAAiB,GACnC,MAAM,CAqBR;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAC1B,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EACjC,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,GACR,WAAW,GAAG,IAAI,CAepB;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EACjC,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,GACR,MAAM,GAAG,IAAI,CAGf"}
+{"version":3,"file":"level-height.d.ts","sourceRoot":"","sources":["../../src/services/level-height.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAiC,MAAM,WAAW,CAAA;AAC3E,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAOzD,eAAO,MAAM,oBAAoB,MAAM,CAAA;AAEvC;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,IAAI,CAAC,WAAW,EAAE,QAAQ,GAAG,UAAU,GAAG,SAAS,CAAC,EAC7D,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,GAChC,MAAM,CAOR;AAED,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,GAChC,MAAM,CAqCR;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAC1B,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EACjC,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,GACR,WAAW,GAAG,IAAI,CAmBpB;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EACjC,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,GACR,MAAM,GAAG,IAAI,CAGf"}

package/dist/services/level-height.js

@@ -1,24 +1,53 @@
-import { pointInPolygon } from '../hooks/spatial-grid/spatial-grid-manager';
+import { computeWallSlabSupport, pointInPolygon } from '../systems/slab/slab-support';
+import { resolveWallTop } from '../systems/wall/wall-top';
+// Cycle with ./storey (it imports DEFAULT_LEVEL_HEIGHT from here) is safe:
+// both sides only reference the other inside function bodies.
+import { CEILING_CLAMP_MARGIN, getCeilingClampBound } from './storey';
 export const DEFAULT_LEVEL_HEIGHT = 2.5;
-export function getLevelHeight(levelId, nodes, resolveWallBaseY) {
+/**
+ * Effective ceiling height in level-local meters. An explicit stored
+ * `height` wins; absent height means the ceiling follows the level top —
+ * the same bound its write-clamp uses: min(storey plane, lowest
+ * covering-slab underside over its polygon) − CEILING_CLAMP_MARGIN (see
+ * {@link getCeilingClampBound}). Falls back to the default plane minus
+ * the same margin when the owning level is unresolvable.
+ */
+export function resolveCeilingHeight(ceiling, nodes) {
+    if (ceiling.height != null)
+        return ceiling.height;
+    const bound = typeof ceiling.parentId === 'string'
+        ? getCeilingClampBound(ceiling.parentId, nodes, ceiling.polygon)
+        : Number.POSITIVE_INFINITY;
+    return Number.isFinite(bound) ? bound : DEFAULT_LEVEL_HEIGHT - CEILING_CLAMP_MARGIN;
+}
+export function deriveLegacyLevelHeight(levelId, nodes) {
     const level = nodes[levelId];
     if (!level)
         return DEFAULT_LEVEL_HEIGHT;
+    const levelChildren = level.children
+        .map((childId) => nodes[childId])
+        .filter((child) => child !== undefined);
+    const slabs = levelChildren.filter((child) => child.type === 'slab');
+    const walls = levelChildren.filter((child) => child.type === 'wall');
     let maxTop = 0;
-    for (const childId of level.children) {
-        const child = nodes[childId];
-        if (!child)
-            continue;
+    for (const child of levelChildren) {
         if (child.type === 'ceiling') {
-            const ch = child.height ?? DEFAULT_LEVEL_HEIGHT;
-            if (ch > maxTop)
-                maxTop = ch;
+            // Absence here is the PRE-migration legacy schema default (2.5), not
+            // follows-mode — this derivation runs before the level has a height
+            // for a follows-mode bound to track.
+            const height = child.height ?? DEFAULT_LEVEL_HEIGHT;
+            if (height > maxTop)
+                maxTop = height;
         }
         else if (child.type === 'wall') {
-            let baseY = resolveWallBaseY?.(childId) ?? 0;
-            if (baseY < 0)
-                baseY = 0;
-            const top = baseY + (child.height ?? DEFAULT_LEVEL_HEIGHT);
+            const wall = child;
+            const electedElevation = computeWallSlabSupport({
+                start: wall.start,
+                end: wall.end,
+                curveOffset: wall.curveOffset,
+                thickness: wall.thickness,
+            }, slabs, walls).elevation;
+            const top = resolveWallTop(wall, level.height ?? DEFAULT_LEVEL_HEIGHT, electedElevation);
             if (top > maxTop)
                 maxTop = top;
         }
@@ -36,6 +65,7 @@ export function getCeilingAt(levelId, nodes, x, z) {
     if (!level)
         return null;
     let best = null;
+    let bestHeight = Number.POSITIVE_INFINITY;
     for (const childId of level.children) {
         const child = nodes[childId];
         if (child?.type !== 'ceiling')
@@ -45,9 +75,11 @@ export function getCeilingAt(levelId, nodes, x, z) {
             continue;
         if (ceiling.holes.some((hole) => hole.length >= 3 && pointInPolygon(x, z, hole)))
             continue;
-        const h = ceiling.height ?? DEFAULT_LEVEL_HEIGHT;
-        if (best === null || h < (best.height ?? DEFAULT_LEVEL_HEIGHT))
+        const h = resolveCeilingHeight(ceiling, nodes);
+        if (best === null || h < bestHeight) {
             best = ceiling;
+            bestHeight = h;
+        }
     }
     return best;
 }
@@ -58,5 +90,5 @@ export function getCeilingAt(levelId, nodes, x, z) {
  */
 export function getCeilingHeightAt(levelId, nodes, x, z) {
     const ceiling = getCeilingAt(levelId, nodes, x, z);
-    return ceiling ? (ceiling.height ?? DEFAULT_LEVEL_HEIGHT) : null;
+    return ceiling ? resolveCeilingHeight(ceiling, nodes) : null;
 }

package/dist/services/storey.d.ts

@@ -0,0 +1,103 @@
+import type { LevelNode, WallNode } from '../schema';
+import type { AnyNode, AnyNodeId } from '../schema/types';
+/**
+ * Gap kept between a ceiling's stored height and its clamp bound (storey
+ * plane or covering-slab underside), so the ceiling surface never
+ * coincides with the solid above it.
+ */
+export declare const CEILING_CLAMP_MARGIN = 0.01;
+/**
+ * Stored storey height in meters (floor-to-floor). Falls back to
+ * {@link DEFAULT_LEVEL_HEIGHT} for unmigrated legacy levels whose `height`
+ * field is absent.
+ */
+export declare function getStoredLevelHeight(level: Pick<LevelNode, 'height'>): number;
+export type LevelElevation = {
+    /** World Y of the level's floor: prefix sum of the storey heights below it. */
+    baseY: number;
+    /** Stored storey height of this level (fallback applied). */
+    height: number;
+    buildingId: string | null;
+    ordinal: number;
+};
+/**
+ * Per-building stacked elevations from stored storey heights: levels are
+ * sorted by ordinal ascending within each building, the lowest level's floor
+ * sits at 0, and each next floor sits on top of the previous storey height.
+ * Levels with no resolvable building share one legacy stack from 0.
+ *
+ * Pure — operates on the serialized nodes record only.
+ */
+export declare function getLevelElevations(nodes: Record<AnyNodeId, AnyNode>): Map<string, LevelElevation>;
+/**
+ * The id of the level directly above `levelId` in its own stack (same
+ * resolved building, or the shared legacy stack for building-less levels):
+ * the level with the lowest ordinal strictly greater than the queried
+ * level's. `null` when the level is topmost or unresolvable.
+ */
+export declare function findLevelAboveId(levelId: string, elevations: Map<string, LevelElevation>): string | null;
+/**
+ * The level directly above `levelId` — see {@link findLevelAboveId}.
+ * `null` when topmost or unresolvable. Pure.
+ */
+export declare function getLevelAbove(levelId: string, nodes: Record<AnyNodeId, AnyNode>): LevelNode | null;
+/**
+ * The id of the level directly below `levelId` in its own stack — mirror of
+ * {@link findLevelAboveId}: the level with the highest ordinal strictly less
+ * than the queried level's. `null` when the level is lowest or unresolvable.
+ */
+export declare function findLevelBelowId(levelId: string, elevations: Map<string, LevelElevation>): string | null;
+/**
+ * The level directly below `levelId` — see {@link findLevelBelowId}.
+ * `null` when lowest or unresolvable. Pure.
+ */
+export declare function getLevelBelow(levelId: string, nodes: Record<AnyNodeId, AnyNode>): LevelNode | null;
+/**
+ * Underside of the LOWEST slab from the level above that covers
+ * level-local point `[x, z]`, expressed in the queried level's local Y:
+ * `storeyHeight + (slab.elevation - slab.thickness)`. `recessed` slabs
+ * (pools) never cover. `null` when no covering slab (or no level above).
+ *
+ * Coordinate spaces: levels stack in Y only (`LevelNode` carries no XZ
+ * transform and the viewer's LevelSystem writes only `position.y`), so a
+ * level-local `[x, z]` is valid in every level of the stack unchanged.
+ */
+export declare function getCoveringSlabUndersideAt(levelId: string, nodes: Record<AnyNodeId, AnyNode>, x: number, z: number): number | null;
+/**
+ * Top plane for a plane-bound wall on `levelId`, in level-local Y:
+ * `min(stored storey height, lowest covering-slab underside over the wall's
+ * span)` — a thick or flush slab on the level above SHORTENS the walls below
+ * instead of colliding with them (Revit-style automatic attach).
+ *
+ * Coverage: the wall's thickness band (centerline + face lines, arc-aware)
+ * is clipped against each covering slab's stored polygon minus holes via
+ * {@link wallOverlapsSlabFootprint} — the same overlap machinery as the
+ * support election. Point sampling is deliberately avoided: auto-slab
+ * polygons derive from wall CENTERLINES, so perimeter walls sit exactly ON
+ * the polygon boundary, where ray-cast point-in-polygon flips with the
+ * edge's orientation (one wall clamped, its neighbor didn't). Boundary
+ * contact counts as covered on every side of the slab.
+ *
+ * This is THE plane for a plane-bound wall (`height` absent). Explicit-height
+ * walls ignore the value (`resolveWallTop` returns their stored height), so
+ * passing it wherever a raw storey height feeds `resolveWallTop` /
+ * `resolveWallEffectiveHeight` is always safe. Falls back to
+ * {@link DEFAULT_LEVEL_HEIGHT} when `levelId` doesn't resolve to a level.
+ */
+export declare function getWallPlaneTop(wall: Pick<WallNode, 'start' | 'end'> & Partial<Pick<WallNode, 'thickness' | 'curveOffset'>>, levelId: string, nodes: Record<AnyNodeId, AnyNode>): number;
+/**
+ * Upper bound for a ceiling's stored height over `polygon` on `levelId`:
+ * `min(storey plane, lowest covering-slab underside) - CEILING_CLAMP_MARGIN`.
+ * The covering underside is sampled at every polygon vertex plus the
+ * centroid — cheap, and a slab overlapping a convex-ish ceiling almost
+ * always covers one of those points; exact polygon-vs-polygon overlap is
+ * not worth its cost for a clamp bound. Ceiling outlines share footprint
+ * edges with the slabs above them the same way walls do, so vertices
+ * sitting exactly on a slab's boundary count as covered on every side
+ * (see `slabCoversPoint`) instead of flipping with the edge orientation.
+ *
+ * Returns `Infinity` when `levelId` doesn't resolve, so callers clamp
+ * against nothing rather than a garbage plane.
+ */
+export declare function getCeilingClampBound(levelId: string, nodes: Record<AnyNodeId, AnyNode>, polygon: ReadonlyArray<[number, number]>): number;
+//# sourceMappingURL=storey.d.ts.map

package/dist/services/storey.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storey.d.ts","sourceRoot":"","sources":["../../src/services/storey.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAgB,SAAS,EAAY,QAAQ,EAAE,MAAM,WAAW,CAAA;AAC5E,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAQzD;;;;GAIG;AACH,eAAO,MAAM,oBAAoB,OAAO,CAAA;AAExC;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,IAAI,CAAC,SAAS,EAAE,QAAQ,CAAC,GAAG,MAAM,CAE7E;AAED,MAAM,MAAM,cAAc,GAAG;IAC3B,+EAA+E;IAC/E,KAAK,EAAE,MAAM,CAAA;IACb,6DAA6D;IAC7D,MAAM,EAAE,MAAM,CAAA;IACd,UAAU,EAAE,MAAM,GAAG,IAAI,CAAA;IACzB,OAAO,EAAE,MAAM,CAAA;CAChB,CAAA;AAkBD;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,GAAG,GAAG,CAAC,MAAM,EAAE,cAAc,CAAC,CAgCjG;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,cAAc,CAAC,GACtC,MAAM,GAAG,IAAI,CAef;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAC3B,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,GAChC,SAAS,GAAG,IAAI,CAKlB;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,cAAc,CAAC,GACtC,MAAM,GAAG,IAAI,CAef;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAC3B,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,GAChC,SAAS,GAAG,IAAI,CAKlB;AAuFD;;;;;;;;;GASG;AACH,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EACjC,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,GACR,MAAM,GAAG,IAAI,CAIf;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,eAAe,CAC7B,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,OAAO,GAAG,KAAK,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,QAAQ,EAAE,WAAW,GAAG,aAAa,CAAC,CAAC,EAC5F,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,GAChC,MAAM,CAYR;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EACjC,OAAO,EAAE,aAAa,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GACvC,MAAM,CAuBR"}

package/dist/services/storey.js

@@ -0,0 +1,296 @@
+import { pointInPolygon, pointOnPolygonBoundary, wallOverlapsSlabFootprint, } from '../systems/slab/slab-support';
+import { DEFAULT_LEVEL_HEIGHT } from './level-height';
+/**
+ * Gap kept between a ceiling's stored height and its clamp bound (storey
+ * plane or covering-slab underside), so the ceiling surface never
+ * coincides with the solid above it.
+ */
+export const CEILING_CLAMP_MARGIN = 0.01;
+/**
+ * Stored storey height in meters (floor-to-floor). Falls back to
+ * {@link DEFAULT_LEVEL_HEIGHT} for unmigrated legacy levels whose `height`
+ * field is absent.
+ */
+export function getStoredLevelHeight(level) {
+    return level.height ?? DEFAULT_LEVEL_HEIGHT;
+}
+/**
+ * Resolves the owning building: explicit `parentId` pointing at a building
+ * wins; legacy levels that only appear in a building's `children` array
+ * resolve through that membership.
+ */
+function resolveLevelBuildingId(levelId, parentId, buildings) {
+    const directParent = parentId ? buildings.find((building) => building.id === parentId) : undefined;
+    if (directParent)
+        return directParent.id;
+    return buildings.find((building) => building.children.includes(levelId))?.id ?? null;
+}
+/**
+ * Per-building stacked elevations from stored storey heights: levels are
+ * sorted by ordinal ascending within each building, the lowest level's floor
+ * sits at 0, and each next floor sits on top of the previous storey height.
+ * Levels with no resolvable building share one legacy stack from 0.
+ *
+ * Pure — operates on the serialized nodes record only.
+ */
+export function getLevelElevations(nodes) {
+    const buildings = Object.values(nodes).filter((node) => node?.type === 'building');
+    const entries = [];
+    for (const node of Object.values(nodes)) {
+        if (node?.type !== 'level')
+            continue;
+        const level = node;
+        entries.push({
+            levelId: level.id,
+            baseY: 0,
+            height: getStoredLevelHeight(level),
+            buildingId: resolveLevelBuildingId(level.id, level.parentId, buildings),
+            ordinal: level.level,
+        });
+    }
+    const elevations = new Map();
+    const cumulativeYByBuilding = new Map();
+    for (const entry of entries.sort((a, b) => a.ordinal - b.ordinal)) {
+        const baseY = cumulativeYByBuilding.get(entry.buildingId) ?? 0;
+        elevations.set(entry.levelId, {
+            baseY,
+            height: entry.height,
+            buildingId: entry.buildingId,
+            ordinal: entry.ordinal,
+        });
+        cumulativeYByBuilding.set(entry.buildingId, baseY + entry.height);
+    }
+    return elevations;
+}
+/**
+ * The id of the level directly above `levelId` in its own stack (same
+ * resolved building, or the shared legacy stack for building-less levels):
+ * the level with the lowest ordinal strictly greater than the queried
+ * level's. `null` when the level is topmost or unresolvable.
+ */
+export function findLevelAboveId(levelId, elevations) {
+    const entry = elevations.get(levelId);
+    if (!entry)
+        return null;
+    let aboveId = null;
+    let aboveOrdinal = Number.POSITIVE_INFINITY;
+    for (const [candidateId, candidate] of elevations) {
+        if (candidateId === levelId)
+            continue;
+        if (candidate.buildingId !== entry.buildingId)
+            continue;
+        if (candidate.ordinal > entry.ordinal && candidate.ordinal < aboveOrdinal) {
+            aboveOrdinal = candidate.ordinal;
+            aboveId = candidateId;
+        }
+    }
+    return aboveId;
+}
+/**
+ * The level directly above `levelId` — see {@link findLevelAboveId}.
+ * `null` when topmost or unresolvable. Pure.
+ */
+export function getLevelAbove(levelId, nodes) {
+    const aboveId = findLevelAboveId(levelId, getLevelElevations(nodes));
+    if (!aboveId)
+        return null;
+    const above = nodes[aboveId];
+    return above?.type === 'level' ? above : null;
+}
+/**
+ * The id of the level directly below `levelId` in its own stack — mirror of
+ * {@link findLevelAboveId}: the level with the highest ordinal strictly less
+ * than the queried level's. `null` when the level is lowest or unresolvable.
+ */
+export function findLevelBelowId(levelId, elevations) {
+    const entry = elevations.get(levelId);
+    if (!entry)
+        return null;
+    let belowId = null;
+    let belowOrdinal = Number.NEGATIVE_INFINITY;
+    for (const [candidateId, candidate] of elevations) {
+        if (candidateId === levelId)
+            continue;
+        if (candidate.buildingId !== entry.buildingId)
+            continue;
+        if (candidate.ordinal < entry.ordinal && candidate.ordinal > belowOrdinal) {
+            belowOrdinal = candidate.ordinal;
+            belowId = candidateId;
+        }
+    }
+    return belowId;
+}
+/**
+ * The level directly below `levelId` — see {@link findLevelBelowId}.
+ * `null` when lowest or unresolvable. Pure.
+ */
+export function getLevelBelow(levelId, nodes) {
+    const belowId = findLevelBelowId(levelId, getLevelElevations(nodes));
+    if (!belowId)
+        return null;
+    const below = nodes[belowId];
+    return below?.type === 'level' ? below : null;
+}
+/**
+ * Storey height of the queried level plus the level-above's covering
+ * (non-recessed) slabs. `null` when `levelId` doesn't resolve to a level.
+ * A missing level above yields an empty slab list, not `null` — the
+ * storey height is still meaningful for the clamp bound.
+ */
+function resolveCoveringSlabContext(levelId, nodes) {
+    const level = nodes[levelId];
+    if (level?.type !== 'level')
+        return null;
+    const above = getLevelAbove(levelId, nodes);
+    const slabs = [];
+    for (const childId of above?.children ?? []) {
+        const child = nodes[childId];
+        if (child?.type !== 'slab')
+            continue;
+        const slab = child;
+        // Recessed slabs (pools) are open shells, not covering solids.
+        if (slab.recessed === true)
+            continue;
+        if (slab.polygon.length < 3)
+            continue;
+        slabs.push(slab);
+    }
+    return { storeyHeight: getStoredLevelHeight(level), slabs };
+}
+/**
+ * Underside of `slab`'s solid in the QUERIED level's local Y. The solid
+ * occupies `[elevation - thickness, elevation]` in ITS level's local Y,
+ * which sits `storeyHeight` above the queried level's floor.
+ */
+function coveringUndersideY(storeyHeight, slab) {
+    return storeyHeight + ((slab.elevation ?? 0.05) - (slab.thickness ?? 0.05));
+}
+/**
+ * Whether `slab`'s stored footprint (polygon minus holes) covers `[x, z]`.
+ * Ray-cast pointInPolygon flips arbitrarily for points exactly ON the
+ * boundary (min-side edges read inside, max-side edges outside), so
+ * boundary contact counts as covered explicitly — the same convention as
+ * the slab-support interval classification. A point on a hole's rim keeps
+ * coverage (mirrors the support election's hole handling).
+ *
+ * Raw stored polygon + holes on purpose (mirrors getCeilingAt): the
+ * clamp bound doesn't need the rendered footprint's junction trims,
+ * and staying off the render path keeps this query cheap and pure.
+ */
+function slabCoversPoint(slab, x, z) {
+    if (!pointInPolygon(x, z, slab.polygon) && !pointOnPolygonBoundary(x, z, slab.polygon)) {
+        return false;
+    }
+    for (const hole of slab.holes ?? []) {
+        if (hole.length < 3)
+            continue;
+        if (pointInPolygon(x, z, hole) && !pointOnPolygonBoundary(x, z, hole))
+            return false;
+    }
+    return true;
+}
+/**
+ * Lowest underside among `slabs` covering `[x, z]`, in the queried
+ * level's local Y, or `null` when none covers the point.
+ */
+function lowestCoveringUndersideAt(context, x, z) {
+    let lowest = null;
+    for (const slab of context.slabs) {
+        if (!slabCoversPoint(slab, x, z))
+            continue;
+        const underside = coveringUndersideY(context.storeyHeight, slab);
+        if (lowest === null || underside < lowest)
+            lowest = underside;
+    }
+    return lowest;
+}
+/**
+ * Underside of the LOWEST slab from the level above that covers
+ * level-local point `[x, z]`, expressed in the queried level's local Y:
+ * `storeyHeight + (slab.elevation - slab.thickness)`. `recessed` slabs
+ * (pools) never cover. `null` when no covering slab (or no level above).
+ *
+ * Coordinate spaces: levels stack in Y only (`LevelNode` carries no XZ
+ * transform and the viewer's LevelSystem writes only `position.y`), so a
+ * level-local `[x, z]` is valid in every level of the stack unchanged.
+ */
+export function getCoveringSlabUndersideAt(levelId, nodes, x, z) {
+    const context = resolveCoveringSlabContext(levelId, nodes);
+    if (!context)
+        return null;
+    return lowestCoveringUndersideAt(context, x, z);
+}
+/**
+ * Top plane for a plane-bound wall on `levelId`, in level-local Y:
+ * `min(stored storey height, lowest covering-slab underside over the wall's
+ * span)` — a thick or flush slab on the level above SHORTENS the walls below
+ * instead of colliding with them (Revit-style automatic attach).
+ *
+ * Coverage: the wall's thickness band (centerline + face lines, arc-aware)
+ * is clipped against each covering slab's stored polygon minus holes via
+ * {@link wallOverlapsSlabFootprint} — the same overlap machinery as the
+ * support election. Point sampling is deliberately avoided: auto-slab
+ * polygons derive from wall CENTERLINES, so perimeter walls sit exactly ON
+ * the polygon boundary, where ray-cast point-in-polygon flips with the
+ * edge's orientation (one wall clamped, its neighbor didn't). Boundary
+ * contact counts as covered on every side of the slab.
+ *
+ * This is THE plane for a plane-bound wall (`height` absent). Explicit-height
+ * walls ignore the value (`resolveWallTop` returns their stored height), so
+ * passing it wherever a raw storey height feeds `resolveWallTop` /
+ * `resolveWallEffectiveHeight` is always safe. Falls back to
+ * {@link DEFAULT_LEVEL_HEIGHT} when `levelId` doesn't resolve to a level.
+ */
+export function getWallPlaneTop(wall, levelId, nodes) {
+    const context = resolveCoveringSlabContext(levelId, nodes);
+    if (!context)
+        return DEFAULT_LEVEL_HEIGHT;
+    let plane = context.storeyHeight;
+    for (const slab of context.slabs) {
+        const underside = coveringUndersideY(context.storeyHeight, slab);
+        if (underside >= plane)
+            continue;
+        if (!wallOverlapsSlabFootprint(wall, slab.polygon, slab.holes))
+            continue;
+        plane = underside;
+    }
+    return plane;
+}
+/**
+ * Upper bound for a ceiling's stored height over `polygon` on `levelId`:
+ * `min(storey plane, lowest covering-slab underside) - CEILING_CLAMP_MARGIN`.
+ * The covering underside is sampled at every polygon vertex plus the
+ * centroid — cheap, and a slab overlapping a convex-ish ceiling almost
+ * always covers one of those points; exact polygon-vs-polygon overlap is
+ * not worth its cost for a clamp bound. Ceiling outlines share footprint
+ * edges with the slabs above them the same way walls do, so vertices
+ * sitting exactly on a slab's boundary count as covered on every side
+ * (see `slabCoversPoint`) instead of flipping with the edge orientation.
+ *
+ * Returns `Infinity` when `levelId` doesn't resolve, so callers clamp
+ * against nothing rather than a garbage plane.
+ */
+export function getCeilingClampBound(levelId, nodes, polygon) {
+    const context = resolveCoveringSlabContext(levelId, nodes);
+    if (!context)
+        return Number.POSITIVE_INFINITY;
+    let bound = context.storeyHeight;
+    if (polygon.length > 0) {
+        let cx = 0;
+        let cz = 0;
+        for (const [x, z] of polygon) {
+            cx += x;
+            cz += z;
+        }
+        const samples = [
+            ...polygon,
+            [cx / polygon.length, cz / polygon.length],
+        ];
+        for (const [x, z] of samples) {
+            const underside = lowestCoveringUndersideAt(context, x, z);
+            if (underside !== null && underside < bound)
+                bound = underside;
+        }
+    }
+    return bound - CEILING_CLAMP_MARGIN;
+}

package/dist/store/actions/node-actions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"node-actions.d.ts","sourceRoot":"","sources":["../../../src/store/actions/node-actions.ts"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EASf,MAAM,cAAc,CAAA;AAErB,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AAG9C,KAAK,YAAY,GAAG;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,EAAE,SAAS,CAAA;CAAE,CAAA;AAC3D,KAAK,YAAY,GAAG;IAAE,EAAE,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,CAAA;CAAE,CAAA;AAC7D,KAAK,YAAY,GAAG,SAAS,CAAA;AA0uB7B,eAAO,MAAM,iBAAiB,GAC5B,KAAK,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,OAAO,CAAC,UAAU,CAAC,KAAK,IAAI,EAC7D,KAAK,MAAM,UAAU,EACrB,KAAK,YAAY,EAAE,SAkDpB,CAAA;AAED,eAAO,MAAM,sBAAsB,GACjC,KAAK,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,OAAO,CAAC,UAAU,CAAC,KAAK,IAAI,EAC7D,KAAK,MAAM,UAAU,EACrB,SAAS;IAAE,MAAM,CAAC,EAAE,YAAY,EAAE,CAAC;IAAC,MAAM,CAAC,EAAE,YAAY,EAAE,CAAC;IAAC,MAAM,CAAC,EAAE,YAAY,EAAE,CAAA;CAAE,SAyIvF,CAAA;AAED,eAAO,MAAM,iBAAiB,GAC5B,KAAK,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,OAAO,CAAC,UAAU,CAAC,KAAK,IAAI,EAC7D,KAAK,MAAM,UAAU,EACrB,SAAS;IAAE,EAAE,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,CAAA;CAAE,EAAE,SAoFrD,CAAA;AAED,eAAO,MAAM,iBAAiB,GAC5B,KAAK,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,OAAO,CAAC,UAAU,CAAC,KAAK,IAAI,EAC7D,KAAK,MAAM,UAAU,EACrB,KAAK,SAAS,EAAE,SAqIjB,CAAA"}
+{"version":3,"file":"node-actions.d.ts","sourceRoot":"","sources":["../../../src/store/actions/node-actions.ts"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EASf,MAAM,cAAc,CAAA;AAErB,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AAG9C,KAAK,YAAY,GAAG;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,EAAE,SAAS,CAAA;CAAE,CAAA;AAC3D,KAAK,YAAY,GAAG;IAAE,EAAE,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,CAAA;CAAE,CAAA;AAC7D,KAAK,YAAY,GAAG,SAAS,CAAA;AA0vB7B,eAAO,MAAM,iBAAiB,GAC5B,KAAK,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,OAAO,CAAC,UAAU,CAAC,KAAK,IAAI,EAC7D,KAAK,MAAM,UAAU,EACrB,KAAK,YAAY,EAAE,SAkDpB,CAAA;AAED,eAAO,MAAM,sBAAsB,GACjC,KAAK,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,OAAO,CAAC,UAAU,CAAC,KAAK,IAAI,EAC7D,KAAK,MAAM,UAAU,EACrB,SAAS;IAAE,MAAM,CAAC,EAAE,YAAY,EAAE,CAAC;IAAC,MAAM,CAAC,EAAE,YAAY,EAAE,CAAC;IAAC,MAAM,CAAC,EAAE,YAAY,EAAE,CAAA;CAAE,SAyIvF,CAAA;AAED,eAAO,MAAM,iBAAiB,GAC5B,KAAK,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,OAAO,CAAC,UAAU,CAAC,KAAK,IAAI,EAC7D,KAAK,MAAM,UAAU,EACrB,SAAS;IAAE,EAAE,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,CAAA;CAAE,EAAE,SAoFrD,CAAA;AAED,eAAO,MAAM,iBAAiB,GAC5B,KAAK,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,OAAO,CAAC,UAAU,CAAC,KAAK,IAAI,EAC7D,KAAK,MAAM,UAAU,EACrB,KAAK,SAAS,EAAE,SA8JjB,CAAA"}

package/dist/store/actions/node-actions.js

@@ -343,8 +343,21 @@ function parseCreatedNode(node, parentId) {
     warnSanitizedNodeMutation('create', node.id, sanitized.issues);
     return sanitized.value;
 }
+// An explicit `key: undefined` in update data REMOVES the key: optional
+// fields like wall.height encode a mode by their absence (absent =
+// plane-bound top), and zod's safeParse echoes explicit-undefined keys, so
+// a plain spread would leave a lingering own key that breaks `'height' in
+// node` checks.
+function mergeNodeUpdate(currentNode, patch) {
+    const merged = { ...currentNode, ...patch };
+    for (const key of Object.keys(patch)) {
+        if (patch[key] === undefined)
+            delete merged[key];
+    }
+    return merged;
+}
 function parseUpdatedNode(currentNode, data) {
-    const candidate = { ...currentNode, ...data };
+    const candidate = mergeNodeUpdate(currentNode, data);
     const parsed = AnyNodeSchema.safeParse(candidate);
     if (parsed.success)
         return parsed.data;
@@ -354,7 +367,7 @@ function parseUpdatedNode(currentNode, data) {
         return candidate;
     }
     warnSanitizedNodeMutation('update', currentNode.id, sanitized.issues);
-    return { ...currentNode, ...sanitized.value };
+    return mergeNodeUpdate(currentNode, sanitized.value);
 }
 function shouldRefreshDefaultRidgeVents(data) {
     return Object.keys(data).some((key) => DEFAULT_RIDGE_VENT_REFRESH_FIELDS.has(key));
@@ -413,7 +426,10 @@ function areWallStylesCompatible(a, b) {
     return ((a.parentId ?? null) === (b.parentId ?? null) &&
         Math.abs((a.curveOffset ?? 0) - (b.curveOffset ?? 0)) <= 1e-6 &&
         Math.abs((a.thickness ?? 0.2) - (b.thickness ?? 0.2)) <= 1e-6 &&
-        Math.abs((a.height ?? 2.5) - (b.height ?? 2.5)) <= 1e-6 &&
+        // Absent height means plane-bound (follows the storey), which must never
+        // merge with an explicit height — even one that currently matches the plane.
+        (a.height == null) === (b.height == null) &&
+        Math.abs((a.height ?? 0) - (b.height ?? 0)) <= 1e-6 &&
         aInterior === bInterior &&
         aExterior === bExterior &&
         a.frontSide === b.frontSide &&
@@ -861,6 +877,34 @@ export const deleteNodesAction = (set, get, ids) => {
                 nodesToMarkDirty.add(update.id);
             }
         }
+        // Deleting a slab strips `supportSlabId` / `deckSlabId` references from
+        // surviving nodes in the same undo commit (mirrors the collectionIds
+        // cleanup below), so those nodes re-elect their support / re-derive
+        // their rise. Deletion is the ONLY writer — a host merely reshaped away
+        // keeps the field and the read path falls back, letting hosting resume
+        // if the slab returns.
+        const deletedSlabIds = new Set();
+        for (const id of allIds) {
+            if (nextNodes[id]?.type === 'slab')
+                deletedSlabIds.add(id);
+        }
+        if (deletedSlabIds.size > 0) {
+            for (const [nodeId, node] of Object.entries(nextNodes)) {
+                if (allIds.has(nodeId))
+                    continue;
+                const patch = {};
+                const hostId = node.supportSlabId;
+                if (hostId && deletedSlabIds.has(hostId))
+                    patch.supportSlabId = undefined;
+                const deckId = node.deckSlabId;
+                if (deckId && deletedSlabIds.has(deckId))
+                    patch.deckSlabId = undefined;
+                if (Object.keys(patch).length > 0) {
+                    nextNodes[nodeId] = { ...node, ...patch };
+                    nodesToMarkDirty.add(nodeId);
+                }
+            }
+        }
         for (const id of allIds) {
             const node = nextNodes[id];
             if (!node)

package/dist/store/history-control.d.ts

@@ -1,3 +1,20 @@
+import type { Collection, CollectionId } from '../schema/collections';
+import type { SceneMaterial, SceneMaterialId } from '../schema/scene-material';
+import type { AnyNode, AnyNodeId } from '../schema/types';
+export type SceneSnapshot = {
+    nodes: Record<AnyNodeId, AnyNode>;
+    rootNodeIds: AnyNodeId[];
+    collections: Record<CollectionId, Collection>;
+    materials: Record<SceneMaterialId, SceneMaterial>;
+    installedPlugins: string[];
+};
+export type SceneCommitOrigin = 'local' | 'load' | 'host';
+export type SceneCommit = {
+    origin: SceneCommitOrigin;
+    before: SceneSnapshot;
+    current: SceneSnapshot;
+};
+export type SceneCommitListener = (commit: SceneCommit) => void;
 type TemporalStoreLike = {
     temporal: {
         getState(): {
@@ -16,6 +33,9 @@ type TemporalHistoryStoreLike<TPastState> = {
         }): void;
     };
 };
+export declare function areSceneSnapshotsEqual(left: SceneSnapshot, right: SceneSnapshot): boolean;
+export declare function subscribeSceneCommits(listener: SceneCommitListener): () => void;
+export declare function notifySceneCommit(commit: SceneCommit): void;
 export declare function pauseSceneHistory(sceneStore: TemporalStoreLike): void;
 export declare function resumeSceneHistory(sceneStore: TemporalStoreLike): void;
 export declare function getSceneHistoryPauseDepth(): number;

package/dist/store/history-control.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"history-control.d.ts","sourceRoot":"","sources":["../../src/store/history-control.ts"],"names":[],"mappings":"AAEA,KAAK,iBAAiB,GAAG;IACvB,QAAQ,EAAE;QACR,QAAQ,IAAI;YACV,KAAK,IAAI,IAAI,CAAA;YACb,MAAM,IAAI,IAAI,CAAA;SACf,CAAA;KACF,CAAA;CACF,CAAA;AAED,KAAK,wBAAwB,CAAC,UAAU,IAAI;IAC1C,QAAQ,EAAE;QACR,QAAQ,IAAI;YACV,UAAU,EAAE,UAAU,EAAE,CAAA;SACzB,CAAA;QACD,QAAQ,CAAC,KAAK,EAAE;YAAE,UAAU,EAAE,UAAU,EAAE,CAAA;SAAE,GAAG,IAAI,CAAA;KACpD,CAAA;CACF,CAAA;AAED,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,iBAAiB,GAAG,IAAI,CAKrE;AAED,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,iBAAiB,GAAG,IAAI,CAStE;AAED,wBAAgB,yBAAyB,IAAI,MAAM,CAElD;AAED,wBAAgB,2BAA2B,IAAI,IAAI,CAElD;AAkBD,wBAAgB,2BAA2B,CAAC,UAAU,EAAE,OAAO,EAC7D,UAAU,EAAE,wBAAwB,CAAC,UAAU,CAAC,EAChD,GAAG,EAAE,MAAM,OAAO,GACjB,OAAO,CAeT"}
+{"version":3,"file":"history-control.d.ts","sourceRoot":"","sources":["../../src/store/history-control.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAA;AACrE,OAAO,KAAK,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAA;AAC9E,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAIzD,MAAM,MAAM,aAAa,GAAG;IAC1B,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAA;IACjC,WAAW,EAAE,SAAS,EAAE,CAAA;IACxB,WAAW,EAAE,MAAM,CAAC,YAAY,EAAE,UAAU,CAAC,CAAA;IAC7C,SAAS,EAAE,MAAM,CAAC,eAAe,EAAE,aAAa,CAAC,CAAA;IACjD,gBAAgB,EAAE,MAAM,EAAE,CAAA;CAC3B,CAAA;AAED,MAAM,MAAM,iBAAiB,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,CAAA;AAEzD,MAAM,MAAM,WAAW,GAAG;IACxB,MAAM,EAAE,iBAAiB,CAAA;IACzB,MAAM,EAAE,aAAa,CAAA;IACrB,OAAO,EAAE,aAAa,CAAA;CACvB,CAAA;AAED,MAAM,MAAM,mBAAmB,GAAG,CAAC,MAAM,EAAE,WAAW,KAAK,IAAI,CAAA;AAE/D,KAAK,iBAAiB,GAAG;IACvB,QAAQ,EAAE;QACR,QAAQ,IAAI;YACV,KAAK,IAAI,IAAI,CAAA;YACb,MAAM,IAAI,IAAI,CAAA;SACf,CAAA;KACF,CAAA;CACF,CAAA;AAED,KAAK,wBAAwB,CAAC,UAAU,IAAI;IAC1C,QAAQ,EAAE;QACR,QAAQ,IAAI;YACV,UAAU,EAAE,UAAU,EAAE,CAAA;SACzB,CAAA;QACD,QAAQ,CAAC,KAAK,EAAE;YAAE,UAAU,EAAE,UAAU,EAAE,CAAA;SAAE,GAAG,IAAI,CAAA;KACpD,CAAA;CACF,CAAA;AA+BD,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,aAAa,EAAE,KAAK,EAAE,aAAa,GAAG,OAAO,CAQzF;AAED,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,mBAAmB,GAAG,MAAM,IAAI,CAK/E;AAYD,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,WAAW,GAAG,IAAI,CAiB3D;AAyBD,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,iBAAiB,GAAG,IAAI,CAKrE;AAED,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,iBAAiB,GAAG,IAAI,CAStE;AAED,wBAAgB,yBAAyB,IAAI,MAAM,CAElD;AAED,wBAAgB,2BAA2B,IAAI,IAAI,CAElD;AAkBD,wBAAgB,2BAA2B,CAAC,UAAU,EAAE,OAAO,EAC7D,UAAU,EAAE,wBAAwB,CAAC,UAAU,CAAC,EAChD,GAAG,EAAE,MAAM,OAAO,GACjB,OAAO,CAuBT"}