@pascal-app/nodes 1.0.3 → 1.0.5

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, getWallThickness, 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');
@@ -171,7 +172,7 @@ function bumpCabinetRunsNearNewRun(runId) {
     bumpCabinetRunsNear(createSceneApi(useScene), [cabinetRunFootprint(run, scene.nodes)], new Set([runId]));
 }
 function wallHitFromWallEvent(event) {
-    if (!event.normal || !isValidWallSideFace(event.normal) || isCurvedWall(event.node))
+    if (!(event.normal && isValidWallSideFace(event.normal)) || isCurvedWall(event.node))
         return null;
     const wall = event.node;
     const dx = wall.end[0] - wall.start[0];
@@ -183,7 +184,7 @@ function wallHitFromWallEvent(event) {
     return {
         wall,
         localX: event.localPosition[0],
-        perpDistance: (side === 'front' ? 1 : -1) * (getWallThickness(wall) / 2),
+        perpDistance: getWallLocalFaceZ(wall, side === 'front' ? 'a' : 'b'),
         side,
         dirX: dx / wallLength,
         dirY: dy / wallLength,
@@ -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') {
@@ -387,15 +402,15 @@ const CabinetTool = () => {
                 width: stretch?.length ?? livePreviewNode.width,
             })
             : [];
-        const sizeDimensions = !stretch && !island
-            ? buildCabinetPlacementSizeDimensions({
+        const sizeDimensions = stretch || island
+            ? []
+            : buildCabinetPlacementSizeDimensions({
                 depth: livePreviewNode.depth,
                 height: livePreviewNode.carcassHeight,
                 position: previewPosition,
                 rotation: next.yaw,
                 width: livePreviewNode.width,
-            })
-            : [];
+            });
         // A stretched span can exceed the schema's width cap — override post-parse.
         usePlacementPreview
             .getState()
@@ -404,7 +419,7 @@ const CabinetTool = () => {
     useFrame(() => {
         const ghostGroup = activeGhostRef.current;
         const current = placementRef.current;
-        if (!ghostGroup || !current) {
+        if (!(ghostGroup && current)) {
             clearPlacementSurface();
             useFacingPose.getState().clear();
             return;
@@ -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,
         });
     });
@@ -507,9 +524,7 @@ const CabinetTool = () => {
             }
             return anchor;
         };
-        const resolveRawPosition = (event) => {
-            return getLevelLocalSnappedPosition(activeLevelId, event, 0, true);
-        };
+        const resolveRawPosition = (event) => getLevelLocalSnappedPosition(activeLevelId, event, 0, true);
         const resolveGridPosition = (raw, bypassGrid = false) => {
             const step = !bypassGrid && isGridSnapActive() ? useEditor.getState().gridSnapStep : 0;
             if (step > 0) {
@@ -542,10 +557,10 @@ const CabinetTool = () => {
                 previewModule: previewNodeRef.current,
                 yaw,
             });
-            const moving = movingFootprintAnchors({
+            const moving = movingAlignmentAnchors({
                 ...alignmentNode,
-                ...(width != null ? { width } : null),
-            }, position[0], position[2], yaw);
+                ...(width == null ? null : { width }),
+            }, useScene.getState().nodes, position[0], position[2], yaw);
             if (moving.length === 0 || alignmentCandidates.length === 0) {
                 useAlignmentGuides.getState().clear();
                 return position;
@@ -556,15 +571,19 @@ const CabinetTool = () => {
                 threshold: FLOOR_PLACEMENT_ALIGNMENT_THRESHOLD_M,
             });
             useAlignmentGuides.getState().set(result.guides);
-            if (!applyAlignmentSnap || !result.snap)
+            if (!(applyAlignmentSnap && result.snap))
                 return position;
             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 = {
@@ -584,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,
@@ -614,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 }
@@ -662,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({
@@ -782,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'
@@ -826,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) {
@@ -837,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,
@@ -857,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,
@@ -874,7 +968,7 @@ const CabinetTool = () => {
             const sceneApi = createSceneApi(useScene);
             sceneApi.pauseHistory();
             try {
-                if (!chainRunRef.current || !chainEndModuleRef.current || !chainCornerSideRef.current) {
+                if (!(chainRunRef.current && chainEndModuleRef.current && chainCornerSideRef.current)) {
                     const { cabinet, buildModule } = buildRunNodes(segment.anchor.position, segment.anchor.yaw);
                     sceneApi.upsert(cabinet, activeLevelId);
                     const modules = segment.stretch.modules.map((m, index) => buildModule(m.x, m.width, index));
@@ -901,7 +995,7 @@ const CabinetTool = () => {
                 const nextRun = connectedModule?.parentId
                     ? sceneApi.get(connectedModule.parentId)
                     : null;
-                if (!connectedModule || !nextRun)
+                if (!(connectedModule && nextRun))
                     throw new Error('Unable to resolve connected corner run');
                 const plannedConnectedWidths = segment.stretch.modules
                     .slice(1)
@@ -953,7 +1047,7 @@ const CabinetTool = () => {
             const currentPlacement = placementRef.current?.stretch && placementRef.current.stretchAnchor
                 ? placementRef.current
                 : resolveActiveStretchPlacement(anchor, event);
-            if (!currentPlacement.valid || !currentPlacement.stretch || !currentPlacement.stretchAnchor) {
+            if (!(currentPlacement.valid && currentPlacement.stretch && currentPlacement.stretchAnchor)) {
                 return null;
             }
             return { anchor: currentPlacement.stretchAnchor, stretch: currentPlacement.stretch };
@@ -968,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;
             }
         };
@@ -1156,7 +1259,7 @@ const CabinetTool = () => {
         const applyTypedDimension = () => {
             const editor = usePlacementPreview.getState();
             const current = placementRef.current;
-            if (!editor.activeDimensionId || !editor.dimensionInput || !current) {
+            if (!(editor.activeDimensionId && editor.dimensionInput && current)) {
                 return false;
             }
             const value = parseMeasurement(editor.dimensionInput, { kind: 'length', unitId: 'm' }, {
@@ -1204,7 +1307,7 @@ const CabinetTool = () => {
                     const next = withPlacementValidity({
                         ...placementBase,
                         position,
-                        ...(wallLocalX != null ? { wallLocalX } : {}),
+                        ...(wallLocalX == null ? {} : { wallLocalX }),
                     }, false);
                     placementRef.current = next;
                     setPlacement(next);
@@ -1283,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) {
@@ -1391,8 +1493,16 @@ const CabinetTool = () => {
             useAlignmentGuides.getState().clear();
             useCabinetPlacementStatus.getState().setBlocked(false);
         };
-    }, [activeLevelId, metricNotation, previewNode, publishFloorplanPreview, toolDefaults, unit]);
-    if (!activeLevelId || !placement)
+    }, [
+        activeLevelId,
+        metricNotation,
+        previewNode,
+        publishFloorplanPreview,
+        toolDefaults,
+        unit,
+        wallCabinet,
+    ]);
+    if (!(activeLevelId && placement))
         return null;
     const stretch = placement.stretch;
     const draftModuleOffsets = draftSegments.map((segment, segmentIndex) => draftSegments
@@ -1401,18 +1511,20 @@ 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
-                ? null
-                : 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
+                : 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 }, [
@@ -1432,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 = [
@@ -1446,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, dimensions: placementBoxDimensions, dimensionInput: dimensionInput, 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", { ref: activeGhostRef, position: visualPosition, 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],
@@ -1454,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;