@pascal-app/nodes 1.0.0-beta.5 → 1.0.1

package/dist/cabinet/definition.js

@@ -1,24 +1,30 @@
-import { findLevelAncestorId, selectionProxyIdFromMetadata } from '@pascal-app/core';
+import { CABINET_METRIC_DEFAULTS, findLevelAncestorId, selectionProxyIdFromMetadata, } from '@pascal-app/core';
+import { findWallOpeningConflicts } from '../shared/wall-opening-clearance';
 import { bakeCabinetAnimationClip } from './animation';
 import { buildCabinetFloorplan, buildCabinetModuleFloorplan } from './floorplan';
 import { cabinetModuleFloorplanMoveTarget } from './floorplan-move';
 import { cabinetFloorplanSiblingOverrides } from './floorplan-overrides';
 import { buildCabinetGeometry } from './geometry';
+import { withCabinetHostedChildren } from './hosted-resize';
 import { toggleCabinetOperationState } from './interaction';
 import { cabinetModuleParentFrame } from './move-frame';
 import { cabinetPaint } from './paint';
+import { cabinetModuleUsesFixedApplianceWidth } from './panel-visibility';
 import { cabinetModuleParametrics, cabinetParametrics } from './parametrics';
+import { resolveCabinetGridPosition } from './placement-snap';
 import useCabinetPlacementType from './placement-type';
+import { metadataForSelectedWidth, metadataWithPresetWidthDebt } from './preset-width-debt';
 import { cabinetQuickActions } from './quick-actions';
 import { cabinetConnectedDepthBounds, cabinetResizeUpperBound, MAX_CABINET_DEPTH, MAX_CABINET_WIDTH, MIN_CABINET_DEPTH, MIN_CABINET_WIDTH, } from './resize-limits';
-import { moduleSideOpen, sortRunModules } from './run-layout';
-import { backAlignedRunDepthOverrides, backAlignZ, buildWallCornerDepthIndex, bumpCabinetRunLayoutRevision, cabinetMetadataRecord, cabinetModulesForRun, totalCabinetHeight as cabinetTotalHeight, cornerSourceWidthOverridesForDerivedDepth, previewCornerRunsFromRunSources, resolveCabinetType, runModuleBaseY, syncCornerRunsFromRunSources, syncCornerRunsFromSourceModule, wallChildOf, wallCornerWidthOverridesForDepthTargets, } from './run-ops';
+import { moduleSideOpen, reflowRunModules as reflowCabinetRunModules, runWallConstraints, sortRunModules, } from './run-layout';
+import { backAlignedRunDepthOverrides, backAlignZ, buildWallCornerDepthIndex, bumpCabinetRunLayoutRevision, cabinetMetadataRecord, cabinetModulesForRun, cabinetModuleTotalHeight, totalCabinetHeight as cabinetTotalHeight, cornerSourceWidthOverridesForDerivedDepth, nestedCornerRunPositionOverrides, previewCornerRunsFromRunSources, resolveCabinetType, runModuleBaseY, syncCornerRunsFromRunSources, syncCornerRunsFromSourceModule, wallChildOf, wallCornerWidthOverridesForDepthTargets, } from './run-ops';
 import { cabinetSceneAction } from './scene-action';
 import { CabinetModuleNode, CabinetNode } from './schema';
 import { cabinetSlots } from './slots';
 import { backAnchoredModuleZ, isHoodCompartmentType, minCabinetCarcassHeightForStack, stackForCabinet, } from './stack';
+import { cabinetSurfaceProvider } from './surfaces';
 import { cabinetFloorplanAffectedIds, cabinetTreeChildIds, cabinetTreeHidden, cabinetTreeLabel, } from './tree-structure';
