@pascal-app/nodes 1.0.4 → 1.0.6

package/dist/cabinet/tool.js

@@ -1,27 +1,28 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { CabinetModuleNode, CabinetNode, collectAlignmentAnchors, createSceneApi, emitter, getFloorPlacedFootprints, getWallLocalFaceZ, isCurvedWall, movingFootprintAnchors, nodeRegistry, resolveAlignment, resolveSupportSlabPatch, spatialGridManager, useScene, } from '@pascal-app/core';
-import { clearPlacementSurface, EDITOR_LAYER, getFloorStackPreviewPosition, getSideFromNormal, isAlignmentGuideActive, isGridSnapActive, isMagneticSnapActive, isValidWallSideFace, markToolCancelConsumed, movementSfxStepKey, PlacementBox, PlacementDimensionGuides, parseMeasurement, publishPlacementSurface, triggerSFX, useAlignmentGuides, useEditor, useFacingPose, usePlacementPreview, } from '@pascal-app/editor';
+import { CabinetModuleNode, CabinetNode, collectAlignmentAnchors, createSceneApi, emitter, getFloorPlacedFootprints, getWallLocalFaceZ, isCurvedWall, movingAlignmentAnchors, nodeRegistry, resolveAlignment, resolveSupportSlabPatch, runAsSingleSceneHistoryStep, spatialGridManager, useScene, } from '@pascal-app/core';
+import { clearPlacementSurface, EDITOR_LAYER, getFloorStackPreviewPosition, getSideFromNormal, isAlignmentGuideActive, isGridSnapActive, isMagneticSnapActive, isTypingTarget, isValidWallSideFace, markToolCancelConsumed, movementSfxStepKey, PlacementBox, PlacementDimensionGuides, parseMeasurement, publishPlacementSurface, triggerSFX, useAlignmentGuides, useEditor, useFacingPose, usePlacementPreview, } from '@pascal-app/editor';
 import { useViewer } from '@pascal-app/viewer';
 import { Html } from '@react-three/drei';
 import { useFrame } from '@react-three/fiber';
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import { Mesh, Quaternion, Vector3 } from 'three';
-import { FLOOR_PLACEMENT_ALIGNMENT_THRESHOLD_M, getLevelLocalSnappedPosition, stopPlacementCommitPropagation, subscribeFloorPlacementClicks, subscribeFloorPlacementDoubleClicks, } from '../shared/floor-placement';
-import { LevelOffsetGroup } from '../shared/level-offset-group';
-import { findWallOpeningConflicts } from '../shared/wall-opening-clearance';
-import { cabinetStretchExitSide, chooseCabinetContinuousAnchor, createCabinetContinuousContinuation, isCabinetContinuousFollowUpClick, isForcePlacementEvent, planCabinetContinuousStretch, resolveCabinetContinuousValidity, } from './continuous-placement';
-import { bumpCabinetRunsNear, cabinetDefinition, cabinetModuleDefinition, cabinetRunFootprint, } from './definition';
-import { buildCabinetGeometry } from './geometry';
-import { applyCabinetModuleInsertion, cabinetModuleForRunInsertion } from './insertion';
-import { buildCabinetPlacementSizeDimensions, resolveCabinetPlacementDimensionPosition, resolveCabinetPlacementDimensions, } from './placement-dimensions';
-import { resolveCabinetGridPosition, resolveCabinetGridPositionInFrame, resolveCabinetLevelPlanFrame, } from './placement-snap';
-import useCabinetPlacementStatus from './placement-status';
-import useCabinetPlacementType from './placement-type';
-import { cabinetPresetById } from './presets';
-import { moduleMaxX, planRunModuleInsertion, planToRunLocal, runLocalToPlan, runWallConstraints, sortRunModules, } from './run-layout';
-import { addCabinetModuleSide, addCornerRun, cabinetModulesForRun, cornerPinnedEndsForRun, previewCornerAdditionLayout, syncCornerRunsFromRunSources, } from './run-ops';
-import { findClosestCabinetWallInPlan, resolveCabinetWallSnapPlacementInScene, } from './wall-snap';
+import { FLOOR_PLACEMENT_ALIGNMENT_THRESHOLD_M, getLevelLocalSnappedPosition, stopPlacementCommitPropagation, subscribeFloorPlacementClicks, subscribeFloorPlacementDoubleClicks, } from '../shared/floor-placement.js';
+import { LevelOffsetGroup } from '../shared/level-offset-group.js';
+import { findWallOpeningConflicts } from '../shared/wall-opening-clearance.js';
+import { cabinetStretchExitSide, chooseCabinetContinuousAnchor, createCabinetContinuousContinuation, isCabinetContinuousFollowUpClick, isForcePlacementEvent, planCabinetContinuousStretch, resolveCabinetContinuousValidity, } from './continuous-placement.js';
+import { bumpCabinetRunsNear, cabinetDefinition, cabinetModuleDefinition, cabinetRunFootprint, } from './definition.js';
+import { buildCabinetGeometry } from './geometry.js';
+import { applyCabinetModuleInsertion, cabinetModuleForRunInsertion } from './insertion.js';
+import { resolveCabinetNeighborPlacement } from './neighbor-placement.js';
+import { buildCabinetPlacementSizeDimensions, resolveCabinetPlacementDimensionPosition, resolveCabinetPlacementDimensions, } from './placement-dimensions.js';
+import { resolveCabinetGridPosition, resolveCabinetGridPositionInFrame, resolveCabinetLevelPlanFrame, } from './placement-snap.js';
+import useCabinetPlacementStatus from './placement-status.js';
+import useCabinetPlacementType from './placement-type.js';
+import { cabinetPresetById, WALL_CABINET_ELEVATION } from './presets.js';
+import { moduleMaxX, planRunModuleInsertion, planToRunLocal, runLocalToPlan, runWallConstraints, sortRunModules, } from './run-layout.js';
+import { addCabinetModuleSide, addCornerRun, cabinetModulesForRun, cornerPinnedEndsForRun, previewCornerAdditionLayout, syncCornerRunsFromRunSources, } from './run-ops.js';
+import { findClosestCabinetWallInPlan, resolveCabinetWallSnapPlacementInScene, } from './wall-snap.js';
 const PREVIEW_OPACITY = 0.55;
 const ROTATE_STEP_RAD = Math.PI / 4;
 const DEFAULT_PLACEMENT_PRESET = cabinetPresetById('base-door');
