@pascal-app/nodes 0.1.1 → 1.0.0-beta.2

package/dist/skylight/definition.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/skylight/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,cAAc,EAIpB,MAAM,kBAAkB,CAAA;AASzB,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;AAoMvC;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,EAAE,cAAc,CAAC,OAAO,YAAY,CAgFlE,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/skylight/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,cAAc,EAIpB,MAAM,kBAAkB,CAAA;AASzB,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;AAoMvC;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,EAAE,cAAc,CAAC,OAAO,YAAY,CAiFlE,CAAA"}

package/dist/skylight/definition.js

@@ -230,6 +230,7 @@ export const skylightDefinition = {
         kind: 'parametric',
         module: () => import('./renderer'),
     },
+    preview: () => import('./preview'),
     system: {
         module: () => import('./system'),
         priority: 3,

package/dist/skylight/tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/skylight/tool.tsx"],"names":[],"mappings":"AA4BA,QAAA,MAAM,YAAY,mCAuHjB,CAAA;AAED,eAAe,YAAY,CAAA"}
+{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/skylight/tool.tsx"],"names":[],"mappings":"AA4BA,QAAA,MAAM,YAAY,mCAsIjB,CAAA;AAED,eAAe,YAAY,CAAA"}

package/dist/skylight/tool.js

@@ -1,7 +1,7 @@
 'use client';
 import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
 import { emitter, SkylightNode, sceneRegistry, useScene, } from '@pascal-app/core';
-import { triggerSFX } from '@pascal-app/editor';
+import { triggerSFX, usePlacementPreview } from '@pascal-app/editor';
 import { useViewer } from '@pascal-app/viewer';
 import { useEffect, useMemo, useRef, useState } from 'react';
 import * as THREE from 'three';
@@ -54,6 +54,12 @@ const SkylightTool = () => {
             setPreviewSurfaceQuat(surfaceQuatFromNormal(normal, new THREE.Quaternion()));
             setPreviewYaw((event.node.rotation ?? 0) + (hit.segment.rotation ?? 0));
             setPreviewPos(worldToBuildingLocal(wx, wy, wz));
+            usePlacementPreview.getState().set(SkylightNode.parse({
+                ...previewNode,
+                parentId: hit.segment.id,
+                position: [hit.localX, hit.localY, hit.localZ],
+                roofSegmentId: hit.segment.id,
+            }), hit.segment);
             publishRoofSurfacePlacementGuides({
                 roof: event.node,
                 segment: hit.segment,
@@ -78,6 +84,9 @@ const SkylightTool = () => {
             state.dirtyNodes.add(hit.segment.id);
             setSelection({ selectedIds: [skylight.id] });
             triggerSFX('sfx:item-place');
+            const placementPreview = usePlacementPreview.getState();
+            if (placementPreview.node?.id === previewNode.id)
+                placementPreview.clear();
             clearRoofSurfacePlacementGuides();
             event.stopPropagation();
         };
@@ -88,12 +97,18 @@ const SkylightTool = () => {
             emitter.off('roof:move', updatePreview);
             emitter.off('roof:enter', updatePreview);
             emitter.off('roof:click', onClick);
+            const placementPreview = usePlacementPreview.getState();
+            if (placementPreview.node?.id === previewNode.id)
+                placementPreview.clear();
             clearRoofSurfacePlacementGuides();
         };
     }, [activeBuildingId, setSelection, previewNode]);
     return (_jsxs(_Fragment, { children: [_jsx(RoofAttachmentFallbackPreview, { activeBuildingId: activeBuildingId, ghost: _jsx(SkylightPreview, { node: previewNode, invalid: true }), onInvalidTarget: () => {
                     setPreviewPos(null);
                     setPreviewSurfaceQuat(null);
+                    const placementPreview = usePlacementPreview.getState();
+                    if (placementPreview.node?.id === previewNode.id)
+                        placementPreview.clear();
                     clearRoofSurfacePlacementGuides();
                 } }), activeBuildingId && previewPos && previewSurfaceQuat && (_jsx("group", { position: previewPos, children: _jsx("group", { "rotation-y": previewYaw, children: _jsx("group", { quaternion: previewSurfaceQuat, children: _jsx(SkylightPreview, { node: previewNode }) }) }) }))] }));
 };

package/dist/slab/definition.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/slab/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,cAAc,EAGpB,MAAM,kBAAkB,CAAA;AAczB,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAqGnC;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,cAAc,EAAE,cAAc,CAAC,OAAO,QAAQ,CA+G1D,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/slab/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAML,KAAK,cAAc,EAKpB,MAAM,kBAAkB,CAAA;AA0BzB,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAsNnC;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,cAAc,EAAE,cAAc,CAAC,OAAO,QAAQ,CAiH1D,CAAA"}

package/dist/slab/definition.js

@@ -1,5 +1,7 @@
-import { pointInPolygon2D, } from '@pascal-app/core';
+import { MIN_SLAB_THICKNESS, markSlabChangeDependents, pointInPolygon2D, syncStairRises, } from '@pascal-app/core';
+import { clearStructuralElevationGuide, publishStructuralElevationGuide, resolveStructuralElevationSnap, } from '@pascal-app/editor';
 import { polygonMeasurementFeatures } from '../shared/polygon-measurement';
+import { applySlabBaseElevationChange, applySlabThicknessChange, applySlabTopChange, getSlabBaseElevation, slabElevationUpperBound, } from './elevation-limit';
 import { buildSlabFloorplan } from './floorplan';
 import { slabAddVertexAffordance, slabDeleteVertexAffordance, slabMoveEdgeAffordance, slabMoveVertexAffordance, } from './floorplan-affordances';
 import { slabFloorplanMoveTarget } from './floorplan-move';
@@ -74,19 +76,42 @@ function slabHandleAnchor(slab) {
     }
     return best ?? fallback;
 }
-// Slab height arrow — vertical chevron on solid slab surface near the
-// polygon center. Drags elevation through zero: positive values extrude
-// upward from ground while negative values create a recessed floor whose
-// depth follows the pointer. Same registry-handle pipeline as the column
-// height arrow, so live override + commit-on-release come for free.
-function slabHeightHandle() {
+function slabElevationGuideSource(slab) {
+    return {
+        nodeId: slab.id,
+        levelId: slab.parentId,
+        anchor: slabHandleAnchor(slab),
+    };
+}
+function slabChangePreviewOverrides(slab, patch, sceneApi) {
+    const next = { ...slab, ...patch };
+    const nodes = { ...sceneApi.nodes(), [slab.id]: next };
+    const previews = new Map();
+    markSlabChangeDependents(slab, next, nodes, (id) => previews.set(id, {}));
+    for (const update of syncStairRises(nodes)) {
+        const segment = nodes[update.id];
+        if (segment?.type !== 'stair-segment' ||
+            !segment.parentId ||
+            !previews.has(segment.parentId)) {
+            continue;
+        }
+        previews.set(update.id, update.data);
+    }
+    return [...previews];
+}
+function slabRecessedDepthHandle() {
     return {
         kind: 'linear-resize',
         axis: 'y',
         anchor: 'min',
         min: MIN_SLAB_ELEVATION,
+        max: (n, sceneApi) => slabElevationUpperBound(sceneApi.nodes(), n),
         currentValue: (n) => n.elevation ?? 0.05,
-        apply: (_n, newValue) => ({ elevation: newValue }),
+        magneticSnap: (n, newValue, sceneApi) => resolveStructuralElevationSnap(slabElevationGuideSource(n), newValue, sceneApi.nodes()),
+        onDrag: (n, sceneApi) => publishStructuralElevationGuide(slabElevationGuideSource(n), n.elevation ?? 0.05, sceneApi.nodes()),
+        onDragEnd: (n) => clearStructuralElevationGuide(n.id),
+        apply: (n, newValue) => applySlabTopChange(n, newValue),
+        previewOverrides: (n, newValue, sceneApi) => slabChangePreviewOverrides(n, applySlabTopChange(n, newValue), sceneApi),
         placement: {
             position: (n) => {
                 const [cx, cz] = slabHandleAnchor(n);
@@ -96,8 +121,58 @@ function slabHeightHandle() {
         },
     };
 }
-function slabHandles(_node) {
-    return [slabHeightHandle()];
+function slabThicknessHandle() {
+    return {
+        kind: 'linear-resize',
+        axis: 'y',
+        anchor: 'min',
+        min: MIN_SLAB_THICKNESS,
+        max: (n, sceneApi) => Math.max(MIN_SLAB_THICKNESS, slabElevationUpperBound(sceneApi.nodes(), n) - getSlabBaseElevation(n)),
+        currentValue: (n) => n.thickness ?? 0.05,
+        magneticSnap: (n, newThickness, sceneApi) => {
+            const base = getSlabBaseElevation(n);
+            const snappedTop = resolveStructuralElevationSnap(slabElevationGuideSource(n), base + newThickness, sceneApi.nodes());
+            return Math.max(MIN_SLAB_THICKNESS, snappedTop - base);
+        },
+        onDrag: (n, sceneApi) => publishStructuralElevationGuide(slabElevationGuideSource(n), n.elevation ?? 0.05, sceneApi.nodes()),
+        onDragEnd: (n) => clearStructuralElevationGuide(n.id),
+        apply: (n, newThickness) => applySlabThicknessChange(n, newThickness),
+        previewOverrides: (n, newThickness, sceneApi) => slabChangePreviewOverrides(n, applySlabThicknessChange(n, newThickness), sceneApi),
+        placement: {
+            position: (n) => {
+                const [cx, cz] = slabHandleAnchor(n);
+                return [cx, (n.elevation ?? 0.05) + HEIGHT_HANDLE_OFFSET, cz];
+            },
+        },
+    };
+}
+function slabBaseElevationHandle() {
+    return {
+        kind: 'linear-resize',
+        axis: 'y',
+        anchor: 'min',
+        shape: 'tracker',
+        gridSnap: true,
+        min: (n) => MIN_SLAB_ELEVATION - (n.thickness ?? 0.05),
+        max: (n, sceneApi) => slabElevationUpperBound(sceneApi.nodes(), n) - (n.thickness ?? 0.05),
+        currentValue: (n) => getSlabBaseElevation(n),
+        magneticSnap: (n, newValue, sceneApi) => resolveStructuralElevationSnap(slabElevationGuideSource(n), newValue, sceneApi.nodes()),
+        onDrag: (n, sceneApi) => publishStructuralElevationGuide(slabElevationGuideSource(n), getSlabBaseElevation(n), sceneApi.nodes()),
+        onDragEnd: (n) => clearStructuralElevationGuide(n.id),
+        apply: (n, newBase) => applySlabBaseElevationChange(n, newBase),
+        previewOverrides: (n, newBase, sceneApi) => slabChangePreviewOverrides(n, applySlabBaseElevationChange(n, newBase), sceneApi),
+        placement: {
+            position: (n) => {
+                const [cx, cz] = slabHandleAnchor(n);
+                return [cx, getSlabBaseElevation(n), cz];
+            },
+        },
+    };
+}
+function slabHandles(node) {
+    return node.recessed
+        ? [slabRecessedDepthHandle()]
+        : [slabThicknessHandle(), slabBaseElevationHandle()];
 }
 /**
  * Slab — Phase 5 batch kind, polygon-based. Stage B: `def.geometry`
@@ -131,6 +206,8 @@ export const slabDefinition = {
         holes: [],
         holeMetadata: [],
         elevation: 0.05,
+        thickness: 0.05,
+        recessed: false,
         autoFromWalls: false,
     }),
     capabilities: {

package/dist/slab/elevation-limit.d.ts

@@ -0,0 +1,43 @@
+import { type AnyNode, type AnyNodeId, type SlabElevationClamp, type SlabNode } from '@pascal-app/core';
+/** Level-local Y of a solid slab's underside (its placement anchor). */
+export declare function getSlabBaseElevation(slab: Pick<SlabNode, 'elevation' | 'thickness'>): number;
+/** Stable vertical reference used by relative slab presets. */
+export declare function getSlabAnchorElevation(slab: Pick<SlabNode, 'elevation' | 'thickness' | 'recessed' | 'recessedRimElevation'>): number;
+/**
+ * Translate a solid slab to a new underside elevation without changing its
+ * authored thickness. Recessed slabs use a different rim/depth contract and
+ * keep the existing top/depth control instead.
+ */
+export declare function applySlabBaseElevationChange(slab: Pick<SlabNode, 'thickness'>, newBase: number): Pick<SlabNode, 'elevation'>;
+/** Translate a solid underside or recessed rim without resizing the body. */
+export declare function applySlabAnchorElevationChange(slab: Pick<SlabNode, 'elevation' | 'thickness' | 'recessed' | 'recessedRimElevation'>, newAnchor: number): Partial<SlabNode>;
+export declare function getSlabRecessDepth(slab: Pick<SlabNode, 'elevation' | 'recessedRimElevation'>): number;
+/** Resize a recess downward while keeping its rim anchor fixed. */
+export declare function applySlabRecessDepthChange(slab: Pick<SlabNode, 'recessedRimElevation'>, newDepth: number): Pick<SlabNode, 'elevation'>;
+/**
+ * Resize a solid slab upward from its underside. The occupied interval changes
+ * from [base, old top] to [base, base + new thickness], so anything hosted on
+ * the walking surface observes the new elevation.
+ */
+export declare function applySlabThicknessChange(slab: Pick<SlabNode, 'elevation' | 'thickness'>, newThickness: number): Pick<SlabNode, 'elevation' | 'thickness' | 'recessed'>;
+/**
+ * Move a slab's authored top while preserving thickness. Recessed slabs keep
+ * their pool-depth gesture; a grounded solid crossing below datum becomes
+ * recessed. Solid slab thickness is edited separately.
+ */
+export declare function applySlabTopChange(slab: SlabNode, newTop: number): Partial<SlabNode>;
+/**
+ * Apply a signed surface preset around the current anchor. Negative values make
+ * a recess below the anchor; positive values make a solid upward from it.
+ */
+export declare function applySlabElevationPreset(slab: SlabNode, signedDepth: number): Partial<SlabNode>;
+/**
+ * Level-context wrapper over the pure core clamp: a slab under
+ * plane-bound walls may not rise past the storey plane minus the
+ * minimum wall height. Slabs outside a level (no parent) are
+ * unconstrained.
+ */
+export declare function clampSlabElevation(nodes: Readonly<Record<AnyNodeId, AnyNode>>, slab: SlabNode, proposedElevation: number): SlabElevationClamp;
+/** Drag-time upper bound for the slab height arrow; +Infinity when unconstrained. */
+export declare function slabElevationUpperBound(nodes: Readonly<Record<AnyNodeId, AnyNode>>, slab: SlabNode): number;
+//# sourceMappingURL=elevation-limit.d.ts.map

package/dist/slab/elevation-limit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"elevation-limit.d.ts","sourceRoot":"","sources":["../../src/slab/elevation-limit.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EAMd,KAAK,kBAAkB,EACvB,KAAK,QAAQ,EAEd,MAAM,kBAAkB,CAAA;AAUzB,wEAAwE;AACxE,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,WAAW,GAAG,WAAW,CAAC,GAAG,MAAM,CAE5F;AAED,+DAA+D;AAC/D,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,WAAW,GAAG,WAAW,GAAG,UAAU,GAAG,sBAAsB,CAAC,GACpF,MAAM,CAER;AAED;;;;GAIG;AACH,wBAAgB,4BAA4B,CAC1C,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,WAAW,CAAC,EACjC,OAAO,EAAE,MAAM,GACd,IAAI,CAAC,QAAQ,EAAE,WAAW,CAAC,CAE7B;AAED,6EAA6E;AAC7E,wBAAgB,8BAA8B,CAC5C,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,WAAW,GAAG,WAAW,GAAG,UAAU,GAAG,sBAAsB,CAAC,EACrF,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,QAAQ,CAAC,CAOnB;AAED,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,WAAW,GAAG,sBAAsB,CAAC,GACzD,MAAM,CAER;AAED,mEAAmE;AACnE,wBAAgB,0BAA0B,CACxC,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,sBAAsB,CAAC,EAC5C,QAAQ,EAAE,MAAM,GACf,IAAI,CAAC,QAAQ,EAAE,WAAW,CAAC,CAG7B;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,WAAW,GAAG,WAAW,CAAC,EAC/C,YAAY,EAAE,MAAM,GACnB,IAAI,CAAC,QAAQ,EAAE,WAAW,GAAG,WAAW,GAAG,UAAU,CAAC,CAOxD;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,CAAC,CAgBpF;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,CAAC,CAiB/F;AAiBD;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC,EAC3C,IAAI,EAAE,QAAQ,EACd,iBAAiB,EAAE,MAAM,GACxB,kBAAkB,CAUpB;AAED,qFAAqF;AACrF,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC,EAC3C,IAAI,EAAE,QAAQ,GACb,MAAM,CAIR"}

package/dist/slab/elevation-limit.js

@@ -0,0 +1,124 @@
+import { clampSlabElevationForWalls, getSlabElevationUpperBound, getStoredLevelHeight, MIN_SLAB_THICKNESS, } from '@pascal-app/core';
+const GROUNDED_SLAB_EPSILON = 1e-3;
+/** Level-local Y of a solid slab's underside (its placement anchor). */
+export function getSlabBaseElevation(slab) {
+    return (slab.elevation ?? 0.05) - (slab.thickness ?? 0.05);
+}
+/** Stable vertical reference used by relative slab presets. */
+export function getSlabAnchorElevation(slab) {
+    return slab.recessed ? (slab.recessedRimElevation ?? 0) : getSlabBaseElevation(slab);
+}
+/**
+ * Translate a solid slab to a new underside elevation without changing its
+ * authored thickness. Recessed slabs use a different rim/depth contract and
+ * keep the existing top/depth control instead.
+ */
+export function applySlabBaseElevationChange(slab, newBase) {
+    return { elevation: newBase + (slab.thickness ?? 0.05) };
+}
+/** Translate a solid underside or recessed rim without resizing the body. */
+export function applySlabAnchorElevationChange(slab, newAnchor) {
+    if (!slab.recessed)
+        return applySlabBaseElevationChange(slab, newAnchor);
+    const rim = getSlabAnchorElevation(slab);
+    return {
+        elevation: slab.elevation + (newAnchor - rim),
+        recessedRimElevation: newAnchor,
+    };
+}
+export function getSlabRecessDepth(slab) {
+    return Math.max(MIN_SLAB_THICKNESS, (slab.recessedRimElevation ?? 0) - slab.elevation);
+}
+/** Resize a recess downward while keeping its rim anchor fixed. */
+export function applySlabRecessDepthChange(slab, newDepth) {
+    const depth = Math.max(MIN_SLAB_THICKNESS, newDepth);
+    return { elevation: (slab.recessedRimElevation ?? 0) - depth };
+}
+/**
+ * Resize a solid slab upward from its underside. The occupied interval changes
+ * from [base, old top] to [base, base + new thickness], so anything hosted on
+ * the walking surface observes the new elevation.
+ */
+export function applySlabThicknessChange(slab, newThickness) {
+    const thickness = Math.max(MIN_SLAB_THICKNESS, newThickness);
+    return {
+        elevation: getSlabBaseElevation(slab) + thickness,
+        thickness,
+        recessed: false,
+    };
+}
+/**
+ * Move a slab's authored top while preserving thickness. Recessed slabs keep
+ * their pool-depth gesture; a grounded solid crossing below datum becomes
+ * recessed. Solid slab thickness is edited separately.
+ */
+export function applySlabTopChange(slab, newTop) {
+    if (slab.recessed) {
+        const rim = getSlabAnchorElevation(slab);
+        if (newTop < rim)
+            return { elevation: newTop, recessed: true };
+        return {
+            elevation: Math.max(newTop, rim + MIN_SLAB_THICKNESS),
+            thickness: Math.max(MIN_SLAB_THICKNESS, newTop - rim),
+            recessed: false,
+            recessedRimElevation: undefined,
+        };
+    }
+    const grounded = Math.abs(slab.elevation - slab.thickness) < GROUNDED_SLAB_EPSILON;
+    if (grounded && newTop <= 0)
+        return { elevation: newTop, recessed: true };
+    return { elevation: newTop, recessed: false };
+}
+/**
+ * Apply a signed surface preset around the current anchor. Negative values make
+ * a recess below the anchor; positive values make a solid upward from it.
+ */
+export function applySlabElevationPreset(slab, signedDepth) {
+    const anchor = getSlabAnchorElevation(slab);
+    if (signedDepth < 0) {
+        return {
+            elevation: anchor + signedDepth,
+            recessed: true,
+            recessedRimElevation: anchor,
+            fillToTerrain: undefined,
+        };
+    }
+    const thickness = Math.max(MIN_SLAB_THICKNESS, signedDepth);
+    return {
+        elevation: anchor + thickness,
+        thickness,
+        recessed: false,
+        recessedRimElevation: undefined,
+    };
+}
+function resolveSlabLevelContext(nodes, slab) {
+    const parent = slab.parentId ? nodes[slab.parentId] : undefined;
+    if (parent?.type !== 'level')
+        return null;
+    const level = parent;
+    const children = level.children.map((childId) => nodes[childId]);
+    return {
+        storeyHeight: getStoredLevelHeight(level),
+        walls: children.filter((child) => child?.type === 'wall'),
+        slabs: children.filter((child) => child?.type === 'slab'),
+    };
+}
+/**
+ * Level-context wrapper over the pure core clamp: a slab under
+ * plane-bound walls may not rise past the storey plane minus the
+ * minimum wall height. Slabs outside a level (no parent) are
+ * unconstrained.
+ */
+export function clampSlabElevation(nodes, slab, proposedElevation) {
+    const context = resolveSlabLevelContext(nodes, slab);
+    if (!context)
+        return { elevation: proposedElevation, clamped: false };
+    return clampSlabElevationForWalls(proposedElevation, slab, context.walls, context.slabs, context.storeyHeight);
+}
+/** Drag-time upper bound for the slab height arrow; +Infinity when unconstrained. */
+export function slabElevationUpperBound(nodes, slab) {
+    const context = resolveSlabLevelContext(nodes, slab);
+    if (!context)
+        return Number.POSITIVE_INFINITY;
+    return getSlabElevationUpperBound(slab, context.walls, context.slabs, context.storeyHeight);
+}

package/dist/slab/floorplan-affordances.d.ts

@@ -13,6 +13,8 @@ export declare const slabMoveVertexAffordance: import("@pascal-app/core").Floorp
         elevatorId?: string | undefined;
     }[];
     elevation: number;
+    thickness: number;
+    recessed: boolean;
     autoFromWalls: boolean;
     name?: string | undefined;
     camera?: {
@@ -41,6 +43,8 @@ export declare const slabMoveVertexAffordance: import("@pascal-app/core").Floorp
     } | undefined;
     materialPreset?: string | undefined;
     slots?: Record<string, string> | undefined;
+    recessedRimElevation?: number | undefined;
+    fillToTerrain?: boolean | undefined;
 }>;
 export declare const slabAddVertexAffordance: import("@pascal-app/core").FloorplanAffordance<{
     object: "node";
@@ -57,6 +61,8 @@ export declare const slabAddVertexAffordance: import("@pascal-app/core").Floorpl
         elevatorId?: string | undefined;
     }[];
     elevation: number;
+    thickness: number;
+    recessed: boolean;
     autoFromWalls: boolean;
     name?: string | undefined;
     camera?: {
@@ -85,6 +91,8 @@ export declare const slabAddVertexAffordance: import("@pascal-app/core").Floorpl
     } | undefined;
     materialPreset?: string | undefined;
     slots?: Record<string, string> | undefined;
+    recessedRimElevation?: number | undefined;
+    fillToTerrain?: boolean | undefined;
 }>;
 export declare const slabMoveEdgeAffordance: import("@pascal-app/core").FloorplanAffordance<{
     object: "node";
@@ -101,6 +109,8 @@ export declare const slabMoveEdgeAffordance: import("@pascal-app/core").Floorpla
         elevatorId?: string | undefined;
     }[];
     elevation: number;
+    thickness: number;
+    recessed: boolean;
     autoFromWalls: boolean;
     name?: string | undefined;
     camera?: {
@@ -129,6 +139,8 @@ export declare const slabMoveEdgeAffordance: import("@pascal-app/core").Floorpla
     } | undefined;
     materialPreset?: string | undefined;
     slots?: Record<string, string> | undefined;
+    recessedRimElevation?: number | undefined;
+    fillToTerrain?: boolean | undefined;
 }>;
 export declare const slabDeleteVertexAffordance: import("@pascal-app/core").FloorplanAffordance<{
     object: "node";
@@ -145,6 +157,8 @@ export declare const slabDeleteVertexAffordance: import("@pascal-app/core").Floo
         elevatorId?: string | undefined;
     }[];
     elevation: number;
+    thickness: number;
+    recessed: boolean;
     autoFromWalls: boolean;
     name?: string | undefined;
     camera?: {
@@ -173,5 +187,7 @@ export declare const slabDeleteVertexAffordance: import("@pascal-app/core").Floo
     } | undefined;
     materialPreset?: string | undefined;
     slots?: Record<string, string> | undefined;
+    recessedRimElevation?: number | undefined;
+    fillToTerrain?: boolean | undefined;
 }>;
 //# sourceMappingURL=floorplan-affordances.d.ts.map

