@pascal-app/nodes 1.0.0-beta.4 → 1.0.0

package/dist/cabinet/tool.js

@@ -1,7 +1,7 @@
 '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, getFloorStackPreviewPosition, getSideFromNormal, isAlignmentGuideActive, isGridSnapActive, isMagneticSnapActive, isValidWallSideFace, markToolCancelConsumed, movementSfxStepKey, PlacementBox, publishPlacementSurface, triggerSFX, useAlignmentGuides, useEditor, useFacingPose, usePlacementPreview, } from '@pascal-app/editor';
+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 { useViewer } from '@pascal-app/viewer';
 import { Html } from '@react-three/drei';
 import { useFrame } from '@react-three/fiber';
@@ -9,21 +9,93 @@ 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 { findClosestWallInPlan } from '../shared/wall-attach-target';
+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 { resolveCabinetGridPosition } from './placement-snap';
+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 { runLocalToPlan } from './run-layout';
-import { addCabinetModuleSide, addCornerRun, previewCornerAdditionLayout } from './run-ops';
-import { collectCabinetWallSnapNeighbors, resolveCabinetWallFaceOffset, resolveCabinetWallSnapPlacement, } from './wall-snap';
+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';
 const PREVIEW_OPACITY = 0.55;
 const ROTATE_STEP_RAD = Math.PI / 4;
 const DEFAULT_PLACEMENT_PRESET = cabinetPresetById('base-door');
 const ISLAND_SEATING_OVERHANG = 0.3;
+function angleDelta(a, b) {
+    return Math.atan2(Math.sin(a - b), Math.cos(a - b));
+}
+function resolveCabinetRunInsertion({ hit, insertionId, nodes, placement, parentLevelId, width, }) {
+    if (isCurvedWall(hit.wall))
+        return null;
+    const candidates = Object.values(nodes).filter((node) => node?.type === 'cabinet' && node.parentId === parentLevelId && node.rotation != null);
+    let best;
+    for (const run of candidates) {
+        if (Math.abs(angleDelta(run.rotation, placement.yaw)) > 0.08)
+            continue;
+        const modules = cabinetModulesForRun(run, nodes);
+        if (modules.length < 2)
+            continue;
+        const local = planToRunLocal(run, placement.position[0], 0, placement.position[2]);
+        const sorted = sortRunModules(modules);
+        const insertionIndex = sorted.findIndex((module) => moduleMaxX(module) > local[0] + 1e-4);
+        if (insertionIndex <= 0 || insertionIndex >= sorted.length)
+            continue;
+        const left = sorted[insertionIndex - 1];
+        const right = sorted[insertionIndex];
+        if (local[0] < moduleMaxX(left) - 0.15 ||
+            local[0] > right.position[0] - right.width / 2 + 0.15) {
+            continue;
+        }
+        const distance = Math.abs(local[2] - (left.position[2] + right.position[2]) / 2);
+        if (!best || distance < best.distance)
+            best = { distance, run, modules, localX: local[0] };
+    }
+    if (!best)
+        return null;
+    const { run, modules, localX } = best;
+    const sorted = sortRunModules(modules);
+    const insertionModule = sorted.find((module) => moduleMaxX(module) > localX + 1e-4);
+    const insertionY = insertionModule?.position[1] ?? sorted[0].position[1];
+    const insertionZ = insertionModule?.position[2] ?? sorted[0].position[2];
+    const preserveEnds = cornerPinnedEndsForRun(modules);
+    const result = planRunModuleInsertion({
+        modules,
+        insertion: {
+            id: insertionId,
+            position: [localX, insertionY, insertionZ],
+            width,
+        },
+        wallConstraints: runWallConstraints(run, modules, nodes),
+        fillerIds: new Set(modules.filter((module) => module.moduleKind === 'corner-filler').map((module) => module.id)),
+        preserveEnds,
+        anchorInsertionSide: preserveEnds.right ? 'right' : 'left',
+    });
+    if (!result.ok)
+        return { kind: 'blocked', reason: 'no-space', runId: run.id };
+    return {
+        kind: 'preview',
+        runId: run.id,
+        plan: {
+            runId: run.id,
+            runPosition: [...run.position],
+            runYaw: run.rotation,
+            modules: result.modules.map((module) => ({
+                id: module.id,
+                position: [...module.position],
+                width: module.width,
+            })),
+            inserted: {
+                position: [...result.inserted.position],
+                width: result.inserted.width,
+            },
+        },
+    };
+}
 function isStretchContinuation(anchor) {
     return 'straightAnchor' in anchor;
 }