@@ -191,7 +192,7 @@ function wallHitFromWallEvent(event) {
         itemRotation: side === 'front' ? 0 : Math.PI,
     };
 }
-const CabinetTool = () => {
+const CabinetPlacementTool = () => {
     const activeLevelId = useViewer((s) => s.selection.levelId);
     const unit = useViewer((s) => s.unit);
     const metricNotation = useViewer((s) => s.metricNotation);
@@ -201,6 +202,7 @@ const CabinetTool = () => {
     const [draftSegments, setDraftSegments] = useState([]);
     const [yaw, setYaw] = useState(0);
     const toolDefaults = useEditor((state) => state.toolDefaults.cabinet);
+    const wallCabinet = toolDefaults?.kitchenPreset === 'wall-cabinet';
     const placementType = useCabinetPlacementType((s) => s.type);
     const islandMode = placementType === 'island';
     const yawRef = useRef(0);
@@ -228,15 +230,15 @@ const CabinetTool = () => {
             ...cabinetModuleDefinition.defaults(),
             ...DEFAULT_PLACEMENT_PRESET.createPatch(),
             ...toolDefaults,
-            showPlinth: runDefaults.showPlinth,
+            showPlinth: !wallCabinet && runDefaults.showPlinth,
             plinthHeight: runDefaults.plinthHeight,
             toeKickDepth: runDefaults.toeKickDepth,
-            withCountertop: runDefaults.withCountertop,
+            withCountertop: toolDefaults?.cabinetType !== 'tall' && !wallCabinet && runDefaults.withCountertop,
             countertopThickness: runDefaults.countertopThickness,
             countertopOverhang: runDefaults.countertopOverhang,
             countertopBackOverhang: runDefaults.countertopBackOverhang,
         });
-    }, [toolDefaults]);
+    }, [toolDefaults, wallCabinet]);
     const [previewSize, setPreviewSize] = useState(() => ({
         depth: previewNodeTemplate.depth,
         height: previewNodeTemplate.carcassHeight,
@@ -251,12 +253,11 @@ const CabinetTool = () => {
     const previewNodeRef = useRef(previewNode);
     previewNodeRef.current = previewNode;
     const placementDimensions = useMemo(() => {
-        const defaults = cabinetDefinition.defaults();
         return [
             previewNode.width,
-            (defaults.showPlinth ? defaults.plinthHeight : 0) +
+            (previewNode.showPlinth ? previewNode.plinthHeight : 0) +
                 previewNode.carcassHeight +
-                (defaults.withCountertop ? defaults.countertopThickness : 0),
+                (previewNode.withCountertop ? previewNode.countertopThickness : 0),
             previewNode.depth + (islandMode ? ISLAND_SEATING_OVERHANG : 0),
         ];
     }, [previewNode, islandMode]);
@@ -338,15 +339,29 @@ const CabinetTool = () => {
                 0,
             ])
             : next.position;
-        const livePreviewNode = previewNodeRef.current;
+        const livePreviewNode = next.neighborJoin
+            ? { ...previewNodeRef.current, depth: next.neighborJoin.depth }
+            : previewNodeRef.current;
         const node = buildCabinetPlacementPreviewNode({
             island,
             position: previewPosition,
             previewModule: livePreviewNode,
             yaw: next.yaw,
         });
-        let floorplanNode = stretch ? { ...node, width: stretch.length } : node;
-        let floorplanContextNodes = [];
+        const previewModules = (stretch?.modules ?? [{ x: 0, width: livePreviewNode.width }]).map((module) => CabinetModuleNode.parse({
+            ...livePreviewNode,
+            id: undefined,
+            parentId: node.id,
+            position: [module.x - (stretch?.centerLocalX ?? 0), 0, 0],
+            width: module.width,
+        }));
+        let floorplanNode = {
+            ...node,
+            parentId: activeLevelId,
+            children: previewModules.map((module) => module.id),
+            ...(stretch ? { width: stretch.length } : {}),
+        };
+        let floorplanContextNodes = previewModules;
         if (next.insertionPreview) {
             const liveRun = useScene.getState().nodes[next.insertionPreview.runId];
             if (liveRun?.type === 'cabinet') {
@@ -431,7 +446,9 @@ const CabinetTool = () => {
         publishPlacementSurface(surfacePointRef.current, surfaceNormalRef.current);
         useFacingPose.getState().set({
             position: [facingPoint.x, facingPoint.y, facingPoint.z],
-            rotationY: current.snappedToWall || current.stretch ? current.yaw : yawRef.current,
+            rotationY: current.snappedToWall || current.stretch || current.neighborJoin
+                ? current.yaw
+                : yawRef.current,
             depth: current.stretch ? placementDimensions[2] : previewNode.depth,
         });
     });
@@ -540,10 +557,10 @@ const CabinetTool = () => {
                 previewModule: previewNodeRef.current,
                 yaw,
             });
-            const moving = movingFootprintAnchors({
+            const moving = movingAlignmentAnchors({
                 ...alignmentNode,
                 ...(width == null ? null : { width }),
-            }, position[0], position[2], yaw);
+            }, useScene.getState().nodes, position[0], position[2], yaw);
             if (moving.length === 0 || alignmentCandidates.length === 0) {
                 useAlignmentGuides.getState().clear();
                 return position;
@@ -559,10 +576,14 @@ const CabinetTool = () => {
             return [position[0] + result.snap.dx, position[1], position[2] + result.snap.dz];
         };
         const withPlacementValidity = (next, bypassCollision) => {
+            if (wallCabinet && !next.insertionPreview)
+                next = { ...next, position: [next.position[0], WALL_CABINET_ELEVATION, next.position[2]] };
             if (bypassCollision) {
                 return { ...next, conflictIds: [], valid: !next.insertionFailure };
             }
-            const livePreviewNode = previewNodeRef.current;
+            const livePreviewNode = next.neighborJoin
+                ? { ...previewNodeRef.current, depth: next.neighborJoin.depth }
+                : previewNodeRef.current;
             const livePlacementDimensions = placementDimensionsRef.current;
             const floorPlaced = nodeRegistry.get(livePreviewNode.type)?.capabilities?.floorPlaced;
             const effectiveNode = {
@@ -582,7 +603,7 @@ const CabinetTool = () => {
             const wall = next.wallId ? useScene.getState().nodes[next.wallId] : undefined;
             const openingConflictIds = wall?.type === 'wall' && next.wallLocalX != null
                 ? findWallOpeningConflicts({
-                    bottom: 0,
+                    bottom: next.position[1],
                     height: livePlacementDimensions[1],
                     localX: next.wallLocalX,
                     nodes: useScene.getState().nodes,
@@ -612,14 +633,16 @@ const CabinetTool = () => {
             if (!wallPlacement)
                 return null;
             const wallSurfaceNormal = [Math.sin(wallPlacement.yaw), 0, Math.cos(wallPlacement.yaw)];
-            const insertion = resolveCabinetRunInsertion({
-                hit,
-                insertionId: previewNodeRef.current.id,
-                nodes,
-                placement: wallPlacement,
-                parentLevelId: activeLevelId,
-                width: previewNodeRef.current.width,
-            });
+            const insertion = wallCabinet
+                ? null
+                : resolveCabinetRunInsertion({
+                    hit,
+                    insertionId: previewNodeRef.current.id,
+                    nodes,
+                    placement: wallPlacement,
+                    parentLevelId: activeLevelId,
+                    width: previewNodeRef.current.width,
+                });
             const insertionPreview = insertion?.kind === 'preview' ? insertion.plan : undefined;
             const insertionFailure = insertion?.kind === 'blocked'
                 ? { runId: insertion.runId, reason: insertion.reason }
@@ -660,6 +683,51 @@ const CabinetTool = () => {
             const raw = resolveRawPosition(event);
             lastRawPositionRef.current = raw;
             const forcePlacement = isForcePlacementEvent(event);
+            // Alt forces past every snap, a run's magnetic join included (E-004).
+            const neighbor = !forcePlacement &&
+                !islandModeRef.current &&
+                isMagneticSnapActive() &&
+                useEditor.getState().getContinuation('cabinet') === 'single'
+                ? resolveCabinetNeighborPlacement({
+                    nodes: useScene.getState().nodes,
+                    levelId: activeLevelId,
+                    position: raw,
+                    module: previewNodeRef.current,
+                    wallTier: wallCabinet,
+                })
+                : null;
+            if (neighbor) {
+                const { run, result, depth, side } = neighbor;
+                if (result.ok) {
+                    useAlignmentGuides.getState().clear();
+                    const position = runLocalToPlan(run, result.inserted.position);
+                    const wallPose = resolveWallPlacement(position);
+                    return withPlacementValidity({
+                        position,
+                        ...(wallPose && Math.abs(angleDelta(wallPose.yaw, run.rotation)) < 0.08
+                            ? { wallId: wallPose.wallId, wallLocalX: wallPose.wallLocalX }
+                            : {}),
+                        yaw: run.rotation,
+                        snappedToWall: false,
+                        neighborJoin: { depth, side, name: run.name || 'Kitchen run' },
+                        insertionPreview: {
+                            runId: run.id,
+                            runPosition: run.position,
+                            runYaw: run.rotation,
+                            modules: result.modules,
+                            inserted: result.inserted,
+                        },
+                    }, forcePlacement);
+                }
+                return {
+                    position: raw,
+                    yaw: run.rotation,
+                    snappedToWall: false,
+                    valid: false,
+                    conflictIds: [],
+                    insertionFailure: { runId: run.id, reason: 'no-space' },
+                };
+            }
             const wallPlacement = islandModeRef.current ? null : resolveWallPlacement(raw);
             if (wallPlacement) {
                 return withPlacementValidity({
@@ -780,6 +848,17 @@ const CabinetTool = () => {
             placementRef.current = next;
             setPlacement(next);
             useCabinetPlacementStatus.getState().setBlocked(!next.valid);
+            useCabinetPlacementStatus
+                .getState()
+                .setTarget(!next.valid
+                ? next.insertionFailure
+                    ? 'No space in this kitchen run'
+                    : 'Placement blocked: overlaps an item or wall opening'
+                : next.neighborJoin
+                    ? `${next.valid ? 'Join' : 'Blocked beside'} ${next.neighborJoin.name} · ${next.neighborJoin.side} side · Depth matched`
+                    : next.insertionFailure
+                        ? 'No space in this kitchen run'
+                        : null);
             publishFloorplanPreview(next);
             const nextSnapKey = movementSfxStepKey({
                 coords: next.snappedToWall && typeof next.wallLocalX === 'number'
@@ -824,6 +903,15 @@ const CabinetTool = () => {
                 event.stopPropagation();
                 return;
             }
+            if (useEditor.getState().getContinuation('cabinet') === 'single') {
+                const adjacent = resolvePlacement(event);
+                if (adjacent.neighborJoin || adjacent.insertionFailure) {
+                    markWallOwnedPointer();
+                    publishPlacement(adjacent, lastWallEventTime);
+                    event.stopPropagation();
+                    return;
+                }
+            }
             const hit = islandModeRef.current ? null : wallHitFromWallEvent(event);
             const next = hit ? resolveWallHitPlacement(hit) : null;
             if (next) {
@@ -835,17 +923,23 @@ const CabinetTool = () => {
             publishPlacement(resolvePlacement(event), lastWallEventTime);
         };
         const buildRunNodes = (position, yaw) => {
-            const patch = DEFAULT_PLACEMENT_PRESET.createPatch();
+            const patch = { ...DEFAULT_PLACEMENT_PRESET.createPatch(), ...toolDefaults };
             const island = islandModeRef.current;
             const cabinet = CabinetNode.parse({
                 ...cabinetDefinition.defaults(),
-                ...toolDefaults,
-                name: island ? 'Kitchen Island' : 'Modular Cabinet',
+                ...(toolDefaults?.kitchenPreset ? {} : toolDefaults),
+                name: island ? 'Kitchen Island' : wallCabinet ? 'Wall cabinets' : 'Kitchen run',
+                runTier: wallCabinet ? 'wall' : 'base',
+                showPlinth: previewNode.showPlinth,
+                withCountertop: !wallCabinet,
                 position,
                 rotation: yaw,
                 parentId: activeLevelId,
+                width: previewNode.width,
                 depth: previewNode.depth,
-                carcassHeight: previewNode.carcassHeight,
+                carcassHeight: previewNode.cabinetType === 'tall'
+                    ? cabinetDefinition.defaults().carcassHeight
+                    : previewNode.carcassHeight,
                 ...(island && {
                     countertopBackOverhang: ISLAND_SEATING_OVERHANG,
                     withFinishedBack: true,
@@ -855,12 +949,14 @@ const CabinetTool = () => {
                 ...cabinetModuleDefinition.defaults(),
                 ...patch,
                 ...toolDefaults,
-                name: index === 0 ? (patch.name ?? 'Base Cabinet') : `Base Cabinet ${index + 1}`,
+                name: index === 0
+                    ? (patch.name ?? 'Base Cabinet')
+                    : `${patch.name ?? 'Base Cabinet'} ${index + 1}`,
                 parentId: cabinet.id,
                 position: [localX, runModuleBaseY(cabinet.plinthHeight, cabinet.showPlinth), 0],
                 width,
                 depth: cabinet.depth,
-                carcassHeight: cabinet.carcassHeight,
+                carcassHeight: previewNode.carcassHeight,
                 plinthHeight: cabinet.plinthHeight,
                 toeKickDepth: cabinet.toeKickDepth,
                 countertopThickness: cabinet.countertopThickness,
@@ -966,35 +1062,44 @@ const CabinetTool = () => {
                 return null;
             const module = cabinetModuleForRunInsertion(CabinetModuleNode.parse({
                 ...previewNodeRef.current,
+                ...(next.neighborJoin ? { depth: next.neighborJoin.depth } : {}),
                 position: insertionPreview.inserted.position,
                 width: insertionPreview.inserted.width,
             }), run);
-            sceneApi.pauseHistory();
+            const history = useScene.temporal.getState();
+            const recorded = new Set(history.pastStates);
             try {
-                const id = applyCabinetModuleInsertion({
-                    module,
-                    plan: insertionPreview,
-                    run,
-                    sceneApi,
-                });
-                if (!id)
-                    throw new Error('Unable to apply cabinet insertion');
-                const liveRun = sceneApi.get(run.id);
-                if (!liveRun)
-                    throw new Error('Unable to resolve inserted cabinet run');
-                sceneApi.update(liveRun.id, resolveSupportSlabPatch(liveRun, sceneApi.nodes()));
-                syncCornerRunsFromRunSources({
-                    run: sceneApi.get(liveRun.id) ?? liveRun,
-                    sceneApi,
+                return runAsSingleSceneHistoryStep(useScene, () => {
+                    const id = applyCabinetModuleInsertion({
+                        module,
+                        plan: insertionPreview,
+                        run,
+                        sceneApi,
+                    });
+                    if (!id)
+                        throw new Error('Unable to apply cabinet insertion');
+                    const liveRun = sceneApi.get(run.id);
+                    if (!liveRun)
+                        throw new Error('Unable to resolve inserted cabinet run');
+                    sceneApi.update(liveRun.id, resolveSupportSlabPatch(liveRun, sceneApi.nodes()));
+                    syncCornerRunsFromRunSources({
+                        run: sceneApi.get(liveRun.id) ?? liveRun,
+                        sceneApi,
+                    });
+                    const updatedRun = sceneApi.get(liveRun.id) ?? liveRun;
+                    bumpCabinetRunsNear(sceneApi, [cabinetRunFootprint(updatedRun, sceneApi.nodes())], new Set([updatedRun.id]));
+                    return id;
                 });
-                const updatedRun = sceneApi.get(liveRun.id) ?? liveRun;
-                bumpCabinetRunsNear(sceneApi, [cabinetRunFootprint(updatedRun, sceneApi.nodes())], new Set([updatedRun.id]));
-                sceneApi.resumeHistory();
-                return id;
             }
             catch {
-                sceneApi.restoreAll();
-                sceneApi.resumeHistory();
+                // A failure part-way leaves nothing behind: undo the writes it recorded, then forget them.
+                const added = useScene.temporal
+                    .getState()
+                    .pastStates.filter((state) => !recorded.has(state)).length;
+                if (added > 0) {
+                    useScene.temporal.getState().undo(added);
+                    useScene.temporal.setState({ futureStates: history.futureStates });
+                }
                 return null;
             }
         };
@@ -1281,8 +1386,7 @@ const CabinetTool = () => {
             return true;
         };
         const onKeyDown = (event) => {
-            const tag = event.target?.tagName;
-            if (tag === 'INPUT' || tag === 'TEXTAREA')
+            if (isTypingTarget(event.target))
                 return;
             const dimensionEditor = usePlacementPreview.getState();
             if (event.key === 'Tab' && dimensionEditor.dimensions.length > 0) {
@@ -1389,7 +1493,15 @@ const CabinetTool = () => {
             useAlignmentGuides.getState().clear();
             useCabinetPlacementStatus.getState().setBlocked(false);
         };
-    }, [activeLevelId, metricNotation, previewNode, publishFloorplanPreview, toolDefaults, unit]);
+    }, [
+        activeLevelId,
+        metricNotation,
+        previewNode,
+        publishFloorplanPreview,
+        toolDefaults,
+        unit,
+        wallCabinet,
+    ]);
     if (!(activeLevelId && placement))
         return null;
     const stretch = placement.stretch;
@@ -1399,19 +1511,21 @@ const CabinetTool = () => {
     const activeStretchGhostOffset = draftSegments.reduce((sum, segment) => sum + segment.stretch.modules.length, 0);
     const placementLabel = placement.insertionFailure
         ? 'No space in this run to insert this cabinet'
-        : stretch
-            ? placement.valid
-                ? `${draftSegments.length + 1} leg${draftSegments.length + 1 === 1 ? '' : 's'} · ${stretch.modules.length} module${stretch.modules.length === 1 ? '' : 's'} · Click to continue · Double-click/Esc to finish`
-                : null
-            : placement.valid
-                ? placement.snappedToWall
-                    ? placement.snapReason === 'cabinet-edge'
-                        ? 'Edge snap'
-                        : placement.snapReason === 'corner'
-                            ? 'Corner snap'
-                            : 'Wall snap'
+        : placement.neighborJoin
+            ? `${placement.valid ? 'Join' : 'Blocked beside'} ${placement.neighborJoin.name} · ${placement.neighborJoin.side} side · Depth matched`
+            : stretch
+                ? placement.valid
+                    ? `${draftSegments.length + 1} leg${draftSegments.length + 1 === 1 ? '' : 's'} · ${stretch.modules.length} module${stretch.modules.length === 1 ? '' : 's'} · Click to continue · Double-click/Esc to finish`
                     : null
-                : null;
+                : placement.valid
+                    ? placement.snappedToWall
+                        ? placement.snapReason === 'cabinet-edge'
+                            ? 'Edge snap'
+                            : placement.snapReason === 'corner'
+                                ? 'Corner snap'
+                                : 'Wall snap'
+                        : `Place ${previewNode.name ?? 'cabinet'}`
+                    : null;
     const labelPosition = stretch
         ? runLocalToPlan({ position: placement.position, rotation: placement.yaw }, [
             stretch.centerLocalX,
@@ -1430,13 +1544,13 @@ const CabinetTool = () => {
         rotation: placement.yaw,
         levelId: activeLevelId,
     });
-    const placementRotationY = placement.snappedToWall || stretch ? placement.yaw : yaw;
+    const placementRotationY = placement.snappedToWall || stretch || placement.neighborJoin ? placement.yaw : yaw;
     const placementBoxDimensions = [
         stretch
             ? stretch.length + (previewNode.withCountertop ? previewNode.countertopOverhang * 2 : 0)
             : placementSnapFootprint.dimensions[0],
         placementSnapFootprint.dimensions[1],
-        placementSnapFootprint.dimensions[2],
+        placement.neighborJoin?.depth ?? placementSnapFootprint.dimensions[2],
     ];
     const placementBoxPlanPosition = runLocalToPlan({ position: placement.position, rotation: placement.yaw }, [stretch?.centerLocalX ?? 0, 0, placementSnapFootprint.offset[1]]);
     const placementBoxPosition = [
@@ -1444,7 +1558,13 @@ const CabinetTool = () => {
         visualPosition[1],
         placementBoxPlanPosition[2],
     ];
-    return (_jsxs(LevelOffsetGroup, { children: [placement.guide && _jsx(WallSnapGuide, { blocked: !placement.valid, guide: placement.guide }), _jsx(PlacementBox, { activeDimensionId: stretch ? null : activeDimensionId, dimensionInput: dimensionInput, dimensions: placementBoxDimensions, measurements: { unit, metricNotation }, measurementValues: stretch ? undefined : [previewNode.width, previewNode.carcassHeight, previewNode.depth], onDimensionSelect: stretch ? undefined : (id) => usePlacementPreview.getState().selectDimension(id), position: placementBoxPosition, rotationY: placementRotationY, valid: placement.valid }), _jsx(PlacementDimensionGuides, {}), draftSegments.map((segment, segmentIndex) => (_jsx("group", { position: segment.anchor.position, rotation: [0, segment.anchor.yaw, 0], children: segment.stretch.modules.map((module, index) => (_jsx("group", { position: [module.x, 0, 0], scale: [module.width / previewNode.width, 1, 1], children: _jsx("primitive", { object: ghostForIndex(draftModuleOffsets[segmentIndex] + index) }) }, `${segmentIndex}-${index}`))) }, `draft-${segmentIndex}`))), _jsx("group", { position: visualPosition, ref: activeGhostRef, rotation: [0, placementRotationY, 0], children: placement.insertionPreview ? (_jsx("primitive", { object: insertionGhost })) : stretch ? (stretch.modules.map((module, index) => (_jsx("group", { position: [module.x, 0, 0], scale: [module.width / previewNode.width, 1, 1], children: _jsx("primitive", { object: ghostForIndex(activeStretchGhostOffset + index) }) }, index)))) : (_jsx("primitive", { object: ghost })) }), placement.insertionPreview ? (_jsx("group", { position: placement.insertionPreview.runPosition, rotation: [0, placement.insertionPreview.runYaw, 0], children: placement.insertionPreview.modules.map((module, index) => (_jsx("group", { position: module.position, scale: [module.width / previewNode.width, 1, 1], children: _jsx("primitive", { object: insertionGhostForIndex(index + 1) }) }, module.id))) })) : null, placementLabel ? (_jsx(Html, { center: true, position: [
+    return (_jsxs(LevelOffsetGroup, { children: [placement.guide && _jsx(WallSnapGuide, { blocked: !placement.valid, guide: placement.guide }), _jsx(PlacementBox, { activeDimensionId: stretch ? null : activeDimensionId, dimensionInput: dimensionInput, dimensions: placementBoxDimensions, measurements: { unit, metricNotation }, measurementValues: stretch
+                    ? undefined
+                    : [
+                        previewNode.width,
+                        previewNode.carcassHeight,
+                        placement.neighborJoin?.depth ?? previewNode.depth,
+                    ], onDimensionSelect: stretch ? undefined : (id) => usePlacementPreview.getState().selectDimension(id), position: placementBoxPosition, rotationY: placementRotationY, valid: placement.valid }), _jsx(PlacementDimensionGuides, {}), draftSegments.map((segment, segmentIndex) => (_jsx("group", { position: segment.anchor.position, rotation: [0, segment.anchor.yaw, 0], children: segment.stretch.modules.map((module, index) => (_jsx("group", { position: [module.x, 0, 0], scale: [module.width / previewNode.width, 1, 1], children: _jsx("primitive", { object: ghostForIndex(draftModuleOffsets[segmentIndex] + index) }) }, `${segmentIndex}-${index}`))) }, `draft-${segmentIndex}`))), _jsx("group", { position: visualPosition, ref: activeGhostRef, rotation: [0, placementRotationY, 0], children: placement.insertionPreview ? (_jsx("group", { scale: [1, 1, (placement.neighborJoin?.depth ?? previewNode.depth) / previewNode.depth], children: _jsx("primitive", { object: insertionGhost }) })) : stretch ? (stretch.modules.map((module, index) => (_jsx("group", { position: [module.x, 0, 0], scale: [module.width / previewNode.width, 1, 1], children: _jsx("primitive", { object: ghostForIndex(activeStretchGhostOffset + index) }) }, index)))) : (_jsx("primitive", { object: ghost })) }), placement.insertionPreview && !placement.neighborJoin ? (_jsx("group", { position: placement.insertionPreview.runPosition, rotation: [0, placement.insertionPreview.runYaw, 0], children: placement.insertionPreview.modules.map((module, index) => (_jsx("group", { position: module.position, scale: [module.width / previewNode.width, 1, 1], children: _jsx("primitive", { object: insertionGhostForIndex(index + 1) }) }, module.id))) })) : null, placementLabel ? (_jsx(Html, { center: true, position: [
                     labelPosition[0],
                     previewNode.plinthHeight + previewNode.carcassHeight + 0.35,
                     labelPosition[2],
@@ -1452,4 +1572,9 @@ const CabinetTool = () => {
                         ? 'border-border/60 bg-background/90'
                         : 'border-red-400/60 bg-red-950/85'}`, children: _jsx("span", { className: "font-medium text-foreground", children: placementLabel }) }) })) : null] }));
 };
-export default CabinetTool;
+// Remount when the chosen item changes so typed dimensions and drafts cannot leak
+// from a base cabinet into a fridge or an overhead cabinet.
+export default function CabinetTool() {
+    const preset = useEditor((state) => state.toolDefaults.cabinet?.kitchenPreset);
+    return _jsx(CabinetPlacementTool, {}, String(preset ?? 'base-door'));
+}

package/dist/cabinet/validation.js

@@ -1,6 +1,6 @@
-import { moduleMaxX, moduleMinX, sortRunModules } from './run-layout';
-import { cabinetModuleCeilingOverflow } from './run-ops';
-import { minCabinetCarcassHeightForStack } from './stack';
+import { moduleMaxX, moduleMinX, sortRunModules } from './run-layout.js';
+import { cabinetModuleCeilingOverflow } from './run-ops.js';
+import { minCabinetCarcassHeightForStack } from './stack.js';
 export const CABINET_PLANNING_TOLERANCE = 1e-4;
 export const MIN_PRACTICAL_TOP_CABINET_HEIGHT = 0.15;
 function issue(code, severity, message, nodeIds) {

package/dist/cabinet/wall-snap.d.ts

@@ -1,5 +1,5 @@
 import { type AnyNode, type AnyNodeId, type CabinetModuleNode } from '@pascal-app/core';
-import type { WallHit } from '../shared/wall-attach-target';
+import type { WallHit } from '../shared/wall-attach-target.js';
 export type CabinetWallSnapNeighbor = {
     minX: number;
     maxX: number;

package/dist/cabinet/wall-snap.js

@@ -1,6 +1,6 @@
 import { calculateLevelMiters, getWallArcData, getWallCurveFrameAt, getWallLocalFaceZ, getWallPlanFootprint, isCurvedWall, WALL_SNAP_DISTANCE_M, } from '@pascal-app/core';
-import { snapCabinetFootprintCenter } from './placement-snap';
-import { planToRunLocal, runLocalToPlan } from './run-layout';
+import { snapCabinetFootprintCenter } from './placement-snap.js';
+import { planToRunLocal, runLocalToPlan } from './run-layout.js';
 const EDGE_SNAP_THRESHOLD = 0.08;
 const FACE_MATCH_THRESHOLD = 0.12;
 const YAW_MATCH_THRESHOLD = 0.08;

package/dist/ceiling/boundary-editor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"boundary-editor.d.ts","sourceRoot":"","sources":["../../src/ceiling/boundary-editor.tsx"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,WAAW,EAKjB,MAAM,kBAAkB,CAAA;AAazB;;;;;;;;;;GAUG;AACH,eAAO,MAAM,qBAAqB,EAAE,KAAK,CAAC,EAAE,CAAC;IAAE,SAAS,EAAE,WAAW,CAAC,IAAI,CAAC,CAAA;CAAE,CA0J5E,CAAA;AAED,eAAe,qBAAqB,CAAA"}
+{"version":3,"file":"boundary-editor.d.ts","sourceRoot":"","sources":["../../src/ceiling/boundary-editor.tsx"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,WAAW,EAKjB,MAAM,kBAAkB,CAAA;AAazB;;;;;;;;;;GAUG;AACH,eAAO,MAAM,qBAAqB,EAAE,KAAK,CAAC,EAAE,CAAC;IAAE,SAAS,EAAE,WAAW,CAAC,IAAI,CAAC,CAAA;CAAE,CA0J5E,CAAA;eAEc,qBAAqB"}

package/dist/ceiling/definition.d.ts

@@ -1,5 +1,5 @@
 import { type NodeDefinition } from '@pascal-app/core';
-import { CeilingNode } from './schema';
+import { CeilingNode } from './schema.js';
 /**
  * Ceiling — Phase 5 batch kind, polygon-based. Structurally similar to
  * slab but with React-rendered hosted children + TSL shader materials +

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

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/ceiling/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,cAAc,EAIpB,MAAM,kBAAkB,CAAA;AAuBzB,OAAO,EAAE,WAAW,EAAE,MAAM,UAAU,CAAA;AA+EtC;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,iBAAiB,EAAE,cAAc,CAAC,OAAO,WAAW,CAuHhE,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/ceiling/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,cAAc,EAIpB,MAAM,kBAAkB,CAAA;AAuBzB,OAAO,EAAE,WAAW,EAAE,MAAM,UAAU,CAAA;AA+EtC;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,iBAAiB,EAAE,cAAc,CAAC,OAAO,WAAW,CAyHhE,CAAA"}

package/dist/ceiling/definition.js

@@ -1,15 +1,15 @@
 import { ceilingSlots, resolveCeilingHeight, useScene, } from '@pascal-app/core';
 import { clearStructuralElevationGuide, DRAFTING_SURFACE_EXTENSION_KEY, publishStructuralElevationGuide, resolveStructuralElevationSnap, } from '@pascal-app/editor';
-import { surfaceBatchable } from '../shared/node-batch/batchable';
-import { polygonMeasurementFeatures } from '../shared/polygon-measurement';
-import { sameOutlineSurfaceCounterparts } from '../shared/surface-counterparts';
-import { buildCeilingFloorplan } from './floorplan';
-import { ceilingAddVertexAffordance, ceilingDeleteVertexAffordance, ceilingMoveEdgeAffordance, ceilingMoveVertexAffordance, } from './floorplan-affordances';
-import { ceilingFloorplanMoveTarget } from './floorplan-move';
-import { CEILING_HANDLE_MIN_HEIGHT, ceilingHeightRange } from './height-bounds';
-import { ceilingPaint } from './paint';
-import { ceilingParametrics } from './parametrics';
-import { CeilingNode } from './schema';
+import { surfaceBatchable } from '../shared/node-batch/batchable.js';
+import { polygonMeasurementFeatures } from '../shared/polygon-measurement.js';
+import { sameOutlineSurfaceCounterparts } from '../shared/surface-counterparts.js';
+import { buildCeilingFloorplan } from './floorplan.js';
+import { ceilingAddVertexAffordance, ceilingDeleteVertexAffordance, ceilingMoveEdgeAffordance, ceilingMoveVertexAffordance, } from './floorplan-affordances.js';
+import { ceilingFloorplanMoveTarget } from './floorplan-move.js';
+import { CEILING_HANDLE_MIN_HEIGHT, ceilingHeightRange } from './height-bounds.js';
+import { ceilingPaint } from './paint.js';
+import { ceilingParametrics } from './parametrics.js';
+import { CeilingNode } from './schema.js';
 const HEIGHT_HANDLE_OFFSET = 0.22;
 // Ceilings no longer drive the storey height; the stored level height
 // does. Height writes clamp under min(storey plane, lowest underside of
@@ -122,6 +122,8 @@ export const ceilingDefinition = {
         autoFromWalls: false,
     }),
     capabilities: {
+        reveal: { phase: 'roof', style: 'settle', height: 0.08 },
+        revealOnEdit: ['polygon', 'holes', 'height'],
         batchable: surfaceBatchable,
         selectable: { hitVolume: 'bbox' },
         surfaces: {
@@ -153,21 +155,21 @@ export const ceilingDefinition = {
     },
     // Stage D: kind-owned placement tool. Multi-click polygon drawing
     // with a vertical TSL-gradient connector + ground-shadow lines.
-    tool: () => import('./tool'),
+    tool: () => import('./tool.js'),
     // Stage D — all four ceiling drag-affordances live in this folder.
     // 1:1 port of the legacy tools (scene.update per tick + history
     // dance + preview fill/outline overlay on move).
     affordanceTools: {
-        'boundary-edit': () => import('./boundary-editor'),
-        'hole-edit': () => import('./hole-editor'),
-        move: () => import('./move-tool'),
+        'boundary-edit': () => import('./boundary-editor.js'),
+        'hole-edit': () => import('./hole-editor.js'),
+        move: () => import('./move-tool.js'),
     },
     renderer: {
         kind: 'parametric',
-        module: () => import('./renderer'),
+        module: () => import('./renderer.js'),
     },
     system: {
-        module: () => import('./system'),
+        module: () => import('./system.js'),
         priority: 4,
     },
     floorplan: buildCeilingFloorplan,