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

package/dist/wall/tool.js

@@ -1,10 +1,11 @@
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
-import { calculateLevelMiters, collectAlignmentAnchors, emitter, getWallMiterBoundaryPoints, resolveAlignment, resolveBuildingForLevel, useScene, wallClosesRoom, } from '@pascal-app/core';
-import { CursorSphere, chainEndJoinsExistingWall, createWallOnCurrentLevel, EDITOR_LAYER, formatAngleRadians, formatLinearMeasurement, getAngleArcToSegmentReference, getAngleToSegmentReference, getSegmentAngleReferenceAtPoint, isAlignmentGuideActive, isAngleSnapActive, isMagneticSnapActive, markToolCancelConsumed, snapWallDraftPointDetailed, triggerSFX, useAlignmentGuides, useEditor, useSegmentDraftChain, useWallSnapIndicator, WALL_CONNECT_SNAP_RADIUS, WALL_JOIN_SNAP_RADIUS, } from '@pascal-app/editor';
+import { calculateLevelMiters, collectAlignmentAnchors, DEFAULT_LEVEL_HEIGHT, emitter, getWallMiterBoundaryPoints, resolveAlignment, resolveBuildingForLevel, sceneRegistry, useScene, wallClosesRoom, } from '@pascal-app/core';
+import { CursorSphere, chainEndJoinsExistingWall, clearPlacementSurface, createWallOnCurrentLevel, EDITOR_LAYER, formatAngleRadians, formatLinearMeasurement, getAngleArcToSegmentReference, getAngleToSegmentReference, getSegmentAngleReferenceAtPoint, isAlignmentGuideActive, isAngleSnapActive, isMagneticSnapActive, markToolCancelConsumed, publishHorizontalConstructionPlane, publishPlacementSurface, resampleTerrainConstructionPlane, resolveEventConstructionPlane, resolvePointerSupportSurface, snapWallDraftPointDetailed, triggerSFX, useAlignmentGuides, useEditor, useFloorplanDraftPreview, useSegmentDraftChain, useWallSnapIndicator, WALL_CONNECT_SNAP_RADIUS, WALL_JOIN_SNAP_RADIUS, } from '@pascal-app/editor';
 import { getSceneTheme, useViewer } from '@pascal-app/viewer';
-import { Html } from '@react-three/drei';
-import { useEffect, useMemo, useRef, useState } from 'react';
-import { BoxGeometry, BufferGeometry, DoubleSide, Vector3 } from 'three';
+import { useThree } from '@react-three/fiber';
+import { useEffect, useRef, useState } from 'react';
+import { BoxGeometry, DoubleSide, Vector3 } from 'three';
+import { DraftAngleArc, DraftAxisGuides, DraftMeasurementLabel, getNearestAxisAngleLabel, } from '../shared/draft-axis-guides';
 /**
  * Phase 5 Stage D — wall placement tool (kind-owned).
  *
@@ -18,7 +19,6 @@ import { BoxGeometry, BufferGeometry, DoubleSide, Vector3 } from 'three';
  *
  * Mounted via `def.tool` from `wall/definition.ts`.
  */
-const WALL_HEIGHT = 2.5;
 const DRAFT_WALL_THICKNESS = 0.1;
 /** Figma-style alignment-snap threshold (meters), matching the move tools. */
 const ALIGNMENT_THRESHOLD_M = 0.08;
@@ -29,19 +29,12 @@ const DRAFT_ANGLE_LABEL_Y_OFFSET = 0.08;
 const DRAFT_ANGLE_ARC_Y_OFFSET = 0.012;
 const DRAFT_ANGLE_ARC_MIN_RADIUS = 0.32;
 const DRAFT_ANGLE_ARC_MAX_RADIUS = 0.72;
-const DRAFT_ANGLE_ARC_SEGMENTS = 24;
-const DRAFT_AXIS_GUIDE_LENGTH = 2000;
-const DRAFT_AXIS_GUIDE_WIDTH = 0.035;
-const DRAFT_AXIS_GUIDE_HEIGHT = 0.004;
-const DRAFT_AXIS_GUIDE_Y_OFFSET = 0.026;
-const DRAFT_AXIS_ANGLE_ARC_Y_OFFSET = 0.05;
-const DRAFT_AXIS_ANGLE_LABEL_Y_OFFSET = 0.16;
-const DRAFT_AXIS_ANGLE_ARC_MIN_RADIUS = 0.36;
-const DRAFT_AXIS_ANGLE_ARC_MAX_RADIUS = 0.82;
-const AXIS_ANGLE_REFERENCES = [
-    { vector: [1, 0], orientation: 'axis' },
-    { vector: [0, 1], orientation: 'axis' },
-];
+// Grid-plane surface publish (pointer-decided): scratch + constant normal so
+// per-move publishes don't allocate.
+const SURFACE_UP = new Vector3(0, 1, 0);
+const surfacePointScratch = new Vector3();
+const wallSurfaceWorldScratch = new Vector3();
+const wallSurfaceLocalScratch = new Vector3();
 function clamp(value, min, max) {
     return Math.min(max, Math.max(min, value));
 }
@@ -58,43 +51,6 @@ function isWithinWallJoinSnapRadius(point, vertex) {
     const dz = point[1] - vertex.z;
     return dx * dx + dz * dz <= WALL_JOIN_SNAP_RADIUS * WALL_JOIN_SNAP_RADIUS;
 }