package/dist/slab/floorplan-affordances.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"floorplan-affordances.d.ts","sourceRoot":"","sources":["../../src/slab/floorplan-affordances.ts"],"names":[],"mappings":"AAgEA,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGpC,CAAA;AACD,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGnC,CAAA;AACD,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGlC,CAAA;AACD,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGtC,CAAA"}
+{"version":3,"file":"floorplan-affordances.d.ts","sourceRoot":"","sources":["../../src/slab/floorplan-affordances.ts"],"names":[],"mappings":"AAgEA,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGpC,CAAA;AACD,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGnC,CAAA;AACD,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGlC,CAAA;AACD,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGtC,CAAA"}

package/dist/slab/geometry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"geometry.d.ts","sourceRoot":"","sources":["../../src/slab/geometry.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,eAAe,EAEpB,KAAK,QAAQ,EAEd,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAEL,KAAK,WAAW,EAKhB,KAAK,aAAa,EAGnB,MAAM,oBAAoB,CAAA;AAC3B,OAAO,EAIL,KAAK,EAKN,MAAM,OAAO,CAAA;AAqJd,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,QAAQ,EACd,GAAG,CAAC,EAAE,eAAe,EACrB,OAAO,GAAE,aAA0B,EACnC,QAAQ,UAAO,EACf,WAAW,GAAE,WAAoB,EACjC,UAAU,CAAC,EAAE,MAAM,GAClB,KAAK,CA8BP"}
+{"version":3,"file":"geometry.d.ts","sourceRoot":"","sources":["../../src/slab/geometry.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,eAAe,EAMpB,KAAK,QAAQ,EAId,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAGL,KAAK,WAAW,EAKhB,KAAK,aAAa,EAGnB,MAAM,oBAAoB,CAAA;AAC3B,OAAO,EAIL,KAAK,EAKN,MAAM,OAAO,CAAA;AAuOd,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,QAAQ,EACd,GAAG,CAAC,EAAE,eAAe,EACrB,OAAO,GAAE,aAA0B,EACnC,QAAQ,UAAO,EACf,WAAW,GAAE,WAAoB,EACjC,UAAU,CAAC,EAAE,MAAM,GAClB,KAAK,CA4DP"}

package/dist/slab/geometry.js

@@ -1,6 +1,7 @@
-import { getMaterialPresetByRef, slabPolygonContextFromGeometry, } from '@pascal-app/core';
-import { applyMaterialPresetToMaterials, createDefaultMaterial, createMaterial, createSurfaceRoleMaterial, generateSlabGeometry, resolveMaterialRef, resolveSlotDefaultMaterial, } from '@pascal-app/viewer';
+import { getLevelElevations, getMaterialPresetByRef, getRenderableSlabPolygon, slabPolygonContextFromGeometry, surfaceHeightAt, terrainFieldOf, } from '@pascal-app/core';
+import { applyMaterialPresetToMaterials, buildTerrainPerimeterFillGeometry, createDefaultMaterial, createMaterial, createSurfaceRoleMaterial, generateSlabGeometry, resolveMaterialRef, resolveSlotDefaultMaterial, } from '@pascal-app/viewer';
 import { BufferGeometry, Float32BufferAttribute, FrontSide, Group, Mesh, Vector3, } from 'three';
+import { creaseCrossings } from '../site/terrain-drape';
 import { SLAB_SIDE_SLOT_DEFAULT, SLAB_TOP_SLOT_DEFAULT } from './slots';
 const slabMaterialCache = new Map();
 function getSlabSlotMaterial(node, slotId, shading, textures, colorPreset, sceneTheme, sceneMaterials) {
@@ -67,8 +68,10 @@ function splitSlabFacesByFacing(geometry) {
     const build = (data) => {
         const geo = new BufferGeometry();
         geo.setAttribute('position', new Float32BufferAttribute(data.pos, 3));
-        if (data.uv.length > 0)
+        if (data.uv.length > 0) {
             geo.setAttribute('uv', new Float32BufferAttribute(data.uv, 2));
+            geo.setAttribute('uv2', new Float32BufferAttribute(data.uv.slice(), 2));
+        }
         geo.computeVertexNormals();
         return geo;
     };
@@ -108,9 +111,86 @@ function getLegacySlabMaterial(node, shading) {
     slabMaterialCache.set(cacheKey, material);
     return material;
 }
+function terrainFillContext(ctx) {
+    if (!ctx)
+        return null;
+    const level = ctx.parent;
+    if (level?.type !== 'level' || !level.parentId)
+        return null;
+    const building = ctx.resolve(level.parentId);
+    if (building?.type !== 'building' || !building.parentId)
+        return null;
+    const site = ctx.resolve(building.parentId);
+    if (site?.type !== 'site')
+        return null;
+    const field = terrainFieldOf(site);
+    const nodes = {
+        [site.id]: site,
+        [building.id]: building,
+        [level.id]: level,
+    };
+    for (const childId of building.children) {
+        const child = ctx.resolve(childId);
+        if (child)
+            nodes[child.id] = child;
+    }
+    const elevation = getLevelElevations(nodes).get(level.id);
+    if (!elevation)
+        return null;
+    const baseWorldY = (building.position?.[1] ?? 0) + elevation.baseY;
+    if (Math.abs(baseWorldY) >= 1e-4)
+        return null;
+    return {
+        baseWorldY,
+        building,
+        field,
+    };
+}
+function buildSlabTerrainFillGeometry(node, polygon, ctx) {
+    const terrain = terrainFillContext(ctx);
+    if (!terrain || polygon.length < 3)
+        return null;
+    let area2 = 0;
+    for (let index = 0; index < polygon.length; index += 1) {
+        const [ax, az] = polygon[index];
+        const [bx, bz] = polygon[(index + 1) % polygon.length];
+        area2 += ax * bz - bx * az;
+    }
+    const contour = area2 < 0 ? [...polygon].reverse() : polygon;
+    const angle = terrain.building.rotation?.[1] ?? 0;
+    const cos = Math.cos(angle);
+    const sin = Math.sin(angle);
+    const [offsetX, , offsetZ] = terrain.building.position ?? [0, 0, 0];
+    const toSite = (x, z) => [
+        cos * x + sin * z + offsetX,
+        -sin * x + cos * z + offsetZ,
+    ];
+    const points = [];
+    for (let index = 0; index < contour.length; index += 1) {
+        const [ax, az] = contour[index];
+        const [bx, bz] = contour[(index + 1) % contour.length];
+        const [siteAx, siteAz] = toSite(ax, az);
+        const [siteBx, siteBz] = toSite(bx, bz);
+        points.push([ax, az]);
+        if (terrain.field) {
+            for (const t of creaseCrossings(terrain.field, siteAx, siteAz, siteBx, siteBz)) {
+                points.push([ax + (bx - ax) * t, az + (bz - az) * t]);
+            }
+        }
+    }
+    const top = node.elevation - node.thickness;
+    const localPoints = points.map(([x, z]) => ({ x, z }));
+    const bottomY = points.map(([x, z]) => {
+        const [siteX, siteZ] = toSite(x, z);
+        const ground = terrain.field ? surfaceHeightAt(terrain.field, siteX, siteZ) : 0;
+        return Math.min(top, ground - terrain.baseWorldY);
+    });
+    return buildTerrainPerimeterFillGeometry(localPoints, bottomY, top, 1e-4);
+}
 export function buildSlabGeometry(node, ctx, shading = 'rendered', textures = true, colorPreset = 'clay', sceneTheme) {
     const group = new Group();
-    const merged = generateSlabGeometry(node, slabPolygonContextFromGeometry(ctx));
+    const polygonContext = slabPolygonContextFromGeometry(ctx);
+    const merged = generateSlabGeometry(node, polygonContext);
     const { top, side } = splitSlabFacesByFacing(merged);
     merged.dispose();
     const elevation = node.elevation ?? 0.05;
@@ -125,9 +205,22 @@ export function buildSlabGeometry(node, ctx, shading = 'rendered', textures = tr
         mesh.castShadow = true;
         mesh.receiveShadow = true;
         mesh.userData.slotId = slotId;
-        if (elevation < 0)
+        // Solid slabs bake [elevation − thickness, elevation] into the geometry;
+        // recessed shells are authored from floor to rim and translated so the
+        // floor sits at `elevation`.
+        if (node.recessed)
             mesh.position.y = elevation;
         group.add(mesh);
     }
+    if (node.fillToTerrain && !node.recessed) {
+        const terrainFill = buildSlabTerrainFillGeometry(node, getRenderableSlabPolygon(node, polygonContext), ctx);
+        if (terrainFill) {
+            const mesh = new Mesh(terrainFill, getSlabSlotMaterial(node, 'side', shading, textures, colorPreset, sceneTheme, ctx?.materials));
+            mesh.castShadow = true;
+            mesh.receiveShadow = true;
+            mesh.userData.slotId = 'side';
+            group.add(mesh);
+        }
+    }
     return group;
 }

package/dist/slab/panel.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/slab/panel.tsx"],"names":[],"mappings":"AAmBA;;;;;;;;;;GAUG;AACH,wBAAgB,SAAS,uCAiQxB;AAED,eAAe,SAAS,CAAA"}
+{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/slab/panel.tsx"],"names":[],"mappings":"AA+BA;;;;;;;;;;GAUG;AACH,wBAAgB,SAAS,uCA8ZxB;AAED,eAAe,SAAS,CAAA"}