@@ -122,6 +194,9 @@ function wallHitFromWallEvent(event) {
 const CabinetTool = () => {
     const activeLevelId = useViewer((s) => s.selection.levelId);
     const unit = useViewer((s) => s.unit);
+    const metricNotation = useViewer((s) => s.metricNotation);
+    const activeDimensionId = usePlacementPreview((s) => s.activeDimensionId);
+    const dimensionInput = usePlacementPreview((s) => s.dimensionInput);
     const [placement, setPlacement] = useState(null);
     const [draftSegments, setDraftSegments] = useState([]);
     const [yaw, setYaw] = useState(0);
@@ -146,7 +221,7 @@ const CabinetTool = () => {
     const surfaceQuatRef = useRef(new Quaternion());
     const surfaceForwardRef = useRef(new Vector3(0, 0, 1));
     const facingPointRef = useRef(new Vector3());
-    const previewNode = useMemo(() => {
+    const previewNodeTemplate = useMemo(() => {
         const runDefaults = cabinetDefinition.defaults();
         return CabinetModuleNode.parse({
             ...cabinetModuleDefinition.defaults(),
@@ -160,6 +235,19 @@ const CabinetTool = () => {
             countertopBackOverhang: runDefaults.countertopBackOverhang,
         });
     }, []);
+    const [previewSize, setPreviewSize] = useState(() => ({
+        depth: previewNodeTemplate.depth,
+        height: previewNodeTemplate.carcassHeight,
+        width: previewNodeTemplate.width,
+    }));
+    const previewNode = useMemo(() => CabinetModuleNode.parse({
+        ...previewNodeTemplate,
+        carcassHeight: previewSize.height,
+        depth: previewSize.depth,
+        width: previewSize.width,
+    }), [previewNodeTemplate, previewSize]);
+    const previewNodeRef = useRef(previewNode);
+    previewNodeRef.current = previewNode;
     const placementDimensions = useMemo(() => {
         const defaults = cabinetDefinition.defaults();
         return [
@@ -170,6 +258,22 @@ const CabinetTool = () => {
             previewNode.depth + (islandMode ? ISLAND_SEATING_OVERHANG : 0),
         ];
     }, [previewNode, islandMode]);
+    const placementDimensionsRef = useRef(placementDimensions);
+    placementDimensionsRef.current = placementDimensions;
+    const placementSnapFootprint = useMemo(() => {
+        const sideAndFrontOverhang = previewNode.withCountertop ? previewNode.countertopOverhang : 0;
+        const backOverhang = islandMode ? ISLAND_SEATING_OVERHANG : 0;
+        return {
+            dimensions: [
+                previewNode.width + sideAndFrontOverhang * 2,
+                placementDimensions[1],
+                previewNode.depth + sideAndFrontOverhang + backOverhang,
+            ],
+            offset: [0, (sideAndFrontOverhang - backOverhang) / 2],
+        };
+    }, [islandMode, placementDimensions, previewNode]);
+    const placementSnapFootprintRef = useRef(placementSnapFootprint);
+    placementSnapFootprintRef.current = placementSnapFootprint;
     const ghost = useMemo(() => {
         const group = buildCabinetGeometry(previewNode);
         group.traverse((child) => {
@@ -182,6 +286,26 @@ const CabinetTool = () => {
         });
         return group;
     }, [previewNode]);
+    const insertionGhost = useMemo(() => {
+        const node = CabinetModuleNode.parse({
+            ...previewNode,
+            plinthHeight: 0,
+            showPlinth: false,
+            countertopThickness: 0,
+            withCountertop: false,
+        });
+        const group = buildCabinetGeometry(node);
+        group.traverse((child) => {
+            child.layers.set(EDITOR_LAYER);
+            if (child instanceof Mesh) {
+                child.material = child.material.clone();
+                child.material.transparent = true;
+                child.material.opacity = PREVIEW_OPACITY;
+                child.raycast = () => { };
+            }
+        });
+        return group;
+    }, [previewNode]);
     // The stretched span renders one ghost per module — the same Object3D can't
     // appear twice in the scene, so extra modules reuse pooled clones (geometry
     // and materials stay shared) instead of cloning on every pointer move.
@@ -194,23 +318,87 @@ const CabinetTool = () => {
             pool.push(ghost.clone());
         return pool[index - 1];
     }, [ghost]);
+    const insertionGhostPoolRef = useRef([]);
+    const insertionGhostForIndex = useCallback((index) => {
+        if (index === 0)
+            return insertionGhost;
+        const pool = insertionGhostPoolRef.current;
+        while (pool.length < index)
+            pool.push(insertionGhost.clone());
+        return pool[index - 1];
+    }, [insertionGhost]);
     const publishFloorplanPreview = useCallback((next, island = islandModeRef.current) => {
         const stretch = next.stretch;
+        const previewPosition = stretch
+            ? runLocalToPlan({ position: next.position, rotation: next.yaw }, [
+                stretch.centerLocalX,
+                0,
+                0,
+            ])
+            : next.position;
+        const livePreviewNode = previewNodeRef.current;
         const node = buildCabinetPlacementPreviewNode({
             island,
-            position: stretch
-                ? runLocalToPlan({ position: next.position, rotation: next.yaw }, [
-                    stretch.centerLocalX,
-                    0,
-                    0,
-                ])
-                : next.position,
-            previewModule: previewNode,
+            position: previewPosition,
+            previewModule: livePreviewNode,
             yaw: next.yaw,
         });
+        let floorplanNode = stretch ? { ...node, width: stretch.length } : node;
+        let floorplanContextNodes = [];
+        if (next.insertionPreview) {
+            const liveRun = useScene.getState().nodes[next.insertionPreview.runId];
+            if (liveRun?.type === 'cabinet') {
+                const insertedId = livePreviewNode.id;
+                const previewModules = [
+                    ...next.insertionPreview.modules.map((planned) => {
+                        const liveModule = useScene.getState().nodes[planned.id];
+                        return liveModule?.type === 'cabinet-module'
+                            ? {
+                                ...liveModule,
+                                position: planned.position,
+                                width: planned.width,
+                            }
+                            : null;
+                    }),
+                    CabinetModuleNode.parse({
+                        ...cabinetModuleForRunInsertion(livePreviewNode, liveRun),
+                        id: insertedId,
+                        position: next.insertionPreview.inserted.position,
+                        width: next.insertionPreview.inserted.width,
+                    }),
+                ].filter((previewModule) => previewModule != null);
+                floorplanNode = CabinetNode.parse({
+                    ...liveRun,
+                    children: previewModules.map((previewModule) => previewModule.id),
+                });
+                floorplanContextNodes = previewModules;
+            }
+        }
+        const placementDimensions = activeLevelId && !island
+            ? resolveCabinetPlacementDimensions({
+                depth: livePreviewNode.depth,
+                levelId: activeLevelId,
+                nodes: useScene.getState().nodes,
+                position: previewPosition,
+                rotation: next.yaw,
+                wallId: next.wallId,
+                width: stretch?.length ?? livePreviewNode.width,
+            })
+            : [];
+        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().set(stretch ? { ...node, width: stretch.length } : node);
-    }, [previewNode]);
+        usePlacementPreview
+            .getState()
+            .set(floorplanNode, null, [...placementDimensions, ...sizeDimensions], floorplanContextNodes);
+    }, [activeLevelId]);
     useFrame(() => {
         const ghostGroup = activeGhostRef.current;
         const current = placementRef.current;
@@ -259,7 +447,7 @@ const CabinetTool = () => {
         previousWasWallSnapRef.current = false;
         previousTickFrameRef.current = -1;
         draftAnchorRef.current = null;
-        let alignmentCandidates = collectAlignmentAnchors(useScene.getState().nodes, previewNode.id, activeLevelId);
+        let alignmentCandidates = collectAlignmentAnchors(useScene.getState().nodes, previewNodeRef.current.id, activeLevelId);
         let lastWallEventTime = -1;
         let wallOwnedPointerAt = Number.NEGATIVE_INFINITY;
         const WALL_OWNS_POINTER_MS = 64;
@@ -322,9 +510,21 @@ const CabinetTool = () => {
         };
         const resolveGridPosition = (raw, bypassGrid = false) => {
             const step = !bypassGrid && isGridSnapActive() ? useEditor.getState().gridSnapStep : 0;
+            if (step > 0) {
+                const frame = resolveCabinetLevelPlanFrame(activeLevelId, useScene.getState().nodes);
+                return resolveCabinetGridPositionInFrame({
+                    raw,
+                    dimensions: placementSnapFootprintRef.current.dimensions,
+                    footprintOffset: placementSnapFootprintRef.current.offset,
+                    yaw: yawRef.current,
+                    step,
+                    frame,
+                });
+            }
             return resolveCabinetGridPosition({
                 raw,
-                dimensions: placementDimensions,
+                dimensions: placementSnapFootprintRef.current.dimensions,
+                footprintOffset: placementSnapFootprintRef.current.offset,
                 yaw: yawRef.current,
                 step,
             });
@@ -337,7 +537,7 @@ const CabinetTool = () => {
             const alignmentNode = buildCabinetPlacementPreviewNode({
                 island: islandModeRef.current,
                 position,
-                previewModule: previewNode,
+                previewModule: previewNodeRef.current,
                 yaw,
             });
             const moving = movingFootprintAnchors({
@@ -359,60 +559,83 @@ const CabinetTool = () => {
             return [position[0] + result.snap.dx, position[1], position[2] + result.snap.dz];
         };
         const withPlacementValidity = (next, bypassCollision) => {
-            if (bypassCollision)
-                return { ...next, conflictIds: [], valid: true };
-            const floorPlaced = nodeRegistry.get(previewNode.type)?.capabilities?.floorPlaced;
+            if (bypassCollision) {
+                return { ...next, conflictIds: [], valid: !next.insertionFailure };
+            }
+            const livePreviewNode = previewNodeRef.current;
+            const livePlacementDimensions = placementDimensionsRef.current;
+            const floorPlaced = nodeRegistry.get(livePreviewNode.type)?.capabilities?.floorPlaced;
             const effectiveNode = {
-                ...previewNode,
+                ...livePreviewNode,
                 position: next.position,
                 rotation: next.yaw,
             };
+            const ignoreIds = next.insertionPreview ? [next.insertionPreview.runId] : undefined;
             const footprints = floorPlaced
                 ? getFloorPlacedFootprints(floorPlaced, effectiveNode, {
                     nodes: useScene.getState().nodes,
                 }).filter((footprint) => footprint.position != null)
                 : [];
             const result = footprints.length > 0
-                ? spatialGridManager.canPlaceOnFloorFootprints(activeLevelId, footprints)
-                : spatialGridManager.canPlaceOnFloor(activeLevelId, next.position, placementDimensions, [
-                    0,
-                    next.yaw,
-                    0,
-                ]);
-            return { ...next, conflictIds: result.conflictIds, valid: result.valid };
+                ? spatialGridManager.canPlaceOnFloorFootprints(activeLevelId, footprints, ignoreIds)
+                : spatialGridManager.canPlaceOnFloor(activeLevelId, next.position, livePlacementDimensions, [0, next.yaw, 0], ignoreIds);
+            const wall = next.wallId ? useScene.getState().nodes[next.wallId] : undefined;
+            const openingConflictIds = wall?.type === 'wall' && next.wallLocalX != null
+                ? findWallOpeningConflicts({
+                    bottom: 0,
+                    height: livePlacementDimensions[1],
+                    localX: next.wallLocalX,
+                    nodes: useScene.getState().nodes,
+                    wall,
+                    width: livePreviewNode.width,
+                })
+                : [];
+            const conflictIds = [...new Set([...result.conflictIds, ...openingConflictIds])];
+            return {
+                ...next,
+                conflictIds,
+                valid: !next.insertionFailure && result.valid && openingConflictIds.length === 0,
+            };
         };
         const resolveWallHitPlacement = (hit) => {
             if (!isWallSnapEligible())
                 return null;
             const nodes = useScene.getState().nodes;
-            const neighbors = collectCabinetWallSnapNeighbors({
+            const wallPlacement = resolveCabinetWallSnapPlacementInScene({
+                depth: previewNodeRef.current.depth,
+                gridStep: isGridSnapActive() ? useEditor.getState().gridSnapStep : 0,
                 hit,
                 nodes,
                 parentLevelId: activeLevelId,
-                width: previewNode.width,
+                width: previewNodeRef.current.width,
             });
-            const faceOffset = resolveCabinetWallFaceOffset({
+            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 wallPlacement = resolveCabinetWallSnapPlacement({
-                depth: previewNode.depth,
-                faceOffset,
-                gridStep: isGridSnapActive() ? useEditor.getState().gridSnapStep : 0,
-                hit,
-                neighbors,
-                width: previewNode.width,
-            });
-            if (!wallPlacement)
-                return null;
-            const wallSurfaceNormal = [Math.sin(wallPlacement.yaw), 0, Math.cos(wallPlacement.yaw)];
+            const insertionPreview = insertion?.kind === 'preview' ? insertion.plan : undefined;
+            const insertionFailure = insertion?.kind === 'blocked'
+                ? { runId: insertion.runId, reason: insertion.reason }
+                : undefined;
+            const insertionPosition = insertionPreview
+                ? runLocalToPlan({ position: insertionPreview.runPosition, rotation: insertionPreview.runYaw }, insertionPreview.inserted.position)
+                : wallPlacement.position;
             return {
                 conflictIds: [],
                 guide: wallPlacement.guide,
-                position: wallPlacement.position,
+                ...(insertionFailure ? { insertionFailure } : {}),
+                ...(insertionPreview ? { insertionPreview } : {}),
+                position: insertionPosition,
                 snapReason: wallPlacement.snapReason,
                 valid: true,
+                wallId: hit.wall.id,
                 wallLocalX: wallPlacement.localX,
                 wallSurfaceNormal,
                 yaw: wallPlacement.yaw,
@@ -423,7 +646,12 @@ const CabinetTool = () => {
             if (!isWallSnapEligible())
                 return null;
             const nodes = useScene.getState().nodes;
-            const hit = findClosestWallInPlan([raw[0], raw[2]], nodes, activeLevelId);
+            const hit = findClosestCabinetWallInPlan({
+                excludeIds: [],
+                nodes,
+                parentLevelId: activeLevelId,
+                planPoint: [raw[0], raw[2]],
+            });
             if (!hit)
                 return null;
             return resolveWallHitPlacement(hit);
@@ -454,6 +682,44 @@ const CabinetTool = () => {
                 snappedToWall: false,
             }, forcePlacement);
         };
+        const resolveStretchedValidity = (anchor, stretch, forcePlace) => {
+            const spanCenter = runLocalToPlan({ position: anchor.position, rotation: anchor.yaw }, [
+                stretch.centerLocalX,
+                0,
+                0,
+            ]);
+            const ignoreIds = chainRootRunRef.current
+                ? [chainRootRunRef.current.id]
+                : undefined;
+            return resolveCabinetContinuousValidity((() => {
+                const floorResult = spatialGridManager.canPlaceOnFloor(activeLevelId, spanCenter, [stretch.length, placementDimensionsRef.current[1], placementDimensionsRef.current[2]], [0, anchor.yaw, 0], ignoreIds);
+                const nodes = useScene.getState().nodes;
+                const wall = anchor.wallId ? nodes[anchor.wallId] : undefined;
+                const wallHit = wall?.type === 'wall' && anchor.wallLocalX != null
+                    ? { wall, localX: anchor.wallLocalX + stretch.centerLocalX }
+                    : findClosestCabinetWallInPlan({
+                        excludeIds: [],
+                        nodes,
+                        parentLevelId: activeLevelId,
+                        planPoint: [spanCenter[0], spanCenter[2]],
+                        yaw: anchor.yaw,
+                    });
+                const openingConflictIds = wallHit && (wallHit.localX ?? null) != null
+                    ? findWallOpeningConflicts({
+                        bottom: 0,
+                        height: placementDimensionsRef.current[1],
+                        localX: wallHit.localX,
+                        nodes,
+                        wall: wallHit.wall,
+                        width: stretch.length,
+                    })
+                    : [];
+                return {
+                    conflictIds: [...new Set([...floorResult.conflictIds, ...openingConflictIds])],
+                    valid: floorResult.valid && openingConflictIds.length === 0,
+                };
+            })(), forcePlace);
+        };
         // While stretching, the run is pinned at the anchored first module and
         // grows toward the cursor — the far end tracks the pointer smoothly.
         const resolveStretchedPlacement = (anchor, event) => {
@@ -461,7 +727,7 @@ const CabinetTool = () => {
             const raw = resolveRawPosition(event);
             let stretch = planCabinetContinuousStretch({
                 anchor,
-                previewWidth: previewNode.width,
+                previewWidth: previewNodeRef.current.width,
                 rawPlanPosition: raw,
             });
             if (anchor.leadingWidth != null &&
@@ -479,6 +745,8 @@ const CabinetTool = () => {
                         position: anchor.position,
                         yaw: anchor.yaw,
                         snappedToWall: anchor.snappedToWall,
+                        wallId: anchor.wallId,
+                        wallLocalX: anchor.wallLocalX,
                         wallSurfaceNormal: anchor.wallSurfaceNormal,
                         valid: false,
                         conflictIds: [],
@@ -488,19 +756,13 @@ const CabinetTool = () => {
                 }
                 stretch = stretchWithAdjustedConnectedWidth(stretch, preview.connectedWidth);
             }
-            const spanCenter = runLocalToPlan({ position: anchor.position, rotation: anchor.yaw }, [
-                stretch.centerLocalX,
-                0,
-                0,
-            ]);
-            const ignoreIds = chainRootRunRef.current
-                ? [chainRootRunRef.current.id]
-                : undefined;
-            const result = resolveCabinetContinuousValidity(spatialGridManager.canPlaceOnFloor(activeLevelId, spanCenter, [stretch.length, placementDimensions[1], placementDimensions[2]], [0, anchor.yaw, 0], ignoreIds), isForcePlacementEvent(event));
+            const result = resolveStretchedValidity(anchor, stretch, isForcePlacementEvent(event));
             return {
                 position: anchor.position,
                 yaw: anchor.yaw,
                 snappedToWall: anchor.snappedToWall,
+                wallId: anchor.wallId,
+                wallLocalX: anchor.wallLocalX,
                 wallSurfaceNormal: anchor.wallSurfaceNormal,
                 valid: result.valid,
                 conflictIds: result.conflictIds,
@@ -692,6 +954,86 @@ const CabinetTool = () => {
             }
             return { anchor: currentPlacement.stretchAnchor, stretch: currentPlacement.stretch };
         };
+        const commitInsertion = (next) => {
+            const insertionPreview = next.insertionPreview;
+            if (!insertionPreview)
+                return null;
+            const sceneApi = createSceneApi(useScene);
+            const run = sceneApi.get(insertionPreview.runId);
+            if (!run)
+                return null;
+            const module = cabinetModuleForRunInsertion(CabinetModuleNode.parse({
+                ...previewNodeRef.current,
+                position: insertionPreview.inserted.position,
+                width: insertionPreview.inserted.width,
+            }), run);
+            sceneApi.pauseHistory();
+            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,
+                });
+                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();
+                return null;
+            }
+        };
+        const updatePreviewSize = (field, value) => {
+            const nextPreviewNode = CabinetModuleNode.parse({
+                ...previewNodeRef.current,
+                carcassHeight: field === 'height' ? value : previewNodeRef.current.carcassHeight,
+                depth: field === 'depth' ? value : previewNodeRef.current.depth,
+                width: field === 'width' ? value : previewNodeRef.current.width,
+            });
+            previewNodeRef.current = nextPreviewNode;
+            setPreviewSize({
+                depth: nextPreviewNode.depth,
+                height: nextPreviewNode.carcassHeight,
+                width: nextPreviewNode.width,
+            });
+            const nextPlacementDimensions = [
+                nextPreviewNode.width,
+                (nextPreviewNode.showPlinth ? nextPreviewNode.plinthHeight : 0) +
+                    nextPreviewNode.carcassHeight +
+                    (nextPreviewNode.withCountertop ? nextPreviewNode.countertopThickness : 0),
+                nextPreviewNode.depth + (islandModeRef.current ? ISLAND_SEATING_OVERHANG : 0),
+            ];
+            placementDimensionsRef.current = nextPlacementDimensions;
+            const sideAndFrontOverhang = nextPreviewNode.withCountertop
+                ? nextPreviewNode.countertopOverhang
+                : 0;
+            placementSnapFootprintRef.current = {
+                dimensions: [
+                    nextPreviewNode.width + sideAndFrontOverhang * 2,
+                    nextPlacementDimensions[1],
+                    nextPreviewNode.depth +
+                        sideAndFrontOverhang +
+                        (islandModeRef.current ? ISLAND_SEATING_OVERHANG : 0),
+                ],
+                offset: [
+                    0,
+                    (sideAndFrontOverhang - (islandModeRef.current ? ISLAND_SEATING_OVERHANG : 0)) / 2,
+                ],
+            };
+        };
         const onDoubleClick = (event) => {
             const anchor = resolveDraftAnchor();
             if (!anchor)
@@ -734,8 +1076,8 @@ const CabinetTool = () => {
                 chainCornerSideRef.current = cabinetStretchExitSide(segment.stretch);
                 draftAnchorRef.current = createCabinetContinuousContinuation({
                     anchor: segment.anchor,
-                    previewDepth: previewNode.depth,
-                    previewWidth: previewNode.width,
+                    previewDepth: previewNodeRef.current.depth,
+                    previewWidth: previewNodeRef.current.width,
                     stretch: segment.stretch,
                 });
                 publishPlacement(resolveActiveStretchPlacement(draftAnchorRef.current, event));
@@ -750,6 +1092,22 @@ const CabinetTool = () => {
                 stopPlacementCommitPropagation(event);
                 return;
             }
+            if (next.insertionPreview) {
+                const insertedId = commitInsertion(next);
+                if (!insertedId) {
+                    stopPlacementCommitPropagation(event);
+                    return;
+                }
+                useViewer.getState().setSelection({ selectedIds: [insertedId] });
+                useEditor.getState().setMode('select');
+                triggerSFX('sfx:item-place');
+                useAlignmentGuides.getState().clear();
+                usePlacementPreview.getState().clear();
+                clearPlacementSurface();
+                useFacingPose.getState().clear();
+                stopPlacementCommitPropagation(event);
+                return;
+            }
             if (useEditor.getState().getContinuation('cabinet') === 'continuous') {
                 draftSegmentsRef.current = [];
                 setDraftSegments([]);
@@ -761,6 +1119,8 @@ const CabinetTool = () => {
                     position: next.position,
                     yaw: next.yaw,
                     snappedToWall: next.snappedToWall,
+                    wallId: next.wallId,
+                    wallLocalX: next.wallLocalX,
                     wallSurfaceNormal: next.wallSurfaceNormal,
                 };
                 publishPlacement(resolveStretchedPlacement(draftAnchorRef.current, event));
@@ -769,7 +1129,7 @@ const CabinetTool = () => {
                 return;
             }
             const { cabinet, buildModule } = buildRunNodes(next.position, next.yaw);
-            const module = buildModule(0, previewNode.width, 0);
+            const module = buildModule(0, previewNodeRef.current.width, 0);
             const nodes = { ...useScene.getState().nodes, [cabinet.id]: cabinet, [module.id]: module };
             const committedCabinet = CabinetNode.parse({
                 ...cabinet,
@@ -789,10 +1149,182 @@ const CabinetTool = () => {
             useFacingPose.getState().clear();
             stopPlacementCommitPropagation(event);
         };
+        const applyTypedDimension = () => {
+            const editor = usePlacementPreview.getState();
+            const current = placementRef.current;
+            if (!editor.activeDimensionId || !editor.dimensionInput || !current) {
+                return false;
+            }
+            const value = parseMeasurement(editor.dimensionInput, { kind: 'length', unitId: 'm' }, {
+                bareUnit: unit === 'imperial' ? 'in' : metricNotation === 'millimeters' ? 'mm' : 'm',
+                system: unit === 'imperial' ? 'imperial' : 'metric',
+            });
+            if (value === null)
+                return false;
+            if (!current.stretch) {
+                const sizeField = editor.activeDimensionId === 'cabinet-width'
+                    ? 'width'
+                    : editor.activeDimensionId === 'cabinet-depth'
+                        ? 'depth'
+                        : editor.activeDimensionId === 'cabinet-height'
+                            ? 'height'
+                            : null;
+                if (sizeField) {
+                    const limits = sizeField === 'width'
+                        ? { max: 3, min: 0.3 }
+                        : sizeField === 'depth'
+                            ? { max: 1.2, min: 0.3 }
+                            : { max: 1.4, min: 0.4 };
+                    const nextValue = Math.min(limits.max, Math.max(limits.min, value));
+                    updatePreviewSize(sizeField, nextValue);
+                    let position = current.position;
+                    let wallLocalX = current.wallLocalX;
+                    if (current.snappedToWall && current.wallId) {
+                        const resolvedWallPosition = resolveCabinetPlacementDimensionPosition({
+                            depth: previewNodeRef.current.depth,
+                            dimensionId: 'wall-clearance',
+                            levelId: activeLevelId,
+                            nodes: useScene.getState().nodes,
+                            position: current.position,
+                            rotation: current.yaw,
+                            wallId: current.wallId,
+                            value: 0,
+                            width: previewNodeRef.current.width,
+                        });
+                        if (resolvedWallPosition) {
+                            position = resolvedWallPosition.position;
+                            wallLocalX = resolvedWallPosition.wallLocalX;
+                        }
+                    }
+                    const { conflictIds: _conflictIds, valid: _valid, ...placementBase } = current;
+                    const next = withPlacementValidity({
+                        ...placementBase,
+                        position,
+                        ...(wallLocalX != null ? { wallLocalX } : {}),
+                    }, false);
+                    placementRef.current = next;
+                    setPlacement(next);
+                    publishFloorplanPreview(next);
+                    editor.clearDimensionEditor();
+                    return true;
+                }
+            }
+            if (current.stretch && current.stretchAnchor) {
+                const spanPosition = runLocalToPlan({ position: current.position, rotation: current.yaw }, [
+                    current.stretch.centerLocalX,
+                    0,
+                    0,
+                ]);
+                const resolved = resolveCabinetPlacementDimensionPosition({
+                    depth: previewNodeRef.current.depth,
+                    dimensionId: editor.activeDimensionId,
+                    levelId: activeLevelId,
+                    nodes: useScene.getState().nodes,
+                    position: spanPosition,
+                    rotation: current.yaw,
+                    wallId: current.wallId,
+                    value,
+                    width: current.stretch.length,
+                });
+                if (!resolved)
+                    return false;
+                const anchorPosition = runLocalToPlan({ position: resolved.position, rotation: current.yaw }, [-current.stretch.centerLocalX, 0, 0]);
+                const nextAnchor = {
+                    ...current.stretchAnchor,
+                    position: anchorPosition,
+                    ...(current.wallId && current.wallLocalX != null
+                        ? { wallLocalX: resolved.wallLocalX - current.stretch.centerLocalX }
+                        : {}),
+                };
+                const validity = resolveStretchedValidity(nextAnchor, current.stretch, false);
+                const next = {
+                    ...current,
+                    conflictIds: validity.conflictIds,
+                    position: anchorPosition,
+                    stretchAnchor: nextAnchor,
+                    valid: validity.valid,
+                    ...(current.wallId && current.wallLocalX != null
+                        ? { wallLocalX: resolved.wallLocalX - current.stretch.centerLocalX }
+                        : {}),
+                };
+                placementRef.current = next;
+                setPlacement(next);
+                publishFloorplanPreview(next);
+                editor.clearDimensionEditor();
+                return true;
+            }
+            const resolved = resolveCabinetPlacementDimensionPosition({
+                depth: previewNodeRef.current.depth,
+                dimensionId: editor.activeDimensionId,
+                levelId: activeLevelId,
+                nodes: useScene.getState().nodes,
+                position: current.position,
+                rotation: current.yaw,
+                wallId: current.wallId,
+                value,
+                width: previewNodeRef.current.width,
+            });
+            if (!resolved)
+                return false;
+            const { conflictIds: _conflictIds, valid: _valid, ...placementBase } = current;
+            const next = withPlacementValidity({
+                ...placementBase,
+                position: resolved.position,
+                wallLocalX: resolved.wallLocalX,
+            }, false);
+            placementRef.current = next;
+            setPlacement(next);
+            publishFloorplanPreview(next);
+            editor.clearDimensionEditor();
+            return true;
+        };
         const onKeyDown = (event) => {
             const tag = event.target?.tagName;
             if (tag === 'INPUT' || tag === 'TEXTAREA')
                 return;
+            const dimensionEditor = usePlacementPreview.getState();
+            if (event.key === 'Tab' && dimensionEditor.dimensions.length > 0) {
+                const currentIndex = dimensionEditor.dimensions.findIndex((dimension) => dimension.id === dimensionEditor.activeDimensionId);
+                const direction = event.shiftKey ? -1 : 1;
+                const nextIndex = (currentIndex + direction + dimensionEditor.dimensions.length) %
+                    dimensionEditor.dimensions.length;
+                dimensionEditor.selectDimension(dimensionEditor.dimensions[nextIndex].id);
+                event.preventDefault();
+                event.stopPropagation();
+                return;
+            }
+            if (dimensionEditor.activeDimensionId && placementRef.current) {
+                if (event.key === 'Enter') {
+                    applyTypedDimension();
+                    event.preventDefault();
+                    event.stopPropagation();
+                    return;
+                }
+                if (event.key === 'Escape') {
+                    dimensionEditor.clearDimensionEditor();
+                    event.preventDefault();
+                    event.stopPropagation();
+                    return;
+                }
+                if (event.key === 'Backspace' || event.key === 'Delete') {
+                    dimensionEditor.setDimensionInput(event.key === 'Delete'
+                        ? ''
+                        : dimensionEditor.dimensionInput.slice(0, Math.max(0, dimensionEditor.dimensionInput.length - 1)));
+                    event.preventDefault();
+                    event.stopPropagation();
+                    return;
+                }
+                if (event.key.length === 1 &&
+                    !event.metaKey &&
+                    !event.ctrlKey &&
+                    !event.altKey &&
+                    /^[0-9a-zA-Z.'"+\- ]$/.test(event.key)) {
+                    dimensionEditor.setDimensionInput(dimensionEditor.dimensionInput + event.key);
+                    event.preventDefault();
+                    event.stopPropagation();
+                    return;
+                }
+            }
             if (event.key === 'i' || event.key === 'I') {
                 event.preventDefault();
                 event.stopPropagation();
@@ -815,12 +1347,7 @@ const CabinetTool = () => {
                 const raw = lastRawPositionRef.current ?? current.position;
                 const position = resolveAlignedCabinetPosition({
                     applyAlignmentSnap: isMagneticSnapActive(),
-                    position: resolveCabinetGridPosition({
-                        raw,
-                        dimensions: placementDimensions,
-                        yaw: yawRef.current,
-                        step: isGridSnapActive() ? useEditor.getState().gridSnapStep : 0,
-                    }),
+                    position: resolveGridPosition(raw),
                     yaw: yawRef.current,
                 });
                 const next = withPlacementValidity({ ...placementBase, position, yaw: yawRef.current }, false);
@@ -860,7 +1387,7 @@ const CabinetTool = () => {
             useAlignmentGuides.getState().clear();
             useCabinetPlacementStatus.getState().setBlocked(false);
         };
-    }, [activeLevelId, placementDimensions, previewNode, publishFloorplanPreview]);
+    }, [activeLevelId, metricNotation, publishFloorplanPreview, unit]);
     if (!activeLevelId || !placement)
         return null;
     const stretch = placement.stretch;
@@ -868,19 +1395,21 @@ const CabinetTool = () => {
         .slice(0, segmentIndex)
         .reduce((sum, previous) => sum + previous.stretch.modules.length, 0));
     const activeStretchGhostOffset = draftSegments.reduce((sum, segment) => sum + segment.stretch.modules.length, 0);
-    const placementLabel = 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'
-                : null;
+    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'
+                    : null;
     const labelPosition = stretch
         ? runLocalToPlan({ position: placement.position, rotation: placement.yaw }, [
             stretch.centerLocalX,
@@ -901,23 +1430,19 @@ const CabinetTool = () => {
     });
     const placementRotationY = placement.snappedToWall || stretch ? placement.yaw : yaw;
     const placementBoxDimensions = [
-        stretch ? stretch.length : placementDimensions[0],
-        placementDimensions[1],
-        placementDimensions[2],
+        stretch
+            ? stretch.length + (previewNode.withCountertop ? previewNode.countertopOverhang * 2 : 0)
+            : placementSnapFootprint.dimensions[0],
+        placementSnapFootprint.dimensions[1],
+        placementSnapFootprint.dimensions[2],
     ];
-    const placementBoxPlanPosition = stretch
-        ? runLocalToPlan({ position: placement.position, rotation: placement.yaw }, [
-            stretch.centerLocalX,
-            0,
-            0,
-        ])
-        : placement.position;
+    const placementBoxPlanPosition = runLocalToPlan({ position: placement.position, rotation: placement.yaw }, [stretch?.centerLocalX ?? 0, 0, placementSnapFootprint.offset[1]]);
     const placementBoxPosition = [
         placementBoxPlanPosition[0],
         visualPosition[1],
         placementBoxPlanPosition[2],
     ];
-    return (_jsxs(LevelOffsetGroup, { children: [placement.guide && _jsx(WallSnapGuide, { blocked: !placement.valid, guide: placement.guide }), _jsx(PlacementBox, { dimensions: placementBoxDimensions, measurements: { unit }, position: placementBoxPosition, rotationY: placementRotationY, valid: placement.valid }), 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: 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 })) }), 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, 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: [
                     labelPosition[0],
                     previewNode.plinthHeight + previewNode.carcassHeight + 0.35,
                     labelPosition[2],