-function getNearestAxisAngleLabel(start, end, y) {
-    const dx = end[0] - start[0];
-    const dz = end[1] - start[1];
-    const length = Math.hypot(dx, dz);
-    if (length < 0.01)
-        return null;
-    const draftVector = [dx, dz];
-    const axisCandidates = [];
-    for (const reference of AXIS_ANGLE_REFERENCES) {
-        const angle = getAngleToSegmentReference(draftVector, reference);
-        const arc = getAngleArcToSegmentReference(draftVector, reference);
-        if (!(angle === null || arc === null)) {
-            axisCandidates.push({ angle, arc });
-        }
-    }
-    const nearestAxisAngle = axisCandidates.sort((a, b) => a.angle - b.angle)[0];
-    if (!nearestAxisAngle)
-        return null;
-    const radius = clamp(length * 0.22, DRAFT_AXIS_ANGLE_ARC_MIN_RADIUS, DRAFT_AXIS_ANGLE_ARC_MAX_RADIUS);
-    const { angle, arc } = nearestAxisAngle;
-    return {
-        id: 'axis',
-        label: formatAngleRadians(angle),
-        position: [
-            start[0] + Math.cos(arc.midAngle) * (radius + 0.16),
-            y + DRAFT_AXIS_ANGLE_LABEL_Y_OFFSET,
-            start[1] + Math.sin(arc.midAngle) * (radius + 0.16),
-        ],
-        arc: {
-            center: start,
-            radius,
-            startAngle: arc.startAngle,
-            endAngle: arc.endAngle,
-            y: y + DRAFT_AXIS_ANGLE_ARC_Y_OFFSET,
-        },
-    };
-}
 function toWallPlanPoint(point) {
     return [point.x, point.y];
 }