-import { resolveCabinetModuleWallSnapLocal, resolveCabinetRunWallSnap } from './wall-snap';
+import { findClosestCabinetWallInPlan, resolveCabinetModuleWallSnapLocal, resolveCabinetRunWallSnap, resolveCabinetWallFaceOffset, } from './wall-snap';
 function isCabinetDuplicableNode(node) {
     return ((node?.type === 'cabinet' || node?.type === 'cabinet-module') &&
         Array.isArray(node.position) &&
@@ -95,7 +101,7 @@ function appendCabinetFloorPlacedFootprints(run, nodes, parentPosition, parentRo
             ];
             footprints.push({
                 position: modulePosition,
-                dimensions: [module.width, cabinetTotalHeight(module), module.depth],
+                dimensions: [module.width, cabinetModuleTotalHeight(module), module.depth],
                 rotation: [0, runRotation + module.rotation, 0],
             });
         }
@@ -128,6 +134,43 @@ export function cabinetFloorPlacedFootprints(node, nodes) {
     appendCabinetFloorPlacedFootprints(node, nodes, [0, 0, 0], 0, footprints);
     return footprints;
 }
+function cabinetRunOverlapsWallOpening({ levelId, node, nodes, position, rotation, }) {
+    const parentLevelId = (levelId ??
+        findLevelAncestorId(node.id, nodes));
+    if (!parentLevelId)
+        return false;
+    const candidate = { ...node, position: [...position], rotation };
+    return cabinetFloorPlacedFootprints(candidate, nodes).some((footprint) => {
+        if (!footprint.position)
+            return false;
+        const hit = findClosestCabinetWallInPlan({
+            excludeIds: [],
+            nodes: nodes,
+            parentLevelId,
+            planPoint: [footprint.position[0], footprint.position[2]],
+            yaw: footprint.rotation[1],
+        });
+        if (!hit)
+            return false;
+        const normalScale = hit.side === 'front' ? 1 : -1;
+        const expectedPerp = resolveCabinetWallFaceOffset({
+            hit,
+            nodes: nodes,
+            parentLevelId,
+        }) +
+            normalScale * (footprint.dimensions[2] / 2);
+        if (Math.abs(hit.perpDistance - expectedPerp) > 0.12)
+            return false;
+        return (findWallOpeningConflicts({
+            bottom: footprint.position[1],
+            height: footprint.dimensions[1],
+            localX: hit.localX,
+            nodes,
+            wall: hit.wall,
+            width: footprint.dimensions[0],
+        }).length > 0);
+    });
+}
 const SIDE_HANDLE_OFFSET = 0.18;
 const HEIGHT_HANDLE_OFFSET = 0.22;
 const ROTATE_CORNER_OFFSET = 0.32;
@@ -135,6 +178,7 @@ const ROTATE_RING_OFFSET = 0.04;
 const MIN_CABINET_CARCASS_HEIGHT = 0.4;
 const CABINET_ADJACENCY_EPSILON = 1e-4;
 const CABINET_DEPTH_SNAP_THRESHOLD = 0.02;
+const CABINET_WIDTH_SNAP_THRESHOLD = 0.08;
 function isCabinetModule(node) {
     return node?.type === 'cabinet-module';
 }
@@ -146,18 +190,32 @@ function hasCabinetParentId(node) {
     return (typeof parentId === 'string' &&
         (parentId.startsWith('cabinet_') || parentId.startsWith('cabinet-module_')));
 }
-function resolveCabinetGroupMoveSnap({ candidatePosition, levelId, movingIds, node, nodes, }) {
+function resolveCabinetGroupMoveSnap({ candidatePosition, candidateRotation, levelId, movingIds, node, nodes, }) {
     if (node.type !== 'cabinet' || !levelId)
         return null;
     return resolveCabinetRunWallSnap({
         cabinet: node,
         candidatePosition,
+        candidateRotation,
         excludeIds: movingIds,
         gridStep: 0,
         nodes: nodes,
         parentLevelId: levelId,
     });
 }
+function resolveCabinetMoveGridSnap({ candidatePosition, candidateRotation, gridStep, node, nodes, }) {
+    if (!isCabinetRun(node))
+        return candidatePosition;
+    const bounds = cabinetLocalBounds(node, nodes);
+    const snapped = resolveCabinetGridPosition({
+        raw: candidatePosition,
+        dimensions: bounds.size,
+        footprintOffset: [bounds.center[0], bounds.center[2]],
+        yaw: candidateRotation,
+        step: gridStep,
+    });
+    return [snapped[0], candidatePosition[1], snapped[2]];
+}
 /**
  * Wall snap for a single dragged module. `parentFrame` kinds exchange
  * `candidatePosition` in the run's LOCAL frame with the move tool (it
@@ -173,7 +231,7 @@ function resolveCabinetModuleGroupMoveSnap({ candidatePosition, levelId, movingI
     const parentLevelId = (levelId ?? run.parentId ?? null);
     if (!parentLevelId)
         return null;
-    return resolveCabinetModuleWallSnapLocal({
+    const position = resolveCabinetModuleWallSnapLocal({
         candidateLocal: candidatePosition,
         excludeIds: movingIds,
         module: node,
@@ -181,6 +239,7 @@ function resolveCabinetModuleGroupMoveSnap({ candidatePosition, levelId, movingI
         parentLevelId,
         run,
     });
+    return position ? { position } : null;
 }
 function cabinetLayoutRevision(metadata) {
     return cabinetMetadataRecord(metadata).cabinetLayoutRevision ?? null;
@@ -277,7 +336,7 @@ export function cabinetRunNeighborSignature(run) {
         run.carcassHeight,
         run.runTier,
         run.countertopOverhang,
-        run.children ?? [],
+        (run.children ?? []).filter((id) => id.startsWith('cabinet_') || id.startsWith('cabinet-module_')),
         cabinetLayoutRevision(run.metadata),
     ]);
 }
@@ -288,7 +347,7 @@ function includeCabinetModuleBounds(module, nodes, origin, bounds) {
     bounds.minX = Math.min(bounds.minX, x - module.width / 2);
     bounds.maxX = Math.max(bounds.maxX, x + module.width / 2);
     bounds.minY = Math.min(bounds.minY, y - (module.showPlinth ? module.plinthHeight : 0));
-    bounds.maxY = Math.max(bounds.maxY, y + module.carcassHeight + (module.withCountertop ? module.countertopThickness : 0));
+    bounds.maxY = Math.max(bounds.maxY, y + cabinetModuleTotalHeight(module));
     bounds.minZ = Math.min(bounds.minZ, z - module.depth / 2);
     bounds.maxZ = Math.max(bounds.maxZ, z + module.depth / 2);
     for (const childId of module.children ?? []) {
@@ -327,7 +386,7 @@ function cabinetLocalBounds(node, nodes) {
         minX: -node.width / 2,
         maxX: node.width / 2,
         minY: 0,
-        maxY: cabinetTotalHeight(node),
+        maxY: node.type === 'cabinet-module' ? cabinetModuleTotalHeight(node) : cabinetTotalHeight(node),
         minZ: -node.depth / 2,
         maxZ: node.depth / 2,
     };
@@ -343,7 +402,7 @@ function cabinetLocalBounds(node, nodes) {
             for (const module of modules) {
                 includeCabinetModuleBounds(module, nodes, [0, 0, 0], bounds);
             }
-            bounds.maxY += node.withCountertop ? node.countertopThickness : 0;
+            bounds.maxY = Math.max(bounds.maxY, cabinetTotalHeight(node));
             // A seating back overhang (unlike the small front/side overhang) is
             // deep enough to matter for selection and collision.
             if (node.withCountertop && node.barLedge?.edge !== 'back') {
@@ -609,7 +668,12 @@ function parentRunGeometryPreviewOverride(node, sceneApi) {
     if (!isCabinetModule(node) || !node.parentId)
         return null;
     const parent = sceneApi.get(node.parentId);
-    return isCabinetRun(parent) ? [parent.id, {}] : null;
+    if (isCabinetRun(parent))
+        return [parent.id, {}];
+    if (!isCabinetModule(parent) || wallChildOf(parent, sceneApi.nodes())?.id !== node.id)
+        return null;
+    const run = parent.parentId ? sceneApi.get(parent.parentId) : undefined;
+    return isCabinetRun(run) ? [run.id, {}] : null;
 }
 function sharedDepthBounds(referenceDepth, targets, nodes) {
     const depthOwners = targets.flatMap((target) => {
@@ -745,6 +809,7 @@ function commitModuleResize(module, patch, sceneApi) {
         return;
     }
     if (typeof patch.width === 'number') {
+        const previousModule = module;
         sceneApi.update(module.id, patch);
         if (resolveCabinetType(module, parentRun) === 'base') {
             const wallChild = wallChildOf(module, sceneApi.nodes());
@@ -753,6 +818,12 @@ function commitModuleResize(module, patch, sceneApi) {
             }
         }
         bumpCabinetRunLayoutRevision(sceneApi, parentRun);
+        syncCornerRunsFromSourceModule({
+            module: sceneApi.get(module.id) ?? module,
+            previousModule,
+            run: sceneApi.get(parentRun.id) ?? parentRun,
+            sceneApi,
+        });
         return;
     }
     const modulePatch = { ...patch };
@@ -781,6 +852,7 @@ function commitModuleResize(module, patch, sceneApi) {
     }
     syncCornerRunsFromSourceModule({
         module: sceneApi.get(module.id) ?? module,
+        previousModule: module,
         run: sceneApi.get(parentRun.id) ?? parentRun,
         sceneApi,
     });
@@ -807,6 +879,156 @@ function commitCabinetResize(node, patch, sceneApi) {
     }
     sceneApi.update(node.id, patch);
 }
+function cabinetManualWidthContext(node, sceneApi) {
+    const parent = node.parentId ? sceneApi.get(node.parentId) : undefined;
+    if (isCabinetRun(parent)) {
+        return { run: parent, selected: node, modules: cabinetModulesForRun(parent, sceneApi.nodes()) };
+    }
+    if (!isCabinetModule(parent))
+        return null;
+    const run = parent.parentId ? sceneApi.get(parent.parentId) : undefined;
+    if (!isCabinetRun(run) || wallChildOf(parent, sceneApi.nodes())?.id !== node.id)
+        return null;
+    return { run, selected: parent, modules: cabinetModulesForRun(run, sceneApi.nodes()) };
+}
+function cabinetWidthIsNestedModule(node, sceneApi) {
+    const context = cabinetManualWidthContext(node, sceneApi);
+    return context !== null && context.selected.id !== node.id;
+}
+function snapCabinetWidth(node, width, side, sceneApi) {
+    const context = cabinetManualWidthContext(node, sceneApi);
+    if (!context)
+        return width;
+    const sorted = sortRunModules(context.modules);
+    const selected = context.selected;
+    const selectedIndex = sorted.findIndex((module) => module.id === selected.id);
+    const neighborHost = sorted[side === 'right' ? selectedIndex + 1 : selectedIndex - 1];
+    if (!neighborHost)
+        return width;
+    const nested = selected.id !== node.id;
+    const snapTarget = nested ? wallChildOf(neighborHost, sceneApi.nodes()) : neighborHost;
+    if (!snapTarget)
+        return width;
+    const selectedCenter = nested
+        ? cabinetModuleRunLocalCenterX(node, sceneApi)
+        : selected.position[0];
+    const targetCenter = nested
+        ? cabinetModuleRunLocalCenterX(snapTarget, sceneApi)
+        : snapTarget.position[0];
+    if (selectedCenter === null || targetCenter === null)
+        return width;
+    const selectedEdge = selectedCenter + (side === 'right' ? node.width / 2 : -node.width / 2);
+    const neighborEdge = targetCenter + (side === 'right' ? -snapTarget.width / 2 : snapTarget.width / 2);
+    const gap = side === 'right' ? neighborEdge - selectedEdge : selectedEdge - neighborEdge;
+    if (gap <= CABINET_ADJACENCY_EPSILON)
+        return width;
+    const targetWidth = node.width + gap - (nested ? 0 : cabinetWallWidthGap(node, side, sceneApi));
+    return targetWidth > node.width && Math.abs(width - targetWidth) <= CABINET_WIDTH_SNAP_THRESHOLD
+        ? targetWidth
+        : width;
+}
+function cabinetIndependentWidthPatch(node, width, side, sceneApi) {
+    const sign = side === 'right' ? 1 : -1;
+    const gap = cabinetWallWidthGap(node, side, sceneApi);
+    const effectiveWidth = width + gap;
+    return {
+        width: effectiveWidth,
+        position: [
+            node.position[0] + (sign * (effectiveWidth - node.width)) / 2,
+            node.position[1],
+            node.position[2],
+        ],
+    };
+}
+function cabinetIndependentWidthPreviewOverrides(node, width, side, sceneApi) {
+    const overrides = [];
+    overrides.push([
+        node.id,
+        cabinetIndependentWidthPatch(node, width, side, sceneApi),
+    ]);
+    const parentRunOverride = parentRunGeometryPreviewOverride(node, sceneApi);
+    if (parentRunOverride)
+        overrides.push(parentRunOverride);
+    const gap = cabinetWallWidthGap(node, side, sceneApi);
+    const selectedWallOverride = wallCabinetWidthOverride(node, width + gap, sceneApi);
+    if (selectedWallOverride)
+        overrides.push(selectedWallOverride);
+    return overrides;
+}
+function previewCabinetCornerWidthOverrides(node, initialOverrides, sceneApi) {
+    const parent = node.parentId
+        ? sceneApi.get(node.parentId)
+        : undefined;
+    if (!parent || !isCabinetRun(parent))
+        return initialOverrides;
+    return previewCornerRunsFromRunSources({
+        baseLayout: 'width-only',
+        initialOverrides,
+        previousModules: cabinetModulesForRun(parent, sceneApi.nodes()),
+        run: parent,
+        sceneApi,
+    });
+}
+function cabinetManualWidthReflow(node, width, side, sceneApi) {
+    const context = cabinetManualWidthContext(node, sceneApi);
+    if (!context)
+        return null;
+    const wallGap = cabinetWallWidthGap(node, side, sceneApi);
+    const selectedWidth = width + wallGap;
+    const runConstraints = runWallConstraints(context.run, context.modules, sceneApi.nodes(), { widthGrowth: Math.max(0, selectedWidth - context.selected.width) });
+    const draggedEnd = side === 'right' ? runConstraints.right : runConstraints.left;
+    const clampedSelectedWidth = selectedWidth > context.selected.width && draggedEnd.constrained
+        ? Math.min(selectedWidth, context.selected.width + draggedEnd.slack)
+        : selectedWidth;
+    const reflowed = reflowCabinetRunModules(context.modules, context.selected.id, clampedSelectedWidth, {
+        resizeSide: side,
+        consumeAdjacentGap: true,
+        eligibleDonorIds: new Set(),
+        maximumWidth: MAX_CABINET_WIDTH,
+    });
+    return reflowed.length > 0 ? { ...context, reflowed, wallGap } : null;
+}
+function commitCabinetManualWidth(node, width, side, sceneApi) {
+    const reflow = cabinetManualWidthReflow(node, width, side, sceneApi);
+    if (!reflow)
+        return;
+    const reflowById = new Map(reflow.reflowed.map((entry) => [entry.id, entry]));
+    for (const module of reflow.modules) {
+        const next = reflowById.get(module.id);
+        if (!next)
+            continue;
+        const isSelected = module.id === reflow.selected.id;
+        const modulePatch = {
+            width: next.width,
+            position: next.position,
+        };
+        if (isSelected) {
+            modulePatch.metadata = metadataForSelectedWidth(module, next.width);
+        }
+        else if (Math.abs(next.width - module.width) > 1e-4) {
+            modulePatch.metadata = metadataWithPresetWidthDebt(module, reflow.selected.id, next.width - module.width);
+        }
+        const nestedCornerOverrides = nestedCornerRunPositionOverrides(module, next.position, sceneApi.nodes());
+        sceneApi.update(module.id, modulePatch);
+        for (const [id, override] of nestedCornerOverrides) {
+            sceneApi.update(id, override);
+        }
+        const wallChild = wallChildOf(module, sceneApi.nodes());
+        if (wallChild) {
+            sceneApi.update(wallChild.id, {
+                width: next.width,
+                position: [0, wallChild.position[1], backAlignZ(module.depth, wallChild.depth)],
+            });
+        }
+    }
+    syncCornerRunsFromRunSources({
+        baseLayout: 'width-only',
+        previousModules: reflow.modules,
+        run: sceneApi.get(reflow.run.id) ?? reflow.run,
+        sceneApi,
+    });
+    bumpCabinetRunLayoutRevision(sceneApi, reflow.run);
+}
 function cabinetWidthHandle(side) {
     const sign = side === 'right' ? 1 : -1;
     return {
@@ -816,26 +1038,40 @@ function cabinetWidthHandle(side) {
         min: (node, sceneApi) => {
             if (!isCabinetModule(node))
                 return MIN_CABINET_WIDTH;
-            const gap = cabinetWallWidthGap(node, side, sceneApi);
-            const connected = cabinetWidthConnectedNeighbor(node, side, sceneApi);
-            if (!connected || isCabinetWidthFiller(connected))
-                return MIN_CABINET_WIDTH - gap;
-            const connectedMax = cabinetResizeUpperBound(connected.width, MAX_CABINET_WIDTH);
-            return Math.max(MIN_CABINET_WIDTH - gap, node.width - (connectedMax - connected.width));
+            const gap = cabinetWidthIsNestedModule(node, sceneApi)
+                ? 0
+                : cabinetWallWidthGap(node, side, sceneApi);
+            return MIN_CABINET_WIDTH - gap;
         },
         max: (node, sceneApi) => {
             const ownMax = cabinetResizeUpperBound(node.width, MAX_CABINET_WIDTH);
             if (!isCabinetModule(node))
                 return ownMax;
-            const gap = cabinetWallWidthGap(node, side, sceneApi);
-            const connected = cabinetWidthConnectedNeighbor(node, side, sceneApi);
-            if (!connected || isCabinetWidthFiller(connected))
-                return ownMax - gap;
-            return Math.min(ownMax - gap, node.width + connected.width - MIN_CABINET_WIDTH);
+            const gap = cabinetWidthIsNestedModule(node, sceneApi)
+                ? 0
+                : cabinetWallWidthGap(node, side, sceneApi);
+            return ownMax - gap;
         },
+        magneticSnap: (node, width, sceneApi) => isCabinetModule(node) ? snapCabinetWidth(node, width, side, sceneApi) : width,
         currentValue: (node) => node.width,
-        apply: (node, width, sceneApi) => {
-            const gap = isCabinetModule(node) ? cabinetWallWidthGap(node, side, sceneApi) : 0;
+        apply: (node, width, sceneApi, modifiers) => {
+            if (isCabinetModule(node) && modifiers?.altKey) {
+                return cabinetIndependentWidthPatch(node, width, side, sceneApi);
+            }
+            if (isCabinetModule(node) &&
+                cabinetManualWidthContext(node, sceneApi) &&
+                !cabinetWidthIsNestedModule(node, sceneApi)) {
+                const reflow = cabinetManualWidthReflow(node, width, side, sceneApi);
+                if (reflow) {
+                    const selected = reflow.reflowed.find((entry) => entry.id === reflow.selected.id);
+                    if (selected)
+                        return { width: selected.width, position: selected.position };
+                }
+                return { width: node.width, position: node.position };
+            }
+            const gap = isCabinetModule(node) && !cabinetWidthIsNestedModule(node, sceneApi)
+                ? cabinetWallWidthGap(node, side, sceneApi)
+                : 0;
             const effectiveWidth = width + gap;
             return {
                 width: effectiveWidth,
@@ -846,14 +1082,67 @@ function cabinetWidthHandle(side) {
                 ],
             };
         },
-        previewOverrides: (node, width, sceneApi) => {
+        previewOverrides: (node, width, sceneApi, modifiers) => {
             if (!isCabinetModule(node))
                 return [];
+            if (modifiers?.altKey) {
+                return previewCabinetCornerWidthOverrides(node, cabinetIndependentWidthPreviewOverrides(node, width, side, sceneApi), sceneApi);
+            }
+            if (cabinetWidthIsNestedModule(node, sceneApi)) {
+                const parentRunOverride = parentRunGeometryPreviewOverride(node, sceneApi);
+                return parentRunOverride ? [parentRunOverride] : [];
+            }
+            const reflow = cabinetManualWidthReflow(node, width, side, sceneApi);
+            if (reflow) {
+                const overrides = [];
+                const parentRunOverride = parentRunGeometryPreviewOverride(node, sceneApi);
+                if (parentRunOverride)
+                    overrides.push(parentRunOverride);
+                for (const entry of reflow.reflowed) {
+                    const module = reflow.modules.find((candidate) => candidate.id === entry.id);
+                    if (!module)
+                        continue;
+                    overrides.push([
+                        module.id,
+                        { width: entry.width, position: entry.position },
+                    ]);
+                    overrides.push(...nestedCornerRunPositionOverrides(module, entry.position, sceneApi.nodes()));
+                    const wallChild = wallChildOf(module, sceneApi.nodes());
+                    if (wallChild) {
+                        overrides.push([
+                            wallChild.id,
+                            {
+                                width: entry.width,
+                                position: [0, wallChild.position[1], backAlignZ(module.depth, wallChild.depth)],
+                            },
+                        ]);
+                    }
+                }
+                return previewCabinetCornerWidthOverrides(node, overrides, sceneApi);
+            }
+            if (cabinetManualWidthContext(node, sceneApi)) {
+                const parentRunOverride = parentRunGeometryPreviewOverride(node, sceneApi);
+                return parentRunOverride ? [parentRunOverride] : [];
+            }
             const overrides = [];
             const parentRunOverride = parentRunGeometryPreviewOverride(node, sceneApi);
             if (parentRunOverride)
                 overrides.push(parentRunOverride);
             const gap = cabinetWallWidthGap(node, side, sceneApi);
+            const effectiveWidth = width + gap;
+            const selectedPosition = [
+                node.position[0] + (sign * (effectiveWidth - node.width)) / 2,
+                node.position[1],
+                node.position[2],
+            ];
+            overrides.push([
+                node.id,
+                {
+                    width: effectiveWidth,
+                    position: selectedPosition,
+                },
+            ]);
+            overrides.push(...nestedCornerRunPositionOverrides(node, selectedPosition, sceneApi.nodes()));
             const selectedWallOverride = wallCabinetWidthOverride(node, width + gap, sceneApi);
             if (selectedWallOverride)
                 overrides.push(selectedWallOverride);
@@ -863,19 +1152,45 @@ function cabinetWidthHandle(side) {
                     connectedResize.module.id,
                     connectedResize.patch,
                 ]);
+                overrides.push(...nestedCornerRunPositionOverrides(connectedResize.module, connectedResize.patch.position, sceneApi.nodes()));
                 const connectedWallOverride = wallCabinetWidthOverride(connectedResize.module, connectedResize.patch.width, sceneApi);
                 if (connectedWallOverride)
                     overrides.push(connectedWallOverride);
             }
-            return overrides;
+            return previewCabinetCornerWidthOverrides(node, overrides, sceneApi);
         },
-        commit: (node, patch, sceneApi) => {
+        commit: (node, patch, sceneApi, modifiers) => {
+            if (isCabinetModule(node) && typeof patch.width === 'number' && modifiers?.altKey) {
+                commitCabinetResize(node, {
+                    ...patch,
+                    metadata: metadataForSelectedWidth(node, patch.width, patch.metadata),
+                }, sceneApi);
+                return;
+            }
+            if (isCabinetModule(node) && typeof patch.width === 'number') {
+                if (cabinetWidthIsNestedModule(node, sceneApi)) {
+                    commitCabinetResize(node, patch, sceneApi);
+                    return;
+                }
+                commitCabinetManualWidth(node, patch.width - cabinetWallWidthGap(node, side, sceneApi), side, sceneApi);
+                return;
+            }
             const connectedResize = isCabinetModule(node) && typeof patch.width === 'number'
                 ? connectedCabinetWidthResize(node, side, patch.width - node.width - cabinetWallWidthGap(node, side, sceneApi), sceneApi)
                 : null;
-            commitCabinetResize(node, patch, sceneApi);
+            const selectedPatch = isCabinetModule(node) && typeof patch.width === 'number'
+                ? {
+                    ...patch,
+                    metadata: metadataForSelectedWidth(node, patch.width, patch.metadata),
+                }
+                : patch;
+            commitCabinetResize(node, selectedPatch, sceneApi);
             if (connectedResize) {
-                commitCabinetResize(connectedResize.module, connectedResize.patch, sceneApi);
+                const widthDelta = connectedResize.patch.width - connectedResize.module.width;
+                commitCabinetResize(connectedResize.module, {
+                    ...connectedResize.patch,
+                    metadata: metadataWithPresetWidthDebt(connectedResize.module, node.id, widthDelta),
+                }, sceneApi);
             }
         },
         visible: (node, sceneApi) => !isCabinetModule(node) || cabinetModuleSideOpen(node, side, sceneApi),
@@ -1332,7 +1647,11 @@ function cabinetHeightHandle() {
         apply: (_node, carcassHeight) => ({ carcassHeight }),
         commit: commitCabinetResize,
         placement: {
-            position: (node) => [0, cabinetTotalHeight(node) + HEIGHT_HANDLE_OFFSET, 0],
+            position: (node, sceneApi) => [
+                0,
+                cabinetLocalBounds(node, sceneApi.nodes()).maxY + HEIGHT_HANDLE_OFFSET,
+                0,
+            ],
         },
     };
 }
@@ -1381,7 +1700,8 @@ function cabinetRotateHandle() {
     };
 }
 function cabinetHandles(node, sceneApi) {
-    if ((node.children ?? []).length > 0) {
+    const structuralChildren = (node.children ?? []).filter((id) => id.startsWith('cabinet_') || id.startsWith('cabinet-module_'));
+    if (structuralChildren.length > 0) {
         const connectedRuns = sceneApi && node.runTier === 'base' ? connectedBaseRuns(node, sceneApi) : [];
         const depthHandles = sceneApi
             ? connectedRuns.map((run) => cabinetConnectedRunDepthHandle(node, run, sceneApi))
@@ -1398,7 +1718,7 @@ function cabinetHandles(node, sceneApi) {
         cabinetHeightHandle(),
         cabinetRotateHandle(),
     ];
-    if ((node.children ?? []).length === 0) {
+    if (structuralChildren.length === 0) {
         handles.unshift(cabinetWidthHandle('left'), cabinetWidthHandle('right'));
     }
     return handles;
@@ -1407,25 +1727,40 @@ function isHoodOnlyCabinet(node) {
     const stack = stackForCabinet(node);
     return stack.length > 0 && stack.every((compartment) => isHoodCompartmentType(compartment.type));
 }
+function cabinetModuleHeightHandleVisible(node, sceneApi) {
+    const parent = node.parentId ? sceneApi.get(node.parentId) : undefined;
+    if (isCabinetRun(parent)) {
+        return parent.runTier === 'wall' || resolveCabinetType(node, parent) === 'tall';
+    }
+    return isCabinetModule(parent) && wallChildOf(parent, sceneApi.nodes())?.id === node.id;
+}
 function cabinetModuleHandles() {
     return [
         {
             ...cabinetWidthHandle('left'),
-            visible: (node, sceneApi) => !isCabinetWidthFiller(node) && !cabinetModuleSideHasCornerFiller(node, 'left', sceneApi),
+            visible: (node, sceneApi) => !isCabinetWidthFiller(node) &&
+                !cabinetModuleUsesFixedApplianceWidth(node) &&
+                !cabinetModuleSideHasCornerFiller(node, 'left', sceneApi),
         },
         {
             ...cabinetWidthHandle('right'),
-            visible: (node, sceneApi) => !isCabinetWidthFiller(node) && !cabinetModuleSideHasCornerFiller(node, 'right', sceneApi),
+            visible: (node, sceneApi) => !isCabinetWidthFiller(node) &&
+                !cabinetModuleUsesFixedApplianceWidth(node) &&
+                !cabinetModuleSideHasCornerFiller(node, 'right', sceneApi),
         },
         {
             ...cabinetDepthHandle(),
             visible: (node) => !isCabinetWidthFiller(node),
         },
+        {
+            ...cabinetHeightHandle(),
+            visible: cabinetModuleHeightHandleVisible,
+        },
     ];
 }
 export const cabinetDefinition = {
     kind: 'cabinet',
-    schemaVersion: 7,
+    schemaVersion: 8,
     schema: CabinetNode,
     category: 'furnish',
     surfaceRole: 'joinery',
@@ -1441,20 +1776,22 @@ export const cabinetDefinition = {
         runTier: 'base',
         children: [],
         width: 0.5,
-        depth: 0.5,
-        carcassHeight: 0.72,
+        depth: CABINET_METRIC_DEFAULTS.depth,
+        carcassHeight: CABINET_METRIC_DEFAULTS.carcassHeight,
         operationState: 0,
-        plinthHeight: 0.1,
+        plinthHeight: CABINET_METRIC_DEFAULTS.plinthHeight,
         toeKickDepth: 0.075,
         boardThickness: 0.018,
-        countertopThickness: 0.02,
+        countertopThickness: CABINET_METRIC_DEFAULTS.countertopThickness,
         countertopOverhang: 0.02,
         countertopBackOverhang: 0,
         withFinishedBack: false,
         withWaterfall: false,
+        withFinishedEnds: false,
         frontThickness: 0.018,
         frontGap: 0.003,
         frontStyle: 'slab',
+        panelReady: false,
         handleStyle: 'bar',
         handlePosition: 'auto',
         frontOverlay: 'full',
@@ -1467,8 +1804,18 @@ export const cabinetDefinition = {
         selectable: { hitVolume: 'bbox' },
         movable: {
             axes: ['x', 'z'],
+            directDrag: true,
             gridSnap: true,
-            groupMoveSnap: resolveCabinetGroupMoveSnap,
+            gridSnapPosition: resolveCabinetMoveGridSnap,
+            groupMoveSnapPose: resolveCabinetGroupMoveSnap,
+            isValidPosition: ({ node, position, rotation, levelId, nodes }) => node.type !== 'cabinet' ||
+                !cabinetRunOverlapsWallOpening({
+                    levelId,
+                    node: node,
+                    nodes: nodes,
+                    position,
+                    rotation,
+                }),
             override: ({ node }) => selectionProxyIdFromMetadata(node.metadata)
                 ? { axes: [], gridSnap: false }
                 : null,
@@ -1477,11 +1824,9 @@ export const cabinetDefinition = {
         duplicable: { subtree: true, prepareSubtreeClone: prepareCabinetSubtreeClone },
         deletable: true,
         surfaces: {
+            hosting: cabinetSurfaceProvider,
             top: {
-                height: (node) => {
-                    const n = node;
-                    return n.plinthHeight + n.carcassHeight + (n.withCountertop ? n.countertopThickness : 0);
-                },
+                height: (node, context) => cabinetLocalBounds(node, context.nodes).maxY,
             },
         },
         floorPlaced: {
@@ -1504,10 +1849,10 @@ export const cabinetDefinition = {
     // Dirty-cascade: a dirtied run re-marks its hosted modules so their
     // composite geometry re-flows with the run (see `cascadeDirty`).
     relations: {
-        hosts: ['cabinet-module'],
+        hosts: ['cabinet', 'cabinet-module', 'item', 'procedural-item'],
     },
     parametrics: cabinetParametrics,
-    handles: cabinetHandles,
+    handles: (node, sceneApi) => cabinetHandles(node, sceneApi).map(withCabinetHostedChildren),
     geometry: buildCabinetGeometry,
     exportAnimation: ({ node, object }) => bakeCabinetAnimationClip(node, object),
     system: {
@@ -1516,6 +1861,7 @@ export const cabinetDefinition = {
     },
     // `operationState` is deliberately absent — door/drawer poses are applied
     // per-frame by the cabinet animation system, not by geometry rebuilds.
+    geometryChildTypes: ['cabinet', 'cabinet-module'],
     geometryKey: (n) => JSON.stringify([
         n.width,
         n.depth,
@@ -1529,10 +1875,12 @@ export const cabinetDefinition = {
         n.countertopBackOverhang,
         n.withFinishedBack,
         n.withWaterfall,
+        n.withFinishedEnds,
         JSON.stringify(n.barLedge ?? null),
         n.frontThickness,
         n.frontGap,
         n.frontStyle,
+        n.panelReady,
         n.handleStyle,
         n.handlePosition,
         n.frontOverlay,
@@ -1547,7 +1895,7 @@ export const cabinetDefinition = {
         // overhang re-trims against the neighbor's new spans (the neighbor's
         // own fields never appear in this key).
         JSON.stringify(cabinetAdjacencyRevision(n.metadata)),
-        JSON.stringify(n.children ?? []),
+        JSON.stringify((n.children ?? []).filter((id) => id.startsWith('cabinet_') || id.startsWith('cabinet-module_'))),
         JSON.stringify(n.stack ?? null),
     ]),
     floorplan: buildCabinetFloorplan,
@@ -1601,7 +1949,7 @@ export const cabinetDefinition = {
 };
 export const cabinetModuleDefinition = {
     kind: 'cabinet-module',
-    schemaVersion: 4,
+    schemaVersion: 5,
     schema: CabinetModuleNode,
     category: 'furnish',
     surfaceRole: 'joinery',
@@ -1617,8 +1965,8 @@ export const cabinetModuleDefinition = {
         children: [],
         cabinetType: 'base',
         width: 0.5,
-        depth: 0.5,
-        carcassHeight: 0.72,
+        depth: CABINET_METRIC_DEFAULTS.depth,
+        carcassHeight: CABINET_METRIC_DEFAULTS.carcassHeight,
         operationState: 0,
         plinthHeight: 0,
         toeKickDepth: 0.075,
@@ -1632,7 +1980,11 @@ export const cabinetModuleDefinition = {
         moduleKind: 'standard',
         openSide: undefined,
         cornerShelf: false,
+        topFinish: 'none',
+        topFinishHeight: CabinetModuleNode.parse({}).topFinishHeight,
+        topFinishDepth: 0.32,
         frontStyle: 'slab',
+        panelReady: false,
         handleStyle: 'bar',
         handlePosition: 'auto',
         frontOverlay: 'full',
@@ -1645,9 +1997,10 @@ export const cabinetModuleDefinition = {
         selectable: { hitVolume: 'bbox' },
         movable: {
             axes: ['x', 'z'],
+            directDrag: true,
             gridSnap: true,
             parentFrame: cabinetModuleParentFrame,
-            groupMoveSnap: resolveCabinetModuleGroupMoveSnap,
+            groupMoveSnapPose: resolveCabinetModuleGroupMoveSnap,
             override: ({ node }) => selectionProxyIdFromMetadata(node.metadata)
                 ? { axes: [], gridSnap: false }
                 : null,
@@ -1660,13 +2013,7 @@ export const cabinetModuleDefinition = {
             footprint: (node) => {
                 const n = node;
                 return {
-                    dimensions: [
-                        n.width,
-                        (n.showPlinth ? n.plinthHeight : 0) +
-                            n.carcassHeight +
-                            (n.withCountertop ? n.countertopThickness : 0),
-                        n.depth,
-                    ],
+                    dimensions: [n.width, cabinetModuleTotalHeight(n), n.depth],
                     rotation: [0, n.rotation, 0],
                 };
             },
@@ -1680,11 +2027,13 @@ export const cabinetModuleDefinition = {
         sceneAction: cabinetSceneAction,
         slots: () => cabinetSlots(),
     },
+    relations: { hosts: ['cabinet', 'cabinet-module', 'item', 'procedural-item'] },
     parametrics: cabinetModuleParametrics,
-    handles: cabinetModuleHandles,
+    handles: () => cabinetModuleHandles().map(withCabinetHostedChildren),
     geometry: buildCabinetGeometry,
     exportAnimation: ({ node, object }) => bakeCabinetAnimationClip(node, object),
     // `operationState` is deliberately absent — see cabinetDefinition.geometryKey.
+    geometryChildTypes: ['cabinet', 'cabinet-module'],
     geometryKey: (n) => JSON.stringify([
         n.cabinetType,
         n.moduleKind,
@@ -1699,6 +2048,7 @@ export const cabinetModuleDefinition = {
         n.frontThickness,
         n.frontGap,
         n.frontStyle,
+        n.panelReady,
         n.handleStyle,
         n.handlePosition,
         n.frontOverlay,
@@ -1707,10 +2057,13 @@ export const cabinetModuleDefinition = {
         n.withCountertop,
         n.openSide ?? null,
         n.cornerShelf ?? false,
+        n.topFinish,
+        n.topFinishHeight,
+        n.topFinishDepth,
         JSON.stringify(n.material ?? null),
         JSON.stringify(n.materialPreset ?? null),
         JSON.stringify(n.slots ?? null),
-        JSON.stringify(n.children ?? []),
+        JSON.stringify((n.children ?? []).filter((id) => id.startsWith('cabinet_') || id.startsWith('cabinet-module_'))),
         JSON.stringify(n.stack ?? null),
     ]),
     floorplan: buildCabinetModuleFloorplan,