@@ -340,13 +296,23 @@ function getBelowLevelWalls() {
 export const WallTool = () => {
     const unit = useViewer((state) => state.unit);
     const isDark = useViewer((state) => getSceneTheme(state.sceneTheme).appearance === 'dark');
+    const activeLevelId = useViewer((state) => state.selection.levelId);
+    const activeLevelHeight = useScene((state) => {
+        const level = activeLevelId ? state.nodes[activeLevelId] : undefined;
+        return level?.type === 'level' ? (level.height ?? DEFAULT_LEVEL_HEIGHT) : DEFAULT_LEVEL_HEIGHT;
+    });
     // A placed wall preset seeds `toolDefaults.wall` (height / thickness …)
     // before the tool mounts, so the draft preview is drawn at the preset's
     // dimensions rather than the generic fallbacks — matching the wall that
     // will be created. Read through refs so the live event handlers below see
     // the latest values without re-subscribing.
     const wallDefaults = useEditor((s) => s.toolDefaults.wall);
-    const previewHeight = typeof wallDefaults?.height === 'number' ? wallDefaults.height : WALL_HEIGHT;
+    // Camera for the pointer-support resolution (deck top vs floor) — read
+    // through a ref so the event handlers below see the live camera.
+    const camera = useThree((state) => state.camera);
+    const cameraRef = useRef(camera);
+    cameraRef.current = camera;
+    const previewHeight = typeof wallDefaults?.height === 'number' ? wallDefaults.height : activeLevelHeight;
     const previewThickness = typeof wallDefaults?.thickness === 'number' ? wallDefaults.thickness : DRAFT_WALL_THICKNESS;
     const previewHeightRef = useRef(previewHeight);
     previewHeightRef.current = previewHeight;
@@ -361,6 +327,7 @@ export const WallTool = () => {
     // the "segment tees into an existing wall" chain-termination test, so
     // snapping onto the chain's own segments never reads as a join.
     const chainWallIds = useRef([]);
+    const constructionPlane = useRef(null);
     const buildingState = useRef(0);
     const [draftMeasurement, setDraftMeasurement] = useState(null);
     const [axisGuide, setAxisGuide] = useState(null);
@@ -409,10 +376,70 @@ export const WallTool = () => {
                 ? [point[0] + ar.snap.dx, point[1] + ar.snap.dz]
                 : point;
         };
+        // The walking surface the pointer actually aims at (deck top when over
+        // the deck, floor/ground underneath it) — only for genuine 3D pointer
+        // events. The 2D floor plan emits synthetic grid events with no camera
+        // ray behind them; those keep the uncapped max election and leave the
+        // grid plane alone.
+        const pointedSurfaceFor = (event) => event.nativeEvent?.target instanceof HTMLCanvasElement
+            ? resolvePointerSupportSurface(cameraRef.current, event.position, {
+                includeNodeTopSurfaces: true,
+            })
+            : null;
+        const snappedWallConstructionPlane = (targetWallIds, walls) => {
+            const activeWallIds = new Set(walls.map((wall) => wall.id));
+            const targetIds = targetWallIds.filter((id) => activeWallIds.has(id));
+            if (targetIds.length === 0)
+                return null;
+            const buildingId = useViewer.getState().selection.buildingId;
+            const buildingMesh = buildingId ? sceneRegistry.nodes.get(buildingId) : undefined;
+            const currentLevelId = useViewer.getState().selection.levelId;
+            const levelMesh = currentLevelId
+                ? sceneRegistry.nodes.get(currentLevelId)
+                : undefined;
+            let resolved = null;
+            for (const id of targetIds) {
+                const targetWall = walls.find((wall) => wall.id === id);
+                if (!targetWall)
+                    continue;
+                const wallMesh = sceneRegistry.nodes.get(id);
+                if (!wallMesh)
+                    continue;
+                wallMesh.getWorldPosition(wallSurfaceWorldScratch);
+                const worldY = wallSurfaceWorldScratch.y;
+                wallSurfaceLocalScratch.copy(wallSurfaceWorldScratch);
+                if (buildingMesh)
+                    buildingMesh.worldToLocal(wallSurfaceLocalScratch);
+                const localY = wallSurfaceLocalScratch.y;
+                wallSurfaceLocalScratch.copy(wallSurfaceWorldScratch);
+                if (levelMesh)
+                    levelMesh.worldToLocal(wallSurfaceLocalScratch);
+                const elevation = wallSurfaceLocalScratch.y;
+                if (resolved &&
+                    (Math.abs(resolved.worldY - worldY) > 1e-4 ||
+                        Math.abs((resolved.elevation ?? elevation) - elevation) > 1e-4 ||
+                        resolved.supportSlabId !== (targetWall.supportSlabId ?? null))) {
+                    // An ambiguous junction at different elevations transfers no plane.
+                    return null;
+                }
+                resolved = {
+                    localY,
+                    worldY,
+                    elevation,
+                    supportSlabId: targetWall.supportSlabId ?? null,
+                    sourceNodeId: targetWall.id,
+                };
+            }
+            return resolved;
+        };
         const stopDrafting = () => {
             buildingState.current = 0;
+            constructionPlane.current = null;
             chainFirstVertex.current = null;
             chainWallIds.current = [];
+            const draftPreview = useFloorplanDraftPreview.getState();
+            draftPreview.setWallDraftStart(null);
+            draftPreview.setWallDraftEnd(null);
             if (wallPreviewRef.current) {
                 wallPreviewRef.current.visible = false;
             }
@@ -421,16 +448,31 @@ export const WallTool = () => {
             useAlignmentGuides.getState().clear();
             useWallSnapIndicator.getState().clear();
             useSegmentDraftChain.getState().clear('wall');
+            clearPlacementSurface();
         };
         const onGridMove = (event) => {
             if (!(cursorRef.current && wallPreviewRef.current))
                 return;
+            // Ride the grid event plane on the pointed surface: aiming at an
+            // elevated deck lifts the plane to the deck top, so the draft's XZ
+            // lands where the cursor points and the preview/cursor Y
+            // (`event.localPosition[1]`) sits at the base the committed wall
+            // will elect. Aiming past the deck edge drops it back to the floor.
+            const pointed = buildingState.current === 0 ? pointedSurfaceFor(event) : null;
+            if (constructionPlane.current) {
+                publishHorizontalConstructionPlane(event, constructionPlane.current);
+            }
+            else if (pointed) {
+                publishPlacementSurface(surfacePointScratch.set(event.position[0], pointed.worldY, event.position[2]), SURFACE_UP);
+            }
             const walls = getCurrentLevelWalls();
             // Add walls on the floor below as extra snap references so the new wall
             // can align with the level beneath it. Kept separate from `walls` so the
             // measurement HUD only reports against the active level.
             const snapWalls = [...walls, ...getBelowLevelWalls()];
-            const localPoint = [event.localPosition[0], event.localPosition[2]];
+            const localPoint = pointed?.localPoint
+                ? [pointed.localPoint[0], pointed.localPoint[2]]
+                : [event.localPosition[0], event.localPosition[2]];
             // Snapping is governed entirely by the snapping mode (grid / lines /
             // angles / off). `'off'` is the bypass — there is no Shift hold-to-bypass.
             const angleLocked = buildingState.current === 1 && isAngleSnapActive();
@@ -451,10 +493,15 @@ export const WallTool = () => {
                 : null);
             if (buildingState.current === 1) {
                 const snappedLocal = gridPosition;
-                endingPoint.current.set(snappedLocal[0], event.localPosition[1], snappedLocal[1]);
+                const draftY = constructionPlane.current?.localY ?? event.localPosition[1];
+                endingPoint.current.set(snappedLocal[0], draftY, snappedLocal[1]);
+                const draftPreview = useFloorplanDraftPreview.getState();
+                draftPreview.setWallDraftStart([startingPoint.current.x, startingPoint.current.z]);
+                draftPreview.setWallDraftEnd(snappedLocal);
                 cursorRef.current.position.copy(endingPoint.current);
                 setAxisGuide({
                     origin: [startingPoint.current.x, startingPoint.current.z],
+                    endOrigin: snappedLocal,
                     y: startingPoint.current.y,
                     angleLabel: getNearestAxisAngleLabel([startingPoint.current.x, startingPoint.current.z], snappedLocal, startingPoint.current.y),
                 });
@@ -468,7 +515,8 @@ export const WallTool = () => {
                 setDraftMeasurement(getDraftMeasurementState([startingPoint.current.x, startingPoint.current.z], snappedLocal, walls, unit, startingPoint.current.y, previewHeightRef.current));
             }
             else {
-                cursorRef.current.position.set(gridPosition[0], event.localPosition[1], gridPosition[1]);
+                const hoverPlane = resampleTerrainConstructionPlane(resolveEventConstructionPlane(event, pointed), gridPosition);
+                cursorRef.current.position.set(gridPosition[0], hoverPlane.localY, gridPosition[1]);
                 setDraftMeasurement(null);
                 setAxisGuide(null);
             }
@@ -482,21 +530,37 @@ export const WallTool = () => {
             }
             const walls = getCurrentLevelWalls();
             const snapWalls = [...walls, ...getBelowLevelWalls()];
-            const localClick = [event.localPosition[0], event.localPosition[2]];
+            const pointed = buildingState.current === 0 ? pointedSurfaceFor(event) : null;
+            const localClick = pointed?.localPoint
+                ? [pointed.localPoint[0], pointed.localPoint[2]]
+                : [event.localPosition[0], event.localPosition[2]];
             if (buildingState.current === 0) {
-                const snappedStart = alignPoint(snapWallDraftPointDetailed({
+                const snapResult = snapWallDraftPointDetailed({
                     point: localClick,
                     walls: snapWalls,
                     magnetic: isMagneticSnapActive(),
-                }).point);
+                });
+                const snappedStart = alignPoint(snapResult.point);
+                const resolvedPlane = (pointed?.sourceNodeId
+                    ? resolveEventConstructionPlane(event, pointed)
+                    : pointMatches(snappedStart, snapResult.point)
+                        ? snappedWallConstructionPlane(snapResult.targetWallIds, walls)
+                        : null) ?? resolveEventConstructionPlane(event, pointed);
+                const plane = resampleTerrainConstructionPlane(resolvedPlane, snappedStart);
+                constructionPlane.current = plane;
+                publishHorizontalConstructionPlane(event, plane);
                 gridPosition = snappedStart;
-                startingPoint.current.set(snappedStart[0], event.localPosition[1], snappedStart[1]);
+                startingPoint.current.set(snappedStart[0], plane.localY, snappedStart[1]);
                 chainFirstVertex.current = startingPoint.current.clone();
                 endingPoint.current.copy(startingPoint.current);
                 buildingState.current = 1;
+                const draftPreview = useFloorplanDraftPreview.getState();
+                draftPreview.setWallDraftStart(snappedStart);
+                draftPreview.setWallDraftEnd(snappedStart);
                 setAxisGuide({
                     origin: snappedStart,
-                    y: event.localPosition[1],
+                    endOrigin: null,
+                    y: plane.localY,
                     angleLabel: null,
                 });
                 triggerSFX('sfx:structure-build-start');
@@ -523,7 +587,12 @@ export const WallTool = () => {
                 if (dx * dx + dz * dz < 0.01 * 0.01)
                     return;
                 // Both start and end are building-local ✓
-                const createdWall = createWallOnCurrentLevel([startingPoint.current.x, startingPoint.current.z], snappedEnd);
+                const createdWall = createWallOnCurrentLevel([startingPoint.current.x, startingPoint.current.z], snappedEnd, {
+                    supportCap: constructionPlane.current?.elevation ?? null,
+                    preferredSupportSlabId: constructionPlane.current?.supportSlabId ?? null,
+                    constructionElevation: constructionPlane.current?.elevation ?? null,
+                    constructionHeight: previewHeightRef.current,
+                });
                 if (!createdWall)
                     return;
                 chainWallIds.current.push(createdWall.id);
@@ -558,13 +627,19 @@ export const WallTool = () => {
                 // chains its next segment from the same point (its own snap
                 // pipeline can resolve a slightly different endpoint).
                 useSegmentDraftChain.getState().setChainStart('wall', [nextStart[0], nextStart[1]]);
-                startingPoint.current.set(nextStart[0], event.localPosition[1], nextStart[1]);
+                const draftY = constructionPlane.current?.localY ?? event.localPosition[1];
+                startingPoint.current.set(nextStart[0], draftY, nextStart[1]);
                 endingPoint.current.copy(startingPoint.current);
+                const draftPreview = useFloorplanDraftPreview.getState();
+                draftPreview.setWallDraftEnd(null);
+                draftPreview.setWallDraftStart(nextStart);
+                draftPreview.setWallDraftEnd(nextStart);
                 cursorRef.current?.position.copy(startingPoint.current);
                 buildingState.current = 1;
                 setAxisGuide({
                     origin: nextStart,
-                    y: event.localPosition[1],
+                    endOrigin: null,
+                    y: draftY,
                     angleLabel: null,
                 });
                 // Hide the preview until the next `onGridMove` writes the
@@ -591,38 +666,15 @@ export const WallTool = () => {
             emitter.off('grid:move', onGridMove);
             emitter.off('grid:click', onGridClick);
             emitter.off('tool:cancel', onCancel);
+            clearPlacementSurface();
             useAlignmentGuides.getState().clear();
             useWallSnapIndicator.getState().clear();
             useSegmentDraftChain.getState().clear('wall');
+            const draftPreview = useFloorplanDraftPreview.getState();
+            draftPreview.setWallDraftStart(null);
+            draftPreview.setWallDraftEnd(null);
         };
     }, [unit]);
-    return (_jsxs("group", { children: [_jsx(WallAxisGuides, { guide: axisGuide, labelColor: measurementColor, labelShadowColor: measurementShadowColor }), _jsx(CursorSphere, { height: previewHeight, ref: cursorRef }), _jsxs("mesh", { layers: EDITOR_LAYER, ref: wallPreviewRef, renderOrder: 1, visible: false, children: [_jsx("shapeGeometry", {}), _jsx("meshBasicMaterial", { color: "#818cf8", depthTest: false, depthWrite: false, opacity: 0.5, side: DoubleSide, transparent: true })] }), draftMeasurement && (_jsxs(_Fragment, { children: [_jsx(DraftMeasurementLabel, { color: measurementColor, label: draftMeasurement.lengthLabel, position: draftMeasurement.lengthPosition, shadowColor: measurementShadowColor }), draftMeasurement.angleLabels.map((angleLabel) => (_jsxs("group", { children: [_jsx(DraftAngleArc, { arc: angleLabel.arc, color: measurementColor }), _jsx(DraftMeasurementLabel, { color: measurementColor, label: angleLabel.label, position: angleLabel.position, shadowColor: measurementShadowColor })] }, angleLabel.id)))] }))] }));
+    return (_jsxs("group", { children: [_jsx(DraftAxisGuides, { guide: axisGuide, labelColor: measurementColor, labelShadowColor: measurementShadowColor }), _jsx(CursorSphere, { height: previewHeight, ref: cursorRef }), _jsxs("mesh", { layers: EDITOR_LAYER, ref: wallPreviewRef, renderOrder: 1, visible: false, children: [_jsx("shapeGeometry", {}), _jsx("meshBasicMaterial", { color: "#818cf8", depthTest: false, depthWrite: false, opacity: 0.5, side: DoubleSide, transparent: true })] }), draftMeasurement && (_jsxs(_Fragment, { children: [_jsx(DraftMeasurementLabel, { color: measurementColor, label: draftMeasurement.lengthLabel, position: draftMeasurement.lengthPosition, shadowColor: measurementShadowColor }), draftMeasurement.angleLabels.map((angleLabel) => (_jsxs("group", { children: [_jsx(DraftAngleArc, { arc: angleLabel.arc, color: measurementColor }), _jsx(DraftMeasurementLabel, { color: measurementColor, label: angleLabel.label, position: angleLabel.position, shadowColor: measurementShadowColor })] }, angleLabel.id)))] }))] }));
 };
-function WallAxisGuides({ guide, labelColor, labelShadowColor, }) {
-    if (!guide)
-        return null;
-    const [x, z] = guide.origin;
-    return (_jsxs(_Fragment, { children: [_jsxs("group", { position: [x, guide.y + DRAFT_AXIS_GUIDE_Y_OFFSET, z], children: [_jsx(WallAxisGuideLine, { axis: "x" }), _jsx(WallAxisGuideLine, { axis: "z" })] }), guide.angleLabel && (_jsxs(_Fragment, { children: [_jsx(DraftAngleArc, { arc: guide.angleLabel.arc, color: "#818cf8" }), _jsx(DraftMeasurementLabel, { color: labelColor, label: guide.angleLabel.label, position: guide.angleLabel.position, shadowColor: labelShadowColor })] }))] }));
-}
-function WallAxisGuideLine({ axis }) {
-    return (_jsxs("mesh", { frustumCulled: false, layers: EDITOR_LAYER, renderOrder: 0, rotation: [0, axis === 'z' ? Math.PI / 2 : 0, 0], children: [_jsx("boxGeometry", { args: [DRAFT_AXIS_GUIDE_LENGTH, DRAFT_AXIS_GUIDE_HEIGHT, DRAFT_AXIS_GUIDE_WIDTH] }), _jsx("meshBasicMaterial", { color: "#818cf8", depthTest: false, depthWrite: false, opacity: 0.36, transparent: true })] }));
-}
-function DraftAngleArc({ arc, color }) {
-    const geometry = useMemo(() => {
-        const segmentCount = Math.max(8, Math.ceil((Math.abs(arc.endAngle - arc.startAngle) / Math.PI) * DRAFT_ANGLE_ARC_SEGMENTS));
-        const points = Array.from({ length: segmentCount + 1 }, (_, index) => {
-            const t = index / segmentCount;
-            const angle = arc.startAngle + (arc.endAngle - arc.startAngle) * t;
-            return new Vector3(arc.center[0] + Math.cos(angle) * arc.radius, arc.y, arc.center[1] + Math.sin(angle) * arc.radius);
-        });
-        return new BufferGeometry().setFromPoints(points);
-    }, [arc]);
-    return (_jsx("line", { frustumCulled: false, geometry: geometry, layers: EDITOR_LAYER, renderOrder: 2, children: _jsx("lineBasicNodeMaterial", { color: color, depthTest: false, depthWrite: false, linewidth: 2, opacity: 0.95, transparent: true }) }));
-}
-function DraftMeasurementLabel({ color, label, position, shadowColor, }) {
-    return (_jsx(Html, { center: true, position: position, style: { pointerEvents: 'none', userSelect: 'none' }, zIndexRange: [100, 0], children: _jsx("div", { className: "whitespace-nowrap font-bold font-mono text-[15px]", style: {
-                color,
-                textShadow: `-1.5px -1.5px 0 ${shadowColor}, 1.5px -1.5px 0 ${shadowColor}, -1.5px 1.5px 0 ${shadowColor}, 1.5px 1.5px 0 ${shadowColor}, 0 0 4px ${shadowColor}, 0 0 4px ${shadowColor}`,
-            }, children: label }) }));
-}
 export default WallTool;

package/dist/wall/treatment-level-data.d.ts

@@ -0,0 +1,14 @@
+import { type WallMiterData, type WallNode } from '@pascal-app/core';
+export type WallTreatmentLevelData = {
+    walls: readonly WallNode[];
+    miterDataByProud: ReadonlyMap<number, WallMiterData>;
+};
+export declare function buildWallTreatmentLevelData(walls: readonly WallNode[], proudOffsets: readonly number[]): WallTreatmentLevelData;
+export declare function treatmentMiterDataForProud(levelData: WallTreatmentLevelData, proud: number): WallMiterData | undefined;
+type WallTreatmentLevelDataState = {
+    byLevelId: ReadonlyMap<string, WallTreatmentLevelData>;
+    setLevelData: (levelId: string, data: WallTreatmentLevelData) => void;
+};
+export declare const useWallTreatmentLevelData: import("zustand").UseBoundStore<import("zustand").StoreApi<WallTreatmentLevelDataState>>;
+export {};
+//# sourceMappingURL=treatment-level-data.d.ts.map

package/dist/wall/treatment-level-data.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"treatment-level-data.d.ts","sourceRoot":"","sources":["../../src/wall/treatment-level-data.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,aAAa,EAClB,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AASzB,MAAM,MAAM,sBAAsB,GAAG;IACnC,KAAK,EAAE,SAAS,QAAQ,EAAE,CAAA;IAC1B,gBAAgB,EAAE,WAAW,CAAC,MAAM,EAAE,aAAa,CAAC,CAAA;CACrD,CAAA;AAED,wBAAgB,2BAA2B,CACzC,KAAK,EAAE,SAAS,QAAQ,EAAE,EAC1B,YAAY,EAAE,SAAS,MAAM,EAAE,GAC9B,sBAAsB,CAgBxB;AAED,wBAAgB,0BAA0B,CACxC,SAAS,EAAE,sBAAsB,EACjC,KAAK,EAAE,MAAM,GACZ,aAAa,GAAG,SAAS,CAE3B;AAED,KAAK,2BAA2B,GAAG;IACjC,SAAS,EAAE,WAAW,CAAC,MAAM,EAAE,sBAAsB,CAAC,CAAA;IACtD,YAAY,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,sBAAsB,KAAK,IAAI,CAAA;CACtE,CAAA;AAED,eAAO,MAAM,yBAAyB,0FAQnC,CAAA"}

package/dist/wall/treatment-level-data.js

@@ -0,0 +1,31 @@
+import { calculateLevelMiters, getWallThickness, } from '@pascal-app/core';
+import { create } from 'zustand';
+const PROUD_KEY_PRECISION = 1e6;
+function proudKey(proud) {
+    return Math.round(proud * PROUD_KEY_PRECISION) / PROUD_KEY_PRECISION;
+}
+export function buildWallTreatmentLevelData(walls, proudOffsets) {
+    const uniqueProudOffsets = new Set([0, ...proudOffsets.map(proudKey)]);
+    const miterDataByProud = new Map();
+    for (const proud of uniqueProudOffsets) {
+        const adjustedWalls = proud === 0
+            ? [...walls]
+            : walls.map((wall) => ({
+                ...wall,
+                thickness: getWallThickness(wall) + proud * 2,
+            }));
+        miterDataByProud.set(proud, calculateLevelMiters(adjustedWalls));
+    }
+    return { walls, miterDataByProud };
+}
+export function treatmentMiterDataForProud(levelData, proud) {
+    return levelData.miterDataByProud.get(proudKey(proud));
+}
+export const useWallTreatmentLevelData = create((set) => ({
+    byLevelId: new Map(),
+    setLevelData: (levelId, data) => set((state) => {
+        const byLevelId = new Map(state.byLevelId);
+        byLevelId.set(levelId, data);
+        return { byLevelId };
+    }),
+}));

package/dist/wall/treatments.d.ts

@@ -1,14 +1,19 @@
-import { type SceneMaterial, type SceneMaterialId, type WallNode } from '@pascal-app/core';
+import { type SceneMaterial, type SceneMaterialId, type WallNode, type WallTrimConfig } from '@pascal-app/core';
 import { type RenderShading } from '@pascal-app/viewer';
 import * as THREE from 'three';
+import { type WallTreatmentLevelData } from './treatment-level-data';
 type OpeningLike = {
     type: string;
     width?: number;
     height?: number;
     position?: [number, number, number];
 };
+type TrimKind = 'skirting' | 'crown' | 'chairRail';
+type WallSide = 'interior' | 'exterior';
 type SceneMaterials = Record<SceneMaterialId, SceneMaterial>;
 type WallTreatmentSlotId = 'skirtingInterior' | 'skirtingExterior' | 'crownInterior' | 'crownExterior' | 'chairRailInterior' | 'chairRailExterior';
+export declare function wallTreatmentProudOffsets(node: WallNode): number[];
+export declare function buildTrimGeometry(node: WallNode, side: WallSide, trim: WallTrimConfig, kind: TrimKind, childrenNodes: OpeningLike[], levelData: WallTreatmentLevelData): THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap> | null;
 export declare function createWallExtraSlotMaterials(node: WallNode, shading: RenderShading, sceneMaterials: SceneMaterials): {
     skirtingInterior: THREE.Material<THREE.MaterialEventMap>;
     skirtingExterior: THREE.Material<THREE.MaterialEventMap>;
@@ -17,9 +22,10 @@ export declare function createWallExtraSlotMaterials(node: WallNode, shading: Re
     chairRailInterior: THREE.Material<THREE.MaterialEventMap>;
     chairRailExterior: THREE.Material<THREE.MaterialEventMap>;
 };
-export declare const WallTreatments: import("react").MemoExoticComponent<({ node, childrenNodes, materials, }: {
+export declare const WallTreatments: import("react").MemoExoticComponent<({ node, childrenNodes, levelData, materials, }: {
     node: WallNode;
     childrenNodes: OpeningLike[];
+    levelData: WallTreatmentLevelData;
     materials: Record<WallTreatmentSlotId, THREE.Material>;
 }) => import("react").JSX.Element>;
 export {};

package/dist/wall/treatments.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"treatments.d.ts","sourceRoot":"","sources":["../../src/wall/treatments.tsx"],"names":[],"mappings":"AAEA,OAAO,EAIL,KAAK,aAAa,EAClB,KAAK,eAAe,EAKpB,KAAK,QAAQ,EAId,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAGL,KAAK,aAAa,EAEnB,MAAM,oBAAoB,CAAA;AAE3B,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAO9B,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;CACpC,CAAA;AAID,KAAK,cAAc,GAAG,MAAM,CAAC,eAAe,EAAE,aAAa,CAAC,CAAA;AAE5D,KAAK,mBAAmB,GACpB,kBAAkB,GAClB,kBAAkB,GAClB,eAAe,GACf,eAAe,GACf,mBAAmB,GACnB,mBAAmB,CAAA;AA0dvB,wBAAgB,4BAA4B,CAC1C,IAAI,EAAE,QAAQ,EACd,OAAO,EAAE,aAAa,EACtB,cAAc,EAAE,cAAc;;;;;;;EAU/B;AAED,eAAO,MAAM,cAAc,4EAIxB;IACD,IAAI,EAAE,QAAQ,CAAA;IACd,aAAa,EAAE,WAAW,EAAE,CAAA;IAC5B,SAAS,EAAE,MAAM,CAAC,mBAAmB,EAAE,KAAK,CAAC,QAAQ,CAAC,CAAA;CACvD,iCAmEC,CAAA"}
+{"version":3,"file":"treatments.d.ts","sourceRoot":"","sources":["../../src/wall/treatments.tsx"],"names":[],"mappings":"AAEA,OAAO,EAKL,KAAK,aAAa,EAClB,KAAK,eAAe,EAMpB,KAAK,QAAQ,EAEb,KAAK,cAAc,EAEpB,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAGL,KAAK,aAAa,EAEnB,MAAM,oBAAoB,CAAA;AAE3B,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAG9B,OAAO,EAA8B,KAAK,sBAAsB,EAAE,MAAM,wBAAwB,CAAA;AAMhG,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;CACpC,CAAA;AAED,KAAK,QAAQ,GAAG,UAAU,GAAG,OAAO,GAAG,WAAW,CAAA;AAClD,KAAK,QAAQ,GAAG,UAAU,GAAG,UAAU,CAAA;AACvC,KAAK,cAAc,GAAG,MAAM,CAAC,eAAe,EAAE,aAAa,CAAC,CAAA;AAE5D,KAAK,mBAAmB,GACpB,kBAAkB,GAClB,kBAAkB,GAClB,eAAe,GACf,eAAe,GACf,mBAAmB,GACnB,mBAAmB,CAAA;AAmNvB,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,QAAQ,GAAG,MAAM,EAAE,CAoBlE;AAuND,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,QAAQ,EACd,IAAI,EAAE,QAAQ,EACd,IAAI,EAAE,cAAc,EACpB,IAAI,EAAE,QAAQ,EACd,aAAa,EAAE,WAAW,EAAE,EAC5B,SAAS,EAAE,sBAAsB,2FAsDlC;AAkBD,wBAAgB,4BAA4B,CAC1C,IAAI,EAAE,QAAQ,EACd,OAAO,EAAE,aAAa,EACtB,cAAc,EAAE,cAAc;;;;;;;EAU/B;AAED,eAAO,MAAM,cAAc,uFAKxB;IACD,IAAI,EAAE,QAAQ,CAAA;IACd,aAAa,EAAE,WAAW,EAAE,CAAA;IAC5B,SAAS,EAAE,sBAAsB,CAAA;IACjC,SAAS,EAAE,MAAM,CAAC,mBAAmB,EAAE,KAAK,CAAC,QAAQ,CAAC,CAAA;CACvD,iCAmEC,CAAA"}

package/dist/wall/treatments.js

@@ -1,10 +1,12 @@
 'use client';
 import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
-import { getWallCurveFrameAt, getWallThickness, isCurvedWall, WALL_CHAIR_RAIL_DEFAULT, WALL_CROWN_DEFAULT, WALL_SKIRTING_DEFAULT, WALL_SURFACE_SLOT_DEFAULTS, } from '@pascal-app/core';
+import { getWallCurveFrameAt, getWallMiterBoundaryPoints, getWallThickness, isCurvedWall, useScene, WALL_CHAIR_RAIL_DEFAULT, WALL_CROWN_DEFAULT, WALL_SKIRTING_DEFAULT, WALL_SURFACE_SLOT_DEFAULTS, } from '@pascal-app/core';
 import { baseMaterial, createMaterialFromPresetRef, resolveMaterialRef, } from '@pascal-app/viewer';
 import { memo, useEffect, useMemo } from 'react';
 import * as THREE from 'three';
 import { mergeGeometries as mergeBufferGeometries } from 'three/examples/jsm/utils/BufferGeometryUtils.js';
+import { resolveWallOpeningCeiling } from '../shared/wall-opening-ceiling';
+import { treatmentMiterDataForProud } from './treatment-level-data';
 const CURVE_SEGMENTS = 24;
 const MIN_SLICE_PROUD = 0.0005;
 const EPS = 1e-6;
@@ -219,6 +221,27 @@ function resolveTrimProfile(kind, trim) {
         TRIM_PROFILES[kind][defaultProfile] ??
         TRIM_PROFILES[kind].flat);
 }
+export function wallTreatmentProudOffsets(node) {
+    const offsets = new Set();
+    const configs = [
+        ['skirting', node.skirting],
+        ['crown', node.crown],
+        ['chairRail', node.chairRail],
+    ];
+    for (const [kind, rawConfig] of configs) {
+        const trim = { ...TRIM_KIND_CONFIG[kind].defaultConfig, ...(rawConfig ?? {}) };
+        if (!trim.enabled)
+            continue;
+        const profile = resolveTrimProfile(kind, trim);
+        if (!profile)
+            continue;
+        for (let index = 0; index < profile.samples; index += 1) {
+            const t = (index + 0.5) / profile.samples;
+            offsets.add(Math.max(MIN_SLICE_PROUD, trim.proud * profile.proudAt(t)));
+        }
+    }
+    return [...offsets];
+}
 function resolveTreatmentSideSign(node, side) {
     if (side === 'interior') {
         if (node.frontSide === 'interior')
@@ -261,8 +284,24 @@ function buildSidePolyline(node, side, offset) {
     }
     return points;
 }
+function buildMiteredSidePolyline(node, levelData, side, offset) {
+    if (isCurvedWall(node))
+        return buildSidePolyline(node, side, offset);
+    const sideSign = resolveTreatmentSideSign(node, side);
+    const toLocal = wallToLocalTransform(node);
+    const proud = offset - getWallThickness(node) / 2;
+    const boundarySource = treatmentMiterDataForProud(levelData, proud);
+    if (!boundarySource)
+        return buildSidePolyline(node, side, offset);
+    const boundary = getWallMiterBoundaryPoints({ ...node, thickness: offset * 2 }, boundarySource);
+    if (!boundary)
+        return buildSidePolyline(node, side, offset);
+    const start = sideSign > 0 ? boundary.startLeft : boundary.startRight;
+    const end = sideSign > 0 ? boundary.endLeft : boundary.endRight;
+    return [toLocal(start.x, start.y), toLocal(end.x, end.y)];
+}
 function clipPolyline(points, x0, x1) {
-    if (points.length < 2 || x1 - x0 <= EPS)
+    if (points.length < 2 || (x0 !== undefined && x1 !== undefined && x1 - x0 <= EPS))
         return [];
     const out = [];
     for (let index = 0; index < points.length - 1; index += 1) {
@@ -272,8 +311,9 @@ function clipPolyline(points, x0, x1) {
             continue;
         const minX = Math.min(a.x, b.x);
         const maxX = Math.max(a.x, b.x);
-        if (maxX < x0 - EPS || minX > x1 + EPS)
+        if ((x0 !== undefined && maxX < x0 - EPS) || (x1 !== undefined && minX > x1 + EPS)) {
             continue;
+        }
         const pushPointAt = (x) => {
             if (Math.abs(b.x - a.x) <= EPS) {
                 return { x, z: a.z };
@@ -284,8 +324,8 @@ function clipPolyline(points, x0, x1) {
                 z: a.z + (b.z - a.z) * t,
             };
         };
-        const start = minX < x0 ? pushPointAt(x0) : a;
-        const end = maxX > x1 ? pushPointAt(x1) : b;
+        const start = x0 !== undefined && minX < x0 ? pushPointAt(x0) : a;
+        const end = x1 !== undefined && maxX > x1 ? pushPointAt(x1) : b;
         if (out.length === 0 ||
             Math.hypot(out[out.length - 1].x - start.x, out[out.length - 1].z - start.z) > EPS) {
             out.push(start);
@@ -396,8 +436,8 @@ function mergeGeometries(geometries) {
         return merged;
     return null;
 }
-function buildTrimGeometry(node, side, trim, kind, childrenNodes) {
-    const wallHeight = node.height ?? 2.5;
+export function buildTrimGeometry(node, side, trim, kind, childrenNodes, levelData) {
+    const wallHeight = resolveWallOpeningCeiling(node, useScene.getState().nodes);
     const height = trim.height;
     const yBottom = kind === 'crown'
         ? Math.max(0, wallHeight - height)
@@ -405,11 +445,12 @@ function buildTrimGeometry(node, side, trim, kind, childrenNodes) {
             ? Math.max(0, Math.min(wallHeight - height, trim.offsetY ?? WALL_CHAIR_RAIL_DEFAULT.offsetY ?? 0.9))
             : 0;
     const thickness = getWallThickness(node);
-    const inner = buildSidePolyline(node, side, thickness / 2);
+    const inner = buildMiteredSidePolyline(node, levelData, side, thickness / 2);
     if (inner.length < 2)
         return null;
+    const wallLength = Math.hypot(node.end[0] - node.start[0], node.end[1] - node.start[1]);
     const openingRanges = trimOpeningRanges(node, childrenNodes, yBottom, height);
-    const fullRanges = [[inner[0].x, inner[inner.length - 1].x]];
+    const fullRanges = [[0, wallLength]];
     const runs = subtractOpeningRanges(fullRanges, openingRanges);
     if (runs.length === 0)
         return null;
@@ -419,14 +460,16 @@ function buildTrimGeometry(node, side, trim, kind, childrenNodes) {
         return null;
     const sliceHeight = height / profile.samples;
     for (const [runStart, runEnd] of runs) {
-        const innerRun = clipPolyline(inner, runStart, runEnd);
+        const clipStart = runStart > EPS ? runStart : undefined;
+        const clipEnd = runEnd < wallLength - EPS ? runEnd : undefined;
+        const innerRun = clipPolyline(inner, clipStart, clipEnd);
         if (innerRun.length < 2)
             continue;
         for (let index = 0; index < profile.samples; index += 1) {
             const t = (index + 0.5) / profile.samples;
             const proud = Math.max(MIN_SLICE_PROUD, trim.proud * profile.proudAt(t));
-            const outerRun = buildSidePolyline(node, side, thickness / 2 + proud);
-            const outerClipped = clipPolyline(outerRun, runStart, runEnd);
+            const outerRun = buildMiteredSidePolyline(node, levelData, side, thickness / 2 + proud);
+            const outerClipped = clipPolyline(outerRun, clipStart, clipEnd);
             if (outerClipped.length < 2)
                 continue;
             const slice = buildTrimSliceGeometry(outerClipped, innerRun, sliceHeight, yBottom + index * sliceHeight);
@@ -459,7 +502,7 @@ export function createWallExtraSlotMaterials(node, shading, sceneMaterials) {
         chairRailExterior: resolveWallSlotMaterial(node, 'chairRailExterior', shading, sceneMaterials),
     };
 }
-export const WallTreatments = memo(function WallTreatments({ node, childrenNodes, materials, }) {
+export const WallTreatments = memo(function WallTreatments({ node, childrenNodes, levelData, materials, }) {
     const fallbackMaterial = materials.skirtingInterior ??
         materials.skirtingExterior ??
         materials.crownInterior ??
@@ -481,7 +524,7 @@ export const WallTreatments = memo(function WallTreatments({ node, childrenNodes
                 ? ['interior', 'exterior']
                 : [trim.sides];
             for (const side of sides) {
-                const geometry = buildTrimGeometry(node, side, trim, kind, childrenNodes);
+                const geometry = buildTrimGeometry(node, side, trim, kind, childrenNodes, levelData);
                 if (!geometry)
                     continue;
                 const slotId = TRIM_KIND_CONFIG[kind].slots[side];
@@ -494,7 +537,7 @@ export const WallTreatments = memo(function WallTreatments({ node, childrenNodes
             }
         }
         return out;
-    }, [childrenNodes, fallbackMaterial, materials, node]);
+    }, [childrenNodes, fallbackMaterial, levelData, materials, node]);
     useEffect(() => () => {
         for (const entry of trimEntries)
             entry.geometry.dispose();

package/dist/window/contextual-dimensions.d.ts

@@ -0,0 +1,3 @@
+import type { FloorplanGeometry, GeometryContext, WindowNode } from '@pascal-app/core';
+export declare function buildWindowContextualDimensions(node: WindowNode, ctx: GeometryContext): FloorplanGeometry | null;
+//# sourceMappingURL=contextual-dimensions.d.ts.map

package/dist/window/contextual-dimensions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contextual-dimensions.d.ts","sourceRoot":"","sources":["../../src/window/contextual-dimensions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAGtF,wBAAgB,+BAA+B,CAC7C,IAAI,EAAE,UAAU,EAChB,GAAG,EAAE,eAAe,GACnB,iBAAiB,GAAG,IAAI,CAK1B"}